merge with develop

src/client/inc/tscUtil.h

@@ -132,10 +132,7 @@ bool tscIsSelectivityWithTagQuery(SSqlCmd* pCmd);
 void tscAddSpecialColumnForSelect(SQueryInfo* pQueryInfo, int32_t outputColIndex, int16_t functionId, SColumnIndex* pIndex,
                                   SSchema* pColSchema, int16_t isTag);
 
-//void addRequiredTagColumn(SQueryInfo* pQueryInfo, int32_t tagColIndex, int32_t tableIndex);
-void addRequiredTagColumn(STableMetaInfo* pTableMetaInfo, SColumnIndex* index);
-
-int32_t tscSetTableId(STableMetaInfo* pTableMetaInfo, SSQLToken* pzTableName, SSqlObj* pSql);
+int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SSQLToken* pzTableName, SSqlObj* pSql);
 void    tscClearInterpInfo(SQueryInfo* pQueryInfo);
 
 bool tscIsInsertData(char* sqlstr);

src/client/inc/tsclient.h

@@ -56,6 +56,7 @@ typedef struct STableMeta {
   STableComInfo tableInfo;
   uint8_t       tableType;
   int16_t       sversion;
+  int16_t       tversion;
   SCMVgroupInfo vgroupInfo;
   int32_t       sid;       // the index of one table in a virtual node
   uint64_t      uid;       // unique id of a table
@@ -294,7 +295,6 @@ typedef struct STscObj {
   char               writeAuth : 1;
   char               superAuth : 1;
   uint32_t           connId;
-  struct SSqlObj *   pSql;
   struct SSqlObj *   pHb;
   struct SSqlObj *   sqlList;
   struct SSqlStream *streamList;
@@ -411,7 +411,7 @@ void doAsyncQuery(STscObj *pObj, SSqlObj *pSql, void (*fp)(), void *param, const
 void tscProcessMultiVnodesInsertFromFile(SSqlObj *pSql);
 void tscKillSTableQuery(SSqlObj *pSql);
 void tscInitResObjForLocalQuery(SSqlObj *pObj, int32_t numOfRes, int32_t rowLen);
-bool tscIsUpdateQuery(STscObj *pObj);
+bool tscIsUpdateQuery(SSqlObj* pSql);
 bool tscHasReachLimitation(SQueryInfo *pQueryInfo, SSqlRes *pRes);
 
 char *tscGetErrorMsgPayload(SSqlCmd *pCmd);

src/client/jni/com_taosdata_jdbc_TSDBJNIConnector.h

@@ -62,7 +62,7 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_connectImp
  * Method:    executeQueryImp
  * Signature: ([BJ)I
  */
-JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_executeQueryImp
+JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_executeQueryImp
   (JNIEnv *, jobject, jbyteArray, jlong);
 
 /*
@@ -71,7 +71,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_executeQueryImp
  * Signature: (J)I
  */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getErrCodeImp
-  (JNIEnv *, jobject, jlong);
+  (JNIEnv *, jobject, jlong, jlong);
 
 /*
  * Class:     com_taosdata_jdbc_TSDBJNIConnector
@@ -87,7 +87,7 @@ JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getErrMsgImp
  * Signature: (J)J
  */
 JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getResultSetImp
-  (JNIEnv *, jobject, jlong);
+  (JNIEnv *env, jobject jobj, jlong con, jlong tres);
 
 /*
  * Class:     com_taosdata_jdbc_TSDBJNIConnector
@@ -103,7 +103,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_freeResultSetImp
  * Signature: (J)I
  */
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getAffectedRowsImp
-  (JNIEnv *, jobject, jlong);
+  (JNIEnv *env, jobject jobj, jlong con, jlong res);
 
 /*
  * Class:     com_taosdata_jdbc_TSDBJNIConnector
@@ -142,8 +142,8 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_subscribeImp
  * Method:    consumeImp
  * Signature: (J)Lcom/taosdata/jdbc/TSDBResultSetRowData;
  */
-JNIEXPORT jobject JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_consumeImp
-  (JNIEnv *, jobject, jlong, jint);
+JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_consumeImp
+  (JNIEnv *, jobject, jlong);
 
 /*
  * Class:     com_taosdata_jdbc_TSDBJNIConnector

src/client/src/TSDBJNIConnector.c

@@ -13,19 +13,35 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "com_taosdata_jdbc_TSDBJNIConnector.h"
 #include "os.h"
 #include "taos.h"
-#include "tscSubquery.h"
+#include "tlog.h"
 #include "tscUtil.h"
 #include "tsclient.h"
-#include "tlog.h"
 #include "ttime.h"
 
-#define jniError(...)  { if (jniDebugFlag & DEBUG_ERROR) { taosPrintLog("ERROR JNI ", jniDebugFlag, __VA_ARGS__); }}
-#define jniWarn(...)   { if (jniDebugFlag & DEBUG_WARN)  { taosPrintLog("WARN JNI ", jniDebugFlag, __VA_ARGS__); }}
-#define jniTrace(...)  { if (jniDebugFlag & DEBUG_TRACE) { taosPrintLog("JNI ", jniDebugFlag, __VA_ARGS__); }}
-#define jniPrint(...)  { taosPrintLog("JNI ", tscEmbedded ? 255 : uDebugFlag, __VA_ARGS__); }
+#include "com_taosdata_jdbc_TSDBJNIConnector.h"
+
+#define jniError(...)                                        \
+  {                                                          \
+    if (jniDebugFlag & DEBUG_ERROR) {                        \
+      taosPrintLog("ERROR JNI ", jniDebugFlag, __VA_ARGS__); \
+    }                                                        \
+  }
+#define jniWarn(...)                                        \
+  {                                                         \
+    if (jniDebugFlag & DEBUG_WARN) {                        \
+      taosPrintLog("WARN JNI ", jniDebugFlag, __VA_ARGS__); \
+    }                                                       \
+  }
+#define jniTrace(...)                                  \
+  {                                                    \
+    if (jniDebugFlag & DEBUG_TRACE) {                  \
+      taosPrintLog("JNI ", jniDebugFlag, __VA_ARGS__); \
+    }                                                  \
+  }
+#define jniPrint(...) \
+  { taosPrintLog("JNI ", tscEmbedded ? 255 : uDebugFlag, __VA_ARGS__); }
 
 int __init = 0;
 
@@ -117,7 +133,8 @@ void jniGetGlobalMethod(JNIEnv *env) {
   jniTrace("native method register finished");
 }
 
-JNIEXPORT void JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setAllocModeImp(JNIEnv *env, jobject jobj, jint jMode, jstring jPath, jboolean jAutoDump) {
+JNIEXPORT void JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setAllocModeImp(JNIEnv *env, jobject jobj, jint jMode,
+                                                                               jstring jPath, jboolean jAutoDump) {
   if (jPath != NULL) {
     const char *path = (*env)->GetStringUTFChars(env, jPath, NULL);
     taosSetAllocMode(jMode, path, !!jAutoDump);
@@ -172,14 +189,14 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setOptions(JNIEnv
     }
     (*env)->ReleaseStringUTFChars(env, optionValue, charset);
   } else if (optionIndex == TSDB_OPTION_TIMEZONE) {
-    const char *timezone = (*env)->GetStringUTFChars(env, optionValue, NULL);
-    if (timezone && strlen(timezone) != 0) {
-      res = taos_options(TSDB_OPTION_TIMEZONE, timezone);
+    const char *tz1 = (*env)->GetStringUTFChars(env, optionValue, NULL);
+    if (tz1 && strlen(tz1) != 0) {
+      res = taos_options(TSDB_OPTION_TIMEZONE, tz1);
       jniTrace("set timezone to %s, result:%d", timezone, res);
     } else {
       jniTrace("input timezone is empty");
     }
-    (*env)->ReleaseStringUTFChars(env, optionValue, timezone);
+    (*env)->ReleaseStringUTFChars(env, optionValue, tz1);
   } else {
     jniError("option index:%d is not found", optionIndex);
   }
@@ -219,9 +236,9 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_connectImp(JNIEn
   }
 
   /*
-  * set numOfThreadsPerCore = 0
-  * means only one thread for client side scheduler
-  */
+   * 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, jport);
@@ -241,8 +258,8 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_connectImp(JNIEn
   return ret;
 }
 
-JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_executeQueryImp(JNIEnv *env, jobject jobj,
-                                                                               jbyteArray jsql, jlong con) {
+JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_executeQueryImp(JNIEnv *env, jobject jobj,
+                                                                                jbyteArray jsql, jlong con) {
   TAOS *tscon = (TAOS *)con;
   if (tscon == NULL) {
     jniError("jobj:%p, connection is already closed", jobj);
@@ -264,65 +281,76 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_executeQueryImp(J
 
   (*env)->GetByteArrayRegion(env, jsql, 0, len, (jbyte *)dst);
   if ((*env)->ExceptionCheck(env)) {
-    //todo handle error
+    // todo handle error
   }
 
   jniTrace("jobj:%p, conn:%p, sql:%s", jobj, tscon, dst);
 
-  int code = taos_query(tscon, dst);
-  if (code != 0) {
-    jniError("jobj:%p, conn:%p, code:%s, msg:%s", jobj, tscon, tstrerror(code), taos_errstr(tscon));
-    free(dst);
-    return JNI_TDENGINE_ERROR;
-  } else {
-    int32_t  affectRows = 0;
-    SSqlObj *pSql = ((STscObj *)tscon)->pSql;
+  SSqlObj *pSql = taos_query(tscon, dst);
+  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(tscon);
+      affectRows = taos_affected_rows(pSql);
       jniTrace("jobj:%p, conn:%p, code:%s, affect rows:%d", jobj, tscon, tstrerror(code), affectRows);
     } else {
       jniTrace("jobj:%p, conn:%p, code:%s", jobj, tscon, tstrerror(code));
     }
-
-    free(dst);
-    return affectRows;
   }
+
+  free(dst);
+  return (jlong)pSql;
 }
 
-JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getErrCodeImp(JNIEnv *env, jobject jobj, jlong con) {
+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_INVALID_CONNECTION;
+    return (jint)TSDB_CODE_INVALID_CONNECTION;
+  }
+
+  if ((void *)tres == NULL) {
+    jniError("jobj:%p, conn:%p, resultset is null", jobj, tscon);
+    return JNI_RESULT_SET_NULL;
   }
 
-  return (jint)-taos_errno(tscon);
+  TAOS_RES *pSql = (TAOS_RES *)tres;
+
+  return (jint)taos_errno(pSql);
 }
 
-JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getErrMsgImp(JNIEnv *env, jobject jobj, jlong con) {
-  TAOS *tscon = (TAOS *)con;
-  return (*env)->NewStringUTF(env, (const char *)taos_errstr(tscon));
+JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getErrMsgImp(JNIEnv *env, jobject jobj, jlong tres) {
+  TAOS_RES *pSql = (TAOS_RES *)tres;
+  return (*env)->NewStringUTF(env, (const char *)taos_errstr(pSql));
 }
 
-JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getResultSetImp(JNIEnv *env, jobject jobj, jlong con) {
+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;
   }
 
-  jlong ret = 0;
+  if ((void *)tres == NULL) {
+    jniError("jobj:%p, conn:%p, resultset is null", jobj, tscon);
+    return JNI_RESULT_SET_NULL;
+  }
+
+  SSqlObj *pSql = (TAOS_RES *)tres;
+  STscObj *pObj = pSql->pTscObj;
 
-  if (tscIsUpdateQuery(tscon)) {
-    ret = 0;  // for update query, no result pointer
-    jniTrace("jobj:%p, conn:%p, no resultset", jobj, tscon);
+  if (tscIsUpdateQuery(pSql)) {
+    taos_free_result(pSql);  // free result here
+    jniTrace("jobj:%p, conn:%p, no resultset, %p", jobj, pObj, (void *)tres);
+    return 0;
   } else {
-    ret = (jlong) taos_use_result(tscon);
-    jniTrace("jobj:%p, conn:%p, get resultset:%p", jobj, tscon, (void *) ret);
+    jniTrace("jobj:%p, conn:%p, get resultset, %p", jobj, pObj, (void *)tres);
+    return tres;
   }
-
-  return ret;
 }
 
 JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_freeResultSetImp(JNIEnv *env, jobject jobj, jlong con,
@@ -343,17 +371,21 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_freeResultSetImp(
   return JNI_SUCCESS;
 }
 
-JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getAffectedRowsImp(JNIEnv *env, jobject jobj,
-                                                                                  jlong con) {
+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;
   }
 
-  jint ret = taos_affected_rows(tscon);
+  if ((void *)res == NULL) {
+    jniError("jobj:%p, conn:%p, resultset is null", jobj, tscon);
+    return JNI_RESULT_SET_NULL;
+  }
 
-  jniTrace("jobj:%p, conn:%p, affect rows:%d", jobj, tscon, (void *)con, ret);
+  jint ret = taos_affected_rows((SSqlObj *)res);
+  jniTrace("jobj:%p, conn:%p, sql:%p, affect rows:%d", jobj, tscon, (void *)con, res, ret);
 
   return ret;
 }
@@ -405,7 +437,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_getSchemaMetaData
  * @return
  */
 jstring jniFromNCharToByteArray(JNIEnv *env, char *nchar, int32_t maxBytes) {
-  int        len = (int)strlen(nchar);
+  int len = (int)strlen(nchar);
   if (len > maxBytes) {  // no terminated symbol exists '\0'
     len = maxBytes;
   }
@@ -439,7 +471,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchRowImp(JNIEn
 
   TAOS_ROW row = taos_fetch_row(result);
   if (row == NULL) {
-    int tserrno = taos_errno(tscon);
+    int tserrno = taos_errno(result);
     if (tserrno == 0) {
       jniTrace("jobj:%p, conn:%p, resultset:%p, fields size is %d, fetch row to the end", jobj, tscon, res, num_fields);
       return JNI_FETCH_END;
@@ -476,24 +508,22 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchRowImp(JNIEn
         float fv = 0;
         fv = GET_FLOAT_VAL(row[i]);
         (*env)->CallVoidMethod(env, rowobj, g_rowdataSetFloatFp, i, (jfloat)fv);
-      }
-        break;
+      } break;
       case TSDB_DATA_TYPE_DOUBLE: {
         double dv = 0;
         dv = GET_DOUBLE_VAL(row[i]);
         (*env)->CallVoidMethod(env, rowobj, g_rowdataSetDoubleFp, i, (jdouble)dv);
-      }
-        break;
+      } break;
       case TSDB_DATA_TYPE_BINARY: {
-        strncpy(tmp, row[i], (size_t) fields[i].bytes);  // handle the case that terminated does not exist
+        strncpy(tmp, row[i], (size_t)fields[i].bytes);  // handle the case that terminated does not exist
         (*env)->CallVoidMethod(env, rowobj, g_rowdataSetStringFp, i, (*env)->NewStringUTF(env, tmp));
 
-        memset(tmp, 0, (size_t) fields[i].bytes);
+        memset(tmp, 0, (size_t)fields[i].bytes);
         break;
       }
       case TSDB_DATA_TYPE_NCHAR: {
         (*env)->CallVoidMethod(env, rowobj, g_rowdataSetByteArrayFp, i,
-                               jniFromNCharToByteArray(env, (char*)row[i], fields[i].bytes));
+                               jniFromNCharToByteArray(env, (char *)row[i], fields[i].bytes));
         break;
       }
       case TSDB_DATA_TYPE_TIMESTAMP:
@@ -552,110 +582,24 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_subscribeImp(JNI
   return sub;
 }
 
-static jobject convert_one_row(JNIEnv *env, TAOS_ROW row, TAOS_FIELD* fields, int num_fields) {
-  jobject rowobj = (*env)->NewObject(env, g_rowdataClass, g_rowdataConstructor, num_fields);
-  jniTrace("created a rowdata object, rowobj:%p", rowobj);
-
-  for (int i = 0; i < num_fields; i++) {
-    if (row[i] == NULL) {
-      continue;
-    }
-
-    switch (fields[i].type) {
-      case TSDB_DATA_TYPE_BOOL:
-        (*env)->CallVoidMethod(env, rowobj, g_rowdataSetBooleanFp, i, (jboolean)(*((char *)row[i]) == 1));
-        break;
-      case TSDB_DATA_TYPE_TINYINT:
-        (*env)->CallVoidMethod(env, rowobj, g_rowdataSetByteFp, i, (jbyte) * ((char *)row[i]));
-        break;
-      case TSDB_DATA_TYPE_SMALLINT:
-        (*env)->CallVoidMethod(env, rowobj, g_rowdataSetShortFp, i, (jshort) * ((short *)row[i]));
-        break;
-      case TSDB_DATA_TYPE_INT:
-        (*env)->CallVoidMethod(env, rowobj, g_rowdataSetIntFp, i, (jint) * (int *)row[i]);
-        break;
-      case TSDB_DATA_TYPE_BIGINT:
-        (*env)->CallVoidMethod(env, rowobj, g_rowdataSetLongFp, i, (jlong) * ((int64_t *)row[i]));
-        break;
-      case TSDB_DATA_TYPE_FLOAT: {
-        float fv = 0;
-        fv = GET_FLOAT_VAL(row[i]);
-        (*env)->CallVoidMethod(env, rowobj, g_rowdataSetFloatFp, i, (jfloat)fv);
-      }
-        break;
-      case TSDB_DATA_TYPE_DOUBLE:{
-        double dv = 0;
-        dv = GET_DOUBLE_VAL(row[i]);
-        (*env)->CallVoidMethod(env, rowobj, g_rowdataSetDoubleFp, i, (jdouble)dv);
-      }
-        break;
-      case TSDB_DATA_TYPE_BINARY: {
-        char tmp[TSDB_MAX_BYTES_PER_ROW] = {0};
-        strncpy(tmp, row[i], (size_t) fields[i].bytes);  // handle the case that terminated does not exist
-        (*env)->CallVoidMethod(env, rowobj, g_rowdataSetStringFp, i, (*env)->NewStringUTF(env, tmp));
-
-        memset(tmp, 0, (size_t) fields[i].bytes);
-        break;
-      }
-      case TSDB_DATA_TYPE_NCHAR:
-        (*env)->CallVoidMethod(env, rowobj, g_rowdataSetByteArrayFp, i,
-                              jniFromNCharToByteArray(env, (char*)row[i], fields[i].bytes));
-        break;
-      case TSDB_DATA_TYPE_TIMESTAMP:
-        (*env)->CallVoidMethod(env, rowobj, g_rowdataSetTimestampFp, i, (jlong) * ((int64_t *)row[i]));
-        break;
-      default:
-        break;
-    }
-  }
-  return rowobj;
-}
-
-JNIEXPORT jobject JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_consumeImp(JNIEnv *env, jobject jobj, jlong sub, jint timeout) {
+JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_consumeImp(JNIEnv *env, jobject jobj, jlong sub) {
   jniTrace("jobj:%p, in TSDBJNIConnector_consumeImp, sub:%ld", jobj, sub);
   jniGetGlobalMethod(env);
 
   TAOS_SUB *tsub = (TAOS_SUB *)sub;
-  jobject   rows = (*env)->NewObject(env, g_arrayListClass, g_arrayListConstructFp);
 
-  int64_t start = taosGetTimestampMs();
-  int count = 0;
+  TAOS_RES *res = taos_consume(tsub);
 
-  while (true) {
-    TAOS_RES *  res = taos_consume(tsub);
-    if (res == NULL) {
-      jniError("jobj:%p, tsub:%p, taos_consume returns NULL", jobj, tsub);
-      return NULL;
-    }
-
-    TAOS_FIELD *fields = taos_fetch_fields(res);
-    int         num_fields = taos_num_fields(res);
-    while (true) {
-      TAOS_ROW row = taos_fetch_row(res);
-      if (row == NULL) {
-        break;
-      }
-      jobject rowobj = convert_one_row(env, row, fields, num_fields);
-      (*env)->CallBooleanMethod(env, rows, g_arrayListAddFp, rowobj);
-      count++;
-    }
-
-    if (count > 0) {
-      break;
-    }
-    if (timeout == -1) {
-      continue;
-    }
-    if (((int)(taosGetTimestampMs() - start)) >= timeout) {
-      jniTrace("jobj:%p, sub:%ld, timeout", jobj, sub);
-      break;
-    }
+  if (res == NULL) {
+    jniError("jobj:%p, tsub:%p, taos_consume returns NULL", jobj, tsub);
+    return 0l;
   }
 
-  return rows;
+  return (long)res;
 }
 
-JNIEXPORT void JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_unsubscribeImp(JNIEnv *env, jobject jobj, jlong sub, jboolean keepProgress) {
+JNIEXPORT void JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_unsubscribeImp(JNIEnv *env, jobject jobj, jlong sub,
+                                                                              jboolean keepProgress) {
   TAOS_SUB *tsub = (TAOS_SUB *)sub;
   taos_unsubscribe(tsub, keepProgress);
 }
@@ -678,7 +622,7 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_validateCreateTab
   char *dst = (char *)calloc(1, sizeof(char) * (len + 1));
   (*env)->GetByteArrayRegion(env, jsql, 0, len, (jbyte *)dst);
   if ((*env)->ExceptionCheck(env)) {
-    //todo handle error
+    // todo handle error
   }
 
   int code = taos_validate_sql(tscon, dst);

src/client/src/tscAsync.c

@@ -50,14 +50,15 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, void (*fp)(), void* param, const
   pSql->maxRetry  = TSDB_MAX_REPLICA_NUM;
   pSql->fp        = fp;
   
+  sem_init(&pSql->rspSem, 0, 0);
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, TSDB_DEFAULT_PAYLOAD_SIZE)) {
     tscError("failed to malloc payload");
     tscQueueAsyncError(fp, param, TSDB_CODE_CLI_OUT_OF_MEMORY);
     return;
   }
   
-  pSql->sqlstr = realloc(pSql->sqlstr, sqlLen + 1);
-  
+  // todo check for OOM problem
+  pSql->sqlstr = calloc(1, sqlLen + 1);
   if (pSql->sqlstr == NULL) {
     tscError("%p failed to malloc sql string buffer", pSql);
     tscQueueAsyncError(fp, param, TSDB_CODE_CLI_OUT_OF_MEMORY);
@@ -95,7 +96,7 @@ void taos_query_a(TAOS *taos, const char *sqlstr, __async_cb_func_t fp, void *pa
   
   int32_t sqlLen = strlen(sqlstr);
   if (sqlLen > tsMaxSQLStringLen) {
-    tscError("sql string too long");
+    tscError("sql string exceeds max length:%d", tsMaxSQLStringLen);
     terrno = TSDB_CODE_INVALID_SQL;
     tscQueueAsyncError(fp, param, TSDB_CODE_INVALID_SQL);
     return;
@@ -486,7 +487,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
           STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
           code = tscGetTableMeta(pSql, pTableMetaInfo);
           assert(code == TSDB_CODE_SUCCESS && pTableMetaInfo->pTableMeta != NULL);
-          (*pSql->fp)(pSql->param, NULL, code);
+          (*pSql->fp)(pSql->param, pSql, code);
           return;
         }
         

src/client/src/tscParseInsert.c

@@ -793,7 +793,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
     }
 
     STableMetaInfo *pSTableMeterMetaInfo = tscGetMetaInfo(pQueryInfo, STABLE_INDEX);
-    tscSetTableId(pSTableMeterMetaInfo, &sToken, pSql);
+    tscSetTableFullName(pSTableMeterMetaInfo, &sToken, pSql);
 
     strncpy(pTag->name, pSTableMeterMetaInfo->name, TSDB_TABLE_ID_LEN);
     code = tscGetTableMeta(pSql, pSTableMeterMetaInfo);
@@ -834,9 +834,8 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
         sql += index;
 
         if (TK_STRING == sToken.type) {
-          sToken.n = strdequote(sToken.z);
-          strtrim(sToken.z);
-          sToken.n = (uint32_t)strlen(sToken.z);
+          strdequote(sToken.z);
+          sToken.n = strtrim(sToken.z);
         }
 
         if (sToken.type == TK_RP) {
@@ -925,7 +924,11 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
 
       for (int32_t i = 0; i < spd.numOfCols; ++i) {
         if (!spd.hasVal[i]) {  // current tag column do not have any value to insert, set it to null
-          setNull(ptr, pTagSchema[i].type, pTagSchema[i].bytes);
+          if (pTagSchema[i].type == TSDB_DATA_TYPE_BINARY || pTagSchema[i].type == TSDB_DATA_TYPE_NCHAR) {
+            setVardataNull(ptr, pTagSchema[i].type);
+          } else {
+            setNull(ptr, pTagSchema[i].type, pTagSchema[i].bytes);
+          }
         }
 
         ptr += pTagSchema[i].bytes;
@@ -944,7 +947,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql) {
       return tscInvalidSQLErrMsg(pCmd->payload, "invalid table name", *sqlstr);
     }
 
-    int32_t ret = tscSetTableId(pTableMetaInfo, &tableToken, pSql);
+    int32_t ret = tscSetTableFullName(pTableMetaInfo, &tableToken, pSql);
     if (ret != TSDB_CODE_SUCCESS) {
       return ret;
     }
@@ -1087,7 +1090,7 @@ int doParseInsertSql(SSqlObj *pSql, char *str) {
       goto _error_clean;
     }
 
-    if ((code = tscSetTableId(pTableMetaInfo, &sToken, pSql)) != TSDB_CODE_SUCCESS) {
+    if ((code = tscSetTableFullName(pTableMetaInfo, &sToken, pSql)) != TSDB_CODE_SUCCESS) {
       goto _error_clean;
     }
 
@@ -1205,9 +1208,8 @@ int doParseInsertSql(SSqlObj *pSql, char *str) {
         str += index;
 
         if (TK_STRING == sToken.type) {
-          sToken.n = strdequote(sToken.z);
-          strtrim(sToken.z);
-          sToken.n = (uint32_t)strlen(sToken.z);
+          strdequote(sToken.z);
+          sToken.n = strtrim(sToken.z);
         }
 
         if (sToken.type == TK_RP) {

src/client/src/tscPrepare.c

@@ -494,7 +494,7 @@ TAOS_STMT* taos_stmt_init(TAOS* taos) {
   tsem_init(&pSql->rspSem, 0, 0);
   pSql->signature     = pSql;
   pSql->pTscObj       = pObj;
-  pSql->pTscObj->pSql = pSql;
+  //pSql->pTscObj->pSql = pSql;
   pSql->maxRetry      = TSDB_MAX_REPLICA_NUM;
 
   pStmt->pSql = pSql;
@@ -515,7 +515,7 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
   //doAsyncQuery(pObj, pSql, waitForQueryRsp, taos, sqlstr, sqlLen);
   SSqlCmd *pCmd    = &pSql->cmd;
   SSqlRes *pRes    = &pSql->res;
-  pSql->param      = (void*)pStmt->taos;
+  pSql->param      = (void*)pSql;
   pSql->fp         = waitForQueryRsp;
   pSql->insertType = TSDB_QUERY_TYPE_STMT_INSERT;
   
@@ -613,7 +613,9 @@ int taos_stmt_execute(TAOS_STMT* stmt) {
     } else {
       tfree(pStmt->pSql->sqlstr);
       pStmt->pSql->sqlstr = sql;
-      ret = taos_query(pStmt->taos, pStmt->pSql->sqlstr);
+      SSqlObj* pSql = taos_query((TAOS*)pStmt->taos, pStmt->pSql->sqlstr);
+      ret = taos_errno(pSql);
+      taos_free_result(pSql);
     }
   }
   return ret;

src/client/src/tscProfile.c

@@ -89,13 +89,23 @@ void tscSaveSlowQueryFp(void *handle, void *tmrId) {
 }
 
 void tscSaveSlowQuery(SSqlObj *pSql) {
-  const static int64_t SLOW_QUERY_INTERVAL = 3000000L;
-  if (pSql->res.useconds < SLOW_QUERY_INTERVAL) return;
+  const static int64_t SLOW_QUERY_INTERVAL = 3000000L; // todo configurable
+  size_t size = 200;  // other part of sql string, expect the main sql str
+  
+  if (pSql->res.useconds < SLOW_QUERY_INTERVAL) {
+    return;
+  }
 
   tscTrace("%p query time:%" PRId64 " sql:%s", pSql, pSql->res.useconds, pSql->sqlstr);
-
-  char *sql = malloc(200);
-  int   len = snprintf(sql, 200, "insert into %s.slowquery values(now, '%s', %" PRId64 ", %" PRId64 ", '", tsMonitorDbName,
+  int32_t sqlSize = TSDB_SLOW_QUERY_SQL_LEN + size;
+  
+  char *sql = malloc(sqlSize);
+  if (sql == NULL) {
+    tscError("%p failed to allocate memory to sent slow query to dnode", pSql);
+    return;
+  }
+  
+  int len = snprintf(sql, size, "insert into %s.slowquery values(now, '%s', %" PRId64 ", %" PRId64 ", '", tsMonitorDbName,
           pSql->pTscObj->user, pSql->stime, pSql->res.useconds);
   int sqlLen = snprintf(sql + len, TSDB_SLOW_QUERY_SQL_LEN, "%s", pSql->sqlstr);
   if (sqlLen > TSDB_SLOW_QUERY_SQL_LEN - 1) {
@@ -103,8 +113,8 @@ void tscSaveSlowQuery(SSqlObj *pSql) {
   } else {
     sqlLen += len;
   }
+  
   strcpy(sql + sqlLen, "')");
-
   taosTmrStart(tscSaveSlowQueryFp, 200, sql, tscTmr);
 }
 

src/client/src/tscSQLParser.c

@@ -163,8 +163,7 @@ static int32_t handlePassword(SSqlCmd* pCmd, SSQLToken* pPwd) {
   }
 
   strdequote(pPwd->z);
-  strtrim(pPwd->z);  // trim space before and after passwords
-  pPwd->n = strlen(pPwd->z);
+  pPwd->n = strtrim(pPwd->z);  // trim space before and after passwords
 
   if (pPwd->n <= 0) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
@@ -226,7 +225,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       } else if (pInfo->type == TSDB_SQL_DROP_TABLE) {
         assert(pInfo->pDCLInfo->nTokens == 1);
 
-        if (tscSetTableId(pTableMetaInfo, pzName, pSql) != TSDB_CODE_SUCCESS) {
+        if (tscSetTableFullName(pTableMetaInfo, pzName, pSql) != TSDB_CODE_SUCCESS) {
           return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
         }
       } else if (pInfo->type == TSDB_SQL_DROP_DNODE) {
@@ -353,7 +352,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
 
-      if (tscSetTableId(pTableMetaInfo, pToken, pSql) != TSDB_CODE_SUCCESS) {
+      if (tscSetTableFullName(pTableMetaInfo, pToken, pSql) != TSDB_CODE_SUCCESS) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
 
@@ -686,7 +685,7 @@ int32_t parseSlidingClause(SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t tscSetTableId(STableMetaInfo* pTableMetaInfo, SSQLToken* pzTableName, SSqlObj* pSql) {
+int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SSQLToken* pzTableName, SSqlObj* pSql) {
   const char* msg = "name too long";
 
   SSqlCmd* pCmd = &pSql->cmd;
@@ -1465,7 +1464,6 @@ static int32_t setExprInfoForFunctions(SQueryInfo* pQueryInfo, SSchema* pSchema,
 
 int32_t addExprAndResultField(SQueryInfo* pQueryInfo, int32_t colIndex, tSQLExprItem* pItem, bool finalResult) {
   STableMetaInfo* pTableMetaInfo = NULL;
-  
   int32_t optr = pItem->pNode->nSQLOptr;
 
   const char* msg1 = "not support column types";
@@ -4302,7 +4300,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     return invalidSqlErrMsg(pQueryInfo->msg, msg1);
   }
 
-  if (tscSetTableId(pTableMetaInfo, &(pAlterSQL->name), pSql) != TSDB_CODE_SUCCESS) {
+  if (tscSetTableFullName(pTableMetaInfo, &(pAlterSQL->name), pSql) != TSDB_CODE_SUCCESS) {
     return invalidSqlErrMsg(pQueryInfo->msg, msg2);
   }
 
@@ -4410,7 +4408,9 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
   } else if (pAlterSQL->type == TSDB_ALTER_TABLE_UPDATE_TAG_VAL) {
     // Note: update can only be applied to table not super table.
-    // the following is handle display tags value for meters created according to super table
+    // the following is used to handle tags value for table created according to super table
+    pCmd->command = TSDB_SQL_UPDATE_TAGS_VAL;
+    
     tVariantList* pVarList = pAlterSQL->varList;
     tVariant*     pTagName = &pVarList->a[0].pVar;
 
@@ -4433,15 +4433,38 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
     // validate the length of binary
     if ((pTagsSchema->type == TSDB_DATA_TYPE_BINARY || pTagsSchema->type == TSDB_DATA_TYPE_NCHAR) &&
-        pVarList->a[1].pVar.nLen > pTagsSchema->bytes) {
+        (pVarList->a[1].pVar.nLen + VARSTR_HEADER_SIZE) > pTagsSchema->bytes) {
       return invalidSqlErrMsg(pQueryInfo->msg, msg14);
     }
-
-    char name1[128] = {0};
-    strncpy(name1, pTagName->pz, pTagName->nLen);
   
-    TAOS_FIELD f = tscCreateField(TSDB_DATA_TYPE_INT, name1, tDataTypeDesc[TSDB_DATA_TYPE_INT].nSize);
-    tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
+    int32_t size = sizeof(SUpdateTableTagValMsg) + pTagsSchema->bytes + TSDB_EXTRA_PAYLOAD_SIZE;
+    if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, size)) {
+      tscError("%p failed to malloc for alter table msg", pSql);
+      return TSDB_CODE_CLI_OUT_OF_MEMORY;
+    }
+
+    SUpdateTableTagValMsg* pUpdateMsg = (SUpdateTableTagValMsg*) (pCmd->payload + tsRpcHeadSize);
+    pUpdateMsg->head.vgId = htonl(pTableMeta->vgroupInfo.vgId);
+    pUpdateMsg->tid = htonl(pTableMeta->sid);
+    pUpdateMsg->uid = htobe64(pTableMeta->uid);
+    pUpdateMsg->colId = htons(pTagsSchema->colId);
+    pUpdateMsg->type  = htons(pTagsSchema->type);
+    pUpdateMsg->bytes = htons(pTagsSchema->bytes);
+    pUpdateMsg->tversion = htons(pTableMeta->tversion);
+    
+    tVariantDump(&pVarList->a[1].pVar, pUpdateMsg->data, pTagsSchema->type, true);
+    
+    int32_t len = 0;
+    if (pTagsSchema->type != TSDB_DATA_TYPE_BINARY && pTagsSchema->type != TSDB_DATA_TYPE_NCHAR) {
+      len = tDataTypeDesc[pTagsSchema->type].nSize;
+    } else {
+      len = varDataLen(pUpdateMsg->data);
+    }
+    
+    pUpdateMsg->tagValLen = htonl(len);  // length may be changed after dump data
+    
+    int32_t total = sizeof(SUpdateTableTagValMsg) + len;
+    pUpdateMsg->head.contLen = htonl(total);
     
   } else if (pAlterSQL->type == TSDB_ALTER_TABLE_ADD_COLUMN) {
     tFieldList* pFieldList = pAlterSQL->pAddColumns;
@@ -4654,8 +4677,7 @@ int32_t validateColumnName(char* name) {
 
   if (token.type == TK_STRING) {
     strdequote(token.z);
-    strtrim(token.z);
-    token.n = (uint32_t)strlen(token.z);
+    token.n = strtrim(token.z);
 
     int32_t k = tSQLGetToken(token.z, &token.type);
     if (k != token.n) {
@@ -5499,7 +5521,7 @@ int32_t doCheckForCreateTable(SSqlObj* pSql, int32_t subClauseIndex, SSqlInfo* p
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
-  if (tscSetTableId(pTableMetaInfo, pzTableName, pSql) != TSDB_CODE_SUCCESS) {
+  if (tscSetTableFullName(pTableMetaInfo, pzTableName, pSql) != TSDB_CODE_SUCCESS) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
   }
 
@@ -5554,7 +5576,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
-  if (tscSetTableId(pStableMeterMetaInfo, pToken, pSql) != TSDB_CODE_SUCCESS) {
+  if (tscSetTableFullName(pStableMeterMetaInfo, pToken, pSql) != TSDB_CODE_SUCCESS) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
@@ -5600,7 +5622,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
   }
 
   STableMetaInfo* pTableMeterMetaInfo = tscGetMetaInfo(pQueryInfo, TABLE_INDEX);
-  ret = tscSetTableId(pTableMeterMetaInfo, &pInfo->pCreateTableInfo->name, pSql);
+  ret = tscSetTableFullName(pTableMeterMetaInfo, &pInfo->pCreateTableInfo->name, pSql);
   if (ret != TSDB_CODE_SUCCESS) {
     return ret;
   }
@@ -5643,7 +5665,7 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
     return invalidSqlErrMsg(pQueryInfo->msg, msg1);
   }
 
-  if (tscSetTableId(pTableMetaInfo, &srcToken, pSql) != TSDB_CODE_SUCCESS) {
+  if (tscSetTableFullName(pTableMetaInfo, &srcToken, pSql) != TSDB_CODE_SUCCESS) {
     return invalidSqlErrMsg(pQueryInfo->msg, msg2);
   }
 
@@ -5674,7 +5696,7 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
   }
 
   // set the created table[stream] name
-  if (tscSetTableId(pTableMetaInfo, pzTableName, pSql) != TSDB_CODE_SUCCESS) {
+  if (tscSetTableFullName(pTableMetaInfo, pzTableName, pSql) != TSDB_CODE_SUCCESS) {
     return invalidSqlErrMsg(pQueryInfo->msg, msg1);
   }
 
@@ -5783,7 +5805,7 @@ int32_t doCheckForQuery(SSqlObj* pSql, SQuerySQL* pQuerySql, int32_t index) {
     STableMetaInfo* pMeterInfo1 = tscGetMetaInfo(pQueryInfo, i);
 
     SSQLToken t = {.type = TSDB_DATA_TYPE_BINARY, .n = pTableItem->nLen, .z = pTableItem->pz};
-    if (tscSetTableId(pMeterInfo1, &t, pSql) != TSDB_CODE_SUCCESS) {
+    if (tscSetTableFullName(pMeterInfo1, &t, pSql) != TSDB_CODE_SUCCESS) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 

src/client/src/tscSchemaUtil.c

@@ -168,6 +168,8 @@ STableMeta* tscCreateTableMetaFromMsg(STableMetaMsg* pTableMetaMsg, size_t* size
   pTableMeta->sid = pTableMetaMsg->sid;
   pTableMeta->uid = pTableMetaMsg->uid;
   pTableMeta->vgroupInfo = pTableMetaMsg->vgroup;
+  pTableMeta->sversion = pTableMetaMsg->sversion;
+  pTableMeta->tversion = pTableMetaMsg->tversion;
   
   memcpy(pTableMeta->schema, pTableMetaMsg->schema, schemaSize);
   

src/client/src/tscServer.c

@@ -222,9 +222,7 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcIpSet *pIpSet) {
   if (pObj->signature != pObj) {
     tscTrace("%p sql is already released or DB connection is closed, freed:%d pObj:%p signature:%p", pSql, pSql->freed,
              pObj, pObj->signature);
-    if (pSql != pObj->pSql) {
-      tscFreeSqlObj(pSql);
-    }
+    tscFreeSqlObj(pSql);
     rpcFreeCont(rpcMsg->pCont);
     return;
   }
@@ -259,6 +257,9 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcIpSet *pIpSet) {
         rpcMsg->code = TSDB_CODE_NOT_READY;
         rpcFreeCont(rpcMsg->pCont);
         return;
+      } else if (pCmd->command == TSDB_SQL_META) {
+//        rpcFreeCont(rpcMsg->pCont);
+//        return;
       } else {
         tscWarn("%p it shall renew table meta, code:%s, retry:%d", pSql, tstrerror(rpcMsg->code), ++pSql->retry);
         
@@ -333,21 +334,11 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcIpSet *pIpSet) {
     rpcMsg->code = (*tscProcessMsgRsp[pCmd->command])(pSql);
   
   if (rpcMsg->code != TSDB_CODE_ACTION_IN_PROGRESS) {
-    void *taosres = tscKeepConn[pCmd->command] ? pSql : NULL;
     rpcMsg->code = pRes->code ? pRes->code : pRes->numOfRows;
     
     tscTrace("%p SQL result:%s res:%p", pSql, tstrerror(pRes->code), pSql);
-
-    /*
-     * Whether to free sqlObj or not should be decided before call the user defined function, since this SqlObj
-     * may be freed in UDF, and reused by other threads before tscShouldBeFreed called, in which case
-     * tscShouldBeFreed checks an object which is actually allocated by other threads.
-     *
-     * If this block of memory is re-allocated for an insert thread, in which tscKeepConn[command] equals to 0,
-     * the tscShouldBeFreed will success and tscFreeSqlObj free it immediately.
-     */
     bool shouldFree = tscShouldBeFreed(pSql);
-    (*pSql->fp)(pSql->param, taosres, rpcMsg->code);
+    (*pSql->fp)(pSql->param, pSql, rpcMsg->code);
 
     if (shouldFree) {
       tscTrace("%p sqlObj is automatically freed", pSql);
@@ -1255,28 +1246,24 @@ int tscEstimateAlterTableMsgLength(SSqlCmd *pCmd) {
 }
 
 int tscBuildAlterTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
-  SCMAlterTableMsg *pAlterTableMsg;
-  char *          pMsg;
-  int             msgLen = 0;
-  int             size = 0;
+  char *pMsg;
+  int   msgLen = 0;
 
-  SSqlCmd *   pCmd = &pSql->cmd;
+  SSqlCmd    *pCmd = &pSql->cmd;
   SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(pCmd, 0);
 
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
-
-  size = tscEstimateAlterTableMsgLength(pCmd);
+  
+  SAlterTableSQL *pAlterInfo = pInfo->pAlterInfo;
+  int size = tscEstimateAlterTableMsgLength(pCmd);
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, size)) {
     tscError("%p failed to malloc for alter table msg", pSql);
     return -1;
   }
-
-  pAlterTableMsg = (SCMAlterTableMsg *)pCmd->payload;
-
+  
+  SCMAlterTableMsg *pAlterTableMsg = (SCMAlterTableMsg *)pCmd->payload;
   tscGetDBInfoFromMeterId(pTableMetaInfo->name, pAlterTableMsg->db);
 
-  SAlterTableSQL *pAlterInfo = pInfo->pAlterInfo;
-
   strcpy(pAlterTableMsg->tableId, pTableMetaInfo->name);
   pAlterTableMsg->type = htons(pAlterInfo->type);
 
@@ -1284,7 +1271,7 @@ int tscBuildAlterTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSchema *pSchema = pAlterTableMsg->schema;
   for (int i = 0; i < tscNumOfFields(pQueryInfo); ++i) {
     TAOS_FIELD *pField = tscFieldInfoGetField(&pQueryInfo->fieldsInfo, i);
-
+  
     pSchema->type = pField->type;
     strcpy(pSchema->name, pField->name);
     pSchema->bytes = htons(pField->bytes);
@@ -1297,6 +1284,7 @@ int tscBuildAlterTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   pMsg += pAlterInfo->tagData.dataLen;
 
   msgLen = pMsg - (char*)pAlterTableMsg;
+
   pCmd->payloadLen = msgLen;
   pCmd->msgType = TSDB_MSG_TYPE_CM_ALTER_TABLE;
 
@@ -1305,6 +1293,16 @@ int tscBuildAlterTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   return TSDB_CODE_SUCCESS;
 }
 
+int tscBuildUpdateTagMsg(SSqlObj* pSql, SSqlInfo *pInfo) {
+  SSqlCmd* pCmd = &pSql->cmd;
+  pCmd->msgType = TSDB_MSG_TYPE_UPDATE_TAG_VAL;
+  
+  SUpdateTableTagValMsg* pUpdateMsg = (SUpdateTableTagValMsg*) (pCmd->payload + tsRpcHeadSize);
+  pCmd->payloadLen = htonl(pUpdateMsg->head.contLen);
+  
+  return TSDB_CODE_SUCCESS;
+}
+
 int tscAlterDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
   pCmd->payloadLen = sizeof(SCMAlterDbMsg);
@@ -1785,7 +1783,7 @@ int tscProcessTableMetaRsp(SSqlObj *pSql) {
 
   pMetaMsg->sid = htonl(pMetaMsg->sid);
   pMetaMsg->sversion = htons(pMetaMsg->sversion);
-  
+  pMetaMsg->tversion = htons(pMetaMsg->tversion);
   pMetaMsg->vgroup.vgId = htonl(pMetaMsg->vgroup.vgId);
   
   pMetaMsg->uid = htobe64(pMetaMsg->uid);
@@ -2534,6 +2532,7 @@ void tscInitMsgsFp() {
   tscBuildMsg[TSDB_SQL_DROP_DNODE] = tscBuildDropDnodeMsg;
   tscBuildMsg[TSDB_SQL_CFG_DNODE] = tscBuildCfgDnodeMsg;
   tscBuildMsg[TSDB_SQL_ALTER_TABLE] = tscBuildAlterTableMsg;
+  tscBuildMsg[TSDB_SQL_UPDATE_TAGS_VAL] = tscBuildUpdateTagMsg;
   tscBuildMsg[TSDB_SQL_ALTER_DB] = tscAlterDbMsg;
 
   tscBuildMsg[TSDB_SQL_CONNECT] = tscBuildConnectMsg;

src/client/src/tscSql.c

@@ -52,7 +52,7 @@ static bool validPassword(const char* passwd) {
   return validImpl(passwd, TSDB_PASSWORD_LEN);
 }
 
-STscObj *taosConnectImpl(const char *ip, const char *user, const char *pass, const char *db, uint16_t port,
+SSqlObj *taosConnectImpl(const char *ip, const char *user, const char *pass, const char *db, uint16_t port,
                        void (*fp)(void *, TAOS_RES *, int), void *param, void **taos) {
   taos_init();
   
@@ -120,10 +120,8 @@ STscObj *taosConnectImpl(const char *ip, const char *user, const char *pass, con
   pSql->pTscObj = pObj;
   pSql->signature = pSql;
   pSql->maxRetry = TSDB_MAX_REPLICA_NUM;
-  
   tsem_init(&pSql->rspSem, 0, 0);
   
-  pObj->pSql = pSql;
   pObj->pDnodeConn = pDnodeConn;
   
   pSql->fp = fp;
@@ -143,42 +141,38 @@ STscObj *taosConnectImpl(const char *ip, const char *user, const char *pass, con
 
   // tsRpcHeaderSize will be updated during RPC initialization, so only after it initialization, this value is valid
   tsInsertHeadSize = tsRpcHeadSize + sizeof(SMsgDesc) + sizeof(SSubmitMsg);
-  return pObj;
+  return pSql;
 }
 
 static void syncConnCallback(void *param, TAOS_RES *tres, int code) {
-  STscObj *pObj = (STscObj *)param;
-  assert(pObj != NULL && pObj->pSql != NULL);
-  
-  if (code < 0) {
-    pObj->pSql->res.code = code;
-  }
+  SSqlObj *pSql = (SSqlObj *) tres;
+  assert(pSql != NULL);
   
-  sem_post(&pObj->pSql->rspSem);
+  sem_post(&pSql->rspSem);
 }
 
 TAOS *taos_connect(const char *ip, const char *user, const char *pass, const char *db, uint16_t port) {
   tscTrace("try to create a connection to %s:%u, user:%s db:%s", ip, port, user, db);
 
-  STscObj *pObj = taosConnectImpl(ip, user, pass, db, port, NULL, NULL, NULL);
-  if (pObj != NULL) {
-    SSqlObj* pSql = pObj->pSql;
-    assert(pSql != NULL);
-    
+  STscObj* pObj = NULL;
+  SSqlObj *pSql = taosConnectImpl(ip, user, pass, db, port, syncConnCallback, NULL, (void**) &pObj);
+  if (pSql != NULL) {
     pSql->fp = syncConnCallback;
-    pSql->param = pObj;
+    pSql->param = pSql;
     
     tscProcessSql(pSql);
     sem_wait(&pSql->rspSem);
     
     if (pSql->res.code != TSDB_CODE_SUCCESS) {
       terrno = pSql->res.code;
+      taos_free_result(pSql);
       taos_close(pObj);
       return NULL;
     }
     
     tscTrace("%p DB connection is opening, dnodeConn:%p", pObj, pObj->pDnodeConn);
-    
+    taos_free_result(pSql);
+  
     // version compare only requires the first 3 segments of the version string
     int code = taosCheckVersion(version, taos_get_server_info(pObj), 3);
     if (code != 0) {
@@ -195,17 +189,14 @@ TAOS *taos_connect(const char *ip, const char *user, const char *pass, const cha
 
 TAOS *taos_connect_a(char *ip, char *user, char *pass, char *db, uint16_t port, void (*fp)(void *, TAOS_RES *, int),
                      void *param, void **taos) {
-  STscObj* pObj = taosConnectImpl(ip, user, pass, db, port, fp, param, taos);
-  if (pObj == NULL) {
+  SSqlObj* pSql = taosConnectImpl(ip, user, pass, db, port, fp, param, taos);
+  if (pSql == NULL) {
     return NULL;
   }
   
-  SSqlObj* pSql = pObj->pSql;
-  
   pSql->res.code = tscProcessSql(pSql);
-  tscTrace("%p DB async connection is opening", pObj);
-  
-  return pObj;
+  tscTrace("%p DB async connection is opening", taos);
+  return taos;
 }
 
 void taos_close(TAOS *taos) {
@@ -265,41 +256,40 @@ int taos_query_imp(STscObj *pObj, SSqlObj *pSql) {
 }
 
 void waitForQueryRsp(void *param, TAOS_RES *tres, int code) {
-  assert(param != NULL);
-  SSqlObj *pSql = ((STscObj *)param)->pSql;
-  
-  // valid error code is less than 0
-  if (code < 0) {
-    pSql->res.code = code;
-  }
+  assert(tres != NULL);
   
+  SSqlObj *pSql = (SSqlObj *) tres;
   sem_post(&pSql->rspSem);
 }
 
-int taos_query(TAOS *taos, const char *sqlstr) {
+TAOS_RES* taos_query(TAOS *taos, const char *sqlstr) {
   STscObj *pObj = (STscObj *)taos;
   if (pObj == NULL || pObj->signature != pObj) {
     terrno = TSDB_CODE_DISCONNECTED;
-    return TSDB_CODE_DISCONNECTED;
+    return NULL;
+  }
+  
+  int32_t sqlLen = strlen(sqlstr);
+  if (sqlLen > tsMaxSQLStringLen) {
+    tscError("sql string exceeds max length:%d", tsMaxSQLStringLen);
+    terrno = TSDB_CODE_INVALID_SQL;
+    return NULL;
+  }
+  
+  taosNotePrintTsc(sqlstr);
+  
+  SSqlObj* pSql = calloc(1, sizeof(SSqlObj));
+  if (pSql == NULL) {
+    tscError("failed to malloc sqlObj");
+    terrno = TSDB_CODE_CLI_OUT_OF_MEMORY;
+    return NULL;
   }
   
-  SSqlObj* pSql = pObj->pSql;
-  size_t   sqlLen = strlen(sqlstr);
   doAsyncQuery(pObj, pSql, waitForQueryRsp, taos, sqlstr, sqlLen);
 
   // wait for the callback function to post the semaphore
   tsem_wait(&pSql->rspSem);
-  return pSql->res.code;
-}
-
-TAOS_RES *taos_use_result(TAOS *taos) {
-  STscObj *pObj = (STscObj *)taos;
-  if (pObj == NULL || pObj->signature != pObj) {
-    terrno = TSDB_CODE_DISCONNECTED;
-    return NULL;
-  }
-
-  return pObj->pSql;
+  return pSql;
 }
 
 int taos_result_precision(TAOS_RES *res) {
@@ -332,18 +322,18 @@ int taos_num_fields(TAOS_RES *res) {
   return num;
 }
 
-int taos_field_count(TAOS *taos) {
-  STscObj *pObj = (STscObj *)taos;
-  if (pObj == NULL || pObj->signature != pObj) return 0;
+int taos_field_count(TAOS_RES *tres) {
+  SSqlObj* pSql = (SSqlObj*) tres;
+  if (pSql == NULL || pSql->signature != pSql) return 0;
 
-  return taos_num_fields(pObj->pSql);
+  return taos_num_fields(pSql);
 }
 
-int taos_affected_rows(TAOS *taos) {
-  STscObj *pObj = (STscObj *)taos;
-  if (pObj == NULL || pObj->signature != pObj) return 0;
+int taos_affected_rows(TAOS_RES *tres) {
+  SSqlObj* pSql = (SSqlObj*) tres;
+  if (pSql == NULL || pSql->signature != pSql) return 0;
 
-  return (pObj->pSql->res.numOfRows);
+  return (pSql->res.numOfRows);
 }
 
 TAOS_FIELD *taos_fetch_fields(TAOS_RES *res) {
@@ -385,9 +375,8 @@ int taos_fetch_block_impl(TAOS_RES *res, TAOS_ROW *rows) {
   SSqlObj *pSql = (SSqlObj *)res;
   SSqlCmd *pCmd = &pSql->cmd;
   SSqlRes *pRes = &pSql->res;
-  STscObj *pObj = pSql->pTscObj;
 
-  if (pRes->qhandle == 0 || pObj->pSql != pSql) {
+  if (pRes->qhandle == 0 || pSql->signature != pSql) {
     *rows = NULL;
     return 0;
   }
@@ -521,95 +510,76 @@ int taos_select_db(TAOS *taos, const char *db) {
   }
 
   snprintf(sql, tListLen(sql), "use %s", db);
-  return taos_query(taos, sql);
+  SSqlObj* pSql = taos_query(taos, sql);
+  int32_t code = pSql->res.code;
+  taos_free_result(pSql);
+  
+  return code;
 }
 
 void taos_free_result(TAOS_RES *res) {
-  if (res == NULL) return;
-
   SSqlObj *pSql = (SSqlObj *)res;
+  tscTrace("%p start to free result", res);
+  
+  if (pSql == NULL || pSql->signature != pSql) {
+    tscTrace("%p result has been freed", pSql);
+    return;
+  }
+  
   SSqlRes *pRes = &pSql->res;
   SSqlCmd *pCmd = &pSql->cmd;
 
-  tscTrace("%p start to free result", pSql);
-
-  if (pSql->signature != pSql) return;
-
-  STscObj* pObj = pSql->pTscObj;
+  // The semaphore can not be changed while freeing async sub query objects.
   if (pRes == NULL || pRes->qhandle == 0) {
-    /* Query rsp is not received from vnode, so the qhandle is NULL */
-    tscTrace("%p qhandle is null, abort free, fp:%p", pSql, pSql->fp);
-    
-    // The semaphore can not be changed while freeing async sub query objects.
-    if (pObj->pSql != pSql) {
-      tscTrace("%p SqlObj is freed by app", pSql);
-      tscFreeSqlObj(pSql);
-    } else {
-      tscPartiallyFreeSqlObj(pSql);
-    }
-  
+    tscTrace("%p SqlObj is freed by app, qhandle is null", pSql);
+    tscFreeSqlObj(pSql);
     return;
   }
 
   // set freeFlag to 1 in retrieve message if there are un-retrieved results data in node
   SQueryInfo *pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
   if (pQueryInfo == NULL) {
-    tscPartiallyFreeSqlObj(pSql);
+    tscFreeSqlObj(pSql);
     return;
   }
 
   pQueryInfo->type = TSDB_QUERY_TYPE_FREE_RESOURCE;
-  STscObj* pTscObj = pSql->pTscObj;
-
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
   /*
-   * case 1. Partial data have been retrieved from vnodes, but not all data has been retrieved yet.
-   *         We need to recycle the connection by noticing the vnode return 0 results.
-   * case 2. When the query response is received from vnodes and the numOfRows is set to 0, the user calls
-   *         taos_free_result before the taos_fetch_row is called in non-stream computing,
-   *         we need to recycle the connection.
-   * case 3. If the query process is cancelled by user in stable query, tscProcessSql should not be called
-   *         for each subquery. Because the failure of execution tsProcessSql may trigger the callback function
-   *         be executed, and the retry efforts may result in double free the resources, e.g.,SRetrieveSupport
+   * If the query process is cancelled by user in stable query, tscProcessSql should not be called
+   * for each subquery. Because the failure of execution tsProcessSql may trigger the callback function
+   * be executed, and the retry efforts may result in double free the resources, e.g.,SRetrieveSupport
    */
-  if ((pCmd->command == TSDB_SQL_SELECT ||
-       pCmd->command == TSDB_SQL_SHOW ||
-       pCmd->command == TSDB_SQL_RETRIEVE ||
-       pCmd->command == TSDB_SQL_FETCH) && pRes->code == TSDB_CODE_SUCCESS && pRes->completed == false &&
+  if (pRes->code == TSDB_CODE_SUCCESS && pRes->completed == false &&
+      (pCmd->command == TSDB_SQL_SELECT || pCmd->command == TSDB_SQL_SHOW ||
+       pCmd->command == TSDB_SQL_RETRIEVE || pCmd->command == TSDB_SQL_FETCH) &&
        (pCmd->command == TSDB_SQL_SELECT && pSql->pStream == NULL && pTableMetaInfo->pTableMeta != NULL)) {
     pCmd->command = (pCmd->command > TSDB_SQL_MGMT) ? TSDB_SQL_RETRIEVE : TSDB_SQL_FETCH;
 
-    tscTrace("%p send msg to free qhandle in vnode, code:%d, numOfRows:%d, command:%s", pSql, pRes->code, pRes->numOfRows,
-        sqlCmd[pCmd->command]);
-
+    tscTrace("%p start to send msg to free qhandle in dnode, command:%s", pSql, sqlCmd[pCmd->command]);
     pSql->freed = 1;
     tscProcessSql(pSql);
-  
-    // waits for response and then goes on
-    if (pTscObj->pSql == pSql) {
+
+    // in case of sync model query, waits for response and then goes on
+    if (pSql->fp == waitForQueryRsp || pSql->fp == waitForRetrieveRsp) {
       sem_wait(&pSql->rspSem);
     }
-  } else { // if no free resource msg is sent to vnode, we free this object immediately.
-    if (pTscObj->pSql != pSql) {
-      tscFreeSqlObj(pSql);
-      tscTrace("%p sql result is freed by app", pSql);
-    } else {
-      tscPartiallyFreeSqlObj(pSql);
-      tscTrace("%p sql result is freed by app", pSql);
-    }
   }
+
+  tscFreeSqlObj(pSql);
+  tscTrace("%p sql result is freed by app", pSql);
 }
 
 // todo should not be used in async query
-int taos_errno(TAOS *taos) {
-  STscObj *pObj = (STscObj *)taos;
+int taos_errno(TAOS_RES *tres) {
+  SSqlObj *pSql = (SSqlObj *) tres;
 
-  if (pObj == NULL || pObj->signature != pObj) {
+  if (pSql == NULL || pSql->signature != pSql) {
     return terrno;
   }
 
-  return pObj->pSql->res.code;
+  return pSql->res.code;
 }
 
 /*
@@ -632,14 +602,13 @@ static bool hasAdditionalErrorInfo(int32_t code, SSqlCmd *pCmd) {
 }
 
 // todo should not be used in async model
-char *taos_errstr(TAOS *taos) {
-  STscObj *pObj = (STscObj *)taos;
+char *taos_errstr(TAOS_RES *tres) {
+  SSqlObj *pSql = (SSqlObj *) tres;
 
-  if (pObj == NULL || pObj->signature != pObj)
-    return (char*)tstrerror(terrno);
+  if (pSql == NULL || pSql->signature != pSql) {
+    return (char*) tstrerror(terrno);
+  }
 
-  SSqlObj* pSql = pObj->pSql;
-  
   if (hasAdditionalErrorInfo(pSql->res.code, &pSql->cmd)) {
     return pSql->cmd.payload;
   } else {
@@ -769,7 +738,8 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
     return TSDB_CODE_DISCONNECTED;
   }
 
-  SSqlObj *pSql = pObj->pSql;
+  SSqlObj* pSql = calloc(1, sizeof(SSqlObj));
+  
   SSqlRes *pRes = &pSql->res;
   SSqlCmd *pCmd = &pSql->cmd;
   
@@ -847,9 +817,7 @@ static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t t
     tblName[len] = '\0';
 
     str = nextStr + 1;
-
-    strtrim(tblName);
-    len = (uint32_t)strlen(tblName);
+    len = strtrim(tblName);
 
     SSQLToken sToken = {.n = len, .type = TK_ID, .z = tblName};
     tSQLGetToken(tblName, &sToken.type);
@@ -861,7 +829,7 @@ static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t t
       return code;
     }
 
-    if ((code = tscSetTableId(pTableMetaInfo, &sToken, pSql)) != TSDB_CODE_SUCCESS) {
+    if ((code = tscSetTableFullName(pTableMetaInfo, &sToken, pSql)) != TSDB_CODE_SUCCESS) {
       return code;
     }
 
@@ -902,7 +870,7 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
     return TSDB_CODE_DISCONNECTED;
   }
 
-  SSqlObj *pSql = pObj->pSql;
+  SSqlObj* pSql = calloc(1, sizeof(SSqlObj));
   SSqlRes *pRes = &pSql->res;
 
   pRes->numOfTotal = 0;  // the number of getting table meta from server

src/client/src/tscStream.c

@@ -459,14 +459,14 @@ static int64_t tscGetLaunchTimestamp(const SSqlStream *pStream) {
   return (pStream->precision == TSDB_TIME_PRECISION_MICRO) ? timer / 1000L : timer;
 }
 
-static void setErrorInfo(STscObj* pObj, int32_t code, char* info) {
-  if (pObj == NULL) {
+static void setErrorInfo(SSqlObj* pSql, int32_t code, char* info) {
+  if (pSql == NULL) {
     return;
   }
 
-  SSqlCmd* pCmd = &pObj->pSql->cmd;
+  SSqlCmd* pCmd = &pSql->cmd;
 
-  pObj->pSql->res.code = code;
+  pSql->res.code = code;
   
   if (info != NULL) {
     strncpy(pCmd->payload, info, pCmd->payloadLen);
@@ -480,7 +480,7 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p
 
   SSqlObj *pSql = (SSqlObj *)calloc(1, sizeof(SSqlObj));
   if (pSql == NULL) {
-    setErrorInfo(pObj, TSDB_CODE_CLI_OUT_OF_MEMORY, NULL);
+    setErrorInfo(pSql, TSDB_CODE_CLI_OUT_OF_MEMORY, NULL);
     return NULL;
   }
 
@@ -490,14 +490,14 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p
   SSqlRes *pRes = &pSql->res;
   int ret = tscAllocPayload(pCmd, TSDB_DEFAULT_PAYLOAD_SIZE);
   if (TSDB_CODE_SUCCESS != ret) {
-    setErrorInfo(pObj, ret, NULL);
+    setErrorInfo(pSql, ret, NULL);
     free(pSql);
     return NULL;
   }
 
   pSql->sqlstr = strdup(sqlstr);
   if (pSql->sqlstr == NULL) {
-    setErrorInfo(pObj, TSDB_CODE_CLI_OUT_OF_MEMORY, NULL);
+    setErrorInfo(pSql, TSDB_CODE_CLI_OUT_OF_MEMORY, NULL);
 
     tfree(pSql);
     return NULL;
@@ -511,7 +511,7 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p
   tscResetSqlCmdObj(&pSql->cmd);
   ret = tscAllocPayload(&pSql->cmd, TSDB_DEFAULT_PAYLOAD_SIZE);
   if (TSDB_CODE_SUCCESS != ret) {
-    setErrorInfo(pObj, ret, NULL);
+    setErrorInfo(pSql, ret, NULL);
     tscError("%p open stream failed, sql:%s, code:%d", pSql, sqlstr, TSDB_CODE_CLI_OUT_OF_MEMORY);
     tscFreeSqlObj(pSql);
     return NULL;
@@ -521,7 +521,7 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p
   SQLInfoDestroy(&SQLInfo);
 
   if (pRes->code != TSDB_CODE_SUCCESS) {
-    setErrorInfo(pObj, pRes->code, pCmd->payload);
+    setErrorInfo(pSql, pRes->code, pCmd->payload);
 
     tscError("%p open stream failed, sql:%s, reason:%s, code:%d", pSql, sqlstr, pCmd->payload, pRes->code);
     tscFreeSqlObj(pSql);
@@ -530,7 +530,7 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p
 
   SSqlStream *pStream = (SSqlStream *)calloc(1, sizeof(SSqlStream));
   if (pStream == NULL) {
-    setErrorInfo(pObj, TSDB_CODE_CLI_OUT_OF_MEMORY, NULL);
+    setErrorInfo(pSql, TSDB_CODE_CLI_OUT_OF_MEMORY, NULL);
 
     tscError("%p open stream failed, sql:%s, reason:%s, code:%d", pSql, sqlstr, pCmd->payload, pRes->code);
     tscFreeSqlObj(pSql);

src/client/src/tscSub.c

@@ -181,21 +181,23 @@ static SArray* getTableList( SSqlObj* pSql ) {
   const char* p = strstr( pSql->sqlstr, " from " );
   char* sql = alloca(strlen(p) + 32);
   sprintf(sql, "select tbid(tbname)%s", p);
-  int code = taos_query( pSql->pTscObj, sql );
-  if (code != TSDB_CODE_SUCCESS) {
-    tscError("failed to retrieve table id: %s", tstrerror(code));
+  
+  SSqlObj* pSql1 = taos_query(pSql->pTscObj, sql);
+  if (terrno != TSDB_CODE_SUCCESS) {
+    tscError("failed to retrieve table id: %s", tstrerror(terrno));
     return NULL;
   }
 
-  TAOS_RES* res = taos_use_result( pSql->pTscObj );
   TAOS_ROW row;
   SArray* result = taosArrayInit( 128, sizeof(STidTags) );
-  while ((row = taos_fetch_row(res))) {
+  while ((row = taos_fetch_row(pSql1))) {
     STidTags tags;
     memcpy(&tags, row[0], sizeof(tags));
     taosArrayPush(result, &tags);
   }
 
+  taos_free_result(pSql1);
+  
   return result;
 }
 

src/client/src/tscSubquery.c

@@ -1715,6 +1715,7 @@ static void multiVnodeInsertMerge(void* param, TAOS_RES* tres, int numOfRows) {
     pParentObj->res.numOfRows += numOfRows;
   }
   
+  taos_free_result(tres);
   int32_t completed = atomic_add_fetch_32(&pState->numOfCompleted, 1);
   if (completed < total) {
     return;
@@ -1732,7 +1733,7 @@ static void multiVnodeInsertMerge(void* param, TAOS_RES* tres, int numOfRows) {
   pParentObj->fp = pParentObj->fetchFp;
   
   // all data has been sent to vnode, call user function
-  (*pParentObj->fp)(pParentObj->param, tres, numOfRows);
+  (*pParentObj->fp)(pParentObj->param, pParentObj, numOfRows);
 }
 
 int32_t tscHandleMultivnodeInsert(SSqlObj *pSql) {

src/client/src/tscUtil.c

@@ -409,8 +409,10 @@ void tscPartiallyFreeSqlObj(SSqlObj* pSql) {
 }
 
 void tscFreeSqlObj(SSqlObj* pSql) {
-  if (pSql == NULL || pSql->signature != pSql) return;
-
+  if (pSql == NULL || pSql->signature != pSql) {
+    return;
+  }
+  
   tscTrace("%p start to free sql object", pSql);
   tscPartiallyFreeSqlObj(pSql);
 
@@ -424,6 +426,7 @@ void tscFreeSqlObj(SSqlObj* pSql) {
   pCmd->allocSize = 0;
   
   tfree(pSql->sqlstr);
+  sem_destroy(&pSql->rspSem);
   free(pSql);
 }
 
@@ -651,6 +654,7 @@ static int trimDataBlock(void* pDataBlock, STableDataBlocks* pTableDataBlock) {
   for (int32_t i = 0; i < numOfRows; ++i) {
     SDataRow trow = (SDataRow)pDataBlock;
     dataRowSetLen(trow, TD_DATA_ROW_HEAD_SIZE + flen);
+    dataRowSetVersion(trow, pTableMeta->sversion);
 
     int toffset = 0;
     for (int32_t j = 0; j < tinfo.numOfColumns; j++) {
@@ -749,16 +753,7 @@ void tscCloseTscObj(STscObj* pObj) {
   assert(pObj != NULL);
   
   pObj->signature = NULL;
-  SSqlObj* pSql = pObj->pSql;
-  
-  if (pSql) {
-    terrno = pSql->res.code;
-    sem_destroy(&pSql->rspSem);
-  }
-  
   taosTmrStopA(&(pObj->pTimer));
-  tscFreeSqlObj(pSql);
-
   pthread_mutex_destroy(&pObj->mutex);
   
   if (pObj->pDnodeConn != NULL) {
@@ -1237,9 +1232,8 @@ void tscColumnListDestroy(SArray* pColumnList) {
  *
  */
 static int32_t validateQuoteToken(SSQLToken* pToken) {
-  pToken->n = strdequote(pToken->z);
-  strtrim(pToken->z);
-  pToken->n = (uint32_t)strlen(pToken->z);
+  strdequote(pToken->z);
+  pToken->n = strtrim(pToken->z);
 
   int32_t k = tSQLGetToken(pToken->z, &pToken->type);
 
@@ -1261,9 +1255,8 @@ int32_t tscValidateName(SSQLToken* pToken) {
   char* sep = strnchr(pToken->z, TS_PATH_DELIMITER[0], pToken->n, true);
   if (sep == NULL) {  // single part
     if (pToken->type == TK_STRING) {
-      pToken->n = strdequote(pToken->z);
-      strtrim(pToken->z);
-      pToken->n = (uint32_t)strlen(pToken->z);
+      strdequote(pToken->z);
+      pToken->n = strtrim(pToken->z);
 
       int len = tSQLGetToken(pToken->z, &pToken->type);
 
@@ -1288,8 +1281,7 @@ int32_t tscValidateName(SSQLToken* pToken) {
     char*   pStr = pToken->z;
 
     if (pToken->type == TK_SPACE) {
-      strtrim(pToken->z);
-      pToken->n = (uint32_t)strlen(pToken->z);
+      pToken->n = strtrim(pToken->z);
     }
 
     pToken->n = tSQLGetToken(pToken->z, &pToken->type);
@@ -1470,22 +1462,24 @@ bool tscShouldFreeHeatBeat(SSqlObj* pHb) {
  * If connection need to be recycled, the SqlObj also should be freed.
  */
 bool tscShouldBeFreed(SSqlObj* pSql) {
-  if (pSql == NULL || pSql->signature != pSql || pSql->fp == NULL) {
+  if (pSql == NULL || pSql->signature != pSql) {
     return false;
   }
-
+  
+  assert(pSql->fp != NULL);
+  
   STscObj* pTscObj = pSql->pTscObj;
-  if (pSql->pStream != NULL || pTscObj->pHb == pSql || pTscObj->pSql == pSql || pSql->pSubscription != NULL) {
+  if (pSql->pStream != NULL || pTscObj->pHb == pSql || pSql->pSubscription != NULL) {
     return false;
   }
 
+  // only the table meta and super table vgroup query will free resource automatically
   int32_t command = pSql->cmd.command;
-  if (command == TSDB_SQL_CONNECT || command == TSDB_SQL_INSERT) {
+  if (command == TSDB_SQL_META || command == TSDB_SQL_STABLEVGROUP) {
     return true;
-  } else {
-    return tscKeepConn[command] == 0 ||
-           (pSql->res.code != TSDB_CODE_ACTION_IN_PROGRESS && pSql->res.code != TSDB_CODE_SUCCESS);
   }
+
+  return false;
 }
 
 /**
@@ -1948,15 +1942,14 @@ int16_t tscGetJoinTagColIndexByUid(STagCond* pTagCond, uint64_t uid) {
   }
 }
 
-bool tscIsUpdateQuery(STscObj* pObj) {
-  if (pObj == NULL || pObj->signature != pObj) {
+bool tscIsUpdateQuery(SSqlObj* pSql) {
+  if (pSql == NULL || pSql->signature != pSql) {
     terrno = TSDB_CODE_DISCONNECTED;
     return TSDB_CODE_DISCONNECTED;
   }
 
-  SSqlCmd* pCmd = &pObj->pSql->cmd;
-  return ((pCmd->command >= TSDB_SQL_INSERT && pCmd->command <= TSDB_SQL_DROP_DNODE) ||
-          TSDB_SQL_USE_DB == pCmd->command);
+  SSqlCmd* pCmd = &pSql->cmd;
+  return ((pCmd->command >= TSDB_SQL_INSERT && pCmd->command <= TSDB_SQL_DROP_DNODE) || TSDB_SQL_USE_DB == pCmd->command);
 }
 
 int32_t tscInvalidSQLErrMsg(char* msg, const char* additionalInfo, const char* sql) {

src/common/inc/qsqltype.h

@@ -35,7 +35,8 @@ enum {
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_SELECT, "select" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_FETCH, "fetch" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_INSERT, "insert" )
-
+  TSDB_DEFINE_SQL_TYPE( TSDB_SQL_UPDATE_TAGS_VAL, "update-tag-val" )
+  
   // the SQL below is for mgmt node
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_MGMT, "mgmt" )
   TSDB_DEFINE_SQL_TYPE( TSDB_SQL_CREATE_DB, "create-db" )

src/common/inc/tdataformat.h

@@ -119,22 +119,24 @@ STSchema *tdGetSchemaFromBuilder(STSchemaBuilder *pBuilder);
 // ----------------- Data row structure
 
 /* A data row, the format is like below:
- * |<------------------------------------- len ---------------------------------->|
- * |<--Head ->|<---------   flen -------------->|                                 |
- * +----------+---------------------------------+---------------------------------+
- * | int32_t  |                                 |                                 |
- * +----------+---------------------------------+---------------------------------+
- * |   len    |           First part            |             Second part         |
- * +----------+---------------------------------+---------------------------------+
+ * |<--------------------+--------------------------- len ---------------------------------->|
+ * |<--     Head      -->|<---------   flen -------------->|                                 |
+ * +---------------------+---------------------------------+---------------------------------+
+ * | int16_t  |  int16_t |                                 |                                 |
+ * +----------+----------+---------------------------------+---------------------------------+
+ * |   len    | sversion |           First part            |             Second part         |
+ * +----------+----------+---------------------------------+---------------------------------+
  */
 typedef void *SDataRow;
 
-#define TD_DATA_ROW_HEAD_SIZE sizeof(int32_t)
+#define TD_DATA_ROW_HEAD_SIZE sizeof(int16_t)*2
 
-#define dataRowLen(r) (*(int32_t *)(r))
+#define dataRowLen(r) (*(int16_t *)(r))
+#define dataRowVersion(r) *(int16_t *)POINTER_SHIFT(r, sizeof(int16_t))
 #define dataRowTuple(r) POINTER_SHIFT(r, TD_DATA_ROW_HEAD_SIZE)
 #define dataRowKey(r) (*(TSKEY *)(dataRowTuple(r)))
 #define dataRowSetLen(r, l) (dataRowLen(r) = (l))
+#define dataRowSetVersion(r, v) (dataRowVersion(r) = (v))
 #define dataRowCpy(dst, r) memcpy((dst), (r), dataRowLen(r))
 #define dataRowMaxBytesFromSchema(s) (schemaTLen(s) + TD_DATA_ROW_HEAD_SIZE)
 
@@ -246,7 +248,7 @@ void       tdResetDataCols(SDataCols *pCols);
 void       tdInitDataCols(SDataCols *pCols, STSchema *pSchema);
 SDataCols *tdDupDataCols(SDataCols *pCols, bool keepData);
 void       tdFreeDataCols(SDataCols *pCols);
-void       tdAppendDataRowToDataCol(SDataRow row, SDataCols *pCols);
+void       tdAppendDataRowToDataCol(SDataRow row, STSchema *pSchema, SDataCols *pCols);
 void       tdPopDataColsPoints(SDataCols *pCols, int pointsToPop);  //!!!!
 int        tdMergeDataCols(SDataCols *target, SDataCols *src, int rowsToMerge);
 void       tdMergeTwoDataCols(SDataCols *target, SDataCols *src1, int *iter1, SDataCols *src2, int *iter2, int tRows);
@@ -278,9 +280,10 @@ typedef struct {
 #define kvRowColVal(r, colIdx) POINTER_SHIFT(kvRowValues(r), (colIdx)->offset)
 #define kvRowColIdxAt(r, i) (kvRowColIdx(r) + (i))
 #define kvRowFree(r) tfree(r)
+#define kvRowEnd(r) POINTER_SHIFT(r, kvRowLen(r))
 
 SKVRow tdKVRowDup(SKVRow row);
-SKVRow tdSetKVRowDataOfCol(SKVRow row, int16_t colId, int8_t type, void *value);
+int    tdSetKVRowDataOfCol(SKVRow *orow, int16_t colId, int8_t type, void *value);
 void * tdEncodeKVRow(void *buf, SKVRow row);
 void * tdDecodeKVRow(void *buf, SKVRow *row);
 

src/common/src/tdataformat.c

@@ -159,7 +159,10 @@ STSchema *tdGetSchemaFromBuilder(STSchemaBuilder *pBuilder) {
 /**
  * Initialize a data row
  */
-void tdInitDataRow(SDataRow row, STSchema *pSchema) { dataRowSetLen(row, TD_DATA_ROW_HEAD_SIZE + schemaFLen(pSchema)); }
+void tdInitDataRow(SDataRow row, STSchema *pSchema) {
+  dataRowSetLen(row, TD_DATA_ROW_HEAD_SIZE + schemaFLen(pSchema));
+  dataRowSetVersion(row, schemaVersion(pSchema));
+}
 
 SDataRow tdNewDataRowFromSchema(STSchema *pSchema) {
   int32_t size = dataRowMaxBytesFromSchema(pSchema);
@@ -262,25 +265,29 @@ bool isNEleNull(SDataCol *pCol, int nEle) {
   }
 }
 
+void dataColSetNullAt(SDataCol *pCol, int index) {
+  if (IS_VAR_DATA_TYPE(pCol->type)) {
+    pCol->dataOff[index] = pCol->len;
+    char *ptr = POINTER_SHIFT(pCol->pData, pCol->len);
+    varDataLen(ptr) = (pCol->type == TSDB_DATA_TYPE_BINARY) ? sizeof(char) : TSDB_NCHAR_SIZE;
+    setNull(varDataVal(ptr), pCol->type, pCol->bytes);
+    pCol->len += varDataTLen(ptr);
+  } else {
+    setNull(POINTER_SHIFT(pCol->pData, TYPE_BYTES[pCol->type] * index), pCol->type, pCol->bytes);
+    pCol->len += TYPE_BYTES[pCol->type];
+  }
+}
+
 void dataColSetNEleNull(SDataCol *pCol, int nEle, int maxPoints) {
-  char *ptr = NULL;
-  switch (pCol->type) {
-    case TSDB_DATA_TYPE_BINARY:
-    case TSDB_DATA_TYPE_NCHAR:
-      pCol->len = 0;
-      for (int i = 0; i < nEle; i++) {
-        pCol->dataOff[i] = pCol->len;
-        ptr = (char *)pCol->pData + pCol->len;
-        varDataLen(ptr) = (pCol->type == TSDB_DATA_TYPE_BINARY) ? sizeof(char) : TSDB_NCHAR_SIZE;
-        setNull(ptr + sizeof(VarDataLenT), pCol->type, pCol->bytes);
-        pCol->len += varDataTLen(ptr);
-      }
 
-      break;
-    default:
-      setNullN(pCol->pData, pCol->type, pCol->bytes, nEle);
-      pCol->len = TYPE_BYTES[pCol->type] * nEle;
-      break;
+  if (IS_VAR_DATA_TYPE(pCol->type)) {
+    pCol->len = 0;
+    for (int i = 0; i < nEle; i++) {
+      dataColSetNullAt(pCol, i);
+    }
+  } else {
+    setNullN(pCol->pData, pCol->type, pCol->bytes, nEle);
+    pCol->len = TYPE_BYTES[pCol->type] * nEle;
   }
 }
 
@@ -377,14 +384,32 @@ void tdResetDataCols(SDataCols *pCols) {
   }
 }
 
-void tdAppendDataRowToDataCol(SDataRow row, SDataCols *pCols) {
+void tdAppendDataRowToDataCol(SDataRow row, STSchema *pSchema, SDataCols *pCols) {
   ASSERT(dataColsKeyLast(pCols) < dataRowKey(row));
 
-  for (int i = 0; i < pCols->numOfCols; i++) {
-    SDataCol *pCol = pCols->cols + i;
-    void *    value = tdGetRowDataOfCol(row, pCol->type, pCol->offset);
+  int rcol = 0;
+  int dcol = 0;
 
-    dataColAppendVal(pCol, value, pCols->numOfRows, pCols->maxPoints);
+  while (dcol < pCols->numOfCols) {
+    SDataCol *pDataCol = &(pCols->cols[dcol]);
+    if (rcol >= schemaNCols(pSchema)) {
+      dataColSetNullAt(pDataCol, pCols->numOfRows);
+      dcol++;
+      continue;
+    }
+
+    STColumn *pRowCol = schemaColAt(pSchema, rcol);
+    if (pRowCol->colId == pDataCol->colId) {
+      void *value = tdGetRowDataOfCol(row, pRowCol->type, pRowCol->offset+TD_DATA_ROW_HEAD_SIZE);
+      dataColAppendVal(pDataCol, value, pCols->numOfRows, pCols->maxPoints);
+      dcol++;
+      rcol++;
+    } else if (pRowCol->colId < pDataCol->colId) {
+      rcol++;
+    } else {
+      dataColSetNullAt(pDataCol, pCols->numOfRows);
+      dcol++;
+    }
   }
   pCols->numOfRows++;
 }
@@ -477,69 +502,103 @@ SKVRow tdKVRowDup(SKVRow row) {
   return trow;
 }
 
-SKVRow tdSetKVRowDataOfCol(SKVRow row, int16_t colId, int8_t type, void *value) {
-  // TODO
-  return NULL;
-  // SColIdx *pColIdx = NULL;
-  // SKVRow rrow = row;
-  // SKVRow nrow = NULL;
-  // void *ptr = taosbsearch(&colId, kvDataRowColIdx(row), kvDataRowNCols(row), sizeof(SColIdx), comparTagId, TD_GE);
-
-  // if (ptr == NULL || ((SColIdx *)ptr)->colId < colId) { // need to add a column value to the row
-  //   int tlen = kvDataRowLen(row) + sizeof(SColIdx) + (IS_VAR_DATA_TYPE(type) ? varDataTLen(value) :
-  //   TYPE_BYTES[type]); nrow = malloc(tlen); if (nrow == NULL) return NULL;
-
-  //   kvDataRowSetNCols(nrow, kvDataRowNCols(row)+1);
-  //   kvDataRowSetLen(nrow, tlen);
-
-  //   if (ptr == NULL) ptr = kvDataRowValues(row);
-
-  //   // Copy the columns before the col
-  //   if (POINTER_DISTANCE(ptr, kvDataRowColIdx(row)) > 0) {
-  //     memcpy(kvDataRowColIdx(nrow), kvDataRowColIdx(row), POINTER_DISTANCE(ptr, kvDataRowColIdx(row)));
-  //     memcpy(kvDataRowValues(nrow), kvDataRowValues(row), ((SColIdx *)ptr)->offset); // TODO: here is not correct
-  //   }
-
-  //   // Set the new col value
-  //   pColIdx = (SColIdx *)POINTER_SHIFT(nrow, POINTER_DISTANCE(ptr, row));
-  //   pColIdx->colId = colId;
-  //   pColIdx->offset = ((SColIdx *)ptr)->offset; // TODO: here is not correct
-
-  //   if (IS_VAR_DATA_TYPE(type)) {
-  //     memcpy(POINTER_SHIFT(kvDataRowValues(nrow), pColIdx->offset), value, varDataLen(value));
-  //   } else {
-  //     memcpy(POINTER_SHIFT(kvDataRowValues(nrow), pColIdx->offset), value, TYPE_BYTES[type]);
-  //   }
-
-  //   // Copy the columns after the col
-  //   if (POINTER_DISTANCE(kvDataRowValues(row), ptr) > 0) {
-  //     // TODO: memcpy();
-  //   }
-  // } else {
-  //   // TODO
-  //   ASSERT(((SColIdx *)ptr)->colId == colId);
-  //   if (IS_VAR_DATA_TYPE(type)) {
-  //     void *pOldVal = kvDataRowColVal(row, (SColIdx *)ptr);
-
-  //     if (varDataTLen(value) == varDataTLen(pOldVal)) { // just update the column value in place
-  //       memcpy(pOldVal, value, varDataTLen(value));
-  //     } else { // enlarge the memory
-  //       // rrow = realloc(rrow, kvDataRowLen(rrow) + varDataTLen(value) - varDataTLen(pOldVal));
-  //       // if (rrow == NULL) return NULL;
-  //       // memmove();
-  //       // for () {
-  //       //   ((SColIdx *)ptr)->offset += balabala;
-  //       // }
-
-  //       // kvDataRowSetLen();
-
-  //     }
-  //   } else {
-  //     memcpy(kvDataRowColVal(row, (SColIdx *)ptr), value, TYPE_BYTES[type]);
-  //   }
-  // }
-
-  // return rrow;
+int tdSetKVRowDataOfCol(SKVRow *orow, int16_t colId, int8_t type, void *value) {
+  SColIdx *pColIdx = NULL;
+  SKVRow   row = *orow;
+  SKVRow   nrow = NULL;
+  void *   ptr = taosbsearch(&colId, kvRowColIdx(row), kvRowNCols(row), sizeof(SColIdx), comparTagId, TD_GE);
+
+  if (ptr == NULL || ((SColIdx *)ptr)->colId < colId) { // need to add a column value to the row
+    int diff = IS_VAR_DATA_TYPE(type) ? varDataTLen(value) : TYPE_BYTES[type];
+    nrow = malloc(kvRowLen(row) + sizeof(SColIdx) + diff);
+    if (nrow == NULL) return -1;
+
+    kvRowSetLen(nrow, kvRowLen(row) + sizeof(SColIdx) + diff);
+    kvRowSetNCols(nrow, kvRowNCols(row) + 1);
+
+    if (ptr == NULL) {
+      memcpy(kvRowColIdx(nrow), kvRowColIdx(row), sizeof(SColIdx) * kvRowNCols(row));
+      memcpy(kvRowValues(nrow), kvRowValues(row), POINTER_DISTANCE(kvRowEnd(row), kvRowValues(row)));
+      int colIdx = kvRowNCols(nrow) - 1;
+      kvRowColIdxAt(nrow, colIdx)->colId = colId;
+      kvRowColIdxAt(nrow, colIdx)->offset = POINTER_DISTANCE(kvRowEnd(row), kvRowValues(row));
+      memcpy(kvRowColVal(nrow, kvRowColIdxAt(nrow, colIdx)), value, diff);
+    } else {
+      int16_t tlen = POINTER_DISTANCE(ptr, kvRowColIdx(row));
+      if (tlen > 0) {
+        memcpy(kvRowColIdx(nrow), kvRowColIdx(row), tlen);
+        memcpy(kvRowValues(nrow), kvRowValues(row), ((SColIdx *)ptr)->offset);
+      }
+
+      int colIdx = tlen / sizeof(SColIdx);
+      kvRowColIdxAt(nrow, colIdx)->colId = colId;
+      kvRowColIdxAt(nrow, colIdx)->offset = ((SColIdx *)ptr)->offset;
+      memcpy(kvRowColVal(nrow, kvRowColIdxAt(nrow, colIdx)), value, diff);
+
+      for (int i = colIdx; i < kvRowNCols(row); i++) {
+        kvRowColIdxAt(nrow, i + 1)->colId = kvRowColIdxAt(row, i)->colId;
+        kvRowColIdxAt(nrow, i + 1)->offset = kvRowColIdxAt(row, i)->offset + diff;
+      }
+      memcpy(kvRowColVal(nrow, kvRowColIdxAt(nrow, colIdx + 1)), kvRowColVal(row, kvRowColIdxAt(row, colIdx)),
+             POINTER_DISTANCE(kvRowEnd(row), kvRowColVal(row, kvRowColIdxAt(row, colIdx)))
+
+      );
+    }
+
+    *orow = nrow;
+    free(row);
+  } else {
+    ASSERT(((SColIdx *)ptr)->colId == colId);
+    if (IS_VAR_DATA_TYPE(type)) {
+      void *pOldVal = kvRowColVal(row, (SColIdx *)ptr);
+
+      if (varDataTLen(value) == varDataTLen(pOldVal)) { // just update the column value in place
+        memcpy(pOldVal, value, varDataTLen(value));
+      } else { // need to reallocate the memory
+        int16_t diff = varDataTLen(value) - varDataTLen(pOldVal);
+        int16_t nlen = kvRowLen(row) + diff;
+        ASSERT(nlen > 0);
+        nrow = malloc(nlen);
+        if (nrow == NULL) return -1;
+
+        kvRowSetLen(nrow, nlen);
+        kvRowSetNCols(nrow, kvRowNCols(row));
+
+        // Copy part ahead
+        nlen = POINTER_DISTANCE(ptr, kvRowColIdx(row));
+        ASSERT(nlen % sizeof(SColIdx) == 0);
+        if (nlen > 0) {
+          ASSERT(((SColIdx *)ptr)->offset > 0);
+          memcpy(kvRowColIdx(nrow), kvRowColIdx(row), nlen);
+          memcpy(kvRowValues(nrow), kvRowValues(row), ((SColIdx *)ptr)->offset);
+        }
+
+        // Construct current column value
+        int colIdx = nlen / sizeof(SColIdx);
+        pColIdx = kvRowColIdxAt(nrow, colIdx);
+        pColIdx->colId = ((SColIdx *)ptr)->colId;
+        pColIdx->offset = ((SColIdx *)ptr)->offset;
+        memcpy(kvRowColVal(nrow, pColIdx), value, varDataTLen(value));
+ 
+        // Construct columns after
+        if (kvRowNCols(nrow) - colIdx - 1 > 0) {
+          for (int i = colIdx + 1; i < kvRowNCols(nrow); i++) {
+            kvRowColIdxAt(nrow, i)->colId = kvRowColIdxAt(row, i)->colId;
+            kvRowColIdxAt(nrow, i)->offset += diff;
+          }
+          memcpy(kvRowColVal(nrow, kvRowColIdxAt(nrow, colIdx + 1)), kvRowColVal(row, kvRowColIdxAt(row, colIdx + 1)),
+                 POINTER_DISTANCE(kvRowEnd(row), kvRowColVal(row, kvRowColIdxAt(row, colIdx + 1))));
+        }
+
+        *orow = nrow;
+        free(row);
+      }
+    } else {
+      memcpy(kvRowColVal(row, (SColIdx *)ptr), value, TYPE_BYTES[type]);
+    }
+  }
+
+  return 0;
 }
 
 void *tdEncodeKVRow(void *buf, SKVRow row) {

src/common/src/ttypes.c

@@ -364,7 +364,7 @@ char tTokenTypeSwitcher[13] = {
 };
 
 bool isValidDataType(int32_t type, int32_t length) {
-  if (type < TSDB_DATA_TYPE_BOOL || type > TSDB_DATA_TYPE_NCHAR) {
+  if (type < TSDB_DATA_TYPE_NULL || type > TSDB_DATA_TYPE_NCHAR) {
     return false;
   }
 

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

@@ -18,8 +18,8 @@ import java.io.InputStream;
 import java.io.Reader;
 import java.math.BigDecimal;
 import java.net.URL;
-import java.sql.*;
 import java.sql.Date;
+import java.sql.*;
 import java.util.*;
 
 /*
@@ -102,41 +102,49 @@ public class DatabaseMetaDataResultSet implements ResultSet {
 
     @Override
     public byte getByte(int columnIndex) throws SQLException {
+        columnIndex--;
         return (byte) rowCursor.getInt(columnIndex, columnMetaDataList.get(columnIndex).getColType());
     }
 
     @Override
     public short getShort(int columnIndex) throws SQLException {
+        columnIndex--;
         return (short) rowCursor.getInt(columnIndex, columnMetaDataList.get(columnIndex).getColType());
     }
 
     @Override
     public int getInt(int columnIndex) throws SQLException {
+        columnIndex--;
         return rowCursor.getInt(columnIndex, columnMetaDataList.get(columnIndex).getColType());
     }
 
     @Override
     public long getLong(int columnIndex) throws SQLException {
+        columnIndex--;
         return rowCursor.getLong(columnIndex, columnMetaDataList.get(columnIndex).getColType());
     }
 
     @Override
     public float getFloat(int columnIndex) throws SQLException {
+        columnIndex--;
         return rowCursor.getFloat(columnIndex, columnMetaDataList.get(columnIndex).getColType());
     }
 
     @Override
     public double getDouble(int columnIndex) throws SQLException {
+        columnIndex--;
         return rowCursor.getDouble(columnIndex, columnMetaDataList.get(columnIndex).getColType());
     }
 
     @Override
     public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
+        columnIndex--;
         return new BigDecimal(rowCursor.getDouble(columnIndex, columnMetaDataList.get(columnIndex).getColType()));
     }
 
     @Override
     public byte[] getBytes(int columnIndex) throws SQLException {
+        columnIndex--;
         return (rowCursor.getString(columnIndex, columnMetaDataList.get(columnIndex).getColType())).getBytes();
     }
 
@@ -152,6 +160,7 @@ public class DatabaseMetaDataResultSet implements ResultSet {
 
     @Override
     public Timestamp getTimestamp(int columnIndex) throws SQLException {
+        columnIndex--;
         return rowCursor.getTimestamp(columnIndex);
     }
 

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

@@ -84,6 +84,14 @@ public class TSDBConnection implements Connection {
 		}
 	}
 
+	public TSDBSubscribe createSubscribe() throws SQLException {
+		if (!this.connector.isClosed()) {
+			return new TSDBSubscribe(this.connector);
+		} else {
+			throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));
+		}
+	}
+
 	public PreparedStatement prepareStatement(String sql) throws SQLException {
 		if (!this.connector.isClosed()) {
 			return new TSDBPreparedStatement(this.connector, sql);

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

@@ -99,7 +99,7 @@ public class TSDBJNIConnector {
 
         this.taos = this.connectImp(host, port, dbName, user, password);
         if (this.taos == TSDBConstants.JNI_NULL_POINTER) {
-            throw new SQLException(TSDBConstants.WrapErrMsg(this.getErrMsg()), "", this.getErrCode());
+            throw new SQLException(TSDBConstants.WrapErrMsg(this.getErrMsg(null)), "", this.getErrCode(null));
         }
 
         return true;
@@ -117,52 +117,57 @@ public class TSDBJNIConnector {
             freeResultSet(taosResultSetPointer);
         }
 
-        int code;
+        long pSql = 0l;
         try {
-            code = this.executeQueryImp(sql.getBytes(TaosGlobalConfig.getCharset()), this.taos);
+            pSql = this.executeQueryImp(sql.getBytes(TaosGlobalConfig.getCharset()), this.taos);
         } catch (Exception e) {
             e.printStackTrace();
+            this.freeResultSet(pSql);
             throw new SQLException(TSDBConstants.WrapErrMsg("Unsupported encoding"));
         }
+        int code = this.getErrCode(pSql);
+
         affectedRows = code;
         if (code < 0) {
             affectedRows = -1;
             if (code == TSDBConstants.JNI_TDENGINE_ERROR) {
-                throw new SQLException(TSDBConstants.WrapErrMsg(this.getErrMsg()), "", this.getErrCode());
+                this.freeResultSet(pSql);
+                throw new SQLException(TSDBConstants.WrapErrMsg(this.getErrMsg(pSql)), "", this.getErrCode(pSql));
             } else {
-                throw new SQLException(TSDBConstants.FixErrMsg(code), "", this.getErrCode());
+                this.freeResultSet(pSql);
+                throw new SQLException(TSDBConstants.FixErrMsg(code), "", this.getErrCode(pSql));
             }
         }
 
         // Try retrieving result set for the executed SQL using the current connection pointer. If the executed
         // SQL is a DML/DDL which doesn't return a result set, then taosResultSetPointer should be 0L. Otherwise,
         // taosResultSetPointer should be a non-zero value.
-        taosResultSetPointer = this.getResultSetImp(this.taos);
+        taosResultSetPointer = this.getResultSetImp(this.taos, pSql);
         if (taosResultSetPointer != TSDBConstants.JNI_NULL_POINTER) {
             isResultsetClosed = false;
         }
         return code;
     }
 
-    private native int executeQueryImp(byte[] sqlBytes, long connection);
+    private native long executeQueryImp(byte[] sqlBytes, long connection);
 
     /**
      * Get recent error code by connection
      */
-    public int getErrCode() {
-        return Math.abs(this.getErrCodeImp(this.taos));
+    public int getErrCode(Long pSql) {
+        return Math.abs(this.getErrCodeImp(this.taos, pSql));
     }
 
-    private native int getErrCodeImp(long connection);
+    private native int getErrCodeImp(long connection, Long pSql);
 
     /**
      * Get recent error message by connection
      */
-    public String getErrMsg() {
-        return this.getErrMsgImp(this.taos);
+    public String getErrMsg(Long pSql) {
+        return this.getErrMsgImp(this.taos, pSql);
     }
 
-    private native String getErrMsgImp(long connection);
+    private native String getErrMsgImp(long connection, Long pSql);
 
     /**
      * Get resultset pointer
@@ -172,7 +177,7 @@ public class TSDBJNIConnector {
         return taosResultSetPointer;
     }
 
-    private native long getResultSetImp(long connection);
+    private native long getResultSetImp(long connection, long pSql);
 
     /**
      * Free resultset operation from C to release resultset pointer by JNI
@@ -212,15 +217,15 @@ public class TSDBJNIConnector {
     /**
      * Get affected rows count
      */
-    public int getAffectedRows() {
+    public int getAffectedRows(Long pSql) {
         int affectedRows = this.affectedRows;
         if (affectedRows < 0) {
-            affectedRows = this.getAffectedRowsImp(this.taos);
+            affectedRows = this.getAffectedRowsImp(this.taos, pSql);
         }
         return affectedRows;
     }
 
-    private native int getAffectedRowsImp(long connection);
+    private native int getAffectedRowsImp(long connection, Long pSql);
 
     /**
      * Get schema metadata
@@ -248,7 +253,7 @@ public class TSDBJNIConnector {
     public void closeConnection() throws SQLException {
         int code = this.closeConnectionImp(this.taos);
         if (code < 0) {
-            throw new SQLException(TSDBConstants.FixErrMsg(code), "", this.getErrCode());
+            throw new SQLException(TSDBConstants.FixErrMsg(code), "", this.getErrCode(null));
         } else if (code == 0) {
             this.taos = TSDBConstants.JNI_NULL_POINTER;
         } else {
@@ -261,31 +266,31 @@ public class TSDBJNIConnector {
     /**
      * Subscribe to a table in TSDB
      */
-    public long subscribe(String host, String user, String password, String database, String table, long time, int period) {
-        return subscribeImp(host, user, password, database, table, time, period);
+    public long subscribe(String topic, String sql, boolean restart, int period) {
+        return subscribeImp(this.taos, restart, topic, sql, period);
     }
 
-    private native long subscribeImp(String host, String user, String password, String database, String table, long time, int period);
+    public native long subscribeImp(long connection, boolean restart, String topic, String sql, int period);
 
     /**
      * Consume a subscribed table
      */
-    public TSDBResultSetRowData consume(long subscription) {
+    public long consume(long subscription) {
         return this.consumeImp(subscription);
     }
 
-    private native TSDBResultSetRowData consumeImp(long subscription);
+    private native long consumeImp(long subscription);
 
     /**
      * Unsubscribe a table
      *
      * @param subscription
      */
-    public void unsubscribe(long subscription) {
-        unsubscribeImp(subscription);
+    public void unsubscribe(long subscription, boolean isKeep) {
+        unsubscribeImp(subscription, isKeep);
     }
 
-    private native void unsubscribeImp(long subscription);
+    private native void unsubscribeImp(long subscription, boolean isKeep);
 
     /**
      * Validate if a <I>create table</I> sql statement is correct without actually creating that table

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

@@ -51,47 +51,47 @@ public class TSDBResultSet implements ResultSet {
 	private boolean lastWasNull = false;
 	private final int COLUMN_INDEX_START_VALUE = 1;
 
-    public TSDBJNIConnector getJniConnector() {
-        return jniConnector;
-    }
+	public TSDBJNIConnector getJniConnector() {
+		return jniConnector;
+	}
 
-    public void setJniConnector(TSDBJNIConnector jniConnector) {
-        this.jniConnector = jniConnector;
-    }
+	public void setJniConnector(TSDBJNIConnector jniConnector) {
+		this.jniConnector = jniConnector;
+	}
 
-    public long getResultSetPointer() {
-        return resultSetPointer;
-    }
+	public long getResultSetPointer() {
+		return resultSetPointer;
+	}
 
-    public void setResultSetPointer(long resultSetPointer) {
-        this.resultSetPointer = resultSetPointer;
-    }
+	public void setResultSetPointer(long resultSetPointer) {
+		this.resultSetPointer = resultSetPointer;
+	}
 
-    public List<ColumnMetaData> getColumnMetaDataList() {
-        return columnMetaDataList;
-    }
+	public List<ColumnMetaData> getColumnMetaDataList() {
+		return columnMetaDataList;
+	}
 
-    public void setColumnMetaDataList(List<ColumnMetaData> columnMetaDataList) {
-        this.columnMetaDataList = columnMetaDataList;
-    }
+	public void setColumnMetaDataList(List<ColumnMetaData> columnMetaDataList) {
+		this.columnMetaDataList = columnMetaDataList;
+	}
 
-    public TSDBResultSetRowData getRowData() {
-        return rowData;
-    }
+	public TSDBResultSetRowData getRowData() {
+		return rowData;
+	}
 
-    public void setRowData(TSDBResultSetRowData rowData) {
-        this.rowData = rowData;
-    }
+	public void setRowData(TSDBResultSetRowData rowData) {
+		this.rowData = rowData;
+	}
 
-    public boolean isLastWasNull() {
-        return lastWasNull;
-    }
+	public boolean isLastWasNull() {
+		return lastWasNull;
+	}
 
-    public void setLastWasNull(boolean lastWasNull) {
-        this.lastWasNull = lastWasNull;
-    }
+	public void setLastWasNull(boolean lastWasNull) {
+		this.lastWasNull = lastWasNull;
+	}
 
-    public TSDBResultSet() {
+	public TSDBResultSet() {
 	}
 
 	public TSDBResultSet(TSDBJNIConnector connecter, long resultSetPointer) throws SQLException {
@@ -119,7 +119,7 @@ public class TSDBResultSet implements ResultSet {
 
 	public boolean next() throws SQLException {
 		if (rowData != null) {
-            this.rowData.clear();
+			this.rowData.clear();
 		}
 
 		int code = this.jniConnector.fetchRow(this.resultSetPointer, this.rowData);
@@ -154,119 +154,119 @@ public class TSDBResultSet implements ResultSet {
 	public String getString(int columnIndex) throws SQLException {
 		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());
-        }
+
+		this.lastWasNull = this.rowData.wasNull(colIndex);
+		if (!lastWasNull) {
+			res = this.rowData.getString(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+		}
 		return res;
 	}
 
 	public boolean getBoolean(int columnIndex) throws SQLException {
-	    boolean res = false;
+		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());
-        }
+			res = this.rowData.getBoolean(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+		}
 		return res;
 	}
 
 	public byte getByte(int columnIndex) throws SQLException {
-	    byte res = 0;
+		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());
-        }
+			res = (byte) this.rowData.getInt(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+		}
 		return res;
 	}
 
 	public short getShort(int columnIndex) throws SQLException {
-	    short res = 0;
+		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());
-        }
+			res = (short) this.rowData.getInt(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+		}
 		return res;
 	}
 
 	public int getInt(int columnIndex) throws SQLException {
-	    int res = 0;
+		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 (!lastWasNull) {
+			res = this.rowData.getInt(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+		}
 		return res;
 	}
 
 	public long getLong(int columnIndex) throws SQLException {
-	    long res = 0l;
+		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 (!lastWasNull) {
+			res = this.rowData.getLong(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+		}
 		return res;
 	}
 
 	public float getFloat(int columnIndex) throws SQLException {
-	    float res = 0;
-	    int colIndex = getTrueColumnIndex(columnIndex);
+		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 (!lastWasNull) {
+			res = this.rowData.getFloat(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+		}
 		return res;
 	}
 
 	public double getDouble(int columnIndex) throws SQLException {
-	    double res = 0;
+		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 (!lastWasNull) {
+			res = this.rowData.getDouble(colIndex, this.columnMetaDataList.get(colIndex).getColType());
+		}
 		return res;
 	}
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see java.sql.ResultSet#getBigDecimal(int, int)
-	 * 
+	 *
 	 * @deprecated Use {@code getBigDecimal(int columnIndex)} or {@code
 	 * getBigDecimal(String columnLabel)}
 	 */
 	@Deprecated
 	public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
-	    BigDecimal res = null;
+		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()));
-        }
+		if (!lastWasNull) {
+			res = new BigDecimal(this.rowData.getLong(colIndex, this.columnMetaDataList.get(colIndex).getColType()));
+		}
 		return res;
 	}
 
 	public byte[] getBytes(int columnIndex) throws SQLException {
-	    byte[] res = null;
+		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();
-        }
+		if (!lastWasNull) {
+			res = this.rowData.getString(colIndex, this.columnMetaDataList.get(colIndex).getColType()).getBytes();
+		}
 		return res;
 	}
 
@@ -281,13 +281,13 @@ public class TSDBResultSet implements ResultSet {
 	}
 
 	public Timestamp getTimestamp(int columnIndex) throws SQLException {
-	    Timestamp res = null;
+		Timestamp res = null;
 		int colIndex = getTrueColumnIndex(columnIndex);
 
 		this.lastWasNull = this.rowData.wasNull(colIndex);
-        if (!lastWasNull) {
-            res = this.rowData.getTimestamp(colIndex);
-        }
+		if (!lastWasNull) {
+			res = this.rowData.getTimestamp(colIndex);
+		}
 		return res;
 	}
 
@@ -297,9 +297,9 @@ public class TSDBResultSet implements ResultSet {
 
 	/*
 	 * (non-Javadoc)
-	 * 
+	 *
 	 * @see java.sql.ResultSet#getUnicodeStream(int)
-	 * 
+	 *
 	 * * @deprecated use <code>getCharacterStream</code> in place of
 	 * <code>getUnicodeStream</code>
 	 */
@@ -409,13 +409,13 @@ public class TSDBResultSet implements ResultSet {
 	}
 
 	public int findColumn(String columnLabel) throws SQLException {
-        Iterator<ColumnMetaData> colMetaDataIt = this.columnMetaDataList.iterator();
-        while (colMetaDataIt.hasNext()) {
-            ColumnMetaData colMetaData = colMetaDataIt.next();
-            if (colMetaData.getColName() != null && colMetaData.getColName().equalsIgnoreCase(columnLabel)) {
-                return colMetaData.getColIndex() + 1;
-            }
-        }
+		Iterator<ColumnMetaData> colMetaDataIt = this.columnMetaDataList.iterator();
+		while (colMetaDataIt.hasNext()) {
+			ColumnMetaData colMetaData = colMetaDataIt.next();
+			if (colMetaData.getColName() != null && colMetaData.getColName().equalsIgnoreCase(columnLabel)) {
+				return colMetaData.getColIndex() + 1;
+			}
+		}
 		throw new SQLException(TSDBConstants.INVALID_VARIABLES);
 	}
 
@@ -882,7 +882,7 @@ public class TSDBResultSet implements ResultSet {
 	}
 
 	public String getNString(int columnIndex) throws SQLException {
-        int colIndex = getTrueColumnIndex(columnIndex);
+		int colIndex = getTrueColumnIndex(columnIndex);
 		return (String) rowData.get(colIndex);
 	}
 
@@ -1017,17 +1017,17 @@ public class TSDBResultSet implements ResultSet {
 	public <T> T getObject(String columnLabel, Class<T> type) throws SQLException {
 		throw new SQLException(TSDBConstants.UNSUPPORT_METHOD_EXCEPTIONZ_MSG);
 	}
-	
+
 	private int getTrueColumnIndex(int columnIndex) throws SQLException {
 		if (columnIndex < this.COLUMN_INDEX_START_VALUE) {
 			throw new SQLException("Column Index out of range, " + columnIndex + " < " + this.COLUMN_INDEX_START_VALUE);
 		}
-		
+
 		int numOfCols = this.columnMetaDataList.size();
 		if (columnIndex > numOfCols) {
 			throw new SQLException("Column Index out of range, " + columnIndex + " > " + numOfCols);
 		}
-		
+
 		return columnIndex - 1;
 	}
 }

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

@@ -27,6 +27,8 @@ public class TSDBStatement implements Statement {
 	/** Timeout for a query */
 	protected int queryTimeout = 0;
 
+	private Long pSql = 0l;
+
     /**
      * Status of current statement
      */
@@ -66,21 +68,23 @@ public class TSDBStatement implements Statement {
         if (isClosed) {
             throw new SQLException("Invalid method call on a closed statement.");
         }
-		int res = this.connecter.executeQuery(sql);
+		long res = this.connecter.executeQuery(sql);
 		long resultSetPointer = this.connecter.getResultSet();
 
 		if (resultSetPointer == TSDBConstants.JNI_CONNECTION_NULL) {
+			this.connecter.freeResultSet(res);
 			throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));
 		} else if (resultSetPointer != TSDBConstants.JNI_NULL_POINTER) {
 			this.connecter.freeResultSet();
 			throw new SQLException("The executed SQL is not a DML or a DDL");
 		} else {
-			return res;
+			int num = this.connecter.getAffectedRows(res);
+			return num;
 		}
 	}
 
-	public String getErrorMsg() {
-		return this.connecter.getErrMsg();
+	public String getErrorMsg(long pSql) {
+		return this.connecter.getErrMsg(pSql);
 	}
 
 	public void close() throws SQLException {
@@ -170,7 +174,7 @@ public class TSDBStatement implements Statement {
         if (isClosed) {
             throw new SQLException("Invalid method call on a closed statement.");
         }
-		return this.connecter.getAffectedRows();
+		return this.connecter.getAffectedRows(this.pSql);
 	}
 
 	public boolean getMoreResults() throws SQLException {

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

+/***************************************************************************
+ * 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 javax.management.OperationsException;
+import java.sql.SQLException;
+import java.util.Map;
+import java.util.TimerTask;
+import java.util.concurrent.*;
+
+public class TSDBSubscribe {
+    private TSDBJNIConnector connecter = null;
+    private static ScheduledExecutorService pool;
+    private static Map<Long, TSDBTimerTask> timerTaskMap = new ConcurrentHashMap<>();
+    private static Map<Long, ScheduledFuture> scheduledMap = new ConcurrentHashMap();
+
+    private static class TimerInstance {
+        private static final ScheduledExecutorService instance = Executors.newScheduledThreadPool(1);
+    }
+
+    public static ScheduledExecutorService getTimerInstance() {
+        return TimerInstance.instance;
+    }
+
+    public TSDBSubscribe(TSDBJNIConnector connecter) throws SQLException {
+        if (null != connecter) {
+            this.connecter = connecter;
+        } else {
+            throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));
+        }
+    }
+
+    /**
+     * sync subscribe
+     *
+     * @param topic
+     * @param sql
+     * @param restart
+     * @param period
+     * @throws SQLException
+     */
+    public long subscribe(String topic, String sql, boolean restart, int period) throws SQLException {
+        if (this.connecter.isClosed()) {
+            throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));
+        }
+        if (period < 1000) {
+            throw new SQLException(TSDBConstants.WrapErrMsg(TSDBConstants.INVALID_VARIABLES));
+        }
+        return this.connecter.subscribe(topic, sql, restart, period);
+    }
+
+    /**
+     * async subscribe
+     *
+     * @param topic
+     * @param sql
+     * @param restart
+     * @param period
+     * @param callBack
+     * @throws SQLException
+     */
+    public long subscribe(String topic, String sql, boolean restart, int period, TSDBSubscribeCallBack callBack) throws SQLException {
+        if (this.connecter.isClosed()) {
+            throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));
+        }
+        final long subscription = this.connecter.subscribe(topic, sql, restart, period);
+        if (null != callBack) {
+            pool = getTimerInstance();
+
+            TSDBTimerTask timerTask = new TSDBTimerTask(subscription, callBack);
+
+            timerTaskMap.put(subscription, timerTask);
+
+            ScheduledFuture scheduledFuture = pool.scheduleAtFixedRate(timerTask, 1, 1000, TimeUnit.MILLISECONDS);
+            scheduledMap.put(subscription, scheduledFuture);
+        }
+        return subscription;
+    }
+
+    public TSDBResultSet consume(long subscription) throws OperationsException, SQLException {
+        if (this.connecter.isClosed()) {
+            throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));
+        }
+        if (0 == subscription) {
+            throw new OperationsException("Invalid use of consume");
+        }
+        long resultSetPointer = this.connecter.consume(subscription);
+
+        if (resultSetPointer == TSDBConstants.JNI_CONNECTION_NULL) {
+            throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));
+        } else if (resultSetPointer == TSDBConstants.JNI_NULL_POINTER) {
+            return null;
+        } else {
+            return new TSDBResultSet(this.connecter, resultSetPointer);
+        }
+    }
+
+    /**
+     * cancel subscribe
+     *
+     * @param subscription
+     * @param isKeep
+     * @throws SQLException
+     */
+    public void unsubscribe(long subscription, boolean isKeep) throws SQLException {
+        if (this.connecter.isClosed()) {
+            throw new SQLException(TSDBConstants.FixErrMsg(TSDBConstants.JNI_CONNECTION_NULL));
+        }
+
+        if (null != timerTaskMap.get(subscription)) {
+            synchronized (timerTaskMap.get(subscription)) {
+                while (1 == timerTaskMap.get(subscription).getState()) {
+                    try {
+                        Thread.sleep(10);
+                    } catch (Exception e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+                timerTaskMap.get(subscription).setState(2);
+                if (!timerTaskMap.isEmpty() && timerTaskMap.containsKey(subscription)) {
+                    timerTaskMap.get(subscription).cancel();
+                    timerTaskMap.remove(subscription);
+                    scheduledMap.get(subscription).cancel(false);
+                    scheduledMap.remove(subscription);
+                }
+                this.connecter.unsubscribe(subscription, isKeep);
+            }
+        } else {
+            this.connecter.unsubscribe(subscription, isKeep);
+        }
+    }
+
+    class TSDBTimerTask extends TimerTask {
+        private long subscription;
+        private TSDBSubscribeCallBack callBack;
+        // 0: not running 1: running 2: cancel
+        private int state = 0;
+
+        public TSDBTimerTask(long subscription, TSDBSubscribeCallBack callBack) {
+            this.subscription = subscription;
+            this.callBack = callBack;
+        }
+
+        public int getState() {
+            return this.state;
+        }
+
+        public void setState(int state) {
+            this.state = state;
+        }
+
+        @Override
+        public void run() {
+            synchronized (this) {
+                if (2 == state) {
+                    return;
+                }
+
+                state = 1;
+
+                try {
+                    TSDBResultSet resultSet = consume(subscription);
+                    callBack.invoke(resultSet);
+                } catch (Exception e) {
+                    this.cancel();
+                    throw new RuntimeException(e);
+                }
+                state = 0;
+            }
+        }
+    }
+}
+

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

+/***************************************************************************
+ * 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;
+
+public interface TSDBSubscribeCallBack {
+    void invoke(TSDBResultSet resultSet);
+}

src/connector/jdbc/src/test/java/TestAsyncTSDBSubscribe.java

+import com.taosdata.jdbc.*;
+import org.apache.commons.lang3.StringUtils;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.util.Properties;
+
+public class TestAsyncTSDBSubscribe {
+    public static void main(String[] args) {
+        String usage = "java -cp taos-jdbcdriver-1.0.3_dev-dist.jar com.taosdata.jdbc.TSDBSubscribe -db dbName -topic topicName " +
+                "-tname tableName -h host";
+        if (args.length < 2) {
+            System.err.println(usage);
+            return;
+        }
+
+        String dbName = "";
+        String tName = "";
+        String host = "localhost";
+        String topic = "";
+        for (int i = 0; i < args.length; i++) {
+            if ("-db".equalsIgnoreCase(args[i]) && i < args.length - 1) {
+                dbName = args[++i];
+            }
+            if ("-tname".equalsIgnoreCase(args[i]) && i < args.length - 1) {
+                tName = args[++i];
+            }
+            if ("-h".equalsIgnoreCase(args[i]) && i < args.length - 1) {
+                host = args[++i];
+            }
+            if ("-topic".equalsIgnoreCase(args[i]) && i < args.length - 1) {
+                topic = args[++i];
+            }
+        }
+        if (StringUtils.isEmpty(dbName) || StringUtils.isEmpty(tName) || StringUtils.isEmpty(topic)) {
+            System.err.println(usage);
+            return;
+        }
+
+        Connection connection = null;
+        TSDBSubscribe subscribe = null;
+        long subscribId = 0;
+        try {
+            Class.forName("com.taosdata.jdbc.TSDBDriver");
+            Properties properties = new Properties();
+            properties.setProperty(TSDBDriver.PROPERTY_KEY_HOST, host);
+            connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":0/" + dbName + "?user=root&password=taosdata", properties);
+            String rawSql = "select * from " + tName + ";";
+            subscribe = ((TSDBConnection) connection).createSubscribe();
+            subscribId = subscribe.subscribe(topic, rawSql, false, 1000, new CallBack("first"));
+            long subscribId2 = subscribe.subscribe("test", rawSql, false, 1000, new CallBack("second"));
+            int a = 0;
+            Thread.sleep(2000);
+            subscribe.unsubscribe(subscribId, true);
+            System.err.println("cancel subscribe");
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static class CallBack implements TSDBSubscribeCallBack {
+        private String name = "";
+
+        public CallBack(String name) {
+            this.name = name;
+        }
+
+        @Override
+        public void invoke(TSDBResultSet resultSet) {
+            try {
+                while (null !=resultSet && resultSet.next()) {
+                    System.out.print("callback_" + name + ": ");
+                    for (int i = 1; i <= resultSet.getMetaData().getColumnCount(); i++) {
+                        System.out.printf(i + ": " + resultSet.getString(i) + "\t");
+                    }
+                    System.out.println();
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+}

src/connector/jdbc/src/test/java/TestPreparedStatement.java

@@ -10,9 +10,9 @@ public class TestPreparedStatement {
         try {
             Class.forName("com.taosdata.jdbc.TSDBDriver");
             Properties properties = new Properties();
-            properties.setProperty(TSDBDriver.PROPERTY_KEY_HOST, "192.168.1.117");
-            Connection connection = DriverManager.getConnection("jdbc:TAOS://192.168.1.117:0/?user=root&password=taosdata", properties);
-            String rawSql = "SELECT ts, c1 FROM (select c1, ts from db.tb1) SUB_QRY";
+            properties.setProperty(TSDBDriver.PROPERTY_KEY_HOST, "localhost");
+            Connection connection = DriverManager.getConnection("jdbc:TAOS://localhost:0/?user=root&password=taosdata", properties);
+            String rawSql = "select * from test.log0601";
 //            String[] params = new String[]{"ts", "c1"};
             PreparedStatement pstmt = (TSDBPreparedStatement) connection.prepareStatement(rawSql);
             ResultSet resSet = pstmt.executeQuery();

src/connector/jdbc/src/test/java/TestTSDBSubscribe.java

+import com.taosdata.jdbc.TSDBConnection;
+import com.taosdata.jdbc.TSDBDriver;
+import com.taosdata.jdbc.TSDBResultSet;
+import com.taosdata.jdbc.TSDBSubscribe;
+import org.apache.commons.lang3.StringUtils;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.util.Properties;
+
+public class TestTSDBSubscribe {
+    public static void main(String[] args) throws Exception {
+        String usage = "java -cp taos-jdbcdriver-1.0.3_dev-dist.jar com.taosdata.jdbc.TSDBSubscribe -db dbName " +
+                "-topic topicName -tname tableName -h host";
+        if (args.length < 2) {
+            System.err.println(usage);
+            return;
+        }
+
+        String dbName = "";
+        String tName = "";
+        String host = "localhost";
+        String topic = "";
+        for (int i = 0; i < args.length; i++) {
+            if ("-db".equalsIgnoreCase(args[i]) && i < args.length - 1) {
+                dbName = args[++i];
+            }
+            if ("-tname".equalsIgnoreCase(args[i]) && i < args.length - 1) {
+                tName = args[++i];
+            }
+            if ("-h".equalsIgnoreCase(args[i]) && i < args.length - 1) {
+                host = args[++i];
+            }
+            if ("-topic".equalsIgnoreCase(args[i]) && i < args.length - 1) {
+                topic = args[++i];
+            }
+        }
+        if (StringUtils.isEmpty(dbName) || StringUtils.isEmpty(tName) || StringUtils.isEmpty(topic)) {
+            System.err.println(usage);
+            return;
+        }
+
+        Connection connection = null;
+        TSDBSubscribe subscribe = null;
+        long subscribId = 0;
+        try {
+            Class.forName("com.taosdata.jdbc.TSDBDriver");
+            Properties properties = new Properties();
+            properties.setProperty(TSDBDriver.PROPERTY_KEY_HOST, host);
+            connection = DriverManager.getConnection("jdbc:TAOS://" + host + ":0/" + dbName + "?user=root&password=taosdata"
+                    , properties);
+            String rawSql = "select * from " + tName + ";";
+            subscribe = ((TSDBConnection) connection).createSubscribe();
+            subscribId = subscribe.subscribe(topic, rawSql, false, 1000);
+            int a = 0;
+            while (true) {
+                Thread.sleep(900);
+                TSDBResultSet resSet = subscribe.consume(subscribId);
+
+                while (resSet.next()) {
+                    for (int i = 1; i <= resSet.getMetaData().getColumnCount(); i++) {
+                        System.out.printf(i + ": " + resSet.getString(i) + "\t");
+                    }
+                    System.out.println("\n======" + a + "==========");
+                }
+
+                a++;
+                if (a >= 10) {
+                    break;
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            if (null != subscribe && 0 != subscribId) {
+                subscribe.unsubscribe(subscribId, true);
+            }
+            if (null != connection) {
+                connection.close();
+            }
+        }
+    }
+}

src/connector/python/linux/python2/taos/cinterface.py

@@ -142,12 +142,14 @@ class CTaosInterface(object):
     libtaos.taos_fetch_fields.restype = ctypes.POINTER(TaosField)
     libtaos.taos_init.restype = None
     libtaos.taos_connect.restype = ctypes.c_void_p
-    libtaos.taos_use_result.restype = ctypes.c_void_p
+    #libtaos.taos_use_result.restype = ctypes.c_void_p
     libtaos.taos_fetch_row.restype = ctypes.POINTER(ctypes.c_void_p)
     libtaos.taos_errstr.restype = ctypes.c_char_p
     libtaos.taos_subscribe.restype = ctypes.c_void_p
     libtaos.taos_consume.restype = ctypes.c_void_p
     libtaos.taos_fetch_lengths.restype = ctypes.c_void_p
+    libtaos.taos_free_result.restype = None
+    libtaos.taos_errno.restype = ctypes.c_int
 
     def __init__(self, config=None):
         '''
@@ -249,12 +251,12 @@ class CTaosInterface(object):
             raise AttributeError("sql is expected as a string")
         # finally:
         #     CTaosInterface.libtaos.close(connection)
-
+      
     @staticmethod
-    def affectedRows(connection):
+    def affectedRows(result):
         """The affected rows after runing query
         """
-        return CTaosInterface.libtaos.taos_affected_rows(connection)
+        return CTaosInterface.libtaos.taos_affected_rows(result)
 
     @staticmethod
     def subscribe(connection, restart, topic, sql, interval):
@@ -292,18 +294,17 @@ class CTaosInterface(object):
         CTaosInterface.libtaos.taos_unsubscribe(sub, 1 if keepProgress else 0)
 
     @staticmethod
-    def useResult(connection):
+    def useResult(result):
         '''Use result after calling self.query
         '''
-        result = ctypes.c_void_p(CTaosInterface.libtaos.taos_use_result(connection))
         fields = []
         pfields = CTaosInterface.fetchFields(result)
-        for i in range(CTaosInterface.fieldsCount(connection)):
+        for i in range(CTaosInterface.fieldsCount(result)):
             fields.append({'name': pfields[i].name.decode('utf-8'),
                            'bytes': pfields[i].bytes,
                            'type': ord(pfields[i].type)})
 
-        return result, fields
+        return fields
 
     @staticmethod
     def fetchBlock(result, fields):
@@ -337,8 +338,8 @@ class CTaosInterface(object):
         result.value = None
 
     @staticmethod
-    def fieldsCount(connection):
-        return CTaosInterface.libtaos.taos_field_count(connection)
+    def fieldsCount(result):
+        return CTaosInterface.libtaos.taos_field_count(result)
 
     @staticmethod
     def fetchFields(result):
@@ -386,29 +387,30 @@ class CTaosInterface(object):
     #         return (ctypes.cast(data,  ctypes.c_char_p).value).rstrip('\x00')
 
     @staticmethod
-    def errno(connection):
+    def errno(result):
         """Return the error number.
         """
-        return CTaosInterface.libtaos.taos_errno(connection)
+        return CTaosInterface.libtaos.taos_errno(result)
 
     @staticmethod
-    def errStr(connection):
+    def errStr(result):
         """Return the error styring
         """
-        return CTaosInterface.libtaos.taos_errstr(connection)
+        return CTaosInterface.libtaos.taos_errstr(result)
 
 
 if __name__ == '__main__':
     cinter = CTaosInterface()
     conn = cinter.connect()
+    result = cinter.query(conn, 'show databases')
 
-    print('Query return value: {}'.format(cinter.query(conn, 'show databases')))
-    print('Affected rows: {}'.format(cinter.affectedRows(conn)))
+    print('Query Affected rows: {}'.format(cinter.affectedRows(result)))
 
-    result, des = CTaosInterface.useResult(conn)
+    fields = CTaosInterface.useResult(result)
 
-    data, num_of_rows = CTaosInterface.fetchBlock(result, des)
+    data, num_of_rows = CTaosInterface.fetchBlock(result, fields)
 
     print(data)
 
+    cinter.freeresult(result)
     cinter.close(conn)
\ No newline at end of file

src/connector/python/linux/python2/taos/connection.py

@@ -78,9 +78,7 @@ class TDengineConnection(object):
     def clear_result_set(self):
         """Clear unused result set on this connection.
         """
-        result = self._chandle.useResult(self._conn)[0]
-        if result:
-            self._chandle.freeResult(result)
+        pass
 
 if __name__ == "__main__":
     conn = TDengineConnection(host='192.168.1.107')

src/connector/python/linux/python2/taos/constants.py

@@ -28,6 +28,6 @@ class FieldType(object):
     C_FLOAT_NULL = float('nan')
     C_DOUBLE_NULL = float('nan')
     C_BINARY_NULL = bytearray([int('0xff', 16)])
-    # Time precision definition
+    # Timestamp precision definition
     C_TIMESTAMP_MILLI = 0
     C_TIMESTAMP_MICRO = 1

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

@@ -116,25 +116,30 @@ class TDengineCursor(object):
         if params is not None:
             pass
 
-        res = CTaosInterface.query(self._connection._conn, stmt)
-
+        # global querySeqNum
+        # querySeqNum += 1
+        # localSeqNum = querySeqNum # avoid raice condition
+        # print("   >> Exec Query ({}): {}".format(localSeqNum, str(stmt)))
+        self._result = CTaosInterface.query(self._connection._conn, stmt)
+        # print("   << Query ({}) Exec Done".format(localSeqNum))
         if (self._logfile):
             with open(self._logfile, "a") as logfile:
                 logfile.write("%s;\n" % operation)
 
-        if res == 0:
-            if CTaosInterface.fieldsCount(self._connection._conn) == 0:
+        errno = CTaosInterface.libtaos.taos_errno(self._result)
+        if errno == 0:
+            if CTaosInterface.fieldsCount(self._result) == 0:
                 self._affected_rows += CTaosInterface.affectedRows(
-                    self._connection._conn)
-                return CTaosInterface.affectedRows(self._connection._conn)
+                    self._result )
+                return CTaosInterface.affectedRows(self._result )
             else:
-                self._result, self._fields = CTaosInterface.useResult(
-                    self._connection._conn)
+                self._fields = CTaosInterface.useResult(
+                    self._result)
                 return self._handle_result()
         else:
             raise ProgrammingError(
                 CTaosInterface.errStr(
-                    self._connection._conn))
+                    self._result ))
 
     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.

src/connector/python/linux/python3/taos/cinterface.py

@@ -142,12 +142,14 @@ class CTaosInterface(object):
     libtaos.taos_fetch_fields.restype = ctypes.POINTER(TaosField)
     libtaos.taos_init.restype = None
     libtaos.taos_connect.restype = ctypes.c_void_p
-    libtaos.taos_use_result.restype = ctypes.c_void_p
+    #libtaos.taos_use_result.restype = ctypes.c_void_p
     libtaos.taos_fetch_row.restype = ctypes.POINTER(ctypes.c_void_p)
     libtaos.taos_errstr.restype = ctypes.c_char_p
     libtaos.taos_subscribe.restype = ctypes.c_void_p
     libtaos.taos_consume.restype = ctypes.c_void_p
     libtaos.taos_fetch_lengths.restype = ctypes.c_void_p
+    libtaos.taos_free_result.restype = None
+    libtaos.taos_errno.restype = ctypes.c_int
 
     def __init__(self, config=None):
         '''
@@ -249,12 +251,12 @@ class CTaosInterface(object):
             raise AttributeError("sql is expected as a string")
         # finally:
         #     CTaosInterface.libtaos.close(connection)
-
+      
     @staticmethod
-    def affectedRows(connection):
+    def affectedRows(result):
         """The affected rows after runing query
         """
-        return CTaosInterface.libtaos.taos_affected_rows(connection)
+        return CTaosInterface.libtaos.taos_affected_rows(result)
 
     @staticmethod
     def subscribe(connection, restart, topic, sql, interval):
@@ -292,18 +294,17 @@ class CTaosInterface(object):
         CTaosInterface.libtaos.taos_unsubscribe(sub, 1 if keepProgress else 0)
 
     @staticmethod
-    def useResult(connection):
+    def useResult(result):
         '''Use result after calling self.query
         '''
-        result = ctypes.c_void_p(CTaosInterface.libtaos.taos_use_result(connection))
         fields = []
         pfields = CTaosInterface.fetchFields(result)
-        for i in range(CTaosInterface.fieldsCount(connection)):
+        for i in range(CTaosInterface.fieldsCount(result)):
             fields.append({'name': pfields[i].name.decode('utf-8'),
                            'bytes': pfields[i].bytes,
                            'type': ord(pfields[i].type)})
 
-        return result, fields
+        return fields
 
     @staticmethod
     def fetchBlock(result, fields):
@@ -337,8 +338,8 @@ class CTaosInterface(object):
         result.value = None
 
     @staticmethod
-    def fieldsCount(connection):
-        return CTaosInterface.libtaos.taos_field_count(connection)
+    def fieldsCount(result):
+        return CTaosInterface.libtaos.taos_field_count(result)
 
     @staticmethod
     def fetchFields(result):
@@ -386,29 +387,30 @@ class CTaosInterface(object):
     #         return (ctypes.cast(data,  ctypes.c_char_p).value).rstrip('\x00')
 
     @staticmethod
-    def errno(connection):
+    def errno(result):
         """Return the error number.
         """
-        return CTaosInterface.libtaos.taos_errno(connection)
+        return CTaosInterface.libtaos.taos_errno(result)
 
     @staticmethod
-    def errStr(connection):
+    def errStr(result):
         """Return the error styring
         """
-        return CTaosInterface.libtaos.taos_errstr(connection).decode('utf-8')
+        return CTaosInterface.libtaos.taos_errstr(result).decode('utf-8')
 
 
 if __name__ == '__main__':
     cinter = CTaosInterface()
     conn = cinter.connect()
+    result = cinter.query(conn, 'show databases')
 
-    print('Query return value: {}'.format(cinter.query(conn, 'show databases')))
-    print('Affected rows: {}'.format(cinter.affectedRows(conn)))
+    print('Query Affected rows: {}'.format(cinter.affectedRows(result)))
 
-    result, des = CTaosInterface.useResult(conn)
+    fields = CTaosInterface.useResult(result)
 
-    data, num_of_rows = CTaosInterface.fetchBlock(result, des)
+    data, num_of_rows = CTaosInterface.fetchBlock(result, fields)
 
     print(data)
 
+    cinter.freeresult(result)
     cinter.close(conn)
\ No newline at end of file

src/connector/python/linux/python3/taos/connection.py

@@ -78,9 +78,7 @@ class TDengineConnection(object):
     def clear_result_set(self):
         """Clear unused result set on this connection.
         """
-        result = self._chandle.useResult(self._conn)[0]
-        if result:
-            self._chandle.freeResult(result)
+        pass
 
 if __name__ == "__main__":
     conn = TDengineConnection(host='192.168.1.107')

src/connector/python/linux/python3/taos/cursor.py

@@ -122,26 +122,26 @@ class TDengineCursor(object):
         # querySeqNum += 1
         # localSeqNum = querySeqNum # avoid raice condition
         # print("   >> Exec Query ({}): {}".format(localSeqNum, str(stmt)))
-        res = CTaosInterface.query(self._connection._conn, stmt)
+        self._result = CTaosInterface.query(self._connection._conn, stmt)
         # print("   << Query ({}) Exec Done".format(localSeqNum))
-
         if (self._logfile):
             with open(self._logfile, "a") as logfile:
                 logfile.write("%s;\n" % operation)
 
-        if res == 0:
-            if CTaosInterface.fieldsCount(self._connection._conn) == 0:
+        errno = CTaosInterface.libtaos.taos_errno(self._result)
+        if errno == 0:
+            if CTaosInterface.fieldsCount(self._result) == 0:
                 self._affected_rows += CTaosInterface.affectedRows(
-                    self._connection._conn)
-                return CTaosInterface.affectedRows(self._connection._conn)
+                    self._result )
+                return CTaosInterface.affectedRows(self._result )
             else:
-                self._result, self._fields = CTaosInterface.useResult(
-                    self._connection._conn)
+                self._fields = CTaosInterface.useResult(
+                    self._result)
                 return self._handle_result()
         else:
             raise ProgrammingError(
                 CTaosInterface.errStr(
-                    self._connection._conn))
+                    self._result ))
 
     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.

src/connector/python/linux/python3/test.py

+from taos.cinterface import CTaosInterface
+from taos.error import *
+from taos.subscription import TDengineSubscription
+from taos.connection import TDengineConnection
+
+
+if __name__ == '__main__':
+    conn = TDengineConnection(
+        host="127.0.0.1", user="root", password="taosdata", database="test")
+
+    # Generate a cursor object to run SQL commands
+    sub = conn.subscribe(False, "test", "select * from log0601;", 1000)
+
+    for i in range(100):
+        print(i)
+        data = sub.consume()
+        for d in data:
+            print(d)
+
+    sub.close()
+    conn.close()

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

@@ -142,12 +142,14 @@ class CTaosInterface(object):
     libtaos.taos_fetch_fields.restype = ctypes.POINTER(TaosField)
     libtaos.taos_init.restype = None
     libtaos.taos_connect.restype = ctypes.c_void_p
-    libtaos.taos_use_result.restype = ctypes.c_void_p
+    #libtaos.taos_use_result.restype = ctypes.c_void_p
     libtaos.taos_fetch_row.restype = ctypes.POINTER(ctypes.c_void_p)
     libtaos.taos_errstr.restype = ctypes.c_char_p
     libtaos.taos_subscribe.restype = ctypes.c_void_p
     libtaos.taos_consume.restype = ctypes.c_void_p
     libtaos.taos_fetch_lengths.restype = ctypes.c_void_p
+    libtaos.taos_free_result.restype = None
+    libtaos.taos_errno.restype = ctypes.c_int
 
     def __init__(self, config=None):
         '''
@@ -251,10 +253,10 @@ class CTaosInterface(object):
         #     CTaosInterface.libtaos.close(connection)
 
     @staticmethod
-    def affectedRows(connection):
+    def affectedRows(result):
         """The affected rows after runing query
         """
-        return CTaosInterface.libtaos.taos_affected_rows(connection)
+        return CTaosInterface.libtaos.taos_affected_rows(result)
 
     @staticmethod
     def subscribe(connection, restart, topic, sql, interval):
@@ -292,18 +294,17 @@ class CTaosInterface(object):
         CTaosInterface.libtaos.taos_unsubscribe(sub, 1 if keepProgress else 0)
 
     @staticmethod
-    def useResult(connection):
+    def useResult(result):
         '''Use result after calling self.query
         '''
-        result = ctypes.c_void_p(CTaosInterface.libtaos.taos_use_result(connection))
         fields = []
         pfields = CTaosInterface.fetchFields(result)
-        for i in range(CTaosInterface.fieldsCount(connection)):
+        for i in range(CTaosInterface.fieldsCount(result)):
             fields.append({'name': pfields[i].name.decode('utf-8'),
                            'bytes': pfields[i].bytes,
                            'type': ord(pfields[i].type)})
 
-        return result, fields
+        return fields
 
     @staticmethod
     def fetchBlock(result, fields):
@@ -337,8 +338,8 @@ class CTaosInterface(object):
         result.value = None
 
     @staticmethod
-    def fieldsCount(connection):
-        return CTaosInterface.libtaos.taos_field_count(connection)
+    def fieldsCount(result):
+        return CTaosInterface.libtaos.taos_field_count(result)
 
     @staticmethod
     def fetchFields(result):
@@ -386,29 +387,30 @@ class CTaosInterface(object):
     #         return (ctypes.cast(data,  ctypes.c_char_p).value).rstrip('\x00')
 
     @staticmethod
-    def errno(connection):
+    def errno(result):
         """Return the error number.
         """
-        return CTaosInterface.libtaos.taos_errno(connection)
+        return CTaosInterface.libtaos.taos_errno(result)
 
     @staticmethod
-    def errStr(connection):
+    def errStr(result):
         """Return the error styring
         """
-        return CTaosInterface.libtaos.taos_errstr(connection)
+        return CTaosInterface.libtaos.taos_errstr(result)
 
 
 if __name__ == '__main__':
     cinter = CTaosInterface()
     conn = cinter.connect()
+    result = cinter.query(conn, 'show databases')
 
-    print('Query return value: {}'.format(cinter.query(conn, 'show databases')))
-    print('Affected rows: {}'.format(cinter.affectedRows(conn)))
+    print('Query Affected rows: {}'.format(cinter.affectedRows(result)))
 
-    result, des = CTaosInterface.useResult(conn)
+    fields = CTaosInterface.useResult(result)
 
-    data, num_of_rows = CTaosInterface.fetchBlock(result, des)
+    data, num_of_rows = CTaosInterface.fetchBlock(result, fields)
 
     print(data)
 
+    cinter.freeresult(result)
     cinter.close(conn)
\ No newline at end of file

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

@@ -79,9 +79,7 @@ class TDengineConnection(object):
     def clear_result_set(self):
         """Clear unused result set on this connection.
         """
-        result = self._chandle.useResult(self._conn)[0]
-        if result:
-            self._chandle.freeResult(result)
+        pass
 
 if __name__ == "__main__":
     conn = TDengineConnection(host='192.168.1.107')

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

@@ -109,16 +109,17 @@ class TDengineCursor(object):
         if params is not None:
             pass
         
-        res = CTaosInterface.query(self._connection._conn, stmt)
-        if res == 0:
-            if CTaosInterface.fieldsCount(self._connection._conn) == 0:
-                self._affected_rows += CTaosInterface.affectedRows(self._connection._conn)
-                return CTaosInterface.affectedRows(self._connection._conn)
+        self._result = CTaosInterface.query(self._connection._conn, stmt)
+        errno = CTaosInterface.libtaos.taos_errno(self._result)
+        if errno == 0:
+            if CTaosInterface.fieldsCount(self._result) == 0:
+                self._affected_rows += CTaosInterface.affectedRows(self._result)
+                return CTaosInterface.affectedRows(self._result )
             else:
-                self._result, self._fields = CTaosInterface.useResult(self._connection._conn)
+                self._fields = CTaosInterface.useResult(self._result)
                 return self._handle_result()
         else:
-            raise ProgrammingError(CTaosInterface.errStr(self._connection._conn))
+            raise ProgrammingError(CTaosInterface.errStr(self._result))
 
     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.

src/connector/python/windows/python3/taos/cinterface.py

@@ -142,12 +142,14 @@ class CTaosInterface(object):
     libtaos.taos_fetch_fields.restype = ctypes.POINTER(TaosField)
     libtaos.taos_init.restype = None
     libtaos.taos_connect.restype = ctypes.c_void_p
-    libtaos.taos_use_result.restype = ctypes.c_void_p
+    #libtaos.taos_use_result.restype = ctypes.c_void_p
     libtaos.taos_fetch_row.restype = ctypes.POINTER(ctypes.c_void_p)
     libtaos.taos_errstr.restype = ctypes.c_char_p
     libtaos.taos_subscribe.restype = ctypes.c_void_p
     libtaos.taos_consume.restype = ctypes.c_void_p
     libtaos.taos_fetch_lengths.restype = ctypes.c_void_p
+    libtaos.taos_free_result.restype = None
+    libtaos.taos_errno.restype = ctypes.c_int
 
     def __init__(self, config=None):
         '''
@@ -251,10 +253,10 @@ class CTaosInterface(object):
         #     CTaosInterface.libtaos.close(connection)
 
     @staticmethod
-    def affectedRows(connection):
+    def affectedRows(result):
         """The affected rows after runing query
         """
-        return CTaosInterface.libtaos.taos_affected_rows(connection)
+        return CTaosInterface.libtaos.taos_affected_rows(result)
 
     @staticmethod
     def subscribe(connection, restart, topic, sql, interval):
@@ -292,18 +294,17 @@ class CTaosInterface(object):
         CTaosInterface.libtaos.taos_unsubscribe(sub, 1 if keepProgress else 0)
 
     @staticmethod
-    def useResult(connection):
+    def useResult(result):
         '''Use result after calling self.query
         '''
-        result = ctypes.c_void_p(CTaosInterface.libtaos.taos_use_result(connection))
         fields = []
         pfields = CTaosInterface.fetchFields(result)
-        for i in range(CTaosInterface.fieldsCount(connection)):
+        for i in range(CTaosInterface.fieldsCount(result)):
             fields.append({'name': pfields[i].name.decode('utf-8'),
                            'bytes': pfields[i].bytes,
                            'type': ord(pfields[i].type)})
 
-        return result, fields
+        return fields
 
     @staticmethod
     def fetchBlock(result, fields):
@@ -337,8 +338,8 @@ class CTaosInterface(object):
         result.value = None
 
     @staticmethod
-    def fieldsCount(connection):
-        return CTaosInterface.libtaos.taos_field_count(connection)
+    def fieldsCount(result):
+        return CTaosInterface.libtaos.taos_field_count(result)
 
     @staticmethod
     def fetchFields(result):
@@ -386,29 +387,30 @@ class CTaosInterface(object):
     #         return (ctypes.cast(data,  ctypes.c_char_p).value).rstrip('\x00')
 
     @staticmethod
-    def errno(connection):
+    def errno(result):
         """Return the error number.
         """
-        return CTaosInterface.libtaos.taos_errno(connection)
+        return CTaosInterface.libtaos.taos_errno(result)
 
     @staticmethod
-    def errStr(connection):
+    def errStr(result):
         """Return the error styring
         """
-        return CTaosInterface.libtaos.taos_errstr(connection).decode('utf-8')
+        return CTaosInterface.libtaos.taos_errstr(result).decode('utf-8')
 
 
 if __name__ == '__main__':
     cinter = CTaosInterface()
     conn = cinter.connect()
+    result = cinter.query(conn, 'show databases')
 
-    print('Query return value: {}'.format(cinter.query(conn, 'show databases')))
-    print('Affected rows: {}'.format(cinter.affectedRows(conn)))
+    print('Query Affected rows: {}'.format(cinter.affectedRows(result)))
 
-    result, des = CTaosInterface.useResult(conn)
+    fields = CTaosInterface.useResult(result)
 
-    data, num_of_rows = CTaosInterface.fetchBlock(result, des)
+    data, num_of_rows = CTaosInterface.fetchBlock(result, fields)
 
     print(data)
 
+    cinter.freeresult(result)
     cinter.close(conn)
\ No newline at end of file

src/connector/python/windows/python3/taos/connection.py

@@ -79,9 +79,7 @@ class TDengineConnection(object):
     def clear_result_set(self):
         """Clear unused result set on this connection.
         """
-        result = self._chandle.useResult(self._conn)[0]
-        if result:
-            self._chandle.freeResult(result)
+        pass
 
 if __name__ == "__main__":
     conn = TDengineConnection(host='192.168.1.107')

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

@@ -109,16 +109,17 @@ class TDengineCursor(object):
         if params is not None:
             pass
         
-        res = CTaosInterface.query(self._connection._conn, stmt)
-        if res == 0:
-            if CTaosInterface.fieldsCount(self._connection._conn) == 0:
-                self._affected_rows += CTaosInterface.affectedRows(self._connection._conn)
-                return CTaosInterface.affectedRows(self._connection._conn)
+        self._result = CTaosInterface.query(self._connection._conn, stmt)
+        errno = CTaosInterface.libtaos.taos_errno(self._result)
+        if errno == 0:
+            if CTaosInterface.fieldsCount(self._result) == 0:
+                self._affected_rows += CTaosInterface.affectedRows(self._result )
+                return CTaosInterface.affectedRows(self._result )
             else:
-                self._result, self._fields = CTaosInterface.useResult(self._connection._conn)
+                self._fields = CTaosInterface.useResult(self._result )
                 return self._handle_result()
         else:
-            raise ProgrammingError(CTaosInterface.errStr(self._connection._conn))
+            raise ProgrammingError(CTaosInterface.errStr(self._result ))
 
     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.

src/dnode/src/dnodeMain.c

@@ -38,6 +38,7 @@ static void dnodeCheckDataDirOpenned(char *dir);
 static SDnodeRunStatus tsDnodeRunStatus = TSDB_DNODE_RUN_STATUS_STOPPED;
 static int32_t dnodeInitComponents();
 static void dnodeCleanupComponents(int32_t stepId);
+static int dnodeCreateDir(const char *dir);
 
 typedef struct {
   const char *const name;
@@ -59,6 +60,16 @@ static const SDnodeComponent tsDnodeComponents[] = {
   {"shell",   dnodeInitShell,      dnodeCleanupShell}
 };
 
+static int dnodeCreateDir(const char *dir) {
+  struct stat dirstat;
+  if (stat(dir, &dirstat) < 0) {
+    if (mkdir(dir, 0755) != 0 && errno != EEXIST) {
+      return -1;
+    } 
+  }
+  return 0;
+}
+
 static void dnodeCleanupComponents(int32_t stepId) {
   for (int32_t i = stepId; i >= 0; i--) {
     tsDnodeComponents[i].cleanup();
@@ -87,9 +98,9 @@ int32_t dnodeInitSystem() {
   taosSetCoreDump();
   signal(SIGPIPE, SIG_IGN);
 
-  struct stat dirstat;
-  if (stat(tsLogDir, &dirstat) < 0) {
-    mkdir(tsLogDir, 0755);
+  if (dnodeCreateDir(tsLogDir) < 0) {
+   printf("failed to create dir: %s, reason: %s\n", tsLogDir, strerror(errno));
+   return -1;
   }
 
   char temp[TSDB_FILENAME_LEN];
@@ -140,7 +151,11 @@ static void dnodeCheckDataDirOpenned(char *dir) {
   char filepath[256] = {0};
   sprintf(filepath, "%s/.running", dir);
 
-  int32_t fd  = open(filepath, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
+  int fd = open(filepath, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO);
+  if (fd < 0) {
+    dError("failed to open lock file:%s, reason: %s, quit", filepath, strerror(errno));
+    exit(0);
+  }
   int32_t ret = flock(fd, LOCK_EX | LOCK_NB);
   if (ret != 0) {
     dError("failed to lock file:%s ret:%d, database may be running, quit", filepath, ret);
@@ -150,16 +165,28 @@ static void dnodeCheckDataDirOpenned(char *dir) {
 }
 
 static int32_t dnodeInitStorage() {
-  struct stat dirstat;
-  if (stat(tsDataDir, &dirstat) < 0) {
-    mkdir(tsDataDir, 0755);
+  if (dnodeCreateDir(tsDataDir) < 0) {
+   dError("failed to create dir: %s, reason: %s", tsDataDir, strerror(errno));
+   return -1;
   }
-
   sprintf(tsMnodeDir, "%s/mnode", tsDataDir);
   sprintf(tsVnodeDir, "%s/vnode", tsDataDir);
   sprintf(tsDnodeDir, "%s/dnode", tsDataDir);
-  mkdir(tsVnodeDir, 0755);
-  mkdir(tsDnodeDir, 0755);
+
+  //TODO(dengyihao): no need to init here 
+  if (dnodeCreateDir(tsMnodeDir) < 0) {
+   dError("failed to create dir: %s, reason: %s", tsMnodeDir, strerror(errno));
+   return -1;
+  } 
+  //TODO(dengyihao): no need to init here
+  if (dnodeCreateDir(tsVnodeDir) < 0) {
+   dError("failed to create dir: %s, reason: %s", tsVnodeDir, strerror(errno));
+   return -1;
+  }
+  if (dnodeCreateDir(tsDnodeDir) < 0) {
+   dError("failed to create dir: %s, reason: %s", tsDnodeDir, strerror(errno));
+   return -1;
+  } 
 
   dnodeCheckDataDirOpenned(tsDnodeDir);
 

src/dnode/src/dnodeShell.c

@@ -40,7 +40,8 @@ int32_t dnodeInitShell() {
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_SUBMIT] = dnodeDispatchToVnodeWriteQueue;
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_QUERY]  = dnodeDispatchToVnodeReadQueue;
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_FETCH]  = dnodeDispatchToVnodeReadQueue;
-
+  dnodeProcessShellMsgFp[TSDB_MSG_TYPE_UPDATE_TAG_VAL] = dnodeDispatchToVnodeWriteQueue;
+  
   // the following message shall be treated as mnode write
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_CREATE_ACCT] = dnodeDispatchToMnodeWriteQueue;
   dnodeProcessShellMsgFp[TSDB_MSG_TYPE_CM_ALTER_ACCT]  = dnodeDispatchToMnodeWriteQueue;

src/inc/taos.h

@@ -88,14 +88,13 @@ int        taos_stmt_execute(TAOS_STMT *stmt);
 TAOS_RES * taos_stmt_use_result(TAOS_STMT *stmt);
 int        taos_stmt_close(TAOS_STMT *stmt);
 
-DLL_EXPORT int taos_query(TAOS *taos, const char *sql);
-DLL_EXPORT TAOS_RES *taos_use_result(TAOS *taos);
+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 *taos);
+DLL_EXPORT int taos_field_count(TAOS_RES *tres);
 DLL_EXPORT int taos_num_fields(TAOS_RES *res);
-DLL_EXPORT int taos_affected_rows(TAOS *taos);
+DLL_EXPORT int taos_affected_rows(TAOS_RES *taos);
 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);
@@ -112,9 +111,9 @@ int* taos_fetch_lengths(TAOS_RES *res);
 // TODO: the return value should be `const`
 DLL_EXPORT char *taos_get_server_info(TAOS *taos);
 DLL_EXPORT char *taos_get_client_info();
-DLL_EXPORT char *taos_errstr(TAOS *taos);
+DLL_EXPORT char *taos_errstr(TAOS_RES *tres);
 
-DLL_EXPORT int taos_errno(TAOS *taos);
+DLL_EXPORT int taos_errno(TAOS_RES *tres);
 
 DLL_EXPORT void taos_query_a(TAOS *taos, const char *sql, void (*fp)(void *param, TAOS_RES *, int code), void *param);
 DLL_EXPORT void taos_fetch_rows_a(TAOS_RES *res, void (*fp)(void *param, TAOS_RES *, int numOfRows), void *param);

src/inc/taosdef.h

@@ -323,7 +323,7 @@ void tsDataSwap(void *pLeft, void *pRight, int32_t type, int32_t size);
 #define TSDB_QUERY_TYPE_SUBQUERY                       0x02u
 #define TSDB_QUERY_TYPE_STABLE_SUBQUERY                0x04u     // two-stage subquery for super table
 
-#define TSDB_QUERY_TYPE_TABLE_QUERY                    0x08u     // query ordinary table; below only apply to client side
+#define TSDB_QUERY_TYPE_TABLE_QUERY                    0x08u    // query ordinary table; below only apply to client side
 #define TSDB_QUERY_TYPE_STABLE_QUERY                   0x10u    // query on super table
 #define TSDB_QUERY_TYPE_JOIN_QUERY                     0x20u    // join query
 #define TSDB_QUERY_TYPE_PROJECTION_QUERY               0x40u    // select *,columns... query

src/inc/taoserror.h

@@ -92,16 +92,15 @@ TAOS_DEFINE_ERROR(TSDB_CODE_NO_USER_FROM_CONN,          0, 0x0185, "can not get
 // table
 TAOS_DEFINE_ERROR(TSDB_CODE_TABLE_ALREADY_EXIST,        0, 0x0200, "table already exist")
 TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TABLE_ID,           0, 0x0201, "invalid table id")
-TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TABLE_TYPE,         0, 0x0202, "invalid table typee")
+TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_TABLE_TYPE,         0, 0x0202, "invalid table type")
 TAOS_DEFINE_ERROR(TSDB_CODE_NOT_SUPER_TABLE,            0, 0x0203, "no super table")           // operation only available for super table
 TAOS_DEFINE_ERROR(TSDB_CODE_TAG_ALREAY_EXIST,           0, 0x0204, "tag already exist")
 TAOS_DEFINE_ERROR(TSDB_CODE_TAG_NOT_EXIST,              0, 0x0205, "tag not exist")
 TAOS_DEFINE_ERROR(TSDB_CODE_FIELD_ALREAY_EXIST,         0, 0x0206, "field already exist")
 TAOS_DEFINE_ERROR(TSDB_CODE_FIELD_NOT_EXIST,            0, 0x0207, "field not exist")
-TAOS_DEFINE_ERROR(TSDB_CODE_COL_NAME_TOO_LONG,          0, 0x0209, "column name too long")
+TAOS_DEFINE_ERROR(TSDB_CODE_COL_NAME_TOO_LONG,          0, 0x0208, "column name too long")
 TAOS_DEFINE_ERROR(TSDB_CODE_TOO_MANY_TAGS,              0, 0x0209, "too many tags")
 
-
 // dnode & mnode
 TAOS_DEFINE_ERROR(TSDB_CODE_NO_ENOUGH_DNODES,           0, 0x0280, "no enough dnodes")
 TAOS_DEFINE_ERROR(TSDB_CODE_DNODE_ALREADY_EXIST,        0, 0x0281, "dnode already exist")
@@ -173,6 +172,8 @@ TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_FILE_FORMAT,        0, 0x0500, "invalid file
 
 // TSDB
 TAOS_DEFINE_ERROR(TSDB_CODE_INVALID_CONFIG,             0, 0x0580, "invalid TSDB configuration")
+TAOS_DEFINE_ERROR(TSDB_CODE_TAG_VER_OUT_OF_DATE,        0, 0x0581, "tag version is out of date")
+TAOS_DEFINE_ERROR(TSDB_CODE_TABLE_SCHEMA_VERSION,       0, 0x0582, "invalid table schema version from client")
 
 
 #ifdef TAOS_ERROR_C

src/inc/taosmsg.h

@@ -43,7 +43,7 @@ enum {
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_SUBMIT, "submit" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_QUERY, "query" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_FETCH, "fetch" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY0, "dummy0" )
+TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_UPDATE_TAG_VAL, "update-tag-val" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY1, "dummy1" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY2, "dummy2" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_DUMMY3, "dummy3" )
@@ -277,6 +277,18 @@ typedef struct {
   // char    tagVal[];
 } SCMAlterTableMsg;
 
+typedef struct {
+  SMsgHead  head;
+  int64_t   uid;
+  int32_t   tid;
+  int16_t   tversion;
+  int16_t   colId;
+  int16_t   type;
+  int16_t   bytes;
+  int32_t   tagValLen;
+  char      data[];
+} SUpdateTableTagValMsg;
+
 typedef struct {
   char clientVersion[TSDB_VERSION_LEN];
   char msgVersion[TSDB_VERSION_LEN];

src/inc/tsdb.h

@@ -45,6 +45,7 @@ typedef struct {
   int (*eventCallBack)(void *);
   void *(*cqCreateFunc)(void *handle, int sid, char *sqlStr, STSchema *pSchema);
   void (*cqDropFunc)(void *handle);
+  void *(*configFunc)(int32_t vgId, int32_t sid);
 } STsdbAppH;
 
 // --------- TSDB REPOSITORY CONFIGURATION DEFINITION
@@ -108,13 +109,14 @@ int  tsdbTableSetSName(STableCfg *config, char *sname, bool dup);
 int  tsdbTableSetStreamSql(STableCfg *config, char *sql, bool dup);
 void tsdbClearTableCfg(STableCfg *config);
 
-int32_t    tsdbGetTableTagVal(TsdbRepoT *repo, STableId *id, int32_t colId, int16_t *type, int16_t *bytes, char **val);
-char *     tsdbGetTableName(TsdbRepoT *repo, const STableId *id, int16_t *bytes);
+void* tsdbGetTableTagVal(TsdbRepoT* repo, const STableId* id, int32_t colId, int16_t type, int16_t bytes);
+char* tsdbGetTableName(TsdbRepoT *repo, const STableId *id);
 STableCfg *tsdbCreateTableCfgFromMsg(SMDCreateTableMsg *pMsg);
 
 int   tsdbCreateTable(TsdbRepoT *repo, STableCfg *pCfg);
 int   tsdbDropTable(TsdbRepoT *pRepo, STableId tableId);
 int   tsdbAlterTable(TsdbRepoT *repo, STableCfg *pCfg);
+int   tsdbUpdateTagValue(TsdbRepoT *repo, SUpdateTableTagValMsg *pMsg);
 TSKEY tsdbGetTableLastKey(TsdbRepoT *repo, uint64_t uid);
 
 uint32_t tsdbGetFileInfo(TsdbRepoT *repo, char *name, uint32_t *index, uint32_t eindex, int32_t *size);

src/kit/shell/src/shellEngine.c

@@ -275,22 +275,28 @@ void shellRunCommandOnServer(TAOS *con, char command[]) {
 
   st = taosGetTimestampUs();
 
-  if (taos_query(con, command)) {
-    taos_error(con);
+  TAOS_RES* pSql = taos_query(con, command);
+  if (taos_errno(pSql)) {
+    taos_error(pSql);
     return;
   }
 
   if (regex_match(command, "^\\s*use\\s+[a-zA-Z0-9_]+\\s*;\\s*$", REG_EXTENDED | REG_ICASE)) {
     fprintf(stdout, "Database changed.\n\n");
     fflush(stdout);
+    
+    taos_free_result(pSql);
     return;
   }
 
-  int num_fields = taos_field_count(con);
+  int num_fields = taos_field_count(pSql);
   if (num_fields != 0) {  // select and show kinds of commands
     int error_no = 0;
-    int numOfRows = shellDumpResult(con, fname, &error_no, printMode);
-    if (numOfRows < 0) return;
+    int numOfRows = shellDumpResult(pSql, fname, &error_no, printMode);
+    if (numOfRows < 0) {
+      taos_free_result(pSql);
+      return;
+    }
 
     et = taosGetTimestampUs();
     if (error_no == 0) {
@@ -299,7 +305,7 @@ void shellRunCommandOnServer(TAOS *con, char command[]) {
       printf("Query interrupted (%s), %d row(s) in set (%.6fs)\n", taos_errstr(con), numOfRows, (et - st) / 1E6);
     }
   } else {
-    int num_rows_affacted = taos_affected_rows(con);
+    int num_rows_affacted = taos_affected_rows(pSql);
     et = taosGetTimestampUs();
     printf("Query OK, %d row(s) affected (%.6fs)\n", num_rows_affacted, (et - st) / 1E6);
   }
@@ -309,6 +315,8 @@ void shellRunCommandOnServer(TAOS *con, char command[]) {
   if (fname != NULL) {
     wordfree(&full_path);
   }
+  
+  taos_free_result(pSql);
 }
 
 /* Function to do regular expression check */
@@ -461,6 +469,7 @@ static int dumpResultToFile(const char* fname, TAOS_RES* result) {
   } while( row != NULL);
 
   fclose(fp);
+  taos_free_result(result);
   return numOfRows;
 }
 
@@ -548,15 +557,15 @@ static void printField(const char* val, TAOS_FIELD* field, int width, int32_t le
 }
 
 
-static int verticalPrintResult(TAOS_RES* result) {
-  TAOS_ROW row = taos_fetch_row(result);
+static int verticalPrintResult(TAOS_RES* tres) {
+  TAOS_ROW row = taos_fetch_row(tres);
   if (row == NULL) {
     return 0;
   }
 
-  int num_fields = taos_num_fields(result);
-  TAOS_FIELD *fields = taos_fetch_fields(result);
-  int precision = taos_result_precision(result);
+  int num_fields = taos_num_fields(tres);
+  TAOS_FIELD *fields = taos_fetch_fields(tres);
+  int precision = taos_result_precision(tres);
 
   int maxColNameLen = 0;
   for (int col = 0; col < num_fields; col++) {
@@ -569,7 +578,7 @@ static int verticalPrintResult(TAOS_RES* result) {
   int numOfRows = 0;
   do {
     printf("*************************** %d.row ***************************\n", numOfRows + 1);
-    int32_t* length = taos_fetch_lengths(result);
+    int32_t* length = taos_fetch_lengths(tres);
     for (int i = 0; i < num_fields; i++) {
       TAOS_FIELD* field = fields + i;
 
@@ -581,7 +590,7 @@ static int verticalPrintResult(TAOS_RES* result) {
     }
 
     numOfRows++;
-    row = taos_fetch_row(result);
+    row = taos_fetch_row(tres);
   } while(row != NULL);
 
   return numOfRows;
@@ -656,15 +665,15 @@ static void printHeader(TAOS_FIELD* fields, int* width, int num_fields) {
 }
 
 
-static int horizontalPrintResult(TAOS_RES* result) {
-  TAOS_ROW row = taos_fetch_row(result);
+static int horizontalPrintResult(TAOS_RES* tres) {
+  TAOS_ROW row = taos_fetch_row(tres);
   if (row == NULL) {
     return 0;
   }
 
-  int num_fields = taos_num_fields(result);
-  TAOS_FIELD *fields = taos_fetch_fields(result);
-  int precision = taos_result_precision(result);
+  int num_fields = taos_num_fields(tres);
+  TAOS_FIELD *fields = taos_fetch_fields(tres);
+  int precision = taos_result_precision(tres);
 
   int width[TSDB_MAX_COLUMNS];
   for (int col = 0; col < num_fields; col++) {
@@ -675,7 +684,7 @@ static int horizontalPrintResult(TAOS_RES* result) {
 
   int numOfRows = 0;
   do {
-    int32_t* length = taos_fetch_lengths(result);
+    int32_t* length = taos_fetch_lengths(tres);
     for (int i = 0; i < num_fields; i++) {
       putchar(' ');
       printField(row[i], fields + i, width[i], length[i], precision);
@@ -684,32 +693,24 @@ static int horizontalPrintResult(TAOS_RES* result) {
     }
     putchar('\n');
     numOfRows++;
-    row = taos_fetch_row(result);
+    row = taos_fetch_row(tres);
   } while(row != NULL);
 
   return numOfRows;
 }
 
 
-int shellDumpResult(TAOS *con, char *fname, int *error_no, bool vertical) {
+int shellDumpResult(TAOS_RES *tres, char *fname, int *error_no, bool vertical) {
   int numOfRows = 0;
-
-  TAOS_RES* result = taos_use_result(con);
-  if (result == NULL) {
-    taos_error(con);
-    return -1;
-  }
-
   if (fname != NULL) {
-    numOfRows = dumpResultToFile(fname, result);
+    numOfRows = dumpResultToFile(fname, tres);
   } else if(vertical) {
-    numOfRows = verticalPrintResult(result);
+    numOfRows = verticalPrintResult(tres);
   } else {
-    numOfRows = horizontalPrintResult(result);
+    numOfRows = horizontalPrintResult(tres);
   }
 
-  *error_no = taos_errno(con);
-  taos_free_result(result);
+  *error_no = taos_errno(tres);
   return numOfRows;
 }
 
@@ -771,12 +772,11 @@ void write_history() {
   fclose(f);
 }
 
-void taos_error(TAOS *con) {
-  fprintf(stderr, "\nDB error: %s\n", taos_errstr(con));
+void taos_error(TAOS_RES *tres) {
+  fprintf(stderr, "\nDB error: %s\n", taos_errstr(tres));
 
   /* free local resouce: allocated memory/metric-meta refcnt */
-  TAOS_RES *pRes = taos_use_result(con);
-  taos_free_result(pRes);
+  taos_free_result(tres);
 }
 
 int isCommentLine(char *line) {
@@ -858,8 +858,9 @@ void shellGetGrantInfo(void *con) {
 
   char sql[] = "show grants";
 
-  int code = taos_query(con, sql);
-
+  TAOS_RES* pSql = taos_query(con, sql);
+  int code = taos_errno(pSql);
+  
   if (code != TSDB_CODE_SUCCESS) {
     if (code == TSDB_CODE_OPS_NOT_SUPPORT) {
       fprintf(stdout, "Server is Community Edition, version is %s\n\n", taos_get_server_info(con));
@@ -869,12 +870,11 @@ void shellGetGrantInfo(void *con) {
     return;
   }
 
-  int num_fields = taos_field_count(con);
+  int num_fields = taos_field_count(result);
   if (num_fields == 0) {
     fprintf(stderr, "\nInvalid grant information.\n");
     exit(0);
   } else {
-    result = taos_use_result(con);
     if (result == NULL) {
       fprintf(stderr, "\nGrant information is null.\n");
       exit(0);

src/kit/shell/src/shellImport.c

@@ -192,11 +192,14 @@ static void shellSourceFile(TAOS *con, char *fptr) {
     }
 
     memcpy(cmd + cmd_len, line, read_len);
-    if (taos_query(con, cmd)) {
+    
+    TAOS_RES* pSql = taos_query(con, cmd);
+    int32_t code = taos_errno(pSql);
+    
+    if (code != 0) {
       fprintf(stderr, "DB error: %s: %s (%d)\n", taos_errstr(con), fname, lineNo);
       /* free local resouce: allocated memory/metric-meta refcnt */
-      TAOS_RES *pRes = taos_use_result(con);
-      taos_free_result(pRes);
+      taos_free_result(pSql);
     }
 
     memset(cmd, 0, MAX_COMMAND_SIZE);

src/kit/shell/src/shellMain.c

@@ -18,21 +18,21 @@
 #include "tsclient.h"
 #include "tutil.h"
 
-TAOS*     con;
+TAOS_RES* con;
 pthread_t pid;
 
 // TODO: IMPLEMENT INTERRUPT HANDLER.
 void interruptHandler(int signum) {
 #ifdef LINUX
-  TAOS_RES* res = taos_use_result(con);
-  taos_stop_query(res);
-  if (res != NULL) {
+  taos_stop_query(con);
+  if (con != NULL) {
     /*
      * we need to free result in async model, in order to avoid free
      * results while the master thread is waiting for server response.
      */
-    tscQueueAsyncFreeResult(res);
+    tscQueueAsyncFreeResult(con);
   }
+  
   result = NULL;
 #else
   printf("\nReceive ctrl+c or other signal, quit shell.\n");
@@ -90,7 +90,6 @@ int main(int argc, char* argv[]) {
   /* Initialize the shell */
   con = shellInit(&args);
   if (con == NULL) {
-    taos_error(con);
     exit(EXIT_FAILURE);
   }
 

src/kit/taosdemo/taosdemo.c

@@ -461,8 +461,7 @@ int main(int argc, char *argv[]) {
   taos_init();
   TAOS *taos = taos_connect(ip_addr, user, pass, NULL, port);
   if (taos == NULL) {
-    fprintf(stderr, "Failed to connect to TDengine, reason:%s\n", taos_errstr(taos));
-    taos_close(taos);
+    fprintf(stderr, "Failed to connect to TDengine, reason:%s\n", taos_errstr(NULL));
     return 1;
   }
   char command[BUFFER_SIZE] = "\0";
@@ -708,27 +707,24 @@ void *readTable(void *sarg) {
       sprintf(command, "select %s from %s%d where ts>= %" PRId64, aggreFunc[j], tb_prefix, i, sTime);
 
       double t = getCurrentTime();
-      if (taos_query(taos, command) != 0) {
-        fprintf(stderr, "Failed to query\n");
-        taos_close(taos);
-        exit(EXIT_FAILURE);
-      }
+      TAOS_RES *pSql = taos_query(taos, command);
+      int32_t code = taos_errno(pSql);
 
-      TAOS_RES *result = taos_use_result(taos);
-      if (result == NULL) {
-        fprintf(stderr, "Failed to retreive results:%s\n", taos_errstr(taos));
+      if (code != 0) {
+        fprintf(stderr, "Failed to query:%s\n", taos_errstr(taos));
+        taos_free_result(pSql);
         taos_close(taos);
-        exit(1);
+        exit(EXIT_FAILURE);
       }
 
-      while (taos_fetch_row(result) != NULL) {
+      while (taos_fetch_row(pSql) != NULL) {
         count++;
       }
 
       t = getCurrentTime() - t;
       totalT += t;
 
-      taos_free_result(result);
+      taos_free_result(pSql);
     }
 
     fprintf(fp, "|%10s  |   %10d   |  %12.2f   |   %10.2f  |\n",
@@ -779,20 +775,18 @@ void *readMetric(void *sarg) {
       fprintf(fp, "%s\n", command);
 
       double t = getCurrentTime();
-      if (taos_query(taos, command) != 0) {
-        fprintf(stderr, "Failed to query\n");
-        taos_close(taos);
-        exit(EXIT_FAILURE);
-      }
 
-      TAOS_RES *result = taos_use_result(taos);
-      if (result == NULL) {
-        fprintf(stderr, "Failed to retreive results:%s\n", taos_errstr(taos));
+      TAOS_RES *pSql = taos_query(taos, command);
+      int32_t code = taos_errno(pSql);
+
+      if (code != 0) {
+        fprintf(stderr, "Failed to query:%s\n", taos_errstr(taos));
+        taos_free_result(pSql);
         taos_close(taos);
         exit(1);
       }
       int count = 0;
-      while (taos_fetch_row(result) != NULL) {
+      while (taos_fetch_row(pSql) != NULL) {
         count++;
       }
       t = getCurrentTime() - t;
@@ -800,7 +794,7 @@ void *readMetric(void *sarg) {
       fprintf(fp, "| Speed: %12.2f(per s) | Latency: %.4f(ms) |\n", num_of_tables * num_of_DPT / t, t * 1000);
       printf("select %10s took %.6f second(s)\n\n", aggreFunc[j], t);
 
-      taos_free_result(result);
+      taos_free_result(pSql);
     }
     fprintf(fp, "\n");
   }
@@ -811,10 +805,19 @@ void *readMetric(void *sarg) {
 
 void queryDB(TAOS *taos, char *command) {
   int i = 5;
-  while (i > 0) {
-    if (taos_query(taos, command) == 0) break;
+  TAOS_RES *pSql = NULL;
+  int32_t code = -1;
+  while (i > 0 && code != 0) {
+    pSql = taos_query(taos, command);
+    code = taos_errno(pSql);
+    taos_free_result(pSql);
+    pSql = NULL;
+    if (code == 0) {
+      break;
+    }
     i--; 
   }
+
   if (i == 0) {
     fprintf(stderr, "Failed to run %s, reason: %s\n", command, taos_errstr(taos));
     taos_close(taos);
@@ -947,6 +950,7 @@ void callBack(void *param, TAOS_RES *res, int code) {
       break;
     }
   }
+   tb_info->timestamp = tmp_time;
 
   taos_query_a(tb_info->taos, buffer, callBack, tb_info);
 

src/kit/taosdump/taosdump.c

@@ -372,14 +372,12 @@ int taosGetTableRecordInfo(char *table, STableRecordInfo *pTableRecordInfo) {
   memset(pTableRecordInfo, 0, sizeof(STableRecordInfo));
 
   sprintf(command, "show tables like %s", table);
-  if (taos_query(taos, command) != 0) {
-    fprintf(stderr, "failed to run command %s\n", command);
-    return -1;
-  }
+  TAOS_RES *result = taos_query(taos, command);\
+  int32_t code = taos_errno(result);
 
-  result = taos_use_result(taos);
-  if (result == NULL) {
-    fprintf(stderr, "failed to use result\n");
+  if (code != 0) {
+    fprintf(stderr, "failed to run command %s, error: %s\n", command, taos_errstr(result));
+    taos_free_result(result);
     return -1;
   }
 
@@ -400,14 +398,12 @@ int taosGetTableRecordInfo(char *table, STableRecordInfo *pTableRecordInfo) {
   if (isSet) return 0;
 
   sprintf(command, "show stables like %s", table);
-  if (taos_query(taos, command) != 0) {
-    fprintf(stderr, "failed to run command %s\n", command);
-    return -1;
-  }
 
-  result = taos_use_result(taos);
-  if (result == NULL) {
-    fprintf(stderr, "failed to use result\n");
+  result = taos_query(taos, command);
+  code = taos_errno(result);
+  if (code != 0) {
+    fprintf(stderr, "failed to run command %s, error: %s\n", command, taos_errstr(result));
+    taos_free_result(result);
     return -1;
   }
 
@@ -467,14 +463,11 @@ int taosDumpOut(SDumpArguments *arguments) {
   taosDumpCharset(fp);
 
   sprintf(command, "show databases");
-  if (taos_query(taos, command) != 0) {
+  result = taos_query(taos, command);
+  int32_t code = taos_errno(result);
+  if (code != 0) {
     fprintf(stderr, "failed to run command: %s, reason: %s\n", command, taos_errstr(taos));
-    goto _exit_failure;
-  }
-
-  result = taos_use_result(taos);
-  if (result == NULL) {
-    fprintf(stderr, "failed to use result\n");
+    taos_free_result(result);
     goto _exit_failure;
   }
 
@@ -551,7 +544,7 @@ int taosDumpOut(SDumpArguments *arguments) {
       taosDumpCreateDbClause(dbInfos[0], arguments->with_property, fp);
 
       sprintf(command, "use %s", dbInfos[0]->name);
-      if (taos_query(taos, command) != 0) {
+      if (taos_query(taos, command) == NULL ) {
         fprintf(stderr, "invalid database %s\n", dbInfos[0]->name);
         goto _exit_failure;
       }
@@ -612,7 +605,7 @@ int taosDumpDb(SDbInfo *dbInfo, SDumpArguments *arguments, FILE *fp) {
   taosDumpCreateDbClause(dbInfo, arguments->with_property, fp);
 
   sprintf(command, "use %s", dbInfo->name);
-  if (taos_query(taos, command) != 0) {
+  if (taos_errno(taos_query(taos, command)) != 0) {
     fprintf(stderr, "invalid database %s\n", dbInfo->name);
     return -1;
   }
@@ -620,14 +613,11 @@ int taosDumpDb(SDbInfo *dbInfo, SDumpArguments *arguments, FILE *fp) {
   fprintf(fp, "USE %s\n\n", dbInfo->name);
 
   sprintf(command, "show tables");
-  if (taos_query(taos, command) != 0) {
-    fprintf(stderr, "failed to run command %s\n", command);
-    return -1;
-  }
-
-  result = taos_use_result(taos);
-  if (result == NULL) {
-    fprintf(stderr, "failed to use result\n");
+  result = taos_query(taos,command);
+  int32_t code = taos_errno(result);
+  if (code != 0) {
+    fprintf(stderr, "failed to run command %s, error: %s\n", command, taos_errstr(result));
+    taos_free_result(result);
     return -1;
   }
 
@@ -725,14 +715,11 @@ void taosDumpCreateMTableClause(STableDef *tableDes, char *metric, int numOfCols
     TAOS_ROW row = NULL;
 
     sprintf(command, "select %s from %s limit 1", tableDes->cols[counter].field, tableDes->name);
-    if (taos_query(taos, command) != 0) {
-      fprintf(stderr, "failed to run command %s\n", command);
-      return;
-    }
 
-    result = taos_use_result(taos);
-    if (result == NULL) {
-      fprintf(stderr, "failed to use result\n");
+    result = taos_query(taos, command);
+    int32_t code = taos_errno(result);
+    if (code != 0) {
+      fprintf(stderr, "failed to run command %s, error: %s\n", command, taos_errstr(result));
       return;
     }
 
@@ -806,14 +793,12 @@ int taosGetTableDes(char *table, STableDef *tableDes) {
   int count = 0;
 
   sprintf(command, "describe %s", table);
-  if (taos_query(taos, command) != 0) {
-    fprintf(stderr, "failed to run command %s\n", command);
-    return -1;
-  }
 
-  result = taos_use_result(taos);
-  if (result == NULL) {
-    fprintf(stderr, "failed to use result\n");
+  result = taos_query(taos, command);
+  int32_t code = taos_errno(result);
+  if (code != 0) {
+    fprintf(stderr, "failed to run command %s, error: %s\n", command, taos_errstr(result));
+    taos_free_result(result);
     return -1;
   }
 
@@ -889,14 +874,11 @@ int32_t taosDumpMetric(char *metric, SDumpArguments *arguments, FILE *fp) {
   strcpy(tableRecord.metric, metric);
 
   sprintf(command, "select tbname from %s", metric);
-  if (taos_query(taos, command) != 0) {
-    fprintf(stderr, "failed to run command %s\n", command);
-    return -1;
-  }
-
-  result = taos_use_result(taos);
-  if (result == NULL) {
-    fprintf(stderr, "failed to use result\n");
+  result = taos_query(taos, command);
+  int32_t code = taos_errno(result);
+  if (code != 0) {
+    fprintf(stderr, "failed to run command %s, error: %s\n", command, taos_errstr(result));
+    taos_free_result(result);
     return -1;
   }
 
@@ -942,18 +924,16 @@ int taosDumpTableData(FILE *fp, char *tbname, SDumpArguments *arguments) {
 
   sprintf(command, "select * from %s where _c0 >= %" PRId64 " and _c0 <= %" PRId64 " order by _c0 asc", tbname, arguments->start_time,
           arguments->end_time);
-  if (taos_query(taos, command) != 0) {
-    fprintf(stderr, "failed to run command %s, reason: %s\n", command, taos_errstr(taos));
-    return -1;
-  }
-
-  result = taos_use_result(taos);
-  if (result == NULL) {
-    fprintf(stderr, "failed to use result\n");
+          
+  result = taos_query(taos, command);
+  int32_t code = taos_errno(result);
+  if (code != 0) {
+    fprintf(stderr, "failed to run command %s, reason: %s\n", command, taos_errstr(result));
+    taos_free_result(result);
     return -1;
   }
 
-  numFields = taos_field_count(taos);
+  numFields = taos_field_count(result);
   assert(numFields > 0);
   TAOS_FIELD *fields = taos_fetch_fields(result);
   tbuf = (char *)malloc(COMMAND_SIZE);
@@ -1194,7 +1174,7 @@ int taosDumpIn(SDumpArguments *arguments) {
           tcommand = command;
         }
         taosReplaceCtrlChar(tcommand);
-        if (taos_query(taos, tcommand) != 0)
+        if (taos_query(taos, tcommand) == NULL)
           fprintf(stderr, "linenu: %" PRId64 " failed to run command %s reason:%s \ncontinue...\n", linenu, command,
                   taos_errstr(taos));
 
@@ -1242,9 +1222,14 @@ int taosDumpIn(SDumpArguments *arguments) {
         tcommand = command;
       }
       taosReplaceCtrlChar(tcommand);
-      if (taos_query(taos, tcommand) != 0)
+      result = taos_query(taos, tcommand);
+      int32_t code = taos_errno(result);
+      if (code != 0) 
+      {
         fprintf(stderr, "linenu:%" PRId64 " failed to run command %s reason: %s \ncontinue...\n", linenu, command,
                 taos_errstr(taos));
+      }
+      taos_free_result(result);
     }
 
     pstr = command;
@@ -1265,7 +1250,7 @@ int taosDumpIn(SDumpArguments *arguments) {
       tcommand = command;
     }
     taosReplaceCtrlChar(lcommand);
-    if (taos_query(taos, tcommand) != 0)
+    if (taos_query(taos, tcommand) == NULL)
       fprintf(stderr, "linenu:%" PRId64 " failed to run command %s reason:%s \ncontinue...\n", linenu, command,
               taos_errstr(taos));
   }

src/kit/taosnetwork/client.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <arpa/inet.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#define BUFFER_SIZE 200
+
+typedef struct {
+  int   port;
+  char *host[15];
+} info;
+
+void *checkPort(void *sarg) {
+  info *pinfo = (info *)sarg;
+  int   port = pinfo->port;
+  char *host = *pinfo->host;
+  int   clientSocket;
+
+  struct sockaddr_in serverAddr;
+  char               sendbuf[BUFFER_SIZE];
+  char               recvbuf[BUFFER_SIZE];
+  int                iDataNum;
+  if ((clientSocket = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
+    perror("socket");
+    return NULL;
+  }
+  serverAddr.sin_family = AF_INET;
+  serverAddr.sin_port = htons(port);
+
+  serverAddr.sin_addr.s_addr = inet_addr(host);
+
+  printf("=================================\n");
+  if (connect(clientSocket, (struct sockaddr *)&serverAddr, sizeof(serverAddr)) < 0) {
+    perror("connect");
+    return NULL;
+  }
+  printf("Connect to: %s:%d...success\n", host, port);
+
+  sprintf(sendbuf, "send port_%d", port);
+  send(clientSocket, sendbuf, strlen(sendbuf), 0);
+  printf("Send msg_%d: %s\n", port, sendbuf);
+
+  recvbuf[0] = '\0';
+  iDataNum = recv(clientSocket, recvbuf, BUFFER_SIZE, 0);
+  recvbuf[iDataNum] = '\0';
+  printf("Read ack msg_%d: %s\n", port, recvbuf);
+
+  printf("=================================\n");
+  close(clientSocket);
+  return NULL;
+}
+
+void *checkUPort(void *sarg) {
+  info *pinfo = (info *)sarg;
+  int   port = pinfo->port;
+  char *host = *pinfo->host;
+  int   clientSocket;
+
+  struct sockaddr_in serverAddr;
+  char               sendbuf[BUFFER_SIZE];
+  char               recvbuf[BUFFER_SIZE];
+  int                iDataNum;
+  if ((clientSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
+    perror("socket");
+    return NULL;
+  }
+  serverAddr.sin_family = AF_INET;
+  serverAddr.sin_port = htons(port);
+
+  serverAddr.sin_addr.s_addr = inet_addr(host);
+
+  printf("=================================\n");
+
+  sprintf(sendbuf, "send msg port_%d by udp", port);
+
+  socklen_t sin_size = sizeof(*(struct sockaddr*)&serverAddr);
+
+  sendto(clientSocket, sendbuf, strlen(sendbuf), 0, (struct sockaddr *)&serverAddr, (int)sin_size);
+
+  printf("Send msg_%d by udp: %s\n", port, sendbuf);
+
+  recvbuf[0] = '\0';
+  iDataNum = recvfrom(clientSocket, recvbuf, BUFFER_SIZE, 0, (struct sockaddr *)&serverAddr, &sin_size);
+  recvbuf[iDataNum] = '\0';
+  printf("Read ack msg_%d from udp: %s\n", port, recvbuf);
+
+  printf("=================================\n");
+  close(clientSocket);
+  return NULL;
+}
+
+int main() {
+  int   port = 6020;
+  char *host = "127.0.0.1";
+  info *tinfo = malloc(sizeof(info));
+  info *uinfo = malloc(sizeof(info));
+
+  for (size_t i = 0; i < 30; i++) {
+    port++;
+    printf("For test: %s:%d\n", host, port);
+
+    *tinfo->host = host;
+    tinfo->port = port;
+    checkPort(tinfo);
+
+    *uinfo->host = host;
+    uinfo->port = port;
+    checkUPort(uinfo);
+  }
+  free(tinfo);
+  free(uinfo);
+}
\ No newline at end of file

src/kit/taosnetwork/server.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <arpa/inet.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#define BUFFER_SIZE 200
+
+typedef struct {
+  int port;
+  int type;  // 0: tcp, 1: udo, default: 0
+} info;
+
+static void *bindPort(void *sarg) {
+  info *pinfo = (info *)sarg;
+  int   port = pinfo->port;
+  int   type = pinfo->type;
+  int   serverSocket;
+
+  struct sockaddr_in server_addr;
+  struct sockaddr_in clientAddr;
+  int                addr_len = sizeof(clientAddr);
+  int                client;
+  char               buffer[BUFFER_SIZE];
+  int                iDataNum;
+
+  if ((serverSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
+    perror("socket");
+    return NULL;
+  }
+
+  bzero(&server_addr, sizeof(server_addr));
+  server_addr.sin_family = AF_INET;
+  server_addr.sin_port = htons(port);
+  server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
+
+  if (bind(serverSocket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
+    perror("connect");
+    return NULL;
+  }
+
+  if (listen(serverSocket, 5) < 0) {
+    perror("listen");
+    return NULL;
+  }
+
+  printf("Bind port: %d success\n", port);
+  while (1) {
+    client = accept(serverSocket, (struct sockaddr *)&clientAddr, (socklen_t *)&addr_len);
+    if (client < 0) {
+      perror("accept");
+      continue;
+    }
+    printf("=================================\n");
+
+    printf("Client ip is %s, Server port is %d\n", inet_ntoa(clientAddr.sin_addr), port);
+    while (1) {
+      buffer[0] = '\0';
+      iDataNum = recv(client, buffer, BUFFER_SIZE, 0);
+
+      if (iDataNum < 0) {
+        perror("recv null");
+        continue;
+      }
+      if (iDataNum > 0) {
+        buffer[iDataNum] = '\0';
+        printf("read msg:%s\n", buffer);
+        if (strcmp(buffer, "quit") == 0) break;
+        buffer[0] = '\0';
+
+        sprintf(buffer, "ack port_%d", port);
+        printf("send ack msg:%s\n", buffer);
+
+        send(client, buffer, strlen(buffer), 0);
+        break;
+      }
+    }
+    printf("=================================\n");
+  }
+  close(serverSocket);
+  return NULL;
+}
+
+static void *bindUPort(void *sarg) {
+  info *pinfo = (info *)sarg;
+  int   port = pinfo->port;
+  int   type = pinfo->type;
+  int   serverSocket;
+
+  struct sockaddr_in server_addr;
+  struct sockaddr_in clientAddr;
+  int                addr_len = sizeof(clientAddr);
+  int                client;
+  char               buffer[BUFFER_SIZE];
+  int                iDataNum;
+
+  if ((serverSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
+    perror("socket");
+    return NULL;
+  }
+
+  bzero(&server_addr, sizeof(server_addr));
+  server_addr.sin_family = AF_INET;
+  server_addr.sin_port = htons(port);
+  server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
+
+  if (bind(serverSocket, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
+    perror("connect");
+    return NULL;
+  }
+
+  socklen_t sin_size;
+  printf("Bind port: %d success\n", port);
+
+  while (1) {
+    buffer[0] = '\0';
+
+    sin_size = sizeof(*(struct sockaddr *)&server_addr);
+
+    iDataNum = recvfrom(serverSocket, buffer, BUFFER_SIZE, 0, (struct sockaddr *)&clientAddr, &sin_size);
+
+    if (iDataNum < 0) {
+      perror("recvfrom null");
+      continue;
+    }
+    if (iDataNum > 0) {
+      printf("=================================\n");
+
+      printf("Client ip is %s, Server port is %d\n", inet_ntoa(clientAddr.sin_addr), port);
+      buffer[iDataNum] = '\0';
+      printf("Read msg from udp:%s\n", buffer);
+      if (strcmp(buffer, "quit") == 0) break;
+      buffer[0] = '\0';
+
+      sprintf(buffer, "ack port_%d by udp", port);
+      printf("Send ack msg by udp:%s\n", buffer);
+
+      sendto(serverSocket, buffer, strlen(buffer), 0, (struct sockaddr *)&clientAddr, (int)sin_size);
+
+      send(client, buffer, strlen(buffer), 0);
+      printf("=================================\n");
+    }
+  }
+
+  close(serverSocket);
+  return NULL;
+}
+
+
+int main() {
+  int        port = 6020;
+  pthread_t *pids = malloc(60 * sizeof(pthread_t));
+  info *     infos = malloc(30 * sizeof(info));
+  info *     uinfos = malloc(30 * sizeof(info));
+
+  for (size_t i = 0; i < 30; i++) {
+    port++;
+
+    info *pinfo = infos++;
+    pinfo->port = port;
+
+    if (pthread_create(pids + i, NULL, bindPort, pinfo) != 0)  //创建线程
+    {                                                          //创建线程失败
+      printf("创建线程失败: %d.\n", port);
+      exit(0);
+    }
+
+    info *uinfo = uinfos++;
+    uinfo->port = port;
+    uinfo->type = 1;
+    if (pthread_create(pids + 30 + i, NULL, bindUPort, uinfo) != 0)  //创建线程
+    {                                                                //创建线程失败
+      printf("创建线程失败: %d.\n", port);
+      exit(0);
+    }
+  }
+  for (int i = 0; i < 30; i++) {
+    pthread_join(pids[i], NULL);
+    pthread_join(pids[(10 + i)], NULL);
+  }
+}

src/kit/taosnetwork/taosnetwork_client.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <netinet/in.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#define SERVER_PORT 8000
+#define SIZE 200
+
+int main() {
+  struct sockaddr_in servaddr, cliaddr;
+  socklen_t          cliaddr_len;
+  int                client_sockfd;
+  char               buf[SIZE];
+  char               recvbuf[SIZE];
+
+  int i, n, flag = 0;
+
+  int len, iDataNum;
+
+  client_sockfd = socket(AF_INET, SOCK_STREAM, 0);
+  bzero(&servaddr, sizeof(servaddr));
+  servaddr.sin_family = AF_INET;
+  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
+  servaddr.sin_port = htons(SERVER_PORT);
+
+  if (connect(client_sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
+    printf("Connected error..\n");
+    return 0;
+  }
+  printf("Connected to server..\n");
+
+  /*循环的发送接收信息并打印接收信息（可以按需发送）--recv返回接收到的字节数，send返回发送的字节数*/
+  while (1) {
+    printf("Enter string to send:");
+    scanf("%s", buf);
+    if (!strcmp(buf, "quit")) {
+      break;
+    }
+    len = (sizeof buf);
+
+    recvbuf[0] = '\0';
+
+    iDataNum = recv(client_sockfd, recvbuf, SIZE, 0);
+
+    recvbuf[iDataNum] = '\0';
+
+    printf("%s\n", recvbuf);
+  }
+  return 0;
+}

src/kit/taosnetwork/taosnetwork_server.c

+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <netinet/in.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#define SERVER_PORT 8000
+#define SIZE 200
+
+int main() {
+  struct sockaddr_in servaddr, cliaddr;
+  socklen_t          cliaddr_len;
+  int                listenfd, connfd;
+  char               buf[BUFSIZ];
+  int                i, n, flag = 0;
+
+  listenfd = socket(AF_INET, SOCK_STREAM, 0);
+  bzero(&servaddr, sizeof(servaddr));
+  servaddr.sin_family = AF_INET;
+  servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
+  servaddr.sin_port = htons(SERVER_PORT);
+  bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
+  listen(listenfd, 20);
+
+  printf("Accepting connections..\n");
+  while (1) {
+    cliaddr_len = sizeof(cliaddr);
+    connfd = accept(listenfd, (struct sockaddr *)&cliaddr,
+                    &cliaddr_len);  //如果得不到客户端发来的消息，将会被阻塞，一直等到消息到来
+    n = read(connfd, buf, SIZE);    //如果n<=0，表示客户端已断开
+    while (1) {
+      if (n != 0) {
+        for (i = 0; i < n; i++) printf("%c", buf[i]);  //输出客户端发来的信息
+      } else {
+        printf("Client say close the connection..\n");
+        break;
+      }
+      n = read(connfd, buf, SIZE);
+    }
+    close(connfd);
+  }
+}

src/kit/taosnetwork/test_client.c

+#include <netinet/in.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+
+#define SERVER_PORT 8888
+#define BUFF_LEN 512
+#define SERVER_IP "172.0.5.182"
+
+void udp_msg_sender(int fd, struct sockaddr* dst) {}
+
+/*
+    client:
+            socket-->sendto-->revcfrom-->close
+*/
+
+int main(int argc, char* argv[]) {
+  int                client_fd;
+  struct sockaddr_in ser_addr;
+
+  client_fd = socket(AF_INET, SOCK_DGRAM, 0);
+  if (client_fd < 0) {
+    printf("create socket fail!\n");
+    return -1;
+  }
+
+  memset(&ser_addr, 0, sizeof(ser_addr));
+  ser_addr.sin_family = AF_INET;
+  // ser_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
+  ser_addr.sin_addr.s_addr = htonl(INADDR_ANY);  //注意网络序转换
+  ser_addr.sin_port = htons(SERVER_PORT);        //注意网络序转换
+
+  socklen_t          len;
+  struct sockaddr_in src;
+  while (1) {
+    char buf[BUFF_LEN] = "TEST UDP MSG!\n";
+    len = sizeof(*(struct sockaddr*)&ser_addr);
+    printf("client:%s\n", buf);  //打印自己发送的信息
+    sendto(client_fd, buf, BUFF_LEN, 0, (struct sockaddr*)&ser_addr, len);
+    memset(buf, 0, BUFF_LEN);
+    recvfrom(client_fd, buf, BUFF_LEN, 0, (struct sockaddr*)&src, &len);  //接收来自server的信息
+    printf("server:%s\n", buf);
+    sleep(1);  //一秒发送一次消息
+  }
+
+  close(client_fd);
+
+  return 0;
+}
\ No newline at end of file

src/kit/taosnetwork/test_server.c

+#include <netinet/in.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+
+#define SERVER_PORT 8888
+#define BUFF_LEN 1024
+
+void handle_udp_msg(int fd) {
+  char      buf[BUFF_LEN];  //接收缓冲区，1024字节
+  socklen_t len;
+  int       count;
+  struct sockaddr_in clent_addr;  // clent_addr用于记录发送方的地址信息
+  while (1) {
+    memset(buf, 0, BUFF_LEN);
+    len = sizeof(clent_addr);
+    count =
+        recvfrom(fd, buf, BUFF_LEN, 0, (struct sockaddr*)&clent_addr, &len);  // recvfrom是拥塞函数，没有数据就一直拥塞
+    if (count == -1) {
+      printf("recieve data fail!\n");
+      return;
+    }
+    printf("client:%s\n", buf);  //打印client发过来的信息
+    memset(buf, 0, BUFF_LEN);
+    sprintf(buf, "I have recieved %d bytes data!\n", count);  //回复client
+    printf("server:%s\n", buf);                               //打印自己发送的信息给
+    sendto(fd, buf, BUFF_LEN, 0, (struct sockaddr*)&clent_addr,
+           len);  //发送信息给client，注意使用了clent_addr结构体指针
+  }
+}
+
+/*
+    server:
+            socket-->bind-->recvfrom-->sendto-->close
+*/
+
+int main(int argc, char* argv[]) {
+  int                server_fd, ret;
+  struct sockaddr_in ser_addr;
+
+  server_fd = socket(AF_INET, SOCK_DGRAM, 0);  // AF_INET:IPV4;SOCK_DGRAM:UDP
+  if (server_fd < 0) {
+    printf("create socket fail!\n");
+    return -1;
+  }
+
+  memset(&ser_addr, 0, sizeof(ser_addr));
+  ser_addr.sin_family = AF_INET;
+  ser_addr.sin_addr.s_addr = htonl(INADDR_ANY);  // IP地址，需要进行网络序转换，INADDR_ANY：本地地址
+  ser_addr.sin_port = htons(SERVER_PORT);        //端口号，需要网络序转换
+
+  ret = bind(server_fd, (struct sockaddr*)&ser_addr, sizeof(ser_addr));
+  if (ret < 0) {
+    printf("socket bind fail!\n");
+    return -1;
+  }
+
+  handle_udp_msg(server_fd);  //处理接收到的数据
+
+  close(server_fd);
+  return 0;
+}
\ No newline at end of file

src/mnode/src/mnodeTable.c

@@ -1352,11 +1352,14 @@ static void *mnodeBuildCreateChildTableMsg(SCMCreateTableMsg *pMsg, SChildTableO
   int32_t tagDataLen = 0;
   int32_t totalCols = 0;
   int32_t contLen = 0;
-  if (pTable->info.type == TSDB_CHILD_TABLE && pMsg != NULL) {
-    pTagData = (STagData*)pMsg->schema;
-    tagDataLen = ntohl(pTagData->dataLen);
+  if (pTable->info.type == TSDB_CHILD_TABLE) {
     totalCols = pTable->superTable->numOfColumns + pTable->superTable->numOfTags;
     contLen = sizeof(SMDCreateTableMsg) + totalCols * sizeof(SSchema) + tagDataLen + pTable->sqlLen;
+    if (pMsg != NULL) {
+      pTagData = (STagData *)pMsg->schema;
+      tagDataLen = ntohl(pTagData->dataLen);
+      contLen += tagDataLen;
+    }
   } else {
     totalCols = pTable->numOfColumns;
     contLen = sizeof(SMDCreateTableMsg) + totalCols * sizeof(SSchema) + pTable->sqlLen;
@@ -1410,7 +1413,7 @@ static void *mnodeBuildCreateChildTableMsg(SCMCreateTableMsg *pMsg, SChildTableO
     memcpy(pCreate->data + totalCols * sizeof(SSchema), pTagData->data, tagDataLen);
   }
 
-  if (pTable->info.type == TSDB_STREAM_TABLE && pMsg != NULL) {
+  if (pTable->info.type == TSDB_STREAM_TABLE) {
     memcpy(pCreate->data + totalCols * sizeof(SSchema), pTable->sql, pTable->sqlLen);
   }
 

src/os/linux/src/linuxSysPara.c

@@ -245,10 +245,10 @@ static void taosGetSystemLocale() {  // get and set default locale
       strncpy(tsCharset, revisedCharset, tListLen(tsCharset));
 
       free(revisedCharset);
-      uError("charset not configured, set to system default:%s", tsCharset);
+      uWarn("charset not configured, set to system default:%s", tsCharset);
     } else {
       strcpy(tsCharset, "UTF-8");
-      uError("can't get locale and charset from system, set it to UTF-8");
+      uWarn("can't get locale and charset from system, set it to UTF-8");
     }
   }
 }

src/plugins/http/src/httpSql.c

@@ -58,10 +58,10 @@ void httpProcessMultiSqlRetrieveCallBack(void *param, TAOS_RES *result, int numO
     if (numOfRows < 0) {
       httpError("context:%p, fd:%d, ip:%s, user:%s, process pos:%d, retrieve failed code:%s, sql:%s",
                 pContext, pContext->fd, pContext->ipstr, pContext->user, multiCmds->pos, tstrerror(numOfRows), sql);
-    } else {
-      taos_free_result(result);
-    }
-
+    } 
+    
+    taos_free_result(result);
+    
     if (singleCmd->cmdReturnType == HTTP_CMD_RETURN_TYPE_WITH_RETURN && encode->stopJsonFp) {
       (encode->stopJsonFp)(pContext, singleCmd);
     }
@@ -103,12 +103,15 @@ void httpProcessMultiSqlCallBack(void *param, TAOS_RES *result, int code) {
     }
     multiCmds->pos++;
     httpProcessMultiSql(pContext);
+
+    taos_free_result(result);
     return;
   }
 
-  if (result == NULL) {
+  int num_fields = taos_field_count(result);
+  if (num_fields == 0) {
     // not select or show commands
-    int affectRows = code;
+    int affectRows = taos_affected_rows(result);
     httpTrace("context:%p, fd:%d, ip:%s, user:%s, process pos:%d, affect rows:%d, sql:%s",
               pContext, pContext->fd, pContext->ipstr, pContext->user, multiCmds->pos, affectRows, sql);
 
@@ -132,6 +135,7 @@ void httpProcessMultiSqlCallBack(void *param, TAOS_RES *result, int code) {
       multiCmds->pos++;
     }
 
+    taos_free_result(result);
     httpProcessMultiSql(pContext);
   } else {
     httpTrace("context:%p, fd:%d, ip:%s, user:%s, process pos:%d, start retrieve, sql:%s",
@@ -212,9 +216,9 @@ void httpProcessSingleSqlRetrieveCallBack(void *param, TAOS_RES *result, int num
     if (numOfRows < 0) {
       httpError("context:%p, fd:%d, ip:%s, user:%s, retrieve failed, code:%s", pContext, pContext->fd, pContext->ipstr,
                 pContext->user, tstrerror(numOfRows));
-    } else {
-      taos_free_result(result);
-    }
+    } 
+    
+    taos_free_result(result);    
 
     if (encode->stopJsonFp) {
       (encode->stopJsonFp)(pContext, &pContext->singleCmd);
@@ -247,12 +251,14 @@ void httpProcessSingleSqlCallBack(void *param, TAOS_RES *result, int code) {
                 pContext, pContext->fd, pContext->ipstr, pContext->user, pContext->session->taos, tstrerror(code), pObj);
       httpSendTaosdErrorResp(pContext, code);
     }
+    taos_free_result(result);
     return;
   }
 
-  if (result == NULL) {
+  int num_fields = taos_field_count(result);
+  if (num_fields == 0) {
     // not select or show commands
-    int affectRows = code;
+    int affectRows = taos_affected_rows(result);
 
     httpTrace("context:%p, fd:%d, ip:%s, user:%s, affect rows:%d, stop query, sqlObj:%p",
               pContext, pContext->fd, pContext->ipstr, pContext->user, affectRows, result);
@@ -269,6 +275,7 @@ void httpProcessSingleSqlCallBack(void *param, TAOS_RES *result, int code) {
       (encode->stopJsonFp)(pContext, &pContext->singleCmd);
     }
 
+    taos_free_result(result);
     httpCloseContextByApp(pContext);
   } else {
     httpTrace("context:%p, fd:%d, ip:%s, user:%s, start retrieve", pContext, pContext->fd, pContext->ipstr,

src/query/inc/qExecutor.h

@@ -116,11 +116,14 @@ typedef struct SQueryCostInfo {
   uint64_t loadDataInCacheSize;
   
   uint64_t loadDataTime;
-  uint64_t dataInRows;
-  uint64_t checkRows;
-  uint32_t dataBlocks;
+  uint64_t totalRows;
+  uint64_t totalCheckedRows;
+  uint32_t totalBlocks;
+  uint32_t loadBlocks;
   uint32_t loadBlockStatis;
   uint32_t discardBlocks;
+  uint64_t elapsedTime;
+  uint64_t computTime;
 } SQueryCostInfo;
 
 typedef struct SGroupItem {
@@ -168,7 +171,7 @@ typedef struct SQueryRuntimeEnv {
   SWindowResInfo       windowResInfo;
   STSBuf*              pTSBuf;
   STSCursor            cur;
-  SQueryCostInfo    summary;
+  SQueryCostInfo       summary;
   bool                 stableQuery;  // super table query or not
   void*                pQueryHandle;
   void*                pSecQueryHandle;  // another thread for
@@ -177,8 +180,6 @@ typedef struct SQueryRuntimeEnv {
 
 typedef struct SQInfo {
   void*   signature;
-  TSKEY   startTime;
-  TSKEY   elapsedTime;
   int32_t pointsInterpo;
   int32_t code;  // error code to returned to client
   sem_t   dataReady;

src/query/src/qfill.c

@@ -110,6 +110,14 @@ void taosDestoryFillInfo(SFillInfo* pFillInfo) {
   tfree(pFillInfo->prevValues);
   tfree(pFillInfo->nextValues);
   tfree(pFillInfo->pTags);
+  
+  for(int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
+    tfree(pFillInfo->pData[i]);
+  }
+  
+  tfree(pFillInfo->pData);
+  tfree(pFillInfo->pFillCol);
+  
   tfree(pFillInfo);
 }
 
@@ -247,7 +255,7 @@ int taosDoLinearInterpolation(int32_t type, SPoint* point1, SPoint* point2, SPoi
 }
 
 static void setTagsValue(SFillInfo* pColInfo, tFilePage** data, char** pTags, int32_t start, int32_t num) {
-  for (int32_t j = 0, i = start; i < pColInfo->numOfCols + pColInfo->numOfTags; ++i, ++j) {
+  for (int32_t j = 0, i = start; i < pColInfo->numOfCols; ++i, ++j) {
     SFillColInfo* pCol = &pColInfo->pFillCol[i];
     
     char* val1 = elePtrAt(data[i]->data, pCol->col.bytes, num);
@@ -344,7 +352,7 @@ static void doInterpoResultImpl(SFillInfo* pFillInfo, tFilePage** data, int32_t*
       setTagsValue(pFillInfo, data, pTags, numOfValCols, *num);
   
     }
-  } else { /* default value interpolation */
+  } else { /* fill the default value */
     for (int32_t i = 1; i < numOfValCols; ++i) {
       SFillColInfo* pCol = &pFillInfo->pFillCol[i];
       

src/rpc/src/rpcMain.c

@@ -218,9 +218,9 @@ void *rpcOpen(const SRpcInit *pInit) {
   pRpc->localPort = pInit->localPort;
   pRpc->afp = pInit->afp;
   pRpc->sessions = pInit->sessions+1;
-  if (pInit->user) strcpy(pRpc->user, pInit->user);
-  if (pInit->secret) strcpy(pRpc->secret, pInit->secret);
-  if (pInit->ckey) strcpy(pRpc->ckey, pInit->ckey);
+  if (pInit->user) tstrncpy(pRpc->user, pInit->user, sizeof(pRpc->user));
+  if (pInit->secret) memcpy(pRpc->secret, pInit->secret, sizeof(pRpc->secret));
+  if (pInit->ckey) tstrncpy(pRpc->ckey, pInit->ckey, sizeof(pRpc->ckey));
   pRpc->spi = pInit->spi;
   pRpc->cfp = pInit->cfp;
   pRpc->afp = pInit->afp;
@@ -434,7 +434,8 @@ void rpcSendResponse(const SRpcMsg *pRsp) {
 }
 
 void rpcSendRedirectRsp(void *thandle, const SRpcIpSet *pIpSet) {
-  SRpcMsg  rpcMsg;
+  SRpcMsg  rpcMsg; 
+  memset(&rpcMsg, 0, sizeof(rpcMsg));
   
   rpcMsg.contLen = sizeof(SRpcIpSet);
   rpcMsg.pCont = rpcMallocCont(rpcMsg.contLen);

src/rpc/src/rpcTcp.c

@@ -253,12 +253,14 @@ void *taosInitTcpClient(uint32_t ip, uint16_t port, char *label, int num, void *
 
   if (pthread_mutex_init(&(pThreadObj->mutex), NULL) < 0) {
     tError("%s failed to init TCP client mutex(%s)", label, strerror(errno));
+    free(pThreadObj);
     return NULL;
   }
 
   pThreadObj->pollFd = epoll_create(10);  // size does not matter
   if (pThreadObj->pollFd < 0) {
     tError("%s failed to create TCP client epoll", label);
+    free(pThreadObj);
     return NULL;
   }
 
@@ -269,6 +271,8 @@ void *taosInitTcpClient(uint32_t ip, uint16_t port, char *label, int num, void *
   int code = pthread_create(&(pThreadObj->thread), &thattr, taosProcessTcpData, (void *)(pThreadObj));
   pthread_attr_destroy(&thattr);
   if (code != 0) {
+    close(pThreadObj->pollFd);
+    free(pThreadObj);
     tError("%s failed to create TCP read data thread(%s)", label, strerror(errno));
     return NULL;
   }
@@ -292,7 +296,7 @@ void *taosOpenTcpClientConnection(void *shandle, void *thandle, uint32_t ip, uin
   SThreadObj *    pThreadObj = shandle;
 
   int fd = taosOpenTcpClientSocket(ip, port, pThreadObj->ip);
-  if (fd <= 0) return NULL;
+  if (fd < 0) return NULL;
 
   SFdObj *pFdObj = taosMallocFdObj(pThreadObj, fd);
   

src/rpc/src/rpcUdp.c

@@ -192,7 +192,7 @@ static void *taosRecvUdpData(void *param) {
 
     char *tmsg = malloc(dataLen + tsRpcOverhead);
     if (NULL == tmsg) {
-      tError("%s failed to allocate memory, size:%d", pConn->label, dataLen);
+      tError("%s failed to allocate memory, size:%ld", pConn->label, dataLen);
       continue;
     }
 

src/rpc/test/rclient.c

@@ -14,6 +14,7 @@
  */
 
 #include "os.h"
+#include "tutil.h"
 #include "tglobal.h"
 #include "rpcLog.h"
 #include "trpc.h"
@@ -105,7 +106,7 @@ int main(int argc, char *argv[]) {
     if (strcmp(argv[i], "-p")==0 && i < argc-1) {
       ipSet.port[0] = atoi(argv[++i]);
     } else if (strcmp(argv[i], "-i") ==0 && i < argc-1) {
-      strcpy(ipSet.fqdn[0], argv[++i]); 
+      tstrncpy(ipSet.fqdn[0], argv[++i], sizeof(ipSet.fqdn)); 
     } else if (strcmp(argv[i], "-t")==0 && i < argc-1) {
       rpcInit.numOfThreads = atoi(argv[++i]);
     } else if (strcmp(argv[i], "-m")==0 && i < argc-1) {

src/rpc/test/rserver.c

@@ -69,6 +69,7 @@ void processShellMsg() {
       taosGetQitem(qall, &type, (void **)&pRpcMsg);
       rpcFreeCont(pRpcMsg->pCont);
 
+      memset(&rpcMsg, 0, sizeof(rpcMsg));
       rpcMsg.pCont = rpcMallocCont(msgSize);
       rpcMsg.contLen = msgSize;
       rpcMsg.handle = pRpcMsg->handle;