merge with develop branch.

Jenkinsfile

@@ -265,12 +265,12 @@ pipeline {
                 }
             }
             timeout(time: 60, unit: 'MINUTES'){
-              sh '''
-              cd ${WKC}/tests/pytest
-              rm -rf /var/lib/taos/*
-              rm -rf /var/log/taos/*
-              ./handle_crash_gen_val_log.sh
-              '''
+              // sh '''
+              // cd ${WKC}/tests/pytest
+              // rm -rf /var/lib/taos/*
+              // rm -rf /var/log/taos/*
+              // ./handle_crash_gen_val_log.sh
+              // '''
               sh '''
               cd ${WKC}/tests/pytest
               rm -rf /var/lib/taos/*

TSZ @ 0ca5b15a

-Subproject commit ceda5bf9fcd7836509ac97dcc0056b3f1dd48cc5
+Subproject commit 0ca5b15a8eac40327dd737be52c926fa5675712c

src/client/inc/tscUtil.h

@@ -36,7 +36,7 @@ extern "C" {
   (((metaInfo)->pTableMeta != NULL) && ((metaInfo)->pTableMeta->tableType == TSDB_CHILD_TABLE))
 
 #define UTIL_TABLE_IS_NORMAL_TABLE(metaInfo) \
-  (!(UTIL_TABLE_IS_SUPER_TABLE(metaInfo) || UTIL_TABLE_IS_CHILD_TABLE(metaInfo) || UTIL_TABLE_IS_TMP_TABLE(metaInfo)))
+  (!(UTIL_TABLE_IS_SUPER_TABLE(metaInfo) || UTIL_TABLE_IS_CHILD_TABLE(metaInfo)))
 
 #define UTIL_TABLE_IS_TMP_TABLE(metaInfo) \
   (((metaInfo)->pTableMeta != NULL) && ((metaInfo)->pTableMeta->tableType == TSDB_TEMP_TABLE))

src/client/src/tscGlobalmerge.c

@@ -35,6 +35,7 @@ typedef struct SCompareParam {
 
 static bool needToMerge(SSDataBlock* pBlock, SArray* columnIndexList, int32_t index, char **buf) {
   int32_t ret = 0;
+
   size_t  size = taosArrayGetSize(columnIndexList);
   if (size > 0) {
     ret = compare_aRv(pBlock, columnIndexList, (int32_t) size, index, buf, TSDB_ORDER_ASC);
@@ -564,9 +565,11 @@ static void savePrevOrderColumns(char** prevRow, SArray* pColumnList, SSDataBloc
   (*hasPrev) = true;
 }
 
+// tsdb_func_tag function only produce one row of result. Therefore, we need to copy the
+// output value to multiple rows
 static void setTagValueForMultipleRows(SQLFunctionCtx* pCtx, int32_t numOfOutput, int32_t numOfRows) {
   if (numOfRows <= 1) {
-    return ;
+    return;
   }
 
   for (int32_t k = 0; k < numOfOutput; ++k) {
@@ -574,31 +577,20 @@ static void setTagValueForMultipleRows(SQLFunctionCtx* pCtx, int32_t numOfOutput
       continue;
     }
 
-    int32_t inc = numOfRows - 1;  // tsdb_func_tag function only produce one row of result
     char* src  = pCtx[k].pOutput;
+    char* dst = pCtx[k].pOutput + pCtx[k].outputBytes;
 
-    for (int32_t i = 0; i < inc; ++i) {
-      pCtx[k].pOutput += pCtx[k].outputBytes;
-      memcpy(pCtx[k].pOutput, src, (size_t)pCtx[k].outputBytes);
+    // Let's start from the second row, as the first row has result value already.
+    for (int32_t i = 1; i < numOfRows; ++i) {
+      memcpy(dst, src, (size_t)pCtx[k].outputBytes);
+      dst += pCtx[k].outputBytes;
     }
   }
 }
 
-static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSDataBlock* pBlock) {
-  SMultiwayMergeInfo* pInfo = pOperator->info;
-  SQLFunctionCtx* pCtx = pInfo->binfo.pCtx;
-
-  char** add = calloc(pBlock->info.numOfCols, POINTER_BYTES);
-  for(int32_t i = 0; i < pBlock->info.numOfCols; ++i) {
-    add[i] = pCtx[i].pInput;
-    pCtx[i].size = 1;
-  }
-
-  for(int32_t i = 0; i < pBlock->info.rows; ++i) {
-    if (pInfo->hasPrev) {
-      if (needToMerge(pBlock, pInfo->orderColumnList, i, pInfo->prevRow)) {
+static void doMergeResultImpl(SMultiwayMergeInfo* pInfo, SQLFunctionCtx *pCtx, int32_t numOfExpr, int32_t rowIndex, char** pDataPtr) {
   for (int32_t j = 0; j < numOfExpr; ++j) {
-          pCtx[j].pInput = add[j] + pCtx[j].inputBytes * i;
+    pCtx[j].pInput = pDataPtr[j] + pCtx[j].inputBytes * rowIndex;
   }
 
   for (int32_t j = 0; j < numOfExpr; ++j) {
@@ -609,16 +601,15 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
 
     if (functionId < 0) {
       SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
-
       doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_MERGE);
-
-            continue;
-          }
-
+    } else {
       aAggs[functionId].mergeFunc(&pCtx[j]);
     }
-      } else {
-        for(int32_t j = 0; j < numOfExpr; ++j) {  // TODO refactor
+  }
+}
+
+static void doFinalizeResultImpl(SMultiwayMergeInfo* pInfo, SQLFunctionCtx *pCtx, int32_t numOfExpr) {
+  for(int32_t j = 0; j < numOfExpr; ++j) {
     int32_t functionId = pCtx[j].functionId;
     if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
       continue;
@@ -626,15 +617,30 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
 
     if (functionId < 0) {
       SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
-
       doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE);
-
-            continue;
+    } else {
+      aAggs[functionId].xFinalize(&pCtx[j]);
+    }
   }
+}
 
-          aAggs[functionId].xFinalize(&pCtx[j]);
+static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSDataBlock* pBlock) {
+  SMultiwayMergeInfo* pInfo = pOperator->info;
+  SQLFunctionCtx* pCtx = pInfo->binfo.pCtx;
+
+  char** addrPtr = calloc(pBlock->info.numOfCols, POINTER_BYTES);
+  for(int32_t i = 0; i < pBlock->info.numOfCols; ++i) {
+    addrPtr[i] = pCtx[i].pInput;
+    pCtx[i].size = 1;
   }
 
+  for(int32_t i = 0; i < pBlock->info.rows; ++i) {
+    if (pInfo->hasPrev) {
+      if (needToMerge(pBlock, pInfo->orderColumnList, i, pInfo->prevRow)) {
+        doMergeResultImpl(pInfo, pCtx, numOfExpr, i, addrPtr);
+      } else {
+        doFinalizeResultImpl(pInfo, pCtx, numOfExpr);
+
         int32_t numOfRows = getNumOfResult(pOperator->pRuntimeEnv, pInfo->binfo.pCtx, pOperator->numOfOutput);
         setTagValueForMultipleRows(pCtx, pOperator->numOfOutput, numOfRows);
 
@@ -655,48 +661,10 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
           aAggs[pCtx[j].functionId].init(&pCtx[j], pCtx[j].resultInfo);
         }
 
-        for (int32_t j = 0; j < numOfExpr; ++j) {
-          pCtx[j].pInput = add[j] + pCtx[j].inputBytes * i;
-        }
-
-        for (int32_t j = 0; j < numOfExpr; ++j) {
-          int32_t functionId = pCtx[j].functionId;
-          if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
-            continue;
-          }
-
-          if (functionId < 0) {
-            SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
-
-            doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_MERGE);
-
-            continue;
-          }
-
-          aAggs[functionId].mergeFunc(&pCtx[j]);
-        }
+        doMergeResultImpl(pInfo, pCtx, numOfExpr, i, addrPtr);
       }
     } else {
-      for (int32_t j = 0; j < numOfExpr; ++j) {
-        pCtx[j].pInput = add[j] + pCtx[j].inputBytes * i;
-      }
-
-      for (int32_t j = 0; j < numOfExpr; ++j) {
-        int32_t functionId = pCtx[j].functionId;
-        if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
-          continue;
-        }
-
-        if (functionId < 0) {
-          SUdfInfo* pUdfInfo = taosArrayGet(pInfo->udfInfo, -1 * functionId - 1);
-
-          doInvokeUdf(pUdfInfo, &pCtx[j], 0, TSDB_UDF_FUNC_MERGE);
-
-          continue;
-        }
-
-        aAggs[functionId].mergeFunc(&pCtx[j]);
-      }
+      doMergeResultImpl(pInfo, pCtx, numOfExpr, i, addrPtr);
     }
 
     savePrevOrderColumns(pInfo->prevRow, pInfo->orderColumnList, pBlock, i, &pInfo->hasPrev);
@@ -704,11 +672,11 @@ static void doExecuteFinalMerge(SOperatorInfo* pOperator, int32_t numOfExpr, SSD
 
   {
     for(int32_t i = 0; i < pBlock->info.numOfCols; ++i) {
-      pCtx[i].pInput = add[i];
+      pCtx[i].pInput = addrPtr[i];
     }
   }
 
-  tfree(add);
+  tfree(addrPtr);
 }
 
 static bool isAllSourcesCompleted(SGlobalMerger *pMerger) {
@@ -816,6 +784,8 @@ SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup) {
     SLocalDataSource *pOneDataSrc = pMerger->pLocalDataSrc[pTree->pNode[0].index];
     bool sameGroup = true;
     if (pInfo->hasPrev) {
+
+      // todo refactor extract method
       int32_t numOfCols = (int32_t)taosArrayGetSize(pInfo->orderColumnList);
 
       // if this row belongs to current result set group
@@ -955,9 +925,10 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
       break;
     }
 
+    bool sameGroup = true;
     if (pAggInfo->hasGroupColData) {
-      bool sameGroup = isSameGroup(pAggInfo->groupColumnList, pBlock, pAggInfo->currentGroupColData);
-      if (!sameGroup) {
+      sameGroup = isSameGroup(pAggInfo->groupColumnList, pBlock, pAggInfo->currentGroupColData);
+      if (!sameGroup && !pAggInfo->multiGroupResults) {
         *newgroup = true;
         pAggInfo->hasDataBlockForNewGroup = true;
         pAggInfo->pExistBlock = pBlock;
@@ -976,26 +947,11 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
   }
 
   if (handleData) { // data in current group is all handled
-    for(int32_t j = 0; j < pOperator->numOfOutput; ++j) {
-      int32_t functionId = pAggInfo->binfo.pCtx[j].functionId;
-      if (functionId == TSDB_FUNC_TAG_DUMMY || functionId == TSDB_FUNC_TS_DUMMY) {
-        continue;
-      }
-
-      if (functionId < 0) {
-        SUdfInfo* pUdfInfo = taosArrayGet(pAggInfo->udfInfo, -1 * functionId - 1);
-
-        doInvokeUdf(pUdfInfo, &pAggInfo->binfo.pCtx[j], 0, TSDB_UDF_FUNC_FINALIZE);
-
-        continue;
-      }
-
-      aAggs[functionId].xFinalize(&pAggInfo->binfo.pCtx[j]);
-    }
+    doFinalizeResultImpl(pAggInfo, pAggInfo->binfo.pCtx, pOperator->numOfOutput);
 
     int32_t numOfRows = getNumOfResult(pOperator->pRuntimeEnv, pAggInfo->binfo.pCtx, pOperator->numOfOutput);
-    pAggInfo->binfo.pRes->info.rows += numOfRows;
 
+    pAggInfo->binfo.pRes->info.rows += numOfRows;
     setTagValueForMultipleRows(pAggInfo->binfo.pCtx, pOperator->numOfOutput, numOfRows);
   }
 
@@ -1019,71 +975,127 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
   return (pRes->info.rows != 0)? pRes:NULL;
 }
 
-static SSDataBlock* skipGroupBlock(SOperatorInfo* pOperator, bool* newgroup) {
-  SSLimitOperatorInfo *pInfo = pOperator->info;
-  assert(pInfo->currentGroupOffset >= 0);
+static void doHandleDataInCurrentGroup(SSLimitOperatorInfo* pInfo, SSDataBlock* pBlock, int32_t rowIndex) {
+  if (pInfo->currentOffset > 0) {
+    pInfo->currentOffset -= 1;
+  } else {
+    // discard the data rows in current group
+    if (pInfo->limit.limit < 0 || (pInfo->limit.limit >= 0 && pInfo->rowsTotal < pInfo->limit.limit)) {
+      size_t num1 = taosArrayGetSize(pInfo->pRes->pDataBlock);
+      for (int32_t i = 0; i < num1; ++i) {
+        SColumnInfoData *pColInfoData = taosArrayGet(pBlock->pDataBlock, i);
+        SColumnInfoData *pDstInfoData = taosArrayGet(pInfo->pRes->pDataBlock, i);
 
-  SSDataBlock* pBlock = NULL;
-  if (pInfo->currentGroupOffset == 0) {
-    publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
-    pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
-    publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
-    if (pBlock == NULL) {
-      setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
-      pOperator->status = OP_EXEC_DONE;
+        SColumnInfo *pColInfo = &pColInfoData->info;
+        
+        char *pSrc = rowIndex * pColInfo->bytes + (char *)pColInfoData->pData;
+        char *pDst = (char *)pDstInfoData->pData + (pInfo->pRes->info.rows * pColInfo->bytes);
+
+        memcpy(pDst, pSrc, pColInfo->bytes);
       }
 
-    if (*newgroup == false && pInfo->limit.limit > 0 && pInfo->rowsTotal >= pInfo->limit.limit) {
-      while ((*newgroup) == false) {  // ignore the remain blocks
-        publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
-        pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
-        publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
-        if (pBlock == NULL) {
-          setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
-          pOperator->status = OP_EXEC_DONE;
-          return NULL;
+      pInfo->rowsTotal += 1;
+      pInfo->pRes->info.rows += 1;
     }
   }
+}
+
+static void ensureOutputBuf(SSLimitOperatorInfo * pInfo, SSDataBlock *pResultBlock, int32_t numOfRows) {
+  if (pInfo->capacity < pResultBlock->info.rows + numOfRows) {
+    int32_t total = pResultBlock->info.rows + numOfRows;
+
+    size_t num = taosArrayGetSize(pResultBlock->pDataBlock);
+    for (int32_t i = 0; i < num; ++i) {
+      SColumnInfoData *pInfoData = taosArrayGet(pResultBlock->pDataBlock, i);
+
+      char *tmp = realloc(pInfoData->pData, total * pInfoData->info.bytes);
+      if (tmp != NULL) {
+        pInfoData->pData = tmp;
+      } else {
+        // todo handle the malloc failure
       }
 
-    return pBlock;
+      pInfo->capacity  = total;
+      pInfo->threshold = (int64_t)(total * 0.8);
     }
+  }
+}
 
-    publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
-    pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
-    publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
+enum {
+  BLOCK_NEW_GROUP  = 1,
+  BLOCK_NO_GROUP   = 2,
+  BLOCK_SAME_GROUP = 3,
+};
 
-    if (pBlock == NULL) {
-      setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
-      pOperator->status = OP_EXEC_DONE;
-      return NULL;
-    }
+static int32_t doSlimitImpl(SOperatorInfo* pOperator, SSLimitOperatorInfo* pInfo, SSDataBlock* pBlock) {
+  int32_t rowIndex = 0;
 
-    while(1) {
-      if (*newgroup) {
-        pInfo->currentGroupOffset -= 1;
-        *newgroup = false;
+  while (rowIndex < pBlock->info.rows) {
+    int32_t numOfCols = (int32_t)taosArrayGetSize(pInfo->orderColumnList);
+
+    bool samegroup = true;
+    if (pInfo->hasPrev) {
+      for (int32_t i = 0; i < numOfCols; ++i) {
+        SColIndex       *pIndex = taosArrayGet(pInfo->orderColumnList, i);
+        SColumnInfoData *pColInfoData = taosArrayGet(pBlock->pDataBlock, pIndex->colIndex);
+
+        SColumnInfo *pColInfo = &pColInfoData->info;
+
+        char   *d = rowIndex * pColInfo->bytes + (char *)pColInfoData->pData;
+        int32_t ret = columnValueAscendingComparator(pInfo->prevRow[i], d, pColInfo->type, pColInfo->bytes);
+        if (ret != 0) {  // it is a new group
+          samegroup = false;
+          break;
+        }
+      }
     }
 
-      while ((*newgroup) == false) {
-        publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
-        pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
-        publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
+    if (!samegroup || !pInfo->hasPrev) {
+      pInfo->ignoreCurrentGroup = false;
+      savePrevOrderColumns(pInfo->prevRow, pInfo->orderColumnList, pBlock, rowIndex, &pInfo->hasPrev);
 
-        if (pBlock == NULL) {
+      pInfo->currentOffset = pInfo->limit.offset;  // reset the offset value for a new group
+      pInfo->rowsTotal = 0;
+
+      if (pInfo->currentGroupOffset > 0) {
+        pInfo->ignoreCurrentGroup = true;
+        pInfo->currentGroupOffset -= 1;  // now we are in the next group data
+        rowIndex += 1;
+        continue;
+      }
+
+      // A new group has arrived according to the result rows, and the group limitation has already reached.
+      // Let's jump out of current loop and return immediately.
+      if (pInfo->slimit.limit >= 0 && pInfo->groupTotal >= pInfo->slimit.limit) {
         setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
         pOperator->status = OP_EXEC_DONE;
-          return NULL;
+        return BLOCK_NO_GROUP;
       }
+
+      pInfo->groupTotal += 1;
+
+      // data in current group not allowed, return if current result does not belong to the previous group.And there
+      // are results exists in current SSDataBlock
+      if (!pInfo->multigroupResult && !samegroup && pInfo->pRes->info.rows > 0) {
+        return BLOCK_NEW_GROUP;
       }
 
-      // now we have got the first data block of the next group.
-      if (pInfo->currentGroupOffset == 0) {
-        return pBlock;
+      doHandleDataInCurrentGroup(pInfo, pBlock, rowIndex);
+
+    } else {  // handle the offset in the same group
+      // All the data in current group needs to be discarded, due to the limit parameter in the SQL statement
+      if (pInfo->ignoreCurrentGroup) {
+        rowIndex += 1;
+        continue;
+      }
+
+      doHandleDataInCurrentGroup(pInfo, pBlock, rowIndex);
     }
+
+    rowIndex += 1;
   }
 
-  return NULL;
+  return BLOCK_SAME_GROUP;
 }
 
 SSDataBlock* doSLimit(void* param, bool* newgroup) {
@@ -1093,63 +1105,41 @@ SSDataBlock* doSLimit(void* param, bool* newgroup) {
   }
 
   SSLimitOperatorInfo *pInfo = pOperator->info;
+  pInfo->pRes->info.rows = 0;
 
-  SSDataBlock *pBlock = NULL;
-  while (1) {
-    pBlock = skipGroupBlock(pOperator, newgroup);
-    if (pBlock == NULL) {
-      setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
-      pOperator->status = OP_EXEC_DONE;
-      return NULL;
-    }
-
-    if (*newgroup) {  // a new group arrives
-      pInfo->groupTotal += 1;
-      pInfo->rowsTotal = 0;
-      pInfo->currentOffset = pInfo->limit.offset;
-    }
-
-    assert(pInfo->currentGroupOffset == 0);
+  if (pInfo->pPrevBlock != NULL) {
+    ensureOutputBuf(pInfo, pInfo->pRes, pInfo->pPrevBlock->info.rows);
+    int32_t ret = doSlimitImpl(pOperator, pInfo, pInfo->pPrevBlock);
+    assert(ret != BLOCK_NEW_GROUP);
 
-    if (pInfo->currentOffset >= pBlock->info.rows) {
-      pInfo->currentOffset -= pBlock->info.rows;
-    } else {
-      if (pInfo->currentOffset == 0) {
-        break;
+    pInfo->pPrevBlock = NULL;
   }
 
-      int32_t remain = (int32_t)(pBlock->info.rows - pInfo->currentOffset);
-      pBlock->info.rows = remain;
+  assert(pInfo->currentGroupOffset >= 0);
 
-      // move the remain rows of this data block to the front.
-      for (int32_t i = 0; i < pBlock->info.numOfCols; ++i) {
-        SColumnInfoData *pColInfoData = taosArrayGet(pBlock->pDataBlock, i);
+  while(1) {
+    publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
+    SSDataBlock *pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
+    publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_AFTER_OPERATOR_EXEC);
 
-        int16_t bytes = pColInfoData->info.bytes;
-        memmove(pColInfoData->pData, pColInfoData->pData + bytes * pInfo->currentOffset, remain * bytes);
+    if (pBlock == NULL) {
+      return pInfo->pRes->info.rows == 0 ? NULL : pInfo->pRes;
     }
 
-      pInfo->currentOffset = 0;
-      break;
-    }
+    ensureOutputBuf(pInfo, pInfo->pRes, pBlock->info.rows);
+    int32_t ret = doSlimitImpl(pOperator, pInfo, pBlock);
+    if (ret == BLOCK_NEW_GROUP) {
+      pInfo->pPrevBlock = pBlock;
+      return pInfo->pRes;
     }
 
-  if (pInfo->slimit.limit > 0 && pInfo->groupTotal > pInfo->slimit.limit) {  // reach the group limit, abort
-    return NULL;
+    if (pOperator->status == OP_EXEC_DONE) {
+      return pInfo->pRes->info.rows == 0 ? NULL : pInfo->pRes;
     }
 
-  if (pInfo->limit.limit > 0 && (pInfo->rowsTotal + pBlock->info.rows >= pInfo->limit.limit)) {
-    pBlock->info.rows = (int32_t)(pInfo->limit.limit - pInfo->rowsTotal);
-    pInfo->rowsTotal = pInfo->limit.limit;
-
-    if (pInfo->slimit.limit > 0 && pInfo->groupTotal >= pInfo->slimit.limit) {
-      pOperator->status = OP_EXEC_DONE;
+    // now the number of rows in current group is enough, let's return to the invoke function
+    if (pInfo->pRes->info.rows > pInfo->threshold) {
+      return pInfo->pRes;
     }
-
-    //    setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
-  } else {
-    pInfo->rowsTotal += pBlock->info.rows;
   }
-
-  return pBlock;
 }

src/client/src/tscParseInsert.c

@@ -1777,6 +1777,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int32_t numOfRow
   }
 
 _error:
+  pParentSql->res.code = code;
   tfree(tokenBuf);
   tfree(line);
   taos_free_result(pSql);

src/client/src/tscSQLParser.c

@@ -427,7 +427,6 @@ int32_t readFromFile(char *name, uint32_t *len, void **buf) {
     return TSDB_CODE_TSC_APP_ERROR;
   }
   close(fd);
-  tfree(*buf);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -931,7 +930,6 @@ int32_t tscValidateSqlInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
           pQueryInfo = pCmd->active;
           pQueryInfo->pUdfInfo = pUdfInfo;
           pQueryInfo->udfCopy = true;
-
         }
       }
 
@@ -7205,7 +7203,6 @@ static int32_t doAddGroupbyColumnsOnDemand(SSqlCmd* pCmd, SQueryInfo* pQueryInfo
   const char* msg1 = "interval not allowed in group by normal column";
 
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
-
   SSchema* pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
 
   SSchema* tagSchema = NULL;
@@ -8735,6 +8732,7 @@ static int32_t doValidateSubquery(SSqlNode* pSqlNode, int32_t index, SSqlObj* pS
   if (taosArrayGetSize(subInfo->pSubquery) >= 2) {
     return invalidOperationMsg(msgBuf, "not support union in subquery");
   }
+
   SQueryInfo* pSub = calloc(1, sizeof(SQueryInfo));
   tscInitQueryInfo(pSub);
 
@@ -8757,6 +8755,7 @@ static int32_t doValidateSubquery(SSqlNode* pSqlNode, int32_t index, SSqlObj* pS
   if (pTableMetaInfo1 == NULL) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
+
   pTableMetaInfo1->pTableMeta        = extractTempTableMetaFromSubquery(pSub);
   pTableMetaInfo1->tableMetaCapacity = tscGetTableMetaSize(pTableMetaInfo1->pTableMeta);
 
@@ -8840,7 +8839,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
       // check if there is 3 level select
       SRelElementPair* subInfo = taosArrayGet(pSqlNode->from->list, i);
       SSqlNode* p = taosArrayGetP(subInfo->pSubquery, 0);
-      if (p->from->type == SQL_NODE_FROM_SUBQUERY){
+      if (p->from->type == SQL_NODE_FROM_SUBQUERY) {
         return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg9);
       }
 
@@ -8933,6 +8932,15 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
       }
     }
 
+    // disable group result mixed up if interval/session window query exists.
+    if (isTimeWindowQuery(pQueryInfo)) {
+      size_t num = taosArrayGetSize(pQueryInfo->pUpstream);
+      for(int32_t i = 0; i < num; ++i) {
+        SQueryInfo* pUp = taosArrayGetP(pQueryInfo->pUpstream, i);
+        pUp->multigroupResult = false;
+      }
+    }
+
     // parse the having clause in the first place
     int32_t joinQuery = (pSqlNode->from != NULL && taosArrayGetSize(pSqlNode->from->list) > 1);
     if (validateHavingClause(pQueryInfo, pSqlNode->pHaving, pCmd, pSqlNode->pSelNodeList, joinQuery, timeWindowQuery) !=

src/client/src/tscServer.c

@@ -332,188 +332,35 @@ int tscSendMsgToServer(SSqlObj *pSql) {
       .code    = 0
   };
   
-  
   rpcSendRequest(pObj->pRpcObj->pDnodeConn, &pSql->epSet, &rpcMsg, &pSql->rpcRid);
   return TSDB_CODE_SUCCESS;
 }
 
-//static void doProcessMsgFromServer(SSchedMsg* pSchedMsg) {
-//  SRpcMsg* rpcMsg = pSchedMsg->ahandle;
-//  SRpcEpSet* pEpSet = pSchedMsg->thandle;
-//
-//  TSDB_CACHE_PTR_TYPE handle = (TSDB_CACHE_PTR_TYPE) rpcMsg->ahandle;
-//  SSqlObj* pSql = (SSqlObj*)taosAcquireRef(tscObjRef, handle);
-//  if (pSql == NULL) {
-//    rpcFreeCont(rpcMsg->pCont);
-//    free(rpcMsg);
-//    free(pEpSet);
-//    return;
-//  }
-//
-//  assert(pSql->self == handle);
-//
-//  STscObj *pObj = pSql->pTscObj;
-//  SSqlRes *pRes = &pSql->res;
-//  SSqlCmd *pCmd = &pSql->cmd;
-//
-//  pSql->rpcRid = -1;
-//
-//  if (pObj->signature != pObj) {
-//    tscDebug("0x%"PRIx64" DB connection is closed, cmd:%d pObj:%p signature:%p", pSql->self, pCmd->command, pObj, pObj->signature);
-//
-//    taosRemoveRef(tscObjRef, handle);
-//    taosReleaseRef(tscObjRef, handle);
-//    rpcFreeCont(rpcMsg->pCont);
-//    free(rpcMsg);
-//    free(pEpSet);
-//    return;
-//  }
-//
-//  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
-//  if (pQueryInfo != NULL && pQueryInfo->type == TSDB_QUERY_TYPE_FREE_RESOURCE) {
-//    tscDebug("0x%"PRIx64" sqlObj needs to be released or DB connection is closed, cmd:%d type:%d, pObj:%p signature:%p",
-//        pSql->self, pCmd->command, pQueryInfo->type, pObj, pObj->signature);
-//
-//    taosRemoveRef(tscObjRef, handle);
-//    taosReleaseRef(tscObjRef, handle);
-//    rpcFreeCont(rpcMsg->pCont);
-//    free(rpcMsg);
-//    free(pEpSet);
-//    return;
-//  }
-//
-//  if (pEpSet) {
-//    if (!tscEpSetIsEqual(&pSql->epSet, pEpSet)) {
-//      if (pCmd->command < TSDB_SQL_MGMT) {
-//        tscUpdateVgroupInfo(pSql, pEpSet);
-//      } else {
-//        tscUpdateMgmtEpSet(pSql, pEpSet);
-//      }
-//    }
-//  }
-//
-//  int32_t cmd = pCmd->command;
-//
-//  // set the flag to denote that sql string needs to be re-parsed and build submit block with table schema
-//  if (cmd == TSDB_SQL_INSERT && rpcMsg->code == TSDB_CODE_TDB_TABLE_RECONFIGURE) {
-//    pSql->cmd.insertParam.schemaAttached = 1;
-//  }
-//
-//  // single table query error need to be handled here.
-//  if ((cmd == TSDB_SQL_SELECT || cmd == TSDB_SQL_UPDATE_TAGS_VAL) &&
-//      (((rpcMsg->code == TSDB_CODE_TDB_INVALID_TABLE_ID || rpcMsg->code == TSDB_CODE_VND_INVALID_VGROUP_ID)) ||
-//       rpcMsg->code == TSDB_CODE_RPC_NETWORK_UNAVAIL || rpcMsg->code == TSDB_CODE_APP_NOT_READY)) {
-//
-//    // 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)) {
-//      // do nothing in case of super table subquery
-//    }  else {
-//      pSql->retry += 1;
-//      tscWarn("0x%" PRIx64 " it shall renew table meta, code:%s, retry:%d", pSql->self, tstrerror(rpcMsg->code), pSql->retry);
-//
-//      pSql->res.code = rpcMsg->code;  // keep the previous error code
-//      if (pSql->retry > pSql->maxRetry) {
-//        tscError("0x%" PRIx64 " max retry %d reached, give up", pSql->self, pSql->maxRetry);
-//      } else {
-//        // wait for a little bit moment and then retry
-//        // todo do not sleep in rpc callback thread, add this process into queue to process
-//        if (rpcMsg->code == TSDB_CODE_APP_NOT_READY || rpcMsg->code == TSDB_CODE_VND_INVALID_VGROUP_ID) {
-//          int32_t duration = getWaitingTimeInterval(pSql->retry);
-//          taosMsleep(duration);
-//        }
-//
-//        pSql->retryReason = rpcMsg->code;
-//        rpcMsg->code = tscRenewTableMeta(pSql, 0);
-//        // if there is an error occurring, proceed to the following error handling procedure.
-//        if (rpcMsg->code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
-//          taosReleaseRef(tscObjRef, handle);
-//          rpcFreeCont(rpcMsg->pCont);
-//          free(rpcMsg);
-//          free(pEpSet);
-//          return;
-//        }
-//      }
-//    }
-//  }
-//
-//  pRes->rspLen = 0;
-//
-//  if (pRes->code == TSDB_CODE_TSC_QUERY_CANCELLED) {
-//    tscDebug("0x%"PRIx64" query is cancelled, code:%s", pSql->self, tstrerror(pRes->code));
-//  } else {
-//    pRes->code = rpcMsg->code;
-//  }
-//
-//  if (pRes->code == TSDB_CODE_SUCCESS) {
-//    tscDebug("0x%"PRIx64" reset retry counter to be 0 due to success rsp, old:%d", pSql->self, pSql->retry);
-//    pSql->retry = 0;
-//  }
-//
-//  if (pRes->code != TSDB_CODE_TSC_QUERY_CANCELLED) {
-//    assert(rpcMsg->msgType == pCmd->msgType + 1);
-//    pRes->code    = rpcMsg->code;
-//    pRes->rspType = rpcMsg->msgType;
-//    pRes->rspLen  = rpcMsg->contLen;
-//
-//    if (pRes->rspLen > 0 && rpcMsg->pCont) {
-//      char *tmp = (char *)realloc(pRes->pRsp, pRes->rspLen);
-//      if (tmp == NULL) {
-//        pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
-//      } else {
-//        pRes->pRsp = tmp;
-//        memcpy(pRes->pRsp, rpcMsg->pCont, pRes->rspLen);
-//      }
-//    } else {
-//      tfree(pRes->pRsp);
-//    }
-//
-//    /*
-//     * There is not response callback function for submit response.
-//     * The actual inserted number of points is the first number.
-//     */
-//    if (rpcMsg->msgType == TSDB_MSG_TYPE_SUBMIT_RSP && pRes->pRsp != NULL) {
-//      SShellSubmitRspMsg *pMsg = (SShellSubmitRspMsg*)pRes->pRsp;
-//      pMsg->code = htonl(pMsg->code);
-//      pMsg->numOfRows = htonl(pMsg->numOfRows);
-//      pMsg->affectedRows = htonl(pMsg->affectedRows);
-//      pMsg->failedRows = htonl(pMsg->failedRows);
-//      pMsg->numOfFailedBlocks = htonl(pMsg->numOfFailedBlocks);
-//
-//      pRes->numOfRows += pMsg->affectedRows;
-//      tscDebug("0x%"PRIx64" SQL cmd:%s, code:%s inserted rows:%d rspLen:%d", pSql->self, sqlCmd[pCmd->command],
-//          tstrerror(pRes->code), pMsg->affectedRows, pRes->rspLen);
-//    } else {
-//      tscDebug("0x%"PRIx64" SQL cmd:%s, code:%s rspLen:%d", pSql->self, sqlCmd[pCmd->command], tstrerror(pRes->code), pRes->rspLen);
-//    }
-//  }
-//
-//  if (pRes->code == TSDB_CODE_SUCCESS && tscProcessMsgRsp[pCmd->command]) {
-//    rpcMsg->code = (*tscProcessMsgRsp[pCmd->command])(pSql);
-//  }
-//
-//  bool shouldFree = tscShouldBeFreed(pSql);
-//  if (rpcMsg->code != TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
-//    if (rpcMsg->code != TSDB_CODE_SUCCESS) {
-//      pRes->code = rpcMsg->code;
-//    }
-//    rpcMsg->code = (pRes->code == TSDB_CODE_SUCCESS) ? (int32_t)pRes->numOfRows : pRes->code;
-//    (*pSql->fp)(pSql->param, pSql, rpcMsg->code);
-//  }
-//
-//  if (shouldFree) { // in case of table-meta/vgrouplist query, automatically free it
-//    tscDebug("0x%"PRIx64" sqlObj is automatically freed", pSql->self);
-//    taosRemoveRef(tscObjRef, handle);
-//  }
-//
-//  taosReleaseRef(tscObjRef, handle);
-//  rpcFreeCont(rpcMsg->pCont);
-//  free(rpcMsg);
-//  free(pEpSet);
-//}
+// handle three situation
+// 1. epset retry, only return last failure ep
+// 2. no epset retry, like 'taos -h invalidFqdn', return invalidFqdn
+// 3. other situation, no expected
+void tscSetFqdnErrorMsg(SSqlObj* pSql, SRpcEpSet* pEpSet) {
+  SSqlCmd* pCmd = &pSql->cmd;
+  SSqlRes* pRes = &pSql->res;
+
+  char* msgBuf = tscGetErrorMsgPayload(pCmd);
+
+  if (pEpSet) {
+    sprintf(msgBuf, "%s\"%s\"", tstrerror(pRes->code),pEpSet->fqdn[(pEpSet->inUse)%(pEpSet->numOfEps)]);
+  } else if (pCmd->command >= TSDB_SQL_MGMT) {
+    SRpcEpSet tEpset;
+
+    SRpcCorEpSet *pCorEpSet = pSql->pTscObj->tscCorMgmtEpSet;
+    taosCorBeginRead(&pCorEpSet->version);
+    tEpset = pCorEpSet->epSet;
+    taosCorEndRead(&pCorEpSet->version);
+
+    sprintf(msgBuf, "%s\"%s\"", tstrerror(pRes->code),tEpset.fqdn[(tEpset.inUse)%(tEpset.numOfEps)]);
+  } else {
+    sprintf(msgBuf, "%s", tstrerror(pRes->code));
+  }
+}
 
 void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {
   TSDB_CACHE_PTR_TYPE handle = (TSDB_CACHE_PTR_TYPE) rpcMsg->ahandle;
@@ -666,28 +513,13 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {
     if (rpcMsg->code != TSDB_CODE_SUCCESS) {
       pRes->code = rpcMsg->code;
     }
+
     rpcMsg->code = (pRes->code == TSDB_CODE_SUCCESS) ? (int32_t)pRes->numOfRows : pRes->code;
-    if (pRes->code == TSDB_CODE_RPC_FQDN_ERROR) {
+    if (rpcMsg->code == TSDB_CODE_RPC_FQDN_ERROR) {
       tscAllocPayload(pCmd, TSDB_FQDN_LEN + 64);
-      // handle three situation 
-      // 1. epset retry, only return last failure ep   
-      // 2. no epset retry, like 'taos -h invalidFqdn', return invalidFqdn 
-      // 3. other situation, no expected 
-      if (pEpSet) {
-        sprintf(tscGetErrorMsgPayload(pCmd), "%s\"%s\"", tstrerror(pRes->code),pEpSet->fqdn[(pEpSet->inUse)%(pEpSet->numOfEps)]);
-      } else if (pCmd->command >= TSDB_SQL_MGMT) {
-        SRpcEpSet tEpset;
-
-        SRpcCorEpSet *pCorEpSet = pSql->pTscObj->tscCorMgmtEpSet;
-        taosCorBeginRead(&pCorEpSet->version); 
-        tEpset = pCorEpSet->epSet;   
-        taosCorEndRead(&pCorEpSet->version); 
-
-        sprintf(tscGetErrorMsgPayload(pCmd), "%s\"%s\"", tstrerror(pRes->code),tEpset.fqdn[(tEpset.inUse)%(tEpset.numOfEps)]);
-      } else {
-        sprintf(tscGetErrorMsgPayload(pCmd), "%s", tstrerror(pRes->code));
-      }
+      tscSetFqdnErrorMsg(pSql, pEpSet);
     }
+
     (*pSql->fp)(pSql->param, pSql, rpcMsg->code);
   }
 

src/client/src/tscSubquery.c

@@ -2444,7 +2444,11 @@ static void doSendQueryReqs(SSchedMsg* pSchedMsg) {
   SSqlObj* pSql = pSchedMsg->ahandle;
   SPair* p = pSchedMsg->msg;
 
-  for(int32_t i = p->first; i < p->second; ++i) {
+  for (int32_t i = p->first; i < p->second; ++i) {
+   if (i >= pSql->subState.numOfSub) {
+      tfree(p);
+      return;
+    }
     SSqlObj* pSub = pSql->pSubs[i];
     SRetrieveSupport* pSupport = pSub->param;
 
@@ -2584,7 +2588,12 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
   int32_t numOfTasks = (pState->numOfSub + MAX_REQUEST_PER_TASK - 1)/MAX_REQUEST_PER_TASK;
   assert(numOfTasks >= 1);
 
-  int32_t num = (pState->numOfSub/numOfTasks) + 1;
+  int32_t num;
+  if (pState->numOfSub / numOfTasks == MAX_REQUEST_PER_TASK) {
+    num = MAX_REQUEST_PER_TASK;
+  } else {
+    num = pState->numOfSub / numOfTasks + 1;
+  }
   tscDebug("0x%"PRIx64 " query will be sent by %d threads", pSql->self, numOfTasks);
 
   for(int32_t j = 0; j < numOfTasks; ++j) {

src/client/src/tscUtil.c

@@ -3181,6 +3181,7 @@ void tscInitQueryInfo(SQueryInfo* pQueryInfo) {
   pQueryInfo->slimit.offset  = 0;
   pQueryInfo->pUpstream      = taosArrayInit(4, POINTER_BYTES);
   pQueryInfo->window         = TSWINDOW_INITIALIZER;
+  pQueryInfo->multigroupResult = true;
 }
 
 int32_t tscAddQueryInfo(SSqlCmd* pCmd) {
@@ -3192,7 +3193,6 @@ int32_t tscAddQueryInfo(SSqlCmd* pCmd) {
   }
 
   tscInitQueryInfo(pQueryInfo);
-
   pQueryInfo->msg = pCmd->payload;  // pointer to the parent error message buffer
 
   if (pCmd->pQueryInfo == NULL) {
@@ -3241,6 +3241,7 @@ static void freeQueryInfoImpl(SQueryInfo* pQueryInfo) {
 
   taosArrayDestroy(pQueryInfo->pUpstream);
   pQueryInfo->pUpstream = NULL;
+  pQueryInfo->bufLen = 0;
 }
 
 void tscClearSubqueryInfo(SSqlCmd* pCmd) {
@@ -3275,6 +3276,7 @@ int32_t tscQueryInfoCopy(SQueryInfo* pQueryInfo, const SQueryInfo* pSrc) {
   pQueryInfo->window         = pSrc->window;
   pQueryInfo->sessionWindow  = pSrc->sessionWindow;
   pQueryInfo->pTableMetaInfo = NULL;
+  pQueryInfo->multigroupResult = pSrc->multigroupResult;
 
   pQueryInfo->bufLen         = pSrc->bufLen;
   pQueryInfo->orderProjectQuery = pSrc->orderProjectQuery;
@@ -3665,19 +3667,20 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
   pNewQueryInfo->limit        = pQueryInfo->limit;
   pNewQueryInfo->slimit       = pQueryInfo->slimit;
   pNewQueryInfo->order        = pQueryInfo->order;
-  pNewQueryInfo->vgroupLimit = pQueryInfo->vgroupLimit;
   pNewQueryInfo->tsBuf        = NULL;
   pNewQueryInfo->fillType     = pQueryInfo->fillType;
   pNewQueryInfo->fillVal      = NULL;
-  pNewQueryInfo->numOfFillVal = 0;
   pNewQueryInfo->clauseLimit  = pQueryInfo->clauseLimit;
   pNewQueryInfo->prjOffset    = pQueryInfo->prjOffset;
+  pNewQueryInfo->numOfFillVal = 0;
   pNewQueryInfo->numOfTables  = 0;
   pNewQueryInfo->pTableMetaInfo = NULL;
   pNewQueryInfo->bufLen       = pQueryInfo->bufLen;
-  pNewQueryInfo->buf = malloc(pQueryInfo->bufLen);
-
+  pNewQueryInfo->vgroupLimit  = pQueryInfo->vgroupLimit;
   pNewQueryInfo->distinct     =  pQueryInfo->distinct;
+  pNewQueryInfo->multigroupResult = pQueryInfo->multigroupResult;
+
+  pNewQueryInfo->buf          = malloc(pQueryInfo->bufLen);
   if (pNewQueryInfo->buf == NULL) {
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
     goto _error;
@@ -4523,7 +4526,7 @@ int32_t tscCreateTableMetaFromSTableMeta(STableMeta** ppChild, const char* name,
   STableMeta* pChild = *ppChild;
 
   size_t sz = (p != NULL) ? tscGetTableMetaSize(p) : 0; //ppSTableBuf actually capacity may larger than sz, dont care
-  if (sz != 0) {
+  if (p != NULL && sz != 0) {
     memset((char *)p, 0, sz);
   }
 
@@ -4811,6 +4814,7 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
   pQueryAttr->distinct          = pQueryInfo->distinct;
   pQueryAttr->sw                = pQueryInfo->sessionWindow;
   pQueryAttr->stateWindow       = pQueryInfo->stateWindow;
+  pQueryAttr->multigroupResult  = pQueryInfo->multigroupResult;
 
   pQueryAttr->numOfCols         = numOfCols;
   pQueryAttr->numOfOutput       = numOfOutput;

go @ b8f76da4

-Subproject commit 050667e5b4d0eafa5387e4283e713559b421203f
+Subproject commit b8f76da4a708d158ec3cc4b844571dc4414e36b4

hivemq-tdengine-extension @ ce520101

-Subproject commit b62a26ecc164a310104df57691691b237e091c89
+Subproject commit ce5201014136503d34fecbd56494b67b4961056c

src/inc/ttokendef.h

@@ -91,63 +91,63 @@
 #define TK_ACCOUNT                         73
 #define TK_USE                             74
 #define TK_DESCRIBE                        75
-#define TK_ALTER                           76
-#define TK_PASS                            77
-#define TK_PRIVILEGE                       78
-#define TK_LOCAL                           79
-#define TK_COMPACT                         80
-#define TK_LP                              81
-#define TK_RP                              82
-#define TK_IF                              83
-#define TK_EXISTS                          84
-#define TK_AS                              85
-#define TK_OUTPUTTYPE                      86
-#define TK_AGGREGATE                       87
-#define TK_BUFSIZE                         88
-#define TK_PPS                             89
-#define TK_TSERIES                         90
-#define TK_DBS                             91
-#define TK_STORAGE                         92
-#define TK_QTIME                           93
-#define TK_CONNS                           94
-#define TK_STATE                           95
-#define TK_COMMA                           96
-#define TK_KEEP                            97
-#define TK_CACHE                           98
-#define TK_REPLICA                         99
-#define TK_QUORUM                         100
-#define TK_DAYS                           101
-#define TK_MINROWS                        102
-#define TK_MAXROWS                        103
-#define TK_BLOCKS                         104
-#define TK_CTIME                          105
-#define TK_WAL                            106
-#define TK_FSYNC                          107
-#define TK_COMP                           108
-#define TK_PRECISION                      109
-#define TK_UPDATE                         110
-#define TK_CACHELAST                      111
-#define TK_PARTITIONS                     112
-#define TK_UNSIGNED                       113
-#define TK_TAGS                           114
-#define TK_USING                          115
-#define TK_NULL                           116
-#define TK_NOW                            117
-#define TK_SELECT                         118
-#define TK_UNION                          119
-#define TK_ALL                            120
-#define TK_DISTINCT                       121
-#define TK_FROM                           122
-#define TK_VARIABLE                       123
-#define TK_INTERVAL                       124
-#define TK_SESSION                        125
-#define TK_STATE_WINDOW                   126
-#define TK_FILL                           127
-#define TK_SLIDING                        128
-#define TK_ORDER                          129
-#define TK_BY                             130
-#define TK_ASC                            131
-#define TK_DESC                           132
+#define TK_DESC                            76
+#define TK_ALTER                           77
+#define TK_PASS                            78
+#define TK_PRIVILEGE                       79
+#define TK_LOCAL                           80
+#define TK_COMPACT                         81
+#define TK_LP                              82
+#define TK_RP                              83
+#define TK_IF                              84
+#define TK_EXISTS                          85
+#define TK_AS                              86
+#define TK_OUTPUTTYPE                      87
+#define TK_AGGREGATE                       88
+#define TK_BUFSIZE                         89
+#define TK_PPS                             90
+#define TK_TSERIES                         91
+#define TK_DBS                             92
+#define TK_STORAGE                         93
+#define TK_QTIME                           94
+#define TK_CONNS                           95
+#define TK_STATE                           96
+#define TK_COMMA                           97
+#define TK_KEEP                            98
+#define TK_CACHE                           99
+#define TK_REPLICA                        100
+#define TK_QUORUM                         101
+#define TK_DAYS                           102
+#define TK_MINROWS                        103
+#define TK_MAXROWS                        104
+#define TK_BLOCKS                         105
+#define TK_CTIME                          106
+#define TK_WAL                            107
+#define TK_FSYNC                          108
+#define TK_COMP                           109
+#define TK_PRECISION                      110
+#define TK_UPDATE                         111
+#define TK_CACHELAST                      112
+#define TK_PARTITIONS                     113
+#define TK_UNSIGNED                       114
+#define TK_TAGS                           115
+#define TK_USING                          116
+#define TK_NULL                           117
+#define TK_NOW                            118
+#define TK_SELECT                         119
+#define TK_UNION                          120
+#define TK_ALL                            121
+#define TK_DISTINCT                       122
+#define TK_FROM                           123
+#define TK_VARIABLE                       124
+#define TK_INTERVAL                       125
+#define TK_SESSION                        126
+#define TK_STATE_WINDOW                   127
+#define TK_FILL                           128
+#define TK_SLIDING                        129
+#define TK_ORDER                          130
+#define TK_BY                             131
+#define TK_ASC                            132
 #define TK_GROUP                          133
 #define TK_HAVING                         134
 #define TK_LIMIT                          135

src/kit/taosdemo/taosdemo.c

@@ -75,6 +75,8 @@ extern char configDir[];
 #define OPT_ABORT          1 /* –abort */
 #define MAX_FILE_NAME_LEN  256              // max file name length on linux is 255.
 
+#define DEFAULT_START_TIME 1500000000000
+
 #define MAX_PREPARED_RAND  1000000
 #define INT_BUFF_LEN            11
 #define BIGINT_BUFF_LEN         21
@@ -102,6 +104,9 @@ extern char configDir[];
 #define NOTE_BUFF_LEN           (SMALL_BUFF_LEN*16)
 
 #define DEFAULT_TIMESTAMP_STEP  1
+#define DEFAULT_INTERLACE_ROWS  0
+#define DEFAULT_DATATYPE_NUM    3
+#define DEFAULT_CHILDTABLES     10000
 
 
 enum TEST_MODE {
@@ -201,9 +206,9 @@ enum _describe_table_index {
 static char *g_dupstr = NULL;
 
 typedef struct SArguments_S {
-    char *   metaFile;
+    char     *metaFile;
     uint32_t test_mode;
-    char *   host;
+    char     *host;
     uint16_t port;
     uint16_t iface;
     char *   user;
@@ -222,7 +227,7 @@ typedef struct SArguments_S {
     char *   output_file;
     bool     async_mode;
     char *   datatype[MAX_NUM_COLUMNS + 1];
-    uint32_t len_of_binary;
+    uint32_t binwidth;
     uint32_t num_of_CPR;
     uint32_t num_of_threads;
     uint64_t insert_interval;
@@ -363,7 +368,7 @@ typedef struct SDbs_S {
     bool        asyncMode;
 
     uint32_t    threadCount;
-    uint32_t    threadCountByCreateTbl;
+    uint32_t    threadCountForCreateTbl;
     uint32_t    dbCount;
     SDataBase   db[MAX_DB_COUNT];
 
@@ -582,12 +587,10 @@ char    *g_randdouble_buff = NULL;
 char    *g_aggreFunc[] = {"*", "count(*)", "avg(col0)", "sum(col0)",
     "max(col0)", "min(col0)", "first(col0)", "last(col0)"};
 
-#define DEFAULT_DATATYPE_NUM    3
-
 SArguments g_args = {
     NULL,           // metaFile
     0,              // test_mode
-    "127.0.0.1",     // host
+    "localhost",    // host
     6030,           // port
     INTERFACE_BUT,  // iface
     "root",         // user
@@ -616,16 +619,16 @@ SArguments g_args = {
         "INT",           // datatype
         "FLOAT",         // datatype. DEFAULT_DATATYPE_NUM is 3
     },
-    64,              // len_of_binary
+    64,              // binwidth
     4,               // num_of_CPR
     10,              // num_of_connections/thread
     0,               // insert_interval
     DEFAULT_TIMESTAMP_STEP, // timestamp_step
     1,               // query_times
-    0,               // interlace_rows;
+    DEFAULT_INTERLACE_ROWS, // interlace_rows;
     30000,           // num_of_RPR
     (1024*1024),     // max_sql_len
-    10000,           // num_of_tables
+    DEFAULT_CHILDTABLES,    // num_of_tables
     10000,           // num_of_DPT
     0,               // abort
     0,               // disorderRatio
@@ -636,10 +639,8 @@ SArguments g_args = {
     true,            // demo_mode;
 };
 
-
-
 static SDbs            g_Dbs;
-static int64_t         g_totalChildTables = 0;
+static int64_t         g_totalChildTables = DEFAULT_CHILDTABLES;
 static int64_t         g_actualChildTables = 0;
 static SQueryMetaInfo  g_queryInfo;
 static FILE *          g_fpOfInsertResult = NULL;
@@ -720,85 +721,92 @@ static void printVersion() {
 
 static void printHelp() {
     char indent[10] = "  ";
-    printf("%s%s%s%s\n", indent, "-f", indent,
+    printf("%s\n\n", "Usage: taosdemo [OPTION...]");
+    printf("%s%s%s%s\n", indent, "-f, --file=FILE", "\t\t",
             "The meta file to the execution procedure. Default is './meta.json'.");
-    printf("%s%s%s%s\n", indent, "-u", indent,
-            "The TDengine user name to use when connecting to the server. Default is 'root'.");
+    printf("%s%s%s%s\n", indent, "-u, --user=USER", "\t\t",
+            "The user name to use when connecting to the server.");
 #ifdef _TD_POWER_
-    printf("%s%s%s%s\n", indent, "-p", indent,
-            "The password to use when connecting to the server. Default is 'powerdb'.");
-    printf("%s%s%s%s\n", indent, "-c", indent,
+    printf("%s%s%s%s\n", indent, "-p, --password", "\t\t",
+            "The password to use when connecting to the server. Default is 'powerdb'");
+    printf("%s%s%s%s\n", indent, "-c, --config-dir=CONFIG_DIR", "\t",
             "Configuration directory. Default is '/etc/power/'.");
 #elif (_TD_TQ_ == true)
-    printf("%s%s%s%s\n", indent, "-p", indent,
-            "The password to use when connecting to the server. Default is 'tqueue'.");
-    printf("%s%s%s%s\n", indent, "-c", indent,
+    printf("%s%s%s%s\n", indent, "-p, --password", "\t\t",
+            "The password to use when connecting to the server. Default is 'tqueue'");
+    printf("%s%s%s%s\n", indent, "-c, --config-dir=CONFIG_DIR", "\t",
             "Configuration directory. Default is '/etc/tq/'.");
 #else
-    printf("%s%s%s%s\n", indent, "-p", indent,
-            "The password to use when connecting to the server. Default is 'taosdata'.");
-    printf("%s%s%s%s\n", indent, "-c", indent,
-            "Configuration directory. Default is '/etc/taos/'.");
+    printf("%s%s%s%s\n", indent, "-p, --password", "\t\t",
+            "The password to use when connecting to the server.");
+    printf("%s%s%s%s\n", indent, "-c, --config-dir=CONFIG_DIR", "\t",
+            "Configuration directory.");
 #endif
-    printf("%s%s%s%s\n", indent, "-h", indent,
-            "The host to connect to TDengine. Default is localhost.");
-    printf("%s%s%s%s\n", indent, "-P", indent,
-            "The TCP/IP port number to use for the connection. Default is 0.");
-    printf("%s%s%s%s\n", indent, "-I", indent,
+    printf("%s%s%s%s\n", indent, "-h, --host=HOST", "\t\t",
+            "TDengine server FQDN to connect. The default host is localhost.");
+    printf("%s%s%s%s\n", indent, "-P, --port=PORT", "\t\t",
+            "The TCP/IP port number to use for the connection.");
+    printf("%s%s%s%s\n", indent, "-I, --interface=INTERFACE", "\t",
             "The interface (taosc, rest, and stmt) taosdemo uses. Default is 'taosc'.");
-    printf("%s%s%s%s\n", indent, "-d", indent,
+    printf("%s%s%s%s\n", indent, "-d, --database=DATABASE", "\t",
             "Destination database. Default is 'test'.");
-    printf("%s%s%s%s\n", indent, "-a", indent,
+    printf("%s%s%s%s\n", indent, "-a, --replica=REPLICA", "\t\t",
             "Set the replica parameters of the database, Default 1, min: 1, max: 3.");
-    printf("%s%s%s%s\n", indent, "-m", indent,
+    printf("%s%s%s%s\n", indent, "-m, --table-prefix=TABLEPREFIX", "\t",
             "Table prefix name. Default is 'd'.");
-    printf("%s%s%s%s\n", indent, "-s", indent, "The select sql file.");
-    printf("%s%s%s%s\n", indent, "-N", indent, "Use normal table flag.");
-    printf("%s%s%s%s\n", indent, "-o", indent,
+    printf("%s%s%s%s\n", indent, "-s, --sql-file=FILE", "\t\t", "The select sql file.");
+    printf("%s%s%s%s\n", indent, "-N, --normal-table", "\t\t", "Use normal table flag.");
+    printf("%s%s%s%s\n", indent, "-o, --output=FILE", "\t\t",
             "Direct output to the named file. Default is './output.txt'.");
-    printf("%s%s%s%s\n", indent, "-q", indent,
+    printf("%s%s%s%s\n", indent, "-s, --sql-file=FILE", "\t\t",
+            "The select sql file.");
+    printf("%s%s%s%s\n", indent, "-q, --query-mode=MODE", "\t\t",
             "Query mode -- 0: SYNC, 1: ASYNC. Default is SYNC.");
-    printf("%s%s%s%s\n", indent, "-b", indent,
+    printf("%s%s%s%s\n", indent, "-b, --data-type=DATATYPE", "\t",
             "The data_type of columns, default: FLOAT, INT, FLOAT.");
-    printf("%s%s%s%s%d\n", indent, "-w", indent,
-            "The length of data_type 'BINARY' or 'NCHAR'. Default is ",
-            g_args.len_of_binary);
-    printf("%s%s%s%s%d%s%d\n", indent, "-l", indent,
+    printf("%s%s%s%s%d\n", indent, "-w, --binwidth=WIDTH", "\t\t",
+            "The width of data_type 'BINARY' or 'NCHAR'. Default is ",
+            g_args.binwidth);
+    printf("%s%s%s%s%d%s%d\n", indent, "-l, --columns=COLUMNS", "\t\t",
             "The number of columns per record. Demo mode by default is ",
             DEFAULT_DATATYPE_NUM,
             " (float, int, float). Max values is ",
             MAX_NUM_COLUMNS);
     printf("%s%s%s%s\n", indent, indent, indent,
-            "All of the new column(s) type is INT. If use -b to specify column type, -l will be ignored.");
-    printf("%s%s%s%s\n", indent, "-T", indent,
+            "\t\t\t\tAll of the new column(s) type is INT. If use -b to specify column type, -l will be ignored.");
+    printf("%s%s%s%s\n", indent, "-T, --threads=NUMBER", "\t\t",
             "The number of threads. Default is 10.");
-    printf("%s%s%s%s\n", indent, "-i", indent,
+    printf("%s%s%s%s\n", indent, "-i, --insert-interval=NUMBER", "\t",
             "The sleep time (ms) between insertion. Default is 0.");
-    printf("%s%s%s%s%d.\n", indent, "-S", indent,
+    printf("%s%s%s%s%d.\n", indent, "-S, --time-step=TIME_STEP", "\t",
             "The timestamp step between insertion. Default is ",
             DEFAULT_TIMESTAMP_STEP);
-    printf("%s%s%s%s\n", indent, "-r", indent,
+    printf("%s%s%s%s%d.\n", indent, "-B, --interlace-rows=NUMBER", "\t",
+            "The interlace rows of insertion. Default is ",
+            DEFAULT_INTERLACE_ROWS);
+    printf("%s%s%s%s\n", indent, "-r, --rec-per-req=NUMBER", "\t",
             "The number of records per request. Default is 30000.");
-    printf("%s%s%s%s\n", indent, "-t", indent,
+    printf("%s%s%s%s\n", indent, "-t, --tables=NUMBER", "\t\t",
             "The number of tables. Default is 10000.");
-    printf("%s%s%s%s\n", indent, "-n", indent,
+    printf("%s%s%s%s\n", indent, "-n, --records=NUMBER", "\t\t",
             "The number of records per table. Default is 10000.");
-    printf("%s%s%s%s\n", indent, "-M", indent,
+    printf("%s%s%s%s\n", indent, "-M, --random", "\t\t\t",
             "The value of records generated are totally random.");
-    printf("%s%s%s%s\n", indent, indent, indent,
-            " The default is to simulate power equipment senario.");
-    printf("%s%s%s%s\n", indent, "-x", indent, "Not insert only flag.");
-    printf("%s%s%s%s\n", indent, "-y", indent, "Default input yes for prompt.");
-    printf("%s%s%s%s\n", indent, "-O", indent,
-            "Insert mode--0: In order, 1 ~ 50: disorder ratio. Default is in order.");
-    printf("%s%s%s%s\n", indent, "-R", indent,
+    printf("%s\n", "\t\t\t\tThe default is to simulate power equipment senario.");
+    printf("%s%s%s%s\n", indent, "-x, --no-insert", "\t\t",
+            "No-insert flag.");
+    printf("%s%s%s%s\n", indent, "-y, --answer-yes", "\t\t", "Default input yes for prompt.");
+    printf("%s%s%s%s\n", indent, "-O, --disorder=NUMBER", "\t\t",
+            "Insert order mode--0: In order, 1 ~ 50: disorder ratio. Default is in order.");
+    printf("%s%s%s%s\n", indent, "-R, --disorder-range=NUMBER", "\t",
             "Out of order data's range, ms, default is 1000.");
-    printf("%s%s%s%s\n", indent, "-g", indent,
+    printf("%s%s%s%s\n", indent, "-g, --debug", "\t\t\t",
             "Print debug info.");
-    printf("%s%s%s\n", indent, "-V, --version\t",
-            "Print version info.");
-    printf("%s%s%s%s\n", indent, "--help\t", indent,
-            "Print command line arguments list info.");
+    printf("%s%s%s%s\n", indent, "-?, --help\t", "\t\t",
+            "Give this help list");
+    printf("%s%s%s%s\n", indent, "    --usage\t", "\t\t",
+            "Give a short usage message");
+    printf("%s%s\n", indent, "-V, --version\t\t\tPrint version info.");
     /*    printf("%s%s%s%s\n", indent, "-D", indent,
           "Delete database if exists. 0: no, 1: yes, default is 1");
           */
@@ -819,66 +827,149 @@ static bool isStringNumber(char *input)
     return true;
 }
 
+static void errorPrintReqArg(char *program, char *wrong_arg)
+{
+    fprintf(stderr,
+            "%s: option requires an argument -- '%s'\n",
+            program, wrong_arg);
+    fprintf(stderr,
+            "Try `taosdemo --help' or `taosdemo --usage' for more information.\n");
+}
+
+static void errorPrintReqArg2(char *program, char *wrong_arg)
+{
+    fprintf(stderr,
+            "%s: option requires a number argument '-%s'\n",
+            program, wrong_arg);
+    fprintf(stderr,
+            "Try `taosdemo --help' or `taosdemo --usage' for more information.\n");
+}
+
+static void errorPrintReqArg3(char *program, char *wrong_arg)
+{
+    fprintf(stderr,
+            "%s: option '%s' requires an argument\n",
+            program, wrong_arg);
+    fprintf(stderr,
+            "Try `taosdemo --help' or `taosdemo --usage' for more information.\n");
+}
+
 static void parse_args(int argc, char *argv[], SArguments *arguments) {
 
     for (int i = 1; i < argc; i++) {
-        if (strcmp(argv[i], "-f") == 0) {
+        if ((strcmp(argv[i], "-f") == 0)
+                || (0 == strncmp(argv[i], "--file", strlen("--file")))) {
+            if (2 == strlen(argv[i])) {
                 arguments->demo_mode = false;
 
                 if (NULL == argv[i+1]) {
-                printHelp();
-                errorPrint("%s", "\n\t-f need a valid json file following!\n");
+                    errorPrintReqArg3(argv[0], "f");
                     exit(EXIT_FAILURE);
                 }
                 arguments->metaFile = argv[++i];
-        } else if (strcmp(argv[i], "-c") == 0) {
+            } else if (strlen("--file") == strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--file");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--file=", strlen("--file="))) {
+                arguments->metaFile = (char *)(argv[i] + strlen("--file="));
+            }
+        } else if ((strcmp(argv[i], "-c") == 0)
+                || (0 == strncmp(argv[i], "--config-dir", strlen("--config-dir")))) {
+            if (2 == strlen(argv[i])) {
                 if (argc == i+1) {
-                printHelp();
-                errorPrint("%s", "\n\t-c need a valid path following!\n");
+                    errorPrintReqArg(argv[0], "c");
                     exit(EXIT_FAILURE);
                 }
                 tstrncpy(configDir, argv[++i], TSDB_FILENAME_LEN);
-        } else if (strcmp(argv[i], "-h") == 0) {
+            } else if (strlen("--config-dir") == strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--config-dir");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--config-dir=", strlen("--config-dir="))) {
+                tstrncpy(configDir, (char *)(argv[i] + strlen("--config-dir=")), TSDB_FILENAME_LEN);
+            }
+        } else if ((strcmp(argv[i], "-h") == 0)
+                || (0 == strncmp(argv[i], "--host", strlen("--host")))) {
+            if (2 == strlen(argv[i])) {
                 if (argc == i+1) {
-                printHelp();
-                errorPrint("%s", "\n\t-h need a valid string following!\n");
+                    errorPrintReqArg(argv[0], "h");
                     exit(EXIT_FAILURE);
                 }
                 arguments->host = argv[++i];
-        } else if (strcmp(argv[i], "-P") == 0) {
-            if ((argc == i+1) ||
-                    (!isStringNumber(argv[i+1]))) {
-                printHelp();
-                errorPrint("%s", "\n\t-P need a number following!\n");
+            } else if (strlen("--host") == strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--host");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--host=", strlen("--host="))) {
+                arguments->host = (char *)(argv[i] + strlen("--host="));
+            }
+        } else if ((strcmp(argv[i], "-P") == 0)
+                || (0 == strncmp(argv[i], "--port", strlen("--port")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i+1) {
+                    errorPrintReqArg(argv[0], "P");
+                    exit(EXIT_FAILURE);
+                } else if (!isStringNumber(argv[i+1])) {
+                    errorPrintReqArg2(argv[0], "P");
                     exit(EXIT_FAILURE);
                 }
                 arguments->port = atoi(argv[++i]);
-        } else if (strcmp(argv[i], "-I") == 0) {
+            } else if (strlen("--port") == strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--port");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--port=", strlen("--port="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--port=")))) {
+                    arguments->port = atoi((char *)(argv[i]+strlen("--port=")));
+                }
+            }
+        } else if ((strcmp(argv[i], "-I") == 0)
+                || (0 == strncmp(argv[i], "--interface", strlen("--interface")))) {
+            if (2 == strlen(argv[i])) {
                 if (argc == i+1) {
-                printHelp();
-                errorPrint("%s", "\n\t-I need a valid string following!\n");
+                    errorPrintReqArg(argv[0], "I");
                     exit(EXIT_FAILURE);
                 }
-            ++i;
-            if (0 == strcasecmp(argv[i], "taosc")) {
+                if (0 == strcasecmp(argv[i+1], "taosc")) {
                     arguments->iface = TAOSC_IFACE;
-            } else if (0 == strcasecmp(argv[i], "rest")) {
+                } else if (0 == strcasecmp(argv[i+1], "rest")) {
                     arguments->iface = REST_IFACE;
-            } else if (0 == strcasecmp(argv[i], "stmt")) {
+                } else if (0 == strcasecmp(argv[i+1], "stmt")) {
                     arguments->iface = STMT_IFACE;
                 } else {
-                errorPrint("%s", "\n\t-I need a valid string following!\n");
+                    errorPrintReqArg(argv[0], "I");
                     exit(EXIT_FAILURE);
                 }
-        } else if (strcmp(argv[i], "-u") == 0) {
+                i++;
+            } else if (strlen("--interface") == strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--interface");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--interface=", strlen("--interface="))) {
+                if (0 == strcasecmp((char *)(argv[i] + strlen("--interface=")), "taosc")) {
+                    arguments->iface = TAOSC_IFACE;
+                } else if (0 == strcasecmp((char *)(argv[i] + strlen("--interface=")), "rest")) {
+                    arguments->iface = REST_IFACE;
+                } else if (0 == strcasecmp((char *)(argv[i] + strlen("--interface=")), "stmt")) {
+                    arguments->iface = STMT_IFACE;
+                } else {
+                    errorPrintReqArg3(argv[0], "--interface");
+                    exit(EXIT_FAILURE);
+                }
+            }
+        } else if ((strcmp(argv[i], "-u") == 0)
+                || (0 == strncmp(argv[i], "--user", strlen("--user")))) {
+            if (2 == strlen(argv[i])) {
                 if (argc == i+1) {
-                printHelp();
-                errorPrint("%s", "\n\t-u need a valid string following!\n");
+                    errorPrintReqArg(argv[0], "u");
                     exit(EXIT_FAILURE);
                 }
                 arguments->user = argv[++i];
-        } else if (strncmp(argv[i], "-p", 2) == 0) {
-            if (strlen(argv[i]) == 2) {
+            } else if (strlen("--user") == strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--user");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--user=", strlen("--user="))) {
+                arguments->user = (char *)(argv[i++] + strlen("--user="));
+            }
+        } else if ((strncmp(argv[i], "-p", 2) == 0)
+                || (0 == strcmp(argv[i], "--password"))) {
+            if ((strlen(argv[i]) == 2) || (0 == strcmp(argv[i], "--password"))) {
                 printf("Enter password: ");
                 taosSetConsoleEcho(false);
                 if (scanf("%s", arguments->password) > 1) {
@@ -888,37 +979,100 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
             } else {
                 tstrncpy(arguments->password, (char *)(argv[i] + 2), SHELL_MAX_PASSWORD_LEN);
             }
-        } else if (strcmp(argv[i], "-o") == 0) {
+        } else if ((strcmp(argv[i], "-o") == 0)
+                || (0 == strncmp(argv[i], "--output", strlen("--output")))) {
+            if (2 == strlen(argv[i])) {
                 if (argc == i+1) {
-                printHelp();
-                errorPrint("%s", "\n\t-o need a valid string following!\n");
+                    errorPrintReqArg3(argv[0], "o");
                     exit(EXIT_FAILURE);
                 }
                 arguments->output_file = argv[++i];
-        } else if (strcmp(argv[i], "-s") == 0) {
+            } else if (strlen("--output") == strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--output");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--output=", strlen("--output="))) {
+                arguments->output_file = (char *)(argv[i++] + strlen("--output="));
+            }
+        } else if ((strcmp(argv[i], "-s") == 0)
+                || (0 == strncmp(argv[i], "--sql-file", strlen("--sql-file")))) {
+            if (2 == strlen(argv[i])) {
                 if (argc == i+1) {
-                printHelp();
-                errorPrint("%s", "\n\t-s need a valid string following!\n");
+                    errorPrintReqArg(argv[0], "s");
                     exit(EXIT_FAILURE);
                 }
                 arguments->sqlFile = argv[++i];
-        } else if (strcmp(argv[i], "-q") == 0) {
-            if ((argc == i+1)
-                    || (!isStringNumber(argv[i+1]))) {
-                printHelp();
-                errorPrint("%s", "\n\t-q need a number following!\nQuery mode -- 0: SYNC, not-0: ASYNC. Default is SYNC.\n");
+            } else if (strlen("--sql-file") == strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--sql-file");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--sql-file=", strlen("--sql-file="))) {
+                arguments->host = (char *)(argv[i++] + strlen("--sql-file="));
+            }
+        } else if ((strcmp(argv[i], "-q") == 0)
+                || (0 == strncmp(argv[i], "--query-mode", strlen("--query-mode")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i+1) {
+                    errorPrintReqArg(argv[0], "q");
+                    exit(EXIT_FAILURE);
+                } else if (!isStringNumber(argv[i+1])) {
+                    errorPrintReqArg2(argv[0], "q");
                     exit(EXIT_FAILURE);
                 }
                 arguments->async_mode = atoi(argv[++i]);
-        } else if (strcmp(argv[i], "-T") == 0) {
-            if ((argc == i+1)
-                    || (!isStringNumber(argv[i+1]))) {
-                printHelp();
-                errorPrint("%s", "\n\t-T need a number following!\n");
+            } else if (strlen("--query-mode") == strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--query-mode");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--query-mode=", strlen("--query-mode="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--query-mode=")))) {
+                    arguments->async_mode = atoi((char *)(argv[i]+strlen("--query-mode=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--query-mode");
+                    exit(EXIT_FAILURE);
+                }
+            }
+        } else if ((strcmp(argv[i], "-T") == 0)
+                || (0 == strncmp(argv[i], "--threads", strlen("--threads")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i+1) {
+                    errorPrintReqArg(argv[0], "T");
+                    exit(EXIT_FAILURE);
+                } else if (!isStringNumber(argv[i+1])) {
+                    errorPrintReqArg2(argv[0], "T");
                     exit(EXIT_FAILURE);
                 }
                 arguments->num_of_threads = atoi(argv[++i]);
-        } else if (strcmp(argv[i], "-i") == 0) {
+            } else if (strlen("--threads") == strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--threads");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--threads=", strlen("--threads="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--threads=")))) {
+                    arguments->num_of_threads = atoi((char *)(argv[i]+strlen("--threads=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--threads");
+                    exit(EXIT_FAILURE);
+                }
+            }
+        } else if ((strcmp(argv[i], "-i") == 0)
+                || (0 == strncmp(argv[i], "--insert-interval", strlen("--insert-interval")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i+1) {
+                    errorPrintReqArg(argv[0], "i");
+                    exit(EXIT_FAILURE);
+                } else if (!isStringNumber(argv[i+1])) {
+                    errorPrintReqArg2(argv[0], "i");
+                    exit(EXIT_FAILURE);
+                }
+                arguments->insert_interval = atoi(argv[++i]);
+            } else if (strlen("--insert-interval")== strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--insert-interval");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--insert-interval=", strlen("--insert-interval="))) {
+                if (isStringNumber((char *)(argv[i] + 18))) {
+                    arguments->insert_interval = atoi((char *)(argv[i]+strlen("--insert-interval=")));
+                } else {
+                    errorPrintReqArg3(argv[0], "--insert-innterval");
+                    exit(EXIT_FAILURE);
+                }
+            }
             if ((argc == i+1) ||
                     (!isStringNumber(argv[i+1]))) {
                 printHelp();
@@ -926,14 +1080,28 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
                 exit(EXIT_FAILURE);
             }
             arguments->insert_interval = atoi(argv[++i]);
-        } else if (strcmp(argv[i], "-S") == 0) {
-            if ((argc == i+1) ||
-                    (!isStringNumber(argv[i+1]))) {
-                printHelp();
-                errorPrint("\n\t%s%s", argv[i], " need a number following!\n");
+        } else if ((strcmp(argv[i], "-S") == 0)
+                || (0 == strncmp(argv[i], "--time-step", strlen("--time-step")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i+1) {
+                    errorPrintReqArg(argv[0], "S");
+                    exit(EXIT_FAILURE);
+                } else if (!isStringNumber(argv[i+1])) {
+                    errorPrintReqArg2(argv[0], "S");
                     exit(EXIT_FAILURE);
                 }
-            arguments->timestamp_step = atoi(argv[++i]);
+                arguments->async_mode = atoi(argv[++i]);
+            } else if (strlen("--time-step") == strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--time-step");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--time-step=", strlen("--time-step="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--time-step=")))) {
+                    arguments->async_mode = atoi((char *)(argv[i]+strlen("--time-step=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--time-step");
+                    exit(EXIT_FAILURE);
+                }
+            }
         } else if (strcmp(argv[i], "-qt") == 0) {
             if ((argc == i+1)
                     || (!isStringNumber(argv[i+1]))) {
@@ -942,56 +1110,134 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
                 exit(EXIT_FAILURE);
             }
             arguments->query_times = atoi(argv[++i]);
-        } else if (strcmp(argv[i], "-B") == 0) {
-            if ((argc == i+1)
-                    || (!isStringNumber(argv[i+1]))) {
-                printHelp();
-                errorPrint("%s", "\n\t-B need a number following!\n");
+        } else if ((strcmp(argv[i], "-B") == 0)
+                || (0 == strncmp(argv[i], "--interlace-rows", strlen("--interlace-rows")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i+1) {
+                    errorPrintReqArg(argv[0], "B");
+                    exit(EXIT_FAILURE);
+                } else if (!isStringNumber(argv[i+1])) {
+                    errorPrintReqArg2(argv[0], "B");
                     exit(EXIT_FAILURE);
                 }
                 arguments->interlace_rows = atoi(argv[++i]);
-        } else if (strcmp(argv[i], "-r") == 0) {
-            if ((argc == i+1)
-                    || (!isStringNumber(argv[i+1]))) {
-                printHelp();
-                errorPrint("%s", "\n\t-r need a number following!\n");
+            } else if (strlen("--interlace-rows")== strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--interlace-rows");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--interlace-rows=", strlen("--interlace-rows="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--interlace-rows=")))) {
+                    arguments->interlace_rows = atoi((char *)(argv[i]+strlen("--interlace-rows=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--interlace-rows");
+                    exit(EXIT_FAILURE);
+                }
+            }
+        } else if ((strcmp(argv[i], "-r") == 0)
+                || (0 == strncmp(argv[i], "--rec-per-req", 13))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i+1) {
+                    errorPrintReqArg(argv[0], "r");
+                    exit(EXIT_FAILURE);
+                } else if (!isStringNumber(argv[i+1])) {
+                    errorPrintReqArg2(argv[0], "r");
                     exit(EXIT_FAILURE);
                 }
                 arguments->num_of_RPR = atoi(argv[++i]);
-        } else if (strcmp(argv[i], "-t") == 0) {
-            if ((argc == i+1) ||
-                    (!isStringNumber(argv[i+1]))) {
-                printHelp();
-                errorPrint("%s", "\n\t-t need a number following!\n");
+            } else if (strlen("--rec-per-req")== strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--rec-per-req");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--rec-per-req=", strlen("--rec-per-req="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--rec-per-req=")))) {
+                    arguments->num_of_RPR = atoi((char *)(argv[i]+strlen("--rec-per-req=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--rec-per-req");
+                    exit(EXIT_FAILURE);
+                }
+            }
+        } else if ((strcmp(argv[i], "-t") == 0)
+                || (0 == strncmp(argv[i], "--tables", strlen("--tables")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i+1) {
+                    errorPrintReqArg(argv[0], "t");
+                    exit(EXIT_FAILURE);
+                } else if (!isStringNumber(argv[i+1])) {
+                    errorPrintReqArg2(argv[0], "t");
                     exit(EXIT_FAILURE);
                 }
                 arguments->num_of_tables = atoi(argv[++i]);
-            g_totalChildTables = arguments->num_of_tables;
-        } else if (strcmp(argv[i], "-n") == 0) {
-            if ((argc == i+1) ||
-                    (!isStringNumber(argv[i+1]))) {
-                printHelp();
-                errorPrint("%s", "\n\t-n need a number following!\n");
+            } else if (strlen("--tables") == strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--tables");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--tables=", strlen("--tables="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--tables=")))) {
+                    arguments->num_of_tables = atoi((char *)(argv[i]+strlen("--tables=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--tables");
+                    exit(EXIT_FAILURE);
+                }
+            }
+        } else if ((strcmp(argv[i], "-n") == 0)
+                || (0 == strncmp(argv[i], "--records", strlen("--records")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i+1) {
+                    errorPrintReqArg(argv[0], "n");
+                    exit(EXIT_FAILURE);
+                } else if (!isStringNumber(argv[i+1])) {
+                    errorPrintReqArg2(argv[0], "n");
                     exit(EXIT_FAILURE);
                 }
                 arguments->num_of_DPT = atoi(argv[++i]);
-        } else if (strcmp(argv[i], "-d") == 0) {
+            } else if (strlen("--records") == strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--records");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--records=", strlen("--records="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--records=")))) {
+                    arguments->num_of_DPT = atoi((char *)(argv[i]+strlen("--records=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--records");
+                    exit(EXIT_FAILURE);
+                }
+            }
+
+            g_totalChildTables = arguments->num_of_DPT;
+        } else if ((strcmp(argv[i], "-d") == 0)
+
+                || (0 == strncmp(argv[i], "--database", strlen("--database")))) {
+            if (2 == strlen(argv[i])) {
                 if (argc == i+1) {
-                printHelp();
-                errorPrint("%s", "\n\t-d need a valid string following!\n");
+                    errorPrintReqArg3(argv[0], "d");
                     exit(EXIT_FAILURE);
                 }
                 arguments->database = argv[++i];
-        } else if (strcmp(argv[i], "-l") == 0) {
+            } else if (strlen("--database") == strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--database");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--database=", strlen("--database="))) {
+                arguments->output_file = (char *)(argv[i] + strlen("--database="));
+            }
+        } else if ((strcmp(argv[i], "-l") == 0)
+                || (0 == strncmp(argv[i], "--columns", strlen("--columns")))) {
             arguments->demo_mode = false;
+            if (2 == strlen(argv[i])) {
                 if (argc == i+1) {
-                if (!isStringNumber(argv[i+1])) {
-                    printHelp();
-                    errorPrint("%s", "\n\t-l need a number following!\n");
+                    errorPrintReqArg(argv[0], "l");
+                    exit(EXIT_FAILURE);
+                } else if (!isStringNumber(argv[i+1])) {
+                    errorPrintReqArg2(argv[0], "l");
                     exit(EXIT_FAILURE);
-                }
                 }
                 arguments->num_of_CPR = atoi(argv[++i]);
+            } else if (strlen("--columns")== strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--columns");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--columns=", strlen("--columns="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--columns=")))) {
+                    arguments->num_of_CPR = atoi((char *)(argv[i]+strlen("--columns")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--columns");
+                    exit(EXIT_FAILURE);
+                }
+            }
 
             if (arguments->num_of_CPR > MAX_NUM_COLUMNS) {
                 printf("WARNING: max acceptible columns count is %d\n", MAX_NUM_COLUMNS);
@@ -1005,36 +1251,46 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
             for (int col = arguments->num_of_CPR; col < MAX_NUM_COLUMNS; col++) {
                 arguments->datatype[col] = NULL;
             }
-        } else if (strcmp(argv[i], "-b") == 0) {
+        } else if ((strcmp(argv[i], "-b") == 0)
+                || (0 == strncmp(argv[i], "--data-type", strlen("--data-type")))) {
             arguments->demo_mode = false;
+
+            char *dataType;
+            if (2 == strlen(argv[i])) {
                 if (argc == i+1) {
-                printHelp();
-                errorPrint("%s", "\n\t-b need valid string following!\n");
+                    errorPrintReqArg(argv[0], "b");
+                    exit(EXIT_FAILURE);
+                }
+                dataType = argv[++i];
+            } else if (strlen("--data-type") == strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--data-type");
                 exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--data-type=", strlen("--data-type="))) {
+                dataType = (char *)(argv[i] + strlen("--data-type="));
             }
-            ++i;
-            if (strstr(argv[i], ",") == NULL) {
+
+            if (strstr(dataType, ",") == NULL) {
                 // only one col
-                if (strcasecmp(argv[i], "INT")
-                        && strcasecmp(argv[i], "FLOAT")
-                        && strcasecmp(argv[i], "TINYINT")
-                        && strcasecmp(argv[i], "BOOL")
-                        && strcasecmp(argv[i], "SMALLINT")
-                        && strcasecmp(argv[i], "BIGINT")
-                        && strcasecmp(argv[i], "DOUBLE")
-                        && strcasecmp(argv[i], "BINARY")
-                        && strcasecmp(argv[i], "TIMESTAMP")
-                        && strcasecmp(argv[i], "NCHAR")) {
+                if (strcasecmp(dataType, "INT")
+                        && strcasecmp(dataType, "FLOAT")
+                        && strcasecmp(dataType, "TINYINT")
+                        && strcasecmp(dataType, "BOOL")
+                        && strcasecmp(dataType, "SMALLINT")
+                        && strcasecmp(dataType, "BIGINT")
+                        && strcasecmp(dataType, "DOUBLE")
+                        && strcasecmp(dataType, "BINARY")
+                        && strcasecmp(dataType, "TIMESTAMP")
+                        && strcasecmp(dataType, "NCHAR")) {
                     printHelp();
                     errorPrint("%s", "-b: Invalid data_type!\n");
                     exit(EXIT_FAILURE);
                 }
-                arguments->datatype[0] = argv[i];
+                arguments->datatype[0] = dataType;
                 arguments->datatype[1] = NULL;
             } else {
                 // more than one col
                 int index = 0;
-                g_dupstr = strdup(argv[i]);
+                g_dupstr = strdup(dataType);
                 char *running = g_dupstr;
                 char *token = strsep(&running, ",");
                 while(token != NULL) {
@@ -1059,75 +1315,155 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
                 }
                 arguments->datatype[index] = NULL;
             }
-        } else if (strcmp(argv[i], "-w") == 0) {
-            if ((argc == i+1) ||
-                    (!isStringNumber(argv[i+1]))) {
-                printHelp();
-                errorPrint("%s", "\n\t-w need a number following!\n");
+        } else if ((strcmp(argv[i], "-w") == 0)
+                || (0 == strncmp(argv[i], "--binwidth", strlen("--binwidth")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i+1) {
+                    errorPrintReqArg(argv[0], "w");
+                    exit(EXIT_FAILURE);
+                } else if (!isStringNumber(argv[i+1])) {
+                    errorPrintReqArg2(argv[0], "w");
                     exit(EXIT_FAILURE);
                 }
-            arguments->len_of_binary = atoi(argv[++i]);
-        } else if (strcmp(argv[i], "-m") == 0) {
-            if ((argc == i+1) ||
-                    (isStringNumber(argv[i+1]))) {
-                printHelp();
-                errorPrint("%s", "\n\t-m need a letter-initial string following!\n");
+                arguments->binwidth = atoi(argv[++i]);
+            } else if (strlen("--binwidth") == strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--binwidth");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--binwidth=", strlen("--binwidth="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--binwidth=")))) {
+                    arguments->binwidth = atoi((char *)(argv[i]+strlen("--binwidth=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--binwidth");
+                    exit(EXIT_FAILURE);
+                }
+            }
+        } else if ((strcmp(argv[i], "-m") == 0)
+                || (0 == strncmp(argv[i], "--table-prefix", strlen("--table-prefix")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i+1) {
+                    errorPrintReqArg3(argv[0], "m");
                     exit(EXIT_FAILURE);
                 }
                 arguments->tb_prefix = argv[++i];
-        } else if (strcmp(argv[i], "-N") == 0) {
+            } else if (strlen("--table-prefix") == strlen(argv[i])
+                    || (strlen("--table-prefix=") == strlen(argv[i]))) {
+                errorPrintReqArg3(argv[0], "--table-prefix");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--table-prefix=", strlen("--table-prefix="))) {
+                arguments->tb_prefix = (char *)(argv[i] + strlen("--table-prefix="));
+            }
+        } else if ((strcmp(argv[i], "-N") == 0)
+                || (0 == strcmp(argv[i], "--normal-table"))) {
             arguments->use_metric = false;
-        } else if (strcmp(argv[i], "-M") == 0) {
+        } else if ((strcmp(argv[i], "-M") == 0)
+                || (0 == strcmp(argv[i], "--random"))) {
             arguments->demo_mode = false;
-        } else if (strcmp(argv[i], "-x") == 0) {
+        } else if ((strcmp(argv[i], "-x") == 0)
+                || (0 == strcmp(argv[i], "--no-insert"))) {
             arguments->insert_only = false;
-        } else if (strcmp(argv[i], "-y") == 0) {
+        } else if ((strcmp(argv[i], "-y") == 0)
+                || (0 == strcmp(argv[i], "--answer-yes"))) {
             arguments->answer_yes = true;
-        } else if (strcmp(argv[i], "-g") == 0) {
+        } else if ((strcmp(argv[i], "-g") == 0)
+                || (0 == strcmp(argv[i], "--debug"))) {
             arguments->debug_print = true;
         } else if (strcmp(argv[i], "-gg") == 0) {
             arguments->verbose_print = true;
         } else if (strcmp(argv[i], "-PP") == 0) {
             arguments->performance_print = true;
-        } else if (strcmp(argv[i], "-O") == 0) {
-            if ((argc == i+1) ||
-                    (!isStringNumber(argv[i+1]))) {
-                printHelp();
-                errorPrint("%s", "\n\t-O need a number following!\n");
+        } else if ((strcmp(argv[i], "-O") == 0)
+                || (0 == strncmp(argv[i], "--disorder", strlen("--disorder")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i+1) {
+                    errorPrintReqArg(argv[0], "O");
+                    exit(EXIT_FAILURE);
+                } else if (!isStringNumber(argv[i+1])) {
+                    errorPrintReqArg2(argv[0], "O");
                     exit(EXIT_FAILURE);
                 }
-
                 arguments->disorderRatio = atoi(argv[++i]);
+            } else if (strlen("--disorder") == strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--disorder");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--disorder=", strlen("--disorder="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--disorder=")))) {
+                    arguments->disorderRatio = atoi((char *)(argv[i]+strlen("--disorder=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--disorder");
+                    exit(EXIT_FAILURE);
+                }
+            }
 
             if (arguments->disorderRatio > 50) {
+                errorPrint("Invalid disorder ratio %d, will be set to %d\n",
+                        arguments->disorderRatio, 50);
                 arguments->disorderRatio = 50;
             }
 
             if (arguments->disorderRatio < 0) {
+                errorPrint("Invalid disorder ratio %d, will be set to %d\n",
+                        arguments->disorderRatio, 0);
                 arguments->disorderRatio = 0;
             }
-
-        } else if (strcmp(argv[i], "-R") == 0) {
-            if ((argc == i+1) ||
-                    (!isStringNumber(argv[i+1]))) {
-                printHelp();
-                errorPrint("%s", "\n\t-R need a number following!\n");
+        } else if ((strcmp(argv[i], "-R") == 0)
+                || (0 == strncmp(argv[i], "--disorder-range",
+                        strlen("--disorder-range")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i+1) {
+                    errorPrintReqArg(argv[0], "R");
+                    exit(EXIT_FAILURE);
+                } else if (!isStringNumber(argv[i+1])) {
+                    errorPrintReqArg2(argv[0], "R");
                     exit(EXIT_FAILURE);
                 }
-
                 arguments->disorderRange = atoi(argv[++i]);
-            if (arguments->disorderRange < 0)
-                arguments->disorderRange = 1000;
+            } else if (strlen("--disorder-range") == strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--disorder-range");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--disorder-range=",
+                        strlen("--disorder-range="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--disorder-range=")))) {
+                    arguments->disorderRange =
+                        atoi((char *)(argv[i]+strlen("--disorder-rnage=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--disorder-range");
+                    exit(EXIT_FAILURE);
+                }
+            }
 
-        } else if (strcmp(argv[i], "-a") == 0) {
-            if ((argc == i+1) ||
-                    (!isStringNumber(argv[i+1]))) {
-                printHelp();
-                errorPrint("%s", "\n\t-a need a number following!\n");
+            if (arguments->disorderRange < 0) {
+                errorPrint("Invalid disorder range %d, will be set to %d\n",
+                        arguments->disorderRange, 1000);
+                arguments->disorderRange = 1000;
+            }
+        } else if ((strcmp(argv[i], "-a") == 0)
+                || (0 == strncmp(argv[i], "--replica",
+                        strlen("--replica")))) {
+            if (2 == strlen(argv[i])) {
+                if (argc == i+1) {
+                    errorPrintReqArg(argv[0], "a");
+                    exit(EXIT_FAILURE);
+                } else if (!isStringNumber(argv[i+1])) {
+                    errorPrintReqArg2(argv[0], "a");
                     exit(EXIT_FAILURE);
                 }
                 arguments->replica = atoi(argv[++i]);
+            } else if (strlen("--replica") == strlen(argv[i])) {
+                errorPrintReqArg3(argv[0], "--replica");
+                exit(EXIT_FAILURE);
+            } else if (0 == strncmp(argv[i], "--replica=",
+                        strlen("--replica="))) {
+                if (isStringNumber((char *)(argv[i] + strlen("--replica=")))) {
+                    arguments->replica =
+                        atoi((char *)(argv[i]+strlen("--replica=")));
+                } else {
+                    errorPrintReqArg2(argv[0], "--replica");
+                    exit(EXIT_FAILURE);
+                }
+            }
             if (arguments->replica > 3 || arguments->replica < 1) {
+                errorPrint("Invalid replica value %d, will be set to %d\n",
+                        arguments->replica, 1);
                 arguments->replica = 1;
             }
         } else if (strcmp(argv[i], "-D") == 0) {
@@ -1136,16 +1472,32 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
                 errorPrint("%s", "\n\t-D need a valud (0~3) number following!\n");
                 exit(EXIT_FAILURE);
             }
-        } else if ((strcmp(argv[i], "--version") == 0) ||
-                (strcmp(argv[i], "-V") == 0)) {
+        } else if ((strcmp(argv[i], "--version") == 0)
+                || (strcmp(argv[i], "-V") == 0)) {
             printVersion();
             exit(0);
-        } else if (strcmp(argv[i], "--help") == 0) {
+        } else if ((strcmp(argv[i], "--help") == 0)
+                || (strcmp(argv[i], "-?") == 0)) {
             printHelp();
             exit(0);
+        } else if (strcmp(argv[i], "--usage") == 0) {
+            printf("    Usage: taosdemo [-f JSONFILE] [-u USER] [-p PASSWORD] [-c CONFIG_DIR]\n\
+                    [-h HOST] [-P PORT] [-I INTERFACE] [-d DATABASE] [-a REPLICA]\n\
+                    [-m TABLEPREFIX] [-s SQLFILE] [-N] [-o OUTPUTFILE] [-q QUERYMODE]\n\
+                    [-b DATATYPES] [-w WIDTH_OF_BINARY] [-l COLUNNS] [-T THREADNUMBER]\n\
+                    [-i SLEEPTIME] [-S TIME_STEP] [-B INTERLACE_ROWS] [-t TABLES]\n\
+                    [-n RECORDS] [-M] [-x] [-y] [-O ORDERMODE] [-R RANGE] [-a REPLIcA][-g]\n\
+                    [--help] [--usage] [--version]\n");
+            exit(0);
         } else {
-            printHelp();
-            errorPrint("%s", "ERROR: wrong options\n");
+            // to simulate argp_option output
+            if (strlen(argv[i]) > 2) {
+                fprintf(stderr, "%s unrecognized options '%s'\n", argv[0], argv[i]);
+            } else {
+                fprintf(stderr, "%s invalid options -- '%s'\n", argv[0],
+                        (char *)((char *)argv[i])+1);
+            }
+            fprintf(stderr, "Try `taosdemo --help' or `taosdemo --usage' for more information.\n");
             exit(EXIT_FAILURE);
         }
     }
@@ -1162,7 +1514,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
     }
     g_args.num_of_CPR = columnCount;
 
-    if (((arguments->debug_print) && (arguments->metaFile == NULL))
+    if (((arguments->debug_print) && (NULL != arguments->metaFile))
             || arguments->verbose_print) {
         printf("###################################################################\n");
         printf("# meta file:                         %s\n", arguments->metaFile);
@@ -1188,7 +1540,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
                 arguments->num_of_RPR);
         printf("# Max SQL length:                    %"PRIu64"\n",
                 arguments->max_sql_len);
-        printf("# Length of Binary:                  %d\n", arguments->len_of_binary);
+        printf("# Length of Binary:                  %d\n", arguments->binwidth);
         printf("# Number of Threads:                 %d\n", arguments->num_of_threads);
         printf("# Number of Tables:                  %"PRId64"\n",
                 arguments->num_of_tables);
@@ -1644,7 +1996,7 @@ static int printfInsertMeta() {
     printf("resultFile:                 \033[33m%s\033[0m\n", g_Dbs.resultFile);
     printf("thread num of insert data:  \033[33m%d\033[0m\n", g_Dbs.threadCount);
     printf("thread num of create table: \033[33m%d\033[0m\n",
-            g_Dbs.threadCountByCreateTbl);
+            g_Dbs.threadCountForCreateTbl);
     printf("top insert interval:        \033[33m%"PRIu64"\033[0m\n",
             g_args.insert_interval);
     printf("number of records per req:  \033[33m%u\033[0m\n",
@@ -1852,7 +2204,7 @@ static void printfInsertMetaToFile(FILE* fp) {
     fprintf(fp, "configDir:                  %s\n", configDir);
     fprintf(fp, "resultFile:                 %s\n", g_Dbs.resultFile);
     fprintf(fp, "thread num of insert data:  %d\n", g_Dbs.threadCount);
-    fprintf(fp, "thread num of create table: %d\n", g_Dbs.threadCountByCreateTbl);
+    fprintf(fp, "thread num of create table: %d\n", g_Dbs.threadCountForCreateTbl);
     fprintf(fp, "number of records per req:  %u\n", g_args.num_of_RPR);
     fprintf(fp, "max sql length:             %"PRIu64"\n", g_args.max_sql_len);
     fprintf(fp, "database count:          %d\n", g_Dbs.dbCount);
@@ -3452,7 +3804,7 @@ static void createChildTables() {
 
                     startMultiThreadCreateChildTable(
                             g_Dbs.db[i].superTbls[j].colsOfCreateChildTable,
-                            g_Dbs.threadCountByCreateTbl,
+                            g_Dbs.threadCountForCreateTbl,
                             startFrom,
                             g_Dbs.db[i].superTbls[j].childTblCount,
                             g_Dbs.db[i].dbName, &(g_Dbs.db[i].superTbls[j]));
@@ -3466,7 +3818,7 @@ static void createChildTables() {
                         || (strncasecmp(g_args.datatype[j],
                                 "NCHAR", strlen("NCHAR")) == 0)) {
                     snprintf(tblColsBuf + len, TSDB_MAX_BYTES_PER_ROW - len,
-                            ",C%d %s(%d)", j, g_args.datatype[j], g_args.len_of_binary);
+                            ",C%d %s(%d)", j, g_args.datatype[j], g_args.binwidth);
                 } else {
                     snprintf(tblColsBuf + len, TSDB_MAX_BYTES_PER_ROW - len,
                             ",C%d %s", j, g_args.datatype[j]);
@@ -3481,7 +3833,7 @@ static void createChildTables() {
                     g_Dbs.db[i].dbName, g_args.num_of_tables, tblColsBuf);
             startMultiThreadCreateChildTable(
                     tblColsBuf,
-                    g_Dbs.threadCountByCreateTbl,
+                    g_Dbs.threadCountForCreateTbl,
                     0,
                     g_args.num_of_tables,
                     g_Dbs.db[i].dbName,
@@ -3838,9 +4190,9 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
 
     cJSON* threads2 = cJSON_GetObjectItem(root, "thread_count_create_tbl");
     if (threads2 && threads2->type == cJSON_Number) {
-        g_Dbs.threadCountByCreateTbl = threads2->valueint;
+        g_Dbs.threadCountForCreateTbl = threads2->valueint;
     } else if (!threads2) {
-        g_Dbs.threadCountByCreateTbl = 1;
+        g_Dbs.threadCountForCreateTbl = 1;
     } else {
         errorPrint("%s", "failed to read json, threads2 not found\n");
         goto PARSE_OVER;
@@ -4202,7 +4554,7 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
             if (batchCreateTbl && batchCreateTbl->type == cJSON_Number) {
                 g_Dbs.db[i].superTbls[j].batchCreateTableNum = batchCreateTbl->valueint;
             } else if (!batchCreateTbl) {
-                g_Dbs.db[i].superTbls[j].batchCreateTableNum = 1000;
+                g_Dbs.db[i].superTbls[j].batchCreateTableNum = 10;
             } else {
                 errorPrint("%s", "failed to read json, batch_create_tbl_num not found\n");
                 goto PARSE_OVER;
@@ -5430,7 +5782,7 @@ static int32_t generateDataTailWithoutStb(
         int64_t retLen = 0;
 
         char **data_type = g_args.datatype;
-        int lenOfBinary = g_args.len_of_binary;
+        int lenOfBinary = g_args.binwidth;
 
         if (g_args.disorderRatio) {
             retLen = generateData(data, data_type,
@@ -6212,7 +6564,7 @@ static int32_t prepareStmtWithoutStb(
             if ( -1 == prepareStmtBindArrayByType(
                         bind,
                         data_type[i],
-                        g_args.len_of_binary,
+                        g_args.binwidth,
                         pThreadInfo->time_precision,
                         NULL)) {
                 return -1;
@@ -6246,7 +6598,7 @@ static int32_t prepareStbStmtBindTag(
         char *tagsVal,
         int32_t timePrec)
 {
-    char *bindBuffer = calloc(1, DOUBLE_BUFF_LEN); // g_args.len_of_binary);
+    char *bindBuffer = calloc(1, DOUBLE_BUFF_LEN); // g_args.binwidth);
     if (bindBuffer == NULL) {
         errorPrint2("%s() LN%d, Failed to allocate %d bind buffer\n",
                 __func__, __LINE__, DOUBLE_BUFF_LEN);
@@ -6278,7 +6630,7 @@ static int32_t prepareStbStmtBindRand(
         int64_t startTime, int32_t recSeq,
         int32_t timePrec)
 {
-    char *bindBuffer = calloc(1, DOUBLE_BUFF_LEN); // g_args.len_of_binary);
+    char *bindBuffer = calloc(1, DOUBLE_BUFF_LEN); // g_args.binwidth);
     if (bindBuffer == NULL) {
         errorPrint2("%s() LN%d, Failed to allocate %d bind buffer\n",
                 __func__, __LINE__, DOUBLE_BUFF_LEN);
@@ -7389,7 +7741,7 @@ static void startMultiThreadInsertData(int threads, char* db_name,
             }
         }
     } else {
-        start_time = 1500000000000;
+        start_time = DEFAULT_START_TIME;
     }
     debugPrint("%s() LN%d, start_time= %"PRId64"\n",
             __func__, __LINE__, start_time);
@@ -7944,11 +8296,11 @@ static int insertTestProcess() {
     if (g_totalChildTables > 0) {
         fprintf(stderr,
                 "creating %"PRId64" table(s) with %d thread(s)\n\n",
-                g_totalChildTables, g_Dbs.threadCountByCreateTbl);
+                g_totalChildTables, g_Dbs.threadCountForCreateTbl);
         if (g_fpOfInsertResult) {
             fprintf(g_fpOfInsertResult,
                 "creating %"PRId64" table(s) with %d thread(s)\n\n",
-                g_totalChildTables, g_Dbs.threadCountByCreateTbl);
+                g_totalChildTables, g_Dbs.threadCountForCreateTbl);
         }
 
         // create child tables
@@ -7959,12 +8311,12 @@ static int insertTestProcess() {
         fprintf(stderr,
                 "\nSpent %.4f seconds to create %"PRId64" table(s) with %d thread(s), actual %"PRId64" table(s) created\n\n",
                 (end - start)/1000.0, g_totalChildTables,
-                g_Dbs.threadCountByCreateTbl, g_actualChildTables);
+                g_Dbs.threadCountForCreateTbl, g_actualChildTables);
         if (g_fpOfInsertResult) {
             fprintf(g_fpOfInsertResult,
                 "\nSpent %.4f seconds to create %"PRId64" table(s) with %d thread(s), actual %"PRId64" table(s) created\n\n",
                 (end - start)/1000.0, g_totalChildTables,
-                g_Dbs.threadCountByCreateTbl, g_actualChildTables);
+                g_Dbs.threadCountForCreateTbl, g_actualChildTables);
         }
     }
 
@@ -8879,7 +9231,7 @@ static void setParaFromArg() {
     }
 
     g_Dbs.threadCount = g_args.num_of_threads;
-    g_Dbs.threadCountByCreateTbl = g_args.num_of_threads;
+    g_Dbs.threadCountForCreateTbl = g_args.num_of_threads;
 
     g_Dbs.dbCount = 1;
     g_Dbs.db[0].drop = true;
@@ -8911,7 +9263,7 @@ static void setParaFromArg() {
         tstrncpy(g_Dbs.db[0].superTbls[0].sTblName, "meters", TSDB_TABLE_NAME_LEN);
         g_Dbs.db[0].superTbls[0].childTblCount = g_args.num_of_tables;
         g_Dbs.threadCount = g_args.num_of_threads;
-        g_Dbs.threadCountByCreateTbl = g_args.num_of_threads;
+        g_Dbs.threadCountForCreateTbl = g_args.num_of_threads;
         g_Dbs.asyncMode = g_args.async_mode;
 
         g_Dbs.db[0].superTbls[0].autoCreateTable = PRE_CREATE_SUBTBL;
@@ -8942,7 +9294,7 @@ static void setParaFromArg() {
 
             tstrncpy(g_Dbs.db[0].superTbls[0].columns[i].dataType,
                     data_type[i], min(DATATYPE_BUFF_LEN, strlen(data_type[i]) + 1));
-            g_Dbs.db[0].superTbls[0].columns[i].dataLen = g_args.len_of_binary;
+            g_Dbs.db[0].superTbls[0].columns[i].dataLen = g_args.binwidth;
             g_Dbs.db[0].superTbls[0].columnCount++;
         }
 
@@ -8964,10 +9316,10 @@ static void setParaFromArg() {
 
         tstrncpy(g_Dbs.db[0].superTbls[0].tags[1].dataType,
                 "BINARY", min(DATATYPE_BUFF_LEN, strlen("BINARY") + 1));
-        g_Dbs.db[0].superTbls[0].tags[1].dataLen = g_args.len_of_binary;
+        g_Dbs.db[0].superTbls[0].tags[1].dataLen = g_args.binwidth;
         g_Dbs.db[0].superTbls[0].tagCount = 2;
     } else {
-        g_Dbs.threadCountByCreateTbl = g_args.num_of_threads;
+        g_Dbs.threadCountForCreateTbl = g_args.num_of_threads;
         g_Dbs.db[0].superTbls[0].tagCount = 0;
     }
 }
@@ -9089,7 +9441,7 @@ static void queryResult() {
     pthread_t read_id;
     threadInfo *pThreadInfo = calloc(1, sizeof(threadInfo));
     assert(pThreadInfo);
-    pThreadInfo->start_time = 1500000000000;  // 2017-07-14 10:40:00.000
+    pThreadInfo->start_time = DEFAULT_START_TIME;  // 2017-07-14 10:40:00.000
     pThreadInfo->start_table_from = 0;
 
     //pThreadInfo->do_aggreFunc = g_Dbs.do_aggreFunc;
@@ -9155,6 +9507,7 @@ int main(int argc, char *argv[]) {
     debugPrint("meta file: %s\n", g_args.metaFile);
 
     if (g_args.metaFile) {
+        g_totalChildTables = 0;
         initOfInsertMeta();
         initOfQueryMeta();
 

src/kit/taosdump/taosdump.c

@@ -225,16 +225,15 @@ static struct argp_option options[] = {
     {"password", 'p', 0,    0,  "User password to connect to server. Default is taosdata.", 0},
 #endif
     {"port", 'P', "PORT",        0,  "Port to connect", 0},
-    {"cversion",      'v', "CVERION",     0,  "client version", 0},
     {"mysqlFlag",     'q', "MYSQLFLAG",   0,  "mysqlFlag, Default is 0", 0},
     // input/output file
     {"outpath", 'o', "OUTPATH",     0,  "Output file path.", 1},
     {"inpath", 'i', "INPATH",      0,  "Input file path.", 1},
     {"resultFile", 'r', "RESULTFILE",  0,  "DumpOut/In Result file path and name.", 1},
 #ifdef _TD_POWER_
-    {"config", 'c', "CONFIG_DIR",  0,  "Configure directory. Default is /etc/power/taos.cfg.", 1},
+    {"config-dir", 'c', "CONFIG_DIR",  0,  "Configure directory. Default is /etc/power/taos.cfg.", 1},
 #else
-    {"config", 'c', "CONFIG_DIR",  0,  "Configure directory. Default is /etc/taos/taos.cfg.", 1},
+    {"config-dir", 'c', "CONFIG_DIR",  0,  "Configure directory. Default is /etc/taos/taos.cfg.", 1},
 #endif
     {"encode", 'e', "ENCODE", 0,  "Input file encoding.", 1},
     // dump unit options
@@ -244,7 +243,7 @@ static struct argp_option options[] = {
     // dump format options
     {"schemaonly", 's', 0, 0,  "Only dump schema.", 2},
     {"without-property", 'N', 0, 0,  "Dump schema without properties.", 2},
-    {"avro", 'V', 0, 0,  "Dump apache avro format data file. By default, dump sql command sequence.", 2},
+    {"avro", 'v', 0, 0,  "Dump apache avro format data file. By default, dump sql command sequence.", 2},
     {"start-time",    'S', "START_TIME",  0,  "Start time to dump. Either epoch or ISO8601/RFC3339 format is acceptable. ISO8601 format example: 2017-10-01T00:00:00.000+0800 or 2017-10-0100:00:00:000+0800 or '2017-10-01 00:00:00.000+0800'",  4},
     {"end-time",      'E', "END_TIME",    0,  "End time to dump. Either epoch or ISO8601/RFC3339 format is acceptable. ISO8601 format example: 2017-10-01T00:00:00.000+0800 or 2017-10-0100:00:00.000+0800 or '2017-10-01 00:00:00.000+0800'",  5},
 #if TSDB_SUPPORT_NANOSECOND == 1
@@ -267,7 +266,6 @@ typedef struct arguments {
     char    *user;
     char    password[SHELL_MAX_PASSWORD_LEN];
     uint16_t port;
-    char     cversion[12];
     uint16_t mysqlFlag;
     // output file
     char     outpath[MAX_FILE_NAME_LEN];
@@ -338,7 +336,6 @@ struct arguments g_args = {
     "taosdata",
 #endif
     0,
-    "",
     0,
     // outpath and inpath
     "",
@@ -379,6 +376,15 @@ static void errorPrintReqArg2(char *program, char *wrong_arg)
             "Try `taosdump --help' or `taosdump --usage' for more information.\n");
 }
 
+static void errorPrintReqArg3(char *program, char *wrong_arg)
+{
+    fprintf(stderr,
+            "%s: option '%s' requires an argument\n",
+            program, wrong_arg);
+    fprintf(stderr,
+            "Try `taosdump --help' or `taosdump --usage' for more information.\n");
+}
+
 /* Parse a single option. */
 static error_t parse_opt(int key, char *arg, struct argp_state *state) {
     /* Get the input argument from argp_parse, which we
@@ -408,15 +414,6 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
         case 'q':
             g_args.mysqlFlag = atoi(arg);
             break;
-        case 'v':
-            if (wordexp(arg, &full_path, 0) != 0) {
-                errorPrint("Invalid client vesion %s\n", arg);
-                return -1;
-            }
-            tstrncpy(g_args.cversion, full_path.we_wordv[0], 11);
-            wordfree(&full_path);
-            break;
-            // output file path
         case 'o':
             if (wordexp(arg, &full_path, 0) != 0) {
                 errorPrint("Invalid path %s\n", arg);
@@ -443,9 +440,13 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
             g_args.resultFile = arg;
             break;
         case 'c':
+            if (0 == strlen(arg)) {
+                errorPrintReqArg3("taosdump", "-c or --config-dir");
+                exit(EXIT_FAILURE);
+            }
             if (wordexp(arg, &full_path, 0) != 0) {
                 errorPrint("Invalid path %s\n", arg);
-                return -1;
+                exit(EXIT_FAILURE);
             }
             tstrncpy(configDir, full_path.we_wordv[0], MAX_FILE_NAME_LEN);
             wordfree(&full_path);
@@ -466,7 +467,7 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
         case 'N':
             g_args.with_property = false;
             break;
-        case 'V':
+        case 'v':
             g_args.avro = true;
             break;
         case 'S':
@@ -673,6 +674,9 @@ static void parse_timestamp(
 }
 
 int main(int argc, char *argv[]) {
+    static char verType[32] = {0};
+    sprintf(verType, "version: %s\n", version);
+    argp_program_version = verType;
 
     int ret = 0;
     /* Parse our arguments; every option seen by parse_opt will be
@@ -699,7 +703,6 @@ int main(int argc, char *argv[]) {
         printf("user: %s\n", g_args.user);
         printf("password: %s\n", g_args.password);
         printf("port: %u\n", g_args.port);
-        printf("cversion: %s\n", g_args.cversion);
         printf("mysqlFlag: %d\n", g_args.mysqlFlag);
         printf("outpath: %s\n", g_args.outpath);
         printf("inpath: %s\n", g_args.inpath);
@@ -728,11 +731,6 @@ int main(int argc, char *argv[]) {
         }
     }
     printf("==============================\n");
-
-    if (g_args.cversion[0] != 0){
-        tstrncpy(version, g_args.cversion, 11);
-    }
-
     if (taosCheckParam(&g_args) < 0) {
         exit(EXIT_FAILURE);
     }
@@ -750,7 +748,6 @@ int main(int argc, char *argv[]) {
         fprintf(g_fpOfResult, "user: %s\n", g_args.user);
         fprintf(g_fpOfResult, "password: %s\n", g_args.password);
         fprintf(g_fpOfResult, "port: %u\n", g_args.port);
-        fprintf(g_fpOfResult, "cversion: %s\n", g_args.cversion);
         fprintf(g_fpOfResult, "mysqlFlag: %d\n", g_args.mysqlFlag);
         fprintf(g_fpOfResult, "outpath: %s\n", g_args.outpath);
         fprintf(g_fpOfResult, "inpath: %s\n", g_args.inpath);

src/query/inc/qExecutor.h

@@ -221,6 +221,7 @@ typedef struct SQueryAttr {
   bool             distinct;         // distinct  query or not
   bool             stateWindow;       // window State on sub/normal table
   bool             createFilterOperator; // if filter operator is needed
+  bool             multigroupResult; // multigroup result can exist in one SSDataBlock
   int32_t          interBufSize;     // intermediate buffer sizse
 
   int32_t          havingNum;        // having expr number
@@ -477,6 +478,13 @@ typedef struct SSLimitOperatorInfo {
 
   char       **prevRow;
   SArray      *orderColumnList;
+  bool         hasPrev;
+  bool         ignoreCurrentGroup;
+  bool         multigroupResult;
+  SSDataBlock *pRes;   // result buffer
+  SSDataBlock *pPrevBlock;
+  int64_t      capacity;
+  int64_t      threshold;
 } SSLimitOperatorInfo;
 
 typedef struct SFilterOperatorInfo {
@@ -488,8 +496,9 @@ typedef struct SFillOperatorInfo {
   SFillInfo   *pFillInfo;
   SSDataBlock *pRes;
   int64_t      totalInputRows;
-
+  void       **p;
   SSDataBlock *existNewGroupBlock;
+  bool         multigroupResult;
 } SFillOperatorInfo;
 
 typedef struct SGroupbyOperatorInfo {
@@ -551,9 +560,9 @@ typedef struct SMultiwayMergeInfo {
   bool                 hasDataBlockForNewGroup;
   SSDataBlock         *pExistBlock;
 
-  bool                 hasPrev;
-  bool                 groupMix;
   SArray              *udfInfo;
+  bool                 hasPrev;
+  bool                 multiGroupResults;
 } SMultiwayMergeInfo;
 
 // todo support the disk-based sort
@@ -575,7 +584,7 @@ SOperatorInfo* createLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorI
 SOperatorInfo* createTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createAllTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createSWindowOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
-SOperatorInfo* createFillOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
+SOperatorInfo* createFillOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, bool multigroupResult);
 SOperatorInfo* createGroupbyOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createMultiTableAggOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createMultiTableTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
@@ -584,10 +593,10 @@ SOperatorInfo* createTagScanOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SExprInf
 SOperatorInfo* createDistinctOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
 SOperatorInfo* createTableBlockInfoScanOperator(void* pTsdbQueryHandle, SQueryRuntimeEnv* pRuntimeEnv);
 SOperatorInfo* createMultiwaySortOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SExprInfo* pExpr, int32_t numOfOutput,
-                                              int32_t numOfRows, void* merger, bool groupMix);
-SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* param, SArray* pUdfInfo);
+                                              int32_t numOfRows, void* merger);
+SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* param, SArray* pUdfInfo, bool groupResultMixedUp);
 SOperatorInfo* createStatewindowOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
-SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* merger);
+SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* merger, bool multigroupResult);
 SOperatorInfo* createFilterOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr,
                                         int32_t numOfOutput, SColumnInfo* pCols, int32_t numOfFilter);
 

src/query/inc/qTableMeta.h

@@ -165,6 +165,7 @@ typedef struct SQueryInfo {
   bool               orderProjectQuery;
   bool               stateWindow;
   bool               globalMerge;
+  bool               multigroupResult;
 } SQueryInfo;
 
 /**

src/query/inc/sql.y

@@ -162,7 +162,10 @@ cmd ::= DESCRIBE ids(X) cpxName(Y). {
     X.n += Y.n;
     setDCLSqlElems(pInfo, TSDB_SQL_DESCRIBE_TABLE, 1, &X);
 }
-
+cmd ::= DESC ids(X) cpxName(Y). {
+    X.n += Y.n;
+    setDCLSqlElems(pInfo, TSDB_SQL_DESCRIBE_TABLE, 1, &X);
+}
 /////////////////////////////////THE ALTER STATEMENT////////////////////////////////////////
 cmd ::= ALTER USER ids(X) PASS ids(Y).          { setAlterUserSql(pInfo, TSDB_ALTER_USER_PASSWD, &X, &Y, NULL);    }
 cmd ::= ALTER USER ids(X) PRIVILEGE ids(Y).     { setAlterUserSql(pInfo, TSDB_ALTER_USER_PRIVILEGES, &X, NULL, &Y);}

src/query/src/qExecutor.c

@@ -38,15 +38,12 @@
 #define SET_REVERSE_SCAN_FLAG(runtime) ((runtime)->scanFlag = REVERSE_SCAN)
 
 #define TSWINDOW_IS_EQUAL(t1, t2) (((t1).skey == (t2).skey) && ((t1).ekey == (t2).ekey))
-
 #define SWITCH_ORDER(n) (((n) = ((n) == TSDB_ORDER_ASC) ? TSDB_ORDER_DESC : TSDB_ORDER_ASC))
 
 #define SDATA_BLOCK_INITIALIZER (SDataBlockInfo) {{0}, 0}
 
 #define MULTI_KEY_DELIM  "-"
 
-#define HASH_CAPACITY_LIMIT  10000000
-
 #define TIME_WINDOW_COPY(_dst, _src)  do {\
    (_dst).skey = (_src).skey;\
    (_dst).ekey = (_src).ekey;\
@@ -2262,30 +2259,30 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
 
       case OP_Fill: {
         SOperatorInfo* pInfo = pRuntimeEnv->proot;
-        pRuntimeEnv->proot = createFillOperatorInfo(pRuntimeEnv, pInfo, pInfo->pExpr, pInfo->numOfOutput);
+        pRuntimeEnv->proot = createFillOperatorInfo(pRuntimeEnv, pInfo, pInfo->pExpr, pInfo->numOfOutput, pQueryAttr->multigroupResult);
         break;
       }
 
       case OP_MultiwayMergeSort: {
-        bool groupMix = true;
-        if (pQueryAttr->slimit.offset != 0 || pQueryAttr->slimit.limit != -1) {
-          groupMix = false;
+        pRuntimeEnv->proot = createMultiwaySortOperatorInfo(pRuntimeEnv, pQueryAttr->pExpr1, pQueryAttr->numOfOutput, 4096, merger);
+        break;
       }
 
-        pRuntimeEnv->proot = createMultiwaySortOperatorInfo(pRuntimeEnv, pQueryAttr->pExpr1, pQueryAttr->numOfOutput,
-                                                            4096, merger, groupMix);  // TODO hack it
-        break;
+      case OP_GlobalAggregate: { // If fill operator exists, the result rows of different group can not be in the same SSDataBlock.
+        bool multigroupResult = pQueryAttr->multigroupResult;
+        if (pQueryAttr->multigroupResult) {
+          multigroupResult = (pQueryAttr->fillType == TSDB_FILL_NONE);
         }
 
-      case OP_GlobalAggregate: {
         pRuntimeEnv->proot = createGlobalAggregateOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr3,
-                                                               pQueryAttr->numOfExpr3, merger, pQueryAttr->pUdfInfo);
+                                                               pQueryAttr->numOfExpr3, merger, pQueryAttr->pUdfInfo, multigroupResult);
         break;
       }
 
       case OP_SLimit: {
-        pRuntimeEnv->proot = createSLimitOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr3,
-                                                      pQueryAttr->numOfExpr3, merger);
+        int32_t num = pRuntimeEnv->proot->numOfOutput;
+        SExprInfo* pExpr = pRuntimeEnv->proot->pExpr;
+        pRuntimeEnv->proot = createSLimitOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pExpr, num, merger, pQueryAttr->multigroupResult);
         break;
       }
 
@@ -3636,7 +3633,7 @@ void updateOutputBuf(SOptrBasicInfo* pBInfo, int32_t *bufCapacity, int32_t numOf
     SColumnInfoData *pColInfo = taosArrayGet(pDataBlock->pDataBlock, i);
     pBInfo->pCtx[i].pOutput = pColInfo->pData + pColInfo->info.bytes * pDataBlock->info.rows;
 
-    // re-estabilish output buffer pointer.
+    // set the correct pointer after the memory buffer reallocated.
     int32_t functionId = pBInfo->pCtx[i].functionId;
 
     if (functionId == TSDB_FUNC_TOP || functionId == TSDB_FUNC_BOTTOM || functionId == TSDB_FUNC_DIFF || functionId == TSDB_FUNC_DERIVATIVE) {
@@ -4200,6 +4197,7 @@ static void toSSDataBlock(SGroupResInfo *pGroupResInfo, SQueryRuntimeEnv* pRunti
 
   // refactor : extract method
   SColumnInfoData* pInfoData = taosArrayGet(pBlock->pDataBlock, 0);
+
   //add condition (pBlock->info.rows >= 1) just to runtime happy
   if (pInfoData->info.type == TSDB_DATA_TYPE_TIMESTAMP && pBlock->info.rows >= 1) {
     STimeWindow* w = &pBlock->info.window;
@@ -4314,15 +4312,15 @@ static void doCopyQueryResultToMsg(SQInfo *pQInfo, int32_t numOfRows, char *data
   }
 }
 
-int32_t doFillTimeIntervalGapsInResults(SFillInfo* pFillInfo, SSDataBlock *pOutput, int32_t capacity) {
-  void** p = calloc(pFillInfo->numOfCols, POINTER_BYTES);
+int32_t doFillTimeIntervalGapsInResults(SFillInfo* pFillInfo, SSDataBlock *pOutput, int32_t capacity, void** p) {
   for(int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
     SColumnInfoData* pColInfoData = taosArrayGet(pOutput->pDataBlock, i);
-    p[i] = pColInfoData->pData;
+    p[i] = pColInfoData->pData + (pColInfoData->info.bytes * pOutput->info.rows);
   }
 
-  pOutput->info.rows = (int32_t)taosFillResultDataBlock(pFillInfo, p, capacity);
-  tfree(p);
+  int32_t numOfRows = (int32_t)taosFillResultDataBlock(pFillInfo, p, capacity - pOutput->info.rows);
+  pOutput->info.rows += numOfRows;
+
   return pOutput->info.rows;
 }
 
@@ -5366,11 +5364,12 @@ static void destroyGlobalAggOperatorInfo(void* param, int32_t numOfOutput) {
 static void destroySlimitOperatorInfo(void* param, int32_t numOfOutput) {
   SSLimitOperatorInfo *pInfo = (SSLimitOperatorInfo*) param;
   taosArrayDestroy(pInfo->orderColumnList);
+  pInfo->pRes = destroyOutputBuf(pInfo->pRes);
   tfree(pInfo->prevRow);
 }
 
 SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream,
-                                                 SExprInfo* pExpr, int32_t numOfOutput, void* param, SArray* pUdfInfo) {
+                                                 SExprInfo* pExpr, int32_t numOfOutput, void* param, SArray* pUdfInfo, bool groupResultMixedUp) {
   SMultiwayMergeInfo* pInfo = calloc(1, sizeof(SMultiwayMergeInfo));
 
   pInfo->resultRowFactor =
@@ -5378,13 +5377,12 @@ SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv,
 
   pRuntimeEnv->scanFlag = MERGE_STAGE;  // TODO init when creating pCtx
 
+  pInfo->multiGroupResults = groupResultMixedUp;
   pInfo->pMerge            = param;
   pInfo->bufCapacity       = 4096;
   pInfo->udfInfo           = pUdfInfo;
-
   pInfo->binfo.pRes        = createOutputBuf(pExpr, numOfOutput, pInfo->bufCapacity * pInfo->resultRowFactor);
   pInfo->binfo.pCtx        = createSQLFunctionCtx(pRuntimeEnv, pExpr, numOfOutput, &pInfo->binfo.rowCellInfoOffset);
-
   pInfo->orderColumnList   = getOrderCheckColumns(pRuntimeEnv->pQueryAttr);
   pInfo->groupColumnList   = getResultGroupCheckColumns(pRuntimeEnv->pQueryAttr);
 
@@ -5439,17 +5437,15 @@ SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv,
 }
 
 SOperatorInfo *createMultiwaySortOperatorInfo(SQueryRuntimeEnv *pRuntimeEnv, SExprInfo *pExpr, int32_t numOfOutput,
-                                              int32_t numOfRows, void *merger, bool groupMix) {
+                                              int32_t numOfRows, void *merger) {
   SMultiwayMergeInfo* pInfo = calloc(1, sizeof(SMultiwayMergeInfo));
 
   pInfo->pMerge          = merger;
-  pInfo->groupMix   = groupMix;
   pInfo->bufCapacity     = numOfRows;
-
   pInfo->orderColumnList = getResultGroupCheckColumns(pRuntimeEnv->pQueryAttr);
   pInfo->binfo.pRes      = createOutputBuf(pExpr, numOfOutput, numOfRows);
 
-  {
+  {  // todo extract method to create prev compare buffer
     int32_t len = 0;
     for(int32_t i = 0; i < numOfOutput; ++i) {
       len += pExpr[i].base.colBytes;
@@ -5457,8 +5453,8 @@ SOperatorInfo *createMultiwaySortOperatorInfo(SQueryRuntimeEnv *pRuntimeEnv, SEx
 
     int32_t numOfCols = (pInfo->orderColumnList != NULL)? (int32_t) taosArrayGetSize(pInfo->orderColumnList):0;
     pInfo->prevRow = calloc(1, (POINTER_BYTES * numOfCols + len));
-    int32_t offset = POINTER_BYTES * numOfCols;
 
+    int32_t offset = POINTER_BYTES * numOfCols;
     for(int32_t i = 0; i < numOfCols; ++i) {
       pInfo->prevRow[i] = (char*)pInfo->prevRow + offset;
 
@@ -5474,7 +5470,8 @@ SOperatorInfo *createMultiwaySortOperatorInfo(SQueryRuntimeEnv *pRuntimeEnv, SEx
   pOperator->status       = OP_IN_EXECUTING;
   pOperator->info         = pInfo;
   pOperator->pRuntimeEnv  = pRuntimeEnv;
-  pOperator->numOfOutput  = pRuntimeEnv->pQueryAttr->numOfCols;
+  pOperator->numOfOutput  = numOfOutput;
+  pOperator->pExpr        = pExpr;
   pOperator->exec         = doMultiwayMergeSort;
   pOperator->cleanup      = destroyGlobalAggOperatorInfo;
   return pOperator;
@@ -6390,19 +6387,13 @@ static SSDataBlock* hashGroupbyAggregate(void* param, bool* newgroup) {
   return pInfo->binfo.pRes;
 }
 
-static SSDataBlock* doFill(void* param, bool* newgroup) {
-  SOperatorInfo* pOperator = (SOperatorInfo*) param;
-  if (pOperator->status == OP_EXEC_DONE) {
-    return NULL;
-  }
-
-  SFillOperatorInfo *pInfo = pOperator->info;
-  SQueryRuntimeEnv  *pRuntimeEnv = pOperator->pRuntimeEnv;
-
+static void doHandleRemainBlockFromNewGroup(SFillOperatorInfo *pInfo, SQueryRuntimeEnv  *pRuntimeEnv, bool *newgroup) {
   if (taosFillHasMoreResults(pInfo->pFillInfo)) {
     *newgroup = false;
-    doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, (int32_t)pRuntimeEnv->resultInfo.capacity);
-    return pInfo->pRes;
+    doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, (int32_t)pRuntimeEnv->resultInfo.capacity, pInfo->p);
+    if (pInfo->pRes->info.rows > pRuntimeEnv->resultInfo.threshold || (!pInfo->multigroupResult)) {
+      return;
+    }
   }
 
   // handle the cached new group data block
@@ -6414,11 +6405,47 @@ static SSDataBlock* doFill(void* param, bool* newgroup) {
     taosFillSetStartInfo(pInfo->pFillInfo, pInfo->existNewGroupBlock->info.rows, ekey);
     taosFillSetInputDataBlock(pInfo->pFillInfo, pInfo->existNewGroupBlock);
 
-    doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, pRuntimeEnv->resultInfo.capacity);
+    doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, pRuntimeEnv->resultInfo.capacity, pInfo->p);
     pInfo->existNewGroupBlock = NULL;
     *newgroup = true;
-    return (pInfo->pRes->info.rows > 0)? pInfo->pRes:NULL;
   }
+}
+
+static SSDataBlock* doFill(void* param, bool* newgroup) {
+  SOperatorInfo* pOperator = (SOperatorInfo*) param;
+
+  SFillOperatorInfo *pInfo = pOperator->info;
+  pInfo->pRes->info.rows = 0;
+
+  if (pOperator->status == OP_EXEC_DONE) {
+    return NULL;
+  }
+
+  SQueryRuntimeEnv  *pRuntimeEnv = pOperator->pRuntimeEnv;
+  doHandleRemainBlockFromNewGroup(pInfo, pRuntimeEnv, newgroup);
+  if (pInfo->pRes->info.rows > pRuntimeEnv->resultInfo.threshold || (!pInfo->multigroupResult && pInfo->pRes->info.rows > 0)) {
+    return pInfo->pRes;
+  }
+//  if (taosFillHasMoreResults(pInfo->pFillInfo)) {
+//    *newgroup = false;
+//    doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, (int32_t)pRuntimeEnv->resultInfo.capacity);
+//    return pInfo->pRes;
+//  }
+//
+//  // handle the cached new group data block
+//  if (pInfo->existNewGroupBlock) {
+//    pInfo->totalInputRows = pInfo->existNewGroupBlock->info.rows;
+//    int64_t ekey = Q_STATUS_EQUAL(pRuntimeEnv->status, QUERY_COMPLETED)?pRuntimeEnv->pQueryAttr->window.ekey:pInfo->existNewGroupBlock->info.window.ekey;
+//    taosResetFillInfo(pInfo->pFillInfo, pInfo->pFillInfo->start);
+//
+//    taosFillSetStartInfo(pInfo->pFillInfo, pInfo->existNewGroupBlock->info.rows, ekey);
+//    taosFillSetInputDataBlock(pInfo->pFillInfo, pInfo->existNewGroupBlock);
+//
+//    doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, pRuntimeEnv->resultInfo.capacity);
+//    pInfo->existNewGroupBlock = NULL;
+//    *newgroup = true;
+//    return (pInfo->pRes->info.rows > 0)? pInfo->pRes:NULL;
+//  }
 
   while(1) {
     publishOperatorProfEvent(pOperator->upstream[0], QUERY_PROF_BEFORE_OPERATOR_EXEC);
@@ -6433,8 +6460,8 @@ static SSDataBlock* doFill(void* param, bool* newgroup) {
       pInfo->existNewGroupBlock = pBlock;
       *newgroup = false;
 
-      // fill the previous group data block
-      // before handle a new data block, close the fill operation for previous group data block
+      // Fill the previous group data block, before handle the data block of new group.
+      // Close the fill operation for previous group data block
       taosFillSetStartInfo(pInfo->pFillInfo, 0, pRuntimeEnv->pQueryAttr->window.ekey);
     } else {
       if (pBlock == NULL) {
@@ -6446,28 +6473,61 @@ static SSDataBlock* doFill(void* param, bool* newgroup) {
         taosFillSetStartInfo(pInfo->pFillInfo, 0, pRuntimeEnv->pQueryAttr->window.ekey);
       } else {
         pInfo->totalInputRows += pBlock->info.rows;
-
-        int64_t ekey = /*Q_STATUS_EQUAL(pRuntimeEnv->status, QUERY_COMPLETED) ? pRuntimeEnv->pQueryAttr->window.ekey
-                                                                            : */pBlock->info.window.ekey;
-
-        taosFillSetStartInfo(pInfo->pFillInfo, pBlock->info.rows, ekey);
+        taosFillSetStartInfo(pInfo->pFillInfo, pBlock->info.rows, pBlock->info.window.ekey);
         taosFillSetInputDataBlock(pInfo->pFillInfo, pBlock);
       }
     }
 
-    doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, pRuntimeEnv->resultInfo.capacity);
-    if (pInfo->pRes->info.rows > 0) {  // current group has no more result to return
+    doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, pRuntimeEnv->resultInfo.capacity, pInfo->p);
+
+    // current group has no more result to return
+    if (pInfo->pRes->info.rows > 0) {
+      // 1. The result in current group not reach the threshold of output result, continue
+      // 2. If multiple group results existing in one SSDataBlock is not allowed, return immediately
+      if (pInfo->pRes->info.rows > pRuntimeEnv->resultInfo.threshold || pBlock == NULL || (!pInfo->multigroupResult)) {
         return pInfo->pRes;
+      }
+
+      doHandleRemainBlockFromNewGroup(pInfo, pRuntimeEnv, newgroup);
+      if (pInfo->pRes->info.rows > pRuntimeEnv->resultInfo.threshold || pBlock == NULL) {
+        return pInfo->pRes;
+      }
+
+//      if (taosFillHasMoreResults(pInfo->pFillInfo)) {
+//        *newgroup = false;
+//        doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, (int32_t)pRuntimeEnv->resultInfo.capacity);
+//        return pInfo->pRes;
+//      }
+//
+//      // handle the cached new group data block
+//      if (pInfo->existNewGroupBlock) {
+//        pInfo->totalInputRows = pInfo->existNewGroupBlock->info.rows;
+//        int64_t ekey = Q_STATUS_EQUAL(pRuntimeEnv->status, QUERY_COMPLETED)?pRuntimeEnv->pQueryAttr->window.ekey:pInfo->existNewGroupBlock->info.window.ekey;
+//        taosResetFillInfo(pInfo->pFillInfo, pInfo->pFillInfo->start);
+//
+//        taosFillSetStartInfo(pInfo->pFillInfo, pInfo->existNewGroupBlock->info.rows, ekey);
+//        taosFillSetInputDataBlock(pInfo->pFillInfo, pInfo->existNewGroupBlock);
+//
+//        doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, pRuntimeEnv->resultInfo.capacity);
+//        pInfo->existNewGroupBlock = NULL;
+//        *newgroup = true;
+//
+//        if (pInfo->pRes->info.rows > pRuntimeEnv->resultInfo.threshold) {
+//          return pInfo->pRes;
+//        }
+//
+////        return (pInfo->pRes->info.rows > 0)? pInfo->pRes:NULL;
+//      }
+
     } else if (pInfo->existNewGroupBlock) {  // try next group
       pInfo->totalInputRows = pInfo->existNewGroupBlock->info.rows;
-      int64_t ekey = /*Q_STATUS_EQUAL(pRuntimeEnv->status, QUERY_COMPLETED) ? pRuntimeEnv->pQueryAttr->window.ekey
-                                                                          :*/ pInfo->existNewGroupBlock->info.window.ekey;
+      int64_t ekey = pInfo->existNewGroupBlock->info.window.ekey;
       taosResetFillInfo(pInfo->pFillInfo, pInfo->pFillInfo->start);
 
       taosFillSetStartInfo(pInfo->pFillInfo, pInfo->existNewGroupBlock->info.rows, ekey);
       taosFillSetInputDataBlock(pInfo->pFillInfo, pInfo->existNewGroupBlock);
 
-      doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, pRuntimeEnv->resultInfo.capacity);
+      doFillTimeIntervalGapsInResults(pInfo->pFillInfo, pInfo->pRes, pRuntimeEnv->resultInfo.capacity, pInfo->p);
       pInfo->existNewGroupBlock = NULL;
       *newgroup = true;
 
@@ -6475,7 +6535,6 @@ static SSDataBlock* doFill(void* param, bool* newgroup) {
     } else {
       return NULL;
     }
-    //    return (pInfo->pRes->info.rows > 0)? pInfo->pRes:NULL;
   }
 }
 
@@ -6576,6 +6635,7 @@ static void destroySFillOperatorInfo(void* param, int32_t numOfOutput) {
   SFillOperatorInfo* pInfo = (SFillOperatorInfo*) param;
   pInfo->pFillInfo = taosDestroyFillInfo(pInfo->pFillInfo);
   pInfo->pRes = destroyOutputBuf(pInfo->pRes);
+  tfree(pInfo->p);
 }
 
 static void destroyGroupbyOperatorInfo(void* param, int32_t numOfOutput) {
@@ -6919,10 +6979,10 @@ SOperatorInfo* createGroupbyOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperato
   return pOperator;
 }
 
-SOperatorInfo* createFillOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr,
-                                      int32_t numOfOutput) {
+SOperatorInfo* createFillOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, bool multigroupResult) {
   SFillOperatorInfo* pInfo = calloc(1, sizeof(SFillOperatorInfo));
   pInfo->pRes = createOutputBuf(pExpr, numOfOutput, pRuntimeEnv->resultInfo.capacity);
+  pInfo->multigroupResult = multigroupResult;
 
   {
     SQueryAttr* pQueryAttr = pRuntimeEnv->pQueryAttr;
@@ -6937,6 +6997,8 @@ SOperatorInfo* createFillOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorIn
         taosCreateFillInfo(pQueryAttr->order.order, w.skey, 0, (int32_t)pRuntimeEnv->resultInfo.capacity, numOfOutput,
                            pQueryAttr->interval.sliding, pQueryAttr->interval.slidingUnit,
                            (int8_t)pQueryAttr->precision, pQueryAttr->fillType, pColInfo, pRuntimeEnv->qinfo);
+
+    pInfo->p = calloc(pInfo->pFillInfo->numOfCols, POINTER_BYTES);
   }
 
   SOperatorInfo* pOperator = calloc(1, sizeof(SOperatorInfo));
@@ -6956,7 +7018,7 @@ SOperatorInfo* createFillOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorIn
   return pOperator;
 }
 
-SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* pMerger) {
+SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* pMerger, bool multigroupResult) {
   SSLimitOperatorInfo* pInfo = calloc(1, sizeof(SSLimitOperatorInfo));
 
   SQueryAttr* pQueryAttr = pRuntimeEnv->pQueryAttr;
@@ -6964,9 +7026,11 @@ SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperator
   pInfo->orderColumnList = getResultGroupCheckColumns(pQueryAttr);
   pInfo->slimit          = pQueryAttr->slimit;
   pInfo->limit           = pQueryAttr->limit;
-
-  pInfo->currentGroupOffset = pQueryAttr->slimit.offset;
+  pInfo->capacity        = pRuntimeEnv->resultInfo.capacity;
+  pInfo->threshold       = (int64_t)(pInfo->capacity * 0.8);
   pInfo->currentOffset   = pQueryAttr->limit.offset;
+  pInfo->currentGroupOffset = pQueryAttr->slimit.offset;
+  pInfo->multigroupResult= multigroupResult;
 
   // TODO refactor
   int32_t len = 0;
@@ -6974,10 +7038,10 @@ SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperator
     len += pExpr[i].base.resBytes;
   }
 
-  int32_t numOfCols = pInfo->orderColumnList != NULL? (int32_t) taosArrayGetSize(pInfo->orderColumnList):0;
+  int32_t numOfCols = (pInfo->orderColumnList != NULL)? (int32_t) taosArrayGetSize(pInfo->orderColumnList):0;
   pInfo->prevRow = calloc(1, (POINTER_BYTES * numOfCols + len));
-  int32_t offset = POINTER_BYTES * numOfCols;
 
+  int32_t offset = POINTER_BYTES * numOfCols;
   for(int32_t i = 0; i < numOfCols; ++i) {
     pInfo->prevRow[i] = (char*)pInfo->prevRow + offset;
 
@@ -6985,6 +7049,8 @@ SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperator
     offset += pExpr[index->colIndex].base.resBytes;
   }
 
+  pInfo->pRes = createOutputBuf(pExpr, numOfOutput, pRuntimeEnv->resultInfo.capacity);
+
   SOperatorInfo* pOperator = calloc(1, sizeof(SOperatorInfo));
 
   pOperator->name         = "SLimitOperator";

src/query/src/qFill.c

@@ -430,7 +430,7 @@ void taosFillSetInputDataBlock(SFillInfo* pFillInfo, const SSDataBlock* pInput)
     SColumnInfoData* pColData = taosArrayGet(pInput->pDataBlock, i);
     pFillInfo->pData[i] = pColData->pData;
 
-    if (TSDB_COL_IS_TAG(pCol->flag)/* || IS_VAR_DATA_TYPE(pCol->col.type)*/) {  // copy the tag value to tag value buffer
+    if (TSDB_COL_IS_TAG(pCol->flag)) {  // copy the tag value to tag value buffer
       SFillTagColInfo* pTag = &pFillInfo->pTags[pCol->tagIndex];
       assert (pTag->col.colId == pCol->col.colId);
       memcpy(pTag->tagVal, pColData->pData, pCol->col.bytes);  // TODO not memcpy??

src/util/src/tutil.c

@@ -165,6 +165,8 @@ char *strnchr(char *haystack, char needle, int32_t len, bool skipquote) {
   return NULL;
 }
 
+
+
 char* strtolower(char *dst, const char *src) {
   int esc = 0;
   char quote = 0, *p = dst, c;

tests/pytest/util/dnodes.py

@@ -123,7 +123,7 @@ class TDDnode:
             "charset":"UTF-8",
             "asyncLog":"0",
             "anyIp":"0",
-            "tsEnableTelemetryReporting":"0",
+            "telemetryReporting":"0",
             "dDebugFlag":"135",
             "tsdbDebugFlag":"135",
             "mDebugFlag":"135",

tests/script/general/parser/columnValue_float.sim

@@ -150,13 +150,13 @@ if $data00 != 0.00150 then
   print expect 0.00150, actual: $data00
   return -1
 endi
-sql create table st_float_15_0 using mt_float tags (3.40282347e+38)
-sql select tagname from  st_float_15_0
+#sql create table st_float_15_0 using mt_float tags (3.40282347e+38)
+#sql select tagname from  st_float_15_0
 #if $data00 != 0.001500 then
 #  return -1
 #endi
-sql create table st_float_16_0 using mt_float tags (-3.40282347e+38)
-sql select tagname from  st_float_16_0
+#sql create table st_float_16_0 using mt_float tags (-3.40282347e+38)
+#sql select tagname from  st_float_16_0
 #if $data00 != 0.001500 then
 #  return -1
 #endi