diff --git a/cmake/install.inc b/cmake/install.inc
index 9bbcc2cf40520a9ab5e7aa4d19f46b47b6b42192..746e493a17cd09db6f8bffa4e3e4ac925fac2510 100755
--- a/cmake/install.inc
+++ b/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 ()
 
diff --git a/packaging/tools/install.sh b/packaging/tools/install.sh
index aedfb0a6834afbf3c0c8c822b056ea5705f8d2ff..ddf7114f08387c2277df47e9174948e479d432ba 100755
--- a/packaging/tools/install.sh
+++ b/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() {
diff --git a/packaging/tools/install_client.sh b/packaging/tools/install_client.sh
index 24586d3390fe5c4f38b6292442fed2936d5ea7a6..34a9bfaecb4d0366008ea9b78a60434297ea9f51 100755
--- a/packaging/tools/install_client.sh
+++ b/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() {
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index f619edd221c005a8d8e707afa5271072b032f74a..a2600785c35a80d040b9f91137c630d7761cef7e 100644
--- a/src/CMakeLists.txt
+++ b/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)
 
diff --git a/src/client/inc/tscSubquery.h b/src/client/inc/tscSubquery.h
index 3226f705283fc4b5af5f1d8c6e3a736300bd2fa6..f7832c9818226d19ba1e20cb47fa17c5bfb0f611 100644
--- a/src/client/inc/tscSubquery.h
+++ b/src/client/inc/tscSubquery.h
@@ -39,9 +39,9 @@ int32_t tscHandleMultivnodeInsert(SSqlObj *pSql);
 int32_t tscHandleInsertRetry(SSqlObj* pSql);
 
 void tscBuildResFromSubqueries(SSqlObj *pSql);
-TAOS_ROW doSetResultRowData(SSqlObj *pSql, bool finalResult);
+TAOS_ROW doSetResultRowData(SSqlObj *pSql);
 
-char *getArithemicInputSrc(void *param, const char *name, int32_t colId);
+char *getArithmeticInputSrc(void *param, const char *name, int32_t colId);
 
 #ifdef __cplusplus
 }
diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index 6b3d97d6f9e5ffb6168938d3bc3e0a7a26dcbf33..ff36cf0f5ac31ecf3baa4abae5697e08a1c8bc0b 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -293,32 +293,32 @@ typedef struct SResRec {
 } SResRec;
 
 typedef struct {
-  int64_t               numOfRows;                  // num of results in current retrieved
-  int64_t               numOfRowsGroup;             // num of results of current group
-  int64_t               numOfTotal;                 // num of total results
-  int64_t               numOfClauseTotal;           // num of total result in current subclause
-  char *                pRsp;
-  int32_t               rspType;
-  int32_t               rspLen;
-  uint64_t              qhandle;
-  int64_t               uid;
-  int64_t               useconds;
-  int64_t               offset;  // offset value from vnode during projection query of stable
-  int32_t               row;
-  int16_t               numOfCols;
-  int16_t               precision;
-  bool                  completed;
-  int32_t               code;
-  int32_t               numOfGroups;
-  SResRec *             pGroupRec;
-  char *                data;
-  TAOS_ROW              tsrow;
-  int32_t*              length;  // length for each field for current row
-  char **               buffer;  // Buffer used to put multibytes encoded using unicode (wchar_t)
-  SColumnIndex *        pColumnIndex;
+  int32_t        numOfRows;                  // num of results in current retrieval
+  int64_t        numOfRowsGroup;             // num of results of current group
+  int64_t        numOfTotal;                 // num of total results
+  int64_t        numOfClauseTotal;           // num of total result in current subclause
+  char *         pRsp;
+  int32_t        rspType;
+  int32_t        rspLen;
+  uint64_t       qhandle;
+  int64_t        useconds;
+  int64_t        offset;  // offset value from vnode during projection query of stable
+  int32_t        row;
+  int16_t        numOfCols;
+  int16_t        precision;
+  bool           completed;
+  int32_t        code;
+  int32_t        numOfGroups;
+  SResRec *      pGroupRec;
+  char *         data;
+  TAOS_ROW       tsrow;
+  TAOS_ROW       urow;
+  int32_t*       length;  // length for each field for current row
+  char **        buffer;  // Buffer used to put multibytes encoded using unicode (wchar_t)
+  SColumnIndex*  pColumnIndex;
+
   SArithmeticSupport*   pArithSup;   // support the arithmetic expression calculation on agg functions
-  
-  struct SLocalReducer *pLocalReducer;
+  struct SLocalReducer* pLocalReducer;
 } SSqlRes;
 
 typedef struct STscObj {
@@ -425,6 +425,7 @@ int32_t tscTansformSQLFuncForSTableQuery(SQueryInfo *pQueryInfo);
 void    tscRestoreSQLFuncForSTableQuery(SQueryInfo *pQueryInfo);
 
 int32_t tscCreateResPointerInfo(SSqlRes *pRes, SQueryInfo *pQueryInfo);
+void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo);
 
 void tscResetSqlCmdObj(SSqlCmd *pCmd, bool removeFromCache);
 
@@ -471,8 +472,9 @@ static FORCE_INLINE void tscGetResultColumnChr(SSqlRes* pRes, SFieldInfo* pField
   int32_t bytes = pInfo->field.bytes;
 
   char* pData = pRes->data + (int32_t)(offset * pRes->numOfRows + bytes * pRes->row);
+  UNUSED(pData);
 
-  // user defined constant value output columns
+//   user defined constant value output columns
   if (pInfo->pSqlExpr != NULL && TSDB_COL_IS_UD_COL(pInfo->pSqlExpr->colInfo.flag)) {
     if (type == TSDB_DATA_TYPE_NCHAR || type == TSDB_DATA_TYPE_BINARY) {
       pData = pInfo->pSqlExpr->param[1].pz;
diff --git a/src/client/jni/com_taosdata_jdbc_TSDBJNIConnector.h b/src/client/jni/com_taosdata_jdbc_TSDBJNIConnector.h
index eaea91d1bfb0197a36fe67d78a09ab190e7e3aeb..582bd6bac03ce0049c7c22fe58fa4fa6eb8c69fb 100644
--- a/src/client/jni/com_taosdata_jdbc_TSDBJNIConnector.h
+++ b/src/client/jni/com_taosdata_jdbc_TSDBJNIConnector.h
@@ -129,6 +129,14 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getSchemaMetaData
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchRowImp
   (JNIEnv *, jobject, jlong, jlong, jobject);
 
+/*
+ * Class:     com_taosdata_jdbc_TSDBJNIConnector
+ * Method:    fetchBlockImp
+ * Signature: (JJLcom/taosdata/jdbc/TSDBResultSetBlockData;)I
+ */
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchBlockImp
+  (JNIEnv *, jobject, jlong, jlong, jobject);
+
 /*
  * Class:     com_taosdata_jdbc_TSDBJNIConnector
  * Method:    closeConnectionImp
diff --git a/src/client/src/TSDBJNIConnector.c b/src/client/src/TSDBJNIConnector.c
index 4e2272eb0566569754df5ef6201f3d190f2789c1..a8829499a324605036beefad62d83eccf4d1c65b 100644
--- a/src/client/src/TSDBJNIConnector.c
+++ b/src/client/src/TSDBJNIConnector.c
@@ -17,7 +17,6 @@
 #include "taos.h"
 #include "tlog.h"
 #include "tscUtil.h"
-#include "tsclient.h"
 
 #include "com_taosdata_jdbc_TSDBJNIConnector.h"
 
@@ -57,6 +56,10 @@ jmethodID g_rowdataSetStringFp;
 jmethodID g_rowdataSetTimestampFp;
 jmethodID g_rowdataSetByteArrayFp;
 
+jmethodID g_blockdataSetByteArrayFp;
+jmethodID g_blockdataSetNumOfRowsFp;
+jmethodID g_blockdataSetNumOfColsFp;
+
 #define JNI_SUCCESS          0
 #define JNI_TDENGINE_ERROR  -1
 #define JNI_CONNECTION_NULL -2
@@ -66,7 +69,7 @@ jmethodID g_rowdataSetByteArrayFp;
 #define JNI_FETCH_END       -6
 #define JNI_OUT_OF_MEMORY   -7
 
-void jniGetGlobalMethod(JNIEnv *env) {
+static void jniGetGlobalMethod(JNIEnv *env) {
   // make sure init function executed once
   switch (atomic_val_compare_exchange_32(&__init, 0, 1)) {
     case 0:
@@ -114,10 +117,31 @@ void jniGetGlobalMethod(JNIEnv *env) {
   g_rowdataSetByteArrayFp = (*env)->GetMethodID(env, g_rowdataClass, "setByteArray", "(I[B)V");
   (*env)->DeleteLocalRef(env, rowdataClass);
 
+  jclass blockdataClass = (*env)->FindClass(env, "com/taosdata/jdbc/TSDBResultSetBlockData");
+  jclass g_blockdataClass = (*env)->NewGlobalRef(env, blockdataClass);
+  g_blockdataSetByteArrayFp = (*env)->GetMethodID(env, g_blockdataClass, "setByteArray", "(II[B)V");
+  g_blockdataSetNumOfRowsFp = (*env)->GetMethodID(env, g_blockdataClass, "setNumOfRows", "(I)V");
+  g_blockdataSetNumOfColsFp = (*env)->GetMethodID(env, g_blockdataClass, "setNumOfCols", "(I)V");
+  (*env)->DeleteLocalRef(env, blockdataClass);
+
   atomic_store_32(&__init, 2);
   jniDebug("native method register finished");
 }
 
+static int32_t check_for_params(jobject jobj, jlong conn, jlong res) {
+  if ((TAOS*) conn == NULL) {
+    jniError("jobj:%p, connection is closed", jobj);
+    return JNI_CONNECTION_NULL;
+  }
+
+  if ((TAOS_RES *) res == NULL) {
+    jniError("jobj:%p, conn:%p, res is null", jobj, (TAOS*) conn);
+    return JNI_RESULT_SET_NULL;
+  }
+
+  return JNI_SUCCESS;
+}
+
 JNIEXPORT void JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setAllocModeImp(JNIEnv *env, jobject jobj, jint jMode,
                                                                                jstring jPath, jboolean jAutoDump) {
   if (jPath != NULL) {
@@ -192,39 +216,37 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setOptions(JNIEnv
 JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_connectImp(JNIEnv *env, jobject jobj, jstring jhost,
                                                                            jint jport, jstring jdbName, jstring juser,
                                                                            jstring jpass) {
-  jlong       ret = 0;
+  jlong       ret  = 0;
   const char *host = NULL;
-  const char *dbname = NULL;
   const char *user = NULL;
   const char *pass = NULL;
+  const char *dbname = NULL;
 
   if (jhost != NULL) {
     host = (*env)->GetStringUTFChars(env, jhost, NULL);
   }
+
   if (jdbName != NULL) {
     dbname = (*env)->GetStringUTFChars(env, jdbName, NULL);
   }
+
   if (juser != NULL) {
     user = (*env)->GetStringUTFChars(env, juser, NULL);
   }
+
   if (jpass != NULL) {
     pass = (*env)->GetStringUTFChars(env, jpass, NULL);
   }
 
   if (user == NULL) {
-    jniDebug("jobj:%p, user is null, use default user %s", jobj, TSDB_DEFAULT_USER);
+    jniDebug("jobj:%p, user not specified, use default user %s", jobj, TSDB_DEFAULT_USER);
   }
+
   if (pass == NULL) {
-    jniDebug("jobj:%p, pass is null, use default password", jobj);
+    jniDebug("jobj:%p, pass not specified, use default password", jobj);
   }
 
-  /*
-   * set numOfThreadsPerCore = 0
-   * means only one thread for client side scheduler
-   */
-  tsNumOfThreadsPerCore = 0.0;
-
-  ret = (jlong)taos_connect((char *)host, (char *)user, (char *)pass, (char *)dbname, (uint16_t)jport);
+  ret = (jlong) taos_connect((char *)host, (char *)user, (char *)pass, (char *)dbname, (uint16_t)jport);
   if (ret == 0) {
     jniError("jobj:%p, conn:%p, connect to database failed, host=%s, user=%s, dbname=%s, port=%d", jobj, (void *)ret,
              (char *)host, (char *)user, (char *)dbname, (int32_t)jport);
@@ -233,10 +255,21 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_connectImp(JNIEn
              (char *)host, (char *)user, (char *)dbname, (int32_t)jport);
   }
 
-  if (host != NULL) (*env)->ReleaseStringUTFChars(env, jhost, host);
-  if (dbname != NULL) (*env)->ReleaseStringUTFChars(env, jdbName, dbname);
-  if (user != NULL) (*env)->ReleaseStringUTFChars(env, juser, user);
-  if (pass != NULL) (*env)->ReleaseStringUTFChars(env, jpass, pass);
+  if (host != NULL) {
+    (*env)->ReleaseStringUTFChars(env, jhost, host);
+  }
+
+  if (dbname != NULL) {
+    (*env)->ReleaseStringUTFChars(env, jdbName, dbname);
+  }
+
+  if (user != NULL) {
+    (*env)->ReleaseStringUTFChars(env, juser, user);
+  }
+
+  if (pass != NULL) {
+    (*env)->ReleaseStringUTFChars(env, jpass, pass);
+  }
 
   return ret;
 }
@@ -245,64 +278,53 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_executeQueryImp(
                                                                                 jbyteArray jsql, jlong con) {
   TAOS *tscon = (TAOS *)con;
   if (tscon == NULL) {
-    jniError("jobj:%p, connection is already closed", jobj);
+    jniError("jobj:%p, connection already closed", jobj);
     return JNI_CONNECTION_NULL;
   }
 
   if (jsql == NULL) {
-    jniError("jobj:%p, conn:%p, sql is null", jobj, tscon);
+    jniError("jobj:%p, conn:%p, empty sql string", jobj, tscon);
     return JNI_SQL_NULL;
   }
 
   jsize len = (*env)->GetArrayLength(env, jsql);
 
-  char *dst = (char *)calloc(1, sizeof(char) * (len + 1));
-  if (dst == NULL) {
-    jniError("jobj:%p, conn:%p, can not alloc memory", jobj, tscon);
+  char *str = (char *) calloc(1, sizeof(char) * (len + 1));
+  if (str == NULL) {
+    jniError("jobj:%p, conn:%p, alloc memory failed", jobj, tscon);
     return JNI_OUT_OF_MEMORY;
   }
 
-  (*env)->GetByteArrayRegion(env, jsql, 0, len, (jbyte *)dst);
+  (*env)->GetByteArrayRegion(env, jsql, 0, len, (jbyte *)str);
   if ((*env)->ExceptionCheck(env)) {
     // todo handle error
   }
 
-  jniDebug("jobj:%p, conn:%p, sql:%s", jobj, tscon, dst);
-
-  SSqlObj *pSql = taos_query(tscon, dst);
+  SSqlObj *pSql = taos_query(tscon, str);
   int32_t  code = taos_errno(pSql);
 
   if (code != TSDB_CODE_SUCCESS) {
     jniError("jobj:%p, conn:%p, code:%s, msg:%s", jobj, tscon, tstrerror(code), taos_errstr(pSql));
   } else {
-    int32_t affectRows = 0;
     if (pSql->cmd.command == TSDB_SQL_INSERT) {
-      affectRows = taos_affected_rows(pSql);
+      int32_t affectRows = taos_affected_rows(pSql);
       jniDebug("jobj:%p, conn:%p, code:%s, affect rows:%d", jobj, tscon, tstrerror(code), affectRows);
     } else {
       jniDebug("jobj:%p, conn:%p, code:%s", jobj, tscon, tstrerror(code));
     }
   }
 
-  free(dst);
-  return (jlong)pSql;
+  free(str);
+  return (jlong) pSql;
 }
 
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getErrCodeImp(JNIEnv *env, jobject jobj, jlong con, jlong tres) {
-  TAOS *tscon = (TAOS *)con;
-  if (tscon == NULL) {
-    jniError("jobj:%p, connection is closed", jobj);
-    return (jint)TSDB_CODE_TSC_INVALID_CONNECTION;
+  int32_t code = check_for_params(jobj, con, tres);
+  if (code != JNI_SUCCESS) {
+    return code;
   }
 
-  if ((void *)tres == NULL) {
-    jniError("jobj:%p, conn:%p, resultset is null", jobj, tscon);
-    return JNI_RESULT_SET_NULL;
-  }
-
-  TAOS_RES *pSql = (TAOS_RES *)tres;
-
-  return (jint)taos_errno(pSql);
+  return (jint)taos_errno((TAOS_RES*) tres);
 }
 
 JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getErrMsgImp(JNIEnv *env, jobject jobj, jlong tres) {
@@ -313,23 +335,16 @@ JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getErrMsgImp(J
 JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getResultSetImp(JNIEnv *env, jobject jobj, jlong con,
                                                                                 jlong tres) {
   TAOS *tscon = (TAOS *)con;
-  if (tscon == NULL) {
-    jniError("jobj:%p, connection is closed", jobj);
-    return JNI_CONNECTION_NULL;
-  }
-
-  if ((void *)tres == NULL) {
-    jniError("jobj:%p, conn:%p, resultset is null", jobj, tscon);
-    return JNI_RESULT_SET_NULL;
+  int32_t code = check_for_params(jobj, con, tres);
+  if (code != JNI_SUCCESS) {
+    return code;
   }
 
   SSqlObj *pSql = (TAOS_RES *)tres;
-  STscObj *pObj = pSql->pTscObj;
-
   if (tscIsUpdateQuery(pSql)) {
-    jniDebug("jobj:%p, conn:%p, update query, no resultset, %p", jobj, pObj, (void *)tres);
+    jniDebug("jobj:%p, conn:%p, update query, no resultset, %p", jobj, tscon, (void *)tres);
   } else {
-    jniDebug("jobj:%p, conn:%p, get resultset, %p", jobj, pObj, (void *)tres);
+    jniDebug("jobj:%p, conn:%p, get resultset, %p", jobj, tscon, (void *)tres);
   }
 
   return tres;
@@ -337,15 +352,9 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getResultSetImp(
 
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_isUpdateQueryImp(JNIEnv *env, jobject jobj, jlong con,
                                                                                 jlong tres) {
-  TAOS *tscon = (TAOS *)con;
-  if (tscon == NULL) {
-    jniError("jobj:%p, connection is closed", jobj);
-    return JNI_CONNECTION_NULL;
-  }
-
-  if ((void *)tres == NULL) {
-    jniError("jobj:%p, conn:%p, resultset is null", jobj, tscon);
-    return JNI_RESULT_SET_NULL;
+  int32_t code = check_for_params(jobj, con, tres);
+  if (code != JNI_SUCCESS) {
+    return code;
   }
 
   SSqlObj *pSql = (TAOS_RES *)tres;
@@ -355,37 +364,27 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_isUpdateQueryImp(
 
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_freeResultSetImp(JNIEnv *env, jobject jobj, jlong con,
                                                                                 jlong res) {
-  TAOS *tscon = (TAOS *)con;
-  if (tscon == NULL) {
-    jniError("jobj:%p, connection is closed", jobj);
-    return JNI_CONNECTION_NULL;
-  }
-
-  if ((void *)res == NULL) {
-    jniError("jobj:%p, conn:%p, resultset is null", jobj, tscon);
-    return JNI_RESULT_SET_NULL;
+  int32_t code = check_for_params(jobj, con, res);
+  if (code != JNI_SUCCESS) {
+    return code;
   }
 
   taos_free_result((void *)res);
-  jniDebug("jobj:%p, conn:%p, free resultset:%p", jobj, tscon, (void *)res);
+  jniDebug("jobj:%p, conn:%p, free resultset:%p", jobj, (TAOS*) con, (void *)res);
+
   return JNI_SUCCESS;
 }
 
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getAffectedRowsImp(JNIEnv *env, jobject jobj, jlong con,
                                                                                   jlong res) {
   TAOS *tscon = (TAOS *)con;
-  if (tscon == NULL) {
-    jniError("jobj:%p, connection is closed", jobj);
-    return JNI_CONNECTION_NULL;
-  }
-
-  if ((void *)res == NULL) {
-    jniError("jobj:%p, conn:%p, resultset is null", jobj, tscon);
-    return JNI_RESULT_SET_NULL;
+  int32_t code = check_for_params(jobj, con, res);
+  if (code != JNI_SUCCESS) {
+    return code;
   }
 
   jint ret = taos_affected_rows((SSqlObj *)res);
-  jniDebug("jobj:%p, conn:%p, sql:%p, res: %p, affect rows:%d", jobj, tscon, (void *)con, (void *)res, (int32_t)ret);
+  jniDebug("jobj:%p, conn:%p, sql:%p, res: %p, affect rows:%d", jobj, tscon, (TAOS *)con, (TAOS_RES *)res, (int32_t)ret);
 
   return ret;
 }
@@ -394,27 +393,20 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getSchemaMetaData
                                                                                     jlong con, jlong res,
                                                                                     jobject arrayListObj) {
   TAOS *tscon = (TAOS *)con;
-  if (tscon == NULL) {
-    jniError("jobj:%p, connection is closed", jobj);
-    return JNI_CONNECTION_NULL;
-  }
-
-  TAOS_RES *result = (TAOS_RES *)res;
-  if (result == NULL) {
-    jniError("jobj:%p, conn:%p, resultset is null", jobj, tscon);
-    return JNI_RESULT_SET_NULL;
+  int32_t code = check_for_params(jobj, con, res);
+  if (code != JNI_SUCCESS) {
+    return code;
   }
 
-  TAOS_FIELD *fields = taos_fetch_fields(result);
-  int         num_fields = taos_num_fields(result);
-
-  // jobject arrayListObj = (*env)->NewObject(env, g_arrayListClass, g_arrayListConstructFp, "");
+  TAOS_RES* tres = (TAOS_RES*) res;
+  TAOS_FIELD *fields = taos_fetch_fields(tres);
 
+  int32_t num_fields = taos_num_fields(tres);
   if (num_fields == 0) {
-    jniError("jobj:%p, conn:%p, resultset:%p, fields size is %d", jobj, tscon, (void *)res, num_fields);
+    jniError("jobj:%p, conn:%p, resultset:%p, fields size is %d", jobj, tscon, tres, num_fields);
     return JNI_NUM_OF_FIELDS_0;
   } else {
-    jniDebug("jobj:%p, conn:%p, resultset:%p, fields size is %d", jobj, tscon, (void *)res, num_fields);
+    jniDebug("jobj:%p, conn:%p, resultset:%p, fields size is %d", jobj, tscon, tres, num_fields);
     for (int i = 0; i < num_fields; ++i) {
       jobject metadataObj = (*env)->NewObject(env, g_metadataClass, g_metadataConstructFp);
       (*env)->SetIntField(env, metadataObj, g_metadataColtypeField, fields[i].type);
@@ -457,21 +449,21 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchRowImp(JNIEn
   }
 
   TAOS_FIELD *fields = taos_fetch_fields(result);
-  int         num_fields = taos_num_fields(result);
 
-  if (num_fields == 0) {
-    jniError("jobj:%p, conn:%p, resultset:%p, fields size is %d", jobj, tscon, (void*)res, num_fields);
+  int32_t numOfFields = taos_num_fields(result);
+  if (numOfFields == 0) {
+    jniError("jobj:%p, conn:%p, resultset:%p, fields size %d", jobj, tscon, (void*)res, numOfFields);
     return JNI_NUM_OF_FIELDS_0;
   }
 
   TAOS_ROW row = taos_fetch_row(result);
   if (row == NULL) {
-    int tserrno = taos_errno(result);
-    if (tserrno == 0) {
-      jniDebug("jobj:%p, conn:%p, resultset:%p, fields size is %d, fetch row to the end", jobj, tscon, (void*)res, num_fields);
+    int code = taos_errno(result);
+    if (code == TSDB_CODE_SUCCESS) {
+      jniDebug("jobj:%p, conn:%p, resultset:%p, fields size is %d, fetch row to the end", jobj, tscon, (void*)res, numOfFields);
       return JNI_FETCH_END;
     } else {
-      jniDebug("jobj:%p, conn:%p, interruptted query", jobj, tscon);
+      jniDebug("jobj:%p, conn:%p, interrupted query", jobj, tscon);
       return JNI_RESULT_SET_NULL;
     }
   }
@@ -480,7 +472,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchRowImp(JNIEn
 
   char tmp[TSDB_MAX_BYTES_PER_ROW] = {0};
 
-  for (int i = 0; i < num_fields; i++) {
+  for (int i = 0; i < numOfFields; i++) {
     if (row[i] == NULL) {
       continue;
     }
@@ -534,6 +526,45 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchRowImp(JNIEn
   return JNI_SUCCESS;
 }
 
+JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchBlockImp(JNIEnv *env, jobject jobj, jlong con,
+                                                                           jlong res, jobject rowobj) {
+  TAOS *  tscon = (TAOS *)con;
+  int32_t code = check_for_params(jobj, con, res);
+  if (code != JNI_SUCCESS) {
+    return code;
+  }
+
+  TAOS_RES *  tres = (TAOS_RES *)res;
+  TAOS_FIELD *fields = taos_fetch_fields(tres);
+
+  int32_t numOfFields = taos_num_fields(tres);
+  assert(numOfFields > 0);
+
+  TAOS_ROW row = NULL;
+  int32_t  numOfRows = taos_fetch_block(tres, &row);
+  if (numOfRows == 0) {
+    code = taos_errno(tres);
+    if (code == JNI_SUCCESS) {
+      jniDebug("jobj:%p, conn:%p, resultset:%p, numOfFields:%d, no data to retrieve", jobj, tscon, (void *)res,
+               numOfFields);
+      return JNI_FETCH_END;
+    } else {
+      jniDebug("jobj:%p, conn:%p, query interrupted", jobj, tscon);
+      return JNI_RESULT_SET_NULL;
+    }
+  }
+
+  (*env)->CallVoidMethod(env, rowobj, g_blockdataSetNumOfRowsFp, (jint)numOfRows);
+  (*env)->CallVoidMethod(env, rowobj, g_blockdataSetNumOfColsFp, (jint)numOfFields);
+
+  for (int i = 0; i < numOfFields; i++) {
+    (*env)->CallVoidMethod(env, rowobj, g_blockdataSetByteArrayFp, i, fields[i].bytes * numOfRows,
+                           jniFromNCharToByteArray(env, (char *)row[i], fields[i].bytes * numOfRows));
+  }
+
+  return JNI_SUCCESS;
+}
+
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_closeConnectionImp(JNIEnv *env, jobject jobj,
                                                                                   jlong con) {
   TAOS *tscon = (TAOS *)con;
@@ -589,7 +620,6 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_consumeImp(JNIEn
   jniGetGlobalMethod(env);
 
   TAOS_SUB *tsub = (TAOS_SUB *)sub;
-
   TAOS_RES *res = taos_consume(tsub);
 
   if (res == NULL) {
@@ -621,16 +651,16 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_validateCreateTab
 
   jsize len = (*env)->GetArrayLength(env, jsql);
 
-  char *dst = (char *)calloc(1, sizeof(char) * (len + 1));
-  (*env)->GetByteArrayRegion(env, jsql, 0, len, (jbyte *)dst);
+  char *str = (char *)calloc(1, sizeof(char) * (len + 1));
+  (*env)->GetByteArrayRegion(env, jsql, 0, len, (jbyte *)str);
   if ((*env)->ExceptionCheck(env)) {
     // todo handle error
   }
 
-  int code = taos_validate_sql(tscon, dst);
+  int code = taos_validate_sql(tscon, str);
   jniDebug("jobj:%p, conn:%p, code is %d", jobj, tscon, code);
 
-  free(dst);
+  free(str);
   return code;
 }
 
diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c
index e9e8214c4c15588b126b0768745db084e6e7dc3b..3ff8a68d8f07f776dbb03b4b55b830b7e37dfdff 100644
--- a/src/client/src/tscAsync.c
+++ b/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;
   }
   
diff --git a/src/client/src/tscLocal.c b/src/client/src/tscLocal.c
index 310c4c665761212f6fc46b889a8a2c887b7213eb..538e652f3c6577098363565a4e76fa637b60709c 100644
--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
@@ -341,7 +341,7 @@ TAOS_ROW tscFetchRow(void *param) {
     return NULL;
   }
 
-  void* data = doSetResultRowData(pSql, true);
+  void* data = doSetResultRowData(pSql);
 
   tscClearSqlOwner(pSql);
   return data;
diff --git a/src/client/src/tscLocalMerge.c b/src/client/src/tscLocalMerge.c
index bf7791a326d8707b85388e23c1a1d432cec52dd0..3c7d46f914dd2632ac97cbcb728898ff9a657e82 100644
--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -884,17 +884,17 @@ static void genFinalResWithoutFill(SSqlRes* pRes, SLocalReducer *pLocalReducer,
   tFilePage * pBeforeFillData = pLocalReducer->pResultBuf;
 
   pRes->data = pLocalReducer->pFinalRes;
-  pRes->numOfRows = pBeforeFillData->num;
+  pRes->numOfRows = (int32_t) pBeforeFillData->num;
 
   if (pQueryInfo->limit.offset > 0) {
     if (pQueryInfo->limit.offset < pRes->numOfRows) {
-      int32_t prevSize = (int32_t)pBeforeFillData->num;
+      int32_t prevSize = (int32_t) pBeforeFillData->num;
       tColModelErase(pLocalReducer->finalModel, pBeforeFillData, prevSize, 0, (int32_t)pQueryInfo->limit.offset - 1);
 
       /* remove the hole in column model */
       tColModelCompact(pLocalReducer->finalModel, pBeforeFillData, prevSize);
 
-      pRes->numOfRows -= pQueryInfo->limit.offset;
+      pRes->numOfRows -= (int32_t) pQueryInfo->limit.offset;
       pQueryInfo->limit.offset = 0;
     } else {
       pQueryInfo->limit.offset -= pRes->numOfRows;
@@ -962,7 +962,7 @@ static void doFillResult(SSqlObj *pSql, SLocalReducer *pLocalReducer, bool doneO
       }
 
       pRes->data = pLocalReducer->pFinalRes;
-      pRes->numOfRows = newRows;
+      pRes->numOfRows = (int32_t) newRows;
 
       pQueryInfo->limit.offset = 0;
       break;
@@ -1651,7 +1651,7 @@ int32_t doArithmeticCalculate(SQueryInfo* pQueryInfo, tFilePage* pOutput, int32_
     // calculate the result from several other columns
     if (pSup->pArithExprInfo != NULL) {
       arithSup.pArithExpr = pSup->pArithExprInfo;
-      tExprTreeCalcTraverse(arithSup.pArithExpr->pExpr, (int32_t) pOutput->num, pbuf + pOutput->num*offset, &arithSup, TSDB_ORDER_ASC, getArithemicInputSrc);
+      tExprTreeCalcTraverse(arithSup.pArithExpr->pExpr, (int32_t) pOutput->num, pbuf + pOutput->num*offset, &arithSup, TSDB_ORDER_ASC, getArithmeticInputSrc);
     } else {
       SSqlExpr* pExpr = pSup->pSqlExpr;
       memcpy(pbuf + pOutput->num * offset, pExpr->offset * pOutput->num + pOutput->data, pExpr->resBytes * pOutput->num);
diff --git a/src/client/src/tscPrepare.c b/src/client/src/tscPrepare.c
index 1739e4348ca2d1e90e4cdc292a14c7dcc5dde2da..68f2ecbf0e194bc13362b0af965959367a9f86b8 100644
--- a/src/client/src/tscPrepare.c
+++ b/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;
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 1b1388238ca7775d1f8ee0127448c6e9d0dd22c2..cbc5604a279fdb4fd0eab8e9cdb902e3c42a4832 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -789,8 +789,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   size_t output = tscNumOfFields(pQueryInfo);
 
-  if ((tscIsSecondStageQuery(pQueryInfo) || UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo) ||
-      UTIL_TABLE_IS_CHILD_TABLE(pTableMetaInfo)) && (output != tscSqlExprNumOfExprs(pQueryInfo))) {
+  if (tscIsSecondStageQuery(pQueryInfo)) {
     pQueryMsg->secondStageOutput = htonl((int32_t) output);
 
     SSqlFuncMsg *pSqlFuncExpr1 = (SSqlFuncMsg *)pMsg;
@@ -1439,19 +1438,6 @@ int tscBuildRetrieveFromMgmtMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int tscSetResultPointer(SQueryInfo *pQueryInfo, SSqlRes *pRes) {
-  if (tscCreateResPointerInfo(pRes, pQueryInfo) != TSDB_CODE_SUCCESS) {
-    return pRes->code;
-  }
-
-  for (int i = 0; i < pQueryInfo->fieldsInfo.numOfOutput; ++i) {
-    int16_t offset = tscFieldInfoGetOffset(pQueryInfo, i);
-    pRes->tsrow[i] = (unsigned char*)((char*) pRes->data + offset * pRes->numOfRows);
-  }
-
-  return 0;
-}
-
 /*
  * this function can only be called once.
  * by using pRes->rspType to denote its status
@@ -1462,15 +1448,18 @@ static int tscLocalResultCommonBuilder(SSqlObj *pSql, int32_t numOfRes) {
   SSqlRes *pRes = &pSql->res;
   SSqlCmd *pCmd = &pSql->cmd;
 
-  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
-
   pRes->code = TSDB_CODE_SUCCESS;
   if (pRes->rspType == 0) {
     pRes->numOfRows = numOfRes;
     pRes->row = 0;
     pRes->rspType = 1;
 
-    tscSetResultPointer(pQueryInfo, pRes);
+    SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
+    if (tscCreateResPointerInfo(pRes, pQueryInfo) != TSDB_CODE_SUCCESS) {
+      return pRes->code;
+    }
+
+    tscSetResRawPtr(pRes, pQueryInfo);
   } else {
     tscResetForNextRetrieve(pRes);
   }
@@ -1514,10 +1503,11 @@ int tscProcessRetrieveLocalMergeRsp(SSqlObj *pSql) {
   }
 
   pRes->code = tscDoLocalMerge(pSql);
-  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
 
   if (pRes->code == TSDB_CODE_SUCCESS && pRes->numOfRows > 0) {
+    SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
     tscCreateResPointerInfo(pRes, pQueryInfo);
+    tscSetResRawPtr(pRes, pQueryInfo);
   }
 
   pRes->row = 0;
@@ -2197,7 +2187,16 @@ int tscProcessRetrieveRspFromNode(SSqlObj *pSql) {
   if (tscCreateResPointerInfo(pRes, pQueryInfo) != TSDB_CODE_SUCCESS) {
     return pRes->code;
   }
-  
+
+  STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+  if (pCmd->command == TSDB_SQL_RETRIEVE) {
+    tscSetResRawPtr(pRes, pQueryInfo);
+  } else if ((UTIL_TABLE_IS_CHILD_TABLE(pTableMetaInfo) || UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo)) && !TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_SUBQUERY)) {
+    tscSetResRawPtr(pRes, pQueryInfo);
+  } else if (tscNonOrderedProjectionQueryOnSTable(pQueryInfo, 0) && !TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_JOIN_QUERY) && !TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_JOIN_SEC_STAGE)) {
+    tscSetResRawPtr(pRes, pQueryInfo);
+  }
+
   if (pSql->pSubscription != NULL) {
     int32_t numOfCols = pQueryInfo->fieldsInfo.numOfOutput;
     
@@ -2219,7 +2218,7 @@ int tscProcessRetrieveRspFromNode(SSqlObj *pSql) {
   }
 
   pRes->row = 0;
-  tscDebug("%p numOfRows:%" PRId64 ", offset:%" PRId64 ", complete:%d", pSql, pRes->numOfRows, pRes->offset, pRes->completed);
+  tscDebug("%p numOfRows:%d, offset:%" PRId64 ", complete:%d", pSql, pRes->numOfRows, pRes->offset, pRes->completed);
 
   return 0;
 }
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index a7b859b294da689406911cb027d75b3c91149ccc..020305a0a83864ec41db4cbf06ce01ec565c2203 100644
--- a/src/client/src/tscSql.c
+++ b/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;
   }
 
@@ -394,7 +394,7 @@ int taos_affected_rows(TAOS_RES *tres) {
   SSqlObj* pSql = (SSqlObj*) tres;
   if (pSql == NULL || pSql->signature != pSql) return 0;
 
-  return (int)(pSql->res.numOfRows);
+  return pSql->res.numOfRows;
 }
 
 TAOS_FIELD *taos_fetch_fields(TAOS_RES *res) {
@@ -443,50 +443,30 @@ int taos_retrieve(TAOS_RES *res) {
   if (pCmd->command < TSDB_SQL_LOCAL) {
     pCmd->command = (pCmd->command > TSDB_SQL_MGMT) ? TSDB_SQL_RETRIEVE : TSDB_SQL_FETCH;
   }
-  tscProcessSql(pSql);
 
-  return (int)pRes->numOfRows;
+  tscProcessSql(pSql);
+  return pRes->numOfRows;
 }
 
-int taos_fetch_block_impl(TAOS_RES *res, TAOS_ROW *rows) {
-  SSqlObj *pSql = (SSqlObj *)res;
-  SSqlCmd *pCmd = &pSql->cmd;
+static bool needToFetchNewBlock(SSqlObj* pSql) {
   SSqlRes *pRes = &pSql->res;
+  SSqlCmd *pCmd = &pSql->cmd;
 
-  if (pRes->qhandle == 0 || pSql->signature != pSql) {
-    *rows = NULL;
-    return 0;
-  }
-
-  // Retrieve new block
-  tscResetForNextRetrieve(pRes);
-  if (pCmd->command < TSDB_SQL_LOCAL) {
-    pCmd->command = (pCmd->command > TSDB_SQL_MGMT) ? TSDB_SQL_RETRIEVE : TSDB_SQL_FETCH;
-  }
-
-  tscProcessSql(pSql);
-  if (pRes->numOfRows == 0) {
-    *rows = NULL;
-    return 0;
-  }
-
-  // secondary merge has handle this situation
-  if (pCmd->command != TSDB_SQL_RETRIEVE_LOCALMERGE) {
-    pRes->numOfClauseTotal += pRes->numOfRows;
-  }
-
-  SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
-  if (pQueryInfo == NULL)
-    return 0;
-
-  assert(0);
-  for (int i = 0; i < pQueryInfo->fieldsInfo.numOfOutput; ++i) {
-    tscGetResultColumnChr(pRes, &pQueryInfo->fieldsInfo, i, 0);
-  }
-
-  *rows = pRes->tsrow;
-
-  return (int)((pQueryInfo->order.order == TSDB_ORDER_DESC) ? pRes->numOfRows : -pRes->numOfRows);
+  return (pRes->completed != true || hasMoreVnodesToTry(pSql) || hasMoreClauseToTry(pSql)) &&
+         (pCmd->command == TSDB_SQL_RETRIEVE ||
+          pCmd->command == TSDB_SQL_RETRIEVE_LOCALMERGE ||
+          pCmd->command == TSDB_SQL_TABLE_JOIN_RETRIEVE ||
+          pCmd->command == TSDB_SQL_FETCH ||
+          pCmd->command == TSDB_SQL_SHOW ||
+          pCmd->command == TSDB_SQL_SHOW_CREATE_TABLE ||
+          pCmd->command == TSDB_SQL_SHOW_CREATE_DATABASE ||
+          pCmd->command == TSDB_SQL_SELECT ||
+          pCmd->command == TSDB_SQL_DESCRIBE_TABLE ||
+          pCmd->command == TSDB_SQL_SERV_STATUS ||
+          pCmd->command == TSDB_SQL_CURRENT_DB ||
+          pCmd->command == TSDB_SQL_SERV_VERSION ||
+          pCmd->command == TSDB_SQL_CLI_VERSION ||
+          pCmd->command == TSDB_SQL_CURRENT_USER);
 }
 
 TAOS_ROW taos_fetch_row(TAOS_RES *res) {
@@ -509,77 +489,50 @@ TAOS_ROW taos_fetch_row(TAOS_RES *res) {
   // set the sql object owner
   tscSetSqlOwner(pSql);
 
-  // current data set are exhausted, fetch more data from node
-  if (pRes->row >= pRes->numOfRows && (pRes->completed != true || hasMoreVnodesToTry(pSql) || hasMoreClauseToTry(pSql)) &&
-      (pCmd->command == TSDB_SQL_RETRIEVE ||
-       pCmd->command == TSDB_SQL_RETRIEVE_LOCALMERGE ||
-       pCmd->command == TSDB_SQL_TABLE_JOIN_RETRIEVE ||
-       pCmd->command == TSDB_SQL_FETCH ||
-       pCmd->command == TSDB_SQL_SHOW ||
-       pCmd->command == TSDB_SQL_SHOW_CREATE_TABLE ||
-       pCmd->command == TSDB_SQL_SHOW_CREATE_DATABASE ||
-       pCmd->command == TSDB_SQL_SELECT ||
-       pCmd->command == TSDB_SQL_DESCRIBE_TABLE ||
-       pCmd->command == TSDB_SQL_SERV_STATUS ||
-       pCmd->command == TSDB_SQL_CURRENT_DB ||
-       pCmd->command == TSDB_SQL_SERV_VERSION ||
-       pCmd->command == TSDB_SQL_CLI_VERSION ||
-       pCmd->command == TSDB_SQL_CURRENT_USER )) {
+  // current data set are exhausted, fetch more result from node
+  if (pRes->row >= pRes->numOfRows && needToFetchNewBlock(pSql)) {
     taos_fetch_rows_a(res, waitForRetrieveRsp, pSql->pTscObj);
     tsem_wait(&pSql->rspSem);
   }
 
-  void* data = doSetResultRowData(pSql, true);
+  void* data = doSetResultRowData(pSql);
 
   tscClearSqlOwner(pSql);
   return data;
 }
 
 int taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows) {
-#if 0
   SSqlObj *pSql = (SSqlObj *)res;
-  SSqlCmd *pCmd = &pSql->cmd;
-  SSqlRes *pRes = &pSql->res;
-
-  int nRows = 0;
-
   if (pSql == NULL || pSql->signature != pSql) {
     terrno = TSDB_CODE_TSC_DISCONNECTED;
-    *rows = NULL;
     return 0;
   }
 
-  // projection query on metric, pipeline retrieve data from vnode list,
-  // instead of two-stage mergednodeProcessMsgFromShell free qhandle
-  nRows = taos_fetch_block_impl(res, rows);
-
-  // current subclause is completed, try the next subclause
-  while (rows == NULL && pCmd->clauseIndex < pCmd->numOfClause - 1) {
-    SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
-
-    pSql->cmd.command = pQueryInfo->command;
-    pCmd->clauseIndex++;
-
-    pRes->numOfTotal += pRes->numOfClauseTotal;
-    pRes->numOfClauseTotal = 0;
-    pRes->rspType = 0;
+  SSqlCmd *pCmd = &pSql->cmd;
+  SSqlRes *pRes = &pSql->res;
 
-    pSql->subState.numOfSub = 0;
-    tfree(pSql->pSubs);
+  if (pRes->qhandle == 0 ||
+      pRes->code == TSDB_CODE_TSC_QUERY_CANCELLED ||
+      pCmd->command == TSDB_SQL_RETRIEVE_EMPTY_RESULT ||
+      pCmd->command == TSDB_SQL_INSERT) {
+    return 0;
+  }
 
-    assert(pSql->fp == NULL);
+  tscResetForNextRetrieve(pRes);
 
-    tscDebug("%p try data in the next subclause:%d, total subclause:%d", pSql, pCmd->clauseIndex, pCmd->numOfClause);
-    tscProcessSql(pSql);
+  // set the sql object owner
+  tscSetSqlOwner(pSql);
 
-    nRows = taos_fetch_block_impl(res, rows);
+  // current data set are exhausted, fetch more data from node
+  if (needToFetchNewBlock(pSql)) {
+    taos_fetch_rows_a(res, waitForRetrieveRsp, pSql->pTscObj);
+    tsem_wait(&pSql->rspSem);
   }
 
-  return nRows;
-#endif
+  *rows = pRes->urow;
 
-  (*rows) = taos_fetch_row(res);
-  return ((*rows) != NULL)? 1:0;
+  tscClearSqlOwner(pSql);
+  return pRes->numOfRows;
 }
 
 int taos_select_db(TAOS *taos, const char *db) {
@@ -600,7 +553,7 @@ int taos_select_db(TAOS *taos, const char *db) {
 }
 
 // send free message to vnode to free qhandle and corresponding resources in vnode
-static UNUSED_FUNC bool tscKillQueryInDnode(SSqlObj* pSql) {
+static bool tscKillQueryInDnode(SSqlObj* pSql) {
   SSqlCmd* pCmd = &pSql->cmd;
   SSqlRes* pRes = &pSql->res;
 
@@ -795,6 +748,25 @@ void taos_stop_query(TAOS_RES *res) {
   tscDebug("%p query is cancelled", res);
 }
 
+bool taos_is_null(TAOS_RES *res, int32_t row, int32_t col) {
+  SSqlObj *pSql = (SSqlObj *)res;
+  if (pSql == NULL || pSql->signature != pSql) {
+    return true;
+  }
+
+  SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+  if (pQueryInfo == NULL) {
+    return true;
+  }
+
+  SInternalField* pInfo = (SInternalField*)TARRAY_GET_ELEM(pQueryInfo->fieldsInfo.internalField, col);
+  if (col < 0 || col >= tscNumOfFields(pQueryInfo) || row < 0 || row > pSql->res.numOfRows) {
+    return true;
+  }
+
+  return isNull(((char*) pSql->res.urow[col]) + row * pInfo->field.bytes, pInfo->field.type);
+}
+
 int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields) {
   int len = 0;
   for (int i = 0; i < num_fields; ++i) {
@@ -892,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);
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index 028f17800bcdb296b2fe679531c2c1b117df89c7..6ebbeeef411f8922662e7045027cf55410cbf89d 100644
--- a/src/client/src/tscSubquery.c
+++ b/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;
 }
 
@@ -948,7 +948,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
     if (!pRes->completed) {
       taosGetTmpfilePath("ts-join", pSupporter->path);
       pSupporter->f = fopen(pSupporter->path, "w");
-      pRes->row = (int32_t)pRes->numOfRows;
+      pRes->row = pRes->numOfRows;
 
       taos_fetch_rows_a(tres, tsCompRetrieveCallback, param);
       return;
@@ -974,7 +974,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
     
     // TODO check for failure
     pSupporter->f = fopen(pSupporter->path, "w");
-    pRes->row = (int32_t)pRes->numOfRows;
+    pRes->row = pRes->numOfRows;
 
     // set the callback function
     pSql->fp = tscJoinQueryCallback;
@@ -1085,7 +1085,7 @@ static void joinRetrieveFinalResCallback(void* param, TAOS_RES* tres, int numOfR
     SSqlRes* pRes1 = &pParentSql->pSubs[i]->res;
 
     if (pRes1->row > 0 && pRes1->numOfRows > 0) {
-      tscDebug("%p sub:%p index:%d numOfRows:%"PRId64" total:%"PRId64 " (not retrieve)", pParentSql, pParentSql->pSubs[i], i,
+      tscDebug("%p sub:%p index:%d numOfRows:%d total:%"PRId64 " (not retrieve)", pParentSql, pParentSql->pSubs[i], i,
                pRes1->numOfRows, pRes1->numOfTotal);
       assert(pRes1->row < pRes1->numOfRows);
     } else {
@@ -1093,7 +1093,7 @@ static void joinRetrieveFinalResCallback(void* param, TAOS_RES* tres, int numOfR
         pRes1->numOfClauseTotal += pRes1->numOfRows;
       }
 
-      tscDebug("%p sub:%p index:%d numOfRows:%"PRId64" total:%"PRId64, pParentSql, pParentSql->pSubs[i], i,
+      tscDebug("%p sub:%p index:%d numOfRows:%d total:%"PRId64, pParentSql, pParentSql->pSubs[i], i,
                pRes1->numOfRows, pRes1->numOfTotal);
     }
   }
@@ -2032,7 +2032,7 @@ static void tscRetrieveFromDnodeCallBack(void *param, TAOS_RES *tres, int numOfR
     assert(pRes->numOfRows == numOfRows);
     int64_t num = atomic_add_fetch_64(&pState->numOfRetrievedRows, numOfRows);
     
-    tscDebug("%p sub:%p retrieve numOfRows:%" PRId64 " totalNumOfRows:%" PRIu64 " from ep:%s, orderOfSub:%d", pParentSql, pSql,
+    tscDebug("%p sub:%p retrieve numOfRows:%d totalNumOfRows:%" PRIu64 " from ep:%s, orderOfSub:%d", pParentSql, pSql,
              pRes->numOfRows, pState->numOfRetrievedRows, pSql->epSet.fqdn[pSql->epSet.inUse], idx);
 
     if (num > tsMaxNumOfOrderedResults && tscIsProjectionQueryOnSTable(pQueryInfo, 0)) {
@@ -2059,7 +2059,7 @@ static void tscRetrieveFromDnodeCallBack(void *param, TAOS_RES *tres, int numOfR
     }
     
     int32_t ret = saveToBuffer(trsupport->pExtMemBuffer[idx], pDesc, trsupport->localBuffer, pRes->data,
-                               (int32_t)pRes->numOfRows, pQueryInfo->groupbyExpr.orderType);
+                               pRes->numOfRows, pQueryInfo->groupbyExpr.orderType);
     if (ret != 0) { // set no disk space error info, and abort retry
       tscAbortFurtherRetryRetrieval(trsupport, tres, TSDB_CODE_TSC_NO_DISKSPACE);
     } else if (pRes->completed) {
@@ -2171,7 +2171,7 @@ static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int numOfRows)
     return;
   }
   
-  tscDebug("%p Async insertion completed, total inserted:%" PRId64, pParentObj, pParentObj->res.numOfRows);
+  tscDebug("%p Async insertion completed, total inserted:%d", pParentObj, pParentObj->res.numOfRows);
 
   // restore user defined fp
   pParentObj->fp = pParentObj->fetchFp;
@@ -2367,6 +2367,7 @@ static void doBuildResFromSubqueries(SSqlObj* pSql) {
   doArithmeticCalculate(pQueryInfo, pFilePage, rowSize, finalRowSize);
 
   pRes->data = pFilePage->data;
+  tscSetResRawPtr(pRes, pQueryInfo);
 }
 
 void tscBuildResFromSubqueries(SSqlObj *pSql) {
@@ -2379,13 +2380,12 @@ void tscBuildResFromSubqueries(SSqlObj *pSql) {
 
   if (pRes->tsrow == NULL) {
     SQueryInfo* pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, pSql->cmd.clauseIndex);
+    pRes->numOfCols = (int16_t) tscSqlExprNumOfExprs(pQueryInfo);
 
-    size_t numOfExprs = tscSqlExprNumOfExprs(pQueryInfo);
-    pRes->numOfCols =  (int16_t)numOfExprs;
-
-    pRes->tsrow  = calloc(numOfExprs, POINTER_BYTES);
-    pRes->buffer = calloc(numOfExprs, POINTER_BYTES);
-    pRes->length = calloc(numOfExprs, sizeof(int32_t));
+    pRes->tsrow  = calloc(pRes->numOfCols, POINTER_BYTES);
+    pRes->urow   = calloc(pRes->numOfCols, POINTER_BYTES);
+    pRes->buffer = calloc(pRes->numOfCols, POINTER_BYTES);
+    pRes->length = calloc(pRes->numOfCols, sizeof(int32_t));
 
     if (pRes->tsrow == NULL || pRes->buffer == NULL || pRes->length == NULL) {
       pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -2405,7 +2405,7 @@ void tscBuildResFromSubqueries(SSqlObj *pSql) {
   }
 }
 
-static void transferNcharData(SSqlObj *pSql, int32_t columnIndex, TAOS_FIELD *pField) {
+static UNUSED_FUNC void transferNcharData(SSqlObj *pSql, int32_t columnIndex, TAOS_FIELD *pField) {
   SSqlRes *pRes = &pSql->res;
   
   if (pRes->tsrow[columnIndex] != NULL && pField->type == TSDB_DATA_TYPE_NCHAR) {
@@ -2429,7 +2429,7 @@ static void transferNcharData(SSqlObj *pSql, int32_t columnIndex, TAOS_FIELD *pF
   }
 }
 
-char *getArithemicInputSrc(void *param, const char *name, int32_t colId) {
+char *getArithmeticInputSrc(void *param, const char *name, int32_t colId) {
   SArithmeticSupport *pSupport = (SArithmeticSupport *) param;
 
   int32_t index = -1;
@@ -2447,7 +2447,7 @@ char *getArithemicInputSrc(void *param, const char *name, int32_t colId) {
   return pSupport->data[index] + pSupport->offset * pExpr->resBytes;
 }
 
-TAOS_ROW doSetResultRowData(SSqlObj *pSql, bool finalResult) {
+TAOS_ROW doSetResultRowData(SSqlObj *pSql) {
   SSqlCmd *pCmd = &pSql->cmd;
   SSqlRes *pRes = &pSql->res;
 
@@ -2460,22 +2460,20 @@ TAOS_ROW doSetResultRowData(SSqlObj *pSql, bool finalResult) {
   SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, pCmd->clauseIndex);
 
   size_t size = tscNumOfFields(pQueryInfo);
-  int32_t offset = 0;
-
   for (int i = 0; i < size; ++i) {
-    tscGetResultColumnChr(pRes, &pQueryInfo->fieldsInfo, i, offset);
-    TAOS_FIELD *pField = TARRAY_GET_ELEM(pQueryInfo->fieldsInfo.internalField, i);
+    SInternalField* pInfo = (SInternalField*)TARRAY_GET_ELEM(pQueryInfo->fieldsInfo.internalField, i);
 
-    offset += pField->bytes;
+    int32_t type  = pInfo->field.type;
+    int32_t bytes = pInfo->field.bytes;
 
-    // primary key column cannot be null in interval query, no need to check
-    if (i == 0 && pQueryInfo->interval.interval > 0) {
-      continue;
+    if (type != TSDB_DATA_TYPE_BINARY && type != TSDB_DATA_TYPE_NCHAR) {
+      pRes->tsrow[i] = isNull(pRes->urow[i], type) ? NULL : pRes->urow[i];
+    } else {
+      pRes->tsrow[i] = isNull(pRes->urow[i], type) ? NULL : varDataVal(pRes->urow[i]);
+      pRes->length[i] = varDataLen(pRes->urow[i]);
     }
 
-    if (pRes->tsrow[i] != NULL && pField->type == TSDB_DATA_TYPE_NCHAR) {
-      transferNcharData(pSql, i, pField);
-    }
+    ((char**) pRes->urow)[i] += bytes;
   }
 
   pRes->row++;  // index increase one-step
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 27824fc1ffe01615a55b78056817733ac4c400c8..7a82bcaaab63603d136ae79f28b1625c90944779 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -220,13 +220,11 @@ bool tscIsPointInterpQuery(SQueryInfo* pQueryInfo) {
 }
 
 bool tscIsSecondStageQuery(SQueryInfo* pQueryInfo) {
-  size_t numOfOutput = tscNumOfFields(pQueryInfo);
-  size_t numOfExprs = tscSqlExprNumOfExprs(pQueryInfo);
-
-  if (numOfOutput == numOfExprs) {
+  if (tscIsProjectionQuery(pQueryInfo)) {
     return false;
   }
 
+  size_t numOfOutput = tscNumOfFields(pQueryInfo);
   for(int32_t i = 0; i < numOfOutput; ++i) {
     SExprInfo* pExprInfo = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, i)->pArithExprInfo;
     if (pExprInfo != NULL) {
@@ -265,16 +263,20 @@ void tscClearInterpInfo(SQueryInfo* pQueryInfo) {
 
 int32_t tscCreateResPointerInfo(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
   if (pRes->tsrow == NULL) {
-    int32_t numOfOutput = pQueryInfo->fieldsInfo.numOfOutput;
-    pRes->numOfCols = numOfOutput;
+    pRes->numOfCols = pQueryInfo->fieldsInfo.numOfOutput;
 
-    pRes->tsrow  = calloc(numOfOutput, POINTER_BYTES);
-    pRes->length = calloc(numOfOutput, sizeof(int32_t));
-    pRes->buffer = calloc(numOfOutput, POINTER_BYTES);
+    pRes->tsrow  = calloc(pRes->numOfCols, POINTER_BYTES);
+    pRes->urow   = calloc(pRes->numOfCols, POINTER_BYTES);
+    pRes->length = calloc(pRes->numOfCols, sizeof(int32_t));
+    pRes->buffer = calloc(pRes->numOfCols, POINTER_BYTES);
 
     // not enough memory
-    if (pRes->tsrow == NULL || (pRes->buffer == NULL && pRes->numOfCols > 0)) {
+    if (pRes->tsrow == NULL  || pRes->urow == NULL || pRes->length == NULL || (pRes->buffer == NULL && pRes->numOfCols > 0)) {
       tfree(pRes->tsrow);
+      tfree(pRes->urow);
+      tfree(pRes->length);
+      tfree(pRes->buffer);
+
       pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
       return pRes->code;
     }
@@ -283,6 +285,71 @@ int32_t tscCreateResPointerInfo(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
   return TSDB_CODE_SUCCESS;
 }
 
+void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
+  assert(pRes->numOfCols > 0);
+
+  int32_t offset = 0;
+
+  for (int32_t i = 0; i < pRes->numOfCols; ++i) {
+    SInternalField* pInfo = (SInternalField*)TARRAY_GET_ELEM(pQueryInfo->fieldsInfo.internalField, i);
+
+    pRes->urow[i] = pRes->data + offset * pRes->numOfRows;
+    pRes->length[i] = pInfo->field.bytes;
+
+    offset += pInfo->field.bytes;
+
+    // generated the user-defined column result
+    if (pInfo->pSqlExpr != NULL && TSDB_COL_IS_UD_COL(pInfo->pSqlExpr->colInfo.flag)) {
+      if (pInfo->pSqlExpr->param[1].nType == TSDB_DATA_TYPE_NULL) {
+        setNullN(pRes->urow[i], pInfo->field.type, pInfo->field.bytes, (int32_t) pRes->numOfRows);
+      } else {
+        if (pInfo->field.type == TSDB_DATA_TYPE_NCHAR || pInfo->field.type == TSDB_DATA_TYPE_BINARY) {
+          assert(pInfo->pSqlExpr->param[1].nLen <= pInfo->field.bytes);
+
+          for (int32_t k = 0; k < pRes->numOfRows; ++k) {
+            char* p = ((char**)pRes->urow)[i] + k * pInfo->field.bytes;
+
+            memcpy(varDataVal(p), pInfo->pSqlExpr->param[1].pz, pInfo->pSqlExpr->param[1].nLen);
+            varDataSetLen(p, pInfo->pSqlExpr->param[1].nLen);
+          }
+        } else {
+          for (int32_t k = 0; k < pRes->numOfRows; ++k) {
+            char* p = ((char**)pRes->urow)[i] + k * pInfo->field.bytes;
+            memcpy(p, &pInfo->pSqlExpr->param[1].i64Key, pInfo->field.bytes);
+          }
+        }
+      }
+
+    } else if (pInfo->field.type == TSDB_DATA_TYPE_NCHAR) {
+      // convert unicode to native code in a temporary buffer extra one byte for terminated symbol
+      pRes->buffer[i] = realloc(pRes->buffer[i], pInfo->field.bytes * pRes->numOfRows);
+
+      // string terminated char for binary data
+      memset(pRes->buffer[i], 0, pInfo->field.bytes * pRes->numOfRows);
+
+      char* p = pRes->urow[i];
+      for (int32_t k = 0; k < pRes->numOfRows; ++k) {
+        char* dst = pRes->buffer[i] + k * pInfo->field.bytes;
+
+        if (isNull(p, TSDB_DATA_TYPE_NCHAR)) {
+          memcpy(dst, p, varDataTLen(p));
+        } else {
+          int32_t length = taosUcs4ToMbs(varDataVal(p), varDataLen(p), varDataVal(dst));
+          varDataSetLen(dst, length);
+
+          if (length == 0) {
+            tscError("charset:%s to %s. val:%s convert failed.", DEFAULT_UNICODE_ENCODEC, tsCharset, (char*)p);
+          }
+        }
+
+        p += pInfo->field.bytes;
+      }
+
+      memcpy(pRes->urow[i], pRes->buffer[i], pInfo->field.bytes * pRes->numOfRows);
+    }
+  }
+}
+
 static void tscDestroyResPointerInfo(SSqlRes* pRes) {
   if (pRes->buffer != NULL) { // free all buffers containing the multibyte string
     for (int i = 0; i < pRes->numOfCols; i++) {
@@ -297,6 +364,7 @@ static void tscDestroyResPointerInfo(SSqlRes* pRes) {
   tfree(pRes->tsrow);
   tfree(pRes->length);
   tfree(pRes->buffer);
+  tfree(pRes->urow);
 
   tfree(pRes->pGroupRec);
   tfree(pRes->pColumnIndex);
diff --git a/src/connector/grafanaplugin b/src/connector/grafanaplugin
index d598db167eb256fe67409b7bb3d0eb7fffc3ff8c..ec77d9049a719dabfd1a7c1122a209e201861944 160000
--- a/src/connector/grafanaplugin
+++ b/src/connector/grafanaplugin
@@ -1 +1 @@
-Subproject commit d598db167eb256fe67409b7bb3d0eb7fffc3ff8c
+Subproject commit ec77d9049a719dabfd1a7c1122a209e201861944
diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/ColumnMetaData.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/ColumnMetaData.java
index 5c7f80c715c12d1d3831a4cfbfe5f4a326b569eb..633fdcd5ab7c9f077abbd725c2511bcc2251db44 100644
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/ColumnMetaData.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/ColumnMetaData.java
@@ -16,10 +16,10 @@ package com.taosdata.jdbc;
 
 public class ColumnMetaData {
 
-	int colType = 0;
-	String colName = null;
-	int colSize = -1;
-	int colIndex = 0;
+	private int colType = 0;
+	private String colName = null;
+	private int colSize = -1;
+	private int colIndex = 0;
 
 	public int getColSize() {
 		return colSize;
diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBConnection.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBConnection.java
index f93412ffecb0673f946f187f13472a0b4d6a140e..94abe3965507170a4b31e17ebb431ddcb4fa11f8 100644
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBConnection.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBConnection.java
@@ -14,7 +14,6 @@
  *****************************************************************************/
 package com.taosdata.jdbc;
 
-import java.io.*;
 import java.sql.Array;
 import java.sql.Blob;
 import java.sql.CallableStatement;
@@ -35,11 +34,10 @@ import java.util.*;
 import java.util.concurrent.Executor;
 
 public class TSDBConnection implements Connection {
+    protected Properties props = null;
 
     private TSDBJNIConnector connector = null;
 
-    protected Properties props = null;
-
     private String catalog = null;
 
     private TSDBDatabaseMetaData dbMetaData = null;
@@ -47,15 +45,21 @@ public class TSDBConnection implements Connection {
     private Properties clientInfoProps = new Properties();
 
     private int timeoutMilliseconds = 0;
-
-    private String tsCharSet = "";
+    
+    private boolean batchFetch = false;
 
     public TSDBConnection(Properties info, TSDBDatabaseMetaData meta) throws SQLException {
         this.dbMetaData = meta;
         connect(info.getProperty(TSDBDriver.PROPERTY_KEY_HOST),
                 Integer.parseInt(info.getProperty(TSDBDriver.PROPERTY_KEY_PORT, "0")),
-                info.getProperty(TSDBDriver.PROPERTY_KEY_DBNAME), info.getProperty(TSDBDriver.PROPERTY_KEY_USER),
+                info.getProperty(TSDBDriver.PROPERTY_KEY_DBNAME), 
+                info.getProperty(TSDBDriver.PROPERTY_KEY_USER),
                 info.getProperty(TSDBDriver.PROPERTY_KEY_PASSWORD));
+        
+        String batchLoad = info.getProperty(TSDBDriver.PROPERTY_KEY_BATCH_LOAD);
+        if (batchLoad != null) {
+        	this.batchFetch = Boolean.parseBoolean(batchLoad);
+        }
     }
 
     private void connect(String host, int port, String dbName, String user, String password) throws SQLException {
@@ -223,6 +227,14 @@ public class TSDBConnection implements Connection {
 
         return this.prepareStatement(sql);
     }
+    
+    public Boolean getBatchFetch() {
+    	return this.batchFetch;
+    }
+    
+    public void setBatchFetch(Boolean batchFetch) {
+    	this.batchFetch = batchFetch;
+    }
 
     public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
         throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java
index 8fb607483b74f4848e98976cddcb7f5c9b2a0244..4dc48c84b30f363c382a641cb705893c4aca8118 100755
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBDriver.java
@@ -86,6 +86,11 @@ public class TSDBDriver extends AbstractTaosDriver {
      */
     public static final String PROPERTY_KEY_CHARSET = "charset";
 
+    /**
+     * fetch data from native function in a batch model
+     */
+    public static final String PROPERTY_KEY_BATCH_LOAD = "batch";
+    
     private TSDBDatabaseMetaData dbMetaData = null;
 
     static {
@@ -172,26 +177,21 @@ public class TSDBDriver extends AbstractTaosDriver {
             url = url.substring(0, index);
             StringTokenizer queryParams = new StringTokenizer(paramString, "&");
             while (queryParams.hasMoreElements()) {
-                String parameterValuePair = queryParams.nextToken();
-                int indexOfEqual = parameterValuePair.indexOf("=");
-                String parameter = null;
-                String value = null;
-                if (indexOfEqual != -1) {
-                    parameter = parameterValuePair.substring(0, indexOfEqual);
-                    if (indexOfEqual + 1 < parameterValuePair.length()) {
-                        value = parameterValuePair.substring(indexOfEqual + 1);
-                    }
-                }
-                if ((value != null && value.length() > 0) && (parameter != null && parameter.length() > 0)) {
-                    urlProps.setProperty(parameter, value);
+                String oneToken = queryParams.nextToken();
+                String[] pair = oneToken.split("=");
+                
+                if ((pair[0] != null && pair[0].trim().length() > 0) && (pair[1] != null && pair[1].trim().length() > 0)) {
+                    urlProps.setProperty(pair[0].trim(), pair[1].trim());
                 }
             }
         }
+        
         // parse Product Name
         String dbProductName = url.substring(0, beginningOfSlashes);
         dbProductName = dbProductName.substring(dbProductName.indexOf(":") + 1);
         dbProductName = dbProductName.substring(0, dbProductName.indexOf(":"));
-        // parse dbname
+        
+        // parse database name
         url = url.substring(beginningOfSlashes + 2);
         int indexOfSlash = url.indexOf("/");
         if (indexOfSlash != -1) {
@@ -200,6 +200,7 @@ public class TSDBDriver extends AbstractTaosDriver {
             }
             url = url.substring(0, indexOfSlash);
         }
+        
         // parse port
         int indexOfColon = url.indexOf(":");
         if (indexOfColon != -1) {
@@ -208,9 +209,11 @@ public class TSDBDriver extends AbstractTaosDriver {
             }
             url = url.substring(0, indexOfColon);
         }
+        
         if (url != null && url.length() > 0 && url.trim().length() > 0) {
             urlProps.setProperty(TSDBDriver.PROPERTY_KEY_HOST, url);
         }
+        
         this.dbMetaData = new TSDBDatabaseMetaData(dbProductName, urlForMeta, urlProps.getProperty(TSDBDriver.PROPERTY_KEY_USER));
         return urlProps;
     }
diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java
index edc160e323d2dc9c885b5404545a6d0689857a31..f918463439fba293171827001acf6930ab271b81 100755
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBJNIConnector.java
@@ -243,6 +243,11 @@ public class TSDBJNIConnector {
 
     private native int fetchRowImp(long connection, long resultSet, TSDBResultSetRowData rowData);
 
+    public int fetchBlock(long resultSet, TSDBResultSetBlockData blockData) {
+		return this.fetchBlockImp(this.taos, resultSet, blockData);
+    }
+    
+    private native int fetchBlockImp(long connection, long resultSet, TSDBResultSetBlockData blockData);
     /**
      * Execute close operation from C to release connection pointer by JNI
      *
diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSet.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSet.java
index 961633b8aec4ec433a56522e504fb35495ccfa78..84a3f58f4692a99737af7d93c5578fc7a5a09c27 100644
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSet.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSet.java
@@ -47,10 +47,14 @@ public class TSDBResultSet implements ResultSet {
 	private List<ColumnMetaData> columnMetaDataList = new ArrayList<ColumnMetaData>();
 
 	private TSDBResultSetRowData rowData;
+	private TSDBResultSetBlockData blockData;
 
+	private boolean batchFetch = false;
 	private boolean lastWasNull = false;
 	private final int COLUMN_INDEX_START_VALUE = 1;
 
+	private int rowIndex = 0;
+
 	public TSDBJNIConnector getJniConnector() {
 		return jniConnector;
 	}
@@ -67,6 +71,14 @@ public class TSDBResultSet implements ResultSet {
 		this.resultSetPointer = resultSetPointer;
 	}
 
+	public void setBatchFetch(boolean batchFetch) {
+		this.batchFetch = batchFetch;
+	}
+	
+	public Boolean getBatchFetch() {
+		return this.batchFetch;
+	}
+
 	public List<ColumnMetaData> getColumnMetaDataList() {
 		return columnMetaDataList;
 	}
@@ -94,8 +106,8 @@ public class TSDBResultSet implements ResultSet {
 	public TSDBResultSet() {
 	}
 
-	public TSDBResultSet(TSDBJNIConnector connecter, long resultSetPointer) throws SQLException {
-		this.jniConnector = connecter;
+	public TSDBResultSet(TSDBJNIConnector connector, long resultSetPointer) throws SQLException {
+		this.jniConnector = connector;
 		this.resultSetPointer = resultSetPointer;
 		int code = this.jniConnector.getSchemaMetaData(this.resultSetPointer, this.columnMetaDataList);
 		if (code == TSDBConstants.JNI_CONNECTION_NULL) {
@@ -107,6 +119,7 @@ public class TSDBResultSet implements ResultSet {
 		}
 
 		this.rowData = new TSDBResultSetRowData(this.columnMetaDataList.size());
+		this.blockData = new TSDBResultSetBlockData(this.columnMetaDataList, this.columnMetaDataList.size());
 	}
 
 	public <T> T unwrap(Class<T> iface) throws SQLException {
@@ -118,21 +131,42 @@ public class TSDBResultSet implements ResultSet {
 	}
 
 	public boolean next() throws SQLException {
-		if (rowData != null) {
-			this.rowData.clear();
-		}
+		if (this.getBatchFetch()) {
+			if (this.blockData.forward()) {
+				return true;
+			}
+
+			int code = this.jniConnector.fetchBlock(this.resultSetPointer, this.blockData);
+			this.blockData.reset();
+
+			if (code == TSDBConstants.JNI_CONNECTION_NULL) {
+				throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));
+			} else if (code == TSDBConstants.JNI_RESULT_SET_NULL) {
+				throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_RESULT_SET_NULL));
+			} else if (code == TSDBConstants.JNI_NUM_OF_FIELDS_0) {
+				throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_NUM_OF_FIELDS_0));
+			} else if (code == TSDBConstants.JNI_FETCH_END) {
+				return false;
+			}
 
-		int code = this.jniConnector.fetchRow(this.resultSetPointer, this.rowData);
-		if (code == TSDBConstants.JNI_CONNECTION_NULL) {
-			throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));
-		} else if (code == TSDBConstants.JNI_RESULT_SET_NULL) {
-			throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_RESULT_SET_NULL));
-		} else if (code == TSDBConstants.JNI_NUM_OF_FIELDS_0) {
-			throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_NUM_OF_FIELDS_0));
-		} else if (code == TSDBConstants.JNI_FETCH_END) {
-			return false;
-		} else {
 			return true;
+		} else {
+			if (rowData != null) {
+				this.rowData.clear();
+			}
+
+			int code = this.jniConnector.fetchRow(this.resultSetPointer, this.rowData);
+			if (code == TSDBConstants.JNI_CONNECTION_NULL) {
+				throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));
+			} else if (code == TSDBConstants.JNI_RESULT_SET_NULL) {
+				throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_RESULT_SET_NULL));
+			} else if (code == TSDBConstants.JNI_NUM_OF_FIELDS_0) {
+				throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_NUM_OF_FIELDS_0));
+			} else if (code == TSDBConstants.JNI_FETCH_END) {
+				return false;
+			} else {
+				return true;
+			}
 		}
 	}
 
@@ -155,21 +189,30 @@ public class TSDBResultSet implements ResultSet {
 		String res = null;
 		int colIndex = getTrueColumnIndex(columnIndex);
 
-		this.lastWasNull = this.rowData.wasNull(colIndex);
-		if (!lastWasNull) {
-			res = this.rowData.getString(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+		if (!this.getBatchFetch()) {
+			this.lastWasNull = this.rowData.wasNull(colIndex);
+			if (!lastWasNull) {
+				res = this.rowData.getString(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+			}
+			return res;
+		} else {
+			return this.blockData.getString(colIndex);
 		}
-		return res;
 	}
 
 	public boolean getBoolean(int columnIndex) throws SQLException {
 		boolean res = false;
 		int colIndex = getTrueColumnIndex(columnIndex);
 
-		this.lastWasNull = this.rowData.wasNull(colIndex);
-		if (!lastWasNull) {
-			res = this.rowData.getBoolean(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+		if (!this.getBatchFetch()) {
+			this.lastWasNull = this.rowData.wasNull(colIndex);
+			if (!lastWasNull) {
+				res = this.rowData.getBoolean(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+			}
+		} else {
+			return this.blockData.getBoolean(colIndex);
 		}
+
 		return res;
 	}
 
@@ -177,66 +220,91 @@ public class TSDBResultSet implements ResultSet {
 		byte res = 0;
 		int colIndex = getTrueColumnIndex(columnIndex);
 
-		this.lastWasNull = this.rowData.wasNull(colIndex);
-		if (!lastWasNull) {
-			res = (byte) this.rowData.getInt(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+		if (!this.getBatchFetch()) {
+			this.lastWasNull = this.rowData.wasNull(colIndex);
+			if (!lastWasNull) {
+				res = (byte) this.rowData.getInt(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+			}
+			return res;
+		} else {
+			return (byte) this.blockData.getInt(colIndex);
 		}
-		return res;
 	}
 
 	public short getShort(int columnIndex) throws SQLException {
 		short res = 0;
 		int colIndex = getTrueColumnIndex(columnIndex);
 
-		this.lastWasNull = this.rowData.wasNull(colIndex);
-		if (!lastWasNull) {
-			res = (short) this.rowData.getInt(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+		if (!this.getBatchFetch()) {
+			this.lastWasNull = this.rowData.wasNull(colIndex);
+			if (!lastWasNull) {
+				res = (short) this.rowData.getInt(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+			}
+			return res;
+		} else {
+			return (short) this.blockData.getInt(colIndex);
 		}
-		return res;
 	}
 
 	public int getInt(int columnIndex) throws SQLException {
 		int res = 0;
 		int colIndex = getTrueColumnIndex(columnIndex);
 
-		this.lastWasNull = this.rowData.wasNull(colIndex);
-		if (!lastWasNull) {
-			res = this.rowData.getInt(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+		if (!this.getBatchFetch()) {
+			this.lastWasNull = this.rowData.wasNull(colIndex);
+			if (!lastWasNull) {
+				res = this.rowData.getInt(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+			}
+			return res;
+		} else {
+			return this.blockData.getInt(colIndex);
 		}
-		return res;
+
 	}
 
 	public long getLong(int columnIndex) throws SQLException {
 		long res = 0l;
 		int colIndex = getTrueColumnIndex(columnIndex);
 
-		this.lastWasNull = this.rowData.wasNull(colIndex);
-		if (!lastWasNull) {
-			res = this.rowData.getLong(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+		if (!this.getBatchFetch()) {
+			this.lastWasNull = this.rowData.wasNull(colIndex);
+			if (!lastWasNull) {
+				res = this.rowData.getLong(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+			}
+			return res;
+		} else {
+			return this.blockData.getLong(colIndex);
 		}
-		return res;
 	}
 
 	public float getFloat(int columnIndex) throws SQLException {
 		float res = 0;
 		int colIndex = getTrueColumnIndex(columnIndex);
 
-		this.lastWasNull = this.rowData.wasNull(colIndex);
-		if (!lastWasNull) {
-			res = this.rowData.getFloat(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+		if (!this.getBatchFetch()) {
+			this.lastWasNull = this.rowData.wasNull(colIndex);
+			if (!lastWasNull) {
+				res = this.rowData.getFloat(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+			}
+			return res;
+		} else {
+			return (float) this.blockData.getDouble(colIndex);
 		}
-		return res;
 	}
 
 	public double getDouble(int columnIndex) throws SQLException {
 		double res = 0;
 		int colIndex = getTrueColumnIndex(columnIndex);
 
-		this.lastWasNull = this.rowData.wasNull(colIndex);
-		if (!lastWasNull) {
-			res = this.rowData.getDouble(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+		if (!this.getBatchFetch()) {
+			this.lastWasNull = this.rowData.wasNull(colIndex);
+			if (!lastWasNull) {
+				res = this.rowData.getDouble(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+			}
+			return res;
+		} else {
+			return this.blockData.getDouble(colIndex);
 		}
-		return res;
 	}
 
 	/*
@@ -249,25 +317,11 @@ public class TSDBResultSet implements ResultSet {
 	 */
 	@Deprecated
 	public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
-		BigDecimal res = null;
-		int colIndex = getTrueColumnIndex(columnIndex);
-
-		this.lastWasNull = this.rowData.wasNull(colIndex);
-		if (!lastWasNull) {
-			res = new BigDecimal(this.rowData.getLong(colIndex, this.columnMetaDataList.get(colIndex).getColType()));
-		}
-		return res;
+		return new BigDecimal(getLong(columnIndex));
 	}
 
 	public byte[] getBytes(int columnIndex) throws SQLException {
-		byte[] res = null;
-		int colIndex = getTrueColumnIndex(columnIndex);
-
-		this.lastWasNull = this.rowData.wasNull(colIndex);
-		if (!lastWasNull) {
-			res = this.rowData.getString(colIndex, this.columnMetaDataList.get(colIndex).getColType()).getBytes();
-		}
-		return res;
+		return getString(columnIndex).getBytes();
 	}
 
 	public Date getDate(int columnIndex) throws SQLException {
@@ -284,11 +338,15 @@ public class TSDBResultSet implements ResultSet {
 		Timestamp res = null;
 		int colIndex = getTrueColumnIndex(columnIndex);
 
-		this.lastWasNull = this.rowData.wasNull(colIndex);
-		if (!lastWasNull) {
-			res = this.rowData.getTimestamp(colIndex);
+		if (!this.getBatchFetch()) {
+			this.lastWasNull = this.rowData.wasNull(colIndex);
+			if (!lastWasNull) {
+				res = this.rowData.getTimestamp(colIndex);
+			}
+			return res;
+		} else {
+			return this.blockData.getTimestamp(columnIndex);
 		}
-		return res;
 	}
 
 	public InputStream getAsciiStream(int columnIndex) throws SQLException {
@@ -400,8 +458,12 @@ public class TSDBResultSet implements ResultSet {
 	public Object getObject(int columnIndex) throws SQLException {
 		int colIndex = getTrueColumnIndex(columnIndex);
 
-		this.lastWasNull = this.rowData.wasNull(colIndex);
-		return this.rowData.get(colIndex);
+		if (!this.getBatchFetch()) {
+			this.lastWasNull = this.rowData.wasNull(colIndex);
+			return this.rowData.get(colIndex);
+		} else {
+			return this.blockData.get(colIndex);
+		}
 	}
 
 	public Object getObject(String columnLabel) throws SQLException {
@@ -433,8 +495,12 @@ public class TSDBResultSet implements ResultSet {
 	public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
 		int colIndex = getTrueColumnIndex(columnIndex);
 
-		this.lastWasNull = this.rowData.wasNull(colIndex);
-		return new BigDecimal(this.rowData.getLong(colIndex, this.columnMetaDataList.get(colIndex).getColType()));
+		if (!this.getBatchFetch()) {
+			this.lastWasNull = this.rowData.wasNull(colIndex);
+			return new BigDecimal(this.rowData.getLong(colIndex, this.columnMetaDataList.get(colIndex).getColType()));
+		} else {
+			return new BigDecimal(this.blockData.getLong(colIndex));
+		}
 	}
 
 	public BigDecimal getBigDecimal(String columnLabel) throws SQLException {
diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetBlockData.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetBlockData.java
new file mode 100644
index 0000000000000000000000000000000000000000..7373890428ae0e02e4ea621595333f13824072a3
--- /dev/null
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetBlockData.java
@@ -0,0 +1,501 @@
+/***************************************************************************
+ * 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/>.
+ *****************************************************************************/
+package com.taosdata.jdbc;
+
+import java.io.UnsupportedEncodingException;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.DoubleBuffer;
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+import java.nio.LongBuffer;
+import java.nio.ShortBuffer;
+import java.sql.SQLDataException;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class TSDBResultSetBlockData {
+	private int numOfRows = 0;
+	private int numOfCols = 0;
+
+	private int rowIndex = 0;
+
+	private List<ColumnMetaData> columnMetaDataList;
+	private ArrayList<Object> colData = null;
+
+	public TSDBResultSetBlockData(List<ColumnMetaData> colMeta, int numOfCols) {
+		this.columnMetaDataList = colMeta;
+		this.setNumOfCols(numOfCols);
+	}
+
+	public TSDBResultSetBlockData() {
+		this.colData = new ArrayList<Object>();
+		this.setNumOfCols(0);
+	}
+
+	public void clear() {
+		if (this.colData != null) {
+			this.colData.clear();
+		}
+
+		if (this.numOfCols == 0) {
+			return;
+		}
+	}
+
+	public int getNumOfRows() {
+		return this.numOfRows;
+	}
+
+	public void setNumOfRows(int numOfRows) {
+		this.numOfRows = numOfRows;
+	}
+
+	public int getNumOfCols() {
+		return numOfCols;
+	}
+
+	public void setNumOfCols(int numOfCols) {
+		this.numOfCols = numOfCols;
+		this.clear();
+	}
+
+	public boolean hasMore() {
+		return this.rowIndex < this.numOfRows;
+	}
+
+	public boolean forward() {
+		if (this.rowIndex > this.numOfRows) {
+			return false;
+		}
+
+		return ((++this.rowIndex) < this.numOfRows);
+	}
+
+	public void reset() {
+		this.rowIndex = 0;
+	}
+
+	public void setBoolean(int col, boolean value) {
+		colData.set(col, value);
+	}
+
+	public void setByteArray(int col, int length, byte[] value) {
+		try {
+			switch (this.columnMetaDataList.get(col).getColType()) {
+			case TSDBConstants.TSDB_DATA_TYPE_BOOL: {
+				ByteBuffer buf = ByteBuffer.wrap(value, 0, length);
+				buf.order(ByteOrder.LITTLE_ENDIAN).asCharBuffer();
+				this.colData.set(col, buf);
+				break;
+			}
+			case TSDBConstants.TSDB_DATA_TYPE_TINYINT: {
+				ByteBuffer buf = ByteBuffer.wrap(value, 0, length);
+				buf.order(ByteOrder.LITTLE_ENDIAN);
+				this.colData.set(col, buf);
+				break;
+			}
+			case TSDBConstants.TSDB_DATA_TYPE_SMALLINT: {
+				ByteBuffer buf = ByteBuffer.wrap(value, 0, length);
+				ShortBuffer sb = buf.order(ByteOrder.LITTLE_ENDIAN).asShortBuffer();
+				this.colData.set(col, sb);
+				break;
+			}
+			case TSDBConstants.TSDB_DATA_TYPE_INT: {
+				ByteBuffer buf = ByteBuffer.wrap(value, 0, length);
+				IntBuffer ib = buf.order(ByteOrder.LITTLE_ENDIAN).asIntBuffer();
+				this.colData.set(col, ib);
+				break;
+			}
+			case TSDBConstants.TSDB_DATA_TYPE_BIGINT: {
+				ByteBuffer buf = ByteBuffer.wrap(value, 0, length);
+				LongBuffer lb = buf.order(ByteOrder.LITTLE_ENDIAN).asLongBuffer();
+				this.colData.set(col, lb);
+				break;
+			}
+			case TSDBConstants.TSDB_DATA_TYPE_FLOAT: {
+				ByteBuffer buf = ByteBuffer.wrap(value, 0, length);
+				FloatBuffer fb = buf.order(ByteOrder.LITTLE_ENDIAN).asFloatBuffer();
+				this.colData.set(col, fb);
+				break;
+			}
+			case TSDBConstants.TSDB_DATA_TYPE_DOUBLE: {
+				ByteBuffer buf = ByteBuffer.wrap(value, 0, length);
+				DoubleBuffer db = buf.order(ByteOrder.LITTLE_ENDIAN).asDoubleBuffer();
+				this.colData.set(col, db);
+				break;
+			}
+			case TSDBConstants.TSDB_DATA_TYPE_BINARY: {
+				ByteBuffer buf = ByteBuffer.wrap(value, 0, length);
+				buf.order(ByteOrder.LITTLE_ENDIAN);
+				this.colData.set(col, buf);
+				break;
+			}
+			case TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP: {
+				ByteBuffer buf = ByteBuffer.wrap(value, 0, length);
+				LongBuffer lb = buf.order(ByteOrder.LITTLE_ENDIAN).asLongBuffer();
+				this.colData.set(col, lb);
+				break;
+			}
+			case TSDBConstants.TSDB_DATA_TYPE_NCHAR: {
+				ByteBuffer buf = ByteBuffer.wrap(value, 0, length);
+				buf.order(ByteOrder.LITTLE_ENDIAN);
+				this.colData.set(col, buf);
+				break;
+			}
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	private static class NullType {
+		private static final byte NULL_BOOL_VAL = 0x2;
+		private static final String NULL_STR = "null";
+		
+		public String toString() {
+			return NullType.NULL_STR;
+		}
+
+		public static boolean isBooleanNull(byte val) {
+			return val == NullType.NULL_BOOL_VAL;
+		}
+
+		private static boolean isTinyIntNull(byte val) {
+			return val == Byte.MIN_VALUE;
+		}
+
+		private static boolean isSmallIntNull(short val) {
+			return val == Short.MIN_VALUE;
+		}
+
+		private static boolean isIntNull(int val) {
+			return val == Integer.MIN_VALUE;
+		}
+
+		private static boolean isBigIntNull(long val) {
+			return val == Long.MIN_VALUE;
+		}
+
+		private static boolean isFloatNull(float val) {
+			return Float.isNaN(val);
+		}
+
+		private static boolean isDoubleNull(double val) {
+			return Double.isNaN(val);
+		}
+
+		private static boolean isBinaryNull(byte[] val, int length) {
+			if (length != Byte.BYTES) {
+				return false;
+			}
+
+			return val[0] == 0xFF;
+		}
+
+		private static boolean isNcharNull(byte[] val, int length) {
+			if (length != Integer.BYTES) {
+				return false;
+			}
+
+			return (val[0] & val[1] & val[2] & val[3]) == 0xFF;
+		}
+
+	}
+
+	/**
+	 * The original type may not be a string type, but will be converted to by
+	 * calling this method
+	 * 
+	 * @param col column index
+	 * @return
+	 * @throws SQLException
+	 */
+	public String getString(int col) throws SQLException {
+		Object obj = get(col);
+		if (obj == null) {
+			return new NullType().toString();
+		}
+
+		return obj.toString();
+	}
+
+	public int getInt(int col) {
+		Object obj = get(col);
+		if (obj == null) {
+			return 0;
+		}
+
+		int type = this.columnMetaDataList.get(col).getColType();
+		switch (type) {
+		case TSDBConstants.TSDB_DATA_TYPE_BOOL:
+		case TSDBConstants.TSDB_DATA_TYPE_TINYINT:
+		case TSDBConstants.TSDB_DATA_TYPE_SMALLINT:
+		case TSDBConstants.TSDB_DATA_TYPE_INT: {
+			return (int) obj;
+		}
+		case TSDBConstants.TSDB_DATA_TYPE_BIGINT:
+		case TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP: {
+			return ((Long) obj).intValue();
+		}
+
+		case TSDBConstants.TSDB_DATA_TYPE_FLOAT:
+		case TSDBConstants.TSDB_DATA_TYPE_DOUBLE: {
+			return ((Double) obj).intValue();
+		}
+
+		case TSDBConstants.TSDB_DATA_TYPE_NCHAR:
+		case TSDBConstants.TSDB_DATA_TYPE_BINARY: {
+			return Integer.parseInt((String) obj);
+		}
+		}
+
+		return 0;
+	}
+
+	public boolean getBoolean(int col) throws SQLException {
+		Object obj = get(col);
+		if (obj == null) {
+			return Boolean.FALSE;
+		}
+
+		int type = this.columnMetaDataList.get(col).getColType();
+		switch (type) {
+		case TSDBConstants.TSDB_DATA_TYPE_BOOL:
+		case TSDBConstants.TSDB_DATA_TYPE_TINYINT:
+		case TSDBConstants.TSDB_DATA_TYPE_SMALLINT:
+		case TSDBConstants.TSDB_DATA_TYPE_INT: {
+			return ((int) obj == 0L) ? Boolean.FALSE : Boolean.TRUE;
+		}
+		case TSDBConstants.TSDB_DATA_TYPE_BIGINT:
+		case TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP: {
+			return (((Long) obj) == 0L) ? Boolean.FALSE : Boolean.TRUE;
+		}
+
+		case TSDBConstants.TSDB_DATA_TYPE_FLOAT:
+		case TSDBConstants.TSDB_DATA_TYPE_DOUBLE: {
+			return (((Double) obj) == 0) ? Boolean.FALSE : Boolean.TRUE;
+		}
+
+		case TSDBConstants.TSDB_DATA_TYPE_NCHAR:
+		case TSDBConstants.TSDB_DATA_TYPE_BINARY: {
+			if ("TRUE".compareToIgnoreCase((String) obj) == 0) {
+				return Boolean.TRUE;
+			} else if ("FALSE".compareToIgnoreCase((String) obj) == 0) {
+				return Boolean.TRUE;
+			} else {
+				throw new SQLDataException();
+			}
+		}
+		}
+
+		return Boolean.FALSE;
+	}
+
+	public long getLong(int col) throws SQLException {
+		Object obj = get(col);
+		if (obj == null) {
+			return 0;
+		}
+
+		int type = this.columnMetaDataList.get(col).getColType();
+		switch (type) {
+		case TSDBConstants.TSDB_DATA_TYPE_BOOL:
+		case TSDBConstants.TSDB_DATA_TYPE_TINYINT:
+		case TSDBConstants.TSDB_DATA_TYPE_SMALLINT:
+		case TSDBConstants.TSDB_DATA_TYPE_INT: {
+			return (int) obj;
+		}
+		case TSDBConstants.TSDB_DATA_TYPE_BIGINT:
+		case TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP: {
+			return (long) obj;
+		}
+
+		case TSDBConstants.TSDB_DATA_TYPE_FLOAT:
+		case TSDBConstants.TSDB_DATA_TYPE_DOUBLE: {
+			return ((Double) obj).longValue();
+		}
+
+		case TSDBConstants.TSDB_DATA_TYPE_NCHAR:
+		case TSDBConstants.TSDB_DATA_TYPE_BINARY: {
+			return Long.parseLong((String) obj);
+		}
+		}
+
+		return 0;
+	}
+
+	public Timestamp getTimestamp(int col) {
+		try {
+			return new Timestamp(getLong(col));
+		} catch (SQLException e) {
+			e.printStackTrace();
+		}
+
+		return null;
+	}
+
+	public double getDouble(int col) {
+		Object obj = get(col);
+		if (obj == null) {
+			return 0;
+		}
+
+		int type = this.columnMetaDataList.get(col).getColType();
+		switch (type) {
+		case TSDBConstants.TSDB_DATA_TYPE_BOOL:
+		case TSDBConstants.TSDB_DATA_TYPE_TINYINT:
+		case TSDBConstants.TSDB_DATA_TYPE_SMALLINT:
+		case TSDBConstants.TSDB_DATA_TYPE_INT: {
+			return (int) obj;
+		}
+		case TSDBConstants.TSDB_DATA_TYPE_BIGINT:
+		case TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP: {
+			return (long) obj;
+		}
+
+		case TSDBConstants.TSDB_DATA_TYPE_FLOAT:
+		case TSDBConstants.TSDB_DATA_TYPE_DOUBLE: {
+			return (double) obj;
+		}
+
+		case TSDBConstants.TSDB_DATA_TYPE_NCHAR:
+		case TSDBConstants.TSDB_DATA_TYPE_BINARY: {
+			return Double.parseDouble((String) obj);
+		}
+		}
+
+		return 0;
+	}
+
+	public Object get(int col) {
+		int fieldSize = this.columnMetaDataList.get(col).getColSize();
+
+		switch (this.columnMetaDataList.get(col).getColType()) {
+		case TSDBConstants.TSDB_DATA_TYPE_BOOL: {
+			ByteBuffer bb = (ByteBuffer) this.colData.get(col);
+
+			byte val = bb.get(this.rowIndex);
+			if (NullType.isBooleanNull(val)) {
+				return null;
+			}
+
+			return (val == 0x0) ? Boolean.FALSE : Boolean.TRUE;
+		}
+
+		case TSDBConstants.TSDB_DATA_TYPE_TINYINT: {
+			ByteBuffer bb = (ByteBuffer) this.colData.get(col);
+
+			byte val = bb.get(this.rowIndex);
+			if (NullType.isTinyIntNull(val)) {
+				return null;
+			}
+
+			return val;
+		}
+
+		case TSDBConstants.TSDB_DATA_TYPE_SMALLINT: {
+			ShortBuffer sb = (ShortBuffer) this.colData.get(col);
+			short val = sb.get(this.rowIndex);
+			if (NullType.isSmallIntNull(val)) {
+				return null;
+			}
+
+			return val;
+		}
+
+		case TSDBConstants.TSDB_DATA_TYPE_INT: {
+			IntBuffer ib = (IntBuffer) this.colData.get(col);
+			int val = ib.get(this.rowIndex);
+			if (NullType.isIntNull(val)) {
+				return null;
+			}
+
+			return val;
+		}
+
+		case TSDBConstants.TSDB_DATA_TYPE_TIMESTAMP:
+		case TSDBConstants.TSDB_DATA_TYPE_BIGINT: {
+			LongBuffer lb = (LongBuffer) this.colData.get(col);
+			long val = lb.get(this.rowIndex);
+			if (NullType.isBigIntNull(val)) {
+				return null;
+			}
+
+			return (long) val;
+		}
+
+		case TSDBConstants.TSDB_DATA_TYPE_FLOAT: {
+			FloatBuffer fb = (FloatBuffer) this.colData.get(col);
+			float val = fb.get(this.rowIndex);
+			if (NullType.isFloatNull(val)) {
+				return null;
+			}
+
+			return val;
+		}
+
+		case TSDBConstants.TSDB_DATA_TYPE_DOUBLE: {
+			DoubleBuffer lb = (DoubleBuffer) this.colData.get(col);
+			double val = lb.get(this.rowIndex);
+			if (NullType.isDoubleNull(val)) {
+				return null;
+			}
+
+			return val;
+		}
+
+		case TSDBConstants.TSDB_DATA_TYPE_BINARY: {
+			ByteBuffer bb = (ByteBuffer) this.colData.get(col);
+			bb.position(fieldSize * this.rowIndex);
+
+			int length = bb.getShort();
+
+			byte[] dest = new byte[length];
+			bb.get(dest, 0, length);
+			if (NullType.isBinaryNull(dest, length)) {
+				return null;
+			}
+
+			return new String(dest);
+		}
+
+		case TSDBConstants.TSDB_DATA_TYPE_NCHAR: {
+			ByteBuffer bb = (ByteBuffer) this.colData.get(col);
+			bb.position(fieldSize * this.rowIndex);
+
+			int length = bb.getShort();
+
+			byte[] dest = new byte[length];
+			bb.get(dest, 0, length);
+			if (NullType.isNcharNull(dest, length)) {
+				return null;
+			}
+
+			try {
+				String ss = TaosGlobalConfig.getCharset();
+				return new String(dest, ss);
+			} catch (UnsupportedEncodingException e) {
+				e.printStackTrace();
+			}
+		}
+		}
+
+		return 0;
+	}
+}
diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetRowData.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetRowData.java
index 8efcac90001b63af53c2943c0137f3c89bc994c5..c57f19550dd14719baecb835d76263df1e6a669b 100644
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetRowData.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBResultSetRowData.java
@@ -218,5 +218,4 @@ public class TSDBResultSetRowData {
 	public void setData(ArrayList<Object> data) {
 		this.data = (ArrayList<Object>) data.clone();
 	}
-
 }
diff --git a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBStatement.java b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBStatement.java
index 5c6b0545e91a13b793478efa1ec687e616d1a9ef..cdd88b825e2a8f6ba81c131bfd1214ffbe46f32c 100644
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBStatement.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBStatement.java
@@ -19,7 +19,7 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class TSDBStatement implements Statement {
-    private TSDBJNIConnector connecter = null;
+    private TSDBJNIConnector connector = null;
 
     /**
      * To store batched commands
@@ -45,9 +45,9 @@ public class TSDBStatement implements Statement {
         this.connection = connection;
     }
 
-    TSDBStatement(TSDBConnection connection, TSDBJNIConnector connecter) {
+    TSDBStatement(TSDBConnection connection, TSDBJNIConnector connector) {
         this.connection = connection;
-        this.connecter = connecter;
+        this.connector = connector;
         this.isClosed = false;
     }
 
@@ -65,25 +65,27 @@ public class TSDBStatement implements Statement {
         }
 
         // TODO make sure it is not a update query
-        pSql = this.connecter.executeQuery(sql);
+        pSql = this.connector.executeQuery(sql);
 
-        long resultSetPointer = this.connecter.getResultSet();
+        long resultSetPointer = this.connector.getResultSet();
 
         if (resultSetPointer == TSDBConstants.JNI_CONNECTION_NULL) {
-            this.connecter.freeResultSet(pSql);
+            this.connector.freeResultSet(pSql);
             throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));
         }
 
         // create/insert/update/delete/alter
         if (resultSetPointer == TSDBConstants.JNI_NULL_POINTER) {
-            this.connecter.freeResultSet(pSql);
+            this.connector.freeResultSet(pSql);
             return null;
         }
 
-        if (!this.connecter.isUpdateQuery(pSql)) {
-            return new TSDBResultSet(this.connecter, resultSetPointer);
+        if (!this.connector.isUpdateQuery(pSql)) {
+        	TSDBResultSet res = new TSDBResultSet(this.connector, resultSetPointer);
+            res.setBatchFetch(this.connection.getBatchFetch());
+            return res;
         } else {
-            this.connecter.freeResultSet(pSql);
+            this.connector.freeResultSet(pSql);
             return null;
         }
 
@@ -95,28 +97,28 @@ public class TSDBStatement implements Statement {
         }
 
         // TODO check if current query is update query
-        pSql = this.connecter.executeQuery(sql);
-        long resultSetPointer = this.connecter.getResultSet();
+        pSql = this.connector.executeQuery(sql);
+        long resultSetPointer = this.connector.getResultSet();
 
         if (resultSetPointer == TSDBConstants.JNI_CONNECTION_NULL) {
-            this.connecter.freeResultSet(pSql);
+            this.connector.freeResultSet(pSql);
             throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));
         }
 
-        this.affectedRows = this.connecter.getAffectedRows(pSql);
-        this.connecter.freeResultSet(pSql);
+        this.affectedRows = this.connector.getAffectedRows(pSql);
+        this.connector.freeResultSet(pSql);
 
         return this.affectedRows;
     }
 
     public String getErrorMsg(long pSql) {
-        return this.connecter.getErrMsg(pSql);
+        return this.connector.getErrMsg(pSql);
     }
 
     public void close() throws SQLException {
         if (!isClosed) {
-            if (!this.connecter.isResultsetClosed()) {
-                this.connecter.freeResultSet();
+            if (!this.connector.isResultsetClosed()) {
+                this.connector.freeResultSet();
             }
             isClosed = true;
         }
@@ -136,7 +138,7 @@ public class TSDBStatement implements Statement {
     }
 
     public void setMaxRows(int max) throws SQLException {
-        // always set maxRows to zero, meaning unlimitted rows in a resultSet
+        // always set maxRows to zero, meaning unlimited rows in a resultSet
     }
 
     public void setEscapeProcessing(boolean enable) throws SQLException {
@@ -172,15 +174,15 @@ public class TSDBStatement implements Statement {
             throw new SQLException("Invalid method call on a closed statement.");
         }
         boolean res = true;
-        pSql = this.connecter.executeQuery(sql);
-        long resultSetPointer = this.connecter.getResultSet();
+        pSql = this.connector.executeQuery(sql);
+        long resultSetPointer = this.connector.getResultSet();
 
         if (resultSetPointer == TSDBConstants.JNI_CONNECTION_NULL) {
-            this.connecter.freeResultSet(pSql);
+            this.connector.freeResultSet(pSql);
             throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));
         } else if (resultSetPointer == TSDBConstants.JNI_NULL_POINTER) {
             // no result set is retrieved
-            this.connecter.freeResultSet(pSql);
+            this.connector.freeResultSet(pSql);
             res = false;
         }
 
@@ -191,10 +193,10 @@ public class TSDBStatement implements Statement {
         if (isClosed) {
             throw new SQLException("Invalid method call on a closed statement.");
         }
-        long resultSetPointer = connecter.getResultSet();
+        long resultSetPointer = connector.getResultSet();
         TSDBResultSet resSet = null;
         if (resultSetPointer != TSDBConstants.JNI_NULL_POINTER) {
-            resSet = new TSDBResultSet(connecter, resultSetPointer);
+            resSet = new TSDBResultSet(connector, resultSetPointer);
         }
         return resSet;
     }
@@ -267,7 +269,7 @@ public class TSDBStatement implements Statement {
     }
 
     public Connection getConnection() throws SQLException {
-        if (this.connecter != null)
+        if (this.connector != null)
             return this.connection;
         throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
     }
diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/BaseTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/BaseTest.java
index b793a47c990a930579b749b1eec95abed6ad554e..ce3735c12894807efadd1f5673fc34eee43ae01b 100644
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/BaseTest.java
+++ b/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();
         }
     }
 
diff --git a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/FailOverTest.java b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/FailOverTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..83295df5274a669ca2fc7fdbba506a97a01cc55c
--- /dev/null
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/cases/FailOverTest.java
@@ -0,0 +1,36 @@
+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();
+            }
+        }
+
+    }
+
+}
diff --git a/src/connector/odbc/CMakeLists.txt b/src/connector/odbc/CMakeLists.txt
index 58e7b6acf1f8424c8b8f72578a9ece027d1a9447..0d8c07041aa741793b7a1b8db20c3a3b470cf193 100644
--- a/src/connector/odbc/CMakeLists.txt
+++ b/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 ()
diff --git a/src/connector/odbc/README.md b/src/connector/odbc/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..e026884a0766772ac315acd3d0cac6535fb77557
--- /dev/null
+++ b/src/connector/odbc/README.md
@@ -0,0 +1,88 @@
+
+# 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
+```
+
+
diff --git a/src/connector/odbc/src/CMakeLists.txt b/src/connector/odbc/src/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2699e1bc90e162c80d27d690e1f7163747616526
--- /dev/null
+++ b/src/connector/odbc/src/CMakeLists.txt
@@ -0,0 +1,54 @@
+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 ()
diff --git a/src/connector/odbc/src/install.sh b/src/connector/odbc/src/install.sh
index b8c04677c7199384f7bc0b66515eb04d0fe560fc..02f31de70ed76e150fbef5d388cbd8a3e9ba73b3 100755
--- a/src/connector/odbc/src/install.sh
+++ b/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"
diff --git a/src/connector/odbc/src/todbc.c b/src/connector/odbc/src/todbc.c
index 953999c434dd3c75670ae06f6b0d7291702d77df..9d2719630f189671d30957c1ce65bbe3efdaef29 100644
--- a/src/connector/odbc/src/todbc.c
+++ b/src/connector/odbc/src/todbc.c
@@ -16,18 +16,35 @@
 // #define _BSD_SOURCE
 #define _XOPEN_SOURCE
 #define _DEFAULT_SOURCE
+#define _GNU_SOURCE
+
+#include "todbc_log.h"
+#include "todbc_flex.h"
 
 #include "taos.h"
 
-#include "os.h"
+#include "tglobal.h"
 #include "taoserror.h"
 #include "todbc_util.h"
+#include "todbc_conv.h"
+
+#include "os.h"
 
-#include <sql.h>
+#include <odbcinst.h>
 #include <sqlext.h>
 
-#include <time.h>
+#ifndef FALSE
+#define FALSE 0
+#endif
 
+#ifndef TRUE
+#define TRUE 1
+#endif
+
+#define UTF8_ENC     "UTF-8"
+#define UTF16_ENC    "UCS-2LE"
+#define UNICODE_ENC  "UCS-4LE"
+#define GB18030_ENC  "GB18030"
 
 #define GET_REF(obj) atomic_load_64(&obj->refcount)
 #define INC_REF(obj) atomic_add_fetch_64(&obj->refcount, 1)
@@ -41,15 +58,22 @@ do {
   obj->err.err_no = eno;                                                                                  \
   const char* estr = tstrerror(eno);                                                                      \
   if (!estr) estr = "Unknown error";                                                                      \
-  int n = snprintf(NULL, 0, "%s: @[%d][TSDB:%x]" err_fmt "", estr, __LINE__, eno, ##__VA_ARGS__);         \
+  int n = snprintf(NULL, 0, "[TSDB:%x]%s: @%s[%d]" err_fmt "",                                            \
+                   eno, estr,                                                                             \
+                   basename((char*)__FILE__), __LINE__,                                                   \
+                   ##__VA_ARGS__);                                                                        \
   if (n<0) break;                                                                                         \
-  char *err_str = (char*)realloc(obj->err.err_str, n+1);                                                  \
+  char *err_str = (char*)realloc(obj->err.err_str, (size_t)n+1);                                          \
   if (!err_str) break;                                                                                    \
   obj->err.err_str = err_str;                                                                             \
-  snprintf(obj->err.err_str, n+1, "%s: @[%d][TSDB:%x]" err_fmt "", estr, __LINE__, eno, ##__VA_ARGS__);   \
+  snprintf(obj->err.err_str, (size_t)n+1, "[TSDB:%x]%s: @%s[%d]" err_fmt "",                              \
+           eno, estr,                                                                                     \
+           basename((char*)__FILE__), __LINE__,                                                           \
+           ##__VA_ARGS__);                                                                                \
   snprintf((char*)obj->err.sql_state, sizeof(obj->err.sql_state), "%s", sqlstate);                        \
 } while (0)
 
+
 #define CLR_ERROR(obj)                                                          \
 do {                                                                            \
   obj->err.err_no = TSDB_CODE_SUCCESS;                                          \
@@ -57,14 +81,13 @@ do {
   obj->err.sql_state[0] = '\0';                                                 \
 } while (0)
 
-#define FILL_ERROR(obj)                                                             \
-do {                                                                                \
-  size_t n = sizeof(obj->err.sql_state);                                            \
-  if (Sqlstate) strncpy((char*)Sqlstate, (char*)obj->err.sql_state, n);             \
-  if (NativeError) *NativeError = obj->err.err_no;                                  \
-  snprintf((char*)MessageText, BufferLength, "%s", obj->err.err_str);               \
-  if (TextLength && obj->err.err_str) *TextLength = strlen(obj->err.err_str);       \
-  if (TextLength && obj->err.err_str) *TextLength = utf8_chars(obj->err.err_str);   \
+#define FILL_ERROR(obj)                                                                          \
+do {                                                                                             \
+  size_t n = sizeof(obj->err.sql_state);                                                         \
+  if (Sqlstate) strncpy((char*)Sqlstate, (char*)obj->err.sql_state, n);                          \
+  if (NativeError) *NativeError = obj->err.err_no;                                               \
+  snprintf((char*)MessageText, (size_t)BufferLength, "%s", obj->err.err_str);                    \
+  if (TextLength && obj->err.err_str) *TextLength = (SQLSMALLINT)utf8_chars(obj->err.err_str);   \
 } while (0)
 
 #define FREE_ERROR(obj)                    \
@@ -87,7 +110,7 @@ do {
   SET_ERROR(obj, sqlstate, TSDB_CODE_QRY_INVALID_QHANDLE, err_fmt, ##__VA_ARGS__);   \
 } while (0);
 
-#define SDUP(s,n)      (s ? (s[n] ? (const char*)strndup((const char*)s,n) : (const char*)s) : strdup(""))
+#define SDUP(s,n)      (s ? (s[(size_t)n] ? (const char*)strndup((const char*)s,(size_t)n) : (const char*)s) : strdup(""))
 #define SFRE(x,s,n)               \
 do {                              \
   if (x==(const char*)s) break;   \
@@ -124,6 +147,15 @@ do {                                                          \
   r_091c = SQL_SUCCESS;                                       \
 } while (0)
 
+#define NORM_STR_LENGTH(obj, ptr, len)                                               \
+do {                                                                                 \
+  if ((len) < 0 && (len)!=SQL_NTS) {                                                 \
+    SET_ERROR((obj), "HY090", TSDB_CODE_ODBC_BAD_ARG, "");                           \
+    return SQL_ERROR;                                                                \
+  }                                                                                  \
+  if (len==SQL_NTS) len = (ptr) ? (SQLSMALLINT)strlen((const char*)(ptr)) : 0;       \
+} while (0)
+
 #define PROFILING 0
 
 #define PROFILE(statement)                            \
@@ -138,22 +170,67 @@ do {                                                  \
   gettimeofday(&tv1, NULL);                           \
   double delta = difftime(tv1.tv_sec, tv0.tv_sec);    \
   delta *= 1000000;                                   \
-  delta += (tv1.tv_usec-tv0.tv_usec);                 \
+  delta += (double)(tv1.tv_usec-tv0.tv_usec);         \
   delta /= 1000000;                                   \
   D("%s: elapsed: [%.6f]s", #statement, delta);       \
 } while (0)
 
-
-#define CHK_CONV(statement)                                                                \
-do {                                                                                       \
-  const char *sqlstate = statement;                                                        \
-  if (sqlstate) {                                                                          \
-    SET_ERROR(sql, sqlstate, TSDB_CODE_ODBC_OUT_OF_RANGE,                                  \
-              "no convertion from [%s[%d/0x%x]] to [%s[%d/0x%x]] for parameter [%d]",      \
-              sql_c_type(valueType), valueType, valueType,                                 \
-              taos_data_type(type), type, type, idx+1);                                    \
-    return SQL_ERROR;                                                                      \
-  }                                                                                        \
+#define CHK_CONV(todb, statement)                                       \
+do {                                                                    \
+  TSDB_CONV_CODE code_0c80 = (statement);                               \
+  switch (code_0c80) {                                                  \
+    case TSDB_CONV_OK: return SQL_SUCCESS;                              \
+    case TSDB_CONV_OOM:                                                 \
+    case TSDB_CONV_NOT_AVAIL: {                                         \
+      SET_ERROR(sql, "HY001", TSDB_CODE_ODBC_OOM, "");                  \
+      return SQL_ERROR;                                                 \
+    } break;                                                            \
+    case TSDB_CONV_OOR: {                                               \
+      SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_OOR, "");             \
+      return SQL_ERROR;                                                 \
+    } break;                                                            \
+    case TSDB_CONV_CHAR_NOT_NUM:                                        \
+    case TSDB_CONV_CHAR_NOT_TS: {                                       \
+      SET_ERROR(sql, "22018", TSDB_CODE_ODBC_CONV_CHAR_NOT_NUM, "");    \
+      return SQL_ERROR;                                                 \
+    } break;                                                            \
+    case TSDB_CONV_NOT_VALID_TS: {                                      \
+      SET_ERROR(sql, "22007", TSDB_CODE_ODBC_CONV_NOT_VALID_TS, "");    \
+      return SQL_ERROR;                                                 \
+    } break;                                                            \
+    case TSDB_CONV_TRUNC_FRACTION: {                                    \
+      SET_ERROR(sql, "01S07", TSDB_CODE_ODBC_CONV_TRUNC_FRAC, "");      \
+      return todb ? SQL_ERROR : SQL_SUCCESS_WITH_INFO;                  \
+    } break;                                                            \
+    case TSDB_CONV_TRUNC: {                                             \
+      SET_ERROR(sql, "22001", TSDB_CODE_ODBC_CONV_TRUNC, "");           \
+      return SQL_ERROR;                                                 \
+    } break;                                                            \
+    case TSDB_CONV_SRC_TOO_LARGE: {                                     \
+      SET_ERROR(sql, "22001", TSDB_CODE_ODBC_CONV_SRC_TOO_LARGE, "");   \
+      return SQL_ERROR;                                                 \
+    } break;                                                            \
+    case TSDB_CONV_SRC_BAD_SEQ: {                                       \
+      SET_ERROR(sql, "22001", TSDB_CODE_ODBC_CONV_SRC_BAD_SEQ, "");     \
+      return SQL_ERROR;                                                 \
+    } break;                                                            \
+    case TSDB_CONV_SRC_INCOMPLETE: {                                    \
+      SET_ERROR(sql, "22001", TSDB_CODE_ODBC_CONV_SRC_INCOMPLETE, "");  \
+      return SQL_ERROR;                                                 \
+    } break;                                                            \
+    case TSDB_CONV_SRC_GENERAL: {                                       \
+      SET_ERROR(sql, "22001", TSDB_CODE_ODBC_CONV_SRC_GENERAL, "");     \
+      return SQL_ERROR;                                                 \
+    } break;                                                            \
+    case TSDB_CONV_BAD_CHAR: {                                          \
+      SET_ERROR(sql, "22001", TSDB_CODE_ODBC_CONV_TRUNC, "");           \
+      return SQL_ERROR;                                                 \
+    } break;                                                            \
+    default: {                                                          \
+      DASSERTX(0, "internal logic error: %d", code_0c80);                              \
+      return SQL_ERROR; /* never reached here */                        \
+    } break;                                                            \
+  }                                                                     \
 } while (0)
 
 typedef struct env_s             env_t;
@@ -185,6 +262,9 @@ struct env_s {
   uint64_t                refcount;
   unsigned int            destroying:1;
 
+  char                    env_locale[64];
+  char                    env_charset[64];
+
   taos_error_t            err;
 };
 
@@ -192,6 +272,16 @@ struct conn_s {
   uint64_t                refcount;
   env_t                  *env;
 
+  char                    client_enc[64];  // ODBC client that communicates with this driver
+  char                    server_enc[64];  // taos dynamic library that's loaded by this driver
+
+  tsdb_conv_t            *client_to_server;
+  tsdb_conv_t            *server_to_client;
+  tsdb_conv_t            *utf8_to_client;
+  tsdb_conv_t            *utf16_to_utf8;
+  tsdb_conv_t            *utf16_to_server;
+  tsdb_conv_t            *client_to_utf8;
+
   TAOS                   *taos;
 
   taos_error_t            err;
@@ -229,50 +319,98 @@ struct c_target_s {
 static pthread_once_t          init_once         = PTHREAD_ONCE_INIT;
 static void init_routine(void);
 
-// conversions
-
-const char* tsdb_int64_to_bit(int64_t src, int8_t *dst);
-const char* tsdb_int64_to_tinyint(int64_t src, int8_t *dst);
-const char* tsdb_int64_to_smallint(int64_t src, int16_t *dst);
-const char* tsdb_int64_to_int(int64_t src, int32_t *dst);
-const char* tsdb_int64_to_bigint(int64_t src, int64_t *dst);
-const char* tsdb_int64_to_ts(int64_t src, int64_t *dst);
-const char* tsdb_int64_to_float(int64_t src, float *dst);
-const char* tsdb_int64_to_double(int64_t src, double *dst);
-const char* tsdb_int64_to_char(int64_t src, char *dst, size_t dlen);
-
-const char* tsdb_double_to_bit(double src, int precision, int8_t *dst);
-const char* tsdb_double_to_tinyint(double src, int precision, int8_t *dst);
-const char* tsdb_double_to_smallint(double src, int precision, int16_t *dst);
-const char* tsdb_double_to_int(double src, int precision, int32_t *dst);
-const char* tsdb_double_to_bigint(double src, int precision, int64_t *dst);
-const char* tsdb_double_to_ts(double src, int precision, int64_t *dst);
-const char* tsdb_double_to_float(double src, int precision, float *dst);
-const char* tsdb_double_to_double(double src, int precision, double *dst);
-const char* tsdb_double_to_char(double src, int precision, char *dst, size_t dlen);
-
-const char* tsdb_chars_to_bit(const char *src, int8_t *dst);
-const char* tsdb_chars_to_tinyint(const char *src, int8_t *dst);
-const char* tsdb_chars_to_smallint(const char *src, int16_t *dst);
-const char* tsdb_chars_to_int(const char *src, int32_t *dst);
-const char* tsdb_chars_to_bigint(const char *src, int64_t *dst);
-const char* tsdb_chars_to_ts(const char *src, int64_t *dst);
-const char* tsdb_chars_to_float(const char *src, float *dst);
-const char* tsdb_chars_to_double(const char *src, double *dst);
-const char* tsdb_chars_to_char(const char *src, char *dst, size_t dlen);
-
-
-static int do_field_display_size(TAOS_FIELD *field);
+static size_t do_field_display_size(TAOS_FIELD *field);
+
+static tsdb_conv_t* tsdb_conn_client_to_server(conn_t *conn) {
+  if (!conn->client_to_server) {
+    conn->client_to_server = tsdb_conv_open(conn->client_enc, conn->server_enc);
+  }
+  return conn->client_to_server;
+}
+
+static tsdb_conv_t* tsdb_conn_server_to_client(conn_t *conn) {
+  if (!conn->server_to_client) {
+    conn->server_to_client = tsdb_conv_open(conn->server_enc, conn->client_enc);
+  }
+  return conn->server_to_client;
+}
+
+static tsdb_conv_t* tsdb_conn_utf8_to_client(conn_t *conn) {
+  if (!conn->utf8_to_client) {
+    conn->utf8_to_client = tsdb_conv_open(UTF8_ENC, conn->client_enc);
+  }
+  return conn->utf8_to_client;
+}
+
+static tsdb_conv_t* tsdb_conn_utf16_to_utf8(conn_t *conn) {
+  if (!conn->utf16_to_utf8) {
+    conn->utf16_to_utf8 = tsdb_conv_open(UTF16_ENC, UTF8_ENC);
+  }
+  return conn->utf16_to_utf8;
+}
+
+static tsdb_conv_t* tsdb_conn_utf16_to_server(conn_t *conn) {
+  if (!conn->utf16_to_server) {
+    conn->utf16_to_server = tsdb_conv_open(UTF16_ENC, conn->server_enc);
+  }
+  return conn->utf16_to_server;
+}
+
+static tsdb_conv_t* tsdb_conn_client_to_utf8(conn_t *conn) {
+  if (!conn->client_to_utf8) {
+    conn->client_to_utf8 = tsdb_conv_open(conn->client_enc, UTF8_ENC);
+  }
+  return conn->client_to_utf8;
+}
+
+static void tsdb_conn_close_convs(conn_t *conn) {
+  if (conn->client_to_server) {
+    tsdb_conv_close(conn->client_to_server);
+    conn->client_to_server = NULL;
+  }
+  if (conn->server_to_client) {
+    tsdb_conv_close(conn->server_to_client);
+    conn->server_to_client = NULL;
+  }
+  if (conn->utf8_to_client) {
+    tsdb_conv_close(conn->utf8_to_client);
+    conn->utf8_to_client = NULL;
+  }
+  if (conn->utf16_to_utf8) {
+    tsdb_conv_close(conn->utf16_to_utf8);
+    conn->utf16_to_utf8 = NULL;
+  }
+  if (conn->utf16_to_server) {
+    tsdb_conv_close(conn->utf16_to_server);
+    conn->utf16_to_server = NULL;
+  }
+  if (conn->client_to_utf8) {
+    tsdb_conv_close(conn->client_to_utf8);
+    conn->client_to_utf8 = NULL;
+  }
+}
+
+#define SFREE(buffer, v, src)                                                           \
+do {                                                                                    \
+  const char *v_096a = (const char*)(v);                                                \
+  const char *src_6a = (const char*)(src);                                              \
+  if (v_096a && v_096a!=src_6a && !is_owned_by_stack_buffer((buffer), v_096a)) {        \
+    free((char*)v_096a);                                                                \
+  }                                                                                     \
+} while (0)
 
 static SQLRETURN doSQLAllocEnv(SQLHENV *EnvironmentHandle)
 {
   pthread_once(&init_once, init_routine);
 
   env_t *env = (env_t*)calloc(1, sizeof(*env));
-  if (!env) return SQL_ERROR;
+  if (!env) return SQL_INVALID_HANDLE;
 
   DASSERT(INC_REF(env)>0);
 
+  snprintf(env->env_locale,  sizeof(env->env_locale),  "%s", tsLocale);
+  snprintf(env->env_charset, sizeof(env->env_charset), "%s", tsCharset);
+
   *EnvironmentHandle = env;
 
   CLR_ERROR(env);
@@ -289,7 +427,7 @@ SQLRETURN SQL_API SQLAllocEnv(SQLHENV *EnvironmentHandle)
 static SQLRETURN doSQLFreeEnv(SQLHENV EnvironmentHandle)
 {
   env_t *env = (env_t*)EnvironmentHandle;
-  if (!env) return SQL_ERROR;
+  if (!env) return SQL_INVALID_HANDLE;
 
   DASSERT(GET_REF(env)==1);
 
@@ -317,7 +455,12 @@ static SQLRETURN doSQLAllocConnect(SQLHENV EnvironmentHandle,
                                    SQLHDBC *ConnectionHandle)
 {
   env_t *env = (env_t*)EnvironmentHandle;
-  if (!env) return SQL_ERROR;
+  if (!env) return SQL_INVALID_HANDLE;
+
+  if (!ConnectionHandle) {
+    SET_ERROR(env, "HY009", TSDB_CODE_ODBC_BAD_ARG, "ConnectionHandle [%p] not valid", ConnectionHandle);
+    return SQL_ERROR;
+  }
 
   DASSERT(INC_REF(env)>1);
 
@@ -330,6 +473,10 @@ static SQLRETURN doSQLAllocConnect(SQLHENV EnvironmentHandle,
     }
 
     conn->env = env;
+
+    snprintf(conn->client_enc, sizeof(conn->client_enc), "%s", conn->env->env_charset);
+    snprintf(conn->server_enc, sizeof(conn->server_enc), "%s", conn->env->env_charset);
+
     *ConnectionHandle = conn;
 
     DASSERT(INC_REF(conn)>0);
@@ -353,7 +500,7 @@ SQLRETURN SQL_API SQLAllocConnect(SQLHENV EnvironmentHandle,
 static SQLRETURN doSQLFreeConnect(SQLHDBC ConnectionHandle)
 {
   conn_t *conn = (conn_t*)ConnectionHandle;
-  if (!conn) return SQL_ERROR;
+  if (!conn) return SQL_INVALID_HANDLE;
 
   DASSERT(GET_REF(conn)==1);
 
@@ -370,6 +517,7 @@ static SQLRETURN doSQLFreeConnect(SQLHDBC ConnectionHandle)
 
     conn->env = NULL;
     FREE_ERROR(conn);
+    tsdb_conn_close_convs(conn);
     free(conn);
   } while (0);
 
@@ -388,6 +536,8 @@ static SQLRETURN doSQLConnect(SQLHDBC ConnectionHandle,
                               SQLCHAR *UserName, SQLSMALLINT NameLength2,
                               SQLCHAR *Authentication, SQLSMALLINT NameLength3)
 {
+  stack_buffer_t buffer; buffer.next = 0;
+
   conn_t *conn = (conn_t*)ConnectionHandle;
   if (!conn) return SQL_ERROR;
 
@@ -396,28 +546,58 @@ static SQLRETURN doSQLConnect(SQLHDBC ConnectionHandle,
     return SQL_ERROR;
   }
 
-  const char *serverName = SDUP(ServerName,     NameLength1);
-  const char *userName   = SDUP(UserName,       NameLength2);
-  const char *auth       = SDUP(Authentication, NameLength3);
+  NORM_STR_LENGTH(conn, ServerName,     NameLength1);
+  NORM_STR_LENGTH(conn, UserName,       NameLength2);
+  NORM_STR_LENGTH(conn, Authentication, NameLength3);
+
+  if (NameLength1>SQL_MAX_DSN_LENGTH) {
+    SET_ERROR(conn, "HY090", TSDB_CODE_ODBC_BAD_ARG, "");
+    return SQL_ERROR;
+  }
+
+  tsdb_conv_t *client_to_server = tsdb_conn_client_to_server(conn);
+  const char *dsn = NULL;
+  const char *uid = NULL;
+  const char *pwd = NULL;
+  const char *svr = NULL;
+  char server[4096]; server[0] = '\0';
 
   do {
-    if ((ServerName && !serverName) || (UserName && !userName) || (Authentication && !auth)) {
+    tsdb_conv(client_to_server, &buffer, (const char*)ServerName,     (size_t)NameLength1, &dsn, NULL);
+    tsdb_conv(client_to_server, &buffer, (const char*)UserName,       (size_t)NameLength2, &uid, NULL);
+    tsdb_conv(client_to_server, &buffer, (const char*)Authentication, (size_t)NameLength3, &pwd, NULL);
+    int n = SQLGetPrivateProfileString(dsn, "Server", "", server, sizeof(server)-1, "Odbc.ini");
+    if (n<=0) {
+      snprintf(server, sizeof(server), "localhost:6030"); // all 7-bit ascii
+    }
+    tsdb_conv(client_to_server, &buffer, (const char*)server, (size_t)strlen(server), &svr, NULL);
+
+    if ((!dsn) || (!uid) || (!pwd) || (!svr)) {
       SET_ERROR(conn, "HY001", TSDB_CODE_ODBC_OOM, "");
       break;
     }
 
+    char *ip         = NULL;
+    int   port       = 0;
+    char *p = strchr(svr, ':');
+    if (p) {
+      ip = strndup(svr, (size_t)(p-svr));
+      port = atoi(p+1);
+    }
+
     // TODO: data-race
     // TODO: shall receive ip/port from odbc.ini
-    conn->taos = taos_connect("localhost", userName, auth, NULL, 0);
+    conn->taos = taos_connect(ip, uid, pwd, NULL, (uint16_t)port);
     if (!conn->taos) {
-      SET_ERROR(conn, "08001", terrno, "failed to connect to data source");
+      SET_ERROR(conn, "08001", terrno, "failed to connect to data source for DSN[%s] @[%s:%d]", dsn, ip, port);
       break;
     }
   } while (0);
 
-  SFRE(serverName, ServerName,     NameLength1);
-  SFRE(userName,   UserName,       NameLength2);
-  SFRE(auth,       Authentication, NameLength3);
+  tsdb_conv_free(client_to_server, dsn, &buffer, (const char*)ServerName);
+  tsdb_conv_free(client_to_server, uid, &buffer, (const char*)UserName);
+  tsdb_conv_free(client_to_server, pwd, &buffer, (const char*)Authentication);
+  tsdb_conv_free(client_to_server, svr, &buffer, (const char*)server);
 
   return conn->taos ? SQL_SUCCESS : SQL_ERROR;
 }
@@ -437,7 +617,7 @@ SQLRETURN SQL_API SQLConnect(SQLHDBC ConnectionHandle,
 static SQLRETURN doSQLDisconnect(SQLHDBC ConnectionHandle)
 {
   conn_t *conn = (conn_t*)ConnectionHandle;
-  if (!conn) return SQL_ERROR;
+  if (!conn) return SQL_INVALID_HANDLE;
 
   if (conn->taos) {
     taos_close(conn->taos);
@@ -455,10 +635,15 @@ SQLRETURN SQL_API SQLDisconnect(SQLHDBC ConnectionHandle)
 }
 
 static SQLRETURN doSQLAllocStmt(SQLHDBC ConnectionHandle,
-                              SQLHSTMT *StatementHandle)
+                                SQLHSTMT *StatementHandle)
 {
   conn_t *conn = (conn_t*)ConnectionHandle;
-  if (!conn) return SQL_ERROR;
+  if (!conn) return SQL_INVALID_HANDLE;
+
+  if (!StatementHandle) {
+    SET_ERROR(conn, "HY009", TSDB_CODE_ODBC_BAD_ARG, "StatementHandle [%p] not valid", StatementHandle);
+    return SQL_ERROR;
+  }
 
   DASSERT(INC_REF(conn)>1);
 
@@ -495,20 +680,17 @@ static SQLRETURN doSQLAllocHandle(SQLSMALLINT HandleType, SQLHANDLE InputHandle,
   switch (HandleType) {
     case SQL_HANDLE_ENV: {
       SQLHENV env = {0};
+      if (!OutputHandle) return SQL_ERROR;
       SQLRETURN r = doSQLAllocEnv(&env);
-      if (r==SQL_SUCCESS && OutputHandle) *OutputHandle = env;
+      if (r==SQL_SUCCESS) *OutputHandle = env;
       return r;
     } break;
     case SQL_HANDLE_DBC: {
-      SQLHDBC dbc = {0};
-      SQLRETURN r = doSQLAllocConnect(InputHandle, &dbc);
-      if (r==SQL_SUCCESS && OutputHandle) *OutputHandle = dbc;
+      SQLRETURN r = doSQLAllocConnect(InputHandle, OutputHandle);
       return r;
     } break;
     case SQL_HANDLE_STMT: {
-      SQLHSTMT stmt = {0};
-      SQLRETURN r = doSQLAllocStmt(InputHandle, &stmt);
-      if (r==SQL_SUCCESS && OutputHandle) *OutputHandle = stmt;
+      SQLRETURN r = doSQLAllocStmt(InputHandle, OutputHandle);
       return r;
     } break;
     default: {
@@ -528,12 +710,20 @@ static SQLRETURN doSQLFreeStmt(SQLHSTMT StatementHandle,
                               SQLUSMALLINT Option)
 {
   sql_t *sql = (sql_t*)StatementHandle;
-  if (!sql) return SQL_ERROR;
-
-  if (Option == SQL_CLOSE) return SQL_SUCCESS;
-  if (Option != SQL_DROP) {
-    SET_ERROR(sql, "HY000", TSDB_CODE_ODBC_NOT_SUPPORT, "free statement with Option[%x] not supported yet", Option);
-    return SQL_ERROR;
+  if (!sql) return SQL_INVALID_HANDLE;
+
+  switch (Option) {
+    case SQL_CLOSE: return SQL_SUCCESS;
+    case SQL_DROP:  break;
+    case SQL_UNBIND:
+    case SQL_RESET_PARAMS: {
+      SET_ERROR(sql, "HY000", TSDB_CODE_ODBC_NOT_SUPPORT, "free statement with Option[%x] not supported yet", Option);
+      return SQL_ERROR;
+    } break;
+    default: {
+      SET_ERROR(sql, "HY092", TSDB_CODE_ODBC_OUT_OF_RANGE, "free statement with Option[%x] not supported yet", Option);
+      return SQL_ERROR;
+    } break;
   }
 
   DASSERT(GET_REF(sql)==1);
@@ -560,6 +750,7 @@ static SQLRETURN doSQLFreeStmt(SQLHSTMT StatementHandle,
   sql->conn = NULL;
 
   FREE_ERROR(sql);
+
   free(sql);
 
   return SQL_SUCCESS;
@@ -573,15 +764,32 @@ SQLRETURN SQL_API SQLFreeStmt(SQLHSTMT StatementHandle,
   return r;
 }
 
+static SQLRETURN do_exec_direct(sql_t *sql, TSDB_CONV_CODE code, const char *statement) {
+  if (code) CHK_CONV(1, code);
+  DASSERT(code==TSDB_CONV_OK);
+
+  SQLRETURN r = SQL_ERROR;
+  do {
+    sql->rs = taos_query(sql->conn->taos, statement);
+    CHK_RS(r, sql, "failed to execute");
+  } while (0);
+
+  return r;
+}
+
 static SQLRETURN doSQLExecDirect(SQLHSTMT StatementHandle,
                                  SQLCHAR *StatementText, SQLINTEGER TextLength)
 {
   sql_t *sql = (sql_t*)StatementHandle;
-  if (!sql) return SQL_ERROR;
+  if (!sql) return SQL_INVALID_HANDLE;
 
   CHK_CONN(sql);
   CHK_CONN_TAOS(sql);
 
+  conn_t *conn = sql->conn;
+
+  NORM_STR_LENGTH(sql, StatementText, TextLength);
+
   if (sql->rs) {
     taos_free_result(sql->rs);
     sql->rs = NULL;
@@ -599,19 +807,15 @@ static SQLRETURN doSQLExecDirect(SQLHSTMT StatementHandle,
   }
   sql->n_params = 0;
 
-  const char *stxt = SDUP(StatementText, TextLength);
-
-  SQLRETURN r = SQL_ERROR;
+  SQLRETURN r = SQL_SUCCESS;
+  stack_buffer_t buffer; buffer.next = 0;
+  tsdb_conv_t *client_to_server = tsdb_conn_client_to_server(conn);
+  const char *stxt = NULL;
   do {
-    if (!stxt) {
-      SET_ERROR(sql, "HY001", TSDB_CODE_ODBC_OOM, "");
-      break;
-    }
-    sql->rs = taos_query(sql->conn->taos, stxt);
-    CHK_RS(r, sql, "failed to execute");
+    TSDB_CONV_CODE code = tsdb_conv(client_to_server, &buffer, (const char*)StatementText, (size_t)TextLength, &stxt, NULL);
+    r = do_exec_direct(sql, code, stxt);
   } while (0);
-
-  SFRE(stxt, StatementText, TextLength);
+  tsdb_conv_free(client_to_server, stxt, &buffer, (const char*)StatementText);
 
   return r;
 }
@@ -624,18 +828,50 @@ SQLRETURN SQL_API SQLExecDirect(SQLHSTMT StatementHandle,
   return r;
 }
 
+static SQLRETURN doSQLExecDirectW(SQLHSTMT hstmt, SQLWCHAR *szSqlStr, SQLINTEGER cbSqlStr)
+{
+  sql_t *sql = (sql_t*)hstmt;
+  if (!sql) return SQL_INVALID_HANDLE;
+
+  CHK_CONN(sql);
+  CHK_CONN_TAOS(sql);
+
+  conn_t *conn = sql->conn;
+
+  if (!szSqlStr) {
+    SET_ERROR(sql, "HY009", TSDB_CODE_ODBC_BAD_ARG, "szSqlStr [%p] not allowed", szSqlStr);
+    return SQL_ERROR;
+  }
+  if (cbSqlStr < 0) {
+    SET_ERROR(sql, "HY090", TSDB_CODE_ODBC_BAD_ARG, "");
+    return SQL_ERROR;
+  }
+
+  SQLRETURN r = SQL_SUCCESS;
+  stack_buffer_t buffer; buffer.next = 0;
+  tsdb_conv_t *utf16_to_server = tsdb_conn_utf16_to_server(conn);
+  const char *stxt = NULL;
+  do {
+    size_t slen = (size_t)cbSqlStr * sizeof(*szSqlStr);
+    TSDB_CONV_CODE code = tsdb_conv(utf16_to_server, &buffer, (const char*)szSqlStr, slen, &stxt, NULL);
+    r = do_exec_direct(sql, code, stxt);
+  } while (0);
+  tsdb_conv_free(utf16_to_server, stxt, &buffer, (const char*)szSqlStr);
+
+  return r;
+}
+
 SQLRETURN SQL_API SQLExecDirectW(SQLHSTMT hstmt, SQLWCHAR *szSqlStr, SQLINTEGER cbSqlStr)
 {
-  size_t bytes = 0;
-  SQLCHAR *utf8 = wchars_to_chars(szSqlStr, cbSqlStr, &bytes);
-  return SQLExecDirect(hstmt, utf8, bytes);
+  SQLRETURN r = doSQLExecDirectW(hstmt, szSqlStr, cbSqlStr);
+  return r;
 }
 
 static SQLRETURN doSQLNumResultCols(SQLHSTMT StatementHandle,
                                     SQLSMALLINT *ColumnCount)
 {
   sql_t *sql = (sql_t*)StatementHandle;
-  if (!sql) return SQL_ERROR;
+  if (!sql) return SQL_INVALID_HANDLE;
 
   CHK_CONN(sql);
   CHK_CONN_TAOS(sql);
@@ -654,7 +890,7 @@ static SQLRETURN doSQLNumResultCols(SQLHSTMT StatementHandle,
 
   int fields = taos_field_count(sql->rs);
   if (ColumnCount) {
-    *ColumnCount = fields;
+    *ColumnCount = (SQLSMALLINT)fields;
   }
 
   return SQL_SUCCESS;
@@ -677,7 +913,22 @@ static SQLRETURN doSQLRowCount(SQLHSTMT StatementHandle,
   CHK_CONN(sql);
   CHK_CONN_TAOS(sql);
 
-  if (sql->is_insert) {
+  // ref: https://docs.microsoft.com/en-us/sql/odbc/reference/syntax/sqlrowcount-function?view=sql-server-ver15
+  // Summary
+  // SQLRowCount returns the number of rows affected by an UPDATE, INSERT, or DELETE statement;
+  // an SQL_ADD, SQL_UPDATE_BY_BOOKMARK, or SQL_DELETE_BY_BOOKMARK operation in SQLBulkOperations;
+  // or an SQL_UPDATE or SQL_DELETE operation in SQLSetPos.
+
+  // how to fetch affected rows from taos?
+  // taos_affected_rows?
+
+  if (1) {
+    SET_ERROR(sql, "IM001", TSDB_CODE_ODBC_NOT_SUPPORT, "");
+    // if (RowCount) *RowCount = 0;
+    return SQL_SUCCESS_WITH_INFO;
+  }
+
+  if (!sql->is_insert) {
     if (RowCount) *RowCount = 0;
     return SQL_SUCCESS;
   }
@@ -735,11 +986,12 @@ static SQLRETURN doSQLColAttribute(SQLHSTMT StatementHandle,
 
   switch (FieldIdentifier) {
     case SQL_COLUMN_DISPLAY_SIZE: {
-      *NumericAttribute = do_field_display_size(field);
+      *NumericAttribute = (SQLLEN)do_field_display_size(field);
     } break;
     case SQL_COLUMN_LABEL: {
+      // todo: check BufferLength
       size_t n = sizeof(field->name);
-      strncpy(CharacterAttribute, field->name, (n>BufferLength ? BufferLength : n));
+      strncpy(CharacterAttribute, field->name, (n>BufferLength ? (size_t)BufferLength : n));
     } break;
     case SQL_COLUMN_UNSIGNED: {
       *NumericAttribute = SQL_FALSE;
@@ -766,75 +1018,19 @@ SQLRETURN SQL_API SQLColAttribute(SQLHSTMT StatementHandle,
   return r;
 }
 
-static SQLRETURN conv_tsdb_bool_to_c_bit(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b);
-static SQLRETURN conv_tsdb_bool_to_c_tinyint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b);
-static SQLRETURN conv_tsdb_bool_to_c_short(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b);
-static SQLRETURN conv_tsdb_bool_to_c_long(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b);
-static SQLRETURN conv_tsdb_bool_to_c_sbigint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b);
-static SQLRETURN conv_tsdb_bool_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b);
-static SQLRETURN conv_tsdb_bool_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b);
-static SQLRETURN conv_tsdb_bool_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b);
-static SQLRETURN conv_tsdb_bool_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b);
-static SQLRETURN conv_tsdb_v1_to_c_tinyint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1);
-static SQLRETURN conv_tsdb_v1_to_c_short(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1);
-static SQLRETURN conv_tsdb_v1_to_c_long(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1);
-static SQLRETURN conv_tsdb_v1_to_c_sbigint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1);
-static SQLRETURN conv_tsdb_v1_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1);
-static SQLRETURN conv_tsdb_v1_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1);
-static SQLRETURN conv_tsdb_v1_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1);
-static SQLRETURN conv_tsdb_v1_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1);
-static SQLRETURN conv_tsdb_v2_to_c_short(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2);
-static SQLRETURN conv_tsdb_v2_to_c_long(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2);
-static SQLRETURN conv_tsdb_v2_to_c_sbigint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2);
-static SQLRETURN conv_tsdb_v2_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2);
-static SQLRETURN conv_tsdb_v2_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2);
-static SQLRETURN conv_tsdb_v2_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2);
-static SQLRETURN conv_tsdb_v2_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2);
-static SQLRETURN conv_tsdb_v4_to_c_long(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4);
-static SQLRETURN conv_tsdb_v4_to_c_sbigint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4);
-static SQLRETURN conv_tsdb_v4_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4);
-static SQLRETURN conv_tsdb_v4_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4);
-static SQLRETURN conv_tsdb_v4_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4);
-static SQLRETURN conv_tsdb_v4_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4);
-static SQLRETURN conv_tsdb_v8_to_c_sbigint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int64_t v8);
-static SQLRETURN conv_tsdb_v8_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int64_t v8);
-static SQLRETURN conv_tsdb_v8_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int64_t v8);
-static SQLRETURN conv_tsdb_v8_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int64_t v8);
-static SQLRETURN conv_tsdb_v8_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int64_t v8);
-static SQLRETURN conv_tsdb_f4_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, float f4);
-static SQLRETURN conv_tsdb_f4_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, float f4);
-static SQLRETURN conv_tsdb_f4_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, float f4);
-static SQLRETURN conv_tsdb_f4_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, float f4);
-static SQLRETURN conv_tsdb_f8_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, double f8);
-static SQLRETURN conv_tsdb_f8_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, double f8);
-static SQLRETURN conv_tsdb_f8_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, double f8);
-static SQLRETURN conv_tsdb_ts_to_c_v8(sql_t *sql, c_target_t *target, TAOS_FIELD *field, SQL_TIMESTAMP_STRUCT *ts);
-static SQLRETURN conv_tsdb_ts_to_c_str(sql_t *sql, c_target_t *target, TAOS_FIELD *field, SQL_TIMESTAMP_STRUCT *ts);
-static SQLRETURN conv_tsdb_ts_to_c_bin(sql_t *sql, c_target_t *target, TAOS_FIELD *field, SQL_TIMESTAMP_STRUCT *ts);
-static SQLRETURN conv_tsdb_ts_to_c_ts(sql_t *sql, c_target_t *target, TAOS_FIELD *field, SQL_TIMESTAMP_STRUCT *ts);
-static SQLRETURN conv_tsdb_bin_to_c_str(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const unsigned char *bin);
-static SQLRETURN conv_tsdb_bin_to_c_bin(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const unsigned char *bin);
-static SQLRETURN conv_tsdb_str_to_c_bit(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str);
-static SQLRETURN conv_tsdb_str_to_c_v1(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str);
-static SQLRETURN conv_tsdb_str_to_c_v2(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str);
-static SQLRETURN conv_tsdb_str_to_c_v4(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str);
-static SQLRETURN conv_tsdb_str_to_c_v8(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str);
-static SQLRETURN conv_tsdb_str_to_c_f4(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str);
-static SQLRETURN conv_tsdb_str_to_c_f8(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str);
-static SQLRETURN conv_tsdb_str_to_c_str(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str);
-static SQLRETURN conv_tsdb_str_to_c_bin(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str);
-
 static SQLRETURN doSQLGetData(SQLHSTMT StatementHandle,
                               SQLUSMALLINT ColumnNumber, SQLSMALLINT TargetType,
                               SQLPOINTER TargetValue, SQLLEN BufferLength,
                               SQLLEN *StrLen_or_Ind)
 {
   sql_t *sql = (sql_t*)StatementHandle;
-  if (!sql) return SQL_ERROR;
+  if (!sql) return SQL_INVALID_HANDLE;
 
   CHK_CONN(sql);
   CHK_CONN_TAOS(sql);
 
+  conn_t *conn = sql->conn;
+
   if (!sql->rs) {
     SET_ERROR(sql, "HY000", TSDB_CODE_ODBC_NO_RESULT, "");
     return SQL_ERROR;
@@ -845,8 +1041,6 @@ static SQLRETURN doSQLGetData(SQLHSTMT StatementHandle,
     return SQL_ERROR;
   }
 
-  DASSERT(TargetValue);
-
   int nfields = taos_field_count(sql->rs);
   TAOS_FIELD *fields = taos_fetch_fields(sql->rs);
 
@@ -859,14 +1053,20 @@ static SQLRETURN doSQLGetData(SQLHSTMT StatementHandle,
     SET_ERROR(sql, "HY009", TSDB_CODE_ODBC_BAD_ARG, "NULL TargetValue not allowed for col [%d]", ColumnNumber);
     return SQL_ERROR;
   }
+  if (BufferLength<0) {
+    SET_ERROR(sql, "HY090", TSDB_CODE_ODBC_BAD_ARG, "");
+    return SQL_ERROR;
+  }
 
   TAOS_FIELD *field = fields + ColumnNumber-1;
   void *row = sql->row[ColumnNumber-1];
 
   if (!row) {
-    if (StrLen_or_Ind) {
-      *StrLen_or_Ind = SQL_NULL_DATA;
+    if (!StrLen_or_Ind) {
+      SET_ERROR(sql, "22002", TSDB_CODE_ODBC_BAD_ARG, "NULL StrLen_or_Ind not allowed for col [%d]", ColumnNumber);
+      return SQL_ERROR;
     }
+    *StrLen_or_Ind = SQL_NULL_DATA;
     return SQL_SUCCESS;
   }
 
@@ -878,89 +1078,49 @@ static SQLRETURN doSQLGetData(SQLHSTMT StatementHandle,
   target.soi       = StrLen_or_Ind;
 
   switch (field->type) {
-    case TSDB_DATA_TYPE_BOOL: {
-      int8_t v = *(int8_t*)row;
-      if (v) v = 1;
-      switch (target.ct) {
-        case SQL_C_BIT:      return conv_tsdb_bool_to_c_bit(sql, &target, field, v);
-        case SQL_C_TINYINT:  return conv_tsdb_bool_to_c_tinyint(sql, &target, field, v);
-        case SQL_C_SHORT:    return conv_tsdb_bool_to_c_short(sql, &target, field, v);
-        case SQL_C_LONG:     return conv_tsdb_bool_to_c_long(sql, &target, field, v);
-        case SQL_C_SBIGINT:  return conv_tsdb_bool_to_c_sbigint(sql, &target, field, v);
-        case SQL_C_FLOAT:    return conv_tsdb_bool_to_c_float(sql, &target, field, v);
-        case SQL_C_DOUBLE:   return conv_tsdb_bool_to_c_double(sql, &target, field, v);
-        case SQL_C_CHAR:     return conv_tsdb_bool_to_c_char(sql, &target, field, v);
-        case SQL_C_BINARY:   return conv_tsdb_bool_to_c_binary(sql, &target, field, v);
-        default: {
-          SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_NOT_SUPPORT,
-                    "no convertion from [%s] to [%s[%d][0x%x]] for col [%d]",
-                    taos_data_type(field->type), sql_c_type(target.ct), target.ct, target.ct, ColumnNumber);
-          return SQL_ERROR;
-        }
-      }
-		} break;
-    case TSDB_DATA_TYPE_TINYINT: {
-      int8_t v = *(int8_t*)row;
-      switch (target.ct) {
-        case SQL_C_TINYINT:  return conv_tsdb_v1_to_c_tinyint(sql, &target, field, v);
-        case SQL_C_SHORT:    return conv_tsdb_v1_to_c_short(sql, &target, field, v);
-        case SQL_C_LONG:     return conv_tsdb_v1_to_c_long(sql, &target, field, v);
-        case SQL_C_SBIGINT:  return conv_tsdb_v1_to_c_sbigint(sql, &target, field, v);
-        case SQL_C_FLOAT:    return conv_tsdb_v1_to_c_float(sql, &target, field, v);
-        case SQL_C_DOUBLE:   return conv_tsdb_v1_to_c_double(sql, &target, field, v);
-        case SQL_C_CHAR:     return conv_tsdb_v1_to_c_char(sql, &target, field, v);
-        case SQL_C_BINARY:   return conv_tsdb_v1_to_c_binary(sql, &target, field, v);
-        default: {
-          SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_NOT_SUPPORT,
-                    "no convertion from [%s] to [%s[%d][0x%x]] for col [%d]",
-                    taos_data_type(field->type), sql_c_type(target.ct), target.ct, target.ct, ColumnNumber);
-          return SQL_ERROR;
-        }
-      }
-		} break;
-    case TSDB_DATA_TYPE_SMALLINT: {
-      int16_t v = *(int16_t*)row;
-      switch (target.ct) {
-        case SQL_C_SHORT:    return conv_tsdb_v2_to_c_short(sql, &target, field, v);
-        case SQL_C_LONG:     return conv_tsdb_v2_to_c_long(sql, &target, field, v);
-        case SQL_C_SBIGINT:  return conv_tsdb_v2_to_c_sbigint(sql, &target, field, v);
-        case SQL_C_FLOAT:    return conv_tsdb_v2_to_c_float(sql, &target, field, v);
-        case SQL_C_DOUBLE:   return conv_tsdb_v2_to_c_double(sql, &target, field, v);
-        case SQL_C_CHAR:     return conv_tsdb_v2_to_c_char(sql, &target, field, v);
-        case SQL_C_BINARY:   return conv_tsdb_v2_to_c_binary(sql, &target, field, v);
-        default: {
-          SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_NOT_SUPPORT,
-                    "no convertion from [%s] to [%s[%d][0x%x]] for col [%d]",
-                    taos_data_type(field->type), sql_c_type(target.ct), target.ct, target.ct, ColumnNumber);
-          return SQL_ERROR;
-        }
-      }
-		} break;
-    case TSDB_DATA_TYPE_INT: {
-      int32_t v = *(int32_t*)row;
-      switch (target.ct) {
-        case SQL_C_LONG:     return conv_tsdb_v4_to_c_long(sql, &target, field, v);
-        case SQL_C_SBIGINT:  return conv_tsdb_v4_to_c_sbigint(sql, &target, field, v);
-        case SQL_C_FLOAT:    return conv_tsdb_v4_to_c_float(sql, &target, field, v);
-        case SQL_C_DOUBLE:   return conv_tsdb_v4_to_c_double(sql, &target, field, v);
-        case SQL_C_CHAR:     return conv_tsdb_v4_to_c_char(sql, &target, field, v);
-        case SQL_C_BINARY:   return conv_tsdb_v4_to_c_binary(sql, &target, field, v);
-        default: {
-          SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_NOT_SUPPORT,
-                    "no convertion from [%s] to [%s[%d][0x%x]] for col [%d]",
-                    taos_data_type(field->type), sql_c_type(target.ct), target.ct, target.ct, ColumnNumber);
-          return SQL_ERROR;
-        }
-      }
-		} break;
+    case TSDB_DATA_TYPE_BOOL:
+    case TSDB_DATA_TYPE_TINYINT:
+    case TSDB_DATA_TYPE_SMALLINT:
+    case TSDB_DATA_TYPE_INT:
     case TSDB_DATA_TYPE_BIGINT: {
-      int64_t v = *(int64_t*)row;
+      int64_t v;
+      switch (field->type) {
+        case TSDB_DATA_TYPE_BOOL:       v = *(int8_t*)row;  if (v) v = 1; break;
+        case TSDB_DATA_TYPE_TINYINT:    v = *(int8_t*)row;  break;
+        case TSDB_DATA_TYPE_SMALLINT:   v = *(int16_t*)row; break;
+        case TSDB_DATA_TYPE_INT:        v = *(int32_t*)row; break;
+        case TSDB_DATA_TYPE_BIGINT:     // fall through
+        default:                        v = *(int64_t*)row; break;
+      }
       switch (target.ct) {
-        case SQL_C_SBIGINT:  return conv_tsdb_v8_to_c_sbigint(sql, &target, field, v);
-        case SQL_C_FLOAT:    return conv_tsdb_v8_to_c_float(sql, &target, field, v);
-        case SQL_C_DOUBLE:   return conv_tsdb_v8_to_c_double(sql, &target, field, v);
-        case SQL_C_CHAR:     return conv_tsdb_v8_to_c_char(sql, &target, field, v);
-        case SQL_C_BINARY:   return conv_tsdb_v8_to_c_binary(sql, &target, field, v);
+        case SQL_C_BIT: {
+          CHK_CONV(0, tsdb_int64_to_bit(v, TargetValue));
+        } break;
+        case SQL_C_TINYINT: {
+          CHK_CONV(0, tsdb_int64_to_tinyint(v, TargetValue));
+        } break;
+        case SQL_C_SHORT: {
+          CHK_CONV(0, tsdb_int64_to_smallint(v, TargetValue));
+        } break;
+        case SQL_C_LONG: {
+          CHK_CONV(0, tsdb_int64_to_int(v, TargetValue));
+        } break;
+        case SQL_C_SBIGINT: {
+          CHK_CONV(0, tsdb_int64_to_bigint(v, TargetValue));
+        } break;
+        case SQL_C_FLOAT: {
+          CHK_CONV(0, tsdb_int64_to_float(v, TargetValue));
+        } break;
+        case SQL_C_DOUBLE: {
+          CHK_CONV(0, tsdb_int64_to_double(v, TargetValue));
+        } break;
+        case SQL_C_CHAR: {
+          tsdb_conv_t *utf8_to_client = tsdb_conn_utf8_to_client(conn);
+          size_t len = (size_t)BufferLength;
+          TSDB_CONV_CODE code = tsdb_conv_write_int64(utf8_to_client, v, (char*)TargetValue, &len);
+          if (StrLen_or_Ind) *StrLen_or_Ind = (SQLLEN)len;
+          CHK_CONV(0, code);
+        } break;
         default: {
           SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_NOT_SUPPORT,
                     "no convertion from [%s] to [%s[%d][0x%x]] for col [%d]",
@@ -972,10 +1132,21 @@ static SQLRETURN doSQLGetData(SQLHSTMT StatementHandle,
     case TSDB_DATA_TYPE_FLOAT: {
       float v = *(float*)row;
       switch (target.ct) {
-        case SQL_C_FLOAT:    return conv_tsdb_f4_to_c_float(sql, &target, field, v);
-        case SQL_C_DOUBLE:   return conv_tsdb_f4_to_c_double(sql, &target, field, v);
-        case SQL_C_CHAR:     return conv_tsdb_f4_to_c_char(sql, &target, field, v);
-        case SQL_C_BINARY:   return conv_tsdb_f4_to_c_binary(sql, &target, field, v);
+        case SQL_C_FLOAT: {
+          *(float*)TargetValue = v;
+          return SQL_SUCCESS;
+        } break;
+        case SQL_C_DOUBLE: {
+          *(double*)TargetValue = v;
+          return SQL_SUCCESS;
+        } break;
+        case SQL_C_CHAR: {
+          tsdb_conv_t *utf8_to_client = tsdb_conn_utf8_to_client(conn);
+          size_t len = (size_t)BufferLength;
+          TSDB_CONV_CODE code = tsdb_conv_write_double(utf8_to_client, v, (char*)TargetValue, &len);
+          if (StrLen_or_Ind) *StrLen_or_Ind = (SQLLEN)len;
+          CHK_CONV(0, code);
+        } break;
         default: {
           SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_NOT_SUPPORT,
                     "no convertion from [%s] to [%s[%d][0x%x]] for col [%d]",
@@ -987,9 +1158,17 @@ static SQLRETURN doSQLGetData(SQLHSTMT StatementHandle,
     case TSDB_DATA_TYPE_DOUBLE: {
       double v = *(double*)row;
       switch (target.ct) {
-        case SQL_C_DOUBLE:   return conv_tsdb_f8_to_c_double(sql, &target, field, v);
-        case SQL_C_CHAR:     return conv_tsdb_f8_to_c_char(sql, &target, field, v);
-        case SQL_C_BINARY:   return conv_tsdb_f8_to_c_binary(sql, &target, field, v);
+        case SQL_C_DOUBLE: {
+          *(double*)TargetValue = v;
+          return SQL_SUCCESS;
+        } break;
+        case SQL_C_CHAR: {
+          tsdb_conv_t *utf8_to_client = tsdb_conn_utf8_to_client(conn);
+          size_t len = (size_t)BufferLength;
+          TSDB_CONV_CODE code = tsdb_conv_write_double(utf8_to_client, v, (char*)TargetValue, &len);
+          if (StrLen_or_Ind) *StrLen_or_Ind = (SQLLEN)len;
+          CHK_CONV(0, code);
+        } break;
         default: {
           SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_NOT_SUPPORT,
                     "no convertion from [%s] to [%s[%d][0x%x]] for col [%d]",
@@ -1002,21 +1181,31 @@ static SQLRETURN doSQLGetData(SQLHSTMT StatementHandle,
       SQL_TIMESTAMP_STRUCT ts = {0};
       int64_t v = *(int64_t*)row;
       time_t t = v/1000;
-      struct tm tm = {0};
-      localtime_r(&t, &tm);
-      ts.year     = tm.tm_year + 1900;
-      ts.month    = tm.tm_mon + 1;
-      ts.day      = tm.tm_mday;
-      ts.hour     = tm.tm_hour;
-      ts.minute   = tm.tm_min;
-      ts.second   = tm.tm_sec;
-      ts.fraction = v%1000 * 1000000;
+      struct tm vtm = {0};
+      localtime_r(&t, &vtm);
+      ts.year     = (SQLSMALLINT)(vtm.tm_year + 1900);
+      ts.month    = (SQLUSMALLINT)(vtm.tm_mon + 1);
+      ts.day      = (SQLUSMALLINT)(vtm.tm_mday);
+      ts.hour     = (SQLUSMALLINT)(vtm.tm_hour);
+      ts.minute   = (SQLUSMALLINT)(vtm.tm_min);
+      ts.second   = (SQLUSMALLINT)(vtm.tm_sec);
+      ts.fraction = (SQLUINTEGER)(v%1000 * 1000000);
       switch (target.ct) {
-        case SQL_C_SBIGINT:   return conv_tsdb_ts_to_c_v8(sql, &target, field, &ts);
-        case SQL_C_CHAR:      return conv_tsdb_ts_to_c_str(sql, &target, field, &ts);
-        case SQL_C_BINARY:    return conv_tsdb_ts_to_c_bin(sql, &target, field, &ts);
-        case SQL_C_TYPE_TIMESTAMP:
-        case SQL_C_TIMESTAMP: return conv_tsdb_ts_to_c_ts(sql, &target, field, &ts);
+        case SQL_C_SBIGINT: {
+          *(int64_t*)TargetValue = v;
+          return SQL_SUCCESS;
+        } break;
+        case SQL_C_CHAR: {
+          tsdb_conv_t *utf8_to_client = tsdb_conn_utf8_to_client(conn);
+          size_t len = (size_t)BufferLength;
+          TSDB_CONV_CODE code = tsdb_conv_write_timestamp(utf8_to_client, ts, (char*)TargetValue, &len);
+          if (StrLen_or_Ind) *StrLen_or_Ind = (SQLLEN)len;
+          CHK_CONV(0, code);
+        } break;
+        case SQL_C_TYPE_TIMESTAMP: {
+          *(SQL_TIMESTAMP_STRUCT*)TargetValue = ts;
+          return SQL_SUCCESS;
+        } break;
         default: {
           SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_NOT_SUPPORT,
                     "no convertion from [%s] to [%s[%d][0x%x]] for col [%d]",
@@ -1026,10 +1215,34 @@ static SQLRETURN doSQLGetData(SQLHSTMT StatementHandle,
       }
 		} break;
     case TSDB_DATA_TYPE_BINARY: {
-      const unsigned char *bin = (const unsigned char *)row;
+      size_t field_bytes = (size_t)field->bytes;
+      field_bytes -= VARSTR_HEADER_SIZE;
       switch (target.ct) {
-        case SQL_C_CHAR:      return conv_tsdb_bin_to_c_str(sql, &target, field, bin);
-        case SQL_C_BINARY:    return conv_tsdb_bin_to_c_bin(sql, &target, field, bin);
+        case SQL_C_CHAR: {
+          // taos cares nothing about what would be stored in 'binary' as most sql implementations do
+          // but the client requires to fetch it as a SQL_C_CHAR
+          // thus, we first try to decode binary to client charset
+          // if failed, we then do hex-serialization
+
+          tsdb_conv_t *server_to_client = tsdb_conn_server_to_client(conn);
+          size_t slen = strnlen((const char*)row, field_bytes);
+          size_t len = (size_t)BufferLength;
+          TSDB_CONV_CODE code = tsdb_conv_write(server_to_client,
+                                    (const char*)row, &slen,
+                                    (char*)TargetValue, &len);
+          if (code==TSDB_CONV_OK) {
+            if (StrLen_or_Ind) *StrLen_or_Ind = (SQLLEN)((size_t)BufferLength - len);
+            CHK_CONV(0, code);
+            // code never reached here
+          }
+
+          // todo: hex-serialization
+          const char *bad = "<bad-charset>";
+          int n = snprintf((char*)TargetValue, (size_t)BufferLength, "%s", bad);
+          // what if n < 0 ?
+          if (StrLen_or_Ind) *StrLen_or_Ind = n;
+          CHK_CONV(0, n>=BufferLength ? TSDB_CONV_TRUNC : TSDB_CONV_OK);
+        } break;
         default: {
           SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_NOT_SUPPORT,
                     "no convertion from [%s] to [%s[%d][0x%x]] for col [%d]",
@@ -1039,17 +1252,19 @@ static SQLRETURN doSQLGetData(SQLHSTMT StatementHandle,
       }
 		} break;
     case TSDB_DATA_TYPE_NCHAR: {
-      const char *str = (const char *)row;
+      size_t field_bytes = (size_t)field->bytes;
+      field_bytes -= VARSTR_HEADER_SIZE;
       switch (target.ct) {
-        case SQL_C_BIT:       return conv_tsdb_str_to_c_bit(sql, &target, field, str);
-        case SQL_C_TINYINT:   return conv_tsdb_str_to_c_v1(sql, &target, field, str);
-        case SQL_C_SHORT:     return conv_tsdb_str_to_c_v2(sql, &target, field, str);
-        case SQL_C_LONG:      return conv_tsdb_str_to_c_v4(sql, &target, field, str);
-        case SQL_C_SBIGINT:   return conv_tsdb_str_to_c_v8(sql, &target, field, str);
-        case SQL_C_FLOAT:     return conv_tsdb_str_to_c_f4(sql, &target, field, str);
-        case SQL_C_DOUBLE:    return conv_tsdb_str_to_c_f8(sql, &target, field, str);
-        case SQL_C_CHAR:      return conv_tsdb_str_to_c_str(sql, &target, field, str);
-        case SQL_C_BINARY:    return conv_tsdb_str_to_c_bin(sql, &target, field, str);
+        case SQL_C_CHAR: {
+          tsdb_conv_t *server_to_client = tsdb_conn_server_to_client(conn);
+          size_t slen = strnlen((const char*)row, field_bytes);
+          size_t len = (size_t)BufferLength;
+          TSDB_CONV_CODE code = tsdb_conv_write(server_to_client,
+                                   (const char*)row, &slen,
+                                   (char*)TargetValue, &len);
+          if (StrLen_or_Ind) *StrLen_or_Ind = (SQLLEN)((size_t)BufferLength - len);
+          CHK_CONV(0, code);
+        } break;
         default: {
           SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_NOT_SUPPORT,
                     "no convertion from [%s] to [%s[%d][0x%x]] for col [%d]",
@@ -1083,7 +1298,7 @@ SQLRETURN SQL_API SQLGetData(SQLHSTMT StatementHandle,
 static SQLRETURN doSQLFetch(SQLHSTMT StatementHandle)
 {
   sql_t *sql = (sql_t*)StatementHandle;
-  if (!sql) return SQL_ERROR;
+  if (!sql) return SQL_INVALID_HANDLE;
 
   CHK_CONN(sql);
   CHK_CONN_TAOS(sql);
@@ -1107,12 +1322,18 @@ SQLRETURN SQL_API SQLFetch(SQLHSTMT StatementHandle)
 static SQLRETURN doSQLPrepare(SQLHSTMT StatementHandle,
                               SQLCHAR *StatementText, SQLINTEGER TextLength)
 {
+  stack_buffer_t buffer; buffer.next = 0;
+
   sql_t *sql = (sql_t*)StatementHandle;
-  if (!sql) return SQL_ERROR;
+  if (!sql) return SQL_INVALID_HANDLE;
 
   CHK_CONN(sql);
   CHK_CONN_TAOS(sql);
 
+  conn_t *conn = sql->conn;
+
+  NORM_STR_LENGTH(sql, StatementText, TextLength);
+
   if (sql->rs) {
     taos_free_result(sql->rs);
     sql->rs = NULL;
@@ -1138,9 +1359,17 @@ static SQLRETURN doSQLPrepare(SQLHSTMT StatementHandle,
       break;
     }
 
+    tsdb_conv_t *client_to_server = tsdb_conn_client_to_server(conn);
+    const char *stxt = NULL;
     int ok = 0;
     do {
-      int r = taos_stmt_prepare(sql->stmt, (const char *)StatementText, TextLength);
+      tsdb_conv(client_to_server, &buffer, (const char*)StatementText, (size_t)TextLength, &stxt, NULL);
+      if ((!stxt)) {
+        SET_ERROR(sql, "HY001", TSDB_CODE_ODBC_OOM, "");
+        break;
+      }
+
+      int r = taos_stmt_prepare(sql->stmt, stxt, (unsigned long)strlen(stxt));
       if (r) {
         SET_ERROR(sql, "HY000", r, "failed to prepare a TAOS statement");
         break;
@@ -1164,7 +1393,7 @@ static SQLRETURN doSQLPrepare(SQLHSTMT StatementHandle,
       DASSERT(params>=0);
 
       if (params>0) {
-        param_bind_t *ar = (param_bind_t*)calloc(1, params * sizeof(*ar));
+        param_bind_t *ar = (param_bind_t*)calloc(1, ((size_t)params) * sizeof(*ar));
         if (!ar) {
           SET_ERROR(sql, "HY001", TSDB_CODE_ODBC_OOM, "");
           break;
@@ -1177,6 +1406,8 @@ static SQLRETURN doSQLPrepare(SQLHSTMT StatementHandle,
       ok = 1;
     } while (0);
 
+    tsdb_conv_free(client_to_server, stxt, &buffer, (const char*)StatementText);
+
     if (!ok) {
       taos_stmt_close(sql->stmt);
       sql->stmt = NULL;
@@ -1206,57 +1437,86 @@ static SQLRETURN do_bind_param_value(sql_t *sql, int idx_row, int idx, param_bin
     SET_ERROR(sql, "HY000", TSDB_CODE_ODBC_NOT_SUPPORT, "parameter [@%d] not bound yet", idx+1);
     return SQL_ERROR;
   }
+  if (param->ParameterValue==NULL) {
+    SET_ERROR(sql, "HY009", TSDB_CODE_ODBC_BAD_ARG, "ParameterValue [@%p] not allowed", param->ParameterValue);
+    return SQL_ERROR;
+  }
+  if (param->StrLen_or_Ind==NULL) {
+    SET_ERROR(sql, "HY009", TSDB_CODE_ODBC_BAD_ARG, "StrLen_or_Ind [@%p] not allowed", param->StrLen_or_Ind);
+    return SQL_ERROR;
+  }
 
-  SQLPOINTER    paramValue = param->ParameterValue;
-  SQLSMALLINT   valueType  = param->ValueType;
-  SQLLEN       *soi        = param->StrLen_or_Ind;
+  conn_t *conn = sql->conn;
 
-  size_t offset = idx_row * sql->rowlen + sql->ptr_offset;
+  unsigned char *paramValue = param->ParameterValue;
+  SQLSMALLINT    valueType  = param->ValueType;
+  SQLLEN        *soi        = param->StrLen_or_Ind;
 
-  if (paramValue) paramValue += offset;
-  if (soi)               soi = (SQLLEN*)((char*)soi + offset);
+  size_t offset = ((size_t)idx_row) * sql->rowlen + sql->ptr_offset;
 
+  paramValue += offset;
+  soi = (SQLLEN*)((char*)soi + offset);
 
-  if (soi && *soi == SQL_NULL_DATA) {
+
+  if (*soi == SQL_NULL_DATA) {
     bind->is_null = (int*)&yes;
     return SQL_SUCCESS;
   }
   bind->is_null = (int*)&no;
-  int type = 0;
-  int bytes = 0;
+  int tsdb_type = 0;   // taos internal data tsdb_type to be bound to
+  int tsdb_bytes = 0;  // we don't rely much on 'tsdb_bytes' here, we delay until taos to check it internally
   if (sql->is_insert) {
-    int r = taos_stmt_get_param(sql->stmt, idx, &type, &bytes);
+    int r = taos_stmt_get_param(sql->stmt, idx, &tsdb_type, &tsdb_bytes);
     if (r) {
       SET_ERROR(sql, "HY000", TSDB_CODE_ODBC_OUT_OF_RANGE, "parameter [@%d] not valid", idx+1);
       return SQL_ERROR;
     }
   } else {
+    // we don't have correspondent data type from taos api
+    // we have to give a good guess here
     switch (valueType) {
+      case SQL_C_BIT: {
+        tsdb_type = TSDB_DATA_TYPE_BOOL;
+      } break;
+      case SQL_C_STINYINT:
+      case SQL_C_TINYINT: {
+        tsdb_type = TSDB_DATA_TYPE_TINYINT;
+      } break;
+      case SQL_C_SSHORT:
+      case SQL_C_SHORT: {
+        tsdb_type = TSDB_DATA_TYPE_SMALLINT;
+      } break;
+      case SQL_C_SLONG:
       case SQL_C_LONG: {
-        type = TSDB_DATA_TYPE_INT;
+        tsdb_type = TSDB_DATA_TYPE_INT;
+      } break;
+      case SQL_C_SBIGINT: {
+        tsdb_type = TSDB_DATA_TYPE_BIGINT;
+      } break;
+      case SQL_C_FLOAT: {
+        tsdb_type = TSDB_DATA_TYPE_FLOAT;
+      } break;
+      case SQL_C_DOUBLE: {
+        tsdb_type = TSDB_DATA_TYPE_DOUBLE;
+      } break;
+      case SQL_C_TIMESTAMP: {
+        tsdb_type = TSDB_DATA_TYPE_TIMESTAMP;
+      } break;
+      case SQL_C_CHAR: {
+        tsdb_type = TSDB_DATA_TYPE_BINARY;
+        tsdb_bytes = SQL_NTS;
       } break;
       case SQL_C_WCHAR: {
-        type = TSDB_DATA_TYPE_NCHAR;
-        bytes = SQL_NTS;
+        tsdb_type = TSDB_DATA_TYPE_NCHAR;
+        tsdb_bytes = SQL_NTS;
       } break;
-      case SQL_C_CHAR:
-      case SQL_C_SHORT:
-      case SQL_C_SSHORT:
       case SQL_C_USHORT:
-      case SQL_C_SLONG:
       case SQL_C_ULONG:
-      case SQL_C_FLOAT:
-      case SQL_C_DOUBLE:
-      case SQL_C_BIT:
-      case SQL_C_TINYINT:
-      case SQL_C_STINYINT:
       case SQL_C_UTINYINT:
-      case SQL_C_SBIGINT:
       case SQL_C_UBIGINT:
       case SQL_C_BINARY:
       case SQL_C_DATE:
       case SQL_C_TIME:
-      case SQL_C_TIMESTAMP:
       case SQL_C_TYPE_DATE:
       case SQL_C_TYPE_TIME:
       case SQL_C_TYPE_TIMESTAMP:
@@ -1273,37 +1533,59 @@ static SQLRETURN do_bind_param_value(sql_t *sql, int idx_row, int idx, param_bin
   }
 
   // ref: https://docs.microsoft.com/en-us/sql/odbc/reference/appendixes/converting-data-from-c-to-sql-data-types?view=sql-server-ver15
-  switch (type) {
+  switch (tsdb_type) {
     case TSDB_DATA_TYPE_BOOL: {
-      bind->buffer_type = type;
+      bind->buffer_type = tsdb_type;
       bind->buffer_length = sizeof(bind->u.b);
       bind->buffer = &bind->u.b;
       bind->length = &bind->buffer_length;
       switch (valueType) {
-        case SQL_C_LONG: {
-          CHK_CONV(tsdb_int64_to_bit(*(int32_t*)paramValue, &bind->u.b));
-        } break;
         case SQL_C_BIT: {
-          CHK_CONV(tsdb_int64_to_bit(*(int8_t*)paramValue, &bind->u.b));
+          CHK_CONV(1, tsdb_int64_to_bit(*(int8_t*)paramValue, &bind->u.b));
         } break;
-        case SQL_C_CHAR:
-        case SQL_C_WCHAR:
-        case SQL_C_SHORT:
-        case SQL_C_SSHORT:
-        case SQL_C_USHORT:
-        case SQL_C_SLONG:
-        case SQL_C_ULONG:
-        case SQL_C_FLOAT:
-        case SQL_C_DOUBLE:
         case SQL_C_TINYINT:
-        case SQL_C_STINYINT:
-        case SQL_C_UTINYINT:
-        case SQL_C_SBIGINT:
-        case SQL_C_UBIGINT:
-        case SQL_C_BINARY:
-        case SQL_C_DATE:
-        case SQL_C_TIME:
-        case SQL_C_TIMESTAMP:
+        case SQL_C_STINYINT: {
+          CHK_CONV(1, tsdb_int64_to_bit(*(int8_t*)paramValue, &bind->u.b));
+        } break;
+        case SQL_C_SHORT:
+        case SQL_C_SSHORT: {
+          CHK_CONV(1, tsdb_int64_to_bit(*(int16_t*)paramValue, &bind->u.b));
+        } break;
+        case SQL_C_LONG:
+        case SQL_C_SLONG: {
+          CHK_CONV(1, tsdb_int64_to_bit(*(int32_t*)paramValue, &bind->u.b));
+        } break;
+        case SQL_C_SBIGINT: {
+          CHK_CONV(1, tsdb_int64_to_bit(*(int64_t*)paramValue, &bind->u.b));
+        } break;
+        case SQL_C_FLOAT: {
+          CHK_CONV(1, tsdb_double_to_bit(*(float*)paramValue, &bind->u.b));
+        } break;
+        case SQL_C_DOUBLE: {
+          CHK_CONV(1, tsdb_double_to_bit(*(double*)paramValue, &bind->u.b));
+        } break;
+        case SQL_C_CHAR: {
+          stack_buffer_t buffer; buffer.next = 0;
+          tsdb_conv_t *client_to_utf8 = tsdb_conn_client_to_utf8(conn);
+          size_t slen = (size_t)*soi;
+          if (slen==SQL_NTS) slen = strlen((const char*)paramValue);
+          CHK_CONV(1, tsdb_conv_chars_to_bit(client_to_utf8, &buffer, (const char *)paramValue, slen, &bind->u.b));
+        } break;
+        case SQL_C_WCHAR: {
+          stack_buffer_t buffer; buffer.next = 0;
+          tsdb_conv_t *utf16_to_utf8 = tsdb_conn_utf16_to_utf8(conn);
+          size_t slen = (size_t)*soi;
+          DASSERT(slen != SQL_NTS);
+          CHK_CONV(1, tsdb_conv_chars_to_bit(utf16_to_utf8, &buffer, (const char *)paramValue, slen, &bind->u.b));
+        } break;
+        case SQL_C_USHORT:
+        case SQL_C_ULONG:
+        case SQL_C_UTINYINT:
+        case SQL_C_UBIGINT:
+        case SQL_C_BINARY:
+        case SQL_C_DATE:
+        case SQL_C_TIME:
+        case SQL_C_TIMESTAMP:
         case SQL_C_TYPE_DATE:
         case SQL_C_TYPE_TIME:
         case SQL_C_TYPE_TIMESTAMP:
@@ -1313,39 +1595,54 @@ static SQLRETURN do_bind_param_value(sql_t *sql, int idx_row, int idx, param_bin
           SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_OUT_OF_RANGE,
                     "no convertion from [%s[%d/0x%x]] to [%s[%d/0x%x]] for parameter [%d]",
                     sql_c_type(valueType), valueType, valueType,
-                    taos_data_type(type), type, type, idx+1);
+                    taos_data_type(tsdb_type), tsdb_type, tsdb_type, idx+1);
           return SQL_ERROR;
         } break;
       }
 		} break;
     case TSDB_DATA_TYPE_TINYINT: {
-      bind->buffer_type = type;
+      bind->buffer_type = tsdb_type;
       bind->buffer_length = sizeof(bind->u.v1);
       bind->buffer = &bind->u.v1;
       bind->length = &bind->buffer_length;
       switch (valueType) {
+        case SQL_C_BIT: {
+          CHK_CONV(1, tsdb_int64_to_tinyint(*(int8_t*)paramValue, &bind->u.v1));
+        } break;
+        case SQL_C_STINYINT:
         case SQL_C_TINYINT: {
-          CHK_CONV(tsdb_int64_to_tinyint(*(int8_t*)paramValue, &bind->u.v1));
+          CHK_CONV(1, tsdb_int64_to_tinyint(*(int8_t*)paramValue, &bind->u.v1));
         } break;
+        case SQL_C_SSHORT:
         case SQL_C_SHORT: {
-          CHK_CONV(tsdb_int64_to_tinyint(*(int16_t*)paramValue, &bind->u.v1));
+          CHK_CONV(1, tsdb_int64_to_tinyint(*(int16_t*)paramValue, &bind->u.v1));
         } break;
+        case SQL_C_SLONG:
         case SQL_C_LONG: {
-          CHK_CONV(tsdb_int64_to_tinyint(*(int32_t*)paramValue, &bind->u.v1));
+          CHK_CONV(1, tsdb_int64_to_tinyint(*(int32_t*)paramValue, &bind->u.v1));
         } break;
         case SQL_C_SBIGINT: {
-          CHK_CONV(tsdb_int64_to_tinyint(*(int64_t*)paramValue, &bind->u.v1));
+          CHK_CONV(1, tsdb_int64_to_tinyint(*(int64_t*)paramValue, &bind->u.v1));
+        } break;
+        case SQL_C_CHAR: {
+          stack_buffer_t buffer; buffer.next = 0;
+          tsdb_conv_t *client_to_utf8 = tsdb_conn_client_to_utf8(conn);
+          size_t slen = (size_t)*soi;
+          if (slen==SQL_NTS) slen = strlen((const char*)paramValue);
+          CHK_CONV(1, tsdb_conv_chars_to_tinyint(client_to_utf8, &buffer, (const char *)paramValue, slen, &bind->u.v1));
+          // CHK_CONV(1, tsdb_chars_to_tinyint((const char *)paramValue, (size_t)*soi, &bind->u.v1));
+        } break;
+        case SQL_C_WCHAR: {
+          stack_buffer_t buffer; buffer.next = 0;
+          tsdb_conv_t *utf16_to_utf8 = tsdb_conn_utf16_to_utf8(conn);
+          size_t slen = (size_t)*soi;
+          DASSERT(slen != SQL_NTS);
+          CHK_CONV(1, tsdb_conv_chars_to_tinyint(utf16_to_utf8, &buffer, (const char *)paramValue, slen, &bind->u.v1));
         } break;
-        case SQL_C_CHAR:
-        case SQL_C_WCHAR:
-        case SQL_C_SSHORT:
         case SQL_C_USHORT:
-        case SQL_C_SLONG:
         case SQL_C_ULONG:
         case SQL_C_FLOAT:
         case SQL_C_DOUBLE:
-        case SQL_C_BIT:
-        case SQL_C_STINYINT:
         case SQL_C_UTINYINT:
         case SQL_C_UBIGINT:
         case SQL_C_BINARY:
@@ -1361,36 +1658,55 @@ static SQLRETURN do_bind_param_value(sql_t *sql, int idx_row, int idx, param_bin
           SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_OUT_OF_RANGE,
                     "no convertion from [%s[%d/0x%x]] to [%s[%d/0x%x]] for parameter [%d]",
                     sql_c_type(valueType), valueType, valueType,
-                    taos_data_type(type), type, type, idx+1);
+                    taos_data_type(tsdb_type), tsdb_type, tsdb_type, idx+1);
           return SQL_ERROR;
         } break;
       }
 		} break;
     case TSDB_DATA_TYPE_SMALLINT: {
-      bind->buffer_type = type;
+      bind->buffer_type = tsdb_type;
       bind->buffer_length = sizeof(bind->u.v2);
       bind->buffer = &bind->u.v2;
       bind->length = &bind->buffer_length;
       switch (valueType) {
-        case SQL_C_LONG: {
-          CHK_CONV(tsdb_int64_to_smallint(*(int32_t*)paramValue, &bind->u.v2));
+        case SQL_C_BIT: {
+          CHK_CONV(1, tsdb_int64_to_smallint(*(int8_t*)paramValue, &bind->u.v2));
         } break;
-        case SQL_C_SHORT: {
-          CHK_CONV(tsdb_int64_to_smallint(*(int16_t*)paramValue, &bind->u.v2));
+        case SQL_C_STINYINT:
+        case SQL_C_TINYINT: {
+          CHK_CONV(1, tsdb_int64_to_smallint(*(int8_t*)paramValue, &bind->u.v2));
         } break;
-        case SQL_C_CHAR:
-        case SQL_C_WCHAR:
         case SQL_C_SSHORT:
-        case SQL_C_USHORT:
+        case SQL_C_SHORT: {
+          CHK_CONV(1, tsdb_int64_to_smallint(*(int16_t*)paramValue, &bind->u.v2));
+        } break;
         case SQL_C_SLONG:
+        case SQL_C_LONG: {
+          CHK_CONV(1, tsdb_int64_to_smallint(*(int32_t*)paramValue, &bind->u.v2));
+        } break;
+        case SQL_C_SBIGINT: {
+          CHK_CONV(1, tsdb_int64_to_smallint(*(int64_t*)paramValue, &bind->u.v2));
+        } break;
+        case SQL_C_CHAR: {
+          stack_buffer_t buffer; buffer.next = 0;
+          tsdb_conv_t *client_to_utf8 = tsdb_conn_client_to_utf8(conn);
+          size_t slen = (size_t)*soi;
+          if (slen==SQL_NTS) slen = strlen((const char*)paramValue);
+          CHK_CONV(1, tsdb_conv_chars_to_smallint(client_to_utf8, &buffer, (const char *)paramValue, slen, &bind->u.v2));
+          // CHK_CONV(1, tsdb_chars_to_smallint((const char*)paramValue, (size_t)*soi, &bind->u.v2));
+        } break;
+        case SQL_C_WCHAR: {
+          stack_buffer_t buffer; buffer.next = 0;
+          tsdb_conv_t *utf16_to_utf8 = tsdb_conn_utf16_to_utf8(conn);
+          size_t slen = (size_t)*soi;
+          DASSERT(slen != SQL_NTS);
+          CHK_CONV(1, tsdb_conv_chars_to_smallint(utf16_to_utf8, &buffer, (const char *)paramValue, slen, &bind->u.v2));
+        } break;
+        case SQL_C_USHORT:
         case SQL_C_ULONG:
         case SQL_C_FLOAT:
         case SQL_C_DOUBLE:
-        case SQL_C_BIT:
-        case SQL_C_TINYINT:
-        case SQL_C_STINYINT:
         case SQL_C_UTINYINT:
-        case SQL_C_SBIGINT:
         case SQL_C_UBIGINT:
         case SQL_C_BINARY:
         case SQL_C_DATE:
@@ -1405,34 +1721,55 @@ static SQLRETURN do_bind_param_value(sql_t *sql, int idx_row, int idx, param_bin
           SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_OUT_OF_RANGE,
                     "no convertion from [%s[%d/0x%x]] to [%s[%d/0x%x]] for parameter [%d]",
                     sql_c_type(valueType), valueType, valueType,
-                    taos_data_type(type), type, type, idx+1);
+                    taos_data_type(tsdb_type), tsdb_type, tsdb_type, idx+1);
           return SQL_ERROR;
         } break;
       }
 		} break;
     case TSDB_DATA_TYPE_INT: {
-      bind->buffer_type = type;
+      bind->buffer_type = tsdb_type;
       bind->buffer_length = sizeof(bind->u.v4);
       bind->buffer = &bind->u.v4;
       bind->length = &bind->buffer_length;
       switch (valueType) {
-        case SQL_C_LONG: {
-          CHK_CONV(tsdb_int64_to_int(*(int32_t*)paramValue, &bind->u.v4));
+        case SQL_C_BIT: {
+          CHK_CONV(1, tsdb_int64_to_int(*(int8_t*)paramValue, &bind->u.v4));
+        } break;
+        case SQL_C_STINYINT:
+        case SQL_C_TINYINT: {
+          CHK_CONV(1, tsdb_int64_to_int(*(int8_t*)paramValue, &bind->u.v4));
         } break;
-        case SQL_C_CHAR:
-        case SQL_C_WCHAR:
-        case SQL_C_SHORT:
         case SQL_C_SSHORT:
-        case SQL_C_USHORT:
+        case SQL_C_SHORT: {
+          CHK_CONV(1, tsdb_int64_to_int(*(int16_t*)paramValue, &bind->u.v4));
+        } break;
         case SQL_C_SLONG:
+        case SQL_C_LONG: {
+          CHK_CONV(1, tsdb_int64_to_int(*(int32_t*)paramValue, &bind->u.v4));
+        } break;
+        case SQL_C_SBIGINT: {
+          CHK_CONV(1, tsdb_int64_to_int(*(int64_t*)paramValue, &bind->u.v4));
+        } break;
+        case SQL_C_CHAR: {
+          stack_buffer_t buffer; buffer.next = 0;
+          tsdb_conv_t *client_to_utf8 = tsdb_conn_client_to_utf8(conn);
+          size_t slen = (size_t)*soi;
+          if (slen==SQL_NTS) slen = strlen((const char*)paramValue);
+          CHK_CONV(1, tsdb_conv_chars_to_int(client_to_utf8, &buffer, (const char *)paramValue, slen, &bind->u.v4));
+          // CHK_CONV(1, tsdb_chars_to_int((const char*)paramValue, (size_t)*soi, &bind->u.v4));
+        } break;
+        case SQL_C_WCHAR: {
+          stack_buffer_t buffer; buffer.next = 0;
+          tsdb_conv_t *utf16_to_utf8 = tsdb_conn_utf16_to_utf8(conn);
+          size_t slen = (size_t)*soi;
+          DASSERT(slen != SQL_NTS);
+          CHK_CONV(1, tsdb_conv_chars_to_int(utf16_to_utf8, &buffer, (const char *)paramValue, slen, &bind->u.v4));
+        } break;
+        case SQL_C_USHORT:
         case SQL_C_ULONG:
         case SQL_C_FLOAT:
         case SQL_C_DOUBLE:
-        case SQL_C_BIT:
-        case SQL_C_TINYINT:
-        case SQL_C_STINYINT:
         case SQL_C_UTINYINT:
-        case SQL_C_SBIGINT:
         case SQL_C_UBIGINT:
         case SQL_C_BINARY:
         case SQL_C_DATE:
@@ -1447,35 +1784,54 @@ static SQLRETURN do_bind_param_value(sql_t *sql, int idx_row, int idx, param_bin
           SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_OUT_OF_RANGE,
                     "no convertion from [%s[%d/0x%x]] to [%s[%d/0x%x]] for parameter [%d]",
                     sql_c_type(valueType), valueType, valueType,
-                    taos_data_type(type), type, type, idx+1);
+                    taos_data_type(tsdb_type), tsdb_type, tsdb_type, idx+1);
           return SQL_ERROR;
         } break;
       }
 		} break;
     case TSDB_DATA_TYPE_BIGINT: {
-      bind->buffer_type = type;
+      bind->buffer_type = tsdb_type;
       bind->buffer_length = sizeof(bind->u.v8);
       bind->buffer = &bind->u.v8;
       bind->length = &bind->buffer_length;
       switch (valueType) {
-        case SQL_C_SBIGINT: {
-          bind->u.v8 = *(int64_t*)paramValue;
+        case SQL_C_BIT: {
+          CHK_CONV(1, tsdb_int64_to_bigint(*(int8_t*)paramValue, &bind->u.v8));
         } break;
-        case SQL_C_LONG: {
-          bind->u.v8 = *(int32_t*)paramValue;
+        case SQL_C_STINYINT:
+        case SQL_C_TINYINT: {
+          CHK_CONV(1, tsdb_int64_to_bigint(*(int8_t*)paramValue, &bind->u.v8));
         } break;
-        case SQL_C_CHAR:
-        case SQL_C_WCHAR:
-        case SQL_C_SHORT:
         case SQL_C_SSHORT:
-        case SQL_C_USHORT:
+        case SQL_C_SHORT: {
+          CHK_CONV(1, tsdb_int64_to_bigint(*(int16_t*)paramValue, &bind->u.v8));
+        } break;
         case SQL_C_SLONG:
+        case SQL_C_LONG: {
+          CHK_CONV(1, tsdb_int64_to_bigint(*(int32_t*)paramValue, &bind->u.v8));
+        } break;
+        case SQL_C_SBIGINT: {
+          CHK_CONV(1, tsdb_int64_to_bigint(*(int64_t*)paramValue, &bind->u.v8));
+        } break;
+        case SQL_C_CHAR: {
+          stack_buffer_t buffer; buffer.next = 0;
+          tsdb_conv_t *client_to_utf8 = tsdb_conn_client_to_utf8(conn);
+          size_t slen = (size_t)*soi;
+          if (slen==SQL_NTS) slen = strlen((const char*)paramValue);
+          CHK_CONV(1, tsdb_conv_chars_to_bigint(client_to_utf8, &buffer, (const char *)paramValue, slen, &bind->u.v8));
+          // CHK_CONV(1, tsdb_chars_to_bigint((const char*)paramValue, (size_t)*soi, &bind->u.v8));
+        } break;
+        case SQL_C_WCHAR: {
+          stack_buffer_t buffer; buffer.next = 0;
+          tsdb_conv_t *utf16_to_utf8 = tsdb_conn_utf16_to_utf8(conn);
+          size_t slen = (size_t)*soi;
+          DASSERT(slen != SQL_NTS);
+          CHK_CONV(1, tsdb_conv_chars_to_bigint(utf16_to_utf8, &buffer, (const char *)paramValue, slen, &bind->u.v8));
+        } break;
+        case SQL_C_USHORT:
         case SQL_C_ULONG:
         case SQL_C_FLOAT:
         case SQL_C_DOUBLE:
-        case SQL_C_BIT:
-        case SQL_C_TINYINT:
-        case SQL_C_STINYINT:
         case SQL_C_UTINYINT:
         case SQL_C_UBIGINT:
         case SQL_C_BINARY:
@@ -1491,36 +1847,58 @@ static SQLRETURN do_bind_param_value(sql_t *sql, int idx_row, int idx, param_bin
           SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_OUT_OF_RANGE,
                     "no convertion from [%s[%d/0x%x]] to [%s[%d/0x%x]] for parameter [%d]",
                     sql_c_type(valueType), valueType, valueType,
-                    taos_data_type(type), type, type, idx+1);
+                    taos_data_type(tsdb_type), tsdb_type, tsdb_type, idx+1);
           return SQL_ERROR;
         } break;
       }
 		} break;
     case TSDB_DATA_TYPE_FLOAT: {
-      bind->buffer_type = type;
+      bind->buffer_type = tsdb_type;
       bind->buffer_length = sizeof(bind->u.f4);
       bind->buffer = &bind->u.f4;
       bind->length = &bind->buffer_length;
       switch (valueType) {
-        case SQL_C_DOUBLE: {
-          bind->u.f4 = *(double*)paramValue;
+        case SQL_C_BIT: {
+          CHK_CONV(1, tsdb_int64_to_float(*(int8_t*)paramValue, &bind->u.f4));
+        } break;
+        case SQL_C_STINYINT:
+        case SQL_C_TINYINT: {
+          CHK_CONV(1, tsdb_int64_to_float(*(int8_t*)paramValue, &bind->u.f4));
+        } break;
+        case SQL_C_SSHORT:
+        case SQL_C_SHORT: {
+          CHK_CONV(1, tsdb_int64_to_float(*(int16_t*)paramValue, &bind->u.f4));
+        } break;
+        case SQL_C_SLONG:
+        case SQL_C_LONG: {
+          CHK_CONV(1, tsdb_int64_to_float(*(int32_t*)paramValue, &bind->u.f4));
+        } break;
+        case SQL_C_SBIGINT: {
+          CHK_CONV(1, tsdb_int64_to_float(*(int64_t*)paramValue, &bind->u.f4));
         } break;
         case SQL_C_FLOAT: {
           bind->u.f4 = *(float*)paramValue;
         } break;
-        case SQL_C_CHAR:
-        case SQL_C_WCHAR:
-        case SQL_C_SHORT:
-        case SQL_C_SSHORT:
+        case SQL_C_DOUBLE: {
+          bind->u.f4 = (float)*(double*)paramValue;
+        } break;
+        case SQL_C_CHAR: {
+          stack_buffer_t buffer; buffer.next = 0;
+          tsdb_conv_t *client_to_utf8 = tsdb_conn_client_to_utf8(conn);
+          size_t slen = (size_t)*soi;
+          if (slen==SQL_NTS) slen = strlen((const char*)paramValue);
+          CHK_CONV(1, tsdb_conv_chars_to_float(client_to_utf8, &buffer, (const char *)paramValue, slen, &bind->u.f4));
+        } break;
+        case SQL_C_WCHAR: {
+          stack_buffer_t buffer; buffer.next = 0;
+          tsdb_conv_t *utf16_to_utf8 = tsdb_conn_utf16_to_utf8(conn);
+          size_t slen = (size_t)*soi;
+          DASSERT(slen != SQL_NTS);
+          CHK_CONV(1, tsdb_conv_chars_to_float(utf16_to_utf8, &buffer, (const char *)paramValue, slen, &bind->u.f4));
+        } break;
         case SQL_C_USHORT:
-        case SQL_C_LONG:
-        case SQL_C_SLONG:
         case SQL_C_ULONG:
-        case SQL_C_BIT:
-        case SQL_C_TINYINT:
-        case SQL_C_STINYINT:
         case SQL_C_UTINYINT:
-        case SQL_C_SBIGINT:
         case SQL_C_UBIGINT:
         case SQL_C_BINARY:
         case SQL_C_DATE:
@@ -1535,34 +1913,59 @@ static SQLRETURN do_bind_param_value(sql_t *sql, int idx_row, int idx, param_bin
           SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_OUT_OF_RANGE,
                     "no convertion from [%s[%d/0x%x]] to [%s[%d/0x%x]] for parameter [%d]",
                     sql_c_type(valueType), valueType, valueType,
-                    taos_data_type(type), type, type, idx+1);
+                    taos_data_type(tsdb_type), tsdb_type, tsdb_type, idx+1);
           return SQL_ERROR;
         } break;
       }
 		} break;
     case TSDB_DATA_TYPE_DOUBLE: {
-      bind->buffer_type = type;
+      bind->buffer_type = tsdb_type;
       bind->buffer_length = sizeof(bind->u.f8);
       bind->buffer = &bind->u.f8;
       bind->length = &bind->buffer_length;
       switch (valueType) {
+        case SQL_C_BIT: {
+          CHK_CONV(1, tsdb_int64_to_double(*(int8_t*)paramValue, &bind->u.f8));
+        } break;
+        case SQL_C_STINYINT:
+        case SQL_C_TINYINT: {
+          CHK_CONV(1, tsdb_int64_to_double(*(int8_t*)paramValue, &bind->u.f8));
+        } break;
+        case SQL_C_SSHORT:
+        case SQL_C_SHORT: {
+          CHK_CONV(1, tsdb_int64_to_double(*(int16_t*)paramValue, &bind->u.f8));
+        } break;
+        case SQL_C_SLONG:
+        case SQL_C_LONG: {
+          CHK_CONV(1, tsdb_int64_to_double(*(int32_t*)paramValue, &bind->u.f8));
+        } break;
+        case SQL_C_SBIGINT: {
+          CHK_CONV(1, tsdb_int64_to_double(*(int64_t*)paramValue, &bind->u.f8));
+        } break;
+        case SQL_C_FLOAT: {
+          bind->u.f8 = *(float*)paramValue;
+        } break;
         case SQL_C_DOUBLE: {
           bind->u.f8 = *(double*)paramValue;
         } break;
-        case SQL_C_CHAR:
-        case SQL_C_WCHAR:
-        case SQL_C_SHORT:
-        case SQL_C_SSHORT:
+        case SQL_C_CHAR: {
+          stack_buffer_t buffer; buffer.next = 0;
+          tsdb_conv_t *client_to_utf8 = tsdb_conn_client_to_utf8(conn);
+          size_t slen = (size_t)*soi;
+          if (slen==SQL_NTS) slen = strlen((const char*)paramValue);
+          CHK_CONV(1, tsdb_conv_chars_to_double(client_to_utf8, &buffer, (const char *)paramValue, slen, &bind->u.f8));
+          // CHK_CONV(1, tsdb_chars_to_double((const char*)paramValue, (size_t)*soi, &bind->u.f8));
+        } break;
+        case SQL_C_WCHAR: {
+          stack_buffer_t buffer; buffer.next = 0;
+          tsdb_conv_t *utf16_to_utf8 = tsdb_conn_utf16_to_utf8(conn);
+          size_t slen = (size_t)*soi;
+          DASSERT(slen != SQL_NTS);
+          CHK_CONV(1, tsdb_conv_chars_to_double(utf16_to_utf8, &buffer, (const char *)paramValue, slen, &bind->u.f8));
+        } break;
         case SQL_C_USHORT:
-        case SQL_C_LONG:
-        case SQL_C_SLONG:
         case SQL_C_ULONG:
-        case SQL_C_FLOAT:
-        case SQL_C_BIT:
-        case SQL_C_TINYINT:
-        case SQL_C_STINYINT:
         case SQL_C_UTINYINT:
-        case SQL_C_SBIGINT:
         case SQL_C_UBIGINT:
         case SQL_C_BINARY:
         case SQL_C_DATE:
@@ -1577,35 +1980,51 @@ static SQLRETURN do_bind_param_value(sql_t *sql, int idx_row, int idx, param_bin
           SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_OUT_OF_RANGE,
                     "no convertion from [%s[%d/0x%x]] to [%s[%d/0x%x]] for parameter [%d]",
                     sql_c_type(valueType), valueType, valueType,
-                    taos_data_type(type), type, type, idx+1);
+                    taos_data_type(tsdb_type), tsdb_type, tsdb_type, idx+1);
           return SQL_ERROR;
         } break;
       }
 		} break;
-    case TSDB_DATA_TYPE_BINARY: {
-      bind->buffer_type = type;
+    case TSDB_DATA_TYPE_TIMESTAMP: {
+      bind->buffer_type = tsdb_type;
+      bind->buffer_length = sizeof(bind->u.v8);
+      bind->buffer = &bind->u.v8;
       bind->length = &bind->buffer_length;
       switch (valueType) {
+        case SQL_C_CHAR: {
+          stack_buffer_t buffer; buffer.next = 0;
+          tsdb_conv_t *client_to_utf8 = tsdb_conn_client_to_utf8(conn);
+          size_t slen = (size_t)*soi;
+          DASSERT(slen != SQL_NTS);
+          CHK_CONV(1, tsdb_conv_chars_to_timestamp_ts(client_to_utf8, &buffer, (const char *)paramValue, slen, &bind->u.v8));
+        } break;
         case SQL_C_WCHAR: {
-          DASSERT(soi);
-          DASSERT(*soi != SQL_NTS);
-          size_t bytes = 0;
-          SQLCHAR *utf8 = wchars_to_chars(paramValue, *soi/2, &bytes);
-          bind->allocated = 1;
-          bind->u.bin = utf8;
-          bind->buffer_length = bytes;
-          bind->buffer = bind->u.bin;
+          stack_buffer_t buffer; buffer.next = 0;
+          tsdb_conv_t *utf16_to_utf8 = tsdb_conn_utf16_to_utf8(conn);
+          size_t slen = (size_t)*soi;
+          DASSERT(slen != SQL_NTS);
+          CHK_CONV(1, tsdb_conv_chars_to_timestamp_ts(utf16_to_utf8, &buffer, (const char *)paramValue, slen, &bind->u.v8));
+        } break;
+        case SQL_C_SBIGINT: {
+          int64_t t = *(int64_t*)paramValue;
+          bind->u.v8 = t;
         } break;
-        case SQL_C_BINARY: {
-          bind->u.bin = (unsigned char*)paramValue;
-          if (*soi == SQL_NTS) {
-            bind->buffer_length = strlen((const char*)paramValue);
-          } else {
-            bind->buffer_length = *soi;
+        case SQL_C_TYPE_TIMESTAMP: {
+          SQL_TIMESTAMP_STRUCT ts = *(SQL_TIMESTAMP_STRUCT*)paramValue;
+          struct tm vtm = {0};
+          vtm.tm_year     = ts.year - 1900;
+          vtm.tm_mon      = ts.month - 1;
+          vtm.tm_mday     = ts.day;
+          vtm.tm_hour     = ts.hour;
+          vtm.tm_min      = ts.minute;
+          vtm.tm_sec      = ts.second;
+          int64_t t = (int64_t) mktime(&vtm);
+          if (t==-1) {
+            CHK_CONV(1, TSDB_CONV_NOT_VALID_TS);
+            // code never reached here
           }
-          bind->buffer = bind->u.bin;
+          bind->u.ts  = t * 1000 + ts.fraction / 1000000;
         } break;
-        case SQL_C_CHAR:
         case SQL_C_SHORT:
         case SQL_C_SSHORT:
         case SQL_C_USHORT:
@@ -1618,53 +2037,107 @@ static SQLRETURN do_bind_param_value(sql_t *sql, int idx_row, int idx, param_bin
         case SQL_C_TINYINT:
         case SQL_C_STINYINT:
         case SQL_C_UTINYINT:
-        case SQL_C_SBIGINT:
         case SQL_C_UBIGINT:
+        case SQL_C_BINARY:
         case SQL_C_DATE:
         case SQL_C_TIME:
         case SQL_C_TIMESTAMP:
         case SQL_C_TYPE_DATE:
         case SQL_C_TYPE_TIME:
-        case SQL_C_TYPE_TIMESTAMP:
         case SQL_C_NUMERIC:
         case SQL_C_GUID:
         default: {
           SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_OUT_OF_RANGE,
                     "no convertion from [%s[%d/0x%x]] to [%s[%d/0x%x]] for parameter [%d]",
                     sql_c_type(valueType), valueType, valueType,
-                    taos_data_type(type), type, type, idx+1);
+                    taos_data_type(tsdb_type), tsdb_type, tsdb_type, idx+1);
           return SQL_ERROR;
         } break;
       }
 		} break;
-    case TSDB_DATA_TYPE_TIMESTAMP: {
-      bind->buffer_type = type;
-      bind->buffer_length = sizeof(bind->u.v8);
-      bind->buffer = &bind->u.v8;
+    case TSDB_DATA_TYPE_BINARY: {
+      bind->buffer_type = tsdb_type;
       bind->length = &bind->buffer_length;
       switch (valueType) {
         case SQL_C_WCHAR: {
-          DASSERT(soi);
-          DASSERT(*soi != SQL_NTS);
-          size_t bytes = 0;
-          int r = 0;
-          int64_t t = 0;
-          SQLCHAR *utf8 = wchars_to_chars(paramValue, *soi/2, &bytes);
-          // why cast utf8 to 'char*' ?
-          r = taosParseTime((char*)utf8, &t, strlen((const char*)utf8), TSDB_TIME_PRECISION_MILLI, 0);
-          bind->u.v8 = t;
-          free(utf8);
-          if (r) {
-            SET_ERROR(sql, "22007", TSDB_CODE_ODBC_OUT_OF_RANGE,
-                      "convertion from [%s[%d/0x%x]] to [%s[%d/0x%x]] for parameter [%d] failed",
-                      sql_c_type(valueType), valueType, valueType,
-                      taos_data_type(type), type, type, idx+1);
-            return SQL_ERROR;
+          // taos cares nothing about what would be stored in 'binary' as most sql implementations do
+          // thus, we just copy it as is
+          // it's caller's responsibility to maintain data-consistency
+          // if he/she is going to use 'binary' to store characters
+          // taos might extend it's sql syntax to let user specify
+          // what charset is to be used for specific 'binary' field when
+          // table is to be created
+          // in such way, 'binary' would be 'internationalized'
+          // but actually speaking, normally, 'char' field is a better
+          // one for this purpose
+          size_t slen = (size_t)*soi;
+          DASSERT(slen != SQL_NTS);
+          bind->u.bin = (unsigned char*)malloc(slen + 1); // add null-terminator, just for case of use
+          if (!bind->u.bin) {
+            CHK_CONV(1, TSDB_CONV_OOM);
+            // code never reached here
           }
+          memcpy(bind->u.bin, paramValue, slen);
+          bind->buffer_length = slen;
+          bind->buffer = bind->u.bin;
+          CHK_CONV(1, TSDB_CONV_OK);
+
+          // tsdb_conv_t *utf16_to_server = tsdb_conn_utf16_to_server(conn);
+          // size_t slen = (size_t)*soi;
+          // DASSERT(slen != SQL_NTS);
+          // const char *buf = NULL;
+          // size_t blen = 0;
+          // TSDB_CONV_CODE code = tsdb_conv(utf16_to_server, NULL, (const char *)paramValue, slen, &buf, &blen);
+          // if (code==TSDB_CONV_OK) {
+          //   if (buf!=(const char*)paramValue) {
+          //     bind->allocated = 1;
+          //   }
+          //   bind->u.bin = (unsigned char*)buf;
+          //   bind->buffer_length = blen;
+          //   bind->buffer = bind->u.bin;
+          // }
+          // CHK_CONV(1, code);
         } break;
-        case SQL_C_SBIGINT: {
-          int64_t t = *(int64_t*)paramValue;
-          bind->u.v8 = t;
+        case SQL_C_CHAR: {
+          // taos cares nothing about what would be stored in 'binary' as most sql implementations do
+          // thus, we just copy it as is
+          // it's caller's responsibility to maintain data-consistency
+          // if he/she is going to use 'binary' to store characters
+          // taos might extend it's sql syntax to let user specify
+          // what charset is to be used for specific 'binary' field when
+          // table is to be created
+          // in such way, 'binary' would be 'internationalized'
+          // but actually speaking, normally, 'char' field is a better
+          // one for this purpose
+          size_t slen = (size_t)*soi;
+          if (slen==SQL_NTS) slen = strlen((const char*)paramValue);
+          // we can not use strndup, because ODBC client might pass in a buffer without null-terminated
+          bind->u.bin = (unsigned char*)malloc(slen + 1); // add null-terminator, just for case of use
+          if (!bind->u.bin) {
+            CHK_CONV(1, TSDB_CONV_OOM);
+            // code never reached here
+          }
+          memcpy(bind->u.bin, paramValue, slen);
+          bind->buffer_length = slen;
+          bind->buffer = bind->u.bin;
+          CHK_CONV(1, TSDB_CONV_OK);
+          // code never reached here
+
+          // tsdb_conv_t *client_to_server = tsdb_conn_client_to_server(conn);
+          // size_t slen = (size_t)*soi;
+          // if (slen==SQL_NTS) slen = strlen((const char*)paramValue);
+          // const char *buf = NULL;
+          // size_t blen = 0;
+          // TSDB_CONV_CODE code = tsdb_conv(client_to_server, NULL, (const char *)paramValue, slen, &buf, &blen);
+          // if (code==TSDB_CONV_OK) {
+          //   if (buf!=(const char*)paramValue) {
+          //     bind->allocated = 1;
+          //   }
+          //   bind->u.bin = (unsigned char*)buf;
+          //   bind->buffer_length = blen;
+          //   bind->buffer = bind->u.bin;
+          // }
+          // CHK_CONV(1, code);
         } break;
         case SQL_C_SHORT:
         case SQL_C_SSHORT:
@@ -1678,6 +2151,7 @@ static SQLRETURN do_bind_param_value(sql_t *sql, int idx_row, int idx, param_bin
         case SQL_C_TINYINT:
         case SQL_C_STINYINT:
         case SQL_C_UTINYINT:
+        case SQL_C_SBIGINT:
         case SQL_C_UBIGINT:
         case SQL_C_BINARY:
         case SQL_C_DATE:
@@ -1685,40 +2159,55 @@ static SQLRETURN do_bind_param_value(sql_t *sql, int idx_row, int idx, param_bin
         case SQL_C_TIMESTAMP:
         case SQL_C_TYPE_DATE:
         case SQL_C_TYPE_TIME:
-        case SQL_C_TYPE_TIMESTAMP:
+        case SQL_C_TYPE_TIMESTAMP: // we don't provide auto-converstion
         case SQL_C_NUMERIC:
         case SQL_C_GUID:
         default: {
           SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_OUT_OF_RANGE,
                     "no convertion from [%s[%d/0x%x]] to [%s[%d/0x%x]] for parameter [%d]",
                     sql_c_type(valueType), valueType, valueType,
-                    taos_data_type(type), type, type, idx+1);
+                    taos_data_type(tsdb_type), tsdb_type, tsdb_type, idx+1);
           return SQL_ERROR;
         } break;
       }
 		} break;
     case TSDB_DATA_TYPE_NCHAR: {
-      bind->buffer_type = type;
+      bind->buffer_type = tsdb_type;
       bind->length = &bind->buffer_length;
       switch (valueType) {
         case SQL_C_WCHAR: {
-          DASSERT(soi);
-          DASSERT(*soi != SQL_NTS);
-          size_t bytes = 0;
-          SQLCHAR *utf8 = wchars_to_chars(paramValue, *soi/2, &bytes);
-          bind->allocated = 1;
-          bind->u.nchar = (char*)utf8;
-          bind->buffer_length = bytes;
-          bind->buffer = bind->u.nchar;
+          tsdb_conv_t *utf16_to_server = tsdb_conn_utf16_to_server(conn);
+          size_t slen = (size_t)*soi;
+          if (slen==SQL_NTS) slen = strlen((const char*)paramValue);
+          const char *buf = NULL;
+          size_t blen = 0;
+          TSDB_CONV_CODE code = tsdb_conv(utf16_to_server, NULL, (const char *)paramValue, slen, &buf, &blen);
+          if (code==TSDB_CONV_OK) {
+            if (buf!=(const char*)paramValue) {
+              bind->allocated = 1;
+            }
+            bind->u.nchar = (char*)buf;
+            bind->buffer_length = blen;
+            bind->buffer = bind->u.nchar;
+          }
+          CHK_CONV(1, code);
         } break;
         case SQL_C_CHAR: {
-          bind->u.nchar = (char*)paramValue;
-          if (*soi == SQL_NTS) {
-            bind->buffer_length = strlen((const char*)paramValue);
-          } else {
-            bind->buffer_length = *soi;
+          tsdb_conv_t *client_to_server = tsdb_conn_client_to_server(conn);
+          size_t slen = (size_t)*soi;
+          if (slen==SQL_NTS) slen = strlen((const char*)paramValue);
+          const char *buf = NULL;
+          size_t blen = 0;
+          TSDB_CONV_CODE code = tsdb_conv(client_to_server, NULL, (const char *)paramValue, slen, &buf, &blen);
+          if (code==TSDB_CONV_OK) {
+            if (buf!=(const char*)paramValue) {
+              bind->allocated = 1;
+            }
+            bind->u.bin = (unsigned char*)buf;
+            bind->buffer_length = blen;
+            bind->buffer = bind->u.bin;
           }
-          bind->buffer = bind->u.nchar;
+          CHK_CONV(1, code);
         } break;
         case SQL_C_SHORT:
         case SQL_C_SSHORT:
@@ -1740,14 +2229,14 @@ static SQLRETURN do_bind_param_value(sql_t *sql, int idx_row, int idx, param_bin
         case SQL_C_TIMESTAMP:
         case SQL_C_TYPE_DATE:
         case SQL_C_TYPE_TIME:
-        case SQL_C_TYPE_TIMESTAMP:
+        case SQL_C_TYPE_TIMESTAMP: // we don't provide auto-converstion
         case SQL_C_NUMERIC:
         case SQL_C_GUID:
         default: {
           SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_OUT_OF_RANGE,
                     "no convertion from [%s[%d/0x%x]] to [%s[%d/0x%x]] for parameter [%d]",
                     sql_c_type(valueType), valueType, valueType,
-                    taos_data_type(type), type, type, idx+1);
+                    taos_data_type(tsdb_type), tsdb_type, tsdb_type, idx+1);
           return SQL_ERROR;
         } break;
       }
@@ -1756,7 +2245,7 @@ static SQLRETURN do_bind_param_value(sql_t *sql, int idx_row, int idx, param_bin
       SET_ERROR(sql, "HYC00", TSDB_CODE_ODBC_OUT_OF_RANGE,
                 "no convertion from [%s[%d/0x%x]] to [%s[%d/0x%x]] for parameter [%d]",
                 sql_c_type(valueType), valueType, valueType,
-                taos_data_type(type), type, type, idx+1);
+                taos_data_type(tsdb_type), tsdb_type, tsdb_type, idx+1);
       return SQL_ERROR;
     } break;
   }
@@ -1797,7 +2286,7 @@ static SQLRETURN do_execute(sql_t *sql)
   for (int i=0; i<sql->n_rows; ++i) {
     TAOS_BIND *binds       = NULL;
     if (sql->n_params>0) {
-      binds = (TAOS_BIND*)calloc(sql->n_params, sizeof(*binds));
+      binds = (TAOS_BIND*)calloc((size_t)sql->n_params, sizeof(*binds));
       if (!binds) {
         SET_ERROR(sql, "HY001", TSDB_CODE_ODBC_OOM, "");
         return SQL_ERROR;
@@ -1827,7 +2316,7 @@ static SQLRETURN do_execute(sql_t *sql)
   }
 
   sql->is_executed = 1;
-  if (sql->is_insert) return SQL_SUCCESS;
+  // if (sql->is_insert) return SQL_SUCCESS;
 
   SQLRETURN r = SQL_SUCCESS;
   PROFILE(sql->rs = taos_stmt_use_result(sql->stmt));
@@ -1872,8 +2361,12 @@ static SQLRETURN doSQLGetDiagField(SQLSMALLINT HandleType, SQLHANDLE Handle,
                                    SQLPOINTER DiagInfo, SQLSMALLINT BufferLength,
                                    SQLSMALLINT *StringLength)
 {
-  // if this function is not exported, isql will never call SQLGetDiagRec
-  return SQL_ERROR;
+  switch (DiagIdentifier) {
+    case SQL_DIAG_CLASS_ORIGIN: {
+      *StringLength = 0;
+    } break;
+  }
+  return SQL_SUCCESS;
 }
 
 SQLRETURN SQL_API SQLGetDiagField(SQLSMALLINT HandleType, SQLHANDLE Handle,
@@ -1949,7 +2442,7 @@ static SQLRETURN doSQLBindParameter(
     SQLLEN 		      *StrLen_or_Ind)
 {
   sql_t *sql = (sql_t*)StatementHandle;
-  if (!sql) return SQL_ERROR;
+  if (!sql) return SQL_INVALID_HANDLE;
 
   CHK_CONN(sql);
   CHK_CONN_TAOS(sql);
@@ -1989,6 +2482,16 @@ static SQLRETURN doSQLBindParameter(
     return SQL_ERROR;
   }
 
+  if (ParameterValue==NULL) {
+    SET_ERROR(sql, "HY009", TSDB_CODE_ODBC_BAD_ARG, "ParameterValue [@%p] not allowed", ParameterValue);
+    return SQL_ERROR;
+  }
+
+  if (StrLen_or_Ind==NULL) {
+    SET_ERROR(sql, "HY009", TSDB_CODE_ODBC_BAD_ARG, "StrLen_or_Ind [@%p] not allowed", StrLen_or_Ind);
+    return SQL_ERROR;
+  }
+
   param_bind_t *pb = sql->params + ParameterNumber - 1;
 
   pb->ParameterNumber      = ParameterNumber;
@@ -2032,26 +2535,25 @@ static SQLRETURN doSQLDriverConnect(
     SQLUSMALLINT       fDriverCompletion)
 {
   conn_t *conn = (conn_t*)hdbc;
-  if (!conn) return SQL_ERROR;
+  if (!conn) return SQL_INVALID_HANDLE;
 
-  if (fDriverCompletion!=SQL_DRIVER_NOPROMPT) {
-    SET_ERROR(conn, "HYC00", TSDB_CODE_ODBC_NOT_SUPPORT, "option[%d] other than SQL_DRIVER_NOPROMPT not supported yet", fDriverCompletion);
+  if (conn->taos) {
+    SET_ERROR(conn, "08002", TSDB_CODE_ODBC_CONNECTION_BUSY, "connection still in use");
     return SQL_ERROR;
   }
 
-  if (conn->taos) {
-    SET_ERROR(conn, "08002", TSDB_CODE_ODBC_CONNECTION_BUSY, "connection still in use");
+  if (fDriverCompletion!=SQL_DRIVER_NOPROMPT) {
+    SET_ERROR(conn, "HYC00", TSDB_CODE_ODBC_NOT_SUPPORT, "option[%d] other than SQL_DRIVER_NOPROMPT not supported yet", fDriverCompletion);
     return SQL_ERROR;
   }
 
+  NORM_STR_LENGTH(conn, szConnStrIn, cbConnStrIn);
+
   // DSN=<dsn>; UID=<uid>; PWD=<pwd>
 
   const char *connStr    = SDUP(szConnStrIn, cbConnStrIn);
 
-  char *serverName = NULL;
-  char *userName   = NULL;
-  char *auth       = NULL;
-  int bytes = 0;
+  conn_val_t val   = {0};
 
   do {
     if (szConnStrIn && !connStr) {
@@ -2059,32 +2561,52 @@ static SQLRETURN doSQLDriverConnect(
       break;
     }
 
-    int n = sscanf((const char*)connStr, "DSN=%m[^;]; UID=%m[^;]; PWD=%m[^;] %n", &serverName, &userName, &auth, &bytes);
-    if (n<1) {
+    int n = todbc_parse_conn_string((const char *)connStr, &val);
+    if (n) {
       SET_ERROR(conn, "HY000", TSDB_CODE_ODBC_BAD_CONNSTR, "unrecognized connection string: [%s]", (const char*)szConnStrIn);
       break;
     }
+    char *ip         = NULL;
+    int   port       = 0;
+    if (val.server) {
+      char *p = strchr(val.server, ':');
+      if (p) {
+        ip = strndup(val.server, (size_t)(p-val.server));
+        port = atoi(p+1);
+      }
+    }
+
+    if ((val.cli_enc && strcmp(val.cli_enc, conn->client_enc)) ||
+        (val.svr_enc && strcmp(val.svr_enc, conn->server_enc)) )
+    {
+      tsdb_conn_close_convs(conn);
+      if (val.cli_enc) {
+        snprintf(conn->client_enc, sizeof(conn->client_enc), "%s", val.cli_enc);
+      }
+      if (val.svr_enc) {
+        snprintf(conn->server_enc, sizeof(conn->server_enc), "%s", val.svr_enc);
+      }
+    }
 
     // TODO: data-race
     // TODO: shall receive ip/port from odbc.ini
-    conn->taos = taos_connect("localhost", userName, auth, NULL, 0);
+    // shall we support non-ansi uid/pwd/db etc?
+    conn->taos = taos_connect(ip ? ip : "localhost", val.uid, val.pwd, val.db, (uint16_t)port);
+    free(ip); ip = NULL;
     if (!conn->taos) {
       SET_ERROR(conn, "HY000", terrno, "failed to connect to data source");
       break;
     }
 
     if (szConnStrOut) {
-      snprintf((char*)szConnStrOut, cbConnStrOutMax, "%s", connStr);
+      snprintf((char*)szConnStrOut, (size_t)cbConnStrOutMax, "%s", connStr);
     }
     if (pcbConnStrOut) {
       *pcbConnStrOut = cbConnStrIn;
     }
-
   } while (0);
 
-  if (serverName) free(serverName);
-  if (userName)   free(userName);
-  if (auth)       free(auth);
+  conn_val_reset(&val);
 
   SFRE(connStr, szConnStrIn,     cbConnStrIn);
 
@@ -2111,7 +2633,7 @@ static SQLRETURN doSQLSetConnectAttr(SQLHDBC ConnectionHandle,
                                      SQLINTEGER StringLength)
 {
   conn_t *conn = (conn_t*)ConnectionHandle;
-  if (!conn) return SQL_ERROR;
+  if (!conn) return SQL_INVALID_HANDLE;
 
   if (Attribute != SQL_ATTR_AUTOCOMMIT) {
     SET_ERROR(conn, "HYC00", TSDB_CODE_ODBC_NOT_SUPPORT, "Attribute other than SQL_ATTR_AUTOCOMMIT not supported yet");
@@ -2141,7 +2663,7 @@ static SQLRETURN doSQLDescribeCol(SQLHSTMT StatementHandle,
                                   SQLSMALLINT *DecimalDigits, SQLSMALLINT *Nullable)
 {
   sql_t *sql = (sql_t*)StatementHandle;
-  if (!sql) return SQL_ERROR;
+  if (!sql) return SQL_INVALID_HANDLE;
 
   CHK_CONN(sql);
   CHK_CONN_TAOS(sql);
@@ -2158,19 +2680,21 @@ static SQLRETURN doSQLDescribeCol(SQLHSTMT StatementHandle,
     SET_ERROR(sql, "07009", TSDB_CODE_ODBC_OUT_OF_RANGE, "invalid column number [%d]", ColumnNumber);
     return SQL_ERROR;
   }
+  if (BufferLength<0) {
+    SET_ERROR(sql, "HY090", TSDB_CODE_ODBC_BAD_ARG, "");
+    return SQL_ERROR;
+  }
 
   TAOS_FIELD *field = fields + ColumnNumber - 1;
   if (ColumnName) {
     size_t n = sizeof(field->name);
-    if (n>BufferLength) n = BufferLength;
+    if (n>BufferLength) n = (size_t)BufferLength;
     strncpy((char*)ColumnName, field->name, n);
   }
   if (NameLength) {
-    *NameLength = strnlen(field->name, sizeof(field->name));
-  }
-  if (ColumnSize) {
-    *ColumnSize = field->bytes;
+    *NameLength = (SQLSMALLINT)strnlen(field->name, sizeof(field->name));
   }
+  if (ColumnSize) *ColumnSize = (SQLULEN)field->bytes;
   if (DecimalDigits) *DecimalDigits = 0;
 
   if (DataType) {
@@ -2204,12 +2728,9 @@ static SQLRETURN doSQLDescribeCol(SQLHSTMT StatementHandle,
       } break;
 
       case TSDB_DATA_TYPE_TIMESTAMP: {
-        // *DataType = SQL_TIMESTAMP;
-        // *ColumnSize = 30;
-        // *DecimalDigits = 3;
         *DataType = SQL_TIMESTAMP;
-        *ColumnSize = sizeof(SQL_TIMESTAMP_STRUCT);
-        *DecimalDigits = 0;
+        if (ColumnSize) *ColumnSize = sizeof(SQL_TIMESTAMP_STRUCT);
+        if (DecimalDigits) *DecimalDigits = 0;
       } break;
 
       case TSDB_DATA_TYPE_NCHAR: {
@@ -2218,7 +2739,7 @@ static SQLRETURN doSQLDescribeCol(SQLHSTMT StatementHandle,
       } break;
 
       case TSDB_DATA_TYPE_BINARY: {
-        *DataType = SQL_BINARY;
+        *DataType = SQL_CHAR;
         if (ColumnSize) *ColumnSize -= VARSTR_HEADER_SIZE;
       } break;
 
@@ -2253,7 +2774,7 @@ SQLRETURN SQL_API SQLDescribeCol(SQLHSTMT StatementHandle,
 static SQLRETURN doSQLNumParams(SQLHSTMT hstmt, SQLSMALLINT *pcpar)
 {
   sql_t *sql = (sql_t*)hstmt;
-  if (!sql) return SQL_ERROR;
+  if (!sql) return SQL_INVALID_HANDLE;
 
   CHK_CONN(sql);
   CHK_CONN_TAOS(sql);
@@ -2281,7 +2802,7 @@ static SQLRETURN doSQLNumParams(SQLHSTMT hstmt, SQLSMALLINT *pcpar)
     return SQL_ERROR;
   }
 
-  if (pcpar) *pcpar = params;
+  if (pcpar) *pcpar = (SQLSMALLINT)params;
 
   return SQL_SUCCESS;
 }
@@ -2298,7 +2819,7 @@ static SQLRETURN doSQLSetStmtAttr(SQLHSTMT StatementHandle,
                                   SQLINTEGER StringLength)
 {
   sql_t *sql = (sql_t*)StatementHandle;
-  if (!sql) return SQL_ERROR;
+  if (!sql) return SQL_INVALID_HANDLE;
 
   CHK_CONN(sql);
   CHK_CONN_TAOS(sql);
@@ -2355,1126 +2876,296 @@ SQLRETURN SQL_API SQLSetStmtAttr(SQLHSTMT StatementHandle,
   return r;
 }
 
+#ifdef _MSC_VER
+
+#define POST_INSTALLER_ERROR(hwndParent, code, fmt, ...)             \
+do {                                                                 \
+  char buf[4096];                                                    \
+  snprintf(buf, sizeof(buf), "%s[%d]%s():" fmt "",                   \
+           basename((char*)__FILE__), __LINE__, __func__,            \
+           ##__VA_ARGS__);                                           \
+  SQLPostInstallerError(code, buf);                                  \
+  if (hwndParent) {                                                  \
+    MessageBox(hwndParent, buf, "Error", MB_OK|MB_ICONEXCLAMATION);  \
+  }                                                                  \
+} while (0)
 
+typedef struct kv_s           kv_t;
+struct kv_s {
+  char    *line;
+  size_t   val;
+};
 
+static BOOL get_driver_dll_path(HWND hwndParent, char *buf, size_t len)
+{
+  HMODULE hm = NULL;
 
-static void init_routine(void) {
-  if (0) {
-    string_conv(NULL, NULL, NULL, 0, NULL, 0, NULL, NULL);
-    utf8_to_ucs4le(NULL, NULL);
-    ucs4le_to_utf8(NULL, 0, NULL);
+  if (GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
+          (LPCSTR) &ConfigDSN, &hm) == 0)
+  {
+      int ret = GetLastError();
+      POST_INSTALLER_ERROR(hwndParent, ODBC_ERROR_REQUEST_FAILED, "GetModuleHandle failed, error = %d\n", ret);
+      return FALSE;
   }
-  taos_init();
+  if (GetModuleFileName(hm, buf, (DWORD)len) == 0)
+  {
+      int ret = GetLastError();
+      POST_INSTALLER_ERROR(hwndParent, ODBC_ERROR_REQUEST_FAILED, "GetModuleFileName failed, error = %d\n", ret);
+      return FALSE;
+  }
+  return TRUE;
 }
 
-static int do_field_display_size(TAOS_FIELD *field) {
-  switch (field->type) {
-    case TSDB_DATA_TYPE_TINYINT:
-      return 5;
-      break;
+static BOOL doDSNAdd(HWND	hwndParent, LPCSTR	lpszDriver, LPCSTR lpszAttributes)
+{
+  BOOL r = TRUE;
 
-    case TSDB_DATA_TYPE_SMALLINT:
-      return 7;
-      break;
+  kv_t *kvs = NULL;
 
-    case TSDB_DATA_TYPE_INT:
-      return 12;
-      break;
+  kv_t dsn = {0};
+  char *line = NULL;
 
-    case TSDB_DATA_TYPE_BIGINT:
-      return 22;
-      break;
+  do {
+    char driver_dll[MAX_PATH + 1];
+    r = get_driver_dll_path(hwndParent, driver_dll, sizeof(driver_dll));
+    if (!r) break;
+
+    dsn.line = strdup("DSN=TAOS_DEMO");
+    if (!dsn.line) { r = FALSE; break; }
+
+    const char *p = lpszAttributes;
+    int ikvs = 0;
+    while (p && *p) {
+      line = strdup(p);
+      if (!line) { r = FALSE; break; }
+      char *v = strchr(line, '=');
+      if (!v) { r = FALSE; break; }
+
+      if (strstr(line, "DSN")==line) {
+        if (dsn.line) {
+          free(dsn.line);
+          dsn.line = NULL;
+          dsn.val  = 0;
+        }
+        dsn.line = line;
+        line = NULL;
+      } else {
+        kv_t *t = (kv_t*)realloc(kvs, (ikvs+1)*sizeof(*t));
+        if (!t) { r = FALSE; free(line); break; }
+        t[ikvs].line = line;
+        *v = '\0';
+        if (v) t[ikvs].val = v - line + 1;
+        line = NULL;
+
+        kvs = t;
+        ++ikvs;
+      }
 
-    case TSDB_DATA_TYPE_FLOAT: {
-      return 12;
-    } break;
+      p += strlen(p) + 1;
+    }
 
-    case TSDB_DATA_TYPE_DOUBLE: {
-      return 20;
-    } break;
+    if (hwndParent) {
+      MessageBox(hwndParent, "Please use odbcconf to add DSN for TAOS ODBC Driver", "Warning!", MB_OK|MB_ICONEXCLAMATION);
+    }
+    if (!r) break;
+
+    char *v = NULL;
+    v = strchr(dsn.line, '=');
+    if (!v) { r = FALSE; break; }
+    *v = '\0';
+    dsn.val = v - dsn.line + 1;
+
+    if ((!dsn.line)) {
+      if (!r) POST_INSTALLER_ERROR(hwndParent, ODBC_ERROR_REQUEST_FAILED, "lack of either DSN or Driver");
+    } else {
+      if (r) r = SQLWritePrivateProfileString("ODBC Data Sources", dsn.line+dsn.val, lpszDriver, "Odbc.ini");
+      if (r) r = SQLWritePrivateProfileString(dsn.line+dsn.val, "Driver", driver_dll, "Odbc.ini");
+    }
 
-    case TSDB_DATA_TYPE_BINARY:
-    case TSDB_DATA_TYPE_NCHAR: {
-      return 3*(field->bytes - VARSTR_HEADER_SIZE) + 2;
-    } break;
-
-    case TSDB_DATA_TYPE_TIMESTAMP:
-      return 26;
-      break;
-
-    case TSDB_DATA_TYPE_BOOL:
-      return 7;
-    default:
-      break;
-  }
-
-  return 10;
-}
-
-// convertion from TSDB_DATA_TYPE_XXX to SQL_C_XXX
-static SQLRETURN conv_tsdb_bool_to_c_bit(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b)
-{
-  int8_t v = b;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_bool_to_c_tinyint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b)
-{
-  int8_t v = b;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_bool_to_c_short(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b)
-{
-  int16_t v = b;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_bool_to_c_long(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b)
-{
-  int32_t v = b;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_bool_to_c_sbigint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b)
-{
-  int64_t v = b;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_bool_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b)
-{
-  float v = b;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_bool_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b)
-{
-  double v = b;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_bool_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b)
-{
-  DASSERT(target->len>0);
-  *target->soi = 1;
-  target->ptr[0] = '0' + b;
-  if (target->len>1) {
-    target->ptr[1] = '\0';
-  }
-
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_bool_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t b)
-{
-  DASSERT(target->len>0);
-  *target->soi = 1;
-  target->ptr[0] = '0' + b;
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_v1_to_c_tinyint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1)
-{
-  int8_t v = v1;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_v1_to_c_short(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1)
-{
-  int16_t v = v1;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_v1_to_c_long(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1)
-{
-  int32_t v = v1;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_v1_to_c_sbigint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1)
-{
-  int64_t v = v1;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_v1_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1)
-{
-  float v = v1;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_v1_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1)
-{
-  double v = v1;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_v1_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1)
-{
-  char buf[64];
-  int n = snprintf(buf, sizeof(buf), "%d", v1);
-  DASSERT(n<sizeof(buf));
-  *target->soi = n;
-  strncpy(target->ptr, buf, (n>=target->len ? target->len : n+1));
-  if (n<=target->len) return SQL_SUCCESS;
-  SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_TINYINT -> SQL_C_BIT");
-  return SQL_SUCCESS_WITH_INFO;
-}
-
-static SQLRETURN conv_tsdb_v1_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int8_t v1)
-{
-  char buf[64];
-  int n = snprintf(buf, sizeof(buf), "%d", v1);
-  DASSERT(n<sizeof(buf));
-  *target->soi = n;
-  strncpy(target->ptr, buf, (n>target->len ? target->len : n));
-  if (n<=target->len) return SQL_SUCCESS;
-  SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_TINYINT -> SQL_C_BIT");
-  return SQL_SUCCESS_WITH_INFO;
-}
-
-static SQLRETURN conv_tsdb_v2_to_c_short(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2)
-{
-  int16_t v = v2;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_v2_to_c_long(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2)
-{
-  int32_t v = v2;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_v2_to_c_sbigint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2)
-{
-  int64_t v = v2;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_v2_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2)
-{
-  float v = v2;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_v2_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2)
-{
-  double v = v2;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_v2_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2)
-{
-  char buf[64];
-  int n = snprintf(buf, sizeof(buf), "%d", v2);
-  DASSERT(n<sizeof(buf));
-  *target->soi = n;
-  strncpy(target->ptr, buf, (n>=target->len ? target->len : n+1));
-  if (n<=target->len) return SQL_SUCCESS;
-  SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_SMALLINT -> SQL_C_CHAR");
-  return SQL_SUCCESS_WITH_INFO;
-}
-
-static SQLRETURN conv_tsdb_v2_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int16_t v2)
-{
-  char buf[64];
-  int n = snprintf(buf, sizeof(buf), "%d", v2);
-  DASSERT(n<sizeof(buf));
-  *target->soi = n;
-  strncpy(target->ptr, buf, (n>target->len ? target->len : n));
-  if (n<=target->len) return SQL_SUCCESS;
-  SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_SMALLINT -> SQL_C_CHAR");
-  return SQL_SUCCESS_WITH_INFO;
-}
-
-
-static SQLRETURN conv_tsdb_v4_to_c_long(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4)
-{
-  int32_t v = v4;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_v4_to_c_sbigint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4)
-{
-  int64_t v = v4;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_v4_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4)
-{
-  float v = v4;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_v4_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4)
-{
-  double v = v4;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_v4_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4)
-{
-  char buf[64];
-  int n = snprintf(buf, sizeof(buf), "%d", v4);
-  DASSERT(n<sizeof(buf));
-  *target->soi = n;
-  strncpy(target->ptr, buf, (n>=target->len ? target->len : n+1));
-  if (n<=target->len) return SQL_SUCCESS;
-  SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_INTEGER -> SQL_C_CHAR");
-  return SQL_SUCCESS_WITH_INFO;
-}
-
-static SQLRETURN conv_tsdb_v4_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int32_t v4)
-{
-  char buf[64];
-  int n = snprintf(buf, sizeof(buf), "%d", v4);
-  DASSERT(n<sizeof(buf));
-  *target->soi = n;
-  strncpy(target->ptr, buf, (n>target->len ? target->len : n));
-  if (n<=target->len) return SQL_SUCCESS;
-  SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_INTEGER -> SQL_C_BINARY");
-  return SQL_SUCCESS_WITH_INFO;
-}
-
-
-static SQLRETURN conv_tsdb_v8_to_c_sbigint(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int64_t v8)
-{
-  int64_t v = v8;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_v8_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int64_t v8)
-{
-  float v = v8;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_v8_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int64_t v8)
-{
-  double v = v8;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_v8_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int64_t v8)
-{
-  char buf[64];
-  int n = snprintf(buf, sizeof(buf), "%" PRId64 "", v8);
-  DASSERT(n<sizeof(buf));
-  *target->soi = n;
-  strncpy(target->ptr, buf, (n>=target->len ? target->len : n+1));
-  if (n<=target->len) return SQL_SUCCESS;
-  SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_BIGINT -> SQL_C_CHAR");
-  return SQL_SUCCESS_WITH_INFO;
-}
-
-static SQLRETURN conv_tsdb_v8_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, int64_t v8)
-{
-  char buf[64];
-  int n = snprintf(buf, sizeof(buf), "%" PRId64 "", v8);
-  DASSERT(n<sizeof(buf));
-  *target->soi = n;
-  strncpy(target->ptr, buf, (n>target->len ? target->len : n));
-  if (n<=target->len) return SQL_SUCCESS;
-  SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_BIGINT -> SQL_C_BINARY");
-  return SQL_SUCCESS_WITH_INFO;
-}
-
-
-static SQLRETURN conv_tsdb_f4_to_c_float(sql_t *sql, c_target_t *target, TAOS_FIELD *field, float f4)
-{
-  float v = f4;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_f4_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, float f4)
-{
-  double v = f4;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_f4_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, float f4)
-{
-  char buf[64];
-  int n = snprintf(buf, sizeof(buf), "%g", f4);
-  DASSERT(n<sizeof(buf));
-  *target->soi = n;
-  strncpy(target->ptr, buf, (n>=target->len ? target->len : n+1));
-  if (n<=target->len) return SQL_SUCCESS;
-  SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_FLOAT -> SQL_C_CHAR");
-  return SQL_SUCCESS_WITH_INFO;
-}
-
-static SQLRETURN conv_tsdb_f4_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, float f4)
-{
-  char buf[64];
-  int n = snprintf(buf, sizeof(buf), "%g", f4);
-  DASSERT(n<sizeof(buf));
-  *target->soi = n;
-  strncpy(target->ptr, buf, (n>target->len ? target->len : n));
-  if (n<=target->len) return SQL_SUCCESS;
-  SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_FLOAT -> SQL_C_BINARY");
-  return SQL_SUCCESS_WITH_INFO;
-}
-
-
-static SQLRETURN conv_tsdb_f8_to_c_double(sql_t *sql, c_target_t *target, TAOS_FIELD *field, double f8)
-{
-  double v = f8;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_f8_to_c_char(sql_t *sql, c_target_t *target, TAOS_FIELD *field, double f8)
-{
-  char buf[64];
-  int n = snprintf(buf, sizeof(buf), "%.6f", f8);
-  DASSERT(n<sizeof(buf));
-  *target->soi = n;
-  strncpy(target->ptr, buf, (n>=target->len ? target->len : n+1));
-  if (n<=target->len) return SQL_SUCCESS;
-  SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_DOUBLE -> SQL_C_CHAR");
-  return SQL_SUCCESS_WITH_INFO;
-}
-
-static SQLRETURN conv_tsdb_f8_to_c_binary(sql_t *sql, c_target_t *target, TAOS_FIELD *field, double f8)
-{
-  char buf[64];
-  int n = snprintf(buf, sizeof(buf), "%g", f8);
-  DASSERT(n<sizeof(buf));
-  *target->soi = n;
-  strncpy(target->ptr, buf, (n>target->len ? target->len : n));
-  if (n<=target->len) return SQL_SUCCESS;
-  SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_DOUBLE -> SQL_C_BINARY");
-  return SQL_SUCCESS_WITH_INFO;
-}
-
-
-static SQLRETURN conv_tsdb_ts_to_c_v8(sql_t *sql, c_target_t *target, TAOS_FIELD *field, SQL_TIMESTAMP_STRUCT *ts)
-{
-  struct tm tm = {0};
-  tm.tm_sec        = ts->second;
-  tm.tm_min        = ts->minute;
-  tm.tm_hour       = ts->hour;
-  tm.tm_mday       = ts->day;
-  tm.tm_mon        = ts->month - 1;
-  tm.tm_year       = ts->year - 1900;
-  time_t t = mktime(&tm);
-  DASSERT(sizeof(t) == sizeof(int64_t));
-  int64_t v = (int64_t)t;
-  v *= 1000;
-  v += ts->fraction / 1000000;
-  memcpy(target->ptr, &v, sizeof(v));
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_ts_to_c_str(sql_t *sql, c_target_t *target, TAOS_FIELD *field, SQL_TIMESTAMP_STRUCT *ts)
-{
-  struct tm tm = {0};
-  tm.tm_sec        = ts->second;
-  tm.tm_min        = ts->minute;
-  tm.tm_hour       = ts->hour;
-  tm.tm_mday       = ts->day;
-  tm.tm_mon        = ts->month - 1;
-  tm.tm_year       = ts->year - 1900;
-
-  char buf[64];
-  int n = strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", &tm);
-  DASSERT(n < sizeof(buf));
-
-  *target->soi = n;
-
-  unsigned int fraction = ts->fraction;
-  fraction /= 1000000;
-  snprintf(target->ptr, target->len, "%s.%03d", buf, fraction);
-  if (target->soi) *target->soi = strlen((const char*)target->ptr);
-
-  if (n <= target->len) {
-    return SQL_SUCCESS;
-  }
-
-  SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_TIMESTAMP -> SQL_C_CHAR");
-  return SQL_SUCCESS_WITH_INFO;
-}
-
-static SQLRETURN conv_tsdb_ts_to_c_bin(sql_t *sql, c_target_t *target, TAOS_FIELD *field, SQL_TIMESTAMP_STRUCT *ts)
-{
-  struct tm tm = {0};
-  tm.tm_sec        = ts->second;
-  tm.tm_min        = ts->minute;
-  tm.tm_hour       = ts->hour;
-  tm.tm_mday       = ts->day;
-  tm.tm_mon        = ts->month - 1;
-  tm.tm_year       = ts->year - 1900;
-
-  char buf[64];
-  int n = strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", &tm);
-  DASSERT(n < sizeof(buf));
-
-  unsigned int fraction = ts->fraction;
-  fraction /= 1000000;
-  snprintf(target->ptr, target->len, "%s.%03d", buf, fraction);
-  if (target->soi) *target->soi = strlen((const char*)target->ptr);
-
-  if (n <= target->len) {
-    return SQL_SUCCESS;
-  }
-
-  SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_TIMESTAMP -> SQL_C_BINARY");
-  return SQL_SUCCESS_WITH_INFO;
-}
-
-static SQLRETURN conv_tsdb_ts_to_c_ts(sql_t *sql, c_target_t *target, TAOS_FIELD *field, SQL_TIMESTAMP_STRUCT *ts)
-{
-  DASSERT(target->len == sizeof(*ts));
-  memcpy(target->ptr, ts, sizeof(*ts));
-  *target->soi = target->len;
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_bin_to_c_str(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const unsigned char *bin)
-{
-  if (target->len<1) {
-    SET_ERROR(sql, "HY090", TSDB_CODE_ODBC_BAD_ARG, "");
-    return SQL_ERROR;
-  }
-  size_t field_bytes = field->bytes - VARSTR_HEADER_SIZE;
-  size_t n = strnlen((const char*)bin, field_bytes);
-
-  if (n < target->len) {
-    memcpy(target->ptr, bin, n);
-    target->ptr[n] = '\0';
-    *target->soi = n;
-    return SQL_SUCCESS;
-  }
-  n = target->len - 1;
-  *target->soi = n;
-  if (n > 0) {
-    memcpy(target->ptr, bin, n-1);
-    target->ptr[n-1] = '\0';
-  }
-  SET_ERROR(sql, "01004", TSDB_CODE_ODBC_CONV_TRUNC, "");
-  return SQL_SUCCESS_WITH_INFO;
-}
-
-static SQLRETURN conv_tsdb_bin_to_c_bin(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const unsigned char *bin)
-{
-  if (target->len<1) {
-    SET_ERROR(sql, "HY090", TSDB_CODE_ODBC_BAD_ARG, "");
-    return SQL_ERROR;
-  }
-  size_t field_bytes = field->bytes - VARSTR_HEADER_SIZE;
-  size_t n = strnlen((const char*)bin, field_bytes);
-
-  if (n <= target->len) {
-    memcpy(target->ptr, bin, n);
-    if (n<target->len) target->ptr[n] = '\0';
-    *target->soi = n;
-    return SQL_SUCCESS;
-  }
-
-  n = target->len;
-  memcpy(target->ptr, bin, n);
-  *target->soi = n;
-  SET_ERROR(sql, "01004", TSDB_CODE_ODBC_CONV_TRUNC, "");
-  return SQL_SUCCESS_WITH_INFO;
-}
-
-static SQLRETURN conv_tsdb_str_to_c_bit(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str)
-{
-  int bytes = 0;
-  double f8 = 0;
-  int n = sscanf(str, "%lf%n", &f8, &bytes);
-
-  int8_t v = f8;
-  memcpy(target->ptr, &v, sizeof(v));
-
-  *target->soi = 1;
-
-  if (n!=1 || bytes!=strlen(str)) {
-    SET_ERROR(sql, "22018", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_BIT");
-    return SQL_SUCCESS_WITH_INFO;
-  }
-
-  char buf[64];
-  snprintf(buf, sizeof(buf), "%d", v);
-
-  if (strcmp(buf, str)==0) {
-    if (v==0 || v==1) return SQL_SUCCESS;
-    SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_BIT");
-    return SQL_SUCCESS_WITH_INFO;
-  }
-
-  if (f8>0 || f8<2) {
-    SET_ERROR(sql, "01S07", TSDB_CODE_ODBC_CONV_TRUNC, "TSDB_DATA_TYPE_NCHAR -> SQL_C_BIT");
-    return SQL_SUCCESS_WITH_INFO;
-  }
-
-  if (f8<0 || f8>2) {
-    SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_BIT");
-    return SQL_SUCCESS_WITH_INFO;
-  }
-
-  SET_ERROR(sql, "01S07", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_BIT");
-  return SQL_SUCCESS_WITH_INFO;
-}
-
-static SQLRETURN conv_tsdb_str_to_c_v1(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str)
-{
-  int bytes = 0;
-  double f8 = 0;
-  int n = sscanf(str, "%lf%n", &f8, &bytes);
-
-  int8_t v = f8;
-  memcpy(target->ptr, &v, sizeof(v));
-
-  *target->soi = 1;
-
-  if (n!=1 || bytes!=strlen(str)) {
-    SET_ERROR(sql, "22018", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_TINYINT");
-    return SQL_SUCCESS_WITH_INFO;
-  }
-
-  char buf[64];
-  snprintf(buf, sizeof(buf), "%d", v);
-
-  if (strcmp(buf, str)==0) return SQL_SUCCESS;
+    for (int i=0; r && i<ikvs; ++i) {
+      const char *k = kvs[i].line;
+      const char *v = NULL;
+      if (kvs[i].val) v = kvs[i].line + kvs[i].val;
+      r = SQLWritePrivateProfileString(dsn.line+dsn.val, k, v, "Odbc.ini");
+    }
+  } while (0);
 
-  if (f8>INT8_MAX || f8<INT8_MIN) {
-    SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_TINYINT");
-    return SQL_SUCCESS_WITH_INFO;
-  }
+  if (dsn.line) free(dsn.line);
+  if (line) free(line);
 
-  SET_ERROR(sql, "01S07", TSDB_CODE_ODBC_CONV_TRUNC, "TSDB_DATA_TYPE_NCHAR -> SQL_C_TINYINT");
-  return SQL_SUCCESS_WITH_INFO;
+  return r;
 }
 
-static SQLRETURN conv_tsdb_str_to_c_v2(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str)
+static BOOL doDSNConfig(HWND	hwndParent, LPCSTR	lpszDriver, LPCSTR lpszAttributes)
 {
-  int bytes = 0;
-  double f8 = 0;
-  int n = sscanf(str, "%lf%n", &f8, &bytes);
-
-  int16_t v = f8;
-  memcpy(target->ptr, &v, sizeof(v));
-
-  *target->soi = 2;
-
-  if (n!=1 || bytes!=strlen(str)) {
-    SET_ERROR(sql, "22018", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_SHORT");
-    return SQL_SUCCESS_WITH_INFO;
-  }
-
-  char buf[64];
-  snprintf(buf, sizeof(buf), "%d", v);
-
-  if (strcmp(buf, str)==0) return SQL_SUCCESS;
-
-  if (f8>INT16_MAX || f8<INT16_MIN) {
-    SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_SHORT");
-    return SQL_SUCCESS_WITH_INFO;
+  const char *p = lpszAttributes;
+  while (p && *p) {
+    p += strlen(p) + 1;
   }
-
-  SET_ERROR(sql, "01S07", TSDB_CODE_ODBC_CONV_TRUNC, "TSDB_DATA_TYPE_NCHAR -> SQL_C_SHORT");
-  return SQL_SUCCESS_WITH_INFO;
+  return FALSE;
 }
 
-static SQLRETURN conv_tsdb_str_to_c_v4(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str)
+static BOOL doDSNRemove(HWND	hwndParent, LPCSTR	lpszDriver, LPCSTR lpszAttributes)
 {
-  int bytes = 0;
-  double f8 = 0;
-  int n = sscanf(str, "%lf%n", &f8, &bytes);
-
-  int32_t v = f8;
-  memcpy(target->ptr, &v, sizeof(v));
-
-  *target->soi = 4;
-
-  if (n!=1 || bytes!=strlen(str)) {
-    SET_ERROR(sql, "22018", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_LONG");
-    return SQL_SUCCESS_WITH_INFO;
-  }
-
-  char buf[64];
-  snprintf(buf, sizeof(buf), "%d", v);
-
-  if (strcmp(buf, str)==0) return SQL_SUCCESS;
+  BOOL r = TRUE;
 
-  if (f8>INT32_MAX || f8<INT32_MIN) {
-    SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_LONG");
-    return SQL_SUCCESS_WITH_INFO;
-  }
-
-  SET_ERROR(sql, "01S07", TSDB_CODE_ODBC_CONV_TRUNC, "TSDB_DATA_TYPE_NCHAR -> SQL_C_LONG");
-  return SQL_SUCCESS_WITH_INFO;
-}
+  kv_t dsn = {0};
+  char *line = NULL;
 
-static SQLRETURN conv_tsdb_str_to_c_v8(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str)
-{
-  int bytes = 0;
-  double f8 = 0;
-  int n = sscanf(str, "%lf%n", &f8, &bytes);
+  do {
+    const char *p = lpszAttributes;
+    int ikvs = 0;
+    while (p && *p) {
+      line = strdup(p);
+      if (!line) { r = FALSE; break; }
+      char *v = strchr(line, '=');
+      if (!v) { r = FALSE; break; }
+      *v = '\0';
+
+      if (strstr(line, "DSN")==line) {
+        if (dsn.line) {
+          free(dsn.line);
+          dsn.line = NULL;
+          dsn.val  = 0;
+        }
+        dsn.line = line;
+        dsn.val = v - line + 1;
+        line = NULL;
+        break;
+      } else {
+        free(line);
+        line = NULL;
+      }
 
-  int64_t v = f8;
-  memcpy(target->ptr, &v, sizeof(v));
+      p += strlen(p) + 1;
+    }
 
-  *target->soi = 8;
+    if (!r) break;
 
-  if (n!=1 || bytes!=strlen(str)) {
-    SET_ERROR(sql, "22018", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_SBIGINT");
-    return SQL_SUCCESS_WITH_INFO;
-  }
+    if (!dsn.line) {
+      POST_INSTALLER_ERROR(hwndParent, ODBC_ERROR_REQUEST_FAILED, "lack of DSN");
+      r = FALSE;
+      break;
+    }
 
-  char buf[64];
-  snprintf(buf, sizeof(buf), "%" PRId64 "", v);
+    r = SQLWritePrivateProfileString("ODBC Data Sources", dsn.line+dsn.val, NULL, "Odbc.ini");
+    if (!r) break;
 
-  if (strcmp(buf, str)==0) return SQL_SUCCESS;
+    char buf[8192];
+    r = SQLGetPrivateProfileString(dsn.line+dsn.val, NULL, "null", buf, sizeof(buf), "Odbc.ini");
+    if (!r) break;
 
-  if (f8>INT64_MAX || f8<INT64_MIN) {
-    SET_ERROR(sql, "22003", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_SBIGINT");
-    return SQL_SUCCESS_WITH_INFO;
-  }
+    int n = 0;
+    char *s = buf;
+    while (s && *s && n++<10) {
+      SQLWritePrivateProfileString(dsn.line+dsn.val, s, NULL, "Odbc.ini");
+      s += strlen(s) + 1;
+    }
+  } while (0);
 
-  SET_ERROR(sql, "01S07", TSDB_CODE_ODBC_CONV_TRUNC, "TSDB_DATA_TYPE_NCHAR -> SQL_C_SBIGINT");
-  return SQL_SUCCESS_WITH_INFO;
+  if (dsn.line) free(dsn.line);
+  if (line) free(line);
+  return r;
 }
 
-static SQLRETURN conv_tsdb_str_to_c_f4(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str)
+static BOOL doConfigDSN(HWND	hwndParent, WORD fRequest, LPCSTR	lpszDriver, LPCSTR lpszAttributes)
 {
-  int bytes = 0;
-  double f8 = 0;
-  int n = sscanf(str, "%lf%n", &f8, &bytes);
-
-  float v = f8;
-  memcpy(target->ptr, &v, sizeof(v));
-
-  *target->soi = 4;
-
-  if (n!=1 || bytes!=strlen(str)) {
-    SET_ERROR(sql, "22018", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_FLOAT");
-    return SQL_SUCCESS_WITH_INFO;
+  BOOL r = FALSE;
+  const char *sReq = NULL;
+  switch(fRequest) {
+    case ODBC_ADD_DSN:    sReq = "ODBC_ADD_DSN";      break;
+    case ODBC_CONFIG_DSN: sReq = "ODBC_CONFIG_DSN";   break;
+    case ODBC_REMOVE_DSN: sReq = "ODBC_REMOVE_DSN";   break;
+    default:              sReq = "UNKNOWN";           break;
   }
-
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_str_to_c_f8(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str)
-{
-  int bytes = 0;
-  double f8 = 0;
-  int n = sscanf(str, "%lf%n", &f8, &bytes);
-
-  float v = f8;
-  memcpy(target->ptr, &v, sizeof(v));
-
-  *target->soi = 8;
-
-  if (n!=1 || bytes!=strlen(str)) {
-    SET_ERROR(sql, "22018", TSDB_CODE_ODBC_CONV_UNDEF, "TSDB_DATA_TYPE_NCHAR -> SQL_C_DOUBLE");
-    return SQL_SUCCESS_WITH_INFO;
-  }
-
-  return SQL_SUCCESS;
-}
-
-static SQLRETURN conv_tsdb_str_to_c_str(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str)
-{
-  return conv_tsdb_bin_to_c_str(sql, target, field, (const unsigned char*)str);
-}
-
-static SQLRETURN conv_tsdb_str_to_c_bin(sql_t *sql, c_target_t *target, TAOS_FIELD *field, const char *str)
-{
-  return conv_tsdb_bin_to_c_bin(sql, target, field, (const unsigned char*)str);
-}
-
-
-
-
-const char* tsdb_int64_to_bit(int64_t src, int8_t *dst)
-{
-  *dst = src;
-  if (src==0 || src==1) return NULL;
-  return "22003";
-}
-
-const char* tsdb_int64_to_tinyint(int64_t src, int8_t *dst)
-{
-  *dst = src;
-  if (src>=SCHAR_MIN && src<=SCHAR_MAX) return NULL;
-  return "22003";
-}
-
-const char* tsdb_int64_to_smallint(int64_t src, int16_t *dst)
-{
-  *dst = src;
-  if (src>=SHRT_MIN && src<=SHRT_MAX) return NULL;
-  return "22003";
-}
-
-const char* tsdb_int64_to_int(int64_t src, int32_t *dst)
-{
-  *dst = src;
-  if (src>=LONG_MIN && src<=LONG_MAX) return NULL;
-  return "22003";
-}
-
-const char* tsdb_int64_to_bigint(int64_t src, int64_t *dst)
-{
-  *dst = src;
-  return NULL;
-}
-
-const char* tsdb_int64_to_ts(int64_t src, int64_t *dst)
-{
-  *dst = src;
-
-  char buf[4096];
-  int n = snprintf(buf, sizeof(buf), "%" PRId64 "", src);
-  DASSERT(n>=0);
-  DASSERT(n<sizeof(buf));
-
-  int64_t secs = src / 1000;
-  struct tm tm = {0};
-  if (&tm != localtime_r(&secs, &tm)) return "22007";
-
-  return NULL;
-}
-
-const char* tsdb_int64_to_float(int64_t src, float *dst)
-{
-  *dst = src;
-  return NULL;
-}
-
-const char* tsdb_int64_to_double(int64_t src, double *dst)
-{
-  *dst = src;
-  return NULL;
-}
-
-const char* tsdb_int64_to_char(int64_t src, char *dst, size_t dlen)
-{
-  int n = snprintf(dst, dlen, "%" PRId64 "", src);
-  if (n<dlen) return NULL;
-  return "22003";
-}
-
-
-const char* tsdb_double_to_bit(double src, int precision, int8_t *dst)
-{
-  int64_t v = src;
-  *dst = v;
-  if (v<0 || v>=2) return "22003";
-
-  char buf[4096];
-  int n = snprintf(buf, sizeof(buf), "%.*g", precision, src);
-  DASSERT(n>=0);
-  DASSERT(n<sizeof(buf));
-  if (strcmp(buf, "0")==0 || strcmp(buf, "1")==1) {
-    return NULL;
+  switch(fRequest) {
+    case ODBC_ADD_DSN: {
+      r = doDSNAdd(hwndParent, lpszDriver, lpszAttributes);
+    } break;
+    case ODBC_CONFIG_DSN: {
+      r = doDSNConfig(hwndParent, lpszDriver, lpszAttributes);
+    } break;
+    case ODBC_REMOVE_DSN: {
+      r = doDSNRemove(hwndParent, lpszDriver, lpszAttributes);
+    } break;
+    default: {
+      POST_INSTALLER_ERROR(hwndParent, ODBC_ERROR_GENERAL_ERR, "not implemented yet");
+      r = FALSE;
+    } break;
   }
-  return "22001";
-}
-
-const char* tsdb_double_to_tinyint(double src, int precision, int8_t *dst)
-{
-  int64_t v = src;
-  *dst = v;
-  if (v<SCHAR_MIN || v>SCHAR_MAX) return "22003";
-
-  char buf[4096];
-  int n = snprintf(buf, sizeof(buf), "%.*g", precision, src);
-  DASSERT(n>=0);
-  DASSERT(n<sizeof(buf));
-  if (strchr(buf, '.')) return "01S07";
-
-  return NULL;
-}
-
-const char* tsdb_double_to_smallint(double src, int precision, int16_t *dst)
-{
-  int64_t v = src;
-  *dst = v;
-  if (v<SHRT_MIN || v>SHRT_MAX) return "22003";
-
-  char buf[4096];
-  int n = snprintf(buf, sizeof(buf), "%.*g", precision, src);
-  DASSERT(n>=0);
-  DASSERT(n<sizeof(buf));
-
-  if (strchr(buf, '.')) return "01S07";
-
-  return NULL;
-}
-
-const char* tsdb_double_to_int(double src, int precision, int32_t *dst)
-{
-  int64_t v = src;
-  *dst = v;
-  if (v<LONG_MIN || v>LONG_MAX) return "22003";
-
-  char buf[4096];
-  int n = snprintf(buf, sizeof(buf), "%.*g", precision, src);
-  DASSERT(n>=0);
-  DASSERT(n<sizeof(buf));
-
-  if (strchr(buf, '.')) return "01S07";
-
-  return NULL;
-}
-
-const char* tsdb_double_to_bigint(double src, int precision, int64_t *dst)
-{
-  int64_t v = src;
-  *dst = v;
-  if (v<LLONG_MIN || v>LLONG_MAX) return "22003";
-
-  char buf[4096];
-  int n = snprintf(buf, sizeof(buf), "%.*g", precision, src);
-  DASSERT(n>=0);
-  DASSERT(n<sizeof(buf));
-
-  if (strchr(buf, '.')) return "01S07";
-
-  return NULL;
-}
-
-const char* tsdb_double_to_ts(double src, int precision, int64_t *dst)
-{
-  int64_t v = src;
-  *dst = v;
-
-  char buf[4096];
-  int n = snprintf(buf, sizeof(buf), "%.*g", precision, src);
-  DASSERT(n>=0);
-  DASSERT(n<sizeof(buf));
-  if (strchr(buf, '.')) return "01S07";
-
-  int64_t secs = v / 1000;
-  struct tm tm = {0};
-  if (&tm != localtime_r(&secs, &tm)) return "22007";
-
-  return NULL;
-}
-
-const char* tsdb_double_to_float(double src, int precision, float *dst)
-{
-  *dst = src;
-
-  char buf1[4096], buf2[4096];
-  int n1 = snprintf(buf1, sizeof(buf1), "%.*g", precision, src);
-  int n2 = snprintf(buf2, sizeof(buf2), "%.*g", precision, *dst);
-
-  DASSERT(n1>=0);
-  DASSERT(n2>=0);
-  DASSERT(n1<sizeof(buf1));
-  DASSERT(n2<sizeof(buf2));
-
-  if (strcmp(buf1, buf2)) return "01S07";
-
-  return NULL;
+  return r;
 }
 
-const char* tsdb_double_to_double(double src, int precision, double *dst)
+BOOL INSTAPI ConfigDSN(HWND	hwndParent, WORD fRequest, LPCSTR	lpszDriver, LPCSTR lpszAttributes)
 {
-  *dst = src;
-  return NULL;
+  BOOL r;
+  r = doConfigDSN(hwndParent, fRequest, lpszDriver, lpszAttributes);
+  return r;
 }
 
-const char* tsdb_double_to_char(double src, int precision, char *dst, size_t dlen)
+BOOL INSTAPI ConfigTranslator(HWND hwndParent, DWORD *pvOption)
 {
-  int n = snprintf(dst, dlen, "%.*g", precision, src);
-  DASSERT(n>=0);
-  if (n>=dlen) return "22001";
-
-  return NULL;
+  POST_INSTALLER_ERROR(hwndParent, ODBC_ERROR_GENERAL_ERR, "not implemented yet");
+  return FALSE;
 }
 
-const char* tsdb_chars_to_bit(const char *src, int8_t *dst)
+BOOL INSTAPI ConfigDriver(HWND hwndParent, WORD fRequest, LPCSTR lpszDriver, LPCSTR lpszArgs,
+                          LPSTR lpszMsg, WORD cbMsgMax, WORD *pcbMsgOut)
 {
-  int bytes = 0;
-  int64_t v = 0;
-  int n = sscanf(src, "%" PRId64 "%n", &v, &bytes);
-  if (n!=1) return "22018";
-
-  if (bytes!=strlen(src)) {
-    if (src[bytes-1]=='.') {
-      if (v==0 || v==1) return "22001";
-
-      return "22003";
-    }
-    return "22018";
-  }
-
-  if (v==0 || v==1) return NULL;
-
-  return "22003";
-}
-
-const char* tsdb_chars_to_tinyint(const char *src, int8_t *dst)
-{
-  int bytes = 0;
-  int64_t v = 0;
-  int n = sscanf(src, "%" PRId64 "%n", &v, &bytes);
-  if (n!=1) return "22018";
-
-
-  if (bytes!=strlen(src)) {
-    if (src[bytes-1]=='.') {
-      if (v<SCHAR_MIN || v>SCHAR_MAX) return "22001";
-
-      return "22003";
-    }
-    return "22018";
-  }
-
-  if (v<SCHAR_MIN || v>SCHAR_MAX) return "22001";
-
-  return NULL;
+  POST_INSTALLER_ERROR(hwndParent, ODBC_ERROR_GENERAL_ERR, "not implemented yet");
+  return FALSE;
 }
 
-const char* tsdb_chars_to_smallint(const char *src, int16_t *dst)
-{
-  int bytes = 0;
-  int64_t v = 0;
-  int n = sscanf(src, "%" PRId64 "%n", &v, &bytes);
-  if (n!=1) return "22018";
-
+#endif // _MSC_VER
 
-  if (bytes!=strlen(src)) {
-    if (src[bytes-1]=='.') {
-      if (v<SHRT_MIN || v>SHRT_MAX) return "22001";
 
-      return "22003";
-    }
-    return "22018";
-  }
-
-  if (v<SHRT_MIN || v>SHRT_MAX) return "22001";
-
-  return NULL;
-}
-
-const char* tsdb_chars_to_int(const char *src, int32_t *dst)
-{
-  int bytes = 0;
-  int64_t v = 0;
-  int n = sscanf(src, "%" PRId64 "%n", &v, &bytes);
-  if (n!=1) return "22018";
-
-
-  if (bytes!=strlen(src)) {
-    if (src[bytes-1]=='.') {
-      if (v<LONG_MIN || v>LONG_MAX) return "22001";
-
-      return "22003";
-    }
-    return "22018";
-  }
-
-  if (v<LONG_MIN || v>LONG_MAX) return "22001";
-
-  return NULL;
+static void init_routine(void) {
+  taos_init();
 }
 
-const char* tsdb_chars_to_bigint(const char *src, int64_t *dst)
-{
-  int bytes = 0;
-  int64_t v = 0;
-  int n = sscanf(src, "%" PRId64 "%n", &v, &bytes);
-  if (n!=1) return "22018";
-
+static size_t do_field_display_size(TAOS_FIELD *field) {
+  switch (field->type) {
+    case TSDB_DATA_TYPE_TINYINT:
+      return 5;
+      break;
 
-  if (bytes!=strlen(src)) {
-    if (src[bytes-1]=='.') {
-      if (v<LLONG_MIN || v>LLONG_MAX) return "22001";
+    case TSDB_DATA_TYPE_SMALLINT:
+      return 7;
+      break;
 
-      return "22003";
-    }
-    return "22018";
-  }
+    case TSDB_DATA_TYPE_INT:
+      return 12;
+      break;
 
-  if (v<LLONG_MIN || v>LLONG_MAX) return "22001";
+    case TSDB_DATA_TYPE_BIGINT:
+      return 22;
+      break;
 
-  return NULL;
-}
+    case TSDB_DATA_TYPE_FLOAT: {
+      return 12;
+    } break;
 
-const char* tsdb_chars_to_ts(const char *src, int64_t *dst)
-{
-  int bytes = 0;
-  int64_t v = 0;
-  int n = sscanf(src, "%" PRId64 "%n", &v, &bytes);
-  if (n!=1) return "22018";
+    case TSDB_DATA_TYPE_DOUBLE: {
+      return 20;
+    } break;
 
+    case TSDB_DATA_TYPE_BINARY:
+    case TSDB_DATA_TYPE_NCHAR: {
+      return 3*((size_t)field->bytes - VARSTR_HEADER_SIZE) + 2;
+    } break;
 
-  if (bytes!=strlen(src)) {
-    if (src[bytes-1]=='.') {
-      if (v<LLONG_MIN || v>LLONG_MAX) return "22001";
+    case TSDB_DATA_TYPE_TIMESTAMP:
+      return 26;
+      break;
 
-      return "22003";
-    }
-    return "22018";
+    case TSDB_DATA_TYPE_BOOL:
+      return 7;
+    default:
+      break;
   }
 
-  if (v<LLONG_MIN || v>LLONG_MAX) return "22001";
-
-  return NULL;
-}
-
-const char* tsdb_chars_to_float(const char *src, float *dst)
-{
-  int bytes = 0;
-  int n = sscanf(src, "%f%n", dst, &bytes);
-  if (n!=1) return "22018";
-
-  if (bytes!=strlen(src)) return "22018";
-
-  return NULL;
-}
-
-const char* tsdb_chars_to_double(const char *src, double *dst)
-{
-  int bytes = 0;
-  int n = sscanf(src, "%lf%n", dst, &bytes);
-  if (n!=1) return "22018";
-
-  if (bytes!=strlen(src)) return "22018";
-
-  return NULL;
+  return 10;
 }
 
-const char* tsdb_chars_to_char(const char *src, char *dst, size_t dlen)
-{
-  int n = snprintf(dst, dlen, "%s", src);
-  if (n>=dlen) return "22001";
 
-  return NULL;
-}
 
diff --git a/src/connector/odbc/src/todbc.def b/src/connector/odbc/src/todbc.def
new file mode 100644
index 0000000000000000000000000000000000000000..1e080f01983ec2b38d657004291008f6da6198dc
--- /dev/null
+++ b/src/connector/odbc/src/todbc.def
@@ -0,0 +1,31 @@
+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
+
diff --git a/src/connector/odbc/src/todbc.rc.in b/src/connector/odbc/src/todbc.rc.in
new file mode 100644
index 0000000000000000000000000000000000000000..cf0b21145456eb20097ed3dda1e582cee1e343d2
--- /dev/null
+++ b/src/connector/odbc/src/todbc.rc.in
@@ -0,0 +1,31 @@
+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
diff --git a/src/connector/odbc/src/todbc.rsp b/src/connector/odbc/src/todbc.rsp
new file mode 100644
index 0000000000000000000000000000000000000000..f5e511565872e51a6afa838ad6cb3d1774c2c422
--- /dev/null
+++ b/src/connector/odbc/src/todbc.rsp
@@ -0,0 +1,5 @@
+INSTALLDRIVER "TAOS ODBC|Driver=todbc.dll|FileUsage=0|ConnectFunctions=YYN"
+
+
+
+
diff --git a/src/connector/odbc/src/todbc_conv.c b/src/connector/odbc/src/todbc_conv.c
new file mode 100644
index 0000000000000000000000000000000000000000..9c0f19764c2b456c63b6d0a01402e37868a0a366
--- /dev/null
+++ b/src/connector/odbc/src/todbc_conv.c
@@ -0,0 +1,660 @@
+/*
+ * 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);
+}
+
diff --git a/src/connector/odbc/src/todbc_conv.h b/src/connector/odbc/src/todbc_conv.h
new file mode 100644
index 0000000000000000000000000000000000000000..2941f3e4961d38ed1e72bfd3d1184d1ea8de251b
--- /dev/null
+++ b/src/connector/odbc/src/todbc_conv.h
@@ -0,0 +1,109 @@
+/*
+ * 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_
+
diff --git a/src/connector/odbc/src/todbc_flex.h b/src/connector/odbc/src/todbc_flex.h
new file mode 100644
index 0000000000000000000000000000000000000000..a13f1f4d2ebd8bbca73d9ff224bb3ed20ed43174
--- /dev/null
+++ b/src/connector/odbc/src/todbc_flex.h
@@ -0,0 +1,36 @@
+/*
+ * 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_
+
diff --git a/src/connector/odbc/src/todbc_log.h b/src/connector/odbc/src/todbc_log.h
new file mode 100644
index 0000000000000000000000000000000000000000..391a690cccb0954736cac76af3354cc8a39754a8
--- /dev/null
+++ b/src/connector/odbc/src/todbc_log.h
@@ -0,0 +1,42 @@
+/*
+ * 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_
+
diff --git a/src/connector/odbc/src/todbc_scanner.l b/src/connector/odbc/src/todbc_scanner.l
new file mode 100644
index 0000000000000000000000000000000000000000..f8c6a15d92442ee7f7b9041f017b41a4ed590314
--- /dev/null
+++ b/src/connector/odbc/src/todbc_scanner.l
@@ -0,0 +1,165 @@
+%{
+#include "todbc_flex.h"
+#include <stdio.h>
+
+#ifdef _MSC_VER
+#define strncasecmp _strnicmp
+#define strcasecmp _stricmp
+#endif
+
+#define PUSH_STATE(state)      yy_push_state(state, yyscanner)
+#define POP_STATE()            yy_pop_state(yyscanner)
+
+#define CHG_STATE(state)                \
+do {                                    \
+    yy_pop_state(yyscanner);            \
+    yy_push_state(state, yyscanner);    \
+} while (0)
+
+#define TOP_STATE(top)                  \
+do {                                    \
+    yy_push_state(INITIAL, yyscanner);  \
+    top = yy_top_state(yyscanner);      \
+    yy_pop_state(yyscanner);            \
+} while (0)
+
+#define UNPUT()                                 \
+do {                                            \
+    while (yyleng) unput(yytext[yyleng-1]);     \
+} while (0)
+
+#define set_key()                       \
+do {                                    \
+    free(yyextra->key);                 \
+    yyextra->key = strdup(yytext);      \
+} while (0)
+
+#define set_val()                                    \
+do {                                                 \
+    if (!yyextra->key) break;                        \
+    if (strcasecmp(yyextra->key, "DSN")==0) {        \
+        free(yyextra->dsn);                          \
+        yyextra->dsn = strdup(yytext);               \
+        break;                                       \
+    }                                                \
+    if (strcasecmp(yyextra->key, "UID")==0) {        \
+        free(yyextra->uid);                          \
+        yyextra->uid = strdup(yytext);               \
+        break;                                       \
+    }                                                \
+    if (strcasecmp(yyextra->key, "PWD")==0) {        \
+        free(yyextra->pwd);                          \
+        yyextra->pwd = strdup(yytext);               \
+        break;                                       \
+    }                                                \
+    if (strcasecmp(yyextra->key, "DB")==0) {         \
+        free(yyextra->db);                           \
+        yyextra->pwd = strdup(yytext);               \
+        break;                                       \
+    }                                                \
+    if (strcasecmp(yyextra->key, "Server")==0) {     \
+        free(yyextra->server);                       \
+        yyextra->server = strdup(yytext);            \
+        break;                                       \
+    }                                                \
+    if (strcasecmp(yyextra->key, "SERVER_ENC")==0) { \
+        free(yyextra->svr_enc);                      \
+        yyextra->svr_enc = strdup(yytext);           \
+        break;                                       \
+    }                                                \
+    if (strcasecmp(yyextra->key, "CLIENT_ENC")==0) { \
+        free(yyextra->cli_enc);                      \
+        yyextra->cli_enc = strdup(yytext);           \
+        break;                                       \
+    }                                                \
+} while (0)
+
+%}
+
+%option prefix="todbc_yy"
+%option extra-type="conn_val_t *"
+%option nounistd
+%option never-interactive
+%option reentrant
+%option noyywrap
+%option noinput nounput
+%option debug verbose
+%option stack
+%option nodefault
+%option warn
+%option perf-report
+%option 8bit
+
+%x KEY EQ BRACE1 BRACE2 VAL
+
+%%
+<<EOF>> { int state; TOP_STATE(state);
+          if (state == INITIAL) yyterminate();
+          if (state == VAL)     yyterminate();
+          return -1; }
+[[:space:]]+    { }
+[[:alnum:]_]+   { set_key(); PUSH_STATE(KEY); }
+.|\n            { return -1; }
+
+<KEY>[[:space:]]+   { }
+<KEY>[=]            { CHG_STATE(EQ); }
+<KEY>.|\n           { return -1; }
+
+<EQ>[[:space:]]+               { }
+<EQ>[^][{}(),;?*=!@/\\\n[:space:]]+     { set_val(); CHG_STATE(VAL); }
+<EQ>[{]                        { CHG_STATE(BRACE1); }
+<EQ>.|\n                       { return -1; }
+
+<BRACE1>[^{}\n]+  { set_val(); CHG_STATE(BRACE2); }
+<BRACE1>.|\n      { return -1; }
+
+<BRACE2>[[:space:]]+       { }
+<BRACE2>[}]       { CHG_STATE(VAL); }
+<BRACE2>.|\n      { return -1; }
+
+<VAL>[;]          { POP_STATE(); }
+<VAL>.|\n         { return -1; }
+%%
+
+int todbc_parse_conn_string(const char *conn, conn_val_t *val) {
+  yyscan_t arg = {0};
+  yylex_init(&arg);
+  yyset_debug(0, arg);
+  yyset_extra(val, arg);
+  yy_scan_string(conn, arg);
+  int ret =yylex(arg);
+  yylex_destroy(arg);
+  if (val->key) free(val->key); val->key = NULL;
+  if (ret) {
+    conn_val_reset(val);
+  }
+  return ret ? -1 : 0;
+}
+
+void conn_val_reset(conn_val_t *val) {
+  if (val->key) {
+    free(val->key); val->key = NULL;
+  }
+  if (val->dsn) {
+    free(val->dsn); val->dsn = NULL;
+  }
+  if (val->uid) {
+    free(val->uid); val->uid = NULL;
+  }
+  if (val->pwd) {
+    free(val->pwd); val->pwd = NULL;
+  }
+  if (val->db) {
+    free(val->db); val->db = NULL;
+  }
+  if (val->server) {
+    free(val->server); val->server = NULL;
+  }
+  if (val->svr_enc) {
+    free(val->svr_enc); val->svr_enc = NULL;
+  }
+  if (val->cli_enc) {
+    free(val->cli_enc); val->cli_enc = NULL;
+  }
+}
+
diff --git a/src/connector/odbc/src/todbc_util.c b/src/connector/odbc/src/todbc_util.c
index b6b45d8120d28da31dcc1d323893984f9b93519b..9c130b4f2f2e6d0f5d4a19e11ab323d42b800195 100644
--- a/src/connector/odbc/src/todbc_util.c
+++ b/src/connector/odbc/src/todbc_util.c
@@ -14,14 +14,10 @@
  */
 
 #include "todbc_util.h"
-
-#include "iconv.h"
-
-#include <sql.h>
-#include <sqltypes.h>
+#include "todbc_log.h"
+#include <iconv.h>
 #include <sqlext.h>
-#include <stdlib.h>
-#include <string.h>
+
 
 const char* sql_sql_type(int type) {
   switch (type) {
@@ -111,39 +107,6 @@ int is_valid_sql_sql_type(int type) {
   return 1;
 }
 
-int string_conv(const char *fromcode, const char *tocode,
-                const unsigned char *src, size_t sbytes,
-                unsigned char *dst, size_t dbytes,
-                size_t *consumed, size_t *generated)
-{
-  if (consumed) *consumed = 0;
-  if (generated) *generated = 0;
-
-  if (dbytes <= 0) return -1;
-  dst[0] = '\0';
-
-  iconv_t conv = iconv_open(tocode, fromcode);
-  if (!conv) return -1;
-
-  int r = 0;
-  do {
-    char *s = (char*)src;
-    char *d = (char*)dst;
-    size_t sl = sbytes;
-    size_t dl = dbytes;
-
-    r = iconv(conv, &s, &sl, &d, &dl);
-    *d = '\0';
-
-    if (consumed) *consumed = sbytes - sl;
-    if (generated) *generated = dbytes - dl;
-
-  } while (0);
-
-  iconv_close(conv);
-  return r;
-}
-
 int utf8_chars(const char *src)
 {
   const char *fromcode = "UTF-8";
@@ -161,78 +124,6 @@ int utf8_chars(const char *src)
 
   size_t chars = (sizeof(buf) - dlen) / 2;
   iconv_close(conv);
-  return chars;
-}
-
-unsigned char* utf8_to_ucs4le(const char *utf8, size_t *chars)
-{
-  const char *tocode = "UCS-4LE";
-  const char *fromcode = "UTF-8";
-
-  iconv_t conv = iconv_open(tocode, fromcode);
-  if (!conv) return NULL;
-
-  unsigned char *ucs4le = NULL;
-
-  do {
-    size_t slen = strlen(utf8);
-    size_t dlen = slen * 4;
-
-    ucs4le = (unsigned char*)malloc(dlen+1);
-    if (!ucs4le) break;
-
-    char *src = (char*)utf8;
-    char *dst = (char*)ucs4le;
-    size_t s = slen;
-    size_t d = dlen;
-    iconv(conv, &src, &s, &dst, &d);
-    dst[0] = '\0';
-
-    if (chars) *chars = (dlen - d) / 4;
-  } while (0);
-
-  iconv_close(conv);
-  return ucs4le;
-}
-
-char* ucs4le_to_utf8(const unsigned char *ucs4le, size_t slen, size_t *chars)
-{
-  const char *fromcode = "UCS-4LE";
-  const char *tocode = "UTF-8";
-
-  iconv_t conv = iconv_open(tocode, fromcode);
-  if (!conv) return NULL;
-
-  char *utf8 = NULL;
-
-  do {
-    size_t dlen = slen;
-
-    utf8 = (char*)malloc(dlen+1);
-    if (!utf8) break;
-
-    char *dst = utf8;
-    char *src = (char*)ucs4le;
-    size_t s = slen;
-    size_t d = dlen;
-    iconv(conv, &src, &s, &dst, &d);
-    dst[0] = '\0';
-
-    if (chars) *chars = (slen - s) / 4;
-  } while (0);
-
-  iconv_close(conv);
-  return utf8;
-}
-
-SQLCHAR* wchars_to_chars(const SQLWCHAR *wchars, size_t chs, size_t *bytes)
-{
-  size_t dlen = chs * 4;
-  SQLCHAR *dst = (SQLCHAR*)malloc(dlen + 1);
-  if (!dst) return NULL;
-
-  string_conv("UCS-2LE", "UTF-8", (const unsigned char*)wchars, chs * sizeof(*wchars), dst, dlen + 1, NULL, bytes);
-
-  return dst;
+  return (int)chars;
 }
 
diff --git a/src/connector/odbc/src/todbc_util.h b/src/connector/odbc/src/todbc_util.h
index 43264975b4e618bd495691e59fb9df59f6664e03..ead0d7348973409c85741cc4d676e40f6f140447 100644
--- a/src/connector/odbc/src/todbc_util.h
+++ b/src/connector/odbc/src/todbc_util.h
@@ -16,33 +16,10 @@
 #ifndef _TODBC_UTIL_H_
 #define _TODBC_UTIL_H_
 
-#include <libgen.h>
-#include <stddef.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sql.h>
-
-#define D(fmt, ...)                                              \
-  fprintf(stderr,                                                \
-          "%s[%d]:%s() " fmt "\n",                               \
-          basename((char*)__FILE__), __LINE__, __func__,         \
-          ##__VA_ARGS__)
-
-#define DASSERT(statement)                                       \
-do {                                                             \
-  if (statement) break;                                          \
-  D("Assertion failure: %s", #statement);                        \
-  abort();                                                       \
-} while (0)
-
-#define DASSERTX(statement, fmt, ...)                                \
-do {                                                                 \
-  if (statement) break;                                              \
-  D("Assertion failure: %s, " fmt "", #statement, ##__VA_ARGS__);    \
-  abort();                                                           \
-} while (0)
-
+#include "os.h"
 
+#include <sql.h>
+#include <sqltypes.h>
 
 const char* sql_sql_type(int type);
 const char* sql_c_type(int type);
@@ -50,14 +27,7 @@ const char* sql_c_type(int type);
 int is_valid_sql_c_type(int type);
 int is_valid_sql_sql_type(int type);
 
-int string_conv(const char *fromcode, const char *tocode,
-                const unsigned char *src, size_t sbytes,
-                unsigned char *dst, size_t dbytes,
-                size_t *consumed, size_t *generated);
 int utf8_chars(const char *src);
 
-unsigned char* utf8_to_ucs4le(const char *utf8, size_t *chars);
-char*          ucs4le_to_utf8(const unsigned char *ucs4le, size_t slen, size_t *chars);
-SQLCHAR*       wchars_to_chars(const SQLWCHAR *wchars, size_t chs, size_t *bytes);
-
 #endif // _TODBC_UTIL_H_
+
diff --git a/src/connector/odbc/tests/CMakeLists.txt b/src/connector/odbc/tests/CMakeLists.txt
index ac57a5647fce8bd036e133936284f3f4c847d8c8..1cc6acaf4bf34aa2158cc1f4fa0836d6e51f3a41 100644
--- a/src/connector/odbc/tests/CMakeLists.txt
+++ b/src/connector/odbc/tests/CMakeLists.txt
@@ -1,7 +1,18 @@
 PROJECT(TDengine)
 
 IF (TD_LINUX)
-  AUX_SOURCE_DIRECTORY(. SRC)
+  # AUX_SOURCE_DIRECTORY(. SRC)
   ADD_EXECUTABLE(tcodbc main.c)
   TARGET_LINK_LIBRARIES(tcodbc odbc)
+  ADD_EXECUTABLE(tconv tconv.c)
+ENDIF ()
+
+IF (TD_WINDOWS_64)
+  SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /GL")
+  SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} /GL")
+  # AUX_SOURCE_DIRECTORY(. SRC)
+  ADD_EXECUTABLE(tcodbc main.c)
+  TARGET_LINK_LIBRARIES(tcodbc odbc32 odbccp32 user32 legacy_stdio_definitions os)
+  ADD_EXECUTABLE(tconv tconv.c)
+  TARGET_LINK_LIBRARIES(tconv tutil)
 ENDIF ()
diff --git a/src/connector/odbc/tests/create_data.stmts b/src/connector/odbc/tests/create_data.stmts
new file mode 100644
index 0000000000000000000000000000000000000000..549cb583d8322906b4bdaffafde8eb510cb91c90
--- /dev/null
+++ b/src/connector/odbc/tests/create_data.stmts
@@ -0,0 +1,12 @@
+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;
+
diff --git a/src/connector/odbc/tests/main.c b/src/connector/odbc/tests/main.c
index 1ac9b71369e8a526b051008b9379fdda4b6a5e77..417de00d55f64249a9194b77fecbeb458c560cc7 100644
--- a/src/connector/odbc/tests/main.c
+++ b/src/connector/odbc/tests/main.c
@@ -1,14 +1,38 @@
+#include "../src/todbc_log.h"
+
+#ifdef _MSC_VER
+#include <winsock2.h>
+#include <windows.h>
+#include "os.h"
+#endif
 #include <sql.h>
 #include <sqlext.h>
+#include <odbcinst.h>
 
 #include <stdio.h>
 #include <string.h>
 
-#include "os.h"
+#define CHK_TEST(statement)                       \
+do {                                              \
+  D("testing: %s", #statement);                   \
+  int r = (statement);                            \
+  if (r) {                                        \
+    D("testing failed: %s", #statement);          \
+    return 1;                                     \
+  }                                               \
+} while (0);
+
+typedef struct db_column_s          db_column_t;
+struct db_column_s {
+  SQLSMALLINT             nameLength;
+  char                    name[4096]; // seems enough
+  SQLSMALLINT             dataType;
+  SQLULEN                 columnSize;
+  SQLSMALLINT             decimalDigits;
+  SQLSMALLINT             nullable;
+};
 
-// static const char *dsn = "TAOS_DSN";
-// static const char *uid = "root";
-// static const char *pwd = "taosdata";
+static db_column_t       *columns = NULL;
 
 typedef struct data_s            data_t;
 struct data_s {
@@ -37,7 +61,7 @@ static const char *pro_stmts[] = {
   // "drop database db"
 };
 
-#define CHK_RESULT(r, ht, h)                                                    \
+#define CHK_RESULT(r, ht, h, fmt, ...)                                          \
 do {                                                                            \
   if (r==0) break;                                                              \
   SQLCHAR      ss[10];                                                          \
@@ -48,23 +72,149 @@ do {
   es[0] = '\0';                                                                 \
   SQLRETURN ret = SQLGetDiagRec(ht, h, 1, ss, &ne, es, sizeof(es), &n);         \
   if (ret) break;                                                               \
-  fprintf(stderr, "%s%s\n", ss, es);                                            \
+  D("[%s]%s: " fmt "", ss, es, ##__VA_ARGS__);                                  \
 } while (0)
 
+static int open_connect(const char *dsn, const char *uid, const char *pwd, SQLHENV *pEnv, SQLHDBC *pConn) {
+  SQLRETURN r;
+  SQLHENV env = {0};
+  SQLHDBC conn = {0};
+  r = SQLAllocEnv(&env);
+  if (r!=SQL_SUCCESS) return 1;
+  do {
+    r = SQLAllocConnect(env, &conn);
+    CHK_RESULT(r, SQL_HANDLE_ENV, env, "");
+    if (r!=SQL_SUCCESS) break;
+    do {
+      r = SQLConnect(conn, (SQLCHAR*)dsn, (SQLSMALLINT)(dsn ? strlen(dsn) : 0),
+                           (SQLCHAR*)uid, (SQLSMALLINT)(uid ? strlen(uid) : 0),
+                           (SQLCHAR*)pwd, (SQLSMALLINT)(pwd ? strlen(pwd) : 0));
+      CHK_RESULT(r, SQL_HANDLE_DBC, conn, "");
+      if (r==SQL_SUCCESS) {
+        *pEnv  = env;
+        *pConn = conn;
+        return 0;
+      }
+    } while (0);
+    SQLFreeConnect(conn);
+  } while (0);
+  SQLFreeEnv(env);
+
+  return 1;
+}
+
+static int open_driver_connect(const char *connstr, SQLHENV *pEnv, SQLHDBC *pConn) {
+  SQLRETURN r;
+  SQLHENV env = {0};
+  SQLHDBC conn = {0};
+  r = SQLAllocEnv(&env);
+  if (r!=SQL_SUCCESS) return 1;
+  do {
+    r = SQLAllocConnect(env, &conn);
+    CHK_RESULT(r, SQL_HANDLE_ENV, env, "");
+    if (r!=SQL_SUCCESS) break;
+    do {
+      SQLCHAR buf[4096];
+      SQLSMALLINT blen = 0;
+      SQLHDBC         ConnectionHandle      = conn;
+      SQLHWND         WindowHandle          = NULL;
+      SQLCHAR *       InConnectionString    = (SQLCHAR*)connstr;
+      SQLSMALLINT     StringLength1         = (SQLSMALLINT)(connstr ? strlen(connstr) : 0);
+      SQLCHAR *       OutConnectionString   = buf;
+      SQLSMALLINT     BufferLength          = sizeof(buf);
+      SQLSMALLINT *   StringLength2Ptr      = &blen;
+      SQLUSMALLINT    DriverCompletion      = SQL_DRIVER_NOPROMPT;
+      r = SQLDriverConnect(ConnectionHandle, WindowHandle, InConnectionString,
+                           StringLength1, OutConnectionString, BufferLength,
+                           StringLength2Ptr, DriverCompletion);
+      CHK_RESULT(r, SQL_HANDLE_DBC, conn, "");
+      if (r==SQL_SUCCESS) {
+        *pEnv  = env;
+        *pConn = conn;
+        return 0;
+      }
+    } while (0);
+    SQLFreeConnect(conn);
+  } while (0);
+  SQLFreeEnv(env);
+
+  return 1;
+}
+
+static SQLRETURN traverse_cols(SQLHSTMT stmt, SQLSMALLINT cols) {
+  SQLRETURN r = SQL_ERROR;
+  for (SQLSMALLINT i=0; i<cols; ++i) {
+    db_column_t column = {0};
+    r = SQLDescribeCol(stmt, (SQLUSMALLINT)(i+1), (SQLCHAR*)column.name,
+                       (SQLSMALLINT)sizeof(column.name), &column.nameLength,
+                       &column.dataType, &column.columnSize,
+                       &column.decimalDigits, &column.nullable);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt, "");
+    D("col%02d:[%s]%d,type:[%d],colSize:[%"PRId64"],decimalDigits:[%d],nullable:[%d]",
+       i+1, column.name, column.nameLength, column.dataType, column.columnSize,
+       column.decimalDigits, column.nullable);
+    db_column_t *col = (db_column_t*)realloc(columns, (size_t)(i+1)*sizeof(*col));
+    if (!col) {
+      D("out of memory");
+      return SQL_ERROR;
+    }
+    col[i] = column;
+    columns = col;
+  }
+  return SQL_SUCCESS;
+}
+
 static int do_statement(SQLHSTMT stmt, const char *statement) {
   SQLRETURN r = 0;
   do {
-    fprintf(stderr, "prepare [%s]\n", statement);
-    r = SQLPrepare(stmt, (SQLCHAR*)statement, strlen(statement));
-    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    r = SQLExecDirect(stmt, (SQLCHAR*)statement, SQL_NTS);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt, "statement: [%s]", statement);
     if (r) break;
-    fprintf(stderr, "execute [%s]\n", statement);
-    r = SQLExecute(stmt);
-    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    SQLSMALLINT cols = 0;
+    r = SQLNumResultCols(stmt, &cols);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt, "");
     if (r) break;
-    fprintf(stderr, "done\n");
+    if (cols <= 0) break;
+    r = traverse_cols(stmt, cols);
+    char buf[4096];
+    while (1) {
+      SQLRETURN r = SQLFetch(stmt);
+      if (r==SQL_NO_DATA) break;
+      CHK_RESULT(r, SQL_HANDLE_STMT, stmt, "");
+      for (size_t i=0; i<cols; ++i) {
+        SQLLEN soi = 0;
+        r = SQLGetData(stmt, (SQLUSMALLINT)(i+1), SQL_C_CHAR, buf, sizeof(buf), &soi);
+        CHK_RESULT(r, SQL_HANDLE_STMT, stmt, "");
+        if (r) {
+          if (r!=SQL_SUCCESS_WITH_INFO) {
+            if (i>0) fprintf(stdout, "\n");
+            return r;
+          }
+        }
+        if (soi==SQL_NULL_DATA) {
+          fprintf(stdout, "%snull", i==0?"":",");
+        } else {
+          fprintf(stdout, "%s\"%s\"", i==0?"":",", buf);
+        }
+      }
+      fprintf(stdout, "\n");
+    }
+
+    // r = SQLFetch(stmt);
+    // if (r==SQL_NO_DATA) {
+    //   D("..........");
+    //   r = SQL_SUCCESS;
+    //   break;
+    // }
+    // CHK_RESULT(r, SQL_HANDLE_STMT, stmt, "");
+    // if (r) break;
+    // r = SQLPrepare(stmt, (SQLCHAR*)statement, strlen(statement));
+    // CHK_RESULT(r, SQL_HANDLE_STMT, stmt, "");
+    // if (r) break;
+    // r = SQLExecute(stmt);
+    // CHK_RESULT(r, SQL_HANDLE_STMT, stmt, "statement: %s", statement);
+    // if (r) break;
   } while (0);
-  fprintf(stderr, "r: [%x][%d]\n", r, r);
   return r;
 }
 
@@ -74,158 +224,450 @@ static int do_insert(SQLHSTMT stmt, data_t data) {
   SQLLEN    lblob;
 
   const char *statement = "insert into t values (?, ?, ?, ?, ?, ?, ?, ?, ?,?)";
-  int ignored = 0;
+  #define ignored 0
 
   do {
-    fprintf(stderr, "prepare [%s]\n", statement);
-    r = SQLPrepare(stmt, (SQLCHAR*)statement, strlen(statement));
-    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    r = SQLPrepare(stmt, (SQLCHAR*)statement, (SQLINTEGER)strlen(statement));
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt, "statement: %s", statement);
     if (r) break;
 
-    fprintf(stderr, "bind 1 [%s]\n", statement);
     r = SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_SBIGINT, SQL_TIMESTAMP, ignored, ignored, &data.ts, ignored, NULL);
-    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt, "statement: %s", statement);
     if (r) break;
 
-    fprintf(stderr, "bind 2 [%s]\n", statement);
     r = SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_BIT, SQL_BIT, ignored, ignored, &data.b, ignored, NULL);
-    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt, "statement: %s", statement);
     if (r) break;
 
-    fprintf(stderr, "bind 3 [%s]\n", statement);
     r = SQLBindParameter(stmt, 3, SQL_PARAM_INPUT, SQL_C_TINYINT, SQL_TINYINT, ignored, ignored, &data.v1, ignored, NULL);
-    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt, "statement: %s", statement);
     if (r) break;
 
-    fprintf(stderr, "bind 4 [%s]\n", statement);
     r = SQLBindParameter(stmt, 4, SQL_PARAM_INPUT, SQL_C_SHORT, SQL_SMALLINT, ignored, ignored, &data.v2, ignored, NULL);
-    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt, "statement: %s", statement);
     if (r) break;
 
-    fprintf(stderr, "bind 5 [%s]\n", statement);
     r = SQLBindParameter(stmt, 5, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, ignored, ignored, &data.v4, ignored, NULL);
-    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt, "statement: %s", statement);
     if (r) break;
 
-    fprintf(stderr, "bind 6 [%s]\n", statement);
     r = SQLBindParameter(stmt, 6, SQL_PARAM_INPUT, SQL_C_SBIGINT, SQL_BIGINT, ignored, ignored, &data.v8, ignored, NULL);
-    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt, "statement: %s", statement);
     if (r) break;
 
-    fprintf(stderr, "bind 7 [%s]\n", statement);
     r = SQLBindParameter(stmt, 7, SQL_PARAM_INPUT, SQL_C_FLOAT, SQL_FLOAT, ignored, ignored, &data.f4, ignored, NULL);
-    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt, "statement: %s", statement);
     if (r) break;
 
-    fprintf(stderr, "bind 8 [%s]\n", statement);
     r = SQLBindParameter(stmt, 8, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, ignored, ignored, &data.f8, ignored, NULL);
-    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt, "statement: %s", statement);
     if (r) break;
 
-    fprintf(stderr, "bind 9 [%s]\n", statement);
     lbin = SQL_NTS;
     r = SQLBindParameter(stmt, 9, SQL_PARAM_INPUT, SQL_C_BINARY, SQL_VARBINARY, sizeof(data.bin)-1, ignored, &data.bin, ignored, &lbin);
-    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt, "statement: %s", statement);
     if (r) break;
 
-    fprintf(stderr, "bind 10 [%s]\n", statement);
     lblob = SQL_NTS;
     r = SQLBindParameter(stmt, 10, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, sizeof(data.blob)-1, ignored, &data.blob, ignored, &lblob);
-    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt, "statement: %s", statement);
     if (r) break;
 
-    fprintf(stderr, "execute [%s]\n", statement);
     r = SQLExecute(stmt);
-    CHK_RESULT(r, SQL_HANDLE_STMT, stmt);
+    CHK_RESULT(r, SQL_HANDLE_STMT, stmt, "statement: %s", statement);
     if (r) break;
 
     // ts += 1;
     // v  = 2;
-    // fprintf(stderr, "execute [%s]\n", statement);
     // r = SQLExecute(stmt);
     // if (r) break;
-
-    fprintf(stderr, "done\n");
   } while (0);
-  fprintf(stderr, "r: [%x][%d]\n", r, r);
+
+  #undef ignored
   return r;
 }
 
-int main(int argc, char *argv[]) {
-  if (argc < 4) return 1;
-  const char *dsn = argv[1];
-  const char *uid = argv[2];
-  const char *pwd = argv[3];
-  SQLRETURN r;
+static int test1(const char *dsn, const char *uid, const char *pwd) {
   SQLHENV env = {0};
   SQLHDBC conn = {0};
-  r = SQLAllocEnv(&env);
-  if (r!=SQL_SUCCESS) return 1;
+  int n = open_connect(dsn, uid, pwd, &env, &conn);
+  if (n) return 1;
+
+  int ok = 0;
   do {
-    r = SQLAllocConnect(env, &conn);
-    CHK_RESULT(r, SQL_HANDLE_ENV, env);
+    SQLRETURN r = SQL_SUCCESS;
+    SQLHSTMT stmt = {0};
+    r = SQLAllocHandle(SQL_HANDLE_STMT, conn, &stmt);
     if (r!=SQL_SUCCESS) break;
     do {
-      r = SQLConnect(conn, (SQLCHAR*)dsn, strlen(dsn),
-                           (SQLCHAR*)uid, strlen(uid),
-                           (SQLCHAR*)pwd, strlen(pwd));
-      CHK_RESULT(r, SQL_HANDLE_DBC, conn);
-      if (r!=SQL_SUCCESS) break;
+      if (do_statement(stmt, "drop database if exists db")) {
+        break;
+      }
+      for (size_t i=0; i<sizeof(pre_stmts)/sizeof(pre_stmts[0]); ++i) {
+        n = do_statement(stmt, pre_stmts[i]);
+        if (n) break;
+      }
       do {
+        data_t       data = {0};
+        data.ts      = 1591060628001;
+        data.b       = 1;
+        data.v1      = 127;
+        data.v2      = 32767;
+        data.v4      = 2147483647;
+        data.v8      = 9223372036854775807;
+        data.f4      = 123.456f;
+        data.f8      = 9999999.999999;
+        memset(data.bin, 0, sizeof(data.bin));
+        memset(data.blob, 0, sizeof(data.blob));
+        snprintf(data.bin, sizeof(data.bin), "hel我lo");
+        snprintf(data.blob, sizeof(data.blob), "world");
+        snprintf(data.blob, sizeof(data.blob), "wo人rld");
         SQLHSTMT stmt = {0};
         r = SQLAllocHandle(SQL_HANDLE_STMT, conn, &stmt);
         if (r!=SQL_SUCCESS) break;
         do {
-          do_statement(stmt, "drop database db");
-          for (size_t i=0; i<sizeof(pre_stmts)/sizeof(pre_stmts[0]); ++i) {
-            r = do_statement(stmt, pre_stmts[i]);
-            if (r!=SQL_SUCCESS) break;
-          }
-          do {
-            data_t       data = {0};
-            data.ts      = 1591060628001;
-            data.b       = 1;
-            data.v1      = 127;
-            data.v2      = 32767;
-            data.v4      = 2147483647;
-            data.v8      = 9223372036854775807;
-            data.f4      = 123.456;
-            data.f8      = 9999999.999999;
-            memset(data.bin, 0, sizeof(data.bin));
-            memset(data.blob, 0, sizeof(data.blob));
-            snprintf(data.bin, sizeof(data.bin), "hel我lo");
-            snprintf(data.blob, sizeof(data.blob), "world");
-            snprintf(data.blob, sizeof(data.blob), "wo人rld");
-            SQLHSTMT stmt = {0};
-            r = SQLAllocHandle(SQL_HANDLE_STMT, conn, &stmt);
-            if (r!=SQL_SUCCESS) break;
-            do {
-              r = do_insert(stmt, data);
-              if (r!=SQL_SUCCESS) break;
-            } while (0);
-            SQLFreeHandle(SQL_HANDLE_STMT, stmt);
-
-            // r = SQLAllocHandle(SQL_HANDLE_STMT, conn, &stmt);
-            // if (r!=SQL_SUCCESS) break;
-            // do {
-            //   r = do_insert(stmt, ts++, v++);
-            //   if (r!=SQL_SUCCESS) break;
-            // } while (0);
-            // SQLFreeHandle(SQL_HANDLE_STMT, stmt);
-          } while (0);
-          if (r!=SQL_SUCCESS) break;
-          for (size_t i=0; i<sizeof(pro_stmts)/sizeof(pro_stmts[0]); ++i) {
-            r = do_statement(stmt, pro_stmts[i]);
-            if (r!=SQL_SUCCESS) break;
-          }
+          n = do_insert(stmt, data);
+          if (n) break;
         } while (0);
         SQLFreeHandle(SQL_HANDLE_STMT, stmt);
+
+        // r = SQLAllocHandle(SQL_HANDLE_STMT, conn, &stmt);
+        // if (r!=SQL_SUCCESS) break;
+        // do {
+        //   r = do_insert(stmt, ts++, v++);
+        //   if (r!=SQL_SUCCESS) break;
+        // } while (0);
+        // SQLFreeHandle(SQL_HANDLE_STMT, stmt);
+        ok = 1;
       } while (0);
-      SQLDisconnect(conn);
+      if (!ok) break;
+      ok = 0;
+      for (size_t i=0; i<sizeof(pro_stmts)/sizeof(pro_stmts[0]); ++i) {
+        n = do_statement(stmt, pro_stmts[i]);
+        if (n) break;
+      }
+      ok = 1;
     } while (0);
-    SQLFreeConnect(conn);
+    SQLFreeHandle(SQL_HANDLE_STMT, stmt);
   } while (0);
+  SQLDisconnect(conn);
+  SQLFreeConnect(conn);
   SQLFreeEnv(env);
+
+  return ok ? 0 : 1;
+}
+
+int test_statements(const char *dsn, const char *uid, const char *pwd, const char **statements) {
+  SQLRETURN r = SQL_SUCCESS;
+  SQLHENV env = {0};
+  SQLHDBC conn = {0};
+  int n = open_connect(dsn, uid, pwd, &env, &conn);
+  if (n) return 1;
+  do {
+    SQLHSTMT stmt = {0};
+    r = SQLAllocHandle(SQL_HANDLE_STMT, conn, &stmt);
+    if (r!=SQL_SUCCESS) break;
+    const char **p = statements;
+    while (*p) {
+      if (do_statement(stmt, *p)) {
+        r = SQL_ERROR;
+        break;
+      }
+      ++p;
+    }
+    SQLFreeHandle(SQL_HANDLE_STMT, stmt);
+  } while (0);
+  SQLDisconnect(conn);
+  SQLFreeConnect(conn);
+  SQLFreeEnv(env);
+  return r ? 1 : 0;
+}
+
+int test_driver_connect(const char *connstr) {
+  SQLRETURN r = SQL_SUCCESS;
+  SQLHENV env = {0};
+  SQLHDBC conn = {0};
+  int n = open_driver_connect(connstr, &env, &conn);
+  if (n) return 1;
+  SQLDisconnect(conn);
+  SQLFreeConnect(conn);
+  SQLFreeEnv(env);
+  return r ? 1 : 0;
+}
+
+int create_statement(SQLHENV env, SQLHDBC conn, SQLHSTMT *pStmt) {
+  SQLHSTMT stmt = {0};
+  SQLRETURN r = SQLAllocHandle(SQL_HANDLE_STMT, conn, &stmt);
+  CHK_RESULT(r, SQL_HANDLE_DBC, conn, "");
+  if (r==SQL_SUCCESS) {
+    *pStmt = stmt;
+    return 0;
+  }
+  if (r==SQL_SUCCESS_WITH_INFO) {
+    SQLFreeHandle(SQL_HANDLE_STMT, stmt);
+  }
+  return 1;
+}
+
+int do_statements(SQLHSTMT stmt, const char **statements) {
+  const char **p = statements;
+  while (p && *p) {
+    CHK_TEST(do_statement(stmt, *p));
+    ++p;
+  }
+  return 0;
+}
+
+int tests_stmt(SQLHENV env, SQLHDBC conn, SQLHSTMT stmt) {
+  const char *statements[] = {
+    "drop database if exists m",
+    "create database m",
+    "use m",
+    // "create table t (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, blob binary(1), name nchar(1))",
+    "create table t (ts timestamp, b bool)",
+    "insert into t values('2020-10-10 00:00:00', 0)",
+    "insert into t values('2020-10-10 00:00:00.001', 1)",
+    NULL
+  };
+  CHK_TEST(do_statements(stmt, statements));
+  return 0;
+}
+
+int tests(SQLHENV env, SQLHDBC conn) {
+  SQLHSTMT stmt = {0};
+  CHK_TEST(create_statement(env, conn, &stmt));
+  int r = tests_stmt(env, conn, stmt);
+  SQLFreeHandle(SQL_HANDLE_STMT, stmt);
   return r ? 1 : 0;
 }
 
+int test_env(void) {
+  SQLRETURN r;
+  SQLHENV env = {0};
+  r = SQLAllocEnv(&env);
+  if (r!=SQL_SUCCESS) return 1;
+  SQLFreeEnv(env);
+  return 0;
+}
+
+int test_sqls_in_stmt(SQLHENV env, SQLHDBC conn, SQLHSTMT stmt, const char *sqls) {
+  FILE *f = fopen(sqls, "rb");
+  if (!f) {
+    D("failed to open file [%s]", sqls);
+    return -1;
+  }
+
+  int r = 0;
+  while (!feof(f)) {
+    char *line = NULL;
+    size_t len = 0;
+
+    ssize_t n = 0;
+#ifdef _MSC_VER
+    n = taosGetline(&line, &len, f);
+#else
+    n = getline(&line, &len, f);
+#endif
+    if (n==-1) break;
+
+    const char *p = NULL;
+    do {
+      if (line[0] == '#') break;
+      if (n>0 && line[n-1] == '\n') line[n-1]='\0';
+      if (n>0 && line[n-1] == '\r') line[n-1]='\0';
+      if (n>1 && line[n-2] == '\r') line[n-2]='\0';
+      p = line;
+      while (isspace(*p)) ++p;
+
+      if (*p==0) break;
+
+      int positive = 1;
+      if (strncmp(p, "N:", 2)==0) {
+        positive = 0;
+        p += 2;
+      } else if (strncmp(p, "P:", 2)==0) {
+        p += 2;
+      }
+
+      D("statement: [%s]", p);
+      r = do_statement(stmt, p);
+
+      if (positive && r==0) break;
+      if (!positive && r) { r = 0; break; }
+      if (positive) return r;
+      D("expecting negative result, but got positive");
+      return -1;
+    } while (0);
+
+    free(line);
+
+    if (r) break;
+  }
+
+  fclose(f);
+  return r ? 1 : 0;
+}
+
+int test_sqls_in_conn(SQLHENV env, SQLHDBC conn, const char *sqls) {
+  SQLHSTMT stmt = {0};
+  CHK_TEST(create_statement(env, conn, &stmt));
+  int r = test_sqls_in_stmt(env, conn, stmt, sqls);
+  SQLFreeHandle(SQL_HANDLE_STMT, stmt);
+  return r ? 1 : 0;
+}
+
+int test_sqls(const char *dsn, const char *uid, const char *pwd, const char *connstr, const char *sqls) {
+  int r = 0;
+  SQLHENV env  = {0};
+  SQLHDBC conn = {0};
+  if (dsn) {
+    CHK_TEST(open_connect(dsn, uid, pwd, &env, &conn));
+  } else {
+    CHK_TEST(open_driver_connect(connstr, &env, &conn));
+  }
+  if (sqls) {
+    r = test_sqls_in_conn(env, conn, sqls);
+  }
+  SQLDisconnect(conn);
+  SQLFreeConnect(conn);
+  SQLFreeEnv(env);
+  return r ? 1 : 0;
+}
+
+void usage(const char *arg0) {
+  fprintf(stdout, "%s usage:\n", arg0);
+  fprintf(stdout, "%s [--dsn <dsn>] [--uid <uid>] [--pwd <pwd>] [--dcs <dcs>] [--sts <sts>]\n", arg0);
+  fprintf(stdout, "  --dsn <dsn>: DSN\n");
+  fprintf(stdout, "  --uid <uid>: UID\n");
+  fprintf(stdout, "  --pwd <pwd>: PWD\n");
+  fprintf(stdout, "  --dcs <dcs>: driver connection string\n");
+  fprintf(stdout, "  --sts <sts>: file where statements store\n");
+}
+
+int main(int argc, char *argv[]) {
+  // if (argc==1) {
+  //   CHK_TEST(test_env());
+  //   CHK_TEST(test1("TAOS_DSN", "root", "taoxsdata"));
+  //   D("Done!");
+  //   return 0;
+  // }
+
+  const char *dsn = NULL;
+  const char *uid = NULL;
+  const char *pwd = NULL;
+  const char *dcs = NULL; // driver connection string
+  const char *sts = NULL; // statements file
+  for (size_t i=1; i<argc; ++i) {
+    const char *arg = argv[i];
+    if (strcmp(arg, "-h")==0) {
+      usage(argv[0]);
+      return 0;
+    }
+    if (strcmp(arg, "--dsn")==0) {
+      ++i;
+      if (i>=argc) {
+        D("<dsn> expected but got nothing");
+        return 1;
+      }
+      if (dcs) {
+        D("--dcs has already been specified");
+        return 1;
+      }
+      dsn = argv[i];
+      continue;
+    }
+    if (strcmp(arg, "--uid")==0) {
+      ++i;
+      if (i>=argc) {
+        D("<uid> expected but got nothing");
+        return 1;
+      }
+      uid = argv[i];
+      continue;
+    }
+    if (strcmp(arg, "--pwd")==0) {
+      ++i;
+      if (i>=argc) {
+        D("<pwd> expected but got nothing");
+        return 1;
+      }
+      pwd = argv[i];
+      continue;
+    }
+    if (strcmp(arg, "--dcs")==0) {
+      ++i;
+      if (i>=argc) {
+        D("<dcs> expected but got nothing");
+        return 1;
+      }
+      if (dsn || uid || pwd) {
+        D("either of --dsn/--uid/--pwd has already been specified");
+        return 1;
+      }
+      dcs = argv[i];
+      continue;
+    }
+    if (strcmp(arg, "--sts")==0) {
+      ++i;
+      if (i>=argc) {
+        D("<sts> expected but got nothing");
+        return 1;
+      }
+      sts = argv[i];
+      continue;
+    }
+  }
+  CHK_TEST(test_sqls(dsn, uid, pwd, dcs, sts));
+  D("Done!");
+  return 0;
+
+  if (0) {
+    const char *dsn = (argc>1) ? argv[1] : NULL;
+    const char *uid = (argc>2) ? argv[2] : NULL;
+    const char *pwd = (argc>3) ? argv[3] : NULL;
+    const char *connstr = (argc>4) ? argv[4] : NULL;
+    const char *sqls = (argc>5) ? argv[5] : NULL;
+
+    dsn = NULL;
+    uid = NULL;
+    pwd = NULL;
+    connstr = argv[1];
+    sqls = argv[2];
+    if (0) {
+      CHK_TEST(test_env());
+
+      CHK_TEST(test1(dsn, uid, pwd));
+
+      const char *statements[] = {
+        "drop database if exists m",
+        "create database m",
+        "use m",
+        "drop database m",
+        NULL
+      };
+      CHK_TEST(test_statements(dsn, uid, pwd, statements));
+
+      if (connstr)
+        CHK_TEST(test_driver_connect(connstr));
+
+      if (connstr) {
+        SQLHENV env  = {0};
+        SQLHDBC conn = {0};
+        CHK_TEST(open_driver_connect(connstr, &env, &conn));
+        int r = tests(env, conn);
+        SQLDisconnect(conn);
+        SQLFreeConnect(conn);
+        SQLFreeEnv(env);
+        if (r) return 1;
+      }
+    }
+
+    if ((dsn || connstr) && 1) {
+      CHK_TEST(test_sqls(dsn, uid, pwd, connstr, sqls));
+    }
+
+    D("Done!");
+    return 0;
+  }
+}
+
diff --git a/src/connector/odbc/tests/odbc.py b/src/connector/odbc/tests/odbc.py
index d2de8f39c631dff15a29565a9a19582c58c43b6f..c137905775e567f6163846690886850cb77a684a 100644
--- a/src/connector/odbc/tests/odbc.py
+++ b/src/connector/odbc/tests/odbc.py
@@ -1,16 +1,17 @@
 import pyodbc
-cnxn = pyodbc.connect('DSN=TAOS_DSN;UID=root;PWD=taosdata', autocommit=True)
+# cnxn = pyodbc.connect('DSN={TAOS_DSN};UID={ root };PWD={ taosdata };HOST={ localhost:6030 }', autocommit=True)
+cnxn = pyodbc.connect('DSN={TAOS_DSN}; UID=root;PWD=taosdata; HOST=localhost:6030', autocommit=True)
 cnxn.setdecoding(pyodbc.SQL_CHAR, encoding='utf-8')
 #cnxn.setdecoding(pyodbc.SQL_WCHAR, encoding='utf-8')
 #cnxn.setencoding(encoding='utf-8')
 
-cursor = cnxn.cursor()
-cursor.execute("SELECT * from db.t")
-row = cursor.fetchone()
-while row:
-    print(row)
-    row = cursor.fetchone()
-cursor.close()
+#cursor = cnxn.cursor()
+#cursor.execute("SELECT * from db.t")
+#row = cursor.fetchone()
+#while row:
+#    print(row)
+#    row = cursor.fetchone()
+#cursor.close()
 
 #cursor = cnxn.cursor()
 #cursor.execute("""
@@ -36,32 +37,32 @@ cursor.execute("create database db");
 cursor.close()
 
 cursor = cnxn.cursor()
-cursor.execute("create table db.t (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin binary(40), blob nchar(10))");
+cursor.execute("create table db.mt (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin binary(40), blob nchar(10))");
 cursor.close()
 
 cursor = cnxn.cursor()
-cursor.execute("insert into db.t values('2020-10-13 06:44:00', 1, 127, 32767, 32768, 32769, 123.456, 789.987, 'hello', 'world')")
+cursor.execute("insert into db.mt values('2020-10-13 06:44:00', 1, 127, 32767, 32768, 32769, 123.456, 789.987, 'hello', 'world')")
 cursor.close()
 
 cursor = cnxn.cursor()
-cursor.execute("insert into db.t values(?,?,?,?,?,?,?,?,?,?)", "2020-10-13 07:06:00", 0, 127, 32767, 32768, 32769, 123.456, 789.987, "hel后lo", "wo哈rld");
+cursor.execute("insert into db.mt values(?,?,?,?,?,?,?,?,?,?)", "2020-10-13 07:06:00", 0, 127, 32767, 32768, 32769, 123.456, 789.987, "hel后lo", "wo哈rld");
 cursor.close()
 
 cursor = cnxn.cursor()
-cursor.execute("SELECT * from db.t")
+cursor.execute("SELECT * from db.mt")
 row = cursor.fetchone()
 while row:
     print(row)
     row = cursor.fetchone()
 cursor.close()
 
-cursor = cnxn.cursor()
-cursor.execute("drop database if exists db");
-cursor.close()
-
-cursor = cnxn.cursor()
-cursor.execute("create database db");
-cursor.close()
+#cursor = cnxn.cursor()
+#cursor.execute("drop database if exists db");
+#cursor.close()
+#
+#cursor = cnxn.cursor()
+#cursor.execute("create database db");
+#cursor.close()
 
 cursor = cnxn.cursor()
 cursor.execute("create table db.t (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, bin binary(4), blob nchar(4))");
@@ -118,3 +119,13 @@ while row:
     row = cursor.fetchone()
 cursor.close()
 
+cursor = cnxn.cursor()
+cursor.execute("create table db.f (ts timestamp, v1 float)")
+cursor.close()
+
+params = [ ('2020-10-20 00:00:10', '123.3') ]
+cursor = cnxn.cursor()
+cursor.fast_executemany = True
+cursor.executemany("insert into db.f values (?, ?)", params)
+cursor.close()
+
diff --git a/src/connector/odbc/tests/query_data.stmts b/src/connector/odbc/tests/query_data.stmts
new file mode 100644
index 0000000000000000000000000000000000000000..b0e9ea27ea81f53780ebf3bced8e8a5f63bf7e2b
--- /dev/null
+++ b/src/connector/odbc/tests/query_data.stmts
@@ -0,0 +1 @@
+P:select * from m.t;
diff --git a/src/connector/odbc/tests/select.stmts b/src/connector/odbc/tests/select.stmts
new file mode 100644
index 0000000000000000000000000000000000000000..f7152ba6cf59ae2d0af75bba1845f6fb80150a0e
--- /dev/null
+++ b/src/connector/odbc/tests/select.stmts
@@ -0,0 +1,4 @@
+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
diff --git a/src/connector/odbc/tests/simples.stmts b/src/connector/odbc/tests/simples.stmts
new file mode 100644
index 0000000000000000000000000000000000000000..0db58a8807491b9ea4be96dc7c4efc5b43488244
--- /dev/null
+++ b/src/connector/odbc/tests/simples.stmts
@@ -0,0 +1,44 @@
+P:drop database if exists m;
+P:create database m;
+P:use m;
+
+P:create table t (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, blob binary(1), name nchar(1));
+P:insert into t (ts, b) values('2020-10-10 00:00:00', 0);
+P:insert into t (ts, b) values('2020-10-10 00:00:00.001', 1);
+P:insert into t (ts, b) values('2020-10-10 00:00:00.002', 10);
+P:select * from t;
+
+P:drop table t;
+P:create table t (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, blob binary(1), name nchar(1));
+P:insert into t (ts, v1) values('2020-10-10 00:00:00', 0);
+P:insert into t (ts, v1) values('2020-10-10 00:00:00.001', 1);
+P:insert into t (ts, v1) values('2020-10-10 00:00:00.002', 10);
+P:select * from t;
+
+P:drop table t;
+P:create table t (ts timestamp, b bool, v1 tinyint, v2 smallint, v4 int, v8 bigint, f4 float, f8 double, blob binary(1), name nchar(1));
+P:insert into t (ts, name) values('2020-10-10 00:00:00', 0);
+P:insert into t (ts, name) values('2020-10-10 00:00:00.001', 1);
+P:insert into t (ts, name) values('2020-10-10 00:00:00.002', '人');
+P:insert into t (ts, name) values('2020-10-10 00:00:00.003', 'a');
+P:select * from t;
+
+P:drop table 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) values('2020-10-10 00:00:00', 0);
+P:insert into t (ts, blob) values('2020-10-10 00:00:00.001', 1);
+P:insert into t (ts, blob) values('2020-10-10 00:00:00.002', 'a');
+P:insert into t (ts, blob) values('2020-10-10 00:00:00.003', 'b');
+P:insert into t (ts, blob) values('2020-10-10 00:00:00.004', '人');
+P:select * from t;
+
+P:drop table 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));
+N:insert into t (ts, blob) values('2020-10-10 00:00:00', '1234');
+N:insert into t (ts, blob) values('2020-10-10 00:00:00.001', '0000');
+N:insert into t (ts, blob) values('2020-10-10 00:00:00.002', '人a');
+P:insert into t (ts, blob) values('2020-10-10 00:00:00.003', 'a');
+P:insert into t (ts, blob) values('2020-10-10 00:00:00.004', 'b');
+P:insert into t (ts, blob) values('2020-10-10 00:00:00.005', '人');
+P:select * from t;
+
diff --git a/src/connector/odbc/tests/tconv.c b/src/connector/odbc/tests/tconv.c
new file mode 100644
index 0000000000000000000000000000000000000000..acae6421bbe52d8522f37a756d5097a3b32bb5c7
--- /dev/null
+++ b/src/connector/odbc/tests/tconv.c
@@ -0,0 +1,156 @@
+#include "../src/todbc_log.h"
+
+#ifdef _MSC_VER
+#include <winsock2.h>
+#include <windows.h>
+#endif
+
+#include <iconv.h>
+
+
+#include <stdio.h>
+#include <string.h>
+
+static void usage(const char *arg0);
+static int  do_conv(iconv_t cnv, FILE *fin, FILE *fout);
+
+int main(int argc, char *argv[]) {
+  const char *from_enc = "UTF-8";
+  const char *to_enc   = "UTF-8";
+  const char *dst_file = NULL;
+  const char *src      = NULL;
+#ifdef _MSC_VER
+  from_enc = "CP936";
+  to_enc   = "CP936";
+#endif
+  for (int i = 1; i < argc; i++) {
+    const char *arg = argv[i];
+    if (strcmp(arg, "-h") == 0) {
+      usage(argv[0]);
+      return 0;
+    } else if (strcmp(arg, "-f") == 0 ) {
+      i += 1;
+      if (i>=argc) {
+        fprintf(stderr, "expecing <from_enc>, but got nothing\n");
+        return 1;
+      }
+      from_enc = argv[i];
+      continue;
+    } else if (strcmp(arg, "-t") == 0 ) {
+      i += 1;
+      if (i>=argc) {
+        fprintf(stderr, "expecing <to_enc>, but got nothing\n");
+        return 1;
+      }
+      to_enc = argv[i];
+      continue;
+    } else if (strcmp(arg, "-o") == 0 ) {
+      i += 1;
+      if (i>=argc) {
+        fprintf(stderr, "expecing <dst_file>, but got nothing\n");
+        return 1;
+      }
+      dst_file = argv[i];
+      continue;
+    } else if (arg[0]=='-') {
+      fprintf(stderr, "unknown argument: [%s]\n", arg);
+      return 1;
+    } else {
+      if (src) {
+        fprintf(stderr, "does not allow multiple files\n");
+        return 1;
+      }
+      src = arg;
+      continue;
+    }
+  }
+  int r = -1;
+  FILE *fin = src ? fopen(src, "rb") : stdin;
+  FILE *fout = dst_file ? fopen(dst_file, "wb") : stdout;
+  iconv_t cnv = iconv_open(to_enc, from_enc);
+  do {
+    if (!fin) {
+      fprintf(stderr, "failed to open file [%s]\n", src);
+      break;
+    }
+    if (!fout) {
+      fprintf(stderr, "failed to open file [%s]\n", dst_file);
+      break;
+    }
+#ifdef _MSC_VER
+    if (fout == stdout) {
+      r = _setmode(_fileno(fout), _O_BINARY);
+      if (r == -1) {
+        fprintf(stderr, "Cannot set binary mode for output stream: %d[%s]\n", errno, strerror(errno));
+      }
+    }
+#endif
+
+    if (cnv == (iconv_t)-1) {
+      fprintf(stderr, "failed to open conv from [%s] to [%s]: [%s]\n", from_enc, to_enc, strerror(errno));
+      break;
+    }
+    r = do_conv(cnv, fin, fout);
+    iconv_close(cnv);
+    cnv = (iconv_t)-1;
+  } while (0);
+  if (fin && fin != stdin) fclose(fin);
+  if (fout && fout != stdout) fclose(fout);
+  return r ? 1 : 0;
+}
+
+static void usage(const char *arg0) {
+  fprintf(stderr, "%s -h | [-f <from_enc>] [-t <to_enc>] [-o <dst file>] [file]\n", arg0);
+  return;
+}
+
+#define IN_SIZE     (64*1024)
+#define OUT_SIZE    (8*IN_SIZE)
+static int do_conv(iconv_t cnv, FILE *fin, FILE *fout) {
+  int r = 0;
+  char src[IN_SIZE];
+  size_t slen = sizeof(src);
+  char dst[OUT_SIZE];
+  size_t dlen = sizeof(dst);
+  char *start = src;
+  while (!feof(fin)) {
+    slen = (size_t)(src + sizeof(src)  - start);
+    size_t n = fread(start, 1, slen, fin);
+    if (n>0) {
+      char   *ss = src;
+      size_t  sl = n;
+      while (sl) {
+        char   *dd = dst;
+        size_t  dn = dlen;
+        size_t v = iconv(cnv, &ss, &sl, &dd, &dn);
+        if (v==(size_t)-1) {
+          int err = errno;
+          if (err == EILSEQ) {
+            fprintf(stderr, "failed to convert: [%s]\n", strerror(err));
+            r = -1;
+            break;
+          }
+          if (err == EINVAL) {
+            fprintf(stderr, "[%s]\n", strerror(errno));
+            size_t ava = (size_t)(src + sizeof(src) - ss);
+            memcpy(src, ss, ava);
+            start = ss;
+          } else {
+            fprintf(stderr, "internal logic error: [%s]\n", strerror(errno));
+            r = -1;
+            break;
+          }
+        }
+        n = fwrite(dst, 1, (size_t)(dd-dst), fout);
+        if (n<dd-dst) {
+          fprintf(stderr, "failed to write: [%s]\n", strerror(errno));
+          r = -1;
+          break;
+        }
+      }
+      if (r) break;
+    }
+  }
+  return r ? -1 : 0;
+}
+
diff --git a/src/connector/odbc/tools/CMakeLists.txt b/src/connector/odbc/tools/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..a0aafb1f3ca36bb0b6fb108e1948214b2dd14a6f
--- /dev/null
+++ b/src/connector/odbc/tools/CMakeLists.txt
@@ -0,0 +1,12 @@
+PROJECT(TDengine)
+
+IF (TD_LINUX)
+  ADD_EXECUTABLE(todbcinst main.c)
+  TARGET_LINK_LIBRARIES(todbcinst odbc odbcinst)
+ENDIF ()
+
+IF (TD_WINDOWS_64)
+  ADD_EXECUTABLE(todbcinst main.c)
+  TARGET_LINK_LIBRARIES(todbcinst odbc32 odbccp32 user32 legacy_stdio_definitions os)
+  INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/todbcinst.exe DESTINATION .)
+ENDIF ()
diff --git a/src/connector/odbc/tools/main.c b/src/connector/odbc/tools/main.c
new file mode 100644
index 0000000000000000000000000000000000000000..7b8421c4e1d54d33a88ca1805e7e4871e1447876
--- /dev/null
+++ b/src/connector/odbc/tools/main.c
@@ -0,0 +1,165 @@
+#include "../src/todbc_log.h"
+
+#ifdef _MSC_VER
+#include <winsock2.h>
+#include <windows.h>
+#include "os.h"
+#endif
+#include <odbcinst.h>
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+static void usage(const char *arg0);
+static int do_install(int i, int argc, char *argv[]);
+static int do_uninstall(int i, int argc, char *argv[]);
+
+int main(int argc, char *argv[]) {
+  for (int i = 1; i < argc; i++) {
+    const char *arg = argv[i];
+    if (strcmp(arg, "-h") == 0) {
+      usage(argv[0]);
+      return 0;
+    } else if (strcmp(arg, "-i") == 0 ) {
+      i = do_install(i + 1, argc, argv);
+      if (i > 0) continue;
+      return i == 0 ? 0 : 1;
+    } else if (strcmp(arg, "-u") == 0 ) {
+      i = do_uninstall(i + 1, argc, argv);
+      if (i > 0) continue;
+      return i == 0 ? 0 : 1;
+    } else {
+      fprintf(stderr, "unknown argument: [%s]\n", arg);
+      return 1;
+    }
+  }
+}
+
+static void usage(const char *arg0) {
+  fprintf(stderr, "%s -h | -i -n [TaosDriverName] -p [TaosDriverPath] | -u [-f] -n [TaosDriverName]\n", arg0);
+  return;
+}
+
+static int do_install(int i, int argc, char *argv[]) {
+  const char* driverName = NULL;
+#ifdef _MSC_VER
+  const char* driverFile = "todbc.dll";
+#else
+  const char* driverFile = "libtodbc.so";
+#endif
+  const char* driverPath = NULL;
+  for (; i < argc; ++i) {
+    const char *arg = argv[i];
+    if (strcmp(arg, "-n") == 0) {
+      i += 1;
+      if (i >= argc) {
+        fprintf(stderr, "expecting TaosDriverName, but got nothing\n");
+        return -1;
+      }
+      arg = argv[i];
+      if (strstr(arg, "TAOS") != arg) {
+        fprintf(stderr, "TaosDriverName shall begin with 'TAOS': [%s]\n", arg);
+        return -1;
+      }
+      driverName = arg;
+    } else if (strcmp(arg, "-p") == 0) {
+      i += 1;
+      if (i >= argc) {
+        fprintf(stderr, "expecting TaosDriverPath, but got nothing\n");
+        return -1;
+      }
+      driverPath = argv[i];
+    } else {
+      fprintf(stderr, "unknown argument: [%s]\n", arg);
+      return -1;
+    }
+  }
+  if (!driverName) {
+    fprintf(stderr, "TaosDriverName not specified\n");
+    return -1;
+  }
+  if (!driverPath) {
+    fprintf(stderr, "TaosDriverPath not specified\n");
+    return -1;
+  }
+  char buf[8192];
+  snprintf(buf, sizeof(buf), "%s%cDriver=%s%cFileUage=0%cConnectFunctions=YYN%c",
+    driverName, 0, driverFile, 0, 0, 0);
+  BOOL ok = 1;
+  DWORD usageCount = 1;
+  char installed[PATH_MAX + 1];
+  WORD len = 0;
+  ok = SQLInstallDriverEx(buf, driverPath, installed, sizeof(installed), &len, ODBC_INSTALL_INQUIRY, &usageCount);
+  if (!ok) {
+    fprintf(stderr, "failed to query TaosDriverName: [%s]\n", driverName);
+    return -1;
+  }
+  int r = 0;
+#ifdef _MSC_VER
+  r = stricmp(driverPath, installed);
+#else
+  r = strcasecmp(driverPath, installed);
+#endif
+  if (r) {
+    fprintf(stderr, "previously installed TaosDriver [%s] has different target path [%s]\n"
+      "it shall be uninstalled before you can install it to different path [%s]\n",
+      driverName, installed, driverPath);
+    return -1;
+  }
+  ok = SQLInstallDriverEx(buf, driverPath, installed, sizeof(installed), &len, ODBC_INSTALL_COMPLETE, &usageCount);
+  if (!ok) {
+    fprintf(stderr, "failed to install TaosDriverName: [%s][%s]\n", driverName, driverPath);
+    return -1;
+  }
+
+  fprintf(stderr, "ODBC driver [%s] has been installed in [%s], and UsageCount is now [%d]\n",
+          driverName, driverPath, usageCount);
+  return argc;
+}
+
+static int do_uninstall(int i, int argc, char *argv[]) {
+  int forceful = 0;
+  const char* driverName = NULL;
+  for (; i < argc; ++i) {
+    const char *arg = argv[i];
+    if (strcmp(arg, "-f") == 0) {
+      forceful = 1;
+    } else if (strcmp(arg, "-n") == 0) {
+      i += 1;
+      if (i >= argc) {
+        fprintf(stderr, "expecting TaosDriverName, but got nothing\n");
+        return -1;
+      }
+      arg = argv[i];
+      if (strstr(arg, "TAOS") != arg) {
+        fprintf(stderr, "TaosDriverName shall begin with 'TAOS': [%s]\n", arg);
+        return -1;
+      }
+      driverName = arg;
+    } else {
+      fprintf(stderr, "unknown argument: [%s]\n", arg);
+      return -1;
+    }
+  }
+  if (!driverName) {
+    fprintf(stderr, "TaosDriverName not specified\n");
+    return -1;
+  }
+  BOOL ok = 1;
+  DWORD usageCount = 1;
+  do {
+    ok = SQLRemoveDriver(driverName, 0, &usageCount);
+    if (!ok) {
+      fprintf(stderr, "failed to remove driver [%s]\n", driverName);
+      return -1;
+    }
+    if (!forceful) {
+      fprintf(stderr, "UsageCount for ODBC driver [%s] is now: [%d]\n", driverName, usageCount);
+      return argc;
+    }
+  } while (usageCount > 0);
+  fprintf(stderr, "ODBC driver [%s] is now fully uninstalled\n", driverName);
+  return argc;
+}
+
diff --git a/src/connector/python/linux/python2/taos/cinterface.py b/src/connector/python/linux/python2/taos/cinterface.py
index 32859f6b340b4393b523d475bce1ac89cef1a040..269326535cfb39373544c71685e8a2b9e9b51db1 100644
--- a/src/connector/python/linux/python2/taos/cinterface.py
+++ b/src/connector/python/linux/python2/taos/cinterface.py
@@ -18,7 +18,7 @@ def _crow_timestamp_to_python(data, num_of_rows, nbytes=None, micro=False):
         _timestamp_converter = _convert_microsecond_to_datetime
 
     if num_of_rows > 0:
-        return list(map(_timestamp_converter, ctypes.cast(data,  ctypes.POINTER(ctypes.c_long))[:abs(num_of_rows)][::-1]))
+        return list(map(_timestamp_converter, ctypes.cast(data,  ctypes.POINTER(ctypes.c_long))[:abs(num_of_rows)][::1]))
     else:
         return list(map(_timestamp_converter, ctypes.cast(data,  ctypes.POINTER(ctypes.c_long))[:abs(num_of_rows)]))
 
@@ -26,7 +26,7 @@ def _crow_bool_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C bool row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele == FieldType.C_BOOL_NULL else bool(ele) for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)][::-1] ]
+        return [ None if ele == FieldType.C_BOOL_NULL else bool(ele) for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if ele == FieldType.C_BOOL_NULL else bool(ele) for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_bool))[:abs(num_of_rows)] ]
 
@@ -34,7 +34,7 @@ def _crow_tinyint_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C tinyint row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele == FieldType.C_TINYINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)][::-1] ]
+        return [ None if ele == FieldType.C_TINYINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if ele == FieldType.C_TINYINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)] ]
     
@@ -42,7 +42,7 @@ def _crow_smallint_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C smallint row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele == FieldType.C_SMALLINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_short))[:abs(num_of_rows)][::-1]]
+        return [ None if ele == FieldType.C_SMALLINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_short))[:abs(num_of_rows)][::1]]
     else:
         return [ None if ele == FieldType.C_SMALLINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_short))[:abs(num_of_rows)] ]
 
@@ -50,7 +50,7 @@ def _crow_int_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C int row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele == FieldType.C_INT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_int))[:abs(num_of_rows)][::-1] ]
+        return [ None if ele == FieldType.C_INT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_int))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if ele == FieldType.C_INT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_int))[:abs(num_of_rows)] ]
 
@@ -58,7 +58,7 @@ def _crow_bigint_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C bigint row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele == FieldType.C_BIGINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_long))[:abs(num_of_rows)][::-1] ]
+        return [ None if ele == FieldType.C_BIGINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_long))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if ele == FieldType.C_BIGINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_long))[:abs(num_of_rows)] ]
 
@@ -66,7 +66,7 @@ def _crow_float_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C float row to python row
     """
     if num_of_rows > 0:
-        return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_float))[:abs(num_of_rows)][::-1] ]
+        return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_float))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_float))[:abs(num_of_rows)] ]
 
@@ -74,7 +74,7 @@ def _crow_double_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C double row to python row
     """
     if num_of_rows > 0:
-        return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_double))[:abs(num_of_rows)][::-1] ]
+        return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_double))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_double))[:abs(num_of_rows)] ]
 
@@ -82,7 +82,7 @@ def _crow_binary_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C binary row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele.value[0:1] == FieldType.C_BINARY_NULL else ele.value.decode('utf-8') for ele in (ctypes.cast(data,  ctypes.POINTER(ctypes.c_char * nbytes)))[:abs(num_of_rows)][::-1]]
+        return [ None if ele.value[0:1] == FieldType.C_BINARY_NULL else ele.value.decode('utf-8') for ele in (ctypes.cast(data,  ctypes.POINTER(ctypes.c_char * nbytes)))[:abs(num_of_rows)][::1]]
     else:
         return [ None if ele.value[0:1] == FieldType.C_BINARY_NULL else ele.value.decode('utf-8') for ele in (ctypes.cast(data,  ctypes.POINTER(ctypes.c_char * nbytes)))[:abs(num_of_rows)]]
 
@@ -311,29 +311,24 @@ class CTaosInterface(object):
     @staticmethod
     def fetchBlock(result, fields):
         pblock = ctypes.c_void_p(0)
-        num_of_rows = CTaosInterface.libtaos.taos_fetch_block(
-            result, ctypes.byref(pblock))
-
-        if num_of_rows == 0:
+        pblock = CTaosInterface.libtaos.taos_fetch_row(result)  
+        if pblock : 
+            num_of_rows = 1
+            isMicro = (CTaosInterface.libtaos.taos_result_precision(result) == FieldType.C_TIMESTAMP_MICRO)
+            blocks = [None] * len(fields)
+            fieldL = CTaosInterface.libtaos.taos_fetch_lengths(result)
+            fieldLen = [ele for ele in ctypes.cast(fieldL,  ctypes.POINTER(ctypes.c_int))[:len(fields)]]
+            for i in range(len(fields)):
+                data = ctypes.cast(pblock, ctypes.POINTER(ctypes.c_void_p))[i]
+                if fields[i]['type'] not in _CONVERT_FUNC:
+                    raise DatabaseError("Invalid data type returned from database")
+                if data is None:
+                    blocks[i] = [None]
+                else:
+                    blocks[i] = _CONVERT_FUNC[fields[i]['type']](data, num_of_rows, fieldLen[i], isMicro)         
+        else:
             return None, 0
-
-        isMicro = (CTaosInterface.libtaos.taos_result_precision(result) == FieldType.C_TIMESTAMP_MICRO)
-        blocks = [None] * len(fields)
-        fieldL = CTaosInterface.libtaos.taos_fetch_lengths(result)
-        fieldLen = [ele for ele in ctypes.cast(fieldL,  ctypes.POINTER(ctypes.c_int))[:len(fields)]]
-        for i in range(len(fields)):
-            data = ctypes.cast(pblock, ctypes.POINTER(ctypes.c_void_p))[i]
-            if data == None:
-                blocks[i] = [None] * num_of_rows
-                continue
-
-            if fields[i]['type'] not in _CONVERT_FUNC:
-                raise DatabaseError("Invalid data type returned from database")
-            
-            blocks[i] = _CONVERT_FUNC[fields[i]['type']](data, num_of_rows, fieldLen[i], isMicro)
-
         return blocks, abs(num_of_rows)
-
     @staticmethod
     def freeResult(result):
         CTaosInterface.libtaos.taos_free_result(result)
diff --git a/src/connector/python/linux/python2/taos/cursor.py b/src/connector/python/linux/python2/taos/cursor.py
index 37c02d330e856717b5ed0bdac76723cf64d3860b..bc6670ca776a351c4739d61fc165d71334ceaa3b 100644
--- a/src/connector/python/linux/python2/taos/cursor.py
+++ b/src/connector/python/linux/python2/taos/cursor.py
@@ -1,6 +1,7 @@
 from .cinterface import CTaosInterface
 from .error import *
 from .constants import FieldType
+import threading
 
 
 class TDengineCursor(object):
@@ -35,6 +36,7 @@ class TDengineCursor(object):
         self._block_iter = 0
         self._affected_rows = 0
         self._logfile = ""
+        self._threadId = threading.get_ident()
 
         if connection is not None:
             self._connection = connection
@@ -42,7 +44,7 @@ class TDengineCursor(object):
     def __iter__(self):
         return self
 
-    def next(self):
+    def __next__(self):
         if self._result is None or self._fields is None:
             raise OperationalError("Invalid use of fetch iterator")
 
@@ -137,7 +139,7 @@ class TDengineCursor(object):
         else:
             raise ProgrammingError(
                 CTaosInterface.errStr(
-                    self._result ), errno)
+                    self._result), errno)
 
     def executemany(self, operation, seq_of_parameters):
         """Prepare a database operation (query or command) and then execute it against all parameter sequences or mappings found in the sequence seq_of_parameters.
@@ -148,6 +150,8 @@ class TDengineCursor(object):
         """Fetch the next row of a query result set, returning a single sequence, or None when no more data is available.
         """
         pass
+    def fetchmany(self):
+        pass
 
     def istype(self, col, dataType):
         if (dataType.upper() == "BOOL"):
@@ -180,9 +184,6 @@ class TDengineCursor(object):
 
         return False
 
-    def fetchmany(self):
-        pass
-
     def fetchall(self):
         """Fetch all (remaining) rows of a query result, returning them as a sequence of sequences (e.g. a list of tuples). Note that the cursor's arraysize attribute can affect the performance of this operation.
         """
@@ -201,8 +202,6 @@ class TDengineCursor(object):
             self._rowcount += num_of_fields
             for i in range(len(self._fields)):
                 buffer[i].extend(block[i])
-
-
         return list(map(tuple, zip(*buffer)))
 
     def nextset(self):
diff --git a/src/connector/python/linux/python3/taos/cinterface.py b/src/connector/python/linux/python3/taos/cinterface.py
index 609154a3a4b38cfd1cf7976fb755e4aef7be3354..be5b99d8c18272c5f53d1e49f731588b70062b29 100644
--- a/src/connector/python/linux/python3/taos/cinterface.py
+++ b/src/connector/python/linux/python3/taos/cinterface.py
@@ -18,7 +18,7 @@ def _crow_timestamp_to_python(data, num_of_rows, nbytes=None, micro=False):
         _timestamp_converter = _convert_microsecond_to_datetime
 
     if num_of_rows > 0:
-        return list(map(_timestamp_converter, ctypes.cast(data,  ctypes.POINTER(ctypes.c_long))[:abs(num_of_rows)][::-1]))
+        return list(map(_timestamp_converter, ctypes.cast(data,  ctypes.POINTER(ctypes.c_long))[:abs(num_of_rows)][::1]))
     else:
         return list(map(_timestamp_converter, ctypes.cast(data,  ctypes.POINTER(ctypes.c_long))[:abs(num_of_rows)]))
 
@@ -26,7 +26,7 @@ def _crow_bool_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C bool row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele == FieldType.C_BOOL_NULL else bool(ele) for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)][::-1] ]
+        return [ None if ele == FieldType.C_BOOL_NULL else bool(ele) for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if ele == FieldType.C_BOOL_NULL else bool(ele) for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_bool))[:abs(num_of_rows)] ]
 
@@ -34,7 +34,7 @@ def _crow_tinyint_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C tinyint row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele == FieldType.C_TINYINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)][::-1] ]
+        return [ None if ele == FieldType.C_TINYINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if ele == FieldType.C_TINYINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)] ]
     
@@ -42,7 +42,7 @@ def _crow_smallint_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C smallint row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele == FieldType.C_SMALLINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_short))[:abs(num_of_rows)][::-1]]
+        return [ None if ele == FieldType.C_SMALLINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_short))[:abs(num_of_rows)][::1]]
     else:
         return [ None if ele == FieldType.C_SMALLINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_short))[:abs(num_of_rows)] ]
 
@@ -50,7 +50,7 @@ def _crow_int_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C int row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele == FieldType.C_INT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_int))[:abs(num_of_rows)][::-1] ]
+        return [ None if ele == FieldType.C_INT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_int))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if ele == FieldType.C_INT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_int))[:abs(num_of_rows)] ]
 
@@ -58,7 +58,7 @@ def _crow_bigint_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C bigint row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele == FieldType.C_BIGINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_long))[:abs(num_of_rows)][::-1] ]
+        return [ None if ele == FieldType.C_BIGINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_long))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if ele == FieldType.C_BIGINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_long))[:abs(num_of_rows)] ]
 
@@ -66,7 +66,7 @@ def _crow_float_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C float row to python row
     """
     if num_of_rows > 0:
-        return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_float))[:abs(num_of_rows)][::-1] ]
+        return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_float))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_float))[:abs(num_of_rows)] ]
 
@@ -74,7 +74,7 @@ def _crow_double_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C double row to python row
     """
     if num_of_rows > 0:
-        return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_double))[:abs(num_of_rows)][::-1] ]
+        return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_double))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_double))[:abs(num_of_rows)] ]
 
@@ -82,7 +82,7 @@ def _crow_binary_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C binary row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele.value[0:1] == FieldType.C_BINARY_NULL else ele.value.decode('utf-8') for ele in (ctypes.cast(data,  ctypes.POINTER(ctypes.c_char * nbytes)))[:abs(num_of_rows)][::-1]]
+        return [ None if ele.value[0:1] == FieldType.C_BINARY_NULL else ele.value.decode('utf-8') for ele in (ctypes.cast(data,  ctypes.POINTER(ctypes.c_char * nbytes)))[:abs(num_of_rows)][::1]]
     else:
         return [ None if ele.value[0:1] == FieldType.C_BINARY_NULL else ele.value.decode('utf-8') for ele in (ctypes.cast(data,  ctypes.POINTER(ctypes.c_char * nbytes)))[:abs(num_of_rows)]]
 
@@ -111,7 +111,7 @@ def _crow_nchar_to_python(data, num_of_rows, nbytes=None, micro=False):
     #         except ValueError:
     #             res.append(None)
     #     return res
-    #         # return [ele.value for ele in (ctypes.cast(data,  ctypes.POINTER(ctypes.c_wchar * (nbytes//4))))[:abs(num_of_rows)][::-1]]
+    #         # return [ele.value for ele in (ctypes.cast(data,  ctypes.POINTER(ctypes.c_wchar * (nbytes//4))))[:abs(num_of_rows)][::1]]
     # else:
     #     return [ele.value for ele in (ctypes.cast(data,  ctypes.POINTER(ctypes.c_wchar * (nbytes//4))))[:abs(num_of_rows)]]
 
@@ -308,32 +308,48 @@ class CTaosInterface(object):
 
         return fields
 
+    # @staticmethod
+    # def fetchBlock(result, fields):
+    #     pblock = ctypes.c_void_p(0)
+    #     num_of_rows = CTaosInterface.libtaos.taos_fetch_block(
+    #         result, ctypes.byref(pblock))
+    #     if num_of_rows == 0:
+    #         return None, 0
+
+    #     isMicro = (CTaosInterface.libtaos.taos_result_precision(result) == FieldType.C_TIMESTAMP_MICRO)
+    #     blocks = [None] * len(fields)
+    #     fieldL = CTaosInterface.libtaos.taos_fetch_lengths(result)
+    #     fieldLen = [ele for ele in ctypes.cast(fieldL,  ctypes.POINTER(ctypes.c_int))[:len(fields)]]
+    #     for i in range(len(fields)):
+    #         data = ctypes.cast(pblock, ctypes.POINTER(ctypes.c_void_p))[i]
+
+    #         if fields[i]['type'] not in _CONVERT_FUNC:
+    #             raise DatabaseError("Invalid data type returned from database")
+    #         print('====================',fieldLen[i])
+    #         blocks[i] = _CONVERT_FUNC[fields[i]['type']](data, num_of_rows, fieldLen[i], isMicro)
+
+    #     return blocks, abs(num_of_rows)
     @staticmethod
     def fetchBlock(result, fields):
         pblock = ctypes.c_void_p(0)
-        num_of_rows = CTaosInterface.libtaos.taos_fetch_block(
-            result, ctypes.byref(pblock))
-
-        if num_of_rows == 0:
+        pblock = CTaosInterface.libtaos.taos_fetch_row(result)  
+        if pblock : 
+            num_of_rows = 1
+            isMicro = (CTaosInterface.libtaos.taos_result_precision(result) == FieldType.C_TIMESTAMP_MICRO)
+            blocks = [None] * len(fields)
+            fieldL = CTaosInterface.libtaos.taos_fetch_lengths(result)
+            fieldLen = [ele for ele in ctypes.cast(fieldL,  ctypes.POINTER(ctypes.c_int))[:len(fields)]]
+            for i in range(len(fields)):
+                data = ctypes.cast(pblock, ctypes.POINTER(ctypes.c_void_p))[i]
+                if fields[i]['type'] not in _CONVERT_FUNC:
+                    raise DatabaseError("Invalid data type returned from database")
+                if data is None:
+                    blocks[i] = [None]
+                else:
+                    blocks[i] = _CONVERT_FUNC[fields[i]['type']](data, num_of_rows, fieldLen[i], isMicro)         
+        else:
             return None, 0
-
-        isMicro = (CTaosInterface.libtaos.taos_result_precision(result) == FieldType.C_TIMESTAMP_MICRO)
-        blocks = [None] * len(fields)
-        fieldL = CTaosInterface.libtaos.taos_fetch_lengths(result)
-        fieldLen = [ele for ele in ctypes.cast(fieldL,  ctypes.POINTER(ctypes.c_int))[:len(fields)]]
-        for i in range(len(fields)):
-            data = ctypes.cast(pblock, ctypes.POINTER(ctypes.c_void_p))[i]
-            if data == None:
-                blocks[i] = [None] * num_of_rows
-                continue
-
-            if fields[i]['type'] not in _CONVERT_FUNC:
-                raise DatabaseError("Invalid data type returned from database")
-            
-            blocks[i] = _CONVERT_FUNC[fields[i]['type']](data, num_of_rows, fieldLen[i], isMicro)
-
         return blocks, abs(num_of_rows)
-
     @staticmethod
     def freeResult(result):
         CTaosInterface.libtaos.taos_free_result(result)
diff --git a/src/connector/python/linux/python3/taos/cursor.py b/src/connector/python/linux/python3/taos/cursor.py
index ec7a85ee1a3f8cb0cd49aca8c2a4242dca89021e..eb10bed4859828961a0c521e146c18a5f8e21d7c 100644
--- a/src/connector/python/linux/python3/taos/cursor.py
+++ b/src/connector/python/linux/python3/taos/cursor.py
@@ -216,7 +216,6 @@ class TDengineCursor(object):
             self._rowcount += num_of_fields
             for i in range(len(self._fields)):
                 buffer[i].extend(block[i])
-
         return list(map(tuple, zip(*buffer)))
 
     def nextset(self):
diff --git a/src/connector/python/windows/python2/taos/cinterface.py b/src/connector/python/windows/python2/taos/cinterface.py
index 6a9c5bfcef0d317844b6b58796f307e5cf155a43..084d38e41cee0e8c31a11d319d47e6bc5b125bd7 100644
--- a/src/connector/python/windows/python2/taos/cinterface.py
+++ b/src/connector/python/windows/python2/taos/cinterface.py
@@ -18,7 +18,7 @@ def _crow_timestamp_to_python(data, num_of_rows, nbytes=None, micro=False):
         _timestamp_converter = _convert_microsecond_to_datetime
 
     if num_of_rows > 0:
-        return list(map(_timestamp_converter, ctypes.cast(data,  ctypes.POINTER(ctypes.c_longlong))[:abs(num_of_rows)][::-1]))
+        return list(map(_timestamp_converter, ctypes.cast(data,  ctypes.POINTER(ctypes.c_longlong))[:abs(num_of_rows)][::1]))
     else:
         return list(map(_timestamp_converter, ctypes.cast(data,  ctypes.POINTER(ctypes.c_longlong))[:abs(num_of_rows)]))
 
@@ -26,7 +26,7 @@ def _crow_bool_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C bool row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele == FieldType.C_BOOL_NULL else bool(ele) for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)][::-1] ]
+        return [ None if ele == FieldType.C_BOOL_NULL else bool(ele) for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if ele == FieldType.C_BOOL_NULL else bool(ele) for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_bool))[:abs(num_of_rows)] ]
 
@@ -34,7 +34,7 @@ def _crow_tinyint_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C tinyint row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele == FieldType.C_TINYINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)][::-1] ]
+        return [ None if ele == FieldType.C_TINYINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if ele == FieldType.C_TINYINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)] ]
     
@@ -42,7 +42,7 @@ def _crow_smallint_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C smallint row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele == FieldType.C_SMALLINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_short))[:abs(num_of_rows)][::-1]]
+        return [ None if ele == FieldType.C_SMALLINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_short))[:abs(num_of_rows)][::1]]
     else:
         return [ None if ele == FieldType.C_SMALLINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_short))[:abs(num_of_rows)] ]
 
@@ -50,7 +50,7 @@ def _crow_int_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C int row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele == FieldType.C_INT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_int))[:abs(num_of_rows)][::-1] ]
+        return [ None if ele == FieldType.C_INT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_int))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if ele == FieldType.C_INT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_int))[:abs(num_of_rows)] ]
 
@@ -58,7 +58,7 @@ def _crow_bigint_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C bigint row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele == FieldType.C_BIGINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_longlong))[:abs(num_of_rows)][::-1] ]
+        return [ None if ele == FieldType.C_BIGINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_longlong))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if ele == FieldType.C_BIGINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_longlong))[:abs(num_of_rows)] ]
 
@@ -66,7 +66,7 @@ def _crow_float_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C float row to python row
     """
     if num_of_rows > 0:
-        return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_float))[:abs(num_of_rows)][::-1] ]
+        return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_float))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_float))[:abs(num_of_rows)] ]
 
@@ -74,7 +74,7 @@ def _crow_double_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C double row to python row
     """
     if num_of_rows > 0:
-        return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_double))[:abs(num_of_rows)][::-1] ]
+        return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_double))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_double))[:abs(num_of_rows)] ]
 
@@ -82,7 +82,7 @@ def _crow_binary_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C binary row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele.value[0:1] == FieldType.C_BINARY_NULL else ele.value.decode('utf-8') for ele in (ctypes.cast(data,  ctypes.POINTER(ctypes.c_char * nbytes)))[:abs(num_of_rows)][::-1]]
+        return [ None if ele.value[0:1] == FieldType.C_BINARY_NULL else ele.value.decode('utf-8') for ele in (ctypes.cast(data,  ctypes.POINTER(ctypes.c_char * nbytes)))[:abs(num_of_rows)][::1]]
     else:
         return [ None if ele.value[0:1] == FieldType.C_BINARY_NULL else ele.value.decode('utf-8') for ele in (ctypes.cast(data,  ctypes.POINTER(ctypes.c_char * nbytes)))[:abs(num_of_rows)]]
 
@@ -310,27 +310,23 @@ class CTaosInterface(object):
     @staticmethod
     def fetchBlock(result, fields):
         pblock = ctypes.c_void_p(0)
-        num_of_rows = CTaosInterface.libtaos.taos_fetch_block(
-            result, ctypes.byref(pblock))
-
-        if num_of_rows == 0:
+        pblock = CTaosInterface.libtaos.taos_fetch_row(result)  
+        if pblock : 
+            num_of_rows = 1
+            isMicro = (CTaosInterface.libtaos.taos_result_precision(result) == FieldType.C_TIMESTAMP_MICRO)
+            blocks = [None] * len(fields)
+            fieldL = CTaosInterface.libtaos.taos_fetch_lengths(result)
+            fieldLen = [ele for ele in ctypes.cast(fieldL,  ctypes.POINTER(ctypes.c_int))[:len(fields)]]
+            for i in range(len(fields)):
+                data = ctypes.cast(pblock, ctypes.POINTER(ctypes.c_void_p))[i]
+                if fields[i]['type'] not in _CONVERT_FUNC:
+                    raise DatabaseError("Invalid data type returned from database")
+                if data is None:
+                    blocks[i] = [None]
+                else:
+                    blocks[i] = _CONVERT_FUNC[fields[i]['type']](data, num_of_rows, fieldLen[i], isMicro)         
+        else:
             return None, 0
-
-        isMicro = (CTaosInterface.libtaos.taos_result_precision(result) == FieldType.C_TIMESTAMP_MICRO)
-        blocks = [None] * len(fields)
-        fieldL = CTaosInterface.libtaos.taos_fetch_lengths(result)
-        fieldLen = [ele for ele in ctypes.cast(fieldL,  ctypes.POINTER(ctypes.c_int))[:len(fields)]]
-        for i in range(len(fields)):
-            data = ctypes.cast(pblock, ctypes.POINTER(ctypes.c_void_p))[i]
-            if data == None:
-                blocks[i] = [None] * num_of_rows
-                continue
-
-            if fields[i]['type'] not in _CONVERT_FUNC:
-                raise DatabaseError("Invalid data type returned from database")
-            
-            blocks[i] = _CONVERT_FUNC[fields[i]['type']](data, num_of_rows, fieldLen[i], isMicro)
-
         return blocks, abs(num_of_rows)
 
     @staticmethod
diff --git a/src/connector/python/windows/python2/taos/cursor.py b/src/connector/python/windows/python2/taos/cursor.py
index 8714fe77cb739f23f79247a41d72aa127b6d6d25..35846cbe11f49386747a5a1f59e5529b84a741a0 100644
--- a/src/connector/python/windows/python2/taos/cursor.py
+++ b/src/connector/python/windows/python2/taos/cursor.py
@@ -1,5 +1,9 @@
 from .cinterface import CTaosInterface
 from .error import *
+from .constants import FieldType
+import threading
+
+# querySeqNum = 0
 
 class TDengineCursor(object):
     """Database cursor which is used to manage the context of a fetch operation.
@@ -32,6 +36,8 @@ class TDengineCursor(object):
         self._block_rows = -1
         self._block_iter = 0
         self._affected_rows = 0
+        self._logfile = ""
+        self._threadId = threading.get_ident()
 
         if connection is not None:
             self._connection = connection
@@ -39,7 +45,7 @@ class TDengineCursor(object):
     def __iter__(self):
         return self
 
-    def next(self):
+    def __next__(self):
         if self._result is None or self._fields is None:
             raise OperationalError("Invalid use of fetch iterator")
 
diff --git a/src/connector/python/windows/python3/taos/cinterface.py b/src/connector/python/windows/python3/taos/cinterface.py
index fa7124431c92a179b2a0042b57e8ad45609ea352..68adf191c9bf696575254974ab6a544d5664faa5 100644
--- a/src/connector/python/windows/python3/taos/cinterface.py
+++ b/src/connector/python/windows/python3/taos/cinterface.py
@@ -18,7 +18,7 @@ def _crow_timestamp_to_python(data, num_of_rows, nbytes=None, micro=False):
         _timestamp_converter = _convert_microsecond_to_datetime
 
     if num_of_rows > 0:
-        return list(map(_timestamp_converter, ctypes.cast(data,  ctypes.POINTER(ctypes.c_longlong))[:abs(num_of_rows)][::-1]))
+        return list(map(_timestamp_converter, ctypes.cast(data,  ctypes.POINTER(ctypes.c_longlong))[:abs(num_of_rows)][::1]))
     else:
         return list(map(_timestamp_converter, ctypes.cast(data,  ctypes.POINTER(ctypes.c_longlong))[:abs(num_of_rows)]))
 
@@ -26,7 +26,7 @@ def _crow_bool_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C bool row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele == FieldType.C_BOOL_NULL else bool(ele) for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)][::-1] ]
+        return [ None if ele == FieldType.C_BOOL_NULL else bool(ele) for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if ele == FieldType.C_BOOL_NULL else bool(ele) for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_bool))[:abs(num_of_rows)] ]
 
@@ -34,7 +34,7 @@ def _crow_tinyint_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C tinyint row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele == FieldType.C_TINYINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)][::-1] ]
+        return [ None if ele == FieldType.C_TINYINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if ele == FieldType.C_TINYINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_byte))[:abs(num_of_rows)] ]
     
@@ -42,7 +42,7 @@ def _crow_smallint_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C smallint row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele == FieldType.C_SMALLINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_short))[:abs(num_of_rows)][::-1]]
+        return [ None if ele == FieldType.C_SMALLINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_short))[:abs(num_of_rows)][::1]]
     else:
         return [ None if ele == FieldType.C_SMALLINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_short))[:abs(num_of_rows)] ]
 
@@ -50,7 +50,7 @@ def _crow_int_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C int row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele == FieldType.C_INT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_int))[:abs(num_of_rows)][::-1] ]
+        return [ None if ele == FieldType.C_INT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_int))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if ele == FieldType.C_INT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_int))[:abs(num_of_rows)] ]
 
@@ -58,7 +58,7 @@ def _crow_bigint_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C bigint row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele == FieldType.C_BIGINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_longlong))[:abs(num_of_rows)][::-1] ]
+        return [ None if ele == FieldType.C_BIGINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_longlong))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if ele == FieldType.C_BIGINT_NULL else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_longlong))[:abs(num_of_rows)] ]
 
@@ -66,7 +66,7 @@ def _crow_float_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C float row to python row
     """
     if num_of_rows > 0:
-        return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_float))[:abs(num_of_rows)][::-1] ]
+        return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_float))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_float))[:abs(num_of_rows)] ]
 
@@ -74,7 +74,7 @@ def _crow_double_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C double row to python row
     """
     if num_of_rows > 0:
-        return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_double))[:abs(num_of_rows)][::-1] ]
+        return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_double))[:abs(num_of_rows)][::1] ]
     else:
         return [ None if math.isnan(ele) else ele for ele in ctypes.cast(data,  ctypes.POINTER(ctypes.c_double))[:abs(num_of_rows)] ]
 
@@ -82,7 +82,7 @@ def _crow_binary_to_python(data, num_of_rows, nbytes=None, micro=False):
     """Function to convert C binary row to python row
     """
     if num_of_rows > 0:
-        return [ None if ele.value[0:1] == FieldType.C_BINARY_NULL else ele.value.decode('utf-8') for ele in (ctypes.cast(data,  ctypes.POINTER(ctypes.c_char * nbytes)))[:abs(num_of_rows)][::-1]]
+        return [ None if ele.value[0:1] == FieldType.C_BINARY_NULL else ele.value.decode('utf-8') for ele in (ctypes.cast(data,  ctypes.POINTER(ctypes.c_char * nbytes)))[:abs(num_of_rows)][::1]]
     else:
         return [ None if ele.value[0:1] == FieldType.C_BINARY_NULL else ele.value.decode('utf-8') for ele in (ctypes.cast(data,  ctypes.POINTER(ctypes.c_char * nbytes)))[:abs(num_of_rows)]]
 
@@ -225,6 +225,7 @@ class CTaosInterface(object):
 
         if connection.value == None:
             print('connect to TDengine failed')
+            raise ConnectionError("connect to TDengine failed")
             # sys.exit(1)
         else:
             print('connect to TDengine success')
@@ -310,27 +311,23 @@ class CTaosInterface(object):
     @staticmethod
     def fetchBlock(result, fields):
         pblock = ctypes.c_void_p(0)
-        num_of_rows = CTaosInterface.libtaos.taos_fetch_block(
-            result, ctypes.byref(pblock))
-
-        if num_of_rows == 0:
+        pblock = CTaosInterface.libtaos.taos_fetch_row(result)  
+        if pblock : 
+            num_of_rows = 1
+            isMicro = (CTaosInterface.libtaos.taos_result_precision(result) == FieldType.C_TIMESTAMP_MICRO)
+            blocks = [None] * len(fields)
+            fieldL = CTaosInterface.libtaos.taos_fetch_lengths(result)
+            fieldLen = [ele for ele in ctypes.cast(fieldL,  ctypes.POINTER(ctypes.c_int))[:len(fields)]]
+            for i in range(len(fields)):
+                data = ctypes.cast(pblock, ctypes.POINTER(ctypes.c_void_p))[i]
+                if fields[i]['type'] not in _CONVERT_FUNC:
+                    raise DatabaseError("Invalid data type returned from database")
+                if data is None:
+                    blocks[i] = [None]
+                else:
+                    blocks[i] = _CONVERT_FUNC[fields[i]['type']](data, num_of_rows, fieldLen[i], isMicro)         
+        else:
             return None, 0
-
-        isMicro = (CTaosInterface.libtaos.taos_result_precision(result) == FieldType.C_TIMESTAMP_MICRO)
-        blocks = [None] * len(fields)
-        fieldL = CTaosInterface.libtaos.taos_fetch_lengths(result)
-        fieldLen = [ele for ele in ctypes.cast(fieldL,  ctypes.POINTER(ctypes.c_int))[:len(fields)]]
-        for i in range(len(fields)):
-            data = ctypes.cast(pblock, ctypes.POINTER(ctypes.c_void_p))[i]
-            if data == None:
-                blocks[i] = [None] * num_of_rows
-                continue
-
-            if fields[i]['type'] not in _CONVERT_FUNC:
-                raise DatabaseError("Invalid data type returned from database")
-            
-            blocks[i] = _CONVERT_FUNC[fields[i]['type']](data, num_of_rows, fieldLen[i], isMicro)
-
         return blocks, abs(num_of_rows)
 
     @staticmethod
diff --git a/src/connector/python/windows/python3/taos/cursor.py b/src/connector/python/windows/python3/taos/cursor.py
index c2c442b06ee71ae90ec63662886c709e38d4d2ad..b58b494cad0e0a2b664ef4765eae2baee27aa20b 100644
--- a/src/connector/python/windows/python3/taos/cursor.py
+++ b/src/connector/python/windows/python3/taos/cursor.py
@@ -1,5 +1,10 @@
 from .cinterface import CTaosInterface
 from .error import *
+from .constants import FieldType
+import threading
+
+# querySeqNum = 0
+
 
 class TDengineCursor(object):
     """Database cursor which is used to manage the context of a fetch operation.
@@ -32,6 +37,8 @@ class TDengineCursor(object):
         self._block_rows = -1
         self._block_iter = 0
         self._affected_rows = 0
+        self._logfile = ""
+        self._threadId = threading.get_ident()
 
         if connection is not None:
             self._connection = connection
diff --git a/src/inc/taos.h b/src/inc/taos.h
index 2c6454ced1911de603f120c79af5237c2f064c48..cd863587a635ea0aee1e4a288f617e4601b0a09a 100644
--- a/src/inc/taos.h
+++ b/src/inc/taos.h
@@ -17,6 +17,7 @@
 #define TDENGINE_TAOS_H
 
 #include <stdint.h>
+#include <stdbool.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -109,13 +110,14 @@ DLL_EXPORT TAOS_RES *taos_query(TAOS *taos, const char *sql);
 DLL_EXPORT TAOS_ROW taos_fetch_row(TAOS_RES *res);
 DLL_EXPORT int taos_result_precision(TAOS_RES *res);  // get the time precision of result
 DLL_EXPORT void taos_free_result(TAOS_RES *res);
-DLL_EXPORT int taos_field_count(TAOS_RES *tres);
+DLL_EXPORT int taos_field_count(TAOS_RES *res);
 DLL_EXPORT int taos_num_fields(TAOS_RES *res);
 DLL_EXPORT int taos_affected_rows(TAOS_RES *res);
 DLL_EXPORT TAOS_FIELD *taos_fetch_fields(TAOS_RES *res);
 DLL_EXPORT int taos_select_db(TAOS *taos, const char *db);
 DLL_EXPORT int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields);
 DLL_EXPORT void taos_stop_query(TAOS_RES *res);
+DLL_EXPORT bool taos_is_null(TAOS_RES *res, int32_t row, int32_t col);
 
 int taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows);
 int taos_validate_sql(TAOS *taos, const char *sql);
diff --git a/src/inc/taoserror.h b/src/inc/taoserror.h
index 3f88ec486ac89868cee33ede7ebfe7e8654a0b86..882f0c6b158ede9930a495dec870ffa63a5e6512 100644
--- a/src/inc/taoserror.h
+++ b/src/inc/taoserror.h
@@ -24,9 +24,9 @@ extern "C" {
 #include <stdbool.h>
 
 #ifdef TAOS_ERROR_C
-#define TAOS_DEFINE_ERROR(name, mod, code, msg) {.val = (0x80000000 | ((mod)<<16) | (code)), .str=(msg)},
+#define TAOS_DEFINE_ERROR(name, mod, code, msg) {.val = (int32_t)((0x80000000 | ((mod)<<16) | (code))), .str=(msg)},
 #else
-#define TAOS_DEFINE_ERROR(name, mod, code, msg) static const int32_t name = (0x80000000 | ((mod)<<16) | (code));
+#define TAOS_DEFINE_ERROR(name, mod, code, msg) static const int32_t name = (int32_t)((0x80000000 | ((mod)<<16) | (code)));
 #endif
  
 #define TAOS_SYSTEM_ERROR(code)             (0x80ff0000 | (code))
@@ -115,6 +115,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_TSC_CONN_KILLED,              0, 0x0215, "Connection
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_SQL_SYNTAX_ERROR,         0, 0x0216, "Syntax error in SQL")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_DB_NOT_SELECTED,          0, 0x0217, "Database not specified or available")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_TABLE_NAME,       0, 0x0218, "Table does not exist")
+TAOS_DEFINE_ERROR(TSDB_CODE_TSC_EXCEED_SQL_LIMIT,         0, 0x0219, "SQL statement too long, check maxSQLLength config")
 
 // mnode
 TAOS_DEFINE_ERROR(TSDB_CODE_MND_MSG_NOT_PROCESSED,        0, 0x0300, "Message not processed")
@@ -373,20 +374,28 @@ TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_VALUE_NULL,           0, 0x11A5, "value not
 TAOS_DEFINE_ERROR(TSDB_CODE_HTTP_OP_VALUE_TYPE,           0, 0x11A6, "value type should be boolean, number or string")
 
 
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_OOM,                     0, 0x2101, "out of memory")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_OOM,                     0, 0x2100, "out of memory")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_CHAR_NOT_NUM,       0, 0x2101, "convertion not a valid literal input")
 TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_UNDEF,              0, 0x2102, "convertion undefined")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_TRUNC,              0, 0x2103, "convertion truncated")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_NOT_SUPPORT,        0, 0x2104, "convertion not supported")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_OUT_OF_RANGE,            0, 0x2105, "out of range")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_NOT_SUPPORT,             0, 0x2106, "not supported yet")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_INVALID_HANDLE,          0, 0x2107, "invalid handle")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_NO_RESULT,               0, 0x2108, "no result set")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_NO_FIELDS,               0, 0x2109, "no fields returned")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_INVALID_CURSOR,          0, 0x2110, "invalid cursor")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_STATEMENT_NOT_READY,     0, 0x2111, "statement not ready")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONNECTION_BUSY,         0, 0x2112, "connection still busy")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_BAD_CONNSTR,             0, 0x2113, "bad connection string")
-TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_BAD_ARG,                 0, 0x2114, "bad argument")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_TRUNC_FRAC,         0, 0x2103, "convertion fractional truncated")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_TRUNC,              0, 0x2104, "convertion truncated")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_NOT_SUPPORT,        0, 0x2105, "convertion not supported")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_OOR,                0, 0x2106, "convertion numeric value out of range")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_OUT_OF_RANGE,            0, 0x2107, "out of range")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_NOT_SUPPORT,             0, 0x2108, "not supported yet")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_INVALID_HANDLE,          0, 0x2109, "invalid handle")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_NO_RESULT,               0, 0x210a, "no result set")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_NO_FIELDS,               0, 0x210b, "no fields returned")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_INVALID_CURSOR,          0, 0x210c, "invalid cursor")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_STATEMENT_NOT_READY,     0, 0x210d, "statement not ready")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONNECTION_BUSY,         0, 0x210e, "connection still busy")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_BAD_CONNSTR,             0, 0x210f, "bad connection string")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_BAD_ARG,                 0, 0x2110, "bad argument")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_NOT_VALID_TS,       0, 0x2111, "not a valid timestamp")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_SRC_TOO_LARGE,      0, 0x2112, "src too large")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_SRC_BAD_SEQ,        0, 0x2113, "src bad sequence")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_SRC_INCOMPLETE,     0, 0x2114, "src incomplete")
+TAOS_DEFINE_ERROR(TSDB_CODE_ODBC_CONV_SRC_GENERAL,        0, 0x2115, "src general")
 
 
 #ifdef TAOS_ERROR_C
diff --git a/src/os/inc/osTime.h b/src/os/inc/osTime.h
index 6b209219c6c736ed95c69659a78d14037987be00..b20ccadadb22a04733d97bd19b919660ee677d0d 100644
--- a/src/os/inc/osTime.h
+++ b/src/os/inc/osTime.h
@@ -38,14 +38,14 @@ int32_t taosGetTimestampSec();
 static FORCE_INLINE int64_t taosGetTimestampMs() {
   struct timeval systemTime;
   gettimeofday(&systemTime, NULL);
-  return (int64_t)systemTime.tv_sec * 1000L + (uint64_t)systemTime.tv_usec / 1000;
+  return (int64_t)systemTime.tv_sec * 1000L + (int64_t)systemTime.tv_usec / 1000;
 }
 
 //@return timestamp in microsecond
 static FORCE_INLINE int64_t taosGetTimestampUs() {
   struct timeval systemTime;
   gettimeofday(&systemTime, NULL);
-  return (int64_t)systemTime.tv_sec * 1000000L + (uint64_t)systemTime.tv_usec;
+  return (int64_t)systemTime.tv_sec * 1000000L + (int64_t)systemTime.tv_usec;
 }
 
 /*
diff --git a/src/os/inc/osWindows.h b/src/os/inc/osWindows.h
index 36e30528bf9d84739fd391442145d7e65e1f7df2..5003e48c44a75011a0006a923a6e53d3d7639195 100644
--- a/src/os/inc/osWindows.h
+++ b/src/os/inc/osWindows.h
@@ -43,6 +43,7 @@
 #include "msvcProcess.h"
 #include "msvcDirect.h"
 #include "msvcFcntl.h"
+#include "msvcLibgen.h"
 #include "msvcStdio.h"
 #include "sys/msvcStat.h"
 #include "sys/msvcTypes.h"
diff --git a/src/os/src/windows/wSysinfo.c b/src/os/src/windows/wSysinfo.c
index c77df71e8e377ac76ec407afe20a1fc6888ebdaa..86bc5e38eeff5697f42bac795ec3b1016b504498 100644
--- a/src/os/src/windows/wSysinfo.c
+++ b/src/os/src/windows/wSysinfo.c
@@ -31,7 +31,10 @@
 #pragma comment(lib, "Mswsock.lib ")
 #endif
 
+#pragma warning(push)
+#pragma warning(disable:4091)
 #include <DbgHelp.h>
+#pragma warning(pop)
 
 static void taosGetSystemTimezone() {
   // get and set default timezone
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 869f57f117db9b349b6d28cd819c84aa36f82baf..2096cf4766843b81014baa972f0d3cc1d5733dc0 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -847,35 +847,50 @@ static int32_t getNextQualifiedWindow(SQueryRuntimeEnv *pRuntimeEnv, STimeWindow
   }
 
   int32_t startPos = 0;
+
   // tumbling time window query, a special case of sliding time window query
   if (pQuery->interval.sliding == pQuery->interval.interval && prevPosition != -1) {
     int32_t factor = GET_FORWARD_DIRECTION_FACTOR(pQuery->order.order);
     startPos = prevPosition + factor;
   } else {
-    startPos = searchFn((char *)primaryKeys, pDataBlockInfo->rows, startKey, pQuery->order.order);
+    if (startKey <= pDataBlockInfo->window.skey && QUERY_IS_ASC_QUERY(pQuery)) {
+      startPos = 0;
+    } else if (startKey >= pDataBlockInfo->window.ekey && !QUERY_IS_ASC_QUERY(pQuery)) {
+      startPos = pDataBlockInfo->rows - 1;
+    } else {
+      startPos = searchFn((char *)primaryKeys, pDataBlockInfo->rows, startKey, pQuery->order.order);
+    }
   }
 
   /*
    * This time window does not cover any data, try next time window,
    * this case may happen when the time window is too small
    */
-  if (QUERY_IS_ASC_QUERY(pQuery) && primaryKeys[startPos] > pNext->ekey) {
-    TSKEY next = primaryKeys[startPos];
-    if (pQuery->interval.intervalUnit == 'n' || pQuery->interval.intervalUnit == 'y') {
-      pNext->skey = taosTimeTruncate(next, &pQuery->interval, pQuery->precision);
-      pNext->ekey = taosTimeAdd(pNext->skey, pQuery->interval.interval, pQuery->interval.intervalUnit, pQuery->precision) - 1;
+  if (primaryKeys == NULL) {
+    if (QUERY_IS_ASC_QUERY(pQuery)) {
+      assert(pDataBlockInfo->window.skey <= pNext->ekey);
     } else {
-      pNext->ekey += ((next - pNext->ekey + pQuery->interval.sliding - 1)/pQuery->interval.sliding) * pQuery->interval.sliding;
-      pNext->skey = pNext->ekey - pQuery->interval.interval + 1;
+      assert(pDataBlockInfo->window.ekey >= pNext->skey);
     }
-  } else if ((!QUERY_IS_ASC_QUERY(pQuery)) && primaryKeys[startPos] < pNext->skey) {
-    TSKEY next = primaryKeys[startPos];
-    if (pQuery->interval.intervalUnit == 'n' || pQuery->interval.intervalUnit == 'y') {
-      pNext->skey = taosTimeTruncate(next, &pQuery->interval, pQuery->precision);
-      pNext->ekey = taosTimeAdd(pNext->skey, pQuery->interval.interval, pQuery->interval.intervalUnit, pQuery->precision) - 1;
-    } else {
-      pNext->skey -= ((pNext->skey - next + pQuery->interval.sliding - 1) / pQuery->interval.sliding) * pQuery->interval.sliding;
-      pNext->ekey = pNext->skey + pQuery->interval.interval - 1;
+  } else {
+    if (QUERY_IS_ASC_QUERY(pQuery) && primaryKeys[startPos] > pNext->ekey) {
+      TSKEY next = primaryKeys[startPos];
+      if (pQuery->interval.intervalUnit == 'n' || pQuery->interval.intervalUnit == 'y') {
+        pNext->skey = taosTimeTruncate(next, &pQuery->interval, pQuery->precision);
+        pNext->ekey = taosTimeAdd(pNext->skey, pQuery->interval.interval, pQuery->interval.intervalUnit, pQuery->precision) - 1;
+      } else {
+        pNext->ekey += ((next - pNext->ekey + pQuery->interval.sliding - 1)/pQuery->interval.sliding) * pQuery->interval.sliding;
+        pNext->skey = pNext->ekey - pQuery->interval.interval + 1;
+      }
+    } else if ((!QUERY_IS_ASC_QUERY(pQuery)) && primaryKeys[startPos] < pNext->skey) {
+      TSKEY next = primaryKeys[startPos];
+      if (pQuery->interval.intervalUnit == 'n' || pQuery->interval.intervalUnit == 'y') {
+        pNext->skey = taosTimeTruncate(next, &pQuery->interval, pQuery->precision);
+        pNext->ekey = taosTimeAdd(pNext->skey, pQuery->interval.interval, pQuery->interval.intervalUnit, pQuery->precision) - 1;
+      } else {
+        pNext->skey -= ((pNext->skey - next + pQuery->interval.sliding - 1) / pQuery->interval.sliding) * pQuery->interval.sliding;
+        pNext->ekey = pNext->skey + pQuery->interval.interval - 1;
+      }
     }
   }
 
@@ -5336,8 +5351,11 @@ static char *getArithemicInputSrc(void *param, const char *name, int32_t colId)
 }
 
 static void doSecondaryArithmeticProcess(SQuery* pQuery) {
-  SArithmeticSupport arithSup = {0};
+  if (pQuery->numOfExpr2 == 0) {
+    return;
+  }
 
+  SArithmeticSupport arithSup = {0};
   tFilePage **data = calloc(pQuery->numOfExpr2, POINTER_BYTES);
   for (int32_t i = 0; i < pQuery->numOfExpr2; ++i) {
     int32_t bytes = pQuery->pExpr2[i].bytes;
diff --git a/src/query/src/qParserImpl.c b/src/query/src/qParserImpl.c
index 4481ff5e8fbbf0244ec664e4c699e4747ebd7e92..0853565fc633d9ed32eb4d562dd4f2901c059d04 100644
--- a/src/query/src/qParserImpl.c
+++ b/src/query/src/qParserImpl.c
@@ -225,7 +225,8 @@ tSQLExpr *tSQLExprCreate(tSQLExpr *pLeft, tSQLExpr *pRight, int32_t optrType) {
       tSQLExprDestroy(pLeft);
       tSQLExprDestroy(pRight);
 
-    } else if ((pLeft->nSQLOptr == TK_FLOAT && pRight->nSQLOptr == TK_INTEGER) || (pLeft->nSQLOptr == TK_INTEGER && pRight->nSQLOptr == TK_FLOAT)) {
+    } else if ((pLeft->nSQLOptr == TK_FLOAT && pRight->nSQLOptr == TK_INTEGER) || (pLeft->nSQLOptr == TK_INTEGER && pRight->nSQLOptr == TK_FLOAT) ||
+        (pLeft->nSQLOptr == TK_FLOAT && pRight->nSQLOptr == TK_FLOAT)) {
       pExpr->val.nType = TSDB_DATA_TYPE_DOUBLE;
       pExpr->nSQLOptr  = TK_FLOAT;
 
diff --git a/src/query/src/qResultbuf.c b/src/query/src/qResultbuf.c
index 2645cff678b7fe91f62dda0f3fe65f3a968f9c11..ec7be3b20479bd66ca42a2166ab5a506a06e93c8 100644
--- a/src/query/src/qResultbuf.c
+++ b/src/query/src/qResultbuf.c
@@ -165,7 +165,7 @@ static char* doFlushPageToDisk(SDiskbasedResultBuf* pResultBuf, SPageInfo* pg) {
 
 static char* flushPageToDisk(SDiskbasedResultBuf* pResultBuf, SPageInfo* pg) {
   int32_t ret = TSDB_CODE_SUCCESS;
-  assert(pResultBuf->numOfPages * pResultBuf->pageSize == pResultBuf->totalBufSize && pResultBuf->numOfPages >= pResultBuf->inMemPages);
+  assert((int64_t)pResultBuf->numOfPages * pResultBuf->pageSize == pResultBuf->totalBufSize && pResultBuf->numOfPages >= pResultBuf->inMemPages);
 
   if (pResultBuf->file == NULL) {
     if ((ret = createDiskFile(pResultBuf)) != TSDB_CODE_SUCCESS) {
diff --git a/tests/script/general/parser/alter.sim b/tests/script/general/parser/alter.sim
index 6b28b20fb87d3983fc93a055505415ffa56ac946..5c15656f246ffa09217a991ca60e127c74353700 100644
--- a/tests/script/general/parser/alter.sim
+++ b/tests/script/general/parser/alter.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c tableMetaKeepTimer -v 3
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = m_alt_db
@@ -56,6 +56,7 @@ if $rows != 2 then
 endi
 print data03 = $data03
 if $data03 != taos then
+  print expect taos, actual: $data03
   return -1
 endi
 sql drop table tb
@@ -113,7 +114,7 @@ endi
 sql drop table tb
 sql drop table mt
 
-sleep 3000
+sleep 500
 ### ALTER TABLE WHILE STREAMING [TBASE271]
 #sql create table tb1 (ts timestamp, c1 int, c2 nchar(5), c3 int)
 #sql create table strm as select count(*), avg(c1), first(c2), sum(c3) from tb1 interval(2s)
@@ -133,7 +134,7 @@ sleep 3000
 #  return -1
 #endi
 #sql alter table tb1 drop column c3
-#sleep 6000
+#sleep 3000
 #sql insert into tb1 values (now, 2, 'taos')
 #sleep 30000
 #sql select * from strm
@@ -144,9 +145,9 @@ sleep 3000
 #  return -1
 #endi
 #sql alter table tb1 add column c3 int
-#sleep 6000
-#sql insert into tb1 values (now, 3, 'taos', 3);
 #sleep 3000
+#sql insert into tb1 values (now, 3, 'taos', 3);
+#sleep 500
 #sql select * from strm
 #if $rows != 3 then
 #   return -1
@@ -185,7 +186,7 @@ sql create database $db
 sql use $db
 sql create table mt (ts timestamp, c1 int, c2 nchar(7), c3 int) tags (t1 int)
 sql create table tb using mt tags(1)
-sleep 3000
+sleep 500
 sql insert into tb values ('2018-11-01 16:30:00.000', 1, 'insert', 1)
 sql alter table mt drop column c3
 
diff --git a/tests/script/general/parser/alter1.sim b/tests/script/general/parser/alter1.sim
index 24cf79eae148acaa822974f1d5d681983f72405a..e013242b824a42f9100557f7a9cc267833138e16 100644
--- a/tests/script/general/parser/alter1.sim
+++ b/tests/script/general/parser/alter1.sim
@@ -3,7 +3,7 @@ system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 sql reset query cache
 
@@ -87,7 +87,7 @@ if $data13 != NULL then
   return -1
 endi
 
-sleep 3000
+sleep 500
 print ================== insert values into table
 sql insert into car1 values (now, 1, 1,1 ) (now +1s, 2,2,2,) car2 values (now, 1,3,3)
 
diff --git a/tests/script/general/parser/alter_stable.sim b/tests/script/general/parser/alter_stable.sim
index b64c919042296099bf0dbb17eddff67c564a745d..6b3f3a8f53548979f12707cf381d583674114616 100644
--- a/tests/script/general/parser/alter_stable.sim
+++ b/tests/script/general/parser/alter_stable.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c tableMetaKeepTimer -v 3
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 print ========== alter_stable.sim
diff --git a/tests/script/general/parser/auto_create_tb.sim b/tests/script/general/parser/auto_create_tb.sim
index 64fec4b56d8a6623cd37884e277e0381192410ba..6deaf92a6c8e713a8fb5281ec2f8e4ca4f2d425f 100644
--- a/tests/script/general/parser/auto_create_tb.sim
+++ b/tests/script/general/parser/auto_create_tb.sim
@@ -4,7 +4,7 @@ system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2
 system sh/exec.sh -n dnode1 -s start
 
-sleep 3000
+sleep 500
 sql connect
 print ======================== dnode1 start
 
@@ -208,11 +208,11 @@ endi
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 5000
+sleep 3000
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
-sleep 3000
+sleep 500
 sql use $db
 
 #### auto create multiple tables
@@ -298,7 +298,7 @@ endi
 sql create table tu(ts timestamp, k int);
 sql_error create table txu using tu tags(0) values(now, 1);
 
-#[TBASE-675]
+print =================> [TBASE-675]
 sql insert into tu values(1565971200000, 1) (1565971200000,2) (1565971200001, 3)(1565971200001, 4)
 sql select * from tu
 if $rows != 2 then
diff --git a/tests/script/general/parser/auto_create_tb_drop_tb.sim b/tests/script/general/parser/auto_create_tb_drop_tb.sim
index be334bca4ad14930d363160d8e31ff63c5514637..8a429cf91abff583abd104344ec1ba300ca684bb 100644
--- a/tests/script/general/parser/auto_create_tb_drop_tb.sim
+++ b/tests/script/general/parser/auto_create_tb_drop_tb.sim
@@ -4,7 +4,7 @@ system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/cfg.sh -n dnode1 -c maxTablesPerVnode -v 4
 system sh/cfg.sh -n dnode1 -c ctime -v 30
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = db
@@ -49,7 +49,7 @@ while $t < $tbNum
 endw
 print ====== tables created
 
-sleep 60000
+sleep 500
 
 sql drop table tb2
 $x = 0
@@ -59,9 +59,7 @@ while $x < $rowNum
   $t1 = $t1 . '
   sql insert into tb1 using $stb tags( $t1 ) values ( $ts , $x ) 
   $x = $x + 1
-endw 
-  
-sleep 6000
+endw
 
 $ts = $ts0 + $delta
 $ts = $ts + 1
diff --git a/tests/script/general/parser/binary_escapeCharacter.sim b/tests/script/general/parser/binary_escapeCharacter.sim
index c3c867795a30c6e2e87081e59cfbf5f558a60fb7..e9e61f35bfda688fcd735085672be95a0fcf626f 100644
--- a/tests/script/general/parser/binary_escapeCharacter.sim
+++ b/tests/script/general/parser/binary_escapeCharacter.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c tableMetaKeepTimer -v 3
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 sql drop database if exists ecdb
diff --git a/tests/script/general/parser/col_arithmetic_operation.sim b/tests/script/general/parser/col_arithmetic_operation.sim
index 3208df95e446f5f06494617fa33a71a5f09ab828..d5ba57e6c7dd5befcacb777a1e22f96ba8dae79d 100644
--- a/tests/script/general/parser/col_arithmetic_operation.sim
+++ b/tests/script/general/parser/col_arithmetic_operation.sim
@@ -3,7 +3,7 @@ system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = ca_db
@@ -34,7 +34,7 @@ while $i < $halfTbNum
   $tb1 = $tbPrefix . $tbId
   sql create table $tb using $stb tags( $i )
   sql create table $tb1 using $stb tags( $tbId )
-  
+
   $x = 0
   while $x < $rowNum
     $xs = $x * $delta
@@ -46,8 +46,7 @@ while $i < $halfTbNum
     $binary = $binary . '
     $nchar = 'nchar . $c
     $nchar = $nchar . '
-    sql insert into $tb values ( $ts , $c , $c , $c , $c , $c , $c , true, $binary , $nchar ) 
-    sql insert into $tb1 values ( $ts , NULL , $c , NULL , $c , NULL , $c , NULL, NULL , $nchar ) 
+    sql insert into $tb values ( $ts , $c , $c , $c , $c , $c , $c , true, $binary , $nchar ) $tb1 values ( $ts , NULL , $c , NULL , $c , NULL , $c , NULL, NULL , $nchar )
     $x = $x + 1
   endw 
   $i = $i + 1
diff --git a/tests/script/general/parser/columnValue.sim b/tests/script/general/parser/columnValue.sim
index e905f612156eae7575c4884210f8fee7b91e7556..2c03a3552a26ff8c64640f908b15fcc5d194f61e 100644
--- a/tests/script/general/parser/columnValue.sim
+++ b/tests/script/general/parser/columnValue.sim
@@ -5,7 +5,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c tableMetaKeepTimer -v 3
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 print ========== columnValues.sim
diff --git a/tests/script/general/parser/columnValue_bigint.sim b/tests/script/general/parser/columnValue_bigint.sim
index e6839b2fb60eadf8d5c284cef99f47f470723378..3546ca15ee15eba485f1868d4bae5f4c545218f9 100644
--- a/tests/script/general/parser/columnValue_bigint.sim
+++ b/tests/script/general/parser/columnValue_bigint.sim
@@ -1,4 +1,4 @@
-sleep 3000
+sleep 500
 sql connect
 sql create database if not exists db
 sql use db
diff --git a/tests/script/general/parser/columnValue_bool.sim b/tests/script/general/parser/columnValue_bool.sim
index 7f3a6c3d6affaefcc2a8d47963ac065c2dc71b25..d68f37590091ab892599d4017a73b6cbb2f28450 100644
--- a/tests/script/general/parser/columnValue_bool.sim
+++ b/tests/script/general/parser/columnValue_bool.sim
@@ -1,4 +1,4 @@
-sleep 3000
+sleep 500
 sql connect
 sql create database if not exists db
 sql use db
diff --git a/tests/script/general/parser/columnValue_double.sim b/tests/script/general/parser/columnValue_double.sim
index 733fc52285a3c90dda50e5bb34a03e51daf4b9ae..fd2da37838cbabea9c6cee2e992a6904df132c3e 100644
--- a/tests/script/general/parser/columnValue_double.sim
+++ b/tests/script/general/parser/columnValue_double.sim
@@ -1,5 +1,5 @@
 ####
-sleep 3000
+sleep 500
 sql connect
 sql create database if not exists db
 sql use db
diff --git a/tests/script/general/parser/columnValue_float.sim b/tests/script/general/parser/columnValue_float.sim
index c71b4b40ee0d799c6faa619cd10b765959074f11..019cf176d0e0f455b5f6b61fcabb501806378c96 100644
--- a/tests/script/general/parser/columnValue_float.sim
+++ b/tests/script/general/parser/columnValue_float.sim
@@ -1,5 +1,5 @@
 ####
-sleep 3000
+sleep 500
 sql connect
 sql create database if not exists db
 sql use db
diff --git a/tests/script/general/parser/columnValue_int.sim b/tests/script/general/parser/columnValue_int.sim
index 2a909ebf3c64dd487d6d4b1bd5341c59794e8970..1f84df5ca05ef70e95c2db03efe0a670abaff8da 100644
--- a/tests/script/general/parser/columnValue_int.sim
+++ b/tests/script/general/parser/columnValue_int.sim
@@ -1,4 +1,4 @@
-sleep 3000
+sleep 500
 sql connect
 sql create database if not exists db
 sql use db
diff --git a/tests/script/general/parser/columnValue_smallint.sim b/tests/script/general/parser/columnValue_smallint.sim
index cf34a85a2a7d8efb7b1d4e4606cead89055ae3b1..af5c5818717b6c2f01e4726975ceaee4703cdbfb 100644
--- a/tests/script/general/parser/columnValue_smallint.sim
+++ b/tests/script/general/parser/columnValue_smallint.sim
@@ -1,4 +1,4 @@
-sleep 3000
+sleep 500
 sql connect
 sql create database if not exists db
 sql use db
diff --git a/tests/script/general/parser/columnValue_tinyint.sim b/tests/script/general/parser/columnValue_tinyint.sim
index 707242a23ed3eecde6c23413e53b67c5daa83a82..3efe52cc91f2ecb1f22000a3f212ec491b9a16c1 100644
--- a/tests/script/general/parser/columnValue_tinyint.sim
+++ b/tests/script/general/parser/columnValue_tinyint.sim
@@ -1,4 +1,4 @@
-sleep 3000
+sleep 500
 sql connect
 sql create database if not exists db
 sql use db
diff --git a/tests/script/general/parser/commit.sim b/tests/script/general/parser/commit.sim
index 4d85806b690fafdb71707133f97f8fc78942c2c2..c798bf9d7cc21f2c91c8c14e8debe22ad253b72b 100644
--- a/tests/script/general/parser/commit.sim
+++ b/tests/script/general/parser/commit.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxTablesperVnode -v 100
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = sc_db
@@ -50,8 +50,7 @@ while $i < $halfNum
     $binary = $binary . '
     $nchar = 'nchar . $c
     $nchar = $nchar . '
-    sql insert into $tb values ( $ts , $c , $c , $c , $c , $c , $c , true, $binary , $nchar ) 
-    sql insert into $tb1 values ( $ts , $c , NULL , $c , NULL , $c , $c , true, $binary , $nchar ) 
+    sql insert into $tb values ( $ts , $c , $c , $c , $c , $c , $c , true, $binary , $nchar )  $tb1 values ( $ts , $c , NULL , $c , NULL , $c , $c , true, $binary , $nchar )
     $x = $x + 1
   endw 
 
@@ -83,12 +82,12 @@ endw
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 5000
-system sh/exec.sh -n dnode1 -s start
 sleep 3000
+system sh/exec.sh -n dnode1 -s start
+sleep 500
 print ================== server restart completed
 sql connect
-sleep 3000
+sleep 500
 
 print ====== select from table and check num of rows returned
 sql use $db
diff --git a/tests/script/general/parser/constCol.sim b/tests/script/general/parser/constCol.sim
index b5a4d4abea614e6618ac91a5df4af9d387c7ad37..4a8e443281dbaa0892106a8fe91bbdd6d61c3e8a 100644
--- a/tests/script/general/parser/constCol.sim
+++ b/tests/script/general/parser/constCol.sim
@@ -353,8 +353,8 @@ if $rows != 3 then
 endi
 
 print =============================> td-2036
-if $data00 != 0.3000000 then
-  print expect: 0.3000000, actual:$data00
+if $data00 != 0.300000000 then
+  print expect: 0.300000000, actual:$data00
   return -1
 endi
 
diff --git a/tests/script/general/parser/create_db.sim b/tests/script/general/parser/create_db.sim
index ed6e427fe70fe5cfe65852352ac680f645a3a21f..3b7f24b6d900dc1f130f91a138da81fd708b16fe 100644
--- a/tests/script/general/parser/create_db.sim
+++ b/tests/script/general/parser/create_db.sim
@@ -5,7 +5,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/exec.sh -n dnode1 -s start
 
-sleep 3000
+sleep 500
 sql connect
 print ======================== dnode1 start
 
diff --git a/tests/script/general/parser/create_mt.sim b/tests/script/general/parser/create_mt.sim
index f21a83067186dc226bd035fe3ff7ba5cc28675c0..e11f32276187d15334193af688b3c50604df2b32 100644
--- a/tests/script/general/parser/create_mt.sim
+++ b/tests/script/general/parser/create_mt.sim
@@ -5,7 +5,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/exec.sh -n dnode1 -s start
 
-sleep 3000
+sleep 500
 sql connect
 print ======================== dnode1 start
 
diff --git a/tests/script/general/parser/create_tb.sim b/tests/script/general/parser/create_tb.sim
index 9d1672fdbef136fccb28d38df967d45132c9d40a..609aad2adbc9611d33c595d33191e5b8a26b3359 100644
--- a/tests/script/general/parser/create_tb.sim
+++ b/tests/script/general/parser/create_tb.sim
@@ -5,7 +5,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/exec.sh -n dnode1 -s start
 
-sleep 3000
+sleep 500
 sql connect
 print ======================== dnode1 start
 
diff --git a/tests/script/general/parser/dbtbnameValidate.sim b/tests/script/general/parser/dbtbnameValidate.sim
index b46a22228280c73a2cfffa145c9ed71d75dd4957..fd40ecc3f758affa3ca401813132b830a241a049 100644
--- a/tests/script/general/parser/dbtbnameValidate.sim
+++ b/tests/script/general/parser/dbtbnameValidate.sim
@@ -3,7 +3,7 @@ system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/exec.sh -n dnode1 -s start
-sleep 1000
+sleep 500
 sql connect
 
 print ========== db name and table name check in create and drop, describe
diff --git a/tests/script/general/parser/fill.sim b/tests/script/general/parser/fill.sim
index 0547db77498cf1d61baf44deb286d9045a469dc3..9851a4e7fcfea026271729cbe7436c47e184df40 100644
--- a/tests/script/general/parser/fill.sim
+++ b/tests/script/general/parser/fill.sim
@@ -3,7 +3,7 @@ system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = m_fl_db
diff --git a/tests/script/general/parser/fill_stb.sim b/tests/script/general/parser/fill_stb.sim
index f0cd058352803f322647aad338bc84be7fa84b5a..83eb98c465927beb70ce403491dcd100f2556c7d 100644
--- a/tests/script/general/parser/fill_stb.sim
+++ b/tests/script/general/parser/fill_stb.sim
@@ -3,7 +3,7 @@ system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = fl1_db
diff --git a/tests/script/general/parser/fill_us.sim b/tests/script/general/parser/fill_us.sim
index b597d378a24f3a07d28d3bebc1a6fe403fdf3208..dc8ee8659d6c3b99e8103e3ee0a622a10e7bc7df 100644
--- a/tests/script/general/parser/fill_us.sim
+++ b/tests/script/general/parser/fill_us.sim
@@ -3,7 +3,7 @@ system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = m_fl_db
diff --git a/tests/script/general/parser/first_last.sim b/tests/script/general/parser/first_last.sim
index 46431b0848c72aefc9b5aaa04f7e13f525dcfe1c..a934d3bcabf09ebe1584c296d6cab2f5c80654d2 100644
--- a/tests/script/general/parser/first_last.sim
+++ b/tests/script/general/parser/first_last.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxTablespervnode -v 4
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = first_db
@@ -76,11 +76,11 @@ run general/parser/first_last_query.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 5000
+sleep 3000
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
-sleep 3000
+sleep 500
 
 run general/parser/first_last_query.sim
 
diff --git a/tests/script/general/parser/first_last_query.sim b/tests/script/general/parser/first_last_query.sim
index d43cd528781cb900f239e4e7549da91ace2d0e5c..a982f10362a46e7c671e8df4674b06c5c9f60b75 100644
--- a/tests/script/general/parser/first_last_query.sim
+++ b/tests/script/general/parser/first_last_query.sim
@@ -1,4 +1,4 @@
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = first_db
diff --git a/tests/script/general/parser/groupby.sim b/tests/script/general/parser/groupby.sim
index 145c4a008f1ae26378baeabdfd5103cc807266f3..c0a6709fe4b4369a5415860b87d949351a85c7ca 100644
--- a/tests/script/general/parser/groupby.sim
+++ b/tests/script/general/parser/groupby.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4
 system sh/exec.sh -n dnode1 -s start
-sleep 1000
+sleep 500
 sql connect
 
 $dbPrefix = group_db
diff --git a/tests/script/general/parser/import.sim b/tests/script/general/parser/import.sim
index 7ab0437685869594daded7fcfd9c886339842221..6da2483738a6d5c805e3a29129183845e64c4f22 100644
--- a/tests/script/general/parser/import.sim
+++ b/tests/script/general/parser/import.sim
@@ -3,7 +3,7 @@ system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = impt_db
@@ -64,7 +64,7 @@ sleep 2000
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
-sleep 3000
+sleep 500
 
 sql use $db
 sql select * from tb
diff --git a/tests/script/general/parser/import_commit1.sim b/tests/script/general/parser/import_commit1.sim
index 197ae5845362f2dbfc9392fe2a57601aec442e22..9c5144a630cbd0df20e8842211c1d3d3e5d5cbb0 100644
--- a/tests/script/general/parser/import_commit1.sim
+++ b/tests/script/general/parser/import_commit1.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/cfg.sh -n dnode1 -c ctime -v 30
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = ic_db
@@ -40,7 +40,7 @@ while $x < $rowNum
 endw 
 print ====== tables created
 
-sleep 6000
+sleep 3000
 
 $ts = $ts0 + $delta
 $ts = $ts + 1
diff --git a/tests/script/general/parser/import_commit2.sim b/tests/script/general/parser/import_commit2.sim
index e400d0c3cb7e347d34b3c75d9ae2b68ffeeb656f..000394386ec169bba4b907969d73878760584eb6 100644
--- a/tests/script/general/parser/import_commit2.sim
+++ b/tests/script/general/parser/import_commit2.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/cfg.sh -n dnode1 -c ctime -v 30
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = ic_db
@@ -39,7 +39,7 @@ while $x < $rowNum
 endw 
 print ====== tables created
 
-sleep 6000
+sleep 3000
 
 $ts = $ts0 + $delta
 $ts = $ts + 1
diff --git a/tests/script/general/parser/import_commit3.sim b/tests/script/general/parser/import_commit3.sim
index 7e7451e689bbe2ac0059b13ba3fa64c530445adf..997a4a22aada1d3f02becd8e02f82c35a41a6175 100644
--- a/tests/script/general/parser/import_commit3.sim
+++ b/tests/script/general/parser/import_commit3.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/cfg.sh -n dnode1 -c ctime -v 30
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = ic_db
@@ -39,7 +39,7 @@ while $x < $rowNum
 endw 
 print ====== tables created
 
-sleep 6000
+sleep 3000
 
 $ts = $ts + 1
 sql insert into $tb values ( $ts , -1, -1, -1, -1, -1)
@@ -47,7 +47,7 @@ $ts = $ts0 + $delta
 $ts = $ts + 1
 sql import into $tb values ( $ts , -2, -2, -2, -2, -2)
 
-sleep 6000
+sleep 3000
 
 sql show databases
 
diff --git a/tests/script/general/parser/insert_multiTbl.sim b/tests/script/general/parser/insert_multiTbl.sim
index b24c1b629fa371e417826bcb1da67180f3317c29..887f97a198237ff9c181c3d313525ae4fb66aec5 100644
--- a/tests/script/general/parser/insert_multiTbl.sim
+++ b/tests/script/general/parser/insert_multiTbl.sim
@@ -6,7 +6,7 @@ system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/exec.sh -n dnode1 -s start
 sleep 2000
 sql connect
-sleep 3000
+sleep 500
 print ======================== dnode1 start
 
 sql create database mul_db
diff --git a/tests/script/general/parser/insert_tb.sim b/tests/script/general/parser/insert_tb.sim
index 4ba455c2446e6fd9804b8e518dc31cacb0781bfc..0a9eb9f678c12de13b33e7dd1ca438c768addf81 100644
--- a/tests/script/general/parser/insert_tb.sim
+++ b/tests/script/general/parser/insert_tb.sim
@@ -5,7 +5,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/exec.sh -n dnode1 -s start
 
-sleep 3000
+sleep 500
 sql connect
 print ======================== dnode1 start
 
@@ -103,7 +103,7 @@ if $rows != 1 then
 endi
 
 sql drop database $db
-sleep 1000
+sleep 500
 sql create database $db
 sql use $db
 sql create table stb1 (ts timestamp, c1 int) tags(t1 int)
@@ -136,7 +136,7 @@ if $data21 != 1.000000000 then
 endi
 
 sql drop database $db
-sleep 1000
+sleep 500
 sql create database $db
 sql use $db
 sql create table stb (ts timestamp, c1 int, c2 bigint, c3 float, c4 double, c5 nchar(10), c6 binary(20)) tags(t1 int, t2 bigint, t3 double, t4 float, t5 nchar(10))
diff --git a/tests/script/general/parser/interp.sim b/tests/script/general/parser/interp.sim
index 1cd857162d9a764519d2edd6f790f9fd1c083b61..8777c3ed9bd4cb22b72253b6503e8c78b96bb703 100644
--- a/tests/script/general/parser/interp.sim
+++ b/tests/script/general/parser/interp.sim
@@ -3,7 +3,7 @@ system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = intp_db
@@ -60,7 +60,7 @@ run general/parser/interp_test.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 5000
+sleep 3000
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
diff --git a/tests/script/general/parser/interp_test.sim b/tests/script/general/parser/interp_test.sim
index 8bffae4af634e9c04c4d5f4614d51e1e1b33ffba..42738a8bd134c3b7cc72569fe490285baa694e57 100644
--- a/tests/script/general/parser/interp_test.sim
+++ b/tests/script/general/parser/interp_test.sim
@@ -1,4 +1,4 @@
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = intp_db
@@ -303,6 +303,8 @@ $tb = $tbPrefix . 0
     return -1
   endi
 
+  print select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $ts0 fill(linear)
+
   sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $ts0 fill(linear)
   if $rows != 1 then
     return -1
@@ -338,6 +340,8 @@ $tb = $tbPrefix . 0
     return -1
   endi
   # columns contain NULL values
+
+  print select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from intp_tb3 where ts = $ts0 fill(linear)
   sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from intp_tb3 where ts = $ts0 fill(linear)
   if $rows != 1 then
     return -1
@@ -380,6 +384,7 @@ $tb = $tbPrefix . 0
   endi
 
   $t = $tsu + 1000
+  print select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(linear)
   sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(linear)
   if $rows != 0 then
     return -1
@@ -387,6 +392,7 @@ $tb = $tbPrefix . 0
 
 ## fill(value)
   $t = $ts0 + 1000
+  print 91
   sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from $tb where ts = $t fill(value, -1, -2)
   if $rows != 1 then
     return -1
@@ -456,6 +462,7 @@ $tb = $tbPrefix . 0
   if $data09 != nchar0 then
     return -1
   endi
+
   # table has NULL columns
   sql select interp(ts), interp(c1), interp(c2), interp(c3), interp(c4), interp(c5), interp(c6), interp(c7), interp(c8), interp(c9) from intp_tb3 where ts = $ts0 fill(value, -1, -2, -3)
   if $rows != 1 then
@@ -491,11 +498,14 @@ $tb = $tbPrefix . 0
 
 ##### select interp from stable
   ## interp(*) from stb
+  print select interp(*) from $stb where ts = $ts0
   sql select interp(*) from $stb where ts = $ts0
   if $rows != 1 then
     return -1
   endi
   $t = $ts0 + 1000
+  print 92
+
   sql select interp(*) from $stb where ts = $t
   if $rows != 0 then
     return -1
diff --git a/tests/script/general/parser/join.sim b/tests/script/general/parser/join.sim
index 624c2e72c40bfee35f8b0b17646c97149eda65c1..3ee90cda352002961c131b7e014f8aa6d8155c05 100644
--- a/tests/script/general/parser/join.sim
+++ b/tests/script/general/parser/join.sim
@@ -7,7 +7,7 @@ system sh/cfg.sh -n dnode1 -c rpcDebugFlag -v 135
 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4
 
 system sh/exec.sh -n dnode1 -s start
-sleep 1000
+sleep 500
 sql connect
 
 $dbPrefix = join_db
@@ -360,9 +360,7 @@ endi
 sql select join_mt1.* from join_mt1
 
 print $rows
-
-$val = 2000
-if $rows != $val then
+if $rows != 2000 then
   return -1
 endi
 
diff --git a/tests/script/general/parser/join_multivnode.sim b/tests/script/general/parser/join_multivnode.sim
index 6bca0e75c40be80f6aa7ef7f25562fa019fe2020..52489bba0124f914acb56402dc43c5055f3d94c3 100644
--- a/tests/script/general/parser/join_multivnode.sim
+++ b/tests/script/general/parser/join_multivnode.sim
@@ -6,7 +6,7 @@ system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4
 
 system sh/exec.sh -n dnode1 -s start
 sql connect
-sleep 1000
+sleep 500
 
 $dbPrefix = join_m_db
 $tbPrefix = join_tb
diff --git a/tests/script/general/parser/lastrow.sim b/tests/script/general/parser/lastrow.sim
index 6321823fe2f75854beeab091663d268876e373b9..cc71123a77e7e48c491d8c1450addb55e243bdd6 100644
--- a/tests/script/general/parser/lastrow.sim
+++ b/tests/script/general/parser/lastrow.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = lr_db
@@ -62,11 +62,11 @@ run general/parser/lastrow_query.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 5000
+sleep 3000
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
-sleep 3000
+sleep 500
 
 run general/parser/lastrow_query.sim
 
diff --git a/tests/script/general/parser/lastrow_query.sim b/tests/script/general/parser/lastrow_query.sim
index f81a48d5b2d61ddf829920201dd01f5dd1ee44ba..5b9c8b60c3f62b48159d13f5cb82ccffd32d0feb 100644
--- a/tests/script/general/parser/lastrow_query.sim
+++ b/tests/script/general/parser/lastrow_query.sim
@@ -1,4 +1,4 @@
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = lr_db
diff --git a/tests/script/general/parser/limit.sim b/tests/script/general/parser/limit.sim
index d8c72349db9ebf40e038a921ea7534e6a1a87e23..fb5e704bf1ba3bab457dae2dc06a23628fde316c 100644
--- a/tests/script/general/parser/limit.sim
+++ b/tests/script/general/parser/limit.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxVgroupsPerDb -v 1
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = lm_db
@@ -62,11 +62,11 @@ run general/parser/limit_stb.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 5000
+sleep 3000
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
-sleep 3000
+sleep 500
 
 run general/parser/limit_tb.sim
 run general/parser/limit_stb.sim
diff --git a/tests/script/general/parser/limit1.sim b/tests/script/general/parser/limit1.sim
index 8b927b2a7fe599e5e51392e8577d3dffb112ea57..7236421ec2eb1617c7c16b5d659b9b57f300559a 100644
--- a/tests/script/general/parser/limit1.sim
+++ b/tests/script/general/parser/limit1.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxVgroupsPerDb -v 1
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = lm1_db
@@ -48,8 +48,7 @@ while $i < $halfNum
     $binary = $binary . '
     $nchar = 'nchar . $c
     $nchar = $nchar . '
-    sql insert into $tb values ( $ts , $c , $c , $c , $c , $c , $c , true, $binary , $nchar ) 
-    sql insert into $tb1 values ( $ts , $c , NULL , $c , NULL , $c , $c , true, $binary , $nchar ) 
+    sql insert into $tb values ( $ts , $c , $c , $c , $c , $c , $c , true, $binary , $nchar )  $tb1 values ( $ts , $c , NULL , $c , NULL , $c , $c , true, $binary , $nchar )
     $x = $x + 1
   endw 
 
@@ -62,7 +61,7 @@ run general/parser/limit1_stb.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 5000
+sleep 3000
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
diff --git a/tests/script/general/parser/limit1_stb.sim b/tests/script/general/parser/limit1_stb.sim
index fbcd8d09656b9c1b5f515c2224fbca8c5e8f324c..d5846adc45327e6faa7b2bd7cdd10b44ea6fc094 100644
--- a/tests/script/general/parser/limit1_stb.sim
+++ b/tests/script/general/parser/limit1_stb.sim
@@ -1,4 +1,4 @@
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = lm1_db
diff --git a/tests/script/general/parser/limit1_tb.sim b/tests/script/general/parser/limit1_tb.sim
index a9484d10dbaaad1c8c08b2ae54caf85ad186207e..1e473eb8580965b6e777c7fe09cbc607af8938a8 100644
--- a/tests/script/general/parser/limit1_tb.sim
+++ b/tests/script/general/parser/limit1_tb.sim
@@ -1,4 +1,4 @@
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = lm1_db
diff --git a/tests/script/general/parser/limit1_tblocks100.sim b/tests/script/general/parser/limit1_tblocks100.sim
index f1702924aaee3091c7ac9e4229b36ec11c141123..9a123e645ce070f5146d2507b90e16b06d258c4d 100644
--- a/tests/script/general/parser/limit1_tblocks100.sim
+++ b/tests/script/general/parser/limit1_tblocks100.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxVgroupsPerDb -v 1
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = lm1_db
@@ -48,8 +48,7 @@ while $i < $halfNum
     $binary = $binary . '
     $nchar = 'nchar . $c
     $nchar = $nchar . '
-    sql insert into $tb values ( $ts , $c , $c , $c , $c , $c , $c , true, $binary , $nchar ) 
-    sql insert into $tb1 values ( $ts , $c , NULL , $c , NULL , $c , $c , true, $binary , $nchar ) 
+    sql insert into $tb values ( $ts , $c , $c , $c , $c , $c , $c , true, $binary , $nchar )  $tb1 values ( $ts , $c , NULL , $c , NULL , $c , $c , true, $binary , $nchar )
     $x = $x + 1
   endw 
 
@@ -62,7 +61,7 @@ run general/parser/limit1_stb.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 5000
+sleep 3000
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
diff --git a/tests/script/general/parser/limit2.sim b/tests/script/general/parser/limit2.sim
index d22c786aa3001e6f7e275466bd5426b7e275b53c..47c3eb6d08ca1f01ded0b8e4597f91d0cd2f1933 100644
--- a/tests/script/general/parser/limit2.sim
+++ b/tests/script/general/parser/limit2.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c rowsInFileBlock -v 255
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = lm2_db
@@ -69,7 +69,7 @@ print ====== tables created
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 5000
+sleep 3000
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
diff --git a/tests/script/general/parser/limit2_query.sim b/tests/script/general/parser/limit2_query.sim
index 8294247a86415bcd90c692a8765475fbb6ecdd6b..f9a1dd8e4b51107d6713d52f850f792f339b3fa4 100644
--- a/tests/script/general/parser/limit2_query.sim
+++ b/tests/script/general/parser/limit2_query.sim
@@ -1,4 +1,4 @@
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = lm2_db
diff --git a/tests/script/general/parser/limit2_tblocks100.sim b/tests/script/general/parser/limit2_tblocks100.sim
index 64f86edd28092bc816b663719c0ab153ff1181e0..1aaa8e885a21b4db79c28645029a015d12a24fb5 100644
--- a/tests/script/general/parser/limit2_tblocks100.sim
+++ b/tests/script/general/parser/limit2_tblocks100.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c rowsInFileBlock -v 255
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = lm2_db
@@ -69,7 +69,7 @@ print ====== tables created
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 3000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
diff --git a/tests/script/general/parser/limit_stb.sim b/tests/script/general/parser/limit_stb.sim
index c9df03ab2efe220dc9a5bf5707cb83f81178e4d2..b41b7b726bc24b83f64cecbec8ac0eb83afa57ea 100644
--- a/tests/script/general/parser/limit_stb.sim
+++ b/tests/script/general/parser/limit_stb.sim
@@ -1,4 +1,4 @@
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = lm_db
diff --git a/tests/script/general/parser/limit_tb.sim b/tests/script/general/parser/limit_tb.sim
index 970c7b75c5683e8ece8ce3c7b5458097a0ec3973..b917627fdf6499fe2dacf948af7badb2b5de43d7 100644
--- a/tests/script/general/parser/limit_tb.sim
+++ b/tests/script/general/parser/limit_tb.sim
@@ -1,4 +1,4 @@
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = lm_db
diff --git a/tests/script/general/parser/mixed_blocks.sim b/tests/script/general/parser/mixed_blocks.sim
index 41082bb1441a111602a127b3dd8e9eb6d0420e51..d3558560df95d02256e0bc6b4a04ae9fae6e5890 100644
--- a/tests/script/general/parser/mixed_blocks.sim
+++ b/tests/script/general/parser/mixed_blocks.sim
@@ -5,7 +5,7 @@ system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4
 system sh/exec.sh -n dnode1 -s start
 
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = mb_db
diff --git a/tests/script/general/parser/nchar.sim b/tests/script/general/parser/nchar.sim
index bdac5ace55a0c5feeb3413eea13a8a7b2c13f7e4..ab4ed2607a062ed32ebe52527d30705aa135aa86 100644
--- a/tests/script/general/parser/nchar.sim
+++ b/tests/script/general/parser/nchar.sim
@@ -5,7 +5,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/exec.sh -n dnode1 -s start
 
-sleep 3000
+sleep 500
 sql connect
 
 print ======================== dnode1 start
diff --git a/tests/script/general/parser/null_char.sim b/tests/script/general/parser/null_char.sim
index 2e39fc7db2e20f9528c2d62458f3a6a625181c73..7b1c81a2958c36acbe96641494a8c156dabb275d 100644
--- a/tests/script/general/parser/null_char.sim
+++ b/tests/script/general/parser/null_char.sim
@@ -6,7 +6,7 @@ system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c tableMetaKeepTimer -v 3
 system sh/exec.sh -n dnode1 -s start
 
-sleep 3000
+sleep 500
 sql connect
 
 print ========== NULL_char.sim
@@ -251,7 +251,7 @@ endi
 ################### nchar
 sql alter table st41 set tag tag_nchar = "��˼����"
 sql select tag_binary, tag_nchar, tag_int, tag_bool, tag_float, tag_double from  st41
-#sleep 1000
+#sleep 500
 #if $data01 != ��˼���� then
 #  print ==== expect ��˼����, actually $data01
 #  return -1
diff --git a/tests/script/general/parser/projection_limit_offset.sim b/tests/script/general/parser/projection_limit_offset.sim
index 7c83ca0c2ff3d44bf487f8a94750736767834cfa..92ebb6fd79627f2e655178df2c031cd77675d1d6 100644
--- a/tests/script/general/parser/projection_limit_offset.sim
+++ b/tests/script/general/parser/projection_limit_offset.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = group_db
@@ -402,7 +402,7 @@ sql_error select k, sum(k)+1 from tm0;
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 5000
+sleep 3000
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
diff --git a/tests/script/general/parser/selectResNum.sim b/tests/script/general/parser/selectResNum.sim
index 42cedc034b7f000eea4b75b156a847a4d1667c5b..464f363222b2d135b68d7e41d18ec33d71d843d2 100644
--- a/tests/script/general/parser/selectResNum.sim
+++ b/tests/script/general/parser/selectResNum.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 200
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = sc_db
@@ -50,8 +50,7 @@ while $i < $halfNum
     $binary = $binary . '
     $nchar = 'nchar . $c
     $nchar = $nchar . '
-    sql insert into $tb values ( $ts , $c , $c , $c , $c , $c , $c , true, $binary , $nchar ) 
-    sql insert into $tb1 values ( $ts , $c , NULL , $c , NULL , $c , $c , true, $binary , $nchar ) 
+    sql insert into $tb values ( $ts , $c , $c , $c , $c , $c , $c , true, $binary , $nchar )  $tb1 values ( $ts , $c , NULL , $c , NULL , $c , $c , true, $binary , $nchar )
     $x = $x + 1
   endw 
 
@@ -119,12 +118,12 @@ endw
 
 print ====== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 6000
+sleep 3000
 system sh/exec.sh -n dnode1 -s start
 print ====== server restart completed
-sleep 3000
+sleep 500
 sql connect
-sleep 3000
+sleep 500
 sql use $db
 
 ##### repeat test after server restart
diff --git a/tests/script/general/parser/select_across_vnodes.sim b/tests/script/general/parser/select_across_vnodes.sim
index ac3a8f2b2b3bd04681a20e070aaf2aba58447b26..44e5576dac11d9f8ebffb9eee8f067bab86344c1 100644
--- a/tests/script/general/parser/select_across_vnodes.sim
+++ b/tests/script/general/parser/select_across_vnodes.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 5
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = sav_db
diff --git a/tests/script/general/parser/select_from_cache_disk.sim b/tests/script/general/parser/select_from_cache_disk.sim
index 4fdfa7b55b88372d5497f399c5c821f10743f4d5..0fa0848144c740c6ed8c7583cbca46816d3da6bc 100644
--- a/tests/script/general/parser/select_from_cache_disk.sim
+++ b/tests/script/general/parser/select_from_cache_disk.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = scd_db
@@ -35,11 +35,11 @@ sql insert into $tb values ('2018-09-17 09:00:00.030', 3)
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 5000
+sleep 3000
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
-sleep 3000
+sleep 500
 sql use $db
 
 # generate some data in cache
diff --git a/tests/script/general/parser/select_with_tags.sim b/tests/script/general/parser/select_with_tags.sim
index 68d145a5f277464a224ccf0b3c92767a48e26fb6..dab76f60044c7b587e6c98bb256f895aeedb656e 100644
--- a/tests/script/general/parser/select_with_tags.sim
+++ b/tests/script/general/parser/select_with_tags.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4
 system sh/exec.sh -n dnode1 -s start
-sleep 1000
+sleep 500
 sql connect
 
 $dbPrefix = select_tags_db
diff --git a/tests/script/general/parser/set_tag_vals.sim b/tests/script/general/parser/set_tag_vals.sim
index 38af57c73d681fb0ed40212a967c741b0431ebad..bf29fe3902f88ae557b53068d1678a0aa1288818 100644
--- a/tests/script/general/parser/set_tag_vals.sim
+++ b/tests/script/general/parser/set_tag_vals.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxVgroupsPerDb -v 1
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = db
diff --git a/tests/script/general/parser/single_row_in_tb.sim b/tests/script/general/parser/single_row_in_tb.sim
index 4305ae1b5d0d6fa1b308885263d1ac9947af3101..fe1edb1f738a01831ad3e926e6b1a925b0c05dcc 100644
--- a/tests/script/general/parser/single_row_in_tb.sim
+++ b/tests/script/general/parser/single_row_in_tb.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = sr_db
@@ -32,7 +32,7 @@ run general/parser/single_row_in_tb_query.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 5000
+sleep 3000
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
diff --git a/tests/script/general/parser/single_row_in_tb_query.sim b/tests/script/general/parser/single_row_in_tb_query.sim
index a1ae70ec814d0babf00dbf5051da45c5cd7daf94..9e90b91220dae51bf31c9f3dde69eb1404223e88 100644
--- a/tests/script/general/parser/single_row_in_tb_query.sim
+++ b/tests/script/general/parser/single_row_in_tb_query.sim
@@ -1,4 +1,4 @@
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = sr_db
diff --git a/tests/script/general/parser/sliding.sim b/tests/script/general/parser/sliding.sim
index b9fd66334d469b09812daac4d0ad15b8a2ac3a9c..4283421169d146a19a7a46eed1c1bd819f77464d 100644
--- a/tests/script/general/parser/sliding.sim
+++ b/tests/script/general/parser/sliding.sim
@@ -6,7 +6,7 @@ system sh/cfg.sh -n dnode1 -c debugFlag -v 135
 system sh/cfg.sh -n dnode1 -c rpcDebugFlag -v 135
 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4
 system sh/exec.sh -n dnode1 -s start
-sleep 1000
+sleep 500
 sql connect
 
 $dbPrefix = sliding_db
diff --git a/tests/script/general/parser/slimit.sim b/tests/script/general/parser/slimit.sim
index edbf0c8cc0499d3cb40e0c7696d278ebcf9ba14a..f7a23019cf2e1bcdca7540dd4acd997f24d31e69 100644
--- a/tests/script/general/parser/slimit.sim
+++ b/tests/script/general/parser/slimit.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = slm_db
@@ -97,11 +97,11 @@ run general/parser/slimit_query.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 5000
+sleep 3000
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
-sleep 3000
+sleep 500
 
 run general/parser/slimit_query.sim
 
diff --git a/tests/script/general/parser/slimit1.sim b/tests/script/general/parser/slimit1.sim
index 9e26a2882a5b013aa804f01c1dd8e339d17d54db..7a2511eb76b2a0d1289c509876375a2a6f06419c 100644
--- a/tests/script/general/parser/slimit1.sim
+++ b/tests/script/general/parser/slimit1.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = slm_alt_tg_db
@@ -56,11 +56,11 @@ run general/parser/slimit1_query.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 5000
+sleep 3000
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
-sleep 3000
+sleep 500
 
 run general/parser/slimit1_query.sim
 
diff --git a/tests/script/general/parser/slimit1_query.sim b/tests/script/general/parser/slimit1_query.sim
index 617ccb3fd9a13b1392510c4287d11f69df5dde4e..c205d456892d79f7a9dd8fa1ec877c04afac49ef 100644
--- a/tests/script/general/parser/slimit1_query.sim
+++ b/tests/script/general/parser/slimit1_query.sim
@@ -1,4 +1,4 @@
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = slm_alt_tg_db
diff --git a/tests/script/general/parser/slimit_alter_tags.sim b/tests/script/general/parser/slimit_alter_tags.sim
index eccd4a6815a5516afe5ed28dc8ec067737f18d01..1072f9ccb46c69ab1156783cbcdeb8940afb9aa4 100644
--- a/tests/script/general/parser/slimit_alter_tags.sim
+++ b/tests/script/general/parser/slimit_alter_tags.sim
@@ -4,7 +4,7 @@ system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 2
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = slm_alt_tg_db
@@ -171,11 +171,11 @@ endi
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 5000
+sleep 3000
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
-sleep 3000
+sleep 500
 
 sql use $db
 ### repeat above queries
diff --git a/tests/script/general/parser/slimit_query.sim b/tests/script/general/parser/slimit_query.sim
index 655bc5f8beab0209428a4796ba83ba10d8b3afde..3020f8047217dfbd9f39b10b5b74b9280faa4737 100644
--- a/tests/script/general/parser/slimit_query.sim
+++ b/tests/script/general/parser/slimit_query.sim
@@ -1,4 +1,4 @@
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = slm_db
diff --git a/tests/script/general/parser/stream_on_sys.sim b/tests/script/general/parser/stream_on_sys.sim
index 845a484488137e509a79bbb057f104378843cb8f..1c8eb82c79a537ddbb322bdb164541263d92373c 100644
--- a/tests/script/general/parser/stream_on_sys.sim
+++ b/tests/script/general/parser/stream_on_sys.sim
@@ -6,7 +6,7 @@ system sh/cfg.sh -n dnode1 -c monitor       -v 1
 system sh/cfg.sh -n dnode1 -c monitorInterval     -v 1
 system sh/exec.sh -n dnode1 -s start
 
-sleep 3000
+sleep 500
 sql connect
 print ======================== stream_on_sys.sim
 
diff --git a/tests/script/general/parser/tags_dynamically_specifiy.sim b/tests/script/general/parser/tags_dynamically_specifiy.sim
index 07bf4d8dd1cae6b0b374b9b67b1dca58f218fb3f..8303a9c86d610476d6dba164e0af3e6a9199b1da 100644
--- a/tests/script/general/parser/tags_dynamically_specifiy.sim
+++ b/tests/script/general/parser/tags_dynamically_specifiy.sim
@@ -3,9 +3,9 @@ system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
-sleep 3000
+sleep 500
 
 $db = dytag_db
 $tbNum = 10
diff --git a/tests/script/general/parser/tags_filter.sim b/tests/script/general/parser/tags_filter.sim
index 9842b4fda6304314a36eb06078fb7cb64e2c9c5c..c3d0fdfc61d2d9ec8aa19100511577652076d91d 100644
--- a/tests/script/general/parser/tags_filter.sim
+++ b/tests/script/general/parser/tags_filter.sim
@@ -3,7 +3,7 @@ system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $db = tf_db
diff --git a/tests/script/general/parser/tbnameIn.sim b/tests/script/general/parser/tbnameIn.sim
index fd5f32972ad9e0d0f89875d1f89d2734fd2cbdd8..87c48717926a535f77e73e69f02464b947a42ee6 100644
--- a/tests/script/general/parser/tbnameIn.sim
+++ b/tests/script/general/parser/tbnameIn.sim
@@ -3,7 +3,7 @@ system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = ti_db
@@ -68,7 +68,7 @@ run general/parser/tbnameIn_query.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 5000
+sleep 3000
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
diff --git a/tests/script/general/parser/tbnameIn_query.sim b/tests/script/general/parser/tbnameIn_query.sim
index 37cc1aa8245a22e698c1d756cfe1eac72fcf3fdb..ad7456f5578ccec76eef3262298130aaed2462c6 100644
--- a/tests/script/general/parser/tbnameIn_query.sim
+++ b/tests/script/general/parser/tbnameIn_query.sim
@@ -1,4 +1,4 @@
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = ti_db
diff --git a/tests/script/general/parser/testSuite.sim b/tests/script/general/parser/testSuite.sim
index 3dd80b8e38c8144fee218ec372e59fe262ac7a15..0e123796597c3d5009860aa85d5c2a73084a9f72 100644
--- a/tests/script/general/parser/testSuite.sim
+++ b/tests/script/general/parser/testSuite.sim
@@ -1,113 +1,113 @@
-sleep 2000
-run general/parser/alter.sim
-sleep 2000
-run general/parser/alter1.sim
-sleep 2000
-run general/parser/alter_stable.sim
-sleep 2000
-run general/parser/auto_create_tb.sim
-sleep 2000
-run general/parser/auto_create_tb_drop_tb.sim
-sleep 2000
-run general/parser/col_arithmetic_operation.sim
-sleep 2000
-run general/parser/columnValue.sim
-sleep 2000
-run general/parser/commit.sim
-sleep 2000
-run general/parser/create_db.sim
-sleep 2000
-run general/parser/create_mt.sim
-sleep 2000
-run general/parser/create_tb.sim
-sleep 2000
-run general/parser/dbtbnameValidate.sim
-sleep 2000
-run general/parser/fill.sim
-sleep 2000
-run general/parser/fill_stb.sim
-sleep 2000
-#run general/parser/fill_us.sim               #
-sleep 2000
-run general/parser/first_last.sim
-sleep 2000
-run general/parser/import_commit1.sim
-sleep 2000
-run general/parser/import_commit2.sim
-sleep 2000
-run general/parser/import_commit3.sim
-sleep 2000
-#run general/parser/import_file.sim
-sleep 2000
-run general/parser/insert_tb.sim
-sleep 2000
-run general/parser/tags_dynamically_specifiy.sim
-sleep 2000
-run general/parser/interp.sim
-sleep 2000
-run general/parser/lastrow.sim
-sleep 2000
-run general/parser/limit.sim
-sleep 2000
-run general/parser/limit1.sim
-sleep 2000
-run general/parser/limit1_tblocks100.sim
-sleep 2000
-run general/parser/limit2.sim
-sleep 2000
-run general/parser/mixed_blocks.sim
-sleep 2000
-run general/parser/nchar.sim
-sleep 2000
-run general/parser/null_char.sim
-sleep 2000
-run general/parser/selectResNum.sim
-sleep 2000
+#sleep 500
+#run general/parser/alter.sim
+#sleep 500
+#run general/parser/alter1.sim
+#sleep 500
+#run general/parser/alter_stable.sim
+#sleep 500
+#run general/parser/auto_create_tb.sim
+#sleep 500
+#run general/parser/auto_create_tb_drop_tb.sim
+#sleep 500
+#run general/parser/col_arithmetic_operation.sim
+#sleep 500
+#run general/parser/columnValue.sim
+#sleep 500
+#run general/parser/commit.sim
+#sleep 500
+#run general/parser/create_db.sim
+#sleep 500
+#run general/parser/create_mt.sim
+#sleep 500
+#run general/parser/create_tb.sim
+#sleep 500
+#run general/parser/dbtbnameValidate.sim
+#sleep 500
+#run general/parser/fill.sim
+#sleep 500
+#run general/parser/fill_stb.sim
+#sleep 500
+##run general/parser/fill_us.sim               #
+#sleep 500
+#run general/parser/first_last.sim
+#sleep 500
+#run general/parser/import_commit1.sim
+#sleep 500
+#run general/parser/import_commit2.sim
+#sleep 500
+#run general/parser/import_commit3.sim
+#sleep 500
+##run general/parser/import_file.sim
+#sleep 500
+#run general/parser/insert_tb.sim
+#sleep 500
+#run general/parser/tags_dynamically_specifiy.sim
+#sleep 500
+#run general/parser/interp.sim
+#sleep 500
+#run general/parser/lastrow.sim
+#sleep 500
+#run general/parser/limit.sim
+#sleep 500
+#run general/parser/limit1.sim
+#sleep 500
+#run general/parser/limit1_tblocks100.sim
+#sleep 500
+#run general/parser/limit2.sim
+#sleep 500
+#run general/parser/mixed_blocks.sim
+#sleep 500
+#run general/parser/nchar.sim
+#sleep 500
+#run general/parser/null_char.sim
+#sleep 500
+#run general/parser/selectResNum.sim
+sleep 500
 run general/parser/select_across_vnodes.sim
-sleep 2000
+sleep 500
 run general/parser/select_from_cache_disk.sim
-sleep 2000
+sleep 500
 run general/parser/set_tag_vals.sim
-sleep 2000
+sleep 500
 run general/parser/single_row_in_tb.sim
-sleep 2000
+sleep 500
 run general/parser/slimit.sim
-sleep 2000
+sleep 500
 run general/parser/slimit1.sim
-sleep 2000
+sleep 500
 run general/parser/slimit_alter_tags.sim
-sleep 2000
+sleep 500
 run general/parser/tbnameIn.sim
-sleep 2000
+sleep 500
 run general/parser/slimit_alter_tags.sim  # persistent failed
-sleep 2000
+sleep 500
 run general/parser/join.sim
-sleep 2000
+sleep 500
 run general/parser/join_multivnode.sim
-sleep 2000
+sleep 500
 run general/parser/projection_limit_offset.sim
-sleep 2000
+sleep 500
 run general/parser/select_with_tags.sim
-sleep 2000
+sleep 500
 run general/parser/groupby.sim
-sleep 2000
+sleep 500
 run general/parser/tags_filter.sim
-sleep 2000
+sleep 500
 run general/parser/topbot.sim
-sleep 2000
+sleep 500
 run general/parser/union.sim
-sleep 2000
+sleep 500
 run general/parser/constCol.sim
-sleep 2000
+sleep 500
 run general/parser/where.sim
-sleep 2000
+sleep 500
 run general/parser/timestamp.sim
-sleep 2000
+sleep 500
 run general/parser/sliding.sim
 
-#sleep 2000
+#sleep 500
 #run general/parser/repeatStream.sim
-#sleep 2000
+#sleep 500
 #run general/parser/stream_on_sys.sim
-#sleep 2000
+#sleep 500
 #run general/parser/stream.sim
\ No newline at end of file
diff --git a/tests/script/general/parser/timestamp.sim b/tests/script/general/parser/timestamp.sim
index 67da0f08698a29582212400f8b189e26d1446ed8..72966459d0ced737e2d0f44702cd5e6956a3aced 100644
--- a/tests/script/general/parser/timestamp.sim
+++ b/tests/script/general/parser/timestamp.sim
@@ -5,7 +5,7 @@ system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4
 
 system sh/exec.sh -n dnode1 -s start
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = ts_db
@@ -59,10 +59,10 @@ run general/parser/timestamp_query.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 3000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
-sleep 3000
+sleep 500
 
 run general/parser/timestamp_query.sim
diff --git a/tests/script/general/parser/timestamp_query.sim b/tests/script/general/parser/timestamp_query.sim
index 783c03602b983bf0faea25db28d1ac1ce29d80b7..056e8bba6bd6587fcba2c2685d9764f3f67c42b7 100644
--- a/tests/script/general/parser/timestamp_query.sim
+++ b/tests/script/general/parser/timestamp_query.sim
@@ -1,4 +1,4 @@
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = ts_db
diff --git a/tests/script/general/parser/topbot.sim b/tests/script/general/parser/topbot.sim
index c2b41888d739c559b24784c42ad040d54d7ae160..08e2f6ab00cdcdc3a974266420f7e66bb2e0a65b 100644
--- a/tests/script/general/parser/topbot.sim
+++ b/tests/script/general/parser/topbot.sim
@@ -5,7 +5,7 @@ system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 200
 
 system sh/exec.sh -n dnode1 -s start
-sleep 1000
+sleep 500
 sql connect
 
 $dbPrefix = tb_db
@@ -128,11 +128,11 @@ sql insert into test values(29999, 1)(70000, 2)(80000, 3)
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 5000
+sleep 3000
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
-sleep 1000
+sleep 500
 
 sql select count(*) from t1.test where ts>10000 and ts<90000 interval(5000a)
 if $rows != 3 then
@@ -169,7 +169,7 @@ endw
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
 system sh/exec.sh -n dnode1 -s start
 sql connect
-sleep 1000
+sleep 500
 sql use db;
 
 $ts = 1000
@@ -221,7 +221,7 @@ sql insert into t2 values('2020-2-2 1:1:1', 1);
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
 system sh/exec.sh -n dnode1 -s start
 sql connect
-sleep 1000
+sleep 500
 
 sql use db
 sql select count(*), first(ts), last(ts) from t2 interval(1d);
diff --git a/tests/script/general/parser/union.sim b/tests/script/general/parser/union.sim
index 024b9c76efe6b8ddd69c723ffc0e1e0b0d82e075..d779d757310336b3b97c6748301e1eab24fe331f 100644
--- a/tests/script/general/parser/union.sim
+++ b/tests/script/general/parser/union.sim
@@ -7,7 +7,7 @@ system sh/cfg.sh -n dnode1 -c rpcDebugFlag -v 135
 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4
 
 system sh/exec.sh -n dnode1 -s start
-sleep 1000
+sleep 500
 sql connect
 
 $dbPrefix = union_db
@@ -96,7 +96,7 @@ while $i < $tbNum
 endw
 
 print sleep 1sec.
-sleep 1000
+sleep 500
 
 $i = 1
 $tb = $tbPrefix . $i
diff --git a/tests/script/general/parser/where.sim b/tests/script/general/parser/where.sim
index 066fac43ad9ee617a2cb9a91a62a6ebf984be6f0..4a38e3c68c64252ab9c53926c2ff33cfddbee2ae 100644
--- a/tests/script/general/parser/where.sim
+++ b/tests/script/general/parser/where.sim
@@ -5,7 +5,7 @@ system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/cfg.sh -n dnode1 -c maxtablespervnode -v 4
 system sh/exec.sh -n dnode1 -s start
 
-sleep 3000
+sleep 500
 sql connect
 
 $dbPrefix = wh_db