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

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 ()
 

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/tscFunctionImpl.c

@@ -130,11 +130,11 @@ typedef struct STopBotInfo {
 } STopBotInfo;
 
 // leastsquares do not apply to super table
-typedef struct SLeastsquareInfo {
+typedef struct SLeastsquaresInfo {
   double  mat[2][3];
   double  startVal;
   int64_t num;
-} SLeastsquareInfo;
+} SLeastsquaresInfo;
 
 typedef struct SAPercentileInfo {
   SHistogramInfo *pHisto;
@@ -316,7 +316,7 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI
     *interBytes = (int16_t)sizeof(SPercentileInfo);
   } else if (functionId == TSDB_FUNC_LEASTSQR) {
     *type = TSDB_DATA_TYPE_BINARY;
-    *bytes = TSDB_AVG_FUNCTION_INTER_BUFFER_SIZE;  // string
+    *bytes = MAX(TSDB_AVG_FUNCTION_INTER_BUFFER_SIZE, sizeof(SLeastsquaresInfo));  // string
     *interBytes = *bytes;
   } else if (functionId == TSDB_FUNC_FIRST_DST || functionId == TSDB_FUNC_LAST_DST) {
     *type = TSDB_DATA_TYPE_BINARY;
@@ -2756,7 +2756,7 @@ static bool leastsquares_function_setup(SQLFunctionCtx *pCtx) {
   }
   
   SResultRowCellInfo *     pResInfo = GET_RES_INFO(pCtx);
-  SLeastsquareInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
+  SLeastsquaresInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
   
   // 2*3 matrix
   pInfo->startVal = pCtx->param[0].dKey;
@@ -2783,7 +2783,7 @@ static bool leastsquares_function_setup(SQLFunctionCtx *pCtx) {
 
 static void leastsquares_function(SQLFunctionCtx *pCtx) {
   SResultRowCellInfo *     pResInfo = GET_RES_INFO(pCtx);
-  SLeastsquareInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
+  SLeastsquaresInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
   
   double(*param)[3] = pInfo->mat;
   double x = pInfo->startVal;
@@ -2853,40 +2853,40 @@ static void leastsquares_function_f(SQLFunctionCtx *pCtx, int32_t index) {
     return;
   }
   
-  SResultRowCellInfo *     pResInfo = GET_RES_INFO(pCtx);
-  SLeastsquareInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
+  SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
+  SLeastsquaresInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
   
   double(*param)[3] = pInfo->mat;
   
   switch (pCtx->inputType) {
     case TSDB_DATA_TYPE_INT: {
       int32_t *p = pData;
-      LEASTSQR_CAL(param, pInfo->startVal, p, index, pCtx->param[1].dKey);
+      LEASTSQR_CAL(param, pInfo->startVal, p, 0, pCtx->param[1].dKey);
       break;
     };
     case TSDB_DATA_TYPE_TINYINT: {
       int8_t *p = pData;
-      LEASTSQR_CAL(param, pInfo->startVal, p, index, pCtx->param[1].dKey);
+      LEASTSQR_CAL(param, pInfo->startVal, p, 0, pCtx->param[1].dKey);
       break;
     }
     case TSDB_DATA_TYPE_SMALLINT: {
       int16_t *p = pData;
-      LEASTSQR_CAL(param, pInfo->startVal, p, index, pCtx->param[1].dKey);
+      LEASTSQR_CAL(param, pInfo->startVal, p, 0, pCtx->param[1].dKey);
       break;
     }
     case TSDB_DATA_TYPE_BIGINT: {
       int64_t *p = pData;
-      LEASTSQR_CAL(param, pInfo->startVal, p, index, pCtx->param[1].dKey);
+      LEASTSQR_CAL(param, pInfo->startVal, p, 0, pCtx->param[1].dKey);
       break;
     }
     case TSDB_DATA_TYPE_FLOAT: {
       float *p = pData;
-      LEASTSQR_CAL(param, pInfo->startVal, p, index, pCtx->param[1].dKey);
+      LEASTSQR_CAL(param, pInfo->startVal, p, 0, pCtx->param[1].dKey);
       break;
     }
     case TSDB_DATA_TYPE_DOUBLE: {
       double *p = pData;
-      LEASTSQR_CAL(param, pInfo->startVal, p, index, pCtx->param[1].dKey);
+      LEASTSQR_CAL(param, pInfo->startVal, p, 0, pCtx->param[1].dKey);
       break;
     }
     default:
@@ -2904,15 +2904,10 @@ static void leastsquares_function_f(SQLFunctionCtx *pCtx, int32_t index) {
 static void leastsquares_finalizer(SQLFunctionCtx *pCtx) {
   // no data in query
   SResultRowCellInfo *     pResInfo = GET_RES_INFO(pCtx);
-  SLeastsquareInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
+  SLeastsquaresInfo *pInfo = GET_ROWCELL_INTERBUF(pResInfo);
   
   if (pInfo->num == 0) {
-    if (pCtx->outputType == TSDB_DATA_TYPE_BINARY || pCtx->outputType == TSDB_DATA_TYPE_NCHAR) {
-      setVardataNull(pCtx->aOutputBuf, pCtx->outputType);
-    } else {
-      setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
-    }
-    
+    setNull(pCtx->aOutputBuf, pCtx->outputType, pCtx->outputBytes);
     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/tscSQLParser.c

@@ -1454,7 +1454,7 @@ static void addPrimaryTsColIntoResult(SQueryInfo* pQueryInfo) {
     }
   }
 
-  SColumnIndex index = {0};
+  SColumnIndex index = COLUMN_INDEX_INITIALIZER;
 
   // set the constant column value always attached to first table.
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
@@ -2432,6 +2432,8 @@ int32_t getTableIndexImpl(SStrToken* pTableToken, SQueryInfo* pQueryInfo, SColum
   if (pTableToken->n == 0) {  // only one table and no table name prefix in column name
     if (pQueryInfo->numOfTables == 1) {
       pIndex->tableIndex = 0;
+    } else {
+      pIndex->tableIndex = COLUMN_INDEX_INITIAL_VAL;
     }
 
     return TSDB_CODE_SUCCESS;
@@ -4187,7 +4189,7 @@ static void cleanQueryExpr(SCondExpr* pCondExpr) {
 static void doAddJoinTagsColumnsIntoTagList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SCondExpr* pCondExpr) {
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   if (QUERY_IS_JOIN_QUERY(pQueryInfo->type) && UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
-    SColumnIndex index = {0};
+    SColumnIndex index = COLUMN_INDEX_INITIALIZER;
 
     if (getColumnIndexByName(pCmd, &pCondExpr->pJoinExpr->pLeft->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
       tscError("%p: invalid column name (left)", pQueryInfo);
@@ -4604,7 +4606,7 @@ int32_t parseOrderbyClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SQuerySQL* pQu
   }
 
   SStrToken    columnName = {pVar->nLen, pVar->nType, pVar->pz};
-  SColumnIndex index = {0};
+  SColumnIndex index = COLUMN_INDEX_INITIALIZER;
 
   if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {  // super table query
     if (getColumnIndexByName(pCmd, &columnName, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
@@ -6622,7 +6624,7 @@ int32_t exprTreeFromSqlExpr(SSqlCmd* pCmd, tExprNode **pExpr, const tSQLExpr* pS
         }
       }
     } else if (pSqlExpr->nSQLOptr == TK_ID) { // column name, normal column arithmetic expression
-      SColumnIndex index = {0};
+      SColumnIndex index = COLUMN_INDEX_INITIALIZER;
       int32_t ret = getColumnIndexByName(pCmd, &pSqlExpr->colInfo, pQueryInfo, &index);
       if (ret != TSDB_CODE_SUCCESS) {
         return ret;

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/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/tests/create_data.stmts

+P:drop database if exists m;
+P:create database m;
+P:use m;
+
+P:drop table if exists t;
+P:create table t (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, blob binary(3), name nchar(1));
+P:insert into t (ts, blob, name) values('2020-10-10 00:00:00',     0,      1);
+P:insert into t (ts, blob, name) values('2020-10-10 00:00:00.001', 1,      2);
+P:insert into t (ts, blob, name) values('2020-10-10 00:00:00.002', '你',   '好');
+P:insert into t (ts, blob, name) values('2020-10-10 00:00:00.003', 'abc',  'd');
+P:select * from t;
+

src/connector/odbc/tests/query_data.stmts

+P:select * from m.t;

tests/script/general/parser/testSuite.sim

-sleep 500
 run general/parser/alter.sim
 sleep 500
 run general/parser/alter1.sim