merge from master into develop

cmake/install.inc

@@ -6,6 +6,8 @@ IF (TD_LINUX)
 ELSEIF (TD_WINDOWS)
   IF (TD_POWER)
     SET(CMAKE_INSTALL_PREFIX C:/PowerDB)
+  ELSEIF (TD_PRO)
+    SET(CMAKE_INSTALL_PREFIX C:/ProDB)
   ELSE ()
     SET(CMAKE_INSTALL_PREFIX C:/TDengine)
   ENDIF ()
@@ -24,6 +26,8 @@ ELSEIF (TD_WINDOWS)
 
   IF (TD_POWER)
     INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/power.exe DESTINATION .)
+  ELSEIF (TD_PRO)
+    INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/prodbc.exe DESTINATION .)
   ELSE ()
     INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/taos.exe DESTINATION .)
     INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/taosdemo.exe DESTINATION .)

cmake/version.inc

@@ -4,7 +4,7 @@ PROJECT(TDengine)
 IF (DEFINED VERNUMBER)
   SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "2.1.7.2")
+  SET(TD_VER_NUMBER "2.2.0.5")
 ENDIF ()
 
 IF (DEFINED VERCOMPATIBLE)

snap/snapcraft.yaml

 name: tdengine
 base: core18
-version: '2.1.7.2'
+version: '2.2.0.5'
 icon: snap/gui/t-dengine.svg
 summary: an open-source big data platform designed and optimized for IoT. 
 description: |
@@ -72,7 +72,7 @@ parts:
       - usr/bin/taosd
       - usr/bin/taos
       - usr/bin/taosdemo
-      - usr/lib/libtaos.so.2.1.7.2
+      - usr/lib/libtaos.so.2.2.0.5
       - usr/lib/libtaos.so.1
       - usr/lib/libtaos.so
 

src/client/inc/tscGlobalmerge.h

@@ -58,6 +58,7 @@ typedef struct SRetrieveSupport {
   int32_t           subqueryIndex;     // index of current vnode in vnode list
   struct SSqlObj   *pParentSql;
   tFilePage *       localBuffer;       // temp buffer, there is a buffer for each vnode to
+  uint32_t          localBufferSize;
   uint32_t          numOfRetry;        // record the number of retry times
 } SRetrieveSupport;
 

src/client/inc/tscSubquery.h

@@ -52,7 +52,7 @@ int tsInsertInitialCheck(SSqlObj *pSql);
 
 void doCleanupSubqueries(SSqlObj *pSql, int32_t numOfSubs);
 
-void tscFreeRetrieveSup(SSqlObj *pSql);
+void tscFreeRetrieveSup(void **param);
 
 
 

src/client/inc/tscUtil.h

@@ -64,7 +64,7 @@ typedef struct STidTags {
 #pragma pack(pop)
 
 typedef struct SJoinSupporter {
-  SSqlObj*        pObj;           // parent SqlObj
+  int64_t         pObj;           // parent SqlObj
   int32_t         subqueryIndex;  // index of sub query
   SInterval       interval;
   SLimitVal       limit;          // limit info
@@ -386,6 +386,8 @@ void tscRemoveCachedTableMeta(STableMetaInfo* pTableMetaInfo, uint64_t id);
 char* cloneCurrentDBName(SSqlObj* pSql);
 
 
+char* cloneCurrentDBName(SSqlObj* pSql);
+
 #ifdef __cplusplus
 }
 #endif

src/client/inc/tsclient.h

@@ -311,6 +311,7 @@ typedef struct {
   char *         data;
   TAOS_ROW       tsrow;
   TAOS_ROW       urow;
+  bool           dataConverted;
   int32_t*       length;  // length for each field for current row
   char **        buffer;  // Buffer used to put multibytes encoded using unicode (wchar_t)
   SColumnIndex*  pColumnIndex;
@@ -364,6 +365,7 @@ typedef struct SSqlObj {
   __async_cb_func_t  fp;
   __async_cb_func_t  fetchFp;
   void            *param;
+  _freeSqlSupporter  freeParam;
   int64_t          stime;
   uint32_t         queryId;
   void *           pStream;
@@ -381,6 +383,7 @@ typedef struct SSqlObj {
 
   SSubqueryState   subState;
   struct SSqlObj **pSubs;
+  struct SSqlObj  *rootObj;
 
   int64_t          metaRid;
   int64_t          svgroupRid;
@@ -448,7 +451,7 @@ int32_t tscTansformFuncForSTableQuery(SQueryInfo *pQueryInfo);
 void    tscRestoreFuncForSTableQuery(SQueryInfo *pQueryInfo);
 
 int32_t tscCreateResPointerInfo(SSqlRes *pRes, SQueryInfo *pQueryInfo);
-void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo);
+void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo, bool converted);
 void tscSetResRawPtrRv(SSqlRes* pRes, SQueryInfo* pQueryInfo, SSDataBlock* pBlock, bool convertNchar);
 
 void handleDownstreamOperator(SSqlObj** pSqlList, int32_t numOfUpstream, SQueryInfo* px, SSqlObj* pParent);

src/client/src/taos.def

@@ -44,3 +44,10 @@ taos_unsubscribe
 taos_open_stream
 taos_close_stream
 taos_load_table_info
+taos_data_type
+taos_stmt_set_sub_tbname
+taos_stmt_get_param
+taos_stmt_bind_param_batch
+taos_stmt_bind_single_param_batch
+taos_is_null
+taos_insert_lines

src/client/src/tscAsync.c

@@ -44,6 +44,7 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, __async_cb_func_t fp, void* para
   pSql->maxRetry  = TSDB_MAX_REPLICA;
   pSql->fp        = fp;
   pSql->fetchFp   = fp;
+  pSql->rootObj   = pSql;
 
   registerSqlObj(pSql);
 
@@ -176,6 +177,9 @@ static void tscProcessAsyncRetrieveImpl(void *param, TAOS_RES *tres, int numOfRo
     } else {
       pRes->code = numOfRows;
     }
+    if (pRes->code == TSDB_CODE_SUCCESS) {
+      pRes->code = TSDB_CODE_TSC_INVALID_QHANDLE;           
+    }
 
     tscAsyncResultOnError(pSql);
     return;

src/client/src/tscParseInsert.c

@@ -114,7 +114,7 @@ int tsParseTime(SStrToken *pToken, int64_t *time, char **next, char *error, int1
   }
 
   for (int k = pToken->n; pToken->z[k] != '\0'; k++) {
-    if (pToken->z[k] == ' ' || pToken->z[k] == '\t') continue;
+    if (isspace(pToken->z[k])) continue;
     if (pToken->z[k] == ',') {
       *next = pTokenEnd;
       *time = useconds;
@@ -1618,7 +1618,8 @@ int tsParseSql(SSqlObj *pSql, bool initial) {
 
     ret = tsParseInsertSql(pSql);
     if (pSql->parseRetry < 1 && (ret == TSDB_CODE_TSC_SQL_SYNTAX_ERROR || ret == TSDB_CODE_TSC_INVALID_OPERATION)) {
-      tscDebug("0x%"PRIx64 " parse insert sql statement failed, code:%s, clear meta cache and retry ", pSql->self, tstrerror(ret));
+      SInsertStatementParam* pInsertParam = &pCmd->insertParam;
+      tscDebug("0x%"PRIx64 " parse insert sql statement failed, code:%s, msg:%s, clear meta cache and retry ", pSql->self, pInsertParam->msg, tstrerror(ret));
 
       tscResetSqlCmd(pCmd, true, pSql->self);
       pSql->parseRetry++;
@@ -1786,6 +1787,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int32_t numOfRow
       pSql->res.numOfRows = 0;
       code = doPackSendDataBlock(pSql, pInsertParam, pTableMeta, count, pTableDataBlock);
       if (code != TSDB_CODE_SUCCESS) {
+        pParentSql->res.code = code;
         goto _error;
       }
 

src/client/src/tscParseLineProtocol.c

@@ -28,7 +28,50 @@ typedef struct  {
   uint8_t precision;
 } SSmlSTableSchema;
 
+<<<<<<< HEAD
 //=================================================================================================
+=======
+typedef struct {
+  char* key;
+  uint8_t type;
+  int16_t length;
+  char* value;
+
+  uint32_t fieldSchemaIdx;
+} TAOS_SML_KV;
+
+typedef struct {
+  char* stableName;
+
+  char* childTableName;
+  TAOS_SML_KV* tags;
+  int32_t tagNum;
+
+  // first kv must be timestamp
+  TAOS_SML_KV* fields;
+  int32_t fieldNum;
+
+  uint32_t schemaIdx;
+} TAOS_SML_DATA_POINT;
+>>>>>>> origin/master
+
+static uint64_t linesSmlHandleId = 0;
+
+uint64_t genLinesSmlId() {
+  uint64_t id;
+<<<<<<< HEAD
+
+  do {
+    id = atomic_add_fetch_64(&linesSmlHandleId, 1);
+  } while (id == 0);
+
+  return id;
+}
+=======
+} SSmlLinesInfo;
+
+//=================================================================================================
+>>>>>>> origin/master
 
 static uint64_t linesSmlHandleId = 0;
 
@@ -184,6 +227,40 @@ static int32_t getSmlMd5ChildTableName(TAOS_SML_DATA_POINT* point, char* tableNa
   return 0;
 }
 
+static int32_t getSmlMd5ChildTableName(TAOS_SML_DATA_POINT* point, char* tableName, int* tableNameLen,
+                                       SSmlLinesInfo* info) {
+  tscDebug("SML:0x%"PRIx64" taos_sml_insert get child table name through md5", info->id);
+  qsort(point->tags, point->tagNum, sizeof(TAOS_SML_KV), compareSmlColKv);
+
+  SStringBuilder sb; memset(&sb, 0, sizeof(sb));
+  char sTableName[TSDB_TABLE_NAME_LEN] = {0};
+  strtolower(sTableName, point->stableName);
+  taosStringBuilderAppendString(&sb, sTableName);
+  for (int j = 0; j < point->tagNum; ++j) {
+    taosStringBuilderAppendChar(&sb, ',');
+    TAOS_SML_KV* tagKv = point->tags + j;
+    char tagName[TSDB_COL_NAME_LEN] = {0};
+    strtolower(tagName, tagKv->key);
+    taosStringBuilderAppendString(&sb, tagName);
+    taosStringBuilderAppendChar(&sb, '=');
+    taosStringBuilderAppend(&sb, tagKv->value, tagKv->length);
+  }
+  size_t len = 0;
+  char* keyJoined = taosStringBuilderGetResult(&sb, &len);
+  MD5_CTX context;
+  MD5Init(&context);
+  MD5Update(&context, (uint8_t *)keyJoined, (uint32_t)len);
+  MD5Final(&context);
+  *tableNameLen = snprintf(tableName, *tableNameLen,
+                           "t_%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", context.digest[0],
+                           context.digest[1], context.digest[2], context.digest[3], context.digest[4], context.digest[5], context.digest[6],
+                           context.digest[7], context.digest[8], context.digest[9], context.digest[10], context.digest[11],
+                           context.digest[12], context.digest[13], context.digest[14], context.digest[15]);
+  taosStringBuilderDestroy(&sb);
+  tscDebug("SML:0x%"PRIx64" child table name: %s", info->id, tableName);
+  return 0;
+}
+
 static int32_t buildDataPointSchemas(TAOS_SML_DATA_POINT* points, int numPoint, SArray* stableSchemas, SSmlLinesInfo* info) {
   int32_t code = 0;
   SHashObj* sname2shema = taosHashInit(32,
@@ -355,6 +432,10 @@ static int32_t applySchemaAction(TAOS* taos, SSchemaAction* action, SSmlLinesInf
           tscError("SML:0x%" PRIx64 " apply schema action. reset query cache. error: %s", info->id, taos_errstr(res2));
         }
         taos_free_result(res2);
+<<<<<<< HEAD
+=======
+        taosMsleep(500);
+>>>>>>> origin/master
       }
       break;
     }
@@ -379,6 +460,10 @@ static int32_t applySchemaAction(TAOS* taos, SSchemaAction* action, SSmlLinesInf
           tscError("SML:0x%" PRIx64 " apply schema action. reset query cache. error: %s", info->id, taos_errstr(res2));
         }
         taos_free_result(res2);
+<<<<<<< HEAD
+=======
+        taosMsleep(500);
+>>>>>>> origin/master
       }
       break;
     }
@@ -400,6 +485,10 @@ static int32_t applySchemaAction(TAOS* taos, SSchemaAction* action, SSmlLinesInf
           tscError("SML:0x%" PRIx64 " apply schema action. reset query cache. error: %s", info->id, taos_errstr(res2));
         }
         taos_free_result(res2);
+<<<<<<< HEAD
+=======
+        taosMsleep(500);
+>>>>>>> origin/master
       }
       break;
     }
@@ -421,6 +510,10 @@ static int32_t applySchemaAction(TAOS* taos, SSchemaAction* action, SSmlLinesInf
           tscError("SML:0x%" PRIx64 " apply schema action. reset query cache. error: %s", info->id, taos_errstr(res2));
         }
         taos_free_result(res2);
+<<<<<<< HEAD
+=======
+        taosMsleep(500);
+>>>>>>> origin/master
       }
       break;
     }
@@ -462,6 +555,10 @@ static int32_t applySchemaAction(TAOS* taos, SSchemaAction* action, SSmlLinesInf
           tscError("SML:0x%" PRIx64 " apply schema action. reset query cache. error: %s", info->id, taos_errstr(res2));
         }
         taos_free_result(res2);
+<<<<<<< HEAD
+=======
+        taosMsleep(500);
+>>>>>>> origin/master
       }
       break;
     }
@@ -558,6 +655,7 @@ static int32_t retrieveTableMeta(TAOS* taos, char* tableName, STableMeta** pTabl
     registerSqlObj(pSql);
     SStrToken tableToken = {.z = tableNameLowerCase, .n = (uint32_t)strlen(tableNameLowerCase), .type = TK_ID};
     tGetToken(tableNameLowerCase, &tableToken.type);
+<<<<<<< HEAD
     
     bool dbIncluded = false;
     // Check if the table name available or not
@@ -565,21 +663,40 @@ static int32_t retrieveTableMeta(TAOS* taos, char* tableName, STableMeta** pTabl
       code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
       sprintf(pSql->cmd.payload, "table name is invalid");
       tscFreeRegisteredSqlObj(pSql);
+=======
+    // Check if the table name available or not
+    if (tscValidateName(&tableToken) != TSDB_CODE_SUCCESS) {
+      code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
+      sprintf(pSql->cmd.payload, "table name is invalid");
+      taosReleaseRef(tscObjRef, pSql->self);
+>>>>>>> origin/master
       return code;
     }
 
     SName sname = {0};
+<<<<<<< HEAD
     if ((code = tscSetTableFullName(&sname, &tableToken, pSql, dbIncluded)) != TSDB_CODE_SUCCESS) {
       tscFreeRegisteredSqlObj(pSql);
+=======
+    if ((code = tscSetTableFullName(&sname, &tableToken, pSql)) != TSDB_CODE_SUCCESS) {
+      taosReleaseRef(tscObjRef, pSql->self);
+>>>>>>> origin/master
       return code;
     }
     char fullTableName[TSDB_TABLE_FNAME_LEN] = {0};
     memset(fullTableName, 0, tListLen(fullTableName));
     tNameExtractFullName(&sname, fullTableName);
+<<<<<<< HEAD
 
     size_t size = 0;
     taosHashGetCloneExt(UTIL_GET_TABLEMETA(pSql), fullTableName, strlen(fullTableName), NULL, (void**)&tableMeta, &size);
     tscFreeRegisteredSqlObj(pSql);
+=======
+    taosReleaseRef(tscObjRef, pSql->self);
+
+    size_t size = 0;
+    taosHashGetCloneExt(tscTableMetaMap, fullTableName, strlen(fullTableName), NULL, (void**)&tableMeta, &size);
+>>>>>>> origin/master
   }
 
   if (tableMeta != NULL) {
@@ -747,41 +864,15 @@ static int32_t creatChildTableIfNotExists(TAOS* taos, const char* cTableName, co
   return code;
 }
 
-static int32_t insertChildTableBatch(TAOS* taos,  char* cTableName, SArray* colsSchema, SArray* rowsBind, SSmlLinesInfo* info) {
-  size_t numCols = taosArrayGetSize(colsSchema);
-  char* sql = malloc(tsMaxSQLStringLen+1);
-  if (sql == NULL) {
-    tscError("malloc sql memory error");
-    return TSDB_CODE_TSC_OUT_OF_MEMORY;
-  }
-
-  int32_t freeBytes = tsMaxSQLStringLen + 1 ;
-  sprintf(sql, "insert into ? (");
-
-  for (int i = 0; i < numCols; ++i) {
-    SSchema* colSchema = taosArrayGet(colsSchema, i);
-    snprintf(sql+strlen(sql), freeBytes-strlen(sql), "%s,", colSchema->name);
-  }
-  snprintf(sql + strlen(sql)-1, freeBytes-strlen(sql)+1, ") values (");
-
-  for (int i = 0; i < numCols; ++i) {
-    snprintf(sql+strlen(sql), freeBytes-strlen(sql), "?,");
-  }
-  snprintf(sql + strlen(sql)-1, freeBytes-strlen(sql)+1, ")");
-  sql[strlen(sql)] = '\0';
-
-  tscDebug("SML:0x%"PRIx64" insert rows into child table %s. num of rows: %zu", info->id, cTableName, taosArrayGetSize(rowsBind));
-
+static int32_t doInsertChildTableWithStmt(TAOS* taos, char* sql, char* cTableName, SArray* batchBind, SSmlLinesInfo* info) {
   int32_t code = 0;
 
   TAOS_STMT* stmt = taos_stmt_init(taos);
   if (stmt == NULL) {
-    tfree(sql);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
   code = taos_stmt_prepare(stmt, sql, (unsigned long)strlen(sql));
-  tfree(sql);
 
   if (code != 0) {
     tscError("SML:0x%"PRIx64" taos_stmt_prepare return %d:%s", info->id, code, tstrerror(code));
@@ -799,9 +890,9 @@ static int32_t insertChildTableBatch(TAOS* taos,  char* cTableName, SArray* cols
       return code;
     }
 
-    size_t rows = taosArrayGetSize(rowsBind);
+    size_t rows = taosArrayGetSize(batchBind);
     for (int32_t i = 0; i < rows; ++i) {
-      TAOS_BIND* colsBinds = taosArrayGetP(rowsBind, i);
+      TAOS_BIND* colsBinds = taosArrayGetP(batchBind, i);
       code = taos_stmt_bind_param(stmt, colsBinds);
       if (code != 0) {
         tscError("SML:0x%"PRIx64" taos_stmt_bind_param return %d:%s", info->id, code, tstrerror(code));
@@ -823,10 +914,17 @@ static int32_t insertChildTableBatch(TAOS* taos,  char* cTableName, SArray* cols
 
     tryAgain = false;
     if ((code == TSDB_CODE_TDB_INVALID_TABLE_ID
+<<<<<<< HEAD
         || code == TSDB_CODE_VND_INVALID_VGROUP_ID
         || code == TSDB_CODE_TDB_TABLE_RECONFIGURE
         || code == TSDB_CODE_APP_NOT_READY
         || code == TSDB_CODE_RPC_NETWORK_UNAVAIL) && try++ < TSDB_MAX_REPLICA) {
+=======
+         || code == TSDB_CODE_VND_INVALID_VGROUP_ID
+         || code == TSDB_CODE_TDB_TABLE_RECONFIGURE
+         || code == TSDB_CODE_APP_NOT_READY
+         || code == TSDB_CODE_RPC_NETWORK_UNAVAIL) && try++ < TSDB_MAX_REPLICA) {
+>>>>>>> origin/master
       tryAgain = true;
     }
 
@@ -838,11 +936,16 @@ static int32_t insertChildTableBatch(TAOS* taos,  char* cTableName, SArray* cols
       }
       taos_free_result(res2);
       if (tryAgain) {
+<<<<<<< HEAD
         taosMsleep(50 * (2 << try));
+=======
+        taosMsleep(100 * (2 << try));
+>>>>>>> origin/master
       }
     }
     if (code == TSDB_CODE_APP_NOT_READY || code == TSDB_CODE_RPC_NETWORK_UNAVAIL) {
       if (tryAgain) {
+<<<<<<< HEAD
         taosMsleep( 50 * (2 << try));
       }
     }
@@ -850,6 +953,67 @@ static int32_t insertChildTableBatch(TAOS* taos,  char* cTableName, SArray* cols
 
 
   taos_stmt_close(stmt);
+=======
+        taosMsleep( 100 * (2 << try));
+      }
+    }
+  } while (tryAgain);
+
+
+  taos_stmt_close(stmt);
+  return code;
+}
+
+static int32_t insertChildTableBatch(TAOS* taos,  char* cTableName, SArray* colsSchema, SArray* rowsBind, size_t rowSize, SSmlLinesInfo* info) {
+  size_t numCols = taosArrayGetSize(colsSchema);
+  char* sql = malloc(tsMaxSQLStringLen+1);
+  if (sql == NULL) {
+    tscError("malloc sql memory error");
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  int32_t freeBytes = tsMaxSQLStringLen + 1 ;
+  sprintf(sql, "insert into ? (");
+
+  for (int i = 0; i < numCols; ++i) {
+    SSchema* colSchema = taosArrayGet(colsSchema, i);
+    snprintf(sql+strlen(sql), freeBytes-strlen(sql), "%s,", colSchema->name);
+  }
+  snprintf(sql + strlen(sql)-1, freeBytes-strlen(sql)+1, ") values (");
+
+  for (int i = 0; i < numCols; ++i) {
+    snprintf(sql+strlen(sql), freeBytes-strlen(sql), "?,");
+  }
+  snprintf(sql + strlen(sql)-1, freeBytes-strlen(sql)+1, ")");
+  sql[strlen(sql)] = '\0';
+
+  size_t rows = taosArrayGetSize(rowsBind);
+  size_t maxBatchSize = TSDB_MAX_WAL_SIZE/rowSize * 4 / 5;
+  size_t batchSize = MIN(maxBatchSize, rows);
+  tscDebug("SML:0x%"PRIx64" insert rows into child table %s. num of rows: %zu, batch size: %zu",
+           info->id, cTableName, rows, batchSize);
+  SArray* batchBind = taosArrayInit(batchSize, POINTER_BYTES);
+  int32_t code = TSDB_CODE_SUCCESS;
+  for (int i = 0; i < rows;) {
+    int j = i;
+    for (; j < i + batchSize && j<rows; ++j) {
+      taosArrayPush(batchBind, taosArrayGet(rowsBind, j));
+    }
+    if (j > i) {
+      tscDebug("SML:0x%"PRIx64" insert child table batch from line %d to line %d.", info->id, i, j - 1);
+      code = doInsertChildTableWithStmt(taos, sql, cTableName, batchBind, info);
+      if (code != 0) {
+        taosArrayDestroy(batchBind);
+        tfree(sql);
+        return code;
+      }
+      taosArrayClear(batchBind);
+    }
+    i = j;
+  }
+  taosArrayDestroy(batchBind);
+  tfree(sql);
+>>>>>>> origin/master
   return code;
 }
 
@@ -857,10 +1021,14 @@ static int32_t arrangePointsByChildTableName(TAOS_SML_DATA_POINT* points, int nu
                                              SHashObj* cname2points, SArray* stableSchemas, SSmlLinesInfo* info) {
   for (int32_t i = 0; i < numPoints; ++i) {
     TAOS_SML_DATA_POINT * point = points + i;
+<<<<<<< HEAD
     uintptr_t valPointer = (uintptr_t)point;
     size_t* pSchemaIndex = taosHashGet(info->smlDataToSchema, &valPointer, sizeof(uintptr_t));
     assert(pSchemaIndex != NULL);
     SSmlSTableSchema* stableSchema = taosArrayGet(stableSchemas, *pSchemaIndex);
+=======
+    SSmlSTableSchema* stableSchema = taosArrayGet(stableSchemas, point->schemaIdx);
+>>>>>>> origin/master
 
     for (int j = 0; j < point->tagNum; ++j) {
       TAOS_SML_KV* kv =  point->tags + j;
@@ -904,10 +1072,14 @@ static int32_t applyChildTableTags(TAOS* taos, char* cTableName, char* sTableNam
     TAOS_SML_DATA_POINT * pDataPoint = taosArrayGetP(cTablePoints, i);
     for (int j = 0; j < pDataPoint->tagNum; ++j) {
       TAOS_SML_KV* kv = pDataPoint->tags + j;
+<<<<<<< HEAD
       uintptr_t valPointer = (uintptr_t)kv;
       size_t* pFieldSchemaIdx = taosHashGet(info->smlDataToSchema, &valPointer, sizeof(uintptr_t));
       assert(pFieldSchemaIdx != NULL);
       tagKVs[*pFieldSchemaIdx] = kv;
+=======
+      tagKVs[kv->fieldSchemaIdx] = kv;
+>>>>>>> origin/master
     }
   }
   
@@ -943,13 +1115,14 @@ static int32_t applyChildTableTags(TAOS* taos, char* cTableName, char* sTableNam
 }
 
 static int32_t applyChildTableFields(TAOS* taos, SSmlSTableSchema* sTableSchema, char* cTableName,
-                                     SArray* cTablePoints, SSmlLinesInfo* info) {
+                                     SArray* cTablePoints, size_t rowSize, SSmlLinesInfo* info) {
   int32_t code = TSDB_CODE_SUCCESS;
 
   size_t numCols = taosArrayGetSize(sTableSchema->fields);
   size_t rows = taosArrayGetSize(cTablePoints);
   SArray* rowsBind = taosArrayInit(rows, POINTER_BYTES);
 
+  int isNullColBind = TSDB_TRUE;
   for (int i = 0; i < rows; ++i) {
     TAOS_SML_DATA_POINT* point = taosArrayGetP(cTablePoints, i);
 
@@ -960,7 +1133,6 @@ static int32_t applyChildTableFields(TAOS* taos, SSmlSTableSchema* sTableSchema,
       return TSDB_CODE_TSC_OUT_OF_MEMORY;
     }
 
-    int isNullColBind = TSDB_TRUE;
     for (int j = 0; j < numCols; ++j) {
       TAOS_BIND* bind = colBinds + j;
       bind->is_null = &isNullColBind;
@@ -980,7 +1152,7 @@ static int32_t applyChildTableFields(TAOS* taos, SSmlSTableSchema* sTableSchema,
     taosArrayPush(rowsBind, &colBinds);
   }
 
-  code = insertChildTableBatch(taos, cTableName, sTableSchema->fields, rowsBind, info);
+  code = insertChildTableBatch(taos, cTableName, sTableSchema->fields, rowsBind, rowSize, info);
   if (code != 0) {
     tscError("SML:0x%"PRIx64" insert into child table %s failed. error %s", info->id, cTableName, tstrerror(code));
   }
@@ -1020,8 +1192,15 @@ static int32_t applyDataPoints(TAOS* taos, TAOS_SML_DATA_POINT* points, int32_t
       goto cleanup;
     }
 
-    tscDebug("SML:0x%"PRIx64" apply child table points. child table: %s", info->id, point->childTableName);
-    code = applyChildTableFields(taos, sTableSchema, point->childTableName, cTablePoints, info);
+    size_t rowSize = 0;
+    size_t numCols = taosArrayGetSize(sTableSchema->fields);
+    for (int i = 0; i < numCols; ++i) {
+      SSchema* colSchema = taosArrayGet(sTableSchema->fields, i);
+      rowSize += colSchema->bytes;
+    }
+
+    tscDebug("SML:0x%"PRIx64" apply child table points. child table: %s, row size: %zu", info->id, point->childTableName, rowSize);
+    code = applyChildTableFields(taos, sTableSchema, point->childTableName, cTablePoints, rowSize, info);
     if (code != 0) {
       tscError("SML:0x%"PRIx64" Apply child table fields failed. child table %s, error %s", info->id, point->childTableName, tstrerror(code));
       goto cleanup;
@@ -1089,6 +1268,14 @@ int taos_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
   return code;
 }
 
+int tsc_sml_insert(TAOS* taos, TAOS_SML_DATA_POINT* points, int numPoint) {
+  SSmlLinesInfo* info = calloc(1, sizeof(SSmlLinesInfo));
+  info->id = genLinesSmlId();
+  int code = tscSmlInsert(taos, points, numPoint, info);
+  free(info);
+  return code;
+}
+
 //=========================================================================
 
 /*        Field                          Escape charaters

src/client/src/tscPrepare.c

@@ -86,6 +86,10 @@ typedef struct STscStmt {
   return _code;             \
 } while (0)
 
+#define STMT_CHECK if (pStmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) { \
+                      STMT_RET(TSDB_CODE_TSC_DISCONNECTED);  \
+                    }
+
 static int32_t invalidOperationMsg(char* dstBuffer, const char* errMsg) {
   return tscInvalidOperationMsg(dstBuffer, errMsg, NULL);
 }
@@ -155,6 +159,22 @@ static int normalStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) {
         var->i64 = *(int64_t*)tb->buffer;
         break;
 
+      case  TSDB_DATA_TYPE_UTINYINT:
+        var->u64 = *(uint8_t*)tb->buffer;
+        break;
+
+      case  TSDB_DATA_TYPE_USMALLINT:
+        var->u64 = *(uint16_t*)tb->buffer;
+        break;
+
+      case  TSDB_DATA_TYPE_UINT:
+        var->u64 = *(uint32_t*)tb->buffer;
+        break;
+
+      case  TSDB_DATA_TYPE_UBIGINT:
+        var->u64 = *(uint64_t*)tb->buffer;
+        break;
+
       case TSDB_DATA_TYPE_FLOAT:
         var->dKey = GET_FLOAT_VAL(tb->buffer);
         break;
@@ -261,9 +281,17 @@ static char* normalStmtBuildSql(STscStmt* stmt) {
     case TSDB_DATA_TYPE_SMALLINT:
     case TSDB_DATA_TYPE_INT:
     case TSDB_DATA_TYPE_BIGINT:
+    case TSDB_DATA_TYPE_TIMESTAMP:
       taosStringBuilderAppendInteger(&sb, var->i64);
       break;
 
+    case TSDB_DATA_TYPE_UTINYINT:
+    case TSDB_DATA_TYPE_USMALLINT:
+    case TSDB_DATA_TYPE_UINT:
+    case TSDB_DATA_TYPE_UBIGINT:
+      taosStringBuilderAppendUnsignedInteger(&sb, var->u64);
+      break;
+
     case TSDB_DATA_TYPE_FLOAT:
     case TSDB_DATA_TYPE_DOUBLE:
       taosStringBuilderAppendDouble(&sb, var->dKey);
@@ -1493,6 +1521,7 @@ TAOS_STMT* taos_stmt_init(TAOS* taos) {
   pSql->maxRetry  = TSDB_MAX_REPLICA;
   pStmt->pSql     = pSql;
   pStmt->last     = STMT_INIT;
+  registerSqlObj(pSql);
 
   return pStmt;
 }
@@ -1500,9 +1529,7 @@ TAOS_STMT* taos_stmt_init(TAOS* taos) {
 int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
   STscStmt* pStmt = (STscStmt*)stmt;
 
-  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
+  STMT_CHECK
 
   if (sql == NULL) {
     tscError("sql is NULL");
@@ -1579,9 +1606,7 @@ int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags
   STscStmt* pStmt = (STscStmt*)stmt;
   int32_t code = 0;
 
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
+  STMT_CHECK
 
   SSqlObj* pSql = pStmt->pSql;
   SSqlCmd* pCmd = &pSql->cmd;
@@ -1757,6 +1782,7 @@ int taos_stmt_set_tbname_tags(TAOS_STMT* stmt, const char* name, TAOS_BIND* tags
 
 int taos_stmt_set_sub_tbname(TAOS_STMT* stmt, const char* name) {
   STscStmt* pStmt = (STscStmt*)stmt;
+  STMT_CHECK
   pStmt->mtb.subSet = true;
   return taos_stmt_set_tbname_tags(stmt, name, NULL);
 }
@@ -1765,6 +1791,7 @@ int taos_stmt_set_sub_tbname(TAOS_STMT* stmt, const char* name) {
 
 int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
   STscStmt* pStmt = (STscStmt*)stmt;
+  STMT_CHECK
   pStmt->mtb.subSet = false;
   return taos_stmt_set_tbname_tags(stmt, name, NULL);
 }
@@ -1772,6 +1799,9 @@ int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
 
 int taos_stmt_close(TAOS_STMT* stmt) {
   STscStmt* pStmt = (STscStmt*)stmt;
+  if (pStmt == NULL || pStmt->taos == NULL) {
+    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
+  }
   if (!pStmt->isInsert) {
     SNormalStmt* normal = &pStmt->normal;
     if (normal->params != NULL) {
@@ -1793,8 +1823,9 @@ int taos_stmt_close(TAOS_STMT* stmt) {
       pStmt->mtb.pTableBlockHashList = tscDestroyBlockHashTable(pStmt->pSql, pStmt->mtb.pTableBlockHashList, rmMeta);
       if (pStmt->pSql){
         taosHashCleanup(pStmt->pSql->cmd.insertParam.pTableBlockHashList);
+        pStmt->pSql->cmd.insertParam.pTableBlockHashList = NULL;
       }
-      pStmt->pSql->cmd.insertParam.pTableBlockHashList = NULL;
+
       taosArrayDestroy(pStmt->mtb.tags);
       tfree(pStmt->mtb.sqlstr);
     }
@@ -1807,9 +1838,7 @@ int taos_stmt_close(TAOS_STMT* stmt) {
 
 int taos_stmt_bind_param(TAOS_STMT* stmt, TAOS_BIND* bind) {
   STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
+  STMT_CHECK
 
   if (pStmt->isInsert) {
     if (pStmt->multiTbInsert) {
@@ -1838,9 +1867,7 @@ int taos_stmt_bind_param(TAOS_STMT* stmt, TAOS_BIND* bind) {
 int taos_stmt_bind_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind) {
   STscStmt* pStmt = (STscStmt*)stmt;
 
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
+  STMT_CHECK
 
   if (bind == NULL || bind->num <= 0 || bind->num > INT16_MAX) {
     tscError("0x%"PRIx64" invalid parameter", pStmt->pSql->self);
@@ -1871,9 +1898,7 @@ int taos_stmt_bind_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind) {
 
 int taos_stmt_bind_single_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind, int colIdx) {
   STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
+  STMT_CHECK
 
   if (bind == NULL || bind->num <= 0 || bind->num > INT16_MAX || colIdx < 0) {
     tscError("0x%"PRIx64" invalid parameter", pStmt->pSql->self);
@@ -1906,9 +1931,7 @@ int taos_stmt_bind_single_param_batch(TAOS_STMT* stmt, TAOS_MULTI_BIND* bind, in
 
 int taos_stmt_add_batch(TAOS_STMT* stmt) {
   STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
+  STMT_CHECK
 
   if (pStmt->isInsert) {
     if (pStmt->last != STMT_BIND && pStmt->last != STMT_BIND_COL) {
@@ -1935,9 +1958,7 @@ int taos_stmt_reset(TAOS_STMT* stmt) {
 int taos_stmt_execute(TAOS_STMT* stmt) {
   int ret = 0;
   STscStmt* pStmt = (STscStmt*)stmt;
-  if (stmt == NULL || pStmt->pSql == NULL || pStmt->taos == NULL) {
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
+  STMT_CHECK
 
   if (pStmt->isInsert) {
     if (pStmt->last != STMT_ADD_BATCH) {
@@ -1958,11 +1979,7 @@ int taos_stmt_execute(TAOS_STMT* stmt) {
     if (sql == NULL) {
       ret = TSDB_CODE_TSC_OUT_OF_MEMORY;
     } else {
-      if (pStmt->pSql != NULL) {
-        tscFreeSqlObj(pStmt->pSql);
-        pStmt->pSql = NULL;
-      }
-
+      taosReleaseRef(tscObjRef, pStmt->pSql->self);
       pStmt->pSql = taos_query((TAOS*)pStmt->taos, sql);
       ret = taos_errno(pStmt->pSql);
       free(sql);
@@ -1983,7 +2000,6 @@ TAOS_RES *taos_stmt_use_result(TAOS_STMT* stmt) {
     tscError("result has been used already.");
     return NULL;
   }
-
   TAOS_RES* result = pStmt->pSql;
   pStmt->pSql = NULL;
   return result;
@@ -1992,9 +2008,7 @@ TAOS_RES *taos_stmt_use_result(TAOS_STMT* stmt) {
 int taos_stmt_is_insert(TAOS_STMT *stmt, int *insert) {
   STscStmt* pStmt = (STscStmt*)stmt;
 
-  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
+  STMT_CHECK
 
   if (insert) *insert = pStmt->isInsert;
 
@@ -2004,9 +2018,7 @@ int taos_stmt_is_insert(TAOS_STMT *stmt, int *insert) {
 int taos_stmt_num_params(TAOS_STMT *stmt, int *nums) {
   STscStmt* pStmt = (STscStmt*)stmt;
 
-  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
+  STMT_CHECK
 
   if (pStmt->isInsert) {
     SSqlObj* pSql = pStmt->pSql;
@@ -2023,9 +2035,7 @@ int taos_stmt_num_params(TAOS_STMT *stmt, int *nums) {
 int taos_stmt_get_param(TAOS_STMT *stmt, int idx, int *type, int *bytes) {
   STscStmt* pStmt = (STscStmt*)stmt;
 
-  if (stmt == NULL || pStmt->taos == NULL || pStmt->pSql == NULL) {
-    STMT_RET(TSDB_CODE_TSC_DISCONNECTED);
-  }
+  STMT_CHECK
 
   if (pStmt->isInsert) {
     SSqlCmd* pCmd = &pStmt->pSql->cmd;

src/client/src/tscSQLParser.c

@@ -440,6 +440,7 @@ int32_t handleUserDefinedFunc(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   const char *msg2 = "path is too long";
   const char *msg3 = "invalid outputtype";
   const char *msg4 = "invalid script";
+  const char *msg5 = "invalid dyn lib";
   SSqlCmd *pCmd = &pSql->cmd;
 
   switch (pInfo->type) {
@@ -475,10 +476,16 @@ int32_t handleUserDefinedFunc(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       if (ret) {
         return ret;
       }
-      //distinguish  *.lua and *.so
+      //validate *.lua or .so
       int32_t pathLen = (int32_t)strlen(createInfo->path.z);
-      if ((pathLen > 3) && (0 == strncmp(createInfo->path.z + pathLen - 3, "lua", 3)) && !isValidScript(buf, len)) {
+      if ((pathLen > 4) && (0 == strncmp(createInfo->path.z + pathLen - 4, ".lua", 4)) && !isValidScript(buf, len)) {
         return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
+      } else if (pathLen > 3 && (0 == strncmp(createInfo->path.z + pathLen - 3, ".so", 3))) {
+        void *handle = taosLoadDll(createInfo->path.z);
+        taosCloseDll(handle);
+        if (handle == NULL) {
+          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
+        }
       }
 
       //TODO CHECK CODE
@@ -2011,6 +2018,7 @@ int32_t validateSelectNodeList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pS
   const char* msg7 = "not support distinct mixed with groupby";
   const char* msg8 = "not support distinct in nest query";
   const char* msg9 = "_block_dist not support subquery, only support stable/table";
+  const char* msg10 = "not support group by in block func";
 
   // too many result columns not support order by in query
   if (taosArrayGetSize(pSelNodeList) > TSDB_MAX_COLUMNS) {
@@ -2045,6 +2053,10 @@ int32_t validateSelectNodeList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pS
         return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg9);
       }
 
+      if (pItem->pNode->functionId == TSDB_FUNC_BLKINFO && pQueryInfo->groupbyExpr.numOfGroupCols > 0) {
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg10);
+      }
+
       SUdfInfo* pUdfInfo = NULL;
       if (pItem->pNode->functionId < 0) {
         pUdfInfo = isValidUdf(pQueryInfo->pUdfInfo, pItem->pNode->Expr.operand.z, pItem->pNode->Expr.operand.n);
@@ -2440,6 +2452,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
   const char* msg10 = "derivative duration should be greater than 1 Second";
   const char* msg11 = "third parameter in derivative should be 0 or 1";
   const char* msg12 = "parameter is out of range [1, 100]";
+  const char* msg13 = "parameter list required";
 
   switch (functionId) {
     case TSDB_FUNC_COUNT: {
@@ -2586,6 +2599,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
         SColumnIndex indexTS = {.tableIndex = index.tableIndex, .columnIndex = 0};
         SExprInfo*   pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &indexTS, TSDB_DATA_TYPE_TIMESTAMP,
                                          TSDB_KEYSIZE, getNewResColId(pCmd), TSDB_KEYSIZE, false);
+        tstrncpy(pExpr->base.aliasName, aAggs[TSDB_FUNC_TS_DUMMY].name, sizeof(pExpr->base.aliasName));
 
         SColumnList ids = createColumnList(1, 0, 0);
         insertResultField(pQueryInfo, colIndex, &ids, TSDB_KEYSIZE, TSDB_DATA_TYPE_TIMESTAMP, aAggs[TSDB_FUNC_TS_DUMMY].name, pExpr);
@@ -3027,6 +3041,10 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
         return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg9);
       }
 
+      if (pItem->pNode->Expr.paramList == NULL || taosArrayGetSize(pItem->pNode->Expr.paramList) <= 0) {
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg13);        
+      }
+      
       tSqlExprItem* pParamElem = taosArrayGet(pItem->pNode->Expr.paramList, 0);;
       if (pParamElem->pNode->tokenId != TK_ID) {
         return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
@@ -3489,6 +3507,27 @@ static bool groupbyTagsOrNull(SQueryInfo* pQueryInfo) {
   return true;
 }
 
+bool groupbyTbname(SQueryInfo* pQueryInfo) {
+  if (pQueryInfo->groupbyExpr.columnInfo == NULL ||
+    taosArrayGetSize(pQueryInfo->groupbyExpr.columnInfo) == 0) {
+    return false;
+  }
+
+  size_t s = taosArrayGetSize(pQueryInfo->groupbyExpr.columnInfo);
+  for (int32_t i = 0; i < s; i++) {
+    SColIndex* colIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, i);
+    if (colIndex->colIndex == TSDB_TBNAME_COLUMN_INDEX) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+
+
+
+
 static bool functionCompatibleCheck(SQueryInfo* pQueryInfo, bool joinQuery, bool twQuery) {
   int32_t startIdx = 0;
   int32_t aggUdf = 0;
@@ -3661,7 +3700,7 @@ int32_t validateGroupbyNode(SQueryInfo* pQueryInfo, SArray* pList, SSqlCmd* pCmd
       tscColumnListInsert(pTableMetaInfo->tagColList, index.columnIndex, pTableMeta->id.uid, pSchema);
     } else {
       // check if the column type is valid, here only support the bool/tinyint/smallint/bigint group by
-      if (pSchema->type == TSDB_DATA_TYPE_TIMESTAMP || pSchema->type == TSDB_DATA_TYPE_FLOAT || pSchema->type == TSDB_DATA_TYPE_DOUBLE) {
+      if (pSchema->type == TSDB_DATA_TYPE_FLOAT || pSchema->type == TSDB_DATA_TYPE_DOUBLE) {
         return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
       }
 
@@ -7269,6 +7308,35 @@ int32_t doFunctionsCompatibleCheck(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, char*
   }
 }
 
+
+int32_t validateFunctionFromUpstream(SQueryInfo* pQueryInfo, char* msg) {
+  const char* msg1 = "TWA/Diff/Derivative/Irate are not allowed to apply to super table without group by tbname";
+
+  int32_t numOfExprs = (int32_t)tscNumOfExprs(pQueryInfo);
+  size_t upNum = taosArrayGetSize(pQueryInfo->pUpstream);
+  
+  for (int32_t i = 0; i < numOfExprs; ++i) {
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
+  
+    int32_t f = pExpr->base.functionId;
+    if (f == TSDB_FUNC_DERIVATIVE || f == TSDB_FUNC_TWA || f == TSDB_FUNC_IRATE || f == TSDB_FUNC_DIFF) {
+      for (int32_t j = 0; j < upNum; ++j) {
+        SQueryInfo* pUp = taosArrayGetP(pQueryInfo->pUpstream, j);
+        STableMetaInfo  *pTableMetaInfo = tscGetMetaInfo(pUp, 0);
+        bool isSTable = UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo);
+        if ((!isSTable) || groupbyTbname(pUp)) {
+          return TSDB_CODE_SUCCESS;
+        }
+      }
+    
+      return invalidOperationMsg(msg, msg1);
+    }
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
 int32_t doLocalQueryProcess(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlNode) {
   const char* msg1 = "only one expression allowed";
   const char* msg2 = "invalid expression in select clause";
@@ -8020,7 +8088,7 @@ int32_t tscGetExprFilters(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pSelect
   size_t n = tscNumOfExprs(pQueryInfo);
   *pExpr = tscExprGet(pQueryInfo, (int32_t)n - 1);
 
-  SInternalField* pField = taosArrayGet(pQueryInfo->fieldsInfo.internalField, n - 1);
+  SInternalField* pField = taosArrayGetLast(pQueryInfo->fieldsInfo.internalField);
   pField->visible = false;
 
   return TSDB_CODE_SUCCESS;
@@ -8274,6 +8342,10 @@ static int32_t getTableNameFromSubquery(SSqlNode* pSqlNode, SArray* tableNameLis
     int32_t num = (int32_t)taosArrayGetSize(sub->pSubquery);
     for (int32_t i = 0; i < num; ++i) {
       SSqlNode* p = taosArrayGetP(sub->pSubquery, i);
+      if (p->from == NULL) {
+        return TSDB_CODE_TSC_INVALID_OPERATION;
+      }
+      
       if (p->from->type == SQL_NODE_FROM_TABLELIST) {
         int32_t code = getTableNameFromSqlNode(p, tableNameList, msgBuf, pSql);
         if (code != TSDB_CODE_SUCCESS) {
@@ -8635,6 +8707,7 @@ static int32_t doValidateSubquery(SSqlNode* pSqlNode, int32_t index, SSqlObj* pS
   pSub->udfCopy = true;
 
   pSub->pDownstream = pQueryInfo;
+  taosArrayPush(pQueryInfo->pUpstream, &pSub);
   int32_t code = validateSqlNode(pSql, p, pSub);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
@@ -8658,8 +8731,6 @@ static int32_t doValidateSubquery(SSqlNode* pSqlNode, int32_t index, SSqlObj* pS
     tstrncpy(pTableMetaInfo1->aliasName, subInfo->aliasName.z, subInfo->aliasName.n + 1);
   }
 
-  taosArrayPush(pQueryInfo->pUpstream, &pSub);
-
   // NOTE: order mix up in subquery not support yet.
   pQueryInfo->order = pSub->order;
 
@@ -8851,6 +8922,10 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
       return code;
     }
 
+    if ((code = validateFunctionFromUpstream(pQueryInfo, tscGetErrorMsgPayload(pCmd))) != TSDB_CODE_SUCCESS) {
+      return code;
+    }
+
 //    updateFunctionInterBuf(pQueryInfo, false);
     updateLastScanOrderIfNeeded(pQueryInfo);
 

src/client/src/tscServer.c

@@ -423,9 +423,10 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {
     // 1. super table subquery
     // 2. nest queries are all not updated the tablemeta and retry parse the sql after cleanup local tablemeta/vgroup id buffer
     if ((TSDB_QUERY_HAS_TYPE(pQueryInfo->type, (TSDB_QUERY_TYPE_STABLE_SUBQUERY | TSDB_QUERY_TYPE_SUBQUERY |
-                                                TSDB_QUERY_TYPE_TAG_FILTER_QUERY)) &&
-         !TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_PROJECTION_QUERY)) ||
-        (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_NEST_SUBQUERY)) || (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_STABLE_SUBQUERY) &&  pQueryInfo->distinct)) {
+                                               TSDB_QUERY_TYPE_TAG_FILTER_QUERY)) &&
+                                               !TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_PROJECTION_QUERY)) ||
+                                               (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_NEST_SUBQUERY)) || (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_STABLE_SUBQUERY) &&  pQueryInfo->distinct)
+                                              || (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_JOIN_QUERY))) {
       // do nothing in case of super table subquery
     }  else {
       pSql->retry += 1;
@@ -1765,7 +1766,7 @@ static int tscLocalResultCommonBuilder(SSqlObj *pSql, int32_t numOfRes) {
       return pRes->code;
     }
 
-    tscSetResRawPtr(pRes, pQueryInfo);
+    tscSetResRawPtr(pRes, pQueryInfo, pRes->dataConverted);
   } else {
     tscResetForNextRetrieve(pRes);
   }
@@ -2229,6 +2230,7 @@ int tscProcessRetrieveFuncRsp(SSqlObj* pSql) {
 
   parQueryInfo->pUdfInfo = pQueryInfo->pUdfInfo;   // assigned to parent sql obj.
   pQueryInfo->pUdfInfo = NULL;
+  taosReleaseRef(tscObjRef, parent->self);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -2743,7 +2745,7 @@ int tscProcessRetrieveRspFromNode(SSqlObj *pSql) {
       (tscNonOrderedProjectionQueryOnSTable(pQueryInfo, 0) &&
        !TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_JOIN_QUERY) &&
        !TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_JOIN_SEC_STAGE))) {
-    tscSetResRawPtr(pRes, pQueryInfo);
+    tscSetResRawPtr(pRes, pQueryInfo, pRes->dataConverted);
   }
 
   if (pSql->pSubscription != NULL) {
@@ -2908,7 +2910,7 @@ int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVg
       pNew->self, numOfTable, numOfVgroupList, numOfUdf, pNew->cmd.payloadLen);
 
   pNew->fp = fp;
-  pNew->param = (void *)pSql->self;
+  pNew->param = (void *)pSql->rootObj->self;
 
   tscDebug("0x%"PRIx64" metaRid from 0x%" PRIx64 " to 0x%" PRIx64 , pSql->self, pSql->metaRid, pNew->self);
   
@@ -2928,6 +2930,7 @@ int32_t tscGetTableMetaImpl(SSqlObj* pSql, STableMetaInfo *pTableMetaInfo, bool
   tNameExtractFullName(&pTableMetaInfo->name, name);
 
   size_t len = strlen(name);
+
    // just make runtime happy
   if (pTableMetaInfo->tableMetaCapacity != 0 && pTableMetaInfo->pTableMeta != NULL) {
     memset(pTableMetaInfo->pTableMeta, 0, pTableMetaInfo->tableMetaCapacity);
@@ -2935,6 +2938,7 @@ int32_t tscGetTableMetaImpl(SSqlObj* pSql, STableMetaInfo *pTableMetaInfo, bool
 
   if (NULL == taosHashGetCloneExt(UTIL_GET_TABLEMETA(pSql), name, len, NULL, (void **)&(pTableMetaInfo->pTableMeta), &pTableMetaInfo->tableMetaCapacity)) {
     tfree(pTableMetaInfo->pTableMeta);
+     pTableMetaInfo->tableMetaCapacity = 0;
   }
   
   STableMeta* pMeta   = pTableMetaInfo->pTableMeta;
@@ -3056,7 +3060,13 @@ int tscRenewTableMeta(SSqlObj *pSql, int32_t tableIndex) {
   // remove stored tableMeta info in hash table
   tscResetSqlCmd(pCmd, true, pSql->self);
 
-  SArray* pNameList  = taosArrayInit(1, POINTER_BYTES);
+  SSqlCmd* pCmd2 = &pSql->rootObj->cmd;
+  pCmd2->pTableMetaMap = tscCleanupTableMetaMap(pCmd2->pTableMetaMap);
+  pCmd2->pTableMetaMap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
+  
+  pSql->rootObj->retryReason = pSql->retryReason;
+
+  SArray* pNameList = taosArrayInit(1, POINTER_BYTES);
   SArray* vgroupList = taosArrayInit(1, POINTER_BYTES);
 
   char* n = strdup(name);

src/client/src/tscSql.c

@@ -880,6 +880,7 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
 
   pSql->pTscObj  = taos;
   pSql->signature = pSql;
+  pSql->rootObj = pSql;
   SSqlCmd *pCmd = &pSql->cmd;
   
   pCmd->resColumnId = TSDB_RES_COL_ID;
@@ -988,6 +989,7 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
 
   pSql->pTscObj   = taos;
   pSql->signature = pSql;
+  pSql->rootObj = pSql;
 
   int32_t code = (uint8_t) tscTransferTableNameList(pSql, str, length, plist);
   free(str);

src/client/src/tscStream.c

@@ -682,6 +682,7 @@ TAOS_STREAM *taos_open_stream_withname(TAOS *taos, const char* dstTable, const c
 
   pSql->signature = pSql;
   pSql->pTscObj = pObj;
+  pSql->rootObj = pSql;
 
   SSqlCmd *pCmd = &pSql->cmd;
   SSqlRes *pRes = &pSql->res;

src/client/src/tscSub.c

@@ -127,6 +127,7 @@ static SSub* tscCreateSubscription(STscObj* pObj, const char* topic, const char*
   pSql->signature = pSql;
   pSql->pTscObj = pObj;
   pSql->pSubscription = pSub;
+  pSql->rootObj = pSql;
   pSub->pSql = pSql;
 
   SSqlCmd* pCmd = &pSql->cmd;

src/client/src/tscUtil.c

@@ -29,6 +29,7 @@
 #include "tsclient.h"
 #include "ttimer.h"
 #include "ttokendef.h"
+#include "httpInt.h"
 
 #ifdef HTTP_EMBEDDED
 #include "httpInt.h"
@@ -64,6 +65,21 @@ int32_t converToStr(char *str, int type, void *buf, int32_t bufSize, int32_t *le
     case TSDB_DATA_TYPE_TIMESTAMP:
       n = sprintf(str, "%" PRId64, *(int64_t*)buf);
       break;
+    case TSDB_DATA_TYPE_UTINYINT:
+      n = sprintf(str, "%d", *(uint8_t*)buf);
+      break;
+
+    case TSDB_DATA_TYPE_USMALLINT:
+      n = sprintf(str, "%d", *(uint16_t*)buf);
+      break;
+
+    case TSDB_DATA_TYPE_UINT:
+      n = sprintf(str, "%d", *(uint32_t*)buf);
+      break;
+
+    case TSDB_DATA_TYPE_UBIGINT:
+      n = sprintf(str, "%" PRId64, *(uint64_t*)buf);
+      break;
 
     case TSDB_DATA_TYPE_FLOAT:
       n = sprintf(str, "%e", GET_FLOAT_VAL(buf));
@@ -739,9 +755,13 @@ static void setResRawPtrImpl(SSqlRes* pRes, SInternalField* pInfo, int32_t i, bo
 
     memcpy(pRes->urow[i], pRes->buffer[i], pInfo->field.bytes * pRes->numOfRows);
   }
+
+  if (convertNchar) {
+    pRes->dataConverted = true;
+  }
 }
 
-void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
+void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo, bool converted) {
   assert(pRes->numOfCols > 0);
   if (pRes->numOfRows == 0) {
     return;
@@ -754,7 +774,7 @@ void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
     pRes->length[i] = pInfo->field.bytes;
 
     offset += pInfo->field.bytes;
-    setResRawPtrImpl(pRes, pInfo, i, true);
+    setResRawPtrImpl(pRes, pInfo, i, converted ? false : true);
   }
 }
 
@@ -1554,6 +1574,8 @@ void tscFreeSqlObj(SSqlObj* pSql) {
     return;
   }
 
+  int64_t sid = pSql->self;
+
   tscDebug("0x%"PRIx64" start to free sqlObj", pSql->self);
 
   pSql->res.code = TSDB_CODE_TSC_QUERY_CANCELLED;
@@ -1585,6 +1607,8 @@ void tscFreeSqlObj(SSqlObj* pSql) {
   tfree(pCmd->payload);
   pCmd->allocSize = 0;
 
+  tscDebug("0x%"PRIx64" addr:%p free completed", sid, pSql);
+
   tsem_destroy(&pSql->rspSem);
   memset(pSql, 0, sizeof(*pSql));
   free(pSql);
@@ -3613,6 +3637,7 @@ void tscResetForNextRetrieve(SSqlRes* pRes) {
 
   pRes->row = 0;
   pRes->numOfRows = 0;
+  pRes->dataConverted = false;
 }
 
 void tscInitResForMerge(SSqlRes* pRes) {
@@ -3642,6 +3667,7 @@ SSqlObj* createSimpleSubObj(SSqlObj* pSql, __async_cb_func_t fp, void* param, in
 
   pNew->pTscObj = pSql->pTscObj;
   pNew->signature = pNew;
+  pNew->rootObj = pSql->rootObj;
 
   SSqlCmd* pCmd = &pNew->cmd;
   pCmd->command = cmd;
@@ -3722,7 +3748,8 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
 
   pNew->pTscObj   = pSql->pTscObj;
   pNew->signature = pNew;
-  pNew->sqlstr    = strdup(pSql->sqlstr);
+  pNew->sqlstr    = strdup(pSql->sqlstr);  
+  pNew->rootObj   = pSql->rootObj;
   tsem_init(&pNew->rspSem, 0, 0);
 
   SSqlCmd* pnCmd  = &pNew->cmd;
@@ -3992,7 +4019,7 @@ static void tscSubqueryCompleteCallback(void* param, TAOS_RES* tres, int code) {
     int32_t index = ps->subqueryIndex;
     bool ret = subAndCheckDone(pSql, pParentSql, index);
 
-    tscFreeRetrieveSup(pSql);
+    tscFreeRetrieveSup(&pSql->param);
 
     if (!ret) {
       tscDebug("0x%"PRIx64" sub:0x%"PRIx64" orderOfSub:%d completed, not all subquery finished", pParentSql->self, pSql->self, index);
@@ -4011,23 +4038,26 @@ static void tscSubqueryCompleteCallback(void* param, TAOS_RES* tres, int code) {
     tscFreeSubobj(pParentSql);
     tfree(pParentSql->pSubs);
 
-    pParentSql->res.code = TSDB_CODE_SUCCESS;
-    pParentSql->retry++;
+    tscFreeSubobj(rootObj);
+    tfree(rootObj->pSubs);
+
+    rootObj->res.code = TSDB_CODE_SUCCESS;
+    rootObj->retry++;
 
-    tscDebug("0x%"PRIx64" retry parse sql and send query, prev error: %s, retry:%d", pParentSql->self,
-             tstrerror(code), pParentSql->retry);
+    tscDebug("0x%"PRIx64" retry parse sql and send query, prev error: %s, retry:%d", rootObj->self,
+             tstrerror(code), rootObj->retry);
 
 
-    tscResetSqlCmd(&pParentSql->cmd, true, pParentSql->self);
+    tscResetSqlCmd(&rootObj->cmd, true);
 
-    code = tsParseSql(pParentSql, true);
+    code = tsParseSql(rootObj, true);
     if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
       return;
     }
 
     if (code != TSDB_CODE_SUCCESS) {
-      pParentSql->res.code = code;
-      tscAsyncResultOnError(pParentSql);
+      rootObj->res.code = code;
+      tscAsyncResultOnError(rootObj);
       return;
     }
 
@@ -4036,6 +4066,16 @@ static void tscSubqueryCompleteCallback(void* param, TAOS_RES* tres, int code) {
     return;
   }
 
+  if (pSql->cmd.command == TSDB_SQL_RETRIEVE_EMPTY_RESULT) {
+    SSqlObj* pParentSql = ps->pParentSql;
+  
+    pParentSql->cmd.command = TSDB_SQL_RETRIEVE_EMPTY_RESULT;
+    
+    (*pParentSql->fp)(pParentSql->param, pParentSql, 0);
+    return;
+  }
+
+
   taos_fetch_rows_a(tres, tscSubqueryRetrieveCallback, param);
 }
 
@@ -4091,7 +4131,8 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
       pNew->sqlstr    = strdup(pSql->sqlstr);
       pNew->fp        = tscSubqueryCompleteCallback;
       pNew->fetchFp   = tscSubqueryCompleteCallback;
-      pNew->maxRetry  = pSql->maxRetry;
+      pNew->maxRetry  = pSql->maxRetry;      
+      pNew->rootObj   = pSql->rootObj;
 
       pNew->cmd.resColumnId = TSDB_RES_COL_ID;
 
@@ -5024,7 +5065,7 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
   }
 
   if (pQueryAttr->fillType != TSDB_FILL_NONE) {
-    pQueryAttr->fillVal = calloc(pQueryAttr->numOfOutput, sizeof(int64_t));
+    pQueryAttr->fillVal = calloc(pQueryInfo->numOfFillVal, sizeof(int64_t));
     memcpy(pQueryAttr->fillVal, pQueryInfo->fillVal, pQueryInfo->numOfFillVal * sizeof(int64_t));
   }
 
@@ -5258,3 +5299,31 @@ char* cloneCurrentDBName(SSqlObj* pSql) {
 
   return p;
 }
+
+char* cloneCurrentDBName(SSqlObj* pSql) {
+  char        *p = NULL;
+  HttpContext *pCtx = NULL;
+
+  pthread_mutex_lock(&pSql->pTscObj->mutex);
+  STscObj *pTscObj = pSql->pTscObj;
+  switch (pTscObj->from) {
+  case TAOS_REQ_FROM_HTTP:
+    pCtx = pSql->param;
+    if (pCtx && pCtx->db[0] != '\0') {
+      char db[TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN] = {0};
+      int32_t len = sprintf(db, "%s%s%s", pTscObj->acctId, TS_PATH_DELIMITER, pCtx->db);
+      assert(len <= sizeof(db));
+
+      p = strdup(db);
+    }
+    break;
+  default:
+    break;
+  }
+  if (p == NULL) {
+    p = strdup(pSql->pTscObj->db);
+  }
+  pthread_mutex_unlock(&pSql->pTscObj->mutex);
+
+  return p;
+}

src/common/src/tglobal.c

@@ -91,7 +91,7 @@ int8_t  tsTscEnableRecordSql = 0;
 
 // the maximum number of results for projection query on super table that are returned from
 // one virtual node, to order according to timestamp
-int32_t tsMaxNumOfOrderedResults = 100000;
+int32_t tsMaxNumOfOrderedResults = 1000000;
 
 // 10 ms for sliding time, the value will changed in case of time precision changed
 int32_t tsMinSlidingTime = 10;
@@ -681,16 +681,6 @@ static void doInitGlobalConfig(void) {
   cfg.unitType = TAOS_CFG_UTYPE_MS;
   taosInitConfigOption(cfg);
 
-  cfg.option = "rpcForceTcp";
-  cfg.ptr = &tsRpcForceTcp;
-  cfg.valType = TAOS_CFG_VTYPE_INT32;
-  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_CLIENT;
-  cfg.minValue = 0;
-  cfg.maxValue = 1;
-  cfg.ptrLength = 0;
-  cfg.unitType = TAOS_CFG_UTYPE_NONE;
-  taosInitConfigOption(cfg);
-
   cfg.option = "rpcMaxTime";
   cfg.ptr = &tsRpcMaxTime;
   cfg.valType = TAOS_CFG_VTYPE_INT32;
@@ -701,6 +691,16 @@ static void doInitGlobalConfig(void) {
   cfg.unitType = TAOS_CFG_UTYPE_SECOND;
   taosInitConfigOption(cfg);
 
+  cfg.option = "rpcForceTcp";
+  cfg.ptr = &tsRpcForceTcp;
+  cfg.valType = TAOS_CFG_VTYPE_INT32;
+  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_CLIENT;
+  cfg.minValue = 0;
+  cfg.maxValue = 1;
+  cfg.ptrLength = 0;
+  cfg.unitType = TAOS_CFG_UTYPE_NONE;
+  taosInitConfigOption(cfg);
+
   cfg.option = "statusInterval";
   cfg.ptr = &tsStatusInterval;
   cfg.valType = TAOS_CFG_VTYPE_INT32;
@@ -1056,8 +1056,8 @@ static void doInitGlobalConfig(void) {
   cfg.ptr = &tsMaxNumOfOrderedResults;
   cfg.valType = TAOS_CFG_VTYPE_INT32;
   cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_CLIENT | TSDB_CFG_CTYPE_B_SHOW;
-  cfg.minValue = TSDB_MAX_SQL_LEN;
-  cfg.maxValue = TSDB_MAX_ALLOWED_SQL_LEN;
+  cfg.minValue = 100000;
+  cfg.maxValue = 100000000;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
   taosInitConfigOption(cfg);
@@ -1256,10 +1256,10 @@ static void doInitGlobalConfig(void) {
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
   taosInitConfigOption(cfg);
 
-  cfg.option = "topicBianryLen";
+  cfg.option = "topicBinaryLen";
   cfg.ptr = &tsTopicBianryLen;
   cfg.valType = TAOS_CFG_VTYPE_INT32;
-  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG;
+  cfg.cfgType = TSDB_CFG_CTYPE_B_CONFIG | TSDB_CFG_CTYPE_B_SHOW;
   cfg.minValue = 16;
   cfg.maxValue = 16000;
   cfg.ptrLength = 0;
@@ -1671,8 +1671,6 @@ static void doInitGlobalConfig(void) {
   cfg.maxValue = MAX_FLOAT;
   cfg.ptrLength = 0;
   cfg.unitType = TAOS_CFG_UTYPE_NONE;
-
-  
   taosInitConfigOption(cfg);
 
   cfg.option = "dPrecision";

src/connector/python/taos/cinterface.py

@@ -178,6 +178,8 @@ def taos_connect(host=None, user="root", password="taosdata", db=None, port=0):
         raise ConnectionError("connect to TDengine failed")
     return connection
 
+_libtaos.taos_connect_auth.restype = c_void_p
+_libtaos.taos_connect_auth.argtypes = c_char_p, c_char_p, c_char_p, c_char_p, c_uint16
 
 _libtaos.taos_connect_auth.restype = c_void_p
 _libtaos.taos_connect_auth.argtypes = c_char_p, c_char_p, c_char_p, c_char_p, c_uint16
@@ -231,7 +233,6 @@ def taos_connect_auth(host=None, user="root", auth="", db=None, port=0):
         raise ConnectionError("connect to TDengine failed")
     return connection
 
-
 _libtaos.taos_query.restype = c_void_p
 _libtaos.taos_query.argtypes = c_void_p, c_char_p
 
@@ -283,7 +284,6 @@ def taos_affected_rows(result):
     """The affected rows after runing query"""
     return _libtaos.taos_affected_rows(result)
 
-
 subscribe_callback_type = CFUNCTYPE(None, c_void_p, c_void_p, c_void_p, c_int)
 _libtaos.taos_subscribe.restype = c_void_p
 # _libtaos.taos_subscribe.argtypes = c_void_p, c_int, c_char_p, c_char_p, subscribe_callback_type, c_void_p, c_int
@@ -597,7 +597,6 @@ def taos_stmt_init(connection):
     """
     return c_void_p(_libtaos.taos_stmt_init(connection))
 
-
 _libtaos.taos_stmt_prepare.restype = c_int
 _libtaos.taos_stmt_prepare.argstype = (c_void_p, c_char_p, c_int)
 
@@ -616,7 +615,6 @@ def taos_stmt_prepare(stmt, sql):
 _libtaos.taos_stmt_close.restype = c_int
 _libtaos.taos_stmt_close.argstype = (c_void_p,)
 
-
 def taos_stmt_close(stmt):
     # type: (ctypes.c_void_p) -> None
     """Close a statement query
@@ -626,6 +624,11 @@ def taos_stmt_close(stmt):
     if res != 0:
         raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
 
+try:
+    _libtaos.taos_stmt_errstr.restype = c_char_p
+    _libtaos.taos_stmt_errstr.argstype = (c_void_p,)
+except AttributeError:
+    print("WARNING: libtaos(%s) does not support taos_stmt_errstr" % taos_get_client_info())
 
 try:
     _libtaos.taos_stmt_errstr.restype = c_char_p
@@ -667,7 +670,6 @@ except AttributeError:
     print("WARNING: libtaos(%s) does not support taos_stmt_set_tbname_tags" % taos_get_client_info())
 
 
-
 def taos_stmt_set_tbname_tags(stmt, name, tags):
     # type: (c_void_p, str, c_void_p) -> None
     """Set table name with tags bind params.
@@ -678,7 +680,6 @@ def taos_stmt_set_tbname_tags(stmt, name, tags):
     if res != 0:
         raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
 
-
 _libtaos.taos_stmt_is_insert.restype = c_int
 _libtaos.taos_stmt_is_insert.argstype = (c_void_p, POINTER(c_int))
 
@@ -698,7 +699,6 @@ def taos_stmt_is_insert(stmt):
 _libtaos.taos_stmt_num_params.restype = c_int
 _libtaos.taos_stmt_num_params.argstype = (c_void_p, POINTER(c_int))
 
-
 def taos_stmt_num_params(stmt):
     # type: (ctypes.c_void_p) -> int
     """Params number of the current statement query.
@@ -710,7 +710,6 @@ def taos_stmt_num_params(stmt):
         raise StatementError(msg=taos_stmt_errstr(stmt), errno=res)
     return num_params.value
 
-
 _libtaos.taos_stmt_bind_param.restype = c_int
 _libtaos.taos_stmt_bind_param.argstype = (c_void_p, c_void_p)
 
@@ -809,15 +808,15 @@ def taos_stmt_use_result(stmt):
     return result
 
 try:
-    _libtaos.taos_schemaless_insert.restype = c_int
-    _libtaos.taos_schemaless_insert.argstype = c_void_p, c_void_p, c_int
+    _libtaos.taos_insert_lines.restype = c_int
+    _libtaos.taos_insert_lines.argstype = c_void_p, c_void_p, c_int
 except AttributeError:
-    print("WARNING: libtaos(%s) does not support schemaless_insert" % taos_get_client_info())
+    print("WARNING: libtaos(%s) does not support insert_lines" % taos_get_client_info())
 
 
 
 
-def taos_schemaless_insert(connection, lines, protocol):
+def taos_insert_lines(connection, lines):
     # type: (c_void_p, list[str] | tuple(str)) -> None
     num_of_lines = len(lines)
     lines = (c_char_p(line.encode("utf-8")) for line in lines)

src/connector/python/taos/error.py

@@ -84,3 +84,19 @@ class SchemalessError(DatabaseError):
     """taos_schemaless_insert errors."""
 
     pass
+
+
+class StatementError(DatabaseError):
+    """Exception raised in STMT API."""
+
+    pass
+
+class ResultError(DatabaseError):
+    """Result related APIs."""
+
+    pass
+
+class LinesError(DatabaseError):
+    """taos_insert_lines errors."""
+
+    pass
\ No newline at end of file

src/inc/taosmsg.h

@@ -206,11 +206,6 @@ typedef struct {
   uint16_t port;
 } SEpAddrMsg;
 
-typedef struct {
-  char*    fqdn;
-  uint16_t port;
-} SEpAddr1;
-
 typedef struct {
   int32_t numOfVnodes;
 } SMsgDesc;
@@ -768,7 +763,7 @@ typedef struct {
   int32_t    vgId;
   int8_t     numOfEps;
   SEpAddrMsg epAddr[TSDB_MAX_REPLICA];
-} SVgroupMsg;
+} SVgroupMsg, SVgroupInfo;
 
 typedef struct {
   int32_t numOfVgroups;

src/kit/shell/CMakeLists.txt

@@ -34,6 +34,8 @@ ELSEIF (TD_WINDOWS)
 
   IF (TD_POWER)
     SET_TARGET_PROPERTIES(shell PROPERTIES OUTPUT_NAME power)
+  ELSEIF (TD_PRO)
+    SET_TARGET_PROPERTIES(shell PROPERTIES OUTPUT_NAME prodbc)
   ELSE ()
     SET_TARGET_PROPERTIES(shell PROPERTIES OUTPUT_NAME taos)
   ENDIF ()

src/kit/shell/src/shellCheck.c

@@ -111,6 +111,7 @@ static void *shellCheckThreadFp(void *arg) {
   int32_t start = pThread->threadIndex * interval;
   int32_t end = (pThread->threadIndex + 1) * interval;
 
+  if (start >= tbNum) return NULL;
   if (end > tbNum) end = tbNum + 1;
 
   char file[32] = {0};
@@ -193,9 +194,11 @@ void shellCheck(TAOS *con, SShellArguments *_args) {
     return;
   }
 
-  fprintf(stdout, "total %d tables will be checked by %d threads\n", tbNum, _args->threadNum);
-  shellRunCheckThreads(con, _args);
-
+  if (tbNum > 0) {
+    fprintf(stdout, "total %d tables will be checked by %d threads\n", tbNum, _args->threadNum);
+    shellRunCheckThreads(con, _args);
+  }
+  
   int64_t end = taosGetTimestampMs();
   fprintf(stdout, "total %d tables checked, failed:%d, time spent %.2f seconds\n", checkedNum, errorNum,
           (end - start) / 1000.0);

src/kit/shell/src/shellEngine.c

@@ -1044,56 +1044,4 @@ void source_file(TAOS *con, char *fptr) {
 
 void shellGetGrantInfo(void *con) {
   return;
-#if 0
-  char sql[] = "show grants";
-
-  TAOS_RES* tres = taos_query(con, sql);
-
-  int code = taos_errno(tres);
-  if (code != TSDB_CODE_SUCCESS) {
-    if (code == TSDB_CODE_COM_OPS_NOT_SUPPORT) {
-      fprintf(stdout, "Server is Community Edition, version is %s\n\n", taos_get_server_info(con));
-    } else {
-      fprintf(stderr, "Failed to check Server Edition, Reason:%d:%s\n\n", taos_errno(con), taos_errstr(con));
-    }
-    return;
-  }
-
-  int num_fields = taos_field_count(tres);
-  if (num_fields == 0) {
-    fprintf(stderr, "\nInvalid grant information.\n");
-    exit(0);
-  } else {
-    if (tres == NULL) {
-      fprintf(stderr, "\nGrant information is null.\n");
-      exit(0);
-    }
-
-    TAOS_FIELD *fields = taos_fetch_fields(tres);
-    TAOS_ROW row = taos_fetch_row(tres);
-    if (row == NULL) {
-      fprintf(stderr, "\nFailed to get grant information from server. Abort.\n");
-      exit(0);
-    }
-
-    char serverVersion[32] = {0};
-    char expiretime[32] = {0};
-    char expired[32] = {0};
-
-    memcpy(serverVersion, row[0], fields[0].bytes);
-    memcpy(expiretime, row[1], fields[1].bytes);
-    memcpy(expired, row[2], fields[2].bytes);
-
-    if (strcmp(expiretime, "unlimited") == 0) {
-      fprintf(stdout, "Server is Enterprise %s Edition, version is %s and will never expire.\n", serverVersion, taos_get_server_info(con));
-    } else {
-      fprintf(stdout, "Server is Enterprise %s Edition, version is %s and will expire at %s.\n", serverVersion, taos_get_server_info(con), expiretime);
-    }
-
-    result = NULL;
-    taos_free_result(tres);
-  }
-
-  fprintf(stdout, "\n");
-  #endif
 }

src/kit/shell/src/shellImport.c

@@ -210,7 +210,7 @@ static void shellSourceFile(TAOS *con, char *fptr) {
     /* free local resouce: allocated memory/metric-meta refcnt */
     taos_free_result(pSql);
 
-    memset(cmd, 0, MAX_COMMAND_SIZE);
+    memset(cmd, 0, tsMaxSQLStringLen);
     cmd_len = 0;
   }
 

src/kit/taosdump/taosdump.c

@@ -1159,7 +1159,6 @@ static int64_t dumpNormalTable(
 
         // create child-table using super-table
         dumpCreateMTableClause(dbName, stable, tableDes, colCount, fp);
-
     } else {  // dump table definition
         colCount = getTableDes(dbName, tbName, tableDes, false);
 

src/kit/taospack/taospack.c

@@ -712,6 +712,15 @@ void leakTest(){
 }
 
 #define DB_CNT 500
+void test_same_float(int algo, bool lossy){
+  float ori =  123.456789123;
+  float floats [DB_CNT];
+  for(int i=0; i< DB_CNT; i++){
+    floats[i] = ori;
+  } 
+  DoFloat(floats, DB_CNT, algo, lossy);
+}
+
 void test_same_double(int algo){
   double ori =  3.1415926;
 
@@ -721,7 +730,6 @@ void test_same_double(int algo){
   } 
 
   DoDouble(doubles, DB_CNT, algo);
-
 }
 
 #ifdef TD_TSZ
@@ -781,6 +789,10 @@ int main(int argc, char *argv[]) {
         return 0;
     }
 
+   if(strcmp(argv[1], "-samef") == 0) {
+        test_same_float(atoi(argv[2]), true);
+        return 0;
+    }
    if(strcmp(argv[1], "-samed") == 0) {
         test_same_double(atoi(argv[2]));
         return 0;

src/query/inc/qAggMain.h

@@ -197,6 +197,7 @@ typedef struct SQLFunctionCtx {
 
   SResultRowCellInfo *resultInfo;
 
+  int16_t      colId;
   SExtTagsInfo tagInfo;
   SPoint1      start;
   SPoint1      end;

src/query/inc/qHistogram.h

@@ -67,7 +67,7 @@ void tHistogramDestroy(SHistogramInfo** pHisto);
 
 void tHistogramPrint(SHistogramInfo* pHisto);
 
-int32_t histoBinarySearch(SHistBin* pEntry, int32_t len, double val);
+int32_t histoBinarySearch(SHistBin* pEntry, int32_t len, double val, int32_t maxEntries);
 
 SHeapEntry* tHeapCreate(int32_t numOfEntries);
 void tHeapSort(SHeapEntry* pEntry, int32_t len);

src/query/inc/sql.y

@@ -98,11 +98,11 @@ cmd ::= SHOW CREATE TABLE ids(X) cpxName(Y).    {
 cmd ::= SHOW CREATE STABLE ids(X) cpxName(Y).    {
    X.n += Y.n;
    setDCLSqlElems(pInfo, TSDB_SQL_SHOW_CREATE_STABLE, 1, &X);
-}    
+}
 
 cmd ::= SHOW CREATE DATABASE ids(X). {
   setDCLSqlElems(pInfo, TSDB_SQL_SHOW_CREATE_DATABASE, 1, &X);
-} 
+}
 
 cmd ::= SHOW dbPrefix(X) TABLES.         {
     setShowOptions(pInfo, TSDB_MGMT_TABLE_TABLE, &X, 0);
@@ -278,7 +278,7 @@ wal(Y)     ::= WAL INTEGER(X).                { Y = X; }
 fsync(Y)   ::= FSYNC INTEGER(X).              { Y = X; }
 comp(Y)    ::= COMP INTEGER(X).               { Y = X; }
 prec(Y)    ::= PRECISION STRING(X).           { Y = X; }
-update(Y)  ::= UPDATE INTEGER(X).             { Y = X; }     
+update(Y)  ::= UPDATE INTEGER(X).             { Y = X; }
 cachelast(Y) ::= CACHELAST INTEGER(X).        { Y = X; }
 partitions(Y) ::= PARTITIONS INTEGER(X).      { Y = X; }
 
@@ -327,7 +327,7 @@ alter_topic_optr(Y) ::= alter_db_optr(Z).                       { Y = Z; Y.dbTyp
 alter_topic_optr(Y) ::= alter_topic_optr(Z) partitions(X).      { Y = Z; Y.partitions = strtol(X.z, NULL, 10); }
 
 %type typename {TAOS_FIELD}
-typename(A) ::= ids(X). { 
+typename(A) ::= ids(X). {
   X.type = 0;
   tSetColumnType (&A, &X);
 }

src/query/src/qAggMain.c

@@ -3752,7 +3752,7 @@ static void interp_function_impl(SQLFunctionCtx *pCtx) {
 
   bool ascQuery = (pCtx->order == TSDB_ORDER_ASC);
 
-  if (pCtx->inputType == TSDB_DATA_TYPE_TIMESTAMP) {
+  if (pCtx->colId == 0 && pCtx->inputType == TSDB_DATA_TYPE_TIMESTAMP) {
     *(TSKEY *)pCtx->pOutput = pCtx->startTs;
   } else if (type == TSDB_FILL_NULL) {
     setNull(pCtx->pOutput, pCtx->outputType, pCtx->outputBytes);
@@ -3789,6 +3789,10 @@ static void interp_function_impl(SQLFunctionCtx *pCtx) {
         }
       }
     } else {
+      if (GET_RES_INFO(pCtx)->numOfRes > 0) {
+        return;
+      }
+    
       // no data generated yet
       if (pCtx->size < 1) {
         return;
@@ -3818,11 +3822,15 @@ static void interp_function_impl(SQLFunctionCtx *pCtx) {
           if (pCtx->size > 1) {
             ekey = GET_TS_DATA(pCtx, 1);
             if ((ascQuery && ekey < pCtx->startTs) || ((!ascQuery) && ekey > pCtx->startTs)) {
+              setNull(pCtx->pOutput, pCtx->inputType, pCtx->inputBytes);
+              SET_VAL(pCtx, 1, 1);
               return;
             }
 
             val = ((char*)pCtx->pInput) + pCtx->inputBytes;            
           } else {
+            setNull(pCtx->pOutput, pCtx->inputType, pCtx->inputBytes);
+            SET_VAL(pCtx, 1, 1);
             return;
           }
         } else {
@@ -3867,7 +3875,7 @@ static void interp_function_impl(SQLFunctionCtx *pCtx) {
   SET_VAL(pCtx, 1, 1);
 }
 
-static void interp_function(SQLFunctionCtx *pCtx) {
+static void interp_function(SQLFunctionCtx *pCtx) {  
   // at this point, the value is existed, return directly
   if (pCtx->size > 0) {
     bool ascQuery = (pCtx->order == TSDB_ORDER_ASC);
@@ -4112,11 +4120,23 @@ static void irate_function(SQLFunctionCtx *pCtx) {
     double v = 0;
     GET_TYPED_DATA(v, double, pCtx->inputType, pData);
 
-    if ((INT64_MIN == pRateInfo->lastKey) || primaryKey[i] > pRateInfo->lastKey) {
+    if (INT64_MIN == pRateInfo->lastKey) {
       pRateInfo->lastValue = v;
       pRateInfo->lastKey   = primaryKey[i];
       continue;
     }
+
+    if (primaryKey[i] > pRateInfo->lastKey) {
+      if ((INT64_MIN == pRateInfo->firstKey) || pRateInfo->lastKey > pRateInfo->firstKey) {
+        pRateInfo->firstValue = pRateInfo->lastValue;
+        pRateInfo->firstKey = pRateInfo->lastKey;
+      }
+
+      pRateInfo->lastValue = v;
+      pRateInfo->lastKey   = primaryKey[i];
+      
+      continue;
+    }
     
     if ((INT64_MIN == pRateInfo->firstKey) || primaryKey[i] > pRateInfo->firstKey) {
       pRateInfo->firstValue = v;

src/query/src/qExecutor.c

@@ -776,6 +776,16 @@ static void setResultRowInterpo(SResultRow* pResult, SResultTsInterpType type) {
   }
 }
 
+static void unsetResultRowInterpo(SResultRow* pResult, SResultTsInterpType type) {
+  assert(pResult != NULL && (type == RESULT_ROW_START_INTERP || type == RESULT_ROW_END_INTERP));
+  if (type == RESULT_ROW_START_INTERP) {
+    pResult->startInterp = false;
+  } else {
+    pResult->endInterp   = false;
+  }
+}
+
+
 static bool resultRowInterpolated(SResultRow* pResult, SResultTsInterpType type) {
   assert(pResult != NULL && (type == RESULT_ROW_START_INTERP || type == RESULT_ROW_END_INTERP));
   if (type == RESULT_ROW_START_INTERP) {
@@ -1239,6 +1249,7 @@ static void doSetInputDataBlock(SOperatorInfo* pOperator, SQLFunctionCtx* pCtx,
 
         // in case of the block distribution query, the inputBytes is not a constant value.
         pCtx[i].pInput = p->pData;
+        pCtx[i].colId  = p->info.colId;
         assert(p->info.colId == pColIndex->colId && pCtx[i].inputType == p->info.type);
 
         if (pCtx[i].functionId < 0) {
@@ -1387,6 +1398,11 @@ static bool setTimeWindowInterpolationStartTs(SOperatorInfo* pOperatorInfo, SQLF
 
   bool ascQuery = QUERY_IS_ASC_QUERY(pQueryAttr);
 
+  if (pos < 0 && !ascQuery) {
+    setNotInterpoWindowKey(pCtx, pOperatorInfo->numOfOutput, RESULT_ROW_START_INTERP);
+    return true;
+  }
+
   TSKEY curTs  = tsCols[pos];
   TSKEY lastTs = *(TSKEY *) pRuntimeEnv->prevRow[0];
 
@@ -1622,6 +1638,7 @@ static void hashAllIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pRe
   }
 
   int32_t startPos = ascQuery? 0 : (pSDataBlock->info.rows - 1);
+  int32_t ostartPos = 0;
   TSKEY ts = getStartTsKey(pQueryAttr, &pSDataBlock->info.window, tsCols, pSDataBlock->info.rows);
 
   STimeWindow win = getCurrentActiveTimeWindow(pResultRowInfo, ts, pQueryAttr);
@@ -1630,7 +1647,7 @@ static void hashAllIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pRe
   SResultRow* pResult = NULL;
   int32_t forwardStep = 0;
   int32_t ret = 0;
-  STimeWindow preWin = win;
+  //STimeWindow preWin = win;
 
   while (1) {
     // null data, failed to allocate more memory buffer
@@ -1644,11 +1661,17 @@ static void hashAllIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pRe
     forwardStep = getNumOfRowsInTimeWindow(pRuntimeEnv, &pSDataBlock->info, tsCols, startPos, ekey, binarySearchForKey, true);
 
     // window start(end) key interpolation
+    unsetResultRowInterpo(pResult, RESULT_ROW_START_INTERP);
+    ostartPos = startPos;
+
+    if (!ascQuery) {
+      startPos += forwardStep * step;
+    }
+    
     doWindowBorderInterpolation(pOperatorInfo, pSDataBlock, pInfo->pCtx, pResult, &win, startPos, forwardStep);
-    doApplyFunctions(pRuntimeEnv, pInfo->pCtx, ascQuery ? &win : &preWin, startPos, forwardStep, tsCols, pSDataBlock->info.rows, numOfOutput);
-    preWin = win;
+    doApplyFunctions(pRuntimeEnv, pInfo->pCtx, &win, ostartPos, forwardStep, tsCols, pSDataBlock->info.rows, numOfOutput);
 
-    int32_t prevEndPos = (forwardStep - 1) * step + startPos;
+    int32_t prevEndPos = (!ascQuery) ? startPos - step : (forwardStep - 1) * step + startPos;
     startPos = getNextQualifiedWindow(pQueryAttr, &win, &pSDataBlock->info, tsCols, binarySearchForKey, prevEndPos);
     if (startPos < 0) {
       if ((ascQuery && win.skey <= pQueryAttr->window.ekey) || ((!ascQuery) && win.ekey >= pQueryAttr->window.ekey)) {
@@ -1658,11 +1681,16 @@ static void hashAllIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pRe
           longjmp(pRuntimeEnv->env, TSDB_CODE_QRY_OUT_OF_MEMORY);
         }
 
-        startPos = pSDataBlock->info.rows - 1;
+        if (ascQuery) {
+          startPos = pSDataBlock->info.rows - 1;
+        } else {
+          startPos = 0;
+        }
 
-        // window start(end) key interpolation
-        doWindowBorderInterpolation(pOperatorInfo, pSDataBlock, pInfo->pCtx, pResult, &win, startPos, forwardStep);
-        doApplyFunctions(pRuntimeEnv, pInfo->pCtx, ascQuery ? &win : &preWin, startPos, forwardStep, tsCols, pSDataBlock->info.rows, numOfOutput);
+        forwardStep = 1;
+        unsetResultRowInterpo(pResult, RESULT_ROW_START_INTERP);
+        setNotInterpoWindowKey(pInfo->pCtx, pQueryAttr->numOfOutput, RESULT_ROW_START_INTERP);
+        doApplyFunctions(pRuntimeEnv, pInfo->pCtx, &win, startPos, forwardStep, tsCols, pSDataBlock->info.rows, numOfOutput);
       }
 
       break;
@@ -2129,6 +2157,7 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
 
   pRuntimeEnv->pResultRowHashTable = taosHashInit(numOfTables, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
   pRuntimeEnv->pResultRowListSet = taosHashInit(numOfTables * 10, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
+  pRuntimeEnv->pResultRowArrayList = taosArrayInit(numOfTables, sizeof(SResultRowCell));
   pRuntimeEnv->keyBuf  = malloc(pQueryAttr->maxTableColumnWidth + sizeof(int64_t) + POINTER_BYTES);
   pRuntimeEnv->pool    = initResultRowPool(getResultRowSize(pRuntimeEnv));
   pRuntimeEnv->pResultRowArrayList = taosArrayInit(numOfTables, sizeof(SResultRowCell));
@@ -2405,6 +2434,7 @@ static void teardownQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv) {
   destroyOperatorInfo(pRuntimeEnv->proot);
 
   pRuntimeEnv->pool = destroyResultRowPool(pRuntimeEnv->pool);
+  taosArrayDestroy(pRuntimeEnv->pResultRowArrayList);
   taosArrayDestroyEx(pRuntimeEnv->prevResult, freeInterResult);
   taosArrayDestroy(pRuntimeEnv->pResultRowArrayList);
   pRuntimeEnv->prevResult = NULL;
@@ -3562,7 +3592,7 @@ void copyToSDataBlock(SQueryRuntimeEnv* pRuntimeEnv, int32_t threshold, SSDataBl
   }
 }
 
-static void updateTableQueryInfoForReverseScan(STableQueryInfo *pTableQueryInfo) {
+static void updateTableQueryInfoForReverseScan(STableQueryInfo *pTableQueryInfo, int64_t qId) {
   if (pTableQueryInfo == NULL) {
     return;
   }
@@ -3573,6 +3603,9 @@ static void updateTableQueryInfoForReverseScan(STableQueryInfo *pTableQueryInfo)
   SWITCH_ORDER(pTableQueryInfo->cur.order);
   pTableQueryInfo->cur.vgroupIndex = -1;
 
+  qDebug("0x%"PRIx64" update query window for reverse scan, %"PRId64" - %"PRId64", lastKey:%"PRId64, qId, pTableQueryInfo->win.skey, pTableQueryInfo->win.ekey,
+    pTableQueryInfo->lastKey);
+
   // set the index to be the end slot of result rows array
   SResultRowInfo* pResultRowInfo = &pTableQueryInfo->resInfo;
   if (pResultRowInfo->size > 0) {
@@ -3593,7 +3626,7 @@ static void setupQueryRangeForReverseScan(SQueryRuntimeEnv* pRuntimeEnv) {
     size_t t = taosArrayGetSize(group);
     for (int32_t j = 0; j < t; ++j) {
       STableQueryInfo *pCheckInfo = taosArrayGetP(group, j);
-      updateTableQueryInfoForReverseScan(pCheckInfo);
+      updateTableQueryInfoForReverseScan(pCheckInfo, GET_QID(pRuntimeEnv));
 
       // update the last key in tableKeyInfo list, the tableKeyInfo is used to build the tsdbQueryHandle and decide
       // the start check timestamp of tsdbQueryHandle
@@ -4142,7 +4175,7 @@ void setParamForStableStddevByColData(SQueryRuntimeEnv* pRuntimeEnv, SQLFunction
  *    merged during merge stage. In this case, we need the pTableQueryInfo->lastResRows to decide if there
  *    is a previous result generated or not.
  */
-void setIntervalQueryRange(SQueryRuntimeEnv *pRuntimeEnv, TSKEY key) {
+void setIntervalQueryRange(SQueryRuntimeEnv *pRuntimeEnv, STimeWindow* winx, int32_t tid) {
   SQueryAttr           *pQueryAttr = pRuntimeEnv->pQueryAttr;
   STableQueryInfo  *pTableQueryInfo = pRuntimeEnv->current;
   SResultRowInfo   *pResultRowInfo = &pTableQueryInfo->resInfo;
@@ -4151,9 +4184,14 @@ void setIntervalQueryRange(SQueryRuntimeEnv *pRuntimeEnv, TSKEY key) {
     return;
   }
 
+  TSKEY key = QUERY_IS_ASC_QUERY(pQueryAttr)? winx->skey:winx->ekey;
+  
+  qDebug("0x%"PRIx64" update query window, tid:%d, %"PRId64" - %"PRId64", old:%"PRId64" - %"PRId64, GET_QID(pRuntimeEnv), tid, key, pTableQueryInfo->win.ekey,
+  pTableQueryInfo->win.skey, pTableQueryInfo->win.ekey);
+
   pTableQueryInfo->win.skey = key;
   STimeWindow win = {.skey = key, .ekey = pQueryAttr->window.ekey};
-
+    
   /**
    * In handling the both ascending and descending order super table query, we need to find the first qualified
    * timestamp of this table, and then set the first qualified start timestamp.
@@ -5399,7 +5437,7 @@ SArray* getResultGroupCheckColumns(SQueryAttr* pQuery) {
 
       // TSDB_FUNC_TAG_DUMMY function needs to be ignored
       if (index->colId == pExpr->colInfo.colId &&
-          ((TSDB_COL_IS_TAG(pExpr->colInfo.flag) && pExpr->functionId == TSDB_FUNC_TAG) ||
+          ((TSDB_COL_IS_TAG(pExpr->colInfo.flag) && ((pExpr->functionId == TSDB_FUNC_TAG) || (pExpr->functionId == TSDB_FUNC_TAGPRJ))) ||
            (TSDB_COL_IS_NORMAL_COL(pExpr->colInfo.flag) && pExpr->functionId == TSDB_FUNC_PRJ))) {
         index->colIndex = j;
         index->colId = pExpr->resColId;
@@ -5602,8 +5640,10 @@ static SSDataBlock* doSort(void* param, bool* newgroup) {
   }
 
   __compar_fn_t  comp = getKeyComparFunc(pSchema[pInfo->colIndex].type, pInfo->order);
-  taoscQSort(pCols, pSchema, numOfCols, pInfo->pDataBlock->info.rows, pInfo->colIndex, comp);
-
+  if (pInfo->pDataBlock->info.rows) {
+    taoscQSort(pCols, pSchema, numOfCols, pInfo->pDataBlock->info.rows, pInfo->colIndex, comp);
+  }
+  
   tfree(pCols);
   tfree(pSchema);
   return (pInfo->pDataBlock->info.rows > 0)? pInfo->pDataBlock:NULL;
@@ -5822,7 +5862,7 @@ static SSDataBlock* doProjectOperation(void* param, bool* newgroup) {
     publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
 
     if (pBlock == NULL) {
-      assert(*newgroup == false);
+      //assert(*newgroup == false);
 
       *newgroup = prevVal;
       setQueryStatus(pRuntimeEnv, QUERY_COMPLETED);
@@ -6112,7 +6152,7 @@ static SSDataBlock* doSTableIntervalAgg(void* param, bool* newgroup) {
 
     setTagValue(pOperator, pTableQueryInfo->pTable, pIntervalInfo->pCtx, pOperator->numOfOutput);
     setInputDataBlock(pOperator, pIntervalInfo->pCtx, pBlock, pQueryAttr->order.order);
-    setIntervalQueryRange(pRuntimeEnv, pBlock->info.window.skey);
+    setIntervalQueryRange(pRuntimeEnv, &pBlock->info.window, pBlock->info.tid);
 
     hashIntervalAgg(pOperator, &pTableQueryInfo->resInfo, pBlock, pTableQueryInfo->groupIndex);
   }
@@ -6167,7 +6207,8 @@ static SSDataBlock* doAllSTableIntervalAgg(void* param, bool* newgroup) {
 
     setTagValue(pOperator, pTableQueryInfo->pTable, pIntervalInfo->pCtx, pOperator->numOfOutput);
     setInputDataBlock(pOperator, pIntervalInfo->pCtx, pBlock, pQueryAttr->order.order);
-    setIntervalQueryRange(pRuntimeEnv, pBlock->info.window.skey);
+
+    setIntervalQueryRange(pRuntimeEnv, &pBlock->info.window, pBlock->info.tid);
 
     hashAllIntervalAgg(pOperator, &pTableQueryInfo->resInfo, pBlock, pTableQueryInfo->groupIndex);
   }

src/query/src/qFill.c

@@ -239,6 +239,9 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, void** data, int32_t outputR
             } else {
               setNull(output, pCol->col.type, pCol->col.bytes);
             }
+            if (!FILL_IS_ASC_FILL(pFillInfo)) {
+              memcpy(*prev + pCol->col.offset, output, pCol->col.bytes);
+            }
           } else {
             assignVal(output, (char*)&pCol->fillVal.i, pCol->col.bytes, pCol->col.type);
           }

src/query/src/qHistogram.c

@@ -161,8 +161,8 @@ int32_t tHistogramAdd(SHistogramInfo** pHisto, double val) {
   }
 
 #if defined(USE_ARRAYLIST)
-  int32_t idx = histoBinarySearch((*pHisto)->elems, (*pHisto)->numOfEntries, val);
-  assert(idx >= 0 && idx <= (*pHisto)->maxEntries && (*pHisto)->elems != NULL);
+  int32_t idx = histoBinarySearch((*pHisto)->elems, (*pHisto)->numOfEntries, val, (*pHisto)->maxEntries);
+  assert(idx >= 0 && idx < (*pHisto)->maxEntries && (*pHisto)->elems != NULL);
 
   if ((*pHisto)->elems[idx].val == val && idx >= 0) {
     (*pHisto)->elems[idx].num += 1;
@@ -359,7 +359,7 @@ int32_t tHistogramAdd(SHistogramInfo** pHisto, double val) {
   return 0;
 }
 
-int32_t histoBinarySearch(SHistBin* pEntry, int32_t len, double val) {
+int32_t histoBinarySearch(SHistBin* pEntry, int32_t len, double val, int32_t maxEntries) {
   int32_t end = len - 1;
   int32_t start = 0;
 
@@ -377,6 +377,7 @@ int32_t histoBinarySearch(SHistBin* pEntry, int32_t len, double val) {
   }
 
   int32_t ret = start > end ? start : end;
+  if(ret >= maxEntries) ret = maxEntries - 1;
   if (ret < 0) {
     return 0;
   } else {
@@ -469,7 +470,7 @@ void tHistogramPrint(SHistogramInfo* pHisto) {
  */
 int64_t tHistogramSum(SHistogramInfo* pHisto, double v) {
 #if defined(USE_ARRAYLIST)
-  int32_t slotIdx = histoBinarySearch(pHisto->elems, pHisto->numOfEntries, v);
+  int32_t slotIdx = histoBinarySearch(pHisto->elems, pHisto->numOfEntries, v, pHisto->maxEntries);
   if (pHisto->elems[slotIdx].val != v) {
     slotIdx -= 1;
 

src/query/src/qPercentile.c

@@ -67,10 +67,18 @@ static int32_t setBoundingBox(MinMaxEntry* range, int16_t type, double minval, d
 
   if (IS_SIGNED_NUMERIC_TYPE(type)) {
     range->i64MinVal = (int64_t) minval;
-    range->i64MaxVal = (int64_t) maxval;
+    if (maxval > INT64_MAX || (int64_t)maxval == INT64_MIN) {
+      range->i64MaxVal = INT64_MAX;
+    } else {
+      range->i64MaxVal = (int64_t) maxval; 
+    }
   } else if (IS_UNSIGNED_NUMERIC_TYPE(type)){
     range->u64MinVal = (uint64_t) minval;
-    range->u64MaxVal = (uint64_t) maxval;
+    if ((uint64_t)maxval > UINT64_MAX) {
+      range->u64MaxVal = UINT64_MAX;
+    } else {
+      range->u64MaxVal = (uint64_t) maxval;
+    }
   } else {
     range->dMinVal = minval;
     range->dMaxVal = maxval;
@@ -127,8 +135,8 @@ int32_t tBucketIntHash(tMemBucket *pBucket, const void *value) {
     index = (delta % pBucket->numOfSlots);
   } else {
     double slotSpan = (double)span / pBucket->numOfSlots;
-    index = (int32_t)((v - pBucket->range.i64MinVal) / slotSpan);
-    if (v == pBucket->range.i64MaxVal) {
+    index = (int32_t)(((double)v - pBucket->range.i64MinVal) / slotSpan);
+    if (index == pBucket->numOfSlots) {
       index -= 1;
     }
   }

src/query/src/qTsbuf.c

@@ -375,6 +375,16 @@ STSBlock* readDataFromDisk(STSBuf* pTSBuf, int32_t order, bool decomp) {
   sz = fread(pBlock->payload, (size_t)pBlock->compLen, 1, pTSBuf->f);
 
   if (decomp) {
+    if (pBlock->numOfElem * TSDB_KEYSIZE > pTSBuf->tsData.allocSize) {
+      pTSBuf->tsData.rawBuf = realloc(pTSBuf->tsData.rawBuf, pBlock->numOfElem * TSDB_KEYSIZE);
+      pTSBuf->tsData.allocSize = pBlock->numOfElem * TSDB_KEYSIZE;
+    }
+
+    if (pBlock->numOfElem * TSDB_KEYSIZE > pTSBuf->bufSize) {
+      pTSBuf->assistBuf = realloc(pTSBuf->assistBuf, pBlock->numOfElem * TSDB_KEYSIZE);
+      pTSBuf->bufSize = pBlock->numOfElem * TSDB_KEYSIZE;
+    }    
+    
     pTSBuf->tsData.len =
         tsDecompressTimestamp(pBlock->payload, pBlock->compLen, pBlock->numOfElem, pTSBuf->tsData.rawBuf,
                               pTSBuf->tsData.allocSize, TWO_STAGE_COMP, pTSBuf->assistBuf, pTSBuf->bufSize);
@@ -471,7 +481,7 @@ void tsBufAppend(STSBuf* pTSBuf, int32_t id, tVariant* tag, const char* pData, i
   
   // the size of raw data exceeds the size of the default prepared buffer, so
   // during getBufBlock, the output buffer needs to be large enough.
-  if (ptsData->len >= ptsData->threshold) {
+  if (ptsData->len >= ptsData->threshold - TSDB_KEYSIZE) {
     writeDataToDisk(pTSBuf);
     shrinkBuffer(ptsData);
   }
@@ -603,6 +613,10 @@ static void tsBufGetBlock(STSBuf* pTSBuf, int32_t groupIndex, int32_t blockIndex
     expandBuffer(&pTSBuf->tsData, (int32_t)s);
   }
   
+  if (s > pTSBuf->bufSize) {
+    pTSBuf->assistBuf = realloc(pTSBuf->assistBuf, s);
+    pTSBuf->bufSize = (int32_t)s;
+  }    
   pTSBuf->tsData.len =
       tsDecompressTimestamp(pBlock->payload, pBlock->compLen, pBlock->numOfElem, pTSBuf->tsData.rawBuf,
                             pTSBuf->tsData.allocSize, TWO_STAGE_COMP, pTSBuf->assistBuf, pTSBuf->bufSize);

src/query/src/qUtil.c

@@ -418,46 +418,6 @@ static int64_t getNumOfResultWindowRes(SQueryRuntimeEnv* pRuntimeEnv, SResultRow
   return 0;
 }
 
-static int32_t tableResultComparFn(const void *pLeft, const void *pRight, void *param) {
-  int32_t left  = *(int32_t *)pLeft;
-  int32_t right = *(int32_t *)pRight;
-
-  SCompSupporter *  supporter = (SCompSupporter *)param;
-
-  int32_t leftPos  = supporter->rowIndex[left];
-  int32_t rightPos = supporter->rowIndex[right];
-
-  /* left source is exhausted */
-  if (leftPos == -1) {
-    return 1;
-  }
-
-  /* right source is exhausted*/
-  if (rightPos == -1) {
-    return -1;
-  }
-
-  STableQueryInfo** pList = supporter->pTableQueryInfo;
-  SResultRow* pWindowRes1 = pList[left]->resInfo.pResult[leftPos];
-//  SResultRow * pWindowRes1 = getResultRow(&(pList[left]->resInfo), leftPos);
-  TSKEY leftTimestamp = pWindowRes1->win.skey;
-
-//  SResultRowInfo *pWindowResInfo2 = &(pList[right]->resInfo);
-//  SResultRow * pWindowRes2 = getResultRow(pWindowResInfo2, rightPos);
-  SResultRow* pWindowRes2 = pList[right]->resInfo.pResult[rightPos];
-  TSKEY rightTimestamp = pWindowRes2->win.skey;
-
-  if (leftTimestamp == rightTimestamp) {
-    return 0;
-  }
-
-  if (supporter->order == TSDB_ORDER_ASC) {
-    return (leftTimestamp > rightTimestamp)? 1:-1;
-  } else {
-    return (leftTimestamp < rightTimestamp)? 1:-1;
-  }
-}
-
 int32_t tsAscOrder(const void* p1, const void* p2) {
   SResultRowCell* pc1 = (SResultRowCell*) p1;
   SResultRowCell* pc2 = (SResultRowCell*) p2;
@@ -532,102 +492,38 @@ static UNUSED_FUNC int32_t mergeIntoGroupResultImpl(SQueryRuntimeEnv *pRuntimeEn
     int32_t* rowCellInfoOffset) {
   bool ascQuery = QUERY_IS_ASC_QUERY(pRuntimeEnv->pQueryAttr);
 
-  int32_t code = TSDB_CODE_SUCCESS;
+  taosArraySort(pRuntimeEnv->pResultRowArrayList, fn);
+}
 
-  int32_t *posList = NULL;
-  SLoserTreeInfo *pTree = NULL;
-  STableQueryInfo **pTableQueryInfoList = NULL;
+static int32_t mergeIntoGroupResultImplRv(SQueryRuntimeEnv *pRuntimeEnv, SGroupResInfo* pGroupResInfo, uint64_t groupId, int32_t* rowCellInfoOffset) {
+  if (!pGroupResInfo->ordered) {
+    orderTheResultRows(pRuntimeEnv);
+    pGroupResInfo->ordered = true;
+  }
 
-  size_t size = taosArrayGetSize(pTableList);
   if (pGroupResInfo->pRows == NULL) {
     pGroupResInfo->pRows = taosArrayInit(100, POINTER_BYTES);
   }
 
-  posList = calloc(size, sizeof(int32_t));
-  pTableQueryInfoList = malloc(POINTER_BYTES * size);
-
-  if (pTableQueryInfoList == NULL || posList == NULL || pGroupResInfo->pRows == NULL || pGroupResInfo->pRows == NULL) {
-    qError("QInfo:%"PRIu64" failed alloc memory", GET_QID(pRuntimeEnv));
-    code = TSDB_CODE_QRY_OUT_OF_MEMORY;
-    goto _end;
-  }
+  size_t len = taosArrayGetSize(pRuntimeEnv->pResultRowArrayList);
+  for(; pGroupResInfo->position < len; ++pGroupResInfo->position) {
 
-  int32_t numOfTables = 0;
-  for (int32_t i = 0; i < size; ++i) {
-    STableQueryInfo *item = taosArrayGetP(pTableList, i);
-    if (item->resInfo.size > 0) {
-      pTableQueryInfoList[numOfTables++] = item;
+    SResultRowCell* pResultRowCell = taosArrayGet(pRuntimeEnv->pResultRowArrayList, pGroupResInfo->position);
+    if (pResultRowCell->groupId != groupId) {
+      break;
     }
-  }
-
-  // there is no data in current group
-  // no need to merge results since only one table in each group
-  if (numOfTables == 0) {
-    goto _end;
-  }
-
-  SCompSupporter cs = {pTableQueryInfoList, posList, pRuntimeEnv->pQueryAttr->order.order};
-
-  int32_t ret = tLoserTreeCreate(&pTree, numOfTables, &cs, tableResultComparFn);
-  if (ret != TSDB_CODE_SUCCESS) {
-    code = TSDB_CODE_QRY_OUT_OF_MEMORY;
-    goto _end;
-  }
 
-  int64_t lastTimestamp = ascQuery? INT64_MIN:INT64_MAX;
-  int64_t startt = taosGetTimestampMs();
-
-  while (1) {
-    int32_t tableIndex = pTree->pNode[0].index;
-
-    SResultRowInfo *pWindowResInfo = &pTableQueryInfoList[tableIndex]->resInfo;
-    SResultRow  *pWindowRes = getResultRow(pWindowResInfo, cs.rowIndex[tableIndex]);
-
-    int64_t num = getNumOfResultWindowRes(pRuntimeEnv, pWindowRes, rowCellInfoOffset);
+    int64_t num = getNumOfResultWindowRes(pRuntimeEnv, pResultRowCell->pRow, rowCellInfoOffset);
     if (num <= 0) {
-      cs.rowIndex[tableIndex] += 1;
-
-      if (cs.rowIndex[tableIndex] >= pWindowResInfo->size) {
-        cs.rowIndex[tableIndex] = -1;
-        if (--numOfTables == 0) { // all input sources are exhausted
-          break;
-        }
-      }
-    } else {
-      assert((pWindowRes->win.skey >= lastTimestamp && ascQuery) || (pWindowRes->win.skey <= lastTimestamp && !ascQuery));
-
-      if (pWindowRes->win.skey != lastTimestamp) {
-        taosArrayPush(pGroupResInfo->pRows, &pWindowRes);
-        pWindowRes->numOfRows = (uint32_t) num;
-      }
-
-      lastTimestamp = pWindowRes->win.skey;
-
-      // move to the next row of current entry
-      if ((++cs.rowIndex[tableIndex]) >= pWindowResInfo->size) {
-        cs.rowIndex[tableIndex] = -1;
-
-        // all input sources are exhausted
-        if ((--numOfTables) == 0) {
-          break;
-        }
-      }
+      continue;
     }
 
-    tLoserTreeAdjust(pTree, tableIndex + pTree->numOfEntries);
-  }
-
-  int64_t endt = taosGetTimestampMs();
-
-  qDebug("QInfo:%"PRIx64" result merge completed for group:%d, elapsed time:%" PRId64 " ms", GET_QID(pRuntimeEnv),
-         pGroupResInfo->currentGroup, endt - startt);
+    taosArrayPush(pGroupResInfo->pRows, &pResultRowCell->pRow);
+    pResultRowCell->pRow->numOfRows = (uint32_t) num;
 
-  _end:
-  tfree(pTableQueryInfoList);
-  tfree(posList);
-  tfree(pTree);
+  }
 
-  return code;
+  return TSDB_CODE_SUCCESS;
 }
 
 int32_t mergeIntoGroupResult(SGroupResInfo* pGroupResInfo, SQueryRuntimeEnv* pRuntimeEnv, int32_t* offset) {

src/query/tests/histogramTest.cpp

@@ -98,19 +98,19 @@ TEST(testCase, histogram_binary_search) {
     pHisto->elems[i].val = i;
   }
 
-  int32_t idx = histoBinarySearch(pHisto->elems, pHisto->numOfEntries, 1);
+  int32_t idx = histoBinarySearch(pHisto->elems, pHisto->numOfEntries, 1, pHisto->maxEntries);
   assert(idx == 1);
 
-  idx = histoBinarySearch(pHisto->elems, pHisto->numOfEntries, 9);
+  idx = histoBinarySearch(pHisto->elems, pHisto->numOfEntries, 9, pHisto->maxEntries);
   assert(idx == 9);
 
-  idx = histoBinarySearch(pHisto->elems, pHisto->numOfEntries, 20);
+  idx = histoBinarySearch(pHisto->elems, pHisto->numOfEntries, 20, pHisto->maxEntries);
   assert(idx == 10);
 
-  idx = histoBinarySearch(pHisto->elems, pHisto->numOfEntries, -1);
+  idx = histoBinarySearch(pHisto->elems, pHisto->numOfEntries, -1, pHisto->maxEntries);
   assert(idx == 0);
 
-  idx = histoBinarySearch(pHisto->elems, pHisto->numOfEntries, 3.9);
+  idx = histoBinarySearch(pHisto->elems, pHisto->numOfEntries, 3.9, pHisto->maxEntries);
   assert(idx == 4);
 
   free(pHisto);

src/rpc/src/rpcMain.c

@@ -399,7 +399,8 @@ void rpcSendRequest(void *shandle, const SRpcEpSet *pEpSet, SRpcMsg *pMsg, int64
   pContext->oldInUse = pEpSet->inUse;
 
   pContext->connType = RPC_CONN_UDPC; 
-  if (contLen > tsRpcMaxUdpSize || tsRpcForceTcp ) pContext->connType = RPC_CONN_TCPC;
+
+  if (contLen > tsRpcMaxUdpSize || tsRpcForceTcp) pContext->connType = RPC_CONN_TCPC;
 
   // connection type is application specific. 
   // for TDengine, all the query, show commands shall have TCP connection

src/tsdb/inc/tsdbMeta.h

@@ -74,7 +74,7 @@ void       tsdbFreeMeta(STsdbMeta* pMeta);
 int        tsdbOpenMeta(STsdbRepo* pRepo);
 int        tsdbCloseMeta(STsdbRepo* pRepo);
 STable*    tsdbGetTableByUid(STsdbMeta* pMeta, uint64_t uid);
-STSchema*  tsdbGetTableSchemaByVersion(STable* pTable, int16_t _version);
+STSchema*  tsdbGetTableSchemaByVersion(STable* pTable, int16_t _version, int8_t rowType);
 int        tsdbWLockRepoMeta(STsdbRepo* pRepo);
 int        tsdbRLockRepoMeta(STsdbRepo* pRepo);
 int        tsdbUnlockRepoMeta(STsdbRepo* pRepo);
@@ -110,8 +110,12 @@ static FORCE_INLINE STSchema* tsdbGetTableSchemaImpl(STable* pTable, bool lock,
   } else {  // get the schema with version
     void* ptr = taosArraySearch(pDTable->schema, &_version, tsdbCompareSchemaVersion, TD_EQ);
     if (ptr == NULL) {
-      terrno = TSDB_CODE_TDB_IVD_TB_SCHEMA_VERSION;
-      goto _exit;
+      if (rowType == SMEM_ROW_KV) {
+        ptr = taosArrayGetLast(pDTable->schema);
+      } else {
+        terrno = TSDB_CODE_TDB_IVD_TB_SCHEMA_VERSION;
+        goto _exit;
+      }
     }
     pTSchema = *(STSchema**)ptr;
   }
@@ -130,7 +134,7 @@ _exit:
 }
 
 static FORCE_INLINE STSchema* tsdbGetTableSchema(STable* pTable) {
-  return tsdbGetTableSchemaImpl(pTable, false, false, -1);
+  return tsdbGetTableSchemaImpl(pTable, false, false, -1, -1);
 }
 
 static FORCE_INLINE STSchema *tsdbGetTableTagSchema(STable *pTable) {

src/tsdb/src/tsdbCommit.c

@@ -1021,7 +1021,7 @@ static int tsdbCommitToTable(SCommitH *pCommith, int tid) {
 }
 
 static int tsdbSetCommitTable(SCommitH *pCommith, STable *pTable) {
-  STSchema *pSchema = tsdbGetTableSchemaImpl(pTable, false, false, -1);
+  STSchema *pSchema = tsdbGetTableSchemaImpl(pTable, false, false, -1, -1);
 
   pCommith->pTable = pTable;
 
@@ -1438,7 +1438,8 @@ static void tsdbLoadAndMergeFromCache(SDataCols *pDataCols, int *iter, SCommitIt
       (*iter)++;
     } else if (key1 > key2) {
       if (pSchema == NULL || schemaVersion(pSchema) != memRowVersion(row)) {
-        pSchema = tsdbGetTableSchemaImpl(pCommitIter->pTable, false, false, memRowVersion(row));
+        pSchema =
+            tsdbGetTableSchemaImpl(pCommitIter->pTable, false, false, memRowVersion(row), (int8_t)memRowType(row));
         ASSERT(pSchema != NULL);
       }
 
@@ -1459,7 +1460,8 @@ static void tsdbLoadAndMergeFromCache(SDataCols *pDataCols, int *iter, SCommitIt
       if (update != TD_ROW_DISCARD_UPDATE) {
         //copy mem data
         if (pSchema == NULL || schemaVersion(pSchema) != memRowVersion(row)) {
-          pSchema = tsdbGetTableSchemaImpl(pCommitIter->pTable, false, false, memRowVersion(row));
+          pSchema =
+              tsdbGetTableSchemaImpl(pCommitIter->pTable, false, false, memRowVersion(row), (int8_t)memRowType(row));
           ASSERT(pSchema != NULL);
         }
 

src/tsdb/src/tsdbCompact.c

@@ -431,7 +431,7 @@ static int tsdbCompactMeta(STsdbRepo *pRepo) {
 
       if (pTh->pTable == NULL || pTh->pBlkIdx == NULL) continue;
 
-      pSchema = tsdbGetTableSchemaImpl(pTh->pTable, true, true, -1);
+      pSchema = tsdbGetTableSchemaImpl(pTh->pTable, true, true, -1, -1);
       taosArrayClear(pComph->aSupBlk);
       if ((tdInitDataCols(pComph->pDataCols, pSchema) < 0) || (tdInitDataCols(pReadh->pDCols[0], pSchema) < 0) ||
           (tdInitDataCols(pReadh->pDCols[1], pSchema) < 0)) {

src/tsdb/src/tsdbMain.c

@@ -624,7 +624,7 @@ static void tsdbStartStream(STsdbRepo *pRepo) {
     STable *pTable = pMeta->tables[i];
     if (pTable && pTable->type == TSDB_STREAM_TABLE) {
       pTable->cqhandle = (*pRepo->appH.cqCreateFunc)(pRepo->appH.cqH, TABLE_UID(pTable), TABLE_TID(pTable), TABLE_NAME(pTable)->data, pTable->sql,
-                                                     tsdbGetTableSchemaImpl(pTable, false, false, -1), 0);
+                                                     tsdbGetTableSchemaImpl(pTable, false, false, -1, -1), 0);
     }
   }
 }

src/tsdb/src/tsdbMemTable.c

@@ -587,7 +587,7 @@ static int tsdbAdjustMemMaxTables(SMemTable *pMemTable, int maxTables) {
 static int tsdbAppendTableRowToCols(STable *pTable, SDataCols *pCols, STSchema **ppSchema, SMemRow row) {
   if (pCols) {
     if (*ppSchema == NULL || schemaVersion(*ppSchema) != memRowVersion(row)) {
-      *ppSchema = tsdbGetTableSchemaImpl(pTable, false, false, memRowVersion(row));
+      *ppSchema = tsdbGetTableSchemaImpl(pTable, false, false, memRowVersion(row), (int8_t)memRowType(row));
       if (*ppSchema == NULL) {
         ASSERT(false);
         return -1;
@@ -735,7 +735,7 @@ static SMemRow tsdbInsertDupKeyMerge(SMemRow row1, SMemRow row2, STsdbRepo* pRep
     if(pSchema2 != NULL && schemaVersion(pSchema2) == dv1) {
       *ppSchema1 = pSchema2;
     } else {
-      *ppSchema1 = tsdbGetTableSchemaImpl(pTable, false, false, memRowVersion(row1));
+      *ppSchema1 = tsdbGetTableSchemaImpl(pTable, false, false, memRowVersion(row1), (int8_t)memRowType(row1));
     }
     pSchema1 = *ppSchema1;
   }
@@ -744,7 +744,7 @@ static SMemRow tsdbInsertDupKeyMerge(SMemRow row1, SMemRow row2, STsdbRepo* pRep
     if(schemaVersion(pSchema1) == dv2) {
       pSchema2 = pSchema1;
     } else {
-      *ppSchema2 = tsdbGetTableSchemaImpl(pTable, false, false, memRowVersion(row2));
+      *ppSchema2 = tsdbGetTableSchemaImpl(pTable, false, false, memRowVersion(row2), (int8_t)memRowType(row2));
       pSchema2 = *ppSchema2;
     }
   }
@@ -852,7 +852,7 @@ static int tsdbInsertDataToTable(STsdbRepo* pRepo, SSubmitBlk* pBlock, int32_t *
     }
   }
 
-  STSchema *pSchema = tsdbGetTableSchemaByVersion(pTable, pBlock->sversion);
+  STSchema *pSchema = tsdbGetTableSchemaByVersion(pTable, pBlock->sversion, -1);
   pRepo->stat.pointsWritten += points * schemaNCols(pSchema);
   pRepo->stat.totalStorage += points * schemaVLen(pSchema);
 
@@ -899,7 +899,7 @@ static int tsdbGetSubmitMsgNext(SSubmitMsgIter *pIter, SSubmitBlk **pPBlock) {
 static int tsdbCheckTableSchema(STsdbRepo *pRepo, SSubmitBlk *pBlock, STable *pTable) {
   ASSERT(pTable != NULL);
 
-  STSchema *pSchema = tsdbGetTableSchemaImpl(pTable, false, false, -1);
+  STSchema *pSchema = tsdbGetTableSchemaImpl(pTable, false, false, -1, -1);
   int       sversion = schemaVersion(pSchema);
 
   if (pBlock->sversion == sversion) {
@@ -956,7 +956,7 @@ static int tsdbCheckTableSchema(STsdbRepo *pRepo, SSubmitBlk *pBlock, STable *pT
     }
   } else {
     ASSERT(pBlock->sversion >= 0);
-    if (tsdbGetTableSchemaImpl(pTable, false, false, pBlock->sversion) == NULL) {
+    if (tsdbGetTableSchemaImpl(pTable, false, false, pBlock->sversion, -1) == NULL) {
       tsdbError("vgId:%d invalid submit schema version %d to table %s tid %d from client", REPO_ID(pRepo),
                 pBlock->sversion, TABLE_CHAR_NAME(pTable), TABLE_TID(pTable));
       terrno = TSDB_CODE_TDB_IVD_TB_SCHEMA_VERSION;
@@ -977,7 +977,7 @@ static void updateTableLatestColumn(STsdbRepo *pRepo, STable *pTable, SMemRow ro
     return;
   }
 
-  pSchema = tsdbGetTableSchemaByVersion(pTable, memRowVersion(row));
+  pSchema = tsdbGetTableSchemaByVersion(pTable, memRowVersion(row), (int8_t)memRowType(row));
   if (pSchema == NULL) {
     return;
   }

src/tsdb/src/tsdbMeta.c

@@ -545,8 +545,8 @@ STable *tsdbGetTableByUid(STsdbMeta *pMeta, uint64_t uid) {
   return *(STable **)ptr;
 }
 
-STSchema *tsdbGetTableSchemaByVersion(STable *pTable, int16_t _version) {
-  return tsdbGetTableSchemaImpl(pTable, true, false, _version);
+STSchema *tsdbGetTableSchemaByVersion(STable *pTable, int16_t _version, int8_t rowType) {
+  return tsdbGetTableSchemaImpl(pTable, true, false, _version, rowType);
 }
 
 int tsdbWLockRepoMeta(STsdbRepo *pRepo) {
@@ -664,7 +664,7 @@ int tsdbInitColIdCacheWithSchema(STable* pTable, STSchema* pSchema) {
 }
 
 STSchema* tsdbGetTableLatestSchema(STable *pTable) {
-  return tsdbGetTableSchemaByVersion(pTable, -1);
+  return tsdbGetTableSchemaByVersion(pTable, -1, -1);
 }
 
 int tsdbUpdateLastColSchema(STable *pTable, STSchema *pNewSchema) {
@@ -969,7 +969,7 @@ static int tsdbAddTableToMeta(STsdbRepo *pRepo, STable *pTable, bool addIdx, boo
   }
 
   if (TABLE_TYPE(pTable) != TSDB_CHILD_TABLE) {
-    STSchema *pSchema = tsdbGetTableSchemaImpl(pTable, false, false, -1);
+    STSchema *pSchema = tsdbGetTableSchemaImpl(pTable, false, false, -1, -1);
     if (schemaNCols(pSchema) > pMeta->maxCols) pMeta->maxCols = schemaNCols(pSchema);
     if (schemaTLen(pSchema) > pMeta->maxRowBytes) pMeta->maxRowBytes = schemaTLen(pSchema);
   }
@@ -977,7 +977,7 @@ static int tsdbAddTableToMeta(STsdbRepo *pRepo, STable *pTable, bool addIdx, boo
   if (lock && tsdbUnlockRepoMeta(pRepo) < 0) return -1;
   if (TABLE_TYPE(pTable) == TSDB_STREAM_TABLE && addIdx) {
     pTable->cqhandle = (*pRepo->appH.cqCreateFunc)(pRepo->appH.cqH, TABLE_UID(pTable), TABLE_TID(pTable), TABLE_NAME(pTable)->data, pTable->sql,
-                                                   tsdbGetTableSchemaImpl(pTable, false, false, -1), 1);
+                                                   tsdbGetTableSchemaImpl(pTable, false, false, -1, -1), 1);
   }
 
   tsdbDebug("vgId:%d table %s tid %d uid %" PRIu64 " is added to meta", REPO_ID(pRepo), TABLE_CHAR_NAME(pTable),
@@ -996,7 +996,7 @@ static void tsdbRemoveTableFromMeta(STsdbRepo *pRepo, STable *pTable, bool rmFro
   SListNode *pNode = NULL;
   STable *   tTable = NULL;
 
-  STSchema *pSchema = tsdbGetTableSchemaImpl(pTable, false, false, -1);
+  STSchema *pSchema = tsdbGetTableSchemaImpl(pTable, false, false, -1, -1);
   int       maxCols = schemaNCols(pSchema);
   int       maxRowBytes = schemaTLen(pSchema);
 
@@ -1030,7 +1030,7 @@ static void tsdbRemoveTableFromMeta(STsdbRepo *pRepo, STable *pTable, bool rmFro
     for (int i = 0; i < pMeta->maxTables; i++) {
       STable *_pTable = pMeta->tables[i];
       if (_pTable != NULL) {
-        pSchema = tsdbGetTableSchemaImpl(_pTable, false, false, -1);
+        pSchema = tsdbGetTableSchemaImpl(_pTable, false, false, -1, -1);
         maxCols = MAX(maxCols, schemaNCols(pSchema));
         maxRowBytes = MAX(maxRowBytes, schemaTLen(pSchema));
       }

src/tsdb/src/tsdbRead.c

@@ -655,55 +655,8 @@ SArray* tsdbGetQueriedTableList(TsdbQueryHandleT *pHandle) {
   return res;
 }
 
-// leave only one table for each group
-static STableGroupInfo* trimTableGroup(STimeWindow* window, STableGroupInfo* pGroupList) {
-  assert(pGroupList);
-  size_t numOfGroup = taosArrayGetSize(pGroupList->pGroupList);
-
-  STableGroupInfo* pNew = calloc(1, sizeof(STableGroupInfo));
-  pNew->pGroupList = taosArrayInit(numOfGroup, POINTER_BYTES);
-
-  for(int32_t i = 0; i < numOfGroup; ++i) {
-    SArray* oneGroup = taosArrayGetP(pGroupList->pGroupList, i);
-    size_t numOfTables = taosArrayGetSize(oneGroup);
-
-    SArray* px = taosArrayInit(4, sizeof(STableKeyInfo));
-    for (int32_t j = 0; j < numOfTables; ++j) {
-      STableKeyInfo* pInfo = (STableKeyInfo*)taosArrayGet(oneGroup, j);
-      if (window->skey <= pInfo->lastKey && ((STable*)pInfo->pTable)->lastKey != TSKEY_INITIAL_VAL) {
-        taosArrayPush(px, pInfo);
-        pNew->numOfTables += 1;
-        break;
-      }
-    }
-
-    // there are no data in this group
-    if (taosArrayGetSize(px) == 0) {
-      taosArrayDestroy(px);
-    } else {
-      taosArrayPush(pNew->pGroupList, &px);
-    }
-  }
-
-  return pNew;
-}
-
 TsdbQueryHandleT tsdbQueryRowsInExternalWindow(STsdbRepo *tsdb, STsdbQueryCond* pCond, STableGroupInfo *groupList, uint64_t qId, SMemRef* pRef) {
-  STableGroupInfo* pNew = trimTableGroup(&pCond->twindow, groupList);
-
-  if (pNew->numOfTables == 0) {
-    tsdbDebug("update query time range to invalidate time window");
-
-    assert(taosArrayGetSize(pNew->pGroupList) == 0);
-    bool asc = ASCENDING_TRAVERSE(pCond->order);
-    if (asc) {
-      pCond->twindow.ekey = pCond->twindow.skey - 1;
-    } else {
-      pCond->twindow.skey = pCond->twindow.ekey - 1;
-    }
-  }
-
-  STsdbQueryHandle *pQueryHandle = (STsdbQueryHandle*) tsdbQueryTables(tsdb, pCond, pNew, qId, pRef);
+  STsdbQueryHandle *pQueryHandle = (STsdbQueryHandle*) tsdbQueryTables(tsdb, pCond, groupList, qId, pRef);
   pQueryHandle->loadExternalRow = true;
   pQueryHandle->currentLoadExternalRows = true;
 
@@ -859,13 +812,25 @@ static TSKEY extractFirstTraverseKey(STableCheckInfo* pCheckInfo, int32_t order,
       pCheckInfo->chosen = CHECKINFO_CHOSEN_BOTH;
     }
     return r1;
-  } else if (r1 < r2 && ASCENDING_TRAVERSE(order)) {
-    pCheckInfo->chosen = CHECKINFO_CHOSEN_MEM;
-    return r1;
-  }
-  else {
-    pCheckInfo->chosen = CHECKINFO_CHOSEN_IMEM;
-    return r2;
+  } else {
+    if (ASCENDING_TRAVERSE(order)) {
+      if (r1 < r2) {
+        pCheckInfo->chosen = CHECKINFO_CHOSEN_MEM;
+        return r1;
+      } else {
+        pCheckInfo->chosen = CHECKINFO_CHOSEN_IMEM;
+        return r2;
+      }
+    } else {
+      if (r1 < r2) {
+        pCheckInfo->chosen = CHECKINFO_CHOSEN_IMEM;
+        return r2;
+      } else {
+        pCheckInfo->chosen = CHECKINFO_CHOSEN_MEM;
+        return r1;
+      }
+    }
+    
   }
 }
 
@@ -930,7 +895,7 @@ static SMemRow getSMemRowInTableMem(STableCheckInfo* pCheckInfo, int32_t order,
         pCheckInfo->chosen = CHECKINFO_CHOSEN_IMEM;
         return rimem;
       } else {
-        pCheckInfo->chosen = CHECKINFO_CHOSEN_IMEM;
+        pCheckInfo->chosen = CHECKINFO_CHOSEN_MEM;
         return rmem;
       }
     }
@@ -1329,11 +1294,11 @@ static int32_t handleDataMergeIfNeeded(STsdbQueryHandle* pQueryHandle, SBlock* p
 
     assert(cur->blockCompleted);
     if (cur->rows == binfo.rows) {
-      tsdbDebug("%p whole file block qualified, brange:%"PRId64"-%"PRId64", rows:%d, lastKey:%"PRId64", %"PRIx64,
-                pQueryHandle, cur->win.skey, cur->win.ekey, cur->rows, cur->lastKey, pQueryHandle->qId);
+      tsdbDebug("%p whole file block qualified, brange:%"PRId64"-%"PRId64", rows:%d, lastKey:%"PRId64", tid:%d, %"PRIx64,
+                pQueryHandle, cur->win.skey, cur->win.ekey, cur->rows, cur->lastKey, binfo.tid, pQueryHandle->qId);
     } else {
-      tsdbDebug("%p create data block from remain file block, brange:%"PRId64"-%"PRId64", rows:%d, total:%d, lastKey:%"PRId64", %"PRIx64,
-                pQueryHandle, cur->win.skey, cur->win.ekey, cur->rows, binfo.rows, cur->lastKey, pQueryHandle->qId);
+      tsdbDebug("%p create data block from remain file block, brange:%"PRId64"-%"PRId64", rows:%d, total:%d, lastKey:%"PRId64", tid:%d, %"PRIx64,
+                pQueryHandle, cur->win.skey, cur->win.ekey, cur->rows, binfo.rows, cur->lastKey, binfo.tid, pQueryHandle->qId);
     }
 
   }
@@ -1572,7 +1537,7 @@ static void mergeTwoRowFromMem(STsdbQueryHandle* pQueryHandle, int32_t capacity,
   int32_t numOfColsOfRow1 = 0;
 
   if (pSchema1 == NULL) {
-    pSchema1 = tsdbGetTableSchemaByVersion(pTable, memRowVersion(row1));
+    pSchema1 = tsdbGetTableSchemaByVersion(pTable, memRowVersion(row1), (int8_t)memRowType(row1));
   }
   if(isRow1DataRow) {
     numOfColsOfRow1 = schemaNCols(pSchema1);
@@ -1584,7 +1549,7 @@ static void mergeTwoRowFromMem(STsdbQueryHandle* pQueryHandle, int32_t capacity,
   if(row2) {
     isRow2DataRow = isDataRow(row2);
     if (pSchema2 == NULL) {
-      pSchema2 = tsdbGetTableSchemaByVersion(pTable, memRowVersion(row2));
+      pSchema2 = tsdbGetTableSchemaByVersion(pTable, memRowVersion(row2), (int8_t)memRowType(row2));
     }
     if(isRow2DataRow) {
       numOfColsOfRow2 = schemaNCols(pSchema2);
@@ -1951,11 +1916,11 @@ static void doMergeTwoLevelData(STsdbQueryHandle* pQueryHandle, STableCheckInfo*
       if ((key < tsArray[pos] && ASCENDING_TRAVERSE(pQueryHandle->order)) ||
           (key > tsArray[pos] && !ASCENDING_TRAVERSE(pQueryHandle->order))) {
         if (rv1 != memRowVersion(row1)) {
-          pSchema1 = tsdbGetTableSchemaByVersion(pTable, memRowVersion(row1));
+          pSchema1 = tsdbGetTableSchemaByVersion(pTable, memRowVersion(row1), (int8_t)memRowType(row1));
           rv1 = memRowVersion(row1);
         }
         if(row2 && rv2 != memRowVersion(row2)) {
-          pSchema2 = tsdbGetTableSchemaByVersion(pTable, memRowVersion(row2));
+          pSchema2 = tsdbGetTableSchemaByVersion(pTable, memRowVersion(row2), (int8_t)memRowType(row2));
           rv2 = memRowVersion(row2);
         }
         
@@ -1976,11 +1941,11 @@ static void doMergeTwoLevelData(STsdbQueryHandle* pQueryHandle, STableCheckInfo*
             doCopyRowsFromFileBlock(pQueryHandle, pQueryHandle->outputCapacity, numOfRows, pos, pos);
           }
           if (rv1 != memRowVersion(row1)) {
-            pSchema1 = tsdbGetTableSchemaByVersion(pTable, memRowVersion(row1));
+            pSchema1 = tsdbGetTableSchemaByVersion(pTable, memRowVersion(row1), (int8_t)memRowType(row1));
             rv1 = memRowVersion(row1);
           }
           if(row2 && rv2 != memRowVersion(row2)) {
-            pSchema2 = tsdbGetTableSchemaByVersion(pTable, memRowVersion(row2));
+            pSchema2 = tsdbGetTableSchemaByVersion(pTable, memRowVersion(row2), (int8_t)memRowType(row2));
             rv2 = memRowVersion(row2);
           }
           
@@ -2644,7 +2609,7 @@ static int tsdbReadRowsFromCache(STableCheckInfo* pCheckInfo, TSKEY maxKey, int
 
     win->ekey = key;
     if (rv != memRowVersion(row)) {
-      pSchema = tsdbGetTableSchemaByVersion(pTable, memRowVersion(row));
+      pSchema = tsdbGetTableSchemaByVersion(pTable, memRowVersion(row), (int8_t)memRowType(row));
       rv = memRowVersion(row);
     }
     mergeTwoRowFromMem(pQueryHandle, maxRowsToRead, numOfRows, row, NULL, numOfCols, pTable, pSchema, NULL, true);

src/tsdb/src/tsdbReadImpl.c

@@ -153,7 +153,7 @@ int tsdbLoadBlockIdx(SReadH *pReadh) {
 }
 
 int tsdbSetReadTable(SReadH *pReadh, STable *pTable) {
-  STSchema *pSchema = tsdbGetTableSchemaImpl(pTable, false, false, -1);
+  STSchema *pSchema = tsdbGetTableSchemaImpl(pTable, false, false, -1, -1);
 
   pReadh->pTable = pTable;
 

src/util/inc/hash.h

@@ -36,7 +36,7 @@ typedef struct SHashNode {
   uint32_t          dataLen;     // length of data
   uint32_t          keyLen;      // length of the key
   int8_t            removed;     // flag to indicate removed
-  int8_t            count;       // reference count
+  int32_t           count;       // reference count
   char              data[];
 } SHashNode;
 

src/util/inc/tstrbuild.h

@@ -43,6 +43,7 @@ void taosStringBuilderAppendStringLen(SStringBuilder* sb, const char* str, size_
 void taosStringBuilderAppendString(SStringBuilder* sb, const char* str);
 void taosStringBuilderAppendNull(SStringBuilder* sb);
 void taosStringBuilderAppendInteger(SStringBuilder* sb, int64_t v);
+void taosStringBuilderAppendUnsignedInteger(SStringBuilder* sb, uint64_t v);
 void taosStringBuilderAppendDouble(SStringBuilder* sb, double v);
 
 #ifdef __cplusplus

src/util/src/hash.c

@@ -119,7 +119,7 @@ static SHashNode *doCreateHashNode(const void *key, size_t keyLen, const void *p
 static FORCE_INLINE SHashNode *doUpdateHashNode(SHashObj *pHashObj, SHashEntry* pe, SHashNode* prev, SHashNode *pNode, SHashNode *pNewNode) {
   assert(pNode->keyLen == pNewNode->keyLen);
 
-  pNode->count--;
+  atomic_sub_fetch_32(&pNode->count, 1);
   if (prev != NULL) {
     prev->next = pNewNode;
   } else {
@@ -459,7 +459,7 @@ int32_t taosHashRemoveWithData(SHashObj *pHashObj, const void *key, size_t keyLe
   if (pNode) {
     code = 0;  // it is found
 
-    pNode->count--;
+    atomic_sub_fetch_32(&pNode->count, 1);
     pNode->removed = 1;
     if (pNode->count <= 0) {
       if (prevNode) {
@@ -820,7 +820,7 @@ static void *taosHashReleaseNode(SHashObj *pHashObj, void *p, int *slot) {
       pNode = pNode->next;
     }
 
-    pOld->count--;
+    atomic_sub_fetch_32(&pOld->count, 1);
     if (pOld->count <=0) {
       if (prevNode) {
         prevNode->next = pOld->next;
@@ -886,7 +886,7 @@ void *taosHashIterate(SHashObj *pHashObj, void *p) {
 
   if (pNode) {
     SHashEntry *pe = pHashObj->hashList[slot];
-    pNode->count++;
+    atomic_add_fetch_32(&pNode->count, 1);
     data = GET_HASH_NODE_DATA(pNode);
     if (pHashObj->type == HASH_ENTRY_LOCK) {
       taosWUnLockLatch(&pe->latch);

src/util/src/tref.c

@@ -442,7 +442,7 @@ static int taosDecRefCount(int rsetId, int64_t rid, int remove) {
       }
       released = 1;
     } else {
-       uTrace("rsetId:%d p:%p rid:%" PRId64 " is released", rsetId, pNode->p, rid);
+       uTrace("rsetId:%d p:%p rid:%" PRId64 " is released, count:%d", rsetId, pNode->p, rid, pNode->count);
     }
   } else {
     uTrace("rsetId:%d rid:%" PRId64 " is not there, failed to release/remove", rsetId, rid);

src/util/src/tstrbuild.c

@@ -73,6 +73,12 @@ void taosStringBuilderAppendInteger(SStringBuilder* sb, int64_t v) {
   taosStringBuilderAppendStringLen(sb, buf, MIN(len, sizeof(buf)));
 }
 
+void taosStringBuilderAppendUnsignedInteger(SStringBuilder* sb, uint64_t v) {
+  char   buf[64];
+  size_t len = snprintf(buf, sizeof(buf), "%" PRId64, v);
+  taosStringBuilderAppendStringLen(sb, buf, MIN(len, sizeof(buf)));
+}
+
 void taosStringBuilderAppendDouble(SStringBuilder* sb, double v) {
   char   buf[512];
   size_t len = snprintf(buf, sizeof(buf), "%.9lf", v);

src/util/src/ttokenizer.c

@@ -142,6 +142,7 @@ static SKeyword keywordTable[] = {
     {"FROM",         TK_FROM},
     {"VARIABLE",     TK_VARIABLE},
     {"INTERVAL",     TK_INTERVAL},
+    {"EVERY",        TK_EVERY},
     {"SESSION",      TK_SESSION},
     {"STATE_WINDOW", TK_STATE_WINDOW},
     {"FILL",         TK_FILL},
@@ -622,7 +623,7 @@ SStrToken tStrGetToken(char* str, int32_t* i, bool isPrevOptr) {
 
     int32_t numOfComma = 0;
     char t = str[*i];
-    while (t == ' ' || t == '\n' || t == '\r' || t == '\t' || t == '\f' || t == ',') {
+    while (isspace(t) || t == ',') {
       if (t == ',' && (++numOfComma > 1)) {  // comma only allowed once
         t0.n = 0;
         return t0;

src/vnode/src/vnodeWrite.c

@@ -289,6 +289,13 @@ static int32_t vnodeWriteToWQueueImp(SVWriteMsg *pWrite) {
   int64_t queuedSize = atomic_add_fetch_64(&pVnode->queuedWMsgSize, pWrite->walHead.len);
 
   if (queued > MAX_QUEUED_MSG_NUM || queuedSize > MAX_QUEUED_MSG_SIZE) {
+    if (pWrite->qtype == TAOS_QTYPE_FWD) {
+      queued = atomic_sub_fetch_32(&pVnode->queuedWMsg, 1);
+      queuedSize = atomic_sub_fetch_64(&pVnode->queuedWMsgSize, pWrite->walHead.len);
+
+      return -1;
+    }
+
     int32_t ms = (queued / MAX_QUEUED_MSG_NUM) * 10 + 3;
     if (ms > 100) ms = 100;
     vDebug("vgId:%d, too many msg:%d in vwqueue, flow control %dms", pVnode->vgId, queued, ms);

tests/examples/c/asyncdemo.c

@@ -20,9 +20,9 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <sys/time.h>
 #include <unistd.h>
-#include <string.h>
 
 #include <taos.h>
 
@@ -33,14 +33,14 @@ int     tablesSelectProcessed = 0;
 int64_t st, et;
 
 typedef struct {
-  int       id;
-  TAOS     *taos;
-  char      name[16];
-  time_t    timeStamp;
-  int       value;
-  int       rowsInserted;
-  int       rowsTried;
-  int       rowsRetrieved;
+  int    id;
+  TAOS * taos;
+  char   name[16];
+  time_t timeStamp;
+  int    value;
+  int    rowsInserted;
+  int    rowsTried;
+  int    rowsRetrieved;
 } STable;
 
 void taos_insert_call_back(void *param, TAOS_RES *tres, int code);
@@ -48,7 +48,7 @@ void taos_select_call_back(void *param, TAOS_RES *tres, int code);
 void taos_error(TAOS *taos);
 
 static void queryDB(TAOS *taos, char *command) {
-  int i;
+  int       i;
   TAOS_RES *pSql = NULL;
   int32_t   code = -1;
 
@@ -57,12 +57,12 @@ static void queryDB(TAOS *taos, char *command) {
       taos_free_result(pSql);
       pSql = NULL;
     }
-    
+
     pSql = taos_query(taos, command);
     code = taos_errno(pSql);
     if (0 == code) {
       break;
-    }    
+    }
   }
 
   if (code != 0) {
@@ -76,15 +76,14 @@ static void queryDB(TAOS *taos, char *command) {
   taos_free_result(pSql);
 }
 
-int main(int argc, char *argv[])
-{
-  TAOS   *taos;
-  struct  timeval systemTime;
-  int     i;
-  char    sql[1024]  = { 0 };
-  char    prefix[20] = { 0 };
-  char    db[128]    = { 0 };
-  STable *tableList;
+int main(int argc, char *argv[]) {
+  TAOS *         taos;
+  struct timeval systemTime;
+  int            i;
+  char           sql[1024] = {0};
+  char           prefix[20] = {0};
+  char           db[128] = {0};
+  STable *       tableList;
 
   if (argc != 5) {
     printf("usage: %s server-ip dbname rowsPerTable numOfTables\n", argv[0]);
@@ -101,8 +100,7 @@ int main(int argc, char *argv[])
   memset(tableList, 0, size);
 
   taos = taos_connect(argv[1], "root", "taosdata", NULL, 0);
-  if (taos == NULL)
-    taos_error(taos);
+  if (taos == NULL) taos_error(taos);
 
   printf("success to connect to server\n");
 
@@ -122,7 +120,7 @@ int main(int argc, char *argv[])
     sprintf(tableList[i].name, "%s%d", prefix, i);
     sprintf(sql, "create table %s%d (ts timestamp, volume bigint)", prefix, i);
     queryDB(taos, sql);
-  }  
+  }
 
   gettimeofday(&systemTime, NULL);
   for (i = 0; i < numOfTables; ++i)
@@ -138,7 +136,7 @@ int main(int argc, char *argv[])
   tablesInsertProcessed = 0;
   tablesSelectProcessed = 0;
 
-  for (i = 0; i<numOfTables; ++i) {
+  for (i = 0; i < numOfTables; ++i) {
     // insert records in asynchronous API
     sprintf(sql, "insert into %s values(%ld, 0)", tableList[i].name, 1546300800000 + i);
     taos_query_a(taos, sql, taos_insert_call_back, (void *)(tableList + i));
@@ -147,12 +145,12 @@ int main(int argc, char *argv[])
   printf("once insert finished, presse any key to query\n");
   getchar();
 
-  while(1) {
+  while (1) {
     if (tablesInsertProcessed < numOfTables) {
-       printf("wait for process finished\n");
-       sleep(1);
-       continue;
-    }  
+      printf("wait for process finished\n");
+      sleep(1);
+      continue;
+    }
 
     break;
   }
@@ -161,9 +159,8 @@ int main(int argc, char *argv[])
   gettimeofday(&systemTime, NULL);
   st = systemTime.tv_sec * 1000000 + systemTime.tv_usec;
 
-
   for (i = 0; i < numOfTables; ++i) {
-    // select records in asynchronous API 
+    // select records in asynchronous API
     sprintf(sql, "select * from %s", tableList[i].name);
     taos_query_a(taos, sql, taos_select_call_back, (void *)(tableList + i));
   }
@@ -171,17 +168,17 @@ int main(int argc, char *argv[])
   printf("\nonce finished, press any key to exit\n");
   getchar();
 
-  while(1) {
+  while (1) {
     if (tablesSelectProcessed < numOfTables) {
-       printf("wait for process finished\n");
-       sleep(1);
-       continue;
-    }  
+      printf("wait for process finished\n");
+      sleep(1);
+      continue;
+    }
 
     break;
   }
 
-  for (i = 0; i<numOfTables; ++i)  {
+  for (i = 0; i < numOfTables; ++i) {
     printf("%s inserted:%d retrieved:%d\n", tableList[i].name, tableList[i].rowsInserted, tableList[i].rowsRetrieved);
   }
 
@@ -193,60 +190,54 @@ int main(int argc, char *argv[])
   return 0;
 }
 
-void taos_error(TAOS *con)
-{
+void taos_error(TAOS *con) {
   fprintf(stderr, "TDengine error: %s\n", taos_errstr(con));
   taos_close(con);
   taos_cleanup();
   exit(1);
 }
 
-void taos_insert_call_back(void *param, TAOS_RES *tres, int code)
-{
-  STable *pTable = (STable *)param;
-  struct  timeval systemTime;
-  char    sql[128];
+void taos_insert_call_back(void *param, TAOS_RES *tres, int code) {
+  STable *       pTable = (STable *)param;
+  struct timeval systemTime;
+  char           sql[128];
 
   pTable->rowsTried++;
 
-  if (code < 0)  {
+  if (code < 0) {
     printf("%s insert failed, code:%d, rows:%d\n", pTable->name, code, pTable->rowsTried);
-  }
-  else if (code == 0) {
+  } else if (code == 0) {
     printf("%s not inserted\n", pTable->name);
-  }
-  else {
+  } else {
     pTable->rowsInserted++;
   }
 
   if (pTable->rowsTried < points) {
     // for this demo, insert another record
-    sprintf(sql, "insert into %s values(%ld, %d)", pTable->name, 1546300800000+pTable->rowsTried*1000, pTable->rowsTried);
+    sprintf(sql, "insert into %s values(%ld, %d)", pTable->name, 1546300800000 + pTable->rowsTried * 1000,
+            pTable->rowsTried);
     taos_query_a(pTable->taos, sql, taos_insert_call_back, (void *)pTable);
-  }
-  else {
+  } else {
     printf("%d rows data are inserted into %s\n", points, pTable->name);
     tablesInsertProcessed++;
     if (tablesInsertProcessed >= numOfTables) {
       gettimeofday(&systemTime, NULL);
       et = systemTime.tv_sec * 1000000 + systemTime.tv_usec;
-      printf("%lld mseconds to insert %d data points\n", (et - st) / 1000, points*numOfTables);
+      printf("%lld mseconds to insert %d data points\n", (et - st) / 1000, points * numOfTables);
     }
   }
-  
+
   taos_free_result(tres);
 }
 
-void taos_retrieve_call_back(void *param, TAOS_RES *tres, int numOfRows)
-{
-  STable   *pTable = (STable *)param;
+void taos_retrieve_call_back(void *param, TAOS_RES *tres, int numOfRows) {
+  STable *       pTable = (STable *)param;
   struct timeval systemTime;
 
   if (numOfRows > 0) {
-
-    for (int i = 0; i<numOfRows; ++i) {
+    for (int i = 0; i < numOfRows; ++i) {
       // synchronous API to retrieve a row from batch of records
-      /*TAOS_ROW row = */(void)taos_fetch_row(tres);
+      /*TAOS_ROW row = */ (void)taos_fetch_row(tres);
       // process row
     }
 
@@ -255,12 +246,10 @@ void taos_retrieve_call_back(void *param, TAOS_RES *tres, int numOfRows)
     // retrieve next batch of rows
     taos_fetch_rows_a(tres, taos_retrieve_call_back, pTable);
 
-  }
-  else {
-    if (numOfRows < 0)
-      printf("%s retrieve failed, code:%d\n", pTable->name, numOfRows);
+  } else {
+    if (numOfRows < 0) printf("%s retrieve failed, code:%d\n", pTable->name, numOfRows);
 
-    //taos_free_result(tres);
+    // taos_free_result(tres);
     printf("%d rows data retrieved from %s\n", pTable->rowsRetrieved, pTable->name);
 
     tablesSelectProcessed++;
@@ -272,19 +261,15 @@ void taos_retrieve_call_back(void *param, TAOS_RES *tres, int numOfRows)
 
     taos_free_result(tres);
   }
-
-
 }
 
-void taos_select_call_back(void *param, TAOS_RES *tres, int code)
-{
+void taos_select_call_back(void *param, TAOS_RES *tres, int code) {
   STable *pTable = (STable *)param;
 
   if (code == 0 && tres) {
     // asynchronous API to fetch a batch of records
     taos_fetch_rows_a(tres, taos_retrieve_call_back, pTable);
-  }
-  else {
+  } else {
     printf("%s select failed, code:%d\n", pTable->name, code);
     taos_free_result(tres);
     taos_cleanup();

tests/examples/c/demo.c

@@ -16,14 +16,14 @@
 // TAOS standard API example. The same syntax as MySQL, but only a subset
 // to compile: gcc -o demo demo.c -ltaos
 
+#include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <inttypes.h>
 #include <taos.h>  // TAOS header file
 
 static void queryDB(TAOS *taos, char *command) {
-  int i;
+  int       i;
   TAOS_RES *pSql = NULL;
   int32_t   code = -1;
 
@@ -32,12 +32,12 @@ static void queryDB(TAOS *taos, char *command) {
       taos_free_result(pSql);
       pSql = NULL;
     }
-    
+
     pSql = taos_query(taos, command);
     code = taos_errno(pSql);
     if (0 == code) {
       break;
-    }    
+    }
   }
 
   if (code != 0) {
@@ -53,7 +53,7 @@ static void queryDB(TAOS *taos, char *command) {
 void Test(TAOS *taos, char *qstr, int i);
 
 int main(int argc, char *argv[]) {
-  char      qstr[1024];
+  char qstr[1024];
 
   // connect to server
   if (argc < 2) {
@@ -63,7 +63,7 @@ int main(int argc, char *argv[]) {
 
   TAOS *taos = taos_connect(argv[1], "root", "taosdata", NULL, 0);
   if (taos == NULL) {
-    printf("failed to connect to server, reason:%s\n", "null taos"/*taos_errstr(taos)*/);
+    printf("failed to connect to server, reason:%s\n", "null taos" /*taos_errstr(taos)*/);
     exit(1);
   }
   for (int i = 0; i < 100; i++) {
@@ -72,28 +72,30 @@ int main(int argc, char *argv[]) {
   taos_close(taos);
   taos_cleanup();
 }
-void Test(TAOS *taos, char *qstr, int index)  {
+void Test(TAOS *taos, char *qstr, int index) {
   printf("==================test at %d\n================================", index);
   queryDB(taos, "drop database if exists demo");
   queryDB(taos, "create database demo");
   TAOS_RES *result;
   queryDB(taos, "use demo");
 
-  queryDB(taos, "create table m1 (ts timestamp, ti tinyint, si smallint, i int, bi bigint, f float, d double, b binary(10))");
+  queryDB(taos,
+          "create table m1 (ts timestamp, ti tinyint, si smallint, i int, bi bigint, f float, d double, b binary(10))");
   printf("success to create table\n");
 
   int i = 0;
   for (i = 0; i < 10; ++i) {
-    sprintf(qstr, "insert into m1 values (%" PRId64 ", %d, %d, %d, %d, %f, %lf, '%s')", (uint64_t)(1546300800000 + i * 1000), i, i, i, i*10000000, i*1.0, i*2.0, "hello");
+    sprintf(qstr, "insert into m1 values (%" PRId64 ", %d, %d, %d, %d, %f, %lf, '%s')",
+            (uint64_t)(1546300800000 + i * 1000), i, i, i, i * 10000000, i * 1.0, i * 2.0, "hello");
     printf("qstr: %s\n", qstr);
-    
+
     // note: how do you wanna do if taos_query returns non-NULL
     // if (taos_query(taos, qstr)) {
     //   printf("insert row: %i, reason:%s\n", i, taos_errstr(taos));
     // }
     TAOS_RES *result1 = taos_query(taos, qstr);
     if (result1 == NULL || taos_errno(result1) != 0) {
-      printf("failed to insert row, reason:%s\n", taos_errstr(result1));    
+      printf("failed to insert row, reason:%s\n", taos_errstr(result1));
       taos_free_result(result1);
       exit(1);
     } else {
@@ -107,7 +109,7 @@ void Test(TAOS *taos, char *qstr, int index)  {
   sprintf(qstr, "SELECT * FROM m1");
   result = taos_query(taos, qstr);
   if (result == NULL || taos_errno(result) != 0) {
-    printf("failed to select, reason:%s\n", taos_errstr(result));    
+    printf("failed to select, reason:%s\n", taos_errstr(result));
     taos_free_result(result);
     exit(1);
   }
@@ -130,4 +132,3 @@ void Test(TAOS *taos, char *qstr, int index)  {
   taos_free_result(result);
   printf("====demo end====\n\n");
 }
-

tests/examples/c/epoll.c

@@ -21,103 +21,101 @@
 
 #ifdef __APPLE__
 #include "osEok.h"
-#else // __APPLE__
+#else  // __APPLE__
 #include <sys/epoll.h>
-#endif // __APPLE__
-#include <sys/types.h>
-#include <sys/time.h>
-#include <sys/socket.h>
-#include <pthread.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <netinet/in.h>
+#endif  // __APPLE__
 #include <arpa/inet.h>
-#include <fcntl.h>
 #include <errno.h>
-#include <string.h>
-#include <arpa/inet.h>
+#include <fcntl.h>
 #include <libgen.h>
 #include <locale.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/time.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 #define D(fmt, ...) fprintf(stderr, "%s[%d]%s(): " fmt "\n", basename(__FILE__), __LINE__, __func__, ##__VA_ARGS__)
-#define A(statement, fmt, ...) do {                                     \
-  if (statement) break;                                                 \
-  fprintf(stderr, "%s[%d]%s(): assert [%s] failed: %d[%s]: " fmt "\n",  \
-          basename(__FILE__), __LINE__, __func__,                       \
-          #statement, errno, strerror(errno),                           \
-          ##__VA_ARGS__);                                               \
-  abort();                                                              \
-} while (0)
+#define A(statement, fmt, ...)                                                                                   \
+  do {                                                                                                           \
+    if (statement) break;                                                                                        \
+    fprintf(stderr, "%s[%d]%s(): assert [%s] failed: %d[%s]: " fmt "\n", basename(__FILE__), __LINE__, __func__, \
+            #statement, errno, strerror(errno), ##__VA_ARGS__);                                                  \
+    abort();                                                                                                     \
+  } while (0)
 
-#define E(fmt, ...) do {                                                \
-  fprintf(stderr, "%s[%d]%s(): %d[%s]: " fmt "\n",                      \
-          basename(__FILE__), __LINE__, __func__,                       \
-          errno, strerror(errno),                                       \
-          ##__VA_ARGS__);                                               \
-} while (0)
+#define E(fmt, ...)                                                                                                  \
+  do {                                                                                                               \
+    fprintf(stderr, "%s[%d]%s(): %d[%s]: " fmt "\n", basename(__FILE__), __LINE__, __func__, errno, strerror(errno), \
+            ##__VA_ARGS__);                                                                                          \
+  } while (0)
 
 #include "os.h"
 
-typedef struct ep_s            ep_t;
+typedef struct ep_s ep_t;
 struct ep_s {
-  int                    ep;
+  int ep;
 
-  pthread_mutex_t        lock;
-  int                    sv[2];  // 0 for read, 1 for write;
-  pthread_t              thread;
+  pthread_mutex_t lock;
+  int             sv[2];  // 0 for read, 1 for write;
+  pthread_t       thread;
 
-  volatile unsigned int  stopping:1;
-  volatile unsigned int  waiting:1;
-  volatile unsigned int  wakenup:1;
+  volatile unsigned int stopping : 1;
+  volatile unsigned int waiting : 1;
+  volatile unsigned int wakenup : 1;
 };
 
 static int ep_dummy = 0;
 
-static ep_t* ep_create(void);
+static ep_t *ep_create(void);
 static void  ep_destroy(ep_t *ep);
-static void* routine(void* arg);
-static int open_listen(unsigned short port);
+static void *routine(void *arg);
+static int   open_listen(unsigned short port);
 
-typedef struct fde_s          fde_t;
+typedef struct fde_s fde_t;
 struct fde_s {
-  int                          skt;
+  int skt;
   void (*on_event)(ep_t *ep, struct epoll_event *events, fde_t *client);
 };
 
 static void listen_event(ep_t *ep, struct epoll_event *ev, fde_t *client);
 static void null_event(ep_t *ep, struct epoll_event *ev, fde_t *client);
 
-#define usage(arg0, fmt, ...)       do {                                               \
-  if (fmt[0]) {                                                                        \
-    fprintf(stderr, "" fmt "\n", ##__VA_ARGS__);                                       \
-  }                                                                                    \
-  fprintf(stderr, "usage:\n");                                                         \
-  fprintf(stderr, "  %s -l <port>             : specify listenning port\n", arg0);     \
-} while (0)
+#define usage(arg0, fmt, ...)                                                        \
+  do {                                                                               \
+    if (fmt[0]) {                                                                    \
+      fprintf(stderr, "" fmt "\n", ##__VA_ARGS__);                                   \
+    }                                                                                \
+    fprintf(stderr, "usage:\n");                                                     \
+    fprintf(stderr, "  %s -l <port>             : specify listenning port\n", arg0); \
+  } while (0)
 
 int main(int argc, char *argv[]) {
   char *prg = basename(argv[0]);
-  if (argc==1) {
+  if (argc == 1) {
     usage(prg, "");
     return 0;
   }
-  ep_t* ep = ep_create();
+  ep_t *ep = ep_create();
   A(ep, "failed");
-  for (int i=1; i<argc; ++i) {
+  for (int i = 1; i < argc; ++i) {
     const char *arg = argv[i];
-    if (0==strcmp(arg, "-l")) {
+    if (0 == strcmp(arg, "-l")) {
       ++i;
-      if (i>=argc) {
+      if (i >= argc) {
         usage(prg, "expecting <port> after -l, but got nothing");
-        return 1; // confirmed potential leakage
+        return 1;  // confirmed potential leakage
       }
       arg = argv[i];
       int port = atoi(arg);
       int skt = open_listen(port);
-      if (skt==-1) continue;
-      fde_t *client = (fde_t*)calloc(1, sizeof(*client));
+      if (skt == -1) continue;
+      fde_t *client = (fde_t *)calloc(1, sizeof(*client));
       if (!client) {
         E("out of memory");
         close(skt);
@@ -126,32 +124,32 @@ int main(int argc, char *argv[]) {
       client->skt = skt;
       client->on_event = listen_event;
       struct epoll_event ev = {0};
-      ev.events   = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLRDHUP;
+      ev.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLRDHUP;
       ev.data.ptr = client;
-      A(0==epoll_ctl(ep->ep, EPOLL_CTL_ADD, skt, &ev), "");
+      A(0 == epoll_ctl(ep->ep, EPOLL_CTL_ADD, skt, &ev), "");
       continue;
     }
     usage(prg, "unknown argument: [%s]", arg);
     return 1;
   }
-  char *line = NULL;
-  size_t linecap = 0;
+  char *  line = NULL;
+  size_t  linecap = 0;
   ssize_t linelen;
   while ((linelen = getline(&line, &linecap, stdin)) > 0) {
-    line[strlen(line)-1] = '\0';
-    if (0==strcmp(line, "exit")) break;
-    if (0==strcmp(line, "quit")) break;
-    if (line==strstr(line, "close")) {
+    line[strlen(line) - 1] = '\0';
+    if (0 == strcmp(line, "exit")) break;
+    if (0 == strcmp(line, "quit")) break;
+    if (line == strstr(line, "close")) {
       int fd = 0;
       sscanf(line, "close %d", &fd);
-      if (fd<=2) {
+      if (fd <= 2) {
         fprintf(stderr, "fd [%d] invalid\n", fd);
         continue;
       }
-      A(0==epoll_ctl(ep->ep, EPOLL_CTL_DEL, fd, NULL), "");
+      A(0 == epoll_ctl(ep->ep, EPOLL_CTL_DEL, fd, NULL), "");
       continue;
     }
-    if (strlen(line)==0) continue;
+    if (strlen(line) == 0) continue;
     fprintf(stderr, "unknown cmd:[%s]\n", line);
   }
   ep_destroy(ep);
@@ -159,69 +157,69 @@ int main(int argc, char *argv[]) {
   return 0;
 }
 
-ep_t* ep_create(void) {
-  ep_t *ep = (ep_t*)calloc(1, sizeof(*ep));
+ep_t *ep_create(void) {
+  ep_t *ep = (ep_t *)calloc(1, sizeof(*ep));
   A(ep, "out of memory");
-  A(-1!=(ep->ep = epoll_create(1)), "");
+  A(-1 != (ep->ep = epoll_create(1)), "");
   ep->sv[0] = -1;
   ep->sv[1] = -1;
-  A(0==socketpair(AF_LOCAL, SOCK_STREAM, 0, ep->sv), "");
-  A(0==pthread_mutex_init(&ep->lock, NULL), "");
-  A(0==pthread_mutex_lock(&ep->lock), "");
+  A(0 == socketpair(AF_LOCAL, SOCK_STREAM, 0, ep->sv), "");
+  A(0 == pthread_mutex_init(&ep->lock, NULL), "");
+  A(0 == pthread_mutex_lock(&ep->lock), "");
   struct epoll_event ev = {0};
-  ev.events   = EPOLLIN;
+  ev.events = EPOLLIN;
   ev.data.ptr = &ep_dummy;
-  A(0==epoll_ctl(ep->ep, EPOLL_CTL_ADD, ep->sv[0], &ev), "");
-  A(0==pthread_create(&ep->thread, NULL, routine, ep), "");
-  A(0==pthread_mutex_unlock(&ep->lock), "");
+  A(0 == epoll_ctl(ep->ep, EPOLL_CTL_ADD, ep->sv[0], &ev), "");
+  A(0 == pthread_create(&ep->thread, NULL, routine, ep), "");
+  A(0 == pthread_mutex_unlock(&ep->lock), "");
   return ep;
 }
 
 static void ep_destroy(ep_t *ep) {
   A(ep, "invalid argument");
   ep->stopping = 1;
-  A(1==send(ep->sv[1], "1", 1, 0), "");
-  A(0==pthread_join(ep->thread, NULL), "");
-  A(0==pthread_mutex_destroy(&ep->lock), "");
-  A(0==close(ep->sv[0]), "");
-  A(0==close(ep->sv[1]), "");
-  A(0==close(ep->ep), "");
+  A(1 == send(ep->sv[1], "1", 1, 0), "");
+  A(0 == pthread_join(ep->thread, NULL), "");
+  A(0 == pthread_mutex_destroy(&ep->lock), "");
+  A(0 == close(ep->sv[0]), "");
+  A(0 == close(ep->sv[1]), "");
+  A(0 == close(ep->ep), "");
   free(ep);
 }
 
-static void* routine(void* arg) {
+static void *routine(void *arg) {
   A(arg, "invalid argument");
-  ep_t *ep = (ep_t*)arg;
+  ep_t *ep = (ep_t *)arg;
 
   while (!ep->stopping) {
     struct epoll_event evs[10];
     memset(evs, 0, sizeof(evs));
 
-    A(0==pthread_mutex_lock(&ep->lock), "");
-    A(ep->waiting==0, "internal logic error");
+    A(0 == pthread_mutex_lock(&ep->lock), "");
+    A(ep->waiting == 0, "internal logic error");
     ep->waiting = 1;
-    A(0==pthread_mutex_unlock(&ep->lock), "");
+    A(0 == pthread_mutex_unlock(&ep->lock), "");
 
-    int r = epoll_wait(ep->ep, evs, sizeof(evs)/sizeof(evs[0]), -1);
-    A(r>0, "indefinite epoll_wait shall not timeout:[%d]", r);
+    int r = epoll_wait(ep->ep, evs, sizeof(evs) / sizeof(evs[0]), -1);
+    A(r > 0, "indefinite epoll_wait shall not timeout:[%d]", r);
 
-    A(0==pthread_mutex_lock(&ep->lock), "");
-    A(ep->waiting==1, "internal logic error");
+    A(0 == pthread_mutex_lock(&ep->lock), "");
+    A(ep->waiting == 1, "internal logic error");
     ep->waiting = 0;
-    A(0==pthread_mutex_unlock(&ep->lock), "");
+    A(0 == pthread_mutex_unlock(&ep->lock), "");
 
-    for (int i=0; i<r; ++i) {
+    for (int i = 0; i < r; ++i) {
       struct epoll_event *ev = evs + i;
       if (ev->data.ptr == &ep_dummy) {
         char c = '\0';
-        A(1==recv(ep->sv[0], &c, 1, 0), "internal logic error");
-        A(0==pthread_mutex_lock(&ep->lock), "");
+        A(1 == recv(ep->sv[0], &c, 1, 0), "internal logic error");
+        A(0 == pthread_mutex_lock(&ep->lock), "");
         ep->wakenup = 0;
-        A(0==pthread_mutex_unlock(&ep->lock), "");
+        A(0 == pthread_mutex_unlock(&ep->lock), "");
         continue;
       }
       A(ev->data.ptr, "internal logic error");
-      fde_t *client = (fde_t*)ev->data.ptr;
+      fde_t *client = (fde_t *)ev->data.ptr;
       client->on_event(ep, ev, client);
       continue;
     }
@@ -232,7 +230,7 @@ static void* routine(void* arg) {
 static int open_listen(unsigned short port) {
   int r = 0;
   int skt = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-  if (skt==-1) {
+  if (skt == -1) {
     E("socket() failed");
     return -1;
   }
@@ -241,7 +239,7 @@ static int open_listen(unsigned short port) {
     si.sin_family = AF_INET;
     si.sin_addr.s_addr = inet_addr("0.0.0.0");
     si.sin_port = htons(port);
-    r = bind(skt, (struct sockaddr*)&si, sizeof(si));
+    r = bind(skt, (struct sockaddr *)&si, sizeof(si));
     if (r) {
       E("bind(%u) failed", port);
       break;
@@ -257,7 +255,7 @@ static int open_listen(unsigned short port) {
     if (r) {
       E("getsockname() failed");
     }
-    A(len==sizeof(si), "internal logic error");
+    A(len == sizeof(si), "internal logic error");
     D("listenning at: %d", ntohs(si.sin_port));
     return skt;
   } while (0);
@@ -268,10 +266,10 @@ static int open_listen(unsigned short port) {
 static void listen_event(ep_t *ep, struct epoll_event *ev, fde_t *client) {
   A(ev->events & EPOLLIN, "internal logic error");
   struct sockaddr_in si = {0};
-  socklen_t silen = sizeof(si);
-  int skt = accept(client->skt, (struct sockaddr*)&si, &silen);
-  A(skt!=-1, "internal logic error");
-  fde_t *server = (fde_t*)calloc(1, sizeof(*server));
+  socklen_t          silen = sizeof(si);
+  int                skt = accept(client->skt, (struct sockaddr *)&si, &silen);
+  A(skt != -1, "internal logic error");
+  fde_t *server = (fde_t *)calloc(1, sizeof(*server));
   if (!server) {
     close(skt);
     return;
@@ -279,26 +277,25 @@ static void listen_event(ep_t *ep, struct epoll_event *ev, fde_t *client) {
   server->skt = skt;
   server->on_event = null_event;
   struct epoll_event ee = {0};
-  ee.events   = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLRDHUP;
+  ee.events = EPOLLIN | EPOLLERR | EPOLLHUP | EPOLLRDHUP;
   ee.data.ptr = server;
-  A(0==epoll_ctl(ep->ep, EPOLL_CTL_ADD, skt, &ee), "");
+  A(0 == epoll_ctl(ep->ep, EPOLL_CTL_ADD, skt, &ee), "");
 }
 
 static void null_event(ep_t *ep, struct epoll_event *ev, fde_t *client) {
   if (ev->events & EPOLLIN) {
     char buf[8192];
-    int n = recv(client->skt, buf, sizeof(buf), 0);
-    A(n>=0 && n<=sizeof(buf), "internal logic error:[%d]", n);
-    A(n==fwrite(buf, 1, n, stdout), "internal logic error");
+    int  n = recv(client->skt, buf, sizeof(buf), 0);
+    A(n >= 0 && n <= sizeof(buf), "internal logic error:[%d]", n);
+    A(n == fwrite(buf, 1, n, stdout), "internal logic error");
   }
   if (ev->events & (EPOLLERR | EPOLLHUP | EPOLLRDHUP)) {
-    A(0==pthread_mutex_lock(&ep->lock), "");
-    A(0==epoll_ctl(ep->ep, EPOLL_CTL_DEL, client->skt, NULL), "");
-    A(0==pthread_mutex_unlock(&ep->lock), "");
+    A(0 == pthread_mutex_lock(&ep->lock), "");
+    A(0 == epoll_ctl(ep->ep, EPOLL_CTL_DEL, client->skt, NULL), "");
+    A(0 == pthread_mutex_unlock(&ep->lock), "");
     close(client->skt);
     client->skt = -1;
     client->on_event = NULL;
     free(client);
   }
 }
-

tests/examples/c/makefile

@@ -6,8 +6,13 @@ TARGET=exe
 LFLAGS = '-Wl,-rpath,/usr/local/taos/driver/' -ltaos -lpthread -lm -lrt
 CFLAGS = -O3 -g -Wall -Wno-deprecated -fPIC -Wno-unused-result -Wconversion \
 	-Wno-char-subscripts -D_REENTRANT -Wno-format -D_REENTRANT -DLINUX \
+
 	-Wno-unused-function -D_M_X64 -I/usr/local/taos/include -std=gnu99 \
 	-I../../../deps/cJson/inc
+
+	-Wno-unused-function -D_M_X64 -I/usr/local/taos/include -std=gnu99
+	-fsanitize=address -fsanitize=undefined -fno-sanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=null -fno-sanitize=alignment
+
 all: $(TARGET)
 
 exe:

tests/examples/c/subscribe.c

@@ -14,10 +14,10 @@ void print_result(TAOS_RES* res, int blockFetch) {
   int         num_fields = taos_num_fields(res);
   TAOS_FIELD* fields = taos_fetch_fields(res);
   int         nRows = 0;
-  
+
   if (blockFetch) {
     nRows = taos_fetch_block(res, &row);
-    //for (int i = 0; i < nRows; i++) {
+    // for (int i = 0; i < nRows; i++) {
     //  taos_print_row(buf, row + i, fields, num_fields);
     //  puts(buf);
     //}
@@ -34,15 +34,11 @@ void print_result(TAOS_RES* res, int blockFetch) {
   printf("%d rows consumed.\n", nRows);
 }
 
-
-void subscribe_callback(TAOS_SUB* tsub, TAOS_RES *res, void* param, int code) {
-  print_result(res, *(int*)param);
-}
-
+void subscribe_callback(TAOS_SUB* tsub, TAOS_RES* res, void* param, int code) { print_result(res, *(int*)param); }
 
 void check_row_count(int line, TAOS_RES* res, int expected) {
-  int actual = 0;
-  TAOS_ROW    row;
+  int      actual = 0;
+  TAOS_ROW row;
   while ((row = taos_fetch_row(res))) {
     actual++;
   }
@@ -53,16 +49,14 @@ void check_row_count(int line, TAOS_RES* res, int expected) {
   }
 }
 
-
 void do_query(TAOS* taos, const char* sql) {
   TAOS_RES* res = taos_query(taos, sql);
   taos_free_result(res);
 }
 
-
 void run_test(TAOS* taos) {
   do_query(taos, "drop database if exists test;");
-  
+
   usleep(100000);
   do_query(taos, "create database test;");
   usleep(100000);
@@ -161,14 +155,13 @@ void run_test(TAOS* taos) {
   taos_unsubscribe(tsub, 0);
 }
 
-
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   const char* host = "127.0.0.1";
   const char* user = "root";
   const char* passwd = "taosdata";
   const char* sql = "select * from meters;";
   const char* topic = "test-multiple";
-  int async = 1, restart = 0, keep = 1, test = 0, blockFetch = 0;
+  int         async = 1, restart = 0, keep = 1, test = 0, blockFetch = 0;
 
   for (int i = 1; i < argc; i++) {
     if (strncmp(argv[i], "-h=", 3) == 0) {
@@ -240,20 +233,21 @@ int main(int argc, char *argv[]) {
   if (tsub == NULL) {
     printf("failed to create subscription.\n");
     exit(0);
-  } 
+  }
 
   if (async) {
     getchar();
-  } else while(1) {
-    TAOS_RES* res = taos_consume(tsub);
-    if (res == NULL) {
-      printf("failed to consume data.");
-      break;
-    } else {
-      print_result(res, blockFetch);
-      getchar();
+  } else
+    while (1) {
+      TAOS_RES* res = taos_consume(tsub);
+      if (res == NULL) {
+        printf("failed to consume data.");
+        break;
+      } else {
+        print_result(res, blockFetch);
+        getchar();
+      }
     }
-  }
 
   printf("total rows consumed: %d\n", nTotalRows);
   taos_unsubscribe(tsub, keep);

tests/nettest/TCPUDP.sh

-#!/bin/bash
-
-for N in -1 0 1 10000 10001
-do
-	for l in 1023 1024 1073741824 1073741825 
-	do
-		for S in udp tcp 
-		do
-			taos -n speed -h BCC-2 -P 6030 -N $N -l $l -S $S 2>&1 | tee -a result.txt
-		done
-	done
-done

tests/pytest/client/version.py

@@ -36,6 +36,7 @@ class TDTestCase:
         else:
             tdLog.exit("sql:%s, row:%d col:%d data:%d != expect:%d " % (sql, 0, 0, version, expectedVersion))
 
+            
         sql = "select client_version()"
         ret = tdSql.query(sql)
         version = floor(float(tdSql.getData(0, 0)[0:3]))        

tests/pytest/crash_gen/service_manager.py

@@ -134,7 +134,8 @@ cDebugFlag 135
 rpcDebugFlag 135
 qDebugFlag 135
 # httpDebugFlag 143
-# asyncLog 0
+asyncLog 0
+debugflag 143
 # tables 10
 maxtablesPerVnode 10
 rpcMaxTime 101