Merge remote-tracking branch 'upstream/develop' into feature/TD-3963

.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)
@@ -138,7 +138,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/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)

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

@@ -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

@@ -407,7 +407,7 @@ 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]]
@@ -647,7 +647,7 @@ Query OK, 1 row(s) in set (0.001091s)
 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）。
 
@@ -657,6 +657,16 @@ SELECT AVG(f1), SPREAD(f1, f2, st2.f1) FROM st2 WHERE f1 > 0 GROUP BY f1 HAVING
 ```
 -->
 
+### <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 示例 
 
 - 对于下面的例子，表tb1用以下语句创建

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

@@ -174,7 +174,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);
 
@@ -306,7 +307,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/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
@@ -372,7 +372,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/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); 

src/client/src/tscParseInsert.c

@@ -68,7 +68,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 +386,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 +411,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;
@@ -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);
     }
@@ -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;
     }

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;
     }
   }
@@ -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/tscSQLParser.c

@@ -64,7 +64,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);
 
@@ -427,17 +427,12 @@ 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) {
@@ -446,19 +441,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;
@@ -645,18 +636,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
     }
@@ -983,11 +982,14 @@ 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);
@@ -997,6 +999,13 @@ 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);
@@ -1341,14 +1350,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) {
@@ -1607,11 +1615,27 @@ 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;
+}
+
 int32_t validateSelectNodeList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pSelNodeList, bool isSTable, bool joinQuery,
                                bool timeWindowQuery) {
   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";
@@ -1676,7 +1700,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);
   }
 

src/client/src/tscServer.c

@@ -2441,10 +2441,22 @@ 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;
+    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;
@@ -2456,10 +2468,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);
       }
@@ -2641,6 +2656,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 ||

src/client/src/tscUtil.c

@@ -1038,7 +1038,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); 
   }
 
   /*
@@ -1255,67 +1256,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("0x%"PRIx64" failed to prepare the data block buffer for merging table data, code:%d", pSql->self, 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("0x%"PRIx64" failed to allocate memory for merging submit block, size:%d", pSql->self, 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;
@@ -1437,7 +1444,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) {
@@ -1449,15 +1456,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) {
@@ -2431,6 +2459,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);
@@ -2706,6 +2739,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) {
@@ -3100,7 +3134,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;
   
@@ -3333,11 +3373,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
@@ -3349,12 +3389,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/common/inc/tcmdtype.h

@@ -80,6 +80,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/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/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
@@ -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 = 10000000000.0f;
+  cfg.maxValue = 100000000.0f;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
   taosInitConfigOption(cfg);

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 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);
@@ -169,37 +166,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 +220,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 +228,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 +265,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 +273,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/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

@@ -12,6 +12,7 @@ import java.util.Properties;
 import java.util.concurrent.TimeUnit;
 
 public class SubscribeTest {
+
     Connection connection;
     Statement statement;
     String dbName = "test";
@@ -19,62 +20,53 @@ public class SubscribeTest {
     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;
-        }
-    }
-
     @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);
+            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();
         }
     }
 
+    @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)");
+        long 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 +78,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(0, special_character_str_1.length() - 2), 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(0, special_character_str_1.length() - 2), 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)

src/connector/python/osx/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/osx/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/osx/python3/taos/cursor.py

@@ -1,280 +0,0 @@
-from .cinterface import CTaosInterface
-from .error import *
-from .constants import FieldType
-
-# querySeqNum = 0
-
-
-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 rowcount of insertion
-        """
-        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/osx/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/osx/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/osx/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/setup.py

@@ -0,0 +1,35 @@
+import setuptools
+
+with open("README.md", "r") as fh:
+    long_description = fh.read()
+
+setuptools.setup(
+    name="taos",
+    version="2.0.9",
+    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=[
+
+        "Environment :: Console",
+        "Environment :: MacOS X",
+        "Environment :: Win32 (MS Windows)",
+        "Programming Language :: Python",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)",
+        "Operating System :: MacOS",
+        "Programming Language :: Python :: 2.7",
+        "Operating System :: Linux",
+        "Operating System :: POSIX :: Linux",
+        "Operating System :: Microsoft :: Windows",
+        "Operating System :: Microsoft :: Windows :: Windows 10",
+    ],
+)

src/connector/python/taos/cinterface.py

@@ -3,6 +3,7 @@ from .constants import FieldType
 from .error import *
 import math
 import datetime
+import platform
 
 
 def _convert_millisecond_to_datetime(milli):
@@ -20,40 +21,28 @@ def _crow_timestamp_to_python(data, num_of_rows, nbytes=None, micro=False):
     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)]))
+    return [
+        None if ele == FieldType.C_BIGINT_NULL else _timestamp_converter(ele) for ele in 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)]]
+    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)]]
 
 
 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)]]
+    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(
@@ -63,92 +52,56 @@ def _crow_tinyint_unsigned_to_python(
         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)]]
+    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)]]
+    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)]]
+    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)]]
+    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)]]
+    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)]]
+    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(
@@ -158,52 +111,33 @@ def _crow_bigint_unsigned_to_python(
         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)]]
+    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)]]
+    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)]]
+    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)]]
+    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):
@@ -230,30 +164,17 @@ def _crow_binary_to_python_block(data, num_of_rows, nbytes=None, micro=False):
     """
     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)
+    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
 
 
@@ -262,20 +183,12 @@ def _crow_nchar_to_python_block(data, num_of_rows, nbytes=None, micro=False):
     """
     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)
+    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)
     return res
 
 
@@ -324,14 +237,38 @@ class TaosField(ctypes.Structure):
 # C interface class
 
 
+def _load_taos_linux():
+    return ctypes.CDLL('libtaos.so')
+
+
+def _load_taos_darwin():
+    return ctypes.cDLL('libtaos.dylib')
+
+
+def _load_taos_windows():
+    return ctypes.windll.LoadLibrary('taos')
+
+
+def _load_taos():
+    load_func = {
+        'Linux': _load_taos_linux,
+        'Darwin': _load_taos_darwin,
+        'Windows': _load_taos_windows,
+    }
+    try:
+        return load_func[platform.system()]()
+    except:
+        sys.exit('unsupported platform to TDengine connector')
+
+
 class CTaosInterface(object):
 
-    libtaos = ctypes.CDLL('libtaos.so')
+    libtaos = _load_taos()
 
     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_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
@@ -432,7 +369,7 @@ class CTaosInterface(object):
         '''Close the TDengine handle
         '''
         CTaosInterface.libtaos.taos_close(connection)
-        #print('connection is closed')
+        # print('connection is closed')
 
     @staticmethod
     def query(connection, sql):

src/connector/python/taos/cursor.py

@@ -45,6 +45,12 @@ class TDengineCursor(object):
         return self
 
     def __next__(self):
+        return self._taos_next()
+
+    def next(self):
+        return self._taos_next()
+
+    def _taos_next(self):
         if self._result is None or self._fields is None:
             raise OperationalError("Invalid use of fetch iterator")
 

src/connector/python/windows/python2

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

src/connector/python/windows/python2/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/windows/python2/README.md

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

src/connector/python/windows/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.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 :: 2",
-        "Operating System :: Windows",
-    ],
-)

src/connector/python/windows/python2/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/windows/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.windll.LoadLibrary('taos')
-
-    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/windows/python2/taos/connection.py

@@ -1,96 +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
-
-        if len(kwargs) > 0:
-            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/windows/python2/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)])
-    # Time precision definition
-    C_TIMESTAMP_MILLI = 0
-    C_TIMESTAMP_MICRO = 1

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

@@ -1,220 +0,0 @@
-from .cinterface import CTaosInterface
-from .error import *
-from .constants import FieldType
-
-# querySeqNum = 0
-
-
-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 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
-
-        self._result = CTaosInterface.query(self._connection._conn, stmt)
-        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 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/windows/python2/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/windows/python2/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