Merge remote-tracking branch 'origin/develop' into feature/crash

.travis.yml

@@ -32,6 +32,8 @@ matrix:
           - python3-setuptools
           - valgrind
           - psmisc
+          - unixodbc
+          - unixodbc-dev
 
     before_script:
       - export TZ=Asia/Harbin

Jenkinsfile

@@ -8,14 +8,11 @@ pipeline {
   stages {
       stage('pre build'){
         agent{label 'master'}
+        when{ changeset "develop"}
         steps{
           sh '''
-              cd ${WKC}
-              td=`git diff develop remotes/origin/develop`
-              if [ ! $td ];then
-                  echo "no changes,skip build"
-                  exit 0
-              fi
+              
+              
               echo "check OK!"
               '''
         }
@@ -23,16 +20,10 @@ pipeline {
       stage('Parallel test stage') {
       parallel {
         stage('pytest') {
+          when{ changeset "develop"}
           agent{label 'master'}
           steps {
             sh '''
-            cd ${WKC}
-              td=`git diff develop remotes/origin/develop`
-              if [ ! $td ];then
-                  echo "no changes,skip build"
-                  exit 0
-              fi
-            
             date
             cd ${WKC}
             git checkout develop
@@ -55,19 +46,14 @@ pipeline {
           }
         }
         stage('test_b1') {
+          when{ changeset "develop"}
           agent{label '184'}
           steps {
             sh '''
-            cd ${WKC}
-              td=`git diff develop remotes/origin/develop`
-              if [ ! $td ];then
-                  echo "no changes,skip build"
-                  exit 0
-              fi
-            date
             cd ${WKC}
             git checkout develop
             git pull
+              
             git submodule update
             cd ${WK}
             git checkout develop
@@ -88,17 +74,13 @@ pipeline {
 
         stage('test_crash_gen') {
           agent{label "185"}
+          when{ changeset "develop"}
           steps {
             sh '''
-            cd ${WKC}
-              td=`git diff develop remotes/origin/develop`
-              if [ ! $td ];then
-                  echo "no changes,skip build"
-                  exit 0
-              fi
             cd ${WKC}
             git checkout develop
             git pull
+              
             git submodule update
             cd ${WK}
             git checkout develop
@@ -122,18 +104,13 @@ pipeline {
 
         stage('test_valgrind') {
           agent{label "186"}
+          when{ changeset "develop"}
           steps {
             sh '''
-            cd ${WKC}
-              td=`git diff develop remotes/origin/develop`
-              if [ ! $td ];then
-                  echo "no changes,skip build"
-                  exit 0
-              fi
-            date
             cd ${WKC}
             git checkout develop
             git pull
+              
             git submodule update
             cd ${WK}
             git checkout develop

cmake/install.inc

@@ -31,7 +31,7 @@ ELSEIF (TD_WINDOWS)
   #INSTALL(TARGETS taos RUNTIME DESTINATION driver)
   #INSTALL(TARGETS shell RUNTIME DESTINATION .)
   IF (TD_MVN_INSTALLED)
-    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.0-dist.jar DESTINATION connector/jdbc)
+    INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos-jdbcdriver-2.0.8-dist.jar DESTINATION connector/jdbc)
   ENDIF ()
 ELSEIF (TD_DARWIN)
   SET(TD_MAKE_INSTALL_SH "${TD_COMMUNITY_DIR}/packaging/tools/make_install.sh")

src/CMakeLists.txt

@@ -20,4 +20,6 @@ ADD_SUBDIRECTORY(tsdb)
 ADD_SUBDIRECTORY(wal)
 ADD_SUBDIRECTORY(cq)
 ADD_SUBDIRECTORY(dnode)
+ADD_SUBDIRECTORY(connector/odbc)
 ADD_SUBDIRECTORY(connector/jdbc)
+

src/client/src/tscPrepare.c

@@ -266,6 +266,388 @@ static int doBindParam(char* data, SParamInfo* param, TAOS_BIND* bind) {
     return TSDB_CODE_SUCCESS;
   }
 
+  if (1) {
+    // allow user bind param data with different type
+    short size = 0;
+    union {
+      int8_t          v1;
+      int16_t         v2;
+      int32_t         v4;
+      int64_t         v8;
+      float           f4;
+      double          f8;
+      unsigned char   buf[32*1024];
+    } u;
+    switch (param->type) {
+      case TSDB_DATA_TYPE_BOOL: {
+        switch (bind->buffer_type) {
+          case TSDB_DATA_TYPE_BOOL: {
+            u.v1 = *(int8_t*)bind->buffer;
+            if (u.v1==0 || u.v1==1) break;
+          } break;
+          case TSDB_DATA_TYPE_TINYINT: {
+            u.v1 = *(int8_t*)bind->buffer;
+            if (u.v1==0 || u.v1==1) break;
+          } break;
+          case TSDB_DATA_TYPE_SMALLINT: {
+            u.v1 = (int8_t)*(int16_t*)bind->buffer;
+            if (u.v1==0 || u.v1==1) break;
+          } break;
+          case TSDB_DATA_TYPE_INT: {
+            u.v1 = (int8_t)*(int32_t*)bind->buffer;
+            if (u.v1==0 || u.v1==1) break;
+          } break;
+          case TSDB_DATA_TYPE_BIGINT: {
+            u.v1 = (int8_t)*(int64_t*)bind->buffer;
+            if (u.v1==0 || u.v1==1) break;
+          } break;
+          case TSDB_DATA_TYPE_BINARY:
+          case TSDB_DATA_TYPE_NCHAR: {
+            // "0", "1" convertible
+            if (strncmp((const char*)bind->buffer, "0", *bind->length)==0) {
+              u.v1 = 0;
+              break;
+            }
+            if (strncmp((const char*)bind->buffer, "1", *bind->length)==0) {
+              u.v1 = 1;
+              break;
+            }
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_FLOAT:
+          case TSDB_DATA_TYPE_DOUBLE:
+          case TSDB_DATA_TYPE_TIMESTAMP:
+          default: {
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+        }
+        memcpy(data + param->offset, &u.v1, sizeof(u.v1));
+        return TSDB_CODE_SUCCESS;
+      } break;
+      case TSDB_DATA_TYPE_TINYINT: {
+        switch (bind->buffer_type) {
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT: {
+            int8_t v = *(int8_t*)bind->buffer;
+            u.v1 = v;
+            if (v >= SCHAR_MIN && v <= SCHAR_MAX) break;
+          } break;
+          case TSDB_DATA_TYPE_SMALLINT: {
+            int16_t v = *(int16_t*)bind->buffer;
+            u.v1 = (int8_t)v;
+            if (v >= SCHAR_MIN && v <= SCHAR_MAX) break;
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_INT: {
+            int32_t v = *(int32_t*)bind->buffer;
+            u.v1 = (int8_t)v;
+            if (v >= SCHAR_MIN && v <= SCHAR_MAX) break;
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_BIGINT: {
+            int64_t v = *(int64_t*)bind->buffer;
+            u.v1 = (int8_t)v;
+            if (v >= SCHAR_MIN && v <= SCHAR_MAX) break;
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_BINARY:
+          case TSDB_DATA_TYPE_NCHAR: {
+            int64_t v;
+            int n,r;
+            r = sscanf((const char*)bind->buffer, "%" PRId64 "%n", &v, &n);
+            if (r==1 && n==strlen((const char*)bind->buffer)) {
+              u.v1 = (int8_t)v;
+              if (v >= SCHAR_MIN && v <= SCHAR_MAX) break;
+            }
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_FLOAT:
+          case TSDB_DATA_TYPE_DOUBLE:
+          case TSDB_DATA_TYPE_TIMESTAMP:
+          default: {
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+        }
+        memcpy(data + param->offset, &u.v1, sizeof(u.v1));
+        return TSDB_CODE_SUCCESS;
+			} break;
+      case TSDB_DATA_TYPE_SMALLINT: {
+        switch (bind->buffer_type) {
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT:
+          case TSDB_DATA_TYPE_SMALLINT: {
+            int v = *(int16_t*)bind->buffer;
+            u.v2 = (int16_t)v;
+          } break;
+          case TSDB_DATA_TYPE_INT: {
+            int32_t v = *(int32_t*)bind->buffer;
+            u.v2 = (int16_t)v;
+            if (v >= SHRT_MIN && v <= SHRT_MAX) break;
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_BIGINT: {
+            int64_t v = *(int64_t*)bind->buffer;
+            u.v2 = (int16_t)v;
+            if (v >= SHRT_MIN && v <= SHRT_MAX) break;
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_BINARY:
+          case TSDB_DATA_TYPE_NCHAR: {
+            int64_t v;
+            int n,r;
+            r = sscanf((const char*)bind->buffer, "%" PRId64 "%n", &v, &n);
+            if (r==1 && n==strlen((const char*)bind->buffer)) {
+              u.v2 = (int16_t)v;
+              if (v >= SHRT_MIN && v <= SHRT_MAX) break;
+            }
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_FLOAT:
+          case TSDB_DATA_TYPE_DOUBLE:
+          case TSDB_DATA_TYPE_TIMESTAMP:
+          default: {
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+        }
+        memcpy(data + param->offset, &u.v2, sizeof(u.v2));
+        return TSDB_CODE_SUCCESS;
+			} break;
+      case TSDB_DATA_TYPE_INT: {
+        switch (bind->buffer_type) {
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT:
+          case TSDB_DATA_TYPE_SMALLINT:
+          case TSDB_DATA_TYPE_INT: {
+            u.v4 = *(int32_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_BIGINT: {
+            int64_t v = *(int64_t*)bind->buffer;
+            u.v4 = (int32_t)v;
+            if (v >= INT_MIN && v <= INT_MAX) break;
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_BINARY:
+          case TSDB_DATA_TYPE_NCHAR: {
+            int64_t v;
+            int n,r;
+            r = sscanf((const char*)bind->buffer, "%" PRId64 "%n", &v, &n);
+            if (r==1 && n==strlen((const char*)bind->buffer)) {
+              u.v4 = (int32_t)v;
+              if (v >= INT_MIN && v <= INT_MAX) break;
+            }
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_FLOAT:
+          case TSDB_DATA_TYPE_DOUBLE:
+          case TSDB_DATA_TYPE_TIMESTAMP:
+          default: {
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+        }
+        memcpy(data + param->offset, &u.v2, sizeof(u.v2));
+        return TSDB_CODE_SUCCESS;
+			} break;
+      case TSDB_DATA_TYPE_FLOAT: {
+        switch (bind->buffer_type) {
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT: {
+            u.f4 = *(int8_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_SMALLINT: {
+            u.f4 = *(int16_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_INT: {
+            u.f4 = (float)*(int32_t*)bind->buffer;
+            // shall we check equality?
+          } break;
+          case TSDB_DATA_TYPE_BIGINT: {
+            u.f4 = (float)*(int64_t*)bind->buffer;
+            // shall we check equality?
+          } break;
+          case TSDB_DATA_TYPE_FLOAT: {
+            u.f4 = *(float*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_DOUBLE: {
+            u.f4 = *(float*)bind->buffer;
+            // shall we check equality?
+          } break;
+          case TSDB_DATA_TYPE_BINARY:
+          case TSDB_DATA_TYPE_NCHAR: {
+            float v;
+            int n,r;
+            r = sscanf((const char*)bind->buffer, "%f%n", &v, &n);
+            if (r==1 && n==strlen((const char*)bind->buffer)) {
+              u.f4 = v;
+              break;
+            }
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_TIMESTAMP:
+          default: {
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+        }
+        memcpy(data + param->offset, &u.f4, sizeof(u.f4));
+        return TSDB_CODE_SUCCESS;
+			} break;
+      case TSDB_DATA_TYPE_BIGINT: {
+        switch (bind->buffer_type) {
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT: {
+            u.v8 = *(int8_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_SMALLINT: {
+            u.v8 = *(int16_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_INT: {
+            u.v8 = *(int32_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_BIGINT: {
+            u.v8 = *(int64_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_BINARY:
+          case TSDB_DATA_TYPE_NCHAR: {
+            int64_t v;
+            int n,r;
+            r = sscanf((const char*)bind->buffer, "%" PRId64 "%n", &v, &n);
+            if (r==1 && n==strlen((const char*)bind->buffer)) {
+              u.v8 = v;
+              break;
+            }
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_FLOAT:
+          case TSDB_DATA_TYPE_DOUBLE:
+          case TSDB_DATA_TYPE_TIMESTAMP:
+          default: {
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+        }
+        memcpy(data + param->offset, &u.v8, sizeof(u.v8));
+        return TSDB_CODE_SUCCESS;
+			} break;
+      case TSDB_DATA_TYPE_DOUBLE: {
+        switch (bind->buffer_type) {
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT: {
+            u.f8 = *(int8_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_SMALLINT: {
+            u.f8 = *(int16_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_INT: {
+            u.f8 = *(int32_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_BIGINT: {
+            u.f8 = (double)*(int64_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_FLOAT: {
+            u.f8 = *(float*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_DOUBLE: {
+            u.f8 = *(double*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_BINARY:
+          case TSDB_DATA_TYPE_NCHAR: {
+            double v;
+            int n,r;
+            r = sscanf((const char*)bind->buffer, "%lf%n", &v, &n);
+            if (r==1 && n==strlen((const char*)bind->buffer)) {
+              u.f8 = v;
+              break;
+            }
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_TIMESTAMP:
+          default: {
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+        } break;
+        memcpy(data + param->offset, &u.f8, sizeof(u.f8));
+        return TSDB_CODE_SUCCESS;
+			} break;
+      case TSDB_DATA_TYPE_TIMESTAMP: {
+        switch (bind->buffer_type) {
+          case TSDB_DATA_TYPE_TIMESTAMP: {
+            u.v8 = *(int64_t*)bind->buffer;
+          } break;
+          case TSDB_DATA_TYPE_BINARY:
+          case TSDB_DATA_TYPE_NCHAR: {
+            // is this the correct way to call taosParseTime?
+            int32_t len = (int32_t)*bind->length;
+            if (taosParseTime(bind->buffer, &u.v8, len, 3, tsDaylight) == TSDB_CODE_SUCCESS) {
+              break;
+            }
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT:
+          case TSDB_DATA_TYPE_SMALLINT:
+          case TSDB_DATA_TYPE_INT:
+          case TSDB_DATA_TYPE_FLOAT:
+          case TSDB_DATA_TYPE_BIGINT:
+          case TSDB_DATA_TYPE_DOUBLE:
+          default: {
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+        } break;
+        memcpy(data + param->offset, &u.v8, sizeof(u.v8));
+        return TSDB_CODE_SUCCESS;
+			} break;
+      case TSDB_DATA_TYPE_BINARY: {
+        switch (bind->buffer_type) {
+          case TSDB_DATA_TYPE_BINARY: {
+            if ((*bind->length) > (uintptr_t)param->bytes) {
+              return TSDB_CODE_TSC_INVALID_VALUE;
+            }
+            size = (short)*bind->length;
+            STR_WITH_SIZE_TO_VARSTR(data + param->offset, bind->buffer, size);
+            return TSDB_CODE_SUCCESS;
+          } break;
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT:
+          case TSDB_DATA_TYPE_SMALLINT:
+          case TSDB_DATA_TYPE_INT:
+          case TSDB_DATA_TYPE_FLOAT:
+          case TSDB_DATA_TYPE_BIGINT:
+          case TSDB_DATA_TYPE_DOUBLE:
+          case TSDB_DATA_TYPE_TIMESTAMP:
+          case TSDB_DATA_TYPE_NCHAR:
+          default: {
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+        }
+			} break;
+      case TSDB_DATA_TYPE_NCHAR: {
+        switch (bind->buffer_type) {
+          case TSDB_DATA_TYPE_NCHAR: {
+            size_t output = 0;
+            if (!taosMbsToUcs4(bind->buffer, *bind->length, varDataVal(data + param->offset), param->bytes - VARSTR_HEADER_SIZE, &output)) {
+              return TSDB_CODE_TSC_INVALID_VALUE;
+            }
+            varDataSetLen(data + param->offset, output);
+            return TSDB_CODE_SUCCESS;
+          } break;
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT:
+          case TSDB_DATA_TYPE_SMALLINT:
+          case TSDB_DATA_TYPE_INT:
+          case TSDB_DATA_TYPE_FLOAT:
+          case TSDB_DATA_TYPE_BIGINT:
+          case TSDB_DATA_TYPE_DOUBLE:
+          case TSDB_DATA_TYPE_TIMESTAMP:
+          case TSDB_DATA_TYPE_BINARY:
+          default: {
+            return TSDB_CODE_TSC_INVALID_VALUE;
+          } break;
+        }
+			} break;
+      default: {
+        return TSDB_CODE_TSC_INVALID_VALUE;
+      } break;
+    }
+  }
+
   if (bind->buffer_type != param->type) {
     return TSDB_CODE_TSC_INVALID_VALUE;
   }
@@ -637,3 +1019,80 @@ TAOS_RES *taos_stmt_use_result(TAOS_STMT* stmt) {
   pStmt->pSql = NULL;
   return result;
 }
+
+int taos_stmt_is_insert(TAOS_STMT *stmt, int *insert) {
+  STscStmt* pStmt = (STscStmt*)stmt;
+
+  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return TSDB_CODE_TSC_DISCONNECTED;
+  }
+
+  if (insert) *insert = pStmt->isInsert;
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int taos_stmt_num_params(TAOS_STMT *stmt, int *nums) {
+  STscStmt* pStmt = (STscStmt*)stmt;
+
+  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return TSDB_CODE_TSC_DISCONNECTED;
+  }
+
+  if (pStmt->isInsert) {
+    SSqlObj* pSql = pStmt->pSql;
+    SSqlCmd *pCmd    = &pSql->cmd;
+    *nums = pCmd->numOfParams;
+    return TSDB_CODE_SUCCESS;
+  } else {
+    SNormalStmt* normal = &pStmt->normal;
+    *nums = normal->numParams;
+    return TSDB_CODE_SUCCESS;
+  }
+}
+
+int taos_stmt_get_param(TAOS_STMT *stmt, int idx, int *type, int *bytes) {
+  STscStmt* pStmt = (STscStmt*)stmt;
+
+  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
+    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return TSDB_CODE_TSC_DISCONNECTED;
+  }
+
+  if (pStmt->isInsert) {
+    SSqlObj* pSql = pStmt->pSql;
+    SSqlCmd *pCmd    = &pSql->cmd;
+    STableDataBlocks* pBlock = taosArrayGetP(pCmd->pDataBlocks, 0);
+
+    assert(pCmd->numOfParams == pBlock->numOfParams);
+    if (idx < 0 || idx >= pBlock->numOfParams) return -1;
+
+    SParamInfo* param = pBlock->params + idx;
+    if (type) *type = param->type;
+    if (bytes) *bytes = param->bytes;
+
+    return TSDB_CODE_SUCCESS;
+  } else {
+    return TSDB_CODE_TSC_APP_ERROR;
+  }
+}
+
+const char *taos_data_type(int type) {
+  switch (type) {
+    case TSDB_DATA_TYPE_NULL:            return "TSDB_DATA_TYPE_NULL";
+    case TSDB_DATA_TYPE_BOOL:            return "TSDB_DATA_TYPE_BOOL";
+    case TSDB_DATA_TYPE_TINYINT:         return "TSDB_DATA_TYPE_TINYINT";
+    case TSDB_DATA_TYPE_SMALLINT:        return "TSDB_DATA_TYPE_SMALLINT";
+    case TSDB_DATA_TYPE_INT:             return "TSDB_DATA_TYPE_INT";
+    case TSDB_DATA_TYPE_BIGINT:          return "TSDB_DATA_TYPE_BIGINT";
+    case TSDB_DATA_TYPE_FLOAT:           return "TSDB_DATA_TYPE_FLOAT";
+    case TSDB_DATA_TYPE_DOUBLE:          return "TSDB_DATA_TYPE_DOUBLE";
+    case TSDB_DATA_TYPE_BINARY:          return "TSDB_DATA_TYPE_BINARY";
+    case TSDB_DATA_TYPE_TIMESTAMP:       return "TSDB_DATA_TYPE_TIMESTAMP";
+    case TSDB_DATA_TYPE_NCHAR:           return "TSDB_DATA_TYPE_NCHAR";
+    default: return "UNKNOWN";
+  }
+}
+

src/connector/jdbc/CMakeLists.txt

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

src/connector/jdbc/pom.xml

@@ -3,7 +3,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.taosdata.jdbc</groupId>
     <artifactId>taos-jdbcdriver</artifactId>
-    <version>2.0.0</version>
+    <version>2.0.8</version>
     <packaging>jar</packaging>
     <name>JDBCDriver</name>
     <url>https://github.com/taosdata/TDengine/tree/master/src/connector/jdbc</url>

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

@@ -587,7 +587,6 @@ public class TSDBDatabaseMetaData implements java.sql.DatabaseMetaData {
     public ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern)
             throws SQLException {
 
-
         /** add by zyyang **********/
         Statement stmt = null;
         if (null != conn && !conn.isClosed()) {

src/connector/odbc/CMakeLists.txt

+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+PROJECT(TDengine)
+
+IF (TD_LINUX_64)
+  find_program(HAVE_ODBCINST NAMES odbcinst)
+
+  IF (HAVE_ODBCINST)
+    include(CheckSymbolExists)
+    # shall we revert CMAKE_REQUIRED_LIBRARIES and how?
+    set(CMAKE_REQUIRED_LIBRARIES odbc)
+    check_symbol_exists(SQLExecute "sql.h" HAVE_ODBC_DEV)
+    if(NOT (HAVE_ODBC_DEV))
+      unset(HAVE_ODBC_DEV CACHE)
+      message(WARNING "unixodbc-dev is not installed yet, you may install it under ubuntu by typing: sudo apt install unixodbc-dev")
+    else ()
+      message(STATUS "unixodbc/unixodbc-dev are installed, and odbc connector will be built")
+      AUX_SOURCE_DIRECTORY(src SRC)
+
+      # generate dynamic library (*.so)
+      ADD_LIBRARY(todbc SHARED ${SRC})
+      SET_TARGET_PROPERTIES(todbc PROPERTIES CLEAN_DIRECT_OUTPUT 1)
+      SET_TARGET_PROPERTIES(todbc PROPERTIES VERSION ${TD_VER_NUMBER} SOVERSION 1)
+      TARGET_LINK_LIBRARIES(todbc taos)
+
+      install(CODE "execute_process(COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/src/install.sh ${CMAKE_BINARY_DIR})")
+
+      ADD_SUBDIRECTORY(tests)
+    endif()
+  ELSE ()
+    message(WARNING "unixodbc is not installed yet, you may install it under ubuntu by typing: sudo apt install unixodbc")
+  ENDIF ()
+ENDIF ()
+

src/connector/odbc/src/install.sh

+#!/bin/bash
+
+set -u
+
+BLD_DIR="$1"
+
+rm -f "${BLD_DIR}/template.ini"
+rm -f "${BLD_DIR}/template.dsn"
+
+cat > "${BLD_DIR}/template.ini" <<EOF
+[TAOS]
+Description = taos odbc driver
+Driver = ${BLD_DIR}/build/lib/libtodbc.so
+EOF
+
+cat > "${BLD_DIR}/template.dsn" <<EOF
+[TAOS_DSN]
+Description=Connection to TAOS
+Driver=TAOS
+EOF
+
+sudo odbcinst -i -d -f "${BLD_DIR}/template.ini" &&
+odbcinst -i -s -f "${BLD_DIR}/template.dsn" &&
+echo "odbc install done"
+

src/connector/odbc/src/todbc_util.c

+/*
+ * 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/>.
+ */
+
+#include "todbc_util.h"
+
+#include "iconv.h"
+
+#include <sql.h>
+#include <sqltypes.h>
+#include <sqlext.h>
+#include <stdlib.h>
+#include <string.h>
+
+const char* sql_sql_type(int type) {
+  switch (type) {
+    case SQL_BIT:                               return "SQL_BIT";
+    case SQL_TINYINT:                           return "SQL_TINYINT";
+    case SQL_SMALLINT:                          return "SQL_SMALLINT";
+    case SQL_INTEGER:                           return "SQL_INTEGER";
+    case SQL_BIGINT:                            return "SQL_BIGINT";
+    case SQL_FLOAT:                             return "SQL_FLOAT";
+    case SQL_DOUBLE:                            return "SQL_DOUBLE";
+    case SQL_DECIMAL:                           return "SQL_DECIMAL";
+    case SQL_NUMERIC:                           return "SQL_NUMERIC";
+    case SQL_REAL:                              return "SQL_REAL";
+    case SQL_CHAR:                              return "SQL_CHAR";
+    case SQL_VARCHAR:                           return "SQL_VARCHAR";
+    case SQL_LONGVARCHAR:                       return "SQL_LONGVARCHAR";
+    case SQL_WCHAR:                             return "SQL_WCHAR";
+    case SQL_WVARCHAR:                          return "SQL_WVARCHAR";
+    case SQL_WLONGVARCHAR:                      return "SQL_WLONGVARCHAR";
+    case SQL_BINARY:                            return "SQL_BINARY";
+    case SQL_VARBINARY:                         return "SQL_VARBINARY";
+    case SQL_LONGVARBINARY:                     return "SQL_LONGVARBINARY";
+    case SQL_DATE:                              return "SQL_DATE";
+    case SQL_TIME:                              return "SQL_TIME";
+    case SQL_TIMESTAMP:                         return "SQL_TIMESTAMP";
+    case SQL_TYPE_DATE:                         return "SQL_TYPE_DATE";
+    case SQL_TYPE_TIME:                         return "SQL_TYPE_TIME";
+    case SQL_TYPE_TIMESTAMP:                    return "SQL_TYPE_TIMESTAMP";
+    case SQL_INTERVAL_MONTH:                    return "SQL_INTERVAL_MONTH";
+    case SQL_INTERVAL_YEAR:                     return "SQL_INTERVAL_YEAR";
+    case SQL_INTERVAL_YEAR_TO_MONTH:            return "SQL_INTERVAL_YEAR_TO_MONTH";
+    case SQL_INTERVAL_DAY:                      return "SQL_INTERVAL_DAY";
+    case SQL_INTERVAL_HOUR:                     return "SQL_INTERVAL_HOUR";
+    case SQL_INTERVAL_MINUTE:                   return "SQL_INTERVAL_MINUTE";
+    case SQL_INTERVAL_SECOND:                   return "SQL_INTERVAL_SECOND";
+    case SQL_INTERVAL_DAY_TO_HOUR:              return "SQL_INTERVAL_DAY_TO_HOUR";
+    case SQL_INTERVAL_DAY_TO_MINUTE:            return "SQL_INTERVAL_DAY_TO_MINUTE";
+    case SQL_INTERVAL_DAY_TO_SECOND:            return "SQL_INTERVAL_DAY_TO_SECOND";
+    case SQL_INTERVAL_HOUR_TO_MINUTE:           return "SQL_INTERVAL_HOUR_TO_MINUTE";
+    case SQL_INTERVAL_HOUR_TO_SECOND:           return "SQL_INTERVAL_HOUR_TO_SECOND";
+    case SQL_INTERVAL_MINUTE_TO_SECOND:         return "SQL_INTERVAL_MINUTE_TO_SECOND";
+    case SQL_GUID:                              return "SQL_GUID";
+    default: return "UNKNOWN";
+  }
+}
+
+const char* sql_c_type(int type) {
+  switch (type) {
+    case SQL_C_CHAR:                  return "SQL_C_CHAR";
+    case SQL_C_WCHAR:                 return "SQL_C_WCHAR";
+    case SQL_C_SHORT:                 return "SQL_C_SHORT";
+    case SQL_C_SSHORT:                return "SQL_C_SSHORT";
+    case SQL_C_USHORT:                return "SQL_C_USHORT";
+    case SQL_C_LONG:                  return "SQL_C_LONG";
+    case SQL_C_SLONG:                 return "SQL_C_SLONG";
+    case SQL_C_ULONG:                 return "SQL_C_ULONG";
+    case SQL_C_FLOAT:                 return "SQL_C_FLOAT";
+    case SQL_C_DOUBLE:                return "SQL_C_DOUBLE";
+    case SQL_C_BIT:                   return "SQL_C_BIT";
+    case SQL_C_TINYINT:               return "SQL_C_TINYINT";
+    case SQL_C_STINYINT:              return "SQL_C_STINYINT";
+    case SQL_C_UTINYINT:              return "SQL_C_UTINYINT";
+    case SQL_C_SBIGINT:               return "SQL_C_SBIGINT";
+    case SQL_C_UBIGINT:               return "SQL_C_UBIGINT";
+    case SQL_C_BINARY:                return "SQL_C_BINARY";
+    case SQL_C_DATE:                  return "SQL_C_DATE";
+    case SQL_C_TIME:                  return "SQL_C_TIME";
+    case SQL_C_TIMESTAMP:             return "SQL_C_TIMESTAMP";
+    case SQL_C_TYPE_DATE:             return "SQL_C_TYPE_DATE";
+    case SQL_C_TYPE_TIME:             return "SQL_C_TYPE_TIME";
+    case SQL_C_TYPE_TIMESTAMP:        return "SQL_C_TYPE_TIMESTAMP";
+    case SQL_C_NUMERIC:               return "SQL_C_NUMERIC";
+    case SQL_C_GUID:                  return "SQL_C_GUID";
+    default: return "UNKNOWN";
+  }
+}
+
+int is_valid_sql_c_type(int type) {
+  const char *ctype = sql_c_type(type);
+  if (strcmp(ctype, "UNKNOWN")==0) return 0;
+  return 1;
+}
+
+int is_valid_sql_sql_type(int type) {
+  const char *sqltype = sql_sql_type(type);
+  if (strcmp(sqltype, "UNKNOWN")==0) return 0;
+  return 1;
+}
+
+int string_conv(const char *fromcode, const char *tocode,
+                const unsigned char *src, size_t sbytes,
+                unsigned char *dst, size_t dbytes,
+                size_t *consumed, size_t *generated)
+{
+  if (consumed) *consumed = 0;
+  if (generated) *generated = 0;
+
+  if (dbytes <= 0) return -1;
+  dst[0] = '\0';
+
+  iconv_t conv = iconv_open(tocode, fromcode);
+  if (!conv) return -1;
+
+  int r = 0;
+  do {
+    char *s = (char*)src;
+    char *d = (char*)dst;
+    size_t sl = sbytes;
+    size_t dl = dbytes;
+
+    r = iconv(conv, &s, &sl, &d, &dl);
+    *d = '\0';
+
+    if (consumed) *consumed = sbytes - sl;
+    if (generated) *generated = dbytes - dl;
+
+  } while (0);
+
+  iconv_close(conv);
+  return r;
+}
+
+int utf8_chars(const char *src)
+{
+  const char *fromcode = "UTF-8";
+  const char *tocode = "UCS-2LE";
+  iconv_t conv = iconv_open(tocode, fromcode);
+  if (!conv) return -1;
+
+  size_t slen = strlen(src);
+  char buf[4096];
+  size_t dlen = sizeof(buf);
+  char *ps = (char*)src;
+  char *pd = buf;
+  iconv(conv, &ps, &slen, &pd, &dlen);
+  DASSERT(slen==0);
+
+  size_t chars = (sizeof(buf) - dlen) / 2;
+  iconv_close(conv);
+  return chars;
+}
+
+unsigned char* utf8_to_ucs4le(const char *utf8, size_t *chars)
+{
+  const char *tocode = "UCS-4LE";
+  const char *fromcode = "UTF-8";
+
+  iconv_t conv = iconv_open(tocode, fromcode);
+  if (!conv) return NULL;
+
+  unsigned char *ucs4le = NULL;
+
+  do {
+    size_t slen = strlen(utf8);
+    size_t dlen = slen * 4;
+
+    ucs4le = (unsigned char*)malloc(dlen+1);
+    if (!ucs4le) break;
+
+    char *src = (char*)utf8;
+    char *dst = (char*)ucs4le;
+    size_t s = slen;
+    size_t d = dlen;
+    iconv(conv, &src, &s, &dst, &d);
+    dst[0] = '\0';
+
+    if (chars) *chars = (dlen - d) / 4;
+  } while (0);
+
+  iconv_close(conv);
+  return ucs4le;
+}
+
+char* ucs4le_to_utf8(const unsigned char *ucs4le, size_t slen, size_t *chars)
+{
+  const char *fromcode = "UCS-4LE";
+  const char *tocode = "UTF-8";
+
+  iconv_t conv = iconv_open(tocode, fromcode);
+  if (!conv) return NULL;
+
+  char *utf8 = NULL;
+
+  do {
+    size_t dlen = slen;
+
+    utf8 = (char*)malloc(dlen+1);
+    if (!utf8) break;
+
+    char *dst = utf8;
+    char *src = (char*)ucs4le;
+    size_t s = slen;
+    size_t d = dlen;
+    iconv(conv, &src, &s, &dst, &d);
+    dst[0] = '\0';
+
+    if (chars) *chars = (slen - s) / 4;
+  } while (0);
+
+  iconv_close(conv);
+  return utf8;
+}
+
+SQLCHAR* wchars_to_chars(const SQLWCHAR *wchars, size_t chs, size_t *bytes)
+{
+  size_t dlen = chs * 4;
+  SQLCHAR *dst = (SQLCHAR*)malloc(dlen + 1);
+  if (!dst) return NULL;
+
+  string_conv("UCS-2LE", "UTF-8", (const unsigned char*)wchars, chs * sizeof(*wchars), dst, dlen + 1, NULL, bytes);
+
+  return dst;
+}
+

src/connector/odbc/src/todbc_util.h

+/*
+ * 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/>.
+ */
+
+#ifndef _TODBC_UTIL_H_
+#define _TODBC_UTIL_H_
+
+#include <libgen.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sql.h>
+
+#define D(fmt, ...)                                              \
+  fprintf(stderr,                                                \
+          "%s[%d]:%s() " fmt "\n",                               \
+          basename((char*)__FILE__), __LINE__, __func__,         \
+          ##__VA_ARGS__)
+
+#define DASSERT(statement)                                       \
+do {                                                             \
+  if (statement) break;                                          \
+  D("Assertion failure: %s", #statement);                        \
+  abort();                                                       \
+} while (0)
+
+#define DASSERTX(statement, fmt, ...)                                \
+do {                                                                 \
+  if (statement) break;                                              \
+  D("Assertion failure: %s, " fmt "", #statement, ##__VA_ARGS__);    \
+  abort();                                                           \
+} while (0)
+
+
+
+const char* sql_sql_type(int type);
+const char* sql_c_type(int type);
+
+int is_valid_sql_c_type(int type);
+int is_valid_sql_sql_type(int type);
+
+int string_conv(const char *fromcode, const char *tocode,
+                const unsigned char *src, size_t sbytes,
+                unsigned char *dst, size_t dbytes,
+                size_t *consumed, size_t *generated);
+int utf8_chars(const char *src);
+
+unsigned char* utf8_to_ucs4le(const char *utf8, size_t *chars);
+char*          ucs4le_to_utf8(const unsigned char *ucs4le, size_t slen, size_t *chars);
+SQLCHAR*       wchars_to_chars(const SQLWCHAR *wchars, size_t chs, size_t *bytes);
+
+#endif // _TODBC_UTIL_H_

src/connector/odbc/tests/CMakeLists.txt

+PROJECT(TDengine)
+
+IF (TD_LINUX)
+  AUX_SOURCE_DIRECTORY(. SRC)
+  ADD_EXECUTABLE(tcodbc main.c)
+  TARGET_LINK_LIBRARIES(tcodbc odbc)
+ENDIF ()

src/connector/odbc/tests/main.c

+#include <sql.h>
+#include <sqlext.h>
+
+#include <stdio.h>
+#include <string.h>
+
+#include "os.h"
+
+// static const char *dsn = "TAOS_DSN";
+// static const char *uid = "root";
+// static const char *pwd = "taosdata";
+
+typedef struct data_s            data_t;
+struct data_s {
+  int64_t                 ts;
+  int8_t                  b;
+  int8_t                  v1;
+  int16_t                 v2;
+  int32_t                 v4;
+  int64_t                 v8;
+  float                   f4;
+  double                  f8;
+  char                    bin[40+1];
+  char                    blob[40+1]; // why 80?  ref: tests/examples/c/apitest.c
+};
+
+static const char *pre_stmts[] = {
+  "create database db",
+  "use db",
+  "create table t (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin binary(40), blob nchar(10))"
+};
+
+static const char *pro_stmts[] = {
+  // "insert into t values ('2019-07-15 00:00:00', 1)",
+  // "insert into t values ('2019-07-15 01:00:00', 2)",
+  "select * from t"
+  // "drop database db"
+};
+
+#define CHK_RESULT(r, ht, h)                                                    \
+do {                                                                            \
+  if (r==0) break;                                                              \
+  SQLCHAR      ss[10];                                                          \
+  SQLINTEGER   ne = 0;                                                          \
+  SQLCHAR      es[4096];                                                        \
+  SQLSMALLINT  n  = 0;                                                          \
+  ss[0] = '\0';                                                                 \
+  es[0] = '\0';                                                                 \
+  SQLRETURN ret = SQLGetDiagRec(ht, h, 1, ss, &ne, es, sizeof(es), &n);         \
+  if (ret) break;                                                               \
+  fprintf(stderr, "%s%s\n", ss, es);                                            \
+} while (0)
+
+static int do_statement(SQLHSTMT stmt, const char *statement) {
+  SQLRETURN r = 0;
+  do {
+    fprintf(stderr, "prepare [%s]\n", statement);
+    r = SQLPrepare(stmt, (SQLCHAR*)statement, strlen(statement));
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    if (r) break;
+    fprintf(stderr, "execute [%s]\n", statement);
+    r = SQLExecute(stmt);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    if (r) break;
+    fprintf(stderr, "done\n");
+  } while (0);
+  fprintf(stderr, "r: [%x][%d]\n", r, r);
+  return r;
+}
+
+static int do_insert(SQLHSTMT stmt, data_t data) {
+  SQLRETURN r = 0;
+  SQLLEN 		lbin;
+  SQLLEN    lblob;
+
+  const char *statement = "insert into t values (?, ?, ?, ?, ?, ?, ?, ?, ?,?)";
+  int ignored = 0;
+
+  do {
+    fprintf(stderr, "prepare [%s]\n", statement);
+    r = SQLPrepare(stmt, (SQLCHAR*)statement, strlen(statement));
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    if (r) break;
+
+    fprintf(stderr, "bind 1 [%s]\n", statement);
+    r = SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_SBIGINT, SQL_TIMESTAMP, ignored, ignored, &data.ts, ignored, NULL);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    if (r) break;
+
+    fprintf(stderr, "bind 2 [%s]\n", statement);
+    r = SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_BIT, SQL_BIT, ignored, ignored, &data.b, ignored, NULL);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    if (r) break;
+
+    fprintf(stderr, "bind 3 [%s]\n", statement);
+    r = SQLBindParameter(stmt, 3, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_TINYINT, ignored, ignored, &data.v1, ignored, NULL);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    if (r) break;
+
+    fprintf(stderr, "bind 4 [%s]\n", statement);
+    r = SQLBindParameter(stmt, 4, SQL_PARAM_INPUT, SQL_C_SHORT, SQL_SMALLINT, ignored, ignored, &data.v2, ignored, NULL);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    if (r) break;
+
+    fprintf(stderr, "bind 5 [%s]\n", statement);
+    r = SQLBindParameter(stmt, 5, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, ignored, ignored, &data.v4, ignored, NULL);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    if (r) break;
+
+    fprintf(stderr, "bind 6 [%s]\n", statement);
+    r = SQLBindParameter(stmt, 6, SQL_PARAM_INPUT, SQL_C_SBIGINT, SQL_BIGINT, ignored, ignored, &data.v8, ignored, NULL);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    if (r) break;
+
+    fprintf(stderr, "bind 7 [%s]\n", statement);
+    r = SQLBindParameter(stmt, 7, SQL_PARAM_INPUT, SQL_C_FLOAT, SQL_FLOAT, ignored, ignored, &data.f4, ignored, NULL);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    if (r) break;
+
+    fprintf(stderr, "bind 8 [%s]\n", statement);
+    r = SQLBindParameter(stmt, 8, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, ignored, ignored, &data.f8, ignored, NULL);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    if (r) break;
+
+    fprintf(stderr, "bind 9 [%s]\n", statement);
+    lbin = SQL_NTS;
+    r = SQLBindParameter(stmt, 9, SQL_PARAM_INPUT, SQL_C_BINARY, SQL_VARBINARY, sizeof(data.bin)-1, ignored, &data.bin, ignored, &lbin);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    if (r) break;
+
+    fprintf(stderr, "bind 10 [%s]\n", statement);
+    lblob = SQL_NTS;
+    r = SQLBindParameter(stmt, 10, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, sizeof(data.blob)-1, ignored, &data.blob, ignored, &lblob);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    if (r) break;
+
+    fprintf(stderr, "execute [%s]\n", statement);
+    r = SQLExecute(stmt);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    if (r) break;
+
+    // ts += 1;
+    // v  = 2;
+    // fprintf(stderr, "execute [%s]\n", statement);
+    // r = SQLExecute(stmt);
+    // if (r) break;
+
+    fprintf(stderr, "done\n");
+  } while (0);
+  fprintf(stderr, "r: [%x][%d]\n", r, r);
+  return r;
+}
+
+int main(int argc, char *argv[]) {
+  if (argc < 4) return 1;
+  const char *dsn = argv[1];
+  const char *uid = argv[2];
+  const char *pwd = argv[3];
+  SQLRETURN r;
+  SQLHENV env = {0};
+  SQLHDBC conn = {0};
+  r = SQLAllocEnv(&env);
+  if (r!=SQL_SUCCESS) return 1;
+  do {
+    r = SQLAllocConnect(env, &conn);
+    CHK_RESULT(r, SQL_HANDLE_ENV, env);
+    if (r!=SQL_SUCCESS) break;
+    do {
+      r = SQLConnect(conn, (SQLCHAR*)dsn, strlen(dsn),
+                           (SQLCHAR*)uid, strlen(uid),
+                           (SQLCHAR*)pwd, strlen(pwd));
+      CHK_RESULT(r, SQL_HANDLE_DBC, conn);
+      if (r!=SQL_SUCCESS) break;
+      do {
+        SQLHSTMT stmt = {0};
+        r = SQLAllocHandle(SQL_HANDLE_STMT, conn, &stmt);
+        if (r!=SQL_SUCCESS) break;
+        do {
+          do_statement(stmt, "drop database db");
+          for (size_t i=0; i<sizeof(pre_stmts)/sizeof(pre_stmts[0]); ++i) {
+            r = do_statement(stmt, pre_stmts[i]);
+            if (r!=SQL_SUCCESS) break;
+          }
+          do {
+            data_t       data = {0};
+            data.ts      = 1591060628001;
+            data.b       = 1;
+            data.v1      = 127;
+            data.v2      = 32767;
+            data.v4      = 2147483647;
+            data.v8      = 9223372036854775807;
+            data.f4      = 123.456;
+            data.f8      = 9999999.999999;
+            memset(data.bin, 0, sizeof(data.bin));
+            memset(data.blob, 0, sizeof(data.blob));
+            snprintf(data.bin, sizeof(data.bin), "hel我lo");
+            snprintf(data.blob, sizeof(data.blob), "world");
+            snprintf(data.blob, sizeof(data.blob), "wo人rld");
+            SQLHSTMT stmt = {0};
+            r = SQLAllocHandle(SQL_HANDLE_STMT, conn, &stmt);
+            if (r!=SQL_SUCCESS) break;
+            do {
+              r = do_insert(stmt, data);
+              if (r!=SQL_SUCCESS) break;
+            } while (0);
+            SQLFreeHandle(SQL_HANDLE_STMT, stmt);
+
+            // r = SQLAllocHandle(SQL_HANDLE_STMT, conn, &stmt);
+            // if (r!=SQL_SUCCESS) break;
+            // do {
+            //   r = do_insert(stmt, ts++, v++);
+            //   if (r!=SQL_SUCCESS) break;
+            // } while (0);
+            // SQLFreeHandle(SQL_HANDLE_STMT, stmt);
+          } while (0);
+          if (r!=SQL_SUCCESS) break;
+          for (size_t i=0; i<sizeof(pro_stmts)/sizeof(pro_stmts[0]); ++i) {
+            r = do_statement(stmt, pro_stmts[i]);
+            if (r!=SQL_SUCCESS) break;
+          }
+        } while (0);
+        SQLFreeHandle(SQL_HANDLE_STMT, stmt);
+      } while (0);
+      SQLDisconnect(conn);
+    } while (0);
+    SQLFreeConnect(conn);
+  } while (0);
+  SQLFreeEnv(env);
+  return r ? 1 : 0;
+}
+

src/connector/odbc/tests/odbc.py

+import pyodbc
+cnxn = pyodbc.connect('DSN=TAOS_DSN;UID=root;PWD=taosdata', autocommit=True)
+cnxn.setdecoding(pyodbc.SQL_CHAR, encoding='utf-8')
+#cnxn.setdecoding(pyodbc.SQL_WCHAR, encoding='utf-8')
+#cnxn.setencoding(encoding='utf-8')
+
+cursor = cnxn.cursor()
+cursor.execute("SELECT * from db.t")
+row = cursor.fetchone()
+while row:
+    print(row)
+    row = cursor.fetchone()
+cursor.close()
+
+#cursor = cnxn.cursor()
+#cursor.execute("""
+#INSERT INTO db.t values (?,?,?,?,?,?,?,?,?,?)
+#""",
+#"2020-12-12 00:00:00",
+#1,
+#27,
+#32767,
+#147483647,
+#223372036854775807,
+#23.456,
+#899.999999,
+#"foo",
+#"bar")
+
+cursor = cnxn.cursor()
+cursor.execute("drop database if exists db");
+cursor.close()
+
+cursor = cnxn.cursor()
+cursor.execute("create database db");
+cursor.close()
+
+cursor = cnxn.cursor()
+cursor.execute("create table db.t (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin binary(40), blob nchar(10))");
+cursor.close()
+
+cursor = cnxn.cursor()
+cursor.execute("insert into db.t values('2020-10-13 06:44:00', 1, 127, 32767, 32768, 32769, 123.456, 789.987, 'hello', 'world')")
+cursor.close()
+
+cursor = cnxn.cursor()
+cursor.execute("insert into db.t values(?,?,?,?,?,?,?,?,?,?)", "2020-10-13 07:06:00", 0, 127, 32767, 32768, 32769, 123.456, 789.987, "hel后lo", "wo哈rld");
+cursor.close()
+
+cursor = cnxn.cursor()
+cursor.execute("SELECT * from db.t")
+row = cursor.fetchone()
+while row:
+    print(row)
+    row = cursor.fetchone()
+cursor.close()
+
+cursor = cnxn.cursor()
+cursor.execute("drop database if exists db");
+cursor.close()
+
+cursor = cnxn.cursor()
+cursor.execute("create database db");
+cursor.close()
+
+cursor = cnxn.cursor()
+cursor.execute("create table db.t (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin binary(4), blob nchar(4))");
+cursor.close()
+
+cursor = cnxn.cursor()
+cursor.execute("insert into db.t values('2020-10-13 06:44:00', 1, 127, 32767, 32768, 32769, 123.456, 789.987, 'hell', 'worl')")
+cursor.close()
+
+cursor = cnxn.cursor()
+cursor.execute("SELECT * from db.t")
+row = cursor.fetchone()
+while row:
+    print(row)
+    row = cursor.fetchone()
+cursor.close()
+
+cursor = cnxn.cursor()
+cursor.execute("create table db.v (ts timestamp, v1 tinyint)")
+cursor.close()
+
+params = [ ('A', 1), ('B', 2), ('C', 3) ]
+params = [ ('A', 1), ('B', 2), ('C', 3) ]
+params = [ ('2020-10-16 00:00:00', 1),
+           ('2020-10-16 00:00:01', 4),
+           ('2020-10-16 00:00:02', 5),
+           ('2020-10-16 00:00:03.009', 6) ]
+cursor = cnxn.cursor()
+cursor.fast_executemany = True
+cursor.executemany("insert into db.v values (?, ?)", params)
+cursor.close()
+
+cursor = cnxn.cursor()
+cursor.execute("SELECT * from db.v")
+row = cursor.fetchone()
+while row:
+    print(row)
+    row = cursor.fetchone()
+cursor.close()
+
+cursor = cnxn.cursor()
+cursor.execute("SELECT * from db.v where v1 > ?", 4)
+row = cursor.fetchone()
+while row:
+    print(row)
+    row = cursor.fetchone()
+cursor.close()
+
+cursor = cnxn.cursor()
+cursor.execute("SELECT * from db.v where v1 > ?", '5')
+row = cursor.fetchone()
+while row:
+    print(row)
+    row = cursor.fetchone()
+cursor.close()
+

src/inc/taos.h

@@ -69,6 +69,8 @@ DLL_EXPORT int   taos_options(TSDB_OPTION option, const void *arg, ...);
 DLL_EXPORT TAOS *taos_connect(const char *ip, const char *user, const char *pass, const char *db, uint16_t port);
 DLL_EXPORT void  taos_close(TAOS *taos);
 
+const char *taos_data_type(int type);
+
 typedef struct TAOS_BIND {
   int            buffer_type;
   void *         buffer;
@@ -77,10 +79,26 @@ typedef struct TAOS_BIND {
   int *          is_null;
   int            is_unsigned;  // unused
   int *          error;        // unused
+  union {
+    int64_t        ts;
+    int8_t         b;
+    int8_t         v1;
+    int16_t        v2;
+    int32_t        v4;
+    int64_t        v8;
+    float          f4;
+    double         f8;
+    unsigned char *bin;
+    char          *nchar;
+  } u;
+  unsigned int     allocated;
 } TAOS_BIND;
 
 TAOS_STMT *taos_stmt_init(TAOS *taos);
 int        taos_stmt_prepare(TAOS_STMT *stmt, const char *sql, unsigned long length);
+int        taos_stmt_is_insert(TAOS_STMT *stmt, int *insert);
+int        taos_stmt_num_params(TAOS_STMT *stmt, int *nums);
+int        taos_stmt_get_param(TAOS_STMT *stmt, int idx, int *type, int *bytes);
 int        taos_stmt_bind_param(TAOS_STMT *stmt, TAOS_BIND *bind);
 int        taos_stmt_add_batch(TAOS_STMT *stmt);
 int        taos_stmt_execute(TAOS_STMT *stmt);

src/inc/taoserror.h

@@ -354,6 +354,23 @@ TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_TAG_VALUE_TOO_LONG,   0, 0x11A4, "tag value
 TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_VALUE_NULL,           0, 0x11A5, "value not find")
 TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_VALUE_TYPE,           0, 0x11A6, "value type should be boolean, number or string")
 
+
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_OOM,                     0, 0x2101, "out of memory")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_UNDEF,              0, 0x2102, "convertion undefined")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_TRUNC,              0, 0x2103, "convertion truncated")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_NOT_SUPPORT,        0, 0x2104, "convertion not supported")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_OUT_OF_RANGE,            0, 0x2105, "out of range")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_NOT_SUPPORT,             0, 0x2106, "not supported yet")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_INVALID_HANDLE,          0, 0x2107, "invalid handle")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_NO_RESULT,               0, 0x2108, "no result set")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_NO_FIELDS,               0, 0x2109, "no fields returned")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_INVALID_CURSOR,          0, 0x2110, "invalid cursor")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_STATEMENT_NOT_READY,     0, 0x2111, "statement not ready")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONNECTION_BUSY,         0, 0x2112, "connection still busy")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_BAD_CONNSTR,             0, 0x2113, "bad connection string")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_BAD_ARG,                 0, 0x2114, "bad argument")
+
+
 #ifdef TAOS_ERROR_C
 };
 #endif

src/os/inc/osDef.h

@@ -27,7 +27,7 @@ extern "C" {
 #define FD_VALID(x) ((x) > STDERR_FILENO)
 #define FD_INITIALIZER  ((int32_t)-1)
 
-#define WCHAR wchar_t
+// #define WCHAR wchar_t
 
 #define POINTER_SHIFT(p, b) ((void *)((char *)(p) + (b)))
 #define POINTER_DISTANCE(p1, p2) ((char *)(p1) - (char *)(p2)) 

tests/examples/JDBC/JDBCDemo/pom.xml

@@ -5,18 +5,11 @@
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>com.taosdata.jdbc</groupId>
-    <artifactId>jdbcdemo</artifactId>
-    <version>1.0-SNAPSHOT</version>
+    <artifactId>jdbcChecker</artifactId>
+    <version>SNAPSHOT</version>
     <packaging>jar</packaging>
     <build>
-
         <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-plugins</artifactId>
-                <version>30</version>
-            </plugin>
-
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-assembly-plugin</artifactId>
@@ -30,7 +23,7 @@
                 <configuration>
                     <archive>
                         <manifest>
-                            <mainClass>TSDBSyncSample</mainClass>
+                            <mainClass>com.taosdata.example.JdbcChecker</mainClass>
                         </manifest>
                     </archive>
                     <descriptorRefs>
@@ -63,12 +56,18 @@
         <dependency>
             <groupId>com.taosdata.jdbc</groupId>
             <artifactId>taos-jdbcdriver</artifactId>
-            <version>2.0.4</version>
+            <version>2.0.8</version>
         </dependency>
         <dependency>
             <groupId>log4j</groupId>
             <artifactId>log4j</artifactId>
             <version>1.2.17</version>
         </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.13.1</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 </project>

tests/examples/JDBC/JDBCDemo/readme.md

@@ -2,12 +2,14 @@
 TDengine's JDBC demo project is organized in a Maven way so that users can easily compile, package and run the project. If you don't have Maven on your server, you may install it using
 <pre>sudo apt-get install maven</pre>
 
-## Compile and Install JDBC Driver
-TDengine's JDBC driver jar is not yet published to maven center repo, so we need to manually compile it and install it to the local Maven repository. This can be easily done with Maven. Go to source directory of the JDBC driver ``TDengine/src/connector/jdbc`` and execute
-<pre>mvn clean package install</pre>
+## Install TDengine Client
+Make sure you have already installed a tdengine client on your current develop environment.
+Download the tdengine package on our website: ``https://www.taosdata.com/cn/all-downloads/`` and install the client.
 
 ## Compile the Demo Code and Run It
 To compile the demo project, go to the source directory ``TDengine/tests/examples/JDBC/JDBCDemo`` and execute
-<pre>mvn clean assembly:single package</pre>
-The ``pom.xml`` is configured to package all the dependencies into one executable jar file. To run it, go to ``examples/JDBC/JDBCDemo/target`` and execute
-<pre>java -jar jdbcdemo-1.0-SNAPSHOT-jar-with-dependencies.jar</pre>
+<pre>mvn clean package assembly:single</pre>
+The ``pom.xml`` is configured to package all the dependencies into one executable jar file.
+
+To run it, go to ``examples/JDBC/JDBCDemo/target`` and execute
+<pre>java -jar jdbcChecker-SNAPSHOT-jar-with-dependencies.jar -host localhost</pre>
\ No newline at end of file

tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JDBCConnectorChecker.java → tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/JdbcChecker.java

@@ -5,7 +5,7 @@ import com.taosdata.jdbc.TSDBDriver;
 import java.sql.*;
 import java.util.Properties;
 
-public class JDBCConnectorChecker {
+public class JdbcChecker {
     private static String host;
     private static String dbName = "test";
     private static String tbName = "weather";
@@ -158,7 +158,7 @@ public class JDBCConnectorChecker {
             return;
         }
 
-        JDBCConnectorChecker checker = new JDBCConnectorChecker();
+        JdbcChecker checker = new JdbcChecker();
         checker.init();
         checker.createDatabase();
         checker.useDatabase();

tests/examples/JDBC/JDBCDemo/src/main/java/com/taosdata/example/jdbcTaosdemo/domain/JdbcTaosdemoConfig.java

@@ -14,9 +14,9 @@ public final class JdbcTaosdemoConfig {
     //Destination database. Default is 'test'
     private String dbName = "test";
     //keep
-    private int keep = 365 * 20;
+    private int keep = 3650;
     //days
-    private int days = 30;
+    private int days = 10;
 
     //Super table Name. Default is 'meters'
     private String stbName = "meters";
@@ -35,7 +35,7 @@ public final class JdbcTaosdemoConfig {
     private boolean deleteTable = false;
 
     public static void printHelp() {
-        System.out.println("Usage: java -jar JDBCConnectorChecker.jar [OPTION...]");
+        System.out.println("Usage: java -jar JdbcTaosDemo.jar [OPTION...]");
         System.out.println("-h    host                       The host to connect to TDengine. you must input one");
         System.out.println("-p    port                       The TCP/IP port number to use for the connection. Default is 6030");
         System.out.println("-u    user                       The TDengine user name to use when connecting to the server. Default is 'root'");