Merge branch 'develop' into feature/query

cmake/install.inc

@@ -9,7 +9,7 @@ ELSEIF (TD_WINDOWS)
   ELSE ()
     SET(CMAKE_INSTALL_PREFIX C:/TDengine)
   ENDIF ()
-  
+
   INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/go     DESTINATION connector)
   INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/nodejs DESTINATION connector)
   INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/python DESTINATION connector)
@@ -20,12 +20,12 @@ ELSEIF (TD_WINDOWS)
   INSTALL(FILES ${TD_COMMUNITY_DIR}/src/inc/taoserror.h DESTINATION include)
   INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos.lib DESTINATION driver)
   INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos.exp DESTINATION driver)
-  INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos.dll DESTINATION driver) 
-   
+  INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos.dll DESTINATION driver)
+
   IF (TD_POWER)
     INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/power.exe DESTINATION .)
-  ELSE ()   
-    INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/taos.exe DESTINATION .)   
+  ELSE ()
+    INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/taos.exe DESTINATION .)
     INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/taosdemo.exe DESTINATION .)
   ENDIF ()
 

packaging/tools/install.sh

@@ -312,7 +312,7 @@ function install_data() {
 }
 
 function install_connector() {
-    ${csudo} cp -rf ${script_dir}/connector/* ${install_main_dir}/connector
+    ${csudo} cp -rf ${script_dir}/connector/ ${install_main_dir}/
 }
 
 function install_examples() {

packaging/tools/install_client.sh

@@ -163,7 +163,7 @@ function install_log() {
 }
 
 function install_connector() {
-    ${csudo} cp -rf ${script_dir}/connector/* ${install_main_dir}/connector
+    ${csudo} cp -rf ${script_dir}/connector/ ${install_main_dir}/
 }
 
 function install_examples() {

src/CMakeLists.txt

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

src/client/src/tscAsync.c

@@ -91,8 +91,8 @@ void taos_query_a(TAOS *taos, const char *sqlstr, __async_cb_func_t fp, void *pa
   int32_t sqlLen = (int32_t)strlen(sqlstr);
   if (sqlLen > tsMaxSQLStringLen) {
     tscError("sql string exceeds max length:%d", tsMaxSQLStringLen);
-    terrno = TSDB_CODE_TSC_INVALID_SQL;
-    tscQueueAsyncError(fp, param, TSDB_CODE_TSC_INVALID_SQL);
+    terrno = TSDB_CODE_TSC_EXCEED_SQL_LIMIT;
+    tscQueueAsyncError(fp, param, terrno);
     return;
   }
   

src/client/src/tscPrepare.c

@@ -268,7 +268,6 @@ static int doBindParam(char* data, SParamInfo* param, TAOS_BIND* bind) {
 
   if (1) {
     // allow user bind param data with different type
-    short size = 0;
     union {
       int8_t          v1;
       int16_t         v2;
@@ -600,7 +599,7 @@ static int doBindParam(char* data, SParamInfo* param, TAOS_BIND* bind) {
             if ((*bind->length) > (uintptr_t)param->bytes) {
               return TSDB_CODE_TSC_INVALID_VALUE;
             }
-            size = (short)*bind->length;
+            short size = (short)*bind->length;
             STR_WITH_SIZE_TO_VARSTR(data + param->offset, bind->buffer, size);
             return TSDB_CODE_SUCCESS;
           } break;

src/client/src/tscSql.c

@@ -321,7 +321,7 @@ TAOS_RES* taos_query_c(TAOS *taos, const char *sqlstr, uint32_t sqlLen, TAOS_RES
   
   if (sqlLen > (uint32_t)tsMaxSQLStringLen) {
     tscError("sql string exceeds max length:%d", tsMaxSQLStringLen);
-    terrno = TSDB_CODE_TSC_INVALID_SQL;
+    terrno = TSDB_CODE_TSC_EXCEED_SQL_LIMIT;
     return NULL;
   }
 
@@ -864,18 +864,16 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
   int32_t sqlLen = (int32_t)strlen(sql);
   if (sqlLen > tsMaxSQLStringLen) {
     tscError("%p sql too long", pSql);
-    pRes->code = TSDB_CODE_TSC_INVALID_SQL;
     tfree(pSql);
-    return pRes->code;
+    return TSDB_CODE_TSC_EXCEED_SQL_LIMIT;
   }
 
   pSql->sqlstr = realloc(pSql->sqlstr, sqlLen + 1);
   if (pSql->sqlstr == NULL) {
-    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
     tscError("%p failed to malloc sql string buffer", pSql);
     tscDebug("%p Valid SQL result:%d, %s pObj:%p", pSql, pRes->code, taos_errstr(pSql), pObj);
     tfree(pSql);
-    return pRes->code;
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
   strtolower(pSql->sqlstr, sql);

src/client/src/tscSubquery.c

@@ -594,7 +594,7 @@ void tscBuildVgroupTableInfo(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, SArr
 
       if (taosArrayGetSize(result) > 0) {
         SVgroupTableInfo* prevGroup = taosArrayGet(result, taosArrayGetSize(result) - 1);
-        tscDebug("%p vgId:%d, tables:%"PRId64, pSql, prevGroup->vgInfo.vgId, taosArrayGetSize(prevGroup->itemList));
+        tscDebug("%p vgId:%d, tables:%"PRIzu, pSql, prevGroup->vgInfo.vgId, taosArrayGetSize(prevGroup->itemList));
       }
 
       taosArrayPush(result, &info);
@@ -612,7 +612,7 @@ void tscBuildVgroupTableInfo(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, SArr
 
   if (taosArrayGetSize(result) > 0) {
     SVgroupTableInfo* g = taosArrayGet(result, taosArrayGetSize(result) - 1);
-    tscDebug("%p vgId:%d, tables:%"PRId64, pSql, g->vgInfo.vgId, taosArrayGetSize(g->itemList));
+    tscDebug("%p vgId:%d, tables:%"PRIzu, pSql, g->vgInfo.vgId, taosArrayGetSize(g->itemList));
   }
 }
 
@@ -753,7 +753,7 @@ static int32_t getIntersectionOfTableTuple(SQueryInfo* pQueryInfo, SSqlObj* pPar
   }
 #endif
 
-  tscDebug("%p tags match complete, result: %"PRId64", %"PRId64, pParentSql, t1, t2);
+  tscDebug("%p tags match complete, result: %"PRIzu", %"PRIzu, pParentSql, t1, t2);
   return TSDB_CODE_SUCCESS;
 }
 

grafanaplugin @ ec77d904

-Subproject commit d598db167eb256fe67409b7bb3d0eb7fffc3ff8c
+Subproject commit ec77d9049a719dabfd1a7c1122a209e201861944

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

@@ -5,24 +5,24 @@ import com.taosdata.jdbc.utils.TDNodes;
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
 
-public class BaseTest {
+public abstract class BaseTest {
 
-    private static boolean testCluster = false;           
+    private static boolean testCluster = false;
     private static TDNodes nodes = new TDNodes();
-    
+
     @BeforeClass
     public static void setupEnv() {
-        try{                         
+        try {
             if (nodes.getTDNode(1).getTaosdPid() != null) {
                 System.out.println("Kill taosd before running JDBC test");
                 nodes.getTDNode(1).setRunning(1);
                 nodes.stop(1);
             }
-            nodes.setTestCluster(testCluster);  
+            nodes.setTestCluster(testCluster);
             nodes.deploy(1);
             nodes.start(1);
         } catch (Exception e) {
-            e.printStackTrace();            
+            e.printStackTrace();
         }
     }
 

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

+package com.taosdata.jdbc.cases;
+
+import org.junit.Test;
+
+import java.sql.*;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.concurrent.TimeUnit;
+
+public class FailOverTest {
+
+    private static final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
+
+    @Test
+    public void testFailOver() throws ClassNotFoundException {
+        Class.forName("com.taosdata.jdbc.TSDBDriver");
+        final String url = "jdbc:TAOS://:/?user=root&password=taosdata";
+
+        long end = System.currentTimeMillis() + 1000 * 60 * 5;
+        while (System.currentTimeMillis() < end) {
+            try (Connection conn = DriverManager.getConnection(url)) {
+                Statement stmt = conn.createStatement();
+                ResultSet resultSet = stmt.executeQuery("select server_status()");
+                resultSet.next();
+                int status = resultSet.getInt("server_status()");
+                System.out.println(">>>>>>>>>" + sdf.format(new Date()) + " status : " + status);
+                stmt.close();
+                TimeUnit.SECONDS.sleep(5);
+            } catch (SQLException | InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+
+    }
+
+}

src/connector/odbc/CMakeLists.txt

@@ -3,7 +3,6 @@ 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?
@@ -14,20 +13,43 @@ IF (TD_LINUX_64)
       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)
+      find_package(FLEX)
+      if(NOT FLEX_FOUND)
+        message(FATAL_ERROR "you need to install flex first")
+      else ()
+        if (CMAKE_C_COMPILER_ID STREQUAL "GNU" AND CMAKE_C_COMPILER_VERSION VERSION_LESS 5.0.0)
+          message(WARNING "gcc 4.8.0 will complain too much about flex-generated code, we just bypass building ODBC driver in such case")
+        else ()
+          SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -Wconversion")
+          SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -Wconversion")
+          ADD_SUBDIRECTORY(src)
+          ADD_SUBDIRECTORY(tools)
+          ADD_SUBDIRECTORY(tests)
+        endif ()
+      endif()
     endif()
   ELSE ()
     message(WARNING "unixodbc is not installed yet, you may install it under ubuntu by typing: sudo apt install unixodbc")
   ENDIF ()
 ENDIF ()
 
+IF (TD_WINDOWS_64)
+  find_package(ODBC)
+  if (NOT ODBC_FOUND)
+    message(FATAL_ERROR "you need to install ODBC first")
+  else ()
+    message(STATUS "ODBC_INCLUDE_DIRS: ${ODBC_INCLUDE_DIRS}")
+    message(STATUS "ODBC_LIBRARIES: ${ODBC_LIBRARIES}")
+    message(STATUS "ODBC_CONFIG: ${ODBC_CONFIG}")
+  endif ()
+  find_package(FLEX)
+  if(NOT FLEX_FOUND)
+    message(WARNING "you need to install flex first\n"
+                    "you may go to: https://github.com/lexxmark/winflexbison\n"
+                    "or download from: https://github.com/lexxmark/winflexbison/releases")
+  else ()
+    ADD_SUBDIRECTORY(src)
+    ADD_SUBDIRECTORY(tools)
+    ADD_SUBDIRECTORY(tests)
+  endif()
+ENDIF ()

src/connector/odbc/README.md

+
+# ODBC Driver #
+
+- **very initial implementation of ODBC driver for TAOS
+
+- **currently partially supported ODBC functions are: `
+SQLAllocEnv
+SQLFreeEnv
+SQLAllocConnect
+SQLFreeConnect
+SQLConnect
+SQLDisconnect
+SQLAllocStmt
+SQLAllocHandle
+SQLFreeStmt
+SQLExecDirect
+SQLExecDirectW
+SQLNumResultCols
+SQLRowCount
+SQLColAttribute
+SQLGetData
+SQLFetch
+SQLPrepare
+SQLExecute
+SQLGetDiagField
+SQLGetDiagRec
+SQLBindParameter
+SQLDriverConnect
+SQLSetConnectAttr
+SQLDescribeCol
+SQLNumParams
+SQLSetStmtAttr
+ConfigDSN
+`
+
+- **internationalized, you can specify different charset/code page for easy going. eg.: insert `utf-8.zh_cn` characters into database located in linux machine, while query them out in `gb2312/gb18030/...` code page in your chinese windows machine, or vice-versa. and much fun, insert `gb2312/gb18030/...` characters into database located in linux box from
+your japanese windows box, and query them out in your local chinese  windows machine.
+
+- **enable ODBC-aware software to communicate with TAOS.
+
+- **enable any language with ODBC-bindings/ODBC-plugings to communicate with TAOS
+
+- **still going on...
+
+# Building and Testing
+**Note**: all `work` is done in TDengine's project directory
+
+
+# Building under Linux, use Ubuntu as example
+```
+sudo apt install unixodbc unixodbc-dev flex
+rm -rf debug && cmake -B debug && cmake --build debug && cmake --install debug && echo yes
+```
+# Building under Windows, use Windows 10 as example
+- install windows `flex` port. We use [https://github.com/lexxmark/winflexbison](url) at the moment. Please be noted to append `<path_to_win_flex.exe>` to your `PATH`.
+- install Microsoft Visual Studio, take VS2015 as example here
+- `"C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" amd64`
+- `rmdir /s /q debug`
+- `cmake -G "NMake Makefiles" -B debug`
+- `cmake --build debug`
+- `cmake --install debug`
+- open your `Command Prompt` with Administrator's priviledge
+- remove previously installed TAOS ODBC driver: run `C:\TDengine\todbcinst -u -f -n TAOS`
+- install TAOS ODBC driver that was just built: run `C:\TDengine\todbcinst -i -n TAOS -p C:\TDengine\driver`
+- add a new user dsn: run `odbcconf CONFIGDSN TAOS "DSN=TAOS_DSN|Server=<fqdn>:<port>`
+
+# Test
+we highly suggest that you build both in linux(ubuntu) and windows(windows 10) platform, because currently TAOS only has it's server-side port on linux platform.
+**Note1**: content within <> shall be modified to match your environment
+**Note2**: `.stmts` source files are all encoded in `UTF-8`
+## start taosd in linux, suppose charset is `UTF-8` as default
+```
+taosd -c ./debug/test/cfg
+```
+## create data in linux
+```
+./debug/build/bin/tcodbc --dsn TAOS_DSN --uid <uid> --pwd <pwd> --sts ./src/connector/odbc/tests/create_data.stmts
+--<or with driver connection string -->
+./debug/build/bin/tcodbc --dcs 'Driver=TAOS;UID=<uid>;PWD=<pwd>;Server=<fqdn>:<port>;client_enc=UTF-8' ./src/connector/odbc/tests/create_data.stmts
+```
+## query data in windows
+```
+.\debug\build\bin\tcodbc --dsn TAOS_DSN --uid <uid> --pwd <pwd> --sts .\src\connector\odbc\tests\query_data.stmts
+--<or with driver connection string -->
+.\debug\build\bin\tcodbc --dcs "Driver=TAOS;UID=<uid>;PWD=<pwd>;Server=<fqdn>:<port>;client_enc=UTF-8" .\src\connector\odbc\tests\query_data.stmts
+```
+
+

src/connector/odbc/src/CMakeLists.txt

+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
+PROJECT(TDengine)
+
+IF (TD_LINUX_64)
+  FLEX_TARGET(todbcFlexScanner
+              todbc_scanner.l
+              ${CMAKE_CURRENT_BINARY_DIR}/todbc_scanner.c
+  )
+  set(todbc_flex_scanner_src
+      ${FLEX_todbcFlexScanner_OUTPUTS}
+  )
+  AUX_SOURCE_DIRECTORY(. SRC)
+
+  # generate dynamic library (*.so)
+  ADD_LIBRARY(todbc SHARED ${SRC} ${todbc_flex_scanner_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 odbcinst)
+  target_include_directories(todbc PUBLIC .)
+
+  install(CODE "execute_process(COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/install.sh ${CMAKE_BINARY_DIR})")
+ENDIF ()
+
+IF (TD_WINDOWS_64)
+  FLEX_TARGET(todbcFlexScanner
+              todbc_scanner.l
+              ${CMAKE_CURRENT_BINARY_DIR}/todbc_scanner.c
+  )
+  set(todbc_flex_scanner_src
+      ${FLEX_todbcFlexScanner_OUTPUTS}
+  )
+  AUX_SOURCE_DIRECTORY(. SRC)
+
+  # generate dynamic library (*.dll)
+  ADD_LIBRARY(todbc SHARED
+              ${SRC}
+              ${todbc_flex_scanner_src}
+              ${CMAKE_CURRENT_BINARY_DIR}/todbc.rc
+              todbc.def)
+  TARGET_LINK_LIBRARIES(todbc taos_static odbccp32 legacy_stdio_definitions)
+  target_include_directories(todbc PUBLIC .)
+  target_compile_definitions(todbc PRIVATE "todbc_EXPORT")
+
+  CONFIGURE_FILE("todbc.rc.in"
+                 "${CMAKE_CURRENT_BINARY_DIR}/todbc.rc")
+  SET_TARGET_PROPERTIES(todbc PROPERTIES LINK_FLAGS
+                        /DEF:todbc.def)
+  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /GL")
+  SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /GL")
+
+  INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/todbc.lib DESTINATION driver)
+  INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/todbc.exp DESTINATION driver)
+  INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/todbc.dll DESTINATION driver)
+ENDIF ()

src/connector/odbc/src/install.sh

@@ -9,16 +9,18 @@ rm -f "${BLD_DIR}/template.dsn"
 
 cat > "${BLD_DIR}/template.ini" <<EOF
 [TAOS]
-Description = taos odbc driver
-Driver = ${BLD_DIR}/build/lib/libtodbc.so
+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
+Server=localhost:6030
 EOF
 
+# better remove first ?
 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.def

+EXPORTS
+SQLAllocEnv
+SQLFreeEnv
+SQLAllocConnect
+SQLFreeConnect
+SQLConnect
+SQLDisconnect
+SQLAllocStmt
+SQLAllocHandle
+SQLFreeStmt
+SQLExecDirect
+SQLExecDirectW
+SQLNumResultCols
+SQLRowCount
+SQLColAttribute
+SQLGetData
+SQLFetch
+SQLPrepare
+SQLExecute
+SQLGetDiagField
+SQLGetDiagRec
+SQLBindParameter
+SQLDriverConnect
+SQLSetConnectAttr
+SQLDescribeCol
+SQLNumParams
+SQLSetStmtAttr
+ConfigDSN
+ConfigTranslator
+ConfigDriver
+

src/connector/odbc/src/todbc.rc.in

+1 VERSIONINFO
+ FILEVERSION ${TD_VER_NUMBER}
+ PRODUCTVERSION ${TD_VER_NUMBER}
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x0L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "FileDescription", "ODBC Driver for TDengine"
+            VALUE "FileVersion", "${TD_VER_NUMBER}"
+            VALUE "InternalName", "todbc.dll(${TD_VER_CPUTYPE})"
+            VALUE "LegalCopyright", "Copyright (C) 2020 TAOS Data"
+            VALUE "OriginalFilename", ""
+            VALUE "ProductName", "todbc.dll(${TD_VER_CPUTYPE})"
+            VALUE "ProductVersion", "${TD_VER_NUMBER}"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END
\ No newline at end of file

src/connector/odbc/src/todbc.rsp

+INSTALLDRIVER "TAOS ODBC|Driver=todbc.dll|FileUsage=0|ConnectFunctions=YYN"
+
+
+
+

src/connector/odbc/src/todbc_conv.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_conv.h"
+
+#include "todbc_log.h"
+
+#include <errno.h>
+#include <limits.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+
+const char* tsdb_conv_code_str(TSDB_CONV_CODE code) {
+  switch (code) {
+    case TSDB_CONV_OK:                 return "TSDB_CONV_OK";
+    case TSDB_CONV_NOT_AVAIL:          return "TSDB_CONV_NOT_AVAIL";
+    case TSDB_CONV_OOM:                return "TSDB_CONV_OOM";
+    case TSDB_CONV_OOR:                return "TSDB_CONV_OOR";
+    case TSDB_CONV_TRUNC_FRACTION:     return "TSDB_CONV_TRUNC_FRACTION";
+    case TSDB_CONV_TRUNC:              return "TSDB_CONV_TRUNC";
+    case TSDB_CONV_CHAR_NOT_NUM:       return "TSDB_CONV_CHAR_NOT_NUM";
+    case TSDB_CONV_CHAR_NOT_TS:        return "TSDB_CONV_CHAR_NOT_TS";
+    case TSDB_CONV_NOT_VALID_TS:       return "TSDB_CONV_NOT_VALID_TS";
+    case TSDB_CONV_GENERAL:            return "TSDB_CONV_GENERAL";
+    case TSDB_CONV_SRC_TOO_LARGE:      return "TSDB_CONV_SRC_TOO_LARGE";
+    case TSDB_CONV_SRC_BAD_SEQ:        return "TSDB_CONV_SRC_BAD_SEQ";
+    case TSDB_CONV_SRC_INCOMPLETE:     return "TSDB_CONV_SRC_INCOMPLETE";
+    case TSDB_CONV_SRC_GENERAL:        return "TSDB_CONV_SRC_GENERAL";
+    case TSDB_CONV_BAD_CHAR:           return "TSDB_CONV_BAD_CHAR";
+    default: return "UNKNOWN";
+  };
+}
+
+// src: int
+TSDB_CONV_CODE tsdb_int64_to_bit(int64_t src, int8_t *dst) {
+  *dst = (int8_t)src;
+  if (src==0 || src==1) return TSDB_CONV_OK;
+  return TSDB_CONV_OOR;
+}
+
+TSDB_CONV_CODE tsdb_int64_to_tinyint(int64_t src, int8_t *dst) {
+  *dst = (int8_t)src;
+  if (src == *dst) return TSDB_CONV_OK;
+  return TSDB_CONV_OOR;
+}
+
+TSDB_CONV_CODE tsdb_int64_to_smallint(int64_t src, int16_t *dst) {
+  *dst = (int16_t)src;
+  if (src == *dst) return TSDB_CONV_OK;
+  return TSDB_CONV_OOR;
+}
+
+TSDB_CONV_CODE tsdb_int64_to_int(int64_t src, int32_t *dst) {
+  *dst = (int32_t)src;
+  if (src == *dst) return TSDB_CONV_OK;
+  return TSDB_CONV_OOR;
+}
+
+TSDB_CONV_CODE tsdb_int64_to_bigint(int64_t src, int64_t *dst) {
+  *dst = src;
+  return TSDB_CONV_OK;
+}
+
+TSDB_CONV_CODE tsdb_int64_to_ts(int64_t src, int64_t *dst) {
+  *dst = src;
+
+  time_t t = (time_t)(src / 1000);
+  struct tm tm = {0};
+  if (localtime_r(&t, &tm)) return TSDB_CONV_OK;
+
+  return TSDB_CONV_OOR;
+}
+
+TSDB_CONV_CODE tsdb_int64_to_float(int64_t src, float *dst) {
+  *dst = (float)src;
+
+  int64_t v = (int64_t)*dst;
+  if (v==src) return TSDB_CONV_OK;
+
+  return TSDB_CONV_OOR;
+}
+
+TSDB_CONV_CODE tsdb_int64_to_double(int64_t src, double *dst) {
+  *dst = (double)src;
+
+  int64_t v = (int64_t)*dst;
+  if (v==src) return TSDB_CONV_OK;
+
+  return TSDB_CONV_OOR;
+}
+
+TSDB_CONV_CODE tsdb_int64_to_char(int64_t src, char *dst, size_t dlen) {
+  int n = snprintf(dst, dlen, "%" PRId64 "", src);
+  DASSERT(n>=0);
+
+  if (n<dlen) return TSDB_CONV_OK;
+
+  return TSDB_CONV_TRUNC;
+}
+
+// src: double
+TSDB_CONV_CODE tsdb_double_to_bit(double src, int8_t *dst) {
+  *dst = (int8_t)src;
+
+  if (src<0 || src>=2) return TSDB_CONV_OOR;
+  if (src == *dst) return TSDB_CONV_OK;
+
+  int64_t v = (int64_t)src;
+  if (v == *dst) return TSDB_CONV_TRUNC_FRACTION;
+
+  return TSDB_CONV_TRUNC;
+}
+
+TSDB_CONV_CODE tsdb_double_to_tinyint(double src, int8_t *dst) {
+  *dst = (int8_t)src;
+
+  if (src<SCHAR_MIN || src>SCHAR_MAX) return TSDB_CONV_OOR;
+  if (src == *dst) return TSDB_CONV_OK;
+
+  int64_t v = (int64_t)src;
+  if (v == *dst) return TSDB_CONV_TRUNC_FRACTION;
+
+  return TSDB_CONV_TRUNC;
+}
+
+TSDB_CONV_CODE tsdb_double_to_smallint(double src, int16_t *dst) {
+  *dst = (int16_t)src;
+
+  if (src<SHRT_MIN || src>SHRT_MAX) return TSDB_CONV_OOR;
+  if (src == *dst) return TSDB_CONV_OK;
+
+  int64_t v = (int64_t)src;
+  if (v == *dst) return TSDB_CONV_TRUNC_FRACTION;
+
+  return TSDB_CONV_TRUNC;
+}
+
+TSDB_CONV_CODE tsdb_double_to_int(double src, int32_t *dst) {
+  *dst = (int32_t)src;
+
+  if (src<LONG_MIN || src>LONG_MAX) return TSDB_CONV_OOR;
+  if (src == *dst) return TSDB_CONV_OK;
+
+  int64_t v = (int64_t)src;
+  if (v == *dst) return TSDB_CONV_TRUNC_FRACTION;
+
+  return TSDB_CONV_TRUNC;
+}
+
+TSDB_CONV_CODE tsdb_double_to_bigint(double src, int64_t *dst) {
+  *dst = (int64_t)src;
+
+  if (src<LLONG_MIN || src>LLONG_MAX) return TSDB_CONV_OOR;
+  if (src == *dst) return TSDB_CONV_OK;
+
+  int64_t v = (int64_t)src;
+  if (v == *dst) return TSDB_CONV_TRUNC_FRACTION;
+
+  return TSDB_CONV_TRUNC;
+}
+
+TSDB_CONV_CODE tsdb_double_to_ts(double src, int64_t *dst) {
+  TSDB_CONV_CODE code = tsdb_double_to_bigint(src, dst);
+
+  if (code==TSDB_CONV_OK || code==TSDB_CONV_TRUNC_FRACTION) {
+    int64_t v = (int64_t)src;
+    time_t t = (time_t)(v / 1000);
+    struct tm tm = {0};
+    if (localtime_r(&t, &tm)) return TSDB_CONV_OK;
+
+    return TSDB_CONV_OOR;
+  }
+
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_double_to_char(double src, char *dst, size_t dlen) {
+  int n = snprintf(dst, dlen, "%lg", src);
+  DASSERT(n>=0);
+
+  if (n<dlen) return TSDB_CONV_OK;
+
+  return TSDB_CONV_TRUNC;
+}
+
+// src: SQL_TIMESTAMP_STRUCT
+TSDB_CONV_CODE tsdb_timestamp_to_char(SQL_TIMESTAMP_STRUCT src, char *dst, size_t dlen) {
+  int n = snprintf(dst, dlen, "%04d-%02d-%02d %02d:%02d:%02d.%03d",
+                   src.year, src.month, src.day,
+                   src.hour, src.minute, src.second,
+                   src.fraction / 1000000);
+  DASSERT(n>=0);
+  if (n<dlen) return TSDB_CONV_OK;
+
+  if (strlen(dst)>=19) return TSDB_CONV_TRUNC_FRACTION;
+
+  return TSDB_CONV_TRUNC;
+}
+
+// src: chars
+TSDB_CONV_CODE tsdb_chars_to_bit(const char *src, size_t smax, int8_t *dst) {
+  if (strcmp(src, "0")==0) {
+    *dst = 0;
+    return TSDB_CONV_OK;
+  }
+
+  if (strcmp(src, "1")==0) {
+    *dst = 1;
+    return TSDB_CONV_OK;
+  }
+
+  double v;
+  int bytes;
+  int n = sscanf(src, "%lg%n", &v, &bytes);
+
+  if (n!=1) return TSDB_CONV_CHAR_NOT_NUM;
+  if (bytes!=strlen(src)) return TSDB_CONV_CHAR_NOT_NUM;
+
+  if (v<0 || v>=2) return TSDB_CONV_OOR;
+
+  return TSDB_CONV_TRUNC_FRACTION;
+}
+
+TSDB_CONV_CODE tsdb_chars_to_tinyint(const char *src, size_t smax, int8_t *dst) {
+  int64_t v;
+  TSDB_CONV_CODE code = tsdb_chars_to_bigint(src, smax, &v);
+  if (code!=TSDB_CONV_OK) return code;
+
+  *dst = (int8_t)v;
+
+  if (v==*dst) return TSDB_CONV_OK;
+
+  return TSDB_CONV_OOR;
+}
+
+TSDB_CONV_CODE tsdb_chars_to_smallint(const char *src, size_t smax, int16_t *dst) {
+  int64_t v;
+  TSDB_CONV_CODE code = tsdb_chars_to_bigint(src, smax, &v);
+  if (code!=TSDB_CONV_OK) return code;
+
+  *dst = (int16_t)v;
+
+  if (v==*dst) return TSDB_CONV_OK;
+
+  return TSDB_CONV_OOR;
+}
+
+TSDB_CONV_CODE tsdb_chars_to_int(const char *src, size_t smax, int32_t *dst) {
+  int64_t v;
+  TSDB_CONV_CODE code = tsdb_chars_to_bigint(src, smax, &v);
+  if (code!=TSDB_CONV_OK) return code;
+
+  *dst = (int32_t)v;
+
+  if (v==*dst) return TSDB_CONV_OK;
+
+  return TSDB_CONV_OOR;
+}
+
+TSDB_CONV_CODE tsdb_chars_to_bigint(const char *src, size_t smax, int64_t *dst) {
+  int bytes;
+  int n = sscanf(src, "%" PRId64 "%n", dst, &bytes);
+
+  if (n!=1) return TSDB_CONV_CHAR_NOT_NUM;
+  if (bytes==strlen(src)) {
+    return TSDB_CONV_OK;
+  }
+
+  double v;
+  n = sscanf(src, "%lg%n", &v, &bytes);
+  if (n!=1) return TSDB_CONV_CHAR_NOT_NUM;
+  if (bytes==strlen(src)) {
+    return TSDB_CONV_TRUNC_FRACTION;
+  }
+
+  return TSDB_CONV_OK;
+}
+
+TSDB_CONV_CODE tsdb_chars_to_ts(const char *src, size_t smax, int64_t *dst) {
+  int64_t v;
+  TSDB_CONV_CODE code = tsdb_chars_to_bigint(src, smax, &v);
+  if (code!=TSDB_CONV_OK) return code;
+
+  *dst = v;
+
+  if (v==*dst) {
+    time_t t = (time_t)(v / 1000);
+    struct tm tm = {0};
+    if (localtime_r(&t, &tm)) return TSDB_CONV_OK;
+  }
+
+  return TSDB_CONV_OOR;
+}
+
+TSDB_CONV_CODE tsdb_chars_to_float(const char *src, size_t smax, float *dst) {
+  int bytes;
+  int n = sscanf(src, "%g%n", dst, &bytes);
+
+  if (n==1 && bytes==strlen(src)) {
+    return TSDB_CONV_OK;
+  }
+
+  return TSDB_CONV_CHAR_NOT_NUM;
+}
+
+TSDB_CONV_CODE tsdb_chars_to_double(const char *src, size_t smax, double *dst) {
+  int bytes;
+  int n = sscanf(src, "%lg%n", dst, &bytes);
+
+  if (n==1 && bytes==strlen(src)) {
+    return TSDB_CONV_OK;
+  }
+
+  return TSDB_CONV_CHAR_NOT_NUM;
+}
+
+TSDB_CONV_CODE tsdb_chars_to_timestamp(const char *src, size_t smax, SQL_TIMESTAMP_STRUCT *dst) {
+  int64_t v = 0;
+  // why cast to 'char*' ?
+  int r = taosParseTime((char*)src, &v, (int32_t)smax, TSDB_TIME_PRECISION_MILLI, 0);
+
+  if (r) {
+    return TSDB_CONV_CHAR_NOT_TS;
+  }
+
+  time_t t = v/1000;
+  struct tm vtm = {0};
+  localtime_r(&t, &vtm);
+  dst->year     = (SQLSMALLINT)(vtm.tm_year + 1900);
+  dst->month    = (SQLUSMALLINT)(vtm.tm_mon + 1);
+  dst->day      = (SQLUSMALLINT)(vtm.tm_mday);
+  dst->hour     = (SQLUSMALLINT)(vtm.tm_hour);
+  dst->minute   = (SQLUSMALLINT)(vtm.tm_min);
+  dst->second   = (SQLUSMALLINT)(vtm.tm_sec);
+  dst->fraction = (SQLUINTEGER)(v%1000 * 1000000);
+
+  return TSDB_CONV_OK;
+}
+
+TSDB_CONV_CODE tsdb_chars_to_timestamp_ts(const char *src, size_t smax, int64_t *dst) {
+  // why cast to 'char*' ?
+  int r = taosParseTime((char*)src, dst, (int32_t)smax, TSDB_TIME_PRECISION_MILLI, 0);
+
+  if (r) {
+    return TSDB_CONV_CHAR_NOT_TS;
+  }
+
+  return TSDB_CONV_OK;
+}
+
+TSDB_CONV_CODE tsdb_chars_to_char(const char *src, size_t smax, char *dst, size_t dmax) {
+  int n = snprintf(dst, dmax, "%s", src);
+  DASSERT(n>=0);
+  if (n<dmax) return TSDB_CONV_OK;
+
+  return TSDB_CONV_TRUNC;
+}
+
+
+char* stack_buffer_alloc(stack_buffer_t *buffer, size_t bytes) {
+  if (!buffer) return NULL;
+  // align-by-size_of-size_t-bytes
+  if (bytes==0) bytes = sizeof(size_t);
+  bytes = (bytes + sizeof(size_t) - 1) / sizeof(size_t) * sizeof(size_t);
+
+  size_t next = buffer->next + bytes;
+  if (next>sizeof(buffer->buf)) return NULL;
+
+  char *p = buffer->buf + buffer->next;
+  buffer->next = next;
+  return p;
+}
+
+int is_owned_by_stack_buffer(stack_buffer_t *buffer, const char *ptr) {
+  if (!buffer) return 0;
+  if (ptr>=buffer->buf && ptr<buffer->buf+buffer->next) return 1;
+  return 0;
+}
+
+
+struct tsdb_conv_s {
+  iconv_t             cnv;
+  unsigned int        direct:1;
+};
+
+static tsdb_conv_t      no_conversion = {0};
+static pthread_once_t   once          = PTHREAD_ONCE_INIT;
+static void once_init(void) {
+  no_conversion.cnv    = (iconv_t)-1;
+  no_conversion.direct = 1;
+}
+
+tsdb_conv_t* tsdb_conv_direct() { // get a non-conversion-converter
+  pthread_once(&once, once_init);
+  return &no_conversion;
+}
+
+tsdb_conv_t* tsdb_conv_open(const char *from_enc, const char *to_enc) {
+  pthread_once(&once, once_init);
+  tsdb_conv_t *cnv = (tsdb_conv_t*)calloc(1, sizeof(*cnv));
+  if (!cnv) return NULL;
+  if (strcmp(from_enc, to_enc)==0 && 0) {
+    cnv->cnv = (iconv_t)-1;
+    cnv->direct = 1;
+    return cnv;
+  }
+  cnv->cnv = iconv_open(to_enc, from_enc);
+  if (cnv->cnv == (iconv_t)-1) {
+    free(cnv);
+    return NULL;
+  }
+  cnv->direct = 0;
+  return cnv;
+}
+
+void tsdb_conv_close(tsdb_conv_t *cnv) {
+  if (!cnv) return;
+  if (cnv == &no_conversion) return;
+  if (!cnv->direct) {
+    if (cnv->cnv != (iconv_t)-1) {
+      iconv_close(cnv->cnv);
+    }
+  }
+  cnv->cnv = (iconv_t)-1;
+  cnv->direct = 0;
+  free(cnv);
+}
+
+TSDB_CONV_CODE tsdb_conv_write(tsdb_conv_t *cnv, const char *src, size_t *slen, char *dst, size_t *dlen) {
+  if (!cnv) return TSDB_CONV_NOT_AVAIL;
+  if (cnv->direct) {
+    size_t n = (*slen > *dlen) ? *dlen : *slen;
+    memcpy(dst, src, n);
+    *slen -= n;
+    *dlen -= n;
+    if (*dlen) dst[n] = '\0';
+    return TSDB_CONV_OK;
+  }
+  if (!cnv->cnv) return TSDB_CONV_NOT_AVAIL;
+  size_t r = iconv(cnv->cnv, (char**)&src, slen, &dst, dlen);
+  if (r==(size_t)-1) return TSDB_CONV_BAD_CHAR;
+  if (*slen)         return TSDB_CONV_TRUNC;
+  if (*dlen) *dst = '\0';
+  return TSDB_CONV_OK;
+}
+
+TSDB_CONV_CODE tsdb_conv_write_int64(tsdb_conv_t *cnv, int64_t val, char *dst, size_t *dlen) {
+  char utf8[64];
+  int n = snprintf(utf8, sizeof(utf8), "%" PRId64 "", val);
+  DASSERT(n>=0);
+  DASSERT(n<sizeof(utf8));
+  size_t len = (size_t)n;
+  TSDB_CONV_CODE code = tsdb_conv_write(cnv, utf8, &len, dst, dlen);
+  *dlen = (size_t)n+1;
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_write_double(tsdb_conv_t *cnv, double val, char *dst, size_t *dlen) {
+  char utf8[256];
+  int n = snprintf(utf8, sizeof(utf8), "%g", val);
+  DASSERT(n>=0);
+  DASSERT(n<sizeof(utf8));
+  size_t len = (size_t)n;
+  TSDB_CONV_CODE code = tsdb_conv_write(cnv, utf8, &len, dst, dlen);
+  *dlen = (size_t)n+1;
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_write_timestamp(tsdb_conv_t *cnv, SQL_TIMESTAMP_STRUCT val, char *dst, size_t *dlen) {
+  char utf8[256];
+  int n = snprintf(utf8, sizeof(utf8), "%04d-%02d-%02d %02d:%02d:%02d.%03d",
+                   val.year, val.month, val.day,
+                   val.hour, val.minute, val.second,
+                   val.fraction / 1000000);
+  DASSERT(n>=0);
+  DASSERT(n<sizeof(utf8));
+  size_t len = (size_t)n;
+  TSDB_CONV_CODE code = tsdb_conv_write(cnv, utf8, &len, dst, dlen);
+  *dlen = (size_t)n+1;
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_chars_to_bit(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int8_t *dst) {
+  const char *utf8 = NULL;
+  TSDB_CONV_CODE code = tsdb_conv(cnv, buffer, src, slen, &utf8, NULL);
+  if (code) return code;
+  code = tsdb_chars_to_bit(utf8, sizeof(utf8), dst);
+  tsdb_conv_free(cnv, utf8, buffer, src);
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_chars_to_tinyint(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int8_t *dst) {
+  const char *utf8 = NULL;
+  TSDB_CONV_CODE code = tsdb_conv(cnv, buffer, src, slen, &utf8, NULL);
+  if (code) return code;
+  code = tsdb_chars_to_tinyint(utf8, sizeof(utf8), dst);
+  tsdb_conv_free(cnv, utf8, buffer, src);
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_chars_to_smallint(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int16_t *dst) {
+  const char *utf8 = NULL;
+  TSDB_CONV_CODE code = tsdb_conv(cnv, buffer, src, slen, &utf8, NULL);
+  if (code) return code;
+  code = tsdb_chars_to_smallint(utf8, sizeof(utf8), dst);
+  tsdb_conv_free(cnv, utf8, buffer, src);
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_chars_to_int(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int32_t *dst) {
+  const char *utf8 = NULL;
+  TSDB_CONV_CODE code = tsdb_conv(cnv, buffer, src, slen, &utf8, NULL);
+  if (code) return code;
+  code = tsdb_chars_to_int(utf8, sizeof(utf8), dst);
+  tsdb_conv_free(cnv, utf8, buffer, src);
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_chars_to_bigint(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int64_t *dst) {
+  const char *utf8 = NULL;
+  TSDB_CONV_CODE code = tsdb_conv(cnv, buffer, src, slen, &utf8, NULL);
+  if (code) return code;
+  code = tsdb_chars_to_bigint(utf8, sizeof(utf8), dst);
+  tsdb_conv_free(cnv, utf8, buffer, src);
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_chars_to_ts(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int64_t *dst) {
+  const char *utf8 = NULL;
+  TSDB_CONV_CODE code = tsdb_conv(cnv, buffer, src, slen, &utf8, NULL);
+  if (code) return code;
+  code = tsdb_chars_to_ts(utf8, sizeof(utf8), dst);
+  tsdb_conv_free(cnv, utf8, buffer, src);
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_chars_to_float(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, float *dst) {
+  const char *utf8 = NULL;
+  TSDB_CONV_CODE code = tsdb_conv(cnv, buffer, src, slen, &utf8, NULL);
+  if (code) return code;
+  code = tsdb_chars_to_float(utf8, sizeof(utf8), dst);
+  tsdb_conv_free(cnv, utf8, buffer, src);
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_chars_to_double(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, double *dst) {
+  const char *utf8 = NULL;
+  TSDB_CONV_CODE code = tsdb_conv(cnv, buffer, src, slen, &utf8, NULL);
+  if (code) return code;
+  code = tsdb_chars_to_double(utf8, sizeof(utf8), dst);
+  tsdb_conv_free(cnv, utf8, buffer, src);
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_chars_to_timestamp(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, SQL_TIMESTAMP_STRUCT *dst) {
+  const char *utf8 = NULL;
+  TSDB_CONV_CODE code = tsdb_conv(cnv, buffer, src, slen, &utf8, NULL);
+  if (code) return code;
+  code = tsdb_chars_to_timestamp(utf8, sizeof(utf8), dst);
+  tsdb_conv_free(cnv, utf8, buffer, src);
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv_chars_to_timestamp_ts(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int64_t *dst) {
+  const char *utf8 = NULL;
+  TSDB_CONV_CODE code = tsdb_conv(cnv, buffer, src, slen, &utf8, NULL);
+  if (code) return code;
+  code = tsdb_chars_to_timestamp_ts(utf8, sizeof(utf8), dst);
+  tsdb_conv_free(cnv, utf8, buffer, src);
+  return code;
+}
+
+TSDB_CONV_CODE tsdb_conv(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, const char **dst, size_t *dlen) {
+  if (!cnv) return TSDB_CONV_NOT_AVAIL;
+
+  char *buf;
+  size_t blen;
+  if (cnv->direct) {
+    if (src[slen]=='\0') { // access violation?
+      *dst = src;
+      if (dlen) *dlen = slen;
+      return TSDB_CONV_OK;
+    }
+    blen = slen + 1;
+  } else {
+    blen = (slen + 1) * 4;
+  }
+
+  buf = stack_buffer_alloc(buffer, blen);
+  if (!buf) {
+    buf = (char*)malloc(blen);
+    if (!buf) return TSDB_CONV_OOM;
+  }
+
+  if (cnv->direct) {
+    size_t n = slen;
+    DASSERT(blen > n);
+    memcpy(buf, src, n);
+    buf[n] = '\0';
+    *dst = buf;
+    if (dlen) *dlen = n;
+    return TSDB_CONV_OK;
+  }
+
+  const char *orig_s = src;
+  char       *orig_d = buf;
+  size_t      orig_blen = blen;
+
+  TSDB_CONV_CODE code;
+  size_t r = iconv(cnv->cnv, (char**)&src, &slen, &buf, &blen);
+  do {
+    if (r==(size_t)-1) {
+      switch(errno) {
+        case E2BIG: {
+          code = TSDB_CONV_SRC_TOO_LARGE;
+        } break;
+        case EILSEQ: {
+          code = TSDB_CONV_SRC_BAD_SEQ;
+        } break;
+        case EINVAL: {
+          code = TSDB_CONV_SRC_INCOMPLETE;
+        } break;
+        default: {
+          code = TSDB_CONV_SRC_GENERAL;
+        } break;
+      }
+      break;
+    }
+    if (slen) {
+      code = TSDB_CONV_TRUNC;
+      break;
+    }
+    DASSERT(blen);
+    *buf = '\0';
+    *dst = orig_d;
+    if (dlen) *dlen = orig_blen - blen;
+    return TSDB_CONV_OK;
+  } while (0);
+
+  if (orig_d!=(char*)orig_s && !is_owned_by_stack_buffer(buffer, orig_d)) free(orig_d);
+  return code;
+}
+
+void tsdb_conv_free(tsdb_conv_t *cnv, const char *ptr, stack_buffer_t *buffer, const char *src) {
+  if (ptr!=src && !is_owned_by_stack_buffer(buffer, ptr)) free((char*)ptr);
+}
+

src/connector/odbc/src/todbc_conv.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_conv_h_
+#define _todbc_conv_h_
+
+#include "os.h"
+#include <iconv.h>
+#include <sql.h>
+
+
+typedef enum {
+  TSDB_CONV_OK             = 0,
+  TSDB_CONV_NOT_AVAIL,
+  TSDB_CONV_OOM,
+  TSDB_CONV_OOR,
+  TSDB_CONV_TRUNC_FRACTION,
+  TSDB_CONV_TRUNC,
+  TSDB_CONV_CHAR_NOT_NUM,
+  TSDB_CONV_CHAR_NOT_TS,
+  TSDB_CONV_NOT_VALID_TS,
+  TSDB_CONV_GENERAL,
+  TSDB_CONV_BAD_CHAR,
+  TSDB_CONV_SRC_TOO_LARGE,
+  TSDB_CONV_SRC_BAD_SEQ,
+  TSDB_CONV_SRC_INCOMPLETE,
+  TSDB_CONV_SRC_GENERAL,
+} TSDB_CONV_CODE;
+
+const char* tsdb_conv_code_str(TSDB_CONV_CODE code);
+
+typedef struct stack_buffer_s           stack_buffer_t;
+struct stack_buffer_s {
+  char                  buf[1024*16];
+  size_t                next;
+};
+
+char* stack_buffer_alloc(stack_buffer_t *buffer, size_t bytes);
+int is_owned_by_stack_buffer(stack_buffer_t *buffer, const char *ptr);
+
+typedef struct tsdb_conv_s             tsdb_conv_t;
+tsdb_conv_t*   tsdb_conv_direct(); // get a non-conversion-converter
+tsdb_conv_t*   tsdb_conv_open(const char *from_enc, const char *to_enc);
+void           tsdb_conv_close(tsdb_conv_t *cnv);
+
+TSDB_CONV_CODE tsdb_conv_write(tsdb_conv_t *cnv, const char *src, size_t *slen, char *dst, size_t *dlen);
+TSDB_CONV_CODE tsdb_conv_write_int64(tsdb_conv_t *cnv, int64_t val, char *dst, size_t *dlen);
+TSDB_CONV_CODE tsdb_conv_write_double(tsdb_conv_t *cnv, double val, char *dst, size_t *dlen);
+TSDB_CONV_CODE tsdb_conv_write_timestamp(tsdb_conv_t *cnv, SQL_TIMESTAMP_STRUCT val, char *dst, size_t *dlen);
+
+TSDB_CONV_CODE tsdb_conv_chars_to_bit(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int8_t *dst);
+TSDB_CONV_CODE tsdb_conv_chars_to_tinyint(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int8_t *dst);
+TSDB_CONV_CODE tsdb_conv_chars_to_smallint(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int16_t *dst);
+TSDB_CONV_CODE tsdb_conv_chars_to_int(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int32_t *dst);
+TSDB_CONV_CODE tsdb_conv_chars_to_bigint(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int64_t *dst);
+TSDB_CONV_CODE tsdb_conv_chars_to_ts(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int64_t *dst);
+TSDB_CONV_CODE tsdb_conv_chars_to_float(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, float *dst);
+TSDB_CONV_CODE tsdb_conv_chars_to_double(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, double *dst);
+TSDB_CONV_CODE tsdb_conv_chars_to_timestamp(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, SQL_TIMESTAMP_STRUCT *dst);
+TSDB_CONV_CODE tsdb_conv_chars_to_timestamp_ts(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, int64_t *dst);
+TSDB_CONV_CODE tsdb_conv(tsdb_conv_t *cnv, stack_buffer_t *buffer, const char *src, size_t slen, const char **dst, size_t *dlen);
+void           tsdb_conv_free(tsdb_conv_t *cnv, const char *ptr, stack_buffer_t *buffer, const char *src);
+
+
+TSDB_CONV_CODE tsdb_int64_to_bit(int64_t src, int8_t *dst);
+TSDB_CONV_CODE tsdb_int64_to_tinyint(int64_t src, int8_t *dst);
+TSDB_CONV_CODE tsdb_int64_to_smallint(int64_t src, int16_t *dst);
+TSDB_CONV_CODE tsdb_int64_to_int(int64_t src, int32_t *dst);
+TSDB_CONV_CODE tsdb_int64_to_bigint(int64_t src, int64_t *dst);
+TSDB_CONV_CODE tsdb_int64_to_ts(int64_t src, int64_t *dst);
+TSDB_CONV_CODE tsdb_int64_to_float(int64_t src, float *dst);
+TSDB_CONV_CODE tsdb_int64_to_double(int64_t src, double *dst);
+TSDB_CONV_CODE tsdb_int64_to_char(int64_t src, char *dst, size_t dlen);
+
+TSDB_CONV_CODE tsdb_double_to_bit(double src, int8_t *dst);
+TSDB_CONV_CODE tsdb_double_to_tinyint(double src, int8_t *dst);
+TSDB_CONV_CODE tsdb_double_to_smallint(double src, int16_t *dst);
+TSDB_CONV_CODE tsdb_double_to_int(double src, int32_t *dst);
+TSDB_CONV_CODE tsdb_double_to_bigint(double src, int64_t *dst);
+TSDB_CONV_CODE tsdb_double_to_ts(double src, int64_t *dst);
+TSDB_CONV_CODE tsdb_double_to_char(double src, char *dst, size_t dlen);
+
+TSDB_CONV_CODE tsdb_timestamp_to_char(SQL_TIMESTAMP_STRUCT src, char *dst, size_t dlen);
+
+TSDB_CONV_CODE tsdb_chars_to_bit(const char *src, size_t smax, int8_t *dst);
+TSDB_CONV_CODE tsdb_chars_to_tinyint(const char *src, size_t smax, int8_t *dst);
+TSDB_CONV_CODE tsdb_chars_to_smallint(const char *src, size_t smax, int16_t *dst);
+TSDB_CONV_CODE tsdb_chars_to_int(const char *src, size_t smax, int32_t *dst);
+TSDB_CONV_CODE tsdb_chars_to_bigint(const char *src, size_t smax, int64_t *dst);
+TSDB_CONV_CODE tsdb_chars_to_ts(const char *src, size_t smax, int64_t *dst);
+TSDB_CONV_CODE tsdb_chars_to_float(const char *src, size_t smax, float *dst);
+TSDB_CONV_CODE tsdb_chars_to_double(const char *src, size_t smax, double *dst);
+TSDB_CONV_CODE tsdb_chars_to_timestamp(const char *src, size_t smax, SQL_TIMESTAMP_STRUCT *dst);
+TSDB_CONV_CODE tsdb_chars_to_char(const char *src, size_t smax, char *dst, size_t dmax);
+
+#endif // _todbc_conv_h_
+

src/connector/odbc/src/todbc_flex.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_FLEX_H_
+#define _TODBC_FLEX_H_
+
+typedef struct conn_val_s              conn_val_t;
+struct conn_val_s {
+    char                *key;
+    char                *dsn;
+    char                *uid;
+    char                *pwd;
+    char                *db;
+    char                *server;
+    char                *svr_enc;
+    char                *cli_enc;
+};
+
+
+void conn_val_reset(conn_val_t *val);
+int todbc_parse_conn_string(const char *conn, conn_val_t *val);
+
+#endif // _TODBC_FLEX_H_
+

src/connector/odbc/src/todbc_log.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_log_h_
+#define _todbc_log_h_
+
+#include "os.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)
+
+#endif // _todbc_log_h_
+

src/connector/odbc/tests/query_data.stmts

+P:select * from m.t;

src/connector/odbc/tests/select.stmts

+P: select * from db.t;
+P: select * from db.f;
+P: select * from db.v;
+P: select * from db.mt;
\ No newline at end of file