[td-225] merge develop

.appveyor.yml

@@ -1,30 +1,49 @@
 version: 1.0.{build}
-os: Visual Studio 2015
+image: 
+  - Visual Studio 2015
+  - macos
 environment:
   matrix:
     - ARCH: amd64
     - ARCH: x86
+matrix:
+  exclude:
+    - image: macos
+      ARCH: x86
+for:
+  - 
+    matrix:
+      only:
+        - image: Visual Studio 2015
+    clone_folder: c:\dev\TDengine
+    clone_depth: 1
 
-clone_folder: c:\dev\TDengine
-clone_depth: 1
+    init:
+      - call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" %ARCH%
 
-init:
-  - call "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" %ARCH%
+    before_build:
+      - cd c:\dev\TDengine
+      - md build
 
-before_build:
-  - cd c:\dev\TDengine
-  - md build
-
-build_script:
-  - cd build
-  - cmake -G "NMake Makefiles" ..
-  - nmake install
+    build_script:
+      - cd build
+      - cmake -G "NMake Makefiles" ..
+      - nmake install
+  -
+    matrix:
+      only:
+        - image: macos
+    clone_depth: 1
 
+    build_script:
+      - mkdir debug
+      - cd debug
+      - cmake .. > /dev/null
+      - make > /dev/null
 notifications:
 - provider: Email
   to:
   - sangshuduo@gmail.com
-  
   on_build_success: true
   on_build_failure: true
   on_build_status_changed: true

.drone.yml

@@ -0,0 +1,180 @@
+---
+kind: pipeline
+name: test_amd64
+
+platform:
+  os: linux
+  arch: amd64
+
+steps:
+- name: smoke_test
+  image: python:3.8
+  commands:
+  - apt-get update
+  - apt-get install -y cmake build-essential gcc 
+  - pip3 install psutil
+  - pip3 install guppy3
+  - pip3 install src/connector/python/linux/python3/
+  - mkdir debug
+  - cd debug
+  - cmake .. 
+  - make 
+  - cd ../tests
+  - ./test-all.sh smoke
+  when:
+    branch:
+    - develop
+    - master
+
+
+- name: crash_gen
+  image: python:3.8
+  commands:
+  - pip3 install requests
+  - pip3 install src/connector/python/linux/python3/
+  - pip3 install psutil
+  - pip3 install guppy3
+  - cd tests/pytest 
+  - ./crash_gen.sh -a -p -t 4 -s 2000
+  when:
+    branch:
+    - develop
+    - master
+
+
+---
+kind: pipeline
+name: test_arm64
+
+platform:
+  os: linux
+  arch: arm64
+
+steps:
+- name: build
+  image: gcc
+  commands:
+  - apt-get update
+  - apt-get install -y cmake build-essential
+  - mkdir debug
+  - cd debug
+  - cmake .. -DCPUTYPE=aarch64 > /dev/null
+  - make 
+  when:
+    branch:
+    - develop
+    - master
+---
+kind: pipeline
+name: test_arm
+
+platform:
+  os: linux
+  arch: arm
+
+steps:
+- name: build
+  image: arm32v7/ubuntu:bionic
+  commands:
+  - apt-get update
+  - apt-get install -y cmake build-essential
+  - mkdir debug
+  - cd debug
+  - cmake .. -DCPUTYPE=aarch32 > /dev/null
+  - make 
+  when:
+    branch:
+    - develop
+    - master
+
+---
+kind: pipeline
+name: build_trusty
+
+platform:
+  os: linux
+  arch: amd64
+
+steps:
+- name: build
+  image: ubuntu:trusty
+  commands:
+  - apt-get update
+  - apt-get install -y gcc cmake3 build-essential git binutils-2.26
+ 
+  - mkdir debug
+  - cd debug
+  - cmake .. 
+  - make 
+  when:
+    branch:
+    - develop
+    - master
+
+---
+kind: pipeline
+name: build_xenial
+
+platform:
+  os: linux
+  arch: amd64
+
+steps:
+- name: build
+  image: ubuntu:xenial
+  commands:
+  - apt-get update
+  - apt-get install -y gcc cmake build-essential
+  - mkdir debug
+  - cd debug
+  - cmake .. 
+  - make 
+  when:
+    branch:
+    - develop
+    - master
+
+---
+kind: pipeline
+name: build_bionic
+platform:
+  os: linux
+  arch: amd64
+
+steps:
+- name: build
+  image: ubuntu:bionic
+  commands:
+  - apt-get update
+  - apt-get install -y gcc cmake build-essential
+  - mkdir debug
+  - cd debug
+  - cmake .. 
+  - make 
+  when:
+    branch:
+    - develop
+    - master
+
+---
+kind: pipeline
+name: goodbye
+
+platform:
+  os: linux
+  arch: amd64
+
+steps:
+- name: 64-bit
+  image: alpine
+  commands:
+  - echo 64-bit is good.
+  when:
+    branch:
+    - develop
+    - master
+
+
+depends_on:
+- test_arm64
+- test_amd64

.travis.yml

@@ -1,296 +0,0 @@
-#
-# Configuration
-#
-#
-# Build Matrix
-#
-branches:
-  only:
-    - master
-    - develop
-    - coverity_scan
-    - /^.*ci-.*$/
-
-matrix:
-  - os: linux
-    dist: focal
-    language: c
-
-    git:
-      - depth: 1
-
-    compiler: gcc
-    env: DESC="linux/gcc build and test"
-
-    addons:
-      apt:
-        packages:
-          - build-essential
-          - cmake
-          - net-tools
-          - python3-pip
-          - python3-setuptools
-          - valgrind
-          - psmisc
-          - unixodbc
-          - unixodbc-dev
-          - mono-complete
-
-    before_script:
-      - export TZ=Asia/Harbin
-      - date
-      - cd ${TRAVIS_BUILD_DIR}
-      - mkdir debug
-      - cd debug
-
-    script:
-      - cmake .. > /dev/null
-      - make > /dev/null
-
-    after_success:
-      - travis_wait 20
-      - |-
-        case $TRAVIS_OS_NAME in
-          linux)
-          cd ${TRAVIS_BUILD_DIR}/debug
-          make install > /dev/null || travis_terminate $?
-
-          py3ver=`python3 --version|awk '{print $2}'|cut -d "." -f 1,2` && apt install python$py3ver-dev
-          pip3 install psutil
-          pip3 install guppy3
-          pip3 install --user ${TRAVIS_BUILD_DIR}/src/connector/python/linux/python3/
-
-          cd ${TRAVIS_BUILD_DIR}/tests/examples/C#/taosdemo
-          mcs -out:taosdemo *.cs || travis_terminate $?
-          pkill -TERM -x taosd
-          fuser -k -n tcp 6030
-          sleep 1
-          ${TRAVIS_BUILD_DIR}/debug/build/bin/taosd -c ${TRAVIS_BUILD_DIR}/debug/test/cfg > /dev/null &
-          sleep 5
-          mono taosdemo -Q DEFAULT -y || travis_terminate $?
-          pkill -KILL -x taosd
-          fuser -k -n tcp 6030
-          sleep 1
-
-          cd ${TRAVIS_BUILD_DIR}/tests
-          ./test-all.sh smoke || travis_terminate $?
-          sleep 1
-
-          cd ${TRAVIS_BUILD_DIR}/tests/pytest
-          pkill -TERM -x taosd
-          fuser -k -n tcp 6030
-          sleep 1
-          ./crash_gen.sh -a -p -t 4 -s 2000|| travis_terminate $?
-          sleep 1
-
-          cd ${TRAVIS_BUILD_DIR}/tests/pytest
-          ./valgrind-test.sh 2>&1 > mem-error-out.log
-          sleep 1
-
-
-          # Color setting
-          RED='\033[0;31m'
-          GREEN='\033[1;32m'
-          GREEN_DARK='\033[0;32m'
-          GREEN_UNDERLINE='\033[4;32m'
-          NC='\033[0m'
-
-          grep 'start to execute\|ERROR SUMMARY' mem-error-out.log|grep -v 'grep'|uniq|tee uniq-mem-error-out.log
-
-          for memError in `grep 'ERROR SUMMARY' uniq-mem-error-out.log | awk '{print $4}'`
-          do
-            if [ -n "$memError" ]; then
-              if [ "$memError" -gt 12 ]; then
-                echo -e "${RED} ## Memory errors number valgrind reports is $memError.\
-                         More than our threshold! ## ${NC}"
-                travis_terminate $memError
-              fi
-            fi
-          done
-
-          grep 'start to execute\|definitely lost:' mem-error-out.log|grep -v 'grep'|uniq|tee uniq-definitely-lost-out.log
-          for defiMemError in `grep 'definitely lost:' uniq-definitely-lost-out.log | awk '{print $7}'`
-          do
-            if [ -n "$defiMemError" ]; then
-              if [ "$defiMemError" -gt 13 ]; then
-                echo -e "${RED} ## Memory errors number valgrind reports \
-                         Definitely lost is $defiMemError. More than our threshold! ## ${NC}"
-                travis_terminate $defiMemError
-              fi
-            fi
-          done
-
-          ;;
-        esac
-
-  - os: linux
-    dist: bionic
-    language: c
-    compiler: gcc
-    env: COVERITY_SCAN=true
-    git:
-      - depth: 1
-
-    script:
-      - echo "this job is for coverity scan"
-
-    addons:
-      coverity_scan:
-        # GitHub project metadata
-        # ** specific to your project **
-        project:
-          name: TDengine
-          version: 2.x
-          description: TDengine
-
-        # Where email notification of build analysis results will be sent
-        notification_email: sdsang@taosdata.com, slguan@taosdata.com
-
-        # Commands to prepare for build_command
-        # ** likely specific to your build **
-        build_command_prepend: cmake . > /dev/null
-
-        # The command that will be added as an argument to "cov-build" to compile your project for analysis,
-        # ** likely specific to your build **
-        build_command: make
-
-        # Pattern to match selecting branches that will run analysis. We recommend leaving this set to 'coverity_scan'.
-        # Take care in resource usage, and consider the build frequency allowances per
-        #   https://scan.coverity.com/faq#frequency
-        branch_pattern: coverity_scan
-
-  - os: linux
-    dist: trusty
-    language: c
-    git:
-      - depth: 1
-
-    addons:
-      apt:
-        packages:
-          - build-essential
-          - cmake
-          - binutils-2.26
-          - unixodbc
-          - unixodbc-dev
-    env: 
-      - DESC="trusty/gcc-4.8/bintuils-2.26 build"
-
-    before_script:
-      - export TZ=Asia/Harbin
-      - date
-      - cd ${TRAVIS_BUILD_DIR}
-      - mkdir debug
-      - cd debug
-
-    script:
-      - cmake .. > /dev/null
-      - export PATH=/usr/lib/binutils-2.26/bin:$PATH && make
-
-  - os: linux
-    dist: bionic
-    language: c
-    compiler: clang
-    env: DESC="linux/clang build"
-    git:
-      - depth: 1
-
-    addons:
-      apt:
-        packages:
-          - build-essential
-          - cmake
-          - unixodbc
-          - unixodbc-dev
-
-    before_script:
-      - export TZ=Asia/Harbin
-      - date
-      - cd ${TRAVIS_BUILD_DIR}
-      - mkdir debug
-      - cd debug
-
-    script:
-      - cmake .. > /dev/null
-      - make  > /dev/null
-
-  - os: linux
-    arch: arm64
-    dist: bionic
-    language: c
-    compiler: clang
-    env: DESC="arm64 linux/clang build"
-    git:
-      - depth: 1
-
-    addons:
-      apt:
-        packages:
-          - build-essential
-          - cmake
-
-    before_script:
-      - export TZ=Asia/Harbin
-      - date
-      - cd ${TRAVIS_BUILD_DIR}
-      - mkdir debug
-      - cd debug
-
-    script:
-      - if [ "${TRAVIS_CPU_ARCH}" == "arm64" ]; then
-         cmake .. -DCPUTYPE=aarch64 > /dev/null;
-        else
-         cmake .. > /dev/null;
-        fi
-      - make > /dev/null
-
-  - os: linux
-    arch: arm64
-    dist: xenial
-    language: c
-    git:
-      - depth: 1
-
-    addons:
-      apt:
-        packages:
-          - build-essential
-          - cmake
-          - unixodbc
-          - unixodbc-dev
-    env:
-      - DESC="arm64 xenial build"
-
-    before_script:
-      - export TZ=Asia/Harbin
-      - date
-      - cd ${TRAVIS_BUILD_DIR}
-      - mkdir debug
-      - cd debug
-
-    script:
-      - if [ "${TRAVIS_CPU_ARCH}" == "arm64" ]; then
-         cmake .. -DCPUTYPE=aarch64 > /dev/null;
-        else
-         cmake .. > /dev/null;
-        fi
-      - make > /dev/null
-
-  - os: osx
-    osx_image: xcode11.4
-    language: c
-    compiler: clang
-    env: DESC="mac/clang build"
-    git:
-      - depth: 1
-    addons:
-      homebrew:
-        - cmake
-        - unixodbc
-
-    script:
-      - cd ${TRAVIS_BUILD_DIR}
-      - mkdir debug
-      - cd debug
-      - cmake .. > /dev/null
-      - make > /dev/null

Jenkinsfile

@@ -94,6 +94,7 @@ def pre_test(){
     make > /dev/null
     make install > /dev/null
     cd ${WKC}/tests
+    pip3 install ${WKC}/src/connector/python/linux/python3/
     '''
     return 1
 }

README.md

@@ -1,4 +1,4 @@
-[![Build Status](https://travis-ci.org/taosdata/TDengine.svg?branch=master)](https://travis-ci.org/taosdata/TDengine)
+[![Build Status](https://cloud.drone.io/api/badges/taosdata/TDengine/status.svg?ref=refs/heads/master)](https://cloud.drone.io/taosdata/TDengine)
 [![Build status](https://ci.appveyor.com/api/projects/status/kf3pwh2or5afsgl9/branch/master?svg=true)](https://ci.appveyor.com/project/sangshuduo/tdengine-2n8ge/branch/master)
 [![Coverage Status](https://coveralls.io/repos/github/taosdata/TDengine/badge.svg?branch=develop)](https://coveralls.io/github/taosdata/TDengine?branch=develop)
 [![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/4201/badge)](https://bestpractices.coreinfrastructure.org/projects/4201)

cmake/define.inc

@@ -57,7 +57,7 @@ IF (TD_LINUX_64)
   ADD_DEFINITIONS(-D_M_X64)
   ADD_DEFINITIONS(-D_TD_LINUX_64)
   MESSAGE(STATUS "linux64 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -gdwarf-2 -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  SET(COMMON_FLAGS "-Wall -Werror -fPIC -gdwarf-2 -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
   ADD_DEFINITIONS(-DUSE_LIBICONV)
 ENDIF ()
 
@@ -65,7 +65,7 @@ IF (TD_LINUX_32)
   ADD_DEFINITIONS(-D_TD_LINUX_32)
   ADD_DEFINITIONS(-DUSE_LIBICONV)
   MESSAGE(STATUS "linux32 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -fsigned-char -munaligned-access -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  SET(COMMON_FLAGS "-Wall -Werror -fPIC -fsigned-char -munaligned-access -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
 ENDIF ()
 
 IF (TD_ARM_64)
@@ -73,7 +73,7 @@ IF (TD_ARM_64)
   ADD_DEFINITIONS(-D_TD_ARM_)
   ADD_DEFINITIONS(-DUSE_LIBICONV)
   MESSAGE(STATUS "arm64 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  SET(COMMON_FLAGS "-Wall -Werror -fPIC -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
 ENDIF ()
 
 IF (TD_ARM_32)
@@ -81,7 +81,7 @@ IF (TD_ARM_32)
   ADD_DEFINITIONS(-D_TD_ARM_)
   ADD_DEFINITIONS(-DUSE_LIBICONV)
   MESSAGE(STATUS "arm32 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE -Wno-pointer-to-int-cast -Wno-int-to-pointer-cast -Wno-incompatible-pointer-types ")
+  SET(COMMON_FLAGS "-Wall -Werror -fPIC -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE -Wno-pointer-to-int-cast -Wno-int-to-pointer-cast -Wno-incompatible-pointer-types ")
 ENDIF ()
 
 IF (TD_MIPS_64)
@@ -89,7 +89,7 @@ IF (TD_MIPS_64)
   ADD_DEFINITIONS(-D_TD_MIPS_64)
   ADD_DEFINITIONS(-DUSE_LIBICONV)
   MESSAGE(STATUS "mips64 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  SET(COMMON_FLAGS "-Wall -Werror -fPIC -fsigned-char -fpack-struct=8 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
 ENDIF ()
 
 IF (TD_MIPS_32)
@@ -97,7 +97,7 @@ IF (TD_MIPS_32)
   ADD_DEFINITIONS(-D_TD_MIPS_32)
   ADD_DEFINITIONS(-DUSE_LIBICONV)
   MESSAGE(STATUS "mips32 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -fPIC -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  SET(COMMON_FLAGS "-Wall -Werror -fPIC -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
 ENDIF ()
 
 IF (TD_APLHINE)
@@ -139,7 +139,7 @@ IF (TD_DARWIN_64)
   ADD_DEFINITIONS(-D_REENTRANT -D__USE_POSIX -D_LIBC_REENTRANT)
   ADD_DEFINITIONS(-DUSE_LIBICONV)
   MESSAGE(STATUS "darwin64 is defined")
-  SET(COMMON_FLAGS "-std=gnu99 -Wall -Werror -Wno-missing-braces -fPIC -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
+  SET(COMMON_FLAGS "-Wall -Werror -Wno-missing-braces -fPIC -msse4.2 -D_FILE_OFFSET_BITS=64 -D_LARGE_FILE")
   SET(DEBUG_FLAGS "-O0 -g3 -DDEBUG")
   SET(RELEASE_FLAGS "-Og")
   INCLUDE_DIRECTORIES(${TD_COMMUNITY_DIR}/deps/cJson/inc)

cmake/env.inc

@@ -32,6 +32,7 @@ ENDIF ()
 #
 
 # Set compiler options
+SET(COMMON_C_FLAGS "${COMMON_FLAGS} -std=gnu99")
 SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${COMMON_FLAGS} ${DEBUG_FLAGS}")
 SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${COMMON_FLAGS} ${RELEASE_FLAGS}")
 

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

cmake/version.inc

@@ -4,7 +4,7 @@ PROJECT(TDengine)
 IF (DEFINED VERNUMBER)
   SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "2.0.20.0")
+  SET(TD_VER_NUMBER "2.1.0.0")
 ENDIF ()
 
 IF (DEFINED VERCOMPATIBLE)

deps/rmonotonic/src/monotonic.c

@@ -36,6 +36,15 @@ static char monotonic_info_string[32];
 
 static long mono_ticksPerMicrosecond = 0;
 
+#ifdef _TD_NINGSI_60
+// implement __rdtsc in ningsi60
+uint64_t __rdtsc(){
+    unsigned int lo,hi;
+    __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
+    return ((uint64_t)hi << 32) | lo;
+}
+#endif
+
 static monotime getMonotonicUs_x86() {
     return __rdtsc() / mono_ticksPerMicrosecond;
 }

documentation20/cn/00.index/docs.md

@@ -117,9 +117,9 @@ TDengine是一个高效的存储、查询、分析时序大数据的平台，专
 ## 常用工具
 
 * [TDengine样例导入工具](https://www.taosdata.com/blog/2020/01/18/1166.html)
-* [TDengine性能对比测试工具](https://www.taosdata.com/blog/2020/01/18/1166.html)
+* [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)
+* [基于Electron开发的跨平台TDengine图形化管理工具](https://github.com/skye0207/TDengineGUI)
 * [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与其他数据库的对比测试

documentation20/cn/06.queries/docs.md

@@ -12,7 +12,7 @@ TDengine 采用 SQL 作为查询语言。应用程序可以通过 C/C++, Java, G
 - 时间戳对齐的连接查询（Join Query: 隐式连接）操作
 - 多种聚合/计算函数: count, max, min, avg, sum, twa, stddev, leastsquares, top, bottom, first, last, percentile, apercentile, last_row, spread, diff等
 
-例如：在TAOS Shell中，从表d1001中查询出vlotage > 215的记录，按时间降序排列，仅仅输出2条。
+例如：在TAOS Shell中，从表d1001中查询出voltage > 215的记录，按时间降序排列，仅仅输出2条。
 ```mysql
 taos> select * from d1001 where voltage > 215 order by ts desc limit 2;
            ts            |       current        |   voltage   |        phase         |

documentation20/cn/08.connector/01.java/docs.md

@@ -16,7 +16,6 @@ TDengine 的 JDBC 驱动实现尽可能与关系型数据库驱动保持一致
 
 * TDengine 目前不支持针对单条数据记录的删除操作。
 * 目前不支持事务操作。
-* 目前不支持表间的 union 操作。
 * 目前不支持嵌套查询（nested query）。
 * 对每个 Connection 的实例，至多只能有一个打开的 ResultSet 实例；如果在 ResultSet 还没关闭的情况下执行了新的查询，taos-jdbcdriver 会自动关闭上一个 ResultSet。
 
@@ -447,7 +446,7 @@ Query OK, 1 row(s) in set (0.000141s)
 
 
 
-## TAOS-JDBCDriver 版本以及支持的 TDengine 版本和 JDK 版本
+## <a class="anchor" id="version"></a>TAOS-JDBCDriver 版本以及支持的 TDengine 版本和 JDK 版本
 
 | taos-jdbcdriver 版本 | TDengine 版本     | JDK 版本 |
 | -------------------- | ----------------- | -------- |

documentation20/cn/08.connector/docs.md

@@ -32,7 +32,7 @@ TDengine提供了丰富的应用程序开发接口，其中包括C/C++、Java、
 
 **Linux**
 
-**1.   从涛思官网（https://www.taosdata.com/cn/all-downloads/）下载**
+**1.   从[涛思官网](https://www.taosdata.com/cn/all-downloads/)下载**
 
 * X64硬件环境：TDengine-client-2.x.x.x-Linux-x64.tar.gz
 
@@ -68,7 +68,7 @@ TDengine提供了丰富的应用程序开发接口，其中包括C/C++、Java、
 
 **Windows x64/x86**
 
-**1.   从涛思官网（https://www.taosdata.com/cn/all-downloads/）下载 ：**
+**1.   从[涛思官网](https://www.taosdata.com/cn/all-downloads/)下载 ：**
 
 * X64硬件环境：TDengine-client-2.X.X.X-Windows-x64.exe
 
@@ -213,7 +213,7 @@ C/C++的API类似于MySQL的C API。应用程序使用时，需要包含TDengine
 
 - `int taos_result_precision(TAOS_RES *res)`
 
-  返回结果集时间戳字段的精度，`0` 代表毫秒，`1` 代表微秒，`2` 代表纳秒。
+  返回结果集时间戳字段的精度，`0` 代表毫秒，`1` 代表微秒。
 
 - `TAOS_ROW taos_fetch_row(TAOS_RES *res)`
 
@@ -349,7 +349,7 @@ TDengine提供时间驱动的实时流式计算API。可以每隔一指定的时
     * param：是应用提供的用于回调的一个参数，回调时，提供给应用
     * callback: 第二个回调函数，会在连续查询自动停止时被调用。
 
-  返回值为NULL，表示创建成功，返回值不为空，表示成功。
+  返回值为NULL，表示创建失败；返回值不为空，表示成功。
 
 - `void taos_close_stream (TAOS_STREAM *tstr)`
 

documentation20/cn/11.administrator/docs.md

@@ -144,7 +144,7 @@ TDengine集群中加入一个新的dnode时，涉及集群相关的一些参数
 - numOfMnodes：系统中管理节点个数。默认值：3。
 - balance：是否启动负载均衡。0：否，1：是。默认值：1。
 - mnodeEqualVnodeNum: 一个mnode等同于vnode消耗的个数。默认值：4。
-- offlineThreshold: dnode离线阈值，超过该时间将导致该dnode从集群中删除。单位为秒，默认值：86400*100（即100天）。
+- offlineThreshold: dnode离线阈值，超过该时间将导致该dnode从集群中删除。单位为秒，默认值：86400*10（即10天）。
 - statusInterval: dnode向mnode报告状态时长。单位为秒，默认值：1。
 - maxTablesPerVnode: 每个vnode中能够创建的最大表个数。默认值：1000000。
 - maxVgroupsPerDb: 每个数据库中能够使用的最大vgroup个数。
@@ -462,31 +462,31 @@ TDengine的所有可执行文件默认存放在 _/usr/local/taos/bin_ 目录下
 
 | 关键字列表 |             |              |            |           |
 | ---------- | ----------- | ------------ | ---------- | --------- |
-| ABLOCKS    | CONNECTIONS | HAVING       | MODULES    | SLIMIT    |
-| ABORT      | COPY        | ID           | NCHAR      | SMALLINT  |
-| ACCOUNT    | COUNT       | IF           | NE         | SPREAD    |
-| ACCOUNTS   | CREATE      | IGNORE       | NONE       | STABLE    |
-| ADD        | CTIME       | IMMEDIATE    | NOT        | STABLES   |
-| AFTER      | DATABASE    | IMPORT       | NOTNULL    | STAR      |
-| ALL        | DATABASES   | IN           | NOW        | STATEMENT |
-| ALTER      | DAYS        | INITIALLY    | OF         | STDDEV    |
-| AND        | DEFERRED    | INSERT       | OFFSET     | STREAM    |
-| AS         | DELIMITERS  | INSTEAD      | OR         | STREAMS   |
-| ASC        | DESC        | INTEGER      | ORDER      | STRING    |
-| ATTACH     | DESCRIBE    | INTERVAL     | PASS       | SUM       |
-| AVG        | DETACH      | INTO         | PERCENTILE | TABLE     |
-| BEFORE     | DIFF        | IP           | PLUS       | TABLES    |
-| BEGIN      | DISTINCT    | IS           | PRAGMA     | TAG       |
-| BETWEEN    | DIVIDE      | ISNULL       | PREV       | TAGS      |
-| BIGINT     | DNODE       | JOIN         | PRIVILEGE  | TBLOCKS   |
-| BINARY     | DNODES      | KEEP         | QUERIES    | TBNAME    |
-| BITAND     | DOT         | KEY          | QUERY      | TIMES     |
-| BITNOT     | DOUBLE      | KILL         | RAISE      | TIMESTAMP |
-| BITOR      | DROP        | LAST         | REM        | TINYINT   |
-| BOOL       | EACH        | LE           | REPLACE    | TOP       |
-| BOTTOM     | END         | LEASTSQUARES | REPLICA    | TOPIC     |
-| BY         | EQ          | LIKE         | RESET      | TRIGGER   |
-| CACHE      | EXISTS      | LIMIT        | RESTRICT   | UMINUS    |
+| ABLOCKS    | CONNECTIONS | HAVING       | MODULES    | SMALLINT  |
+| ABORT      | COPY        | ID           | NCHAR      | SPREAD    |
+| ACCOUNT    | COUNT       | IF           | NE         | STABLE    |
+| ACCOUNTS   | CREATE      | IGNORE       | NONE       | STABLES   |
+| ADD        | CTIME       | IMMEDIATE    | NOT        | STAR      |
+| AFTER      | DATABASE    | IMPORT       | NOTNULL    | STATEMENT |
+| ALL        | DATABASES   | IN           | NOW        | STDDEV    |
+| ALTER      | DAYS        | INITIALLY    | OF         | STREAM    |
+| AND        | DEFERRED    | INSERT       | OFFSET     | STREAMS   |
+| AS         | DELIMITERS  | INSTEAD      | OR         | STRING    |
+| ASC        | DESC        | INTEGER      | ORDER      | SUM       |
+| ATTACH     | DESCRIBE    | INTERVAL     | PASS       | TABLE     |
+| AVG        | DETACH      | INTO         | PERCENTILE | TABLES    |
+| BEFORE     | DIFF        | IP           | PLUS       | TAG       |
+| BEGIN      | DISTINCT    | IS           | PRAGMA     | TAGS      |
+| BETWEEN    | DIVIDE      | ISNULL       | PREV       | TBLOCKS   |
+| BIGINT     | DNODE       | JOIN         | PRIVILEGE  | TBNAME    |
+| BINARY     | DNODES      | KEEP         | QUERIES    | TIMES     |
+| BITAND     | DOT         | KEY          | QUERY      | TIMESTAMP |
+| BITNOT     | DOUBLE      | KILL         | RAISE      | TINYINT   |
+| BITOR      | DROP        | LAST         | REM        | TOP       |
+| BOOL       | EACH        | LE           | REPLACE    | TOPIC     |
+| BOTTOM     | END         | LEASTSQUARES | REPLICA    | TRIGGER   |
+| BY         | EQ          | LIKE         | RESET      | UMINUS    |
+| CACHE      | EXISTS      | LIMIT        | RESTRICT   | UNION     |
 | CASCADE    | EXPLAIN     | LINEAR       | ROW        | UPLUS     |
 | CHANGE     | FAIL        | LOCAL        | ROWS       | USE       |
 | CLOG       | FILL        | LP           | RP         | USER      |
@@ -498,5 +498,5 @@ TDengine的所有可执行文件默认存放在 _/usr/local/taos/bin_ 目录下
 | CONCAT     | GLOB        | METRICS      | SHOW       | VIEW      |
 | CONFIGS    | GRANTS      | MIN          | SLASH      | WAVG      |
 | CONFLICT   | GROUP       | MINUS        | SLIDING    | WHERE     |
-| CONNECTION | GT          | MNODES       |            |           |
+| CONNECTION | GT          | MNODES       | SLIMIT     |           |
 

documentation20/cn/12.taos-sql/docs.md

@@ -48,7 +48,7 @@ TDengine 缺省的时间戳是毫秒精度，但通过修改配置参数 enableM
 | 3    |  BIGINT   | 8      | 长整型，范围 [-2^63+1,   2^63-1], -2^63 用于 NULL                                 |
 | 4    |   FLOAT   | 4      | 浮点型，有效位数 6-7，范围 [-3.4E38, 3.4E38]                  |
 | 5    |  DOUBLE   | 8      | 双精度浮点型，有效位数 15-16，范围 [-1.7E308, 1.7E308]      |
-| 6    |  BINARY   | 自定义 | 记录二进制字节型字符串，建议只用于处理 ASCII 可见字符，中文等多字节字符需使用 nchar。理论上，最长可以有 16374 字节，但由于每行数据最多 16K 字节，实际上限一般小于理论值。binary 仅支持字符串输入，字符串两端使用单引号引用，否则英文全部自动转化为小写。使用时须指定大小，如 binary(20) 定义了最长为 20 个字节型字符的字符串，每个字节型字符占 1 byte 的存储空间，此时如果用户字符串超出 20 字节将会报错。对于字符串内的单引号，可以用转义字符反斜线加单引号来表示，即 `\’`。 |
+| 6    |  BINARY   | 自定义 | 记录单字节字符串，建议只用于处理 ASCII 可见字符，中文等多字节字符需使用 nchar。理论上，最长可以有 16374 字节，但由于每行数据最多 16K 字节，实际上限一般小于理论值。binary 仅支持字符串输入，字符串两端需使用单引号引用。使用时须指定大小，如 binary(20) 定义了最长为 20 个单字节字符的字符串，每个字符占 1 byte 的存储空间，此时如果用户字符串超出 20 字节将会报错。对于字符串内的单引号，可以用转义字符反斜线加单引号来表示，即 `\’`。 |
 | 7    | SMALLINT  | 2      | 短整型， 范围 [-32767, 32767], -32768 用于 NULL                                |
 | 8    |  TINYINT  | 1      | 单字节整型，范围 [-127, 127], -128 用于 NULL                                |
 | 9    |   BOOL    | 1      | 布尔型，{true, false}                                      |
@@ -56,7 +56,7 @@ TDengine 缺省的时间戳是毫秒精度，但通过修改配置参数 enableM
 
 **Tips**:
 1. TDengine 对 SQL 语句中的英文字符不区分大小写，自动转化为小写执行。因此用户大小写敏感的字符串及密码，需要使用单引号将字符串引起来。
-2. **注意**，虽然 Binary 类型在底层存储上支持字节型的二进制字符，但不同编程语言对二进制数据的处理方式并不保证一致，因此建议在 Binary 类型中只存储 ASCII 可见字符，而避免存储不可见字符。多字节的数据，例如中文字符，则需要使用 nchar 类型进行保存。如果强行使用 Binary 类型保存中文字符，虽然有时也能正常读写，但并不带有字符集信息，很容易出现数据乱码甚至数据损坏。
+2. **注意**，虽然 Binary 类型在底层存储上支持字节型的二进制字符，但不同编程语言对二进制数据的处理方式并不保证一致，因此建议在 Binary 类型中只存储 ASCII 可见字符，而避免存储不可见字符。多字节的数据，例如中文字符，则需要使用 nchar 类型进行保存。如果强行使用 Binary 类型保存中文字符，虽然有时也能正常读写，但并不带有字符集信息，很容易出现数据乱码甚至数据损坏等情况。
 
 ## <a class="anchor" id="management"></a>数据库管理
 
@@ -407,18 +407,14 @@ SELECT select_expr [, select_expr ...]
     [INTERVAL (interval_val [, interval_offset])]
     [SLIDING sliding_val]
     [FILL fill_val]
-    [GROUP BY col_list [HAVING having_condition]]
+    [GROUP BY col_list]
     [ORDER BY col_list { DESC | ASC }]
     [SLIMIT limit_val [SOFFSET offset_val]]
     [LIMIT limit_val [OFFSET offset_val]]
     [>> export_file];
 ```
 
-#### SELECT子句
-
-一个选择子句可以是联合查询（UNION）和另一个查询的子查询（SUBQUERY）。
-
-##### 通配符
+#### 通配符
 
 通配符 * 可以用于代指全部列。对于普通表，结果中只有普通列。
 ```mysql
@@ -470,7 +466,7 @@ Query OK, 1 row(s) in set (0.020443s)
 ```
 
 在使用SQL函数来进行查询过程中，部分SQL函数支持通配符操作。其中的区别在于：
-```count(\*)```函数只返回一列。```first```、```last```、```last_row```函数则是返回全部列。
+```count(*)```函数只返回一列。```first```、```last```、```last_row```函数则是返回全部列。
 
 ```mysql
 taos> SELECT COUNT(*) FROM d1001;
@@ -488,7 +484,7 @@ taos> SELECT FIRST(*) FROM d1001;
 Query OK, 1 row(s) in set (0.000849s)
 ```
 
-##### 标签列
+#### 标签列
 
 从 2.0.14 版本开始，支持在普通表的查询中指定 _标签列_，且标签列的值会与普通列的数据一起返回。
 ```mysql
@@ -622,13 +618,15 @@ taos> SELECT COUNT(tbname) FROM meters WHERE groupId > 2;
 Query OK, 1 row(s) in set (0.001091s)
 ```
 
-- 可以使用 * 返回所有列，或指定列名。可以对数字列进行四则运算，可以给输出的列取列名
-- WHERE 语句可以使用各种逻辑判断来过滤数字值，或使用通配符来过滤字符串
+- 可以使用 * 返回所有列，或指定列名。可以对数字列进行四则运算，可以给输出的列取列名。
+  * 暂不支持含列名的四则运算表达式用于条件过滤算子（例如，不支持 `where a*2>6;`，但可以写 `where a>6/2;`）。
+  * 暂不支持含列名的四则运算表达式作为 SQL 函数的应用对象（例如，不支持 `select min(2*a) from t;`，但可以写 `select 2*min(a) from t;`）。
+- WHERE 语句可以使用各种逻辑判断来过滤数字值，或使用通配符来过滤字符串。
 - 输出结果缺省按首列时间戳升序排序，但可以指定按降序排序( _c0 指首列时间戳)。使用 ORDER BY 对其他字段进行排序为非法操作。
 - 参数 LIMIT 控制输出条数，OFFSET 指定从第几条开始输出。LIMIT/OFFSET 对结果集的执行顺序在 ORDER BY 之后。
   * 在有 GROUP BY 子句的情况下，LIMIT 参数控制的是每个分组中至多允许输出的条数。
 - 参数 SLIMIT 控制由 GROUP BY 指令划分的分组中，至多允许输出几个分组的数据。
-- 通过”>>"输出结果可以导出到指定文件
+- 通过 ">>" 输出结果可以导出到指定文件。
 
 ### 支持的条件过滤操作
 
@@ -648,7 +646,8 @@ Query OK, 1 row(s) in set (0.001091s)
 2. 针对单一字段的过滤，如果是时间过滤条件，则一条语句中只支持设定一个；但针对其他的（普通）列或标签列，则可以使用 `OR` 关键字进行组合条件的查询过滤。例如：((value > 20 AND value < 30) OR (value < 12)) 。
 3. 从 2.0.17 版本开始，条件过滤开始支持 BETWEEN AND 语法，例如 `WHERE col2 BETWEEN 1.5 AND 3.25` 表示查询条件为“1.5 ≤ col2 ≤ 3.25”。
 
-### GROUP BY 之后的 HAVING 过滤
+<!-- 
+### <a class="anchor" id="having"></a>GROUP BY 之后的 HAVING 过滤
 
 从 2.0.20 版本开始，GROUP BY 之后允许再跟一个 HAVING 子句，对成组后的各组数据再做筛选。HAVING 子句可以使用聚合函数和选择函数作为过滤条件（但暂时不支持 LEASTSQUARES、TOP、BOTTOM、LAST_ROW）。
 
@@ -656,6 +655,17 @@ Query OK, 1 row(s) in set (0.001091s)
 ```mysql
 SELECT AVG(f1), SPREAD(f1, f2, st2.f1) FROM st2 WHERE f1 > 0 GROUP BY f1 HAVING AVG(f1) > 0;
 ```
+-->
+
+### <a class="anchor" id="union"></a>UNION ALL 操作符
+
+```mysql
+SELECT ...
+UNION ALL SELECT ...
+[UNION ALL SELECT ...]
+```
+
+TDengine 支持 UNION ALL 操作符。也就是说，如果多个 SELECT 子句返回结果集的结构完全相同（列名、列类型、列数、顺序），那么可以通过 UNION ALL 把这些结果集合并到一起。目前只支持 UNION ALL 模式，也即在结果集的合并过程中是不去重的。
 
 ### SQL 示例 
 
@@ -705,11 +715,11 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
     应用字段：应用全部字段。
 
-    适用于：表、超级表。
+    适用于：**表、超级表**。
 
     说明：
 
-    1）可以使用星号*来替代具体的字段，使用星号(*)返回全部记录数量。
+    1）可以使用星号\*来替代具体的字段，使用星号(\*)返回全部记录数量。
 
     2）针对同一表的（不包含NULL值）字段查询结果均相同。
 
@@ -740,7 +750,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
     应用字段：不能应用在timestamp、binary、nchar、bool字段。
 
-    适用于：表、超级表。
+    适用于：**表、超级表**。
 
     示例：
     ```mysql
@@ -767,7 +777,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
 
-    适用于：表。
+    适用于：**表**。
 
 - **SUM**
     ```mysql
@@ -779,7 +789,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
 
-    适用于：表、超级表。
+    适用于：**表、超级表**。
 
     示例：
     ```mysql
@@ -806,7 +816,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
 
-    适用于：表。（从 2.0.15.1 版本开始，本函数也支持超级表）
+    适用于：**表**。（从 2.0.15.1 版本开始，本函数也支持**超级表**）
 
     示例：
     ```mysql
@@ -829,7 +839,7 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
     说明：自变量是时间戳，因变量是该列的值。
 
-    适用于：表。
+    适用于：**表**。
 
     示例：
     ```mysql
@@ -852,6 +862,8 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
 
+    适用于：**表、超级表**。
+
     示例：
     ```mysql
     taos> SELECT MIN(current), MIN(voltage) FROM meters;
@@ -877,6 +889,8 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
 
+    适用于：**表、超级表**。
+
     示例：
     ```mysql
     taos> SELECT MAX(current), MAX(voltage) FROM meters;
@@ -902,6 +916,8 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
     应用字段：所有字段。
 
+    适用于：**表、超级表**。
+
     说明：
 
     1）如果要返回各个列的首个（时间戳最小）非NULL值，可以使用FIRST(\*)；
@@ -935,6 +951,8 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
     应用字段：所有字段。
 
+    适用于：**表、超级表**。
+
     说明：
 
     1）如果要返回各个列的最后（时间戳最大）一个非NULL值，可以使用LAST(\*)；
@@ -966,6 +984,8 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
 
+    适用于：**表、超级表**。
+
     说明：
 
     1）*k*值取值范围1≤*k*≤100；
@@ -1000,6 +1020,8 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
 
+    适用于：**表、超级表**。
+
     说明：
 
     1）*k*值取值范围1≤*k*≤100；
@@ -1033,6 +1055,8 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
 
+    适用于：**表**。
+
     说明：*P*值取值范围0≤*P*≤100，为0的时候等同于MIN，为100的时候等同于MAX。
 
     示例：
@@ -1048,12 +1072,14 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     ```mysql
     SELECT APERCENTILE(field_name, P) FROM { tb_name | stb_name } [WHERE clause];
     ```
-    功能说明：统计表中某列的值百分比分位数，与PERCENTILE函数相似，但是返回近似结果。
+    功能说明：统计表/超级表中某列的值百分比分位数，与PERCENTILE函数相似，但是返回近似结果。
 
     返回结果数据类型： 双精度浮点数Double。
 
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
 
+    适用于：**表、超级表**。
+
     说明：*P*值取值范围0≤*P*≤100，为0的时候等同于MIN，为100的时候等同于MAX。推荐使用```APERCENTILE```函数，该函数性能远胜于```PERCENTILE```函数
 
     ```mysql
@@ -1068,12 +1094,14 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
     ```mysql
     SELECT LAST_ROW(field_name) FROM { tb_name | stb_name };
     ```
-    功能说明：返回表（超级表）的最后一条记录。
+    功能说明：返回表/超级表的最后一条记录。
 
     返回结果数据类型：同应用的字段。
 
     应用字段：所有字段。
 
+    适用于：**表、超级表**。
+
     说明：与last函数不同，last_row不支持时间范围限制，强制返回最后一条记录。
 
     示例：
@@ -1102,6 +1130,8 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
 
+    适用于：**表**。
+
     说明：输出结果行数是范围内总行数减一，第一行没有结果输出。
 
     示例：
@@ -1124,6 +1154,8 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
     应用字段：不能应用在binary、nchar、bool类型字段。
 
+    适用于：**表、超级表**。
+
     说明：可用于TIMESTAMP字段，此时表示记录的时间覆盖范围。
 
     示例：
@@ -1152,6 +1184,8 @@ TDengine支持针对数据的聚合查询。提供支持的聚合和选择函数
 
     应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
 
+    适用于：**表、超级表**。
+
     说明：
 
     1）支持两列或多列之间进行计算，可使用括号控制计算优先级；

importSampleData/README.md

@@ -97,7 +97,7 @@ go build -o bin/taosimport app/main.go
 
     是否保存统计信息到 tdengine 的 statistic 表中，1 是，0 否， 默认 0。
 
-* -savetb int
+* -savetb string
 
     当 save 为 1 时保存统计信息的表名， 默认 statistic。
 

importSampleData/app/main.go

@@ -7,7 +7,6 @@ import (
 	"encoding/json"
 	"flag"
 	"fmt"
-	"hash/crc32"
 	"io"
 	"log"
 	"os"
@@ -17,47 +16,55 @@ import (
 	"sync"
 	"time"
 
-	dataimport "github.com/taosdata/TDengine/importSampleData/import"
+	dataImport "github.com/taosdata/TDengine/importSampleData/import"
 
 	_ "github.com/taosdata/driver-go/taosSql"
 )
 
 const (
-	TIMESTAMP                     = "timestamp"
-	DATETIME                      = "datetime"
-	MILLISECOND                   = "millisecond"
-	DEFAULT_STARTTIME       int64 = -1
-	DEFAULT_INTERVAL        int64 = 1 * 1000
-	DEFAULT_DELAY           int64 = -1
-	DEFAULT_STATISTIC_TABLE       = "statistic"
+	// 主键类型必须为 timestamp
+	TIMESTAMP = "timestamp"
 
-	JSON_FORMAT       = "json"
-	CSV_FORMAT        = "csv"
-	SUPERTABLE_PREFIX = "s_"
-	SUBTABLE_PREFIX   = "t_"
+	// 样例数据中主键时间字段是 millisecond 还是 dateTime 格式
+	DATETIME    = "datetime"
+	MILLISECOND = "millisecond"
 
-	DRIVER_NAME      = "taosSql"
-	STARTTIME_LAYOUT = "2006-01-02 15:04:05.000"
-	INSERT_PREFIX    = "insert into "
+	DefaultStartTime int64 = -1
+	DefaultInterval  int64 = 1 * 1000 // 导入的记录时间间隔，该设置只会在指定 auto=1 之后生效，否则会根据样例数据自动计算间隔时间。单位为毫秒，默认 1000。
+	DefaultDelay     int64 = -1       //
+
+	// 当 save 为 1 时保存统计信息的表名， 默认 statistic。
+	DefaultStatisticTable = "statistic"
+
+	// 样例数据文件格式，可以是 json 或 csv
+	JsonFormat = "json"
+	CsvFormat  = "csv"
+
+	SuperTablePrefix = "s_" // 超级表前缀
+	SubTablePrefix   = "t_" // 子表前缀
+
+	DriverName      = "taosSql"
+	StartTimeLayout = "2006-01-02 15:04:05.000"
+	InsertPrefix    = "insert into "
 )
 
 var (
-	cfg          string
-	cases        string
-	hnum         int
-	vnum         int
-	thread       int
-	batch        int
-	auto         int
-	starttimestr string
-	interval     int64
-	host         string
-	port         int
-	user         string
-	password     string
-	dropdb       int
-	db           string
-	dbparam      string
+	cfg          string // 导入配置文件路径，包含样例数据文件相关描述及对应 TDengine 配置信息。默认使用 config/cfg.toml
+	cases        string // 需要导入的场景名称，该名称可从 -cfg 指定的配置文件中 [usecase] 查看，可同时导入多个场景，中间使用逗号分隔，如：sensor_info,camera_detection，默认为 sensor_info
+	hnum         int    // 需要将样例数据进行横向扩展的倍数，假设原有样例数据包含 1 张子表 t_0 数据，指定 hnum 为 2 时会根据原有表名创建 t、t_1 两张子表。默认为 100。
+	vnum         int    // 需要将样例数据进行纵向扩展的次数，如果设置为 0 代表将历史数据导入至当前时间后持续按照指定间隔导入。默认为 1000，表示将样例数据在时间轴上纵向复制1000 次
+	thread       int    // 执行导入数据的线程数目，默认为 10
+	batch        int    // 执行导入数据时的批量大小，默认为 100。批量是指一次写操作时，包含多少条记录
+	auto         int    // 是否自动生成样例数据中的主键时间戳，1 是，0 否， 默认 0
+	startTimeStr string // 导入的记录开始时间，格式为 "yyyy-MM-dd HH:mm:ss.SSS"，不设置会使用样例数据中最小时间，设置后会忽略样例数据中的主键时间，会按照指定的 start 进行导入。如果 auto 为 1，则必须设置 start，默认为空
+	interval     int64  // 导入的记录时间间隔，该设置只会在指定 auto=1 之后生效，否则会根据样例数据自动计算间隔时间。单位为毫秒，默认 1000
+	host         string // 导入的 TDengine 服务器 IP，默认为 127.0.0.1
+	port         int    // 导入的 TDengine 服务器端口，默认为 6030
+	user         string // 导入的 TDengine 用户名，默认为 root
+	password     string // 导入的 TDengine 用户密码，默认为 taosdata
+	dropdb       int    // 导入数据之前是否删除数据库，1 是，0 否， 默认 0
+	db           string // 导入的 TDengine 数据库名称，默认为 test_yyyyMMdd
+	dbparam      string // 当指定的数据库不存在时，自动创建数据库时可选项配置参数，如 days 10 cache 16000 ablocks 4，默认为空
 
 	dataSourceName string
 	startTime      int64
@@ -72,10 +79,10 @@ var (
 	lastStaticTime time.Time
 	lastTotalRows  int64
 	timeTicker     *time.Ticker
-	delay          int64 // default 10 milliseconds
-	tick           int64
-	save           int
-	saveTable      string
+	delay          int64  // 当 vnum 设置为 0 时持续导入的时间间隔，默认为所有场景中最小记录间隔时间的一半，单位 ms。
+	tick           int64  // 打印统计信息的时间间隔，默认 2000 ms。
+	save           int    // 是否保存统计信息到 tdengine 的 statistic 表中，1 是，0 否， 默认 0。
+	saveTable      string // 当 save 为 1 时保存统计信息的表名， 默认 statistic。
 )
 
 type superTableConfig struct {
@@ -83,7 +90,7 @@ type superTableConfig struct {
 	endTime     int64
 	cycleTime   int64
 	avgInterval int64
-	config      dataimport.CaseConfig
+	config      dataImport.CaseConfig
 }
 
 type scaleTableInfo struct {
@@ -92,14 +99,14 @@ type scaleTableInfo struct {
 	insertRows     int64
 }
 
-type tableRows struct {
-	tableName string // tableName
-	value     string // values(...)
-}
+//type tableRows struct {
+//	tableName string // tableName
+//	value     string // values(...)
+//}
 
 type dataRows struct {
 	rows   []map[string]interface{}
-	config dataimport.CaseConfig
+	config dataImport.CaseConfig
 }
 
 func (rows dataRows) Len() int {
@@ -107,9 +114,9 @@ func (rows dataRows) Len() int {
 }
 
 func (rows dataRows) Less(i, j int) bool {
-	itime := getPrimaryKey(rows.rows[i][rows.config.Timestamp])
-	jtime := getPrimaryKey(rows.rows[j][rows.config.Timestamp])
-	return itime < jtime
+	iTime := getPrimaryKey(rows.rows[i][rows.config.Timestamp])
+	jTime := getPrimaryKey(rows.rows[j][rows.config.Timestamp])
+	return iTime < jTime
 }
 
 func (rows dataRows) Swap(i, j int) {
@@ -123,26 +130,26 @@ func getPrimaryKey(value interface{}) int64 {
 }
 
 func init() {
-	parseArg() //parse argument
+	parseArg() // parse argument
 
 	if db == "" {
-		//db = "go"
+		// 导入的 TDengine 数据库名称，默认为 test_yyyyMMdd
 		db = fmt.Sprintf("test_%s", time.Now().Format("20060102"))
 	}
 
-	if auto == 1 && len(starttimestr) == 0 {
+	if auto == 1 && len(startTimeStr) == 0 {
 		log.Fatalf("startTime must be set when auto is 1, the format is \"yyyy-MM-dd HH:mm:ss.SSS\" ")
 	}
 
-	if len(starttimestr) != 0 {
-		t, err := time.ParseInLocation(STARTTIME_LAYOUT, strings.TrimSpace(starttimestr), time.Local)
+	if len(startTimeStr) != 0 {
+		t, err := time.ParseInLocation(StartTimeLayout, strings.TrimSpace(startTimeStr), time.Local)
 		if err != nil {
-			log.Fatalf("param startTime %s error, %s\n", starttimestr, err)
+			log.Fatalf("param startTime %s error, %s\n", startTimeStr, err)
 		}
 
 		startTime = t.UnixNano() / 1e6 // as millisecond
 	} else {
-		startTime = DEFAULT_STARTTIME
+		startTime = DefaultStartTime
 	}
 
 	dataSourceName = fmt.Sprintf("%s:%s@/tcp(%s:%d)/", user, password, host, port)
@@ -154,9 +161,9 @@ func init() {
 
 func main() {
 
-	importConfig := dataimport.LoadConfig(cfg)
+	importConfig := dataImport.LoadConfig(cfg)
 
-	var caseMinumInterval int64 = -1
+	var caseMinInterval int64 = -1
 
 	for _, userCase := range strings.Split(cases, ",") {
 		caseConfig, ok := importConfig.UserCases[userCase]
@@ -168,7 +175,7 @@ func main() {
 
 		checkUserCaseConfig(userCase, &caseConfig)
 
-		//read file as map array
+		// read file as map array
 		fileRows := readFile(caseConfig)
 		log.Printf("case [%s] sample data file contains %d rows.\n", userCase, len(fileRows.rows))
 
@@ -177,31 +184,31 @@ func main() {
 			continue
 		}
 
-		_, exists := superTableConfigMap[caseConfig.Stname]
+		_, exists := superTableConfigMap[caseConfig.StName]
 		if !exists {
-			superTableConfigMap[caseConfig.Stname] = &superTableConfig{config: caseConfig}
+			superTableConfigMap[caseConfig.StName] = &superTableConfig{config: caseConfig}
 		} else {
-			log.Fatalf("the stname of case %s already exist.\n", caseConfig.Stname)
+			log.Fatalf("the stname of case %s already exist.\n", caseConfig.StName)
 		}
 
 		var start, cycleTime, avgInterval int64 = getSuperTableTimeConfig(fileRows)
 
 		// set super table's startTime, cycleTime and avgInterval
-		superTableConfigMap[caseConfig.Stname].startTime = start
-		superTableConfigMap[caseConfig.Stname].avgInterval = avgInterval
-		superTableConfigMap[caseConfig.Stname].cycleTime = cycleTime
+		superTableConfigMap[caseConfig.StName].startTime = start
+		superTableConfigMap[caseConfig.StName].cycleTime = cycleTime
+		superTableConfigMap[caseConfig.StName].avgInterval = avgInterval
 
-		if caseMinumInterval == -1 || caseMinumInterval > avgInterval {
-			caseMinumInterval = avgInterval
+		if caseMinInterval == -1 || caseMinInterval > avgInterval {
+			caseMinInterval = avgInterval
 		}
 
-		startStr := time.Unix(0, start*int64(time.Millisecond)).Format(STARTTIME_LAYOUT)
+		startStr := time.Unix(0, start*int64(time.Millisecond)).Format(StartTimeLayout)
 		log.Printf("case [%s] startTime %s(%d), average dataInterval %d ms, cycleTime %d ms.\n", userCase, startStr, start, avgInterval, cycleTime)
 	}
 
-	if DEFAULT_DELAY == delay {
+	if DefaultDelay == delay {
 		// default delay
-		delay = caseMinumInterval / 2
+		delay = caseMinInterval / 2
 		if delay < 1 {
 			delay = 1
 		}
@@ -218,7 +225,7 @@ func main() {
 	createSuperTable(superTableConfigMap)
 	log.Printf("create %d superTable ,used %d ms.\n", superTableNum, time.Since(start)/1e6)
 
-	//create sub table
+	// create sub table
 	start = time.Now()
 	createSubTable(subTableMap)
 	log.Printf("create %d times of %d subtable ,all %d tables, used %d ms.\n", hnum, len(subTableMap), len(scaleTableMap), time.Since(start)/1e6)
@@ -278,7 +285,7 @@ func staticSpeed() {
 	defer connection.Close()
 
 	if save == 1 {
-		connection.Exec("use " + db)
+		_, _ = connection.Exec("use " + db)
 		_, err := connection.Exec("create table if not exists " + saveTable + "(ts timestamp, speed int)")
 		if err != nil {
 			log.Fatalf("create %s Table error: %s\n", saveTable, err)
@@ -294,12 +301,12 @@ func staticSpeed() {
 		total := getTotalRows(successRows)
 		currentSuccessRows := total - lastTotalRows
 
-		speed := currentSuccessRows * 1e9 / int64(usedTime)
+		speed := currentSuccessRows * 1e9 / usedTime
 		log.Printf("insert %d rows, used %d ms, speed %d rows/s", currentSuccessRows, usedTime/1e6, speed)
 
 		if save == 1 {
 			insertSql := fmt.Sprintf("insert into %s values(%d, %d)", saveTable, currentTime.UnixNano()/1e6, speed)
-			connection.Exec(insertSql)
+			_, _ = connection.Exec(insertSql)
 		}
 
 		lastStaticTime = currentTime
@@ -327,12 +334,13 @@ func getSuperTableTimeConfig(fileRows dataRows) (start, cycleTime, avgInterval i
 	} else {
 
 		// use the sample data primary timestamp
-		sort.Sort(fileRows) // sort the file data by the primarykey
+		sort.Sort(fileRows) // sort the file data by the primaryKey
 		minTime := getPrimaryKey(fileRows.rows[0][fileRows.config.Timestamp])
 		maxTime := getPrimaryKey(fileRows.rows[len(fileRows.rows)-1][fileRows.config.Timestamp])
 
 		start = minTime // default startTime use the minTime
-		if DEFAULT_STARTTIME != startTime {
+		// 设置了start时间的话 按照start来
+		if DefaultStartTime != startTime {
 			start = startTime
 		}
 
@@ -350,31 +358,21 @@ func getSuperTableTimeConfig(fileRows dataRows) (start, cycleTime, avgInterval i
 	return
 }
 
-func createStatisticTable() {
-	connection := getConnection()
-	defer connection.Close()
-
-	_, err := connection.Exec("create table if not exist " + db + "." + saveTable + "(ts timestamp, speed int)")
-	if err != nil {
-		log.Fatalf("createStatisticTable error: %s\n", err)
-	}
-}
-
 func createSubTable(subTableMaps map[string]*dataRows) {
 
 	connection := getConnection()
 	defer connection.Close()
 
-	connection.Exec("use " + db)
+	_, _ = connection.Exec("use " + db)
 
 	createTablePrefix := "create table if not exists "
+	var buffer bytes.Buffer
 	for subTableName := range subTableMaps {
 
-		superTableName := getSuperTableName(subTableMaps[subTableName].config.Stname)
-		tagValues := subTableMaps[subTableName].rows[0] // the first rows values as tags
+		superTableName := getSuperTableName(subTableMaps[subTableName].config.StName)
+		firstRowValues := subTableMaps[subTableName].rows[0] // the first rows values as tags
 
-		buffers := bytes.Buffer{}
-		// create table t using supertTable tags(...);
+		// create table t using superTable tags(...);
 		for i := 0; i < hnum; i++ {
 			tableName := getScaleSubTableName(subTableName, i)
 
@@ -384,21 +382,21 @@ func createSubTable(subTableMaps map[string]*dataRows) {
 			}
 			scaleTableNames = append(scaleTableNames, tableName)
 
-			buffers.WriteString(createTablePrefix)
-			buffers.WriteString(tableName)
-			buffers.WriteString(" using ")
-			buffers.WriteString(superTableName)
-			buffers.WriteString(" tags(")
+			buffer.WriteString(createTablePrefix)
+			buffer.WriteString(tableName)
+			buffer.WriteString(" using ")
+			buffer.WriteString(superTableName)
+			buffer.WriteString(" tags(")
 			for _, tag := range subTableMaps[subTableName].config.Tags {
-				tagValue := fmt.Sprintf("%v", tagValues[strings.ToLower(tag.Name)])
-				buffers.WriteString("'" + tagValue + "'")
-				buffers.WriteString(",")
+				tagValue := fmt.Sprintf("%v", firstRowValues[strings.ToLower(tag.Name)])
+				buffer.WriteString("'" + tagValue + "'")
+				buffer.WriteString(",")
 			}
-			buffers.Truncate(buffers.Len() - 1)
-			buffers.WriteString(")")
+			buffer.Truncate(buffer.Len() - 1)
+			buffer.WriteString(")")
 
-			createTableSql := buffers.String()
-			buffers.Reset()
+			createTableSql := buffer.String()
+			buffer.Reset()
 
 			//log.Printf("create table: %s\n", createTableSql)
 			_, err := connection.Exec(createTableSql)
@@ -420,7 +418,7 @@ func createSuperTable(superTableConfigMap map[string]*superTableConfig) {
 		if err != nil {
 			log.Fatalf("drop database error: %s\n", err)
 		}
-		log.Printf("dropDb: %s\n", dropDbSql)
+		log.Printf("dropdb: %s\n", dropDbSql)
 	}
 
 	createDbSql := "create database if not exists " + db + " " + dbparam
@@ -431,7 +429,7 @@ func createSuperTable(superTableConfigMap map[string]*superTableConfig) {
 	}
 	log.Printf("createDb: %s\n", createDbSql)
 
-	connection.Exec("use " + db)
+	_, _ = connection.Exec("use " + db)
 
 	prefix := "create table if not exists "
 	var buffer bytes.Buffer
@@ -464,7 +462,7 @@ func createSuperTable(superTableConfigMap map[string]*superTableConfig) {
 		createSql := buffer.String()
 		buffer.Reset()
 
-		//log.Printf("supertable: %s\n", createSql)
+		//log.Printf("superTable: %s\n", createSql)
 		_, err = connection.Exec(createSql)
 		if err != nil {
 			log.Fatalf("create supertable error: %s\n", err)
@@ -473,15 +471,15 @@ func createSuperTable(superTableConfigMap map[string]*superTableConfig) {
 
 }
 
-func getScaleSubTableName(subTableName string, hnum int) string {
-	if hnum == 0 {
+func getScaleSubTableName(subTableName string, hNum int) string {
+	if hNum == 0 {
 		return subTableName
 	}
-	return fmt.Sprintf("%s_%d", subTableName, hnum)
+	return fmt.Sprintf("%s_%d", subTableName, hNum)
 }
 
-func getSuperTableName(stname string) string {
-	return SUPERTABLE_PREFIX + stname
+func getSuperTableName(stName string) string {
+	return SuperTablePrefix + stName
 }
 
 /**
@@ -499,7 +497,7 @@ func normalizationData(fileRows dataRows, minTime int64) int64 {
 
 		row[fileRows.config.Timestamp] = getPrimaryKey(row[fileRows.config.Timestamp]) - minTime
 
-		subTableName := getSubTableName(tableValue, fileRows.config.Stname)
+		subTableName := getSubTableName(tableValue, fileRows.config.StName)
 
 		value, ok := subTableMap[subTableName]
 		if !ok {
@@ -527,7 +525,7 @@ func normalizationDataWithSameInterval(fileRows dataRows, avgInterval int64) int
 			continue
 		}
 
-		subTableName := getSubTableName(tableValue, fileRows.config.Stname)
+		subTableName := getSubTableName(tableValue, fileRows.config.StName)
 
 		value, ok := currSubTableMap[subTableName]
 		if !ok {
@@ -543,7 +541,7 @@ func normalizationDataWithSameInterval(fileRows dataRows, avgInterval int64) int
 
 	}
 
-	var maxRows, tableRows int = 0, 0
+	var maxRows, tableRows = 0, 0
 	for tableName := range currSubTableMap {
 		tableRows = len(currSubTableMap[tableName].rows)
 		subTableMap[tableName] = currSubTableMap[tableName] // add to global subTableMap
@@ -556,7 +554,7 @@ func normalizationDataWithSameInterval(fileRows dataRows, avgInterval int64) int
 }
 
 func getSubTableName(subTableValue string, superTableName string) string {
-	return SUBTABLE_PREFIX + subTableValue + "_" + superTableName
+	return SubTablePrefix + subTableValue + "_" + superTableName
 }
 
 func insertData(threadIndex, start, end int, wg *sync.WaitGroup, successRows []int64) {
@@ -564,25 +562,25 @@ func insertData(threadIndex, start, end int, wg *sync.WaitGroup, successRows []i
 	defer connection.Close()
 	defer wg.Done()
 
-	connection.Exec("use " + db) // use db
+	_, _ = connection.Exec("use " + db) // use db
 
 	log.Printf("thread-%d start insert into [%d, %d) subtables.\n", threadIndex, start, end)
 
 	num := 0
 	subTables := scaleTableNames[start:end]
+	var buffer bytes.Buffer
 	for {
 		var currSuccessRows int64
 		var appendRows int
 		var lastTableName string
 
-		buffers := bytes.Buffer{}
-		buffers.WriteString(INSERT_PREFIX)
+		buffer.WriteString(InsertPrefix)
 
 		for _, tableName := range subTables {
 
 			subTableInfo := subTableMap[scaleTableMap[tableName].subTableName]
 			subTableRows := int64(len(subTableInfo.rows))
-			superTableConf := superTableConfigMap[subTableInfo.config.Stname]
+			superTableConf := superTableConfigMap[subTableInfo.config.StName]
 
 			tableStartTime := superTableConf.startTime
 			var tableEndTime int64
@@ -605,40 +603,35 @@ func insertData(threadIndex, start, end int, wg *sync.WaitGroup, successRows []i
 					// append
 
 					if lastTableName != tableName {
-						buffers.WriteString(tableName)
-						buffers.WriteString(" values")
+						buffer.WriteString(tableName)
+						buffer.WriteString(" values")
 					}
 					lastTableName = tableName
 
-					buffers.WriteString("(")
-					buffers.WriteString(fmt.Sprintf("%v", currentTime))
-					buffers.WriteString(",")
+					buffer.WriteString("(")
+					buffer.WriteString(fmt.Sprintf("%v", currentTime))
+					buffer.WriteString(",")
 
-					// fieldNum := len(subTableInfo.config.Fields)
 					for _, field := range subTableInfo.config.Fields {
-						buffers.WriteString(getFieldValue(currentRow[strings.ToLower(field.Name)]))
-						buffers.WriteString(",")
-						// if( i != fieldNum -1){
-
-						// }
+						buffer.WriteString(getFieldValue(currentRow[strings.ToLower(field.Name)]))
+						buffer.WriteString(",")
 					}
 
-					buffers.Truncate(buffers.Len() - 1)
-					buffers.WriteString(") ")
+					buffer.Truncate(buffer.Len() - 1)
+					buffer.WriteString(") ")
 
 					appendRows++
 					insertRows++
 					if appendRows == batch {
-						// executebatch
-						insertSql := buffers.String()
-						connection.Exec("use " + db)
+						// executeBatch
+						insertSql := buffer.String()
 						affectedRows := executeBatchInsert(insertSql, connection)
 
 						successRows[threadIndex] += affectedRows
 						currSuccessRows += affectedRows
 
-						buffers.Reset()
-						buffers.WriteString(INSERT_PREFIX)
+						buffer.Reset()
+						buffer.WriteString(InsertPrefix)
 						lastTableName = ""
 						appendRows = 0
 					}
@@ -654,15 +647,14 @@ func insertData(threadIndex, start, end int, wg *sync.WaitGroup, successRows []i
 
 		// left := len(rows)
 		if appendRows > 0 {
-			// executebatch
-			insertSql := buffers.String()
-			connection.Exec("use " + db)
+			// executeBatch
+			insertSql := buffer.String()
 			affectedRows := executeBatchInsert(insertSql, connection)
 
 			successRows[threadIndex] += affectedRows
 			currSuccessRows += affectedRows
 
-			buffers.Reset()
+			buffer.Reset()
 		}
 
 		// log.Printf("thread-%d finished insert %d rows, used %d ms.", threadIndex, currSuccessRows, time.Since(threadStartTime)/1e6)
@@ -688,65 +680,10 @@ func insertData(threadIndex, start, end int, wg *sync.WaitGroup, successRows []i
 
 }
 
-func buildSql(rows []tableRows) string {
-
-	var lastTableName string
-
-	buffers := bytes.Buffer{}
-
-	for i, row := range rows {
-		if i == 0 {
-			lastTableName = row.tableName
-			buffers.WriteString(INSERT_PREFIX)
-			buffers.WriteString(row.tableName)
-			buffers.WriteString(" values")
-			buffers.WriteString(row.value)
-			continue
-		}
-
-		if lastTableName == row.tableName {
-			buffers.WriteString(row.value)
-		} else {
-			buffers.WriteString(" ")
-			buffers.WriteString(row.tableName)
-			buffers.WriteString(" values")
-			buffers.WriteString(row.value)
-			lastTableName = row.tableName
-		}
-	}
-
-	inserSql := buffers.String()
-	return inserSql
-}
-
-func buildRow(tableName string, currentTime int64, subTableInfo *dataRows, currentRow map[string]interface{}) tableRows {
-
-	tableRows := tableRows{tableName: tableName}
-
-	buffers := bytes.Buffer{}
-
-	buffers.WriteString("(")
-	buffers.WriteString(fmt.Sprintf("%v", currentTime))
-	buffers.WriteString(",")
-
-	for _, field := range subTableInfo.config.Fields {
-		buffers.WriteString(getFieldValue(currentRow[strings.ToLower(field.Name)]))
-		buffers.WriteString(",")
-	}
-
-	buffers.Truncate(buffers.Len() - 1)
-	buffers.WriteString(")")
-
-	insertSql := buffers.String()
-	tableRows.value = insertSql
-
-	return tableRows
-}
-
 func executeBatchInsert(insertSql string, connection *sql.DB) int64 {
-	result, error := connection.Exec(insertSql)
-	if error != nil {
-		log.Printf("execute insertSql %s error, %s\n", insertSql, error)
+	result, err := connection.Exec(insertSql)
+	if err != nil {
+		log.Printf("execute insertSql %s error, %s\n", insertSql, err)
 		return 0
 	}
 	affected, _ := result.RowsAffected()
@@ -754,7 +691,6 @@ func executeBatchInsert(insertSql string, connection *sql.DB) int64 {
 		affected = 0
 	}
 	return affected
-	// return 0
 }
 
 func getFieldValue(fieldValue interface{}) string {
@@ -762,7 +698,7 @@ func getFieldValue(fieldValue interface{}) string {
 }
 
 func getConnection() *sql.DB {
-	db, err := sql.Open(DRIVER_NAME, dataSourceName)
+	db, err := sql.Open(DriverName, dataSourceName)
 	if err != nil {
 		panic(err)
 	}
@@ -773,19 +709,11 @@ func getSubTableNameValue(suffix interface{}) string {
 	return fmt.Sprintf("%v", suffix)
 }
 
-func hash(s string) int {
-	v := int(crc32.ChecksumIEEE([]byte(s)))
-	if v < 0 {
-		return -v
-	}
-	return v
-}
-
-func readFile(config dataimport.CaseConfig) dataRows {
+func readFile(config dataImport.CaseConfig) dataRows {
 	fileFormat := strings.ToLower(config.Format)
-	if fileFormat == JSON_FORMAT {
+	if fileFormat == JsonFormat {
 		return readJSONFile(config)
-	} else if fileFormat == CSV_FORMAT {
+	} else if fileFormat == CsvFormat {
 		return readCSVFile(config)
 	}
 
@@ -793,7 +721,7 @@ func readFile(config dataimport.CaseConfig) dataRows {
 	return dataRows{}
 }
 
-func readCSVFile(config dataimport.CaseConfig) dataRows {
+func readCSVFile(config dataImport.CaseConfig) dataRows {
 	var rows dataRows
 	f, err := os.Open(config.FilePath)
 	if err != nil {
@@ -813,7 +741,7 @@ func readCSVFile(config dataimport.CaseConfig) dataRows {
 	line := strings.ToLower(string(lineBytes))
 	titles := strings.Split(line, config.Separator)
 	if len(titles) < 3 {
-		// need suffix、 primarykey and at least one other field
+		// need suffix、 primaryKey and at least one other field
 		log.Printf("the first line of file %s should be title row, and at least 3 field.\n", config.FilePath)
 		return rows
 	}
@@ -848,7 +776,7 @@ func readCSVFile(config dataimport.CaseConfig) dataRows {
 		}
 
 		// if the primary key valid
-		primaryKeyValue := getPrimaryKeyMillisec(config.Timestamp, config.TimestampType, config.TimestampTypeFormat, dataMap)
+		primaryKeyValue := getPrimaryKeyMilliSec(config.Timestamp, config.TimestampType, config.TimestampTypeFormat, dataMap)
 		if primaryKeyValue == -1 {
 			log.Printf("the Timestamp[%s] of line %d is not valid, will filtered.\n", config.Timestamp, lineNum)
 			continue
@@ -861,7 +789,7 @@ func readCSVFile(config dataimport.CaseConfig) dataRows {
 	return rows
 }
 
-func readJSONFile(config dataimport.CaseConfig) dataRows {
+func readJSONFile(config dataImport.CaseConfig) dataRows {
 
 	var rows dataRows
 	f, err := os.Open(config.FilePath)
@@ -899,7 +827,7 @@ func readJSONFile(config dataimport.CaseConfig) dataRows {
 			continue
 		}
 
-		primaryKeyValue := getPrimaryKeyMillisec(config.Timestamp, config.TimestampType, config.TimestampTypeFormat, line)
+		primaryKeyValue := getPrimaryKeyMilliSec(config.Timestamp, config.TimestampType, config.TimestampTypeFormat, line)
 		if primaryKeyValue == -1 {
 			log.Printf("the Timestamp[%s] of line %d is not valid, will filtered.\n", config.Timestamp, lineNum)
 			continue
@@ -916,7 +844,7 @@ func readJSONFile(config dataimport.CaseConfig) dataRows {
 /**
 * get primary key as millisecond , otherwise return -1
  */
-func getPrimaryKeyMillisec(key string, valueType string, valueFormat string, line map[string]interface{}) int64 {
+func getPrimaryKeyMilliSec(key string, valueType string, valueFormat string, line map[string]interface{}) int64 {
 	if !existMapKeyAndNotEmpty(key, line) {
 		return -1
 	}
@@ -971,13 +899,13 @@ func existMapKeyAndNotEmpty(key string, maps map[string]interface{}) bool {
 	return true
 }
 
-func checkUserCaseConfig(caseName string, caseConfig *dataimport.CaseConfig) {
+func checkUserCaseConfig(caseName string, caseConfig *dataImport.CaseConfig) {
 
-	if len(caseConfig.Stname) == 0 {
+	if len(caseConfig.StName) == 0 {
 		log.Fatalf("the stname of case %s can't be empty\n", caseName)
 	}
 
-	caseConfig.Stname = strings.ToLower(caseConfig.Stname)
+	caseConfig.StName = strings.ToLower(caseConfig.StName)
 
 	if len(caseConfig.Tags) == 0 {
 		log.Fatalf("the tags of case %s can't be empty\n", caseName)
@@ -1029,24 +957,24 @@ func checkUserCaseConfig(caseName string, caseConfig *dataimport.CaseConfig) {
 }
 
 func parseArg() {
-	flag.StringVar(&cfg, "cfg", "config/cfg.toml", "configuration file which describes usecase and data format.")
-	flag.StringVar(&cases, "cases", "sensor_info", "usecase for dataset to be imported. Multiple choices can be separated by comma, for example, -cases sensor_info,camera_detection.")
+	flag.StringVar(&cfg, "cfg", "config/cfg.toml", "configuration file which describes useCase and data format.")
+	flag.StringVar(&cases, "cases", "sensor_info", "useCase for dataset to be imported. Multiple choices can be separated by comma, for example, -cases sensor_info,camera_detection.")
 	flag.IntVar(&hnum, "hnum", 100, "magnification factor of the sample tables. For example, if hnum is 100 and in the sample data there are 10 tables, then 10x100=1000 tables will be created in the database.")
 	flag.IntVar(&vnum, "vnum", 1000, "copies of the sample records in each table. If set to 0，this program will never stop simulating and importing data even if the timestamp has passed current time.")
-	flag.Int64Var(&delay, "delay", DEFAULT_DELAY, "the delay time interval(millisecond) to continue generating data when vnum set 0.")
+	flag.Int64Var(&delay, "delay", DefaultDelay, "the delay time interval(millisecond) to continue generating data when vnum set 0.")
 	flag.Int64Var(&tick, "tick", 2000, "the tick time interval(millisecond) to print statistic info.")
 	flag.IntVar(&save, "save", 0, "whether to save the statistical info into 'statistic' table. 0 is disabled and 1 is enabled.")
-	flag.StringVar(&saveTable, "savetb", DEFAULT_STATISTIC_TABLE, "the table to save 'statistic' info when save set 1.")
+	flag.StringVar(&saveTable, "savetb", DefaultStatisticTable, "the table to save 'statistic' info when save set 1.")
 	flag.IntVar(&thread, "thread", 10, "number of threads to import data.")
 	flag.IntVar(&batch, "batch", 100, "rows of records in one import batch.")
-	flag.IntVar(&auto, "auto", 0, "whether to use the starttime and interval specified by users when simulating the data. 0 is disabled and 1 is enabled.")
-	flag.StringVar(&starttimestr, "start", "", "the starting timestamp of simulated data, in the format of yyyy-MM-dd HH:mm:ss.SSS. If not specified, the ealiest timestamp in the sample data will be set as the starttime.")
-	flag.Int64Var(&interval, "interval", DEFAULT_INTERVAL, "time inteval between two consecutive records, in the unit of millisecond. Only valid when auto is 1.")
+	flag.IntVar(&auto, "auto", 0, "whether to use the startTime and interval specified by users when simulating the data. 0 is disabled and 1 is enabled.")
+	flag.StringVar(&startTimeStr, "start", "", "the starting timestamp of simulated data, in the format of yyyy-MM-dd HH:mm:ss.SSS. If not specified, the earliest timestamp in the sample data will be set as the startTime.")
+	flag.Int64Var(&interval, "interval", DefaultInterval, "time interval between two consecutive records, in the unit of millisecond. Only valid when auto is 1.")
 	flag.StringVar(&host, "host", "127.0.0.1", "tdengine server ip.")
 	flag.IntVar(&port, "port", 6030, "tdengine server port.")
 	flag.StringVar(&user, "user", "root", "user name to login into the database.")
 	flag.StringVar(&password, "password", "taosdata", "the import tdengine user password")
-	flag.IntVar(&dropdb, "dropdb", 0, "whether to drop the existing datbase. 1 is yes and 0 otherwise.")
+	flag.IntVar(&dropdb, "dropdb", 0, "whether to drop the existing database. 1 is yes and 0 otherwise.")
 	flag.StringVar(&db, "db", "", "name of the database to store data.")
 	flag.StringVar(&dbparam, "dbparam", "", "database configurations when it is created.")
 
@@ -1066,7 +994,7 @@ func printArg() {
 	fmt.Println("-thread:", thread)
 	fmt.Println("-batch:", batch)
 	fmt.Println("-auto:", auto)
-	fmt.Println("-start:", starttimestr)
+	fmt.Println("-start:", startTimeStr)
 	fmt.Println("-interval:", interval)
 	fmt.Println("-host:", host)
 	fmt.Println("-port", port)

importSampleData/data/sensor_info.csv

@@ -899,103 +899,103 @@ devid,location,color,devgroup,ts,temperature,humidity
 8, haerbing, yellow, 2, 1575129697000, 31, 16.321497
 8, haerbing, yellow, 2, 1575129698000, 25, 15.864515
 8, haerbing, yellow, 2, 1575129699000, 25, 16.492443
-9, sijiazhuang, blue, 0, 1575129600000, 23, 16.002889
-9, sijiazhuang, blue, 0, 1575129601000, 26, 17.034610
-9, sijiazhuang, blue, 0, 1575129602000, 29, 12.892319
-9, sijiazhuang, blue, 0, 1575129603000, 34, 15.321807
-9, sijiazhuang, blue, 0, 1575129604000, 29, 12.562642
-9, sijiazhuang, blue, 0, 1575129605000, 32, 17.190246
-9, sijiazhuang, blue, 0, 1575129606000, 19, 15.361774
-9, sijiazhuang, blue, 0, 1575129607000, 26, 15.022364
-9, sijiazhuang, blue, 0, 1575129608000, 31, 14.837084
-9, sijiazhuang, blue, 0, 1575129609000, 25, 11.554289
-9, sijiazhuang, blue, 0, 1575129610000, 21, 15.313973
-9, sijiazhuang, blue, 0, 1575129611000, 27, 18.621783
-9, sijiazhuang, blue, 0, 1575129612000, 31, 18.018101
-9, sijiazhuang, blue, 0, 1575129613000, 23, 14.421450
-9, sijiazhuang, blue, 0, 1575129614000, 28, 10.833142
-9, sijiazhuang, blue, 0, 1575129615000, 33, 18.169837
-9, sijiazhuang, blue, 0, 1575129616000, 21, 18.772730
-9, sijiazhuang, blue, 0, 1575129617000, 24, 18.893146
-9, sijiazhuang, blue, 0, 1575129618000, 24, 10.290187
-9, sijiazhuang, blue, 0, 1575129619000, 23, 17.393345
-9, sijiazhuang, blue, 0, 1575129620000, 30, 12.949215
-9, sijiazhuang, blue, 0, 1575129621000, 19, 19.267621
-9, sijiazhuang, blue, 0, 1575129622000, 33, 14.831735
-9, sijiazhuang, blue, 0, 1575129623000, 21, 14.711125
-9, sijiazhuang, blue, 0, 1575129624000, 16, 17.168485
-9, sijiazhuang, blue, 0, 1575129625000, 17, 16.426433
-9, sijiazhuang, blue, 0, 1575129626000, 19, 13.879050
-9, sijiazhuang, blue, 0, 1575129627000, 21, 18.308168
-9, sijiazhuang, blue, 0, 1575129628000, 17, 10.845681
-9, sijiazhuang, blue, 0, 1575129629000, 20, 10.238272
-9, sijiazhuang, blue, 0, 1575129630000, 19, 19.424976
-9, sijiazhuang, blue, 0, 1575129631000, 31, 13.885909
-9, sijiazhuang, blue, 0, 1575129632000, 15, 19.264740
-9, sijiazhuang, blue, 0, 1575129633000, 30, 12.460645
-9, sijiazhuang, blue, 0, 1575129634000, 27, 17.608036
-9, sijiazhuang, blue, 0, 1575129635000, 25, 13.493812
-9, sijiazhuang, blue, 0, 1575129636000, 19, 10.955939
-9, sijiazhuang, blue, 0, 1575129637000, 24, 11.956587
-9, sijiazhuang, blue, 0, 1575129638000, 15, 19.141381
-9, sijiazhuang, blue, 0, 1575129639000, 24, 14.801530
-9, sijiazhuang, blue, 0, 1575129640000, 17, 14.347318
-9, sijiazhuang, blue, 0, 1575129641000, 29, 14.803237
-9, sijiazhuang, blue, 0, 1575129642000, 28, 10.342297
-9, sijiazhuang, blue, 0, 1575129643000, 29, 19.368282
-9, sijiazhuang, blue, 0, 1575129644000, 31, 17.491654
-9, sijiazhuang, blue, 0, 1575129645000, 18, 13.161736
-9, sijiazhuang, blue, 0, 1575129646000, 17, 16.067354
-9, sijiazhuang, blue, 0, 1575129647000, 18, 13.736465
-9, sijiazhuang, blue, 0, 1575129648000, 23, 19.103276
-9, sijiazhuang, blue, 0, 1575129649000, 29, 16.075892
-9, sijiazhuang, blue, 0, 1575129650000, 21, 10.728566
-9, sijiazhuang, blue, 0, 1575129651000, 15, 18.921849
-9, sijiazhuang, blue, 0, 1575129652000, 24, 16.914709
-9, sijiazhuang, blue, 0, 1575129653000, 19, 13.501651
-9, sijiazhuang, blue, 0, 1575129654000, 19, 13.538347
-9, sijiazhuang, blue, 0, 1575129655000, 16, 13.261095
-9, sijiazhuang, blue, 0, 1575129656000, 32, 16.315746
-9, sijiazhuang, blue, 0, 1575129657000, 27, 16.400939
-9, sijiazhuang, blue, 0, 1575129658000, 24, 13.321819
-9, sijiazhuang, blue, 0, 1575129659000, 27, 19.070181
-9, sijiazhuang, blue, 0, 1575129660000, 27, 13.040922
-9, sijiazhuang, blue, 0, 1575129661000, 32, 10.872530
-9, sijiazhuang, blue, 0, 1575129662000, 28, 16.428657
-9, sijiazhuang, blue, 0, 1575129663000, 32, 13.883854
-9, sijiazhuang, blue, 0, 1575129664000, 33, 14.299554
-9, sijiazhuang, blue, 0, 1575129665000, 30, 16.445130
-9, sijiazhuang, blue, 0, 1575129666000, 15, 18.059404
-9, sijiazhuang, blue, 0, 1575129667000, 21, 12.348847
-9, sijiazhuang, blue, 0, 1575129668000, 32, 13.315378
-9, sijiazhuang, blue, 0, 1575129669000, 17, 15.689507
-9, sijiazhuang, blue, 0, 1575129670000, 22, 15.591808
-9, sijiazhuang, blue, 0, 1575129671000, 27, 16.386065
-9, sijiazhuang, blue, 0, 1575129672000, 25, 10.564803
-9, sijiazhuang, blue, 0, 1575129673000, 20, 12.276544
-9, sijiazhuang, blue, 0, 1575129674000, 26, 15.828786
-9, sijiazhuang, blue, 0, 1575129675000, 18, 12.236420
-9, sijiazhuang, blue, 0, 1575129676000, 15, 19.439522
-9, sijiazhuang, blue, 0, 1575129677000, 19, 19.831531
-9, sijiazhuang, blue, 0, 1575129678000, 22, 17.115744
-9, sijiazhuang, blue, 0, 1575129679000, 29, 19.879456
-9, sijiazhuang, blue, 0, 1575129680000, 34, 10.207136
-9, sijiazhuang, blue, 0, 1575129681000, 16, 17.633523
-9, sijiazhuang, blue, 0, 1575129682000, 15, 14.227873
-9, sijiazhuang, blue, 0, 1575129683000, 34, 12.027768
-9, sijiazhuang, blue, 0, 1575129684000, 22, 11.376610
-9, sijiazhuang, blue, 0, 1575129685000, 21, 11.711299
-9, sijiazhuang, blue, 0, 1575129686000, 33, 14.281126
-9, sijiazhuang, blue, 0, 1575129687000, 31, 10.895302
-9, sijiazhuang, blue, 0, 1575129688000, 31, 13.971350
-9, sijiazhuang, blue, 0, 1575129689000, 15, 15.262790
-9, sijiazhuang, blue, 0, 1575129690000, 23, 12.440568
-9, sijiazhuang, blue, 0, 1575129691000, 32, 19.731267
-9, sijiazhuang, blue, 0, 1575129692000, 22, 10.518092
-9, sijiazhuang, blue, 0, 1575129693000, 34, 17.863021
-9, sijiazhuang, blue, 0, 1575129694000, 28, 11.478909
-9, sijiazhuang, blue, 0, 1575129695000, 16, 15.075524
-9, sijiazhuang, blue, 0, 1575129696000, 16, 10.292127
-9, sijiazhuang, blue, 0, 1575129697000, 22, 13.716012
-9, sijiazhuang, blue, 0, 1575129698000, 32, 10.906551
-9, sijiazhuang, blue, 0, 1575129699000, 19, 18.386868
+9, shijiazhuang, blue, 0, 1575129600000, 23, 16.002889
+9, shijiazhuang, blue, 0, 1575129601000, 26, 17.034610
+9, shijiazhuang, blue, 0, 1575129602000, 29, 12.892319
+9, shijiazhuang, blue, 0, 1575129603000, 34, 15.321807
+9, shijiazhuang, blue, 0, 1575129604000, 29, 12.562642
+9, shijiazhuang, blue, 0, 1575129605000, 32, 17.190246
+9, shijiazhuang, blue, 0, 1575129606000, 19, 15.361774
+9, shijiazhuang, blue, 0, 1575129607000, 26, 15.022364
+9, shijiazhuang, blue, 0, 1575129608000, 31, 14.837084
+9, shijiazhuang, blue, 0, 1575129609000, 25, 11.554289
+9, shijiazhuang, blue, 0, 1575129610000, 21, 15.313973
+9, shijiazhuang, blue, 0, 1575129611000, 27, 18.621783
+9, shijiazhuang, blue, 0, 1575129612000, 31, 18.018101
+9, shijiazhuang, blue, 0, 1575129613000, 23, 14.421450
+9, shijiazhuang, blue, 0, 1575129614000, 28, 10.833142
+9, shijiazhuang, blue, 0, 1575129615000, 33, 18.169837
+9, shijiazhuang, blue, 0, 1575129616000, 21, 18.772730
+9, shijiazhuang, blue, 0, 1575129617000, 24, 18.893146
+9, shijiazhuang, blue, 0, 1575129618000, 24, 10.290187
+9, shijiazhuang, blue, 0, 1575129619000, 23, 17.393345
+9, shijiazhuang, blue, 0, 1575129620000, 30, 12.949215
+9, shijiazhuang, blue, 0, 1575129621000, 19, 19.267621
+9, shijiazhuang, blue, 0, 1575129622000, 33, 14.831735
+9, shijiazhuang, blue, 0, 1575129623000, 21, 14.711125
+9, shijiazhuang, blue, 0, 1575129624000, 16, 17.168485
+9, shijiazhuang, blue, 0, 1575129625000, 17, 16.426433
+9, shijiazhuang, blue, 0, 1575129626000, 19, 13.879050
+9, shijiazhuang, blue, 0, 1575129627000, 21, 18.308168
+9, shijiazhuang, blue, 0, 1575129628000, 17, 10.845681
+9, shijiazhuang, blue, 0, 1575129629000, 20, 10.238272
+9, shijiazhuang, blue, 0, 1575129630000, 19, 19.424976
+9, shijiazhuang, blue, 0, 1575129631000, 31, 13.885909
+9, shijiazhuang, blue, 0, 1575129632000, 15, 19.264740
+9, shijiazhuang, blue, 0, 1575129633000, 30, 12.460645
+9, shijiazhuang, blue, 0, 1575129634000, 27, 17.608036
+9, shijiazhuang, blue, 0, 1575129635000, 25, 13.493812
+9, shijiazhuang, blue, 0, 1575129636000, 19, 10.955939
+9, shijiazhuang, blue, 0, 1575129637000, 24, 11.956587
+9, shijiazhuang, blue, 0, 1575129638000, 15, 19.141381
+9, shijiazhuang, blue, 0, 1575129639000, 24, 14.801530
+9, shijiazhuang, blue, 0, 1575129640000, 17, 14.347318
+9, shijiazhuang, blue, 0, 1575129641000, 29, 14.803237
+9, shijiazhuang, blue, 0, 1575129642000, 28, 10.342297
+9, shijiazhuang, blue, 0, 1575129643000, 29, 19.368282
+9, shijiazhuang, blue, 0, 1575129644000, 31, 17.491654
+9, shijiazhuang, blue, 0, 1575129645000, 18, 13.161736
+9, shijiazhuang, blue, 0, 1575129646000, 17, 16.067354
+9, shijiazhuang, blue, 0, 1575129647000, 18, 13.736465
+9, shijiazhuang, blue, 0, 1575129648000, 23, 19.103276
+9, shijiazhuang, blue, 0, 1575129649000, 29, 16.075892
+9, shijiazhuang, blue, 0, 1575129650000, 21, 10.728566
+9, shijiazhuang, blue, 0, 1575129651000, 15, 18.921849
+9, shijiazhuang, blue, 0, 1575129652000, 24, 16.914709
+9, shijiazhuang, blue, 0, 1575129653000, 19, 13.501651
+9, shijiazhuang, blue, 0, 1575129654000, 19, 13.538347
+9, shijiazhuang, blue, 0, 1575129655000, 16, 13.261095
+9, shijiazhuang, blue, 0, 1575129656000, 32, 16.315746
+9, shijiazhuang, blue, 0, 1575129657000, 27, 16.400939
+9, shijiazhuang, blue, 0, 1575129658000, 24, 13.321819
+9, shijiazhuang, blue, 0, 1575129659000, 27, 19.070181
+9, shijiazhuang, blue, 0, 1575129660000, 27, 13.040922
+9, shijiazhuang, blue, 0, 1575129661000, 32, 10.872530
+9, shijiazhuang, blue, 0, 1575129662000, 28, 16.428657
+9, shijiazhuang, blue, 0, 1575129663000, 32, 13.883854
+9, shijiazhuang, blue, 0, 1575129664000, 33, 14.299554
+9, shijiazhuang, blue, 0, 1575129665000, 30, 16.445130
+9, shijiazhuang, blue, 0, 1575129666000, 15, 18.059404
+9, shijiazhuang, blue, 0, 1575129667000, 21, 12.348847
+9, shijiazhuang, blue, 0, 1575129668000, 32, 13.315378
+9, shijiazhuang, blue, 0, 1575129669000, 17, 15.689507
+9, shijiazhuang, blue, 0, 1575129670000, 22, 15.591808
+9, shijiazhuang, blue, 0, 1575129671000, 27, 16.386065
+9, shijiazhuang, blue, 0, 1575129672000, 25, 10.564803
+9, shijiazhuang, blue, 0, 1575129673000, 20, 12.276544
+9, shijiazhuang, blue, 0, 1575129674000, 26, 15.828786
+9, shijiazhuang, blue, 0, 1575129675000, 18, 12.236420
+9, shijiazhuang, blue, 0, 1575129676000, 15, 19.439522
+9, shijiazhuang, blue, 0, 1575129677000, 19, 19.831531
+9, shijiazhuang, blue, 0, 1575129678000, 22, 17.115744
+9, shijiazhuang, blue, 0, 1575129679000, 29, 19.879456
+9, shijiazhuang, blue, 0, 1575129680000, 34, 10.207136
+9, shijiazhuang, blue, 0, 1575129681000, 16, 17.633523
+9, shijiazhuang, blue, 0, 1575129682000, 15, 14.227873
+9, shijiazhuang, blue, 0, 1575129683000, 34, 12.027768
+9, shijiazhuang, blue, 0, 1575129684000, 22, 11.376610
+9, shijiazhuang, blue, 0, 1575129685000, 21, 11.711299
+9, shijiazhuang, blue, 0, 1575129686000, 33, 14.281126
+9, shijiazhuang, blue, 0, 1575129687000, 31, 10.895302
+9, shijiazhuang, blue, 0, 1575129688000, 31, 13.971350
+9, shijiazhuang, blue, 0, 1575129689000, 15, 15.262790
+9, shijiazhuang, blue, 0, 1575129690000, 23, 12.440568
+9, shijiazhuang, blue, 0, 1575129691000, 32, 19.731267
+9, shijiazhuang, blue, 0, 1575129692000, 22, 10.518092
+9, shijiazhuang, blue, 0, 1575129693000, 34, 17.863021
+9, shijiazhuang, blue, 0, 1575129694000, 28, 11.478909
+9, shijiazhuang, blue, 0, 1575129695000, 16, 15.075524
+9, shijiazhuang, blue, 0, 1575129696000, 16, 10.292127
+9, shijiazhuang, blue, 0, 1575129697000, 22, 13.716012
+9, shijiazhuang, blue, 0, 1575129698000, 32, 10.906551
+9, shijiazhuang, blue, 0, 1575129699000, 19, 18.386868

importSampleData/go.mod

@@ -0,0 +1,8 @@
+module github.com/taosdata/TDengine/importSampleData
+
+go 1.13
+
+require (
+	github.com/pelletier/go-toml v1.9.0 // indirect
+	github.com/taosdata/driver-go v0.0.0-20210415143420-d99751356e28 // indirect
+)

importSampleData/import/import_config.go

@@ -14,23 +14,23 @@ var (
 	once sync.Once
 )
 
-// Config inclue all scene import config
+// Config include all scene import config
 type Config struct {
 	UserCases map[string]CaseConfig
 }
 
 // CaseConfig include the sample data config and tdengine config
 type CaseConfig struct {
-	Format                string
-	FilePath              string
-	Separator             string
-	Stname                string
-	SubTableName          string
-	Timestamp             string
-	TimestampType   	  string
-	TimestampTypeFormat   string
-	Tags                  []FieldInfo
-	Fields                []FieldInfo
+	Format              string
+	FilePath            string
+	Separator           string
+	StName              string
+	SubTableName        string
+	Timestamp           string
+	TimestampType       string
+	TimestampTypeFormat string
+	Tags                []FieldInfo
+	Fields              []FieldInfo
 }
 
 // FieldInfo is field or tag info

packaging/cfg/taos.cfg

@@ -64,7 +64,7 @@
 # monitorInterval           30
 
 # number of seconds allowed for a dnode to be offline, for cluster only 
-# offlineThreshold          8640000
+# offlineThreshold          864000
 
 # RPC re-try timer, millisecond
 # rpcTimer                  300

snap/snapcraft.yaml

@@ -1,6 +1,7 @@
 name: tdengine
 base: core18
-version: '2.0.20.0'
+
+version: '2.1.0.0'
 icon: snap/gui/t-dengine.svg
 summary: an open-source big data platform designed and optimized for IoT. 
 description: |
@@ -72,7 +73,7 @@ parts:
       - usr/bin/taosd
       - usr/bin/taos
       - usr/bin/taosdemo
-      - usr/lib/libtaos.so.2.0.20.0
+      - usr/lib/libtaos.so.2.1.0.0
       - usr/lib/libtaos.so.1
       - usr/lib/libtaos.so
 

src/client/inc/tscSubquery.h

@@ -48,6 +48,8 @@ void tscLockByThread(int64_t *lockedBy);
 
 void tscUnlockByThread(int64_t *lockedBy);
 
+int tsInsertInitialCheck(SSqlObj *pSql);
+
 #ifdef __cplusplus
 }
 #endif

src/client/inc/tscUtil.h

@@ -175,7 +175,8 @@ void    tscFieldInfoClear(SFieldInfo* pFieldInfo);
 
 static FORCE_INLINE int32_t tscNumOfFields(SQueryInfo* pQueryInfo) { return pQueryInfo->fieldsInfo.numOfOutput; }
 
-int32_t tscFieldInfoCompare(const SFieldInfo* pFieldInfo1, const SFieldInfo* pFieldInfo2);
+int32_t tscFieldInfoCompare(const SFieldInfo* pFieldInfo1, const SFieldInfo* pFieldInfo2, int32_t *diffSize);
+int32_t tscFieldInfoSetSize(const SFieldInfo* pFieldInfo1, const SFieldInfo* pFieldInfo2);
 
 void addExprParams(SSqlExpr* pExpr, char* argument, int32_t type, int32_t bytes);
 
@@ -308,7 +309,7 @@ STableMeta* createSuperTableMeta(STableMetaMsg* pChild);
 uint32_t tscGetTableMetaSize(STableMeta* pTableMeta);
 CChildTableMeta* tscCreateChildMeta(STableMeta* pTableMeta);
 uint32_t tscGetTableMetaMaxSize();
-int32_t tscCreateTableMetaFromCChildMeta(STableMeta* pChild, const char* name);
+int32_t tscCreateTableMetaFromCChildMeta(STableMeta* pChild, const char* name, void* buf);
 STableMeta* tscTableMetaDup(STableMeta* pTableMeta);
 int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAttr, void* addr);
 

src/client/inc/tschemautil.h

@@ -21,8 +21,8 @@ extern "C" {
 #endif
 
 #include "taosmsg.h"
-#include "tstoken.h"
 #include "tsclient.h"
+#include "ttoken.h"
 
 /**
  * get the number of tags of this table

src/client/inc/tsclient.h

@@ -84,6 +84,7 @@ typedef struct STableMeta {
 
 typedef struct STableMetaInfo {
   STableMeta   *pTableMeta;      // table meta, cached in client side and acquired by name
+  uint32_t       tableMetaSize;
   SVgroupsInfo *vgroupList;
   SArray       *pVgroupTables;   // SArray<SVgroupTableInfo>
   
@@ -154,13 +155,12 @@ typedef struct STagCond {
 
 typedef struct SParamInfo {
   int32_t  idx;
-  char     type;
+  uint8_t  type;
   uint8_t  timePrec;
   int16_t  bytes;
   uint32_t offset;
 } SParamInfo;
 
-
 typedef struct SBoundColumn {
   bool    hasVal;  // denote if current column has bound or not
   int32_t offset;  // all column offset value
@@ -376,7 +376,8 @@ typedef struct SSqlObj {
   tsem_t           rspSem;
   SSqlCmd          cmd;
   SSqlRes          res;
-
+  bool             isBind;
+  
   SSubqueryState   subState;
   struct SSqlObj **pSubs;
 

src/client/jni/com_taosdata_jdbc_TSDBJNIConnector.h

@@ -100,7 +100,7 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getResultSetImp
 /*
  * Class:     com_taosdata_jdbc_TSDBJNIConnector
  * Method:    isUpdateQueryImp
- * Signature: (J)J
+ * Signature: (JJ)I
  */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_isUpdateQueryImp
   (JNIEnv *env, jobject jobj, jlong con, jlong tres);
@@ -185,6 +185,44 @@ JNIEXPORT void JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_unsubscribeImp
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_validateCreateTableSqlImp
   (JNIEnv *, jobject, jlong, jbyteArray);
 
+/*
+ * Class:     com_taosdata_jdbc_TSDBJNIConnector
+ * Method:    prepareStmtImp
+ * Signature: ([BJ)I
+ */
+JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_prepareStmtImp
+  (JNIEnv *, jobject, jbyteArray, jlong);
+
+/*
+ * Class:     com_taosdata_jdbc_TSDBJNIConnector
+ * Method:    setBindTableNameImp
+ * Signature: (JLjava/lang/String;J)I
+ */
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setBindTableNameImp
+  (JNIEnv *, jobject, jlong, jstring, jlong);
+
+/*
+ * Class:     com_taosdata_jdbc_TSDBJNIConnector
+ * Method:    bindColDataImp
+ * Signature: (J[B[B[BIIIIJ)J
+ */
+JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_bindColDataImp
+(JNIEnv *, jobject, jlong, jbyteArray, jbyteArray, jbyteArray, jint, jint, jint, jint, jlong);
+
+/*
+ * Class:     com_taosdata_jdbc_TSDBJNIConnector
+ * Method:    executeBatchImp
+ * Signature: (JJ)I
+ */
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_executeBatchImp(JNIEnv *env, jobject jobj, jlong stmt, jlong con);
+
+/*
+ * Class:     com_taosdata_jdbc_TSDBJNIConnector
+ * Method:    executeBatchImp
+ * Signature: (JJ)I
+ */
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_closeStmt(JNIEnv *env, jobject jobj, jlong stmt, jlong con);
+
 #ifdef __cplusplus
 }
 #endif

src/client/src/TSDBJNIConnector.c

@@ -687,4 +687,194 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TDDBJNIConnector_getResultTimePrec
   }
 
   return taos_result_precision(result);
-}
+}
+
+JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_prepareStmtImp(JNIEnv *env, jobject jobj, jbyteArray jsql, jlong con) {
+  TAOS *tscon = (TAOS *)con;
+  if (tscon == NULL) {
+    jniError("jobj:%p, connection already closed", jobj);
+    return JNI_CONNECTION_NULL;
+  }
+
+  if (jsql == NULL) {
+    jniError("jobj:%p, conn:%p, empty sql string", jobj, tscon);
+    return JNI_SQL_NULL;
+  }
+
+  jsize len = (*env)->GetArrayLength(env, jsql);
+
+  char *str = (char *) calloc(1, sizeof(char) * (len + 1));
+  if (str == NULL) {
+    jniError("jobj:%p, conn:%p, alloc memory failed", jobj, tscon);
+    return JNI_OUT_OF_MEMORY;
+  }
+
+  (*env)->GetByteArrayRegion(env, jsql, 0, len, (jbyte *)str);
+  if ((*env)->ExceptionCheck(env)) {
+    // todo handle error
+  }
+
+  TAOS_STMT* pStmt = taos_stmt_init(tscon);
+  int32_t code = taos_stmt_prepare(pStmt, str, len);
+  if (code != TSDB_CODE_SUCCESS) {
+    jniError("jobj:%p, conn:%p, code:%s", jobj, tscon, tstrerror(code));
+    return JNI_TDENGINE_ERROR;
+  }
+
+  free(str);
+  return (jlong) pStmt;
+}
+
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setBindTableNameImp(JNIEnv *env, jobject jobj, jlong stmt, jstring jname, jlong conn) {
+  TAOS *tsconn = (TAOS *)conn;
+  if (tsconn == NULL) {
+    jniError("jobj:%p, connection already closed", jobj);
+    return JNI_CONNECTION_NULL;
+  }
+
+  TAOS_STMT* pStmt = (TAOS_STMT*) stmt;
+  if (pStmt == NULL) {
+    jniError("jobj:%p, conn:%p, invalid stmt handle", jobj, tsconn);
+    return JNI_SQL_NULL;
+  }
+
+  const char *name = (*env)->GetStringUTFChars(env, jname, NULL);
+
+  int32_t code = taos_stmt_set_tbname((void*)stmt, name);
+  if (code != TSDB_CODE_SUCCESS) {
+    (*env)->ReleaseStringUTFChars(env, jname, name);
+
+    jniError("jobj:%p, conn:%p, code:%s", jobj, tsconn, tstrerror(code));
+    return JNI_TDENGINE_ERROR;
+  }
+
+  jniDebug("jobj:%p, conn:%p, set stmt bind table name:%s", jobj, tsconn, name);
+
+  (*env)->ReleaseStringUTFChars(env, jname, name);
+  return JNI_SUCCESS;
+}
+
+JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_bindColDataImp(JNIEnv *env, jobject jobj, jlong stmt,
+    jbyteArray colDataList, jbyteArray lengthList, jbyteArray nullList, jint dataType, jint dataBytes, jint numOfRows, jint colIndex, jlong con) {
+  TAOS *tscon = (TAOS *)con;
+  if (tscon == NULL) {
+    jniError("jobj:%p, connection already closed", jobj);
+    return JNI_CONNECTION_NULL;
+  }
+
+  TAOS_STMT* pStmt = (TAOS_STMT*) stmt;
+  if (pStmt == NULL) {
+    jniError("jobj:%p, conn:%p, invalid stmt", jobj, tscon);
+    return JNI_SQL_NULL;
+  }
+
+  // todo refactor
+  jsize len = (*env)->GetArrayLength(env, colDataList);
+  char *colBuf = (char *)calloc(1, len);
+  (*env)->GetByteArrayRegion(env, colDataList, 0, len, (jbyte *)colBuf);
+  if ((*env)->ExceptionCheck(env)) {
+    // todo handle error
+  }
+
+  len = (*env)->GetArrayLength(env, lengthList);
+  char *lengthArray = (char*) calloc(1, len);
+  (*env)->GetByteArrayRegion(env, lengthList, 0, len, (jbyte*) lengthArray);
+  if ((*env)->ExceptionCheck(env)) {
+  }
+
+  len = (*env)->GetArrayLength(env, nullList);
+  char *nullArray = (char*) calloc(1, len);
+  (*env)->GetByteArrayRegion(env, nullList, 0, len, (jbyte*) nullArray);
+  if ((*env)->ExceptionCheck(env)) {
+  }
+
+  // bind multi-rows with only one invoke.
+  TAOS_MULTI_BIND* b = calloc(1, sizeof(TAOS_MULTI_BIND));
+
+  b->num           = numOfRows;
+  b->buffer_type   = dataType;  // todo check data type
+  b->buffer_length = IS_VAR_DATA_TYPE(dataType)? dataBytes:tDataTypes[dataType].bytes;
+  b->is_null       = nullArray;
+  b->buffer        = colBuf;
+  b->length        = (int32_t*)lengthArray;
+
+  // set the length and is_null array
+  switch(dataType) {
+    case TSDB_DATA_TYPE_INT:
+    case TSDB_DATA_TYPE_TINYINT:
+    case TSDB_DATA_TYPE_SMALLINT:
+    case TSDB_DATA_TYPE_TIMESTAMP:
+    case TSDB_DATA_TYPE_BIGINT: {
+      int32_t bytes = tDataTypes[dataType].bytes;
+      for(int32_t i = 0; i < numOfRows; ++i) {
+        b->length[i]  = bytes;
+      }
+      break;
+    }
+
+    case TSDB_DATA_TYPE_NCHAR:
+    case TSDB_DATA_TYPE_BINARY: {
+      // do nothing
+    }
+  }
+
+  int32_t code = taos_stmt_bind_single_param_batch(pStmt, b, colIndex);
+  tfree(b->length);
+  tfree(b->buffer);
+  tfree(b->is_null);
+  tfree(b);
+
+  if (code != TSDB_CODE_SUCCESS) {
+    jniError("jobj:%p, conn:%p, code:%s", jobj, tscon, tstrerror(code));
+    return JNI_TDENGINE_ERROR;
+  }
+
+  return JNI_SUCCESS;
+}
+
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_executeBatchImp(JNIEnv *env, jobject jobj, jlong stmt, jlong con) {
+  TAOS *tscon = (TAOS *)con;
+  if (tscon == NULL) {
+    jniError("jobj:%p, connection already closed", jobj);
+    return JNI_CONNECTION_NULL;
+  }
+
+  TAOS_STMT *pStmt = (TAOS_STMT*) stmt;
+  if (pStmt == NULL) {
+    jniError("jobj:%p, conn:%p, invalid stmt", jobj, tscon);
+    return JNI_SQL_NULL;
+  }
+
+  taos_stmt_add_batch(pStmt);
+  int32_t code = taos_stmt_execute(pStmt);
+  if (code != TSDB_CODE_SUCCESS) {
+    jniError("jobj:%p, conn:%p, code:%s", jobj, tscon, tstrerror(code));
+    return JNI_TDENGINE_ERROR;
+  }
+
+  jniDebug("jobj:%p, conn:%p, batch execute", jobj, tscon);
+  return JNI_SUCCESS;
+}
+
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_closeStmt(JNIEnv *env, jobject jobj, jlong stmt, jlong con) {
+  TAOS *tscon = (TAOS *)con;
+  if (tscon == NULL) {
+    jniError("jobj:%p, connection already closed", jobj);
+    return JNI_CONNECTION_NULL;
+  }
+
+  TAOS_STMT *pStmt = (TAOS_STMT*) stmt;
+  if (pStmt == NULL) {
+    jniError("jobj:%p, conn:%p, invalid stmt", jobj, tscon);
+    return JNI_SQL_NULL;
+  }
+
+  int32_t code = taos_stmt_close(pStmt);
+  if (code != TSDB_CODE_SUCCESS) {
+    jniError("jobj:%p, conn:%p, code:%s", jobj, tscon, tstrerror(code));
+    return JNI_TDENGINE_ERROR;
+  }
+
+  jniDebug("jobj:%p, conn:%p, stmt closed", jobj, tscon);
+  return JNI_SUCCESS;
+}

src/client/src/tscAsync.c

@@ -49,7 +49,7 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, __async_cb_func_t fp, void* para
 
   pSql->sqlstr = calloc(1, sqlLen + 1);
   if (pSql->sqlstr == NULL) {
-    tscError("%p failed to malloc sql string buffer", pSql);
+    tscError("0x%"PRIx64" failed to malloc sql string buffer", pSql->self);
     pSql->res.code = TSDB_CODE_TSC_OUT_OF_MEMORY;
     tscAsyncResultOnError(pSql);
     return;
@@ -81,7 +81,7 @@ void taos_query_a(TAOS *taos, const char *sqlstr, __async_cb_func_t fp, void *pa
 TAOS_RES * taos_query_ra(TAOS *taos, const char *sqlstr, __async_cb_func_t fp, void *param) {
   STscObj *pObj = (STscObj *)taos;
   if (pObj == NULL || pObj->signature != pObj) {
-    tscError("bug!!! pObj:%p", pObj);
+    tscError("pObj:%p is NULL or freed", pObj);
     terrno = TSDB_CODE_TSC_DISCONNECTED;
     tscQueueAsyncError(fp, param, TSDB_CODE_TSC_DISCONNECTED);
     return NULL;
@@ -288,7 +288,7 @@ static void tscAsyncResultCallback(SSchedMsg *pMsg) {
   }
 
   assert(pSql->res.code != TSDB_CODE_SUCCESS);
-  tscError("%p invoke user specified function due to error occurred, code:%s", pSql, tstrerror(pSql->res.code));
+  tscError("0x%"PRIx64" async result callback, code:%s", pSql->self, tstrerror(pSql->res.code));
 
   SSqlRes *pRes = &pSql->res;
   if (pSql->fp == NULL || pSql->fetchFp == NULL){
@@ -368,7 +368,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
   SSqlObj *sub = (SSqlObj*) res;
   const char* msg = (sub->cmd.command == TSDB_SQL_STABLEVGROUP)? "vgroup-list":"table-meta";
   if (code != TSDB_CODE_SUCCESS) {
-    tscError("%p get %s failed, code:%s", pSql, msg, tstrerror(code));
+    tscError("0x%"PRIx64" get %s failed, code:%s", pSql->self, msg, tstrerror(code));
     goto _error;
   }
 

src/client/src/tscLocal.c

@@ -326,6 +326,7 @@ TAOS_ROW tscFetchRow(void *param) {
        pCmd->command == TSDB_SQL_FETCH ||
        pCmd->command == TSDB_SQL_SHOW ||
        pCmd->command == TSDB_SQL_SHOW_CREATE_TABLE ||
+       pCmd->command == TSDB_SQL_SHOW_CREATE_STABLE ||
        pCmd->command == TSDB_SQL_SHOW_CREATE_DATABASE ||
        pCmd->command == TSDB_SQL_SELECT ||
        pCmd->command == TSDB_SQL_DESCRIBE_TABLE ||
@@ -679,6 +680,9 @@ static int32_t tscProcessShowCreateTable(SSqlObj *pSql) {
   assert(pTableMetaInfo->pTableMeta != NULL);
 
   const char* tableName = tNameGetTableName(&pTableMetaInfo->name);
+  if (pSql->cmd.command == TSDB_SQL_SHOW_CREATE_STABLE && !UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo))  {
+    return TSDB_CODE_TSC_INVALID_VALUE;
+  }
 
   char *result = (char *)calloc(1, TSDB_MAX_BINARY_LEN);
   int32_t code = TSDB_CODE_SUCCESS;
@@ -907,7 +911,7 @@ int tscProcessLocalCmd(SSqlObj *pSql) {
      */
     pRes->qId = 0x1;
     pRes->numOfRows = 0;
-  } else if (pCmd->command == TSDB_SQL_SHOW_CREATE_TABLE) {
+  } else if (pCmd->command == TSDB_SQL_SHOW_CREATE_TABLE || pCmd->command == TSDB_SQL_SHOW_CREATE_STABLE) {
     pRes->code = tscProcessShowCreateTable(pSql); 
   } else if (pCmd->command == TSDB_SQL_SHOW_CREATE_DATABASE) {
     pRes->code = tscProcessShowCreateDatabase(pSql); 
@@ -926,7 +930,7 @@ int tscProcessLocalCmd(SSqlObj *pSql) {
     pRes->code = tscProcessServStatus(pSql);
   } else {
     pRes->code = TSDB_CODE_TSC_INVALID_SQL;
-    tscError("%p not support command:%d", pSql, pCmd->command);
+    tscError("0x%"PRIx64" not support command:%d", pSql->self, pCmd->command);
   }
 
   // keep the code in local variable in order to avoid invalid read in case of async query

src/client/src/tscLocalMerge.c

@@ -113,14 +113,14 @@ void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrde
   
   if (pMemBuffer == NULL) {
     tscLocalReducerEnvDestroy(pMemBuffer, pDesc, finalmodel, pFFModel, numOfBuffer);
-    tscError("%p pMemBuffer is NULL", pMemBuffer);
+    tscError("pMemBuffer:%p is NULL", pMemBuffer);
     pRes->code = TSDB_CODE_TSC_APP_ERROR;
     return;
   }
  
   if (pDesc->pColumnModel == NULL) {
     tscLocalReducerEnvDestroy(pMemBuffer, pDesc, finalmodel, pFFModel, numOfBuffer);
-    tscError("%p no local buffer or intermediate result format model", pSql);
+    tscError("0x%"PRIx64" no local buffer or intermediate result format model", pSql->self);
     pRes->code = TSDB_CODE_TSC_APP_ERROR;
     return;
   }
@@ -144,7 +144,7 @@ void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrde
   }
 
   if (pDesc->pColumnModel->capacity >= pMemBuffer[0]->pageSize) {
-    tscError("%p Invalid value of buffer capacity %d and page size %d ", pSql, pDesc->pColumnModel->capacity,
+    tscError("0x%"PRIx64" Invalid value of buffer capacity %d and page size %d ", pSql->self, pDesc->pColumnModel->capacity,
              pMemBuffer[0]->pageSize);
 
     tscLocalReducerEnvDestroy(pMemBuffer, pDesc, finalmodel, pFFModel, numOfBuffer);
@@ -156,7 +156,7 @@ void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrde
   
   SLocalMerger *pMerger = (SLocalMerger *) calloc(1, size);
   if (pMerger == NULL) {
-    tscError("%p failed to create local merge structure, out of memory", pSql);
+    tscError("0x%"PRIx64" failed to create local merge structure, out of memory", pSql->self);
 
     tscLocalReducerEnvDestroy(pMemBuffer, pDesc, finalmodel, pFFModel, numOfBuffer);
     pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -180,7 +180,7 @@ void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrde
     for (int32_t j = 0; j < numOfFlushoutInFile; ++j) {
       SLocalDataSource *ds = (SLocalDataSource *)malloc(sizeof(SLocalDataSource) + pMemBuffer[0]->pageSize);
       if (ds == NULL) {
-        tscError("%p failed to create merge structure", pSql);
+        tscError("0x%"PRIx64" failed to create merge structure", pSql->self);
         pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
         tfree(pMerger);
         return;
@@ -538,7 +538,7 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr
 
   (*pMemBuffer) = (tExtMemBuffer **)malloc(POINTER_BYTES * pSql->subState.numOfSub);
   if (*pMemBuffer == NULL) {
-    tscError("%p failed to allocate memory", pSql);
+    tscError("0x%"PRIx64" failed to allocate memory", pSql->self);
     pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
     return pRes->code;
   }
@@ -547,7 +547,7 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr
   
   pSchema = (SSchema *)calloc(1, sizeof(SSchema) * size);
   if (pSchema == NULL) {
-    tscError("%p failed to allocate memory", pSql);
+    tscError("0x%"PRIx64" failed to allocate memory", pSql->self);
     pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
     return pRes->code;
   }

src/client/src/tscParseInsert.c

@@ -29,8 +29,7 @@
 #include "taosdef.h"
 
 #include "tscLog.h"
-#include "tscSubquery.h"
-#include "tstoken.h"
+#include "ttoken.h"
 
 #include "tdataformat.h"
 
@@ -68,7 +67,7 @@ int tsParseTime(SStrToken *pToken, int64_t *time, char **next, char *error, int1
   } else if (strncmp(pToken->z, "0", 1) == 0 && pToken->n == 1) {
     // do nothing
   } else if (pToken->type == TK_INTEGER) {
-    useconds = tsosStr2int64(pToken->z);
+    useconds = taosStr2int64(pToken->z);
   } else {
     // strptime("2001-11-12 18:31:01", "%Y-%m-%d %H:%M:%S", &tm);
     if (taosParseTime(pToken->z, time, pToken->n, timePrec, tsDaylight) != TSDB_CODE_SUCCESS) {
@@ -386,7 +385,7 @@ int32_t tsParseOneColumn(SSchema *pSchema, SStrToken *pToken, char *payload, cha
  * The server time/client time should not be mixed up in one sql string
  * Do not employ sort operation is not involved if server time is used.
  */
-static int32_t tsCheckTimestamp(STableDataBlocks *pDataBlocks, const char *start) {
+int32_t tsCheckTimestamp(STableDataBlocks *pDataBlocks, const char *start) {
   // once the data block is disordered, we do NOT keep previous timestamp any more
   if (!pDataBlocks->ordered) {
     return TSDB_CODE_SUCCESS;
@@ -411,6 +410,7 @@ static int32_t tsCheckTimestamp(STableDataBlocks *pDataBlocks, const char *start
 
   if (k <= pDataBlocks->prevTS && (pDataBlocks->tsSource == TSDB_USE_CLI_TS)) {
     pDataBlocks->ordered = false;
+    tscWarn("NOT ordered input timestamp");
   }
 
   pDataBlocks->prevTS = k;
@@ -463,23 +463,24 @@ int tsParseOneRow(char **str, STableDataBlocks *pDataBlocks, SSqlCmd *pCmd, int1
     // Remove quotation marks
     if (TK_STRING == sToken.type) {
       // delete escape character: \\, \', \"
-      char    delim = sToken.z[0];
+      char delim = sToken.z[0];
+
       int32_t cnt = 0;
       int32_t j = 0;
       for (uint32_t k = 1; k < sToken.n - 1; ++k) {
-        if (sToken.z[k] == delim || sToken.z[k] == '\\') {
-          if (sToken.z[k + 1] == delim) {
-            cnt++;
+        if (sToken.z[k] == '\\' || (sToken.z[k] == delim && sToken.z[k + 1] == delim)) {
             tmpTokenBuf[j] = sToken.z[k + 1];
-            j++;
-            k++;
-            continue;
-          }
+
+          cnt++;
+          j++;
+          k++;
+          continue;
         }
 
         tmpTokenBuf[j] = sToken.z[k];
         j++;
       }
+
       tmpTokenBuf[j] = 0;
       sToken.z = tmpTokenBuf;
       sToken.n -= 2 + cnt;
@@ -693,6 +694,8 @@ void tscSortRemoveDataBlockDupRows(STableDataBlocks *dataBuf) {
     pBlocks->numOfRows = i + 1;
     dataBuf->size = sizeof(SSubmitBlk) + dataBuf->rowSize * pBlocks->numOfRows;
   }
+
+  dataBuf->prevTS = INT64_MIN;
 }
 
 static int32_t doParseInsertStatement(SSqlCmd* pCmd, char **str, STableDataBlocks* dataBuf, int32_t *totalNum) {
@@ -705,19 +708,11 @@ static int32_t doParseInsertStatement(SSqlCmd* pCmd, char **str, STableDataBlock
   }
 
   code = TSDB_CODE_TSC_INVALID_SQL;
-  char  *tmpTokenBuf = calloc(1, 16*1024);  // used for deleting Escape character: \\, \', \"
-  if (NULL == tmpTokenBuf) {
-    return TSDB_CODE_TSC_OUT_OF_MEMORY;
-  }
+  char tmpTokenBuf[16*1024] = {0};  // used for deleting Escape character: \\, \', \"
 
   int32_t numOfRows = 0;
   code = tsParseValues(str, dataBuf, maxNumOfRows, pCmd, &numOfRows, tmpTokenBuf);
 
-  free(tmpTokenBuf);
-  if (code != TSDB_CODE_SUCCESS) {
-    return code;
-  }
-
   for (uint32_t i = 0; i < dataBuf->numOfParams; ++i) {
     SParamInfo *param = dataBuf->params + i;
     if (param->idx == -1) {
@@ -934,6 +929,42 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
       return tscSQLSyntaxErrMsg(pCmd->payload, ") expected", sToken.z);
     }
 
+    /* parse columns after super table tags values.
+     * insert into table_name using super_table(tag_name1, tag_name2) tags(tag_val1, tag_val2)
+     * (normal_col1, normal_col2) values(normal_col1_val, normal_col2_val);
+     * */
+    index = 0;
+    sToken = tStrGetToken(sql, &index, false);
+    sql += index;
+    int numOfColsAfterTags = 0;
+    if (sToken.type == TK_LP) {
+      if (*boundColumn != NULL) {
+        return tscSQLSyntaxErrMsg(pCmd->payload, "bind columns again", sToken.z);
+      } else {
+        *boundColumn = &sToken.z[0];
+      }
+
+      while (1) {
+        index = 0;
+        sToken = tStrGetToken(sql, &index, false);
+
+        if (sToken.type == TK_RP) {
+          break;
+        }
+
+        sql += index;
+        ++numOfColsAfterTags;
+      }
+
+      if (numOfColsAfterTags == 0 && (*boundColumn) != NULL) {
+        return TSDB_CODE_TSC_INVALID_SQL;
+      }
+
+      sToken = tStrGetToken(sql, &index, false);
+    }
+
+    sql = sToken.z;
+
     if (tscValidateName(&tableToken) != TSDB_CODE_SUCCESS) {
       return tscInvalidSQLErrMsg(pCmd->payload, "invalid table name", *sqlstr);
     }
@@ -975,7 +1006,7 @@ int validateTableName(char *tblName, int len, SStrToken* psTblToken) {
 
   psTblToken->n    = len;
   psTblToken->type = TK_ID;
-  tSQLGetToken(psTblToken->z, &psTblToken->type);
+  tGetToken(psTblToken->z, &psTblToken->type);
 
   return tscValidateName(psTblToken);
 }
@@ -1147,7 +1178,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
         return code;
       }
 
-      tscError("%p async insert parse error, code:%s", pSql, tstrerror(code));
+      tscError("0x%"PRIx64" async insert parse error, code:%s", pSql->self, tstrerror(code));
       pCmd->curSql = NULL;
       goto _clean;
     }
@@ -1262,7 +1293,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
     goto _clean;
   }
 
-  if (taosHashGetSize(pCmd->pTableBlockHashList) > 0) { // merge according to vgId
+  if ((pCmd->insertType != TSDB_QUERY_TYPE_STMT_INSERT) && taosHashGetSize(pCmd->pTableBlockHashList) > 0) { // merge according to vgId
     if ((code = tscMergeTableDataBlocks(pSql, true)) != TSDB_CODE_SUCCESS) {
       goto _clean;
     }
@@ -1415,7 +1446,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int32_t numOfRow
     assert(pSql->res.numOfRows == 0);
     int32_t ret = fseek(fp, 0, SEEK_SET);
     if (ret < 0) {
-      tscError("%p failed to seek SEEK_SET since:%s", pSql, tstrerror(errno));
+      tscError("0x%"PRIx64" failed to seek SEEK_SET since:%s", pSql->self, tstrerror(errno));
       code = TAOS_SYSTEM_ERROR(errno);
       goto _error;
     }
@@ -1536,7 +1567,7 @@ void tscImportDataFromFile(SSqlObj *pSql) {
   FILE *fp = fopen(pCmd->payload, "rb");
   if (fp == NULL) {
     pSql->res.code = TAOS_SYSTEM_ERROR(errno);
-    tscError("%p failed to open file %s to load data from file, code:%s", pSql, pCmd->payload, tstrerror(pSql->res.code));
+    tscError("0x%"PRIx64" failed to open file %s to load data from file, code:%s", pSql->self, pCmd->payload, tstrerror(pSql->res.code));
 
     tfree(pSupporter);
     taos_free_result(pNew);

src/client/src/tscPrepare.c

@@ -24,6 +24,7 @@
 #include "tscSubquery.h"
 
 int tsParseInsertSql(SSqlObj *pSql);
+int32_t tsCheckTimestamp(STableDataBlocks *pDataBlocks, const char *start);
 
 ////////////////////////////////////////////////////////////////////////////////
 // functions for normal statement preparation
@@ -43,10 +44,32 @@ typedef struct SNormalStmt {
   tVariant*        params;
 } SNormalStmt;
 
+typedef struct SMultiTbStmt {
+  bool      nameSet;
+  uint64_t  currentUid;
+  uint32_t  tbNum;
+  SStrToken tbname;
+  SHashObj *pTableHash;  
+  SHashObj *pTableBlockHashList;     // data block for each table
+} SMultiTbStmt;
+
+typedef enum {
+  STMT_INIT = 1,
+  STMT_PREPARE,
+  STMT_SETTBNAME,
+  STMT_BIND,
+  STMT_BIND_COL,
+  STMT_ADD_BATCH,
+  STMT_EXECUTE
+} STMT_ST;
+
 typedef struct STscStmt {
   bool isInsert;
+  bool multiTbInsert;
+  int16_t  last;
   STscObj* taos;
   SSqlObj* pSql;
+  SMultiTbStmt mtb;
   SNormalStmt normal;
 } STscStmt;
 
@@ -135,7 +158,7 @@ static int normalStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) {
         break;
 
       default:
-        tscDebug("param %d: type mismatch or invalid", i);
+        tscDebug("0x%"PRIx64" bind column%d: type mismatch or invalid", stmt->pSql->self, i);
         return TSDB_CODE_TSC_INVALID_VALUE;
     }
   }
@@ -151,7 +174,7 @@ static int normalStmtPrepare(STscStmt* stmt) {
 
   while (sql[i] != 0) {
     SStrToken token = {0};
-    token.n = tSQLGetToken(sql + i, &token.type);
+    token.n = tGetToken(sql + i, &token.type);
 
     if (token.type == TK_QUESTION) {
       sql[i] = 0;
@@ -255,12 +278,13 @@ static char* normalStmtBuildSql(STscStmt* stmt) {
 
 ////////////////////////////////////////////////////////////////////////////////
 // functions for insertion statement preparation
-static int doBindParam(char* data, SParamInfo* param, TAOS_BIND* bind) {
+static int doBindParam(STableDataBlocks* pBlock, char* data, SParamInfo* param, TAOS_BIND* bind, int32_t colNum) {
   if (bind->is_null != NULL && *(bind->is_null)) {
     setNull(data + param->offset, param->type, param->bytes);
     return TSDB_CODE_SUCCESS;
   }
 
+#if 0
   if (0) {
     // allow user bind param data with different type
     union {
@@ -641,6 +665,7 @@ static int doBindParam(char* data, SParamInfo* param, TAOS_BIND* bind) {
       }
     }
   }
+#endif
 
   if (bind->buffer_type != param->type) {
     return TSDB_CODE_TSC_INVALID_VALUE;
@@ -690,29 +715,106 @@ static int doBindParam(char* data, SParamInfo* param, TAOS_BIND* bind) {
   }
 
   memcpy(data + param->offset, bind->buffer, size);
+  if (param->offset == 0) {
+    if (tsCheckTimestamp(pBlock, data + param->offset) != TSDB_CODE_SUCCESS) {
+      tscError("invalid timestamp");
+      return TSDB_CODE_TSC_INVALID_VALUE;
+    }
+  }
+  
+  return TSDB_CODE_SUCCESS;
+}
+
+
+static int doBindBatchParam(STableDataBlocks* pBlock, SParamInfo* param, TAOS_MULTI_BIND* bind, int32_t rowNum) {
+  if (bind->buffer_type != param->type || !isValidDataType(param->type)) {
+    return TSDB_CODE_TSC_INVALID_VALUE;
+  }
+
+  if (IS_VAR_DATA_TYPE(param->type) && bind->length == NULL) {
+    tscError("BINARY/NCHAR no length");
+    return TSDB_CODE_TSC_INVALID_VALUE;
+  }
+
+  for (int i = 0; i < bind->num; ++i) {
+    char* data = pBlock->pData + sizeof(SSubmitBlk) + pBlock->rowSize * (rowNum + i);
+
+    if (bind->is_null != NULL && bind->is_null[i]) {
+      setNull(data + param->offset, param->type, param->bytes);
+      continue;
+    }
+
+    if (!IS_VAR_DATA_TYPE(param->type)) {
+      memcpy(data + param->offset, (char *)bind->buffer + bind->buffer_length * i, tDataTypes[param->type].bytes);
+      
+      if (param->offset == 0) {
+        if (tsCheckTimestamp(pBlock, data + param->offset) != TSDB_CODE_SUCCESS) {
+          tscError("invalid timestamp");
+          return TSDB_CODE_TSC_INVALID_VALUE;
+        }
+      }
+    } else if (param->type == TSDB_DATA_TYPE_BINARY) {
+      if (bind->length[i] > (uintptr_t)param->bytes) {
+        tscError("binary length too long, ignore it, max:%d, actual:%d", param->bytes, (int32_t)bind->length[i]);
+        return TSDB_CODE_TSC_INVALID_VALUE;
+      }
+      int16_t bsize = (short)bind->length[i];
+      STR_WITH_SIZE_TO_VARSTR(data + param->offset, (char *)bind->buffer + bind->buffer_length * i, bsize);
+    } else if (param->type == TSDB_DATA_TYPE_NCHAR) {
+      if (bind->length[i] > (uintptr_t)param->bytes) {
+        tscError("nchar string length too long, ignore it, max:%d, actual:%d", param->bytes, (int32_t)bind->length[i]);
+        return TSDB_CODE_TSC_INVALID_VALUE;
+      }
+
+      int32_t output = 0;
+      if (!taosMbsToUcs4((char *)bind->buffer + bind->buffer_length * i, bind->length[i], varDataVal(data + param->offset), param->bytes - VARSTR_HEADER_SIZE, &output)) {
+        tscError("convert nchar string to UCS4_LE failed:%s", (char*)((char *)bind->buffer + bind->buffer_length * i));
+        return TSDB_CODE_TSC_INVALID_VALUE;
+      }
+
+      varDataSetLen(data + param->offset, output);
+    }
+  }
+  
   return TSDB_CODE_SUCCESS;
 }
 
 static int insertStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) {
   SSqlCmd* pCmd = &stmt->pSql->cmd;
-
-  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0, 0);
-
-  STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
-  if (pCmd->pTableBlockHashList == NULL) {
-    pCmd->pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
-  }
-
+  STscStmt* pStmt = (STscStmt*)stmt;
+  
   STableDataBlocks* pBlock = NULL;
+  
+  if (pStmt->multiTbInsert) {
+    if (pCmd->pTableBlockHashList == NULL) {
+      tscError("0x%"PRIx64" Table block hash list is empty", pStmt->pSql->self);
+      return TSDB_CODE_TSC_APP_ERROR;
+    }
+    
+    STableDataBlocks** t1 = (STableDataBlocks**)taosHashGet(pCmd->pTableBlockHashList, (const char*)&pStmt->mtb.currentUid, sizeof(pStmt->mtb.currentUid));
+    if (t1 == NULL) {
+      tscError("0x%"PRIx64" no table data block in hash list, uid:%" PRId64 , pStmt->pSql->self, pStmt->mtb.currentUid);
+      return TSDB_CODE_TSC_APP_ERROR;
+    }
 
-  int32_t ret =
-      tscGetDataBlockFromList(pCmd->pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
-                              pTableMeta->tableInfo.rowSize, &pTableMetaInfo->name, pTableMeta, &pBlock, NULL);
-  if (ret != 0) {
-    // todo handle error
+    pBlock = *t1;
+  } else {
+    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0, 0);
+
+    STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
+    if (pCmd->pTableBlockHashList == NULL) {
+      pCmd->pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
+    }
+
+    int32_t ret =
+        tscGetDataBlockFromList(pCmd->pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
+                                pTableMeta->tableInfo.rowSize, &pTableMetaInfo->name, pTableMeta, &pBlock, NULL);
+    if (ret != 0) {
+      return ret;
+    }
   }
 
-  uint32_t totalDataSize = sizeof(SSubmitBlk) + pCmd->batchSize * pBlock->rowSize;
+  uint32_t totalDataSize = sizeof(SSubmitBlk) + (pCmd->batchSize + 1) * pBlock->rowSize;
   if (totalDataSize > pBlock->nAllocSize) {
     const double factor = 1.5;
 
@@ -729,9 +831,9 @@ static int insertStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) {
   for (uint32_t j = 0; j < pBlock->numOfParams; ++j) {
     SParamInfo* param = &pBlock->params[j];
 
-    int code = doBindParam(data, param, &bind[param->idx]);
+    int code = doBindParam(pBlock, data, param, &bind[param->idx], 1);
     if (code != TSDB_CODE_SUCCESS) {
-      tscDebug("param %d: type mismatch or invalid", param->idx);
+      tscDebug("0x%"PRIx64" bind column %d: type mismatch or invalid", pStmt->pSql->self, param->idx);
       return code;
     }
   }
@@ -739,9 +841,135 @@ static int insertStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) {
   return TSDB_CODE_SUCCESS;
 }
 
+
+static int insertStmtBindParamBatch(STscStmt* stmt, TAOS_MULTI_BIND* bind, int colIdx) {
+  SSqlCmd* pCmd = &stmt->pSql->cmd;
+  STscStmt* pStmt = (STscStmt*)stmt;
+  int rowNum = bind->num;
+  
+  STableDataBlocks* pBlock = NULL;
+  
+  if (pStmt->multiTbInsert) {
+    if (pCmd->pTableBlockHashList == NULL) {
+      tscError("0x%"PRIx64" Table block hash list is empty", pStmt->pSql->self);
+      return TSDB_CODE_TSC_APP_ERROR;
+    }
+
+    STableDataBlocks** t1 = (STableDataBlocks**)taosHashGet(pCmd->pTableBlockHashList, (const char*)&pStmt->mtb.currentUid, sizeof(pStmt->mtb.currentUid));
+    if (t1 == NULL) {
+      tscError("0x%"PRIx64" no table data block in hash list, uid:%" PRId64 , pStmt->pSql->self, pStmt->mtb.currentUid);
+      return TSDB_CODE_TSC_APP_ERROR;
+    }
+
+    pBlock = *t1;
+  } else {
+    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0, 0);
+
+    STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
+    if (pCmd->pTableBlockHashList == NULL) {
+      pCmd->pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
+    }
+
+    int32_t ret =
+        tscGetDataBlockFromList(pCmd->pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
+                                pTableMeta->tableInfo.rowSize, &pTableMetaInfo->name, pTableMeta, &pBlock, NULL);
+    if (ret != 0) {
+      return ret;
+    }
+  }
+
+  assert(colIdx == -1 || (colIdx >= 0 && colIdx < pBlock->numOfParams));
+
+  uint32_t totalDataSize = sizeof(SSubmitBlk) + (pCmd->batchSize + rowNum) * pBlock->rowSize;
+  if (totalDataSize > pBlock->nAllocSize) {
+    const double factor = 1.5;
+
+    void* tmp = realloc(pBlock->pData, (uint32_t)(totalDataSize * factor));
+    if (tmp == NULL) {
+      return TSDB_CODE_TSC_OUT_OF_MEMORY;
+    }
+
+    pBlock->pData = (char*)tmp;
+    pBlock->nAllocSize = (uint32_t)(totalDataSize * factor);
+  }
+
+  if (colIdx == -1) {
+    for (uint32_t j = 0; j < pBlock->numOfParams; ++j) {
+      SParamInfo* param = &pBlock->params[j];
+      if (bind[param->idx].num != rowNum) {
+        tscError("0x%"PRIx64" param %d: num[%d:%d] not match", pStmt->pSql->self, param->idx, rowNum, bind[param->idx].num);
+        return TSDB_CODE_TSC_INVALID_VALUE;
+      }
+      
+      int code = doBindBatchParam(pBlock, param, &bind[param->idx], pCmd->batchSize);
+      if (code != TSDB_CODE_SUCCESS) {
+        tscError("0x%"PRIx64" bind column %d: type mismatch or invalid", pStmt->pSql->self, param->idx);
+        return code;
+      }
+    }
+
+    pCmd->batchSize += rowNum - 1;
+  } else {
+    SParamInfo* param = &pBlock->params[colIdx];
+   
+    int code = doBindBatchParam(pBlock, param, bind, pCmd->batchSize);
+    if (code != TSDB_CODE_SUCCESS) {
+      tscError("0x%"PRIx64" bind column %d: type mismatch or invalid", pStmt->pSql->self, param->idx);
+      return code;
+    }
+
+    if (colIdx == (pBlock->numOfParams - 1)) {
+      pCmd->batchSize += rowNum - 1;
+    }
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
+static int insertStmtUpdateBatch(STscStmt* stmt) {
+  SSqlObj* pSql = stmt->pSql;
+  SSqlCmd* pCmd = &pSql->cmd;
+  STableDataBlocks* pBlock = NULL;
+
+  if (pCmd->batchSize > INT16_MAX) {
+    tscError("too many record:%d", pCmd->batchSize);
+    return TSDB_CODE_TSC_APP_ERROR;
+  }
+  
+  assert(pCmd->numOfClause == 1);
+  if (taosHashGetSize(pCmd->pTableBlockHashList) == 0) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  STableDataBlocks** t1 = (STableDataBlocks**)taosHashGet(pCmd->pTableBlockHashList, (const char*)&stmt->mtb.currentUid, sizeof(stmt->mtb.currentUid));
+  if (t1 == NULL) {
+    tscError("0x%"PRIx64" no table data block in hash list, uid:%" PRId64 , pSql->self, stmt->mtb.currentUid);
+    return TSDB_CODE_TSC_APP_ERROR;
+  }
+
+  pBlock = *t1;
+
+  STableMeta* pTableMeta = pBlock->pTableMeta;
+
+  pBlock->size = sizeof(SSubmitBlk) + pCmd->batchSize * pBlock->rowSize;
+  SSubmitBlk* pBlk = (SSubmitBlk*) pBlock->pData;
+  pBlk->numOfRows = pCmd->batchSize;
+  pBlk->dataLen = 0;
+  pBlk->uid = pTableMeta->id.uid;
+  pBlk->tid = pTableMeta->id.tid;
+
+  return TSDB_CODE_SUCCESS;
+}
+
 static int insertStmtAddBatch(STscStmt* stmt) {
   SSqlCmd* pCmd = &stmt->pSql->cmd;
   ++pCmd->batchSize;
+  
+  if (stmt->multiTbInsert) {
+    return insertStmtUpdateBatch(stmt);
+  }
+  
   return TSDB_CODE_SUCCESS;
 }
 
@@ -835,6 +1063,83 @@ static int insertStmtExecute(STscStmt* stmt) {
   return pSql->res.code;
 }
 
+static void insertBatchClean(STscStmt* pStmt) {
+  SSqlCmd *pCmd = &pStmt->pSql->cmd;
+  SSqlObj *pSql = pStmt->pSql;
+  int32_t size = taosHashGetSize(pCmd->pTableBlockHashList);
+  
+  // data block reset
+  pCmd->batchSize = 0;
+  
+  for(int32_t i = 0; i < size; ++i) {
+    if (pCmd->pTableNameList && pCmd->pTableNameList[i]) {
+      tfree(pCmd->pTableNameList[i]);
+    }
+  }
+
+  tfree(pCmd->pTableNameList);
+
+/*
+  STableDataBlocks** p = taosHashIterate(pCmd->pTableBlockHashList, NULL);
+
+  STableDataBlocks* pOneTableBlock = *p;
+
+  while (1) {  
+    SSubmitBlk* pBlocks = (SSubmitBlk*) pOneTableBlock->pData;
+    
+    pOneTableBlock->size = sizeof(SSubmitBlk);
+
+    pBlocks->numOfRows = 0;
+  
+    p = taosHashIterate(pCmd->pTableBlockHashList, p);
+    if (p == NULL) {
+      break;
+    }
+
+    pOneTableBlock = *p;
+  }
+*/
+
+  pCmd->pDataBlocks = tscDestroyBlockArrayList(pCmd->pDataBlocks);
+  pCmd->numOfTables = 0;
+
+  taosHashEmpty(pCmd->pTableBlockHashList);
+  tscFreeSqlResult(pSql);
+  tscFreeSubobj(pSql);
+  tfree(pSql->pSubs);
+  pSql->subState.numOfSub = 0;  
+}
+
+static int insertBatchStmtExecute(STscStmt* pStmt) {
+  int32_t code = 0;
+  
+  if(pStmt->mtb.nameSet == false) {
+    tscError("0x%"PRIx64" no table name set", pStmt->pSql->self);
+    return TSDB_CODE_TSC_APP_ERROR;
+  }
+  
+  pStmt->pSql->retry = pStmt->pSql->maxRetry + 1;  //no retry
+
+  if (taosHashGetSize(pStmt->pSql->cmd.pTableBlockHashList) > 0) { // merge according to vgId
+    if ((code = tscMergeTableDataBlocks(pStmt->pSql, false)) != TSDB_CODE_SUCCESS) {
+      return code;
+    }
+  }
+
+  code = tscHandleMultivnodeInsert(pStmt->pSql);
+
+  if (code != TSDB_CODE_SUCCESS) {
+    return code;
+  }
+  
+  // wait for the callback function to post the semaphore
+  tsem_wait(&pStmt->pSql->rspSem);
+
+  insertBatchClean(pStmt);
+  
+  return pStmt->pSql->res.code;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // interface functions
 
@@ -866,7 +1171,9 @@ TAOS_STMT* taos_stmt_init(TAOS* taos) {
   pSql->signature = pSql;
   pSql->pTscObj   = pObj;
   pSql->maxRetry  = TSDB_MAX_REPLICA;
+  pSql->isBind    = true;
   pStmt->pSql     = pSql;
+  pStmt->last     = STMT_INIT;
 
   return pStmt;
 }
@@ -879,6 +1186,13 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
     return TSDB_CODE_TSC_DISCONNECTED;
   }
 
+  if (pStmt->last != STMT_INIT) {
+    tscError("prepare status error, last:%d", pStmt->last);
+    return TSDB_CODE_TSC_APP_ERROR;
+  }
+
+  pStmt->last = STMT_PREPARE;
+  
   SSqlObj* pSql = pStmt->pSql;
   size_t   sqlLen = strlen(sql);
 
@@ -917,6 +1231,36 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
 
     registerSqlObj(pSql);
 
+    int32_t ret = TSDB_CODE_SUCCESS;
+
+    if ((ret = tsInsertInitialCheck(pSql)) != TSDB_CODE_SUCCESS) {
+      return ret;
+    }
+    
+    int32_t index = 0;
+    SStrToken sToken = tStrGetToken(pCmd->curSql, &index, false);
+
+    if (sToken.n == 0) {
+      return TSDB_CODE_TSC_INVALID_SQL;
+    }
+
+    if (sToken.n == 1 && sToken.type == TK_QUESTION) {
+      pStmt->multiTbInsert = true;
+      pStmt->mtb.tbname = sToken;
+      pStmt->mtb.nameSet = false;
+      if (pStmt->mtb.pTableHash == NULL) {
+        pStmt->mtb.pTableHash = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, false);
+      }
+      if (pStmt->mtb.pTableBlockHashList == NULL) {
+        pStmt->mtb.pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
+      }
+
+      return TSDB_CODE_SUCCESS;      
+    }
+
+    pStmt->multiTbInsert = false;
+    memset(&pStmt->mtb, 0, sizeof(pStmt->mtb));
+
     int32_t code = tsParseSql(pSql, true);
     if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
       // wait for the callback function to post the semaphore
@@ -931,6 +1275,105 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
   return normalStmtPrepare(pStmt);
 }
 
+
+int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
+  STscStmt* pStmt = (STscStmt*)stmt;
+  SSqlObj* pSql = pStmt->pSql;
+  SSqlCmd* pCmd = &pSql->cmd;
+
+  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return TSDB_CODE_TSC_DISCONNECTED;
+  }
+
+  if (name == NULL) {
+    terrno = TSDB_CODE_TSC_APP_ERROR;
+    tscError("0x%"PRIx64" name is NULL", pSql->self);
+    return TSDB_CODE_TSC_APP_ERROR;
+  }
+
+  if (pStmt->multiTbInsert == false || !tscIsInsertData(pSql->sqlstr)) {
+    terrno = TSDB_CODE_TSC_APP_ERROR;
+    tscError("0x%"PRIx64" not multi table insert", pSql->self);
+    return TSDB_CODE_TSC_APP_ERROR;
+  }
+
+  if (pStmt->last == STMT_INIT || pStmt->last == STMT_BIND || pStmt->last == STMT_BIND_COL) {
+    tscError("0x%"PRIx64" settbname status error, last:%d", pSql->self, pStmt->last);
+    return TSDB_CODE_TSC_APP_ERROR;
+  }
+
+  pStmt->last = STMT_SETTBNAME;
+
+  uint64_t* uid = (uint64_t*)taosHashGet(pStmt->mtb.pTableHash, name, strlen(name));
+  if (uid != NULL) {
+    pStmt->mtb.currentUid = *uid;
+
+    STableDataBlocks** t1 = (STableDataBlocks**)taosHashGet(pStmt->mtb.pTableBlockHashList, (const char*)&pStmt->mtb.currentUid, sizeof(pStmt->mtb.currentUid));
+    if (t1 == NULL) {
+      tscError("0x%"PRIx64" no table data block in hash list, uid:%" PRId64 , pSql->self, pStmt->mtb.currentUid);
+      return TSDB_CODE_TSC_APP_ERROR;
+    }
+
+    SSubmitBlk* pBlk = (SSubmitBlk*) (*t1)->pData;    
+    pCmd->batchSize = pBlk->numOfRows;
+
+    taosHashPut(pCmd->pTableBlockHashList, (void *)&pStmt->mtb.currentUid, sizeof(pStmt->mtb.currentUid), (void*)t1, POINTER_BYTES);
+    
+    tscDebug("0x%"PRIx64" table:%s is already prepared, uid:%" PRIu64, pSql->self, name, pStmt->mtb.currentUid);
+    return TSDB_CODE_SUCCESS;
+  }
+  
+  pStmt->mtb.tbname = tscReplaceStrToken(&pSql->sqlstr, &pStmt->mtb.tbname, name);
+  pStmt->mtb.nameSet = true;
+
+  tscDebug("0x%"PRIx64" SQL: %s", pSql->self, pSql->sqlstr);
+
+  pSql->cmd.parseFinished = 0;
+  pSql->cmd.numOfParams = 0;
+  pSql->cmd.batchSize   = 0;
+
+  if (taosHashGetSize(pCmd->pTableBlockHashList) > 0) {
+    SHashObj* hashList = pCmd->pTableBlockHashList;
+    pCmd->pTableBlockHashList = NULL;
+    tscResetSqlCmd(pCmd, true);
+    pCmd->pTableBlockHashList = hashList;
+  }
+  
+  int32_t code = tsParseSql(pStmt->pSql, true);
+  if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+    // wait for the callback function to post the semaphore
+    tsem_wait(&pStmt->pSql->rspSem);
+    
+    code = pStmt->pSql->res.code;
+  }
+
+  if (code == TSDB_CODE_SUCCESS) {
+    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0, 0);
+    STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
+    STableDataBlocks* pBlock = NULL;
+    code = tscGetDataBlockFromList(pCmd->pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
+                              pTableMeta->tableInfo.rowSize, &pTableMetaInfo->name, pTableMeta, &pBlock, NULL);
+    if (code != TSDB_CODE_SUCCESS) {
+      return code;
+    }
+
+    SSubmitBlk* blk = (SSubmitBlk*)pBlock->pData;
+    blk->numOfRows = 0;
+
+    pStmt->mtb.currentUid = pTableMeta->id.uid;
+    pStmt->mtb.tbNum++;
+
+    taosHashPut(pStmt->mtb.pTableBlockHashList, (void *)&pStmt->mtb.currentUid, sizeof(pStmt->mtb.currentUid), (void*)&pBlock, POINTER_BYTES);
+    
+    taosHashPut(pStmt->mtb.pTableHash, name, strlen(name), (char*) &pTableMeta->id.uid, sizeof(pTableMeta->id.uid));
+
+    tscDebug("0x%"PRIx64" table:%s is prepared, uid:%" PRIx64, pSql->self, name, pStmt->mtb.currentUid);
+  }
+  
+  return code;
+}
+
 int taos_stmt_close(TAOS_STMT* stmt) {
   STscStmt* pStmt = (STscStmt*)stmt;
   if (!pStmt->isInsert) {
@@ -943,6 +1386,13 @@ int taos_stmt_close(TAOS_STMT* stmt) {
     }
     free(normal->parts);
     free(normal->sql);
+  } else {
+    if (pStmt->multiTbInsert) {
+      taosHashCleanup(pStmt->mtb.pTableHash);
+      pStmt->mtb.pTableBlockHashList = tscDestroyBlockHashTable(pStmt->mtb.pTableBlockHashList, true);
+      taosHashCleanup(pStmt->pSql->cmd.pTableBlockHashList);
+      pStmt->pSql->cmd.pTableBlockHashList = NULL;
+    }
   }
 
   taos_free_result(pStmt->pSql);
@@ -952,18 +1402,122 @@ int taos_stmt_close(TAOS_STMT* stmt) {
 
 int taos_stmt_bind_param(TAOS_STMT* stmt, TAOS_BIND* bind) {
   STscStmt* pStmt = (STscStmt*)stmt;
+  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return TSDB_CODE_TSC_DISCONNECTED;
+  }
+  
   if (pStmt->isInsert) {
+    if (pStmt->multiTbInsert) {
+      if (pStmt->last != STMT_SETTBNAME && pStmt->last != STMT_ADD_BATCH) {
+        tscError("0x%"PRIx64" bind param status error, last:%d", pStmt->pSql->self, pStmt->last);
+        return TSDB_CODE_TSC_APP_ERROR;
+      }
+    } else {
+      if (pStmt->last != STMT_PREPARE && pStmt->last != STMT_ADD_BATCH && pStmt->last != STMT_EXECUTE) {
+        tscError("0x%"PRIx64" bind param status error, last:%d", pStmt->pSql->self, pStmt->last);
+        return TSDB_CODE_TSC_APP_ERROR;
+      }
+    }
+
+    pStmt->last = STMT_BIND;
+    
     return insertStmtBindParam(pStmt, bind);
   } else {
     return normalStmtBindParam(pStmt, bind);
   }
 }
 
+
+int taos_stmt_bind_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind) {
+  STscStmt* pStmt = (STscStmt*)stmt;
+
+  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return TSDB_CODE_TSC_DISCONNECTED;
+  }
+
+  if (bind == NULL || bind->num <= 0 || bind->num > INT16_MAX) {
+    tscError("0x%"PRIx64" invalid parameter", pStmt->pSql->self);
+    return TSDB_CODE_TSC_APP_ERROR;
+  }
+    
+  if (!pStmt->isInsert) {
+    tscError("0x%"PRIx64" not or invalid batch insert", pStmt->pSql->self);
+    return TSDB_CODE_TSC_APP_ERROR;
+  }
+
+  if (pStmt->multiTbInsert) {
+    if (pStmt->last != STMT_SETTBNAME && pStmt->last != STMT_ADD_BATCH) {
+      tscError("0x%"PRIx64" bind param status error, last:%d", pStmt->pSql->self, pStmt->last);
+      return TSDB_CODE_TSC_APP_ERROR;
+    }  
+  } else {
+    if (pStmt->last != STMT_PREPARE && pStmt->last != STMT_ADD_BATCH && pStmt->last != STMT_EXECUTE) {
+      tscError("0x%"PRIx64" bind param status error, last:%d", pStmt->pSql->self, pStmt->last);
+      return TSDB_CODE_TSC_APP_ERROR;
+    }
+  }
+
+  pStmt->last = STMT_BIND;
+  
+  return insertStmtBindParamBatch(pStmt, bind, -1);
+}
+
+int taos_stmt_bind_single_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind, int colIdx) {
+  STscStmt* pStmt = (STscStmt*)stmt;
+  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return TSDB_CODE_TSC_DISCONNECTED;
+  }
+
+  if (bind == NULL || bind->num <= 0 || bind->num > INT16_MAX) {
+    tscError("0x%"PRIx64" invalid parameter", pStmt->pSql->self);
+    return TSDB_CODE_TSC_APP_ERROR;
+  }
+
+  if (!pStmt->isInsert) {
+    tscError("0x%"PRIx64" not or invalid batch insert", pStmt->pSql->self);
+    return TSDB_CODE_TSC_APP_ERROR;
+  }
+
+  if (pStmt->multiTbInsert) {
+    if (pStmt->last != STMT_SETTBNAME && pStmt->last != STMT_ADD_BATCH && pStmt->last != STMT_BIND_COL) {
+      tscError("0x%"PRIx64" bind param status error, last:%d", pStmt->pSql->self, pStmt->last);
+      return TSDB_CODE_TSC_APP_ERROR;
+    }  
+  } else {
+    if (pStmt->last != STMT_PREPARE && pStmt->last != STMT_ADD_BATCH && pStmt->last != STMT_BIND_COL && pStmt->last != STMT_EXECUTE) {
+      tscError("0x%"PRIx64" bind param status error, last:%d", pStmt->pSql->self, pStmt->last);
+      return TSDB_CODE_TSC_APP_ERROR;
+    }
+  }
+
+  pStmt->last = STMT_BIND_COL;
+
+  return insertStmtBindParamBatch(pStmt, bind, colIdx);
+}
+
+
+
 int taos_stmt_add_batch(TAOS_STMT* stmt) {
   STscStmt* pStmt = (STscStmt*)stmt;
+  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return TSDB_CODE_TSC_DISCONNECTED;
+  }
+  
   if (pStmt->isInsert) {
+    if (pStmt->last != STMT_BIND && pStmt->last != STMT_BIND_COL) {
+      tscError("0x%"PRIx64" add batch status error, last:%d", pStmt->pSql->self, pStmt->last);
+      return TSDB_CODE_TSC_APP_ERROR;
+    }
+
+    pStmt->last = STMT_ADD_BATCH;
+    
     return insertStmtAddBatch(pStmt);
   }
+  
   return TSDB_CODE_COM_OPS_NOT_SUPPORT;
 }
 
@@ -978,8 +1532,24 @@ int taos_stmt_reset(TAOS_STMT* stmt) {
 int taos_stmt_execute(TAOS_STMT* stmt) {
   int ret = 0;
   STscStmt* pStmt = (STscStmt*)stmt;
+  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return TSDB_CODE_TSC_DISCONNECTED;
+  }
+  
   if (pStmt->isInsert) {
-    ret = insertStmtExecute(pStmt);
+    if (pStmt->last != STMT_ADD_BATCH) {
+      tscError("0x%"PRIx64" exec status error, last:%d", pStmt->pSql->self, pStmt->last);
+      return TSDB_CODE_TSC_APP_ERROR;
+    }
+
+    pStmt->last = STMT_EXECUTE;
+    
+    if (pStmt->multiTbInsert) {
+      ret = insertBatchStmtExecute(pStmt);
+    } else {
+      ret = insertStmtExecute(pStmt);
+    }
   } else { // normal stmt query
     char* sql = normalStmtBuildSql(pStmt);
     if (sql == NULL) {
@@ -1074,7 +1644,7 @@ int taos_stmt_get_param(TAOS_STMT *stmt, int idx, int *type, int *bytes) {
     }
 
     if (idx<0 || idx>=pBlock->numOfParams) {
-      tscError("param %d: out of range", idx);
+      tscError("0x%"PRIx64" param %d: out of range", pStmt->pSql->self, idx);
       abort();
     }
 

src/client/src/tscProfile.c

@@ -104,7 +104,7 @@ void tscSaveSlowQuery(SSqlObj *pSql) {
   
   char *sql = malloc(sqlSize);
   if (sql == NULL) {
-    tscError("%p failed to allocate memory to sent slow query to dnode", pSql);
+    tscError("0x%"PRIx64" failed to allocate memory to sent slow query to dnode", pSql->self);
     return;
   }
   

src/client/src/tscSQLParser.c

@@ -21,20 +21,20 @@
 #endif // __APPLE__
 
 #include "os.h"
-#include "ttype.h"
-#include "texpr.h"
 #include "taos.h"
 #include "taosmsg.h"
 #include "tcompare.h"
+#include "texpr.h"
 #include "tname.h"
 #include "tscLog.h"
 #include "tscUtil.h"
 #include "tschemautil.h"
 #include "tsclient.h"
-#include "tstoken.h"
 #include "tstrbuild.h"
+#include "ttoken.h"
 #include "ttokendef.h"
 #include "qScript.h"
+#include "ttype.h"
 #include "qUtil.h"
 
 #define DEFAULT_PRIMARY_TIMESTAMP_COL_NAME "_c0"
@@ -65,7 +65,7 @@ static char*   getAccountId(SSqlObj* pSql);
 
 static bool has(SArray* pFieldList, int32_t startIdx, const char* name);
 static char* cloneCurrentDBName(SSqlObj* pSql);
-static bool hasSpecifyDB(SStrToken* pTableName);
+static int32_t getDelimiterIndex(SStrToken* pTableName);
 static bool validateTableColumnInfo(SArray* pFieldList, SSqlCmd* pCmd);
 static bool validateTagParams(SArray* pTagsList, SArray* pFieldList, SSqlCmd* pCmd);
 
@@ -570,17 +570,11 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
     case TSDB_SQL_DESCRIBE_TABLE: {
       const char* msg1 = "invalid table name";
-      const char* msg2 = "table name too long";
 
       SStrToken* pToken = taosArrayGet(pInfo->pMiscInfo->a, 0);
       if (tscValidateName(pToken) != TSDB_CODE_SUCCESS) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
-
-      if (!tscValidateTableNameLength(pToken->n)) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
-      }
-
       // additional msg has been attached already
       code = tscSetTableFullName(pTableMetaInfo, pToken, pSql);
       if (code != TSDB_CODE_SUCCESS) {
@@ -589,19 +583,15 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
       return tscGetTableMeta(pSql, pTableMetaInfo);
     }
+    case TSDB_SQL_SHOW_CREATE_STABLE:
     case TSDB_SQL_SHOW_CREATE_TABLE: {
       const char* msg1 = "invalid table name";
-      const char* msg2 = "table name is too long";
 
       SStrToken* pToken = taosArrayGet(pInfo->pMiscInfo->a, 0);
       if (tscValidateName(pToken) != TSDB_CODE_SUCCESS) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
-      if (!tscValidateTableNameLength(pToken->n)) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
-      }
-
       code = tscSetTableFullName(pTableMetaInfo, pToken, pSql);
       if (code != TSDB_CODE_SUCCESS) {
         return code;
@@ -788,18 +778,26 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       // set the command/global limit parameters from the first subclause to the sqlcmd object
       SQueryInfo* pQueryInfo1 = tscGetQueryInfo(pCmd, 0);
       pCmd->command = pQueryInfo1->command;
+      int32_t diffSize = 0;
 
       // if there is only one element, the limit of clause is the limit of global result.
       // validate the select node for "UNION ALL" subclause
       for (int32_t i = 1; i < pCmd->numOfClause; ++i) {
         SQueryInfo* pQueryInfo2 = tscGetQueryInfo(pCmd, i);
 
-        int32_t ret = tscFieldInfoCompare(&pQueryInfo1->fieldsInfo, &pQueryInfo2->fieldsInfo);
+        int32_t ret = tscFieldInfoCompare(&pQueryInfo1->fieldsInfo, &pQueryInfo2->fieldsInfo, &diffSize);
         if (ret != 0) {
           return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
         }
       }
 
+      if (diffSize) {
+        for (int32_t i = 1; i < pCmd->numOfClause; ++i) {
+          SQueryInfo* pQueryInfo2 = tscGetQueryInfo(pCmd, i);
+          tscFieldInfoSetSize(&pQueryInfo1->fieldsInfo, &pQueryInfo2->fieldsInfo);
+        }
+      }
+
       pCmd->parseFinished = 1;
       return TSDB_CODE_SUCCESS;  // do not build query message here
     }
@@ -1126,11 +1124,13 @@ int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SStrToken* pTableNam
   const char* msg1 = "name too long";
   const char* msg2 = "acctId too long";
   const char* msg3 = "no acctId";
+  const char* msg4 = "db name too long";
+  const char* msg5 = "table name too long";
 
   SSqlCmd* pCmd = &pSql->cmd;
   int32_t  code = TSDB_CODE_SUCCESS;
-
-  if (hasSpecifyDB(pTableName)) { // db has been specified in sql string so we ignore current db path
+  int32_t  idx  = getDelimiterIndex(pTableName);
+  if (idx != -1) { // db has been specified in sql string so we ignore current db path
     char* acctId = getAccountId(pSql);
     if (acctId == NULL || strlen(acctId) <= 0) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
@@ -1140,7 +1140,14 @@ int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SStrToken* pTableNam
     if (code != 0) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
     }
-    
+    if (idx >= TSDB_DB_NAME_LEN) {
+      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+    }
+
+    if (pTableName->n - 1 - idx >= TSDB_TABLE_NAME_LEN) {
+      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+    }
+
     char name[TSDB_TABLE_FNAME_LEN] = {0};
     strncpy(name, pTableName->z, pTableName->n);
 
@@ -1484,14 +1491,13 @@ static char* cloneCurrentDBName(SSqlObj* pSql) {
 }
 
 /* length limitation, strstr cannot be applied */
-static bool hasSpecifyDB(SStrToken* pTableName) {
+static int32_t getDelimiterIndex(SStrToken* pTableName) {
   for (uint32_t i = 0; i < pTableName->n; ++i) {
     if (pTableName->z[i] == TS_PATH_DELIMITER[0]) {
-      return true;
+      return i;
     }
   }
-
-  return false;
+  return -1;
 }
 
 int32_t setObjFullName(char* fullName, const char* account, SStrToken* pDB, SStrToken* tableName, int32_t* xlen) {
@@ -1750,6 +1756,21 @@ bool isValidDistinctSql(SQueryInfo* pQueryInfo) {
   return false;
 }
 
+static bool hasNoneUserDefineExpr(SQueryInfo* pQueryInfo) {
+  size_t numOfExprs = taosArrayGetSize(pQueryInfo->exprList);
+  for (int32_t i = 0; i < numOfExprs; ++i) {
+    SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, i);
+
+    if (TSDB_COL_IS_UD_COL(pExpr->colInfo.flag)) {
+      continue;
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
 void genUdfList(SArray* pUdfInfo, tSqlExpr *pNode) {
   if (pNode == NULL) {
     return;
@@ -1816,6 +1837,7 @@ int32_t validateSelectNodeList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pS
   assert(pSelNodeList != NULL && pCmd != NULL);
 
   const char* msg1 = "too many items in selection clause";
+
   const char* msg2 = "functions or others can not be mixed up";
   const char* msg3 = "not support query expression";
   const char* msg4 = "only support distinct one tag";
@@ -1885,7 +1907,7 @@ int32_t validateSelectNodeList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pS
   
   // there is only one user-defined column in the final result field, add the timestamp column.
   size_t numOfSrcCols = taosArrayGetSize(pQueryInfo->colList);
-  if (numOfSrcCols <= 0 && !tscQueryTags(pQueryInfo) && !tscQueryBlockInfo(pQueryInfo)) {
+  if ((numOfSrcCols <= 0 || !hasNoneUserDefineExpr(pQueryInfo)) && !tscQueryTags(pQueryInfo) && !tscQueryBlockInfo(pQueryInfo)) {
     addPrimaryTsColIntoResult(pQueryInfo);
   }
 
@@ -4914,7 +4936,7 @@ int32_t getTimeRange(STimeWindow* win, tSqlExpr* pRight, int32_t optr, int16_t t
       }
     } else {
       SStrToken token = {.z = pRight->value.pz, .n = pRight->value.nLen, .type = TK_ID};
-      int32_t   len = tSQLGetToken(pRight->value.pz, &token.type);
+      int32_t   len = tGetToken(pRight->value.pz, &token.type);
 
       if ((token.type != TK_INTEGER && token.type != TK_FLOAT) || len != pRight->value.nLen) {
         return TSDB_CODE_TSC_INVALID_SQL;
@@ -5514,7 +5536,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     int32_t size = sizeof(SUpdateTableTagValMsg) + pTagsSchema->bytes + schemaLen + TSDB_EXTRA_PAYLOAD_SIZE;
 
     if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, size)) {
-      tscError("%p failed to malloc for alter table msg", pSql);
+      tscError("0x%"PRIx64" failed to malloc for alter table msg", pSql->self);
       return TSDB_CODE_TSC_OUT_OF_MEMORY;
     }
 
@@ -5812,13 +5834,13 @@ int32_t validateLocalConfig(SMiscInfo* pOptions) {
 }
 
 int32_t validateColumnName(char* name) {
-  bool ret = isKeyWord(name, (int32_t)strlen(name));
+  bool ret = taosIsKeyWordToken(name, (int32_t)strlen(name));
   if (ret) {
     return TSDB_CODE_TSC_INVALID_SQL;
   }
 
   SStrToken token = {.z = name};
-  token.n = tSQLGetToken(name, &token.type);
+  token.n = tGetToken(name, &token.type);
 
   if (token.type != TK_STRING && token.type != TK_ID) {
     return TSDB_CODE_TSC_INVALID_SQL;
@@ -5829,7 +5851,7 @@ int32_t validateColumnName(char* name) {
     strntolower(token.z, token.z, token.n);
     token.n = (uint32_t)strtrim(token.z);
 
-    int32_t k = tSQLGetToken(token.z, &token.type);
+    int32_t k = tGetToken(token.z, &token.type);
     if (k != token.n) {
       return TSDB_CODE_TSC_INVALID_SQL;
     }
@@ -7843,4 +7865,3 @@ bool hasNormalColumnFilter(SQueryInfo* pQueryInfo) {
 
   return false;
 }
-

src/client/src/tscServer.c

@@ -222,7 +222,7 @@ void tscProcessHeartBeatRsp(void *param, TAOS_RES *tres, int code) {
     assert(online <= total);
 
     if (online < total) {
-      tscError("HB:%p, total dnode:%d, online dnode:%d", pSql, total, online);
+      tscError("0x%"PRIx64", HB, total dnode:%d, online dnode:%d", pSql->self, total, online);
       pSql->res.code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
     }
 
@@ -274,7 +274,7 @@ void tscProcessActivityTimer(void *handle, void *tmrId) {
   taosReleaseRef(tscObjRef, pObj->hbrid);
 
   if (code != TSDB_CODE_SUCCESS) {
-    tscError("%p failed to sent HB to server, reason:%s", pHB, tstrerror(code));
+    tscError("0x%"PRIx64" failed to sent HB to server, reason:%s", pHB->self, tstrerror(code));
   }
 
   taosReleaseRef(tscRefId, rid);
@@ -286,7 +286,7 @@ int tscSendMsgToServer(SSqlObj *pSql) {
   
   char *pMsg = rpcMallocCont(pCmd->payloadLen);
   if (NULL == pMsg) {
-    tscError("%p msg:%s malloc failed", pSql, taosMsg[pSql->cmd.msgType]);
+    tscError("0x%"PRIx64" msg:%s malloc failed", pSql->self, taosMsg[pSql->cmd.msgType]);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
@@ -370,11 +370,11 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {
        rpcMsg->code == TSDB_CODE_APP_NOT_READY)) {
         
     pSql->retry++;
-    tscWarn("%p it shall renew table meta, code:%s, retry:%d", pSql, tstrerror(rpcMsg->code), pSql->retry);
+    tscWarn("0x%"PRIx64" it shall renew table meta, code:%s, retry:%d", pSql->self, tstrerror(rpcMsg->code), pSql->retry);
 
     pSql->res.code = rpcMsg->code;  // keep the previous error code
     if (pSql->retry > pSql->maxRetry) {
-      tscError("%p max retry %d reached, give up", pSql, pSql->maxRetry);
+      tscError("0x%"PRIx64" max retry %d reached, give up", pSql->self, pSql->maxRetry);
     } else {
       // wait for a little bit moment and then retry
       // todo do not sleep in rpc callback thread, add this process into queueu to process
@@ -667,8 +667,8 @@ static char *doSerializeTableInfo(SQueryTableMsg *pQueryMsg, SSqlObj *pSql, STab
         assert(index < pTableMetaInfo->vgroupList->numOfVgroups);
         pVgroupInfo = &pTableMetaInfo->vgroupList->vgroups[index];
       } else {
-        tscError("%p No vgroup info found", pSql);
-
+        tscError("0x%"PRIx64" No vgroup info found", pSql->self);
+        
         *succeed = 0;
         return pMsg;
       }
@@ -762,21 +762,20 @@ static int32_t serializeColFilterInfo(SColumnFilterInfo* pColFilters, int16_t nu
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t serializeSqlExpr(SSqlExpr* pExpr, STableMetaInfo* pTableMetaInfo, char** pMsg, void* addr) {
+static int32_t serializeSqlExpr(SSqlExpr* pExpr, STableMetaInfo* pTableMetaInfo, char** pMsg, int64_t id, bool validateColumn) {
   STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
 
   // the queried table has been removed and a new table with the same name has already been created already
   // return error msg
   if (pExpr->uid != pTableMeta->id.uid) {
-    tscError("%p table has already been destroyed", addr);
+    tscError("0x%"PRIx64" table has already been destroyed", id);
     return TSDB_CODE_TSC_INVALID_TABLE_NAME;
   }
 
-  //TODO disable it temporarily
-//  if (!tscValidateColumnId(pTableMetaInfo, pExpr->colInfo.colId, pExpr->numOfParams)) {
-//    tscError("%p table schema is not matched with parsed sql", addr);
-//    return TSDB_CODE_TSC_INVALID_SQL;
-//  }
+  if (validateColumn && !tscValidateColumnId(pTableMetaInfo, pExpr->colInfo.colId, pExpr->numOfParams)) {
+    tscError("0x%"PRIx64" table schema is not matched with parsed sql", id);
+    return TSDB_CODE_TSC_INVALID_SQL;
+  }
 
   assert(pExpr->resColId < 0);
   SSqlExpr* pSqlExpr = (SSqlExpr *)(*pMsg);
@@ -909,14 +908,14 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   }
 
   for (int32_t i = 0; i < query.numOfOutput; ++i) {
-    code = serializeSqlExpr(&query.pExpr1[i].base, pTableMetaInfo, &pMsg, pSql);
+    code = serializeSqlExpr(&query.pExpr1[i].base, pTableMetaInfo, &pMsg, pSql->self, true);
     if (code != TSDB_CODE_SUCCESS) {
       goto _end;
     }
   }
 
   for (int32_t i = 0; i < query.numOfExpr2; ++i) {
-    code = serializeSqlExpr(&query.pExpr2[i].base, pTableMetaInfo, &pMsg, pSql);
+    code = serializeSqlExpr(&query.pExpr2[i].base, pTableMetaInfo, &pMsg, pSql->self, false);
     if (code != TSDB_CODE_SUCCESS) {
       goto _end;
     }
@@ -1104,7 +1103,7 @@ int32_t tscBuildCreateDnodeMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
   pCmd->payloadLen = sizeof(SCreateDnodeMsg);
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
-    tscError("%p failed to malloc for query msg", pSql);
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
@@ -1122,7 +1121,7 @@ int32_t tscBuildAcctMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
   pCmd->payloadLen = sizeof(SCreateAcctMsg);
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
-    tscError("%p failed to malloc for query msg", pSql);
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
@@ -1168,7 +1167,7 @@ int32_t tscBuildUserMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pCmd->payloadLen = sizeof(SCreateUserMsg);
 
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
-    tscError("%p failed to malloc for query msg", pSql);
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
@@ -1207,7 +1206,7 @@ int32_t tscBuildDropDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pCmd->payloadLen = sizeof(SDropDbMsg);
 
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
-    tscError("%p failed to malloc for query msg", pSql);
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
@@ -1240,7 +1239,7 @@ int32_t tscBuildDropTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pCmd->payloadLen = sizeof(SCMDropTableMsg);
 
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
-    tscError("%p failed to malloc for query msg", pSql);
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
@@ -1261,7 +1260,7 @@ int32_t tscBuildDropDnodeMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   pCmd->payloadLen = sizeof(SDropDnodeMsg);
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
-    tscError("%p failed to malloc for query msg", pSql);
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
@@ -1282,7 +1281,7 @@ int32_t tscBuildDropUserAcctMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pCmd->msgType = (pInfo->type == TSDB_SQL_DROP_USER)? TSDB_MSG_TYPE_CM_DROP_USER:TSDB_MSG_TYPE_CM_DROP_ACCT;
 
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
-    tscError("%p failed to malloc for query msg", pSql);
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
@@ -1297,7 +1296,7 @@ int32_t tscBuildUseDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pCmd->payloadLen = sizeof(SUseDbMsg);
 
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
-    tscError("%p failed to malloc for query msg", pSql);
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
@@ -1314,7 +1313,7 @@ int32_t tscBuildSyncDbReplicaMsg(SSqlObj* pSql, SSqlInfo *pInfo) {
   pCmd->payloadLen = sizeof(SSyncDbMsg);
 
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
-    tscError("%p failed to malloc for query msg", pSql);
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
@@ -1333,7 +1332,7 @@ int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pCmd->payloadLen = sizeof(SShowMsg) + 100;
 
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
-    tscError("%p failed to malloc for query msg", pSql);
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
@@ -1427,7 +1426,7 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   // Reallocate the payload size
   size = tscEstimateCreateTableMsgLength(pSql, pInfo);
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, size)) {
-    tscError("%p failed to malloc for create table msg", pSql);
+    tscError("0x%"PRIx64" failed to malloc for create table msg", pSql->self);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
@@ -1526,7 +1525,7 @@ int tscBuildAlterTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SAlterTableInfo *pAlterInfo = pInfo->pAlterInfo;
   int size = tscEstimateAlterTableMsgLength(pCmd);
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, size)) {
-    tscError("%p failed to malloc for alter table msg", pSql);
+    tscError("0x%"PRIx64" failed to malloc for alter table msg", pSql->self);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
   
@@ -1600,7 +1599,7 @@ int tscBuildRetrieveFromMgmtMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pCmd->payloadLen = sizeof(SRetrieveTableMsg);
 
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
-    tscError("%p failed to malloc for query msg", pSql);
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
@@ -1722,7 +1721,7 @@ int tscBuildConnectMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pCmd->payloadLen = sizeof(SConnectMsg);
 
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, pCmd->payloadLen)) {
-    tscError("%p failed to malloc for query msg", pSql);
+    tscError("0x%"PRIx64" failed to malloc for query msg", pSql->self);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
@@ -1885,7 +1884,7 @@ int tscBuildHeartBeatMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   int size = numOfQueries * sizeof(SQueryDesc) + numOfStreams * sizeof(SStreamDesc) + sizeof(SHeartBeatMsg) + 100;
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, size)) {
     pthread_mutex_unlock(&pObj->mutex);
-    tscError("%p failed to create heartbeat msg", pSql);
+    tscError("0x%"PRIx64" failed to create heartbeat msg", pSql->self);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
@@ -1961,10 +1960,12 @@ int tscProcessTableMetaRsp(SSqlObj *pSql) {
 
   STableMeta* pTableMeta = tscCreateTableMetaFromMsg(pMetaMsg);
   if (!tIsValidSchema(pTableMeta->schema, pTableMeta->tableInfo.numOfColumns, pTableMeta->tableInfo.numOfTags)) {
-    tscError("%p invalid table meta from mnode, name:%s", pSql, tNameGetTableName(&pTableMetaInfo->name));
+    tscError("0x%"PRIx64" invalid table meta from mnode, name:%s", pSql->self, tNameGetTableName(&pTableMetaInfo->name));
     return TSDB_CODE_TSC_INVALID_VALUE;
   }
 
+  assert(pTableMeta->tableType == TSDB_SUPER_TABLE || pTableMeta->tableType == TSDB_CHILD_TABLE || pTableMeta->tableType == TSDB_NORMAL_TABLE || pTableMeta->tableType == TSDB_STREAM_TABLE);
+
   if (pTableMeta->tableType == TSDB_CHILD_TABLE) {
     // check if super table hashmap or not
     int32_t len = (int32_t) strnlen(pTableMeta->sTableName, TSDB_TABLE_FNAME_LEN);
@@ -2205,8 +2206,7 @@ int tscProcessSTableVgroupRsp(SSqlObj *pSql) {
 
     pInfo->vgroupList->numOfVgroups = pVgroupMsg->numOfVgroups;
     if (pInfo->vgroupList->numOfVgroups <= 0) {
-      //tfree(pInfo->vgroupList);
-      tscError("%p empty vgroup info", pSql);
+      tscDebug("0x%"PRIx64" empty vgroup info, no corresponding tables for stable", pSql->self);
     } else {
       for (int32_t j = 0; j < pInfo->vgroupList->numOfVgroups; ++j) {
         // just init, no need to lock
@@ -2522,7 +2522,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code);
 static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
   SSqlObj *pNew = calloc(1, sizeof(SSqlObj));
   if (NULL == pNew) {
-    tscError("%p malloc failed for new sqlobj to get table meta", pSql);
+    tscError("0x%"PRIx64" malloc failed for new sqlobj to get table meta", pSql->self);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
@@ -2536,7 +2536,7 @@ static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaIn
 
   pNew->cmd.autoCreated = pSql->cmd.autoCreated;  // create table if not exists
   if (TSDB_CODE_SUCCESS != tscAllocPayload(&pNew->cmd, TSDB_DEFAULT_PAYLOAD_SIZE + pSql->cmd.payloadLen)) {
-    tscError("%p malloc failed for payload to get table meta", pSql);
+    tscError("0x%"PRIx64" malloc failed for payload to get table meta", pSql->self);
     tscFreeSqlObj(pNew);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
@@ -2549,7 +2549,7 @@ static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaIn
   if (pSql->cmd.autoCreated) {
     int32_t code = copyTagData(&pNew->cmd.tagData, &pSql->cmd.tagData);
     if (code != TSDB_CODE_SUCCESS) {
-      tscError("%p malloc failed for new tag data to get table meta", pSql);
+      tscError("0x%"PRIx64" malloc failed for new tag data to get table meta", pSql->self);
       tscFreeSqlObj(pNew);
       return TSDB_CODE_TSC_OUT_OF_MEMORY;
     }
@@ -2577,10 +2577,23 @@ static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaIn
 int32_t tscGetTableMeta(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
   assert(tIsValidName(&pTableMetaInfo->name));
 
-  tfree(pTableMetaInfo->pTableMeta);
-
   uint32_t size = tscGetTableMetaMaxSize();
-  pTableMetaInfo->pTableMeta = calloc(1, size);
+  if (pTableMetaInfo->pTableMeta == NULL) {
+    pTableMetaInfo->pTableMeta    = calloc(1, size);
+    pTableMetaInfo->tableMetaSize = size;
+  } else if (pTableMetaInfo->tableMetaSize < size) {
+    char *tmp = realloc(pTableMetaInfo->pTableMeta, size); 
+    if (tmp == NULL) { 
+      return TSDB_CODE_TSC_OUT_OF_MEMORY;
+    }
+    pTableMetaInfo->pTableMeta = (STableMeta *)tmp;
+    memset(pTableMetaInfo->pTableMeta, 0, size);
+    pTableMetaInfo->tableMetaSize = size;
+  } else {
+    //uint32_t s = tscGetTableMetaSize(pTableMetaInfo->pTableMeta);
+    memset(pTableMetaInfo->pTableMeta, 0, size);
+    pTableMetaInfo->tableMetaSize = size;
+  }
 
   pTableMetaInfo->pTableMeta->tableType = -1;
   pTableMetaInfo->pTableMeta->tableInfo.numOfColumns  = -1;
@@ -2592,10 +2605,13 @@ int32_t tscGetTableMeta(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
   taosHashGetClone(tscTableMetaInfo, name, len, NULL, pTableMetaInfo->pTableMeta, -1);
 
   // TODO resize the tableMeta
+  char buf[80*1024] = {0};
+  assert(size < 80*1024);
+
   STableMeta* pMeta = pTableMetaInfo->pTableMeta;
   if (pMeta->id.uid > 0) {
     if (pMeta->tableType == TSDB_CHILD_TABLE) {
-      int32_t code = tscCreateTableMetaFromCChildMeta(pTableMetaInfo->pTableMeta, name);
+      int32_t code = tscCreateTableMetaFromCChildMeta(pTableMetaInfo->pTableMeta, name, buf);
       if (code != TSDB_CODE_SUCCESS) {
         return getTableMetaFromMnode(pSql, pTableMetaInfo);
       }
@@ -2681,7 +2697,7 @@ int tscRenewTableMeta(SSqlObj *pSql, int32_t tableIndex) {
   char name[TSDB_TABLE_FNAME_LEN] = {0};
   int32_t code = tNameExtractFullName(&pTableMetaInfo->name, name);
   if (code != TSDB_CODE_SUCCESS) {
-    tscError("%p failed to generate the table full name", pSql);
+    tscError("0x%"PRIx64" failed to generate the table full name", pSql->self);
     return TSDB_CODE_TSC_INVALID_SQL;
   }
 
@@ -2835,6 +2851,7 @@ void tscInitMsgsFp() {
   tscProcessMsgRsp[TSDB_SQL_ALTER_DB] = tscProcessAlterDbMsgRsp;
 
   tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_TABLE] = tscProcessShowCreateRsp;
+  tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_STABLE] = tscProcessShowCreateRsp;
   tscProcessMsgRsp[TSDB_SQL_SHOW_CREATE_DATABASE] = tscProcessShowCreateRsp;
 
   tscKeepConn[TSDB_SQL_SHOW] = 1;

src/client/src/tscSql.c

@@ -457,6 +457,7 @@ static bool needToFetchNewBlock(SSqlObj* pSql) {
           pCmd->command == TSDB_SQL_FETCH ||
           pCmd->command == TSDB_SQL_SHOW ||
           pCmd->command == TSDB_SQL_SHOW_CREATE_TABLE ||
+          pCmd->command == TSDB_SQL_SHOW_CREATE_STABLE ||
           pCmd->command == TSDB_SQL_SHOW_CREATE_DATABASE ||
           pCmd->command == TSDB_SQL_SELECT ||
           pCmd->command == TSDB_SQL_DESCRIBE_TABLE ||
@@ -588,7 +589,7 @@ static bool tscKillQueryInDnode(SSqlObj* pSql) {
 void taos_free_result(TAOS_RES *res) {
   SSqlObj* pSql = (SSqlObj*) res;
   if (pSql == NULL || pSql->signature != pSql) {
-    tscError("%p already released sqlObj", res);
+    tscError("0x%"PRIx64" already released sqlObj", pSql ? pSql->self : -1);
     return;
   }
 
@@ -881,15 +882,14 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
 
   int32_t sqlLen = (int32_t)strlen(sql);
   if (sqlLen > tsMaxSQLStringLen) {
-    tscError("%p sql too long", pSql);
+    tscError("0x%"PRIx64" sql too long", pSql->self);
     tfree(pSql);
     return TSDB_CODE_TSC_EXCEED_SQL_LIMIT;
   }
 
   pSql->sqlstr = realloc(pSql->sqlstr, sqlLen + 1);
   if (pSql->sqlstr == NULL) {
-    tscError("%p failed to malloc sql string buffer", pSql);
-    tscDebug("0x%"PRIx64" Valid SQL result:%d, %s pObj:%p", pSql->self, pRes->code, taos_errstr(pSql), pObj);
+    tscError("0x%"PRIx64" failed to malloc sql string buffer", pSql->self);
     tfree(pSql);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
@@ -914,7 +914,7 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
   }
 
   if (code != TSDB_CODE_SUCCESS) {
-    tscDebug("0x%"PRIx64" Valid SQL result:%d, %s pObj:%p", pSql->self, code, taos_errstr(pSql), pObj);
+    tscError("0x%"PRIx64" invalid SQL result:%d, %s pObj:%p", pSql->self, code, taos_errstr(pSql), pObj);
   }
 
   taos_free_result(pSql);
@@ -963,7 +963,7 @@ static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t t
     len = (int32_t)strtrim(tblName);
 
     SStrToken sToken = {.n = len, .type = TK_ID, .z = tblName};
-    tSQLGetToken(tblName, &sToken.type);
+    tGetToken(tblName, &sToken.type);
 
     // Check if the table name available or not
     if (tscValidateName(&sToken) != TSDB_CODE_SUCCESS) {
@@ -1031,14 +1031,14 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
 
   int32_t tblListLen = (int32_t)strlen(tableNameList);
   if (tblListLen > MAX_TABLE_NAME_LENGTH) {
-    tscError("%p tableNameList too long, length:%d, maximum allowed:%d", pSql, tblListLen, MAX_TABLE_NAME_LENGTH);
+    tscError("0x%"PRIx64" tableNameList too long, length:%d, maximum allowed:%d", pSql->self, tblListLen, MAX_TABLE_NAME_LENGTH);
     tscFreeSqlObj(pSql);
     return TSDB_CODE_TSC_INVALID_SQL;
   }
 
   char *str = calloc(1, tblListLen + 1);
   if (str == NULL) {
-    tscError("%p failed to malloc sql string buffer", pSql);
+    tscError("0x%"PRIx64" failed to malloc sql string buffer", pSql->self);
     tscFreeSqlObj(pSql);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }

src/client/src/tscStream.c

@@ -102,7 +102,7 @@ static void doLaunchQuery(void* param, TAOS_RES* tres, int32_t code) {
   }
 
   if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo) && (pTableMetaInfo->pVgroupTables == NULL) && (pTableMetaInfo->vgroupList == NULL || pTableMetaInfo->vgroupList->numOfVgroups <= 0)) {
-    tscDebug("%p empty vgroup list", pSql);
+    tscDebug("0x%"PRIx64" empty vgroup list", pSql->self);
     pTableMetaInfo->vgroupList = tscVgroupInfoClear(pTableMetaInfo->vgroupList);
     code = TSDB_CODE_TSC_APP_ERROR;
   }
@@ -110,10 +110,9 @@ static void doLaunchQuery(void* param, TAOS_RES* tres, int32_t code) {
   // failed to get table Meta or vgroup list, retry in 10sec.
   if (code == TSDB_CODE_SUCCESS) {
     tscTansformFuncForSTableQuery(pQueryInfo);
-    tscDebug("0x%"PRIx64" stream:%p, start stream query on:%s", pSql->self, pStream, tNameGetTableName(&pTableMetaInfo->name));
+    tscDebug("0x%"PRIx64" stream:%p started to query table:%s", pSql->self, pStream, tNameGetTableName(&pTableMetaInfo->name));
 
     pQueryInfo->command = TSDB_SQL_SELECT;
-    pSql->cmd.active = pQueryInfo;
 
     pSql->fp = tscProcessStreamQueryCallback;
     pSql->fetchFp = tscProcessStreamQueryCallback;
@@ -140,7 +139,7 @@ static void tscProcessStreamTimer(void *handle, void *tmrId) {
   pStream->numOfRes = 0;  // reset the numOfRes.
   SSqlObj *pSql = pStream->pSql;
   SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
-  tscDebug("0x%"PRIx64" add into timer", pSql->self);
+  tscDebug("0x%"PRIx64" timer launch query", pSql->self);
 
   if (pStream->isProject) {
     /*
@@ -195,8 +194,8 @@ static void tscProcessStreamQueryCallback(void *param, TAOS_RES *tres, int numOf
   SSqlStream *pStream = (SSqlStream *)param;
   if (tres == NULL || numOfRows < 0) {
     int64_t retryDelay = tscGetRetryDelayTime(pStream, pStream->interval.sliding, pStream->precision);
-    tscError("%p stream:%p, query data failed, code:0x%08x, retry in %" PRId64 "ms", pStream->pSql, pStream, numOfRows,
-             retryDelay);
+    tscError("0x%"PRIx64" stream:%p, query data failed, code:0x%08x, retry in %" PRId64 "ms", pStream->pSql->self,
+        pStream, numOfRows, retryDelay);
 
     STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pStream->pSql->cmd, 0, 0);
 
@@ -204,6 +203,14 @@ static void tscProcessStreamQueryCallback(void *param, TAOS_RES *tres, int numOf
     tNameExtractFullName(&pTableMetaInfo->name, name);
 
     taosHashRemove(tscTableMetaInfo, name, strnlen(name, TSDB_TABLE_FNAME_LEN));
+
+    tfree(pTableMetaInfo->pTableMeta);
+
+    tscFreeSqlResult(pStream->pSql);
+    tscFreeSubobj(pStream->pSql);
+    tfree(pStream->pSql->pSubs);
+    pStream->pSql->subState.numOfSub = 0;
+
     pTableMetaInfo->vgroupList = tscVgroupInfoClear(pTableMetaInfo->vgroupList);
 
     tscSetRetryTimer(pStream, pStream->pSql, retryDelay);
@@ -260,13 +267,14 @@ static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOf
 
   if (pSql == NULL || numOfRows < 0) {
     int64_t retryDelayTime = tscGetRetryDelayTime(pStream, pStream->interval.sliding, pStream->precision);
-    tscError("%p stream:%p, retrieve data failed, code:0x%08x, retry in %" PRId64 "ms", pSql, pStream, numOfRows, retryDelayTime);
+    tscError("0x%"PRIx64" stream:%p, retrieve data failed, code:0x%08x, retry in %" PRId64 " ms", pSql->self, pStream, numOfRows, retryDelayTime);
   
     tscSetRetryTimer(pStream, pStream->pSql, retryDelayTime);
     return;
   }
 
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  STableMetaInfo *pTableMetaInfo = pQueryInfo->pTableMetaInfo[0];
 
   if (numOfRows > 0) { // when reaching here the first execution of stream computing is successful.
     for(int32_t i = 0; i < numOfRows; ++i) {
@@ -293,7 +301,7 @@ static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOf
         /* no resuls in the query range, retry */
         // todo set retry dynamic time
         int32_t retry = tsProjectExecInterval;
-        tscError("%p stream:%p, retrieve no data, code:0x%08x, retry in %" PRId32 "ms", pSql, pStream, numOfRows, retry);
+        tscError("0x%"PRIx64" stream:%p, retrieve no data, code:0x%08x, retry in %" PRId32 "ms", pSql->self, pStream, numOfRows, retry);
 
         tscSetRetryTimer(pStream, pStream->pSql, retry);
         return;
@@ -306,6 +314,10 @@ static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOf
              pStream->numOfRes);
 
     tfree(pTableMetaInfo->pTableMeta);
+    if (pQueryInfo->pQInfo != NULL) {
+      qDestroyQueryInfo(pQueryInfo->pQInfo);
+      pQueryInfo->pQInfo = NULL;
+    }
 
     tscFreeSqlResult(pSql);
     tscFreeSubobj(pSql);    
@@ -338,10 +350,10 @@ static void tscSetRetryTimer(SSqlStream *pStream, SSqlObj *pSql, int64_t timer)
       return;
     }
   
-    tscDebug("0x%"PRIx64" stream:%p, next start at %" PRId64 ", in %" PRId64 "ms. delay:%" PRId64 "ms qrange %" PRId64 "-%" PRId64, pStream->pSql->self, pStream,
+    tscDebug("0x%"PRIx64" stream:%p, next start at %" PRId64 "(ts window ekey), in %" PRId64 " ms. delay:%" PRId64 "ms qrange %" PRId64 "-%" PRId64, pStream->pSql->self, pStream,
              now + timer, timer, delay, pStream->stime, etime);
   } else {
-    tscDebug("0x%"PRIx64" stream:%p, next start at %" PRId64 ", in %" PRId64 "ms. delay:%" PRId64 "ms qrange %" PRId64 "-%" PRId64, pStream->pSql->self, pStream,
+    tscDebug("0x%"PRIx64" stream:%p, next start at %" PRId64 "(ts window ekey), in %" PRId64 " ms. delay:%" PRId64 "ms qrange %" PRId64 "-%" PRId64, pStream->pSql->self, pStream,
              pStream->stime, timer, delay, pStream->stime - pStream->interval.interval, pStream->stime - 1);
   }
 
@@ -399,7 +411,6 @@ static void tscSetNextLaunchTimer(SSqlStream *pStream, SSqlObj *pSql) {
     }
   } else {
     int64_t stime = taosTimeTruncate(pStream->stime - 1, &pStream->interval, pStream->precision);
-    //int64_t stime = taosGetIntervalStartTimestamp(pStream->stime - 1, pStream->interval.interval, pStream->interval.interval, pStream->interval.intervalUnit, pStream->precision);
     if (stime >= pStream->etime) {
       tscDebug("0x%"PRIx64" stream:%p, stime:%" PRId64 " is larger than end time: %" PRId64 ", stop the stream", pStream->pSql->self, pStream,
                pStream->stime, pStream->etime);
@@ -441,7 +452,7 @@ static int32_t tscSetSlidingWindowInfo(SSqlObj *pSql, SSqlStream *pStream) {
   }
   
   if (pQueryInfo->interval.intervalUnit != 'n' && pQueryInfo->interval.intervalUnit!= 'y' && pQueryInfo->interval.interval < minIntervalTime) {
-    tscWarn("%p stream:%p, original sample interval:%" PRId64 " too small, reset to:%" PRId64, pSql, pStream,
+    tscWarn("0x%"PRIx64" stream:%p, original sample interval:%" PRId64 " too small, reset to:%" PRId64, pSql->self, pStream,
             (int64_t)pQueryInfo->interval.interval, minIntervalTime);
     pQueryInfo->interval.interval = minIntervalTime;
   }
@@ -458,14 +469,14 @@ static int32_t tscSetSlidingWindowInfo(SSqlObj *pSql, SSqlStream *pStream) {
       (pStream->precision == TSDB_TIME_PRECISION_MICRO) ? tsMinSlidingTime * 1000L : tsMinSlidingTime;
 
   if (pQueryInfo->interval.intervalUnit != 'n' && pQueryInfo->interval.intervalUnit!= 'y' && pQueryInfo->interval.sliding < minSlidingTime) {
-    tscWarn("%p stream:%p, original sliding value:%" PRId64 " too small, reset to:%" PRId64, pSql, pStream,
+    tscWarn("0x%"PRIx64" stream:%p, original sliding value:%" PRId64 " too small, reset to:%" PRId64, pSql->self, pStream,
         pQueryInfo->interval.sliding, minSlidingTime);
 
     pQueryInfo->interval.sliding = minSlidingTime;
   }
 
   if (pQueryInfo->interval.sliding > pQueryInfo->interval.interval) {
-    tscWarn("%p stream:%p, sliding value:%" PRId64 " can not be larger than interval range, reset to:%" PRId64, pSql, pStream,
+    tscWarn("0x%"PRIx64" stream:%p, sliding value:%" PRId64 " can not be larger than interval range, reset to:%" PRId64, pSql->self, pStream,
             pQueryInfo->interval.sliding, pQueryInfo->interval.interval);
 
     pQueryInfo->interval.sliding = pQueryInfo->interval.interval;
@@ -508,7 +519,7 @@ static int64_t tscGetStreamStartTimestamp(SSqlObj *pSql, SSqlStream *pStream, in
     } else {
       int64_t newStime = taosTimeTruncate(stime, &pStream->interval, pStream->precision);
       if (newStime != stime) {
-        tscWarn("%p stream:%p, last timestamp:%" PRId64 ", reset to:%" PRId64, pSql, pStream, stime, newStime);
+        tscWarn("0x%"PRIx64" stream:%p, last timestamp:%" PRId64 ", reset to:%" PRId64, pSql->self, pStream, stime, newStime);
         stime = newStime;
       }
     }
@@ -539,7 +550,7 @@ static void tscCreateStream(void *param, TAOS_RES *res, int code) {
 
   if (code != TSDB_CODE_SUCCESS) {
     pSql->res.code = code;
-    tscError("%p open stream failed, sql:%s, reason:%s, code:%s", pSql, pSql->sqlstr, pCmd->payload, tstrerror(code));
+    tscError("0x%"PRIx64" open stream failed, sql:%s, reason:%s, code:%s", pSql->self, pSql->sqlstr, pCmd->payload, tstrerror(code));
 
     pStream->fp(pStream->param, NULL, NULL);
     return;
@@ -558,7 +569,7 @@ static void tscCreateStream(void *param, TAOS_RES *res, int code) {
   if (tscSetSlidingWindowInfo(pSql, pStream) != TSDB_CODE_SUCCESS) {
     pSql->res.code = code;
 
-    tscError("%p stream %p open failed, since the interval value is incorrect", pSql, pStream);
+    tscError("0x%"PRIx64" stream %p open failed, since the interval value is incorrect", pSql->self, pStream);
     pStream->fp(pStream->param, NULL, NULL);
     return;
   }
@@ -598,7 +609,7 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p
 
   SSqlStream *pStream = (SSqlStream *)calloc(1, sizeof(SSqlStream));
   if (pStream == NULL) {
-    tscError("%p open stream failed, sql:%s, reason:%s, code:0x%08x", pSql, sqlstr, pCmd->payload, pRes->code);
+    tscError("0x%"PRIx64" open stream failed, sql:%s, reason:%s, code:0x%08x", pSql->self, sqlstr, pCmd->payload, pRes->code);
     tscFreeSqlObj(pSql);
     return NULL;
   }
@@ -614,26 +625,26 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p
 
   pSql->sqlstr = calloc(1, strlen(sqlstr) + 1);
   if (pSql->sqlstr == NULL) {
-    tscError("%p failed to malloc sql string buffer", pSql);
+    tscError("0x%"PRIx64" failed to malloc sql string buffer", pSql->self);
     tscFreeSqlObj(pSql);
     return NULL;
   }
 
   strtolower(pSql->sqlstr, sqlstr);
 
-  tscDebugL("%p SQL: %s", pSql, pSql->sqlstr);
+  registerSqlObj(pSql);
+
+  tscDebugL("0x%"PRIx64" SQL: %s", pSql->self, pSql->sqlstr);
   tsem_init(&pSql->rspSem, 0, 0);
 
   pSql->fp = tscCreateStream;
   pSql->fetchFp = tscCreateStream;
 
-  registerSqlObj(pSql);
-  
   int32_t code = tsParseSql(pSql, true);
   if (code == TSDB_CODE_SUCCESS) {
     tscCreateStream(pStream, pSql, code);
   } else if (code != TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
-    tscError("%p open stream failed, sql:%s, code:%s", pSql, sqlstr, tstrerror(code));
+    tscError("0x%"PRIx64" open stream failed, sql:%s, code:%s", pSql->self, sqlstr, tstrerror(code));
     taosReleaseRef(tscObjRef, pSql->self);
     free(pStream);
     return NULL;

src/client/src/tscSub.c

@@ -224,11 +224,11 @@ static SArray* getTableList( SSqlObj* pSql ) {
   
   SSqlObj* pNew = taos_query(pSql->pTscObj, sql);
   if (pNew == NULL) {
-    tscError("failed to retrieve table id: cannot create new sql object.");
+    tscError("0x%"PRIx64"failed to retrieve table id: cannot create new sql object.", pSql->self);
     return NULL;
 
   } else if (taos_errno(pNew) != TSDB_CODE_SUCCESS) {
-    tscError("failed to retrieve table id: %s", tstrerror(taos_errno(pNew)));
+    tscError("0x%"PRIx64"failed to retrieve table id,error: %s", pSql->self, tstrerror(taos_errno(pNew)));
     return NULL;
   }
 

src/client/src/tscSubquery.c

@@ -71,7 +71,7 @@ static void subquerySetState(SSqlObj *pSql, SSubqueryState *subState, int idx, i
 
   pthread_mutex_lock(&subState->mutex);
   
-  tscDebug("subquery:%p,%d state set to %d", pSql, idx, state);
+  tscDebug("subquery:0x%"PRIx64",%d state set to %d", pSql->self, idx, state);
   
   subState->states[idx] = state;
 
@@ -85,12 +85,18 @@ static bool allSubqueryDone(SSqlObj *pParentSql) {
   //lock in caller
   tscDebug("0x%"PRIx64" total subqueries: %d", pParentSql->self, subState->numOfSub);
   for (int i = 0; i < subState->numOfSub; i++) {
+    SSqlObj* pSub = pParentSql->pSubs[i];
     if (0 == subState->states[i]) {
-      tscDebug("0x%"PRIx64" subquery:%p, index: %d NOT finished, abort query completion check", pParentSql->self, pParentSql->pSubs[i], i);
+      tscDebug("0x%"PRIx64" subquery:0x%"PRIx64", index: %d NOT finished, abort query completion check", pParentSql->self,
+               pSub->self, i);
       done = false;
       break;
     } else {
-      tscDebug("0x%"PRIx64" subquery:%p, index: %d finished", pParentSql->self, pParentSql->pSubs[i], i);
+      if (pSub != NULL) {
+        tscDebug("0x%"PRIx64" subquery:0x%"PRIx64", index: %d finished", pParentSql->self, pSub->self, i);
+      } else {
+        tscDebug("0x%"PRIx64" subquery:%p, index: %d finished", pParentSql->self, pSub, i);
+      }
     }
   }
 
@@ -107,14 +113,15 @@ static bool subAndCheckDone(SSqlObj *pSql, SSqlObj *pParentSql, int idx) {
   bool done = allSubqueryDone(pParentSql);
 
   if (done) {
-    tscDebug("0x%"PRIx64" subquery:%p,%d all subs already done", pParentSql->self, pSql, idx);
+    tscDebug("0x%"PRIx64" subquery:0x%"PRIx64",%d all subs already done", pParentSql->self,
+        pSql->self, idx);
     
     pthread_mutex_unlock(&subState->mutex);
     
     return false;
   }
   
-  tscDebug("0x%"PRIx64" subquery:%p,%d state set to 1", pParentSql->self, pSql, idx);
+  tscDebug("0x%"PRIx64" subquery:0x%"PRIx64",%d state set to 1", pParentSql->self, pSql->self, idx);
   
   subState->states[idx] = 1;
 
@@ -171,7 +178,8 @@ static int64_t doTSBlockIntersect(SSqlObj* pSql, STimeWindow * win) {
       return 0;
     }
 
-    tscDebug("0x%"PRIx64" sub:%p table idx:%d, input group number:%d", pSql->self, pSql->pSubs[i], i, pSupporter->pTSBuf->numOfGroups);
+    tscDebug("0x%"PRIx64" sub:0x%"PRIx64" table idx:%d, input group number:%d", pSql->self,
+        pSql->pSubs[i]->self, i, pSupporter->pTSBuf->numOfGroups);
 
     ctxlist[i].p = pSupporter;
     ctxlist[i].res = output;
@@ -377,9 +385,9 @@ static int64_t doTSBlockIntersect(SSqlObj* pSql, STimeWindow * win) {
   TSKEY et = taosGetTimestampUs();
 
   for (int32_t i = 0; i < joinNum; ++i) {
-    tscDebug("0x%"PRIx64" sub:%p tblidx:%d, input:%" PRId64 ", final:%" PRId64 " in %d vnodes for secondary query after ts blocks "
+    tscDebug("0x%"PRIx64" sub:0x%"PRIx64" tblidx:%d, input:%" PRId64 ", final:%" PRId64 " in %d vnodes for secondary query after ts blocks "
              "intersecting, skey:%" PRId64 ", ekey:%" PRId64 ", numOfVnode:%d, elapsed time:%" PRId64 " us",
-             pSql->self, pSql->pSubs[i], i, ctxlist[i].numOfInput, ctxlist[i].res->numOfTotal, ctxlist[i].res->numOfGroups, win->skey, win->ekey,
+             pSql->self, pSql->pSubs[i]->self, i, ctxlist[i].numOfInput, ctxlist[i].res->numOfTotal, ctxlist[i].res->numOfGroups, win->skey, win->ekey,
              tsBufGetNumOfGroup(ctxlist[i].res), et - st);
   }
 
@@ -630,7 +638,13 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
       int16_t colId = tscGetJoinTagColIdByUid(&pQueryInfo->tagCond, pTableMetaInfo->pTableMeta->id.uid);
 
       // set the tag column id for executor to extract correct tag value
+#ifndef _TD_NINGSI_60      
       pExpr->base.param[0] = (tVariant) {.i64 = colId, .nType = TSDB_DATA_TYPE_BIGINT, .nLen = sizeof(int64_t)};
+#else
+      pExpr->base.param[0].i64 = colId;
+      pExpr->base.param[0].nType = TSDB_DATA_TYPE_BIGINT;
+      pExpr->base.param[0].nLen = sizeof(int64_t);
+#endif
       pExpr->base.numOfParams = 1;
     }
 
@@ -656,7 +670,7 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
   //prepare the subqueries object failed, abort
   if (!success) {
     pSql->res.code = TSDB_CODE_TSC_OUT_OF_MEMORY;
-    tscError("%p failed to prepare subqueries objs for secondary phase query, numOfSub:%d, code:%d", pSql,
+    tscError("0x%"PRIx64" failed to prepare subqueries objs for secondary phase query, numOfSub:%d, code:%d", pSql->self,
         pSql->subState.numOfSub, pSql->res.code);
     freeJoinSubqueryObj(pSql);
     
@@ -701,7 +715,7 @@ void freeJoinSubqueryObj(SSqlObj* pSql) {
 
 static int32_t quitAllSubquery(SSqlObj* pSqlSub, SSqlObj* pSqlObj, SJoinSupporter* pSupporter) {
   if (subAndCheckDone(pSqlSub, pSqlObj, pSupporter->subqueryIndex)) {
-    tscError("%p all subquery return and query failed, global code:%s", pSqlObj, tstrerror(pSqlObj->res.code));  
+    tscError("0x%"PRIx64" all subquery return and query failed, global code:%s", pSqlObj->self, tstrerror(pSqlObj->res.code));
     freeJoinSubqueryObj(pSqlObj);
     return 0;
   }
@@ -785,7 +799,7 @@ void tscBuildVgroupTableInfo(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, SArr
     STableIdInfo item = {.uid = tt->uid, .tid = tt->tid, .key = INT64_MIN};
     taosArrayPush(vgTables, &item);
 
-    tscTrace("%p tid:%d, uid:%"PRIu64",vgId:%d added", pSql, tt->tid, tt->uid, tt->vgId);
+    tscTrace("0x%"PRIx64" tid:%d, uid:%"PRIu64",vgId:%d added", pSql->self, tt->tid, tt->uid, tt->vgId);
     prev = tt;
   }
 
@@ -851,9 +865,9 @@ static void issueTsCompQuery(SSqlObj* pSql, SJoinSupporter* pSupporter, SSqlObj*
   size_t numOfCols = taosArrayGetSize(pQueryInfo->colList);
   
   tscDebug(
-      "%p subquery:%p tableIndex:%d, vgroupIndex:%d, numOfVgroups:%d, type:%d, ts_comp query to retrieve timestamps, "
+      "0x%"PRIx64" subquery:0x%"PRIx64" tableIndex:%d, vgroupIndex:%d, numOfVgroups:%d, type:%d, ts_comp query to retrieve timestamps, "
       "numOfExpr:%" PRIzu ", colList:%" PRIzu ", numOfOutputFields:%d, name:%s",
-      pParent, pSql, 0, pTableMetaInfo->vgroupIndex, pTableMetaInfo->vgroupList->numOfVgroups, pQueryInfo->type,
+      pParent->self, pSql->self, 0, pTableMetaInfo->vgroupIndex, pTableMetaInfo->vgroupList->numOfVgroups, pQueryInfo->type,
       tscSqlExprNumOfExprs(pQueryInfo), numOfCols, pQueryInfo->fieldsInfo.numOfOutput, tNameGetTableName(&pTableMetaInfo->name));
   
   tscBuildAndSendRequest(pSql, NULL);
@@ -866,7 +880,7 @@ static bool checkForDuplicateTagVal(SSchema* pColSchema, SJoinSupporter* p1, SSq
     assert(prev->vgId >= 1 && p->vgId >= 1);
 
     if (doCompare(prev->tag, p->tag, pColSchema->type, pColSchema->bytes) == 0) {
-      tscError("%p join tags have same value for different table, free all sub SqlObj and quit", pPSqlObj);
+      tscError("0x%"PRIx64" join tags have same value for different table, free all sub SqlObj and quit", pPSqlObj->self);
       pPSqlObj->res.code = TSDB_CODE_QRY_DUP_JOIN_KEY;
       return false;
     }
@@ -1102,7 +1116,7 @@ static void tidTagRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
   assert(TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_TAG_FILTER_QUERY));
 
   if (pParentSql->res.code != TSDB_CODE_SUCCESS) {
-    tscError("%p abort query due to other subquery failure. code:%d, global code:%d", pSql, numOfRows, pParentSql->res.code);
+    tscError("0x%"PRIx64" abort query due to other subquery failure. code:%d, global code:%d", pSql->self, numOfRows, pParentSql->res.code);
     if (quitAllSubquery(pSql, pParentSql, pSupporter)) {
       return;
     }
@@ -1117,7 +1131,7 @@ static void tidTagRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
     // todo retry if other subqueries are not failed
 
     assert(numOfRows < 0 && numOfRows == taos_errno(pSql));
-    tscError("%p sub query failed, code:%s, index:%d", pSql, tstrerror(numOfRows), pSupporter->subqueryIndex);
+    tscError("0x%"PRIx64" sub query failed, code:%s, index:%d", pSql->self, tstrerror(numOfRows), pSupporter->subqueryIndex);
 
     pParentSql->res.code = numOfRows;
     if (quitAllSubquery(pSql, pParentSql, pSupporter)) {
@@ -1136,7 +1150,7 @@ static void tidTagRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
     // todo handle memory error
     char* tmp = realloc(pSupporter->pIdTagList, length);
     if (tmp == NULL) {
-      tscError("%p failed to malloc memory", pSql);
+      tscError("0x%"PRIx64" failed to malloc memory", pSql->self);
 
       pParentSql->res.code = TAOS_SYSTEM_ERROR(errno);
       if (quitAllSubquery(pSql, pParentSql, pSupporter)) {
@@ -1256,7 +1270,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
   assert(!TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_JOIN_SEC_STAGE));
 
   if (pParentSql->res.code != TSDB_CODE_SUCCESS) {
-    tscError("%p abort query due to other subquery failure. code:%d, global code:%d", pSql, numOfRows, pParentSql->res.code);
+    tscError("0x%"PRIx64" abort query due to other subquery failure. code:%d, global code:%d", pSql->self, numOfRows, pParentSql->res.code);
     if (quitAllSubquery(pSql, pParentSql, pSupporter)){
       return;
     }
@@ -1270,7 +1284,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
   if (taos_errno(pSql) != TSDB_CODE_SUCCESS) {
     // todo retry if other subqueries are not failed yet 
     assert(numOfRows < 0 && numOfRows == taos_errno(pSql));
-    tscError("%p sub query failed, code:%s, index:%d", pSql, tstrerror(numOfRows), pSupporter->subqueryIndex);
+    tscError("0x%"PRIx64" sub query failed, code:%s, index:%d", pSql->self, tstrerror(numOfRows), pSupporter->subqueryIndex);
 
     pParentSql->res.code = numOfRows;
     if (quitAllSubquery(pSql, pParentSql, pSupporter)){
@@ -1286,7 +1300,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
       pSupporter->f = fopen(pSupporter->path, "wb");
 
       if (pSupporter->f == NULL) {
-        tscError("%p failed to create tmp file:%s, reason:%s", pSql, pSupporter->path, strerror(errno));
+        tscError("0x%"PRIx64" failed to create tmp file:%s, reason:%s", pSql->self, pSupporter->path, strerror(errno));
         
         pParentSql->res.code = TAOS_SYSTEM_ERROR(errno);
 
@@ -1306,7 +1320,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
 
     STSBuf* pBuf = tsBufCreateFromFile(pSupporter->path, true);
     if (pBuf == NULL) {  // in error process, close the fd
-      tscError("%p invalid ts comp file from vnode, abort subquery, file size:%d", pSql, numOfRows);
+      tscError("0x%"PRIx64" invalid ts comp file from vnode, abort subquery, file size:%d", pSql->self, numOfRows);
 
       pParentSql->res.code = TAOS_SYSTEM_ERROR(errno);
       if (quitAllSubquery(pSql, pParentSql, pSupporter)){
@@ -1403,7 +1417,7 @@ static void joinRetrieveFinalResCallback(void* param, TAOS_RES* tres, int numOfR
   SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
 
   if (pParentSql->res.code != TSDB_CODE_SUCCESS) {
-    tscError("%p abort query due to other subquery failure. code:%d, global code:%d", pSql, numOfRows, pParentSql->res.code);
+    tscError("0x%"PRIx64" abort query due to other subquery failure. code:%d, global code:%d", pSql->self, numOfRows, pParentSql->res.code);
     if (quitAllSubquery(pSql, pParentSql, pSupporter)) {
       return;
     }
@@ -1418,7 +1432,7 @@ static void joinRetrieveFinalResCallback(void* param, TAOS_RES* tres, int numOfR
     assert(numOfRows == taos_errno(pSql));
 
     pParentSql->res.code = numOfRows;
-    tscError("%p retrieve failed, index:%d, code:%s", pSql, pSupporter->subqueryIndex, tstrerror(numOfRows));
+    tscError("0x%"PRIx64" retrieve failed, index:%d, code:%s", pSql->self, pSupporter->subqueryIndex, tstrerror(numOfRows));
 
     tscAsyncResultOnError(pParentSql);
     return;
@@ -1454,7 +1468,7 @@ static void joinRetrieveFinalResCallback(void* param, TAOS_RES* tres, int numOfR
   }
 
   if (!subAndCheckDone(pSql, pParentSql, pSupporter->subqueryIndex)) {
-    tscDebug("0x%"PRIx64" sub:%p,%d completed, total:%d", pParentSql->self, tres, pSupporter->subqueryIndex, pState->numOfSub);
+    tscDebug("0x%"PRIx64" sub:0x%"PRIx64",%d completed, total:%d", pParentSql->self, pSql->self, pSupporter->subqueryIndex, pState->numOfSub);
     return;
   }
 
@@ -1475,16 +1489,16 @@ static void joinRetrieveFinalResCallback(void* param, TAOS_RES* tres, int numOfR
     SSqlRes* pRes1 = &pParentSql->pSubs[i]->res;
 
     if (pRes1->row > 0 && pRes1->numOfRows > 0) {
-      tscDebug("0x%"PRIx64" sub:%p index:%d numOfRows:%d total:%"PRId64 " (not retrieve)", pParentSql->self, pParentSql->pSubs[i], i,
-               pRes1->numOfRows, pRes1->numOfTotal);
+      tscDebug("0x%"PRIx64" sub:0x%"PRIx64" index:%d numOfRows:%d total:%"PRId64 " (not retrieve)", pParentSql->self,
+          pParentSql->pSubs[i]->self, i, pRes1->numOfRows, pRes1->numOfTotal);
       assert(pRes1->row < pRes1->numOfRows);
     } else {
       if (!pQueryInfo->globalMerge) {
         pRes1->numOfClauseTotal += pRes1->numOfRows;
       }
 
-      tscDebug("0x%"PRIx64" sub:%p index:%d numOfRows:%d total:%"PRId64, pParentSql->self, pParentSql->pSubs[i], i,
-               pRes1->numOfRows, pRes1->numOfTotal);
+      tscDebug("0x%"PRIx64" sub:0x%"PRIx64" index:%d numOfRows:%d total:%"PRId64, pParentSql->self,
+          pParentSql->pSubs[i]->self, i, pRes1->numOfRows, pRes1->numOfTotal);
     }
   }
 
@@ -1665,7 +1679,7 @@ void tscFetchDatablockForSubquery(SSqlObj* pSql) {
     STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
     
     if (pRes1->row >= pRes1->numOfRows) {
-      tscDebug("0x%"PRIx64" subquery:%p retrieve data from vnode, subquery:%d, vgroupIndex:%d", pSql->self, pSql1,
+      tscDebug("0x%"PRIx64" subquery:0x%"PRIx64" retrieve data from vnode, subquery:%d, vgroupIndex:%d", pSql->self, pSql1->self,
                pSupporter->subqueryIndex, pTableMetaInfo->vgroupIndex);
 
       tscResetForNextRetrieve(pRes1);
@@ -1745,7 +1759,7 @@ void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {
 
   // retrieve actual query results from vnode during the second stage join subquery
   if (pParentSql->res.code != TSDB_CODE_SUCCESS) {
-    tscError("%p abort query due to other subquery failure. code:%d, global code:%d", pSql, code, pParentSql->res.code);
+    tscError("0x%"PRIx64" abort query due to other subquery failure. code:%d, global code:%d", pSql->self, code, pParentSql->res.code);
     if (quitAllSubquery(pSql, pParentSql, pSupporter)) {
       return;
     }
@@ -1759,7 +1773,7 @@ void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {
   if (taos_errno(pSql) != TSDB_CODE_SUCCESS) {
     assert(taos_errno(pSql) == code);
 
-    tscError("%p abort query, code:%s, global code:%s", pSql, tstrerror(code), tstrerror(pParentSql->res.code));
+    tscError("0x%"PRIx64" abort query, code:%s, global code:%s", pSql->self, tstrerror(code), tstrerror(pParentSql->res.code));
     pParentSql->res.code = code;
 
     if (quitAllSubquery(pSql, pParentSql, pSupporter)) {
@@ -1985,12 +1999,12 @@ void tscHandleMasterJoinQuery(SSqlObj* pSql) {
 
   memset(pSql->subState.states, 0, sizeof(*pSql->subState.states) * pSql->subState.numOfSub);
   tscDebug("0x%"PRIx64" reset all sub states to 0", pSql->self);
-  
+
   tscDebug("0x%"PRIx64" start subquery, total:%d", pSql->self, pQueryInfo->numOfTables);
   for (int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
     SJoinSupporter *pSupporter = tscCreateJoinSupporter(pSql, i);
     if (pSupporter == NULL) {  // failed to create support struct, abort current query
-      tscError("%p tableIndex:%d, failed to allocate join support object, abort further query", pSql, i);
+      tscError("0x%"PRIx64" tableIndex:%d, failed to allocate join support object, abort further query", pSql->self, i);
       code = TSDB_CODE_TSC_OUT_OF_MEMORY;
       goto _error;
     }
@@ -2388,9 +2402,9 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
   tscTansformFuncForSTableQuery(pNewQueryInfo);
 
   tscDebug(
-      "%p first round subquery:%p tableIndex:%d, vgroupIndex:%d, numOfVgroups:%d, type:%d, query to retrieve timestamps, "
+      "0x%"PRIx64" first round subquery:0x%"PRIx64" tableIndex:%d, vgroupIndex:%d, numOfVgroups:%d, type:%d, query to retrieve timestamps, "
       "numOfExpr:%" PRIzu ", colList:%d, numOfOutputFields:%d, name:%s",
-      pSql, pNew, 0, pTableMetaInfo->vgroupIndex, pTableMetaInfo->vgroupList->numOfVgroups, pNewQueryInfo->type,
+      pSql->self, pNew->self, 0, pTableMetaInfo->vgroupIndex, pTableMetaInfo->vgroupList->numOfVgroups, pNewQueryInfo->type,
       tscSqlExprNumOfExprs(pNewQueryInfo), index+1, pNewQueryInfo->fieldsInfo.numOfOutput, tNameGetTableName(&pTableMetaInfo->name));
 
   tscHandleMasterSTableQuery(pNew);
@@ -2476,7 +2490,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
   for (; i < pState->numOfSub; ++i) {
     SRetrieveSupport *trs = (SRetrieveSupport *)calloc(1, sizeof(SRetrieveSupport));
     if (trs == NULL) {
-      tscError("%p failed to malloc buffer for SRetrieveSupport, orderOfSub:%d, reason:%s", pSql, i, strerror(errno));
+      tscError("0x%"PRIx64" failed to malloc buffer for SRetrieveSupport, orderOfSub:%d, reason:%s", pSql->self, i, strerror(errno));
       break;
     }
     
@@ -2485,7 +2499,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
 
     trs->localBuffer = (tFilePage *)calloc(1, nBufferSize + sizeof(tFilePage));
     if (trs->localBuffer == NULL) {
-      tscError("%p failed to malloc buffer for local buffer, orderOfSub:%d, reason:%s", pSql, i, strerror(errno));
+      tscError("0x%"PRIx64" failed to malloc buffer for local buffer, orderOfSub:%d, reason:%s", pSql->self, i, strerror(errno));
       tfree(trs);
       break;
     }
@@ -2497,7 +2511,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
 
     SSqlObj *pNew = tscCreateSTableSubquery(pSql, trs, NULL);
     if (pNew == NULL) {
-      tscError("%p failed to malloc buffer for subObj, orderOfSub:%d, reason:%s", pSql, i, strerror(errno));
+      tscError("0x%"PRIx64" failed to malloc buffer for subObj, orderOfSub:%d, reason:%s", pSql->self, i, strerror(errno));
       tfree(trs->localBuffer);
       tfree(trs);
       break;
@@ -2510,11 +2524,12 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
       assert(pNewQueryInfo->tsBuf != NULL);
     }
     
-    tscDebug("0x%"PRIx64" sub:%p create subquery success. orderOfSub:%d", pSql->self, pNew, trs->subqueryIndex);
+    tscDebug("0x%"PRIx64" sub:0x%"PRIx64" create subquery success. orderOfSub:%d", pSql->self, pNew->self,
+        trs->subqueryIndex);
   }
   
   if (i < pState->numOfSub) {
-    tscError("%p failed to prepare subquery structure and launch subqueries", pSql);
+    tscError("0x%"PRIx64" failed to prepare subquery structure and launch subqueries", pSql->self);
     pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
     
     tscLocalReducerEnvDestroy(pMemoryBuf, pDesc, pModel, pFinalModel, pState->numOfSub);
@@ -2558,7 +2573,7 @@ static void tscHandleSubqueryError(SRetrieveSupport *trsupport, SSqlObj *pSql, i
 
 static void tscAbortFurtherRetryRetrieval(SRetrieveSupport *trsupport, TAOS_RES *tres, int32_t code) {
 // set no disk space error info
-  tscError("sub:%p failed to flush data to disk, reason:%s", tres, tstrerror(code));
+  tscError("sub:0x%"PRIx64" failed to flush data to disk, reason:%s", ((SSqlObj *)tres)->self, tstrerror(code));
   SSqlObj* pParentSql = trsupport->pParentSql;
 
   pParentSql->res.code = code;
@@ -2583,7 +2598,7 @@ static int32_t tscReissueSubquery(SRetrieveSupport *oriTrs, SSqlObj *pSql, int32
   const uint32_t nBufferSize = (1u << 16u);  // 64KB
   trsupport->localBuffer = (tFilePage *)calloc(1, nBufferSize + sizeof(tFilePage));
   if (trsupport->localBuffer == NULL) {
-    tscError("%p failed to malloc buffer for local buffer, reason:%s", pSql, strerror(errno));
+    tscError("0x%"PRIx64" failed to malloc buffer for local buffer, reason:%s", pSql->self, strerror(errno));
     tfree(trsupport);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
@@ -2598,13 +2613,13 @@ static int32_t tscReissueSubquery(SRetrieveSupport *oriTrs, SSqlObj *pSql, int32
 
   // clear local saved number of results
   trsupport->localBuffer->num = 0;
-  tscError("%p sub:%p retrieve/query failed, code:%s, orderOfSub:%d, retry:%d", trsupport->pParentSql, pSql,
+  tscError("0x%"PRIx64" sub:0x%"PRIx64" retrieve/query failed, code:%s, orderOfSub:%d, retry:%d", trsupport->pParentSql->self, pSql->self,
            tstrerror(code), subqueryIndex, trsupport->numOfRetry);
 
   SSqlObj *pNew = tscCreateSTableSubquery(trsupport->pParentSql, trsupport, pSql);
   if (pNew == NULL) {
-    tscError("%p sub:%p failed to create new subquery due to error:%s, abort retry, vgId:%d, orderOfSub:%d",
-             oriTrs->pParentSql, pSql, tstrerror(terrno), pVgroup->vgId, oriTrs->subqueryIndex);
+    tscError("0x%"PRIx64" sub:0x%"PRIx64" failed to create new subquery due to error:%s, abort retry, vgId:%d, orderOfSub:%d",
+             oriTrs->pParentSql->self, pSql->self, tstrerror(terrno), pVgroup->vgId, oriTrs->subqueryIndex);
 
     pParentSql->res.code = terrno;
     oriTrs->numOfRetry = MAX_NUM_OF_SUBQUERY_RETRY;
@@ -2658,7 +2673,7 @@ void tscHandleSubqueryError(SRetrieveSupport *trsupport, SSqlObj *pSql, int numO
 
   if (numOfRows >= 0) {  // current query is successful, but other sub query failed, still abort current query.
     tscDebug("0x%"PRIx64" sub:0x%"PRIx64" retrieve numOfRows:%d,orderOfSub:%d", pParentSql->self, pSql->self, numOfRows, subqueryIndex);
-    tscError("%p sub:%p abort further retrieval due to other queries failure,orderOfSub:%d,code:%s", pParentSql, pSql,
+    tscError("0x%"PRIx64" sub:0x%"PRIx64" abort further retrieval due to other queries failure,orderOfSub:%d,code:%s", pParentSql->self, pSql->self,
              subqueryIndex, tstrerror(pParentSql->res.code));
   } else {
     if (trsupport->numOfRetry++ < MAX_NUM_OF_SUBQUERY_RETRY && pParentSql->res.code == TSDB_CODE_SUCCESS) {
@@ -2670,20 +2685,21 @@ void tscHandleSubqueryError(SRetrieveSupport *trsupport, SSqlObj *pSql, int numO
       }
     } else {  // reach the maximum retry count, abort
       atomic_val_compare_exchange_32(&pParentSql->res.code, TSDB_CODE_SUCCESS, numOfRows);
-      tscError("%p sub:%p retrieve failed,code:%s,orderOfSub:%d failed.no more retry,set global code:%s", pParentSql, pSql,
+      tscError("0x%"PRIx64" sub:0x%"PRIx64" retrieve failed,code:%s,orderOfSub:%d failed.no more retry,set global code:%s", pParentSql->self, pSql->self,
                tstrerror(numOfRows), subqueryIndex, tstrerror(pParentSql->res.code));
     }
   }
 
   if (!subAndCheckDone(pSql, pParentSql, subqueryIndex)) {
-    tscDebug("0x%"PRIx64" sub:%p,%d freed, not finished, total:%d", pParentSql->self, pSql, trsupport->subqueryIndex, pState->numOfSub);
+    tscDebug("0x%"PRIx64" sub:0x%"PRIx64",%d freed, not finished, total:%d", pParentSql->self,
+        pSql->self, trsupport->subqueryIndex, pState->numOfSub);
 
     tscFreeRetrieveSup(pSql);
     return;
   }  
   
   // all subqueries are failed
-  tscError("%p retrieve from %d vnode(s) completed,code:%s.FAILED.", pParentSql, pState->numOfSub,
+  tscError("0x%"PRIx64" retrieve from %d vnode(s) completed,code:%s.FAILED.", pParentSql->self, pState->numOfSub,
       tstrerror(pParentSql->res.code));
 
   // release allocated resource
@@ -2717,8 +2733,8 @@ static void tscAllDataRetrievedFromDnode(SRetrieveSupport *trsupport, SSqlObj* p
   // data in from current vnode is stored in cache and disk
   uint32_t numOfRowsFromSubquery = (uint32_t)(trsupport->pExtMemBuffer[idx]->numOfTotalElems + trsupport->localBuffer->num);
   SVgroupsInfo* vgroupsInfo = pTableMetaInfo->vgroupList;
-  tscDebug("0x%"PRIx64" sub:%p all data retrieved from ep:%s, vgId:%d, numOfRows:%d, orderOfSub:%d", pParentSql->self, pSql,
-           vgroupsInfo->vgroups[0].epAddr[0].fqdn, vgroupsInfo->vgroups[0].vgId, numOfRowsFromSubquery, idx);
+  tscDebug("0x%"PRIx64" sub:0x%"PRIx64" all data retrieved from ep:%s, vgId:%d, numOfRows:%d, orderOfSub:%d", pParentSql->self,
+      pSql->self, vgroupsInfo->vgroups[0].epAddr[0].fqdn, vgroupsInfo->vgroups[0].vgId, numOfRowsFromSubquery, idx);
   
   tColModelCompact(pDesc->pColumnModel, trsupport->localBuffer, pDesc->pColumnModel->capacity);
 
@@ -2731,7 +2747,7 @@ static void tscAllDataRetrievedFromDnode(SRetrieveSupport *trsupport, SSqlObj* p
 #endif
   
   if (tsTotalTmpDirGB != 0 && tsAvailTmpDirectorySpace < tsReservedTmpDirectorySpace) {
-    tscError("%p sub:%p client disk space remain %.3f GB, need at least %.3f GB, stop query", pParentSql, pSql,
+    tscError("0x%"PRIx64" sub:0x%"PRIx64" client disk space remain %.3f GB, need at least %.3f GB, stop query", pParentSql->self, pSql->self,
              tsAvailTmpDirectorySpace, tsReservedTmpDirectorySpace);
     tscAbortFurtherRetryRetrieval(trsupport, pSql, TSDB_CODE_TSC_NO_DISKSPACE);
     return;
@@ -2746,7 +2762,8 @@ static void tscAllDataRetrievedFromDnode(SRetrieveSupport *trsupport, SSqlObj* p
   }
   
   if (!subAndCheckDone(pSql, pParentSql, idx)) {
-    tscDebug("0x%"PRIx64" sub:%p orderOfSub:%d freed, not finished", pParentSql->self, pSql, trsupport->subqueryIndex);
+    tscDebug("0x%"PRIx64" sub:0x%"PRIx64" orderOfSub:%d freed, not finished", pParentSql->self, pSql->self,
+        trsupport->subqueryIndex);
 
     tscFreeRetrieveSup(pSql);
     return;
@@ -2837,7 +2854,7 @@ static void tscRetrieveFromDnodeCallBack(void *param, TAOS_RES *tres, int numOfR
     }
 
     if (trsupport->numOfRetry++ < MAX_NUM_OF_SUBQUERY_RETRY) {
-      tscError("%p sub:%p failed code:%s, retry:%d", pParentSql, pSql, tstrerror(numOfRows), trsupport->numOfRetry);
+      tscError("0x%"PRIx64" sub:0x%"PRIx64" failed code:%s, retry:%d", pParentSql->self, pSql->self, tstrerror(numOfRows), trsupport->numOfRetry);
 
       int32_t sent = 0;
       
@@ -2865,8 +2882,8 @@ static void tscRetrieveFromDnodeCallBack(void *param, TAOS_RES *tres, int numOfR
         pParentSql->self, pSql, pRes->numOfRows, pState->numOfRetrievedRows, pSql->epSet.fqdn[pSql->epSet.inUse], idx);
 
     if (num > tsMaxNumOfOrderedResults && tscIsProjectionQueryOnSTable(pQueryInfo, 0)) {
-      tscError("%p sub:%p num of OrderedRes is too many, max allowed:%" PRId32 " , current:%" PRId64,
-               pParentSql, pSql, tsMaxNumOfOrderedResults, num);
+      tscError("0x%"PRIx64" sub:0x%"PRIx64" num of OrderedRes is too many, max allowed:%" PRId32 " , current:%" PRId64,
+               pParentSql->self, pSql->self, tsMaxNumOfOrderedResults, num);
       tscAbortFurtherRetryRetrieval(trsupport, tres, TSDB_CODE_TSC_SORTED_RES_TOO_MANY);
       return;
     }
@@ -2881,7 +2898,7 @@ static void tscRetrieveFromDnodeCallBack(void *param, TAOS_RES *tres, int numOfR
     
     // no disk space for tmp directory
     if (tsTotalTmpDirGB != 0 && tsAvailTmpDirectorySpace < tsReservedTmpDirectorySpace) {
-      tscError("%p sub:%p client disk space remain %.3f GB, need at least %.3f GB, stop query", pParentSql, pSql,
+      tscError("0x%"PRIx64" sub:0x%"PRIx64" client disk space remain %.3f GB, need at least %.3f GB, stop query", pParentSql->self, pSql->self,
                tsAvailTmpDirectorySpace, tsReservedTmpDirectorySpace);
       tscAbortFurtherRetryRetrieval(trsupport, tres, TSDB_CODE_TSC_NO_DISKSPACE);
       return;
@@ -2951,8 +2968,8 @@ void tscRetrieveDataRes(void *param, TAOS_RES *tres, int code) {
   // stable query killed or other subquery failed, all query stopped
   if (pParentSql->res.code != TSDB_CODE_SUCCESS) {
     trsupport->numOfRetry = MAX_NUM_OF_SUBQUERY_RETRY;
-    tscError("%p query cancelled or failed, sub:%p, vgId:%d, orderOfSub:%d, code:%s, global code:%s",
-        pParentSql, pSql, pVgroup->vgId, trsupport->subqueryIndex, tstrerror(code), tstrerror(pParentSql->res.code));
+    tscError("0x%"PRIx64" query cancelled or failed, sub:0x%"PRIx64", vgId:%d, orderOfSub:%d, code:%s, global code:%s",
+        pParentSql->self, pSql->self, pVgroup->vgId, trsupport->subqueryIndex, tstrerror(code), tstrerror(pParentSql->res.code));
 
     tscHandleSubqueryError(param, tres, code);
     return;
@@ -2969,7 +2986,7 @@ void tscRetrieveDataRes(void *param, TAOS_RES *tres, int code) {
     assert(code == taos_errno(pSql));
 
     if (trsupport->numOfRetry++ < MAX_NUM_OF_SUBQUERY_RETRY) {
-      tscError("%p sub:%p failed code:%s, retry:%d", pParentSql, pSql, tstrerror(code), trsupport->numOfRetry);
+      tscError("0x%"PRIx64" sub:0x%"PRIx64" failed code:%s, retry:%d", pParentSql->self, pSql->self, tstrerror(code), trsupport->numOfRetry);
       
       int32_t sent = 0;
 
@@ -2978,7 +2995,7 @@ void tscRetrieveDataRes(void *param, TAOS_RES *tres, int code) {
         return;
       }
     } else {
-      tscError("%p sub:%p reach the max retry times, set global code:%s", pParentSql, pSql, tstrerror(code));
+      tscError("0x%"PRIx64" sub:0x%"PRIx64" reach the max retry times, set global code:%s", pParentSql->self, pSql->self, tstrerror(code));
       atomic_val_compare_exchange_32(&pParentSql->res.code, TSDB_CODE_SUCCESS, code);  // set global code and abort
     }
 
@@ -2998,7 +3015,7 @@ void tscRetrieveDataRes(void *param, TAOS_RES *tres, int code) {
 
 static bool needRetryInsert(SSqlObj* pParentObj, int32_t numOfSub) {
   if (pParentObj->retry > pParentObj->maxRetry) {
-    tscError("%p max retry reached, abort the retry effort", pParentObj);
+    tscError("0x%"PRIx64" max retry reached, abort the retry effort", pParentObj->self);
     return false;
   }
 
@@ -3090,16 +3107,17 @@ static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int numOfRows)
       }
     }
 
-    tscError("%p Async insertion completed, total inserted:%d rows, numOfFailed:%d, numOfTotal:%d", pParentObj,
+    tscError("0x%"PRIx64" Async insertion completed, total inserted:%d rows, numOfFailed:%d, numOfTotal:%d", pParentObj->self,
              pParentObj->res.numOfRows, numOfFailed, numOfSub);
 
-    tscDebug("0x%"PRIx64" cleanup %d tableMeta in hashTable", pParentObj->self, pParentObj->cmd.numOfTables);
+    tscDebug("0x%"PRIx64" cleanup %d tableMeta in hashTable before reparse sql", pParentObj->self, pParentObj->cmd.numOfTables);
     for(int32_t i = 0; i < pParentObj->cmd.numOfTables; ++i) {
       char name[TSDB_TABLE_FNAME_LEN] = {0};
       tNameExtractFullName(pParentObj->cmd.pTableNameList[i], name);
       taosHashRemove(tscTableMetaInfo, name, strnlen(name, TSDB_TABLE_FNAME_LEN));
     }
 
+    pParentObj->res.code = TSDB_CODE_SUCCESS;
     pParentObj->cmd.parseFinished = false;
 
     tscResetSqlCmd(&pParentObj->cmd, false);
@@ -3159,7 +3177,7 @@ int32_t tscHandleMultivnodeInsert(SSqlObj *pSql) {
       pSup->pSql = pSql;
 
       pSub->param = pSup;
-      tscDebug("0x%"PRIx64" sub:%p launch sub insert, orderOfSub:%d", pSql->self, pSub, i);
+      tscDebug("0x%"PRIx64" sub:0x%"PRIx64" launch sub insert, orderOfSub:%d", pSql->self, pSub->self, i);
       if (pSub->res.code != TSDB_CODE_SUCCESS) {
         tscHandleInsertRetry(pSql, pSub);
       }
@@ -3207,7 +3225,7 @@ int32_t tscHandleMultivnodeInsert(SSqlObj *pSql) {
 
     SSqlObj *pNew = createSimpleSubObj(pSql, multiVnodeInsertFinalize, pSupporter, TSDB_SQL_INSERT);
     if (pNew == NULL) {
-      tscError("%p failed to malloc buffer for subObj, orderOfSub:%d, reason:%s", pSql, numOfSub, strerror(errno));
+      tscError("0x%"PRIx64" failed to malloc buffer for subObj, orderOfSub:%d, reason:%s", pSql->self, numOfSub, strerror(errno));
       goto _error;
     }
   
@@ -3231,7 +3249,7 @@ int32_t tscHandleMultivnodeInsert(SSqlObj *pSql) {
   }
   
   if (numOfSub < pSql->subState.numOfSub) {
-    tscError("%p failed to prepare subObj structure and launch sub-insertion", pSql);
+    tscError("0x%"PRIx64" failed to prepare subObj structure and launch sub-insertion", pSql->self);
     pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
     goto _error;
   }

src/client/src/tscUtil.c

@@ -865,7 +865,7 @@ void tscFreeSqlResult(SSqlObj* pSql) {
   
   SSqlRes* pRes = &pSql->res;
   tscDestroyResPointerInfo(pRes);
-  
+
   memset(&pSql->res, 0, sizeof(SSqlRes));
 }
 
@@ -1112,7 +1112,8 @@ int32_t tscCopyDataBlockToPayload(SSqlObj* pSql, STableDataBlocks* pDataBlock) {
       tfree(pTableMetaInfo->pTableMeta);
     }
 
-    pTableMetaInfo->pTableMeta = tscTableMetaDup(pDataBlock->pTableMeta);
+    pTableMetaInfo->pTableMeta    = tscTableMetaDup(pDataBlock->pTableMeta);
+    pTableMetaInfo->tableMetaSize = tscGetTableMetaSize(pDataBlock->pTableMeta); 
   }
 
   /*
@@ -1329,67 +1330,73 @@ int32_t tscMergeTableDataBlocks(SSqlObj* pSql, bool freeBlockMap) {
 
   STableDataBlocks* pOneTableBlock = *p;
   while(pOneTableBlock) {
-    // the maximum expanded size in byte when a row-wise data is converted to SDataRow format
-    int32_t expandSize = getRowExpandSize(pOneTableBlock->pTableMeta);
-    STableDataBlocks* dataBuf = NULL;
-    
-    int32_t ret = tscGetDataBlockFromList(pVnodeDataBlockHashList, pOneTableBlock->vgId, TSDB_PAYLOAD_SIZE,
-                                INSERT_HEAD_SIZE, 0, &pOneTableBlock->tableName, pOneTableBlock->pTableMeta, &dataBuf, pVnodeDataBlockList);
-    if (ret != TSDB_CODE_SUCCESS) {
-      tscError("%p failed to prepare the data block buffer for merging table data, code:%d", pSql, ret);
-      taosHashCleanup(pVnodeDataBlockHashList);
-      tscDestroyBlockArrayList(pVnodeDataBlockList);
-      return ret;
-    }
-
     SSubmitBlk* pBlocks = (SSubmitBlk*) pOneTableBlock->pData;
-    int64_t destSize = dataBuf->size + pOneTableBlock->size + pBlocks->numOfRows * expandSize + sizeof(STColumn) * tscGetNumOfColumns(pOneTableBlock->pTableMeta);
-
-    if (dataBuf->nAllocSize < destSize) {
-      while (dataBuf->nAllocSize < destSize) {
-        dataBuf->nAllocSize = (uint32_t)(dataBuf->nAllocSize * 1.5);
-      }
-
-      char* tmp = realloc(dataBuf->pData, dataBuf->nAllocSize);
-      if (tmp != NULL) {
-        dataBuf->pData = tmp;
-        memset(dataBuf->pData + dataBuf->size, 0, dataBuf->nAllocSize - dataBuf->size);
-      } else {  // failed to allocate memory, free already allocated memory and return error code
-        tscError("%p failed to allocate memory for merging submit block, size:%d", pSql, dataBuf->nAllocSize);
-
+    if (pBlocks->numOfRows > 0) {
+      // the maximum expanded size in byte when a row-wise data is converted to SDataRow format
+      int32_t expandSize = getRowExpandSize(pOneTableBlock->pTableMeta);
+      STableDataBlocks* dataBuf = NULL;
+      
+      int32_t ret = tscGetDataBlockFromList(pVnodeDataBlockHashList, pOneTableBlock->vgId, TSDB_PAYLOAD_SIZE,
+                                  INSERT_HEAD_SIZE, 0, &pOneTableBlock->tableName, pOneTableBlock->pTableMeta, &dataBuf, pVnodeDataBlockList);
+      if (ret != TSDB_CODE_SUCCESS) {
+        tscError("0x%"PRIx64" failed to prepare the data block buffer for merging table data, code:%d", pSql->self, ret);
         taosHashCleanup(pVnodeDataBlockHashList);
         tscDestroyBlockArrayList(pVnodeDataBlockList);
-        tfree(dataBuf->pData);
-
-        return TSDB_CODE_TSC_OUT_OF_MEMORY;
+        return ret;
       }
+
+      int64_t destSize = dataBuf->size + pOneTableBlock->size + pBlocks->numOfRows * expandSize + sizeof(STColumn) * tscGetNumOfColumns(pOneTableBlock->pTableMeta);
+
+      if (dataBuf->nAllocSize < destSize) {
+        while (dataBuf->nAllocSize < destSize) {
+          dataBuf->nAllocSize = (uint32_t)(dataBuf->nAllocSize * 1.5);
+        }
+
+        char* tmp = realloc(dataBuf->pData, dataBuf->nAllocSize);
+        if (tmp != NULL) {
+          dataBuf->pData = tmp;
+          memset(dataBuf->pData + dataBuf->size, 0, dataBuf->nAllocSize - dataBuf->size);
+        } else {  // failed to allocate memory, free already allocated memory and return error code
+          tscError("0x%"PRIx64" failed to allocate memory for merging submit block, size:%d", pSql->self, dataBuf->nAllocSize);
+
+          taosHashCleanup(pVnodeDataBlockHashList);
+          tscDestroyBlockArrayList(pVnodeDataBlockList);
+          tfree(dataBuf->pData);
+
+          return TSDB_CODE_TSC_OUT_OF_MEMORY;
+        }
+      }
+
+      tscSortRemoveDataBlockDupRows(pOneTableBlock);
+      char* ekey = (char*)pBlocks->data + pOneTableBlock->rowSize*(pBlocks->numOfRows-1);
+
+      tscDebug("0x%"PRIx64" name:%s, name:%d rows:%d sversion:%d skey:%" PRId64 ", ekey:%" PRId64, pSql->self, tNameGetTableName(&pOneTableBlock->tableName),
+          pBlocks->tid, pBlocks->numOfRows, pBlocks->sversion, GET_INT64_VAL(pBlocks->data), GET_INT64_VAL(ekey));
+
+      int32_t len = pBlocks->numOfRows * (pOneTableBlock->rowSize + expandSize) + sizeof(STColumn) * tscGetNumOfColumns(pOneTableBlock->pTableMeta);
+
+      pBlocks->tid = htonl(pBlocks->tid);
+      pBlocks->uid = htobe64(pBlocks->uid);
+      pBlocks->sversion = htonl(pBlocks->sversion);
+      pBlocks->numOfRows = htons(pBlocks->numOfRows);
+      pBlocks->schemaLen = 0;
+
+      // erase the empty space reserved for binary data
+      int32_t finalLen = trimDataBlock(dataBuf->pData + dataBuf->size, pOneTableBlock, pCmd->submitSchema);
+      assert(finalLen <= len);
+
+      dataBuf->size += (finalLen + sizeof(SSubmitBlk));
+      assert(dataBuf->size <= dataBuf->nAllocSize);
+
+      // the length does not include the SSubmitBlk structure
+      pBlocks->dataLen = htonl(finalLen);
+      dataBuf->numOfTables += 1;
+
+      pBlocks->numOfRows = 0;
+    }else {
+      tscDebug("0x%"PRIx64" table %s data block is empty", pSql->self, pOneTableBlock->tableName.tname);
     }
-
-    tscSortRemoveDataBlockDupRows(pOneTableBlock);
-    char* ekey = (char*)pBlocks->data + pOneTableBlock->rowSize*(pBlocks->numOfRows-1);
-
-    tscDebug("0x%"PRIx64" name:%s, name:%d rows:%d sversion:%d skey:%" PRId64 ", ekey:%" PRId64, pSql->self, tNameGetTableName(&pOneTableBlock->tableName),
-        pBlocks->tid, pBlocks->numOfRows, pBlocks->sversion, GET_INT64_VAL(pBlocks->data), GET_INT64_VAL(ekey));
-
-    int32_t len = pBlocks->numOfRows * (pOneTableBlock->rowSize + expandSize) + sizeof(STColumn) * tscGetNumOfColumns(pOneTableBlock->pTableMeta);
-
-    pBlocks->tid = htonl(pBlocks->tid);
-    pBlocks->uid = htobe64(pBlocks->uid);
-    pBlocks->sversion = htonl(pBlocks->sversion);
-    pBlocks->numOfRows = htons(pBlocks->numOfRows);
-    pBlocks->schemaLen = 0;
-
-    // erase the empty space reserved for binary data
-    int32_t finalLen = trimDataBlock(dataBuf->pData + dataBuf->size, pOneTableBlock, pCmd->submitSchema);
-    assert(finalLen <= len);
-
-    dataBuf->size += (finalLen + sizeof(SSubmitBlk));
-    assert(dataBuf->size <= dataBuf->nAllocSize);
-
-    // the length does not include the SSubmitBlk structure
-    pBlocks->dataLen = htonl(finalLen);
-    dataBuf->numOfTables += 1;
-
+    
     p = taosHashIterate(pCmd->pTableBlockHashList, p);
     if (p == NULL) {
       break;
@@ -1511,7 +1518,7 @@ int16_t tscFieldInfoGetOffset(SQueryInfo* pQueryInfo, int32_t index) {
   return pInfo->pExpr->base.offset;
 }
 
-int32_t tscFieldInfoCompare(const SFieldInfo* pFieldInfo1, const SFieldInfo* pFieldInfo2) {
+int32_t tscFieldInfoCompare(const SFieldInfo* pFieldInfo1, const SFieldInfo* pFieldInfo2, int32_t *diffSize) {
   assert(pFieldInfo1 != NULL && pFieldInfo2 != NULL);
 
   if (pFieldInfo1->numOfOutput != pFieldInfo2->numOfOutput) {
@@ -1523,15 +1530,36 @@ int32_t tscFieldInfoCompare(const SFieldInfo* pFieldInfo1, const SFieldInfo* pFi
     TAOS_FIELD* pField2 = tscFieldInfoGetField((SFieldInfo*) pFieldInfo2, i);
 
     if (pField1->type != pField2->type ||
-        pField1->bytes != pField2->bytes ||
         strcasecmp(pField1->name, pField2->name) != 0) {
       return 1;
     }
+
+    if (pField1->bytes != pField2->bytes) {
+      *diffSize = 1;
+
+      if (pField2->bytes > pField1->bytes) {
+        pField1->bytes = pField2->bytes;
+      }
+    }
   }
 
   return 0;
 }
 
+int32_t tscFieldInfoSetSize(const SFieldInfo* pFieldInfo1, const SFieldInfo* pFieldInfo2) {
+  assert(pFieldInfo1 != NULL && pFieldInfo2 != NULL);
+
+  for (int32_t i = 0; i < pFieldInfo1->numOfOutput; ++i) {
+    TAOS_FIELD* pField1 = tscFieldInfoGetField((SFieldInfo*) pFieldInfo1, i);
+    TAOS_FIELD* pField2 = tscFieldInfoGetField((SFieldInfo*) pFieldInfo2, i);
+
+    pField2->bytes = pField1->bytes;
+  }
+
+  return 0;
+}
+
+
 int32_t tscGetResRowLength(SArray* pExprList) {
   size_t num = taosArrayGetSize(pExprList);
   if (num == 0) {
@@ -1941,7 +1969,7 @@ void tscColumnListDestroy(SArray* pColumnList) {
 static int32_t validateQuoteToken(SStrToken* pToken) {
   tscDequoteAndTrimToken(pToken);
 
-  int32_t k = tSQLGetToken(pToken->z, &pToken->type);
+  int32_t k = tGetToken(pToken->z, &pToken->type);
 
   if (pToken->type == TK_STRING) {
     return tscValidateName(pToken);
@@ -2009,7 +2037,7 @@ int32_t tscValidateName(SStrToken* pToken) {
       tscStrToLower(pToken->z, pToken->n);
       //pToken->n = (uint32_t)strtrim(pToken->z);
        
-      int len = tSQLGetToken(pToken->z, &pToken->type);
+      int len = tGetToken(pToken->z, &pToken->type);
 
       // single token, validate it
       if (len == pToken->n) {
@@ -2035,7 +2063,7 @@ int32_t tscValidateName(SStrToken* pToken) {
       pToken->n = (uint32_t)strtrim(pToken->z);
     }
 
-    pToken->n = tSQLGetToken(pToken->z, &pToken->type);
+    pToken->n = tGetToken(pToken->z, &pToken->type);
     if (pToken->z[pToken->n] != TS_PATH_DELIMITER[0]) {
       return TSDB_CODE_TSC_INVALID_SQL;
     }
@@ -2052,7 +2080,7 @@ int32_t tscValidateName(SStrToken* pToken) {
 
     pToken->z = sep + 1;
     pToken->n = (uint32_t)(oldLen - (sep - pStr) - 1);
-    int32_t len = tSQLGetToken(pToken->z, &pToken->type);
+    int32_t len = tGetToken(pToken->z, &pToken->type);
     if (len != pToken->n || (pToken->type != TK_STRING && pToken->type != TK_ID)) {
       return TSDB_CODE_TSC_INVALID_SQL;
     }
@@ -2507,6 +2535,11 @@ STableMetaInfo* tscAddTableMetaInfo(SQueryInfo* pQueryInfo, SName* name, STableM
   }
 
   pTableMetaInfo->pTableMeta = pTableMeta;
+  if (pTableMetaInfo->pTableMeta == NULL) {
+    pTableMetaInfo->tableMetaSize = 0; 
+  } else {
+    pTableMetaInfo->tableMetaSize = tscGetTableMetaSize(pTableMeta);
+  }
   
   if (vgroupList != NULL) {
     pTableMetaInfo->vgroupList = tscVgroupInfoClone(vgroupList);
@@ -2565,7 +2598,7 @@ void registerSqlObj(SSqlObj* pSql) {
 SSqlObj* createSimpleSubObj(SSqlObj* pSql, __async_cb_func_t fp, void* param, int32_t cmd) {
   SSqlObj* pNew = (SSqlObj*)calloc(1, sizeof(SSqlObj));
   if (pNew == NULL) {
-    tscError("%p new subquery failed, tableIndex:%d", pSql, 0);
+    tscError("0x%"PRIx64" new subquery failed, tableIndex:%d", pSql->self, 0);
     return NULL;
   }
 
@@ -2579,7 +2612,7 @@ SSqlObj* createSimpleSubObj(SSqlObj* pSql, __async_cb_func_t fp, void* param, in
 
   int32_t code = copyTagData(&pNew->cmd.tagData, &pSql->cmd.tagData);
   if (code != TSDB_CODE_SUCCESS) {
-    tscError("%p new subquery failed, unable to malloc tag data, tableIndex:%d", pSql, 0);
+    tscError("0x%"PRIx64" new subquery failed, unable to malloc tag data, tableIndex:%d", pSql->self, 0);
     free(pNew);
     return NULL;
   }
@@ -2655,7 +2688,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
 
   SSqlObj* pNew = (SSqlObj*)calloc(1, sizeof(SSqlObj));
   if (pNew == NULL) {
-    tscError("%p new subquery failed, tableIndex:%d", pSql, tableIndex);
+    tscError("0x%"PRIx64" new subquery failed, tableIndex:%d", pSql->self, tableIndex);
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
     return NULL;
   }
@@ -2755,7 +2788,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
   }
 
   if (tscAllocPayload(pnCmd, TSDB_DEFAULT_PAYLOAD_SIZE) != TSDB_CODE_SUCCESS) {
-    tscError("%p new subquery failed, tableIndex:%d, vgroupIndex:%d", pSql, tableIndex, pTableMetaInfo->vgroupIndex);
+    tscError("0x%"PRIx64" new subquery failed, tableIndex:%d, vgroupIndex:%d", pSql->self, tableIndex, pTableMetaInfo->vgroupIndex);
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
     goto _error;
   }
@@ -2791,6 +2824,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
 
     pFinalInfo = tscAddTableMetaInfo(pNewQueryInfo, &pTableMetaInfo->name, pTableMeta, pTableMetaInfo->vgroupList,
                                      pTableMetaInfo->tagColList, pTableMetaInfo->pVgroupTables);
+    
   } else {  // transfer the ownership of pTableMeta to the newly create sql object.
     STableMetaInfo* pPrevInfo = tscGetTableMetaInfoFromCmd(&pPrevSql->cmd, pPrevSql->cmd.clauseIndex, 0);
     if (pPrevInfo->pTableMeta && pPrevInfo->pTableMeta->tableType < 0) {
@@ -2806,7 +2840,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
 
   // this case cannot be happened
   if (pFinalInfo->pTableMeta == NULL) {
-    tscError("%p new subquery failed since no tableMeta, name:%s", pSql, tNameGetTableName(&pTableMetaInfo->name));
+    tscError("0x%"PRIx64" new subquery failed since no tableMeta, name:%s", pSql->self, tNameGetTableName(&pTableMetaInfo->name));
 
     if (pPrevSql != NULL) { // pass the previous error to client
       assert(pPrevSql->res.code != TSDB_CODE_SUCCESS);
@@ -2824,13 +2858,14 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
     assert(pFinalInfo->vgroupList != NULL);
   }
 
+  registerSqlObj(pNew);
+
   if (cmd == TSDB_SQL_SELECT) {
     size_t size = taosArrayGetSize(pNewQueryInfo->colList);
     
-    tscDebug(
-        "%p new subquery:%p, tableIndex:%d, vgroupIndex:%d, type:%d, exprInfo:%" PRIzu ", colList:%" PRIzu ","
+    tscDebug("0x%"PRIx64" new subquery:0x%"PRIx64", tableIndex:%d, vgroupIndex:%d, type:%d, exprInfo:%" PRIzu ", colList:%" PRIzu ","
         "fieldInfo:%d, name:%s, qrang:%" PRId64 " - %" PRId64 " order:%d, limit:%" PRId64,
-        pSql, pNew, tableIndex, pTableMetaInfo->vgroupIndex, pNewQueryInfo->type, tscSqlExprNumOfExprs(pNewQueryInfo),
+        pSql->self, pNew->self, tableIndex, pTableMetaInfo->vgroupIndex, pNewQueryInfo->type, tscSqlExprNumOfExprs(pNewQueryInfo),
         size, pNewQueryInfo->fieldsInfo.numOfOutput, tNameGetTableName(&pFinalInfo->name), pNewQueryInfo->window.skey,
         pNewQueryInfo->window.ekey, pNewQueryInfo->order.order, pNewQueryInfo->limit.limit);
     
@@ -2839,7 +2874,6 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
     tscDebug("0x%"PRIx64" new sub insertion: %p, vnodeIdx:%d", pSql->self, pNew, pTableMetaInfo->vgroupIndex);
   }
 
-  registerSqlObj(pNew);
   return pNew;
 
 _error:
@@ -3185,7 +3219,13 @@ void tscTryQueryNextClause(SSqlObj* pSql, __async_cb_func_t fp) {
 
   //backup the total number of result first
   int64_t num = pRes->numOfTotal + pRes->numOfClauseTotal;
+
+
+  // DON't free final since it may be recoreded and used later in APP
+  TAOS_FIELD* finalBk = pRes->final;
+  pRes->final = NULL;
   tscFreeSqlResult(pSql);
+  pRes->final = finalBk;
   
   pRes->numOfTotal = num;
   
@@ -3418,11 +3458,11 @@ CChildTableMeta* tscCreateChildMeta(STableMeta* pTableMeta) {
   return cMeta;
 }
 
-int32_t tscCreateTableMetaFromCChildMeta(STableMeta* pChild, const char* name) {
-  assert(pChild != NULL);
+int32_t tscCreateTableMetaFromCChildMeta(STableMeta* pChild, const char* name, void* buf) {
+  assert(pChild != NULL && buf != NULL);
 
-  uint32_t size = tscGetTableMetaMaxSize();
-  STableMeta* p = calloc(1, size);
+//  uint32_t size = tscGetTableMetaMaxSize();
+  STableMeta* p = buf;//calloc(1, size);
 
   taosHashGetClone(tscTableMetaInfo, pChild->sTableName, strnlen(pChild->sTableName, TSDB_TABLE_FNAME_LEN), NULL, p, -1);
   if (p->id.uid > 0) { // tableMeta exists, build child table meta and return
@@ -3434,12 +3474,12 @@ int32_t tscCreateTableMetaFromCChildMeta(STableMeta* pChild, const char* name) {
 
     memcpy(pChild->schema, p->schema, sizeof(SSchema) *total);
 
-    tfree(p);
+//    tfree(p);
     return TSDB_CODE_SUCCESS;
   } else { // super table has been removed, current tableMeta is also expired. remove it here
     taosHashRemove(tscTableMetaInfo, name, strnlen(name, TSDB_TABLE_FNAME_LEN));
 
-    tfree(p);
+//    tfree(p);
     return -1;
   }
 }

src/client/tests/timeParseTest.cpp

@@ -4,7 +4,7 @@
 #include <iostream>
 
 #include "taos.h"
-#include "tstoken.h"
+#include "ttoken.h"
 #include "tutil.h"
 
 int main(int argc, char** argv) {

src/common/inc/tcmdtype.h

@@ -83,6 +83,7 @@ enum {
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_TABLE_JOIN_RETRIEVE, "join-retrieve" )
 
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_SHOW_CREATE_TABLE, "show-create-table")
+  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_SHOW_CREATE_STABLE, "show-create-stable")
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_SHOW_CREATE_DATABASE, "show-create-database")
 
   /*

src/common/inc/tdataformat.h

@@ -15,10 +15,7 @@
 #ifndef _TD_DATA_FORMAT_H_
 #define _TD_DATA_FORMAT_H_
 
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-
+#include "os.h"
 #include "talgo.h"
 #include "ttype.h"
 #include "tutil.h"

src/common/inc/texpr.h

@@ -89,9 +89,6 @@ tExprNode* exprdup(tExprNode* pTree);
 
 bool exprTreeApplyFilter(tExprNode *pExpr, const void *pItem, SExprTraverseSupp *param);
 
-typedef void (*_arithmetic_operator_fn_t)(void *left, int32_t numLeft, int32_t leftType, void *right, int32_t numRight,
-                                          int32_t rightType, void *output, int32_t order);
-
 void arithmeticTreeTraverse(tExprNode *pExprs, int32_t numOfRows, char *pOutput, void *param, int32_t order,
                             char *(*cb)(void *, const char*, int32_t));
 

src/common/inc/tglobal.h

@@ -44,6 +44,7 @@ extern int32_t  tsDnodeId;
 // common
 extern int      tsRpcTimer;
 extern int      tsRpcMaxTime;
+extern int      tsRpcForceTcp; // all commands go to tcp protocol if this is enabled
 extern int32_t  tsMaxConnections;
 extern int32_t  tsMaxShellConns;
 extern int32_t  tsShellActivityTimer;

src/common/inc/tname.h

@@ -18,7 +18,7 @@
 
 #include "os.h"
 #include "taosmsg.h"
-#include "tstoken.h"
+#include "ttoken.h"
 #include "tvariant.h"
 
 typedef struct SDataStatis {

src/common/inc/tvariant.h

@@ -16,8 +16,8 @@
 #ifndef TDENGINE_TVARIANT_H
 #define TDENGINE_TVARIANT_H
 
-#include "tstoken.h"
 #include "tarray.h"
+#include "ttoken.h"
 
 #ifdef __cplusplus
 extern "C" {

src/common/src/tglobal.c

@@ -48,6 +48,7 @@ int32_t  tsDnodeId = 0;
 // common
 int32_t tsRpcTimer       = 1000;
 int32_t tsRpcMaxTime     = 600;  // seconds;
+int32_t tsRpcForceTcp    = 0;  //disable this, means query, show command use udp protocol as default
 int32_t tsMaxShellConns  = 50000;
 int32_t tsMaxConnections = 5000;
 int32_t tsShellActivityTimer  = 3;  // second
@@ -139,7 +140,7 @@ int32_t tsTableIncStepPerVnode = TSDB_TABLES_STEP;
 int8_t  tsEnableBalance = 1;
 int8_t  tsAlternativeRole = 0;
 int32_t tsBalanceInterval = 300;           // seconds
-int32_t tsOfflineThreshold = 86400 * 100;  // seconds 100 days
+int32_t tsOfflineThreshold = 86400 * 10;  // seconds of 10 days
 int32_t tsMnodeEqualVnodeNum = 4;
 int8_t  tsEnableFlowCtrl = 1;
 int8_t  tsEnableSlaveQuery = 1;
@@ -625,6 +626,16 @@ static void doInitGlobalConfig(void) {
   cfg.unitType = TAOS_CFG_UTYPE_MS;
   taosInitConfigOption(cfg);
 
+  cfg.option = "rpcForceTcp";
+  cfg.ptr = &tsRpcForceTcp;
+  cfg.valType = TAOS_CFG_VTYPE_INT32;
+  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_CLIENT;
+  cfg.minValue = 0;
+  cfg.maxValue = 1;
+  cfg.ptrLength = 0;
+  cfg.unitType = TAOS_CFG_UTYPE_NONE;
+  taosInitConfigOption(cfg);
+
   cfg.option = "rpcMaxTime";
   cfg.ptr = &tsRpcMaxTime;
   cfg.valType = TAOS_CFG_VTYPE_INT32;
@@ -921,7 +932,7 @@ static void doInitGlobalConfig(void) {
   cfg.valType = TAOS_CFG_VTYPE_INT32;
   cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_CLIENT | TSDB_CFG_CTYPE_B_SHOW;
   cfg.minValue = -1;
-  cfg.maxValue = 10000000;
+  cfg.maxValue = 100000000.0f;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
   taosInitConfigOption(cfg);

src/common/src/tname.c

@@ -2,7 +2,7 @@
 #include "tutil.h"
 
 #include "tname.h"
-#include "tstoken.h"
+#include "ttoken.h"
 #include "tvariant.h"
 
 #define VALIDNUMOFCOLS(x)  ((x) >= TSDB_MIN_COLUMNS && (x) <= TSDB_MAX_COLUMNS)

src/common/src/tvariant.c

@@ -14,14 +14,14 @@
  */
 #include "os.h"
 
-#include "tvariant.h"
 #include "hash.h"
 #include "taos.h"
 #include "taosdef.h"
-#include "tstoken.h"
+#include "ttoken.h"
 #include "ttokendef.h"
-#include "tutil.h"
 #include "ttype.h"
+#include "tutil.h"
+#include "tvariant.h"
 
 void tVariantCreate(tVariant *pVar, SStrToken *token) {
   int32_t ret = 0;
@@ -49,7 +49,7 @@ void tVariantCreate(tVariant *pVar, SStrToken *token) {
       ret = tStrToInteger(token->z, token->type, token->n, &pVar->i64, true);
       if (ret != 0) {
         SStrToken t = {0};
-        tSQLGetToken(token->z, &t.type);
+        tGetToken(token->z, &t.type);
         if (t.type == TK_MINUS) {  // it is a signed number which is greater than INT64_MAX or less than INT64_MIN
           pVar->nType = -1;   // -1 means error type
           return;
@@ -460,7 +460,7 @@ static FORCE_INLINE int32_t convertToInteger(tVariant *pVariant, int64_t *result
     *result = (int64_t) pVariant->dKey;
   } else if (pVariant->nType == TSDB_DATA_TYPE_BINARY) {
     SStrToken token = {.z = pVariant->pz, .n = pVariant->nLen};
-    /*int32_t n = */tSQLGetToken(pVariant->pz, &token.type);
+    /*int32_t n = */tGetToken(pVariant->pz, &token.type);
 
     if (token.type == TK_NULL) {
       if (releaseVariantPtr) {
@@ -495,10 +495,10 @@ static FORCE_INLINE int32_t convertToInteger(tVariant *pVariant, int64_t *result
     wchar_t *endPtr = NULL;
     
     SStrToken token = {0};
-    token.n = tSQLGetToken(pVariant->pz, &token.type);
+    token.n = tGetToken(pVariant->pz, &token.type);
     
     if (token.type == TK_MINUS || token.type == TK_PLUS) {
-      token.n = tSQLGetToken(pVariant->pz + token.n, &token.type);
+      token.n = tGetToken(pVariant->pz + token.n, &token.type);
     }
     
     if (token.type == TK_FLOAT) {

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.28-dist.jar ${LIBRARY_OUTPUT_PATH}
+    COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/target/taos-jdbcdriver-2.0.29.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})

src/connector/jdbc/deploy-pom.xml

@@ -5,7 +5,7 @@
 
   <groupId>com.taosdata.jdbc</groupId>
   <artifactId>taos-jdbcdriver</artifactId>
-  <version>2.0.28</version>
+  <version>2.0.29</version>
   <packaging>jar</packaging>
 
   <name>JDBCDriver</name>

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.28</version>
+    <version>2.0.29</version>
     <packaging>jar</packaging>
     <name>JDBCDriver</name>
     <url>https://github.com/taosdata/TDengine/tree/master/src/connector/jdbc</url>

src/connector/jdbc/src/main/java/com/taosdata/jdbc/AbstractResultSet.java

@@ -84,10 +84,12 @@ public abstract class AbstractResultSet extends WrapperImpl implements ResultSet
     }
 
     @Override
+    @Deprecated
     public InputStream getUnicodeStream(int columnIndex) throws SQLException {
-        if (isClosed())
+        if (isClosed()) {
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_RESULTSET_CLOSED);
-
+        }
+        
         throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
     }
 
@@ -171,6 +173,7 @@ public abstract class AbstractResultSet extends WrapperImpl implements ResultSet
     }
 
     @Override
+    @Deprecated
     public InputStream getUnicodeStream(String columnLabel) throws SQLException {
         return getUnicodeStream(findColumn(columnLabel));
     }

src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBConnection.java

@@ -49,7 +49,7 @@ public class TSDBConnection extends AbstractConnection {
         this.databaseMetaData.setConnection(this);
     }
 
-    public TSDBJNIConnector getConnection() {
+    public TSDBJNIConnector getConnector() {
         return this.connector;
     }
 
@@ -58,7 +58,7 @@ public class TSDBConnection extends AbstractConnection {
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_CONNECTION_CLOSED);
         }
 
-        return new TSDBStatement(this, this.connector);
+        return new TSDBStatement(this);
     }
 
     public TSDBSubscribe subscribe(String topic, String sql, boolean restart) throws SQLException {
@@ -74,14 +74,18 @@ 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);
+        }
+        
+        return new TSDBPreparedStatement(this, sql);
     }
 
     public void close() throws SQLException {
-        if (isClosed)
+        if (isClosed) {
             return;
+        }
+        
         this.connector.closeConnection();
         this.isClosed = true;
     }

src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java

@@ -104,7 +104,7 @@ public class TSDBDriver extends AbstractDriver {
 
     static {
         try {
-            java.sql.DriverManager.registerDriver(new TSDBDriver());
+            DriverManager.registerDriver(new TSDBDriver());
         } catch (SQLException e) {
             throw TSDBError.createRuntimeException(TSDBErrorNumbers.ERROR_CANNOT_REGISTER_JNI_DRIVER, e);
         }

src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java

@@ -18,6 +18,7 @@ package com.taosdata.jdbc;
 
 import com.taosdata.jdbc.utils.TaosInfo;
 
+import java.nio.ByteBuffer;
 import java.sql.SQLException;
 import java.sql.SQLWarning;
 import java.util.List;
@@ -29,10 +30,13 @@ 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 boolean isResultsetClosed;
+
     private int affectedRows = -1;
 
     static {
@@ -75,7 +79,6 @@ public class TSDBJNIConnector {
 
     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);
             closeConnection();
             this.taos = TSDBConstants.JNI_NULL_POINTER;
         }
@@ -97,12 +100,6 @@ public class TSDBJNIConnector {
      * @throws SQLException
      */
     public long executeQuery(String sql) throws SQLException {
-        // close previous result set if the user forgets to invoke the
-        // free method to close previous result set.
-//        if (!this.isResultsetClosed) {
-//            freeResultSet(taosResultSetPointer);
-//        }
-
         Long pSql = 0l;
         try {
             pSql = this.executeQueryImp(sql.getBytes(TaosGlobalConfig.getCharset()), this.taos);
@@ -135,6 +132,7 @@ public class TSDBJNIConnector {
 
         // Try retrieving result set for the executed SQL using the current connection pointer. 
         pSql = this.getResultSetImp(this.taos, pSql);
+        // if pSql == 0L that means resultset is closed
         isResultsetClosed = (pSql == TSDBConstants.JNI_NULL_POINTER);
 
         return pSql;
@@ -169,37 +167,14 @@ public class TSDBJNIConnector {
     private native long isUpdateQueryImp(long connection, long pSql);
 
     /**
-     * Free resultset operation from C to release resultset pointer by JNI
+     * Free result set operation from C to release result set pointer by JNI
      */
     public int freeResultSet(long pSql) {
-        int res = TSDBConstants.JNI_SUCCESS;
-//        if (result != taosResultSetPointer && taosResultSetPointer != TSDBConstants.JNI_NULL_POINTER) {
-//            throw new RuntimeException("Invalid result set pointer");
-//        }
-
-//        if (taosResultSetPointer != TSDBConstants.JNI_NULL_POINTER) {
-        res = this.freeResultSetImp(this.taos, pSql);
-//            taosResultSetPointer = TSDBConstants.JNI_NULL_POINTER;
-//        }
-
+        int res = this.freeResultSetImp(this.taos, pSql);
         isResultsetClosed = true;
         return res;
     }
 
-    /**
-     * Close the open result set which is associated to the current connection. If the result set is already
-     * closed, return 0 for success.
-     */
-//    public int freeResultSet() {
-//        int resCode = TSDBConstants.JNI_SUCCESS;
-//        if (!isResultsetClosed) {
-//            resCode = this.freeResultSetImp(this.taos, this.taosResultSetPointer);
-//            taosResultSetPointer = TSDBConstants.JNI_NULL_POINTER;
-//            isResultsetClosed = true;
-//        }
-//        return resCode;
-//    }
-
     private native int freeResultSetImp(long connection, long result);
 
     /**
@@ -246,6 +221,7 @@ public class TSDBJNIConnector {
      */
     public void closeConnection() throws SQLException {
         int code = this.closeConnectionImp(this.taos);
+        
         if (code < 0) {
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL);
         } else if (code == 0) {
@@ -253,6 +229,7 @@ public class TSDBJNIConnector {
         } else {
             throw new SQLException("Undefined error code returned by TDengine when closing a connection");
         }
+        
         // invoke closeConnectionImpl only here
         taosInfo.connect_close_increment();
     }
@@ -289,7 +266,7 @@ public class TSDBJNIConnector {
     private native void unsubscribeImp(long subscription, boolean isKeep);
 
     /**
-     * Validate if a <I>create table</I> sql statement is correct without actually creating that table
+     * Validate if a <I>create table</I> SQL statement is correct without actually creating that table
      */
     public boolean validateCreateTableSql(String sql) {
         int res = validateCreateTableSqlImp(taos, sql.getBytes());
@@ -297,4 +274,66 @@ public class TSDBJNIConnector {
     }
 
     private native int validateCreateTableSqlImp(long connection, byte[] sqlBytes);
+    
+	public long prepareStmt(String sql) throws SQLException {
+    	Long stmt = 0L;
+    	try {
+    	stmt = prepareStmtImp(sql.getBytes(), this.taos);
+    	} catch (Exception e) {
+            e.printStackTrace();
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_ENCODING);
+        }
+    	
+        if (stmt == TSDBConstants.JNI_CONNECTION_NULL) {
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL);
+        }
+        
+        if (stmt == TSDBConstants.JNI_SQL_NULL) {
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_SQL_NULL);
+        }
+        
+        if (stmt == TSDBConstants.JNI_OUT_OF_MEMORY) {
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_OUT_OF_MEMORY);
+        }
+        
+    	return stmt;
+    }
+    
+    private native long prepareStmtImp(byte[] sql, long con);
+    
+    public void setBindTableName(long stmt, String tableName) throws SQLException {
+		int code = setBindTableNameImp(stmt, tableName, this.taos);
+		if (code != TSDBConstants.JNI_SUCCESS) {
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN, "failed to set table name");
+		}
+	}
+    
+    private native int setBindTableNameImp(long stmt, String name, long conn);
+    
+    public void bindColumnDataArray(long stmt, ByteBuffer colDataList, ByteBuffer lengthList, ByteBuffer isNullList, int type, int bytes, int numOfRows,int columnIndex) throws SQLException {
+    	int code = bindColDataImp(stmt, colDataList.array(), lengthList.array(), isNullList.array(), type, bytes, numOfRows, columnIndex, this.taos);
+    	if (code != TSDBConstants.JNI_SUCCESS) {
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN, "failed to bind column data");
+    	}
+	}
+    
+    private native int bindColDataImp(long stmt, byte[] colDataList, byte[] lengthList, byte[] isNullList, int type, int bytes, int numOfRows, int columnIndex, long conn);
+    
+    public void executeBatch(long stmt) throws SQLException {
+    	int code = executeBatchImp(stmt, this.taos);
+    	if (code != TSDBConstants.JNI_SUCCESS) {
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN, "failed to execute batch bind");
+    	}
+    }
+    
+    private native int executeBatchImp(long stmt, long con);
+    
+    public void closeBatch(long stmt) throws SQLException {
+    	int code = closeStmt(stmt, this.taos);
+    	if (code != TSDBConstants.JNI_SUCCESS) {
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN, "failed to close batch bind");
+    	}
+    }
+    
+    private native int closeStmt(long stmt, long con);
 }

src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBPreparedStatement.java

@@ -14,36 +14,44 @@
  *****************************************************************************/
 package com.taosdata.jdbc;
 
+import com.taosdata.jdbc.utils.Utils;
+
 import java.io.InputStream;
 import java.io.Reader;
+import java.io.UnsupportedEncodingException;
 import java.math.BigDecimal;
 import java.net.URL;
-import java.nio.charset.Charset;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 import java.sql.*;
 import java.util.ArrayList;
 import java.util.Calendar;
+import java.util.Collections;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 /*
- * TDengine only supports a subset of the standard SQL, thus this implemetation of the
+ * TDengine only supports a subset of the standard SQL, thus this implementation of the
  * standard JDBC API contains more or less some adjustments customized for certain
  * compatibility needs.
  */
 public class TSDBPreparedStatement extends TSDBStatement implements PreparedStatement {
-
     private String rawSql;
     private Object[] parameters;
     private boolean isPrepared;
-
+    
+    private ArrayList<ColumnInfo> colData;
+    private String tableName;
+    private long nativeStmtHandle = 0;
+    
     private volatile TSDBParameterMetaData parameterMetaData;
 
-    TSDBPreparedStatement(TSDBConnection connection, TSDBJNIConnector connecter, String sql) {
-        super(connection, connecter);
+    TSDBPreparedStatement(TSDBConnection connection, String sql) {
+		super(connection);
         init(sql);
 
+        int parameterCnt = 0;
         if (sql.contains("?")) {
-            int parameterCnt = 0;
             for (int i = 0; i < sql.length(); i++) {
                 if ('?' == sql.charAt(i)) {
                     parameterCnt++;
@@ -52,6 +60,12 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
             parameters = new Object[parameterCnt];
             this.isPrepared = true;
         }
+
+		if (parameterCnt > 1) {
+	        // the table name is also a parameter, so ignore it.
+	        this.colData = new ArrayList<ColumnInfo>(parameterCnt - 1);
+	        this.colData.addAll(Collections.nCopies(parameterCnt - 1, null));
+		}
     }
 
     private void init(String sql) {
@@ -126,28 +140,7 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
      * @return a string of the native sql statement for TSDB
      */
     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;
-                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);
-            } else {
-                sql = sql.replaceFirst("[?]", "NULL");
-            }
-        }
-        clearParameters();
-        return sql;
+        return Utils.getNativeSql(rawSql, this.parameters);
     }
 
     @Override
@@ -275,15 +268,19 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
     public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
         if (isClosed())
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
-        setObject(parameterIndex,x);
+        setObject(parameterIndex, x);
     }
 
     @Override
     public void setObject(int parameterIndex, Object x) throws SQLException {
-        if (isClosed())
+        if (isClosed()) {
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
-        if (parameterIndex < 1 && parameterIndex >= parameters.length)
+        }
+        
+        if (parameterIndex < 1 && parameterIndex >= parameters.length) {
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_PARAMETER_INDEX_OUT_RANGE);
+        }
+        
         parameters[parameterIndex - 1] = x;
     }
 
@@ -320,9 +317,10 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
 
     @Override
     public void setRef(int parameterIndex, Ref x) throws SQLException {
-        if (isClosed())
+        if (isClosed()) {
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
-
+        }
+        
         throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
     }
 
@@ -535,4 +533,276 @@ public class TSDBPreparedStatement extends TSDBStatement implements PreparedStat
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
         throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNSUPPORTED_METHOD);
     }
+    
+    ///////////////////////////////////////////////////////////////////////
+    // NOTE: the following APIs are not JDBC compatible
+    // set the bind table name
+    private static class ColumnInfo {
+    	@SuppressWarnings("rawtypes")
+		private ArrayList data;
+    	private int       type;
+    	private int       bytes;
+    	private boolean   typeIsSet;
+    	
+    	public ColumnInfo() {
+    		this.typeIsSet = false;
+    	}
+    	
+    	public void setType(int type) throws SQLException {
+    		if (this.isTypeSet()) {
+                throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN, "column data type has been set");
+    		}
+
+    		this.typeIsSet = true;
+    		this.type = type;
+    	}
+    	
+    	public boolean isTypeSet() {
+    		return this.typeIsSet;
+    	}
+    };
+    
+    public void setTableName(String name) {
+    	this.tableName = name;
+    }
+    
+    public <T> void setValueImpl(int columnIndex, ArrayList<T> list, int type, int bytes) throws SQLException {
+    	ColumnInfo col = (ColumnInfo) this.colData.get(columnIndex);
+    	if (col == null) {
+    		ColumnInfo p = new ColumnInfo();
+    		p.setType(type);
+    		p.bytes = bytes;
+    		p.data = (ArrayList<?>) list.clone();
+    		this.colData.set(columnIndex, p);
+    	} else {
+    		if (col.type != type) {
+                throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN, "column data type mismatch");
+    		}
+    		col.data.addAll(list);
+    	}
+    }
+    
+    public void setInt(int columnIndex, ArrayList<Integer> list) throws SQLException {
+    	setValueImpl(columnIndex, list, TSDBConstants.TSDB_DATA_TYPE_INT, Integer.BYTES);
+    }
+    
+    public void setFloat(int columnIndex, ArrayList<Float> list) throws SQLException {
+    	setValueImpl(columnIndex, list, TSDBConstants.TSDB_DATA_TYPE_FLOAT, Float.BYTES);
+    }
+    
+    public void setTimestamp(int columnIndex, ArrayList<Long> list) throws SQLException {
+    	setValueImpl(columnIndex, list, TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP, Long.BYTES);
+    }
+    
+    public void setLong(int columnIndex, ArrayList<Long> list) throws SQLException {
+    	setValueImpl(columnIndex, list, TSDBConstants.TSDB_DATA_TYPE_BIGINT, Long.BYTES);
+    }
+    
+    public void setDouble(int columnIndex, ArrayList<Double> list) throws SQLException {
+    	setValueImpl(columnIndex, list, TSDBConstants.TSDB_DATA_TYPE_DOUBLE, Double.BYTES);
+    }
+    
+    public void setBoolean(int columnIndex, ArrayList<Boolean> list) throws SQLException {
+    	setValueImpl(columnIndex, list, TSDBConstants.TSDB_DATA_TYPE_BOOL, Byte.BYTES);
+    }
+    
+    public void setByte(int columnIndex, ArrayList<Byte> list) throws SQLException {
+    	setValueImpl(columnIndex, list, TSDBConstants.TSDB_DATA_TYPE_TINYINT, Byte.BYTES);
+    }
+    
+    public void setShort(int columnIndex, ArrayList<Short> list) throws SQLException {
+    	setValueImpl(columnIndex, list, TSDBConstants.TSDB_DATA_TYPE_SMALLINT, Short.BYTES);
+    }
+    
+    public void setString(int columnIndex, ArrayList<String> list, int size) throws SQLException {
+    	setValueImpl(columnIndex, list, TSDBConstants.TSDB_DATA_TYPE_BINARY, size);
+    }
+    
+    // note: expand the required space for each NChar character
+    public void setNString(int columnIndex, ArrayList<String> list, int size) throws SQLException {
+    	setValueImpl(columnIndex, list, TSDBConstants.TSDB_DATA_TYPE_NCHAR, size * Integer.BYTES);
+    }
+    
+    public void columnDataAddBatch() throws SQLException {
+    	// pass the data block to native code
+		if (rawSql == null) {
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN, "sql statement not set yet");
+		}
+		
+		// table name is not set yet, abort
+		if (this.tableName == null) {
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN, "table name not set yet");
+		}
+		
+		int numOfCols = this.colData.size();
+		if (numOfCols == 0) {
+			throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN, "column data not bind");
+		}
+		
+		TSDBJNIConnector connector = ((TSDBConnection) this.getConnection()).getConnector();
+		this.nativeStmtHandle = connector.prepareStmt(rawSql);
+		connector.setBindTableName(this.nativeStmtHandle, this.tableName);
+		
+		ColumnInfo colInfo = (ColumnInfo) this.colData.get(0);
+		if (colInfo == null) {
+			throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN, "column data not bind");
+		}
+		
+		int rows = colInfo.data.size();
+		for (int i = 0; i < numOfCols; ++i) {
+			ColumnInfo col1 = this.colData.get(i);
+			if (col1 == null || !col1.isTypeSet()) {
+                throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN, "column data not bind");
+			}
+			
+			if (rows != col1.data.size()) {
+                throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN, "the rows in column data not identical");
+			}
+			
+			ByteBuffer colDataList = ByteBuffer.allocate(rows * col1.bytes);
+			colDataList.order(ByteOrder.LITTLE_ENDIAN);
+			
+            ByteBuffer lengthList = ByteBuffer.allocate(rows * Integer.BYTES);
+            lengthList.order(ByteOrder.LITTLE_ENDIAN);
+            
+            ByteBuffer isNullList = ByteBuffer.allocate(rows * Byte.BYTES);
+            isNullList.order(ByteOrder.LITTLE_ENDIAN);
+            
+			switch (col1.type) {
+				case TSDBConstants.TSDB_DATA_TYPE_INT: {
+					for (int j = 0; j < rows; ++j) {
+						Integer val = (Integer) col1.data.get(j);
+						colDataList.putInt(val == null? Integer.MIN_VALUE:val);						
+						isNullList.put((byte) (val == null? 1:0));
+					}
+					break;
+				}
+				
+				case TSDBConstants.TSDB_DATA_TYPE_TINYINT: {
+					for (int j = 0; j < rows; ++j) {
+						Byte val = (Byte) col1.data.get(j);
+						colDataList.put(val == null? 0:val);
+						isNullList.put((byte) (val == null? 1:0));
+					}
+					break;
+				}
+				
+				case TSDBConstants.TSDB_DATA_TYPE_BOOL: {
+					for (int j = 0; j < rows; ++j) {
+						Boolean val = (Boolean) col1.data.get(j);
+						if (val == null) {
+							colDataList.put((byte) 0);
+						} else {
+							colDataList.put((byte) (val? 1:0));
+						}
+						
+						isNullList.put((byte) (val == null? 1:0));
+					}
+					break;
+				}
+				
+				case TSDBConstants.TSDB_DATA_TYPE_SMALLINT: {
+					for (int j = 0; j < rows; ++j) {
+						Short val = (Short) col1.data.get(j);
+						colDataList.putShort(val == null? 0:val);
+						isNullList.put((byte) (val == null? 1:0));
+					}
+					break;
+				}
+				
+				case TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP:
+				case TSDBConstants.TSDB_DATA_TYPE_BIGINT: {
+					for (int j = 0; j < rows; ++j) {
+						Long val = (Long) col1.data.get(j);
+						colDataList.putLong(val == null? 0:val);
+						isNullList.put((byte) (val == null? 1:0));
+					}
+					break;
+				}
+				
+				case TSDBConstants.TSDB_DATA_TYPE_FLOAT: {
+					for (int j = 0; j < rows; ++j) {
+						Float val = (Float) col1.data.get(j);
+						colDataList.putFloat(val == null? 0:val);
+						isNullList.put((byte) (val == null? 1:0));
+					}
+					break;
+				}
+	
+				case TSDBConstants.TSDB_DATA_TYPE_DOUBLE: {
+					for (int j = 0; j < rows; ++j) {
+						Double val = (Double) col1.data.get(j);
+						colDataList.putDouble(val == null? 0:val);
+						isNullList.put((byte) (val == null? 1:0));
+					}
+					break;
+				}
+				
+				case TSDBConstants.TSDB_DATA_TYPE_NCHAR: 
+				case TSDBConstants.TSDB_DATA_TYPE_BINARY: {
+					String charset = TaosGlobalConfig.getCharset();
+					for (int j = 0; j < rows; ++j) {
+						String val = (String) col1.data.get(j);
+
+						colDataList.position(j * col1.bytes);  // seek to the correct position
+						if (val != null) {
+							byte[] b = null;
+							try {
+								if (col1.type == TSDBConstants.TSDB_DATA_TYPE_BINARY) {
+									b = val.getBytes();
+								} else {
+									b = val.getBytes(charset);
+								}
+							} catch (UnsupportedEncodingException e) {
+								e.printStackTrace();
+							}
+							
+							if (val.length() > col1.bytes) {
+				                throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN, "string data too long");
+							}
+							
+							colDataList.put(b);
+							lengthList.putInt(b.length);
+							isNullList.put((byte) 0);
+						} else {
+							lengthList.putInt(0);
+							isNullList.put((byte) 1);
+						}
+					}
+					break;
+				}
+				
+				case TSDBConstants.TSDB_DATA_TYPE_UTINYINT:
+				case TSDBConstants.TSDB_DATA_TYPE_USMALLINT:
+				case TSDBConstants.TSDB_DATA_TYPE_UINT:
+				case TSDBConstants.TSDB_DATA_TYPE_UBIGINT: {
+	                throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_UNKNOWN, "not support data types");
+				}
+			};
+			
+			connector.bindColumnDataArray(this.nativeStmtHandle, colDataList, lengthList, isNullList, col1.type, col1.bytes, rows, i);
+		}
+    }
+    
+	public void columnDataExecuteBatch() throws SQLException {
+		TSDBJNIConnector connector = ((TSDBConnection) this.getConnection()).getConnector();
+		connector.executeBatch(this.nativeStmtHandle);
+		this.columnDataClearBatch();
+	}
+    
+    public void columnDataClearBatch() {
+    	int size = this.colData.size();
+    	this.colData.clear();
+    	
+        this.colData.addAll(Collections.nCopies(size, null));
+        this.tableName = null;   // clear the table name
+    }
+    
+    public void columnDataCloseBatch() throws SQLException {
+		TSDBJNIConnector connector = ((TSDBConnection) this.getConnection()).getConnector();
+		connector.closeBatch(this.nativeStmtHandle);
+		
+		this.nativeStmtHandle = 0L;
+		this.tableName = null;
+    }
 }

src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSet.java

@@ -109,6 +109,8 @@ public class TSDBResultSet extends AbstractResultSet implements ResultSet {
     public void close() throws SQLException {
         if (isClosed)
             return;
+        if (this.statement == null)
+            return;
         if (this.jniConnector != null) {
             int code = this.jniConnector.freeResultSet(this.resultSetPointer);
             if (code == TSDBConstants.JNI_CONNECTION_NULL) {
@@ -461,12 +463,13 @@ public class TSDBResultSet extends AbstractResultSet implements ResultSet {
     }
 
     public boolean isClosed() throws SQLException {
-        if (isClosed)
-            return true;
-        if (jniConnector != null) {
-            isClosed = jniConnector.isResultsetClosed();
-        }
         return isClosed;
+//        if (isClosed)
+//            return true;
+//        if (jniConnector != null) {
+//            isClosed = jniConnector.isResultsetClosed();
+//        }
+//        return isClosed;
     }
 
     public String getNString(int columnIndex) throws SQLException {

src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetBlockData.java

@@ -29,6 +29,8 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
+import com.taosdata.jdbc.utils.NullType;
+
 public class TSDBResultSetBlockData {
     private int numOfRows = 0;
     private int rowIndex = 0;
@@ -164,59 +166,7 @@ public class TSDBResultSetBlockData {
         }
     }
 
-    private static class NullType {
-        private static final byte NULL_BOOL_VAL = 0x2;
-        private static final String NULL_STR = "null";
-
-        public String toString() {
-            return NullType.NULL_STR;
-        }
-
-        public static boolean isBooleanNull(byte val) {
-            return val == NullType.NULL_BOOL_VAL;
-        }
-
-        private static boolean isTinyIntNull(byte val) {
-            return val == Byte.MIN_VALUE;
-        }
-
-        private static boolean isSmallIntNull(short val) {
-            return val == Short.MIN_VALUE;
-        }
-
-        private static boolean isIntNull(int val) {
-            return val == Integer.MIN_VALUE;
-        }
-
-        private static boolean isBigIntNull(long val) {
-            return val == Long.MIN_VALUE;
-        }
-
-        private static boolean isFloatNull(float val) {
-            return Float.isNaN(val);
-        }
-
-        private static boolean isDoubleNull(double val) {
-            return Double.isNaN(val);
-        }
-
-        private static boolean isBinaryNull(byte[] val, int length) {
-            if (length != Byte.BYTES) {
-                return false;
-            }
-
-            return val[0] == 0xFF;
-        }
-
-        private static boolean isNcharNull(byte[] val, int length) {
-            if (length != Integer.BYTES) {
-                return false;
-            }
-
-            return (val[0] & val[1] & val[2] & val[3]) == 0xFF;
-        }
-
-    }
+    
 
     /**
      * The original type may not be a string type, but will be converted to by
@@ -488,8 +438,8 @@ public class TSDBResultSetBlockData {
                 }
 
                 try {
-                    String ss = TaosGlobalConfig.getCharset();
-                    return new String(dest, ss);
+                    String charset = TaosGlobalConfig.getCharset();
+                    return new String(dest, charset);
                 } catch (UnsupportedEncodingException e) {
                     e.printStackTrace();
                 }

src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetRowData.java

@@ -84,7 +84,8 @@ public class TSDBResultSetRowData {
         data.set(col, value);
     }
 
-    public int getInt(int col, int srcType) throws SQLException {
+    @SuppressWarnings("deprecation")
+	public int getInt(int col, int srcType) throws SQLException {
         Object obj = data.get(col);
 
         switch (srcType) {
@@ -128,7 +129,7 @@ public class TSDBResultSetRowData {
                 long value = (long) obj;
                 if (value < 0)
                     throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_NUMERIC_VALUE_OUT_OF_RANGE);
-                return new Long(value).intValue();
+                return Long.valueOf(value).intValue();
             }
         }
 

src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBStatement.java

@@ -19,8 +19,6 @@ import java.sql.ResultSet;
 import java.sql.SQLException;
 
 public class TSDBStatement extends AbstractStatement {
-
-    private TSDBJNIConnector connector;
     /**
      * Status of current statement
      */
@@ -29,29 +27,26 @@ public class TSDBStatement extends AbstractStatement {
     private TSDBConnection connection;
     private TSDBResultSet resultSet;
 
-    public void setConnection(TSDBConnection connection) {
+    TSDBStatement(TSDBConnection connection) {
         this.connection = connection;
     }
 
-    TSDBStatement(TSDBConnection connection, TSDBJNIConnector connector) {
-        this.connection = connection;
-        this.connector = connector;
-    }
-
     public ResultSet executeQuery(String sql) throws SQLException {
         // check if closed
-        if (isClosed())
+        if (isClosed()) {
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
+        }
+        
         //TODO: 如果在executeQuery方法中执行insert语句，那么先执行了SQL，再通过pSql来检查是否为一个insert语句，但这个insert SQL已经执行成功了
 
         // execute query
-        long pSql = this.connector.executeQuery(sql);
+        long pSql = this.connection.getConnector().executeQuery(sql);
         // if pSql is create/insert/update/delete/alter SQL
-        if (this.connector.isUpdateQuery(pSql)) {
-            this.connector.freeResultSet(pSql);
+        if (this.connection.getConnector().isUpdateQuery(pSql)) {
+            this.connection.getConnector().freeResultSet(pSql);
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_WITH_EXECUTEQUERY);
         }
-        TSDBResultSet res = new TSDBResultSet(this, this.connector, pSql);
+        TSDBResultSet res = new TSDBResultSet(this, this.connection.getConnector(), pSql);
         res.setBatchFetch(this.connection.getBatchFetch());
         return res;
     }
@@ -60,14 +55,14 @@ public class TSDBStatement extends AbstractStatement {
         if (isClosed())
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
 
-        long pSql = this.connector.executeQuery(sql);
+        long pSql = this.connection.getConnector().executeQuery(sql);
         // if pSql is create/insert/update/delete/alter SQL
-        if (!this.connector.isUpdateQuery(pSql)) {
-            this.connector.freeResultSet(pSql);
+        if (!this.connection.getConnector().isUpdateQuery(pSql)) {
+            this.connection.getConnector().freeResultSet(pSql);
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_WITH_EXECUTEUPDATE);
         }
-        int affectedRows = this.connector.getAffectedRows(pSql);
-        this.connector.freeResultSet(pSql);
+        int affectedRows = this.connection.getConnector().getAffectedRows(pSql);
+        this.connection.getConnector().freeResultSet(pSql);
         return affectedRows;
     }
 
@@ -81,30 +76,29 @@ public class TSDBStatement extends AbstractStatement {
 
     public boolean execute(String sql) throws SQLException {
         // check if closed
-        if (isClosed())
+        if (isClosed()) {
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
+        }
+        
         // execute query
-        long pSql = this.connector.executeQuery(sql);
+        long pSql = this.connection.getConnector().executeQuery(sql);
         // if pSql is create/insert/update/delete/alter SQL
-        if (this.connector.isUpdateQuery(pSql)) {
-            this.affectedRows = this.connector.getAffectedRows(pSql);
-            this.connector.freeResultSet(pSql);
+        if (this.connection.getConnector().isUpdateQuery(pSql)) {
+            this.affectedRows = this.connection.getConnector().getAffectedRows(pSql);
+            this.connection.getConnector().freeResultSet(pSql);
             return false;
         }
 
-        this.resultSet = new TSDBResultSet(this, this.connector, pSql);
+        this.resultSet = new TSDBResultSet(this, this.connection.getConnector(), pSql);
         this.resultSet.setBatchFetch(this.connection.getBatchFetch());
         return true;
     }
 
     public ResultSet getResultSet() throws SQLException {
-        if (isClosed())
+        if (isClosed()) {
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
-//        long resultSetPointer = connector.getResultSet();
-//        TSDBResultSet resSet = null;
-//        if (resultSetPointer != TSDBConstants.JNI_NULL_POINTER) {
-//            resSet = new TSDBResultSet(connector, resultSetPointer);
-//        }
+        }
+        
         return this.resultSet;
     }
 
@@ -115,12 +109,20 @@ public class TSDBStatement extends AbstractStatement {
     }
 
     public Connection getConnection() throws SQLException {
-        if (isClosed())
+        if (isClosed()) {
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_STATEMENT_CLOSED);
-        if (this.connector == null)
+        }
+        
+        if (this.connection.getConnector() == null) {
             throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_JNI_CONNECTION_NULL);
+        }
+        
         return this.connection;
     }
+    
+    public void setConnection(TSDBConnection connection) {
+        this.connection = connection;
+    }
 
     public boolean isClosed() throws SQLException {
         return isClosed;

src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulDriver.java

@@ -17,7 +17,7 @@ public class RestfulDriver extends AbstractDriver {
 
     static {
         try {
-            java.sql.DriverManager.registerDriver(new RestfulDriver());
+            DriverManager.registerDriver(new RestfulDriver());
         } catch (SQLException e) {
             throw TSDBError.createRuntimeException(TSDBErrorNumbers.ERROR_URL_NOT_SET, e);
         }

src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulPreparedStatement.java

@@ -2,12 +2,12 @@ package com.taosdata.jdbc.rs;
 
 import com.taosdata.jdbc.TSDBError;
 import com.taosdata.jdbc.TSDBErrorNumbers;
+import com.taosdata.jdbc.utils.Utils;
 
 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;
 
@@ -21,6 +21,7 @@ public class RestfulPreparedStatement extends RestfulStatement implements Prepar
     public RestfulPreparedStatement(RestfulConnection conn, String database, String sql) {
         super(conn, database);
         this.rawSql = sql;
+
         if (sql.contains("?")) {
             int parameterCnt = 0;
             for (int i = 0; i < sql.length(); i++) {
@@ -58,29 +59,14 @@ public class RestfulPreparedStatement extends RestfulStatement implements Prepar
         return executeUpdate(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;
-                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);
-            } else {
-                sql = sql.replaceFirst("[?]", "NULL");
-            }
-        }
-        clearParameters();
-        return sql;
+    /****
+     * 将rawSql转换成一条可执行的sql语句，使用属性parameters中的变脸进行替换
+     * 对于insert into ?.? (?,?,?) using ?.? (?,?,?) tags(?, ?, ?) values(?, ?, ?)
+     * @param rawSql，可能是insert、select或其他，使用?做占位符
+     * @return
+     */
+    private String getNativeSql(String rawSql) {
+        return Utils.getNativeSql(rawSql, this.parameters);
     }
 
     @Override
@@ -220,8 +206,8 @@ 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);
-        
-        setObject(parameterIndex,x);
+
+        setObject(parameterIndex, x);
     }
 
     @Override

src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulStatement.java

@@ -136,21 +136,21 @@ public class RestfulStatement extends AbstractStatement {
             throw TSDBError.createSQLException(jsonObject.getInteger("code"), jsonObject.getString("desc"));
         }
         this.resultSet = null;
-        this.affectedRows = checkJsonResultSet(jsonObject);
+        this.affectedRows = getAffectedRows(jsonObject);
         return this.affectedRows;
     }
 
-    private int checkJsonResultSet(JSONObject jsonObject) {
+    private int getAffectedRows(JSONObject jsonObject) throws SQLException {
         // create ... SQLs should return 0 , and Restful result is this:
         // {"status": "succ", "head": ["affected_rows"], "data": [[0]], "rows": 1}
         JSONArray head = jsonObject.getJSONArray("head");
+        if (head.size() != 1 || !"affected_rows".equals(head.getString(0)))
+            throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_VARIABLE);
         JSONArray data = jsonObject.getJSONArray("data");
-        int rows = Integer.parseInt(jsonObject.getString("rows"));
-        if (head.size() == 1 && "affected_rows".equals(head.getString(0))
-                && data.size() == 1 && data.getJSONArray(0).getInteger(0) == 0 && rows == 1) {
-            return 0;
-        }
-        return rows;
+        if (data != null)
+            return data.getJSONArray(0).getInteger(0);
+
+        throw TSDBError.createSQLException(TSDBErrorNumbers.ERROR_INVALID_VARIABLE);
     }
 
     @Override

src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/NullType.java

@@ -0,0 +1,91 @@
+package com.taosdata.jdbc.utils;
+
+public class NullType {
+    private static final byte NULL_BOOL_VAL = 0x2;
+    private static final String NULL_STR = "null";
+
+    public String toString() {
+        return NullType.NULL_STR;
+    }
+
+    public static boolean isBooleanNull(byte val) {
+        return val == NullType.NULL_BOOL_VAL;
+    }
+    
+    public static boolean isTinyIntNull(byte val) {
+        return val == Byte.MIN_VALUE;
+    }
+    
+    public static boolean isSmallIntNull(short val) {
+        return val == Short.MIN_VALUE;
+    }
+
+    public static boolean isIntNull(int val) {
+        return val == Integer.MIN_VALUE;
+    }
+    
+    public static boolean isBigIntNull(long val) {
+        return val == Long.MIN_VALUE;
+    }
+    
+    public static boolean isFloatNull(float val) {
+        return Float.isNaN(val);
+    }
+    
+    public static boolean isDoubleNull(double val) {
+        return Double.isNaN(val);
+    }
+    
+    public static boolean isBinaryNull(byte[] val, int length) {
+        if (length != Byte.BYTES) {
+            return false;
+        }
+
+        return val[0] == 0xFF;
+    }
+    
+    public static boolean isNcharNull(byte[] val, int length) {
+        if (length != Integer.BYTES) {
+            return false;
+        }
+
+        return (val[0] & val[1] & val[2] & val[3]) == 0xFF;
+    }
+    
+    public static byte getBooleanNull() {
+    	return NullType.NULL_BOOL_VAL;
+    }
+    
+    public static byte getTinyintNull() {
+    	return Byte.MIN_VALUE;
+    }
+    
+    public static int getIntNull() {
+    	return Integer.MIN_VALUE;
+    }
+    
+    public static short getSmallIntNull() {
+    	return Short.MIN_VALUE;
+    }
+
+    public static long getBigIntNull() {
+    	return Long.MIN_VALUE;
+    }
+    
+    public static int getFloatNull() {
+    	return 0x7FF00000;
+    }
+
+    public static long getDoubleNull() {
+    	return 0x7FFFFF0000000000L;
+    }
+
+    public static byte getBinaryNull() {
+    	return (byte) 0xFF;
+    }
+    
+    public static byte[] getNcharNull() {
+    	return new byte[] {(byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF};
+    }
+
+}

src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/Utils.java

@@ -0,0 +1,136 @@
+package com.taosdata.jdbc.utils;
+
+import com.google.common.collect.Range;
+import com.google.common.collect.RangeSet;
+import com.google.common.collect.TreeRangeSet;
+
+import java.nio.charset.Charset;
+import java.sql.Timestamp;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class Utils {
+
+    private static Pattern ptn = Pattern.compile(".*?'");
+
+    public static String escapeSingleQuota(String origin) {
+        Matcher m = ptn.matcher(origin);
+        StringBuffer sb = new StringBuffer();
+        int end = 0;
+        while (m.find()) {
+            end = m.end();
+            String seg = origin.substring(m.start(), end);
+            int len = seg.length();
+            if (len == 1) {
+                if ('\'' == seg.charAt(0)) {
+                    sb.append("\\'");
+                } else {
+                    sb.append(seg);
+                }
+            } else { // len > 1
+                sb.append(seg.substring(0, seg.length() - 2));
+                char lastcSec = seg.charAt(seg.length() - 2);
+                if (lastcSec == '\\') {
+                    sb.append("\\'");
+                } else {
+                    sb.append(lastcSec);
+                    sb.append("\\'");
+                }
+            }
+        }
+
+        if (end < origin.length()) {
+            sb.append(origin.substring(end));
+        }
+        return sb.toString();
+    }
+
+    public static String getNativeSql(String rawSql, Object[] parameters) {
+        // toLowerCase
+        String preparedSql = rawSql.trim().toLowerCase();
+
+        String[] clause = new String[0];
+        if (SqlSyntaxValidator.isInsertSql(preparedSql)) {
+            // insert or import
+            clause = new String[]{"values\\s*\\(.*?\\)", "tags\\s*\\(.*?\\)"};
+        }
+        if (SqlSyntaxValidator.isSelectSql(preparedSql)) {
+            // select
+            clause = new String[]{"where\\s*.*"};
+        }
+        Map<Integer, Integer> placeholderPositions = new HashMap<>();
+        RangeSet<Integer> clauseRangeSet = TreeRangeSet.create();
+        findPlaceholderPosition(preparedSql, placeholderPositions);
+        findClauseRangeSet(preparedSql, clause, clauseRangeSet);
+
+        return transformSql(rawSql, parameters, placeholderPositions, clauseRangeSet);
+    }
+
+    private static void findClauseRangeSet(String preparedSql, String[] regexArr, RangeSet<Integer> clauseRangeSet) {
+        clauseRangeSet.clear();
+        for (String regex : regexArr) {
+            Matcher matcher = Pattern.compile(regex).matcher(preparedSql);
+            while (matcher.find()) {
+                int start = matcher.start();
+                int end = matcher.end();
+                clauseRangeSet.add(Range.closed(start, end));
+            }
+        }
+    }
+
+    private static void findPlaceholderPosition(String preparedSql, Map<Integer, Integer> placeholderPosition) {
+        placeholderPosition.clear();
+        Matcher matcher = Pattern.compile("\\?").matcher(preparedSql);
+        int index = 0;
+        while (matcher.find()) {
+            int pos = matcher.start();
+            placeholderPosition.put(index, pos);
+            index++;
+        }
+    }
+
+    /***
+     *
+     * @param rawSql
+     * @param paramArr
+     * @param placeholderPosition
+     * @param clauseRangeSet
+     * @return
+     */
+    private static String transformSql(String rawSql, Object[] paramArr, Map<Integer, Integer> placeholderPosition, RangeSet<Integer> clauseRangeSet) {
+        String[] sqlArr = rawSql.split("\\?");
+
+        return IntStream.range(0, sqlArr.length).mapToObj(index -> {
+            if (index == paramArr.length)
+                return sqlArr[index];
+
+            Object para = paramArr[index];
+            String paraStr;
+            if (para != null) {
+                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 = Utils.escapeSingleQuota(paraStr);
+
+                    Integer pos = placeholderPosition.get(index);
+                    boolean contains = clauseRangeSet.contains(pos);
+                    if (contains) {
+                        paraStr = "'" + paraStr + "'";
+                    }
+                }
+            } else {
+                paraStr = "NULL";
+            }
+            return sqlArr[index] + paraStr;
+        }).collect(Collectors.joining());
+    }
+
+}

src/connector/jdbc/src/test/java/com/taosdata/jdbc/SubscribeTest.java

@@ -1,6 +1,7 @@
 package com.taosdata.jdbc;
 
 import org.junit.After;
+import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 
@@ -12,69 +13,76 @@ import java.util.Properties;
 import java.util.concurrent.TimeUnit;
 
 public class SubscribeTest {
+
     Connection connection;
     Statement statement;
     String dbName = "test";
     String tName = "t0";
     String host = "127.0.0.1";
     String topic = "test";
-
-    @Before
-    public void createDatabase() {
-        try {
-            Class.forName("com.taosdata.jdbc.TSDBDriver");
-            Properties properties = new Properties();
-            properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
-            properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
-            properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
-            connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":0/", properties);
-
-            statement = connection.createStatement();
-            statement.execute("drop database if exists " + dbName);
-            statement.execute("create database if not exists " + dbName);
-            statement.execute("create table if not exists " + dbName + "." + tName + " (ts timestamp, k int, v int)");
-            long ts = System.currentTimeMillis();
-            for (int i = 0; i < 2; i++) {
-                ts += i;
-                String sql = "insert into " + dbName + "." + tName + " values (" + ts + ", " + (100 + i) + ", " + i + ")";
-                statement.executeUpdate(sql);
-            }
-
-        } catch (ClassNotFoundException | SQLException e) {
-            return;
-        }
-    }
+    private long ts;
 
     @Test
     public void subscribe() {
         try {
             String rawSql = "select * from " + dbName + "." + tName + ";";
-            System.out.println(rawSql);
-//            TSDBSubscribe subscribe = ((TSDBConnection) connection).subscribe(topic, rawSql, false);
+            TSDBConnection conn = connection.unwrap(TSDBConnection.class);
+            TSDBSubscribe subscribe = conn.subscribe(topic, rawSql, false);
 
-//            int a = 0;
-//            while (true) {
-//                TimeUnit.MILLISECONDS.sleep(1000);
-//                TSDBResultSet resSet = subscribe.consume();
-//                while (resSet.next()) {
-//                    for (int i = 1; i <= resSet.getMetaData().getColumnCount(); i++) {
-//                        System.out.printf(i + ": " + resSet.getString(i) + "\t");
-//                    }
-//                    System.out.println("\n======" + a + "==========");
-//                }
-//                a++;
-//                if (a >= 2) {
-//                    break;
-//                }
-//                resSet.close();
-//            }
-//
-//            subscribe.close(true);
-        } catch (Exception e) {
-            e.printStackTrace();
+            for (int j = 0; j < 10; j++) {
+                TimeUnit.SECONDS.sleep(1);
+                TSDBResultSet resSet = subscribe.consume();
+
+                int rowCnt = 0;
+                while (resSet.next()) {
+                    if (rowCnt == 0) {
+                        long cur_ts = resSet.getTimestamp(1).getTime();
+                        int k = resSet.getInt(2);
+                        int v = resSet.getInt(3);
+                        Assert.assertEquals(ts, cur_ts);
+                        Assert.assertEquals(100, k);
+                        Assert.assertEquals(1, v);
+                    }
+                    if (rowCnt == 1) {
+                        long cur_ts = resSet.getTimestamp(1).getTime();
+                        int k = resSet.getInt(2);
+                        int v = resSet.getInt(3);
+                        Assert.assertEquals(ts + 1, cur_ts);
+                        Assert.assertEquals(101, k);
+                        Assert.assertEquals(2, v);
+
+                    }
+                    rowCnt++;
+                }
+                if (j == 0)
+                    Assert.assertEquals(2, rowCnt);
+                resSet.close();
+            }
+            subscribe.close(true);
+
+
+        } catch (SQLException | InterruptedException throwables) {
+            throwables.printStackTrace();
         }
     }
 
+    @Before
+    public void createDatabase() throws SQLException {
+        Properties properties = new Properties();
+        properties.setProperty(TSDBDriver.PROPERTY_KEY_CHARSET, "UTF-8");
+        properties.setProperty(TSDBDriver.PROPERTY_KEY_LOCALE, "en_US.UTF-8");
+        properties.setProperty(TSDBDriver.PROPERTY_KEY_TIME_ZONE, "UTC-8");
+        connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":0/", properties);
+
+        statement = connection.createStatement();
+        statement.execute("drop database if exists " + dbName);
+        statement.execute("create database if not exists " + dbName);
+        statement.execute("create table if not exists " + dbName + "." + tName + " (ts timestamp, k int, v int)");
+        ts = System.currentTimeMillis();
+        statement.executeUpdate("insert into " + dbName + "." + tName + " values (" + ts + ", 100, 1)");
+        statement.executeUpdate("insert into " + dbName + "." + tName + " values (" + (ts + 1) + ", 101, 2)");
+    }
+
     @After
     public void close() {
         try {
@@ -86,6 +94,5 @@ public class SubscribeTest {
         } catch (SQLException e) {
             e.printStackTrace();
         }
-
     }
 }

src/connector/jdbc/src/test/java/com/taosdata/jdbc/TSDBResultSetTest.java

@@ -3,7 +3,6 @@ package com.taosdata.jdbc;
 import com.google.common.primitives.Ints;
 import com.google.common.primitives.Longs;
 import com.google.common.primitives.Shorts;
-import com.taosdata.jdbc.rs.RestfulResultSet;
 import org.junit.AfterClass;
 import org.junit.Assert;
 import org.junit.BeforeClass;
@@ -177,7 +176,8 @@ public class TSDBResultSetTest {
         rs.getAsciiStream("f1");
     }
 
-    @Test(expected = SQLFeatureNotSupportedException.class)
+    @SuppressWarnings("deprecation")
+	@Test(expected = SQLFeatureNotSupportedException.class)
     public void getUnicodeStream() throws SQLException {
         rs.getUnicodeStream("f1");
     }
@@ -326,7 +326,7 @@ public class TSDBResultSetTest {
 
     @Test(expected = SQLFeatureNotSupportedException.class)
     public void getRow() throws SQLException {
-        int row = rs.getRow();
+        rs.getRow();
     }
 
     @Test(expected = SQLFeatureNotSupportedException.class)
@@ -405,12 +405,12 @@ public class TSDBResultSetTest {
 
     @Test(expected = SQLFeatureNotSupportedException.class)
     public void updateByte() throws SQLException {
-        rs.updateByte(1, new Byte("0"));
+        rs.updateByte(1, (byte) 0);
     }
 
     @Test(expected = SQLFeatureNotSupportedException.class)
     public void updateShort() throws SQLException {
-        rs.updateShort(1, new Short("0"));
+        rs.updateShort(1, (short) 0);
     }
 
     @Test(expected = SQLFeatureNotSupportedException.class)

src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/InsertSpecialCharacterJniTest.java

@@ -0,0 +1,401 @@
+package com.taosdata.jdbc.cases;
+
+import org.junit.*;
+
+import java.sql.*;
+
+public class InsertSpecialCharacterJniTest {
+
+    private static final String host = "127.0.0.1";
+    private static Connection conn;
+    private static String dbName = "spec_char_test";
+    private static String tbname1 = "test";
+    private static String tbname2 = "weather";
+    private static String special_character_str_1 = "$asd$$fsfsf$";
+    private static String special_character_str_2 = "\\\\asdfsfsf\\\\";
+    private static String special_character_str_3 = "\\\\asdfsfsf\\";
+    private static String special_character_str_4 = "?asd??fsf?sf?";
+    private static String special_character_str_5 = "?#sd@$f(('<(s[P)>\"){]}f?s[]{}%vaew|\"fsfs^a&d*jhg)(j))(f@~!?$";
+
+    @Test
+    public void testCase01() throws SQLException {
+        final long now = System.currentTimeMillis();
+        // insert
+        final String sql = "insert into " + tbname1 + "(ts, f1) values(?, ?)";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setTimestamp(1, new Timestamp(now));
+            pstmt.setBytes(2, special_character_str_1.getBytes());
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(1, ret);
+        }
+        // query
+        final String query = "select * from ?";
+        try (PreparedStatement pstmt = conn.prepareStatement(query)) {
+            pstmt.setString(1, tbname1);
+
+            ResultSet rs = pstmt.executeQuery();
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            String f1 = new String(rs.getBytes(2));
+            Assert.assertEquals(special_character_str_1, f1);
+            String f2 = rs.getString(3);
+            Assert.assertNull(f2);
+        }
+    }
+
+
+    @Test
+    public void testCase02() throws SQLException {
+        //TODO:
+        // Expected :\asdfsfsf\\
+        // Actual   :\asdfsfsf\
+
+        final long now = System.currentTimeMillis();
+        // insert
+        final String sql = "insert into " + tbname1 + "(ts, f1) values(?, ?)";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setTimestamp(1, new Timestamp(now));
+            pstmt.setBytes(2, special_character_str_2.getBytes());
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(1, ret);
+        }
+        // query
+        final String query = "select * from " + tbname1;
+        try (PreparedStatement pstmt = conn.prepareStatement(query)) {
+            ResultSet rs = pstmt.executeQuery();
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            String f1 = new String(rs.getBytes(2));
+            //TODO: bug to be fixed
+//            Assert.assertEquals(special_character_str_2, f1);
+            Assert.assertEquals(special_character_str_2.substring(1, special_character_str_1.length() - 1), f1);
+            String f2 = rs.getString(3);
+            Assert.assertNull(f2);
+        }
+    }
+
+    @Test(expected = SQLException.class)
+    public void testCase03() throws SQLException {
+        //TODO:
+        // TDengine ERROR (216): Syntax error in SQL
+        final long now = System.currentTimeMillis();
+        // insert
+        final String sql = "insert into " + tbname1 + "(ts, f1) values(?, ?)";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setTimestamp(1, new Timestamp(now));
+            pstmt.setBytes(2, special_character_str_3.getBytes());
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(1, ret);
+        }
+        // query
+        final String query = "select * from " + tbname1;
+        try (PreparedStatement pstmt = conn.prepareStatement(query)) {
+            ResultSet rs = pstmt.executeQuery();
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            String f1 = new String(rs.getBytes(2));
+            Assert.assertEquals(special_character_str_3, f1);
+            String f2 = rs.getString(3);
+            Assert.assertNull(f2);
+        }
+    }
+
+    @Test
+    public void testCase04() throws SQLException {
+        final long now = System.currentTimeMillis();
+        // insert
+        final String sql = "insert into " + tbname1 + "(ts, f1) values(?, ?)";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setTimestamp(1, new Timestamp(now));
+            pstmt.setBytes(2, special_character_str_4.getBytes());
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(1, ret);
+        }
+        // query
+        final String query = "select * from " + tbname1;
+        try (Statement stmt = conn.createStatement()) {
+            ResultSet rs = stmt.executeQuery(query);
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            String f1 = new String(rs.getBytes(2));
+            Assert.assertEquals(special_character_str_4, f1);
+            String f2 = rs.getString(3);
+            Assert.assertNull(f2);
+        }
+    }
+
+    @Test
+    public void testCase05() throws SQLException {
+        final long now = System.currentTimeMillis();
+        // insert
+        final String sql = "insert into " + tbname1 + "(ts, f1) values(?, ?)";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setTimestamp(1, new Timestamp(now));
+            pstmt.setBytes(2, special_character_str_5.getBytes());
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(1, ret);
+        }
+        // query
+        final String query = "select * from " + tbname1;
+        try (Statement stmt = conn.createStatement()) {
+            ResultSet rs = stmt.executeQuery(query);
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            String f1 = new String(rs.getBytes(2));
+            Assert.assertEquals(special_character_str_5, f1);
+            String f2 = rs.getString(3);
+            Assert.assertNull(f2);
+        }
+    }
+
+    @Test
+    public void testCase06() throws SQLException {
+        final long now = System.currentTimeMillis();
+        // insert
+        final String sql = "insert into t? using " + tbname2 + " tags(?) values(?, ?, ?)";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setInt(1, 1);
+            pstmt.setString(2, special_character_str_4);
+            pstmt.setTimestamp(3, new Timestamp(now));
+            pstmt.setBytes(4, special_character_str_4.getBytes());
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(1, ret);
+        }
+        // query t1
+        final String query = "select * from t1";
+        try (Statement stmt = conn.createStatement()) {
+            ResultSet rs = stmt.executeQuery(query);
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            String f1 = new String(rs.getBytes(2));
+            Assert.assertEquals(special_character_str_4, f1);
+            String f2 = rs.getString(3);
+            Assert.assertNull(f2);
+        }
+    }
+
+    @Test
+    public void testCase07() throws SQLException {
+        final long now = System.currentTimeMillis();
+        // insert
+        final String sql = "insert into " + tbname1 + "(ts, f1, f2) values(?, ?, ?)  ; ";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setTimestamp(1, new Timestamp(now));
+            pstmt.setBytes(2, special_character_str_4.getBytes());
+            pstmt.setString(3, special_character_str_4);
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(1, ret);
+        }
+        // query
+        final String query = "select * from " + tbname1;
+        try (Statement stmt = conn.createStatement()) {
+            ResultSet rs = stmt.executeQuery(query);
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            String f1 = new String(rs.getBytes(2));
+            Assert.assertEquals(special_character_str_4, f1);
+            String f2 = rs.getString(3);
+            Assert.assertEquals(special_character_str_4, f2);
+        }
+    }
+
+    @Test(expected = SQLException.class)
+    public void testCase08() throws SQLException {
+        final long now = System.currentTimeMillis();
+        // insert
+        final String sql = "insert into t? using " + tbname2 + " tags(?) values(?, ?, ?) ? ";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setInt(1, 1);
+            pstmt.setString(2, special_character_str_5);
+            pstmt.setTimestamp(3, new Timestamp(now));
+            pstmt.setBytes(4, special_character_str_5.getBytes());
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(1, ret);
+        }
+    }
+
+    @Test
+    public void testCase09() throws SQLException {
+        final long now = System.currentTimeMillis();
+        // insert
+        final String sql = "insert into ?.t? using " + tbname2 + " tags(?) values(?, ?, ?) t? using weather tags(?) values(?,?,?) ";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            // t1
+            pstmt.setString(1, dbName);
+            pstmt.setInt(2, 1);
+            pstmt.setString(3, special_character_str_5);
+            pstmt.setTimestamp(4, new Timestamp(now));
+            pstmt.setBytes(5, special_character_str_5.getBytes());
+            // t2
+            pstmt.setInt(7, 2);
+            pstmt.setString(8, special_character_str_5);
+            pstmt.setTimestamp(9, new Timestamp(now));
+            pstmt.setString(11, special_character_str_5);
+
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(2, ret);
+        }
+        // query t1
+        String query = "select * from t?";
+        try (PreparedStatement pstmt = conn.prepareStatement(query)) {
+            pstmt.setInt(1, 1);
+
+            ResultSet rs = pstmt.executeQuery();
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            String f1 = new String(rs.getBytes(2));
+            Assert.assertEquals(special_character_str_5, f1);
+            String f2 = rs.getString(3);
+            Assert.assertNull(f2);
+        }
+        // query t2
+        query = "select * from t2";
+        try (Statement stmt = conn.createStatement()) {
+            ResultSet rs = stmt.executeQuery(query);
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            byte[] f1 = rs.getBytes(2);
+            Assert.assertNull(f1);
+            String f2 = new String(rs.getBytes(3));
+            Assert.assertEquals(special_character_str_5, f2);
+        }
+    }
+
+    @Test
+    public void testCase10() throws SQLException {
+        final long now = System.currentTimeMillis();
+
+        // insert
+        final String sql = "insert into t? using ? tags(?) values(?, ?, ?) t? using " + tbname2 + " tags(?) values(?,?,?) ";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            // t1
+            pstmt.setInt(1, 1);
+            pstmt.setString(2, tbname2);
+            pstmt.setString(3, special_character_str_5);
+            pstmt.setTimestamp(4, new Timestamp(now));
+            pstmt.setBytes(5, special_character_str_5.getBytes());
+            // t2
+            pstmt.setInt(7, 2);
+            pstmt.setString(8, special_character_str_5);
+            pstmt.setTimestamp(9, new Timestamp(now));
+            pstmt.setString(11, special_character_str_5);
+
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(2, ret);
+        }
+        //query t1
+        String query = "select * from ?.t? where ts < ? and ts >= ? and ? is not null";
+        try (PreparedStatement pstmt = conn.prepareStatement(query)) {
+            pstmt.setString(1, dbName);
+            pstmt.setInt(2, 1);
+            pstmt.setTimestamp(3, new Timestamp(System.currentTimeMillis()));
+            pstmt.setTimestamp(4, new Timestamp(0));
+            pstmt.setString(5, "f1");
+
+            ResultSet rs = pstmt.executeQuery();
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            String f1 = new String(rs.getBytes(2));
+            Assert.assertEquals(special_character_str_5, f1);
+            byte[] f2 = rs.getBytes(3);
+            Assert.assertNull(f2);
+        }
+        // query t2
+        query = "select * from t? where ts < ? and ts >= ? and ? is not null";
+        try (PreparedStatement pstmt = conn.prepareStatement(query)) {
+            pstmt.setInt(1, 2);
+            pstmt.setTimestamp(2, new Timestamp(System.currentTimeMillis()));
+            pstmt.setTimestamp(3, new Timestamp(0));
+            pstmt.setString(4, "f2");
+
+            ResultSet rs = pstmt.executeQuery();
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            byte[] f1 = rs.getBytes(2);
+            Assert.assertNull(f1);
+            String f2 = new String(rs.getBytes(3));
+            Assert.assertEquals(special_character_str_5, f2);
+        }
+    }
+
+    @Test(expected = SQLException.class)
+    public void testCase11() throws SQLException {
+        final String speicalCharacterStr = "?#sd@$f(((s[P)){]}f?s[]{}%vs^a&d*jhg)(j))(f@~!?$";
+        final long now = System.currentTimeMillis();
+
+        final String sql = "insert into t? using " + tbname2 + " values(?, ?, 'abc?abc') ";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setInt(1, 1);
+            pstmt.setTimestamp(2, new Timestamp(now));
+            pstmt.setBytes(3, speicalCharacterStr.getBytes());
+
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(1, ret);
+        }
+    }
+
+
+    @Test
+    public void testCase12() throws SQLException {
+        final long now = System.currentTimeMillis();
+        // insert
+        final String sql = "insert into " + tbname1 + "(ts, f1, f2) values(?, 'HelloTDengine', ?)  ; ";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setTimestamp(1, new Timestamp(now));
+            pstmt.setString(2, special_character_str_4);
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(1, ret);
+        }
+        // query
+        final String query = "select * from " + tbname1;
+        try (Statement stmt = conn.createStatement()) {
+            ResultSet rs = stmt.executeQuery(query);
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            String f1 = new String(rs.getBytes(2));
+            Assert.assertEquals("HelloTDengine", f1);
+            String f2 = rs.getString(3);
+            Assert.assertEquals(special_character_str_4, f2);
+        }
+    }
+
+    @Before
+    public void before() throws SQLException {
+        try (Statement stmt = conn.createStatement()) {
+            stmt.execute("drop table if exists " + tbname1 + "");
+            stmt.execute("create table " + tbname1 + "(ts timestamp,f1 binary(64),f2 nchar(64))");
+            stmt.execute("drop table if exists " + tbname2);
+            stmt.execute("create table " + tbname2 + "(ts timestamp, f1 binary(64), f2 nchar(64)) tags(loc nchar(64))");
+        }
+    }
+
+    @BeforeClass
+    public static void beforeClass() throws SQLException {
+        String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata";
+        conn = DriverManager.getConnection(url);
+        try (Statement stmt = conn.createStatement()) {
+            stmt.execute("drop database if exists " + dbName);
+            stmt.execute("create database if not exists " + dbName);
+            stmt.execute("use " + dbName);
+        }
+    }
+
+    @AfterClass
+    public static void afterClass() throws SQLException {
+        if (conn != null)
+            conn.close();
+    }
+
+}

src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/InsertSpecialCharacterRestfulTest.java

@@ -0,0 +1,401 @@
+package com.taosdata.jdbc.cases;
+
+import org.junit.*;
+
+import java.sql.*;
+
+public class InsertSpecialCharacterRestfulTest {
+
+    private static final String host = "127.0.0.1";
+    //    private static final String host = "master";
+    private static Connection conn;
+    private static String dbName = "spec_char_test";
+    private static String tbname1 = "test";
+    private static String tbname2 = "weather";
+    private static String special_character_str_1 = "$asd$$fsfsf$";
+    private static String special_character_str_2 = "\\\\asdfsfsf\\\\";
+    private static String special_character_str_3 = "\\\\asdfsfsf\\";
+    private static String special_character_str_4 = "?asd??fsf?sf?";
+    private static String special_character_str_5 = "?#sd@$f(('<(s[P)>\"){]}f?s[]{}%vaew|\"fsfs^a&d*jhg)(j))(f@~!?$";
+
+    @Test
+    public void testCase01() throws SQLException {
+        final long now = System.currentTimeMillis();
+        // insert
+        final String sql = "insert into " + tbname1 + "(ts, f1) values(?, ?)";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setTimestamp(1, new Timestamp(now));
+            pstmt.setBytes(2, special_character_str_1.getBytes());
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(1, ret);
+        }
+        // query
+        final String query = "select * from ?";
+        try (PreparedStatement pstmt = conn.prepareStatement(query)) {
+            pstmt.setString(1, tbname1);
+
+            ResultSet rs = pstmt.executeQuery();
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            String f1 = new String(rs.getBytes(2));
+            Assert.assertEquals(special_character_str_1, f1);
+            String f2 = rs.getString(3);
+            Assert.assertNull(f2);
+        }
+    }
+
+
+    @Test
+    public void testCase02() throws SQLException {
+        //TODO:
+        // Expected :\asdfsfsf\
+        // Actual   :\asdfsfsf\
+
+        final long now = System.currentTimeMillis();
+        // insert
+        final String sql = "insert into " + tbname1 + "(ts, f1) values(?, ?)";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setTimestamp(1, new Timestamp(now));
+            pstmt.setBytes(2, special_character_str_2.getBytes());
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(1, ret);
+        }
+        // query
+        final String query = "select * from " + tbname1;
+        try (PreparedStatement pstmt = conn.prepareStatement(query)) {
+            ResultSet rs = pstmt.executeQuery();
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            String f1 = new String(rs.getBytes(2));
+            //TODO: bug to be fixed
+//            Assert.assertEquals(special_character_str_2, f1);
+            Assert.assertEquals(special_character_str_2.substring(1, special_character_str_1.length() - 1), f1);
+            String f2 = rs.getString(3);
+            Assert.assertNull(f2);
+        }
+    }
+
+    @Test(expected = SQLException.class)
+    public void testCase03() throws SQLException {
+        //TODO:
+        // TDengine ERROR (216): Syntax error in SQL
+        final long now = System.currentTimeMillis();
+        // insert
+        final String sql = "insert into " + tbname1 + "(ts, f1) values(?, ?)";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setTimestamp(1, new Timestamp(now));
+            pstmt.setBytes(2, special_character_str_3.getBytes());
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(1, ret);
+        }
+        // query
+        final String query = "select * from " + tbname1;
+        try (PreparedStatement pstmt = conn.prepareStatement(query)) {
+            ResultSet rs = pstmt.executeQuery();
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            String f1 = new String(rs.getBytes(2));
+            Assert.assertEquals(special_character_str_3, f1);
+            String f2 = rs.getString(3);
+            Assert.assertNull(f2);
+        }
+    }
+
+    @Test
+    public void testCase04() throws SQLException {
+        final long now = System.currentTimeMillis();
+        // insert
+        final String sql = "insert into " + tbname1 + "(ts, f1) values(?, ?)";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setTimestamp(1, new Timestamp(now));
+            pstmt.setBytes(2, special_character_str_4.getBytes());
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(1, ret);
+        }
+        // query
+        final String query = "select * from " + tbname1;
+        try (Statement stmt = conn.createStatement()) {
+            ResultSet rs = stmt.executeQuery(query);
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            String f1 = new String(rs.getBytes(2));
+            Assert.assertEquals(special_character_str_4, f1);
+            String f2 = rs.getString(3);
+            Assert.assertNull(f2);
+        }
+    }
+
+    @Test
+    public void testCase05() throws SQLException {
+        final long now = System.currentTimeMillis();
+        // insert
+        final String sql = "insert into " + tbname1 + "(ts, f1) values(?, ?)";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setTimestamp(1, new Timestamp(now));
+            pstmt.setBytes(2, special_character_str_5.getBytes());
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(1, ret);
+        }
+        // query
+        final String query = "select * from " + tbname1;
+        try (Statement stmt = conn.createStatement()) {
+            ResultSet rs = stmt.executeQuery(query);
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            String f1 = new String(rs.getBytes(2));
+            Assert.assertEquals(special_character_str_5, f1);
+            String f2 = rs.getString(3);
+            Assert.assertNull(f2);
+        }
+    }
+
+    @Test
+    public void testCase06() throws SQLException {
+        final long now = System.currentTimeMillis();
+        // insert
+        final String sql = "insert into t? using " + tbname2 + " tags(?) values(?, ?, ?)";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setInt(1, 1);
+            pstmt.setString(2, special_character_str_4);
+            pstmt.setTimestamp(3, new Timestamp(now));
+            pstmt.setBytes(4, special_character_str_4.getBytes());
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(1, ret);
+        }
+        // query t1
+        final String query = "select * from t1";
+        try (Statement stmt = conn.createStatement()) {
+            ResultSet rs = stmt.executeQuery(query);
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            String f1 = new String(rs.getBytes(2));
+            Assert.assertEquals(special_character_str_4, f1);
+            String f2 = rs.getString(3);
+            Assert.assertNull(f2);
+        }
+    }
+
+    @Test
+    public void testCase07() throws SQLException {
+        final long now = System.currentTimeMillis();
+        // insert
+        final String sql = "insert into " + tbname1 + "(ts, f1, f2) values(?, ?, ?)  ; ";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setTimestamp(1, new Timestamp(now));
+            pstmt.setBytes(2, special_character_str_4.getBytes());
+            pstmt.setString(3, special_character_str_4);
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(1, ret);
+        }
+        // query
+        final String query = "select * from " + tbname1;
+        try (Statement stmt = conn.createStatement()) {
+            ResultSet rs = stmt.executeQuery(query);
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            String f1 = new String(rs.getBytes(2));
+            Assert.assertEquals(special_character_str_4, f1);
+            String f2 = rs.getString(3);
+            Assert.assertEquals(special_character_str_4, f2);
+        }
+    }
+
+    @Test(expected = SQLException.class)
+    public void testCase08() throws SQLException {
+        final long now = System.currentTimeMillis();
+        // insert
+        final String sql = "insert into t? using " + tbname2 + " tags(?) values(?, ?, ?) ? ";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setInt(1, 1);
+            pstmt.setString(2, special_character_str_5);
+            pstmt.setTimestamp(3, new Timestamp(now));
+            pstmt.setBytes(4, special_character_str_5.getBytes());
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(1, ret);
+        }
+    }
+
+    @Test
+    public void testCase09() throws SQLException {
+        final long now = System.currentTimeMillis();
+        // insert
+        final String sql = "insert into ?.t? using " + tbname2 + " tags(?) values(?, ?, ?) t? using weather tags(?) values(?,?,?) ";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            // t1
+            pstmt.setString(1, dbName);
+            pstmt.setInt(2, 1);
+            pstmt.setString(3, special_character_str_5);
+            pstmt.setTimestamp(4, new Timestamp(now));
+            pstmt.setBytes(5, special_character_str_5.getBytes());
+            // t2
+            pstmt.setInt(7, 2);
+            pstmt.setString(8, special_character_str_5);
+            pstmt.setTimestamp(9, new Timestamp(now));
+            pstmt.setString(11, special_character_str_5);
+
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(2, ret);
+        }
+        // query t1
+        String query = "select * from t?";
+        try (PreparedStatement pstmt = conn.prepareStatement(query)) {
+            pstmt.setInt(1, 1);
+
+            ResultSet rs = pstmt.executeQuery();
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            String f1 = new String(rs.getBytes(2));
+            Assert.assertEquals(special_character_str_5, f1);
+            String f2 = rs.getString(3);
+            Assert.assertNull(f2);
+        }
+        // query t2
+        query = "select * from t2";
+        try (Statement stmt = conn.createStatement()) {
+            ResultSet rs = stmt.executeQuery(query);
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            byte[] f1 = rs.getBytes(2);
+            Assert.assertNull(f1);
+            String f2 = new String(rs.getBytes(3));
+            Assert.assertEquals(special_character_str_5, f2);
+        }
+    }
+
+    @Test
+    public void testCase10() throws SQLException {
+        final long now = System.currentTimeMillis();
+
+        // insert
+        final String sql = "insert into t? using ? tags(?) values(?, ?, ?) t? using " + tbname2 + " tags(?) values(?,?,?) ";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            // t1
+            pstmt.setInt(1, 1);
+            pstmt.setString(2, tbname2);
+            pstmt.setString(3, special_character_str_5);
+            pstmt.setTimestamp(4, new Timestamp(now));
+            pstmt.setBytes(5, special_character_str_5.getBytes());
+            // t2
+            pstmt.setInt(7, 2);
+            pstmt.setString(8, special_character_str_5);
+            pstmt.setTimestamp(9, new Timestamp(now));
+            pstmt.setString(11, special_character_str_5);
+
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(2, ret);
+        }
+        //query t1
+        String query = "select * from ?.t? where ts < ? and ts >= ? and ? is not null";
+        try (PreparedStatement pstmt = conn.prepareStatement(query)) {
+            pstmt.setString(1, dbName);
+            pstmt.setInt(2, 1);
+            pstmt.setTimestamp(3, new Timestamp(System.currentTimeMillis()));
+            pstmt.setTimestamp(4, new Timestamp(0));
+            pstmt.setString(5, "f1");
+
+            ResultSet rs = pstmt.executeQuery();
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            String f1 = new String(rs.getBytes(2));
+            Assert.assertEquals(special_character_str_5, f1);
+            byte[] f2 = rs.getBytes(3);
+            Assert.assertNull(f2);
+        }
+        // query t2
+        query = "select * from t? where ts < ? and ts >= ? and ? is not null";
+        try (PreparedStatement pstmt = conn.prepareStatement(query)) {
+            pstmt.setInt(1, 2);
+            pstmt.setTimestamp(2, new Timestamp(System.currentTimeMillis()));
+            pstmt.setTimestamp(3, new Timestamp(0));
+            pstmt.setString(4, "f2");
+
+            ResultSet rs = pstmt.executeQuery();
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            byte[] f1 = rs.getBytes(2);
+            Assert.assertNull(f1);
+            String f2 = new String(rs.getBytes(3));
+            Assert.assertEquals(special_character_str_5, f2);
+        }
+    }
+
+    @Test(expected = SQLException.class)
+    public void testCase11() throws SQLException {
+        final String speicalCharacterStr = "?#sd@$f(((s[P)){]}f?s[]{}%vs^a&d*jhg)(j))(f@~!?$";
+        final long now = System.currentTimeMillis();
+
+        final String sql = "insert into t? using " + tbname2 + " values(?, ?, 'abc?abc') ";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setInt(1, 1);
+            pstmt.setTimestamp(2, new Timestamp(now));
+            pstmt.setBytes(3, speicalCharacterStr.getBytes());
+
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(1, ret);
+        }
+    }
+
+    @Test
+    public void testCase12() throws SQLException {
+        final long now = System.currentTimeMillis();
+        // insert
+        final String sql = "insert into " + tbname1 + "(ts, f1, f2) values(?, 'HelloTDengine', ?)  ; ";
+        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setTimestamp(1, new Timestamp(now));
+            pstmt.setString(2, special_character_str_4);
+            int ret = pstmt.executeUpdate();
+            Assert.assertEquals(1, ret);
+        }
+        // query
+        final String query = "select * from " + tbname1;
+        try (Statement stmt = conn.createStatement()) {
+            ResultSet rs = stmt.executeQuery(query);
+            rs.next();
+            long timestamp = rs.getTimestamp(1).getTime();
+            Assert.assertEquals(now, timestamp);
+            String f1 = new String(rs.getBytes(2));
+            Assert.assertEquals("HelloTDengine", f1);
+            String f2 = rs.getString(3);
+            Assert.assertEquals(special_character_str_4, f2);
+        }
+    }
+
+    @Before
+    public void before() throws SQLException {
+        try (Statement stmt = conn.createStatement()) {
+            stmt.execute("drop table if exists " + tbname1 + "");
+            stmt.execute("create table " + tbname1 + "(ts timestamp,f1 binary(64),f2 nchar(64))");
+            stmt.execute("drop table if exists " + tbname2);
+            stmt.execute("create table " + tbname2 + "(ts timestamp, f1 binary(64), f2 nchar(64)) tags(loc nchar(64))");
+        }
+    }
+
+    @BeforeClass
+    public static void beforeClass() throws SQLException {
+        String url = "jdbc:TAOS-RS://" + host + ":6041/?user=root&password=taosdata";
+        conn = DriverManager.getConnection(url);
+        try (Statement stmt = conn.createStatement()) {
+            stmt.execute("drop database if exists " + dbName);
+            stmt.execute("create database if not exists " + dbName);
+            stmt.execute("use " + dbName);
+        }
+    }
+
+    @AfterClass
+    public static void afterClass() throws SQLException {
+        if (conn != null)
+            conn.close();
+    }
+
+}

src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulPreparedStatementTest.java

@@ -6,11 +6,11 @@ import org.junit.BeforeClass;
 import org.junit.Test;
 
 import java.io.IOException;
-import java.io.Serializable;
 import java.sql.*;
 
 public class RestfulPreparedStatementTest {
     private static final String host = "127.0.0.1";
+    //    private static final String host = "master";
     private static Connection conn;
     private static final String sql_insert = "insert into t1 values(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
     private static PreparedStatement pstmt_insert;

src/connector/jdbc/src/test/java/com/taosdata/jdbc/utils/UtilsTest.java

@@ -0,0 +1,24 @@
+package com.taosdata.jdbc.utils;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class UtilsTest {
+
+    @Test
+    public void escapeSingleQuota() {
+        String s = "'''''a\\'";
+        String news = Utils.escapeSingleQuota(s);
+        Assert.assertEquals("\\'\\'\\'\\'\\'a\\'", news);
+
+        s = "\'''''a\\'";
+        news = Utils.escapeSingleQuota(s);
+        Assert.assertEquals("\\'\\'\\'\\'\\'a\\'", news);
+
+        s = "\'\'\'\''a\\'";
+        news = Utils.escapeSingleQuota(s);
+        Assert.assertEquals("\\'\\'\\'\\'\\'a\\'", news);
+    }
+}

src/connector/python/.gitignore

@@ -0,0 +1,154 @@
+
+# Created by https://www.toptal.com/developers/gitignore/api/python
+# Edit at https://www.toptal.com/developers/gitignore?templates=python
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+pytestdebug.log
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+doc/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#poetry.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+# .env
+.env/
+.venv/
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+pythonenv*
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# operating system-related files
+# file properties cache/storage on macOS
+*.DS_Store
+# thumbnail cache on Windows
+Thumbs.db
+
+# profiling data
+.prof
+
+
+# End of https://www.toptal.com/developers/gitignore/api/python

src/connector/python/README.md

@@ -0,0 +1,17 @@
+# TDengine Connector for Python
+
+[TDengine] connector for Python enables python programs to access TDengine, using an API which is compliant with the Python DB API 2.0 (PEP-249). It uses TDengine C client library for client server communications.
+
+## Install
+
+```sh
+pip install git+https://github.com/taosdata/TDengine-connector-python
+```
+
+## Source Code
+
+[TDengine] connector for Python source code is hosted on [GitHub](https://github.com/taosdata/TDengine-connector-python).
+
+## License - AGPL
+
+Keep same with [TDengine](https://github.com/taosdata/TDengine).

src/connector/python/examples/demo.py

@@ -0,0 +1,12 @@
+import taos
+
+conn = taos.connect(host='127.0.0.1',
+                    user='root',
+                    passworkd='taodata',
+                    database='log')
+cursor = conn.cursor()
+
+sql = "select * from log.log limit 10"
+cursor.execute(sql)
+for row in cursor:
+    print(row)

src/connector/python/linux/python2

@@ -0,0 +1 @@
+../

src/connector/python/linux/python2/README.md

@@ -1 +0,0 @@
-# TDengine python client interface

src/connector/python/linux/python2/setup.py

@@ -1,20 +0,0 @@
-import setuptools
-
-with open("README.md", "r") as fh:
-    long_description = fh.read()
-
-setuptools.setup(
-    name="taos",
-    version="2.0.8",
-    author="Taosdata Inc.",
-    author_email="support@taosdata.com",
-    description="TDengine python client package",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    url="https://github.com/pypa/sampleproject",
-    packages=setuptools.find_packages(),
-    classifiers=[
-        "Programming Language :: Python :: 2",
-        "Operating System :: Linux",
-    ],
-)

src/connector/python/linux/python2/taos/cinterface.py

@@ -1,642 +0,0 @@
-import ctypes
-from .constants import FieldType
-from .error import *
-import math
-import datetime
-
-
-def _convert_millisecond_to_datetime(milli):
-    return datetime.datetime.fromtimestamp(milli / 1000.0)
-
-
-def _convert_microsecond_to_datetime(micro):
-    return datetime.datetime.fromtimestamp(micro / 1000000.0)
-
-
-def _crow_timestamp_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C bool row to python row
-    """
-    _timestamp_converter = _convert_millisecond_to_datetime
-    if micro:
-        _timestamp_converter = _convert_microsecond_to_datetime
-
-    if num_of_rows > 0:
-        return list(map(_timestamp_converter, ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_int64))[:abs(num_of_rows)]))
-    else:
-        return list(map(_timestamp_converter, ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_int64))[:abs(num_of_rows)]))
-
-
-def _crow_bool_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C bool row to python row
-    """
-    if num_of_rows > 0:
-        return [
-            None if ele == FieldType.C_BOOL_NULL else bool(ele) for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_byte))[
-                :abs(num_of_rows)]]
-    else:
-        return [
-            None if ele == FieldType.C_BOOL_NULL else bool(ele) for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_bool))[
-                :abs(num_of_rows)]]
-
-
-def _crow_tinyint_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C tinyint row to python row
-    """
-    if num_of_rows > 0:
-        return [None if ele == FieldType.C_TINYINT_NULL else ele for ele in ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)]]
-    else:
-        return [None if ele == FieldType.C_TINYINT_NULL else ele for ele in ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)]]
-
-
-def _crow_tinyint_unsigned_to_python(
-        data,
-        num_of_rows,
-        nbytes=None,
-        micro=False):
-    """Function to convert C tinyint row to python row
-    """
-    if num_of_rows > 0:
-        return [
-            None if ele == FieldType.C_TINYINT_UNSIGNED_NULL else ele for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_ubyte))[
-                :abs(num_of_rows)]]
-    else:
-        return [
-            None if ele == FieldType.C_TINYINT_UNSIGNED_NULL else ele for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_ubyte))[
-                :abs(num_of_rows)]]
-
-
-def _crow_smallint_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C smallint row to python row
-    """
-    if num_of_rows > 0:
-        return [
-            None if ele == FieldType.C_SMALLINT_NULL else ele for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_short))[
-                :abs(num_of_rows)]]
-    else:
-        return [
-            None if ele == FieldType.C_SMALLINT_NULL else ele for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_short))[
-                :abs(num_of_rows)]]
-
-
-def _crow_smallint_unsigned_to_python(
-        data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C smallint row to python row
-    """
-    if num_of_rows > 0:
-        return [
-            None if ele == FieldType.C_SMALLINT_UNSIGNED_NULL else ele for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_ushort))[
-                :abs(num_of_rows)]]
-    else:
-        return [
-            None if ele == FieldType.C_SMALLINT_UNSIGNED_NULL else ele for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_ushort))[
-                :abs(num_of_rows)]]
-
-
-def _crow_int_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C int row to python row
-    """
-    if num_of_rows > 0:
-        return [None if ele == FieldType.C_INT_NULL else ele for ele in ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_int))[:abs(num_of_rows)]]
-    else:
-        return [None if ele == FieldType.C_INT_NULL else ele for ele in ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_int))[:abs(num_of_rows)]]
-
-
-def _crow_int_unsigned_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C int row to python row
-    """
-    if num_of_rows > 0:
-        return [
-            None if ele == FieldType.C_INT_UNSIGNED_NULL else ele for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_uint))[
-                :abs(num_of_rows)]]
-    else:
-        return [
-            None if ele == FieldType.C_INT_UNSIGNED_NULL else ele for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_uint))[
-                :abs(num_of_rows)]]
-
-
-def _crow_bigint_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C bigint row to python row
-    """
-    if num_of_rows > 0:
-        return [None if ele == FieldType.C_BIGINT_NULL else ele for ele in ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_int64))[:abs(num_of_rows)]]
-    else:
-        return [None if ele == FieldType.C_BIGINT_NULL else ele for ele in ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_int64))[:abs(num_of_rows)]]
-
-
-def _crow_bigint_unsigned_to_python(
-        data,
-        num_of_rows,
-        nbytes=None,
-        micro=False):
-    """Function to convert C bigint row to python row
-    """
-    if num_of_rows > 0:
-        return [
-            None if ele == FieldType.C_BIGINT_UNSIGNED_NULL else ele for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_uint64))[
-                :abs(num_of_rows)]]
-    else:
-        return [
-            None if ele == FieldType.C_BIGINT_UNSIGNED_NULL else ele for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_uint64))[
-                :abs(num_of_rows)]]
-
-
-def _crow_float_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C float row to python row
-    """
-    if num_of_rows > 0:
-        return [None if math.isnan(ele) else ele for ele in ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_float))[:abs(num_of_rows)]]
-    else:
-        return [None if math.isnan(ele) else ele for ele in ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_float))[:abs(num_of_rows)]]
-
-
-def _crow_double_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C double row to python row
-    """
-    if num_of_rows > 0:
-        return [None if math.isnan(ele) else ele for ele in ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_double))[:abs(num_of_rows)]]
-    else:
-        return [None if math.isnan(ele) else ele for ele in ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_double))[:abs(num_of_rows)]]
-
-
-def _crow_binary_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C binary row to python row
-    """
-    assert(nbytes is not None)
-    if num_of_rows > 0:
-        return [None if ele.value[0:1] == FieldType.C_BINARY_NULL else ele.value.decode(
-            'utf-8') for ele in (ctypes.cast(data, ctypes.POINTER(ctypes.c_char * nbytes)))[:abs(num_of_rows)]]
-    else:
-        return [None if ele.value[0:1] == FieldType.C_BINARY_NULL else ele.value.decode(
-            'utf-8') for ele in (ctypes.cast(data, ctypes.POINTER(ctypes.c_char * nbytes)))[:abs(num_of_rows)]]
-
-
-def _crow_nchar_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C nchar row to python row
-    """
-    assert(nbytes is not None)
-    res = []
-    for i in range(abs(num_of_rows)):
-        try:
-            if num_of_rows >= 0:
-                tmpstr = ctypes.c_char_p(data)
-                res.append(tmpstr.value.decode())
-            else:
-                res.append((ctypes.cast(data + nbytes * i,
-                                        ctypes.POINTER(ctypes.c_wchar * (nbytes // 4))))[0].value)
-        except ValueError:
-            res.append(None)
-
-    return res
-
-
-def _crow_binary_to_python_block(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C binary row to python row
-    """
-    assert(nbytes is not None)
-    res = []
-    if num_of_rows > 0:
-        for i in range(abs(num_of_rows)):
-            try:
-                rbyte = ctypes.cast(
-                    data + nbytes * i,
-                    ctypes.POINTER(
-                        ctypes.c_short))[
-                    :1].pop()
-                tmpstr = ctypes.c_char_p(data + nbytes * i + 2)
-                res.append(tmpstr.value.decode()[0:rbyte])
-            except ValueError:
-                res.append(None)
-    else:
-        for i in range(abs(num_of_rows)):
-            try:
-                rbyte = ctypes.cast(
-                    data + nbytes * i,
-                    ctypes.POINTER(
-                        ctypes.c_short))[
-                    :1].pop()
-                tmpstr = ctypes.c_char_p(data + nbytes * i + 2)
-                res.append(tmpstr.value.decode()[0:rbyte])
-            except ValueError:
-                res.append(None)
-    return res
-
-
-def _crow_nchar_to_python_block(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C nchar row to python row
-    """
-    assert(nbytes is not None)
-    res = []
-    if num_of_rows >= 0:
-        for i in range(abs(num_of_rows)):
-            try:
-                tmpstr = ctypes.c_char_p(data + nbytes * i + 2)
-                res.append(tmpstr.value.decode())
-            except ValueError:
-                res.append(None)
-    else:
-        for i in range(abs(num_of_rows)):
-            try:
-                res.append((ctypes.cast(data + nbytes * i + 2,
-                                        ctypes.POINTER(ctypes.c_wchar * (nbytes // 4))))[0].value)
-            except ValueError:
-                res.append(None)
-    return res
-
-
-_CONVERT_FUNC = {
-    FieldType.C_BOOL: _crow_bool_to_python,
-    FieldType.C_TINYINT: _crow_tinyint_to_python,
-    FieldType.C_SMALLINT: _crow_smallint_to_python,
-    FieldType.C_INT: _crow_int_to_python,
-    FieldType.C_BIGINT: _crow_bigint_to_python,
-    FieldType.C_FLOAT: _crow_float_to_python,
-    FieldType.C_DOUBLE: _crow_double_to_python,
-    FieldType.C_BINARY: _crow_binary_to_python,
-    FieldType.C_TIMESTAMP: _crow_timestamp_to_python,
-    FieldType.C_NCHAR: _crow_nchar_to_python,
-    FieldType.C_TINYINT_UNSIGNED: _crow_tinyint_unsigned_to_python,
-    FieldType.C_SMALLINT_UNSIGNED: _crow_smallint_unsigned_to_python,
-    FieldType.C_INT_UNSIGNED: _crow_int_unsigned_to_python,
-    FieldType.C_BIGINT_UNSIGNED: _crow_bigint_unsigned_to_python
-}
-
-_CONVERT_FUNC_BLOCK = {
-    FieldType.C_BOOL: _crow_bool_to_python,
-    FieldType.C_TINYINT: _crow_tinyint_to_python,
-    FieldType.C_SMALLINT: _crow_smallint_to_python,
-    FieldType.C_INT: _crow_int_to_python,
-    FieldType.C_BIGINT: _crow_bigint_to_python,
-    FieldType.C_FLOAT: _crow_float_to_python,
-    FieldType.C_DOUBLE: _crow_double_to_python,
-    FieldType.C_BINARY: _crow_binary_to_python_block,
-    FieldType.C_TIMESTAMP: _crow_timestamp_to_python,
-    FieldType.C_NCHAR: _crow_nchar_to_python_block,
-    FieldType.C_TINYINT_UNSIGNED: _crow_tinyint_unsigned_to_python,
-    FieldType.C_SMALLINT_UNSIGNED: _crow_smallint_unsigned_to_python,
-    FieldType.C_INT_UNSIGNED: _crow_int_unsigned_to_python,
-    FieldType.C_BIGINT_UNSIGNED: _crow_bigint_unsigned_to_python
-}
-
-# Corresponding TAOS_FIELD structure in C
-
-
-class TaosField(ctypes.Structure):
-    _fields_ = [('name', ctypes.c_char * 65),
-                ('type', ctypes.c_char),
-                ('bytes', ctypes.c_short)]
-
-# C interface class
-
-
-class CTaosInterface(object):
-
-    libtaos = ctypes.CDLL('libtaos.so')
-
-    libtaos.taos_fetch_fields.restype = ctypes.POINTER(TaosField)
-    libtaos.taos_init.restype = None
-    libtaos.taos_connect.restype = ctypes.c_void_p
-    #libtaos.taos_use_result.restype = ctypes.c_void_p
-    libtaos.taos_fetch_row.restype = ctypes.POINTER(ctypes.c_void_p)
-    libtaos.taos_errstr.restype = ctypes.c_char_p
-    libtaos.taos_subscribe.restype = ctypes.c_void_p
-    libtaos.taos_consume.restype = ctypes.c_void_p
-    libtaos.taos_fetch_lengths.restype = ctypes.c_void_p
-    libtaos.taos_free_result.restype = None
-    libtaos.taos_errno.restype = ctypes.c_int
-    libtaos.taos_query.restype = ctypes.POINTER(ctypes.c_void_p)
-
-    def __init__(self, config=None):
-        '''
-        Function to initialize the class
-        @host     : str, hostname to connect
-        @user     : str, username to connect to server
-        @password : str, password to connect to server
-        @db       : str, default db to use when log in
-        @config   : str, config directory
-
-        @rtype    : None
-        '''
-        if config is None:
-            self._config = ctypes.c_char_p(None)
-        else:
-            try:
-                self._config = ctypes.c_char_p(config.encode('utf-8'))
-            except AttributeError:
-                raise AttributeError("config is expected as a str")
-
-        if config is not None:
-            CTaosInterface.libtaos.taos_options(3, self._config)
-
-        CTaosInterface.libtaos.taos_init()
-
-    @property
-    def config(self):
-        """ Get current config
-        """
-        return self._config
-
-    def connect(
-            self,
-            host=None,
-            user="root",
-            password="taosdata",
-            db=None,
-            port=0):
-        '''
-        Function to connect to server
-
-        @rtype: c_void_p, TDengine handle
-        '''
-        # host
-        try:
-            _host = ctypes.c_char_p(host.encode(
-                "utf-8")) if host is not None else ctypes.c_char_p(None)
-        except AttributeError:
-            raise AttributeError("host is expected as a str")
-
-        # user
-        try:
-            _user = ctypes.c_char_p(user.encode("utf-8"))
-        except AttributeError:
-            raise AttributeError("user is expected as a str")
-
-        # password
-        try:
-            _password = ctypes.c_char_p(password.encode("utf-8"))
-        except AttributeError:
-            raise AttributeError("password is expected as a str")
-
-        # db
-        try:
-            _db = ctypes.c_char_p(
-                db.encode("utf-8")) if db is not None else ctypes.c_char_p(None)
-        except AttributeError:
-            raise AttributeError("db is expected as a str")
-
-        # port
-        try:
-            _port = ctypes.c_int(port)
-        except TypeError:
-            raise TypeError("port is expected as an int")
-
-        connection = ctypes.c_void_p(CTaosInterface.libtaos.taos_connect(
-            _host, _user, _password, _db, _port))
-
-        if connection.value is None:
-            print('connect to TDengine failed')
-            raise ConnectionError("connect to TDengine failed")
-            # sys.exit(1)
-        # else:
-        #    print('connect to TDengine success')
-
-        return connection
-
-    @staticmethod
-    def close(connection):
-        '''Close the TDengine handle
-        '''
-        CTaosInterface.libtaos.taos_close(connection)
-        #print('connection is closed')
-
-    @staticmethod
-    def query(connection, sql):
-        '''Run SQL
-
-        @sql: str, sql string to run
-
-        @rtype: 0 on success and -1 on failure
-        '''
-        try:
-            return CTaosInterface.libtaos.taos_query(
-                connection, ctypes.c_char_p(sql.encode('utf-8')))
-        except AttributeError:
-            raise AttributeError("sql is expected as a string")
-        # finally:
-        #     CTaosInterface.libtaos.close(connection)
-
-    @staticmethod
-    def affectedRows(result):
-        """The affected rows after runing query
-        """
-        return CTaosInterface.libtaos.taos_affected_rows(result)
-
-    @staticmethod
-    def subscribe(connection, restart, topic, sql, interval):
-        """Create a subscription
-         @restart boolean,
-         @sql string, sql statement for data query, must be a 'select' statement.
-         @topic string, name of this subscription
-        """
-        return ctypes.c_void_p(CTaosInterface.libtaos.taos_subscribe(
-            connection,
-            1 if restart else 0,
-            ctypes.c_char_p(topic.encode('utf-8')),
-            ctypes.c_char_p(sql.encode('utf-8')),
-            None,
-            None,
-            interval))
-
-    @staticmethod
-    def consume(sub):
-        """Consume data of a subscription
-        """
-        result = ctypes.c_void_p(CTaosInterface.libtaos.taos_consume(sub))
-        fields = []
-        pfields = CTaosInterface.fetchFields(result)
-        for i in range(CTaosInterface.libtaos.taos_num_fields(result)):
-            fields.append({'name': pfields[i].name.decode('utf-8'),
-                           'bytes': pfields[i].bytes,
-                           'type': ord(pfields[i].type)})
-        return result, fields
-
-    @staticmethod
-    def unsubscribe(sub, keepProgress):
-        """Cancel a subscription
-        """
-        CTaosInterface.libtaos.taos_unsubscribe(sub, 1 if keepProgress else 0)
-
-    @staticmethod
-    def useResult(result):
-        '''Use result after calling self.query
-        '''
-        fields = []
-        pfields = CTaosInterface.fetchFields(result)
-        for i in range(CTaosInterface.fieldsCount(result)):
-            fields.append({'name': pfields[i].name.decode('utf-8'),
-                           'bytes': pfields[i].bytes,
-                           'type': ord(pfields[i].type)})
-
-        return fields
-
-    @staticmethod
-    def fetchBlock(result, fields):
-        pblock = ctypes.c_void_p(0)
-        num_of_rows = CTaosInterface.libtaos.taos_fetch_block(
-            result, ctypes.byref(pblock))
-        if num_of_rows == 0:
-            return None, 0
-        isMicro = (CTaosInterface.libtaos.taos_result_precision(
-            result) == FieldType.C_TIMESTAMP_MICRO)
-        blocks = [None] * len(fields)
-        fieldL = CTaosInterface.libtaos.taos_fetch_lengths(result)
-        fieldLen = [
-            ele for ele in ctypes.cast(
-                fieldL, ctypes.POINTER(
-                    ctypes.c_int))[
-                :len(fields)]]
-        for i in range(len(fields)):
-            data = ctypes.cast(pblock, ctypes.POINTER(ctypes.c_void_p))[i]
-            if fields[i]['type'] not in _CONVERT_FUNC_BLOCK:
-                raise DatabaseError("Invalid data type returned from database")
-            blocks[i] = _CONVERT_FUNC_BLOCK[fields[i]['type']](
-                data, num_of_rows, fieldLen[i], isMicro)
-
-        return blocks, abs(num_of_rows)
-
-    @staticmethod
-    def fetchRow(result, fields):
-        pblock = ctypes.c_void_p(0)
-        pblock = CTaosInterface.libtaos.taos_fetch_row(result)
-        if pblock:
-            num_of_rows = 1
-            isMicro = (CTaosInterface.libtaos.taos_result_precision(
-                result) == FieldType.C_TIMESTAMP_MICRO)
-            blocks = [None] * len(fields)
-            fieldL = CTaosInterface.libtaos.taos_fetch_lengths(result)
-            fieldLen = [
-                ele for ele in ctypes.cast(
-                    fieldL, ctypes.POINTER(
-                        ctypes.c_int))[
-                    :len(fields)]]
-            for i in range(len(fields)):
-                data = ctypes.cast(pblock, ctypes.POINTER(ctypes.c_void_p))[i]
-                if fields[i]['type'] not in _CONVERT_FUNC:
-                    raise DatabaseError(
-                        "Invalid data type returned from database")
-                if data is None:
-                    blocks[i] = [None]
-                else:
-                    blocks[i] = _CONVERT_FUNC[fields[i]['type']](
-                        data, num_of_rows, fieldLen[i], isMicro)
-        else:
-            return None, 0
-        return blocks, abs(num_of_rows)
-
-    @staticmethod
-    def freeResult(result):
-        CTaosInterface.libtaos.taos_free_result(result)
-        result.value = None
-
-    @staticmethod
-    def fieldsCount(result):
-        return CTaosInterface.libtaos.taos_field_count(result)
-
-    @staticmethod
-    def fetchFields(result):
-        return CTaosInterface.libtaos.taos_fetch_fields(result)
-
-    # @staticmethod
-    # def fetchRow(result, fields):
-    #     l = []
-    #     row = CTaosInterface.libtaos.taos_fetch_row(result)
-    #     if not row:
-    #         return None
-
-    #     for i in range(len(fields)):
-    #         l.append(CTaosInterface.getDataValue(
-    #             row[i], fields[i]['type'], fields[i]['bytes']))
-
-    #     return tuple(l)
-
-    # @staticmethod
-    # def getDataValue(data, dtype, byte):
-    #     '''
-    #     '''
-    #     if not data:
-    #         return None
-
-    #     if (dtype == CTaosInterface.TSDB_DATA_TYPE_BOOL):
-    #         return ctypes.cast(data,  ctypes.POINTER(ctypes.c_bool))[0]
-    #     elif (dtype == CTaosInterface.TSDB_DATA_TYPE_TINYINT):
-    #         return ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[0]
-    #     elif (dtype == CTaosInterface.TSDB_DATA_TYPE_SMALLINT):
-    #         return ctypes.cast(data,  ctypes.POINTER(ctypes.c_short))[0]
-    #     elif (dtype == CTaosInterface.TSDB_DATA_TYPE_INT):
-    #         return ctypes.cast(data,  ctypes.POINTER(ctypes.c_int))[0]
-    #     elif (dtype == CTaosInterface.TSDB_DATA_TYPE_BIGINT):
-    #         return ctypes.cast(data,  ctypes.POINTER(ctypes.c_int64))[0]
-    #     elif (dtype == CTaosInterface.TSDB_DATA_TYPE_FLOAT):
-    #         return ctypes.cast(data,  ctypes.POINTER(ctypes.c_float))[0]
-    #     elif (dtype == CTaosInterface.TSDB_DATA_TYPE_DOUBLE):
-    #         return ctypes.cast(data,  ctypes.POINTER(ctypes.c_double))[0]
-    #     elif (dtype == CTaosInterface.TSDB_DATA_TYPE_BINARY):
-    #         return (ctypes.cast(data,  ctypes.POINTER(ctypes.c_char))[0:byte]).rstrip('\x00')
-    #     elif (dtype == CTaosInterface.TSDB_DATA_TYPE_TIMESTAMP):
-    #         return ctypes.cast(data,  ctypes.POINTER(ctypes.c_int64))[0]
-    #     elif (dtype == CTaosInterface.TSDB_DATA_TYPE_NCHAR):
-    #         return (ctypes.cast(data,  ctypes.c_char_p).value).rstrip('\x00')
-
-    @staticmethod
-    def errno(result):
-        """Return the error number.
-        """
-        return CTaosInterface.libtaos.taos_errno(result)
-
-    @staticmethod
-    def errStr(result):
-        """Return the error styring
-        """
-        return CTaosInterface.libtaos.taos_errstr(result).decode('utf-8')
-
-
-if __name__ == '__main__':
-    cinter = CTaosInterface()
-    conn = cinter.connect()
-    result = cinter.query(conn, 'show databases')
-
-    print('Query Affected rows: {}'.format(cinter.affectedRows(result)))
-
-    fields = CTaosInterface.useResult(result)
-
-    data, num_of_rows = CTaosInterface.fetchBlock(result, fields)
-
-    print(data)
-
-    cinter.freeResult(result)
-    cinter.close(conn)

src/connector/python/linux/python2/taos/cursor.py

@@ -1,278 +0,0 @@
-from .cinterface import CTaosInterface
-from .error import *
-from .constants import FieldType
-
-
-class TDengineCursor(object):
-    """Database cursor which is used to manage the context of a fetch operation.
-
-    Attributes:
-        .description: Read-only attribute consists of 7-item sequences:
-
-            > name (mondatory)
-            > type_code (mondatory)
-            > display_size
-            > internal_size
-            > precision
-            > scale
-            > null_ok
-
-            This attribute will be None for operations that do not return rows or
-            if the cursor has not had an operation invoked via the .execute*() method yet.
-
-        .rowcount:This read-only attribute specifies the number of rows that the last
-            .execute*() produced (for DQL statements like SELECT) or affected
-    """
-
-    def __init__(self, connection=None):
-        self._description = []
-        self._rowcount = -1
-        self._connection = None
-        self._result = None
-        self._fields = None
-        self._block = None
-        self._block_rows = -1
-        self._block_iter = 0
-        self._affected_rows = 0
-        self._logfile = ""
-
-        if connection is not None:
-            self._connection = connection
-
-    def __iter__(self):
-        return self
-
-    def next(self):
-        if self._result is None or self._fields is None:
-            raise OperationalError("Invalid use of fetch iterator")
-
-        if self._block_rows <= self._block_iter:
-            block, self._block_rows = CTaosInterface.fetchRow(
-                self._result, self._fields)
-            if self._block_rows == 0:
-                raise StopIteration
-            self._block = list(map(tuple, zip(*block)))
-            self._block_iter = 0
-
-        data = self._block[self._block_iter]
-        self._block_iter += 1
-
-        return data
-
-    @property
-    def description(self):
-        """Return the description of the object.
-        """
-        return self._description
-
-    @property
-    def rowcount(self):
-        """Return the rowcount of the object
-        """
-        return self._rowcount
-
-    @property
-    def affected_rows(self):
-        """Return the affected_rows of the object
-        """
-        return self._affected_rows
-
-    def callproc(self, procname, *args):
-        """Call a stored database procedure with the given name.
-
-        Void functionality since no stored procedures.
-        """
-        pass
-
-    def log(self, logfile):
-        self._logfile = logfile
-
-    def close(self):
-        """Close the cursor.
-        """
-        if self._connection is None:
-            return False
-
-        self._reset_result()
-        self._connection = None
-
-        return True
-
-    def execute(self, operation, params=None):
-        """Prepare and execute a database operation (query or command).
-        """
-        if not operation:
-            return None
-
-        if not self._connection:
-            # TODO : change the exception raised here
-            raise ProgrammingError("Cursor is not connected")
-
-        self._reset_result()
-
-        stmt = operation
-        if params is not None:
-            pass
-
-        # global querySeqNum
-        # querySeqNum += 1
-        # localSeqNum = querySeqNum # avoid raice condition
-        # print("   >> Exec Query ({}): {}".format(localSeqNum, str(stmt)))
-        self._result = CTaosInterface.query(self._connection._conn, stmt)
-        # print("   << Query ({}) Exec Done".format(localSeqNum))
-        if (self._logfile):
-            with open(self._logfile, "a") as logfile:
-                logfile.write("%s;\n" % operation)
-
-        errno = CTaosInterface.libtaos.taos_errno(self._result)
-        if errno == 0:
-            if CTaosInterface.fieldsCount(self._result) == 0:
-                self._affected_rows += CTaosInterface.affectedRows(
-                    self._result)
-                return CTaosInterface.affectedRows(self._result)
-            else:
-                self._fields = CTaosInterface.useResult(
-                    self._result)
-                return self._handle_result()
-        else:
-            raise ProgrammingError(
-                CTaosInterface.errStr(
-                    self._result), errno)
-
-    def executemany(self, operation, seq_of_parameters):
-        """Prepare a database operation (query or command) and then execute it against all parameter sequences or mappings found in the sequence seq_of_parameters.
-        """
-        pass
-
-    def fetchone(self):
-        """Fetch the next row of a query result set, returning a single sequence, or None when no more data is available.
-        """
-        pass
-
-    def fetchmany(self):
-        pass
-
-    def istype(self, col, dataType):
-        if (dataType.upper() == "BOOL"):
-            if (self._description[col][1] == FieldType.C_BOOL):
-                return True
-        if (dataType.upper() == "TINYINT"):
-            if (self._description[col][1] == FieldType.C_TINYINT):
-                return True
-        if (dataType.upper() == "TINYINT UNSIGNED"):
-            if (self._description[col][1] == FieldType.C_TINYINT_UNSIGNED):
-                return True
-        if (dataType.upper() == "SMALLINT"):
-            if (self._description[col][1] == FieldType.C_SMALLINT):
-                return True
-        if (dataType.upper() == "SMALLINT UNSIGNED"):
-            if (self._description[col][1] == FieldType.C_SMALLINT_UNSIGNED):
-                return True
-        if (dataType.upper() == "INT"):
-            if (self._description[col][1] == FieldType.C_INT):
-                return True
-        if (dataType.upper() == "INT UNSIGNED"):
-            if (self._description[col][1] == FieldType.C_INT_UNSIGNED):
-                return True
-        if (dataType.upper() == "BIGINT"):
-            if (self._description[col][1] == FieldType.C_BIGINT):
-                return True
-        if (dataType.upper() == "BIGINT UNSIGNED"):
-            if (self._description[col][1] == FieldType.C_BIGINT_UNSIGNED):
-                return True
-        if (dataType.upper() == "FLOAT"):
-            if (self._description[col][1] == FieldType.C_FLOAT):
-                return True
-        if (dataType.upper() == "DOUBLE"):
-            if (self._description[col][1] == FieldType.C_DOUBLE):
-                return True
-        if (dataType.upper() == "BINARY"):
-            if (self._description[col][1] == FieldType.C_BINARY):
-                return True
-        if (dataType.upper() == "TIMESTAMP"):
-            if (self._description[col][1] == FieldType.C_TIMESTAMP):
-                return True
-        if (dataType.upper() == "NCHAR"):
-            if (self._description[col][1] == FieldType.C_NCHAR):
-                return True
-
-        return False
-
-    def fetchall_row(self):
-        """Fetch all (remaining) rows of a query result, returning them as a sequence of sequences (e.g. a list of tuples). Note that the cursor's arraysize attribute can affect the performance of this operation.
-        """
-        if self._result is None or self._fields is None:
-            raise OperationalError("Invalid use of fetchall")
-
-        buffer = [[] for i in range(len(self._fields))]
-        self._rowcount = 0
-        while True:
-            block, num_of_fields = CTaosInterface.fetchRow(
-                self._result, self._fields)
-            errno = CTaosInterface.libtaos.taos_errno(self._result)
-            if errno != 0:
-                raise ProgrammingError(
-                    CTaosInterface.errStr(
-                        self._result), errno)
-            if num_of_fields == 0:
-                break
-            self._rowcount += num_of_fields
-            for i in range(len(self._fields)):
-                buffer[i].extend(block[i])
-        return list(map(tuple, zip(*buffer)))
-
-    def fetchall(self):
-        if self._result is None or self._fields is None:
-            raise OperationalError("Invalid use of fetchall")
-
-        buffer = [[] for i in range(len(self._fields))]
-        self._rowcount = 0
-        while True:
-            block, num_of_fields = CTaosInterface.fetchBlock(
-                self._result, self._fields)
-            errno = CTaosInterface.libtaos.taos_errno(self._result)
-            if errno != 0:
-                raise ProgrammingError(
-                    CTaosInterface.errStr(
-                        self._result), errno)
-            if num_of_fields == 0:
-                break
-            self._rowcount += num_of_fields
-            for i in range(len(self._fields)):
-                buffer[i].extend(block[i])
-        return list(map(tuple, zip(*buffer)))
-
-    def nextset(self):
-        """
-        """
-        pass
-
-    def setinputsize(self, sizes):
-        pass
-
-    def setutputsize(self, size, column=None):
-        pass
-
-    def _reset_result(self):
-        """Reset the result to unused version.
-        """
-        self._description = []
-        self._rowcount = -1
-        if self._result is not None:
-            CTaosInterface.freeResult(self._result)
-        self._result = None
-        self._fields = None
-        self._block = None
-        self._block_rows = -1
-        self._block_iter = 0
-        self._affected_rows = 0
-
-    def _handle_result(self):
-        """Handle the return result from query.
-        """
-        self._description = []
-        for ele in self._fields:
-            self._description.append(
-                (ele['name'], ele['type'], None, None, None, None, False))
-
-        return self._result

src/connector/python/linux/python3

@@ -0,0 +1 @@
+../

src/connector/python/linux/python3/LICENSE

@@ -1,12 +0,0 @@
-  Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
-
-This program is free software: you can use, redistribute, and/or modify
-it under the terms of the GNU Affero General Public License, version 3
-or later ("AGPL"), as published by the Free Software Foundation.
-
-This program is distributed in the hope that it will be useful, but WITHOUT
-ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program. If not, see <http://www.gnu.org/licenses/>.

src/connector/python/linux/python3/README.md

@@ -1 +0,0 @@
-# TDengine python client interface

src/connector/python/linux/python3/setup.py

@@ -1,20 +0,0 @@
-import setuptools
-
-with open("README.md", "r") as fh:
-    long_description = fh.read()
-
-setuptools.setup(
-    name="taos",
-    version="2.0.7",
-    author="Taosdata Inc.",
-    author_email="support@taosdata.com",
-    description="TDengine python client package",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    url="https://github.com/pypa/sampleproject",
-    packages=setuptools.find_packages(),
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "Operating System :: Linux",
-    ],
-)

src/connector/python/linux/python3/taos/__init__.py

@@ -1,24 +0,0 @@
-
-from .connection import TDengineConnection
-from .cursor import TDengineCursor
-
-# Globals
-threadsafety = 0
-paramstyle = 'pyformat'
-
-__all__ = ['connection', 'cursor']
-
-
-def connect(*args, **kwargs):
-    """ Function to return a TDengine connector object
-
-    Current supporting keyword parameters:
-    @dsn: Data source name as string
-    @user: Username as string(optional)
-    @password: Password as string(optional)
-    @host: Hostname(optional)
-    @database: Database name(optional)
-
-    @rtype: TDengineConnector
-    """
-    return TDengineConnection(*args, **kwargs)

src/connector/python/linux/python3/taos/connection.py

@@ -1,95 +0,0 @@
-from .cursor import TDengineCursor
-from .subscription import TDengineSubscription
-from .cinterface import CTaosInterface
-
-
-class TDengineConnection(object):
-    """ TDengine connection object
-    """
-
-    def __init__(self, *args, **kwargs):
-        self._conn = None
-        self._host = None
-        self._user = "root"
-        self._password = "taosdata"
-        self._database = None
-        self._port = 0
-        self._config = None
-        self._chandle = None
-
-        self.config(**kwargs)
-
-    def config(self, **kwargs):
-        # host
-        if 'host' in kwargs:
-            self._host = kwargs['host']
-
-        # user
-        if 'user' in kwargs:
-            self._user = kwargs['user']
-
-        # password
-        if 'password' in kwargs:
-            self._password = kwargs['password']
-
-        # database
-        if 'database' in kwargs:
-            self._database = kwargs['database']
-
-        # port
-        if 'port' in kwargs:
-            self._port = kwargs['port']
-
-        # config
-        if 'config' in kwargs:
-            self._config = kwargs['config']
-
-        self._chandle = CTaosInterface(self._config)
-        self._conn = self._chandle.connect(
-            self._host,
-            self._user,
-            self._password,
-            self._database,
-            self._port)
-
-    def close(self):
-        """Close current connection.
-        """
-        return CTaosInterface.close(self._conn)
-
-    def subscribe(self, restart, topic, sql, interval):
-        """Create a subscription.
-        """
-        if self._conn is None:
-            return None
-        sub = CTaosInterface.subscribe(
-            self._conn, restart, topic, sql, interval)
-        return TDengineSubscription(sub)
-
-    def cursor(self):
-        """Return a new Cursor object using the connection.
-        """
-        return TDengineCursor(self)
-
-    def commit(self):
-        """Commit any pending transaction to the database.
-
-        Since TDengine do not support transactions, the implement is void functionality.
-        """
-        pass
-
-    def rollback(self):
-        """Void functionality
-        """
-        pass
-
-    def clear_result_set(self):
-        """Clear unused result set on this connection.
-        """
-        pass
-
-
-if __name__ == "__main__":
-    conn = TDengineConnection(host='192.168.1.107')
-    conn.close()
-    print("Hello world")

src/connector/python/linux/python3/taos/constants.py

@@ -1,42 +0,0 @@
-"""Constants in TDengine python
-"""
-
-from .dbapi import *
-
-
-class FieldType(object):
-    """TDengine Field Types
-    """
-    # type_code
-    C_NULL = 0
-    C_BOOL = 1
-    C_TINYINT = 2
-    C_SMALLINT = 3
-    C_INT = 4
-    C_BIGINT = 5
-    C_FLOAT = 6
-    C_DOUBLE = 7
-    C_BINARY = 8
-    C_TIMESTAMP = 9
-    C_NCHAR = 10
-    C_TINYINT_UNSIGNED = 11
-    C_SMALLINT_UNSIGNED = 12
-    C_INT_UNSIGNED = 13
-    C_BIGINT_UNSIGNED = 14
-    # NULL value definition
-    # NOTE: These values should change according to C definition in tsdb.h
-    C_BOOL_NULL = 0x02
-    C_TINYINT_NULL = -128
-    C_TINYINT_UNSIGNED_NULL = 255
-    C_SMALLINT_NULL = -32768
-    C_SMALLINT_UNSIGNED_NULL = 65535
-    C_INT_NULL = -2147483648
-    C_INT_UNSIGNED_NULL = 4294967295
-    C_BIGINT_NULL = -9223372036854775808
-    C_BIGINT_UNSIGNED_NULL = 18446744073709551615
-    C_FLOAT_NULL = float('nan')
-    C_DOUBLE_NULL = float('nan')
-    C_BINARY_NULL = bytearray([int('0xff', 16)])
-    # Timestamp precision definition
-    C_TIMESTAMP_MILLI = 0
-    C_TIMESTAMP_MICRO = 1

src/connector/python/linux/python3/taos/dbapi.py

@@ -1,44 +0,0 @@
-"""Type Objects and Constructors.
-"""
-
-import time
-import datetime
-
-
-class DBAPITypeObject(object):
-    def __init__(self, *values):
-        self.values = values
-
-    def __com__(self, other):
-        if other in self.values:
-            return 0
-        if other < self.values:
-            return 1
-        else:
-            return -1
-
-
-Date = datetime.date
-Time = datetime.time
-Timestamp = datetime.datetime
-
-
-def DataFromTicks(ticks):
-    return Date(*time.localtime(ticks)[:3])
-
-
-def TimeFromTicks(ticks):
-    return Time(*time.localtime(ticks)[3:6])
-
-
-def TimestampFromTicks(ticks):
-    return Timestamp(*time.localtime(ticks)[:6])
-
-
-Binary = bytes
-
-# STRING = DBAPITypeObject(*constants.FieldType.get_string_types())
-# BINARY = DBAPITypeObject(*constants.FieldType.get_binary_types())
-# NUMBER = BAPITypeObject(*constants.FieldType.get_number_types())
-# DATETIME = DBAPITypeObject(*constants.FieldType.get_timestamp_types())
-# ROWID = DBAPITypeObject()

src/connector/python/linux/python3/taos/error.py

@@ -1,66 +0,0 @@
-"""Python exceptions
-"""
-
-
-class Error(Exception):
-    def __init__(self, msg=None, errno=None):
-        self.msg = msg
-        self._full_msg = self.msg
-        self.errno = errno
-
-    def __str__(self):
-        return self._full_msg
-
-
-class Warning(Exception):
-    """Exception raised for important warnings like data truncations while inserting.
-    """
-    pass
-
-
-class InterfaceError(Error):
-    """Exception raised for errors that are related to the database interface rather than the database itself.
-    """
-    pass
-
-
-class DatabaseError(Error):
-    """Exception raised for errors that are related to the database.
-    """
-    pass
-
-
-class DataError(DatabaseError):
-    """Exception raised for errors that are due to problems with the processed data like division by zero, numeric value out of range.
-    """
-    pass
-
-
-class OperationalError(DatabaseError):
-    """Exception raised for errors that are related to the database's operation and not necessarily under the control of the programmer
-    """
-    pass
-
-
-class IntegrityError(DatabaseError):
-    """Exception raised when the relational integrity of the database is affected.
-    """
-    pass
-
-
-class InternalError(DatabaseError):
-    """Exception raised when the database encounters an internal error.
-    """
-    pass
-
-
-class ProgrammingError(DatabaseError):
-    """Exception raised for programming errors.
-    """
-    pass
-
-
-class NotSupportedError(DatabaseError):
-    """Exception raised in case a method or database API was used which is not supported by the database,.
-    """
-    pass

src/connector/python/linux/python3/taos/subscription.py

@@ -1,57 +0,0 @@
-from .cinterface import CTaosInterface
-from .error import *
-
-
-class TDengineSubscription(object):
-    """TDengine subscription object
-    """
-
-    def __init__(self, sub):
-        self._sub = sub
-
-    def consume(self):
-        """Consume rows of a subscription
-        """
-        if self._sub is None:
-            raise OperationalError("Invalid use of consume")
-
-        result, fields = CTaosInterface.consume(self._sub)
-        buffer = [[] for i in range(len(fields))]
-        while True:
-            block, num_of_fields = CTaosInterface.fetchBlock(result, fields)
-            if num_of_fields == 0:
-                break
-            for i in range(len(fields)):
-                buffer[i].extend(block[i])
-
-        self.fields = fields
-        return list(map(tuple, zip(*buffer)))
-
-    def close(self, keepProgress=True):
-        """Close the Subscription.
-        """
-        if self._sub is None:
-            return False
-
-        CTaosInterface.unsubscribe(self._sub, keepProgress)
-        return True
-
-
-if __name__ == '__main__':
-    from .connection import TDengineConnection
-    conn = TDengineConnection(
-        host="127.0.0.1",
-        user="root",
-        password="taosdata",
-        database="test")
-
-    # Generate a cursor object to run SQL commands
-    sub = conn.subscribe(True, "test", "select * from meters;", 1000)
-
-    for i in range(0, 10):
-        data = sub.consume()
-        for d in data:
-            print(d)
-
-    sub.close()
-    conn.close()

src/connector/python/osx/python3

@@ -0,0 +1 @@
+../

src/connector/python/osx/python3/LICENSE

@@ -1,12 +0,0 @@
-  Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
-
-This program is free software: you can use, redistribute, and/or modify
-it under the terms of the GNU Affero General Public License, version 3
-or later ("AGPL"), as published by the Free Software Foundation.
-
-This program is distributed in the hope that it will be useful, but WITHOUT
-ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program. If not, see <http://www.gnu.org/licenses/>.

src/connector/python/osx/python3/README.md

@@ -1 +0,0 @@
-# TDengine python client interface

src/connector/python/osx/python3/setup.py

@@ -1,20 +0,0 @@
-import setuptools
-
-with open("README.md", "r") as fh:
-    long_description = fh.read()
-
-setuptools.setup(
-    name="taos",
-    version="2.0.7",
-    author="Taosdata Inc.",
-    author_email="support@taosdata.com",
-    description="TDengine python client package",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    url="https://github.com/pypa/sampleproject",
-    packages=setuptools.find_packages(),
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "Operating System :: MacOS X",
-    ],
-)

src/connector/python/osx/python3/taos/__init__.py

@@ -1,24 +0,0 @@
-
-from .connection import TDengineConnection
-from .cursor import TDengineCursor
-
-# Globals
-threadsafety = 0
-paramstyle = 'pyformat'
-
-__all__ = ['connection', 'cursor']
-
-
-def connect(*args, **kwargs):
-    """ Function to return a TDengine connector object
-
-    Current supporting keyword parameters:
-    @dsn: Data source name as string
-    @user: Username as string(optional)
-    @password: Password as string(optional)
-    @host: Hostname(optional)
-    @database: Database name(optional)
-
-    @rtype: TDengineConnector
-    """
-    return TDengineConnection(*args, **kwargs)

src/connector/python/osx/python3/taos/cinterface.py

@@ -1,642 +0,0 @@
-import ctypes
-from .constants import FieldType
-from .error import *
-import math
-import datetime
-
-
-def _convert_millisecond_to_datetime(milli):
-    return datetime.datetime.fromtimestamp(milli / 1000.0)
-
-
-def _convert_microsecond_to_datetime(micro):
-    return datetime.datetime.fromtimestamp(micro / 1000000.0)
-
-
-def _crow_timestamp_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C bool row to python row
-    """
-    _timestamp_converter = _convert_millisecond_to_datetime
-    if micro:
-        _timestamp_converter = _convert_microsecond_to_datetime
-
-    if num_of_rows > 0:
-        return list(map(_timestamp_converter, ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_int64))[:abs(num_of_rows)]))
-    else:
-        return list(map(_timestamp_converter, ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_int64))[:abs(num_of_rows)]))
-
-
-def _crow_bool_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C bool row to python row
-    """
-    if num_of_rows > 0:
-        return [
-            None if ele == FieldType.C_BOOL_NULL else bool(ele) for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_byte))[
-                :abs(num_of_rows)]]
-    else:
-        return [
-            None if ele == FieldType.C_BOOL_NULL else bool(ele) for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_bool))[
-                :abs(num_of_rows)]]
-
-
-def _crow_tinyint_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C tinyint row to python row
-    """
-    if num_of_rows > 0:
-        return [None if ele == FieldType.C_TINYINT_NULL else ele for ele in ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)]]
-    else:
-        return [None if ele == FieldType.C_TINYINT_NULL else ele for ele in ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)]]
-
-
-def _crow_tinyint_unsigned_to_python(
-        data,
-        num_of_rows,
-        nbytes=None,
-        micro=False):
-    """Function to convert C tinyint row to python row
-    """
-    if num_of_rows > 0:
-        return [
-            None if ele == FieldType.C_TINYINT_UNSIGNED_NULL else ele for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_ubyte))[
-                :abs(num_of_rows)]]
-    else:
-        return [
-            None if ele == FieldType.C_TINYINT_UNSIGNED_NULL else ele for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_ubyte))[
-                :abs(num_of_rows)]]
-
-
-def _crow_smallint_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C smallint row to python row
-    """
-    if num_of_rows > 0:
-        return [
-            None if ele == FieldType.C_SMALLINT_NULL else ele for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_short))[
-                :abs(num_of_rows)]]
-    else:
-        return [
-            None if ele == FieldType.C_SMALLINT_NULL else ele for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_short))[
-                :abs(num_of_rows)]]
-
-
-def _crow_smallint_unsigned_to_python(
-        data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C smallint row to python row
-    """
-    if num_of_rows > 0:
-        return [
-            None if ele == FieldType.C_SMALLINT_UNSIGNED_NULL else ele for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_ushort))[
-                :abs(num_of_rows)]]
-    else:
-        return [
-            None if ele == FieldType.C_SMALLINT_UNSIGNED_NULL else ele for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_ushort))[
-                :abs(num_of_rows)]]
-
-
-def _crow_int_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C int row to python row
-    """
-    if num_of_rows > 0:
-        return [None if ele == FieldType.C_INT_NULL else ele for ele in ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_int))[:abs(num_of_rows)]]
-    else:
-        return [None if ele == FieldType.C_INT_NULL else ele for ele in ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_int))[:abs(num_of_rows)]]
-
-
-def _crow_int_unsigned_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C int row to python row
-    """
-    if num_of_rows > 0:
-        return [
-            None if ele == FieldType.C_INT_UNSIGNED_NULL else ele for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_uint))[
-                :abs(num_of_rows)]]
-    else:
-        return [
-            None if ele == FieldType.C_INT_UNSIGNED_NULL else ele for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_uint))[
-                :abs(num_of_rows)]]
-
-
-def _crow_bigint_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C bigint row to python row
-    """
-    if num_of_rows > 0:
-        return [None if ele == FieldType.C_BIGINT_NULL else ele for ele in ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_int64))[:abs(num_of_rows)]]
-    else:
-        return [None if ele == FieldType.C_BIGINT_NULL else ele for ele in ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_int64))[:abs(num_of_rows)]]
-
-
-def _crow_bigint_unsigned_to_python(
-        data,
-        num_of_rows,
-        nbytes=None,
-        micro=False):
-    """Function to convert C bigint row to python row
-    """
-    if num_of_rows > 0:
-        return [
-            None if ele == FieldType.C_BIGINT_UNSIGNED_NULL else ele for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_uint64))[
-                :abs(num_of_rows)]]
-    else:
-        return [
-            None if ele == FieldType.C_BIGINT_UNSIGNED_NULL else ele for ele in ctypes.cast(
-                data, ctypes.POINTER(
-                    ctypes.c_uint64))[
-                :abs(num_of_rows)]]
-
-
-def _crow_float_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C float row to python row
-    """
-    if num_of_rows > 0:
-        return [None if math.isnan(ele) else ele for ele in ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_float))[:abs(num_of_rows)]]
-    else:
-        return [None if math.isnan(ele) else ele for ele in ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_float))[:abs(num_of_rows)]]
-
-
-def _crow_double_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C double row to python row
-    """
-    if num_of_rows > 0:
-        return [None if math.isnan(ele) else ele for ele in ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_double))[:abs(num_of_rows)]]
-    else:
-        return [None if math.isnan(ele) else ele for ele in ctypes.cast(
-            data, ctypes.POINTER(ctypes.c_double))[:abs(num_of_rows)]]
-
-
-def _crow_binary_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C binary row to python row
-    """
-    assert(nbytes is not None)
-    if num_of_rows > 0:
-        return [None if ele.value[0:1] == FieldType.C_BINARY_NULL else ele.value.decode(
-            'utf-8') for ele in (ctypes.cast(data, ctypes.POINTER(ctypes.c_char * nbytes)))[:abs(num_of_rows)]]
-    else:
-        return [None if ele.value[0:1] == FieldType.C_BINARY_NULL else ele.value.decode(
-            'utf-8') for ele in (ctypes.cast(data, ctypes.POINTER(ctypes.c_char * nbytes)))[:abs(num_of_rows)]]
-
-
-def _crow_nchar_to_python(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C nchar row to python row
-    """
-    assert(nbytes is not None)
-    res = []
-    for i in range(abs(num_of_rows)):
-        try:
-            if num_of_rows >= 0:
-                tmpstr = ctypes.c_char_p(data)
-                res.append(tmpstr.value.decode())
-            else:
-                res.append((ctypes.cast(data + nbytes * i,
-                                        ctypes.POINTER(ctypes.c_wchar * (nbytes // 4))))[0].value)
-        except ValueError:
-            res.append(None)
-
-    return res
-
-
-def _crow_binary_to_python_block(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C binary row to python row
-    """
-    assert(nbytes is not None)
-    res = []
-    if num_of_rows > 0:
-        for i in range(abs(num_of_rows)):
-            try:
-                rbyte = ctypes.cast(
-                    data + nbytes * i,
-                    ctypes.POINTER(
-                        ctypes.c_short))[
-                    :1].pop()
-                tmpstr = ctypes.c_char_p(data + nbytes * i + 2)
-                res.append(tmpstr.value.decode()[0:rbyte])
-            except ValueError:
-                res.append(None)
-    else:
-        for i in range(abs(num_of_rows)):
-            try:
-                rbyte = ctypes.cast(
-                    data + nbytes * i,
-                    ctypes.POINTER(
-                        ctypes.c_short))[
-                    :1].pop()
-                tmpstr = ctypes.c_char_p(data + nbytes * i + 2)
-                res.append(tmpstr.value.decode()[0:rbyte])
-            except ValueError:
-                res.append(None)
-    return res
-
-
-def _crow_nchar_to_python_block(data, num_of_rows, nbytes=None, micro=False):
-    """Function to convert C nchar row to python row
-    """
-    assert(nbytes is not None)
-    res = []
-    if num_of_rows >= 0:
-        for i in range(abs(num_of_rows)):
-            try:
-                tmpstr = ctypes.c_char_p(data + nbytes * i + 2)
-                res.append(tmpstr.value.decode())
-            except ValueError:
-                res.append(None)
-    else:
-        for i in range(abs(num_of_rows)):
-            try:
-                res.append((ctypes.cast(data + nbytes * i + 2,
-                                        ctypes.POINTER(ctypes.c_wchar * (nbytes // 4))))[0].value)
-            except ValueError:
-                res.append(None)
-    return res
-
-
-_CONVERT_FUNC = {
-    FieldType.C_BOOL: _crow_bool_to_python,
-    FieldType.C_TINYINT: _crow_tinyint_to_python,
-    FieldType.C_SMALLINT: _crow_smallint_to_python,
-    FieldType.C_INT: _crow_int_to_python,
-    FieldType.C_BIGINT: _crow_bigint_to_python,
-    FieldType.C_FLOAT: _crow_float_to_python,
-    FieldType.C_DOUBLE: _crow_double_to_python,
-    FieldType.C_BINARY: _crow_binary_to_python,
-    FieldType.C_TIMESTAMP: _crow_timestamp_to_python,
-    FieldType.C_NCHAR: _crow_nchar_to_python,
-    FieldType.C_TINYINT_UNSIGNED: _crow_tinyint_unsigned_to_python,
-    FieldType.C_SMALLINT_UNSIGNED: _crow_smallint_unsigned_to_python,
-    FieldType.C_INT_UNSIGNED: _crow_int_unsigned_to_python,
-    FieldType.C_BIGINT_UNSIGNED: _crow_bigint_unsigned_to_python
-}
-
-_CONVERT_FUNC_BLOCK = {
-    FieldType.C_BOOL: _crow_bool_to_python,
-    FieldType.C_TINYINT: _crow_tinyint_to_python,
-    FieldType.C_SMALLINT: _crow_smallint_to_python,
-    FieldType.C_INT: _crow_int_to_python,
-    FieldType.C_BIGINT: _crow_bigint_to_python,
-    FieldType.C_FLOAT: _crow_float_to_python,
-    FieldType.C_DOUBLE: _crow_double_to_python,
-    FieldType.C_BINARY: _crow_binary_to_python_block,
-    FieldType.C_TIMESTAMP: _crow_timestamp_to_python,
-    FieldType.C_NCHAR: _crow_nchar_to_python_block,
-    FieldType.C_TINYINT_UNSIGNED: _crow_tinyint_unsigned_to_python,
-    FieldType.C_SMALLINT_UNSIGNED: _crow_smallint_unsigned_to_python,
-    FieldType.C_INT_UNSIGNED: _crow_int_unsigned_to_python,
-    FieldType.C_BIGINT_UNSIGNED: _crow_bigint_unsigned_to_python
-}
-
-# Corresponding TAOS_FIELD structure in C
-
-
-class TaosField(ctypes.Structure):
-    _fields_ = [('name', ctypes.c_char * 65),
-                ('type', ctypes.c_char),
-                ('bytes', ctypes.c_short)]
-
-# C interface class
-
-
-class CTaosInterface(object):
-
-    libtaos = ctypes.CDLL('libtaos.dylib')
-
-    libtaos.taos_fetch_fields.restype = ctypes.POINTER(TaosField)
-    libtaos.taos_init.restype = None
-    libtaos.taos_connect.restype = ctypes.c_void_p
-    #libtaos.taos_use_result.restype = ctypes.c_void_p
-    libtaos.taos_fetch_row.restype = ctypes.POINTER(ctypes.c_void_p)
-    libtaos.taos_errstr.restype = ctypes.c_char_p
-    libtaos.taos_subscribe.restype = ctypes.c_void_p
-    libtaos.taos_consume.restype = ctypes.c_void_p
-    libtaos.taos_fetch_lengths.restype = ctypes.c_void_p
-    libtaos.taos_free_result.restype = None
-    libtaos.taos_errno.restype = ctypes.c_int
-    libtaos.taos_query.restype = ctypes.POINTER(ctypes.c_void_p)
-
-    def __init__(self, config=None):
-        '''
-        Function to initialize the class
-        @host     : str, hostname to connect
-        @user     : str, username to connect to server
-        @password : str, password to connect to server
-        @db       : str, default db to use when log in
-        @config   : str, config directory
-
-        @rtype    : None
-        '''
-        if config is None:
-            self._config = ctypes.c_char_p(None)
-        else:
-            try:
-                self._config = ctypes.c_char_p(config.encode('utf-8'))
-            except AttributeError:
-                raise AttributeError("config is expected as a str")
-
-        if config is not None:
-            CTaosInterface.libtaos.taos_options(3, self._config)
-
-        CTaosInterface.libtaos.taos_init()
-
-    @property
-    def config(self):
-        """ Get current config
-        """
-        return self._config
-
-    def connect(
-            self,
-            host=None,
-            user="root",
-            password="taosdata",
-            db=None,
-            port=0):
-        '''
-        Function to connect to server
-
-        @rtype: c_void_p, TDengine handle
-        '''
-        # host
-        try:
-            _host = ctypes.c_char_p(host.encode(
-                "utf-8")) if host is not None else ctypes.c_char_p(None)
-        except AttributeError:
-            raise AttributeError("host is expected as a str")
-
-        # user
-        try:
-            _user = ctypes.c_char_p(user.encode("utf-8"))
-        except AttributeError:
-            raise AttributeError("user is expected as a str")
-
-        # password
-        try:
-            _password = ctypes.c_char_p(password.encode("utf-8"))
-        except AttributeError:
-            raise AttributeError("password is expected as a str")
-
-        # db
-        try:
-            _db = ctypes.c_char_p(
-                db.encode("utf-8")) if db is not None else ctypes.c_char_p(None)
-        except AttributeError:
-            raise AttributeError("db is expected as a str")
-
-        # port
-        try:
-            _port = ctypes.c_int(port)
-        except TypeError:
-            raise TypeError("port is expected as an int")
-
-        connection = ctypes.c_void_p(CTaosInterface.libtaos.taos_connect(
-            _host, _user, _password, _db, _port))
-
-        if connection.value is None:
-            print('connect to TDengine failed')
-            raise ConnectionError("connect to TDengine failed")
-            # sys.exit(1)
-        # else:
-        #    print('connect to TDengine success')
-
-        return connection
-
-    @staticmethod
-    def close(connection):
-        '''Close the TDengine handle
-        '''
-        CTaosInterface.libtaos.taos_close(connection)
-        #print('connection is closed')
-
-    @staticmethod
-    def query(connection, sql):
-        '''Run SQL
-
-        @sql: str, sql string to run
-
-        @rtype: 0 on success and -1 on failure
-        '''
-        try:
-            return CTaosInterface.libtaos.taos_query(
-                connection, ctypes.c_char_p(sql.encode('utf-8')))
-        except AttributeError:
-            raise AttributeError("sql is expected as a string")
-        # finally:
-        #     CTaosInterface.libtaos.close(connection)
-
-    @staticmethod
-    def affectedRows(result):
-        """The affected rows after runing query
-        """
-        return CTaosInterface.libtaos.taos_affected_rows(result)
-
-    @staticmethod
-    def subscribe(connection, restart, topic, sql, interval):
-        """Create a subscription
-         @restart boolean,
-         @sql string, sql statement for data query, must be a 'select' statement.
-         @topic string, name of this subscription
-        """
-        return ctypes.c_void_p(CTaosInterface.libtaos.taos_subscribe(
-            connection,
-            1 if restart else 0,
-            ctypes.c_char_p(topic.encode('utf-8')),
-            ctypes.c_char_p(sql.encode('utf-8')),
-            None,
-            None,
-            interval))
-
-    @staticmethod
-    def consume(sub):
-        """Consume data of a subscription
-        """
-        result = ctypes.c_void_p(CTaosInterface.libtaos.taos_consume(sub))
-        fields = []
-        pfields = CTaosInterface.fetchFields(result)
-        for i in range(CTaosInterface.libtaos.taos_num_fields(result)):
-            fields.append({'name': pfields[i].name.decode('utf-8'),
-                           'bytes': pfields[i].bytes,
-                           'type': ord(pfields[i].type)})
-        return result, fields
-
-    @staticmethod
-    def unsubscribe(sub, keepProgress):
-        """Cancel a subscription
-        """
-        CTaosInterface.libtaos.taos_unsubscribe(sub, 1 if keepProgress else 0)
-
-    @staticmethod
-    def useResult(result):
-        '''Use result after calling self.query
-        '''
-        fields = []
-        pfields = CTaosInterface.fetchFields(result)
-        for i in range(CTaosInterface.fieldsCount(result)):
-            fields.append({'name': pfields[i].name.decode('utf-8'),
-                           'bytes': pfields[i].bytes,
-                           'type': ord(pfields[i].type)})
-
-        return fields
-
-    @staticmethod
-    def fetchBlock(result, fields):
-        pblock = ctypes.c_void_p(0)
-        num_of_rows = CTaosInterface.libtaos.taos_fetch_block(
-            result, ctypes.byref(pblock))
-        if num_of_rows == 0:
-            return None, 0
-        isMicro = (CTaosInterface.libtaos.taos_result_precision(
-            result) == FieldType.C_TIMESTAMP_MICRO)
-        blocks = [None] * len(fields)
-        fieldL = CTaosInterface.libtaos.taos_fetch_lengths(result)
-        fieldLen = [
-            ele for ele in ctypes.cast(
-                fieldL, ctypes.POINTER(
-                    ctypes.c_int))[
-                :len(fields)]]
-        for i in range(len(fields)):
-            data = ctypes.cast(pblock, ctypes.POINTER(ctypes.c_void_p))[i]
-            if fields[i]['type'] not in _CONVERT_FUNC_BLOCK:
-                raise DatabaseError("Invalid data type returned from database")
-            blocks[i] = _CONVERT_FUNC_BLOCK[fields[i]['type']](
-                data, num_of_rows, fieldLen[i], isMicro)
-
-        return blocks, abs(num_of_rows)
-
-    @staticmethod
-    def fetchRow(result, fields):
-        pblock = ctypes.c_void_p(0)
-        pblock = CTaosInterface.libtaos.taos_fetch_row(result)
-        if pblock:
-            num_of_rows = 1
-            isMicro = (CTaosInterface.libtaos.taos_result_precision(
-                result) == FieldType.C_TIMESTAMP_MICRO)
-            blocks = [None] * len(fields)
-            fieldL = CTaosInterface.libtaos.taos_fetch_lengths(result)
-            fieldLen = [
-                ele for ele in ctypes.cast(
-                    fieldL, ctypes.POINTER(
-                        ctypes.c_int))[
-                    :len(fields)]]
-            for i in range(len(fields)):
-                data = ctypes.cast(pblock, ctypes.POINTER(ctypes.c_void_p))[i]
-                if fields[i]['type'] not in _CONVERT_FUNC:
-                    raise DatabaseError(
-                        "Invalid data type returned from database")
-                if data is None:
-                    blocks[i] = [None]
-                else:
-                    blocks[i] = _CONVERT_FUNC[fields[i]['type']](
-                        data, num_of_rows, fieldLen[i], isMicro)
-        else:
-            return None, 0
-        return blocks, abs(num_of_rows)
-
-    @staticmethod
-    def freeResult(result):
-        CTaosInterface.libtaos.taos_free_result(result)
-        result.value = None
-
-    @staticmethod
-    def fieldsCount(result):
-        return CTaosInterface.libtaos.taos_field_count(result)
-
-    @staticmethod
-    def fetchFields(result):
-        return CTaosInterface.libtaos.taos_fetch_fields(result)
-
-    # @staticmethod
-    # def fetchRow(result, fields):
-    #     l = []
-    #     row = CTaosInterface.libtaos.taos_fetch_row(result)
-    #     if not row:
-    #         return None
-
-    #     for i in range(len(fields)):
-    #         l.append(CTaosInterface.getDataValue(
-    #             row[i], fields[i]['type'], fields[i]['bytes']))
-
-    #     return tuple(l)
-
-    # @staticmethod
-    # def getDataValue(data, dtype, byte):
-    #     '''
-    #     '''
-    #     if not data:
-    #         return None
-
-    #     if (dtype == CTaosInterface.TSDB_DATA_TYPE_BOOL):
-    #         return ctypes.cast(data,  ctypes.POINTER(ctypes.c_bool))[0]
-    #     elif (dtype == CTaosInterface.TSDB_DATA_TYPE_TINYINT):
-    #         return ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[0]
-    #     elif (dtype == CTaosInterface.TSDB_DATA_TYPE_SMALLINT):
-    #         return ctypes.cast(data,  ctypes.POINTER(ctypes.c_short))[0]
-    #     elif (dtype == CTaosInterface.TSDB_DATA_TYPE_INT):
-    #         return ctypes.cast(data,  ctypes.POINTER(ctypes.c_int))[0]
-    #     elif (dtype == CTaosInterface.TSDB_DATA_TYPE_BIGINT):
-    #         return ctypes.cast(data,  ctypes.POINTER(ctypes.c_int64))[0]
-    #     elif (dtype == CTaosInterface.TSDB_DATA_TYPE_FLOAT):
-    #         return ctypes.cast(data,  ctypes.POINTER(ctypes.c_float))[0]
-    #     elif (dtype == CTaosInterface.TSDB_DATA_TYPE_DOUBLE):
-    #         return ctypes.cast(data,  ctypes.POINTER(ctypes.c_double))[0]
-    #     elif (dtype == CTaosInterface.TSDB_DATA_TYPE_BINARY):
-    #         return (ctypes.cast(data,  ctypes.POINTER(ctypes.c_char))[0:byte]).rstrip('\x00')
-    #     elif (dtype == CTaosInterface.TSDB_DATA_TYPE_TIMESTAMP):
-    #         return ctypes.cast(data,  ctypes.POINTER(ctypes.c_int64))[0]
-    #     elif (dtype == CTaosInterface.TSDB_DATA_TYPE_NCHAR):
-    #         return (ctypes.cast(data,  ctypes.c_char_p).value).rstrip('\x00')
-
-    @staticmethod
-    def errno(result):
-        """Return the error number.
-        """
-        return CTaosInterface.libtaos.taos_errno(result)
-
-    @staticmethod
-    def errStr(result):
-        """Return the error styring
-        """
-        return CTaosInterface.libtaos.taos_errstr(result).decode('utf-8')
-
-
-if __name__ == '__main__':
-    cinter = CTaosInterface()
-    conn = cinter.connect()
-    result = cinter.query(conn, 'show databases')
-
-    print('Query Affected rows: {}'.format(cinter.affectedRows(result)))
-
-    fields = CTaosInterface.useResult(result)
-
-    data, num_of_rows = CTaosInterface.fetchBlock(result, fields)
-
-    print(data)
-
-    cinter.freeResult(result)
-    cinter.close(conn)