From ac9ae238ab5506ce7a16b6bee071ef7f1883d8bc Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Wed, 28 Apr 2021 16:41:19 +0800
Subject: [PATCH 001/128] [td-225]fix the bug found by regression test.

---
 src/client/inc/tscLocalMerge.h  |  34 +--
 src/client/src/tscLocalMerge.c  | 414 ++++++++------------------------
 src/client/src/tscServer.c      |   5 +
 src/client/src/tscSubquery.c    |  36 +--
 src/client/src/tscUtil.c        |   5 +-
 src/vnode/src/vnodeRead.c       |   2 +-
 tests/examples/c/CMakeLists.txt |   2 +
 7 files changed, 142 insertions(+), 356 deletions(-)

diff --git a/src/client/inc/tscLocalMerge.h b/src/client/inc/tscLocalMerge.h
index 143922bb1f..3c0bde0000 100644
--- a/src/client/inc/tscLocalMerge.h
+++ b/src/client/inc/tscLocalMerge.h
@@ -39,39 +39,29 @@ typedef struct SLocalDataSource {
 } SLocalDataSource;
 
 typedef struct SLocalMerger {
-  SLocalDataSource **    pLocalDataSrc;
+  SLocalDataSource     **pLocalDataSrc;
   int32_t                numOfBuffer;
   int32_t                numOfCompleted;
   int32_t                numOfVnode;
-  SLoserTreeInfo *       pLoserTree;
-  tFilePage *            pResultBuf;
-  int32_t                nResultBufSize;
-  tFilePage *            pTempBuffer;
-  struct SQLFunctionCtx *pCtx;
-  int32_t                rowSize;      // size of each intermediate result.
-  tOrderDescriptor *     pDesc;
-  SColumnModel *         resColModel;
-  SColumnModel*          finalModel;
-  tExtMemBuffer **       pExtMemBuffer;      // disk-based buffer
-  bool                   orderPrjOnSTable;   // projection query on stable
+  SLoserTreeInfo        *pLoserTree;
+  int32_t                rowSize;          // size of each intermediate result.
+  tOrderDescriptor      *pDesc;
+  tExtMemBuffer        **pExtMemBuffer;    // disk-based buffer
+  char                  *buf;              // temp buffer
 } SLocalMerger;
 
 typedef struct SRetrieveSupport {
   tExtMemBuffer **  pExtMemBuffer;     // for build loser tree
   tOrderDescriptor *pOrderDescriptor;
-  SColumnModel*     pFinalColModel;    // colModel for final result
-  SColumnModel*     pFFColModel;
   int32_t           subqueryIndex;     // index of current vnode in vnode list
   SSqlObj *         pParentSql;
   tFilePage *       localBuffer;       // temp buffer, there is a buffer for each vnode to
   uint32_t          numOfRetry;        // record the number of retry times
 } SRetrieveSupport;
 
-int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOrderDescriptor **pDesc,
-                                 SColumnModel **pFinalModel, SColumnModel** pFFModel, uint32_t nBufferSize);
+int32_t tscLocalReducerEnvCreate(SQueryInfo* pQueryInfo, tExtMemBuffer ***pMemBuffer, int32_t numOfSub, tOrderDescriptor **pDesc, uint32_t nBufferSize, int64_t id);
 
-void tscLocalReducerEnvDestroy(tExtMemBuffer **pMemBuffer, tOrderDescriptor *pDesc, SColumnModel *pFinalModel, SColumnModel* pFFModel,
-                               int32_t numOfVnodes);
+void tscLocalReducerEnvDestroy(tExtMemBuffer **pMemBuffer, tOrderDescriptor *pDesc, int32_t numOfVnodes);
 
 int32_t saveToBuffer(tExtMemBuffer *pMemoryBuf, tOrderDescriptor *pDesc, tFilePage *pPage, void *data,
                      int32_t numOfRows, int32_t orderType);
@@ -81,12 +71,10 @@ int32_t tscFlushTmpBuffer(tExtMemBuffer *pMemoryBuf, tOrderDescriptor *pDesc, tF
 /*
  * create local reducer to launch the second-stage reduce process at client site
  */
-void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrderDescriptor *pDesc,
-                           SColumnModel *finalModel, SColumnModel *pFFModel, SSqlObj* pSql);
+int32_t tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrderDescriptor *pDesc,
+                          SQueryInfo *pQueryInfo, SLocalMerger **pMerger, int64_t id);
 
-void tscDestroyLocalMerger(SSqlObj *pSql);
-
-//int32_t tscDoLocalMerge(SSqlObj *pSql);
+void tscDestroyLocalMerger(SLocalMerger* pLocalMerger);
 
 #ifdef __cplusplus
 }
diff --git a/src/client/src/tscLocalMerge.c b/src/client/src/tscLocalMerge.c
index e4a3ace6b5..f1e0196d68 100644
--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -14,13 +14,11 @@
  */
 
 #include "tscLocalMerge.h"
-#include "tscSubquery.h"
+//#include "tscSubquery.h"
 #include "os.h"
 #include "texpr.h"
 #include "tlosertree.h"
 #include "tscLog.h"
-#include "tscUtil.h"
-#include "tschemautil.h"
 #include "tsclient.h"
 #include "qUtil.h"
 
@@ -59,77 +57,25 @@ int32_t treeComparator(const void *pLeft, const void *pRight, void *param) {
   }
 }
 
-// todo merge with vnode side function
-void tsCreateSQLFunctionCtx(SQueryInfo* pQueryInfo, SQLFunctionCtx* pCtx, SSchema* pSchema) {
-  size_t size = tscSqlExprNumOfExprs(pQueryInfo);
-  
-  for (int32_t i = 0; i < size; ++i) {
-    SExprInfo *pExpr = tscSqlExprGet(pQueryInfo, i);
-
-    pCtx[i].order = pQueryInfo->order.order;
-    pCtx[i].functionId = pExpr->base.functionId;
-
-    pCtx[i].order = pQueryInfo->order.order;
-    pCtx[i].functionId = pExpr->base.functionId;
-
-    // input data format comes from pModel
-    pCtx[i].inputType = pSchema[i].type;
-    pCtx[i].inputBytes = pSchema[i].bytes;
-
-    pCtx[i].outputBytes = pExpr->base.resBytes;
-    pCtx[i].outputType  = pExpr->base.resType;
-
-    // input buffer hold only one point data
-    pCtx[i].size = 1;
-    pCtx[i].hasNull = true;
-    pCtx[i].currentStage = MERGE_STAGE;
-
-    // for top/bottom function, the output of timestamp is the first column
-    int32_t functionId = pExpr->base.functionId;
-    if (functionId == TSDB_FUNC_TOP || functionId == TSDB_FUNC_BOTTOM || functionId == TSDB_FUNC_DIFF) {
-      pCtx[i].ptsOutputBuf = pCtx[0].pOutput;
-      pCtx[i].param[2].i64 = pQueryInfo->order.order;
-      pCtx[i].param[2].nType  = TSDB_DATA_TYPE_BIGINT;
-      pCtx[i].param[1].i64 = pQueryInfo->order.orderColId;
-      pCtx[i].param[0].i64 = pExpr->base.param[0].i64;  // top/bot parameter
-    } else if (functionId == TSDB_FUNC_APERCT) {
-      pCtx[i].param[0].i64 = pExpr->base.param[0].i64;
-      pCtx[i].param[0].nType  = pExpr->base.param[0].nType;
-    } else if (functionId == TSDB_FUNC_BLKINFO) {
-      pCtx[i].param[0].i64 = pExpr->base.param[0].i64;
-      pCtx[i].param[0].nType = pExpr->base.param[0].nType;
-      pCtx[i].numOfParams = 1;
-    }
-
-    pCtx[i].interBufBytes = pExpr->base.interBytes;
-    pCtx[i].stableQuery = true;
-  }
-}
-
-void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrderDescriptor *pDesc,
-                          SColumnModel *finalmodel, SColumnModel *pFFModel, SSqlObj *pSql) {
-  SSqlCmd* pCmd = &pSql->cmd;
-  SSqlRes* pRes = &pSql->res;
-  
+int32_t tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrderDescriptor *pDesc,
+                             SQueryInfo* pQueryInfo, SLocalMerger **pMerger, int64_t id) {
   if (pMemBuffer == NULL) {
-    tscLocalReducerEnvDestroy(pMemBuffer, pDesc, finalmodel, pFFModel, numOfBuffer);
-    tscError("pMemBuffer:%p is NULL", pMemBuffer);
-    pRes->code = TSDB_CODE_TSC_APP_ERROR;
-    return;
+    tscLocalReducerEnvDestroy(pMemBuffer, pDesc, numOfBuffer);
+    tscError("0x%"PRIx64" %p pMemBuffer is NULL", id, pMemBuffer);
+    return TSDB_CODE_TSC_APP_ERROR;
   }
  
   if (pDesc->pColumnModel == NULL) {
-    tscLocalReducerEnvDestroy(pMemBuffer, pDesc, finalmodel, pFFModel, numOfBuffer);
-    tscError("0x%"PRIx64" no local buffer or intermediate result format model", pSql->self);
-    pRes->code = TSDB_CODE_TSC_APP_ERROR;
-    return;
+    tscLocalReducerEnvDestroy(pMemBuffer, pDesc, numOfBuffer);
+    tscError("0x%"PRIx64" no local buffer or intermediate result format model", id);
+    return  TSDB_CODE_TSC_APP_ERROR;
   }
 
   int32_t numOfFlush = 0;
   for (int32_t i = 0; i < numOfBuffer; ++i) {
     int32_t len = pMemBuffer[i]->fileMeta.flushoutData.nLength;
     if (len == 0) {
-      tscDebug("0x%"PRIx64" no data retrieved from orderOfVnode:%d", pSql->self, i + 1);
+      tscDebug("0x%"PRIx64" no data retrieved from orderOfVnode:%d", id, i + 1);
       continue;
     }
 
@@ -137,41 +83,38 @@ void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrde
   }
 
   if (numOfFlush == 0 || numOfBuffer == 0) {
-    tscLocalReducerEnvDestroy(pMemBuffer, pDesc, finalmodel, pFFModel, numOfBuffer);
-    pCmd->command = TSDB_SQL_RETRIEVE_EMPTY_RESULT; // no result, set the result empty
-    tscDebug("0x%"PRIx64" retrieved no data", pSql->self);
-    return;
+    tscLocalReducerEnvDestroy(pMemBuffer, pDesc, numOfBuffer);
+    tscDebug("0x%"PRIx64" no data to retrieve", id);
+    return TSDB_CODE_SUCCESS;
   }
 
   if (pDesc->pColumnModel->capacity >= pMemBuffer[0]->pageSize) {
-    tscError("0x%"PRIx64" Invalid value of buffer capacity %d and page size %d ", pSql->self, pDesc->pColumnModel->capacity,
+    tscError("0x%"PRIx64" Invalid value of buffer capacity %d and page size %d ", id, pDesc->pColumnModel->capacity,
              pMemBuffer[0]->pageSize);
 
-    tscLocalReducerEnvDestroy(pMemBuffer, pDesc, finalmodel, pFFModel, numOfBuffer);
-    pRes->code = TSDB_CODE_TSC_APP_ERROR;
-    return;
+    tscLocalReducerEnvDestroy(pMemBuffer, pDesc, numOfBuffer);
+    return TSDB_CODE_TSC_APP_ERROR;
   }
 
   size_t size = sizeof(SLocalMerger) + POINTER_BYTES * numOfFlush;
   
-  SLocalMerger *pMerger = (SLocalMerger *) calloc(1, size);
-  if (pMerger == NULL) {
-    tscError("0x%"PRIx64" failed to create local merge structure, out of memory", pSql->self);
+  *pMerger = (SLocalMerger *) calloc(1, size);
+  if ((*pMerger) == NULL) {
+    tscError("0x%"PRIx64" failed to create local merge structure, out of memory", id);
 
-    tscLocalReducerEnvDestroy(pMemBuffer, pDesc, finalmodel, pFFModel, numOfBuffer);
-    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
-    return;
+    tscLocalReducerEnvDestroy(pMemBuffer, pDesc, numOfBuffer);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
-  pMerger->pExtMemBuffer = pMemBuffer;
-  pMerger->pLocalDataSrc = (SLocalDataSource **)&pMerger[1];
-  assert(pMerger->pLocalDataSrc != NULL);
+  (*pMerger)->pExtMemBuffer = pMemBuffer;
+  (*pMerger)->pLocalDataSrc = (SLocalDataSource **)&pMerger[1];
+  assert((*pMerger)->pLocalDataSrc != NULL);
 
-  pMerger->numOfBuffer = numOfFlush;
-  pMerger->numOfVnode = numOfBuffer;
+  (*pMerger)->numOfBuffer = numOfFlush;
+  (*pMerger)->numOfVnode = numOfBuffer;
 
-  pMerger->pDesc = pDesc;
-  tscDebug("0x%"PRIx64" the number of merged leaves is: %d", pSql->self, pMerger->numOfBuffer);
+  (*pMerger)->pDesc = pDesc;
+  tscDebug("0x%"PRIx64" the number of merged leaves is: %d", id, (*pMerger)->numOfBuffer);
 
   int32_t idx = 0;
   for (int32_t i = 0; i < numOfBuffer; ++i) {
@@ -180,13 +123,12 @@ void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrde
     for (int32_t j = 0; j < numOfFlushoutInFile; ++j) {
       SLocalDataSource *ds = (SLocalDataSource *)malloc(sizeof(SLocalDataSource) + pMemBuffer[0]->pageSize);
       if (ds == NULL) {
-        tscError("0x%"PRIx64" failed to create merge structure", pSql->self);
-        pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+        tscError("0x%"PRIx64" failed to create merge structure", id);
         tfree(pMerger);
-        return;
+        return TSDB_CODE_TSC_OUT_OF_MEMORY;
       }
       
-      pMerger->pLocalDataSrc[idx] = ds;
+      (*pMerger)->pLocalDataSrc[idx] = ds;
 
       ds->pMemBuffer = pMemBuffer[i];
       ds->flushoutIdx = j;
@@ -194,7 +136,7 @@ void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrde
       ds->pageId = 0;
       ds->rowIdx = 0;
 
-      tscDebug("0x%"PRIx64" load data from disk into memory, orderOfVnode:%d, total:%d", pSql->self, i + 1, idx + 1);
+      tscDebug("0x%"PRIx64" load data from disk into memory, orderOfVnode:%d, total:%d", id, i + 1, idx + 1);
       tExtMemBufferLoadData(pMemBuffer[i], &(ds->filePage), j, 0);
 #ifdef _DEBUG_VIEW
       printf("load data page into mem for build loser tree: %" PRIu64 " rows\n", ds->filePage.num);
@@ -208,7 +150,7 @@ void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrde
 #endif
       
       if (ds->filePage.num == 0) {  // no data in this flush, the index does not increase
-        tscDebug("0x%"PRIx64" flush data is empty, ignore %d flush record", pSql->self, idx);
+        tscDebug("0x%"PRIx64" flush data is empty, ignore %d flush record", id, idx);
         tfree(ds);
         continue;
       }
@@ -219,92 +161,43 @@ void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrde
   
   // no data actually, no need to merge result.
   if (idx == 0) {
-    tfree(pMerger);
-    return;
+    tscDebug("0x%"PRIx64" retrieved no data", id);
+    tscLocalReducerEnvDestroy(pMemBuffer, pDesc, numOfBuffer);
+    return TSDB_CODE_SUCCESS;
   }
 
-  pMerger->numOfBuffer = idx;
+  (*pMerger)->numOfBuffer = idx;
 
   SCompareParam *param = malloc(sizeof(SCompareParam));
   if (param == NULL) {
-    tfree(pMerger);
-    return;
+    tfree((*pMerger));
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
-  param->pLocalData = pMerger->pLocalDataSrc;
-  param->pDesc = pMerger->pDesc;
-  param->num = pMerger->pLocalDataSrc[0]->pMemBuffer->numOfElemsPerPage;
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  param->pLocalData = (*pMerger)->pLocalDataSrc;
+  param->pDesc = (*pMerger)->pDesc;
+  param->num = (*pMerger)->pLocalDataSrc[0]->pMemBuffer->numOfElemsPerPage;
 
   param->groupOrderType = pQueryInfo->groupbyExpr.orderType;
-  pMerger->orderPrjOnSTable = tscOrderedProjectionQueryOnSTable(pQueryInfo, 0);
 
-  pRes->code = tLoserTreeCreate(&pMerger->pLoserTree, pMerger->numOfBuffer, param, treeComparator);
-  if (pMerger->pLoserTree == NULL || pRes->code != 0) {
+  int32_t code = tLoserTreeCreate(&(*pMerger)->pLoserTree, (*pMerger)->numOfBuffer, param, treeComparator);
+  if ((*pMerger)->pLoserTree == NULL || code != TSDB_CODE_SUCCESS) {
     tfree(param);
-    tfree(pMerger);
-    return;
+    tfree((*pMerger));
+    return code;
   }
 
-  // the input data format follows the old format, but output in a new format.
-  // so, all the input must be parsed as old format
-  pMerger->pCtx = (SQLFunctionCtx *)calloc(tscSqlExprNumOfExprs(pQueryInfo), sizeof(SQLFunctionCtx));
-  pMerger->rowSize = pMemBuffer[0]->nElemSize;
+  (*pMerger)->rowSize = pMemBuffer[0]->nElemSize;
 
-  tscFieldInfoUpdateOffset(pQueryInfo);
+  // todo fixed row size is larger than the minimum page size;
+  assert((*pMerger)->rowSize <= pMemBuffer[0]->pageSize);
 
-  if (pMerger->rowSize > pMemBuffer[0]->pageSize) {
-    assert(false);  // todo fixed row size is larger than the minimum page size;
-  }
-
-  // used to keep the latest input row
-  pMerger->pTempBuffer = (tFilePage *)calloc(1, pMerger->rowSize + sizeof(tFilePage));
-
-  pMerger->nResultBufSize = pMemBuffer[0]->pageSize * 16;
-  pMerger->pResultBuf = (tFilePage *)calloc(1, pMerger->nResultBufSize + sizeof(tFilePage));
-
-  pMerger->resColModel = finalmodel;
-  pMerger->resColModel->capacity = pMerger->nResultBufSize;
-  pMerger->finalModel = pFFModel;
-
-  if (finalmodel->rowSize > 0) {
-    pMerger->resColModel->capacity /= finalmodel->rowSize;
-  }
-
-  assert(finalmodel->rowSize > 0 && finalmodel->rowSize <= pMerger->rowSize);
-
-  if (pMerger->pTempBuffer == NULL || pMerger->pLoserTree == NULL) {
-    tfree(pMerger->pTempBuffer);
-    tfree(pMerger->pLoserTree);
+  if ((*pMerger)->pLoserTree == NULL) {
+    tfree((*pMerger)->pLoserTree);
     tfree(param);
-    tfree(pMerger);
-    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
-    return;
+    tfree((*pMerger));
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
-  
-  pMerger->pTempBuffer->num = 0;
-  tscCreateResPointerInfo(pRes, pQueryInfo);
-
-  SSchema* pschema = calloc(pDesc->pColumnModel->numOfCols, sizeof(SSchema));
-  for(int32_t i = 0; i < pDesc->pColumnModel->numOfCols; ++i) {
-    pschema[i] = pDesc->pColumnModel->pFields[i].field;
-  }
-
-  tsCreateSQLFunctionCtx(pQueryInfo, pMerger->pCtx, pschema);
-//  setCtxInputOutputBuffer(pQueryInfo, pMerger->pCtx, pMerger, pDesc);
-
-  tfree(pschema);
-
-  int32_t maxBufSize = 0;
-  for (int32_t k = 0; k < tscSqlExprNumOfExprs(pQueryInfo); ++k) {
-    SExprInfo *pExpr = tscSqlExprGet(pQueryInfo, k);
-    if (maxBufSize < pExpr->base.resBytes && pExpr->base.functionId == TSDB_FUNC_TAG) {
-      maxBufSize = pExpr->base.resBytes;
-    }
-  }
-
-  // we change the capacity of schema to denote that there is only one row in temp buffer
-  pMerger->pDesc->pColumnModel->capacity = 1;
 
   // restore the limitation value at the last stage
   if (tscOrderedProjectionQueryOnSTable(pQueryInfo, 0)) {
@@ -312,22 +205,10 @@ void tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tOrde
     pQueryInfo->limit.offset = pQueryInfo->prjOffset;
   }
 
-  pRes->pLocalMerger = pMerger;
-  pRes->numOfGroups = 0;
+  // we change the capacity of schema to denote that there is only one row in temp buffer
+  (*pMerger)->pDesc->pColumnModel->capacity = 1;
 
-//  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
-//  STableComInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
-  
-//  TSKEY stime = (pQueryInfo->order.order == TSDB_ORDER_ASC)? pQueryInfo->window.skey : pQueryInfo->window.ekey;
-//  int64_t revisedSTime = taosTimeTruncate(stime, &pQueryInfo->interval, tinfo.precision);
-  
-//  if (pQueryInfo->fillType != TSDB_FILL_NONE) {
-//    SFillColInfo* pFillCol = createFillColInfo(pQueryInfo);
-//    pMerger->pFillInfo =
-//        taosCreateFillInfo(pQueryInfo->order.order, revisedSTime, pQueryInfo->groupbyExpr.numOfGroupCols, 4096,
-//                           (int32_t)pQueryInfo->fieldsInfo.numOfOutput, pQueryInfo->interval.sliding,
-//                           pQueryInfo->interval.slidingUnit, tinfo.precision, pQueryInfo->fillType, pFillCol, pSql);
-//  }
+  return TSDB_CODE_SUCCESS;
 }
 
 static int32_t tscFlushTmpBufferImpl(tExtMemBuffer *pMemoryBuf, tOrderDescriptor *pDesc, tFilePage *pPage,
@@ -418,44 +299,29 @@ int32_t saveToBuffer(tExtMemBuffer *pMemoryBuf, tOrderDescriptor *pDesc, tFilePa
   return 0;
 }
 
-void tscDestroyLocalMerger(SSqlObj *pSql) {
-  if (pSql == NULL) {
+void tscDestroyLocalMerger(SLocalMerger* pLocalMerger) {
+  if (pLocalMerger == NULL) {
     return;
   }
 
-  SSqlRes *pRes = &(pSql->res);
-  if (pRes->pLocalMerger == NULL) {
-    return;
+  if (pLocalMerger->pLoserTree) {
+    tfree(pLocalMerger->pLoserTree->param);
+    tfree(pLocalMerger->pLoserTree);
   }
 
-  // there is no more result, so we release all allocated resource
-  SLocalMerger *pLocalMerge = (SLocalMerger *)atomic_exchange_ptr(&pRes->pLocalMerger, NULL);
-  tfree(pLocalMerge->pResultBuf);
-  tfree(pLocalMerge->pCtx);
-
-  if (pLocalMerge->pLoserTree) {
-    tfree(pLocalMerge->pLoserTree->param);
-    tfree(pLocalMerge->pLoserTree);
+  tscLocalReducerEnvDestroy(pLocalMerger->pExtMemBuffer, pLocalMerger->pDesc, pLocalMerger->numOfVnode);
+  for (int32_t i = 0; i < pLocalMerger->numOfBuffer; ++i) {
+    tfree(pLocalMerger->pLocalDataSrc[i]);
   }
 
-  tscLocalReducerEnvDestroy(pLocalMerge->pExtMemBuffer, pLocalMerge->pDesc, pLocalMerge->resColModel,
-                            pLocalMerge->finalModel, pLocalMerge->numOfVnode);
-  for (int32_t i = 0; i < pLocalMerge->numOfBuffer; ++i) {
-    tfree(pLocalMerge->pLocalDataSrc[i]);
-  }
-
-  pLocalMerge->numOfBuffer = 0;
-  pLocalMerge->numOfCompleted = 0;
-  tfree(pLocalMerge->pTempBuffer);
-
-  free(pLocalMerge);
-
-  tscDebug("0x%"PRIx64" free local reducer finished", pSql->self);
+  pLocalMerger->numOfBuffer = 0;
+  pLocalMerger->numOfCompleted = 0;
+  tfree(pLocalMerger->buf);
+  free(pLocalMerger);
 }
 
-static int32_t createOrderDescriptor(tOrderDescriptor **pOrderDesc, SSqlCmd *pCmd, SColumnModel *pModel) {
-  int32_t     numOfGroupByCols = 0;
-  SQueryInfo *pQueryInfo = tscGetActiveQueryInfo(pCmd);
+static int32_t createOrderDescriptor(tOrderDescriptor **pOrderDesc, SQueryInfo* pQueryInfo, SColumnModel *pModel) {
+  int32_t numOfGroupByCols = 0;
 
   if (pQueryInfo->groupbyExpr.numOfGroupCols > 0) {
     numOfGroupByCols = pQueryInfo->groupbyExpr.numOfGroupCols;
@@ -525,32 +391,25 @@ static int32_t createOrderDescriptor(tOrderDescriptor **pOrderDesc, SSqlCmd *pCm
   }
 }
 
-int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOrderDescriptor **pOrderDesc,
-                                 SColumnModel **pFinalModel, SColumnModel** pFFModel, uint32_t nBufferSizes) {
-  SSqlCmd *pCmd = &pSql->cmd;
-  SSqlRes *pRes = &pSql->res;
-
-  SSchema *     pSchema = NULL;
+int32_t tscLocalReducerEnvCreate(SQueryInfo *pQueryInfo, tExtMemBuffer ***pMemBuffer, int32_t numOfSub,
+                                 tOrderDescriptor **pOrderDesc, uint32_t nBufferSizes, int64_t id) {
+  SSchema      *pSchema = NULL;
   SColumnModel *pModel = NULL;
-  *pFinalModel = NULL;
 
-  SQueryInfo *    pQueryInfo = tscGetActiveQueryInfo(pCmd);
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
-  (*pMemBuffer) = (tExtMemBuffer **)malloc(POINTER_BYTES * pSql->subState.numOfSub);
+  (*pMemBuffer) = (tExtMemBuffer **)malloc(POINTER_BYTES * numOfSub);
   if (*pMemBuffer == NULL) {
-    tscError("0x%"PRIx64" failed to allocate memory", pSql->self);
-    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
-    return pRes->code;
+    tscError("0x%"PRIx64" failed to allocate memory", id);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
   
   size_t size = tscSqlExprNumOfExprs(pQueryInfo);
   
   pSchema = (SSchema *)calloc(1, sizeof(SSchema) * size);
   if (pSchema == NULL) {
-    tscError("0x%"PRIx64" failed to allocate memory", pSql->self);
-    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
-    return pRes->code;
+    tscError("0x%"PRIx64" failed to allocate memory", id);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
   int32_t rlen = 0;
@@ -570,6 +429,7 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr
   }
   
   pModel = createColumnModel(pSchema, (int32_t)size, capacity);
+  tfree(pSchema);
 
   int32_t pg = DEFAULT_PAGE_SIZE;
   int32_t overhead = sizeof(tFilePage);
@@ -577,95 +437,26 @@ int32_t tscLocalReducerEnvCreate(SSqlObj *pSql, tExtMemBuffer ***pMemBuffer, tOr
     pg *= 2;
   }
 
-  size_t numOfSubs = pSql->subState.numOfSub;
-  assert(numOfSubs <= pTableMetaInfo->vgroupList->numOfVgroups);
-  for (int32_t i = 0; i < numOfSubs; ++i) {
+  assert(numOfSub <= pTableMetaInfo->vgroupList->numOfVgroups);
+  for (int32_t i = 0; i < numOfSub; ++i) {
     (*pMemBuffer)[i] = createExtMemBuffer(nBufferSizes, rlen, pg, pModel);
     (*pMemBuffer)[i]->flushModel = MULTIPLE_APPEND_MODEL;
   }
 
-  if (createOrderDescriptor(pOrderDesc, pCmd, pModel) != TSDB_CODE_SUCCESS) {
-    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
-    tfree(pSchema);
-    return pRes->code;
+  if (createOrderDescriptor(pOrderDesc, pQueryInfo, pModel) != TSDB_CODE_SUCCESS) {
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
-  // final result depends on the fields number
-  memset(pSchema, 0, sizeof(SSchema) * size);
-
-  for (int32_t i = 0; i < size; ++i) {
-    SExprInfo *pExpr = tscSqlExprGet(pQueryInfo, i);
-
-    SSchema p1 = {0};
-    if (pExpr->base.colInfo.colIndex == TSDB_TBNAME_COLUMN_INDEX) {
-      p1 = *tGetTbnameColumnSchema();
-    } else if (TSDB_COL_IS_UD_COL(pExpr->base.colInfo.flag)) {
-      p1.bytes = pExpr->base.resBytes;
-      p1.type  = (uint8_t) pExpr->base.resType;
-      tstrncpy(p1.name, pExpr->base.aliasName, tListLen(p1.name));
-    } else {
-      p1 = *tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, pExpr->base.colInfo.colIndex);
-    }
-
-    int32_t inter = 0;
-    int16_t type = -1;
-    int16_t bytes = 0;
-
-    // the final result size and type in the same as query on single table.
-    // so here, set the flag to be false;
-    int32_t functionId = pExpr->base.functionId;
-    if (functionId >= TSDB_FUNC_TS && functionId <= TSDB_FUNC_DIFF) {
-      type = pModel->pFields[i].field.type;
-      bytes = pModel->pFields[i].field.bytes;
-    } else {
-      if (functionId == TSDB_FUNC_FIRST_DST) {
-        functionId = TSDB_FUNC_FIRST;
-      } else if (functionId == TSDB_FUNC_LAST_DST) {
-        functionId = TSDB_FUNC_LAST;
-      } else if (functionId == TSDB_FUNC_STDDEV_DST) {
-        functionId = TSDB_FUNC_STDDEV;
-      }
-
-      int32_t ret = getResultDataInfo(p1.type, p1.bytes, functionId, 0, &type, &bytes, &inter, 0, false);
-      assert(ret == TSDB_CODE_SUCCESS);
-    }
-
-    pSchema[i].type = (uint8_t)type;
-    pSchema[i].bytes = bytes;
-    strcpy(pSchema[i].name, pModel->pFields[i].field.name);
-  }
-  
-  *pFinalModel = createColumnModel(pSchema, (int32_t)size, capacity);
-
-  memset(pSchema, 0, sizeof(SSchema) * size);
-  size = tscNumOfFields(pQueryInfo);
-
-  for(int32_t i = 0; i < size; ++i) {
-    SInternalField* pField = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, i);
-    pSchema[i].bytes = pField->field.bytes;
-    pSchema[i].type = pField->field.type;
-    tstrncpy(pSchema[i].name, pField->field.name, tListLen(pSchema[i].name));
-  }
-
-  *pFFModel = createColumnModel(pSchema, (int32_t) size, capacity);
-
-   tfree(pSchema);
   return TSDB_CODE_SUCCESS;
 }
 
 /**
  * @param pMemBuffer
  * @param pDesc
- * @param pFinalModel
  * @param numOfVnodes
  */
-void tscLocalReducerEnvDestroy(tExtMemBuffer **pMemBuffer, tOrderDescriptor *pDesc, SColumnModel *pFinalModel, SColumnModel *pFFModel,
-                               int32_t numOfVnodes) {
-  destroyColumnModel(pFinalModel);
-  destroyColumnModel(pFFModel);
-
+void tscLocalReducerEnvDestroy(tExtMemBuffer **pMemBuffer, tOrderDescriptor *pDesc, int32_t numOfVnodes) {
   tOrderDescDestroy(pDesc);
-
   for (int32_t i = 0; i < numOfVnodes; ++i) {
     pMemBuffer[i] = destoryExtMemBuffer(pMemBuffer[i]);
   }
@@ -877,10 +668,12 @@ static bool isAllSourcesCompleted(SLocalMerger *pLocalMerge) {
   return (pLocalMerge->numOfBuffer == pLocalMerge->numOfCompleted);
 }
 
-void tscInitResObjForLocalQuery(SSqlObj *pObj, int32_t numOfRes, int32_t rowLen) {
-  SSqlRes *pRes = &pObj->res;
+void tscInitResObjForLocalQuery(SSqlObj *pSql, int32_t numOfRes, int32_t rowLen) {
+  SSqlRes *pRes = &pSql->res;
   if (pRes->pLocalMerger != NULL) {
-    tscDestroyLocalMerger(pObj);
+    tscDestroyLocalMerger(pRes->pLocalMerger);
+    pRes->pLocalMerger = NULL;
+    tscDebug("0x%"PRIx64" free local reducer finished", pSql->self);
   }
 
   pRes->qId = 1;  // hack to pass the safety check in fetch_row function
@@ -891,14 +684,12 @@ void tscInitResObjForLocalQuery(SSqlObj *pObj, int32_t numOfRes, int32_t rowLen)
   pRes->pLocalMerger = (SLocalMerger *)calloc(1, sizeof(SLocalMerger));
 
   /*
-   * we need one additional byte space
-   * the sprintf function needs one additional space to put '\0' at the end of string
+   * One more byte space is required, since the sprintf function needs one additional space to put '\0' at
+   * the end of string
    */
-  size_t allocSize = numOfRes * rowLen + sizeof(tFilePage) + 1;
-  pRes->pLocalMerger->pResultBuf = (tFilePage *)calloc(1, allocSize);
-
-  pRes->pLocalMerger->pResultBuf->num = numOfRes;
-  pRes->data = pRes->pLocalMerger->pResultBuf->data;
+  size_t size = numOfRes * rowLen + 1;
+  pRes->pLocalMerger->buf = calloc(1, size);
+  pRes->data = pRes->pLocalMerger->buf;
 }
 
 int32_t doArithmeticCalculate(SQueryInfo* pQueryInfo, tFilePage* pOutput, int32_t rowSize, int32_t finalRowSize) {
@@ -944,8 +735,8 @@ int32_t doArithmeticCalculate(SQueryInfo* pQueryInfo, tFilePage* pOutput, int32_
   return offset;
 }
 
-#define COLMODEL_GET_VAL(data, schema, allrow, rowId, colId) \
-  (data + (schema)->pFields[colId].offset * (allrow) + (rowId) * (schema)->pFields[colId].field.bytes)
+#define COLMODEL_GET_VAL(data, schema, rowId, colId) \
+  (data + (schema)->pFields[colId].offset * ((schema)->capacity) + (rowId) * (schema)->pFields[colId].field.bytes)
 
 static void appendOneRowToDataBlock(SSDataBlock *pBlock, char *buf, SColumnModel *pModel, int32_t rowIndex,
                                     int32_t maxRows) {
@@ -953,7 +744,7 @@ static void appendOneRowToDataBlock(SSDataBlock *pBlock, char *buf, SColumnModel
     SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, i);
     char* p = pColInfo->pData + pBlock->info.rows * pColInfo->info.bytes;
 
-    char *src = COLMODEL_GET_VAL(buf, pModel, maxRows, rowIndex, i);
+    char *src = COLMODEL_GET_VAL(buf, pModel, rowIndex, i);
     memmove(p, src, pColInfo->info.bytes);
   }
 
@@ -970,8 +761,6 @@ SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup) {
 
   SLocalMerger   *pMerger = pInfo->pMerge;
   SLoserTreeInfo *pTree   = pMerger->pLoserTree;
-  SColumnModel   *pModel  = pMerger->pDesc->pColumnModel;
-  tFilePage      *tmpBuffer = pMerger->pTempBuffer;
 
   pInfo->binfo.pRes->info.rows = 0;
 
@@ -984,7 +773,7 @@ SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup) {
     printf("chosen data in pTree[0] = %d\n", pTree->pNode[0].index);
 #endif
 
-    assert((pTree->pNode[0].index < pMerger->numOfBuffer) && (pTree->pNode[0].index >= 0) && tmpBuffer->num == 0);
+    assert((pTree->pNode[0].index < pMerger->numOfBuffer) && (pTree->pNode[0].index >= 0));
 
     // chosen from loser tree
     SLocalDataSource *pOneDataSrc = pMerger->pLocalDataSrc[pTree->pNode[0].index];
@@ -998,7 +787,7 @@ SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup) {
         SColumnInfoData *pColInfo = taosArrayGet(pInfo->binfo.pRes->pDataBlock, pIndex->colIndex);
 
         char *newRow =
-            COLMODEL_GET_VAL(pOneDataSrc->filePage.data, pModel, pOneDataSrc->pMemBuffer->pColumnModel->capacity,
+            COLMODEL_GET_VAL(pOneDataSrc->filePage.data, pOneDataSrc->pMemBuffer->pColumnModel,
                              pOneDataSrc->rowIdx, pIndex->colIndex);
 
         char *  data = pInfo->prevRow[i];
@@ -1021,7 +810,7 @@ SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup) {
         SColumnInfoData *pColInfo = taosArrayGet(pInfo->binfo.pRes->pDataBlock, pIndex->colIndex);
 
         char *curCol =
-            COLMODEL_GET_VAL(pOneDataSrc->filePage.data, pModel, pOneDataSrc->pMemBuffer->pColumnModel->capacity,
+            COLMODEL_GET_VAL(pOneDataSrc->filePage.data, pOneDataSrc->pMemBuffer->pColumnModel,
                              pOneDataSrc->rowIdx, pIndex->colIndex);
         memcpy(pInfo->prevRow[i], curCol, pColInfo->info.bytes);
       }
@@ -1033,7 +822,8 @@ SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup) {
       return pInfo->binfo.pRes;
     }
 
-    appendOneRowToDataBlock(pInfo->binfo.pRes, pOneDataSrc->filePage.data, pModel, pOneDataSrc->rowIdx, pOneDataSrc->pMemBuffer->pColumnModel->capacity);
+    appendOneRowToDataBlock(pInfo->binfo.pRes, pOneDataSrc->filePage.data, pOneDataSrc->pMemBuffer->pColumnModel,
+        pOneDataSrc->rowIdx, pOneDataSrc->pMemBuffer->pColumnModel->capacity);
 
 #if defined(_DEBUG_VIEW)
     printf("chosen row:\t");
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 9528a553b2..215c96784e 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -1615,6 +1615,11 @@ int tscProcessRetrieveLocalMergeRsp(SSqlObj *pSql) {
     return code;
   }
 
+  if (pRes->pLocalMerger == NULL) { // no result from subquery, so abort here directly.
+    (*pSql->fp)(pSql->param, pSql, pRes->numOfRows);
+    return code;
+  }
+
   // global aggregation may be the upstream for parent query
   SQueryInfo *pQueryInfo = tscGetActiveQueryInfo(pCmd);
   if (pQueryInfo->pQInfo == NULL) {
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index 67eea432e6..5e78901d6f 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -2422,8 +2422,6 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
   
   tExtMemBuffer   **pMemoryBuf = NULL;
   tOrderDescriptor *pDesc  = NULL;
-  SColumnModel     *pModel = NULL;
-  SColumnModel     *pFinalModel = NULL;
 
   pRes->qId = 0x1;  // hack the qhandle check
   
@@ -2442,9 +2440,9 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
 
   assert(pState->numOfSub > 0);
   
-  int32_t ret = tscLocalReducerEnvCreate(pSql, &pMemoryBuf, &pDesc, &pModel, &pFinalModel, nBufferSize);
+  int32_t ret = tscLocalReducerEnvCreate(pQueryInfo, &pMemoryBuf, pSql->subState.numOfSub, &pDesc, nBufferSize, pSql->self);
   if (ret != 0) {
-    pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    pRes->code = ret;
     tscAsyncResultOnError(pSql);
     tfree(pMemoryBuf);
     return ret;
@@ -2455,7 +2453,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
   if (pSql->pSubs == NULL) {
     tfree(pSql->pSubs);
     pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
-    tscLocalReducerEnvDestroy(pMemoryBuf, pDesc, pModel, pFinalModel,pState->numOfSub);
+    tscLocalReducerEnvDestroy(pMemoryBuf, pDesc,pState->numOfSub);
 
     tscAsyncResultOnError(pSql);
     return ret;
@@ -2498,8 +2496,6 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
     
     trs->subqueryIndex  = i;
     trs->pParentSql     = pSql;
-    trs->pFinalColModel = pModel;
-    trs->pFFColModel    = pFinalModel;
 
     SSqlObj *pNew = tscCreateSTableSubquery(pSql, trs, NULL);
     if (pNew == NULL) {
@@ -2524,13 +2520,13 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
     tscError("0x%"PRIx64" failed to prepare subquery structure and launch subqueries", pSql->self);
     pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
     
-    tscLocalReducerEnvDestroy(pMemoryBuf, pDesc, pModel, pFinalModel, pState->numOfSub);
+    tscLocalReducerEnvDestroy(pMemoryBuf, pDesc, pState->numOfSub);
     doCleanupSubqueries(pSql, i);
     return pRes->code;   // free all allocated resource
   }
   
   if (pRes->code == TSDB_CODE_TSC_QUERY_CANCELLED) {
-    tscLocalReducerEnvDestroy(pMemoryBuf, pDesc, pModel, pFinalModel, pState->numOfSub);
+    tscLocalReducerEnvDestroy(pMemoryBuf, pDesc, pState->numOfSub);
     doCleanupSubqueries(pSql, i);
     return pRes->code;
   }
@@ -2695,7 +2691,7 @@ void tscHandleSubqueryError(SRetrieveSupport *trsupport, SSqlObj *pSql, int numO
       tstrerror(pParentSql->res.code));
 
   // release allocated resource
-  tscLocalReducerEnvDestroy(trsupport->pExtMemBuffer, trsupport->pOrderDescriptor, trsupport->pFinalColModel, trsupport->pFFColModel,
+  tscLocalReducerEnvDestroy(trsupport->pExtMemBuffer, trsupport->pOrderDescriptor,
                             pState->numOfSub);
   
   tscFreeRetrieveSup(pSql);
@@ -2770,19 +2766,25 @@ static void tscAllDataRetrievedFromDnode(SRetrieveSupport *trsupport, SSqlObj* p
   SQueryInfo *pPQueryInfo = tscGetQueryInfo(&pParentSql->cmd, 0);
   tscClearInterpInfo(pPQueryInfo);
   
-  tscCreateLocalMerger(trsupport->pExtMemBuffer, pState->numOfSub, pDesc, trsupport->pFinalColModel, trsupport->pFFColModel, pParentSql);
+  code = tscCreateLocalMerger(trsupport->pExtMemBuffer, pState->numOfSub, pDesc, pPQueryInfo, &pParentSql->res.pLocalMerger, pParentSql->self);
+  pParentSql->res.code = code;
+
+  if (code == TSDB_CODE_SUCCESS && trsupport->pExtMemBuffer == NULL) {
+    pParentSql->cmd.command = TSDB_SQL_RETRIEVE_EMPTY_RESULT; // no result, set the result empty
+  } else {
+    pParentSql->cmd.command = TSDB_SQL_RETRIEVE_LOCALMERGE;
+  }
+
+  tscCreateResPointerInfo(&pParentSql->res, pPQueryInfo);
+
   tscDebug("0x%"PRIx64" build loser tree completed", pParentSql->self);
   
   pParentSql->res.precision = pSql->res.precision;
   pParentSql->res.numOfRows = 0;
   pParentSql->res.row = 0;
-  
-  tscFreeRetrieveSup(pSql);
+  pParentSql->res.numOfGroups = 0;
 
-  // set the command flag must be after the semaphore been correctly set.
-  if (pParentSql->cmd.command != TSDB_SQL_RETRIEVE_EMPTY_RESULT) {
-    pParentSql->cmd.command = TSDB_SQL_RETRIEVE_LOCALMERGE;
-  }
+  tscFreeRetrieveSup(pSql);
 
   if (pParentSql->res.code == TSDB_CODE_SUCCESS) {
     (*pParentSql->fp)(pParentSql->param, pParentSql, 0);
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 420b78f64d..95acce3d77 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -828,11 +828,10 @@ void tscResetSqlCmd(SSqlCmd* pCmd, bool removeMeta) {
 }
 
 void tscFreeSqlResult(SSqlObj* pSql) {
-  tscDestroyLocalMerger(pSql);
-  
   SSqlRes* pRes = &pSql->res;
-  tscDestroyResPointerInfo(pRes);
+  tscDestroyLocalMerger(pRes->pLocalMerger);
 
+  tscDestroyResPointerInfo(pRes);
   memset(&pSql->res, 0, sizeof(SSqlRes));
 }
 
diff --git a/src/vnode/src/vnodeRead.c b/src/vnode/src/vnodeRead.c
index b28bdbf130..d7d3da66d0 100644
--- a/src/vnode/src/vnodeRead.c
+++ b/src/vnode/src/vnodeRead.c
@@ -354,7 +354,7 @@ static int32_t vnodeProcessFetchMsg(SVnodeObj *pVnode, SVReadMsg *pRead) {
 
   // kill current query and free corresponding resources.
   if (pRetrieve->free == 1) {
-    vWarn("vgId:%d, QInfo:%"PRIu64 "-%p, retrieve msg received to kill query and free qhandle", pVnode->vgId, pRetrieve->qId, *handle);
+    vWarn("vgId:%d, QInfo:%"PRIx64 "-%p, retrieve msg received to kill query and free qhandle", pVnode->vgId, pRetrieve->qId, *handle);
     qKillQuery(*handle);
     qReleaseQInfo(pVnode->qMgmt, (void **)&handle, true);
 
diff --git a/tests/examples/c/CMakeLists.txt b/tests/examples/c/CMakeLists.txt
index 954fe468b1..7f941b8c87 100644
--- a/tests/examples/c/CMakeLists.txt
+++ b/tests/examples/c/CMakeLists.txt
@@ -5,6 +5,8 @@ IF (TD_LINUX)
   AUX_SOURCE_DIRECTORY(. SRC)
   ADD_EXECUTABLE(demo apitest.c)
   TARGET_LINK_LIBRARIES(demo taos_static trpc tutil pthread )
+  ADD_EXECUTABLE(subscribe subscribe.c)
+  TARGET_LINK_LIBRARIES(subscribe taos_static trpc tutil pthread )
   ADD_EXECUTABLE(epoll epoll.c)
   TARGET_LINK_LIBRARIES(epoll taos_static trpc tutil pthread )
 ENDIF ()

From 006d59bfd79e1a82f0ae70fbc710a5335b0fcdce Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Thu, 29 Apr 2021 15:05:54 +0800
Subject: [PATCH 002/128] [td-3299]

---
 src/client/inc/tscUtil.h       |   1 +
 src/client/inc/tsclient.h      |   6 ++
 src/client/src/tscLocalMerge.c |  36 ++++----
 src/client/src/tscSubquery.c   |  18 +---
 src/client/src/tscUtil.c       |   3 +-
 src/query/src/qPlan.c          | 145 ++++++++++++++++++++++++++++-----
 6 files changed, 152 insertions(+), 57 deletions(-)

diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index 9220754330..68f55c9912 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -200,6 +200,7 @@ SColumn* tscColumnClone(const SColumn* src);
 bool tscColumnExists(SArray* pColumnList, int32_t columnIndex, uint64_t uid);
 SColumn* tscColumnListInsert(SArray* pColumnList, int32_t columnIndex, uint64_t uid, SSchema* pSchema);
 void tscColumnListDestroy(SArray* pColList);
+void tscColumnListCopy(SArray* dst, const SArray* src, uint64_t tableUid);
 
 void convertQueryResult(SSqlRes* pRes, SQueryInfo* pQueryInfo);
 
diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index ec3b0c4421..749a896bfd 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -238,6 +238,12 @@ typedef struct SQueryInfo {
   SArray            *pUpstream;   // SArray<struct SQueryInfo>
   struct SQueryInfo *pDownstream;
   int32_t            havingFieldNum;
+  bool               stableQuery;
+  bool               groupbyColumn;
+  bool               simpleAgg;
+  bool               arithmeticOnAgg;
+  bool               projectionQuery;
+  bool               hasFilter;
 } SQueryInfo;
 
 typedef struct {
diff --git a/src/client/src/tscLocalMerge.c b/src/client/src/tscLocalMerge.c
index f1e0196d68..f192d6d1f0 100644
--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -14,7 +14,7 @@
  */
 
 #include "tscLocalMerge.h"
-//#include "tscSubquery.h"
+#include "tscSubquery.h"
 #include "os.h"
 #include "texpr.h"
 #include "tlosertree.h"
@@ -96,9 +96,7 @@ int32_t tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tO
     return TSDB_CODE_TSC_APP_ERROR;
   }
 
-  size_t size = sizeof(SLocalMerger) + POINTER_BYTES * numOfFlush;
-  
-  *pMerger = (SLocalMerger *) calloc(1, size);
+  *pMerger = (SLocalMerger *) calloc(1, sizeof(SLocalMerger));
   if ((*pMerger) == NULL) {
     tscError("0x%"PRIx64" failed to create local merge structure, out of memory", id);
 
@@ -107,7 +105,7 @@ int32_t tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tO
   }
 
   (*pMerger)->pExtMemBuffer = pMemBuffer;
-  (*pMerger)->pLocalDataSrc = (SLocalDataSource **)&pMerger[1];
+  (*pMerger)->pLocalDataSrc = calloc(numOfFlush, POINTER_BYTES);
   assert((*pMerger)->pLocalDataSrc != NULL);
 
   (*pMerger)->numOfBuffer = numOfFlush;
@@ -304,19 +302,22 @@ void tscDestroyLocalMerger(SLocalMerger* pLocalMerger) {
     return;
   }
 
-  if (pLocalMerger->pLoserTree) {
-    tfree(pLocalMerger->pLoserTree->param);
-    tfree(pLocalMerger->pLoserTree);
-  }
-
-  tscLocalReducerEnvDestroy(pLocalMerger->pExtMemBuffer, pLocalMerger->pDesc, pLocalMerger->numOfVnode);
   for (int32_t i = 0; i < pLocalMerger->numOfBuffer; ++i) {
     tfree(pLocalMerger->pLocalDataSrc[i]);
   }
 
   pLocalMerger->numOfBuffer = 0;
+  tscLocalReducerEnvDestroy(pLocalMerger->pExtMemBuffer, pLocalMerger->pDesc, pLocalMerger->numOfVnode);
+
   pLocalMerger->numOfCompleted = 0;
+
+  if (pLocalMerger->pLoserTree) {
+    tfree(pLocalMerger->pLoserTree->param);
+    tfree(pLocalMerger->pLoserTree);
+  }
+
   tfree(pLocalMerger->buf);
+  tfree(pLocalMerger->pLocalDataSrc);
   free(pLocalMerger);
 }
 
@@ -786,11 +787,10 @@ SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup) {
         SColIndex *      pIndex = taosArrayGet(pInfo->orderColumnList, i);
         SColumnInfoData *pColInfo = taosArrayGet(pInfo->binfo.pRes->pDataBlock, pIndex->colIndex);
 
-        char *newRow =
-            COLMODEL_GET_VAL(pOneDataSrc->filePage.data, pOneDataSrc->pMemBuffer->pColumnModel,
-                             pOneDataSrc->rowIdx, pIndex->colIndex);
+        char *newRow = COLMODEL_GET_VAL(pOneDataSrc->filePage.data, pOneDataSrc->pMemBuffer->pColumnModel,
+                                        pOneDataSrc->rowIdx, pIndex->colIndex);
 
-        char *  data = pInfo->prevRow[i];
+        char   *data = pInfo->prevRow[i];
         int32_t ret = columnValueAscendingComparator(data, newRow, pColInfo->info.type, pColInfo->info.bytes);
         if (ret == 0) {
           continue;
@@ -809,9 +809,8 @@ SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup) {
         SColIndex *      pIndex = taosArrayGet(pInfo->orderColumnList, i);
         SColumnInfoData *pColInfo = taosArrayGet(pInfo->binfo.pRes->pDataBlock, pIndex->colIndex);
 
-        char *curCol =
-            COLMODEL_GET_VAL(pOneDataSrc->filePage.data, pOneDataSrc->pMemBuffer->pColumnModel,
-                             pOneDataSrc->rowIdx, pIndex->colIndex);
+        char *curCol = COLMODEL_GET_VAL(pOneDataSrc->filePage.data, pOneDataSrc->pMemBuffer->pColumnModel,
+                                        pOneDataSrc->rowIdx, pIndex->colIndex);
         memcpy(pInfo->prevRow[i], curCol, pColInfo->info.bytes);
       }
 
@@ -956,7 +955,6 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
     if (pInfoData->info.type == TSDB_DATA_TYPE_TIMESTAMP && pRes->info.rows > 0) {
       STimeWindow* w = &pRes->info.window;
 
-      // TODO in case of desc order, swap it
       w->skey = *(int64_t*)pInfoData->pData;
       w->ekey = *(int64_t*)(((char*)pInfoData->pData) + TSDB_KEYSIZE * (pRes->info.rows - 1));
 
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index 5e78901d6f..8e5d26337d 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -65,15 +65,11 @@ static void skipRemainValue(STSBuf* pTSBuf, tVariant* tag1) {
 }
 
 static void subquerySetState(SSqlObj *pSql, SSubqueryState *subState, int idx, int8_t state) {
-  assert(idx < subState->numOfSub);
-  assert(subState->states);
+  assert(idx < subState->numOfSub && subState->states != NULL);
+  tscDebug("subquery:0x%"PRIx64",%d state set to %d", pSql->self, idx, state);
 
   pthread_mutex_lock(&subState->mutex);
-  
-  tscDebug("subquery:0x%"PRIx64",%d state set to %d", pSql->self, idx, state);
-  
   subState->states[idx] = state;
-
   pthread_mutex_unlock(&subState->mutex);
 }
 
@@ -110,13 +106,9 @@ static bool subAndCheckDone(SSqlObj *pSql, SSqlObj *pParentSql, int idx) {
   pthread_mutex_lock(&subState->mutex);
 
   bool done = allSubqueryDone(pParentSql);
-
   if (done) {
-    tscDebug("0x%"PRIx64" subquery:0x%"PRIx64",%d all subs already done", pParentSql->self,
-        pSql->self, idx);
-    
+    tscDebug("0x%"PRIx64" subquery:0x%"PRIx64",%d all subs already done", pParentSql->self, pSql->self, idx);
     pthread_mutex_unlock(&subState->mutex);
-    
     return false;
   }
   
@@ -125,9 +117,7 @@ static bool subAndCheckDone(SSqlObj *pSql, SSqlObj *pParentSql, int idx) {
   subState->states[idx] = 1;
 
   done = allSubqueryDone(pParentSql);
-
   pthread_mutex_unlock(&subState->mutex);
-
   return done;
 }
 
@@ -701,8 +691,6 @@ void freeJoinSubqueryObj(SSqlObj* pSql) {
   }
   
   tfree(pSql->subState.states);
-  
-  
   pSql->subState.numOfSub = 0;
 }
 
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 95acce3d77..7e30e92b9c 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -829,7 +829,9 @@ void tscResetSqlCmd(SSqlCmd* pCmd, bool removeMeta) {
 
 void tscFreeSqlResult(SSqlObj* pSql) {
   SSqlRes* pRes = &pSql->res;
+
   tscDestroyLocalMerger(pRes->pLocalMerger);
+  pRes->pLocalMerger = NULL;
 
   tscDestroyResPointerInfo(pRes);
   memset(&pSql->res, 0, sizeof(SSqlRes));
@@ -853,7 +855,6 @@ void tscFreeSubobj(SSqlObj* pSql) {
   }
 
   tfree(pSql->subState.states);
-
   pSql->subState.numOfSub = 0;
 }
 
diff --git a/src/query/src/qPlan.c b/src/query/src/qPlan.c
index 0554a887ec..89a3e07b10 100644
--- a/src/query/src/qPlan.c
+++ b/src/query/src/qPlan.c
@@ -1,37 +1,138 @@
+#include <tscUtil.h>
 #include "os.h"
-#include "tsclient.h"
 #include "qUtil.h"
 #include "texpr.h"
+#include "tsclient.h"
 
-#define QNODE_PROJECT    1
-#define QNODE_FILTER     2
-#define QNODE_RELATION   3
-#define QNODE_AGGREGATE  4
-#define QNODE_GROUPBY    5
-#define QNODE_LIMIT      6
-#define QNODE_JOIN       7
-#define QNODE_DIST       8
-#define QNODE_SORT       9
-#define QNODE_UNIONALL   10
-#define QNODE_TIMEWINDOW 11
+#define QNODE_PROJECT       1
+#define QNODE_FILTER        2
+#define QNODE_TABLESCAN     3
+#define QNODE_AGGREGATE     4
+#define QNODE_GROUPBY       5
+#define QNODE_LIMIT         6
+#define QNODE_JOIN          7
+#define QNODE_DISTINCT      8
+#define QNODE_SORT          9
+#define QNODE_UNIONALL      10
+#define QNODE_TIMEWINDOW    11
+#define QNODE_SESSIONWINDOW 12
+#define QNODE_FILL          13
+
+typedef struct SQueryNodeBasicInfo {
+  int32_t type;
+  char   *name;
+} SQueryNodeBasicInfo;
 
 typedef struct SQueryNode {
-  int32_t    type;         // the type of logic node
-  char      *name;         // the name of logic node
+  SQueryNodeBasicInfo info;
+//  char              *name;         // the name of logic node
+//  int32_t            type;         // the type of logic node
 
-  SSchema   *pSchema;      // the schema of the input SSDatablock
-  int32_t    numOfCols;    // number of input columns
-  SExprInfo *pExpr;        // the query functions or sql aggregations
-  int32_t    numOfOutput;  // number of result columns, which is also the number of pExprs
+  SSchema           *pSchema;      // the schema of the input SSDatablock
+  int32_t            numOfCols;    // number of input columns
+  SExprInfo         *pExpr;        // the query functions or sql aggregations
+  int32_t            numOfOutput;  // number of result columns, which is also the number of pExprs
 
   // previous operator to generated result for current node to process
   // in case of join, multiple prev nodes exist.
-  struct SQueryNode* prevNode;
-  struct SQueryNode* nextNode;
+  SArray            *pPrevNodes;// upstream nodes
+  struct SQueryNode *nextNode;
 } SQueryNode;
 
-// TODO create the query plan
-SQueryNode* qCreateQueryPlan(SQueryInfo* pQueryInfo) {
+static SQueryNode* createQueryNode(int32_t type, const char* name, SQueryNode** prev, int32_t numOfPrev) {
+  SQueryNode* pNode = calloc(1, sizeof(SQueryNode));
+  pNode->info.type = type;
+  pNode->info.name = strdup(name);
+  pNode->pPrevNodes = taosArrayInit(4, POINTER_BYTES);
+  for(int32_t i = 0; i < numOfPrev; ++i) {
+    taosArrayPush(pNode->pPrevNodes, &prev[i]);
+  }
+
+  return pNode;
+}
+
+static SQueryNode* doCreateQueryPlanForOneTable(SQueryInfo* pQueryInfo) {
+  SQueryNode* pNode = createQueryNode(QNODE_TABLESCAN, "", NULL, 0);
+
+  // check for filter
+  if (pQueryInfo->hasFilter) {
+    pNode = createQueryNode(QNODE_FILTER, "", &pNode, 1);
+  }
+
+  if (pQueryInfo->distinctTag) {
+    pNode = createQueryNode(QNODE_DISTINCT, "", &pNode, 0);
+
+  } else if (pQueryInfo->projectionQuery) {
+    pNode = createQueryNode(QNODE_PROJECT, "", &pNode, 1);
+  } else {  // check for aggregation
+    if (pQueryInfo->interval.interval > 0) {
+      pNode = createQueryNode(QNODE_TIMEWINDOW, "", &pNode, 1);
+    } else if (pQueryInfo->groupbyColumn) {
+      pNode = createQueryNode(QNODE_GROUPBY, "", &pNode, 1);
+    } else if (pQueryInfo->sessionWindow.gap > 0) {
+      pNode = createQueryNode(QNODE_SESSIONWINDOW, "", &pNode, 1);
+    } else if (pQueryInfo->simpleAgg) {
+      pNode = createQueryNode(QNODE_AGGREGATE, "", &pNode, 1);
+    }
+
+    if (pQueryInfo->havingFieldNum > 0) {
+      pNode = createQueryNode(QNODE_FILTER, "", &pNode, 1);
+    }
+
+    if (pQueryInfo->arithmeticOnAgg) {
+      pNode = createQueryNode(QNODE_PROJECT, "", &pNode, 1);
+    }
+
+    if (pQueryInfo->fillType != TSDB_FILL_NONE) {
+      pNode = createQueryNode(QNODE_FILL, "", &pNode, 1);
+    }
+  }
+
+  if (pQueryInfo->limit.limit != -1 || pQueryInfo->limit.offset != 0) {
+    pNode = createQueryNode(QNODE_LIMIT, "", &pNode, 1);
+  }
+
+  return pNode;
+}
+
+SArray* qCreateQueryPlan(SQueryInfo* pQueryInfo) {
+  // join and subquery
+  SArray* upstream = NULL;
+  if (pQueryInfo->pUpstream != NULL) {  // subquery in the from clause
+    upstream = taosArrayInit(4, POINTER_BYTES);
+
+    size_t size = taosArrayGetSize(pQueryInfo->pUpstream);
+    for(int32_t i = 0; i < size; ++i) {
+      SQueryInfo* pq = taosArrayGet(pQueryInfo->pUpstream, i);
+      SArray* p = qCreateQueryPlan(pq);
+      taosArrayPushBatch(upstream, p->pData, (int32_t) taosArrayGetSize(p));
+    }
+  }
+
+  if (pQueryInfo->numOfTables > 1) {  // it is a join query
+    // 1. separate the select clause according to table
+    int32_t tableIndex = 0;
+    STableMetaInfo* pTableMetaInfo = pQueryInfo->pTableMetaInfo[tableIndex];
+    uint64_t uid = pTableMetaInfo->pTableMeta->id.uid;
+
+    SArray* exprList = taosArrayInit(4, POINTER_BYTES);
+    if (tscSqlExprCopy(exprList, pQueryInfo->exprList, uid, true) != 0) {
+      terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
+      exit(-1);
+    }
+
+    SArray* tableColumnList = taosArrayInit(4, sizeof(SColumn));
+    tscColumnListCopy(tableColumnList, pQueryInfo->colList, uid);
+
+
+    // 2.
+    SQueryNode* pNode = doCreateQueryPlanForOneTable(pQueryInfo);
+    UNUSED(pNode);
+  } else {  // only one table, normal query process
+    SQueryNode* pNode = doCreateQueryPlanForOneTable(pQueryInfo);
+    UNUSED(pNode);
+  }
+
   return NULL;
 }
 

From 6216f6c519a93adbb3183f8e17e2bcc2aa0dd1d9 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Fri, 30 Apr 2021 16:38:37 +0800
Subject: [PATCH 003/128] [td-225] fix bug found by regression test.

---
 src/query/src/qExecutor.c                             | 11 ++++++++---
 .../script/general/parser/binary_escapeCharacter.sim  |  1 +
 tests/script/general/parser/testSuite.sim             |  3 ++-
 3 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 818e7c6b03..feaa205c3e 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -4466,13 +4466,18 @@ SArray* getOrderCheckColumns(SQueryAttr* pQuery) {
     for(int32_t i = 0; i < numOfCols; ++i) {
       SColIndex* index = taosArrayGet(pOrderColumns, i);
       for(int32_t j = 0; j < pQuery->numOfOutput; ++j) {
-        if (index->colId == pQuery->pExpr1[j].base.colInfo.colId) {
+        SSqlExpr* pExpr = &pQuery->pExpr1[j].base;
+        int32_t functionId = pExpr->functionId;
+
+        if (index->colId == pExpr->colInfo.colId &&
+            (functionId == TSDB_FUNC_PRJ || functionId == TSDB_FUNC_TAG || functionId == TSDB_FUNC_TS)) {
           index->colIndex = j;
-          index->colId = pQuery->pExpr1[j].base.resColId;
+          index->colId = pExpr->resColId;
         }
       }
     }
   }
+
   return pOrderColumns;
 }
 
@@ -4804,7 +4809,7 @@ static SSDataBlock* doArithmeticOperation(void* param, bool* newgroup) {
     }
 
     // Return result of the previous group in the firstly.
-    if (newgroup && pRes->info.rows > 0) {
+    if (*newgroup && pRes->info.rows > 0) {
       pArithInfo->existDataBlock = pBlock;
       clearNumOfRes(pInfo->pCtx, pOperator->numOfOutput);
       return pInfo->pRes;
diff --git a/tests/script/general/parser/binary_escapeCharacter.sim b/tests/script/general/parser/binary_escapeCharacter.sim
index f0589d154f..d3a0d3ea64 100644
--- a/tests/script/general/parser/binary_escapeCharacter.sim
+++ b/tests/script/general/parser/binary_escapeCharacter.sim
@@ -1,3 +1,4 @@
+
 system sh/stop_dnodes.sh
 
 system sh/deploy.sh -n dnode1 -i 1
diff --git a/tests/script/general/parser/testSuite.sim b/tests/script/general/parser/testSuite.sim
index 62af4818e5..8e764f9670 100644
--- a/tests/script/general/parser/testSuite.sim
+++ b/tests/script/general/parser/testSuite.sim
@@ -55,4 +55,5 @@ run general/parser/sliding.sim
 run general/parser/function.sim
 run general/parser/stableOp.sim
 run general/parser/having.sim
-run general/parser/having_child.sim
\ No newline at end of file
+run general/parser/having_child.sim
+run general/parser/binary_escapeCharacter.sim

From c18dd031fd5e770692c10d1db308c16e30a97d0f Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Thu, 6 May 2021 10:09:10 +0800
Subject: [PATCH 004/128] [td-3299]

---
 src/client/inc/tscUtil.h        |  39 ++-
 src/client/inc/tsclient.h       |  10 +-
 src/client/src/tscAsync.c       |  15 +-
 src/client/src/tscLocal.c       |  12 +-
 src/client/src/tscLocalMerge.c  |  16 +-
 src/client/src/tscParseInsert.c |   3 +-
 src/client/src/tscPrepare.c     |   1 -
 src/client/src/tscSQLParser.c   | 357 +++++++++++-----------
 src/client/src/tscServer.c      |  28 +-
 src/client/src/tscStream.c      |   2 +-
 src/client/src/tscSubquery.c    |  57 ++--
 src/client/src/tscUtil.c        | 345 +++++++++++++---------
 src/common/inc/tname.h          |   4 +-
 src/common/src/tarithoperator.c |   1 +
 src/common/src/texpr.c          |  35 ++-
 src/query/inc/qExecutor.h       |  14 +-
 src/query/inc/qFill.h           |   2 +-
 src/query/inc/qPlan.h           |  33 ++-
 src/query/inc/qUtil.h           |   2 +
 src/query/src/qAggMain.c        |   2 +-
 src/query/src/qExecutor.c       |  12 +-
 src/query/src/qPlan.c           | 508 +++++++++++++++++++++++++++-----
 22 files changed, 999 insertions(+), 499 deletions(-)

diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index 68f55c9912..777656d2e1 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -59,7 +59,7 @@ typedef struct SJoinSupporter {
   SArray*         exprList;
   SFieldInfo      fieldsInfo;
   STagCond        tagCond;
-  SSqlGroupbyExpr groupInfo;       // group by info
+  SGroupbyExpr groupInfo;       // group by info
   struct STSBuf*  pTSBuf;          // the TSBuf struct that holds the compressed timestamp array
   FILE*           f;               // temporary file in order to create TSBuf
   char            path[PATH_MAX];  // temporary file path, todo dynamic allocate memory
@@ -92,11 +92,11 @@ typedef struct SVgroupTableInfo {
 
 static FORCE_INLINE SQueryInfo* tscGetQueryInfo(SSqlCmd* pCmd, int32_t subClauseIndex) {
   assert(pCmd != NULL && subClauseIndex >= 0);
-  if (pCmd->pQueryInfo == NULL || subClauseIndex >= pCmd->numOfClause) {
+  if (pCmd->pQueryInfo == NULL) {
     return NULL;
   }
 
-  return pCmd->pQueryInfo[subClauseIndex];
+  return pCmd->active;
 }
 
 SQueryInfo* tscGetActiveQueryInfo(SSqlCmd* pCmd);
@@ -127,7 +127,7 @@ int32_t tscGetDataBlockFromList(SHashObj* pHashList, int64_t id, int32_t size, i
  */
 bool tscIsPointInterpQuery(SQueryInfo* pQueryInfo);
 bool tscIsTWAQuery(SQueryInfo* pQueryInfo);
-bool tscIsSecondStageQuery(SQueryInfo* pQueryInfo);
+bool tsIsArithmeticQueryOnAggResult(SQueryInfo* pQueryInfo);
 bool tscGroupbyColumn(SQueryInfo* pQueryInfo);
 bool tscIsTopBotQuery(SQueryInfo* pQueryInfo);
 bool hasTagValOutput(SQueryInfo* pQueryInfo);
@@ -136,13 +136,14 @@ bool isStabledev(SQueryInfo* pQueryInfo);
 bool isTsCompQuery(SQueryInfo* pQueryInfo);
 bool isSimpleAggregate(SQueryInfo* pQueryInfo);
 bool isBlockDistQuery(SQueryInfo* pQueryInfo);
-int32_t tscGetTopbotQueryParam(SQueryInfo* pQueryInfo);
+bool isSimpleAggregateRv(SQueryInfo* pQueryInfo);
 
 bool tscNonOrderedProjectionQueryOnSTable(SQueryInfo *pQueryInfo, int32_t tableIndex);
 bool tscOrderedProjectionQueryOnSTable(SQueryInfo* pQueryInfo, int32_t tableIndex);
 bool tscIsProjectionQueryOnSTable(SQueryInfo* pQueryInfo, int32_t tableIndex);
 
 bool tscIsProjectionQuery(SQueryInfo* pQueryInfo);
+bool tscHasColumnFilter(SQueryInfo* pQueryInfo);
 
 bool tscIsTwoStageSTableQuery(SQueryInfo* pQueryInfo, int32_t tableIndex);
 bool tscQueryTags(SQueryInfo* pQueryInfo);
@@ -175,26 +176,32 @@ void    tscFieldInfoClear(SFieldInfo* pFieldInfo);
 static FORCE_INLINE int32_t tscNumOfFields(SQueryInfo* pQueryInfo) { return pQueryInfo->fieldsInfo.numOfOutput; }
 
 int32_t tscFieldInfoCompare(const SFieldInfo* pFieldInfo1, const SFieldInfo* pFieldInfo2);
+void tscInsertPrimaryTsSourceColumn(SQueryInfo* pQueryInfo, uint64_t uid);
 
-void addExprParams(SSqlExpr* pExpr, char* argument, int32_t type, int32_t bytes);
 
 int32_t   tscGetResRowLength(SArray* pExprList);
 
-SExprInfo* tscSqlExprInsert(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
+SExprInfo* tscExprInsert(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
     int16_t size, int16_t resColId, int16_t interSize, bool isTagCol);
 
-SExprInfo* tscSqlExprAppend(SQueryInfo* pQueryInfo, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
+SExprInfo* tscExprCreate(SQueryInfo* pQueryInfo, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
+                         int16_t size, int16_t resColId, int16_t interSize, int32_t colType);
+
+void tscExprAddParams(SSqlExpr* pExpr, char* argument, int32_t type, int32_t bytes);
+
+SExprInfo* tscExprAppend(SQueryInfo* pQueryInfo, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
                            int16_t size, int16_t resColId, int16_t interSize, bool isTagCol);
 
-SExprInfo* tscSqlExprUpdate(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, int16_t srcColumnIndex, int16_t type,
+SExprInfo* tscExprUpdate(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, int16_t srcColumnIndex, int16_t type,
                            int16_t size);
-size_t   tscSqlExprNumOfExprs(SQueryInfo* pQueryInfo);
-void tscInsertPrimaryTsSourceColumn(SQueryInfo* pQueryInfo, uint64_t uid);
 
-SExprInfo* tscSqlExprGet(SQueryInfo* pQueryInfo, int32_t index);
-int32_t   tscSqlExprCopy(SArray* dst, const SArray* src, uint64_t uid, bool deepcopy);
-void      tscSqlExprAssign(SExprInfo* dst, const SExprInfo* src);
-void      tscSqlExprInfoDestroy(SArray* pExprInfo);
+size_t     tscNumOfExprs(SQueryInfo* pQueryInfo);
+SExprInfo *tscExprGet(SQueryInfo* pQueryInfo, int32_t index);
+int32_t    tscExprCopy(SArray* dst, const SArray* src, uint64_t uid, bool deepcopy);
+void       tscExprAssign(SExprInfo* dst, const SExprInfo* src);
+void       tscExprDestroy(SArray* pExprInfo);
+
+int32_t createProjectionExpr(SQueryInfo* pQueryInfo, STableMetaInfo* pTableMetaInfo, SExprInfo*** pExpr, int32_t* num);
 
 SColumn* tscColumnClone(const SColumn* src);
 bool tscColumnExists(SArray* pColumnList, int32_t columnIndex, uint64_t uid);
@@ -243,7 +250,7 @@ SArray* tscVgroupTableInfoDup(SArray* pVgroupTables);
 void tscRemoveVgroupTableGroup(SArray* pVgroupTable, int32_t index);
 void tscVgroupTableCopy(SVgroupTableInfo* info, SVgroupTableInfo* pInfo);
 
-int  tscGetSTableVgroupInfo(SSqlObj* pSql, int32_t clauseIndex);
+int  tscGetSTableVgroupInfo(SSqlObj* pSql, SQueryInfo* pQueryInfo);
 int  tscGetTableMeta(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo);
 int  tscGetTableMetaEx(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, bool createIfNotExists);
 
diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index 749a896bfd..a8ab715edf 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -203,10 +203,11 @@ typedef struct SQueryInfo {
   SInterval        interval;      // tumble time window
   SSessionWindow   sessionWindow; // session time window
 
-  SSqlGroupbyExpr  groupbyExpr;   // groupby tags info
+  SGroupbyExpr  groupbyExpr;   // groupby tags info
   SArray *         colList;       // SArray<SColumn*>
   SFieldInfo       fieldsInfo;
   SArray *         exprList;      // SArray<SExprInfo*>
+  SArray *         exprList1;     // final exprlist in case of arithmetic expression exists
   SLimitVal        limit;
   SLimitVal        slimit;
   STagCond         tagCond;
@@ -230,8 +231,6 @@ typedef struct SQueryInfo {
   int32_t          bufLen;
   char*            buf;
   SQInfo*          pQInfo;      // global merge operator
-  SArray*          pDSOperator;    // data source operator
-  SArray*          pPhyOperator;   // physical query execution plan
   SQueryAttr*      pQueryAttr;     // query object
 
   struct SQueryInfo *sibling;     // sibling
@@ -244,6 +243,7 @@ typedef struct SQueryInfo {
   bool               arithmeticOnAgg;
   bool               projectionQuery;
   bool               hasFilter;
+  bool               onlyTagQuery;
 } SQueryInfo;
 
 typedef struct {
@@ -268,8 +268,8 @@ typedef struct {
   char *       payload;
   int32_t      payloadLen;
 
-  SQueryInfo **pQueryInfo;
-  int32_t      numOfClause;
+  SQueryInfo  *pQueryInfo;
+//  int32_t      numOfClause;
   int32_t      clauseIndex;  // index of multiple subclause query
   SQueryInfo  *active;       // current active query info
 
diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c
index 09b31e4b19..aa570faa06 100644
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -127,7 +127,8 @@ static void tscAsyncFetchRowsProxy(void *param, TAOS_RES *tres, int numOfRows) {
        * all available virtual node has been checked already, now we need to check
        * for the next subclause queries
        */
-      if (pCmd->clauseIndex < pCmd->numOfClause - 1) {
+      if (pCmd->active->sibling != NULL) {
+        pCmd->active = pCmd->active->sibling;
         tscTryQueryNextClause(pSql, tscAsyncQueryRowsForNextVnode);
         return;
       }
@@ -231,7 +232,8 @@ void taos_fetch_rows_a(TAOS_RES *tres, __async_cb_func_t fp, void *param) {
          * all available virtual nodes in current clause has been checked already, now try the
          * next one in the following union subclause
          */
-        if (pCmd->clauseIndex < pCmd->numOfClause - 1) {
+        if (pCmd->active->sibling != NULL) {
+          pCmd->active = pCmd->active->sibling;  // todo refactor
           tscTryQueryNextClause(pSql, tscAsyncQueryRowsForNextVnode);
           return;
         }
@@ -317,13 +319,13 @@ static int32_t updateMetaBeforeRetryQuery(SSqlObj* pSql, STableMetaInfo* pTableM
   // update the pExpr info, colList info, number of table columns
   // TODO Re-parse this sql and issue the corresponding subquery as an alternative for this case.
   if (pSql->retryReason == TSDB_CODE_TDB_INVALID_TABLE_ID) {
-    int32_t numOfExprs = (int32_t) tscSqlExprNumOfExprs(pQueryInfo);
+    int32_t numOfExprs = (int32_t) tscNumOfExprs(pQueryInfo);
     int32_t numOfCols = tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
     int32_t numOfTags = tscGetNumOfTags(pTableMetaInfo->pTableMeta);
 
     SSchema *pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
     for (int32_t i = 0; i < numOfExprs; ++i) {
-      SSqlExpr *pExpr = &(tscSqlExprGet(pQueryInfo, i)->base);
+      SSqlExpr *pExpr = &(tscExprGet(pQueryInfo, i)->base);
       pExpr->uid = pTableMetaInfo->pTableMeta->id.uid;
 
       if (pExpr->colInfo.colIndex >= 0) {
@@ -474,7 +476,8 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
     }
 
   } else {  // stream computing
-    STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+    SQueryInfo* pQueryInfo = tscGetActiveQueryInfo(pCmd);
+    STableMetaInfo *pTableMetaInfo = pQueryInfo->pTableMetaInfo[0];
 
     code = tscGetTableMeta(pSql, pTableMetaInfo);
     if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
@@ -485,7 +488,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
     }
 
     if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
-      code = tscGetSTableVgroupInfo(pSql, pCmd->clauseIndex);
+      code = tscGetSTableVgroupInfo(pSql, pQueryInfo);
       if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
         taosReleaseRef(tscObjRef, pSql->self);
         return;
diff --git a/src/client/src/tscLocal.c b/src/client/src/tscLocal.c
index a7882ffa61..6a4dd79300 100644
--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
@@ -161,7 +161,7 @@ static int32_t tscBuildTableSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
   tstrncpy(f.name, "Field", sizeof(f.name));
   
   SInternalField* pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY,
+  pInfo->pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY,
       (TSDB_COL_NAME_LEN - 1) + VARSTR_HEADER_SIZE, -1000, (TSDB_COL_NAME_LEN - 1), false);
   
   rowLen += ((TSDB_COL_NAME_LEN - 1) + VARSTR_HEADER_SIZE);
@@ -171,7 +171,7 @@ static int32_t tscBuildTableSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
   tstrncpy(f.name, "Type", sizeof(f.name));
   
   pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, (int16_t)(typeColLength + VARSTR_HEADER_SIZE),
+  pInfo->pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, (int16_t)(typeColLength + VARSTR_HEADER_SIZE),
       -1000, typeColLength, false);
   
   rowLen += typeColLength + VARSTR_HEADER_SIZE;
@@ -181,7 +181,7 @@ static int32_t tscBuildTableSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
   tstrncpy(f.name, "Length", sizeof(f.name));
   
   pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_INT, sizeof(int32_t),
+  pInfo->pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_INT, sizeof(int32_t),
       -1000, sizeof(int32_t), false);
   
   rowLen += sizeof(int32_t);
@@ -191,7 +191,7 @@ static int32_t tscBuildTableSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
   tstrncpy(f.name, "Note", sizeof(f.name));
   
   pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, (int16_t)(noteColLength + VARSTR_HEADER_SIZE),
+  pInfo->pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, (int16_t)(noteColLength + VARSTR_HEADER_SIZE),
       -1000, noteColLength, false);
   
   rowLen += noteColLength + VARSTR_HEADER_SIZE;
@@ -404,7 +404,7 @@ static int32_t tscSCreateBuildResultFields(SSqlObj *pSql, BuildType type, const
   } 
 
   SInternalField* pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, f.bytes, -1000, f.bytes - VARSTR_HEADER_SIZE, false);
+  pInfo->pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY, f.bytes, -1000, f.bytes - VARSTR_HEADER_SIZE, false);
 
   rowLen += f.bytes; 
 
@@ -417,7 +417,7 @@ static int32_t tscSCreateBuildResultFields(SSqlObj *pSql, BuildType type, const
   }
 
   pInfo = tscFieldInfoAppend(&pQueryInfo->fieldsInfo, &f);
-  pInfo->pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY,
+  pInfo->pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index, TSDB_DATA_TYPE_BINARY,
       (int16_t)(ddlLen + VARSTR_HEADER_SIZE), -1000, ddlLen, false);
 
   rowLen += ddlLen + VARSTR_HEADER_SIZE;
diff --git a/src/client/src/tscLocalMerge.c b/src/client/src/tscLocalMerge.c
index f192d6d1f0..187352e306 100644
--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -341,13 +341,13 @@ static int32_t createOrderDescriptor(tOrderDescriptor **pOrderDesc, SQueryInfo*
   if (numOfGroupByCols > 0) {
 
     if (pQueryInfo->groupbyExpr.numOfGroupCols > 0) {
-      int32_t numOfInternalOutput = (int32_t) tscSqlExprNumOfExprs(pQueryInfo);
+      int32_t numOfInternalOutput = (int32_t) tscNumOfExprs(pQueryInfo);
 
       // the last "pQueryInfo->groupbyExpr.numOfGroupCols" columns are order-by columns
       for (int32_t i = 0; i < pQueryInfo->groupbyExpr.numOfGroupCols; ++i) {
         SColIndex* pColIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, i);
         for(int32_t j = 0; j < numOfInternalOutput; ++j) {
-          SExprInfo* pExprInfo = tscSqlExprGet(pQueryInfo, j);
+          SExprInfo* pExprInfo = tscExprGet(pQueryInfo, j);
 
           int32_t functionId = pExprInfo->base.functionId;
           if (pColIndex->colId == pExprInfo->base.colInfo.colId && (functionId == TSDB_FUNC_PRJ || functionId == TSDB_FUNC_TAG)) {
@@ -369,9 +369,9 @@ static int32_t createOrderDescriptor(tOrderDescriptor **pOrderDesc, SQueryInfo*
       if (pQueryInfo->interval.interval != 0) {
         orderColIndexList[0] = PRIMARYKEY_TIMESTAMP_COL_INDEX;
       } else {
-        size_t size = tscSqlExprNumOfExprs(pQueryInfo);
+        size_t size = tscNumOfExprs(pQueryInfo);
         for (int32_t i = 0; i < size; ++i) {
-          SExprInfo *pExpr = tscSqlExprGet(pQueryInfo, i);
+          SExprInfo *pExpr = tscExprGet(pQueryInfo, i);
           if (pExpr->base.functionId == TSDB_FUNC_PRJ && pExpr->base.colInfo.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
             orderColIndexList[0] = i;
           }
@@ -405,7 +405,7 @@ int32_t tscLocalReducerEnvCreate(SQueryInfo *pQueryInfo, tExtMemBuffer ***pMemBu
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
   
-  size_t size = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t size = tscNumOfExprs(pQueryInfo);
   
   pSchema = (SSchema *)calloc(1, sizeof(SSchema) * size);
   if (pSchema == NULL) {
@@ -415,7 +415,7 @@ int32_t tscLocalReducerEnvCreate(SQueryInfo *pQueryInfo, tExtMemBuffer ***pMemBu
 
   int32_t rlen = 0;
   for (int32_t i = 0; i < size; ++i) {
-    SExprInfo *pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo *pExpr = tscExprGet(pQueryInfo, i);
 
     pSchema[i].bytes = pExpr->base.resBytes;
     pSchema[i].type = (int8_t)pExpr->base.resType;
@@ -702,12 +702,12 @@ int32_t doArithmeticCalculate(SQueryInfo* pQueryInfo, tFilePage* pOutput, int32_
 
   // todo refactor
   arithSup.offset     = 0;
-  arithSup.numOfCols  = (int32_t) tscSqlExprNumOfExprs(pQueryInfo);
+  arithSup.numOfCols  = (int32_t) tscNumOfExprs(pQueryInfo);
   arithSup.exprList   = pQueryInfo->exprList;
   arithSup.data       = calloc(arithSup.numOfCols, POINTER_BYTES);
 
   for(int32_t k = 0; k < arithSup.numOfCols; ++k) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, k);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, k);
     arithSup.data[k] = (pOutput->data + pOutput->num* pExpr->base.offset);
   }
 
diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index 6b88c90747..7ee5375d23 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -1363,7 +1363,6 @@ static int doPackSendDataBlock(SSqlObj *pSql, int32_t numOfRows, STableDataBlock
   SSqlCmd *pCmd = &pSql->cmd;
   pSql->res.numOfRows = 0;
 
-  assert(pCmd->numOfClause == 1);
   STableMeta *pTableMeta = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0)->pTableMeta;
 
   SSubmitBlk *pBlocks = (SSubmitBlk *)(pTableDataBlocks->pData);
@@ -1527,7 +1526,7 @@ void tscImportDataFromFile(SSqlObj *pSql) {
   }
 
   assert(pCmd->dataSourceType == DATA_FROM_DATA_FILE  && strlen(pCmd->payload) != 0);
-  pCmd->active = pCmd->pQueryInfo[0];
+  pCmd->active = pCmd->pQueryInfo;
 
   SImportFileSupport *pSupporter = calloc(1, sizeof(SImportFileSupport));
   SSqlObj *pNew = createSubqueryObj(pSql, 0, parseFileSendDataBlock, pSupporter, TSDB_SQL_INSERT, NULL);
diff --git a/src/client/src/tscPrepare.c b/src/client/src/tscPrepare.c
index c3c8986e2f..c25263d399 100644
--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -774,7 +774,6 @@ static int insertStmtExecute(STscStmt* stmt) {
     return TSDB_CODE_TSC_INVALID_VALUE;
   }
 
-  assert(pCmd->numOfClause == 1);
   if (taosHashGetSize(pCmd->pTableBlockHashList) == 0) {
     return TSDB_CODE_SUCCESS;
   }
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 87b4669a04..eb27c01ede 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -35,6 +35,7 @@
 #include "tstrbuild.h"
 #include "ttokendef.h"
 #include "qUtil.h"
+#include "qPlan.h"
 
 #define DEFAULT_PRIMARY_TIMESTAMP_COL_NAME "_c0"
 
@@ -70,7 +71,7 @@ static bool validateTagParams(SArray* pTagsList, SArray* pFieldList, SSqlCmd* pC
 
 static int32_t setObjFullName(char* fullName, const char* account, SStrToken* pDB, SStrToken* tableName, int32_t* len);
 
-static void getColumnName(tSqlExprItem* pItem, char* resultFieldName, int32_t nameLength);
+static void getColumnName(tSqlExprItem* pItem, char* resultFieldName, char* rawName, int32_t nameLength);
 
 static int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t colIndex, tSqlExprItem* pItem, bool finalResult);
 static int32_t insertResultField(SQueryInfo* pQueryInfo, int32_t outputIndex, SColumnList* pIdList, int16_t bytes,
@@ -111,7 +112,7 @@ static bool validateOneTags(SSqlCmd* pCmd, TAOS_FIELD* pTagField);
 static bool hasTimestampForPointInterpQuery(SQueryInfo* pQueryInfo);
 static bool hasNormalColumnFilter(SQueryInfo* pQueryInfo);
 
-static int32_t validateLimitNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t index, SSqlNode* pSqlNode, SSqlObj* pSql);
+static int32_t validateLimitNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlNode, SSqlObj* pSql);
 static int32_t parseCreateDBOptions(SSqlCmd* pCmd, SCreateDbInfo* pCreateDbSql);
 static int32_t getColumnIndexByName(SSqlCmd* pCmd, const SStrToken* pToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex);
 static int32_t getTableIndexByName(SStrToken* pToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex);
@@ -126,7 +127,7 @@ static SColumnList createColumnList(int32_t num, int16_t tableIndex, int32_t col
 static int32_t doCheckForCreateTable(SSqlObj* pSql, int32_t subClauseIndex, SSqlInfo* pInfo);
 static int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo);
 static int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo);
-static int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, int32_t index);
+static int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInfo);
 static int32_t exprTreeFromSqlExpr(SSqlCmd* pCmd, tExprNode **pExpr, const tSqlExpr* pSqlExpr, SQueryInfo* pQueryInfo, SArray* pCols, uint64_t *uid);
 static bool    validateDebugFlag(int32_t v);
 static int32_t checkQueryRangeForFill(SSqlCmd* pCmd, SQueryInfo* pQueryInfo);
@@ -618,43 +619,46 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     case TSDB_SQL_SELECT: {
       const char* msg1 = "columns in select clause not identical";
 
-      size_t size = taosArrayGetSize(pInfo->list);
-      for (int32_t i = pCmd->numOfClause; i < size; ++i) {
-        SQueryInfo* p = tscGetQueryInfoS(pCmd, i);
-        if (p == NULL) {
-          pRes->code = terrno;
-          return pRes->code;
-        }
+      SQueryInfo* pCurrent = pCmd->pQueryInfo;
+      for(int32_t i = 0; i < pCmd->clauseIndex; ++i) {
+        pCurrent = pCurrent->sibling;
       }
 
-      assert(pCmd->numOfClause == size);
+      size_t size = taosArrayGetSize(pInfo->list);
       for (int32_t i = pCmd->clauseIndex; i < size; ++i) {
         SSqlNode* pSqlNode = taosArrayGetP(pInfo->list, i);
         tscTrace("%p start to parse %dth subclause, total:%d", pSql, i, (int32_t) size);
-        if ((code = validateSqlNode(pSql, pSqlNode, i)) != TSDB_CODE_SUCCESS) {
+        if ((code = validateSqlNode(pSql, pSqlNode, pCurrent)) != TSDB_CODE_SUCCESS) {
           return code;
         }
 
         tscPrintSelNodeList(pSql, i);
         pCmd->clauseIndex += 1;
+        if (i+1 < size && pCurrent->sibling == NULL) {
+          if ((code = tscAddQueryInfo(pCmd)) != TSDB_CODE_SUCCESS) {
+            return code;
+          }
+
+          pCurrent = pCmd->active;
+        }
       }
 
       // restore the clause index
       pCmd->clauseIndex = 0;
 
       // set the command/global limit parameters from the first subclause to the sqlcmd object
-      SQueryInfo* pQueryInfo1 = tscGetQueryInfo(pCmd, 0);
-      pCmd->command = pQueryInfo1->command;
+      pCmd->active = pCmd->pQueryInfo;
+      pCmd->command = pCmd->pQueryInfo->command;
 
       // if there is only one element, the limit of clause is the limit of global result.
       // validate the select node for "UNION ALL" subclause
-      for (int32_t i = 1; i < pCmd->numOfClause; ++i) {
-        SQueryInfo* pQueryInfo2 = tscGetQueryInfo(pCmd, i);
-
-        int32_t ret = tscFieldInfoCompare(&pQueryInfo1->fieldsInfo, &pQueryInfo2->fieldsInfo);
+      SQueryInfo* pQueryInfo1 = pCmd->pQueryInfo;
+      while(pQueryInfo1->sibling != NULL) {
+        int32_t ret = tscFieldInfoCompare(&pQueryInfo1->fieldsInfo, &pQueryInfo1->sibling->fieldsInfo);
         if (ret != 0) {
           return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
         }
+        pQueryInfo1 = pQueryInfo1->sibling;
       }
 
       pCmd->parseFinished = 1;
@@ -707,10 +711,10 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
  * are available.
  */
 static bool isTopBottomQuery(SQueryInfo* pQueryInfo) {
-  size_t size = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t size = tscNumOfExprs(pQueryInfo);
   
   for (int32_t i = 0; i < size; ++i) {
-    int32_t functionId = tscSqlExprGet(pQueryInfo, i)->base.functionId;
+    int32_t functionId = tscExprGet(pQueryInfo, i)->base.functionId;
 
     if (functionId == TSDB_FUNC_TOP || functionId == TSDB_FUNC_BOTTOM) {
       return true;
@@ -722,7 +726,7 @@ static bool isTopBottomQuery(SQueryInfo* pQueryInfo) {
 
 // need to add timestamp column in result set, if it is a time window query
 static int32_t addPrimaryTsColumnForTimeWindowQuery(SQueryInfo* pQueryInfo) {
-  uint64_t uid = tscSqlExprGet(pQueryInfo, 0)->base.uid;
+  uint64_t uid = tscExprGet(pQueryInfo, 0)->base.uid;
 
   int32_t  tableIndex = COLUMN_INDEX_INITIAL_VAL;
   for (int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
@@ -767,9 +771,9 @@ static int32_t checkInvalidExprForTimeWindow(SSqlCmd* pCmd, SQueryInfo* pQueryIn
    * invalid sql:
    * select count(tbname)/count(tag1)/count(tag2) from super_table_name [interval(1d)|session(ts, 1d)];
    */
-  size_t size = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t size = tscNumOfExprs(pQueryInfo);
   for (int32_t i = 0; i < size; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     if (pExpr->base.functionId == TSDB_FUNC_COUNT && TSDB_COL_IS_TAG(pExpr->base.colInfo.flag)) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
@@ -1193,8 +1197,6 @@ bool validateOneTags(SSqlCmd* pCmd, TAOS_FIELD* pTagField) {
   const char* msg5 = "invalid binary/nchar tag length";
   const char* msg6 = "invalid data type in tags";
 
-  assert(pCmd->numOfClause == 1);
-
   STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
   STableMeta*     pTableMeta = pTableMetaInfo->pTableMeta;
 
@@ -1267,7 +1269,7 @@ bool validateOneColumn(SSqlCmd* pCmd, TAOS_FIELD* pColField) {
   const char* msg5 = "invalid column name";
   const char* msg6 = "invalid column length";
 
-  assert(pCmd->numOfClause == 1);
+//  assert(pCmd->numOfClause == 1);
   STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
   STableMeta*     pTableMeta = pTableMetaInfo->pTableMeta;
   
@@ -1434,7 +1436,7 @@ static int32_t handleArithmeticExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32
     // expr string is set as the parameter of function
     SColumnIndex index = {.tableIndex = tableIndex};
 
-    SExprInfo* pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_ARITHM, &index, TSDB_DATA_TYPE_DOUBLE, sizeof(double),
+    SExprInfo* pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_ARITHM, &index, TSDB_DATA_TYPE_DOUBLE, sizeof(double),
                                        getNewResColId(pQueryInfo), sizeof(double), false);
 
     char* name = (pItem->aliasName != NULL)? pItem->aliasName:pItem->pNode->token.z;
@@ -1477,7 +1479,7 @@ static int32_t handleArithmeticExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32
     char* c = tbufGetData(&bw, false);
 
     // set the serialized binary string as the parameter of arithmetic expression
-    addExprParams(&pExpr->base, c, TSDB_DATA_TYPE_BINARY, (int32_t)len);
+    tscExprAddParams(&pExpr->base, c, TSDB_DATA_TYPE_BINARY, (int32_t)len);
     insertResultField(pQueryInfo, exprIndex, &columnList, sizeof(double), TSDB_DATA_TYPE_DOUBLE, pExpr->base.aliasName, pExpr);
 
     // add ts column
@@ -1490,40 +1492,37 @@ static int32_t handleArithmeticExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32
     columnList.num = 0;
     columnList.ids[0] = (SColumnIndex) {0, 0};
 
+    char rawName[TSDB_COL_NAME_LEN] = {0};
     char aliasName[TSDB_COL_NAME_LEN] = {0};
-    if (pItem->aliasName != NULL) {
-      tstrncpy(aliasName, pItem->aliasName, TSDB_COL_NAME_LEN);
-    } else {
-      int32_t nameLen = MIN(TSDB_COL_NAME_LEN, pItem->pNode->token.n + 1);
-      tstrncpy(aliasName, pItem->pNode->token.z, nameLen);
-    }
+    getColumnName(pItem, aliasName, rawName, TSDB_COL_NAME_LEN);
 
     insertResultField(pQueryInfo, exprIndex, &columnList, sizeof(double), TSDB_DATA_TYPE_DOUBLE, aliasName, NULL);
 
     int32_t slot = tscNumOfFields(pQueryInfo) - 1;
     SInternalField* pInfo = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, slot);
+    assert(pInfo->pExpr == NULL);
 
-    if (pInfo->pExpr == NULL) {
-      SExprInfo* pExprInfo = calloc(1, sizeof(SExprInfo));
+    SExprInfo* pExprInfo = calloc(1, sizeof(SExprInfo));
 
-      // arithmetic expression always return result in the format of double float
-      pExprInfo->base.resBytes   = sizeof(double);
-      pExprInfo->base.interBytes = sizeof(double);
-      pExprInfo->base.resType    = TSDB_DATA_TYPE_DOUBLE;
+    // arithmetic expression always return result in the format of double float
+    pExprInfo->base.resBytes   = sizeof(double);
+    pExprInfo->base.interBytes = sizeof(double);
+    pExprInfo->base.resType    = TSDB_DATA_TYPE_DOUBLE;
 
-      pExprInfo->base.functionId = TSDB_FUNC_ARITHM;
-      pExprInfo->base.numOfParams = 1;
-      pExprInfo->base.resColId = getNewResColId(pQueryInfo);
+    pExprInfo->base.functionId = TSDB_FUNC_ARITHM;
+    pExprInfo->base.numOfParams = 1;
+    pExprInfo->base.resColId = getNewResColId(pQueryInfo);
+    strncpy(pExprInfo->base.aliasName, aliasName, tListLen(pExprInfo->base.aliasName));
+    strncpy(pExprInfo->base.token, rawName, tListLen(pExprInfo->base.token));
 
-      int32_t ret = exprTreeFromSqlExpr(pCmd, &pExprInfo->pExpr, pItem->pNode, pQueryInfo, NULL, &(pExprInfo->base.uid));
-      if (ret != TSDB_CODE_SUCCESS) {
-        tExprTreeDestroy(pExprInfo->pExpr, NULL);
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), "invalid expression in select clause");
-      }
-
-      pInfo->pExpr = pExprInfo;
+    int32_t ret = exprTreeFromSqlExpr(pCmd, &pExprInfo->pExpr, pItem->pNode, pQueryInfo, NULL, &(pExprInfo->base.uid));
+    if (ret != TSDB_CODE_SUCCESS) {
+      tExprTreeDestroy(pExprInfo->pExpr, NULL);
+      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), "invalid expression in select clause");
     }
 
+    pInfo->pExpr = pExprInfo;
+
     SBufferWriter bw = tbufInitWriter(NULL, false);
 
     TRY(0) {
@@ -1570,9 +1569,9 @@ static void addProjectQueryCol(SQueryInfo* pQueryInfo, int32_t startPos, SColumn
 
 static void addPrimaryTsColIntoResult(SQueryInfo* pQueryInfo) {
   // primary timestamp column has been added already
-  size_t size = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t size = tscNumOfExprs(pQueryInfo);
   for (int32_t i = 0; i < size; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     if (pExpr->base.functionId == TSDB_FUNC_PRJ && pExpr->base.colInfo.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
       return;
     }
@@ -1585,7 +1584,7 @@ static void addPrimaryTsColIntoResult(SQueryInfo* pQueryInfo) {
 
   // add the timestamp column into the output columns
   SColumnIndex index = {0};  // primary timestamp column info
-  int32_t numOfCols = (int32_t)tscSqlExprNumOfExprs(pQueryInfo);
+  int32_t numOfCols = (int32_t)tscNumOfExprs(pQueryInfo);
   tscAddFuncInSelectClause(pQueryInfo, numOfCols, TSDB_FUNC_PRJ, &index, pSchema, TSDB_COL_NORMAL);
 
   SInternalField* pSupInfo = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, numOfCols);
@@ -1601,7 +1600,7 @@ bool isValidDistinctSql(SQueryInfo* pQueryInfo) {
   if ((pQueryInfo->type & TSDB_QUERY_TYPE_STABLE_QUERY)  != TSDB_QUERY_TYPE_STABLE_QUERY) {
     return false;
   }
-  if (tscQueryTags(pQueryInfo) && tscSqlExprNumOfExprs(pQueryInfo) == 1){
+  if (tscQueryTags(pQueryInfo) && tscNumOfExprs(pQueryInfo) == 1){
     return true;
   }
   return false;
@@ -1629,7 +1628,7 @@ int32_t validateSelectNodeList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pS
   bool hasDistinct = false;
   size_t numOfExpr = taosArrayGetSize(pSelNodeList);
   for (int32_t i = 0; i < numOfExpr; ++i) {
-    int32_t outputIndex = (int32_t)tscSqlExprNumOfExprs(pQueryInfo);
+    int32_t outputIndex = (int32_t)tscNumOfExprs(pQueryInfo);
     tSqlExprItem* pItem = taosArrayGet(pSelNodeList, i);
      
     if (hasDistinct == false) {
@@ -1728,7 +1727,7 @@ SExprInfo* doAddProjectCol(SQueryInfo* pQueryInfo, int32_t colIndex, int32_t tab
   }
 
   int16_t colId = getNewResColId(pQueryInfo);
-  return tscSqlExprAppend(pQueryInfo, functionId, &index, pSchema->type, pSchema->bytes, colId, pSchema->bytes,
+  return tscExprAppend(pQueryInfo, functionId, &index, pSchema->type, pSchema->bytes, colId, pSchema->bytes,
                           (functionId == TSDB_FUNC_TAGPRJ));
 }
 
@@ -1736,9 +1735,10 @@ SExprInfo* tscAddFuncInSelectClause(SQueryInfo* pQueryInfo, int32_t outputColInd
                                   SColumnIndex* pIndex, SSchema* pColSchema, int16_t flag) {
   int16_t colId = getNewResColId(pQueryInfo);
 
-  SExprInfo* pExpr = tscSqlExprInsert(pQueryInfo, outputColIndex, functionId, pIndex, pColSchema->type,
+  SExprInfo* pExpr = tscExprInsert(pQueryInfo, outputColIndex, functionId, pIndex, pColSchema->type,
                                      pColSchema->bytes, colId, pColSchema->bytes, TSDB_COL_IS_TAG(flag));
   tstrncpy(pExpr->base.aliasName, pColSchema->name, sizeof(pExpr->base.aliasName));
+  tstrncpy(pExpr->base.token, pColSchema->name, sizeof(pExpr->base.token));
 
   SColumnList ids = createColumnList(1, pIndex->tableIndex, pIndex->columnIndex);
   if (TSDB_COL_IS_TAG(flag)) {
@@ -1791,7 +1791,7 @@ int32_t addProjectionExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
   const char* msg0 = "invalid column name";
   const char* msg1 = "tag for normal table query is not allowed";
 
-  int32_t startPos = (int32_t)tscSqlExprNumOfExprs(pQueryInfo);
+  int32_t startPos = (int32_t)tscNumOfExprs(pQueryInfo);
   int32_t optr = pItem->pNode->tokenId;
 
   if (optr == TK_ALL) {  // project on all fields
@@ -1889,7 +1889,7 @@ static int32_t setExprInfoForFunctions(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SS
     bytes = pSchema->bytes;
   }
   
-  SExprInfo* pExpr = tscSqlExprAppend(pQueryInfo, functionID, pColIndex, type, bytes, getNewResColId(pQueryInfo), bytes, false);
+  SExprInfo* pExpr = tscExprAppend(pQueryInfo, functionID, pColIndex, type, bytes, getNewResColId(pQueryInfo), bytes, false);
   tstrncpy(pExpr->base.aliasName, name, tListLen(pExpr->base.aliasName));
 
   if (cvtFunc.originFuncId == TSDB_FUNC_LAST_ROW && cvtFunc.originFuncId != functionID) {
@@ -1943,9 +1943,9 @@ void setResultColName(char* name, tSqlExprItem* pItem, int32_t functionId, SStrT
 
 static void updateLastScanOrderIfNeeded(SQueryInfo* pQueryInfo) {
   if (pQueryInfo->sessionWindow.gap > 0 || tscGroupbyColumn(pQueryInfo)) {
-    size_t numOfExpr = tscSqlExprNumOfExprs(pQueryInfo);
+    size_t numOfExpr = tscNumOfExprs(pQueryInfo);
     for (int32_t i = 0; i < numOfExpr; ++i) {
-      SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+      SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
       if (pExpr->base.functionId != TSDB_FUNC_LAST && pExpr->base.functionId != TSDB_FUNC_LAST_DST) {
         continue;
       }
@@ -1984,14 +1984,14 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
       if (pItem->pNode->pParam != NULL) {
         tSqlExprItem* pParamElem = taosArrayGet(pItem->pNode->pParam, 0);
         SStrToken* pToken = &pParamElem->pNode->colInfo;
-        int16_t sqlOptr = pParamElem->pNode->tokenId;
-        if ((pToken->z == NULL || pToken->n == 0) 
-            && (TK_INTEGER != sqlOptr)) /*select count(1) from table*/ {
+        int16_t tokenId = pParamElem->pNode->tokenId;
+        if ((pToken->z == NULL || pToken->n == 0) && (TK_INTEGER != tokenId)) {
           return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
         }
 
-        if (sqlOptr == TK_ALL) {
-          // select table.*
+        // select count(table.*)
+        // select count(1)|count(2)
+        if (tokenId == TK_ALL || tokenId == TK_INTEGER) {
           // check if the table name is valid or not
           SStrToken tmpToken = pParamElem->pNode->colInfo;
 
@@ -2001,24 +2001,9 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
 
           index = (SColumnIndex){0, PRIMARYKEY_TIMESTAMP_COL_INDEX};
           int32_t size = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes;
-          pExpr = tscSqlExprAppend(pQueryInfo, functionId, &index, TSDB_DATA_TYPE_BIGINT, size, getNewResColId(pQueryInfo), size, false);
-        } else if (sqlOptr == TK_INTEGER) { // select count(1) from table1
-          char buf[8] = {0};  
-          int64_t val = -1;
-          tVariant* pVariant = &pParamElem->pNode->value;
-          if (pVariant->nType == TSDB_DATA_TYPE_BIGINT) {
-            tVariantDump(pVariant, buf, TSDB_DATA_TYPE_BIGINT, true);
-            val = GET_INT64_VAL(buf); 
-          }
-          if (val == 1) {
-            index = (SColumnIndex){0, PRIMARYKEY_TIMESTAMP_COL_INDEX};
-            int32_t size = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes;
-            pExpr = tscSqlExprAppend(pQueryInfo, functionId, &index, TSDB_DATA_TYPE_BIGINT, size, getNewResColId(pQueryInfo), size, false);
-          } else {
-            return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
-          }
+          pExpr = tscExprAppend(pQueryInfo, functionId, &index, TSDB_DATA_TYPE_BIGINT, size, getNewResColId(pQueryInfo), size, false);
         } else {
-          // count the number of meters created according to the super table
+          // count the number of table created according to the super table
           if (getColumnIndexByName(pCmd, pToken, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
             return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
           }
@@ -2033,18 +2018,18 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
           }
 
           int32_t size = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes;
-          pExpr = tscSqlExprAppend(pQueryInfo, functionId, &index, TSDB_DATA_TYPE_BIGINT, size, getNewResColId(pQueryInfo), size, isTag);
+          pExpr = tscExprAppend(pQueryInfo, functionId, &index, TSDB_DATA_TYPE_BIGINT, size, getNewResColId(pQueryInfo), size, isTag);
         }
       } else {  // count(*) is equalled to count(primary_timestamp_key)
         index = (SColumnIndex){0, PRIMARYKEY_TIMESTAMP_COL_INDEX};
         int32_t size = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes;
-        pExpr = tscSqlExprAppend(pQueryInfo, functionId, &index, TSDB_DATA_TYPE_BIGINT, size, getNewResColId(pQueryInfo), size, false);
+        pExpr = tscExprAppend(pQueryInfo, functionId, &index, TSDB_DATA_TYPE_BIGINT, size, getNewResColId(pQueryInfo), size, false);
       }
 
       pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
 
       memset(pExpr->base.aliasName, 0, tListLen(pExpr->base.aliasName));
-      getColumnName(pItem, pExpr->base.aliasName, sizeof(pExpr->base.aliasName) - 1);
+      getColumnName(pItem, pExpr->base.aliasName, pExpr->base.token,sizeof(pExpr->base.aliasName) - 1);
       
       SColumnList list = createColumnList(1, index.tableIndex, index.columnIndex);
       if (finalResult) {
@@ -2123,7 +2108,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
       if (functionId == TSDB_FUNC_DIFF) {
         colIndex += 1;
         SColumnIndex indexTS = {.tableIndex = index.tableIndex, .columnIndex = 0};
-        SExprInfo* pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &indexTS, TSDB_DATA_TYPE_TIMESTAMP, TSDB_KEYSIZE,
+        SExprInfo* pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &indexTS, TSDB_DATA_TYPE_TIMESTAMP, TSDB_KEYSIZE,
                                            getNewResColId(pQueryInfo), TSDB_KEYSIZE, false);
 
         SColumnList ids = createColumnList(1, 0, 0);
@@ -2135,7 +2120,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);
       }
 
-      SExprInfo* pExpr = tscSqlExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, getNewResColId(pQueryInfo), resultSize, false);
+      SExprInfo* pExpr = tscExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, getNewResColId(pQueryInfo), resultSize, false);
 
       if (functionId == TSDB_FUNC_LEASTSQR) {
         /* set the leastsquares parameters */
@@ -2144,20 +2129,20 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
           return TSDB_CODE_TSC_INVALID_SQL;
         }
 
-        addExprParams(&pExpr->base, val, TSDB_DATA_TYPE_DOUBLE, DOUBLE_BYTES);
+        tscExprAddParams(&pExpr->base, val, TSDB_DATA_TYPE_DOUBLE, DOUBLE_BYTES);
 
         memset(val, 0, tListLen(val));
         if (tVariantDump(&pParamElem[2].pNode->value, val, TSDB_DATA_TYPE_DOUBLE, true) < 0) {
           return TSDB_CODE_TSC_INVALID_SQL;
         }
 
-        addExprParams(&pExpr->base, val, TSDB_DATA_TYPE_DOUBLE, sizeof(double));
+        tscExprAddParams(&pExpr->base, val, TSDB_DATA_TYPE_DOUBLE, sizeof(double));
       }
 
       SColumnList ids = createColumnList(1, index.tableIndex, index.columnIndex);
 
       memset(pExpr->base.aliasName, 0, tListLen(pExpr->base.aliasName));
-      getColumnName(pItem, pExpr->base.aliasName, sizeof(pExpr->base.aliasName) - 1);
+      getColumnName(pItem, pExpr->base.aliasName, pExpr->base.token,sizeof(pExpr->base.aliasName) - 1);
 
       if (finalResult) {
         int32_t numOfOutput = tscNumOfFields(pQueryInfo);
@@ -2349,8 +2334,8 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
         tscInsertPrimaryTsSourceColumn(pQueryInfo, pTableMetaInfo->pTableMeta->id.uid);
         colIndex += 1;  // the first column is ts
 
-        pExpr = tscSqlExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, getNewResColId(pQueryInfo), resultSize, false);
-        addExprParams(&pExpr->base, val, TSDB_DATA_TYPE_DOUBLE, sizeof(double));
+        pExpr = tscExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, getNewResColId(pQueryInfo), resultSize, false);
+        tscExprAddParams(&pExpr->base, val, TSDB_DATA_TYPE_DOUBLE, sizeof(double));
       } else {
         tVariantDump(pVariant, val, TSDB_DATA_TYPE_BIGINT, true);
 
@@ -2362,7 +2347,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
         // todo REFACTOR
         // set the first column ts for top/bottom query
         SColumnIndex index1 = {index.tableIndex, PRIMARYKEY_TIMESTAMP_COL_INDEX};
-        pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS, &index1, TSDB_DATA_TYPE_TIMESTAMP, TSDB_KEYSIZE, getNewResColId(pQueryInfo),
+        pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS, &index1, TSDB_DATA_TYPE_TIMESTAMP, TSDB_KEYSIZE, getNewResColId(pQueryInfo),
                                  TSDB_KEYSIZE, false);
         tstrncpy(pExpr->base.aliasName, aAggs[TSDB_FUNC_TS].name, sizeof(pExpr->base.aliasName));
 
@@ -2373,12 +2358,12 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
 
         colIndex += 1;  // the first column is ts
 
-        pExpr = tscSqlExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, getNewResColId(pQueryInfo), resultSize, false);
-        addExprParams(&pExpr->base, val, TSDB_DATA_TYPE_BIGINT, sizeof(int64_t));
+        pExpr = tscExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, getNewResColId(pQueryInfo), resultSize, false);
+        tscExprAddParams(&pExpr->base, val, TSDB_DATA_TYPE_BIGINT, sizeof(int64_t));
       }
   
       memset(pExpr->base.aliasName, 0, tListLen(pExpr->base.aliasName));
-      getColumnName(pItem, pExpr->base.aliasName, sizeof(pExpr->base.aliasName) - 1);
+      getColumnName(pItem, pExpr->base.aliasName, pExpr->base.token,sizeof(pExpr->base.aliasName) - 1);
 
       // todo refactor: tscColumnListInsert part
       SColumnList ids = createColumnList(1, index.tableIndex, index.columnIndex);
@@ -2508,12 +2493,14 @@ static SColumnList createColumnList(int32_t num, int16_t tableIndex, int32_t col
   return columnList;
 }
 
-void getColumnName(tSqlExprItem* pItem, char* resultFieldName, int32_t nameLength) {
+void getColumnName(tSqlExprItem* pItem, char* resultFieldName, char* rawName, int32_t nameLength) {
+  int32_t len = ((int32_t)pItem->pNode->token.n < nameLength) ? (int32_t)pItem->pNode->token.n : nameLength;
+  strncpy(rawName, pItem->pNode->token.z, len);
+
   if (pItem->aliasName != NULL) {
-    strncpy(resultFieldName, pItem->aliasName, nameLength);
+    strncpy(resultFieldName, pItem->aliasName, len);
   } else {
-    int32_t len = ((int32_t)pItem->pNode->token.n < nameLength) ? (int32_t)pItem->pNode->token.n : nameLength;
-    strncpy(resultFieldName, pItem->pNode->token.z, len);
+    strncpy(resultFieldName, rawName, len);
   }
 }
 
@@ -2656,7 +2643,7 @@ int32_t getColumnIndexByName(SSqlCmd* pCmd, const SStrToken* pToken, SQueryInfo*
 int32_t setShowInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   SSqlCmd*        pCmd = &pSql->cmd;
   STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
-  assert(pCmd->numOfClause == 1);
+//  assert(pCmd->numOfClause == 1);
 
   pCmd->command = TSDB_SQL_SHOW;
 
@@ -2793,9 +2780,9 @@ int32_t tscTansformFuncForSTableQuery(SQueryInfo* pQueryInfo) {
   int16_t type = 0;
   int32_t interBytes = 0;
   
-  size_t size = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t size = tscNumOfExprs(pQueryInfo);
   for (int32_t k = 0; k < size; ++k) {
-    SExprInfo*   pExpr = tscSqlExprGet(pQueryInfo, k);
+    SExprInfo*   pExpr = tscExprGet(pQueryInfo, k);
     int16_t functionId = aAggs[pExpr->base.functionId].stableFuncId;
 
     int32_t colIndex = pExpr->base.colInfo.colIndex;
@@ -2809,7 +2796,7 @@ int32_t tscTansformFuncForSTableQuery(SQueryInfo* pQueryInfo) {
         return TSDB_CODE_TSC_INVALID_SQL;
       }
 
-      tscSqlExprUpdate(pQueryInfo, k, functionId, pExpr->base.colInfo.colIndex, TSDB_DATA_TYPE_BINARY, bytes);
+      tscExprUpdate(pQueryInfo, k, functionId, pExpr->base.colInfo.colIndex, TSDB_DATA_TYPE_BINARY, bytes);
       // todo refactor
       pExpr->base.interBytes = interBytes;
     }
@@ -2826,9 +2813,9 @@ void tscRestoreFuncForSTableQuery(SQueryInfo* pQueryInfo) {
     return;
   }
   
-  size_t size = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t size = tscNumOfExprs(pQueryInfo);
   for (int32_t i = 0; i < size; ++i) {
-    SExprInfo*   pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo*   pExpr = tscExprGet(pQueryInfo, i);
     SSchema* pSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, pExpr->base.colInfo.colIndex);
     
     // the final result size and type in the same as query on single table.
@@ -2859,9 +2846,9 @@ bool hasUnsupportFunctionsForSTableQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo)
   const char* msg3 = "function not support for super table query";
 
   // filter sql function not supported by metric query yet.
-  size_t size = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t size = tscNumOfExprs(pQueryInfo);
   for (int32_t i = 0; i < size; ++i) {
-    int32_t functionId = tscSqlExprGet(pQueryInfo, i)->base.functionId;
+    int32_t functionId = tscExprGet(pQueryInfo, i)->base.functionId;
     if ((aAggs[functionId].status & TSDB_FUNCSTATE_STABLE) == 0) {
       invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
       return true;
@@ -2909,10 +2896,10 @@ static bool groupbyTagsOrNull(SQueryInfo* pQueryInfo) {
 static bool functionCompatibleCheck(SQueryInfo* pQueryInfo, bool joinQuery, bool twQuery) {
   int32_t startIdx = 0;
 
-  size_t numOfExpr = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t numOfExpr = tscNumOfExprs(pQueryInfo);
   assert(numOfExpr > 0);
 
-  SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, startIdx);
+  SExprInfo* pExpr = tscExprGet(pQueryInfo, startIdx);
 
   // ts function can be simultaneously used with any other functions.
   int32_t functionID = pExpr->base.functionId;
@@ -2920,18 +2907,18 @@ static bool functionCompatibleCheck(SQueryInfo* pQueryInfo, bool joinQuery, bool
     startIdx++;
   }
 
-  int32_t factor = functionCompatList[tscSqlExprGet(pQueryInfo, startIdx)->base.functionId];
+  int32_t factor = functionCompatList[tscExprGet(pQueryInfo, startIdx)->base.functionId];
 
-  if (tscSqlExprGet(pQueryInfo, 0)->base.functionId == TSDB_FUNC_LAST_ROW && (joinQuery || twQuery || !groupbyTagsOrNull(pQueryInfo))) {
+  if (tscExprGet(pQueryInfo, 0)->base.functionId == TSDB_FUNC_LAST_ROW && (joinQuery || twQuery || !groupbyTagsOrNull(pQueryInfo))) {
     return false;
   }
 
   // diff function cannot be executed with other function
   // arithmetic function can be executed with other arithmetic functions
-  size_t size = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t size = tscNumOfExprs(pQueryInfo);
   
   for (int32_t i = startIdx + 1; i < size; ++i) {
-    SExprInfo* pExpr1 = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr1 = tscExprGet(pQueryInfo, i);
 
     int16_t functionId = pExpr1->base.functionId;
     if (functionId == TSDB_FUNC_TAGPRJ || functionId == TSDB_FUNC_TAG || functionId == TSDB_FUNC_TS) {
@@ -3025,7 +3012,7 @@ int32_t validateGroupbyNode(SQueryInfo* pQueryInfo, SArray* pList, SSqlCmd* pCmd
       groupTag = true;
     }
   
-    SSqlGroupbyExpr* pGroupExpr = &pQueryInfo->groupbyExpr;
+    SGroupbyExpr* pGroupExpr = &pQueryInfo->groupbyExpr;
     if (pGroupExpr->columnInfo == NULL) {
       pGroupExpr->columnInfo = taosArrayInit(4, sizeof(SColIndex));
     }
@@ -3041,6 +3028,7 @@ int32_t validateGroupbyNode(SQueryInfo* pQueryInfo, SArray* pList, SSqlCmd* pCmd
       }
 
       SColIndex colIndex = { .colIndex = relIndex, .flag = TSDB_COL_TAG, .colId = pSchema->colId, };
+      strncpy(colIndex.name, pSchema->name, tListLen(colIndex.name));
       taosArrayPush(pGroupExpr->columnInfo, &colIndex);
       
       index.columnIndex = relIndex;
@@ -3054,6 +3042,8 @@ int32_t validateGroupbyNode(SQueryInfo* pQueryInfo, SArray* pList, SSqlCmd* pCmd
       tscColumnListInsert(pQueryInfo->colList, index.columnIndex, pTableMeta->id.uid, pSchema);
       
       SColIndex colIndex = { .colIndex = index.columnIndex, .flag = TSDB_COL_NORMAL, .colId = pSchema->colId };
+      strncpy(colIndex.name, pSchema->name, tListLen(colIndex.name));
+
       taosArrayPush(pGroupExpr->columnInfo, &colIndex);
       pQueryInfo->groupbyExpr.orderType = TSDB_ORDER_ASC;
 
@@ -3510,7 +3500,7 @@ static int32_t validateSQLExpr(SSqlCmd* pCmd, tSqlExpr* pExpr, SQueryInfo* pQuer
       return TSDB_CODE_TSC_INVALID_SQL;
     }
 
-    int32_t outputIndex = (int32_t)tscSqlExprNumOfExprs(pQueryInfo);
+    int32_t outputIndex = (int32_t)tscNumOfExprs(pQueryInfo);
   
     tSqlExprItem item = {.pNode = pExpr, .aliasName = NULL};
   
@@ -3526,7 +3516,7 @@ static int32_t validateSQLExpr(SSqlCmd* pCmd, tSqlExpr* pExpr, SQueryInfo* pQuer
     }
 
     // It is invalid in case of more than one sqlExpr, such as first(ts, k) - last(ts, k)
-    int32_t inc = (int32_t) tscSqlExprNumOfExprs(pQueryInfo) - outputIndex;
+    int32_t inc = (int32_t) tscNumOfExprs(pQueryInfo) - outputIndex;
     if (inc > 1) {
       return TSDB_CODE_TSC_INVALID_SQL;
     }
@@ -3534,7 +3524,7 @@ static int32_t validateSQLExpr(SSqlCmd* pCmd, tSqlExpr* pExpr, SQueryInfo* pQuer
     // Not supported data type in arithmetic expression
     uint64_t id = -1;
     for(int32_t i = 0; i < inc; ++i) {
-      SExprInfo* p1 = tscSqlExprGet(pQueryInfo, i + outputIndex);
+      SExprInfo* p1 = tscExprGet(pQueryInfo, i + outputIndex);
       int16_t t = p1->base.resType;
       if (t == TSDB_DATA_TYPE_BINARY || t == TSDB_DATA_TYPE_NCHAR || t == TSDB_DATA_TYPE_BOOL || t == TSDB_DATA_TYPE_TIMESTAMP) {
         return TSDB_CODE_TSC_INVALID_SQL;
@@ -4826,9 +4816,9 @@ int32_t validateFillNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlNo
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
   }
 
-  size_t numOfExprs = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t numOfExprs = tscNumOfExprs(pQueryInfo);
   for(int32_t i = 0; i < numOfExprs; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     if (pExpr->base.functionId == TSDB_FUNC_TOP || pExpr->base.functionId == TSDB_FUNC_BOTTOM) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
     }
@@ -4945,10 +4935,10 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
         pQueryInfo->groupbyExpr.orderType = p1->sortOrder;
       } else if (isTopBottomQuery(pQueryInfo)) {
         /* order of top/bottom query in interval is not valid  */
-        SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, 0);
+        SExprInfo* pExpr = tscExprGet(pQueryInfo, 0);
         assert(pExpr->base.functionId == TSDB_FUNC_TS);
 
-        pExpr = tscSqlExprGet(pQueryInfo, 1);
+        pExpr = tscExprGet(pQueryInfo, 1);
         if (pExpr->base.colInfo.colIndex != index.columnIndex && index.columnIndex != PRIMARYKEY_TIMESTAMP_COL_INDEX) {
           return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
         }
@@ -5007,10 +4997,10 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
 
     if (isTopBottomQuery(pQueryInfo)) {
       /* order of top/bottom query in interval is not valid  */
-      SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, 0);
+      SExprInfo* pExpr = tscExprGet(pQueryInfo, 0);
       assert(pExpr->base.functionId == TSDB_FUNC_TS);
 
-      pExpr = tscSqlExprGet(pQueryInfo, 1);
+      pExpr = tscExprGet(pQueryInfo, 1);
       if (pExpr->base.colInfo.colIndex != index.columnIndex && index.columnIndex != PRIMARYKEY_TIMESTAMP_COL_INDEX) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
@@ -5322,7 +5312,7 @@ int32_t validateSqlFunctionInStreamSql(SSqlCmd* pCmd, SQueryInfo* pQueryInfo) {
   
   size_t size = taosArrayGetSize(pQueryInfo->exprList);
   for (int32_t i = 0; i < size; ++i) {
-    int32_t functId = tscSqlExprGet(pQueryInfo, i)->base.functionId;
+    int32_t functId = tscExprGet(pQueryInfo, i)->base.functionId;
     if (!IS_STREAM_QUERY_VALID(aAggs[functId].status)) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
@@ -5339,13 +5329,13 @@ int32_t validateFunctionsInIntervalOrGroupbyQuery(SSqlCmd* pCmd, SQueryInfo* pQu
   size_t size = taosArrayGetSize(pQueryInfo->exprList);
   
   for (int32_t k = 0; k < size; ++k) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, k);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, k);
 
     // projection query on primary timestamp, the selectivity function needs to be present.
     if (pExpr->base.functionId == TSDB_FUNC_PRJ && pExpr->base.colInfo.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
       bool hasSelectivity = false;
       for (int32_t j = 0; j < size; ++j) {
-        SExprInfo* pEx = tscSqlExprGet(pQueryInfo, j);
+        SExprInfo* pEx = tscExprGet(pQueryInfo, j);
         if ((aAggs[pEx->base.functionId].status & TSDB_FUNCSTATE_SELECTIVITY) == TSDB_FUNCSTATE_SELECTIVITY) {
           hasSelectivity = true;
           break;
@@ -5553,7 +5543,7 @@ bool hasTimestampForPointInterpQuery(SQueryInfo* pQueryInfo) {
   return !(pQueryInfo->window.skey != pQueryInfo->window.ekey && pQueryInfo->interval.interval == 0);
 }
 
-int32_t validateLimitNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t clauseIndex, SSqlNode* pSqlNode, SSqlObj* pSql) {
+int32_t validateLimitNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlNode, SSqlObj* pSql) {
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
   const char* msg0 = "soffset/offset can not be less than 0";
@@ -5606,7 +5596,7 @@ int32_t validateLimitNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t clauseI
      * And then launching multiple async-queries against all qualified virtual nodes, during the first-stage
      * query operation.
      */
-    int32_t code = tscGetSTableVgroupInfo(pSql, clauseIndex);
+    int32_t code = tscGetSTableVgroupInfo(pSql, pQueryInfo);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
     }
@@ -5756,7 +5746,7 @@ void addGroupInfoForSubquery(SSqlObj* pParentObj, SSqlObj* pSql, int32_t subClau
 
     size_t size = taosArrayGetSize(pQueryInfo->exprList);
     if (size > 0) {
-      pExpr = tscSqlExprGet(pQueryInfo, (int32_t)size - 1);
+      pExpr = tscExprGet(pQueryInfo, (int32_t)size - 1);
     }
 
     if (pExpr == NULL || pExpr->base.functionId != TSDB_FUNC_TAG) {
@@ -5773,7 +5763,7 @@ void addGroupInfoForSubquery(SSqlObj* pParentObj, SSqlObj* pSql, int32_t subClau
       int16_t type = pTagSchema->type;
       int16_t bytes = pTagSchema->bytes;
 
-      pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TAG, &index, type, bytes, getNewResColId(pQueryInfo), bytes, true);
+      pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TAG, &index, type, bytes, getNewResColId(pQueryInfo), bytes, true);
       pExpr->base.colInfo.flag = TSDB_COL_TAG;
 
       // NOTE: tag column does not add to source column list
@@ -5800,14 +5790,17 @@ static void doLimitOutputNormalColOfGroupby(SExprInfo* pExpr) {
 
 void doAddGroupColumnForSubquery(SQueryInfo* pQueryInfo, int32_t tagIndex) {
   SColIndex* pColIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, tagIndex);
-  size_t size = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t size = tscNumOfExprs(pQueryInfo);
 
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
   SSchema*     pSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, pColIndex->colIndex);
   SColumnIndex colIndex = {.tableIndex = 0, .columnIndex = pColIndex->colIndex};
 
-  tscAddFuncInSelectClause(pQueryInfo, (int32_t)size, TSDB_FUNC_PRJ, &colIndex, pSchema, TSDB_COL_NORMAL);
+  SExprInfo* pExprInfo = tscAddFuncInSelectClause(pQueryInfo, (int32_t)size, TSDB_FUNC_PRJ, &colIndex, pSchema,
+      TSDB_COL_NORMAL);
+
+  strncpy(pExprInfo->base.token, pExprInfo->base.colInfo.name, tListLen(pExprInfo->base.token));
 
   int32_t numOfFields = tscNumOfFields(pQueryInfo);
   SInternalField* pInfo = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, numOfFields - 1);
@@ -5825,7 +5818,7 @@ static void doUpdateSqlFunctionForTagPrj(SQueryInfo* pQueryInfo) {
   bool isSTable = UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo);
 
   for (int32_t i = 0; i < size; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     if (pExpr->base.functionId == TSDB_FUNC_TAGPRJ || pExpr->base.functionId == TSDB_FUNC_TAG) {
       pExpr->base.functionId = TSDB_FUNC_TAG_DUMMY;
       tagLength += pExpr->base.resBytes;
@@ -5838,7 +5831,7 @@ static void doUpdateSqlFunctionForTagPrj(SQueryInfo* pQueryInfo) {
   SSchema* pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
 
   for (int32_t i = 0; i < size; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     if ((pExpr->base.functionId != TSDB_FUNC_TAG_DUMMY && pExpr->base.functionId != TSDB_FUNC_TS_DUMMY) &&
        !(pExpr->base.functionId == TSDB_FUNC_PRJ && TSDB_COL_IS_UD_COL(pExpr->base.colInfo.flag))) {
       SSchema* pColSchema = &pSchema[pExpr->base.colInfo.colIndex];
@@ -5852,7 +5845,7 @@ static int32_t doUpdateSqlFunctionForColPrj(SQueryInfo* pQueryInfo) {
   size_t size = taosArrayGetSize(pQueryInfo->exprList);
   
   for (int32_t i = 0; i < size; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
 
     if (pExpr->base.functionId == TSDB_FUNC_PRJ && (!TSDB_COL_IS_UD_COL(pExpr->base.colInfo.flag) && (pExpr->base.colInfo.colId != PRIMARYKEY_TIMESTAMP_COL_INDEX))) {
       bool qualifiedCol = false;
@@ -5877,7 +5870,7 @@ static int32_t doUpdateSqlFunctionForColPrj(SQueryInfo* pQueryInfo) {
   return TSDB_CODE_SUCCESS;
 }
 
-static bool tagColumnInGroupby(SSqlGroupbyExpr* pGroupbyExpr, int16_t columnId) {
+static bool tagColumnInGroupby(SGroupbyExpr* pGroupbyExpr, int16_t columnId) {
   for (int32_t j = 0; j < pGroupbyExpr->numOfGroupCols; ++j) {
     SColIndex* pColIndex = taosArrayGet(pGroupbyExpr->columnInfo, j);
   
@@ -5895,7 +5888,7 @@ static bool onlyTagPrjFunction(SQueryInfo* pQueryInfo) {
   
   size_t size = taosArrayGetSize(pQueryInfo->exprList);
   for (int32_t i = 0; i < size; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     if (pExpr->base.functionId == TSDB_FUNC_PRJ) {
       hasColumnPrj = true;
     } else if (pExpr->base.functionId == TSDB_FUNC_TAGPRJ) {
@@ -5910,9 +5903,9 @@ static bool onlyTagPrjFunction(SQueryInfo* pQueryInfo) {
 static bool allTagPrjInGroupby(SQueryInfo* pQueryInfo) {
   bool allInGroupby = true;
 
-  size_t size = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t size = tscNumOfExprs(pQueryInfo);
   for (int32_t i = 0; i < size; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     if (pExpr->base.functionId != TSDB_FUNC_TAGPRJ) {
       continue;
     }
@@ -5931,7 +5924,7 @@ static void updateTagPrjFunction(SQueryInfo* pQueryInfo) {
   size_t size = taosArrayGetSize(pQueryInfo->exprList);
   
   for (int32_t i = 0; i < size; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     if (pExpr->base.functionId == TSDB_FUNC_TAGPRJ) {
       pExpr->base.functionId = TSDB_FUNC_TAG;
     }
@@ -6001,7 +5994,7 @@ static int32_t checkUpdateTagPrjFunctions(SQueryInfo* pQueryInfo, SSqlCmd* pCmd)
        * Otherwise, return with error code.
        */
       for (int32_t i = 0; i < numOfExprs; ++i) {
-        SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+        SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
         int16_t functionId = pExpr->base.functionId;
         if (functionId == TSDB_FUNC_TAGPRJ || (aAggs[functionId].status & TSDB_FUNCSTATE_SELECTIVITY) == 0) {
           continue;
@@ -6069,15 +6062,16 @@ static int32_t doAddGroupbyColumnsOnDemand(SSqlCmd* pCmd, SQueryInfo* pQueryInfo
       }
     }
   
-    size_t size = tscSqlExprNumOfExprs(pQueryInfo);
+    size_t size = tscNumOfExprs(pQueryInfo);
   
     if (TSDB_COL_IS_TAG(pColIndex->flag)) {
       SColumnIndex index = {.tableIndex = pQueryInfo->groupbyExpr.tableIndex, .columnIndex = colIndex};
-      SExprInfo*   pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TAG, &index, s->type, s->bytes,
+      SExprInfo*   pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TAG, &index, s->type, s->bytes,
                                           getNewResColId(pQueryInfo), s->bytes, true);
 
       memset(pExpr->base.aliasName, 0, sizeof(pExpr->base.aliasName));
       tstrncpy(pExpr->base.aliasName, s->name, sizeof(pExpr->base.aliasName));
+      tstrncpy(pExpr->base.token, s->name, sizeof(pExpr->base.aliasName));
 
       pExpr->base.colInfo.flag = TSDB_COL_TAG;
 
@@ -6092,7 +6086,7 @@ static int32_t doAddGroupbyColumnsOnDemand(SSqlCmd* pCmd, SQueryInfo* pQueryInfo
 
       bool hasGroupColumn = false;
       for (int32_t j = 0; j < size; ++j) {
-        SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, j);
+        SExprInfo* pExpr = tscExprGet(pQueryInfo, j);
         if ((pExpr->base.functionId == TSDB_FUNC_PRJ) && pExpr->base.colInfo.colId == pColIndex->colId) {
           hasGroupColumn = true;
           break;
@@ -6113,10 +6107,10 @@ static int32_t doTagFunctionCheck(SQueryInfo* pQueryInfo) {
   bool tagProjection = false;
   bool tableCounting = false;
 
-  int32_t numOfCols = (int32_t) tscSqlExprNumOfExprs(pQueryInfo);
+  int32_t numOfCols = (int32_t) tscNumOfExprs(pQueryInfo);
 
   for (int32_t i = 0; i < numOfCols; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     int32_t functionId = pExpr->base.functionId;
 
     if (functionId == TSDB_FUNC_TAGPRJ) {
@@ -6162,9 +6156,9 @@ int32_t doFunctionsCompatibleCheck(SSqlCmd* pCmd, SQueryInfo* pQueryInfo) {
     }
 
     // check all query functions in selection clause, multi-output functions are not allowed
-    size_t size = tscSqlExprNumOfExprs(pQueryInfo);
+    size_t size = tscNumOfExprs(pQueryInfo);
     for (int32_t i = 0; i < size; ++i) {
-      SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+      SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
       int32_t   functId = pExpr->base.functionId;
 
       /*
@@ -6271,7 +6265,7 @@ int32_t doLocalQueryProcess(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
   }
   
   SColumnIndex ind = {0};
-  SExprInfo* pExpr1 = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TAG_DUMMY, &ind, TSDB_DATA_TYPE_INT,
+  SExprInfo* pExpr1 = tscExprAppend(pQueryInfo, TSDB_FUNC_TAG_DUMMY, &ind, TSDB_DATA_TYPE_INT,
                                       tDataTypes[TSDB_DATA_TYPE_INT].bytes, getNewResColId(pQueryInfo), tDataTypes[TSDB_DATA_TYPE_INT].bytes, false);
 
   tSqlExprItem* item = taosArrayGet(pExprList, 0);
@@ -6368,7 +6362,7 @@ int32_t tscCheckCreateDbParams(SSqlCmd* pCmd, SCreateDbMsg* pCreate) {
 void tscPrintSelNodeList(SSqlObj* pSql, int32_t subClauseIndex) {
   SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, subClauseIndex);
 
-  int32_t size = (int32_t)tscSqlExprNumOfExprs(pQueryInfo);
+  int32_t size = (int32_t)tscNumOfExprs(pQueryInfo);
   if (size == 0) {
     return;
   }
@@ -6380,7 +6374,7 @@ void tscPrintSelNodeList(SSqlObj* pSql, int32_t subClauseIndex) {
 
   offset += sprintf(str, "num:%d [", size);
   for (int32_t i = 0; i < size; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
 
     char    tmpBuf[1024] = {0};
     int32_t tmpLen = 0;
@@ -6828,9 +6822,9 @@ int32_t tscGetExprFilters(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pSelect
         getColumnIndexByName(pCmd, pToken, pQueryInfo, &index);
       }
 
-      size_t numOfNodeInSel = tscSqlExprNumOfExprs(pQueryInfo);
+      size_t numOfNodeInSel = tscNumOfExprs(pQueryInfo);
       for(int32_t k = 0; k < numOfNodeInSel; ++k) {
-        SExprInfo* pExpr1 = tscSqlExprGet(pQueryInfo, k);
+        SExprInfo* pExpr1 = tscExprGet(pQueryInfo, k);
 
         if (pExpr1->base.functionId != functionId) {
           continue;
@@ -6852,7 +6846,7 @@ int32_t tscGetExprFilters(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pSelect
 
   tSqlExprItem item = {.pNode = pSqlExpr, .aliasName = NULL, .distinct = false};
 
-  int32_t outputIndex = (int32_t)tscSqlExprNumOfExprs(pQueryInfo);
+  int32_t outputIndex = (int32_t)tscNumOfExprs(pQueryInfo);
 
   // ADD TRUE FOR TEST
   if (addExprAndResultField(pCmd, pQueryInfo, outputIndex, &item, true) != TSDB_CODE_SUCCESS) {
@@ -6861,8 +6855,8 @@ int32_t tscGetExprFilters(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pSelect
 
   ++pQueryInfo->havingFieldNum;
 
-  size_t n = tscSqlExprNumOfExprs(pQueryInfo);
-  *pExpr = tscSqlExprGet(pQueryInfo, (int32_t)n - 1);
+  size_t n = tscNumOfExprs(pQueryInfo);
+  *pExpr = tscExprGet(pQueryInfo, (int32_t)n - 1);
 
   SInternalField* pField = taosArrayGet(pQueryInfo->fieldsInfo.internalField, n - 1);
   pField->visible = false;
@@ -7072,7 +7066,7 @@ int32_t validateHavingClause(SQueryInfo* pQueryInfo, tSqlExpr* pExpr, SSqlCmd* p
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t doLoadAllTableMeta(SSqlObj* pSql, int32_t index, SSqlNode* pSqlNode, int32_t numOfTables) {
+static int32_t doLoadAllTableMeta(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNode* pSqlNode, int32_t numOfTables) {
   const char* msg1 = "invalid table name";
   const char* msg2 = "invalid table alias name";
   const char* msg3 = "alias name too long";
@@ -7080,8 +7074,6 @@ static int32_t doLoadAllTableMeta(SSqlObj* pSql, int32_t index, SSqlNode* pSqlNo
   int32_t code = TSDB_CODE_SUCCESS;
 
   SSqlCmd* pCmd = &pSql->cmd;
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, index);
-
   for (int32_t i = 0; i < numOfTables; ++i) {
     if (pQueryInfo->numOfTables <= i) {  // more than one table
       tscAddEmptyMetaInfo(pQueryInfo);
@@ -7160,7 +7152,7 @@ static STableMeta* extractTempTableMetaFromNestQuery(SQueryInfo* pUpstream) {
   return meta;
 }
 
-int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, int32_t index) {
+int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInfo) {
   assert(pSqlNode != NULL && (pSqlNode->from == NULL || taosArrayGetSize(pSqlNode->from->list) > 0));
 
   const char* msg1 = "point interpolation query needs timestamp";
@@ -7171,14 +7163,11 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, int32_t index) {
 
   SSqlCmd* pCmd = &pSql->cmd;
 
-  SQueryInfo      *pQueryInfo = tscGetQueryInfo(pCmd, index);
   STableMetaInfo  *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   if (pTableMetaInfo == NULL) {
     pTableMetaInfo = tscAddEmptyMetaInfo(pQueryInfo);
   }
 
-  assert(pCmd->clauseIndex == index);
-
   /*
    * handle the sql expression without from subclause
    * select current_database();
@@ -7197,7 +7186,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, int32_t index) {
     SArray* list = taosArrayGetP(pSqlNode->from->list, 0);
     SSqlNode* p = taosArrayGetP(list, 0);
 
-    code = validateSqlNode(pSql, p, 0);
+    code = validateSqlNode(pSql, p, NULL);
     if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
       return code;
     }
@@ -7206,7 +7195,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, int32_t index) {
       return code;
     }
 
-    pQueryInfo = pCmd->pQueryInfo[0];
+    pQueryInfo = pCmd->pQueryInfo;
 
     SQueryInfo* current = calloc(1, sizeof(SQueryInfo));
 
@@ -7222,7 +7211,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, int32_t index) {
     current->numOfTables = 1;
     current->order = pQueryInfo->order;
 
-    pCmd->pQueryInfo[0] = current;
+    pCmd->pQueryInfo = current;
     pQueryInfo->pDownstream = current;
 
     if (validateSelectNodeList(pCmd, current, pSqlNode->pSelNodeList, false, false, false) != TSDB_CODE_SUCCESS) {
@@ -7238,14 +7227,14 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, int32_t index) {
     }
 
     // set all query tables, which are maybe more than one.
-    code = doLoadAllTableMeta(pSql, index, pSqlNode, (int32_t) fromSize);
+    code = doLoadAllTableMeta(pSql, pQueryInfo, pSqlNode, (int32_t) fromSize);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
     }
 
     bool isSTable = UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo);
     if (isSTable) {
-      code = tscGetSTableVgroupInfo(pSql, index);  // TODO refactor: getTablemeta along with vgroupInfo
+      code = tscGetSTableVgroupInfo(pSql, pQueryInfo);  // TODO refactor: getTablemeta along with vgroupInfo
       if (code != TSDB_CODE_SUCCESS) {
         return code;
       }
@@ -7345,7 +7334,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, int32_t index) {
       }
     }
 
-    if ((code = validateLimitNode(pCmd, pQueryInfo, index, pSqlNode, pSql)) != TSDB_CODE_SUCCESS) {
+    if ((code = validateLimitNode(pCmd, pQueryInfo, pSqlNode, pSql)) != TSDB_CODE_SUCCESS) {
       return code;
     }
 
@@ -7361,6 +7350,32 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, int32_t index) {
     }
   }
 
+  { // set the query info
+    pQueryInfo->projectionQuery = tscIsProjectionQuery(pQueryInfo);
+    pQueryInfo->hasFilter = tscHasColumnFilter(pQueryInfo);
+    pQueryInfo->simpleAgg = isSimpleAggregateRv(pQueryInfo);
+    pQueryInfo->onlyTagQuery = onlyTagPrjFunction(pQueryInfo);
+    pQueryInfo->groupbyColumn = tscGroupbyColumn(pQueryInfo);
+
+    pQueryInfo->arithmeticOnAgg = tsIsArithmeticQueryOnAggResult(pQueryInfo);
+
+    SExprInfo** p = NULL;
+    int32_t numOfExpr = 0;
+    code = createProjectionExpr(pQueryInfo, pTableMetaInfo, &p, &numOfExpr);
+
+    if (pQueryInfo->exprList1 == NULL) {
+      pQueryInfo->exprList1 = taosArrayInit(4, POINTER_BYTES);
+    }
+
+    taosArrayPushBatch(pQueryInfo->exprList1, (void*) p, numOfExpr);
+  }
+
+  SQueryNode* p = qCreateQueryPlan(pQueryInfo);
+  char* s = queryPlanToString(p);
+  printf("%s\n", s);
+  tfree(s);
+
+  qDestroyQueryPlan(p);
   return TSDB_CODE_SUCCESS;  // Does not build query message here
 }
 
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 215c96784e..4e4ed1bcf0 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -624,7 +624,7 @@ static int32_t tscEstimateQueryMsgSize(SSqlObj *pSql, int32_t clauseIndex) {
 
   int32_t srcColListSize = (int32_t)(taosArrayGetSize(pQueryInfo->colList) * sizeof(SColumnInfo));
 
-  size_t  numOfExprs = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t  numOfExprs = tscNumOfExprs(pQueryInfo);
   int32_t exprSize = (int32_t)(sizeof(SSqlExpr) * numOfExprs * 2);
 
   int32_t tsBufSize = (pQueryInfo->tsBuf != NULL) ? pQueryInfo->tsBuf->fileSize : 0;
@@ -929,7 +929,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     goto _end;
   }
   
-  SSqlGroupbyExpr *pGroupbyExpr = query.pGroupbyExpr;
+  SGroupbyExpr *pGroupbyExpr = query.pGroupbyExpr;
   if (pGroupbyExpr->numOfGroupCols > 0) {
     pQueryMsg->orderByIdx = htons(pGroupbyExpr->orderIndex);
     pQueryMsg->orderType = htons(pGroupbyExpr->orderType);
@@ -1050,7 +1050,7 @@ int32_t tscBuildCreateDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   SCreateDbMsg *pCreateDbMsg = (SCreateDbMsg *)pCmd->payload;
 
-  assert(pCmd->numOfClause == 1);
+//  assert(pCmd->numOfClause == 1);
   STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
   int32_t code = tNameExtractFullName(&pTableMetaInfo->name, pCreateDbMsg->db);
   assert(code == TSDB_CODE_SUCCESS);
@@ -1632,9 +1632,9 @@ int tscProcessRetrieveLocalMergeRsp(SSqlObj *pSql) {
     taosArrayPush(group, &tableKeyInfo);
     taosArrayPush(tableGroupInfo.pGroupList, &group);
 
-    SExprInfo* list = calloc(tscSqlExprNumOfExprs(pQueryInfo), sizeof(SExprInfo));
-    for(int32_t i = 0; i < tscSqlExprNumOfExprs(pQueryInfo); ++i) {
-      SExprInfo* pExprInfo = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* list = calloc(tscNumOfExprs(pQueryInfo), sizeof(SExprInfo));
+    for(int32_t i = 0; i < tscNumOfExprs(pQueryInfo); ++i) {
+      SExprInfo* pExprInfo = tscExprGet(pQueryInfo, i);
       list[i] = *pExprInfo;
     }
 
@@ -2166,7 +2166,7 @@ int tscProcessShowRsp(SSqlObj *pSql) {
     TAOS_FIELD f = tscCreateField(pSchema->type, pSchema->name, pSchema->bytes);
     SInternalField* pInfo = tscFieldInfoAppend(pFieldInfo, &f);
     
-    pInfo->pExpr = tscSqlExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index,
+    pInfo->pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index,
                      pTableSchema[i].type, pTableSchema[i].bytes, getNewResColId(pQueryInfo), pTableSchema[i].bytes, false);
   }
   
@@ -2411,7 +2411,7 @@ static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaIn
   }
 
   STableMetaInfo *pNewMeterMetaInfo = tscAddEmptyMetaInfo(pNewQueryInfo);
-  assert(pNew->cmd.numOfClause == 1 && pNewQueryInfo->numOfTables == 1);
+  assert(/*pNew->cmd.numOfClause == 1 && */pNewQueryInfo->numOfTables == 1);
 
   tNameAssign(&pNewMeterMetaInfo->name, &pTableMetaInfo->name);
 
@@ -2513,8 +2513,7 @@ int tscRenewTableMeta(SSqlObj *pSql, int32_t tableIndex) {
   return getTableMetaFromMnode(pSql, pTableMetaInfo);
 }
 
-static bool allVgroupInfoRetrieved(SSqlCmd* pCmd, int32_t clauseIndex) {
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, clauseIndex);
+static bool allVgroupInfoRetrieved(SQueryInfo* pQueryInfo) {
   for (int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
     STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, i);
     if (pTableMetaInfo->vgroupList == NULL) {
@@ -2526,11 +2525,9 @@ static bool allVgroupInfoRetrieved(SSqlCmd* pCmd, int32_t clauseIndex) {
   return true;
 }
 
-int tscGetSTableVgroupInfo(SSqlObj *pSql, int32_t clauseIndex) {
-  int      code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
-  SSqlCmd *pCmd = &pSql->cmd;
-  
-  if (allVgroupInfoRetrieved(pCmd, clauseIndex)) {
+int tscGetSTableVgroupInfo(SSqlObj *pSql, SQueryInfo* pQueryInfo) {
+  int32_t code = TSDB_CODE_RPC_NETWORK_UNAVAIL;
+  if (allVgroupInfoRetrieved(pQueryInfo)) {
     return TSDB_CODE_SUCCESS;
   }
 
@@ -2547,7 +2544,6 @@ int tscGetSTableVgroupInfo(SSqlObj *pSql, int32_t clauseIndex) {
     return code;
   }
   
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, clauseIndex);
   for (int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
     STableMetaInfo *pMInfo = tscGetMetaInfo(pQueryInfo, i);
     STableMeta* pTableMeta = tscTableMetaDup(pMInfo->pTableMeta);
diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c
index 17bf575b60..f05956529f 100644
--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@@ -37,7 +37,7 @@ static int64_t getDelayValueAfterTimewindowClosed(SSqlStream* pStream, int64_t l
 
 static bool isProjectStream(SQueryInfo* pQueryInfo) {
   for (int32_t i = 0; i < pQueryInfo->fieldsInfo.numOfOutput; ++i) {
-    SExprInfo *pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo *pExpr = tscExprGet(pQueryInfo, i);
     if (pExpr->base.functionId != TSDB_FUNC_PRJ) {
       return false;
     }
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index 8e5d26337d..e1b42d8930 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -417,14 +417,15 @@ static void tscDestroyJoinSupporter(SJoinSupporter* pSupporter) {
   }
 
   if (pSupporter->exprList != NULL) {
-    tscSqlExprInfoDestroy(pSupporter->exprList);
+    tscExprDestroy(pSupporter->exprList);
+    pSupporter->exprList = NULL;
   }
   
   if (pSupporter->colList != NULL) {
     tscColumnListDestroy(pSupporter->colList);
   }
 
-  tscFieldInfoClear(&pSupporter->fieldsInfo);
+//  tscFieldInfoClear(&pSupporter->fieldsInfo);
 
   if (pSupporter->pTSBuf != NULL) {
     tsBufDestroy(pSupporter->pTSBuf);
@@ -554,7 +555,7 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
     pSubQueryInfo->tsBuf = NULL;
   
     // free result for async object will also free sqlObj
-    assert(tscSqlExprNumOfExprs(pSubQueryInfo) == 1); // ts_comp query only requires one result columns
+    assert(tscNumOfExprs(pSubQueryInfo) == 1); // ts_comp query only requires one result columns
     taos_free_result(pPrevSub);
   
     SSqlObj *pNew = createSubqueryObj(pSql, (int16_t) i, tscJoinQueryCallback, pSupporter, TSDB_SQL_SELECT, NULL);
@@ -582,7 +583,7 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
     pQueryInfo->groupbyExpr = pSupporter->groupInfo;
     pQueryInfo->pUpstream   = taosArrayInit(4, sizeof(POINTER_BYTES));
 
-    assert(pNew->subState.numOfSub == 0 && pNew->cmd.numOfClause == 1 && pQueryInfo->numOfTables == 1);
+    assert(pNew->subState.numOfSub == 0 && pQueryInfo->numOfTables == 1);
   
     tscFieldInfoUpdateOffset(pQueryInfo);
   
@@ -593,7 +594,7 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
     pSupporter->colList = NULL;
     pSupporter->pVgroupTables = NULL;
     memset(&pSupporter->fieldsInfo, 0, sizeof(SFieldInfo));
-    memset(&pSupporter->groupInfo, 0, sizeof(SSqlGroupbyExpr));
+    memset(&pSupporter->groupInfo, 0, sizeof(SGroupbyExpr));
 
     /*
      * When handling the projection query, the offset value will be modified for table-table join, which is changed
@@ -605,7 +606,7 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
     SColumnIndex index = {.tableIndex = 0, .columnIndex = PRIMARYKEY_TIMESTAMP_COL_INDEX};
     SSchema* s = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, 0);
 
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, 0);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, 0);
     int16_t funcId = pExpr->base.functionId;
 
     // add the invisible timestamp column
@@ -618,7 +619,7 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
       tscPrintSelNodeList(pNew, 0);
       tscFieldInfoUpdateOffset(pQueryInfo);
 
-      pExpr = tscSqlExprGet(pQueryInfo, 0);
+      pExpr = tscExprGet(pQueryInfo, 0);
     }
 
     // set the join condition tag column info, todo extract method
@@ -821,7 +822,7 @@ static void issueTsCompQuery(SSqlObj* pSql, SJoinSupporter* pSupporter, SSqlObj*
   
   // set the tags value for ts_comp function
   if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
-    SExprInfo *pExpr = tscSqlExprGet(pQueryInfo, 0);
+    SExprInfo *pExpr = tscExprGet(pQueryInfo, 0);
     int16_t tagColId = tscGetJoinTagColIdByUid(&pSupporter->tagCond, pTableMetaInfo->pTableMeta->id.uid);
     pExpr->base.param[0].i64 = tagColId;
     pExpr->base.param[0].nLen = sizeof(int64_t);
@@ -849,7 +850,7 @@ static void issueTsCompQuery(SSqlObj* pSql, SJoinSupporter* pSupporter, SSqlObj*
       "0x%"PRIx64" subquery:0x%"PRIx64" tableIndex:%d, vgroupIndex:%d, numOfVgroups:%d, type:%d, ts_comp query to retrieve timestamps, "
       "numOfExpr:%" PRIzu ", colList:%" PRIzu ", numOfOutputFields:%d, name:%s",
       pParent->self, pSql->self, 0, pTableMetaInfo->vgroupIndex, pTableMetaInfo->vgroupList->numOfVgroups, pQueryInfo->type,
-      tscSqlExprNumOfExprs(pQueryInfo), numOfCols, pQueryInfo->fieldsInfo.numOfOutput, tNameGetTableName(&pTableMetaInfo->name));
+      tscNumOfExprs(pQueryInfo), numOfCols, pQueryInfo->fieldsInfo.numOfOutput, tNameGetTableName(&pTableMetaInfo->name));
   
   tscBuildAndSendRequest(pSql, NULL);
 }
@@ -1688,7 +1689,7 @@ void tscSetupOutputColumnIndex(SSqlObj* pSql) {
 
   SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
 
-  int32_t numOfExprs = (int32_t)tscSqlExprNumOfExprs(pQueryInfo);
+  int32_t numOfExprs = (int32_t)tscNumOfExprs(pQueryInfo);
   pRes->pColumnIndex = calloc(1, sizeof(SColumnIndex) * numOfExprs);
   if (pRes->pColumnIndex == NULL) {
     pRes->code = TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -1696,7 +1697,7 @@ void tscSetupOutputColumnIndex(SSqlObj* pSql) {
   }
 
   for (int32_t i = 0; i < numOfExprs; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
 
     int32_t tableIndexOfSub = -1;
     for (int32_t j = 0; j < pQueryInfo->numOfTables; ++j) {
@@ -1714,7 +1715,7 @@ void tscSetupOutputColumnIndex(SSqlObj* pSql) {
     
     size_t numOfSubExpr = taosArrayGetSize(pSubQueryInfo->exprList);
     for (int32_t k = 0; k < numOfSubExpr; ++k) {
-      SExprInfo* pSubExpr = tscSqlExprGet(pSubQueryInfo, k);
+      SExprInfo* pSubExpr = tscExprGet(pSubQueryInfo, k);
       if (pExpr->base.functionId == pSubExpr->base.functionId && pExpr->base.colInfo.colId == pSubExpr->base.colInfo.colId) {
         pRes->pColumnIndex[i] = (SColumnIndex){.tableIndex = tableIndexOfSub, .columnIndex = k};
         break;
@@ -1737,7 +1738,7 @@ void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {
   SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
-  assert(pQueryInfo->numOfTables == 1 && pSql->cmd.numOfClause == 1);
+  assert(pQueryInfo->numOfTables == 1);
 
   // retrieve actual query results from vnode during the second stage join subquery
   if (pParentSql->res.code != TSDB_CODE_SUCCESS) {
@@ -1865,7 +1866,7 @@ int32_t tscCreateJoinSubquery(SSqlObj *pSql, int16_t tableIndex, SJoinSupporter
     }
 
     pSupporter->groupInfo = pNewQueryInfo->groupbyExpr;
-    memset(&pNewQueryInfo->groupbyExpr, 0, sizeof(SSqlGroupbyExpr));
+    memset(&pNewQueryInfo->groupbyExpr, 0, sizeof(SGroupbyExpr));
 
     pNew->cmd.numOfCols = 0;
     pNewQueryInfo->interval.interval = 0;
@@ -1878,7 +1879,7 @@ int32_t tscCreateJoinSubquery(SSqlObj *pSql, int16_t tableIndex, SJoinSupporter
     pNewQueryInfo->order.orderColId = INT32_MIN;
 
     // backup the data and clear it in the sqlcmd object
-    memset(&pNewQueryInfo->groupbyExpr, 0, sizeof(SSqlGroupbyExpr));
+    memset(&pNewQueryInfo->groupbyExpr, 0, sizeof(SGroupbyExpr));
     
     tscInitQueryInfo(pNewQueryInfo);
     STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pNewQueryInfo, 0);
@@ -1912,7 +1913,7 @@ int32_t tscCreateJoinSubquery(SSqlObj *pSql, int16_t tableIndex, SJoinSupporter
       tscDebug(
           "%p subquery:%p tableIndex:%d, vgroupIndex:%d, type:%d, transfer to tid_tag query to retrieve (tableId, tags), "
           "exprInfo:%" PRIzu ", colList:%" PRIzu ", fieldsInfo:%d, tagIndex:%d, name:%s",
-          pSql, pNew, tableIndex, pTableMetaInfo->vgroupIndex, pNewQueryInfo->type, tscSqlExprNumOfExprs(pNewQueryInfo),
+          pSql, pNew, tableIndex, pTableMetaInfo->vgroupIndex, pNewQueryInfo->type, tscNumOfExprs(pNewQueryInfo),
           numOfCols, pNewQueryInfo->fieldsInfo.numOfOutput, colIndex.columnIndex, tNameGetTableName(&pNewQueryInfo->pTableMetaInfo[0]->name));
     } else {
       SSchema      colSchema = {.type = TSDB_DATA_TYPE_BINARY, .bytes = 1};
@@ -1920,7 +1921,7 @@ int32_t tscCreateJoinSubquery(SSqlObj *pSql, int16_t tableIndex, SJoinSupporter
       tscAddFuncInSelectClause(pNewQueryInfo, 0, TSDB_FUNC_TS_COMP, &colIndex, &colSchema, TSDB_COL_NORMAL);
 
       // set the tags value for ts_comp function
-      SExprInfo *pExpr = tscSqlExprGet(pNewQueryInfo, 0);
+      SExprInfo *pExpr = tscExprGet(pNewQueryInfo, 0);
 
       if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
         int16_t tagColId = tscGetJoinTagColIdByUid(&pSupporter->tagCond, pTableMetaInfo->pTableMeta->id.uid);
@@ -1947,7 +1948,7 @@ int32_t tscCreateJoinSubquery(SSqlObj *pSql, int16_t tableIndex, SJoinSupporter
       tscDebug(
           "%p subquery:%p tableIndex:%d, vgroupIndex:%d, type:%u, transfer to ts_comp query to retrieve timestamps, "
           "exprInfo:%" PRIzu ", colList:%" PRIzu ", fieldsInfo:%d, name:%s",
-          pSql, pNew, tableIndex, pTableMetaInfo->vgroupIndex, pNewQueryInfo->type, tscSqlExprNumOfExprs(pNewQueryInfo),
+          pSql, pNew, tableIndex, pTableMetaInfo->vgroupIndex, pNewQueryInfo->type, tscNumOfExprs(pNewQueryInfo),
           numOfCols, pNewQueryInfo->fieldsInfo.numOfOutput, tNameGetTableName(&pNewQueryInfo->pTableMetaInfo[0]->name));
     }
   } else {
@@ -2086,7 +2087,7 @@ typedef struct SFirstRoundQuerySup {
 void doAppendData(SInterResult* pInterResult, TAOS_ROW row, int32_t numOfCols, SQueryInfo* pQueryInfo) {
   TSKEY key = INT64_MIN;
   for(int32_t i = 0; i < numOfCols; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     if (TSDB_COL_IS_TAG(pExpr->base.colInfo.flag) || pExpr->base.functionId == TSDB_FUNC_PRJ) {
       continue;
     }
@@ -2179,7 +2180,7 @@ void tscFirstRoundRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
 
         int32_t offset = 0;
         for (int32_t i = 0; i < numOfCols && offset < pSup->tagLen; ++i) {
-          SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+          SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
 
           // tag or group by column
           if (TSDB_COL_IS_TAG(pExpr->base.colInfo.flag) || pExpr->base.functionId == TSDB_FUNC_PRJ) {
@@ -2321,11 +2322,11 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
   pCmd->command = TSDB_SQL_SELECT;
   pNew->fp = tscFirstRoundCallback;
 
-  int32_t numOfExprs = (int32_t) tscSqlExprNumOfExprs(pQueryInfo);
+  int32_t numOfExprs = (int32_t) tscNumOfExprs(pQueryInfo);
 
   int32_t index = 0;
   for(int32_t i = 0; i < numOfExprs; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     if (pExpr->base.functionId == TSDB_FUNC_TS && pQueryInfo->interval.interval > 0) {
       taosArrayPush(pSup->pColsInfo, &pExpr->base.resColId);
 
@@ -2385,7 +2386,7 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
       "0x%"PRIx64" first round subquery:0x%"PRIx64" tableIndex:%d, vgroupIndex:%d, numOfVgroups:%d, type:%d, query to retrieve timestamps, "
       "numOfExpr:%" PRIzu ", colList:%d, numOfOutputFields:%d, name:%s",
       pSql->self, pNew->self, 0, pTableMetaInfo->vgroupIndex, pTableMetaInfo->vgroupList->numOfVgroups, pNewQueryInfo->type,
-      tscSqlExprNumOfExprs(pNewQueryInfo), index+1, pNewQueryInfo->fieldsInfo.numOfOutput, tNameGetTableName(&pTableMetaInfo->name));
+      tscNumOfExprs(pNewQueryInfo), index+1, pNewQueryInfo->fieldsInfo.numOfOutput, tNameGetTableName(&pTableMetaInfo->name));
 
   tscHandleMasterSTableQuery(pNew);
   return TSDB_CODE_SUCCESS;
@@ -2897,7 +2898,7 @@ static SSqlObj *tscCreateSTableSubquery(SSqlObj *pSql, SRetrieveSupport *trsuppo
     pQueryInfo->limit.limit = -1;
     pQueryInfo->limit.offset = 0;
 
-    assert(pQueryInfo->numOfTables == 1 && pNew->cmd.numOfClause == 1 && trsupport->subqueryIndex < pSql->subState.numOfSub);
+    assert(/*pQueryInfo->numOfTables == 1 && pNew->cmd.numOfClause == 1 &&*/ trsupport->subqueryIndex < pSql->subState.numOfSub);
     
     // launch subquery for each vnode, so the subquery index equals to the vgroupIndex.
     STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, table_index);
@@ -2924,7 +2925,7 @@ void tscRetrieveDataRes(void *param, TAOS_RES *tres, int code) {
   SSqlObj*  pSql = (SSqlObj *) tres;
 
   SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
-  assert(pSql->cmd.numOfClause == 1 && pQueryInfo->numOfTables == 1);
+  assert(pQueryInfo->numOfTables == 1);
   
   STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0, 0);
   SVgroupInfo* pVgroup = &pTableMetaInfo->vgroupList->vgroups[trsupport->subqueryIndex];
@@ -3296,12 +3297,12 @@ static void doBuildResFromSubqueries(SSqlObj* pSql) {
       continue;
     }
 
-    SQueryInfo* pSubQueryInfo = pSub->cmd.pQueryInfo[0];
+    SQueryInfo* pSubQueryInfo = pSub->cmd.pQueryInfo;
     tscRestoreFuncForSTableQuery(pSubQueryInfo);
     tscFieldInfoUpdateOffset(pSubQueryInfo);
   }
 
-  size_t numOfExprs = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t numOfExprs = tscNumOfExprs(pQueryInfo);
   for(int32_t i = 0; i < numOfExprs; ++i) {
     SColumnIndex* pIndex = &pRes->pColumnIndex[i];
     SSqlRes*      pRes1 = &pSql->pSubs[pIndex->tableIndex]->res;
@@ -3348,7 +3349,7 @@ void tscBuildResFromSubqueries(SSqlObj *pSql) {
 
   if (pRes->tsrow == NULL) {
     SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, pSql->cmd.clauseIndex);
-    pRes->numOfCols = (int16_t) tscSqlExprNumOfExprs(pQueryInfo);
+    pRes->numOfCols = (int16_t) tscNumOfExprs(pQueryInfo);
 
     pRes->tsrow  = calloc(pRes->numOfCols, POINTER_BYTES);
     pRes->urow   = calloc(pRes->numOfCols, POINTER_BYTES);
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 7e30e92b9c..cb4939ff28 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -78,10 +78,10 @@ void tsSetSTableQueryCond(STagCond* pTagCond, uint64_t uid, SBufferWriter* bw) {
 }
 
 bool tscQueryTags(SQueryInfo* pQueryInfo) {
-  int32_t numOfCols = (int32_t) tscSqlExprNumOfExprs(pQueryInfo);
+  int32_t numOfCols = (int32_t) tscNumOfExprs(pQueryInfo);
 
   for (int32_t i = 0; i < numOfCols; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     int32_t functId = pExpr->base.functionId;
 
     // "select count(tbname)" query
@@ -98,10 +98,10 @@ bool tscQueryTags(SQueryInfo* pQueryInfo) {
 }
 
 bool tscQueryBlockInfo(SQueryInfo* pQueryInfo) {
-  int32_t numOfCols = (int32_t) tscSqlExprNumOfExprs(pQueryInfo);
+  int32_t numOfCols = (int32_t) tscNumOfExprs(pQueryInfo);
 
   for (int32_t i = 0; i < numOfCols; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     int32_t functId = pExpr->base.functionId;
 
     if (functId == TSDB_FUNC_BLKINFO) {
@@ -146,14 +146,14 @@ bool tscIsProjectionQueryOnSTable(SQueryInfo* pQueryInfo, int32_t tableIndex) {
    * 1. failed to get tableMeta from server; 2. not a super table; 3. limitation is 0;
    * 4. show queries, instead of a select query
    */
-  size_t numOfExprs = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t numOfExprs = tscNumOfExprs(pQueryInfo);
   if (pTableMetaInfo == NULL || !UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo) ||
       pQueryInfo->command == TSDB_SQL_RETRIEVE_EMPTY_RESULT || numOfExprs == 0) {
     return false;
   }
   
   for (int32_t i = 0; i < numOfExprs; ++i) {
-    int32_t functionId = tscSqlExprGet(pQueryInfo, i)->base.functionId;
+    int32_t functionId = tscExprGet(pQueryInfo, i)->base.functionId;
 
     if (functionId != TSDB_FUNC_PRJ &&
         functionId != TSDB_FUNC_TAGPRJ &&
@@ -189,10 +189,10 @@ bool tscOrderedProjectionQueryOnSTable(SQueryInfo* pQueryInfo, int32_t tableInde
 }
 
 bool tscIsProjectionQuery(SQueryInfo* pQueryInfo) {
-  size_t size = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t size = tscNumOfExprs(pQueryInfo);
 
   for (int32_t i = 0; i < size; ++i) {
-    int32_t functionId = tscSqlExprGet(pQueryInfo, i)->base.functionId;
+    int32_t functionId = tscExprGet(pQueryInfo, i)->base.functionId;
 
     if (functionId != TSDB_FUNC_PRJ && functionId != TSDB_FUNC_TAGPRJ && functionId != TSDB_FUNC_TAG &&
         functionId != TSDB_FUNC_TS && functionId != TSDB_FUNC_ARITHM) {
@@ -203,10 +203,27 @@ bool tscIsProjectionQuery(SQueryInfo* pQueryInfo) {
   return true;
 }
 
-bool tscIsPointInterpQuery(SQueryInfo* pQueryInfo) {
-  size_t size = tscSqlExprNumOfExprs(pQueryInfo);
+bool tscHasColumnFilter(SQueryInfo* pQueryInfo) {
+  // filter on primary timestamp column
+  if (pQueryInfo->window.skey != INT64_MIN || pQueryInfo->window.ekey != INT64_MAX) {
+    return true;
+  }
+
+  size_t size = taosArrayGetSize(pQueryInfo->colList);
   for (int32_t i = 0; i < size; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SColumn* pCol = taosArrayGet(pQueryInfo->colList, i);
+    if (pCol->info.flist.numOfFilters > 0) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool tscIsPointInterpQuery(SQueryInfo* pQueryInfo) {
+  size_t size = tscNumOfExprs(pQueryInfo);
+  for (int32_t i = 0; i < size; ++i) {
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     assert(pExpr != NULL);
 
     int32_t functionId = pExpr->base.functionId;
@@ -222,7 +239,7 @@ bool tscIsPointInterpQuery(SQueryInfo* pQueryInfo) {
   return true;
 }
 
-bool tscIsSecondStageQuery(SQueryInfo* pQueryInfo) {
+bool tsIsArithmeticQueryOnAggResult(SQueryInfo* pQueryInfo) {
   if (tscIsProjectionQuery(pQueryInfo)) {
     return false;
   }
@@ -242,7 +259,7 @@ bool tscGroupbyColumn(SQueryInfo* pQueryInfo) {
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   int32_t         numOfCols = tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
 
-  SSqlGroupbyExpr* pGroupbyExpr = &pQueryInfo->groupbyExpr;
+  SGroupbyExpr* pGroupbyExpr = &pQueryInfo->groupbyExpr;
   for (int32_t k = 0; k < pGroupbyExpr->numOfGroupCols; ++k) {
     SColIndex* pIndex = taosArrayGet(pGroupbyExpr->columnInfo, k);
     if (!TSDB_COL_IS_TAG(pIndex->flag) && pIndex->colIndex < numOfCols) {  // group by normal columns
@@ -254,10 +271,10 @@ bool tscGroupbyColumn(SQueryInfo* pQueryInfo) {
 }
 
 bool tscIsTopBotQuery(SQueryInfo* pQueryInfo) {
-  size_t numOfExprs = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t numOfExprs = tscNumOfExprs(pQueryInfo);
 
   for (int32_t i = 0; i < numOfExprs; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     if (pExpr == NULL) {
       continue;
     }
@@ -275,8 +292,8 @@ bool tscIsTopBotQuery(SQueryInfo* pQueryInfo) {
 }
 
 bool isTsCompQuery(SQueryInfo* pQueryInfo) {
-  size_t    numOfExprs = tscSqlExprNumOfExprs(pQueryInfo);
-  SExprInfo* pExpr1 = tscSqlExprGet(pQueryInfo, 0);
+  size_t    numOfExprs = tscNumOfExprs(pQueryInfo);
+  SExprInfo* pExpr1 = tscExprGet(pQueryInfo, 0);
   if (numOfExprs != 1) {
     return false;
   }
@@ -285,15 +302,15 @@ bool isTsCompQuery(SQueryInfo* pQueryInfo) {
 }
 
 bool hasTagValOutput(SQueryInfo* pQueryInfo) {
-  size_t    numOfExprs = tscSqlExprNumOfExprs(pQueryInfo);
-  SExprInfo* pExpr1 = tscSqlExprGet(pQueryInfo, 0);
+  size_t    numOfExprs = tscNumOfExprs(pQueryInfo);
+  SExprInfo* pExpr1 = tscExprGet(pQueryInfo, 0);
 
   if (numOfExprs == 1 && pExpr1->base.functionId == TSDB_FUNC_TS_COMP) {
     return true;
   }
 
   for (int32_t i = 0; i < numOfExprs; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     if (pExpr == NULL) {
       continue;
     }
@@ -308,9 +325,9 @@ bool hasTagValOutput(SQueryInfo* pQueryInfo) {
 }
 
 bool timeWindowInterpoRequired(SQueryInfo *pQueryInfo) {
-  size_t numOfExprs = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t numOfExprs = tscNumOfExprs(pQueryInfo);
   for (int32_t i = 0; i < numOfExprs; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     if (pExpr == NULL) {
       continue;
     }
@@ -325,9 +342,9 @@ bool timeWindowInterpoRequired(SQueryInfo *pQueryInfo) {
 }
 
 bool isStabledev(SQueryInfo* pQueryInfo) {
-  size_t numOfExprs = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t numOfExprs = tscNumOfExprs(pQueryInfo);
   for (int32_t i = 0; i < numOfExprs; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     if (pExpr == NULL) {
       continue;
     }
@@ -342,9 +359,9 @@ bool isStabledev(SQueryInfo* pQueryInfo) {
 }
 
 bool tscIsTWAQuery(SQueryInfo* pQueryInfo) {
-  size_t numOfExprs = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t numOfExprs = tscNumOfExprs(pQueryInfo);
   for (int32_t i = 0; i < numOfExprs; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     if (pExpr == NULL) {
       continue;
     }
@@ -358,9 +375,9 @@ bool tscIsTWAQuery(SQueryInfo* pQueryInfo) {
 }
 
 bool tscNeedReverseScan(SQueryInfo* pQueryInfo) {
-  size_t numOfExprs = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t numOfExprs = tscNumOfExprs(pQueryInfo);
   for (int32_t i = 0; i < numOfExprs; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     if (pExpr == NULL) {
       continue;
     }
@@ -396,9 +413,9 @@ bool isSimpleAggregate(SQueryInfo* pQueryInfo) {
     return true;
   }
 
-  size_t numOfExprs = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t numOfExprs = tscNumOfExprs(pQueryInfo);
   for (int32_t i = 0; i < numOfExprs; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     if (pExpr == NULL) {
       continue;
     }
@@ -416,9 +433,39 @@ bool isSimpleAggregate(SQueryInfo* pQueryInfo) {
   return false;
 }
 
+bool isSimpleAggregateRv(SQueryInfo* pQueryInfo) {
+  if (pQueryInfo->interval.interval > 0 || pQueryInfo->sessionWindow.gap > 0) {
+    return false;
+  }
+
+  if (tscGroupbyColumn(pQueryInfo) || isTsCompQuery(pQueryInfo)) {
+    return false;
+  }
+
+  size_t numOfExprs = tscNumOfExprs(pQueryInfo);
+  for (int32_t i = 0; i < numOfExprs; ++i) {
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
+    if (pExpr == NULL) {
+      continue;
+    }
+
+    int32_t functionId = pExpr->base.functionId;
+    if (functionId == TSDB_FUNC_TS || functionId == TSDB_FUNC_TS_DUMMY) {
+      continue;
+    }
+
+    if (!IS_MULTIOUTPUT(aAggs[functionId].status)) {
+      return true;
+    }
+  }
+
+  return false;
+
+}
+
 bool isBlockDistQuery(SQueryInfo* pQueryInfo) {
-  size_t numOfExprs = tscSqlExprNumOfExprs(pQueryInfo);
-  SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, 0);
+  size_t numOfExprs = tscNumOfExprs(pQueryInfo);
+  SExprInfo* pExpr = tscExprGet(pQueryInfo, 0);
   return (numOfExprs == 1 && pExpr->base.colInfo.colId == TSDB_BLOCK_DIST_COLUMN_INDEX);
 }
 
@@ -702,7 +749,7 @@ void handleDownstreamOperator(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
     // handle the following query process
     SQueryInfo *px = pQueryInfo->pDownstream;
     SColumnInfo* pColumnInfo = extractColumnInfoFromResult(px->pTableMetaInfo[0]->pTableMeta, px->colList);
-    int32_t numOfOutput = (int32_t) tscSqlExprNumOfExprs(px);
+    int32_t numOfOutput = (int32_t) tscNumOfExprs(px);
 
     int32_t numOfCols = (int32_t) taosArrayGetSize(px->colList);
     SQueriedTableInfo info = {.colList = pColumnInfo, .numOfCols = numOfCols,};
@@ -762,17 +809,19 @@ static void tscDestroyResPointerInfo(SSqlRes* pRes) {
 }
 
 void tscFreeQueryInfo(SSqlCmd* pCmd, bool removeMeta) {
-  if (pCmd == NULL || pCmd->numOfClause == 0) {
+  if (pCmd == NULL) {
     return;
   }
-  
-  for (int32_t i = 0; i < pCmd->numOfClause; ++i) {
-    SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, i);
 
-    // recursive call it
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, 0);
+
+  while(pQueryInfo != NULL) {
+    SQueryInfo* p = pQueryInfo->sibling;
+
     if (taosArrayGetSize(pQueryInfo->pUpstream) > 0) {
       SQueryInfo* pUp = taosArrayGetP(pQueryInfo->pUpstream, 0);
       freeQueryInfoImpl(pUp);
+
       clearAllTableMetaInfo(pUp, removeMeta);
       if (pUp->pQInfo != NULL) {
         qDestroyQueryInfo(pUp->pQInfo);
@@ -781,7 +830,7 @@ void tscFreeQueryInfo(SSqlCmd* pCmd, bool removeMeta) {
 
       tfree(pUp);
     }
-    
+
     freeQueryInfoImpl(pQueryInfo);
     clearAllTableMetaInfo(pQueryInfo, removeMeta);
 
@@ -791,10 +840,11 @@ void tscFreeQueryInfo(SSqlCmd* pCmd, bool removeMeta) {
     }
 
     tfree(pQueryInfo);
+
+    pQueryInfo = p;
   }
-  
-  pCmd->numOfClause = 0;
-  tfree(pCmd->pQueryInfo);
+
+  pCmd->pQueryInfo = NULL;
 }
 
 void destroyTableNameList(SSqlCmd* pCmd) {
@@ -1026,7 +1076,7 @@ int32_t tscCopyDataBlockToPayload(SSqlObj* pSql, STableDataBlocks* pDataBlock) {
 
   pCmd->numOfTablesInSubmit = pDataBlock->numOfTables;
 
-  assert(pCmd->numOfClause == 1);
+//  assert(pCmd->numOfClause == 1);
   STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
 
   // todo refactor
@@ -1407,7 +1457,7 @@ SInternalField* tscFieldInfoInsert(SFieldInfo* pFieldInfo, int32_t index, TAOS_F
 }
 
 void tscFieldInfoUpdateOffset(SQueryInfo* pQueryInfo) {
-  size_t numOfExprs = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t numOfExprs = tscNumOfExprs(pQueryInfo);
   
   SExprInfo* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
   pExpr->base.offset = 0;
@@ -1527,8 +1577,8 @@ void tscFieldInfoClear(SFieldInfo* pFieldInfo) {
   memset(pFieldInfo, 0, sizeof(SFieldInfo));
 }
 
-static SExprInfo* doCreateSqlExpr(SQueryInfo* pQueryInfo, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
-                                  int16_t size, int16_t resColId, int16_t interSize, int32_t colType) {
+SExprInfo* tscExprCreate(SQueryInfo* pQueryInfo, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
+                         int16_t size, int16_t resColId, int16_t interSize, int32_t colType) {
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, pColIndex->tableIndex);
   
   SExprInfo* pExpr = calloc(1, sizeof(SExprInfo));
@@ -1587,29 +1637,29 @@ static SExprInfo* doCreateSqlExpr(SQueryInfo* pQueryInfo, int16_t functionId, SC
   return pExpr;
 }
 
-SExprInfo* tscSqlExprInsert(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
+SExprInfo* tscExprInsert(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
                            int16_t size, int16_t resColId, int16_t interSize, bool isTagCol) {
   int32_t num = (int32_t)taosArrayGetSize(pQueryInfo->exprList);
   if (index == num) {
-    return tscSqlExprAppend(pQueryInfo, functionId, pColIndex, type, size, resColId, interSize, isTagCol);
+    return tscExprAppend(pQueryInfo, functionId, pColIndex, type, size, resColId, interSize, isTagCol);
   }
   
-  SExprInfo* pExpr = doCreateSqlExpr(pQueryInfo, functionId, pColIndex, type, size, resColId, interSize, isTagCol);
+  SExprInfo* pExpr = tscExprCreate(pQueryInfo, functionId, pColIndex, type, size, resColId, interSize, isTagCol);
   taosArrayInsert(pQueryInfo->exprList, index, &pExpr);
   return pExpr;
 }
 
-SExprInfo* tscSqlExprAppend(SQueryInfo* pQueryInfo, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
+SExprInfo* tscExprAppend(SQueryInfo* pQueryInfo, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
                            int16_t size, int16_t resColId, int16_t interSize, bool isTagCol) {
-  SExprInfo* pExpr = doCreateSqlExpr(pQueryInfo, functionId, pColIndex, type, size, resColId, interSize, isTagCol);
+  SExprInfo* pExpr = tscExprCreate(pQueryInfo, functionId, pColIndex, type, size, resColId, interSize, isTagCol);
   taosArrayPush(pQueryInfo->exprList, &pExpr);
   return pExpr;
 }
 
-SExprInfo* tscSqlExprUpdate(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, int16_t srcColumnIndex,
+SExprInfo* tscExprUpdate(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, int16_t srcColumnIndex,
                            int16_t type, int16_t size) {
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
-  SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, index);
+  SExprInfo* pExpr = tscExprGet(pQueryInfo, index);
   if (pExpr == NULL) {
     return NULL;
   }
@@ -1631,9 +1681,9 @@ bool tscMultiRoundQuery(SQueryInfo* pQueryInfo, int32_t index) {
     return false;
   }
 
-  int32_t numOfExprs = (int32_t) tscSqlExprNumOfExprs(pQueryInfo);
+  int32_t numOfExprs = (int32_t) tscNumOfExprs(pQueryInfo);
   for(int32_t i = 0; i < numOfExprs; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     if (pExpr->base.functionId == TSDB_FUNC_STDDEV_DST) {
       return true;
     }
@@ -1642,11 +1692,11 @@ bool tscMultiRoundQuery(SQueryInfo* pQueryInfo, int32_t index) {
   return false;
 }
 
-size_t tscSqlExprNumOfExprs(SQueryInfo* pQueryInfo) {
+size_t tscNumOfExprs(SQueryInfo* pQueryInfo) {
   return taosArrayGetSize(pQueryInfo->exprList);
 }
 
-void addExprParams(SSqlExpr* pExpr, char* argument, int32_t type, int32_t bytes) {
+void tscExprAddParams(SSqlExpr* pExpr, char* argument, int32_t type, int32_t bytes) {
   assert (pExpr != NULL || argument != NULL || bytes != 0);
 
   // set parameter value
@@ -1657,14 +1707,14 @@ void addExprParams(SSqlExpr* pExpr, char* argument, int32_t type, int32_t bytes)
   assert(pExpr->numOfParams <= 3);
 }
 
-SExprInfo* tscSqlExprGet(SQueryInfo* pQueryInfo, int32_t index) {
+SExprInfo* tscExprGet(SQueryInfo* pQueryInfo, int32_t index) {
   return taosArrayGetP(pQueryInfo->exprList, index);
 }
 
 /*
  * NOTE: Does not release SExprInfo here.
  */
-void tscSqlExprInfoDestroy(SArray* pExprInfo) {
+void tscExprDestroy(SArray* pExprInfo) {
   size_t size = taosArrayGetSize(pExprInfo);
   
   for(int32_t i = 0; i < size; ++i) {
@@ -1675,7 +1725,7 @@ void tscSqlExprInfoDestroy(SArray* pExprInfo) {
   taosArrayDestroy(pExprInfo);
 }
 
-int32_t tscSqlExprCopy(SArray* dst, const SArray* src, uint64_t uid, bool deepcopy) {
+int32_t tscExprCopy(SArray* dst, const SArray* src, uint64_t uid, bool deepcopy) {
   assert(src != NULL && dst != NULL);
   
   size_t size = taosArrayGetSize(src);
@@ -1685,7 +1735,7 @@ int32_t tscSqlExprCopy(SArray* dst, const SArray* src, uint64_t uid, bool deepco
     if (pExpr->base.uid == uid) {
       if (deepcopy) {
         SExprInfo* p1 = calloc(1, sizeof(SExprInfo));
-        tscSqlExprAssign(p1, pExpr);
+        tscExprAssign(p1, pExpr);
 
         taosArrayPush(dst, &p1);
       } else {
@@ -1724,7 +1774,7 @@ bool tscColumnExists(SArray* pColumnList, int32_t columnIndex, uint64_t uid) {
   return true;
 }
 
-void tscSqlExprAssign(SExprInfo* dst, const SExprInfo* src) {
+void tscExprAssign(SExprInfo* dst, const SExprInfo* src) {
   assert(dst != NULL && src != NULL);
 
   *dst = *src;
@@ -2138,9 +2188,9 @@ void tscGetSrcColumnInfo(SSrcColumnInfo* pColInfo, SQueryInfo* pQueryInfo) {
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   SSchema*        pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
   
-  size_t numOfExprs = tscSqlExprNumOfExprs(pQueryInfo);
+  size_t numOfExprs = tscNumOfExprs(pQueryInfo);
   for (int32_t i = 0; i < numOfExprs; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     pColInfo[i].functionId = pExpr->base.functionId;
 
     if (TSDB_COL_IS_TAG(pExpr->base.colInfo.flag)) {
@@ -2193,11 +2243,12 @@ bool tscShouldBeFreed(SSqlObj* pSql) {
  * @return
  */
 STableMetaInfo* tscGetTableMetaInfoFromCmd(SSqlCmd* pCmd, int32_t clauseIndex, int32_t tableIndex) {
-  if (pCmd == NULL || pCmd->numOfClause == 0) {
-    return NULL;
-  }
+  assert(pCmd != NULL);
+//  if (pCmd == NULL || pCmd->numOfClause == 0) {
+//    return NULL;
+//  }
 
-  assert(clauseIndex >= 0 && clauseIndex < pCmd->numOfClause);
+//  assert(clauseIndex >= 0 && clauseIndex < pCmd->numOfClause);
 
   SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, clauseIndex);
   return tscGetMetaInfo(pQueryInfo, tableIndex);
@@ -2272,13 +2323,13 @@ int32_t tscAddQueryInfo(SSqlCmd* pCmd) {
   assert(pCmd != NULL);
 
   // todo refactor: remove this structure
-  size_t s = pCmd->numOfClause + 1;
-  char*  tmp = realloc(pCmd->pQueryInfo, s * POINTER_BYTES);
-  if (tmp == NULL) {
-    return TSDB_CODE_TSC_OUT_OF_MEMORY;
-  }
+//  size_t s = pCmd->numOfClause + 1;
+//  char*  tmp = realloc(pCmd->pQueryInfo, s * POINTER_BYTES);
+//  if (tmp == NULL) {
+//    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+//  }
 
-  pCmd->pQueryInfo = (SQueryInfo**)tmp;
+//  pCmd->pQueryInfo = (SQueryInfo**)tmp;
 
   SQueryInfo* pQueryInfo = calloc(1, sizeof(SQueryInfo));
   if (pQueryInfo == NULL) {
@@ -2290,7 +2341,19 @@ int32_t tscAddQueryInfo(SSqlCmd* pCmd) {
   pQueryInfo->window = TSWINDOW_INITIALIZER;
   pQueryInfo->msg = pCmd->payload;  // pointer to the parent error message buffer
 
-  pCmd->pQueryInfo[pCmd->numOfClause++] = pQueryInfo;
+  if (pCmd->pQueryInfo == NULL) {
+    pCmd->pQueryInfo = pQueryInfo;
+  } else {
+    SQueryInfo* p = pCmd->pQueryInfo;
+    while(p->sibling != NULL) {
+      p = p->sibling;
+    }
+
+    p->sibling = pQueryInfo;
+  }
+
+  pCmd->active = pQueryInfo;
+//  pCmd->pQueryInfo[pCmd->numOfClause++] = pQueryInfo;
   return TSDB_CODE_SUCCESS;
 }
 
@@ -2298,7 +2361,7 @@ static void freeQueryInfoImpl(SQueryInfo* pQueryInfo) {
   tscTagCondRelease(&pQueryInfo->tagCond);
   tscFieldInfoClear(&pQueryInfo->fieldsInfo);
 
-  tscSqlExprInfoDestroy(pQueryInfo->exprList);
+  tscExprDestroy(pQueryInfo->exprList);
   pQueryInfo->exprList = NULL;
 
   tscColumnListDestroy(pQueryInfo->colList);
@@ -2320,9 +2383,11 @@ static void freeQueryInfoImpl(SQueryInfo* pQueryInfo) {
 }
 
 void tscClearSubqueryInfo(SSqlCmd* pCmd) {
-  for (int32_t i = 0; i < pCmd->numOfClause; ++i) {
-    SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, i);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  while (pQueryInfo != NULL) {
+    SQueryInfo* p = pQueryInfo->sibling;
     freeQueryInfoImpl(pQueryInfo);
+    pQueryInfo = p;
   }
 }
 
@@ -2535,14 +2600,14 @@ SSqlObj* createSimpleSubObj(SSqlObj* pSql, __async_cb_func_t fp, void* param, in
 }
 
 static void doSetSqlExprAndResultFieldInfo(SQueryInfo* pNewQueryInfo, int64_t uid) {
-  int32_t numOfOutput = (int32_t)tscSqlExprNumOfExprs(pNewQueryInfo);
+  int32_t numOfOutput = (int32_t)tscNumOfExprs(pNewQueryInfo);
   if (numOfOutput == 0) {
     return;
   }
 
   // set the field info in pNewQueryInfo object according to sqlExpr information
   for (int32_t i = 0; i < numOfOutput; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pNewQueryInfo, i);
+    SExprInfo* pExpr = tscExprGet(pNewQueryInfo, i);
 
     TAOS_FIELD f = tscCreateField((int8_t) pExpr->base.resType, pExpr->base.aliasName, pExpr->base.resBytes);
     SInternalField* pInfo1 = tscFieldInfoAppend(&pNewQueryInfo->fieldsInfo, &f);
@@ -2556,7 +2621,7 @@ static void doSetSqlExprAndResultFieldInfo(SQueryInfo* pNewQueryInfo, int64_t ui
 
     bool matched = false;
     for (int32_t k1 = 0; k1 < numOfOutput; ++k1) {
-      SExprInfo* pExpr1 = tscSqlExprGet(pNewQueryInfo, k1);
+      SExprInfo* pExpr1 = tscExprGet(pNewQueryInfo, k1);
 
       if (strcmp(field->name, pExpr1->base.aliasName) == 0) {  // establish link according to the result field name
         SInternalField* pInfo = tscFieldInfoGetInternalField(&pNewQueryInfo->fieldsInfo, f);
@@ -2599,7 +2664,6 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
   pnCmd->allocSize = 0;
 
   pnCmd->pQueryInfo  = NULL;
-  pnCmd->numOfClause = 0;
   pnCmd->clauseIndex = 0;
   pnCmd->pDataBlocks = NULL;
 
@@ -2686,7 +2750,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
     TSDB_QUERY_SET_TYPE(pNewQueryInfo->type, TSDB_QUERY_TYPE_SUBQUERY);// it must be the subquery
   }
 
-  if (tscSqlExprCopy(pNewQueryInfo->exprList, pQueryInfo->exprList, uid, true) != 0) {
+  if (tscExprCopy(pNewQueryInfo->exprList, pQueryInfo->exprList, uid, true) != 0) {
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
     goto _error;
   }
@@ -2746,7 +2810,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
     
     tscDebug("0x%"PRIx64" new subquery:0x%"PRIx64", tableIndex:%d, vgroupIndex:%d, type:%d, exprInfo:%" PRIzu ", colList:%" PRIzu ","
         "fieldInfo:%d, name:%s, qrang:%" PRId64 " - %" PRId64 " order:%d, limit:%" PRId64,
-        pSql->self, pNew->self, tableIndex, pTableMetaInfo->vgroupIndex, pNewQueryInfo->type, tscSqlExprNumOfExprs(pNewQueryInfo),
+        pSql->self, pNew->self, tableIndex, pTableMetaInfo->vgroupIndex, pNewQueryInfo->type, tscNumOfExprs(pNewQueryInfo),
         size, pNewQueryInfo->fieldsInfo.numOfOutput, tNameGetTableName(&pFinalInfo->name), pNewQueryInfo->window.skey,
         pNewQueryInfo->window.ekey, pNewQueryInfo->order.order, pNewQueryInfo->limit.limit);
     
@@ -2923,17 +2987,15 @@ bool tscIsQueryWithLimit(SSqlObj* pSql) {
   }
 
   SSqlCmd* pCmd = &pSql->cmd;
-  for (int32_t i = 0; i < pCmd->numOfClause; ++i) {
-    SQueryInfo* pqi = tscGetQueryInfoS(pCmd, i);
-    if (pqi == NULL) {
-      continue;
-    }
-
+  SQueryInfo* pqi = tscGetQueryInfo(pCmd, 0);
+  while(pqi != NULL) {
     if (pqi->limit.limit > 0) {
       return true;
     }
+
+    pqi = pqi->sibling;
   }
-  
+
   return false;
 }
 
@@ -3027,7 +3089,8 @@ bool hasMoreVnodesToTry(SSqlObj* pSql) {
 }
 
 bool hasMoreClauseToTry(SSqlObj* pSql) {
-  return pSql->cmd.clauseIndex < pSql->cmd.numOfClause - 1;
+  SSqlCmd* pCmd = &pSql->cmd;
+  return pCmd->active->sibling != NULL;
 }
 
 void tscTryQueryNextVnode(SSqlObj* pSql, __async_cb_func_t fp) {
@@ -3090,9 +3153,6 @@ void tscTryQueryNextClause(SSqlObj* pSql, __async_cb_func_t fp) {
   SSqlCmd* pCmd = &pSql->cmd;
   SSqlRes* pRes = &pSql->res;
 
-  // current subclause is completed, try the next subclause
-  assert(pCmd->clauseIndex < pCmd->numOfClause - 1);
-
   pCmd->clauseIndex++;
   SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
 
@@ -3108,7 +3168,7 @@ void tscTryQueryNextClause(SSqlObj* pSql, __async_cb_func_t fp) {
   pSql->subState.numOfSub = 0;
   pSql->fp = fp;
 
-  tscDebug("0x%"PRIx64" try data in the next subclause:%d, total subclause:%d", pSql->self, pCmd->clauseIndex, pCmd->numOfClause);
+  tscDebug("0x%"PRIx64" try data in the next subclause:%d", pSql->self, pCmd->clauseIndex);
   if (pCmd->command > TSDB_SQL_LOCAL) {
     tscProcessLocalCmd(pSql);
   } else {
@@ -3371,69 +3431,78 @@ STableMeta* tscTableMetaDup(STableMeta* pTableMeta) {
   return p;
 }
 
-static int32_t createSecondaryExpr(SQueryAttr* pQueryAttr, SQueryInfo* pQueryInfo, STableMetaInfo* pTableMetaInfo) {
-  if (!tscIsSecondStageQuery(pQueryInfo)) {
+int32_t createProjectionExpr(SQueryInfo* pQueryInfo, STableMetaInfo* pTableMetaInfo, SExprInfo*** pExpr, int32_t* num) {
+  if (!pQueryInfo->arithmeticOnAgg) {
     return TSDB_CODE_SUCCESS;
   }
 
-  pQueryAttr->numOfExpr2 = tscNumOfFields(pQueryInfo);
-  pQueryAttr->pExpr2 = calloc(pQueryAttr->numOfExpr2, sizeof(SExprInfo));
-  if (pQueryAttr->pExpr2 == NULL) {
+  *num = tscNumOfFields(pQueryInfo);
+  *pExpr = calloc(*(num), POINTER_BYTES);
+  if ((*pExpr) == NULL) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
-  for (int32_t i = 0; i < pQueryAttr->numOfExpr2; ++i) {
+  for (int32_t i = 0; i < (*num); ++i) {
     SInternalField* pField = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, i);
-    SExprInfo*      pExpr = pField->pExpr;
+    SExprInfo* pSource = pField->pExpr;
 
-    SSqlExpr *pse = &pQueryAttr->pExpr2[i].base;
+    SExprInfo* px = calloc(1, sizeof(SExprInfo));
+    (*pExpr)[i] = px;
+
+    SSqlExpr *pse = &px->base;
     pse->uid      = pTableMetaInfo->pTableMeta->id.uid;
-    pse->resColId = pExpr->base.resColId;
+    pse->resColId = pSource->base.resColId;
+    strncpy(pse->aliasName, pSource->base.aliasName, tListLen(pse->aliasName));
+    strncpy(pse->token, pSource->base.token, tListLen(pse->token));
 
-    if (pExpr->base.functionId != TSDB_FUNC_ARITHM) {  // this should be switched to projection query
+    if (pSource->base.functionId != TSDB_FUNC_ARITHM) {  // this should be switched to projection query
       pse->numOfParams = 0;      // no params for projection query
       pse->functionId  = TSDB_FUNC_PRJ;
-      pse->colInfo.colId = pExpr->base.resColId;
+      pse->colInfo.colId = pSource->base.resColId;
 
-      for (int32_t j = 0; j < pQueryAttr->numOfOutput; ++j) {
-        if (pQueryAttr->pExpr1[j].base.resColId == pse->colInfo.colId) {
+      int32_t numOfOutput = (int32_t) taosArrayGetSize(pQueryInfo->exprList);
+      for (int32_t j = 0; j < numOfOutput; ++j) {
+        SExprInfo* px = taosArrayGetP(pQueryInfo->exprList, j);
+        if (px->base.resColId == pse->colInfo.colId) {
           pse->colInfo.colIndex = j;
+          break;
         }
       }
 
       pse->colInfo.flag = TSDB_COL_NORMAL;
-      pse->resType  = pExpr->base.resType;
-      pse->resBytes = pExpr->base.resBytes;
+      pse->resType  = pSource->base.resType;
+      pse->resBytes = pSource->base.resBytes;
+      strncpy(pse->colInfo.name, pSource->base.aliasName, tListLen(pse->colInfo.name));
 
       // TODO restore refactor
-      int32_t functionId = pExpr->base.functionId;
-      if (pExpr->base.functionId == TSDB_FUNC_FIRST_DST) {
+      int32_t functionId = pSource->base.functionId;
+      if (pSource->base.functionId == TSDB_FUNC_FIRST_DST) {
         functionId = TSDB_FUNC_FIRST;
-      } else if (pExpr->base.functionId == TSDB_FUNC_LAST_DST) {
+      } else if (pSource->base.functionId == TSDB_FUNC_LAST_DST) {
         functionId = TSDB_FUNC_LAST;
-      } else if (pExpr->base.functionId == TSDB_FUNC_STDDEV_DST) {
+      } else if (pSource->base.functionId == TSDB_FUNC_STDDEV_DST) {
         functionId = TSDB_FUNC_STDDEV;
       }
 
       int32_t inter = 0;
-      getResultDataInfo(pExpr->base.colType, pExpr->base.colBytes, functionId, 0, &pse->resType,
+      getResultDataInfo(pSource->base.colType, pSource->base.colBytes, functionId, 0, &pse->resType,
           &pse->resBytes, &inter, 0, false);
       pse->colType  = pse->resType;
       pse->colBytes = pse->resBytes;
 
     } else {  // arithmetic expression
-      pse->colInfo.colId = pExpr->base.colInfo.colId;
-      pse->colType  = pExpr->base.colType;
-      pse->colBytes = pExpr->base.colBytes;
+      pse->colInfo.colId = pSource->base.colInfo.colId;
+      pse->colType  = pSource->base.colType;
+      pse->colBytes = pSource->base.colBytes;
       pse->resBytes = sizeof(double);
       pse->resType  = TSDB_DATA_TYPE_DOUBLE;
 
-      pse->functionId = pExpr->base.functionId;
-      pse->numOfParams = pExpr->base.numOfParams;
+      pse->functionId = pSource->base.functionId;
+      pse->numOfParams = pSource->base.numOfParams;
 
-      for (int32_t j = 0; j < pExpr->base.numOfParams; ++j) {
-        tVariantAssign(&pse->param[j], &pExpr->base.param[j]);
-        buildArithmeticExprFromMsg(&pQueryAttr->pExpr2[i], NULL);
+      for (int32_t j = 0; j < pSource->base.numOfParams; ++j) {
+        tVariantAssign(&pse->param[j], &pSource->base.param[j]);
+        buildArithmeticExprFromMsg(px, NULL);
       }
     }
   }
@@ -3444,7 +3513,7 @@ static int32_t createSecondaryExpr(SQueryAttr* pQueryAttr, SQueryInfo* pQueryInf
 static int32_t createGlobalAggregateExpr(SQueryAttr* pQueryAttr, SQueryInfo* pQueryInfo) {
   assert(tscIsTwoStageSTableQuery(pQueryInfo, 0));
 
-  pQueryAttr->numOfExpr3 = (int32_t) tscSqlExprNumOfExprs(pQueryInfo);
+  pQueryAttr->numOfExpr3 = (int32_t) tscNumOfExprs(pQueryInfo);
   pQueryAttr->pExpr3 = calloc(pQueryAttr->numOfExpr3, sizeof(SExprInfo));
   if (pQueryAttr->pExpr3 == NULL) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -3454,7 +3523,7 @@ static int32_t createGlobalAggregateExpr(SQueryAttr* pQueryAttr, SQueryInfo* pQu
     SExprInfo* pExpr = &pQueryAttr->pExpr1[i];
     SSqlExpr*  pse = &pQueryAttr->pExpr3[i].base;
 
-    tscSqlExprAssign(&pQueryAttr->pExpr3[i], pExpr);
+    tscExprAssign(&pQueryAttr->pExpr3[i], pExpr);
     pse->colInfo.colId = pExpr->base.resColId;
     pse->colInfo.colIndex = i;
 
@@ -3536,7 +3605,7 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
   memset(pQueryAttr, 0, sizeof(SQueryAttr));
 
   int16_t numOfCols        = (int16_t) taosArrayGetSize(pQueryInfo->colList);
-  int16_t numOfOutput      = (int16_t) tscSqlExprNumOfExprs(pQueryInfo);
+  int16_t numOfOutput      = (int16_t) tscNumOfExprs(pQueryInfo);
 
   pQueryAttr->topBotQuery       = tscIsTopBotQuery(pQueryInfo);
   pQueryAttr->hasTagResults     = hasTagValOutput(pQueryInfo);
@@ -3571,7 +3640,7 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
 
   STableMetaInfo* pTableMetaInfo = pQueryInfo->pTableMetaInfo[0];
 
-  pQueryAttr->pGroupbyExpr    = calloc(1, sizeof(SSqlGroupbyExpr));
+  pQueryAttr->pGroupbyExpr    = calloc(1, sizeof(SGroupbyExpr));
   *(pQueryAttr->pGroupbyExpr) = pQueryInfo->groupbyExpr;
 
   if (pQueryInfo->groupbyExpr.numOfGroupCols > 0) {
@@ -3582,8 +3651,8 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
 
   pQueryAttr->pExpr1 = calloc(pQueryAttr->numOfOutput, sizeof(SExprInfo));
   for(int32_t i = 0; i < pQueryAttr->numOfOutput; ++i) {
-    SExprInfo* pExpr = tscSqlExprGet(pQueryInfo, i);
-    tscSqlExprAssign(&pQueryAttr->pExpr1[i], pExpr);
+    SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
+    tscExprAssign(&pQueryAttr->pExpr1[i], pExpr);
 
     if (pQueryAttr->pExpr1[i].base.functionId == TSDB_FUNC_ARITHM) {
       for (int32_t j = 0; j < pQueryAttr->pExpr1[i].base.numOfParams; ++j) {
@@ -3609,13 +3678,21 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
   }
 
   // for simple table, not for super table
-  int32_t code = createSecondaryExpr(pQueryAttr, pQueryInfo, pTableMetaInfo);
-  if (code != TSDB_CODE_SUCCESS) {
-    return code;
+  if (pQueryInfo->arithmeticOnAgg) {
+    pQueryAttr->numOfExpr2 = (int32_t) taosArrayGetSize(pQueryInfo->exprList1);
+    pQueryAttr->pExpr2 = calloc(pQueryAttr->numOfExpr2, sizeof(SExprInfo));
+    for(int32_t i = 0; i < pQueryAttr->numOfExpr2; ++i) {
+      SExprInfo* p = taosArrayGetP(pQueryInfo->exprList1, i);
+      tscExprAssign(&pQueryAttr->pExpr2[i], p);
+    }
   }
+//  int32_t code = createProjectionExpr(pQueryInfo, pTableMetaInfo, &pQueryAttr->pExpr2, &pQueryAttr->numOfExpr2);
+//  if (code != TSDB_CODE_SUCCESS) {
+//    return code;
+//  }
 
   // tag column info
-  code = createTagColumnInfo(pQueryAttr, pQueryInfo, pTableMetaInfo);
+  int32_t code = createTagColumnInfo(pQueryAttr, pQueryInfo, pTableMetaInfo);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
diff --git a/src/common/inc/tname.h b/src/common/inc/tname.h
index f37a4d9a36..3c39716528 100644
--- a/src/common/inc/tname.h
+++ b/src/common/inc/tname.h
@@ -44,8 +44,8 @@ typedef struct SResPair {
 // the structure for sql function in select clause
 typedef struct SSqlExpr {
   char      aliasName[TSDB_COL_NAME_LEN];  // as aliasName
+  char      token[TSDB_COL_NAME_LEN];      // original token
   SColIndex colInfo;
-
   uint64_t  uid;            // refactor use the pointer
 
   int16_t   functionId;     // function id in aAgg array
@@ -92,8 +92,6 @@ size_t tableIdPrefix(const char* name, char* prefix, int32_t len);
 
 void extractTableNameFromToken(SStrToken *pToken, SStrToken* pTable);
 
-//SSchema tGetTbnameColumnSchema();
-
 SSchema tGetBlockDistColumnSchema();
 
 SSchema tGetUserSpecifiedColumnSchema(tVariant* pVal, SStrToken* exprStr, const char* name);
diff --git a/src/common/src/tarithoperator.c b/src/common/src/tarithoperator.c
index 1cb667d259..b37e358b9c 100644
--- a/src/common/src/tarithoperator.c
+++ b/src/common/src/tarithoperator.c
@@ -2569,6 +2569,7 @@ _arithmetic_operator_fn_t getArithmeticOperatorFn(int32_t arithmeticOptr) {
     case TSDB_BINARY_OP_REMAINDER:
       return vectorRemainder;
     default:
+      assert(0);
       return NULL;
   }
 }
diff --git a/src/common/src/texpr.c b/src/common/src/texpr.c
index 4334a0de26..f2dd3890a1 100644
--- a/src/common/src/texpr.c
+++ b/src/common/src/texpr.c
@@ -13,6 +13,7 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <texpr.h>
 #include "os.h"
 
 #include "texpr.h"
@@ -465,27 +466,29 @@ tExprNode* exprTreeFromTableName(const char* tbnameCond) {
   return expr;
 }
 
-tExprNode* exprdup(tExprNode* pTree) {
-  if (pTree == NULL) {
+tExprNode* exprdup(tExprNode* pNode) {
+  if (pNode == NULL) {
     return NULL;
   }
 
-  tExprNode* pNode = calloc(1, sizeof(tExprNode));
-  if (pTree->nodeType == TSQL_NODE_EXPR) {
-    tExprNode* pLeft  = exprdup(pTree->_node.pLeft);
-    tExprNode* pRight = exprdup(pTree->_node.pRight);
+  tExprNode* pCloned = calloc(1, sizeof(tExprNode));
+  if (pNode->nodeType == TSQL_NODE_EXPR) {
+    tExprNode* pLeft  = exprdup(pNode->_node.pLeft);
+    tExprNode* pRight = exprdup(pNode->_node.pRight);
 
-    pNode->nodeType     = TSQL_NODE_EXPR;
-    pNode->_node.pLeft  = pLeft;
-    pNode->_node.pRight = pRight;
-  } else if (pTree->nodeType == TSQL_NODE_VALUE) {
-    pNode->pVal = calloc(1, sizeof(tVariant));
-    tVariantAssign(pNode->pVal, pTree->pVal);
-  } else if (pTree->nodeType == TSQL_NODE_COL) {
-    pNode->pSchema = calloc(1, sizeof(SSchema));
-    *pNode->pSchema = *pTree->pSchema;
+    pCloned->_node.pLeft  = pLeft;
+    pCloned->_node.pRight = pRight;
+    pCloned->_node.optr  = pNode->_node.optr;
+    pCloned->_node.hasPK = pNode->_node.hasPK;
+  } else if (pNode->nodeType == TSQL_NODE_VALUE) {
+    pCloned->pVal = calloc(1, sizeof(tVariant));
+    tVariantAssign(pCloned->pVal, pNode->pVal);
+  } else if (pNode->nodeType == TSQL_NODE_COL) {
+    pCloned->pSchema = calloc(1, sizeof(SSchema));
+    *pCloned->pSchema = *pNode->pSchema;
   }
 
-  return pNode;
+  pCloned->nodeType = pNode->nodeType;
+  return pCloned;
 }
 
diff --git a/src/query/inc/qExecutor.h b/src/query/inc/qExecutor.h
index b9361650e9..b8835ea3e2 100644
--- a/src/query/inc/qExecutor.h
+++ b/src/query/inc/qExecutor.h
@@ -70,13 +70,13 @@ typedef struct SResultRowPool {
   SArray* pData;    // SArray<void*>
 } SResultRowPool;
 
-typedef struct SSqlGroupbyExpr {
+typedef struct SGroupbyExpr {
   int16_t tableIndex;
   SArray* columnInfo;  // SArray<SColIndex>, group by columns information
-  int16_t numOfGroupCols;
+  int16_t numOfGroupCols;  // todo remove it
   int16_t orderIndex;  // order by column index
   int16_t orderType;   // order by type: asc/desc
-} SSqlGroupbyExpr;
+} SGroupbyExpr;
 
 typedef struct SResultRow {
   int32_t       pageId;      // pageId & rowId is the position of current result in disk-based output buffer
@@ -216,7 +216,7 @@ typedef struct SQueryAttr {
   int32_t          intermediateResultRowSize; // intermediate result row size, in case of top-k query.
   int32_t          maxTableColumnWidth;
   int32_t          tagLen;           // tag value length of current query
-  SSqlGroupbyExpr* pGroupbyExpr;
+  SGroupbyExpr* pGroupbyExpr;
 
   SExprInfo*       pExpr1;
   SExprInfo*       pExpr2;
@@ -362,7 +362,7 @@ typedef struct SQueryParam {
 
   SColIndex       *pGroupColIndex;
   SColumnInfo     *pTagColumnInfo;
-  SSqlGroupbyExpr *pGroupbyExpr;
+  SGroupbyExpr *pGroupbyExpr;
   int32_t          tableScanOperator;
   SArray          *pOperator;
 } SQueryParam;
@@ -536,8 +536,8 @@ int32_t createQueryFunc(SQueriedTableInfo* pTableInfo, int32_t numOfOutput, SExp
 int32_t createIndirectQueryFuncExprFromMsg(SQueryTableMsg *pQueryMsg, int32_t numOfOutput, SExprInfo **pExprInfo,
                                            SSqlExpr **pExpr, SExprInfo *prevExpr);
 
-SSqlGroupbyExpr *createGroupbyExprFromMsg(SQueryTableMsg *pQueryMsg, SColIndex *pColIndex, int32_t *code);
-SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SSqlGroupbyExpr *pGroupbyExpr, SExprInfo *pExprs,
+SGroupbyExpr *createGroupbyExprFromMsg(SQueryTableMsg *pQueryMsg, SColIndex *pColIndex, int32_t *code);
+SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SGroupbyExpr *pGroupbyExpr, SExprInfo *pExprs,
                         SExprInfo *pSecExprs, STableGroupInfo *pTableGroupInfo, SColumnInfo* pTagCols, int32_t vgId, char* sql, uint64_t *qId);
 
 int32_t initQInfo(STsBufInfo* pTsBufInfo, void* tsdb, void* sourceOptr, SQInfo* pQInfo, SQueryParam* param, char* start,
diff --git a/src/query/inc/qFill.h b/src/query/inc/qFill.h
index 00ac86caf4..4c76bdb035 100644
--- a/src/query/inc/qFill.h
+++ b/src/query/inc/qFill.h
@@ -62,7 +62,7 @@ typedef struct SFillInfo {
 
   SFillColInfo* pFillCol;         // column info for fill operations
   SFillTagColInfo* pTags;         // tags value for filling gap
-  void*     handle;               // for dubug purpose
+  void*     handle;               // for debug purpose
 } SFillInfo;
 
 typedef struct SPoint {
diff --git a/src/query/inc/qPlan.h b/src/query/inc/qPlan.h
index 8f35565e4b..30c0f8db4e 100644
--- a/src/query/inc/qPlan.h
+++ b/src/query/inc/qPlan.h
@@ -16,7 +16,38 @@
 #ifndef TDENGINE_QPLAN_H
 #define TDENGINE_QPLAN_H
 
-//TODO refactor
+struct SQueryInfo;
+
+typedef struct SQueryNodeBasicInfo {
+  int32_t type;
+  char   *name;
+} SQueryNodeBasicInfo;
+
+typedef struct SQueryTableInfo {
+  char     *tableName;
+  STableId  id;
+} SQueryTableInfo;
+
+typedef struct SQueryNode {
+  SQueryNodeBasicInfo info;
+  SQueryTableInfo    tableInfo;
+  SSchema           *pSchema;      // the schema of the input SSDatablock
+  int32_t            numOfCols;    // number of input columns
+  SExprInfo         *pExpr;        // the query functions or sql aggregations
+  int32_t            numOfOutput;  // number of result columns, which is also the number of pExprs
+
+  void              *pExtInfo;     // additional information
+  // previous operator to generated result for current node to process
+  // in case of join, multiple prev nodes exist.
+  SArray            *pPrevNodes;// upstream nodes
+  struct SQueryNode *nextNode;
+} SQueryNode;
+
+SQueryNode* qCreateQueryPlan(struct SQueryInfo* pQueryInfo);
+void* qDestroyQueryPlan(SQueryNode* pQueryNode);
+
+char* queryPlanToString(SQueryNode* pQueryNode);
+
 SArray* createTableScanPlan(SQueryAttr* pQueryAttr);
 SArray* createExecOperatorPlan(SQueryAttr* pQueryAttr);
 SArray* createGlobalMergePlan(SQueryAttr* pQueryAttr);
diff --git a/src/query/inc/qUtil.h b/src/query/inc/qUtil.h
index 3ca6d96746..c340d8f952 100644
--- a/src/query/inc/qUtil.h
+++ b/src/query/inc/qUtil.h
@@ -47,6 +47,8 @@ void    clearResultRow(SQueryRuntimeEnv* pRuntimeEnv, SResultRow* pResultRow, in
 
 SResultRowCellInfo* getResultCell(const SResultRow* pRow, int32_t index, int32_t* offset);
 
+void* destroyQueryFuncExpr(SExprInfo* pExprInfo, int32_t numOfExpr);
+
 static FORCE_INLINE SResultRow *getResultRow(SResultRowInfo *pResultRowInfo, int32_t slot) {
   assert(pResultRowInfo != NULL && slot >= 0 && slot < pResultRowInfo->size);
   return pResultRowInfo->pResult[slot];
diff --git a/src/query/src/qAggMain.c b/src/query/src/qAggMain.c
index 3b1ffa46d9..844817c144 100644
--- a/src/query/src/qAggMain.c
+++ b/src/query/src/qAggMain.c
@@ -3700,7 +3700,7 @@ char *getArithColumnData(void *param, const char* name, int32_t colId) {
     }
   }
   
-  assert(index >= 0 /*&& colId >= 0*/);
+  assert(index >= 0);
   return pSupport->data[index] + pSupport->offset * pSupport->colList[index].bytes;
 }
 
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index feaa205c3e..79e9e94406 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -189,7 +189,7 @@ static void destroyOperatorInfo(SOperatorInfo* pOperator);
 
 static int32_t doCopyToSDataBlock(SQueryRuntimeEnv* pRuntimeEnv, SGroupResInfo* pGroupResInfo, int32_t orderType, SSDataBlock* pBlock);
 
-static int32_t getGroupbyColumnIndex(SSqlGroupbyExpr *pGroupbyExpr, SSDataBlock* pDataBlock);
+static int32_t getGroupbyColumnIndex(SGroupbyExpr *pGroupbyExpr, SSDataBlock* pDataBlock);
 static int32_t setGroupResultOutputBuf(SQueryRuntimeEnv *pRuntimeEnv, SGroupbyOperatorInfo *pInfo, int32_t numOfCols, char *pData, int16_t type, int16_t bytes, int32_t groupIndex);
 
 static void initCtxOutputBuffer(SQLFunctionCtx* pCtx, int32_t size);
@@ -1418,7 +1418,7 @@ static int32_t setGroupResultOutputBuf(SQueryRuntimeEnv *pRuntimeEnv, SGroupbyOp
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t getGroupbyColumnIndex(SSqlGroupbyExpr *pGroupbyExpr, SSDataBlock* pDataBlock) {
+static int32_t getGroupbyColumnIndex(SGroupbyExpr *pGroupbyExpr, SSDataBlock* pDataBlock) {
   for (int32_t k = 0; k < pGroupbyExpr->numOfGroupCols; ++k) {
     SColIndex* pColIndex = taosArrayGet(pGroupbyExpr->columnInfo, k);
     if (TSDB_COL_IS_TAG(pColIndex->flag)) {
@@ -6603,13 +6603,13 @@ int32_t createIndirectQueryFuncExprFromMsg(SQueryTableMsg* pQueryMsg, int32_t nu
   return TSDB_CODE_SUCCESS;
 }
 
-SSqlGroupbyExpr *createGroupbyExprFromMsg(SQueryTableMsg *pQueryMsg, SColIndex *pColIndex, int32_t *code) {
+SGroupbyExpr *createGroupbyExprFromMsg(SQueryTableMsg *pQueryMsg, SColIndex *pColIndex, int32_t *code) {
   if (pQueryMsg->numOfGroupCols == 0) {
     return NULL;
   }
 
   // using group by tag columns
-  SSqlGroupbyExpr *pGroupbyExpr = (SSqlGroupbyExpr *)calloc(1, sizeof(SSqlGroupbyExpr));
+  SGroupbyExpr *pGroupbyExpr = (SGroupbyExpr *)calloc(1, sizeof(SGroupbyExpr));
   if (pGroupbyExpr == NULL) {
     *code = TSDB_CODE_QRY_OUT_OF_MEMORY;
     return NULL;
@@ -6770,7 +6770,7 @@ FORCE_INLINE bool checkQIdEqual(void *qHandle, uint64_t qId) {
   return ((SQInfo *)qHandle)->qId == qId;
 }
 
-SQInfo* createQInfoImpl(SQueryTableMsg* pQueryMsg, SSqlGroupbyExpr* pGroupbyExpr, SExprInfo* pExprs,
+SQInfo* createQInfoImpl(SQueryTableMsg* pQueryMsg, SGroupbyExpr* pGroupbyExpr, SExprInfo* pExprs,
                         SExprInfo* pSecExprs, STableGroupInfo* pTableGroupInfo, SColumnInfo* pTagCols, int32_t vgId,
                         char* sql, uint64_t *qId) {
   int16_t numOfCols = pQueryMsg->numOfCols;
@@ -7073,7 +7073,7 @@ static void doDestroyTableQueryInfo(STableGroupInfo* pTableqinfoGroupInfo) {
   pTableqinfoGroupInfo->numOfTables = 0;
 }
 
-static void* destroyQueryFuncExpr(SExprInfo* pExprInfo, int32_t numOfExpr) {
+void* destroyQueryFuncExpr(SExprInfo* pExprInfo, int32_t numOfExpr) {
   if (pExprInfo == NULL) {
     assert(numOfExpr == 0);
     return NULL;
diff --git a/src/query/src/qPlan.c b/src/query/src/qPlan.c
index 89a3e07b10..fdfbf5e5c3 100644
--- a/src/query/src/qPlan.c
+++ b/src/query/src/qPlan.c
@@ -1,12 +1,14 @@
-#include <tscUtil.h>
 #include "os.h"
+#include "qExecutor.h"
 #include "qUtil.h"
 #include "texpr.h"
+#include "qPlan.h"
 #include "tsclient.h"
+#include "tscUtil.h"
 
-#define QNODE_PROJECT       1
-#define QNODE_FILTER        2
-#define QNODE_TABLESCAN     3
+#define QNODE_TAGSCAN       1
+#define QNODE_TABLESCAN     2
+#define QNODE_PROJECT       3
 #define QNODE_AGGREGATE     4
 #define QNODE_GROUPBY       5
 #define QNODE_LIMIT         6
@@ -18,126 +20,492 @@
 #define QNODE_SESSIONWINDOW 12
 #define QNODE_FILL          13
 
-typedef struct SQueryNodeBasicInfo {
-  int32_t type;
-  char   *name;
-} SQueryNodeBasicInfo;
+typedef struct SFillEssInfo {
+  int32_t  fillType;  // fill type
+  int64_t *val;      // fill value
+} SFillEssInfo;
 
-typedef struct SQueryNode {
-  SQueryNodeBasicInfo info;
-//  char              *name;         // the name of logic node
-//  int32_t            type;         // the type of logic node
-
-  SSchema           *pSchema;      // the schema of the input SSDatablock
-  int32_t            numOfCols;    // number of input columns
-  SExprInfo         *pExpr;        // the query functions or sql aggregations
-  int32_t            numOfOutput;  // number of result columns, which is also the number of pExprs
-
-  // previous operator to generated result for current node to process
-  // in case of join, multiple prev nodes exist.
-  SArray            *pPrevNodes;// upstream nodes
-  struct SQueryNode *nextNode;
-} SQueryNode;
-
-static SQueryNode* createQueryNode(int32_t type, const char* name, SQueryNode** prev, int32_t numOfPrev) {
+static SQueryNode* createQueryNode(int32_t type, const char* name, SQueryNode** prev,
+                                   int32_t numOfPrev, SExprInfo** pExpr, int32_t numOfOutput, SQueryTableInfo* pTableInfo,
+                                   void* pExtInfo) {
   SQueryNode* pNode = calloc(1, sizeof(SQueryNode));
+
   pNode->info.type = type;
   pNode->info.name = strdup(name);
+
+  if (pTableInfo->id.uid != 0) { // it is a true table
+    pNode->tableInfo.id = pTableInfo->id;
+    pNode->tableInfo.tableName = strdup(pTableInfo->tableName);
+  }
+
+  pNode->numOfOutput = numOfOutput;
+  pNode->pExpr = calloc(numOfOutput, sizeof(SExprInfo));
+  for(int32_t i = 0; i < numOfOutput; ++i) {
+    tscExprAssign(&pNode->pExpr[i], pExpr[i]);
+  }
+
   pNode->pPrevNodes = taosArrayInit(4, POINTER_BYTES);
   for(int32_t i = 0; i < numOfPrev; ++i) {
     taosArrayPush(pNode->pPrevNodes, &prev[i]);
   }
 
+  switch(type) {
+    case QNODE_TABLESCAN: {
+      STimeWindow* window = calloc(1, sizeof(STimeWindow));
+      memcpy(window, pExtInfo, sizeof(STimeWindow));
+      pNode->pExtInfo = window;
+      break;
+    }
+
+    case QNODE_TIMEWINDOW: {
+      SInterval* pInterval = calloc(1, sizeof(SInterval));
+      pNode->pExtInfo = pInterval;
+      memcpy(pInterval, pExtInfo, sizeof(SInterval));
+      break;
+    }
+
+    case QNODE_GROUPBY: {
+      SGroupbyExpr* p = (SGroupbyExpr*) pExtInfo;
+      SGroupbyExpr* pGroupbyExpr = calloc(1, sizeof(SGroupbyExpr));
+
+      pGroupbyExpr->tableIndex = p->tableIndex;
+      pGroupbyExpr->orderType  = p->orderType;
+      pGroupbyExpr->orderIndex = p->orderIndex;
+      pGroupbyExpr->numOfGroupCols = p->numOfGroupCols;
+      pGroupbyExpr->columnInfo = taosArrayDup(p->columnInfo);
+      pNode->pExtInfo = pGroupbyExpr;
+      break;
+    }
+
+    case QNODE_FILL: { // todo !!
+      pNode->pExtInfo = pExtInfo;
+      break;
+    }
+
+    case QNODE_LIMIT: {
+      pNode->pExtInfo = calloc(1, sizeof(SLimitVal));
+      memcpy(pNode->pExtInfo, pExtInfo, sizeof(SLimitVal));
+      break;
+    }
+  }
   return pNode;
 }
 
-static SQueryNode* doCreateQueryPlanForOneTable(SQueryInfo* pQueryInfo) {
-  SQueryNode* pNode = createQueryNode(QNODE_TABLESCAN, "", NULL, 0);
+static SQueryNode* doAddTableColumnNode(SQueryInfo* pQueryInfo, STableMetaInfo* pTableMetaInfo,
+                                        SQueryTableInfo* info, SArray* pExprs, SArray* tableCols) {
+  if (pQueryInfo->onlyTagQuery) {
+    int32_t     num = taosArrayGetSize(pExprs);
+    SQueryNode* pNode = createQueryNode(QNODE_TAGSCAN, "TableTagScan", NULL, 0, pExprs->pData, num, info, NULL);
 
-  // check for filter
-  if (pQueryInfo->hasFilter) {
-    pNode = createQueryNode(QNODE_FILTER, "", &pNode, 1);
+    if (pQueryInfo->distinctTag) {
+      pNode = createQueryNode(QNODE_DISTINCT, "Distinct", &pNode, 1, pExprs->pData, num, info, NULL);
+    }
+
+    return pNode;
   }
 
-  if (pQueryInfo->distinctTag) {
-    pNode = createQueryNode(QNODE_DISTINCT, "", &pNode, 0);
+  STimeWindow* window = &pQueryInfo->window;
+  SQueryNode*  pNode = createQueryNode(QNODE_TABLESCAN, "TableScan", NULL, 0, NULL, 0,
+      info, window);
+  if (pQueryInfo->projectionQuery) {
+    int32_t numOfOutput = taosArrayGetSize(pExprs);
+    pNode = createQueryNode(QNODE_PROJECT, "Projection", &pNode, 1, pExprs->pData, numOfOutput, info, NULL);
+  } else {
+    // table source column projection, generate the projection expr
+    int32_t     numOfCols = taosArrayGetSize(tableCols);
+    SExprInfo** pExpr = calloc(numOfCols, POINTER_BYTES);
+    SSchema*    pSchema = pTableMetaInfo->pTableMeta->schema;
 
-  } else if (pQueryInfo->projectionQuery) {
-    pNode = createQueryNode(QNODE_PROJECT, "", &pNode, 1);
-  } else {  // check for aggregation
+    for (int32_t i = 0; i < numOfCols; ++i) {
+      SColumn* pCol = taosArrayGetP(tableCols, i);
+
+      SColumnIndex index = {.tableIndex = 0, .columnIndex = pCol->columnIndex};
+      SExprInfo*   p = tscExprCreate(pQueryInfo, TSDB_FUNC_PRJ, &index, pCol->info.type, pCol->info.bytes,
+                                     pCol->info.colId, 0, TSDB_COL_NORMAL);
+      strncpy(p->base.aliasName, pSchema[pCol->columnIndex].name, tListLen(p->base.aliasName));
+
+      pExpr[i] = p;
+    }
+
+    pNode = createQueryNode(QNODE_PROJECT, "Projection", &pNode, 1, pExpr, numOfCols, info, NULL);
+    for (int32_t i = 0; i < numOfCols; ++i) {
+      destroyQueryFuncExpr(pExpr[i], 1);
+    }
+    tfree(pExpr);
+  }
+
+  return pNode;
+}
+
+static SQueryNode* doCreateQueryPlanForOneTableImpl(SQueryInfo* pQueryInfo, SQueryNode* pNode, SQueryTableInfo* info,
+    SArray* pExprs) {
+    // check for aggregation
     if (pQueryInfo->interval.interval > 0) {
-      pNode = createQueryNode(QNODE_TIMEWINDOW, "", &pNode, 1);
+      int32_t numOfOutput = taosArrayGetSize(pExprs);
+
+      pNode = createQueryNode(QNODE_TIMEWINDOW, "TimeWindowAgg", &pNode, 1, pExprs->pData, numOfOutput, info,
+                              &pQueryInfo->interval);
     } else if (pQueryInfo->groupbyColumn) {
-      pNode = createQueryNode(QNODE_GROUPBY, "", &pNode, 1);
+      int32_t numOfOutput = taosArrayGetSize(pExprs);
+      pNode = createQueryNode(QNODE_GROUPBY, "Groupby", &pNode, 1, pExprs->pData, numOfOutput, info,
+                              &pQueryInfo->groupbyExpr);
     } else if (pQueryInfo->sessionWindow.gap > 0) {
-      pNode = createQueryNode(QNODE_SESSIONWINDOW, "", &pNode, 1);
+      pNode = createQueryNode(QNODE_SESSIONWINDOW, "SessionWindowAgg", &pNode, 1, NULL, 0, info, NULL);
     } else if (pQueryInfo->simpleAgg) {
-      pNode = createQueryNode(QNODE_AGGREGATE, "", &pNode, 1);
+      int32_t numOfOutput = taosArrayGetSize(pExprs);
+      pNode = createQueryNode(QNODE_AGGREGATE, "Aggregate", &pNode, 1, pExprs->pData, numOfOutput, info, NULL);
     }
 
-    if (pQueryInfo->havingFieldNum > 0) {
-      pNode = createQueryNode(QNODE_FILTER, "", &pNode, 1);
-    }
-
-    if (pQueryInfo->arithmeticOnAgg) {
-      pNode = createQueryNode(QNODE_PROJECT, "", &pNode, 1);
+    if (pQueryInfo->havingFieldNum > 0 || pQueryInfo->arithmeticOnAgg) {
+      int32_t numOfExpr = taosArrayGetSize(pQueryInfo->exprList1);
+      pNode =
+          createQueryNode(QNODE_PROJECT, "Projection", &pNode, 1, pQueryInfo->exprList1->pData, numOfExpr, info, NULL);
     }
 
     if (pQueryInfo->fillType != TSDB_FILL_NONE) {
-      pNode = createQueryNode(QNODE_FILL, "", &pNode, 1);
+      SFillEssInfo* pInfo = calloc(1, sizeof(SFillEssInfo));
+      pInfo->fillType = pQueryInfo->fillType;
+      pInfo->val = calloc(pNode->numOfOutput, sizeof(int64_t));
+      memcpy(pInfo->val, pQueryInfo->fillVal, pNode->numOfOutput);
+
+      pNode = createQueryNode(QNODE_FILL, "Fill", &pNode, 1, NULL, 0, info, pInfo);
     }
-  }
+
 
   if (pQueryInfo->limit.limit != -1 || pQueryInfo->limit.offset != 0) {
-    pNode = createQueryNode(QNODE_LIMIT, "", &pNode, 1);
+    pNode = createQueryNode(QNODE_LIMIT, "Limit", &pNode, 1, NULL, 0, info, &pQueryInfo->limit);
   }
 
   return pNode;
 }
 
-SArray* qCreateQueryPlan(SQueryInfo* pQueryInfo) {
-  // join and subquery
+static SQueryNode* doCreateQueryPlanForOneTable(SQueryInfo* pQueryInfo, STableMetaInfo* pTableMetaInfo, SArray* pExprs,
+                                                SArray* tableCols) {
+  char name[TSDB_TABLE_FNAME_LEN] = {0};
+  tNameExtractFullName(&pTableMetaInfo->name, name);
+
+  SQueryTableInfo info = {.tableName = strdup(name), .id = pTableMetaInfo->pTableMeta->id,};
+
+  // handle the only tag query
+  SQueryNode* pNode = doAddTableColumnNode(pQueryInfo, pTableMetaInfo, &info, pExprs, tableCols);
+  if (pQueryInfo->onlyTagQuery) {
+    tfree(info.tableName);
+    return pNode;
+  }
+
+  SQueryNode* pNode1 = doCreateQueryPlanForOneTableImpl(pQueryInfo, pNode, &info, pExprs);
+  tfree(info.tableName);
+  return pNode1;
+}
+
+SArray* createQueryPlanImpl(SQueryInfo* pQueryInfo) {
   SArray* upstream = NULL;
-  if (pQueryInfo->pUpstream != NULL) {  // subquery in the from clause
+
+  if (pQueryInfo->pUpstream != NULL && taosArrayGetSize(pQueryInfo->pUpstream) > 0) {  // subquery in the from clause
     upstream = taosArrayInit(4, POINTER_BYTES);
 
     size_t size = taosArrayGetSize(pQueryInfo->pUpstream);
     for(int32_t i = 0; i < size; ++i) {
       SQueryInfo* pq = taosArrayGet(pQueryInfo->pUpstream, i);
-      SArray* p = qCreateQueryPlan(pq);
+      SArray* p = createQueryPlanImpl(pq);
       taosArrayPushBatch(upstream, p->pData, (int32_t) taosArrayGetSize(p));
     }
   }
 
   if (pQueryInfo->numOfTables > 1) {  // it is a join query
     // 1. separate the select clause according to table
-    int32_t tableIndex = 0;
-    STableMetaInfo* pTableMetaInfo = pQueryInfo->pTableMetaInfo[tableIndex];
-    uint64_t uid = pTableMetaInfo->pTableMeta->id.uid;
+    upstream = taosArrayInit(5, POINTER_BYTES);
 
-    SArray* exprList = taosArrayInit(4, POINTER_BYTES);
-    if (tscSqlExprCopy(exprList, pQueryInfo->exprList, uid, true) != 0) {
-      terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
-      exit(-1);
+    for(int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
+      STableMetaInfo* pTableMetaInfo = pQueryInfo->pTableMetaInfo[i];
+      uint64_t        uid = pTableMetaInfo->pTableMeta->id.uid;
+
+      SArray* exprList = taosArrayInit(4, POINTER_BYTES);
+      if (tscExprCopy(exprList, pQueryInfo->exprList, uid, true) != 0) {
+        terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
+        exit(-1);
+      }
+
+      SArray* tableColumnList = taosArrayInit(4, sizeof(SColumn));
+      tscColumnListCopy(tableColumnList, pQueryInfo->colList, uid);
+
+      // 2. create the query execution node
+      char name[TSDB_TABLE_FNAME_LEN] = {0};
+      tNameExtractFullName(&pTableMetaInfo->name, name);
+      SQueryTableInfo info = {.tableName = strdup(name), .id = pTableMetaInfo->pTableMeta->id,};
+      SQueryNode* pNode = doAddTableColumnNode(pQueryInfo, pTableMetaInfo, &info, exprList, tableColumnList);
+
+      taosArrayPush(upstream, &pNode);
     }
 
-    SArray* tableColumnList = taosArrayInit(4, sizeof(SColumn));
-    tscColumnListCopy(tableColumnList, pQueryInfo->colList, uid);
+    // 3. add the join node here
+    SQueryTableInfo info = {0};
+    int32_t num = taosArrayGetSize(pQueryInfo->exprList);
+    SQueryNode* pNode = createQueryNode(QNODE_JOIN, "Join", upstream->pData, pQueryInfo->numOfTables,
+        pQueryInfo->exprList->pData, num, &info, NULL);
 
-
-    // 2.
-    SQueryNode* pNode = doCreateQueryPlanForOneTable(pQueryInfo);
-    UNUSED(pNode);
-  } else {  // only one table, normal query process
-    SQueryNode* pNode = doCreateQueryPlanForOneTable(pQueryInfo);
-    UNUSED(pNode);
+    // 4. add the aggregation or projection execution node
+    pNode = doCreateQueryPlanForOneTableImpl(pQueryInfo, pNode, &info, pQueryInfo->exprList);
+    upstream = taosArrayInit(5, POINTER_BYTES);
+    taosArrayPush(upstream, &pNode);
+  } else { // only one table, normal query process
+    STableMetaInfo* pTableMetaInfo = pQueryInfo->pTableMetaInfo[0];
+    SQueryNode* pNode = doCreateQueryPlanForOneTable(pQueryInfo, pTableMetaInfo, pQueryInfo->exprList, pQueryInfo->colList);
+    upstream = taosArrayInit(5, POINTER_BYTES);
+    taosArrayPush(upstream, &pNode);
   }
 
+  return upstream;
+}
+
+SQueryNode* qCreateQueryPlan(SQueryInfo* pQueryInfo) {
+  SArray* upstream = createQueryPlanImpl(pQueryInfo);
+  assert(taosArrayGetSize(upstream) == 1);
+
+  SQueryNode* p = taosArrayGetP(upstream, 0);
+  taosArrayDestroy(upstream);
+
+  return p;
+}
+
+static void doDestroyQueryNode(SQueryNode* pQueryNode) {
+  tfree(pQueryNode->pExtInfo);
+  tfree(pQueryNode->pSchema);
+  tfree(pQueryNode->info.name);
+
+  tfree(pQueryNode->tableInfo.tableName);
+
+  pQueryNode->pExpr = destroyQueryFuncExpr(pQueryNode->pExpr, pQueryNode->numOfOutput);
+
+  if (pQueryNode->pPrevNodes != NULL) {
+    int32_t size = taosArrayGetSize(pQueryNode->pPrevNodes);
+    for(int32_t i = 0; i < size; ++i) {
+      SQueryNode* p = taosArrayGetP(pQueryNode->pPrevNodes, i);
+      doDestroyQueryNode(p);
+    }
+
+    taosArrayDestroy(pQueryNode->pPrevNodes);
+  }
+
+  tfree(pQueryNode);
+}
+
+void* qDestroyQueryPlan(SQueryNode* pQueryNode) {
+  if (pQueryNode == NULL) {
+    return NULL;
+  }
+
+  doDestroyQueryNode(pQueryNode);
   return NULL;
 }
 
-char* queryPlanToString() {
-  return NULL;
+bool hasAliasName(SExprInfo* pExpr) {
+  assert(pExpr != NULL);
+  return strncmp(pExpr->base.token, pExpr->base.aliasName, tListLen(pExpr->base.aliasName)) != 0;
+}
+
+static int32_t doPrintPlan(char* buf, SQueryNode* pQueryNode, int32_t level, int32_t totalLen) {
+  if (level > 0) {
+    sprintf(buf + totalLen, "%*c", level, ' ');
+    totalLen += level;
+  }
+
+  int32_t len1 = sprintf(buf + totalLen, "%s(", pQueryNode->info.name);
+  int32_t len = len1 + totalLen;
+
+  switch(pQueryNode->info.type) {
+    case QNODE_TABLESCAN: {
+      STimeWindow* win = (STimeWindow*) pQueryNode->pExtInfo;
+      len1 = sprintf(buf + len, "%s #0x%"PRIx64") time_range: %"PRId64" - %"PRId64"\n", pQueryNode->tableInfo.tableName,
+                             pQueryNode->tableInfo.id.uid, win->skey, win->ekey);
+      len += len1;
+      break;
+    }
+
+    case QNODE_PROJECT: {
+      len1 = sprintf(buf + len, "cols: ");
+      len += len1;
+
+      for(int32_t i = 0; i < pQueryNode->numOfOutput; ++i) {
+        SSqlExpr* p = &pQueryNode->pExpr[i].base;
+        len1 = sprintf(buf + len, "[%s #%d]", p->aliasName, p->resColId);
+        len += len1;
+
+        if (i < pQueryNode->numOfOutput - 1) {
+          len1 = sprintf(buf + len, ", ");
+          len += len1;
+        }
+      }
+
+      len1 = sprintf(buf + len, ")");
+      len += len1;
+
+      //todo print filter info
+      len1 = sprintf(buf + len, " filters:(nil)\n");
+      len += len1;
+      break;
+    }
+
+    case QNODE_AGGREGATE: {
+      for(int32_t i = 0; i < pQueryNode->numOfOutput; ++i) {
+        SSqlExpr* pExpr = &pQueryNode->pExpr[i].base;
+        if (hasAliasName(&pQueryNode->pExpr[i])) {
+          len1 = sprintf(buf + len,"[%s #%s]", pExpr->token, pExpr->aliasName);
+        } else {
+          len1 = sprintf(buf + len,"[%s]", pExpr->token);
+        }
+
+        len += len1;
+        if (i < pQueryNode->numOfOutput - 1) {
+          len1 = sprintf(buf + len, ", ");
+          len += len1;
+        }
+      }
+
+      len1 = sprintf(buf + len, ")\n");
+      len += len1;
+      break;
+    }
+
+    case QNODE_TIMEWINDOW: {
+      for(int32_t i = 0; i < pQueryNode->numOfOutput; ++i) {
+        SSqlExpr* pExpr = &pQueryNode->pExpr[i].base;
+        if (hasAliasName(&pQueryNode->pExpr[i])) {
+          len1 = sprintf(buf + len,"[%s #%s]", pExpr->token, pExpr->aliasName);
+        } else {
+          len1 = sprintf(buf + len,"[%s]", pExpr->token);
+        }
+
+        len += len1;
+        if (i < pQueryNode->numOfOutput - 1) {
+          len1 = sprintf(buf + len,", ");
+          len += len1;
+        }
+      }
+
+      len1 = sprintf(buf + len,") ");
+      len += len1;
+
+      SInterval* pInterval = pQueryNode->pExtInfo;
+      len1 = sprintf(buf + len, "interval:%"PRId64"(%c), sliding:%"PRId64"(%c), offset:%"PRId64"\n", pInterval->interval,
+             pInterval->intervalUnit, pInterval->sliding, pInterval->slidingUnit, pInterval->offset);
+      len += len1;
+
+      break;
+    }
+
+    case QNODE_GROUPBY: {  // todo hide the invisible column
+      for(int32_t i = 0; i < pQueryNode->numOfOutput; ++i) {
+        SSqlExpr* pExpr = &pQueryNode->pExpr[i].base;
+
+        if (hasAliasName(&pQueryNode->pExpr[i])) {
+          len1 = sprintf(buf + len,"[%s #%s]", pExpr->token, pExpr->aliasName);
+        } else {
+          len1 = sprintf(buf + len,"[%s]", pExpr->token);
+        }
+
+        len += len1;
+        if (i < pQueryNode->numOfOutput - 1) {
+          len1 = sprintf(buf + len,", ");
+          len += len1;
+        }
+      }
+
+      SGroupbyExpr* pGroupbyExpr = pQueryNode->pExtInfo;
+      SColIndex* pIndex = taosArrayGet(pGroupbyExpr->columnInfo, 0);
+
+      len1 = sprintf(buf + len,") groupby_col: [%s #%d]\n", pIndex->name, pIndex->colId);
+      len += len1;
+
+      break;
+    }
+
+    case QNODE_FILL: {
+      SFillEssInfo* pEssInfo = pQueryNode->pExtInfo;
+      len1 = sprintf(buf + len,"%d", pEssInfo->fillType);
+      len += len1;
+
+      if (pEssInfo->fillType == TSDB_FILL_SET_VALUE) {
+        len1 = sprintf(buf + len,", val:");
+        len += len1;
+
+        // todo get the correct fill data type
+        for(int32_t i = 0; i < pQueryNode->numOfOutput; ++i) {
+          len1 = sprintf(buf + len,"%"PRId64, pEssInfo->val[i]);
+          len += len1;
+
+          if (i < pQueryNode->numOfOutput - 1) {
+            len1 = sprintf(buf + len,", ");
+            len += len1;
+          }
+        }
+      }
+
+      len1 = sprintf(buf + len,")\n");
+      len += len1;
+      break;
+    }
+
+    case QNODE_LIMIT: {
+      SLimitVal* pVal = pQueryNode->pExtInfo;
+      len1 = sprintf(buf + len,"limit: %"PRId64", offset: %"PRId64")\n", pVal->limit, pVal->offset);
+      len += len1;
+      break;
+    }
+
+    case QNODE_DISTINCT:
+    case QNODE_TAGSCAN: {
+      len1 = sprintf(buf + len,"cols: ");
+      len += len1;
+
+      for(int32_t i = 0; i < pQueryNode->numOfOutput; ++i) {
+        SSqlExpr* p = &pQueryNode->pExpr[i].base;
+        len1 = sprintf(buf + len,"[%s #%d]", p->aliasName, p->resColId);
+        len += len1;
+
+        if (i < pQueryNode->numOfOutput - 1) {
+          len1 = sprintf(buf + len,", ");
+          len += len1;
+        }
+      }
+
+      len1 = sprintf(buf + len,")\n");
+      len += len1;
+
+      break;
+    }
+
+    case QNODE_JOIN: {
+      //  print join condition
+      len1 = sprintf(buf + len, "\n");
+      len += len1;
+      break;
+    }
+  }
+
+  return len;
+}
+
+int32_t queryPlanToStringImpl(char* buf, SQueryNode* pQueryNode, int32_t level, int32_t totalLen) {
+  int32_t len = doPrintPlan(buf, pQueryNode, level, totalLen);
+
+  for(int32_t i = 0; i < taosArrayGetSize(pQueryNode->pPrevNodes); ++i) {
+    SQueryNode* p1 = taosArrayGetP(pQueryNode->pPrevNodes, i);
+    int32_t len1 = queryPlanToStringImpl(buf, p1, level + 1, len);
+    len = len1;
+  }
+
+  return len;
+}
+
+char* queryPlanToString(SQueryNode* pQueryNode) {
+  assert(pQueryNode);
+
+  char* buf = calloc(1, 4096);
+
+  int32_t len = sprintf(buf, "===== logic plan =====\n");
+  queryPlanToStringImpl(buf, pQueryNode, 0, len);
+  return buf;
 }
 
 SQueryNode* queryPlanFromString() {

From dbe026a8ef38a3e64a43837d2fceb5202686c196 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Thu, 6 May 2021 10:51:43 +0800
Subject: [PATCH 005/128] [td-3299]

---
 src/client/src/tscSubquery.c |  1 -
 src/query/src/qPlan.c        | 40 +++++++++++++++++++++++++++---------
 2 files changed, 30 insertions(+), 11 deletions(-)

diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index e1b42d8930..8903d528be 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -439,7 +439,6 @@ static void tscDestroyJoinSupporter(SJoinSupporter* pSupporter) {
     pSupporter->f = NULL;
   }
 
-
   if (pSupporter->pVgroupTables != NULL) {
     taosArrayDestroy(pSupporter->pVgroupTables);
     pSupporter->pVgroupTables = NULL;
diff --git a/src/query/src/qPlan.c b/src/query/src/qPlan.c
index fdfbf5e5c3..5e43469f7b 100644
--- a/src/query/src/qPlan.c
+++ b/src/query/src/qPlan.c
@@ -1,10 +1,11 @@
 #include "os.h"
+#include "tschemautil.h"
+#include "qPlan.h"
 #include "qExecutor.h"
 #include "qUtil.h"
 #include "texpr.h"
-#include "qPlan.h"
-#include "tsclient.h"
 #include "tscUtil.h"
+#include "tsclient.h"
 
 #define QNODE_TAGSCAN       1
 #define QNODE_TABLESCAN     2
@@ -226,13 +227,31 @@ SArray* createQueryPlanImpl(SQueryInfo* pQueryInfo) {
         exit(-1);
       }
 
-      SArray* tableColumnList = taosArrayInit(4, sizeof(SColumn));
-      tscColumnListCopy(tableColumnList, pQueryInfo->colList, uid);
-
       // 2. create the query execution node
       char name[TSDB_TABLE_FNAME_LEN] = {0};
       tNameExtractFullName(&pTableMetaInfo->name, name);
       SQueryTableInfo info = {.tableName = strdup(name), .id = pTableMetaInfo->pTableMeta->id,};
+
+      // 3. add the join columns (the tags and the primary timestamp column)
+      tscInsertPrimaryTsSourceColumn(pQueryInfo, info.id.uid);
+
+      SArray* tableColumnList = taosArrayInit(4, sizeof(SColumn));
+      tscColumnListCopy(tableColumnList, pQueryInfo->colList, uid);
+
+      // TODO add the tag column into the required column list
+      if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
+        int16_t tagColId = tscGetJoinTagColIdByUid(&pQueryInfo->tagCond, info.id.uid);
+        SSchema* s = tscGetColumnSchemaById(pTableMetaInfo->pTableMeta, tagColId);
+
+        SColumn* col    = calloc(1, sizeof(SColumn));
+        col->tableUid   = info.id.uid;
+        col->info.colId = tagColId;
+        col->info.type  = s->type;
+        col->info.bytes = s->bytes;
+        taosArrayPush(pQueryInfo->colList, &col);
+      }
+
+      // 4. add the projection query node
       SQueryNode* pNode = doAddTableColumnNode(pQueryInfo, pTableMetaInfo, &info, exprList, tableColumnList);
 
       taosArrayPush(upstream, &pNode);
@@ -315,9 +334,9 @@ static int32_t doPrintPlan(char* buf, SQueryNode* pQueryNode, int32_t level, int
 
   switch(pQueryNode->info.type) {
     case QNODE_TABLESCAN: {
-      STimeWindow* win = (STimeWindow*) pQueryNode->pExtInfo;
-      len1 = sprintf(buf + len, "%s #0x%"PRIx64") time_range: %"PRId64" - %"PRId64"\n", pQueryNode->tableInfo.tableName,
-                             pQueryNode->tableInfo.id.uid, win->skey, win->ekey);
+      STimeWindow* win = (STimeWindow*)pQueryNode->pExtInfo;
+      len1 = sprintf(buf + len, "%s #0x%" PRIx64 ") time_range: %" PRId64 " - %" PRId64 "\n",
+                     pQueryNode->tableInfo.tableName, pQueryNode->tableInfo.id.uid, win->skey, win->ekey);
       len += len1;
       break;
     }
@@ -387,8 +406,9 @@ static int32_t doPrintPlan(char* buf, SQueryNode* pQueryNode, int32_t level, int
       len += len1;
 
       SInterval* pInterval = pQueryNode->pExtInfo;
-      len1 = sprintf(buf + len, "interval:%"PRId64"(%c), sliding:%"PRId64"(%c), offset:%"PRId64"\n", pInterval->interval,
-             pInterval->intervalUnit, pInterval->sliding, pInterval->slidingUnit, pInterval->offset);
+      len1 = sprintf(buf + len, "interval:%" PRId64 "(%c), sliding:%" PRId64 "(%c), offset:%" PRId64 "\n",
+                     pInterval->interval, pInterval->intervalUnit, pInterval->sliding, pInterval->slidingUnit,
+                     pInterval->offset);
       len += len1;
 
       break;

From d57b94599f2a44af26f4fbeecb6c20fae3858f9a Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Thu, 6 May 2021 15:05:45 +0800
Subject: [PATCH 006/128] [td-3299]

---
 src/client/inc/tsclient.h     |  4 ++--
 src/client/src/tscSQLParser.c |  6 +++++-
 src/query/src/qPlan.c         | 32 +++++++++++---------------------
 src/query/src/qSqlParser.c    |  1 -
 4 files changed, 18 insertions(+), 25 deletions(-)

diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index a8ab715edf..c62b830a69 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -134,8 +134,8 @@ typedef struct SJoinNode {
 } SJoinNode;
 
 typedef struct SJoinInfo {
-  bool      hasJoin;
-  SJoinNode*  joinTables[TSDB_MAX_JOIN_TABLE_NUM];
+  bool       hasJoin;
+  SJoinNode *joinTables[TSDB_MAX_JOIN_TABLE_NUM];
 } SJoinInfo;
 
 typedef struct STagCond {
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index eb27c01ede..e6c2ca12bc 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -3678,10 +3678,14 @@ static bool validateJoinExprNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr
   SSchema*        pLeftSchema = tscGetTableSchema(pLeftMeterMeta->pTableMeta);
   int16_t         leftType = pLeftSchema[pLeftIndex->columnIndex].type;
 
+  tscColumnListInsert(pQueryInfo->colList, pLeftIndex->columnIndex, pLeftMeterMeta->pTableMeta->id.uid, &pLeftSchema[pLeftIndex->columnIndex]);
+
   STableMetaInfo* pRightMeterMeta = tscGetMetaInfo(pQueryInfo, rightIndex.tableIndex);
   SSchema*        pRightSchema = tscGetTableSchema(pRightMeterMeta->pTableMeta);
   int16_t         rightType = pRightSchema[rightIndex.columnIndex].type;
 
+  tscColumnListInsert(pQueryInfo->colList, rightIndex.columnIndex, pRightMeterMeta->pTableMeta->id.uid, &pRightSchema[rightIndex.columnIndex]);
+
   if (leftType != rightType) {
     invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
     return false;
@@ -3846,7 +3850,7 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
       taosArrayPush((*rightNode)->tsJoin, &leftIdx);
 
       /*
-       * to release expression, e.g., m1.ts = m2.ts,
+       * To release expression, e.g., m1.ts = m2.ts,
        * since this expression is used to set the join query type
        */
       tSqlExprDestroy(*pExpr);
diff --git a/src/query/src/qPlan.c b/src/query/src/qPlan.c
index 5e43469f7b..2686473d87 100644
--- a/src/query/src/qPlan.c
+++ b/src/query/src/qPlan.c
@@ -23,9 +23,15 @@
 
 typedef struct SFillEssInfo {
   int32_t  fillType;  // fill type
-  int64_t *val;      // fill value
+  int64_t *val;       // fill value
 } SFillEssInfo;
 
+typedef struct SJoinCond {
+  bool     tagExists; // denote if tag condition exists or not
+  SColumn *tagCond[2];
+  SColumn *colCond[2];
+} SJoinCond;
+
 static SQueryNode* createQueryNode(int32_t type, const char* name, SQueryNode** prev,
                                    int32_t numOfPrev, SExprInfo** pExpr, int32_t numOfOutput, SQueryTableInfo* pTableInfo,
                                    void* pExtInfo) {
@@ -92,8 +98,8 @@ static SQueryNode* createQueryNode(int32_t type, const char* name, SQueryNode**
   return pNode;
 }
 
-static SQueryNode* doAddTableColumnNode(SQueryInfo* pQueryInfo, STableMetaInfo* pTableMetaInfo,
-                                        SQueryTableInfo* info, SArray* pExprs, SArray* tableCols) {
+static SQueryNode* doAddTableColumnNode(SQueryInfo* pQueryInfo, STableMetaInfo* pTableMetaInfo, SQueryTableInfo* info,
+                                        SArray* pExprs, SArray* tableCols) {
   if (pQueryInfo->onlyTagQuery) {
     int32_t     num = taosArrayGetSize(pExprs);
     SQueryNode* pNode = createQueryNode(QNODE_TAGSCAN, "TableTagScan", NULL, 0, pExprs->pData, num, info, NULL);
@@ -232,28 +238,12 @@ SArray* createQueryPlanImpl(SQueryInfo* pQueryInfo) {
       tNameExtractFullName(&pTableMetaInfo->name, name);
       SQueryTableInfo info = {.tableName = strdup(name), .id = pTableMetaInfo->pTableMeta->id,};
 
-      // 3. add the join columns (the tags and the primary timestamp column)
-      tscInsertPrimaryTsSourceColumn(pQueryInfo, info.id.uid);
-
+      // 3. get the required table column list
       SArray* tableColumnList = taosArrayInit(4, sizeof(SColumn));
       tscColumnListCopy(tableColumnList, pQueryInfo->colList, uid);
 
-      // TODO add the tag column into the required column list
-      if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
-        int16_t tagColId = tscGetJoinTagColIdByUid(&pQueryInfo->tagCond, info.id.uid);
-        SSchema* s = tscGetColumnSchemaById(pTableMetaInfo->pTableMeta, tagColId);
-
-        SColumn* col    = calloc(1, sizeof(SColumn));
-        col->tableUid   = info.id.uid;
-        col->info.colId = tagColId;
-        col->info.type  = s->type;
-        col->info.bytes = s->bytes;
-        taosArrayPush(pQueryInfo->colList, &col);
-      }
-
       // 4. add the projection query node
       SQueryNode* pNode = doAddTableColumnNode(pQueryInfo, pTableMetaInfo, &info, exprList, tableColumnList);
-
       taosArrayPush(upstream, &pNode);
     }
 
@@ -497,7 +487,7 @@ static int32_t doPrintPlan(char* buf, SQueryNode* pQueryNode, int32_t level, int
 
     case QNODE_JOIN: {
       //  print join condition
-      len1 = sprintf(buf + len, "\n");
+      len1 = sprintf(buf + len, ")\n");
       len += len1;
       break;
     }
diff --git a/src/query/src/qSqlParser.c b/src/query/src/qSqlParser.c
index fb8f164ed3..ed4ac11141 100644
--- a/src/query/src/qSqlParser.c
+++ b/src/query/src/qSqlParser.c
@@ -229,7 +229,6 @@ tSqlExpr *tSqlExprCreate(tSqlExpr *pLeft, tSqlExpr *pRight, int32_t optrType) {
         pExpr->flags &= ~(1 << EXPR_FLAG_TS_ERROR);
       }
 
-
       switch (optrType) {
         case TK_PLUS: {
           pExpr->value.i64 = pLeft->value.i64 + pRight->value.i64;

From 77d95c27620112c2d1e27f1fa95c15e88e186e0c Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Thu, 6 May 2021 15:18:43 +0800
Subject: [PATCH 007/128] [td-3299]fix the memory leak.

---
 src/client/src/tscSQLParser.c | 9 +++++----
 src/client/src/tscUtil.c      | 5 +++++
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index e6c2ca12bc..cfec522268 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -7190,7 +7190,8 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
     SArray* list = taosArrayGetP(pSqlNode->from->list, 0);
     SSqlNode* p = taosArrayGetP(list, 0);
 
-    code = validateSqlNode(pSql, p, NULL);
+    SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+    code = validateSqlNode(pSql, p, pQueryInfo);
     if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
       return code;
     }
@@ -7199,8 +7200,6 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
       return code;
     }
 
-    pQueryInfo = pCmd->pQueryInfo;
-
     SQueryInfo* current = calloc(1, sizeof(SQueryInfo));
 
     tscInitQueryInfo(current);
@@ -7374,12 +7373,14 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
     taosArrayPushBatch(pQueryInfo->exprList1, (void*) p, numOfExpr);
   }
 
+#if 0
   SQueryNode* p = qCreateQueryPlan(pQueryInfo);
   char* s = queryPlanToString(p);
-  printf("%s\n", s);
   tfree(s);
 
   qDestroyQueryPlan(p);
+#endif
+
   return TSDB_CODE_SUCCESS;  // Does not build query message here
 }
 
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index cb4939ff28..81e91eb58e 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -2364,6 +2364,11 @@ static void freeQueryInfoImpl(SQueryInfo* pQueryInfo) {
   tscExprDestroy(pQueryInfo->exprList);
   pQueryInfo->exprList = NULL;
 
+  if (pQueryInfo->exprList1 != NULL) {
+    tscExprDestroy(pQueryInfo->exprList1);
+    pQueryInfo->exprList1 = NULL;
+  }
+
   tscColumnListDestroy(pQueryInfo->colList);
   pQueryInfo->colList = NULL;
 

From c36a71e8eb8406896571e7fce2cfd887b0c6ad35 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Thu, 6 May 2021 19:15:24 +0800
Subject: [PATCH 008/128] [td-3299]

---
 src/client/inc/tscUtil.h      |  3 +++
 src/client/src/tscSQLParser.c | 21 ++++++++++++++++++++-
 src/client/src/tscSql.c       |  4 ++++
 src/client/src/tscSubquery.c  |  2 ++
 src/client/src/tscUtil.c      |  7 +++----
 src/query/inc/qExecutor.h     |  1 +
 src/query/src/qExecutor.c     | 18 +++++++++---------
 7 files changed, 42 insertions(+), 14 deletions(-)

diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index 777656d2e1..93041ccca8 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -36,6 +36,9 @@ extern "C" {
 #define UTIL_TABLE_IS_NORMAL_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))
+
 #pragma pack(push,1)
 // this struct is transfered as binary, padding two bytes to avoid
 // an 'uid' whose low bytes is 0xff being recoginized as NULL,
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index cfec522268..a894ffc883 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -1859,7 +1859,9 @@ int32_t addProjectionExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
 
     // add the primary timestamp column even though it is not required by user
     STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
-    tscInsertPrimaryTsSourceColumn(pQueryInfo, pTableMetaInfo->pTableMeta->id.uid);
+    if (!UTIL_TABLE_IS_TMP_TABLE(pTableMetaInfo)) {
+      tscInsertPrimaryTsSourceColumn(pQueryInfo, pTableMetaInfo->pTableMeta->id.uid);
+    }
   } else {
     return TSDB_CODE_TSC_INVALID_SQL;
   }
@@ -7221,6 +7223,23 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
       return TSDB_CODE_TSC_INVALID_SQL;
     }
 
+    // all columns are added into the table column list
+    for(int32_t i = 0; i < pTableMeta->tableInfo.numOfColumns; ++i) {
+      tscColumnListInsert(current->colList, i, pTableMetaInfo1->pTableMeta->id.uid,
+                          &pTableMetaInfo1->pTableMeta->schema[i]);
+    }
+
+    if (pSqlNode->pWhere != NULL) {
+      if (validateWhereNode(current, &pSqlNode->pWhere, pSql) != TSDB_CODE_SUCCESS) {
+        return TSDB_CODE_TSC_INVALID_SQL;
+      }
+
+      pSqlNode->pWhere = NULL;
+      if (pTableMeta->tableInfo.precision == TSDB_TIME_PRECISION_MILLI) {
+        current->window.skey = current->window.skey / 1000;
+        current->window.ekey = current->window.ekey / 1000;
+      }
+    }
   } else {
     pQueryInfo->command = TSDB_SQL_SELECT;
 
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index 8dbb1c0a52..dd26b8834d 100644
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -378,6 +378,10 @@ int taos_num_fields(TAOS_RES *res) {
     return num;
   }
 
+  while(pQueryInfo->pDownstream != NULL) {
+    pQueryInfo = pQueryInfo->pDownstream;
+  }
+
   size_t numOfCols = tscNumOfFields(pQueryInfo);
   for(int32_t i = 0; i < numOfCols; ++i) {
     SInternalField* pInfo = taosArrayGet(pQueryInfo->fieldsInfo.internalField, i);
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index 8903d528be..f8384192e0 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -3580,6 +3580,8 @@ void* createQueryInfoFromQueryNode(SQueryInfo* pQueryInfo, SExprInfo* pExprs, ST
 
   tfree(pExprs);
 
+  createFilterInfo(pQueryAttr, 0);
+
   SArray* pa = NULL;
   if (stage == MASTER_SCAN) {
     pa = createExecOperatorPlan(pQueryAttr);
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 81e91eb58e..02a0d10124 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -479,9 +479,9 @@ void tscClearInterpInfo(SQueryInfo* pQueryInfo) {
 }
 
 int32_t tscCreateResPointerInfo(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
-  if (pRes->tsrow == NULL) {
-    pRes->numOfCols = pQueryInfo->fieldsInfo.numOfOutput;
+  pRes->numOfCols = pQueryInfo->fieldsInfo.numOfOutput;
 
+  if (pRes->tsrow == NULL) {
     pRes->tsrow  = calloc(pRes->numOfCols, POINTER_BYTES);
     pRes->urow   = calloc(pRes->numOfCols, POINTER_BYTES);
     pRes->length = calloc(pRes->numOfCols, sizeof(int32_t));
@@ -704,8 +704,7 @@ SOperatorInfo* createDummyInputOperator(char* pResult, SSchema* pSchema, int32_t
   assert(numOfCols > 0);
   SDummyInputInfo* pInfo = calloc(1, sizeof(SDummyInputInfo));
 
-  pInfo->pRes = (SSqlRes*) pResult;
-
+  pInfo->pRes  = (SSqlRes*) pResult;
   pInfo->block = calloc(numOfCols, sizeof(SSDataBlock));
   pInfo->block->info.numOfCols = numOfCols;
 
diff --git a/src/query/inc/qExecutor.h b/src/query/inc/qExecutor.h
index b8835ea3e2..c028aa0768 100644
--- a/src/query/inc/qExecutor.h
+++ b/src/query/inc/qExecutor.h
@@ -543,6 +543,7 @@ SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SGroupbyExpr *pGroupbyExpr, S
 int32_t initQInfo(STsBufInfo* pTsBufInfo, void* tsdb, void* sourceOptr, SQInfo* pQInfo, SQueryParam* param, char* start,
                   int32_t prevResultLen, void* merger);
 
+int32_t createFilterInfo(SQueryAttr* pQueryAttr, uint64_t qId);
 void freeColumnFilterInfo(SColumnFilterInfo* pFilter, int32_t numOfFilters);
 
 STableQueryInfo *createTableQueryInfo(SQueryAttr* pQueryAttr, void* pTable, bool groupbyColumn, STimeWindow win, void* buf);
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 79e9e94406..e979cf3f12 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -1748,7 +1748,7 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
         SOperatorInfo* prev = pRuntimeEnv->proot;
         if (i == 0) {
           pRuntimeEnv->proot = createArithOperatorInfo(pRuntimeEnv, prev, pQueryAttr->pExpr1, pQueryAttr->numOfOutput);
-          if (pRuntimeEnv->proot != NULL && pRuntimeEnv->proot->operatorType != OP_DummyInput) {  // TODO refactor
+          if (pRuntimeEnv->proot != NULL && prev->operatorType != OP_DummyInput) {  // TODO refactor
             setTableScanFilterOperatorInfo(prev->info, pRuntimeEnv->proot);
           }
         } else {
@@ -1765,12 +1765,12 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
       }
 
       case OP_Filter: {  // todo refactor
-        assert(pQueryAttr->havingNum > 0);
         if (pQueryAttr->stableQuery) {
           pRuntimeEnv->proot = createFilterOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr3, pQueryAttr->numOfExpr3);
         } else {
           pRuntimeEnv->proot = createFilterOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr1, pQueryAttr->numOfOutput);
         }
+
         break;
       }
 
@@ -4141,12 +4141,12 @@ static void doCloseAllTimeWindow(SQueryRuntimeEnv* pRuntimeEnv) {
 }
 
 static SSDataBlock* doTableScanImpl(void* param, bool* newgroup) {
-  SOperatorInfo*   pOperator = (SOperatorInfo*) param;
+  SOperatorInfo    *pOperator = (SOperatorInfo*) param;
 
-  STableScanInfo*  pTableScanInfo = pOperator->info;
-  SSDataBlock*      pBlock = &pTableScanInfo->block;
+  STableScanInfo   *pTableScanInfo = pOperator->info;
+  SSDataBlock      *pBlock = &pTableScanInfo->block;
   SQueryRuntimeEnv *pRuntimeEnv = pOperator->pRuntimeEnv;
-  SQueryAttr*       pQueryAttr = pRuntimeEnv->pQueryAttr;
+  SQueryAttr       *pQueryAttr = pRuntimeEnv->pQueryAttr;
   STableGroupInfo  *pTableGroupInfo = &pOperator->pRuntimeEnv->tableqinfoGroupInfo;
 
   *newgroup = false;
@@ -5410,7 +5410,7 @@ SOperatorInfo* createArithOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorI
 }
 
 SOperatorInfo* createFilterOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr,
-                                           int32_t numOfOutput) {
+                                        int32_t numOfOutput) {
   SFilterOperatorInfo* pInfo = calloc(1, sizeof(SFilterOperatorInfo));
 
   {
@@ -5444,7 +5444,7 @@ SOperatorInfo* createFilterOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperator
 
   SOperatorInfo* pOperator = calloc(1, sizeof(SOperatorInfo));
 
-  pOperator->name         = "ConditionOperator";
+  pOperator->name         = "FilterOperator";
   pOperator->operatorType = OP_Filter;
   pOperator->blockingOptr = false;
   pOperator->status       = OP_IN_EXECUTING;
@@ -6685,7 +6685,7 @@ void* doDestroyFilterInfo(SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFil
   return NULL;
 }
 
-static int32_t createFilterInfo(SQueryAttr* pQueryAttr, uint64_t qId) {
+int32_t createFilterInfo(SQueryAttr* pQueryAttr, uint64_t qId) {
   for (int32_t i = 0; i < pQueryAttr->numOfCols; ++i) {
     if (pQueryAttr->tableCols[i].flist.numOfFilters > 0) {
       pQueryAttr->numOfFilterCols++;

From 266b878ba2c6c84d48f9c7a15152913662ed8836 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Thu, 6 May 2021 22:57:57 +0800
Subject: [PATCH 009/128] [td-3299]

---
 src/query/inc/qExecutor.h |   3 +-
 src/query/inc/qUtil.h     |   1 +
 src/query/src/qExecutor.c | 102 +++++++++++++++++++++++---------------
 src/query/src/qPlan.c     |   9 +++-
 4 files changed, 72 insertions(+), 43 deletions(-)

diff --git a/src/query/inc/qExecutor.h b/src/query/inc/qExecutor.h
index c028aa0768..3e0f1f5e8f 100644
--- a/src/query/inc/qExecutor.h
+++ b/src/query/inc/qExecutor.h
@@ -514,7 +514,8 @@ SOperatorInfo* createMultiwaySortOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SEx
                                               int32_t numOfRows, void* merger, bool groupMix);
 SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* param);
 SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput, void* merger);
-SOperatorInfo* createFilterOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr, int32_t numOfOutput);
+SOperatorInfo* createFilterOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr,
+                                        int32_t numOfOutput, SColumnInfo* pCols, int32_t numOfFilter);
 
 SSDataBlock* doGlobalAggregate(void* param, bool* newgroup);
 SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup);
diff --git a/src/query/inc/qUtil.h b/src/query/inc/qUtil.h
index c340d8f952..0756e41785 100644
--- a/src/query/inc/qUtil.h
+++ b/src/query/inc/qUtil.h
@@ -48,6 +48,7 @@ void    clearResultRow(SQueryRuntimeEnv* pRuntimeEnv, SResultRow* pResultRow, in
 SResultRowCellInfo* getResultCell(const SResultRow* pRow, int32_t index, int32_t* offset);
 
 void* destroyQueryFuncExpr(SExprInfo* pExprInfo, int32_t numOfExpr);
+void* freeColumnInfo(SColumnInfo* pColumnInfo, int32_t numOfCols);
 
 static FORCE_INLINE SResultRow *getResultRow(SResultRowInfo *pResultRowInfo, int32_t slot) {
   assert(pResultRowInfo != NULL && slot >= 0 && slot < pResultRowInfo->size);
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index e979cf3f12..da857533ac 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -167,6 +167,8 @@ static void setBlockStatisInfo(SQLFunctionCtx *pCtx, SSDataBlock* pSDataBlock, S
 static void destroyTableQueryInfoImpl(STableQueryInfo *pTableQueryInfo);
 static bool hasMainOutput(SQueryAttr *pQueryAttr);
 
+static SColumnInfo* extractColumnFilterInfo(SExprInfo* pExpr, int32_t numOfOutput, int32_t* numOfFilterCols);
+
 static int32_t setTimestampListJoinInfo(SQueryRuntimeEnv* pRuntimeEnv, tVariant* pTag, STableQueryInfo *pTableQueryInfo);
 static void releaseQueryBuf(size_t numOfTables);
 static int32_t binarySearchForKey(char *pValue, int num, TSKEY key, int order);
@@ -1765,12 +1767,25 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
       }
 
       case OP_Filter: {  // todo refactor
-        if (pQueryAttr->stableQuery) {
-          pRuntimeEnv->proot = createFilterOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr3, pQueryAttr->numOfExpr3);
+        int32_t numOfFilterCols = 0;
+        if (pQueryAttr->numOfFilterCols > 0) {
+          pRuntimeEnv->proot = createFilterOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr1,
+                                                        pQueryAttr->numOfOutput, pQueryAttr->tableCols, pQueryAttr->numOfFilterCols);
         } else {
-          pRuntimeEnv->proot = createFilterOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr1, pQueryAttr->numOfOutput);
+          if (pQueryAttr->stableQuery) {
+            SColumnInfo* pColInfo =
+                extractColumnFilterInfo(pQueryAttr->pExpr3, pQueryAttr->numOfExpr3, &numOfFilterCols);
+            pRuntimeEnv->proot = createFilterOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr3,
+                                                          pQueryAttr->numOfExpr3, pColInfo, numOfFilterCols);
+            freeColumnInfo(pColInfo, pQueryAttr->numOfExpr3);
+          } else {
+            SColumnInfo* pColInfo =
+                extractColumnFilterInfo(pQueryAttr->pExpr1, pQueryAttr->numOfOutput, &numOfFilterCols);
+            pRuntimeEnv->proot = createFilterOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr1,
+                                                          pQueryAttr->numOfOutput, pColInfo, numOfFilterCols);
+            freeColumnInfo(pColInfo, pQueryAttr->numOfOutput);
+          }
         }
-
         break;
       }
 
@@ -5409,38 +5424,37 @@ SOperatorInfo* createArithOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorI
   return pOperator;
 }
 
+static SColumnInfo* extractColumnFilterInfo(SExprInfo* pExpr, int32_t numOfOutput, int32_t* numOfFilterCols) {
+  SColumnInfo* pCols = calloc(numOfOutput, sizeof(SColumnInfo));
+
+  int32_t numOfFilter = 0;
+  for(int32_t i = 0; i < numOfOutput; ++i) {
+    if (pExpr[i].base.flist.numOfFilters > 0) {
+      numOfFilter += 1;
+    }
+
+    pCols[i].type = pExpr[i].base.resType;
+    pCols[i].bytes = pExpr[i].base.resBytes;
+    pCols[i].colId = pExpr[i].base.resColId;
+
+    pCols[i].flist.numOfFilters = pExpr[i].base.flist.numOfFilters;
+    pCols[i].flist.filterInfo = calloc(pCols[i].flist.numOfFilters, sizeof(SColumnFilterInfo));
+    memcpy(pCols[i].flist.filterInfo, pExpr[i].base.flist.filterInfo, pCols[i].flist.numOfFilters * sizeof(SColumnFilterInfo));
+  }
+
+  assert(numOfFilter > 0);
+
+  *numOfFilterCols = numOfFilter;
+  return pCols;
+}
+
 SOperatorInfo* createFilterOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr,
-                                        int32_t numOfOutput) {
+                                        int32_t numOfOutput, SColumnInfo* pCols, int32_t numOfFilter) {
   SFilterOperatorInfo* pInfo = calloc(1, sizeof(SFilterOperatorInfo));
 
-  {
-    SColumnInfo* pCols = calloc(numOfOutput, sizeof(SColumnInfo));
-
-    int32_t numOfFilter = 0;
-    for(int32_t i = 0; i < numOfOutput; ++i) {
-      if (pExpr[i].base.flist.numOfFilters > 0) {
-        numOfFilter += 1;
-      }
-
-      pCols[i].type = pExpr[i].base.resType;
-      pCols[i].bytes = pExpr[i].base.resBytes;
-      pCols[i].colId = pExpr[i].base.resColId;
-
-      pCols[i].flist.numOfFilters = pExpr[i].base.flist.numOfFilters;
-      pCols[i].flist.filterInfo = calloc(pCols[i].flist.numOfFilters, sizeof(SColumnFilterInfo));
-      memcpy(pCols[i].flist.filterInfo, pExpr[i].base.flist.filterInfo, pCols[i].flist.numOfFilters * sizeof(SColumnFilterInfo));
-    }
-
-    assert(numOfFilter > 0);
-    doCreateFilterInfo(pCols, numOfOutput, numOfFilter, &pInfo->pFilterInfo, 0);
-    pInfo->numOfFilterCols = numOfFilter;
-
-    for(int32_t i = 0; i < numOfOutput; ++i) {
-      tfree(pCols[i].flist.filterInfo);
-    }
-
-    tfree(pCols);
-  }
+  assert(numOfFilter > 0 && pCols != NULL);
+  doCreateFilterInfo(pCols, numOfOutput, numOfFilter, &pInfo->pFilterInfo, 0);
+  pInfo->numOfFilterCols = numOfFilter;
 
   SOperatorInfo* pOperator = calloc(1, sizeof(SOperatorInfo));
 
@@ -7097,6 +7111,20 @@ void* destroyQueryFuncExpr(SExprInfo* pExprInfo, int32_t numOfExpr) {
   return NULL;
 }
 
+void* freeColumnInfo(SColumnInfo* pColumnInfo, int32_t numOfCols) {
+  if (pColumnInfo != NULL) {
+    assert(numOfCols > 0);
+
+    for (int32_t i = 0; i < numOfCols; i++) {
+      freeColumnFilterInfo(pColumnInfo[i].flist.filterInfo, pColumnInfo[i].flist.numOfFilters);
+    }
+
+    tfree(pColumnInfo);
+  }
+
+  return NULL;
+}
+
 void freeQInfo(SQInfo *pQInfo) {
   if (!isValidQInfo(pQInfo)) {
     return;
@@ -7281,13 +7309,7 @@ void freeQueryAttr(SQueryAttr* pQueryAttr) {
     tfree(pQueryAttr->tagColList);
     tfree(pQueryAttr->pFilterInfo);
 
-    if (pQueryAttr->tableCols != NULL) {
-      for (int32_t i = 0; i < pQueryAttr->numOfCols; i++) {
-        SColumnInfo* column = pQueryAttr->tableCols + i;
-        freeColumnFilterInfo(column->flist.filterInfo, column->flist.numOfFilters);
-      }
-      tfree(pQueryAttr->tableCols);
-    }
+    pQueryAttr->tableCols = freeColumnInfo(pQueryAttr->tableCols, pQueryAttr->numOfCols);
 
     if (pQueryAttr->pGroupbyExpr != NULL) {
       taosArrayDestroy(pQueryAttr->pGroupbyExpr->columnInfo);
diff --git a/src/query/src/qPlan.c b/src/query/src/qPlan.c
index 2686473d87..c46257ba9e 100644
--- a/src/query/src/qPlan.c
+++ b/src/query/src/qPlan.c
@@ -615,8 +615,13 @@ SArray* createExecOperatorPlan(SQueryAttr* pQueryAttr) {
       taosArrayPush(plan, &op);
     }
   } else {  // diff/add/multiply/subtract/division
-    op = OP_Arithmetic;
-    taosArrayPush(plan, &op);
+    if (pQueryAttr->numOfFilterCols > 0 && pQueryAttr->vgId == 0) { // todo refactor
+      op = OP_Filter;
+      taosArrayPush(plan, &op);
+    } else {
+      op = OP_Arithmetic;
+      taosArrayPush(plan, &op);
+    }
   }
 
   if (pQueryAttr->limit.limit > 0 || pQueryAttr->limit.offset > 0) {

From f28e7b4e2eed34c23f50e10bd4f97f5249a0ccdb Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Thu, 6 May 2021 23:11:49 +0800
Subject: [PATCH 010/128] [td-3299]

---
 src/query/inc/qFill.h |  2 --
 src/query/src/qFill.c | 55 +------------------------------------------
 2 files changed, 1 insertion(+), 56 deletions(-)

diff --git a/src/query/inc/qFill.h b/src/query/inc/qFill.h
index 4c76bdb035..caa0c55b3f 100644
--- a/src/query/inc/qFill.h
+++ b/src/query/inc/qFill.h
@@ -82,8 +82,6 @@ void taosFillSetStartInfo(SFillInfo* pFillInfo, int32_t numOfRows, TSKEY endKey)
 
 void taosFillSetInputDataBlock(SFillInfo* pFillInfo, const struct SSDataBlock* pInput);
 
-void taosFillCopyInputDataFromOneFilePage(SFillInfo* pFillInfo, const tFilePage* pInput);
-
 bool taosFillHasMoreResults(SFillInfo* pFillInfo);
 
 int64_t getNumOfResultsAfterFillGap(SFillInfo* pFillInfo, int64_t ekey, int32_t maxNumOfRows);
diff --git a/src/query/src/qFill.c b/src/query/src/qFill.c
index fa572029fc..7dd73c9fe4 100644
--- a/src/query/src/qFill.c
+++ b/src/query/src/qFill.c
@@ -363,10 +363,6 @@ SFillInfo* taosCreateFillInfo(int32_t order, TSKEY skey, int32_t numOfTags, int3
   pFillInfo->rowSize = setTagColumnInfo(pFillInfo, pFillInfo->numOfCols, pFillInfo->alloc);
   assert(pFillInfo->rowSize > 0);
 
-  for(int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
-    pFillInfo->pData[i] = malloc(pFillInfo->pFillCol[i].col.bytes * pFillInfo->alloc);
-  }
-
   return pFillInfo;
 }
 
@@ -392,10 +388,6 @@ void* taosDestroyFillInfo(SFillInfo* pFillInfo) {
     tfree(pFillInfo->pTags[i].tagVal);
   }
 
-  for(int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
-    tfree(pFillInfo->pData[i]);
-  }
-
   tfree(pFillInfo->pTags);
   
   tfree(pFillInfo->pData);
@@ -417,17 +409,6 @@ void taosFillSetStartInfo(SFillInfo* pFillInfo, int32_t numOfRows, TSKEY endKey)
 
   pFillInfo->index     = 0;
   pFillInfo->numOfRows = numOfRows;
-  
-  // ensure the space
-  if (pFillInfo->alloc < numOfRows) {
-    for(int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
-      char* tmp = realloc(pFillInfo->pData[i], numOfRows*pFillInfo->pFillCol[i].col.bytes);
-      assert(tmp != NULL); // todo handle error
-      
-      memset(tmp, 0, numOfRows*pFillInfo->pFillCol[i].col.bytes);
-      pFillInfo->pData[i] = tmp;
-    }
-  }
 }
 
 void taosFillSetInputDataBlock(SFillInfo* pFillInfo, const SSDataBlock* pInput) {
@@ -435,16 +416,7 @@ void taosFillSetInputDataBlock(SFillInfo* pFillInfo, const SSDataBlock* pInput)
     SFillColInfo* pCol = &pFillInfo->pFillCol[i];
 
     SColumnInfoData* pColData = taosArrayGet(pInput->pDataBlock, i);
-//    pFillInfo->pData[i] = pColData->pData;
-    if (pInput->info.rows > pFillInfo->alloc) {
-      char* t = realloc(pFillInfo->pData[i], pColData->info.bytes * pInput->info.rows);
-      assert(t != NULL);
-
-      pFillInfo->pData[i] = t;
-      pFillInfo->alloc = pInput->info.rows;
-    }
-
-    memcpy(pFillInfo->pData[i], pColData->pData, pColData->info.bytes * pInput->info.rows);
+    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
       SFillTagColInfo* pTag = &pFillInfo->pTags[pCol->tagIndex];
@@ -454,31 +426,6 @@ void taosFillSetInputDataBlock(SFillInfo* pFillInfo, const SSDataBlock* pInput)
   }
 }
 
-void taosFillCopyInputDataFromOneFilePage(SFillInfo* pFillInfo, const tFilePage* pInput) {
-  assert(pFillInfo->numOfRows == pInput->num);
-
-  for(int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
-    SFillColInfo* pCol = &pFillInfo->pFillCol[i];
-
-    const char* data = pInput->data + pCol->col.offset * pInput->num;
-    if (pInput->num > pFillInfo->alloc) {
-      char* t = realloc(pFillInfo->pData[i], (size_t)(pCol->col.bytes * pInput->num));
-      assert(t != NULL);
-
-      pFillInfo->pData[i] = t;
-      pFillInfo->alloc = (int32_t)pInput->num;
-    }
-
-    memcpy(pFillInfo->pData[i], data, (size_t)(pCol->col.bytes * pInput->num));
-
-    if (TSDB_COL_IS_TAG(pCol->flag)/* || IS_VAR_DATA_TYPE(pCol->col.type)*/) {  // copy the tag value to tag value buffer
-      SFillTagColInfo* pTag = &pFillInfo->pTags[pCol->tagIndex];
-      assert (pTag->col.colId == pCol->col.colId);
-      memcpy(pTag->tagVal, data, pCol->col.bytes);  // TODO not memcpy??
-    }
-  }
-}
-
 bool taosFillHasMoreResults(SFillInfo* pFillInfo) {
   int32_t remain = taosNumOfRemainRows(pFillInfo);
   if (remain > 0) {

From 7cacd403d5ecf379c5660718062aa49a9f7744ad Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Sat, 8 May 2021 16:40:45 +0800
Subject: [PATCH 011/128] add cache last null columns feature

---
 documentation20/cn/11.administrator/docs.md |  2 +-
 src/common/src/ttypes.c                     | 58 +++++++++++++++++++++
 src/inc/taosdef.h                           |  2 +-
 src/inc/tsdb.h                              |  6 ++-
 src/inc/ttype.h                             |  3 ++
 src/tsdb/inc/tsdbMeta.h                     |  3 ++
 src/tsdb/src/tsdbMain.c                     |  8 +--
 src/tsdb/src/tsdbMemTable.c                 | 57 +++++++++++++++++++-
 src/tsdb/src/tsdbMeta.c                     |  7 +++
 9 files changed, 138 insertions(+), 8 deletions(-)

diff --git a/documentation20/cn/11.administrator/docs.md b/documentation20/cn/11.administrator/docs.md
index bfa0456c7d..b9340210d2 100644
--- a/documentation20/cn/11.administrator/docs.md
+++ b/documentation20/cn/11.administrator/docs.md
@@ -129,7 +129,7 @@ taosd -C
 - blocks：每个VNODE（TSDB）中有多少cache大小的内存块。因此一个VNODE的用的内存大小粗略为（cache * blocks）。单位为块，默认值：4。（可通过 alter database 修改）
 - replica：副本个数，取值范围：1-3。单位为个，默认值：1。（可通过 alter database 修改）
 - precision：时间戳精度标识，ms表示毫秒，us表示微秒。默认值：ms。
-- cacheLast：是否在内存中缓存子表 last_row，0：关闭；1：开启。默认值：0。（可通过 alter database 修改）（从 2.0.11 版本开始支持此参数）
+- cacheLast：是否在内存中缓存子表的最近数据，0：关闭；1：缓存子表最近一行数据；2：缓存子表每一列的最近的非NULL值，设置为3表示同时开启了1和2。默认值：0。（可通过 alter database 修改）（从 2.0.11 版本开始支持此参数）
 
 对于一个应用场景，可能有多种数据特征的数据并存，最佳的设计是将具有相同数据特征的表放在一个库里，这样一个应用有多个库，而每个库可以配置不同的存储参数，从而保证系统有最优的性能。TDengine允许应用在创建库时指定上述存储参数，如果指定，该参数就将覆盖对应的系统配置参数。举例，有下述SQL：
 
diff --git a/src/common/src/ttypes.c b/src/common/src/ttypes.c
index 6fa27a029b..77e12e23d2 100644
--- a/src/common/src/ttypes.c
+++ b/src/common/src/ttypes.c
@@ -417,6 +417,16 @@ void setVardataNull(char* val, int32_t type) {
   }
 }
 
+bool isVardataNull(char* val, int32_t type) {
+  if (type == TSDB_DATA_TYPE_BINARY) {
+    return *(uint8_t*) varDataVal(val) == TSDB_DATA_BINARY_NULL;
+  } else if (type == TSDB_DATA_TYPE_NCHAR) {
+    return *(uint32_t*) varDataVal(val) == TSDB_DATA_NCHAR_NULL;
+  } else {
+    assert(0);
+  }
+}
+
 void setNull(char *val, int32_t type, int32_t bytes) { setNullN(val, type, bytes, 1); }
 
 void setNullN(char *val, int32_t type, int32_t bytes, int32_t numOfElems) {
@@ -492,6 +502,54 @@ void setNullN(char *val, int32_t type, int32_t bytes, int32_t numOfElems) {
   }
 }
 
+bool isNullN(char *val, int32_t type) {
+  switch (type) {
+    case TSDB_DATA_TYPE_BOOL:
+      return *(uint8_t *)(val) == TSDB_DATA_BOOL_NULL;
+      break;
+    case TSDB_DATA_TYPE_TINYINT:
+      return *(uint8_t *)(val) == TSDB_DATA_TINYINT_NULL;
+      break;
+    case TSDB_DATA_TYPE_SMALLINT:
+      return *(uint16_t *)(val) == TSDB_DATA_SMALLINT_NULL;
+      break;
+    case TSDB_DATA_TYPE_INT:
+      return *(uint32_t *)(val) == TSDB_DATA_INT_NULL;
+      break;
+    case TSDB_DATA_TYPE_BIGINT:
+    case TSDB_DATA_TYPE_TIMESTAMP:
+      return *(uint64_t *)(val) == TSDB_DATA_BIGINT_NULL;
+      break;
+    case TSDB_DATA_TYPE_UTINYINT:
+      return *(uint8_t *)(val) == TSDB_DATA_UTINYINT_NULL;
+      break;
+    case TSDB_DATA_TYPE_USMALLINT:
+      return *(uint16_t *)(val) == TSDB_DATA_USMALLINT_NULL;
+      break;
+    case TSDB_DATA_TYPE_UINT:
+      return *(uint32_t *)(val) == TSDB_DATA_UINT_NULL;
+      break;
+    case TSDB_DATA_TYPE_UBIGINT:
+      return *(uint64_t *)(val) == TSDB_DATA_UBIGINT_NULL;
+      break;
+    case TSDB_DATA_TYPE_FLOAT:
+      return *(uint32_t *)(val) == TSDB_DATA_FLOAT_NULL;
+      break;
+    case TSDB_DATA_TYPE_DOUBLE:
+      return *(uint64_t *)(val) == TSDB_DATA_DOUBLE_NULL;
+      break;
+    case TSDB_DATA_TYPE_NCHAR:
+    case TSDB_DATA_TYPE_BINARY:
+      return isVardataNull(val, type);
+      break;
+    default: {
+      return *(uint32_t *)(val) == TSDB_DATA_INT_NULL;
+      break;
+    }
+  }
+
+}
+
 static uint8_t   nullBool     = TSDB_DATA_BOOL_NULL;
 static uint8_t   nullTinyInt  = TSDB_DATA_TINYINT_NULL;
 static uint16_t  nullSmallInt = TSDB_DATA_SMALLINT_NULL;
diff --git a/src/inc/taosdef.h b/src/inc/taosdef.h
index e9170860a6..f6479ea15d 100644
--- a/src/inc/taosdef.h
+++ b/src/inc/taosdef.h
@@ -299,7 +299,7 @@ do { \
 #define TSDB_DEFAULT_DB_UPDATE_OPTION   0
 
 #define TSDB_MIN_DB_CACHE_LAST_ROW      0
-#define TSDB_MAX_DB_CACHE_LAST_ROW      1
+#define TSDB_MAX_DB_CACHE_LAST_ROW      2
 #define TSDB_DEFAULT_CACHE_LAST_ROW     0
 
 #define TSDB_MIN_FSYNC_PERIOD           0
diff --git a/src/inc/tsdb.h b/src/inc/tsdb.h
index 1ba5131f6d..7c28d3e485 100644
--- a/src/inc/tsdb.h
+++ b/src/inc/tsdb.h
@@ -69,9 +69,13 @@ typedef struct {
   int8_t  precision;
   int8_t  compression;
   int8_t  update;
-  int8_t  cacheLastRow;
+  int8_t  cacheLastRow;    // 0:no cache, 1: cache last row, 2: cache last NULL column
 } STsdbCfg;
 
+#define CACHE_NO_LAST(c)          ((c)->cacheLastRow == 0)
+#define CACHE_LAST_ROW(c)         (((c)->cacheLastRow & 1) > 0)
+#define CACHE_LAST_NULL_COLUMN(c) (((c)->cacheLastRow & 2) > 0)
+
 // --------- TSDB REPOSITORY USAGE STATISTICS
 typedef struct {
   int64_t totalStorage;  // total bytes occupie
diff --git a/src/inc/ttype.h b/src/inc/ttype.h
index 662a23bfdb..120667ce6e 100644
--- a/src/inc/ttype.h
+++ b/src/inc/ttype.h
@@ -176,6 +176,9 @@ void  setNull(char *val, int32_t type, int32_t bytes);
 void  setNullN(char *val, int32_t type, int32_t bytes, int32_t numOfElems);
 void *getNullValue(int32_t type);
 
+bool isVardataNull(char* val, int32_t type);
+bool isNullN(char *val, int32_t type);
+
 void assignVal(char *val, const char *src, int32_t len, int32_t type);
 void tsDataSwap(void *pLeft, void *pRight, int32_t type, int32_t size, void* buf);
 
diff --git a/src/tsdb/inc/tsdbMeta.h b/src/tsdb/inc/tsdbMeta.h
index cc916fa689..d339989bb3 100644
--- a/src/tsdb/inc/tsdbMeta.h
+++ b/src/tsdb/inc/tsdbMeta.h
@@ -36,6 +36,9 @@ typedef struct STable {
   char*          sql;
   void*          cqhandle;
   SRWLatch       latch;  // TODO: implementa latch functions
+
+  SDataCol      *lastCols;
+  int32_t        lastColNum;
   T_REF_DECLARE()
 } STable;
 
diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index 99929f3542..5a44b03c81 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -447,8 +447,10 @@ static int32_t tsdbCheckAndSetDefaultCfg(STsdbCfg *pCfg) {
   if (pCfg->update != 0) pCfg->update = 1;
 
   // update cacheLastRow
-  if (pCfg->cacheLastRow != 0) pCfg->cacheLastRow = 1;
-
+  if (pCfg->cacheLastRow != 0) {
+    if (pCfg->cacheLastRow > 3)
+      pCfg->cacheLastRow = 1;
+  }
   return 0;
 }
 
@@ -581,7 +583,7 @@ int tsdbRestoreInfo(STsdbRepo *pRepo) {
       if (pIdx && lastKey < pIdx->maxKey) {
         pTable->lastKey = pIdx->maxKey;
 
-        if (pCfg->cacheLastRow) {
+        if (CACHE_LAST_ROW(pCfg)) {
           if (tsdbLoadBlockInfo(&readh, NULL) < 0) {
             tsdbDestroyReadH(&readh);
             return -1;
diff --git a/src/tsdb/src/tsdbMemTable.c b/src/tsdb/src/tsdbMemTable.c
index 20ec426018..18041f0291 100644
--- a/src/tsdb/src/tsdbMemTable.c
+++ b/src/tsdb/src/tsdbMemTable.c
@@ -955,11 +955,61 @@ static void tsdbFreeRows(STsdbRepo *pRepo, void **rows, int rowCounter) {
   }
 }
 
+static void updateTableLatestColumn(STsdbRepo *pRepo, STable *pTable, SDataRow row) {
+  //tsdbDebug("vgId:%d updateTableLatestColumn, row version:%d", REPO_ID(pRepo), dataRowVersion(row));
+
+  if (pTable->numOfSchemas <= 0) {
+    return;
+  }
+  STSchema* pSchema = pTable->schema[pTable->numOfSchemas - 1];
+  int i = pTable->numOfSchemas - 1;
+  while ((pSchema == NULL || pSchema->version != dataRowVersion(row)) && i >= 0) {
+    i -= 1;
+    pSchema = pTable->schema[i];
+  }
+  if (pSchema == NULL || pSchema->version != dataRowVersion(row)) {
+    return;
+  }
+
+  SDataCol *pLatestCols = pTable->lastCols;
+
+  for (int j = 0; j < schemaNCols(pSchema); j++) {
+    if (j >= pTable->lastColNum) {
+      pTable->lastCols = realloc(pTable->lastCols, pTable->lastColNum + 10);
+      for (int i = 0; i < 10; ++i) {
+        pTable->lastCols[i + pTable->lastColNum].bytes = 0;
+        pTable->lastCols[i + pTable->lastColNum].pData = NULL;
+      }
+      pTable->lastColNum += 10;
+    }
+
+    STColumn *pTCol = schemaColAt(pSchema, j);
+    SDataCol *pDataCol = &(pLatestCols[j]);
+    void* value = tdGetRowDataOfCol(row, (int8_t)pTCol->type, TD_DATA_ROW_HEAD_SIZE + pSchema->columns[j].offset);
+    if (isNullN(value, pTCol->type)) {
+      continue;
+    }
+    if (pDataCol->pData == NULL) {
+      pDataCol->pData = malloc(pSchema->columns[j].bytes);
+      pDataCol->bytes = pSchema->columns[j].bytes;
+    } else if (pDataCol->bytes < pSchema->columns[j].bytes) {
+      pDataCol->pData = realloc(pDataCol->pData, pSchema->columns[j].bytes);
+      pDataCol->bytes = pSchema->columns[j].bytes;
+    }
+
+    //tsdbDebug("vgId:%d cache column %d for %d,%p", REPO_ID(pRepo), j, pDataCol->bytes, pDataCol->pData);
+
+    memcpy(pDataCol->pData, value, pDataCol->bytes);
+  }
+}
+
 static int tsdbUpdateTableLatestInfo(STsdbRepo *pRepo, STable *pTable, SDataRow row) {
   STsdbCfg *pCfg = &pRepo->config;
 
+  tsdbDebug("vgId:%d tsdbUpdateTableLatestInfo, %ld, %ld, %d", REPO_ID(pRepo), tsdbGetTableLastKeyImpl(pTable), dataRowKey(row), pCfg->cacheLastRow);
+
   if (tsdbGetTableLastKeyImpl(pTable) < dataRowKey(row)) {
-    if (pCfg->cacheLastRow || pTable->lastRow != NULL) {
+    if (CACHE_LAST_ROW(pCfg) || pTable->lastRow != NULL) {
       SDataRow nrow = pTable->lastRow;
       if (taosTSizeof(nrow) < dataRowLen(row)) {
         SDataRow orow = nrow;
@@ -984,7 +1034,10 @@ static int tsdbUpdateTableLatestInfo(STsdbRepo *pRepo, STable *pTable, SDataRow
     } else {
       pTable->lastKey = dataRowKey(row);
     }
-  }
 
+    if (CACHE_LAST_NULL_COLUMN(pCfg)) {
+      updateTableLatestColumn(pRepo, pTable, row);
+    }
+  }
   return 0;
 }
diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c
index 3e6263b9d3..b8e3273664 100644
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
@@ -14,6 +14,7 @@
  */
 #include "tsdbint.h"
 
+#define TSDB_LATEST_COLUMN_ARRAY_SIZE 20
 #define TSDB_SUPER_TABLE_SL_LEVEL 5
 #define DEFAULT_TAG_INDEX_COLUMN 0
 
@@ -671,6 +672,12 @@ static STable *tsdbNewTable() {
   }
 
   pTable->lastKey = TSKEY_INITIAL_VAL;
+  pTable->lastCols = (SDataCol*)malloc(TSDB_LATEST_COLUMN_ARRAY_SIZE * sizeof(SDataCol));
+  pTable->lastColNum = TSDB_LATEST_COLUMN_ARRAY_SIZE;
+  for (int i = 0; i < pTable->lastColNum; ++i) {
+    pTable->lastCols[i].bytes = 0;
+    pTable->lastCols[i].pData = NULL;
+  }
 
   return pTable;
 }

From 913eb1c71911752378f79c1fa978c09dd8fba83c Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Sat, 8 May 2021 17:08:29 +0800
Subject: [PATCH 012/128] cache last null columns feature

---
 src/tsdb/src/tsdbMeta.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c
index b8e3273664..9b98ca19fc 100644
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
@@ -794,6 +794,13 @@ static void tsdbFreeTable(STable *pTable) {
     tSkipListDestroy(pTable->pIndex);
     taosTZfree(pTable->lastRow);
     tfree(pTable->sql);
+
+    for (int i = 0; i < pTable->lastColNum; ++i) {
+      if (pTable->lastCols[i].pData == NULL) {
+        continue;
+      }
+      free(pTable->lastCols[i].pData);
+    }
     free(pTable);
   }
 }

From f0640ac09ef0af41781fd3daed847b4ff91a1920 Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Sat, 8 May 2021 18:02:26 +0800
Subject: [PATCH 013/128] disable debug log

---
 src/tsdb/src/tsdbMemTable.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tsdb/src/tsdbMemTable.c b/src/tsdb/src/tsdbMemTable.c
index 18041f0291..d7d1e5ea18 100644
--- a/src/tsdb/src/tsdbMemTable.c
+++ b/src/tsdb/src/tsdbMemTable.c
@@ -1006,7 +1006,7 @@ static void updateTableLatestColumn(STsdbRepo *pRepo, STable *pTable, SDataRow r
 static int tsdbUpdateTableLatestInfo(STsdbRepo *pRepo, STable *pTable, SDataRow row) {
   STsdbCfg *pCfg = &pRepo->config;
 
-  tsdbDebug("vgId:%d tsdbUpdateTableLatestInfo, %ld, %ld, %d", REPO_ID(pRepo), tsdbGetTableLastKeyImpl(pTable), dataRowKey(row), pCfg->cacheLastRow);
+  //tsdbDebug("vgId:%d tsdbUpdateTableLatestInfo, %ld, %ld, %d", REPO_ID(pRepo), tsdbGetTableLastKeyImpl(pTable), dataRowKey(row), pCfg->cacheLastRow);
 
   if (tsdbGetTableLastKeyImpl(pTable) < dataRowKey(row)) {
     if (CACHE_LAST_ROW(pCfg) || pTable->lastRow != NULL) {

From 4814df777c8166e1d01f707efdc5e397e1a5ac81 Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Sat, 8 May 2021 18:40:48 +0800
Subject: [PATCH 014/128] fix compile error

---
 src/common/src/ttypes.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/common/src/ttypes.c b/src/common/src/ttypes.c
index 77e12e23d2..6587a27760 100644
--- a/src/common/src/ttypes.c
+++ b/src/common/src/ttypes.c
@@ -425,6 +425,8 @@ bool isVardataNull(char* val, int32_t type) {
   } else {
     assert(0);
   }
+
+  return false;
 }
 
 void setNull(char *val, int32_t type, int32_t bytes) { setNullN(val, type, bytes, 1); }
@@ -548,6 +550,7 @@ bool isNullN(char *val, int32_t type) {
     }
   }
 
+  return false;
 }
 
 static uint8_t   nullBool     = TSDB_DATA_BOOL_NULL;

From 8880e515df0ead0a29bf724f633af78770ea23cd Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sun, 9 May 2021 10:05:52 +0800
Subject: [PATCH 015/128] [td-3949]

---
 src/client/src/tscSQLParser.c |   15 +-
 src/query/inc/qSqlparser.h    |   16 +-
 src/query/inc/sql.y           |    8 +-
 src/query/src/qSqlParser.c    |   67 +-
 src/query/src/sql.c           | 1649 +++++++++++++++++----------------
 5 files changed, 915 insertions(+), 840 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index a894ffc883..63768a41d7 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -6689,8 +6689,8 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);
   }
   
-  STableNamePair* p1 = taosArrayGet(pFromInfo->list, 0);
-  SStrToken srcToken = {.z = p1->name.z, .n = p1->name.n, .type = TK_STRING};
+  SRelElementPair* p1 = taosArrayGet(pFromInfo->list, 0);
+  SStrToken srcToken = {.z = p1->tableName.z, .n = p1->tableName.n, .type = TK_STRING};
   if (tscValidateName(&srcToken) != TSDB_CODE_SUCCESS) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
@@ -7085,8 +7085,8 @@ static int32_t doLoadAllTableMeta(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNod
       tscAddEmptyMetaInfo(pQueryInfo);
     }
 
-    STableNamePair *item = taosArrayGet(pSqlNode->from->list, i);
-    SStrToken      *oriName = &item->name;
+    SRelElementPair *item = taosArrayGet(pSqlNode->from->list, i);
+    SStrToken      *oriName = &item->tableName;
 
     if (oriName->type == TK_INTEGER || oriName->type == TK_FLOAT) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
@@ -7284,10 +7284,9 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
         pQueryInfo->window.skey = pQueryInfo->window.skey / 1000;
         pQueryInfo->window.ekey = pQueryInfo->window.ekey / 1000;
       }
-    } else {  // set the time rang
-      if (taosArrayGetSize(pSqlNode->from->list) > 1) {
-        // If it is a join query, no where clause is not allowed.
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), "condition missing for join query ");
+    } else {
+      if (taosArrayGetSize(pSqlNode->from->list) > 1) { // Cross join not allowed yet
+        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), "cross join not supported yet");
       }
     }
 
diff --git a/src/query/inc/qSqlparser.h b/src/query/inc/qSqlparser.h
index 85cba06b3e..bbf391659b 100644
--- a/src/query/inc/qSqlparser.h
+++ b/src/query/inc/qSqlparser.h
@@ -107,14 +107,19 @@ typedef struct SSqlNode {
   struct tSqlExpr   *pHaving;      // having clause [optional]
 } SSqlNode;
 
-typedef struct STableNamePair {
-  SStrToken name;
+typedef struct SRelElementPair {
+  union {
+    SStrToken  tableName;
+    SArray    *pSubquery;
+    //SSqlNode  *pSubquery;
+  };
+
   SStrToken aliasName;
-} STableNamePair;
+} SRelElementPair;
 
 typedef struct SRelationInfo {
   int32_t       type;        // nested query|table name list
-  SArray       *list;        // SArray<STableNamePair>|SArray<SSqlNode*>
+  SArray       *list;        // SArray<SRelElementPair>|SArray<SSqlNode*>
 } SRelationInfo;
 
 typedef struct SCreatedTableInfo {
@@ -254,8 +259,9 @@ SArray *tVariantListInsert(SArray *pList, tVariant *pVar, uint8_t sortOrder, int
 SArray *tVariantListAppendToken(SArray *pList, SStrToken *pAliasToken, uint8_t sortOrder);
 
 SRelationInfo *setTableNameList(SRelationInfo* pFromInfo, SStrToken *pName, SStrToken* pAlias);
-SRelationInfo *setSubquery(SRelationInfo* pFromInfo, SArray* pSqlNode);
+//SRelationInfo *setSubquery(SRelationInfo* pFromInfo, SRelElementPair* p);
 void          *destroyRelationInfo(SRelationInfo* pFromInfo);
+SRelationInfo *addSubqueryElem(SRelationInfo* pRelationInfo, SArray* pSub, SStrToken* pAlias);
 
 // sql expr leaf node
 tSqlExpr *tSqlExprCreateIdValue(SStrToken *pToken, int32_t optrType);
diff --git a/src/query/inc/sql.y b/src/query/inc/sql.y
index fd922240c2..f6a72eb8c5 100644
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
@@ -508,7 +508,13 @@ distinct(X) ::= .            { X.n = 0;}
 %type from {SRelationInfo*}
 %destructor from {destroyRelationInfo($$);}
 from(A) ::= FROM tablelist(X).                 {A = X;}
-from(A) ::= FROM LP union(Y) RP.               {A = setSubquery(NULL, Y);}
+from(A) ::= FROM sub(X).                       {A = X;}
+
+%type sub {SRelationInfo*}
+%destructor sub {destroyRelationInfo($$);}
+sub(A)  ::= LP union(Y) RP.                    {A = addSubqueryElem(NULL, Y, NULL);}
+sub(A)  ::= LP union(Y) RP ids(Z).             {A = addSubqueryElem(NULL, Y, &Z);}
+sub(A)  ::= sub(X) COMMA LP union(Y) RP ids(Z).{A = addSubqueryElem(X, Y, &Z);}
 
 %type tablelist {SRelationInfo*}
 %destructor tablelist {destroyRelationInfo($$);}
diff --git a/src/query/src/qSqlParser.c b/src/query/src/qSqlParser.c
index ed4ac11141..e26b850215 100644
--- a/src/query/src/qSqlParser.c
+++ b/src/query/src/qSqlParser.c
@@ -535,11 +535,11 @@ SArray *tVariantListInsert(SArray *pList, tVariant *pVar, uint8_t sortOrder, int
 SRelationInfo *setTableNameList(SRelationInfo* pRelationInfo, SStrToken *pName, SStrToken* pAlias) {
   if (pRelationInfo == NULL) {
     pRelationInfo = calloc(1, sizeof(SRelationInfo));
-    pRelationInfo->list = taosArrayInit(4, sizeof(STableNamePair));
+    pRelationInfo->list = taosArrayInit(4, sizeof(SRelElementPair));
   }
 
   pRelationInfo->type = SQL_NODE_FROM_TABLELIST;
-  STableNamePair p = {.name = *pName};
+  SRelElementPair p = {.tableName = *pName};
   if (pAlias != NULL) {
     p.aliasName = *pAlias;
   } else {
@@ -550,17 +550,41 @@ SRelationInfo *setTableNameList(SRelationInfo* pRelationInfo, SStrToken *pName,
   return pRelationInfo;
 }
 
-SRelationInfo* setSubquery(SRelationInfo* pRelationInfo, SArray* pList) {
-  if (pRelationInfo == NULL) {
-    pRelationInfo = calloc(1, sizeof(SRelationInfo));
-    pRelationInfo->list = taosArrayInit(4, POINTER_BYTES);
-  }
+//SRelationInfo* setSubquery(SRelationInfo* pRelationInfo, SArray* pList, SStrToken* pAlias) {
+//  if (pRelationInfo == NULL) {
+//    pRelationInfo = calloc(1, sizeof(SRelationInfo));
+//    pRelationInfo->list = taosArrayInit(4, POINTER_BYTES);
+//  }
+//
+//  pRelationInfo->type = SQL_NODE_FROM_SUBQUERY;
+//  SRelElementPair p = {.pSubquery = pList};
+//  if (pAlias != NULL) {
+//    p.aliasName = *pAlias;
+//  } else {
+//    TPARSER_SET_NONE_TOKEN(p.aliasName);
+//  }
+//
+//  taosArrayPush(pRelationInfo->list, &p);
+//  return pRelationInfo;
+//}
 
-  pRelationInfo->type = SQL_NODE_FROM_SUBQUERY;
-  taosArrayPush(pRelationInfo->list, &pList);
-
-  return pRelationInfo;
-}
+//SRelationInfo* setSubquery(SRelationInfo* pRelationInfo, SRelElementPair* p) {
+//  if (pRelationInfo == NULL) {
+//    pRelationInfo = calloc(1, sizeof(SRelationInfo));
+//    pRelationInfo->list = taosArrayInit(4, POINTER_BYTES);
+//  }
+//
+//  pRelationInfo->type = SQL_NODE_FROM_SUBQUERY;
+//  SRelElementPair elem = *p;
+////  if (pAlias != NULL) {
+////    p.aliasName = *pAlias;
+////  } else {
+////    TPARSER_SET_NONE_TOKEN(p.aliasName);
+////  }
+//
+//  taosArrayPush(pRelationInfo->list, &p);
+//  return pRelationInfo;
+//}
 
 void* destroyRelationInfo(SRelationInfo* pRelationInfo) {
   if (pRelationInfo == NULL) {
@@ -582,6 +606,25 @@ void* destroyRelationInfo(SRelationInfo* pRelationInfo) {
   return NULL;
 }
 
+SRelationInfo* addSubqueryElem(SRelationInfo* pRelationInfo, SArray* pSub, SStrToken* pAlias) {
+  if (pRelationInfo == NULL) {
+    pRelationInfo = calloc(1, sizeof(SRelationInfo));
+    pRelationInfo->list = taosArrayInit(4, sizeof(SRelElementPair));
+  }
+
+  pRelationInfo->type = SQL_NODE_FROM_SUBQUERY;
+
+  SRelElementPair p = {.pSubquery = pSub};
+  if (pAlias != NULL) {
+    p.aliasName = *pAlias;
+  } else {
+    TPARSER_SET_NONE_TOKEN(p.aliasName);
+  }
+
+  taosArrayPush(pRelationInfo->list, &p);
+  return pRelationInfo;
+}
+
 
 void tSetDbName(SStrToken *pCpxName, SStrToken *pDb) {
   pCpxName->type = pDb->type;
diff --git a/src/query/src/sql.c b/src/query/src/sql.c
index f3929da022..0f7c7be7c2 100644
--- a/src/query/src/sql.c
+++ b/src/query/src/sql.c
@@ -97,27 +97,27 @@
 #endif
 /************* Begin control #defines *****************************************/
 #define YYCODETYPE unsigned short int
-#define YYNOCODE 264
+#define YYNOCODE 265
 #define YYACTIONTYPE unsigned short int
 #define ParseTOKENTYPE SStrToken
 typedef union {
   int yyinit;
   ParseTOKENTYPE yy0;
-  SCreateTableSql* yy14;
-  int yy20;
-  SSqlNode* yy116;
-  tSqlExpr* yy118;
-  SArray* yy159;
-  SIntervalVal yy184;
-  SCreatedTableInfo yy206;
-  SRelationInfo* yy236;
-  SSessionWindowVal yy249;
-  int64_t yy317;
-  SCreateDbInfo yy322;
-  SCreateAcctInfo yy351;
-  TAOS_FIELD yy407;
-  SLimitVal yy440;
-  tVariant yy488;
+  SCreatedTableInfo yy96;
+  SRelationInfo* yy148;
+  tSqlExpr* yy178;
+  SCreateAcctInfo yy187;
+  SArray* yy285;
+  TAOS_FIELD yy295;
+  SSqlNode* yy344;
+  tVariant yy362;
+  SIntervalVal yy376;
+  SLimitVal yy438;
+  int yy460;
+  SCreateTableSql* yy470;
+  SSessionWindowVal yy523;
+  int64_t yy525;
+  SCreateDbInfo yy526;
 } YYMINORTYPE;
 #ifndef YYSTACKDEPTH
 #define YYSTACKDEPTH 100
@@ -127,17 +127,17 @@ typedef union {
 #define ParseARG_FETCH SSqlInfo* pInfo = yypParser->pInfo
 #define ParseARG_STORE yypParser->pInfo = pInfo
 #define YYFALLBACK 1
-#define YYNSTATE             315
-#define YYNRULE              269
+#define YYNSTATE             321
+#define YYNRULE              272
 #define YYNTOKEN             187
-#define YY_MAX_SHIFT         314
-#define YY_MIN_SHIFTREDUCE   508
-#define YY_MAX_SHIFTREDUCE   776
-#define YY_ERROR_ACTION      777
-#define YY_ACCEPT_ACTION     778
-#define YY_NO_ACTION         779
-#define YY_MIN_REDUCE        780
-#define YY_MAX_REDUCE        1048
+#define YY_MAX_SHIFT         320
+#define YY_MIN_SHIFTREDUCE   515
+#define YY_MAX_SHIFTREDUCE   786
+#define YY_ERROR_ACTION      787
+#define YY_ACCEPT_ACTION     788
+#define YY_NO_ACTION         789
+#define YY_MIN_REDUCE        790
+#define YY_MAX_REDUCE        1061
 /************* End control #defines *******************************************/
 
 /* Define the yytestcase() macro to be a no-op if is not already defined
@@ -203,260 +203,265 @@ typedef union {
 **  yy_default[]       Default action for each state.
 **
 *********** Begin parsing tables **********************************************/
-#define YY_ACTTAB_COUNT (683)
+#define YY_ACTTAB_COUNT (691)
 static const YYACTIONTYPE yy_action[] = {
- /*     0 */   133,  555,  204,  312,  208,  140,  947,  226,  140,  556,
- /*    10 */   778,  314,   17,   47,   48,  140,   51,   52,   30,  181,
- /*    20 */   214,   41,  181,   50,  262,   55,   53,   57,   54, 1029,
- /*    30 */   926,  211, 1030,   46,   45,  179,  181,   44,   43,   42,
- /*    40 */    47,   48,  924,   51,   52,  210, 1030,  214,   41,  555,
- /*    50 */    50,  262,   55,   53,   57,   54,  938,  556,  185,  205,
- /*    60 */    46,   45,  923,  247,   44,   43,   42,   48,  944,   51,
- /*    70 */    52,  242,  978,  214,   41,   79,   50,  262,   55,   53,
- /*    80 */    57,   54,  979,  634,  257,   30,   46,   45,  278,  225,
- /*    90 */    44,   43,   42,  509,  510,  511,  512,  513,  514,  515,
- /*   100 */   516,  517,  518,  519,  520,  521,  313,  555,   85,  231,
- /*   110 */    70,  288,  287,   47,   48,  556,   51,   52,  298,  219,
- /*   120 */   214,   41,  555,   50,  262,   55,   53,   57,   54,  922,
- /*   130 */   556,  105,  720,   46,   45, 1026,  298,   44,   43,   42,
- /*   140 */    47,   49,  914,   51,   52,  926,  140,  214,   41,  234,
- /*   150 */    50,  262,   55,   53,   57,   54, 1025,  238,  237,  227,
- /*   160 */    46,   45,  285,  284,   44,   43,   42,   23,  276,  307,
- /*   170 */   306,  275,  274,  273,  305,  272,  304,  303,  302,  271,
- /*   180 */   301,  300,  886,   30,  874,  875,  876,  877,  878,  879,
- /*   190 */   880,  881,  882,  883,  884,  885,  887,  888,   51,   52,
- /*   200 */   825, 1024,  214,   41,  166,   50,  262,   55,   53,   57,
- /*   210 */    54,  259,   18,   78,   82,   46,   45,   61,  223,   44,
- /*   220 */    43,   42,  213,  735,  217,   25,  724,  923,  727,  190,
- /*   230 */   730,  221,  213,  735,  198,  191,  724,  912,  727,   62,
- /*   240 */   730,  118,  117,  189,   69,  909,  910,   29,  913,   44,
- /*   250 */    43,   42,   30,   74,  200,  201,  308,  926,  261,   30,
- /*   260 */    23,   36,  307,  306,  200,  201,  938,  305,   30,  304,
- /*   270 */   303,  302,   74,  301,  300,  894,  911,  199,  892,  893,
- /*   280 */    36,  206,  926,  895,  920,  897,  898,  896,  224,  899,
- /*   290 */   900,  280,  658,  218,  834,  655,  923,  656,  166,  657,
- /*   300 */   281,  673,  241,  923,   68,   55,   53,   57,   54,  282,
- /*   310 */   197,  263,  923,   46,   45,   30,  278,   44,   43,   42,
- /*   320 */    80,  103,  108,  228,  229,   56,  220,   97,  107,  113,
- /*   330 */   116,  106,  736,   71,  726,   56,  729,  110,  732,   30,
- /*   340 */     1,  154,  736,    5,  156,  725,  183,  728,  732,   33,
- /*   350 */   155,   92,   87,   91,  731,  680,  286,  184,  826,  923,
- /*   360 */   174,  170,  166,  245,  731,  212,  172,  169,  121,  120,
- /*   370 */   119,   46,   45,    3,  167,   44,   43,   42,   12,  677,
- /*   380 */   290,  722,   84,  923,   81,  670,  311,  310,  126,  701,
- /*   390 */   702,  243,   24,  686,  692,   31,  693,  135,   60,  756,
- /*   400 */    20,  659,  737,   19,   64,  186,   19,  739,  644,    6,
- /*   410 */   180,  265,   31,  187,  646,   31,  267,  723,   60,  645,
- /*   420 */    83,  188,   28,   60,   65,  268,  662,   67,  663,  633,
- /*   430 */    96,   95,  660,  194,  661,  115,  114,   14,   13,  102,
- /*   440 */   101,  195,   16,   15,  131,  129,  733,  193,  178,  192,
- /*   450 */   182, 1040,  925,  989,  988,  215,  985,  734,  239,  984,
- /*   460 */   216,  289,  132,  946,   39,  971,  954,  970,  956,  939,
- /*   470 */   246,  130,  248,  134,  138,  921,  150,  244,  151,  207,
- /*   480 */   250,  299,  685,  149,  919,  255,  142,  936,  143,  141,
- /*   490 */   144,  152,  256,  153,  260,  258,   66,  145,  837,  270,
- /*   500 */    63,   37,   58,  176,   34,  254,  279,  833, 1045,  252,
- /*   510 */    93, 1044, 1042,  249,  147,  157,  283, 1039,   99, 1038,
- /*   520 */   146, 1036,  158,  855,   35,   32,   38,  177,  822,   40,
- /*   530 */   109,  104,  820,  111,  112,  818,  817,  230,  168,  815,
- /*   540 */   814,  813,  812,  811,  810,  171,  173,  807,  805,  803,
- /*   550 */   291,  801,  799,  175,  292,   72,   75,  293,  251,  972,
- /*   560 */   294,  295,  296,  297,  309,  776,  202,  232,  222,  269,
- /*   570 */   233,  775,  236,  235,  774,  761,  203,  762,   88,  196,
- /*   580 */    89,  240,  245,  264,    8,   73,   76,  665,  687,  690,
- /*   590 */   816,  161,  136,  122,  856,  159,  164,  160,  162,  163,
- /*   600 */   165,  123,  809,    2,  890,  124,  808,    4,  125,  800,
- /*   610 */   137,  209,   77,  148,  253,   26,  694,  139,    9,  902,
- /*   620 */    10,   27,  738,    7,   11,  740,   21,   22,  266,   86,
- /*   630 */   597,  593,   84,  591,  590,  589,  586,  559,  277,   90,
- /*   640 */    31,   94,   98,   59,  100,  636,  635,  632,  581,  579,
- /*   650 */   571,  577,  573,  575,  569,  567,  600,  599,  598,  596,
- /*   660 */   595,  594,  592,  588,  587,   60,  557,  525,  523,  780,
- /*   670 */   779,  779,  779,  779,  779,  779,  779,  779,  779,  779,
- /*   680 */   779,  127,  128,
+ /*     0 */   957,  562,  207,  318,   70,   18,  212,  948,  184,  563,
+ /*    10 */   788,  320,  182,   48,   49,  143,   52,   53,  215, 1043,
+ /*    20 */   218,   42,  209,   51,  268,   56,   54,   58,   55,  922,
+ /*    30 */   641,  184,  936,   47,   46,  184,  921,   45,   44,   43,
+ /*    40 */    48,   49, 1042,   52,   53,  214, 1043,  218,   42,  562,
+ /*    50 */    51,  268,   56,   54,   58,   55,  948,  563,  294,  293,
+ /*    60 */    47,   46,  954,  143,   45,   44,   43,   49,   31,   52,
+ /*    70 */    53,  246,  136,  218,   42,  188,   51,  268,   56,   54,
+ /*    80 */    58,   55,  304,  992,   88,  263,   47,   46,  143,  229,
+ /*    90 */    45,   44,   43,  516,  517,  518,  519,  520,  521,  522,
+ /*   100 */   523,  524,  525,  526,  527,  528,  319,  562,  284,  235,
+ /*   110 */    71,  230,  932,   48,   49,  563,   52,   53,  924,  223,
+ /*   120 */   218,   42,  562,   51,  268,   56,   54,   58,   55,  265,
+ /*   130 */   563,   81,  730,   47,   46,  253,  252,   45,   44,   43,
+ /*   140 */    48,   50,  284,   52,   53,  936,  934,  218,   42,  238,
+ /*   150 */    51,  268,   56,   54,   58,   55,  991,  242,  241,  231,
+ /*   160 */    47,   46,  291,  290,   45,   44,   43,   24,  282,  313,
+ /*   170 */   312,  281,  280,  279,  311,  278,  310,  309,  308,  277,
+ /*   180 */   307,  306,  896,   31,  884,  885,  886,  887,  888,  889,
+ /*   190 */   890,  891,  892,  893,  894,  895,  897,  898,   52,   53,
+ /*   200 */   835, 1039,  218,   42,  169,   51,  268,   56,   54,   58,
+ /*   210 */    55,  227,   19,  225,   85,   47,   46,    1,  157,   45,
+ /*   220 */    44,   43,  217,  745,  208,   25,  734,  933,  737,  193,
+ /*   230 */   740,  314,  217,  745, 1038,  194,  734,  677,  737,  936,
+ /*   240 */   740,  121,  120,  192,    8,  919,  920,   30,  923,    3,
+ /*   250 */   170,  736,   31,  739,  203,  204,  930,  936,  267,   31,
+ /*   260 */    24,  108,  313,  312,  203,  204,  304,  311,   31,  310,
+ /*   270 */   309,  308,   77,  307,  306,  904,  948,  680,  902,  903,
+ /*   280 */    37,  228,  216,  905,  286,  907,  908,  906,   83,  909,
+ /*   290 */   910,  210,  665,  221,  143,  662,  933,  663,  224,  664,
+ /*   300 */   222,   72,  245,  933,   69,   56,   54,   58,   55,  287,
+ /*   310 */   200,  269,  933,   47,   46,   31,  844,   45,   44,   43,
+ /*   320 */   169,  106,  111,  232,  233,   57,    6,  100,  110,  116,
+ /*   330 */   119,  109,  746,   77,  735,   57,  738,  113,  742,   31,
+ /*   340 */    31,   37,  746,    5,  159,   45,   44,   43,  742,   34,
+ /*   350 */   158,   95,   90,   94,  741,  684,  288,  711,  712,  933,
+ /*   360 */   177,  173,   82,  743,  741,   74,  175,  172,  124,  123,
+ /*   370 */   122,   47,   46,  249,  836,   45,   44,   43,  169,   75,
+ /*   380 */   292,  296,  247,  933,  933,  732,   32,  249,   13,  317,
+ /*   390 */   316,  129,   87,  696,   84,   62,  702,  138,  703,  766,
+ /*   400 */    61,  666,   21,   20,  747,  651,   65,  749,   20,   32,
+ /*   410 */   271,  653,  273, 1037,   32,   61,   86,   63,  652,  201,
+ /*   420 */    29,  733,   61,  274,  118,  117,   66,   99,   98,  202,
+ /*   430 */    15,   14,  186,  105,  104,   68,  669,  640,  670,   17,
+ /*   440 */    16,  667,  187,  668,  134,  132,  744,  189,  183,  190,
+ /*   450 */   191,  197,  198,  196,  181,  195,  185, 1002,  243, 1053,
+ /*   460 */   935, 1001,  219,  998,  997,  220,  295,  135,   40,  956,
+ /*   470 */   967,  984,  983,  964,  965,  949,  250,  133,  969,  931,
+ /*   480 */   900,  153,  254,  211,  256,  695,  305,  107,  261,  152,
+ /*   490 */   149,  147,  946,  137,  141,  154,  144,  145,  266,   67,
+ /*   500 */   929,  155,  156,  847,   64,  276,   38,   59,  179,   35,
+ /*   510 */   285,  843, 1058,   96, 1057, 1055,  146,  160,  289, 1052,
+ /*   520 */   264,  102,  262, 1051, 1049,  161,  865,   36,   33,  260,
+ /*   530 */    39,  180,  832,  112,  830,  114,  115,  828,  827,  258,
+ /*   540 */   234,  171,  825,  824,  823,  822,  821,  820,  174,  176,
+ /*   550 */   817,  815,  813,  811,  809,  178,  255,  248,   73,   78,
+ /*   560 */    41,  257,  985,  297,  298,  299,  300,  205,  302,  301,
+ /*   570 */   226,  275,  303,  315,  786,  236,  237,  785,   91,  206,
+ /*   580 */   199,  240,   92,  784,  239,  772,  771,  244,  249,  826,
+ /*   590 */   270,  125,  164,    9,  866,  166,  162,  163,  165,  167,
+ /*   600 */   168,  126,  819,    2,  127,  818,    4,  128,  810,  672,
+ /*   610 */    76,   26,  251,  697,  150,  148,  139,  151,   79,  140,
+ /*   620 */    80,  912,  700,  213,  259,   10,  704,  142,   27,   11,
+ /*   630 */   748,   28,    7,   12,   22,  750,   23,   89,  272,  604,
+ /*   640 */   600,   87,  598,  597,  596,  593,  566,  283,   32,   93,
+ /*   650 */    97,  643,   60,  642,  639,  588,  586,  101,  578,  584,
+ /*   660 */   580,  582,  576,  574,  607,  103,  606,  605,  603,  602,
+ /*   670 */   601,  599,  595,  594,   61,  564,  532,  530,  790,  789,
+ /*   680 */   789,  130,  789,  789,  789,  789,  789,  789,  789,  789,
+ /*   690 */   131,
 };
 static const YYCODETYPE yy_lookahead[] = {
- /*     0 */   191,    1,  190,  191,  210,  191,  191,  191,  191,    9,
- /*    10 */   188,  189,  252,   13,   14,  191,   16,   17,  191,  252,
- /*    20 */    20,   21,  252,   23,   24,   25,   26,   27,   28,  262,
- /*    30 */   236,  261,  262,   33,   34,  252,  252,   37,   38,   39,
- /*    40 */    13,   14,  226,   16,   17,  261,  262,   20,   21,    1,
- /*    50 */    23,   24,   25,   26,   27,   28,  234,    9,  252,  232,
- /*    60 */    33,   34,  235,  254,   37,   38,   39,   14,  253,   16,
- /*    70 */    17,  249,  258,   20,   21,  258,   23,   24,   25,   26,
- /*    80 */    27,   28,  258,    5,  260,  191,   33,   34,   79,   67,
+ /*     0 */   191,    1,  190,  191,  197,  252,  210,  234,  252,    9,
+ /*    10 */   188,  189,  252,   13,   14,  191,   16,   17,  262,  263,
+ /*    20 */    20,   21,  249,   23,   24,   25,   26,   27,   28,    0,
+ /*    30 */     5,  252,  236,   33,   34,  252,  229,   37,   38,   39,
+ /*    40 */    13,   14,  263,   16,   17,  262,  263,   20,   21,    1,
+ /*    50 */    23,   24,   25,   26,   27,   28,  234,    9,   33,   34,
+ /*    60 */    33,   34,  253,  191,   37,   38,   39,   14,  191,   16,
+ /*    70 */    17,  249,  191,   20,   21,  252,   23,   24,   25,   26,
+ /*    80 */    27,   28,   81,  259,  197,  261,   33,   34,  191,   67,
  /*    90 */    37,   38,   39,   45,   46,   47,   48,   49,   50,   51,
- /*   100 */    52,   53,   54,   55,   56,   57,   58,    1,  197,   61,
- /*   110 */   110,   33,   34,   13,   14,    9,   16,   17,   81,  210,
- /*   120 */    20,   21,    1,   23,   24,   25,   26,   27,   28,  235,
- /*   130 */     9,   76,  105,   33,   34,  252,   81,   37,   38,   39,
- /*   140 */    13,   14,  231,   16,   17,  236,  191,   20,   21,  135,
- /*   150 */    23,   24,   25,   26,   27,   28,  252,  143,  144,  137,
+ /*   100 */    52,   53,   54,   55,   56,   57,   58,    1,   79,   61,
+ /*   110 */   110,  191,  235,   13,   14,    9,   16,   17,  231,  210,
+ /*   120 */    20,   21,    1,   23,   24,   25,   26,   27,   28,  257,
+ /*   130 */     9,  259,  105,   33,   34,  254,  255,   37,   38,   39,
+ /*   140 */    13,   14,   79,   16,   17,  236,  226,   20,   21,  135,
+ /*   150 */    23,   24,   25,   26,   27,   28,  259,  143,  144,  137,
  /*   160 */    33,   34,  140,  141,   37,   38,   39,   88,   89,   90,
  /*   170 */    91,   92,   93,   94,   95,   96,   97,   98,   99,  100,
  /*   180 */   101,  102,  209,  191,  211,  212,  213,  214,  215,  216,
  /*   190 */   217,  218,  219,  220,  221,  222,  223,  224,   16,   17,
  /*   200 */   196,  252,   20,   21,  200,   23,   24,   25,   26,   27,
- /*   210 */    28,  256,   44,  258,  197,   33,   34,  109,   67,   37,
+ /*   210 */    28,   67,   44,  210,  197,   33,   34,  198,  199,   37,
  /*   220 */    38,   39,    1,    2,  232,  104,    5,  235,    7,   61,
- /*   230 */     9,  210,    1,    2,  252,   67,    5,    0,    7,  131,
- /*   240 */     9,   73,   74,   75,  197,  228,  229,  230,  231,   37,
- /*   250 */    38,   39,  191,  104,   33,   34,  210,  236,   37,  191,
- /*   260 */    88,  112,   90,   91,   33,   34,  234,   95,  191,   97,
- /*   270 */    98,   99,  104,  101,  102,  209,  229,  252,  212,  213,
- /*   280 */   112,  249,  236,  217,  191,  219,  220,  221,  137,  223,
- /*   290 */   224,  140,    2,  232,  196,    5,  235,    7,  200,    9,
- /*   300 */   232,   37,  134,  235,  136,   25,   26,   27,   28,  232,
- /*   310 */   142,   15,  235,   33,   34,  191,   79,   37,   38,   39,
- /*   320 */   237,   62,   63,   33,   34,  104,  233,   68,   69,   70,
- /*   330 */    71,   72,  111,  250,    5,  104,    7,   78,  117,  191,
- /*   340 */   198,  199,  111,   62,   63,    5,  252,    7,  117,   68,
- /*   350 */    69,   70,   71,   72,  133,  105,  232,  252,  196,  235,
- /*   360 */    62,   63,  200,  113,  133,   60,   68,   69,   70,   71,
- /*   370 */    72,   33,   34,  194,  195,   37,   38,   39,  104,  115,
- /*   380 */   232,    1,  108,  235,  110,  109,   64,   65,   66,  124,
- /*   390 */   125,  105,  116,  105,  105,  109,  105,  109,  109,  105,
- /*   400 */   109,  111,  105,  109,  109,  252,  109,  111,  105,  104,
- /*   410 */   252,  105,  109,  252,  105,  109,  105,   37,  109,  105,
- /*   420 */   109,  252,  104,  109,  129,  107,    5,  104,    7,  106,
- /*   430 */   138,  139,    5,  252,    7,   76,   77,  138,  139,  138,
- /*   440 */   139,  252,  138,  139,   62,   63,  117,  252,  252,  252,
- /*   450 */   252,  236,  236,  227,  227,  227,  227,  117,  191,  227,
- /*   460 */   227,  227,  191,  191,  251,  259,  191,  259,  191,  234,
- /*   470 */   234,   60,  255,  191,  191,  234,  238,  192,  191,  255,
- /*   480 */   255,  103,  117,  239,  191,  255,  246,  248,  245,  247,
- /*   490 */   244,  191,  121,  191,  122,  126,  128,  243,  191,  191,
- /*   500 */   130,  191,  127,  191,  191,  120,  191,  191,  191,  119,
- /*   510 */   191,  191,  191,  118,  241,  191,  191,  191,  191,  191,
- /*   520 */   242,  191,  191,  191,  191,  191,  191,  191,  191,  132,
- /*   530 */   191,   87,  191,  191,  191,  191,  191,  191,  191,  191,
+ /*   230 */     9,  210,    1,    2,  252,   67,    5,  109,    7,  236,
+ /*   240 */     9,   73,   74,   75,  116,  228,  229,  230,  231,  194,
+ /*   250 */   195,    5,  191,    7,   33,   34,  191,  236,   37,  191,
+ /*   260 */    88,   76,   90,   91,   33,   34,   81,   95,  191,   97,
+ /*   270 */    98,   99,  104,  101,  102,  209,  234,   37,  212,  213,
+ /*   280 */   112,  137,   60,  217,  140,  219,  220,  221,  237,  223,
+ /*   290 */   224,  249,    2,  232,  191,    5,  235,    7,  233,    9,
+ /*   300 */   232,  250,  134,  235,  136,   25,   26,   27,   28,  232,
+ /*   310 */   142,   15,  235,   33,   34,  191,  196,   37,   38,   39,
+ /*   320 */   200,   62,   63,   33,   34,  104,  104,   68,   69,   70,
+ /*   330 */    71,   72,  111,  104,    5,  104,    7,   78,  117,  191,
+ /*   340 */   191,  112,  111,   62,   63,   37,   38,   39,  117,   68,
+ /*   350 */    69,   70,   71,   72,  133,  115,  232,  124,  125,  235,
+ /*   360 */    62,   63,  259,  117,  133,  105,   68,   69,   70,   71,
+ /*   370 */    72,   33,   34,  113,  196,   37,   38,   39,  200,  105,
+ /*   380 */   232,  232,  105,  235,  235,    1,  109,  113,  104,   64,
+ /*   390 */    65,   66,  108,  105,  110,  109,  105,  109,  105,  105,
+ /*   400 */   109,  111,  109,  109,  105,  105,  109,  111,  109,  109,
+ /*   410 */   105,  105,  105,  252,  109,  109,  109,  131,  105,  252,
+ /*   420 */   104,   37,  109,  107,   76,   77,  129,  138,  139,  252,
+ /*   430 */   138,  139,  252,  138,  139,  104,    5,  106,    7,  138,
+ /*   440 */   139,    5,  252,    7,   62,   63,  117,  252,  252,  252,
+ /*   450 */   252,  252,  252,  252,  252,  252,  252,  227,  191,  236,
+ /*   460 */   236,  227,  227,  227,  227,  227,  227,  191,  251,  191,
+ /*   470 */   191,  260,  260,  191,  191,  234,  234,   60,  191,  234,
+ /*   480 */   225,  238,  256,  256,  256,  117,  103,   87,  256,  239,
+ /*   490 */   242,  244,  248,  191,  191,  191,  247,  246,  122,  128,
+ /*   500 */   191,  191,  191,  191,  130,  191,  191,  127,  191,  191,
+ /*   510 */   191,  191,  191,  191,  191,  191,  245,  191,  191,  191,
+ /*   520 */   126,  191,  121,  191,  191,  191,  191,  191,  191,  120,
+ /*   530 */   191,  191,  191,  191,  191,  191,  191,  191,  191,  119,
  /*   540 */   191,  191,  191,  191,  191,  191,  191,  191,  191,  191,
- /*   550 */    86,  191,  191,  191,   50,  192,  192,   83,  192,  192,
- /*   560 */    85,   54,   84,   82,   79,    5,  192,  145,  192,  192,
- /*   570 */     5,    5,    5,  145,    5,   89,  192,   90,  197,  192,
- /*   580 */   197,  135,  113,  107,  104,  114,  109,  105,  105,  105,
- /*   590 */   192,  202,  104,  193,  208,  207,  204,  206,  205,  203,
- /*   600 */   201,  193,  192,  198,  225,  193,  192,  194,  193,  192,
- /*   610 */   109,    1,  104,  240,  104,  109,  105,  104,  123,  225,
- /*   620 */   123,  109,  105,  104,  104,  111,  104,  104,  107,   76,
- /*   630 */     9,    5,  108,    5,    5,    5,    5,   80,   15,   76,
- /*   640 */   109,  139,  139,   16,  139,    5,    5,  105,    5,    5,
- /*   650 */     5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
- /*   660 */     5,    5,    5,    5,    5,  109,   80,   60,   59,    0,
- /*   670 */   263,  263,  263,  263,  263,  263,  263,  263,  263,  263,
- /*   680 */   263,   21,   21,  263,  263,  263,  263,  263,  263,  263,
- /*   690 */   263,  263,  263,  263,  263,  263,  263,  263,  263,  263,
- /*   700 */   263,  263,  263,  263,  263,  263,  263,  263,  263,  263,
- /*   710 */   263,  263,  263,  263,  263,  263,  263,  263,  263,  263,
- /*   720 */   263,  263,  263,  263,  263,  263,  263,  263,  263,  263,
- /*   730 */   263,  263,  263,  263,  263,  263,  263,  263,  263,  263,
- /*   740 */   263,  263,  263,  263,  263,  263,  263,  263,  263,  263,
- /*   750 */   263,  263,  263,  263,  263,  263,  263,  263,  263,  263,
- /*   760 */   263,  263,  263,  263,  263,  263,  263,  263,  263,  263,
- /*   770 */   263,  263,  263,  263,  263,  263,  263,  263,  263,  263,
- /*   780 */   263,  263,  263,  263,  263,  263,  263,  263,  263,  263,
- /*   790 */   263,  263,  263,  263,  263,  263,  263,  263,  263,  263,
- /*   800 */   263,  263,  263,  263,  263,  263,  263,  263,  263,  263,
- /*   810 */   263,  263,  263,  263,  263,  263,  263,  263,  263,  263,
- /*   820 */   263,  263,  263,  263,  263,  263,  263,  263,  263,  263,
- /*   830 */   263,  263,  263,  263,  263,  263,  263,  263,  263,  263,
- /*   840 */   263,  263,  263,  263,  263,  263,  263,  263,  263,  263,
- /*   850 */   263,  263,  263,  263,  263,  263,  263,  263,  263,  263,
- /*   860 */   263,  263,  263,  263,  263,  263,  263,  263,  263,  263,
+ /*   550 */   191,  191,  191,  191,  191,  191,  118,  192,  192,  192,
+ /*   560 */   132,  192,  192,   86,   50,   83,   85,  192,   84,   54,
+ /*   570 */   192,  192,   82,   79,    5,  145,    5,    5,  197,  192,
+ /*   580 */   192,    5,  197,    5,  145,   90,   89,  135,  113,  192,
+ /*   590 */   107,  193,  202,  104,  208,  203,  207,  206,  205,  204,
+ /*   600 */   201,  193,  192,  198,  193,  192,  194,  193,  192,  105,
+ /*   610 */   114,  104,  109,  105,  241,  243,  104,  240,  109,  109,
+ /*   620 */   104,  225,  105,    1,  104,  123,  105,  104,  109,  123,
+ /*   630 */   105,  109,  104,  104,  104,  111,  104,   76,  107,    9,
+ /*   640 */     5,  108,    5,    5,    5,    5,   80,   15,  109,   76,
+ /*   650 */   139,    5,   16,    5,  105,    5,    5,  139,    5,    5,
+ /*   660 */     5,    5,    5,    5,    5,  139,    5,    5,    5,    5,
+ /*   670 */     5,    5,    5,    5,  109,   80,   60,   59,    0,  264,
+ /*   680 */   264,   21,  264,  264,  264,  264,  264,  264,  264,  264,
+ /*   690 */    21,  264,  264,  264,  264,  264,  264,  264,  264,  264,
+ /*   700 */   264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
+ /*   710 */   264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
+ /*   720 */   264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
+ /*   730 */   264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
+ /*   740 */   264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
+ /*   750 */   264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
+ /*   760 */   264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
+ /*   770 */   264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
+ /*   780 */   264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
+ /*   790 */   264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
+ /*   800 */   264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
+ /*   810 */   264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
+ /*   820 */   264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
+ /*   830 */   264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
+ /*   840 */   264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
+ /*   850 */   264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
+ /*   860 */   264,  264,  264,  264,  264,  264,  264,  264,  264,  264,
+ /*   870 */   264,  264,  264,  264,  264,  264,  264,  264,
 };
-#define YY_SHIFT_COUNT    (314)
+#define YY_SHIFT_COUNT    (320)
 #define YY_SHIFT_MIN      (0)
-#define YY_SHIFT_MAX      (669)
+#define YY_SHIFT_MAX      (678)
 static const unsigned short int yy_shift_ofst[] = {
- /*     0 */   168,   79,   79,  172,  172,    9,  221,  231,  106,  106,
- /*    10 */   106,  106,  106,  106,  106,  106,  106,    0,   48,  231,
- /*    20 */   290,  290,  290,  290,  121,  149,  106,  106,  106,  237,
- /*    30 */   106,  106,   55,    9,   37,   37,  683,  683,  683,  231,
+ /*     0 */   168,   79,   79,  172,  172,   63,  221,  231,  121,  106,
+ /*    10 */   106,  106,  106,  106,  106,  106,  106,  106,    0,   48,
+ /*    20 */   231,  290,  290,  290,  290,  229,  229,  106,  106,  106,
+ /*    30 */    29,  106,  106,  185,   63,    1,    1,  691,  691,  691,
  /*    40 */   231,  231,  231,  231,  231,  231,  231,  231,  231,  231,
- /*    50 */   231,  231,  231,  231,  231,  231,  231,  231,  231,  290,
- /*    60 */   290,   78,   78,   78,   78,   78,   78,   78,  106,  106,
- /*    70 */   106,  264,  106,  149,  149,  106,  106,  106,  265,  265,
- /*    80 */   276,  149,  106,  106,  106,  106,  106,  106,  106,  106,
+ /*    50 */   231,  231,  231,  231,  231,  231,  231,  231,  231,  231,
+ /*    60 */   290,  290,   25,   25,   25,   25,   25,   25,   25,  106,
+ /*    70 */   106,  106,  240,  106,  106,  106,  229,  229,  106,  106,
+ /*    80 */   106,  233,  233,  128,  229,  106,  106,  106,  106,  106,
  /*    90 */   106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
  /*   100 */   106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
  /*   110 */   106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
  /*   120 */   106,  106,  106,  106,  106,  106,  106,  106,  106,  106,
- /*   130 */   106,  106,  411,  411,  411,  365,  365,  365,  411,  365,
- /*   140 */   411,  368,  370,  375,  372,  369,  371,  385,  390,  395,
- /*   150 */   397,  411,  411,  411,  378,    9,    9,  411,  411,  444,
- /*   160 */   464,  504,  474,  475,  507,  478,  481,  378,  411,  485,
- /*   170 */   485,  411,  485,  411,  485,  411,  683,  683,   27,  100,
- /*   180 */   127,  100,  100,   53,  182,  280,  280,  280,  280,  259,
- /*   190 */   281,  298,  338,  338,  338,  338,   22,   14,  212,  212,
- /*   200 */   329,  340,  274,  151,  322,  286,  250,  288,  289,  291,
- /*   210 */   294,  297,  380,  305,  296,  108,  295,  303,  306,  309,
- /*   220 */   311,  314,  318,  292,  299,  301,  323,  304,  421,  427,
- /*   230 */   359,  382,  560,  422,  565,  566,  428,  567,  569,  487,
- /*   240 */   486,  446,  469,  476,  480,  471,  482,  477,  483,  488,
- /*   250 */   484,  501,  508,  610,  510,  511,  513,  506,  495,  512,
- /*   260 */   497,  517,  519,  514,  520,  476,  522,  521,  523,  524,
- /*   270 */   553,  621,  626,  628,  629,  630,  631,  557,  623,  563,
- /*   280 */   502,  531,  531,  627,  503,  505,  531,  640,  641,  542,
- /*   290 */   531,  643,  644,  645,  646,  647,  648,  649,  650,  651,
- /*   300 */   652,  653,  654,  655,  656,  657,  658,  659,  556,  586,
- /*   310 */   660,  661,  607,  609,  669,
+ /*   130 */   106,  106,  106,  106,  106,  417,  417,  417,  368,  368,
+ /*   140 */   368,  417,  368,  417,  371,  374,  380,  376,  394,  401,
+ /*   150 */   409,  420,  438,  428,  417,  417,  417,  383,   63,   63,
+ /*   160 */   417,  417,  400,  477,  514,  482,  481,  515,  484,  490,
+ /*   170 */   383,  417,  494,  494,  417,  494,  417,  494,  417,  691,
+ /*   180 */   691,   27,  100,  127,  100,  100,   53,  182,  280,  280,
+ /*   190 */   280,  280,  259,  281,  298,  338,  338,  338,  338,   22,
+ /*   200 */    14,  308,  308,  246,  329,  284,  144,  325,  277,  260,
+ /*   210 */   274,  288,  291,  293,  294,  299,  384,  222,  296,  286,
+ /*   220 */   297,  300,  305,  306,  307,  313,  316,  289,  292,  295,
+ /*   230 */   331,  301,  431,  436,  348,  382,  569,  430,  571,  572,
+ /*   240 */   439,  576,  578,  495,  497,  452,  475,  483,  489,  496,
+ /*   250 */   504,  507,  503,  509,  508,  512,  517,  510,  516,  622,
+ /*   260 */   520,  521,  523,  519,  502,  522,  506,  525,  528,  524,
+ /*   270 */   529,  483,  530,  531,  532,  533,  561,  630,  635,  637,
+ /*   280 */   638,  639,  640,  566,  632,  573,  511,  539,  539,  636,
+ /*   290 */   518,  526,  539,  646,  648,  549,  539,  650,  651,  653,
+ /*   300 */   654,  655,  656,  657,  658,  659,  661,  662,  663,  664,
+ /*   310 */   665,  666,  667,  668,  565,  595,  660,  669,  616,  618,
+ /*   320 */   678,
 };
-#define YY_REDUCE_COUNT (177)
-#define YY_REDUCE_MIN   (-240)
-#define YY_REDUCE_MAX   (417)
+#define YY_REDUCE_COUNT (180)
+#define YY_REDUCE_MIN   (-247)
+#define YY_REDUCE_MAX   (416)
 static const short yy_reduce_ofst[] = {
- /*     0 */  -178,  -27,  -27,   66,   66,   17, -230, -216, -173, -176,
- /*    10 */   -45,   -8,   61,   68,   77,  124,  148, -185, -188, -233,
- /*    20 */  -206,  -91,   21,   46, -191,   32, -186, -183,   93,  -89,
- /*    30 */  -184, -106,    4,   47,   98,  162,   83,  142,  179, -240,
- /*    40 */  -217, -194, -117,  -96,  -51,  -18,   25,   94,  105,  153,
- /*    50 */   158,  161,  169,  181,  189,  195,  196,  197,  198,  215,
- /*    60 */   216,  226,  227,  228,  229,  232,  233,  234,  267,  271,
- /*    70 */   272,  213,  275,  235,  236,  277,  282,  283,  206,  208,
- /*    80 */   238,  241,  287,  293,  300,  302,  307,  308,  310,  312,
- /*    90 */   313,  315,  316,  317,  319,  320,  321,  324,  325,  326,
- /*   100 */   327,  328,  330,  331,  332,  333,  334,  335,  336,  337,
- /*   110 */   339,  341,  342,  343,  344,  345,  346,  347,  348,  349,
- /*   120 */   350,  351,  352,  353,  354,  355,  356,  357,  358,  360,
- /*   130 */   361,  362,  285,  363,  364,  217,  224,  225,  366,  230,
- /*   140 */   367,  239,  242,  240,  243,  246,  254,  278,  273,  373,
- /*   150 */   244,  374,  376,  377,  379,  381,  383,  384,  387,  386,
- /*   160 */   388,  391,  389,  393,  396,  392,  399,  394,  398,  400,
- /*   170 */   408,  410,  412,  414,  415,  417,  405,  413,
+ /*     0 */  -178,  -27,  -27,   66,   66,   17, -244, -217, -119,   -8,
+ /*    10 */  -176, -128,   61,   68,   77,  124,  148,  149, -191, -188,
+ /*    20 */  -221, -204,  -91,    3,   21, -227,   42, -103,  103,   65,
+ /*    30 */  -113,  -80, -123,    4, -193,  120,  178,   51,   19,   55,
+ /*    40 */  -247, -240, -177,  -51,  -18,  161,  167,  177,  180,  190,
+ /*    50 */   195,  196,  197,  198,  199,  200,  201,  202,  203,  204,
+ /*    60 */   223,  224,  230,  234,  235,  236,  237,  238,  239,  267,
+ /*    70 */   276,  278,  217,  279,  282,  283,  241,  242,  287,  302,
+ /*    80 */   303,  211,  212,  243,  245,  304,  309,  310,  311,  312,
+ /*    90 */   314,  315,  317,  318,  319,  320,  321,  322,  323,  324,
+ /*   100 */   326,  327,  328,  330,  332,  333,  334,  335,  336,  337,
+ /*   110 */   339,  340,  341,  342,  343,  344,  345,  346,  347,  349,
+ /*   120 */   350,  351,  352,  353,  354,  355,  356,  357,  358,  359,
+ /*   130 */   360,  361,  362,  363,  364,  365,  366,  367,  226,  227,
+ /*   140 */   228,  369,  232,  370,  244,  249,  251,  271,  247,  372,
+ /*   150 */   248,  373,  377,  250,  375,  378,  379,  255,  381,  385,
+ /*   160 */   387,  388,  386,  389,  391,  390,  393,  392,  395,  399,
+ /*   170 */   396,  397,  398,  408,  410,  411,  413,  414,  416,  405,
+ /*   180 */   412,
 };
 static const YYACTIONTYPE yy_default[] = {
- /*     0 */   777,  889,  835,  901,  823,  832, 1032, 1032,  777,  777,
- /*    10 */   777,  777,  777,  777,  777,  777,  777,  948,  796, 1032,
- /*    20 */   777,  777,  777,  777,  777,  777,  777,  777,  777,  832,
- /*    30 */   777,  777,  838,  832,  838,  838,  943,  873,  891,  777,
- /*    40 */   777,  777,  777,  777,  777,  777,  777,  777,  777,  777,
- /*    50 */   777,  777,  777,  777,  777,  777,  777,  777,  777,  777,
- /*    60 */   777,  777,  777,  777,  777,  777,  777,  777,  777,  777,
- /*    70 */   777,  950,  953,  777,  777,  955,  777,  777,  975,  975,
- /*    80 */   941,  777,  777,  777,  777,  777,  777,  777,  777,  777,
- /*    90 */   777,  777,  777,  777,  777,  777,  777,  777,  777,  777,
- /*   100 */   777,  777,  777,  777,  777,  777,  777,  777,  777,  821,
- /*   110 */   777,  819,  777,  777,  777,  777,  777,  777,  777,  777,
- /*   120 */   777,  777,  777,  777,  777,  777,  806,  777,  777,  777,
- /*   130 */   777,  777,  798,  798,  798,  777,  777,  777,  798,  777,
- /*   140 */   798,  982,  986,  980,  968,  976,  967,  963,  961,  960,
- /*   150 */   990,  798,  798,  798,  836,  832,  832,  798,  798,  854,
- /*   160 */   852,  850,  842,  848,  844,  846,  840,  824,  798,  830,
- /*   170 */   830,  798,  830,  798,  830,  798,  873,  891,  777,  991,
- /*   180 */   777, 1031,  981, 1021, 1020, 1027, 1019, 1018, 1017,  777,
- /*   190 */   777,  777, 1013, 1014, 1016, 1015,  777,  777, 1023, 1022,
- /*   200 */   777,  777,  777,  777,  777,  777,  777,  777,  777,  777,
- /*   210 */   777,  777,  777,  993,  777,  987,  983,  777,  777,  777,
- /*   220 */   777,  777,  777,  777,  777,  777,  903,  777,  777,  777,
- /*   230 */   777,  777,  777,  777,  777,  777,  777,  777,  777,  777,
- /*   240 */   777,  777,  940,  777,  777,  777,  777,  951,  777,  777,
- /*   250 */   777,  777,  777,  777,  777,  777,  777,  977,  777,  969,
- /*   260 */   777,  777,  777,  777,  777,  915,  777,  777,  777,  777,
- /*   270 */   777,  777,  777,  777,  777,  777,  777,  777,  777,  777,
- /*   280 */   777, 1043, 1041,  777,  777,  777, 1037,  777,  777,  777,
- /*   290 */  1035,  777,  777,  777,  777,  777,  777,  777,  777,  777,
- /*   300 */   777,  777,  777,  777,  777,  777,  777,  777,  857,  777,
- /*   310 */   804,  802,  777,  794,  777,
+ /*     0 */   787,  899,  845,  911,  833,  842, 1045, 1045,  787,  787,
+ /*    10 */   787,  787,  787,  787,  787,  787,  787,  787,  958,  806,
+ /*    20 */  1045,  787,  787,  787,  787,  787,  787,  787,  787,  787,
+ /*    30 */   842,  787,  787,  848,  842,  848,  848,  953,  883,  901,
+ /*    40 */   787,  787,  787,  787,  787,  787,  787,  787,  787,  787,
+ /*    50 */   787,  787,  787,  787,  787,  787,  787,  787,  787,  787,
+ /*    60 */   787,  787,  787,  787,  787,  787,  787,  787,  787,  787,
+ /*    70 */   787,  787,  960,  966,  963,  787,  787,  787,  968,  787,
+ /*    80 */   787,  988,  988,  951,  787,  787,  787,  787,  787,  787,
+ /*    90 */   787,  787,  787,  787,  787,  787,  787,  787,  787,  787,
+ /*   100 */   787,  787,  787,  787,  787,  787,  787,  787,  787,  787,
+ /*   110 */   787,  787,  831,  787,  829,  787,  787,  787,  787,  787,
+ /*   120 */   787,  787,  787,  787,  787,  787,  787,  787,  787,  816,
+ /*   130 */   787,  787,  787,  787,  787,  808,  808,  808,  787,  787,
+ /*   140 */   787,  808,  787,  808,  995,  999,  993,  981,  989,  980,
+ /*   150 */   976,  974,  973, 1003,  808,  808,  808,  846,  842,  842,
+ /*   160 */   808,  808,  864,  862,  860,  852,  858,  854,  856,  850,
+ /*   170 */   834,  808,  840,  840,  808,  840,  808,  840,  808,  883,
+ /*   180 */   901,  787, 1004,  787, 1044,  994, 1034, 1033, 1040, 1032,
+ /*   190 */  1031, 1030,  787,  787,  787, 1026, 1027, 1029, 1028,  787,
+ /*   200 */   787, 1036, 1035,  787,  787,  787,  787,  787,  787,  787,
+ /*   210 */   787,  787,  787,  787,  787,  787,  787, 1006,  787, 1000,
+ /*   220 */   996,  787,  787,  787,  787,  787,  787,  787,  787,  787,
+ /*   230 */   913,  787,  787,  787,  787,  787,  787,  787,  787,  787,
+ /*   240 */   787,  787,  787,  787,  787,  787,  950,  787,  787,  787,
+ /*   250 */   787,  787,  962,  961,  787,  787,  787,  787,  787,  787,
+ /*   260 */   787,  787,  787,  990,  787,  982,  787,  787,  787,  787,
+ /*   270 */   787,  925,  787,  787,  787,  787,  787,  787,  787,  787,
+ /*   280 */   787,  787,  787,  787,  787,  787,  787, 1056, 1054,  787,
+ /*   290 */   787,  787, 1050,  787,  787,  787, 1048,  787,  787,  787,
+ /*   300 */   787,  787,  787,  787,  787,  787,  787,  787,  787,  787,
+ /*   310 */   787,  787,  787,  787,  867,  787,  814,  812,  787,  804,
+ /*   320 */   787,
 };
 /********** End of lemon-generated parsing tables *****************************/
 
@@ -1004,14 +1009,15 @@ static const char *const yyTokenName[] = {
   /*  252 */ "expr",
   /*  253 */ "as",
   /*  254 */ "tablelist",
-  /*  255 */ "tmvar",
-  /*  256 */ "sortlist",
-  /*  257 */ "sortitem",
-  /*  258 */ "item",
-  /*  259 */ "sortorder",
-  /*  260 */ "grouplist",
-  /*  261 */ "exprlist",
-  /*  262 */ "expritem",
+  /*  255 */ "sub",
+  /*  256 */ "tmvar",
+  /*  257 */ "sortlist",
+  /*  258 */ "sortitem",
+  /*  259 */ "item",
+  /*  260 */ "sortorder",
+  /*  261 */ "grouplist",
+  /*  262 */ "exprlist",
+  /*  263 */ "expritem",
 };
 #endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */
 
@@ -1191,103 +1197,106 @@ static const char *const yyRuleName[] = {
  /* 169 */ "distinct ::= DISTINCT",
  /* 170 */ "distinct ::=",
  /* 171 */ "from ::= FROM tablelist",
- /* 172 */ "from ::= FROM LP union RP",
- /* 173 */ "tablelist ::= ids cpxName",
- /* 174 */ "tablelist ::= ids cpxName ids",
- /* 175 */ "tablelist ::= tablelist COMMA ids cpxName",
- /* 176 */ "tablelist ::= tablelist COMMA ids cpxName ids",
- /* 177 */ "tmvar ::= VARIABLE",
- /* 178 */ "interval_opt ::= INTERVAL LP tmvar RP",
- /* 179 */ "interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP",
- /* 180 */ "interval_opt ::=",
- /* 181 */ "session_option ::=",
- /* 182 */ "session_option ::= SESSION LP ids cpxName COMMA tmvar RP",
- /* 183 */ "fill_opt ::=",
- /* 184 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
- /* 185 */ "fill_opt ::= FILL LP ID RP",
- /* 186 */ "sliding_opt ::= SLIDING LP tmvar RP",
- /* 187 */ "sliding_opt ::=",
- /* 188 */ "orderby_opt ::=",
- /* 189 */ "orderby_opt ::= ORDER BY sortlist",
- /* 190 */ "sortlist ::= sortlist COMMA item sortorder",
- /* 191 */ "sortlist ::= item sortorder",
- /* 192 */ "item ::= ids cpxName",
- /* 193 */ "sortorder ::= ASC",
- /* 194 */ "sortorder ::= DESC",
- /* 195 */ "sortorder ::=",
- /* 196 */ "groupby_opt ::=",
- /* 197 */ "groupby_opt ::= GROUP BY grouplist",
- /* 198 */ "grouplist ::= grouplist COMMA item",
- /* 199 */ "grouplist ::= item",
- /* 200 */ "having_opt ::=",
- /* 201 */ "having_opt ::= HAVING expr",
- /* 202 */ "limit_opt ::=",
- /* 203 */ "limit_opt ::= LIMIT signed",
- /* 204 */ "limit_opt ::= LIMIT signed OFFSET signed",
- /* 205 */ "limit_opt ::= LIMIT signed COMMA signed",
- /* 206 */ "slimit_opt ::=",
- /* 207 */ "slimit_opt ::= SLIMIT signed",
- /* 208 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
- /* 209 */ "slimit_opt ::= SLIMIT signed COMMA signed",
- /* 210 */ "where_opt ::=",
- /* 211 */ "where_opt ::= WHERE expr",
- /* 212 */ "expr ::= LP expr RP",
- /* 213 */ "expr ::= ID",
- /* 214 */ "expr ::= ID DOT ID",
- /* 215 */ "expr ::= ID DOT STAR",
- /* 216 */ "expr ::= INTEGER",
- /* 217 */ "expr ::= MINUS INTEGER",
- /* 218 */ "expr ::= PLUS INTEGER",
- /* 219 */ "expr ::= FLOAT",
- /* 220 */ "expr ::= MINUS FLOAT",
- /* 221 */ "expr ::= PLUS FLOAT",
- /* 222 */ "expr ::= STRING",
- /* 223 */ "expr ::= NOW",
- /* 224 */ "expr ::= VARIABLE",
- /* 225 */ "expr ::= PLUS VARIABLE",
- /* 226 */ "expr ::= MINUS VARIABLE",
- /* 227 */ "expr ::= BOOL",
- /* 228 */ "expr ::= NULL",
- /* 229 */ "expr ::= ID LP exprlist RP",
- /* 230 */ "expr ::= ID LP STAR RP",
- /* 231 */ "expr ::= expr IS NULL",
- /* 232 */ "expr ::= expr IS NOT NULL",
- /* 233 */ "expr ::= expr LT expr",
- /* 234 */ "expr ::= expr GT expr",
- /* 235 */ "expr ::= expr LE expr",
- /* 236 */ "expr ::= expr GE expr",
- /* 237 */ "expr ::= expr NE expr",
- /* 238 */ "expr ::= expr EQ expr",
- /* 239 */ "expr ::= expr BETWEEN expr AND expr",
- /* 240 */ "expr ::= expr AND expr",
- /* 241 */ "expr ::= expr OR expr",
- /* 242 */ "expr ::= expr PLUS expr",
- /* 243 */ "expr ::= expr MINUS expr",
- /* 244 */ "expr ::= expr STAR expr",
- /* 245 */ "expr ::= expr SLASH expr",
- /* 246 */ "expr ::= expr REM expr",
- /* 247 */ "expr ::= expr LIKE expr",
- /* 248 */ "expr ::= expr IN LP exprlist RP",
- /* 249 */ "exprlist ::= exprlist COMMA expritem",
- /* 250 */ "exprlist ::= expritem",
- /* 251 */ "expritem ::= expr",
- /* 252 */ "expritem ::=",
- /* 253 */ "cmd ::= RESET QUERY CACHE",
- /* 254 */ "cmd ::= SYNCDB ids REPLICA",
- /* 255 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
- /* 256 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
- /* 257 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
- /* 258 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
- /* 259 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
- /* 260 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
- /* 261 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist",
- /* 262 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids",
- /* 263 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist",
- /* 264 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids",
- /* 265 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids",
- /* 266 */ "cmd ::= KILL CONNECTION INTEGER",
- /* 267 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
- /* 268 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
+ /* 172 */ "from ::= FROM sub",
+ /* 173 */ "sub ::= LP union RP",
+ /* 174 */ "sub ::= LP union RP ids",
+ /* 175 */ "sub ::= sub COMMA LP union RP ids",
+ /* 176 */ "tablelist ::= ids cpxName",
+ /* 177 */ "tablelist ::= ids cpxName ids",
+ /* 178 */ "tablelist ::= tablelist COMMA ids cpxName",
+ /* 179 */ "tablelist ::= tablelist COMMA ids cpxName ids",
+ /* 180 */ "tmvar ::= VARIABLE",
+ /* 181 */ "interval_opt ::= INTERVAL LP tmvar RP",
+ /* 182 */ "interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP",
+ /* 183 */ "interval_opt ::=",
+ /* 184 */ "session_option ::=",
+ /* 185 */ "session_option ::= SESSION LP ids cpxName COMMA tmvar RP",
+ /* 186 */ "fill_opt ::=",
+ /* 187 */ "fill_opt ::= FILL LP ID COMMA tagitemlist RP",
+ /* 188 */ "fill_opt ::= FILL LP ID RP",
+ /* 189 */ "sliding_opt ::= SLIDING LP tmvar RP",
+ /* 190 */ "sliding_opt ::=",
+ /* 191 */ "orderby_opt ::=",
+ /* 192 */ "orderby_opt ::= ORDER BY sortlist",
+ /* 193 */ "sortlist ::= sortlist COMMA item sortorder",
+ /* 194 */ "sortlist ::= item sortorder",
+ /* 195 */ "item ::= ids cpxName",
+ /* 196 */ "sortorder ::= ASC",
+ /* 197 */ "sortorder ::= DESC",
+ /* 198 */ "sortorder ::=",
+ /* 199 */ "groupby_opt ::=",
+ /* 200 */ "groupby_opt ::= GROUP BY grouplist",
+ /* 201 */ "grouplist ::= grouplist COMMA item",
+ /* 202 */ "grouplist ::= item",
+ /* 203 */ "having_opt ::=",
+ /* 204 */ "having_opt ::= HAVING expr",
+ /* 205 */ "limit_opt ::=",
+ /* 206 */ "limit_opt ::= LIMIT signed",
+ /* 207 */ "limit_opt ::= LIMIT signed OFFSET signed",
+ /* 208 */ "limit_opt ::= LIMIT signed COMMA signed",
+ /* 209 */ "slimit_opt ::=",
+ /* 210 */ "slimit_opt ::= SLIMIT signed",
+ /* 211 */ "slimit_opt ::= SLIMIT signed SOFFSET signed",
+ /* 212 */ "slimit_opt ::= SLIMIT signed COMMA signed",
+ /* 213 */ "where_opt ::=",
+ /* 214 */ "where_opt ::= WHERE expr",
+ /* 215 */ "expr ::= LP expr RP",
+ /* 216 */ "expr ::= ID",
+ /* 217 */ "expr ::= ID DOT ID",
+ /* 218 */ "expr ::= ID DOT STAR",
+ /* 219 */ "expr ::= INTEGER",
+ /* 220 */ "expr ::= MINUS INTEGER",
+ /* 221 */ "expr ::= PLUS INTEGER",
+ /* 222 */ "expr ::= FLOAT",
+ /* 223 */ "expr ::= MINUS FLOAT",
+ /* 224 */ "expr ::= PLUS FLOAT",
+ /* 225 */ "expr ::= STRING",
+ /* 226 */ "expr ::= NOW",
+ /* 227 */ "expr ::= VARIABLE",
+ /* 228 */ "expr ::= PLUS VARIABLE",
+ /* 229 */ "expr ::= MINUS VARIABLE",
+ /* 230 */ "expr ::= BOOL",
+ /* 231 */ "expr ::= NULL",
+ /* 232 */ "expr ::= ID LP exprlist RP",
+ /* 233 */ "expr ::= ID LP STAR RP",
+ /* 234 */ "expr ::= expr IS NULL",
+ /* 235 */ "expr ::= expr IS NOT NULL",
+ /* 236 */ "expr ::= expr LT expr",
+ /* 237 */ "expr ::= expr GT expr",
+ /* 238 */ "expr ::= expr LE expr",
+ /* 239 */ "expr ::= expr GE expr",
+ /* 240 */ "expr ::= expr NE expr",
+ /* 241 */ "expr ::= expr EQ expr",
+ /* 242 */ "expr ::= expr BETWEEN expr AND expr",
+ /* 243 */ "expr ::= expr AND expr",
+ /* 244 */ "expr ::= expr OR expr",
+ /* 245 */ "expr ::= expr PLUS expr",
+ /* 246 */ "expr ::= expr MINUS expr",
+ /* 247 */ "expr ::= expr STAR expr",
+ /* 248 */ "expr ::= expr SLASH expr",
+ /* 249 */ "expr ::= expr REM expr",
+ /* 250 */ "expr ::= expr LIKE expr",
+ /* 251 */ "expr ::= expr IN LP exprlist RP",
+ /* 252 */ "exprlist ::= exprlist COMMA expritem",
+ /* 253 */ "exprlist ::= expritem",
+ /* 254 */ "expritem ::= expr",
+ /* 255 */ "expritem ::=",
+ /* 256 */ "cmd ::= RESET QUERY CACHE",
+ /* 257 */ "cmd ::= SYNCDB ids REPLICA",
+ /* 258 */ "cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist",
+ /* 259 */ "cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids",
+ /* 260 */ "cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist",
+ /* 261 */ "cmd ::= ALTER TABLE ids cpxName DROP TAG ids",
+ /* 262 */ "cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids",
+ /* 263 */ "cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem",
+ /* 264 */ "cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist",
+ /* 265 */ "cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids",
+ /* 266 */ "cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist",
+ /* 267 */ "cmd ::= ALTER STABLE ids cpxName DROP TAG ids",
+ /* 268 */ "cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids",
+ /* 269 */ "cmd ::= KILL CONNECTION INTEGER",
+ /* 270 */ "cmd ::= KILL STREAM INTEGER COLON INTEGER",
+ /* 271 */ "cmd ::= KILL QUERY INTEGER COLON INTEGER",
 };
 #endif /* NDEBUG */
 
@@ -1415,51 +1424,52 @@ static void yy_destructor(
     case 242: /* fill_opt */
     case 244: /* groupby_opt */
     case 245: /* orderby_opt */
-    case 256: /* sortlist */
-    case 260: /* grouplist */
+    case 257: /* sortlist */
+    case 261: /* grouplist */
 {
-taosArrayDestroy((yypminor->yy159));
+taosArrayDestroy((yypminor->yy285));
 }
       break;
     case 230: /* create_table_list */
 {
-destroyCreateTableSql((yypminor->yy14));
+destroyCreateTableSql((yypminor->yy470));
 }
       break;
     case 234: /* select */
 {
-destroySqlNode((yypminor->yy116));
+destroySqlNode((yypminor->yy344));
 }
       break;
     case 237: /* selcollist */
     case 250: /* sclp */
-    case 261: /* exprlist */
+    case 262: /* exprlist */
 {
-tSqlExprListDestroy((yypminor->yy159));
+tSqlExprListDestroy((yypminor->yy285));
 }
       break;
     case 238: /* from */
     case 254: /* tablelist */
+    case 255: /* sub */
 {
-destroyRelationInfo((yypminor->yy236));
+destroyRelationInfo((yypminor->yy148));
 }
       break;
     case 239: /* where_opt */
     case 246: /* having_opt */
     case 252: /* expr */
-    case 262: /* expritem */
+    case 263: /* expritem */
 {
-tSqlExprDestroy((yypminor->yy118));
+tSqlExprDestroy((yypminor->yy178));
 }
       break;
     case 249: /* union */
 {
-destroyAllSqlNode((yypminor->yy159));
+destroyAllSqlNode((yypminor->yy285));
 }
       break;
-    case 257: /* sortitem */
+    case 258: /* sortitem */
 {
-tVariantDestroy(&(yypminor->yy488));
+tVariantDestroy(&(yypminor->yy362));
 }
       break;
 /********* End destructor definitions *****************************************/
@@ -1925,103 +1935,106 @@ static const struct {
   {  251,   -1 }, /* (169) distinct ::= DISTINCT */
   {  251,    0 }, /* (170) distinct ::= */
   {  238,   -2 }, /* (171) from ::= FROM tablelist */
-  {  238,   -4 }, /* (172) from ::= FROM LP union RP */
-  {  254,   -2 }, /* (173) tablelist ::= ids cpxName */
-  {  254,   -3 }, /* (174) tablelist ::= ids cpxName ids */
-  {  254,   -4 }, /* (175) tablelist ::= tablelist COMMA ids cpxName */
-  {  254,   -5 }, /* (176) tablelist ::= tablelist COMMA ids cpxName ids */
-  {  255,   -1 }, /* (177) tmvar ::= VARIABLE */
-  {  240,   -4 }, /* (178) interval_opt ::= INTERVAL LP tmvar RP */
-  {  240,   -6 }, /* (179) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
-  {  240,    0 }, /* (180) interval_opt ::= */
-  {  241,    0 }, /* (181) session_option ::= */
-  {  241,   -7 }, /* (182) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
-  {  242,    0 }, /* (183) fill_opt ::= */
-  {  242,   -6 }, /* (184) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
-  {  242,   -4 }, /* (185) fill_opt ::= FILL LP ID RP */
-  {  243,   -4 }, /* (186) sliding_opt ::= SLIDING LP tmvar RP */
-  {  243,    0 }, /* (187) sliding_opt ::= */
-  {  245,    0 }, /* (188) orderby_opt ::= */
-  {  245,   -3 }, /* (189) orderby_opt ::= ORDER BY sortlist */
-  {  256,   -4 }, /* (190) sortlist ::= sortlist COMMA item sortorder */
-  {  256,   -2 }, /* (191) sortlist ::= item sortorder */
-  {  258,   -2 }, /* (192) item ::= ids cpxName */
-  {  259,   -1 }, /* (193) sortorder ::= ASC */
-  {  259,   -1 }, /* (194) sortorder ::= DESC */
-  {  259,    0 }, /* (195) sortorder ::= */
-  {  244,    0 }, /* (196) groupby_opt ::= */
-  {  244,   -3 }, /* (197) groupby_opt ::= GROUP BY grouplist */
-  {  260,   -3 }, /* (198) grouplist ::= grouplist COMMA item */
-  {  260,   -1 }, /* (199) grouplist ::= item */
-  {  246,    0 }, /* (200) having_opt ::= */
-  {  246,   -2 }, /* (201) having_opt ::= HAVING expr */
-  {  248,    0 }, /* (202) limit_opt ::= */
-  {  248,   -2 }, /* (203) limit_opt ::= LIMIT signed */
-  {  248,   -4 }, /* (204) limit_opt ::= LIMIT signed OFFSET signed */
-  {  248,   -4 }, /* (205) limit_opt ::= LIMIT signed COMMA signed */
-  {  247,    0 }, /* (206) slimit_opt ::= */
-  {  247,   -2 }, /* (207) slimit_opt ::= SLIMIT signed */
-  {  247,   -4 }, /* (208) slimit_opt ::= SLIMIT signed SOFFSET signed */
-  {  247,   -4 }, /* (209) slimit_opt ::= SLIMIT signed COMMA signed */
-  {  239,    0 }, /* (210) where_opt ::= */
-  {  239,   -2 }, /* (211) where_opt ::= WHERE expr */
-  {  252,   -3 }, /* (212) expr ::= LP expr RP */
-  {  252,   -1 }, /* (213) expr ::= ID */
-  {  252,   -3 }, /* (214) expr ::= ID DOT ID */
-  {  252,   -3 }, /* (215) expr ::= ID DOT STAR */
-  {  252,   -1 }, /* (216) expr ::= INTEGER */
-  {  252,   -2 }, /* (217) expr ::= MINUS INTEGER */
-  {  252,   -2 }, /* (218) expr ::= PLUS INTEGER */
-  {  252,   -1 }, /* (219) expr ::= FLOAT */
-  {  252,   -2 }, /* (220) expr ::= MINUS FLOAT */
-  {  252,   -2 }, /* (221) expr ::= PLUS FLOAT */
-  {  252,   -1 }, /* (222) expr ::= STRING */
-  {  252,   -1 }, /* (223) expr ::= NOW */
-  {  252,   -1 }, /* (224) expr ::= VARIABLE */
-  {  252,   -2 }, /* (225) expr ::= PLUS VARIABLE */
-  {  252,   -2 }, /* (226) expr ::= MINUS VARIABLE */
-  {  252,   -1 }, /* (227) expr ::= BOOL */
-  {  252,   -1 }, /* (228) expr ::= NULL */
-  {  252,   -4 }, /* (229) expr ::= ID LP exprlist RP */
-  {  252,   -4 }, /* (230) expr ::= ID LP STAR RP */
-  {  252,   -3 }, /* (231) expr ::= expr IS NULL */
-  {  252,   -4 }, /* (232) expr ::= expr IS NOT NULL */
-  {  252,   -3 }, /* (233) expr ::= expr LT expr */
-  {  252,   -3 }, /* (234) expr ::= expr GT expr */
-  {  252,   -3 }, /* (235) expr ::= expr LE expr */
-  {  252,   -3 }, /* (236) expr ::= expr GE expr */
-  {  252,   -3 }, /* (237) expr ::= expr NE expr */
-  {  252,   -3 }, /* (238) expr ::= expr EQ expr */
-  {  252,   -5 }, /* (239) expr ::= expr BETWEEN expr AND expr */
-  {  252,   -3 }, /* (240) expr ::= expr AND expr */
-  {  252,   -3 }, /* (241) expr ::= expr OR expr */
-  {  252,   -3 }, /* (242) expr ::= expr PLUS expr */
-  {  252,   -3 }, /* (243) expr ::= expr MINUS expr */
-  {  252,   -3 }, /* (244) expr ::= expr STAR expr */
-  {  252,   -3 }, /* (245) expr ::= expr SLASH expr */
-  {  252,   -3 }, /* (246) expr ::= expr REM expr */
-  {  252,   -3 }, /* (247) expr ::= expr LIKE expr */
-  {  252,   -5 }, /* (248) expr ::= expr IN LP exprlist RP */
-  {  261,   -3 }, /* (249) exprlist ::= exprlist COMMA expritem */
-  {  261,   -1 }, /* (250) exprlist ::= expritem */
-  {  262,   -1 }, /* (251) expritem ::= expr */
-  {  262,    0 }, /* (252) expritem ::= */
-  {  189,   -3 }, /* (253) cmd ::= RESET QUERY CACHE */
-  {  189,   -3 }, /* (254) cmd ::= SYNCDB ids REPLICA */
-  {  189,   -7 }, /* (255) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
-  {  189,   -7 }, /* (256) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
-  {  189,   -7 }, /* (257) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
-  {  189,   -7 }, /* (258) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
-  {  189,   -8 }, /* (259) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
-  {  189,   -9 }, /* (260) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
-  {  189,   -7 }, /* (261) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
-  {  189,   -7 }, /* (262) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
-  {  189,   -7 }, /* (263) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
-  {  189,   -7 }, /* (264) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
-  {  189,   -8 }, /* (265) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
-  {  189,   -3 }, /* (266) cmd ::= KILL CONNECTION INTEGER */
-  {  189,   -5 }, /* (267) cmd ::= KILL STREAM INTEGER COLON INTEGER */
-  {  189,   -5 }, /* (268) cmd ::= KILL QUERY INTEGER COLON INTEGER */
+  {  238,   -2 }, /* (172) from ::= FROM sub */
+  {  255,   -3 }, /* (173) sub ::= LP union RP */
+  {  255,   -4 }, /* (174) sub ::= LP union RP ids */
+  {  255,   -6 }, /* (175) sub ::= sub COMMA LP union RP ids */
+  {  254,   -2 }, /* (176) tablelist ::= ids cpxName */
+  {  254,   -3 }, /* (177) tablelist ::= ids cpxName ids */
+  {  254,   -4 }, /* (178) tablelist ::= tablelist COMMA ids cpxName */
+  {  254,   -5 }, /* (179) tablelist ::= tablelist COMMA ids cpxName ids */
+  {  256,   -1 }, /* (180) tmvar ::= VARIABLE */
+  {  240,   -4 }, /* (181) interval_opt ::= INTERVAL LP tmvar RP */
+  {  240,   -6 }, /* (182) interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
+  {  240,    0 }, /* (183) interval_opt ::= */
+  {  241,    0 }, /* (184) session_option ::= */
+  {  241,   -7 }, /* (185) session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
+  {  242,    0 }, /* (186) fill_opt ::= */
+  {  242,   -6 }, /* (187) fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+  {  242,   -4 }, /* (188) fill_opt ::= FILL LP ID RP */
+  {  243,   -4 }, /* (189) sliding_opt ::= SLIDING LP tmvar RP */
+  {  243,    0 }, /* (190) sliding_opt ::= */
+  {  245,    0 }, /* (191) orderby_opt ::= */
+  {  245,   -3 }, /* (192) orderby_opt ::= ORDER BY sortlist */
+  {  257,   -4 }, /* (193) sortlist ::= sortlist COMMA item sortorder */
+  {  257,   -2 }, /* (194) sortlist ::= item sortorder */
+  {  259,   -2 }, /* (195) item ::= ids cpxName */
+  {  260,   -1 }, /* (196) sortorder ::= ASC */
+  {  260,   -1 }, /* (197) sortorder ::= DESC */
+  {  260,    0 }, /* (198) sortorder ::= */
+  {  244,    0 }, /* (199) groupby_opt ::= */
+  {  244,   -3 }, /* (200) groupby_opt ::= GROUP BY grouplist */
+  {  261,   -3 }, /* (201) grouplist ::= grouplist COMMA item */
+  {  261,   -1 }, /* (202) grouplist ::= item */
+  {  246,    0 }, /* (203) having_opt ::= */
+  {  246,   -2 }, /* (204) having_opt ::= HAVING expr */
+  {  248,    0 }, /* (205) limit_opt ::= */
+  {  248,   -2 }, /* (206) limit_opt ::= LIMIT signed */
+  {  248,   -4 }, /* (207) limit_opt ::= LIMIT signed OFFSET signed */
+  {  248,   -4 }, /* (208) limit_opt ::= LIMIT signed COMMA signed */
+  {  247,    0 }, /* (209) slimit_opt ::= */
+  {  247,   -2 }, /* (210) slimit_opt ::= SLIMIT signed */
+  {  247,   -4 }, /* (211) slimit_opt ::= SLIMIT signed SOFFSET signed */
+  {  247,   -4 }, /* (212) slimit_opt ::= SLIMIT signed COMMA signed */
+  {  239,    0 }, /* (213) where_opt ::= */
+  {  239,   -2 }, /* (214) where_opt ::= WHERE expr */
+  {  252,   -3 }, /* (215) expr ::= LP expr RP */
+  {  252,   -1 }, /* (216) expr ::= ID */
+  {  252,   -3 }, /* (217) expr ::= ID DOT ID */
+  {  252,   -3 }, /* (218) expr ::= ID DOT STAR */
+  {  252,   -1 }, /* (219) expr ::= INTEGER */
+  {  252,   -2 }, /* (220) expr ::= MINUS INTEGER */
+  {  252,   -2 }, /* (221) expr ::= PLUS INTEGER */
+  {  252,   -1 }, /* (222) expr ::= FLOAT */
+  {  252,   -2 }, /* (223) expr ::= MINUS FLOAT */
+  {  252,   -2 }, /* (224) expr ::= PLUS FLOAT */
+  {  252,   -1 }, /* (225) expr ::= STRING */
+  {  252,   -1 }, /* (226) expr ::= NOW */
+  {  252,   -1 }, /* (227) expr ::= VARIABLE */
+  {  252,   -2 }, /* (228) expr ::= PLUS VARIABLE */
+  {  252,   -2 }, /* (229) expr ::= MINUS VARIABLE */
+  {  252,   -1 }, /* (230) expr ::= BOOL */
+  {  252,   -1 }, /* (231) expr ::= NULL */
+  {  252,   -4 }, /* (232) expr ::= ID LP exprlist RP */
+  {  252,   -4 }, /* (233) expr ::= ID LP STAR RP */
+  {  252,   -3 }, /* (234) expr ::= expr IS NULL */
+  {  252,   -4 }, /* (235) expr ::= expr IS NOT NULL */
+  {  252,   -3 }, /* (236) expr ::= expr LT expr */
+  {  252,   -3 }, /* (237) expr ::= expr GT expr */
+  {  252,   -3 }, /* (238) expr ::= expr LE expr */
+  {  252,   -3 }, /* (239) expr ::= expr GE expr */
+  {  252,   -3 }, /* (240) expr ::= expr NE expr */
+  {  252,   -3 }, /* (241) expr ::= expr EQ expr */
+  {  252,   -5 }, /* (242) expr ::= expr BETWEEN expr AND expr */
+  {  252,   -3 }, /* (243) expr ::= expr AND expr */
+  {  252,   -3 }, /* (244) expr ::= expr OR expr */
+  {  252,   -3 }, /* (245) expr ::= expr PLUS expr */
+  {  252,   -3 }, /* (246) expr ::= expr MINUS expr */
+  {  252,   -3 }, /* (247) expr ::= expr STAR expr */
+  {  252,   -3 }, /* (248) expr ::= expr SLASH expr */
+  {  252,   -3 }, /* (249) expr ::= expr REM expr */
+  {  252,   -3 }, /* (250) expr ::= expr LIKE expr */
+  {  252,   -5 }, /* (251) expr ::= expr IN LP exprlist RP */
+  {  262,   -3 }, /* (252) exprlist ::= exprlist COMMA expritem */
+  {  262,   -1 }, /* (253) exprlist ::= expritem */
+  {  263,   -1 }, /* (254) expritem ::= expr */
+  {  263,    0 }, /* (255) expritem ::= */
+  {  189,   -3 }, /* (256) cmd ::= RESET QUERY CACHE */
+  {  189,   -3 }, /* (257) cmd ::= SYNCDB ids REPLICA */
+  {  189,   -7 }, /* (258) cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+  {  189,   -7 }, /* (259) cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+  {  189,   -7 }, /* (260) cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+  {  189,   -7 }, /* (261) cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+  {  189,   -8 }, /* (262) cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+  {  189,   -9 }, /* (263) cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+  {  189,   -7 }, /* (264) cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
+  {  189,   -7 }, /* (265) cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
+  {  189,   -7 }, /* (266) cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
+  {  189,   -7 }, /* (267) cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
+  {  189,   -8 }, /* (268) cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
+  {  189,   -3 }, /* (269) cmd ::= KILL CONNECTION INTEGER */
+  {  189,   -5 }, /* (270) cmd ::= KILL STREAM INTEGER COLON INTEGER */
+  {  189,   -5 }, /* (271) cmd ::= KILL QUERY INTEGER COLON INTEGER */
 };
 
 static void yy_accept(yyParser*);  /* Forward Declaration */
@@ -2268,13 +2281,13 @@ static void yy_reduce(
         break;
       case 43: /* cmd ::= ALTER DATABASE ids alter_db_optr */
       case 44: /* cmd ::= ALTER TOPIC ids alter_topic_optr */ yytestcase(yyruleno==44);
-{ SStrToken t = {0};  setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy322, &t);}
+{ SStrToken t = {0};  setCreateDbInfo(pInfo, TSDB_SQL_ALTER_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy526, &t);}
         break;
       case 45: /* cmd ::= ALTER ACCOUNT ids acct_optr */
-{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy351);}
+{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-1].minor.yy0, NULL, &yymsp[0].minor.yy187);}
         break;
       case 46: /* cmd ::= ALTER ACCOUNT ids PASS ids acct_optr */
-{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy351);}
+{ setCreateAcctSql(pInfo, TSDB_SQL_ALTER_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy187);}
         break;
       case 47: /* ids ::= ID */
       case 48: /* ids ::= STRING */ yytestcase(yyruleno==48);
@@ -2296,11 +2309,11 @@ static void yy_reduce(
 { setDCLSqlElems(pInfo, TSDB_SQL_CREATE_DNODE, 1, &yymsp[0].minor.yy0);}
         break;
       case 54: /* cmd ::= CREATE ACCOUNT ids PASS ids acct_optr */
-{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy351);}
+{ setCreateAcctSql(pInfo, TSDB_SQL_CREATE_ACCT, &yymsp[-3].minor.yy0, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy187);}
         break;
       case 55: /* cmd ::= CREATE DATABASE ifnotexists ids db_optr */
       case 56: /* cmd ::= CREATE TOPIC ifnotexists ids topic_optr */ yytestcase(yyruleno==56);
-{ setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy322, &yymsp[-2].minor.yy0);}
+{ setCreateDbInfo(pInfo, TSDB_SQL_CREATE_DB, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy526, &yymsp[-2].minor.yy0);}
         break;
       case 57: /* cmd ::= CREATE USER ids PASS ids */
 { setCreateUserSql(pInfo, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);}
@@ -2329,20 +2342,20 @@ static void yy_reduce(
         break;
       case 76: /* acct_optr ::= pps tseries storage streams qtime dbs users conns state */
 {
-    yylhsminor.yy351.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
-    yylhsminor.yy351.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
-    yylhsminor.yy351.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
-    yylhsminor.yy351.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
-    yylhsminor.yy351.maxPointsPerSecond     = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
-    yylhsminor.yy351.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
-    yylhsminor.yy351.maxQueryTime   = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
-    yylhsminor.yy351.maxConnections   = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
-    yylhsminor.yy351.stat    = yymsp[0].minor.yy0;
+    yylhsminor.yy187.maxUsers   = (yymsp[-2].minor.yy0.n>0)?atoi(yymsp[-2].minor.yy0.z):-1;
+    yylhsminor.yy187.maxDbs     = (yymsp[-3].minor.yy0.n>0)?atoi(yymsp[-3].minor.yy0.z):-1;
+    yylhsminor.yy187.maxTimeSeries = (yymsp[-7].minor.yy0.n>0)?atoi(yymsp[-7].minor.yy0.z):-1;
+    yylhsminor.yy187.maxStreams = (yymsp[-5].minor.yy0.n>0)?atoi(yymsp[-5].minor.yy0.z):-1;
+    yylhsminor.yy187.maxPointsPerSecond     = (yymsp[-8].minor.yy0.n>0)?atoi(yymsp[-8].minor.yy0.z):-1;
+    yylhsminor.yy187.maxStorage = (yymsp[-6].minor.yy0.n>0)?strtoll(yymsp[-6].minor.yy0.z, NULL, 10):-1;
+    yylhsminor.yy187.maxQueryTime   = (yymsp[-4].minor.yy0.n>0)?strtoll(yymsp[-4].minor.yy0.z, NULL, 10):-1;
+    yylhsminor.yy187.maxConnections   = (yymsp[-1].minor.yy0.n>0)?atoi(yymsp[-1].minor.yy0.z):-1;
+    yylhsminor.yy187.stat    = yymsp[0].minor.yy0;
 }
-  yymsp[-8].minor.yy351 = yylhsminor.yy351;
+  yymsp[-8].minor.yy187 = yylhsminor.yy187;
         break;
       case 77: /* keep ::= KEEP tagitemlist */
-{ yymsp[-1].minor.yy159 = yymsp[0].minor.yy159; }
+{ yymsp[-1].minor.yy285 = yymsp[0].minor.yy285; }
         break;
       case 78: /* cache ::= CACHE INTEGER */
       case 79: /* replica ::= REPLICA INTEGER */ yytestcase(yyruleno==79);
@@ -2362,234 +2375,234 @@ static void yy_reduce(
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0; }
         break;
       case 93: /* db_optr ::= */
-{setDefaultCreateDbOption(&yymsp[1].minor.yy322); yymsp[1].minor.yy322.dbType = TSDB_DB_TYPE_DEFAULT;}
+{setDefaultCreateDbOption(&yymsp[1].minor.yy526); yymsp[1].minor.yy526.dbType = TSDB_DB_TYPE_DEFAULT;}
         break;
       case 94: /* db_optr ::= db_optr cache */
-{ yylhsminor.yy322 = yymsp[-1].minor.yy322; yylhsminor.yy322.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy322 = yylhsminor.yy322;
+{ yylhsminor.yy526 = yymsp[-1].minor.yy526; yylhsminor.yy526.cacheBlockSize = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy526 = yylhsminor.yy526;
         break;
       case 95: /* db_optr ::= db_optr replica */
       case 112: /* alter_db_optr ::= alter_db_optr replica */ yytestcase(yyruleno==112);
-{ yylhsminor.yy322 = yymsp[-1].minor.yy322; yylhsminor.yy322.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy322 = yylhsminor.yy322;
+{ yylhsminor.yy526 = yymsp[-1].minor.yy526; yylhsminor.yy526.replica = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy526 = yylhsminor.yy526;
         break;
       case 96: /* db_optr ::= db_optr quorum */
       case 113: /* alter_db_optr ::= alter_db_optr quorum */ yytestcase(yyruleno==113);
-{ yylhsminor.yy322 = yymsp[-1].minor.yy322; yylhsminor.yy322.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy322 = yylhsminor.yy322;
+{ yylhsminor.yy526 = yymsp[-1].minor.yy526; yylhsminor.yy526.quorum = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy526 = yylhsminor.yy526;
         break;
       case 97: /* db_optr ::= db_optr days */
-{ yylhsminor.yy322 = yymsp[-1].minor.yy322; yylhsminor.yy322.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy322 = yylhsminor.yy322;
+{ yylhsminor.yy526 = yymsp[-1].minor.yy526; yylhsminor.yy526.daysPerFile = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy526 = yylhsminor.yy526;
         break;
       case 98: /* db_optr ::= db_optr minrows */
-{ yylhsminor.yy322 = yymsp[-1].minor.yy322; yylhsminor.yy322.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
-  yymsp[-1].minor.yy322 = yylhsminor.yy322;
+{ yylhsminor.yy526 = yymsp[-1].minor.yy526; yylhsminor.yy526.minRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+  yymsp[-1].minor.yy526 = yylhsminor.yy526;
         break;
       case 99: /* db_optr ::= db_optr maxrows */
-{ yylhsminor.yy322 = yymsp[-1].minor.yy322; yylhsminor.yy322.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
-  yymsp[-1].minor.yy322 = yylhsminor.yy322;
+{ yylhsminor.yy526 = yymsp[-1].minor.yy526; yylhsminor.yy526.maxRowsPerBlock = strtod(yymsp[0].minor.yy0.z, NULL); }
+  yymsp[-1].minor.yy526 = yylhsminor.yy526;
         break;
       case 100: /* db_optr ::= db_optr blocks */
       case 115: /* alter_db_optr ::= alter_db_optr blocks */ yytestcase(yyruleno==115);
-{ yylhsminor.yy322 = yymsp[-1].minor.yy322; yylhsminor.yy322.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy322 = yylhsminor.yy322;
+{ yylhsminor.yy526 = yymsp[-1].minor.yy526; yylhsminor.yy526.numOfBlocks = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy526 = yylhsminor.yy526;
         break;
       case 101: /* db_optr ::= db_optr ctime */
-{ yylhsminor.yy322 = yymsp[-1].minor.yy322; yylhsminor.yy322.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy322 = yylhsminor.yy322;
+{ yylhsminor.yy526 = yymsp[-1].minor.yy526; yylhsminor.yy526.commitTime = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy526 = yylhsminor.yy526;
         break;
       case 102: /* db_optr ::= db_optr wal */
       case 117: /* alter_db_optr ::= alter_db_optr wal */ yytestcase(yyruleno==117);
-{ yylhsminor.yy322 = yymsp[-1].minor.yy322; yylhsminor.yy322.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy322 = yylhsminor.yy322;
+{ yylhsminor.yy526 = yymsp[-1].minor.yy526; yylhsminor.yy526.walLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy526 = yylhsminor.yy526;
         break;
       case 103: /* db_optr ::= db_optr fsync */
       case 118: /* alter_db_optr ::= alter_db_optr fsync */ yytestcase(yyruleno==118);
-{ yylhsminor.yy322 = yymsp[-1].minor.yy322; yylhsminor.yy322.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy322 = yylhsminor.yy322;
+{ yylhsminor.yy526 = yymsp[-1].minor.yy526; yylhsminor.yy526.fsyncPeriod = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy526 = yylhsminor.yy526;
         break;
       case 104: /* db_optr ::= db_optr comp */
       case 116: /* alter_db_optr ::= alter_db_optr comp */ yytestcase(yyruleno==116);
-{ yylhsminor.yy322 = yymsp[-1].minor.yy322; yylhsminor.yy322.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy322 = yylhsminor.yy322;
+{ yylhsminor.yy526 = yymsp[-1].minor.yy526; yylhsminor.yy526.compressionLevel = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy526 = yylhsminor.yy526;
         break;
       case 105: /* db_optr ::= db_optr prec */
-{ yylhsminor.yy322 = yymsp[-1].minor.yy322; yylhsminor.yy322.precision = yymsp[0].minor.yy0; }
-  yymsp[-1].minor.yy322 = yylhsminor.yy322;
+{ yylhsminor.yy526 = yymsp[-1].minor.yy526; yylhsminor.yy526.precision = yymsp[0].minor.yy0; }
+  yymsp[-1].minor.yy526 = yylhsminor.yy526;
         break;
       case 106: /* db_optr ::= db_optr keep */
       case 114: /* alter_db_optr ::= alter_db_optr keep */ yytestcase(yyruleno==114);
-{ yylhsminor.yy322 = yymsp[-1].minor.yy322; yylhsminor.yy322.keep = yymsp[0].minor.yy159; }
-  yymsp[-1].minor.yy322 = yylhsminor.yy322;
+{ yylhsminor.yy526 = yymsp[-1].minor.yy526; yylhsminor.yy526.keep = yymsp[0].minor.yy285; }
+  yymsp[-1].minor.yy526 = yylhsminor.yy526;
         break;
       case 107: /* db_optr ::= db_optr update */
       case 119: /* alter_db_optr ::= alter_db_optr update */ yytestcase(yyruleno==119);
-{ yylhsminor.yy322 = yymsp[-1].minor.yy322; yylhsminor.yy322.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy322 = yylhsminor.yy322;
+{ yylhsminor.yy526 = yymsp[-1].minor.yy526; yylhsminor.yy526.update = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy526 = yylhsminor.yy526;
         break;
       case 108: /* db_optr ::= db_optr cachelast */
       case 120: /* alter_db_optr ::= alter_db_optr cachelast */ yytestcase(yyruleno==120);
-{ yylhsminor.yy322 = yymsp[-1].minor.yy322; yylhsminor.yy322.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy322 = yylhsminor.yy322;
+{ yylhsminor.yy526 = yymsp[-1].minor.yy526; yylhsminor.yy526.cachelast = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy526 = yylhsminor.yy526;
         break;
       case 109: /* topic_optr ::= db_optr */
       case 121: /* alter_topic_optr ::= alter_db_optr */ yytestcase(yyruleno==121);
-{ yylhsminor.yy322 = yymsp[0].minor.yy322; yylhsminor.yy322.dbType = TSDB_DB_TYPE_TOPIC; }
-  yymsp[0].minor.yy322 = yylhsminor.yy322;
+{ yylhsminor.yy526 = yymsp[0].minor.yy526; yylhsminor.yy526.dbType = TSDB_DB_TYPE_TOPIC; }
+  yymsp[0].minor.yy526 = yylhsminor.yy526;
         break;
       case 110: /* topic_optr ::= topic_optr partitions */
       case 122: /* alter_topic_optr ::= alter_topic_optr partitions */ yytestcase(yyruleno==122);
-{ yylhsminor.yy322 = yymsp[-1].minor.yy322; yylhsminor.yy322.partitions = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[-1].minor.yy322 = yylhsminor.yy322;
+{ yylhsminor.yy526 = yymsp[-1].minor.yy526; yylhsminor.yy526.partitions = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[-1].minor.yy526 = yylhsminor.yy526;
         break;
       case 111: /* alter_db_optr ::= */
-{ setDefaultCreateDbOption(&yymsp[1].minor.yy322); yymsp[1].minor.yy322.dbType = TSDB_DB_TYPE_DEFAULT;}
+{ setDefaultCreateDbOption(&yymsp[1].minor.yy526); yymsp[1].minor.yy526.dbType = TSDB_DB_TYPE_DEFAULT;}
         break;
       case 123: /* typename ::= ids */
 { 
   yymsp[0].minor.yy0.type = 0;
-  tSetColumnType (&yylhsminor.yy407, &yymsp[0].minor.yy0);
+  tSetColumnType (&yylhsminor.yy295, &yymsp[0].minor.yy0);
 }
-  yymsp[0].minor.yy407 = yylhsminor.yy407;
+  yymsp[0].minor.yy295 = yylhsminor.yy295;
         break;
       case 124: /* typename ::= ids LP signed RP */
 {
-  if (yymsp[-1].minor.yy317 <= 0) {
+  if (yymsp[-1].minor.yy525 <= 0) {
     yymsp[-3].minor.yy0.type = 0;
-    tSetColumnType(&yylhsminor.yy407, &yymsp[-3].minor.yy0);
+    tSetColumnType(&yylhsminor.yy295, &yymsp[-3].minor.yy0);
   } else {
-    yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy317;  // negative value of name length
-    tSetColumnType(&yylhsminor.yy407, &yymsp[-3].minor.yy0);
+    yymsp[-3].minor.yy0.type = -yymsp[-1].minor.yy525;  // negative value of name length
+    tSetColumnType(&yylhsminor.yy295, &yymsp[-3].minor.yy0);
   }
 }
-  yymsp[-3].minor.yy407 = yylhsminor.yy407;
+  yymsp[-3].minor.yy295 = yylhsminor.yy295;
         break;
       case 125: /* typename ::= ids UNSIGNED */
 {
   yymsp[-1].minor.yy0.type = 0;
   yymsp[-1].minor.yy0.n = ((yymsp[0].minor.yy0.z + yymsp[0].minor.yy0.n) - yymsp[-1].minor.yy0.z);
-  tSetColumnType (&yylhsminor.yy407, &yymsp[-1].minor.yy0);
+  tSetColumnType (&yylhsminor.yy295, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy407 = yylhsminor.yy407;
+  yymsp[-1].minor.yy295 = yylhsminor.yy295;
         break;
       case 126: /* signed ::= INTEGER */
-{ yylhsminor.yy317 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
-  yymsp[0].minor.yy317 = yylhsminor.yy317;
+{ yylhsminor.yy525 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+  yymsp[0].minor.yy525 = yylhsminor.yy525;
         break;
       case 127: /* signed ::= PLUS INTEGER */
-{ yymsp[-1].minor.yy317 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
+{ yymsp[-1].minor.yy525 = strtol(yymsp[0].minor.yy0.z, NULL, 10); }
         break;
       case 128: /* signed ::= MINUS INTEGER */
-{ yymsp[-1].minor.yy317 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
+{ yymsp[-1].minor.yy525 = -strtol(yymsp[0].minor.yy0.z, NULL, 10);}
         break;
       case 132: /* cmd ::= CREATE TABLE create_table_list */
-{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy14;}
+{ pInfo->type = TSDB_SQL_CREATE_TABLE; pInfo->pCreateTableInfo = yymsp[0].minor.yy470;}
         break;
       case 133: /* create_table_list ::= create_from_stable */
 {
   SCreateTableSql* pCreateTable = calloc(1, sizeof(SCreateTableSql));
   pCreateTable->childTableInfo = taosArrayInit(4, sizeof(SCreatedTableInfo));
 
-  taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy206);
+  taosArrayPush(pCreateTable->childTableInfo, &yymsp[0].minor.yy96);
   pCreateTable->type = TSQL_CREATE_TABLE_FROM_STABLE;
-  yylhsminor.yy14 = pCreateTable;
+  yylhsminor.yy470 = pCreateTable;
 }
-  yymsp[0].minor.yy14 = yylhsminor.yy14;
+  yymsp[0].minor.yy470 = yylhsminor.yy470;
         break;
       case 134: /* create_table_list ::= create_table_list create_from_stable */
 {
-  taosArrayPush(yymsp[-1].minor.yy14->childTableInfo, &yymsp[0].minor.yy206);
-  yylhsminor.yy14 = yymsp[-1].minor.yy14;
+  taosArrayPush(yymsp[-1].minor.yy470->childTableInfo, &yymsp[0].minor.yy96);
+  yylhsminor.yy470 = yymsp[-1].minor.yy470;
 }
-  yymsp[-1].minor.yy14 = yylhsminor.yy14;
+  yymsp[-1].minor.yy470 = yylhsminor.yy470;
         break;
       case 135: /* create_table_args ::= ifnotexists ids cpxName LP columnlist RP */
 {
-  yylhsminor.yy14 = tSetCreateTableInfo(yymsp[-1].minor.yy159, NULL, NULL, TSQL_CREATE_TABLE);
-  setSqlInfo(pInfo, yylhsminor.yy14, NULL, TSDB_SQL_CREATE_TABLE);
+  yylhsminor.yy470 = tSetCreateTableInfo(yymsp[-1].minor.yy285, NULL, NULL, TSQL_CREATE_TABLE);
+  setSqlInfo(pInfo, yylhsminor.yy470, NULL, TSDB_SQL_CREATE_TABLE);
 
   yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
   setCreatedTableName(pInfo, &yymsp[-4].minor.yy0, &yymsp[-5].minor.yy0);
 }
-  yymsp[-5].minor.yy14 = yylhsminor.yy14;
+  yymsp[-5].minor.yy470 = yylhsminor.yy470;
         break;
       case 136: /* create_stable_args ::= ifnotexists ids cpxName LP columnlist RP TAGS LP columnlist RP */
 {
-  yylhsminor.yy14 = tSetCreateTableInfo(yymsp[-5].minor.yy159, yymsp[-1].minor.yy159, NULL, TSQL_CREATE_STABLE);
-  setSqlInfo(pInfo, yylhsminor.yy14, NULL, TSDB_SQL_CREATE_TABLE);
+  yylhsminor.yy470 = tSetCreateTableInfo(yymsp[-5].minor.yy285, yymsp[-1].minor.yy285, NULL, TSQL_CREATE_STABLE);
+  setSqlInfo(pInfo, yylhsminor.yy470, NULL, TSDB_SQL_CREATE_TABLE);
 
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
   setCreatedTableName(pInfo, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
 }
-  yymsp[-9].minor.yy14 = yylhsminor.yy14;
+  yymsp[-9].minor.yy470 = yylhsminor.yy470;
         break;
       case 137: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName TAGS LP tagitemlist RP */
 {
   yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
-  yylhsminor.yy206 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy159, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
+  yylhsminor.yy96 = createNewChildTableInfo(&yymsp[-5].minor.yy0, NULL, yymsp[-1].minor.yy285, &yymsp[-8].minor.yy0, &yymsp[-9].minor.yy0);
 }
-  yymsp[-9].minor.yy206 = yylhsminor.yy206;
+  yymsp[-9].minor.yy96 = yylhsminor.yy96;
         break;
       case 138: /* create_from_stable ::= ifnotexists ids cpxName USING ids cpxName LP tagNamelist RP TAGS LP tagitemlist RP */
 {
   yymsp[-8].minor.yy0.n += yymsp[-7].minor.yy0.n;
   yymsp[-11].minor.yy0.n += yymsp[-10].minor.yy0.n;
-  yylhsminor.yy206 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy159, yymsp[-1].minor.yy159, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0);
+  yylhsminor.yy96 = createNewChildTableInfo(&yymsp[-8].minor.yy0, yymsp[-5].minor.yy285, yymsp[-1].minor.yy285, &yymsp[-11].minor.yy0, &yymsp[-12].minor.yy0);
 }
-  yymsp[-12].minor.yy206 = yylhsminor.yy206;
+  yymsp[-12].minor.yy96 = yylhsminor.yy96;
         break;
       case 139: /* tagNamelist ::= tagNamelist COMMA ids */
-{taosArrayPush(yymsp[-2].minor.yy159, &yymsp[0].minor.yy0); yylhsminor.yy159 = yymsp[-2].minor.yy159;  }
-  yymsp[-2].minor.yy159 = yylhsminor.yy159;
+{taosArrayPush(yymsp[-2].minor.yy285, &yymsp[0].minor.yy0); yylhsminor.yy285 = yymsp[-2].minor.yy285;  }
+  yymsp[-2].minor.yy285 = yylhsminor.yy285;
         break;
       case 140: /* tagNamelist ::= ids */
-{yylhsminor.yy159 = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(yylhsminor.yy159, &yymsp[0].minor.yy0);}
-  yymsp[0].minor.yy159 = yylhsminor.yy159;
+{yylhsminor.yy285 = taosArrayInit(4, sizeof(SStrToken)); taosArrayPush(yylhsminor.yy285, &yymsp[0].minor.yy0);}
+  yymsp[0].minor.yy285 = yylhsminor.yy285;
         break;
       case 141: /* create_table_args ::= ifnotexists ids cpxName AS select */
 {
-  yylhsminor.yy14 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy116, TSQL_CREATE_STREAM);
-  setSqlInfo(pInfo, yylhsminor.yy14, NULL, TSDB_SQL_CREATE_TABLE);
+  yylhsminor.yy470 = tSetCreateTableInfo(NULL, NULL, yymsp[0].minor.yy344, TSQL_CREATE_STREAM);
+  setSqlInfo(pInfo, yylhsminor.yy470, NULL, TSDB_SQL_CREATE_TABLE);
 
   yymsp[-3].minor.yy0.n += yymsp[-2].minor.yy0.n;
   setCreatedTableName(pInfo, &yymsp[-3].minor.yy0, &yymsp[-4].minor.yy0);
 }
-  yymsp[-4].minor.yy14 = yylhsminor.yy14;
+  yymsp[-4].minor.yy470 = yylhsminor.yy470;
         break;
       case 142: /* columnlist ::= columnlist COMMA column */
-{taosArrayPush(yymsp[-2].minor.yy159, &yymsp[0].minor.yy407); yylhsminor.yy159 = yymsp[-2].minor.yy159;  }
-  yymsp[-2].minor.yy159 = yylhsminor.yy159;
+{taosArrayPush(yymsp[-2].minor.yy285, &yymsp[0].minor.yy295); yylhsminor.yy285 = yymsp[-2].minor.yy285;  }
+  yymsp[-2].minor.yy285 = yylhsminor.yy285;
         break;
       case 143: /* columnlist ::= column */
-{yylhsminor.yy159 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy159, &yymsp[0].minor.yy407);}
-  yymsp[0].minor.yy159 = yylhsminor.yy159;
+{yylhsminor.yy285 = taosArrayInit(4, sizeof(TAOS_FIELD)); taosArrayPush(yylhsminor.yy285, &yymsp[0].minor.yy295);}
+  yymsp[0].minor.yy285 = yylhsminor.yy285;
         break;
       case 144: /* column ::= ids typename */
 {
-  tSetColumnInfo(&yylhsminor.yy407, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy407);
+  tSetColumnInfo(&yylhsminor.yy295, &yymsp[-1].minor.yy0, &yymsp[0].minor.yy295);
 }
-  yymsp[-1].minor.yy407 = yylhsminor.yy407;
+  yymsp[-1].minor.yy295 = yylhsminor.yy295;
         break;
       case 145: /* tagitemlist ::= tagitemlist COMMA tagitem */
-{ yylhsminor.yy159 = tVariantListAppend(yymsp[-2].minor.yy159, &yymsp[0].minor.yy488, -1);    }
-  yymsp[-2].minor.yy159 = yylhsminor.yy159;
+{ yylhsminor.yy285 = tVariantListAppend(yymsp[-2].minor.yy285, &yymsp[0].minor.yy362, -1);    }
+  yymsp[-2].minor.yy285 = yylhsminor.yy285;
         break;
       case 146: /* tagitemlist ::= tagitem */
-{ yylhsminor.yy159 = tVariantListAppend(NULL, &yymsp[0].minor.yy488, -1); }
-  yymsp[0].minor.yy159 = yylhsminor.yy159;
+{ yylhsminor.yy285 = tVariantListAppend(NULL, &yymsp[0].minor.yy362, -1); }
+  yymsp[0].minor.yy285 = yylhsminor.yy285;
         break;
       case 147: /* tagitem ::= INTEGER */
       case 148: /* tagitem ::= FLOAT */ yytestcase(yyruleno==148);
       case 149: /* tagitem ::= STRING */ yytestcase(yyruleno==149);
       case 150: /* tagitem ::= BOOL */ yytestcase(yyruleno==150);
-{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy488, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy488 = yylhsminor.yy488;
+{ toTSDBType(yymsp[0].minor.yy0.type); tVariantCreate(&yylhsminor.yy362, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy362 = yylhsminor.yy362;
         break;
       case 151: /* tagitem ::= NULL */
-{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy488, &yymsp[0].minor.yy0); }
-  yymsp[0].minor.yy488 = yylhsminor.yy488;
+{ yymsp[0].minor.yy0.type = 0; tVariantCreate(&yylhsminor.yy362, &yymsp[0].minor.yy0); }
+  yymsp[0].minor.yy362 = yylhsminor.yy362;
         break;
       case 152: /* tagitem ::= MINUS INTEGER */
       case 153: /* tagitem ::= MINUS FLOAT */ yytestcase(yyruleno==153);
@@ -2599,56 +2612,56 @@ static void yy_reduce(
     yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
     yymsp[-1].minor.yy0.type = yymsp[0].minor.yy0.type;
     toTSDBType(yymsp[-1].minor.yy0.type);
-    tVariantCreate(&yylhsminor.yy488, &yymsp[-1].minor.yy0);
+    tVariantCreate(&yylhsminor.yy362, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy488 = yylhsminor.yy488;
+  yymsp[-1].minor.yy362 = yylhsminor.yy362;
         break;
       case 156: /* select ::= SELECT selcollist from where_opt interval_opt session_option fill_opt sliding_opt groupby_opt orderby_opt having_opt slimit_opt limit_opt */
 {
-  yylhsminor.yy116 = tSetQuerySqlNode(&yymsp[-12].minor.yy0, yymsp[-11].minor.yy159, yymsp[-10].minor.yy236, yymsp[-9].minor.yy118, yymsp[-4].minor.yy159, yymsp[-3].minor.yy159, &yymsp[-8].minor.yy184, &yymsp[-7].minor.yy249, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy159, &yymsp[0].minor.yy440, &yymsp[-1].minor.yy440, yymsp[-2].minor.yy118);
+  yylhsminor.yy344 = tSetQuerySqlNode(&yymsp[-12].minor.yy0, yymsp[-11].minor.yy285, yymsp[-10].minor.yy148, yymsp[-9].minor.yy178, yymsp[-4].minor.yy285, yymsp[-3].minor.yy285, &yymsp[-8].minor.yy376, &yymsp[-7].minor.yy523, &yymsp[-5].minor.yy0, yymsp[-6].minor.yy285, &yymsp[0].minor.yy438, &yymsp[-1].minor.yy438, yymsp[-2].minor.yy178);
 }
-  yymsp[-12].minor.yy116 = yylhsminor.yy116;
+  yymsp[-12].minor.yy344 = yylhsminor.yy344;
         break;
       case 157: /* select ::= LP select RP */
-{yymsp[-2].minor.yy116 = yymsp[-1].minor.yy116;}
+{yymsp[-2].minor.yy344 = yymsp[-1].minor.yy344;}
         break;
       case 158: /* union ::= select */
-{ yylhsminor.yy159 = setSubclause(NULL, yymsp[0].minor.yy116); }
-  yymsp[0].minor.yy159 = yylhsminor.yy159;
+{ yylhsminor.yy285 = setSubclause(NULL, yymsp[0].minor.yy344); }
+  yymsp[0].minor.yy285 = yylhsminor.yy285;
         break;
       case 159: /* union ::= union UNION ALL select */
-{ yylhsminor.yy159 = appendSelectClause(yymsp[-3].minor.yy159, yymsp[0].minor.yy116); }
-  yymsp[-3].minor.yy159 = yylhsminor.yy159;
+{ yylhsminor.yy285 = appendSelectClause(yymsp[-3].minor.yy285, yymsp[0].minor.yy344); }
+  yymsp[-3].minor.yy285 = yylhsminor.yy285;
         break;
       case 160: /* cmd ::= union */
-{ setSqlInfo(pInfo, yymsp[0].minor.yy159, NULL, TSDB_SQL_SELECT); }
+{ setSqlInfo(pInfo, yymsp[0].minor.yy285, NULL, TSDB_SQL_SELECT); }
         break;
       case 161: /* select ::= SELECT selcollist */
 {
-  yylhsminor.yy116 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy159, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
+  yylhsminor.yy344 = tSetQuerySqlNode(&yymsp[-1].minor.yy0, yymsp[0].minor.yy285, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 }
-  yymsp[-1].minor.yy116 = yylhsminor.yy116;
+  yymsp[-1].minor.yy344 = yylhsminor.yy344;
         break;
       case 162: /* sclp ::= selcollist COMMA */
-{yylhsminor.yy159 = yymsp[-1].minor.yy159;}
-  yymsp[-1].minor.yy159 = yylhsminor.yy159;
+{yylhsminor.yy285 = yymsp[-1].minor.yy285;}
+  yymsp[-1].minor.yy285 = yylhsminor.yy285;
         break;
       case 163: /* sclp ::= */
-      case 188: /* orderby_opt ::= */ yytestcase(yyruleno==188);
-{yymsp[1].minor.yy159 = 0;}
+      case 191: /* orderby_opt ::= */ yytestcase(yyruleno==191);
+{yymsp[1].minor.yy285 = 0;}
         break;
       case 164: /* selcollist ::= sclp distinct expr as */
 {
-   yylhsminor.yy159 = tSqlExprListAppend(yymsp[-3].minor.yy159, yymsp[-1].minor.yy118,  yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
+   yylhsminor.yy285 = tSqlExprListAppend(yymsp[-3].minor.yy285, yymsp[-1].minor.yy178,  yymsp[-2].minor.yy0.n? &yymsp[-2].minor.yy0:0, yymsp[0].minor.yy0.n?&yymsp[0].minor.yy0:0);
 }
-  yymsp[-3].minor.yy159 = yylhsminor.yy159;
+  yymsp[-3].minor.yy285 = yylhsminor.yy285;
         break;
       case 165: /* selcollist ::= sclp STAR */
 {
    tSqlExpr *pNode = tSqlExprCreateIdValue(NULL, TK_ALL);
-   yylhsminor.yy159 = tSqlExprListAppend(yymsp[-1].minor.yy159, pNode, 0, 0);
+   yylhsminor.yy285 = tSqlExprListAppend(yymsp[-1].minor.yy285, pNode, 0, 0);
 }
-  yymsp[-1].minor.yy159 = yylhsminor.yy159;
+  yymsp[-1].minor.yy285 = yylhsminor.yy285;
         break;
       case 166: /* as ::= AS ids */
 { yymsp[-1].minor.yy0 = yymsp[0].minor.yy0;    }
@@ -2665,332 +2678,340 @@ static void yy_reduce(
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
       case 171: /* from ::= FROM tablelist */
-{yymsp[-1].minor.yy236 = yymsp[0].minor.yy236;}
+      case 172: /* from ::= FROM sub */ yytestcase(yyruleno==172);
+{yymsp[-1].minor.yy148 = yymsp[0].minor.yy148;}
         break;
-      case 172: /* from ::= FROM LP union RP */
-{yymsp[-3].minor.yy236 = setSubquery(NULL, yymsp[-1].minor.yy159);}
+      case 173: /* sub ::= LP union RP */
+{yymsp[-2].minor.yy148 = addSubqueryElem(NULL, yymsp[-1].minor.yy285, NULL);}
         break;
-      case 173: /* tablelist ::= ids cpxName */
+      case 174: /* sub ::= LP union RP ids */
+{yymsp[-3].minor.yy148 = addSubqueryElem(NULL, yymsp[-2].minor.yy285, &yymsp[0].minor.yy0);}
+        break;
+      case 175: /* sub ::= sub COMMA LP union RP ids */
+{yylhsminor.yy148 = addSubqueryElem(yymsp[-5].minor.yy148, yymsp[-2].minor.yy285, &yymsp[0].minor.yy0);}
+  yymsp[-5].minor.yy148 = yylhsminor.yy148;
+        break;
+      case 176: /* tablelist ::= ids cpxName */
 {
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-  yylhsminor.yy236 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL);
+  yylhsminor.yy148 = setTableNameList(NULL, &yymsp[-1].minor.yy0, NULL);
 }
-  yymsp[-1].minor.yy236 = yylhsminor.yy236;
+  yymsp[-1].minor.yy148 = yylhsminor.yy148;
         break;
-      case 174: /* tablelist ::= ids cpxName ids */
+      case 177: /* tablelist ::= ids cpxName ids */
 {
   yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-  yylhsminor.yy236 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
+  yylhsminor.yy148 = setTableNameList(NULL, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
 }
-  yymsp[-2].minor.yy236 = yylhsminor.yy236;
+  yymsp[-2].minor.yy148 = yylhsminor.yy148;
         break;
-      case 175: /* tablelist ::= tablelist COMMA ids cpxName */
+      case 178: /* tablelist ::= tablelist COMMA ids cpxName */
 {
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
-  yylhsminor.yy236 = setTableNameList(yymsp[-3].minor.yy236, &yymsp[-1].minor.yy0, NULL);
+  yylhsminor.yy148 = setTableNameList(yymsp[-3].minor.yy148, &yymsp[-1].minor.yy0, NULL);
 }
-  yymsp[-3].minor.yy236 = yylhsminor.yy236;
+  yymsp[-3].minor.yy148 = yylhsminor.yy148;
         break;
-      case 176: /* tablelist ::= tablelist COMMA ids cpxName ids */
+      case 179: /* tablelist ::= tablelist COMMA ids cpxName ids */
 {
   yymsp[-2].minor.yy0.n += yymsp[-1].minor.yy0.n;
-  yylhsminor.yy236 = setTableNameList(yymsp[-4].minor.yy236, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
+  yylhsminor.yy148 = setTableNameList(yymsp[-4].minor.yy148, &yymsp[-2].minor.yy0, &yymsp[0].minor.yy0);
 }
-  yymsp[-4].minor.yy236 = yylhsminor.yy236;
+  yymsp[-4].minor.yy148 = yylhsminor.yy148;
         break;
-      case 177: /* tmvar ::= VARIABLE */
+      case 180: /* tmvar ::= VARIABLE */
 {yylhsminor.yy0 = yymsp[0].minor.yy0;}
   yymsp[0].minor.yy0 = yylhsminor.yy0;
         break;
-      case 178: /* interval_opt ::= INTERVAL LP tmvar RP */
-{yymsp[-3].minor.yy184.interval = yymsp[-1].minor.yy0; yymsp[-3].minor.yy184.offset.n = 0;}
+      case 181: /* interval_opt ::= INTERVAL LP tmvar RP */
+{yymsp[-3].minor.yy376.interval = yymsp[-1].minor.yy0; yymsp[-3].minor.yy376.offset.n = 0;}
         break;
-      case 179: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
-{yymsp[-5].minor.yy184.interval = yymsp[-3].minor.yy0; yymsp[-5].minor.yy184.offset = yymsp[-1].minor.yy0;}
+      case 182: /* interval_opt ::= INTERVAL LP tmvar COMMA tmvar RP */
+{yymsp[-5].minor.yy376.interval = yymsp[-3].minor.yy0; yymsp[-5].minor.yy376.offset = yymsp[-1].minor.yy0;}
         break;
-      case 180: /* interval_opt ::= */
-{memset(&yymsp[1].minor.yy184, 0, sizeof(yymsp[1].minor.yy184));}
+      case 183: /* interval_opt ::= */
+{memset(&yymsp[1].minor.yy376, 0, sizeof(yymsp[1].minor.yy376));}
         break;
-      case 181: /* session_option ::= */
-{yymsp[1].minor.yy249.col.n = 0; yymsp[1].minor.yy249.gap.n = 0;}
+      case 184: /* session_option ::= */
+{yymsp[1].minor.yy523.col.n = 0; yymsp[1].minor.yy523.gap.n = 0;}
         break;
-      case 182: /* session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
+      case 185: /* session_option ::= SESSION LP ids cpxName COMMA tmvar RP */
 {
    yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-   yymsp[-6].minor.yy249.col = yymsp[-4].minor.yy0;
-   yymsp[-6].minor.yy249.gap = yymsp[-1].minor.yy0;
+   yymsp[-6].minor.yy523.col = yymsp[-4].minor.yy0;
+   yymsp[-6].minor.yy523.gap = yymsp[-1].minor.yy0;
 }
         break;
-      case 183: /* fill_opt ::= */
-{ yymsp[1].minor.yy159 = 0;     }
+      case 186: /* fill_opt ::= */
+{ yymsp[1].minor.yy285 = 0;     }
         break;
-      case 184: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
+      case 187: /* fill_opt ::= FILL LP ID COMMA tagitemlist RP */
 {
     tVariant A = {0};
     toTSDBType(yymsp[-3].minor.yy0.type);
     tVariantCreate(&A, &yymsp[-3].minor.yy0);
 
-    tVariantListInsert(yymsp[-1].minor.yy159, &A, -1, 0);
-    yymsp[-5].minor.yy159 = yymsp[-1].minor.yy159;
+    tVariantListInsert(yymsp[-1].minor.yy285, &A, -1, 0);
+    yymsp[-5].minor.yy285 = yymsp[-1].minor.yy285;
 }
         break;
-      case 185: /* fill_opt ::= FILL LP ID RP */
+      case 188: /* fill_opt ::= FILL LP ID RP */
 {
     toTSDBType(yymsp[-1].minor.yy0.type);
-    yymsp[-3].minor.yy159 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
+    yymsp[-3].minor.yy285 = tVariantListAppendToken(NULL, &yymsp[-1].minor.yy0, -1);
 }
         break;
-      case 186: /* sliding_opt ::= SLIDING LP tmvar RP */
+      case 189: /* sliding_opt ::= SLIDING LP tmvar RP */
 {yymsp[-3].minor.yy0 = yymsp[-1].minor.yy0;     }
         break;
-      case 187: /* sliding_opt ::= */
+      case 190: /* sliding_opt ::= */
 {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = NULL; yymsp[1].minor.yy0.type = 0;   }
         break;
-      case 189: /* orderby_opt ::= ORDER BY sortlist */
-{yymsp[-2].minor.yy159 = yymsp[0].minor.yy159;}
+      case 192: /* orderby_opt ::= ORDER BY sortlist */
+{yymsp[-2].minor.yy285 = yymsp[0].minor.yy285;}
         break;
-      case 190: /* sortlist ::= sortlist COMMA item sortorder */
+      case 193: /* sortlist ::= sortlist COMMA item sortorder */
 {
-    yylhsminor.yy159 = tVariantListAppend(yymsp[-3].minor.yy159, &yymsp[-1].minor.yy488, yymsp[0].minor.yy20);
+    yylhsminor.yy285 = tVariantListAppend(yymsp[-3].minor.yy285, &yymsp[-1].minor.yy362, yymsp[0].minor.yy460);
 }
-  yymsp[-3].minor.yy159 = yylhsminor.yy159;
+  yymsp[-3].minor.yy285 = yylhsminor.yy285;
         break;
-      case 191: /* sortlist ::= item sortorder */
+      case 194: /* sortlist ::= item sortorder */
 {
-  yylhsminor.yy159 = tVariantListAppend(NULL, &yymsp[-1].minor.yy488, yymsp[0].minor.yy20);
+  yylhsminor.yy285 = tVariantListAppend(NULL, &yymsp[-1].minor.yy362, yymsp[0].minor.yy460);
 }
-  yymsp[-1].minor.yy159 = yylhsminor.yy159;
+  yymsp[-1].minor.yy285 = yylhsminor.yy285;
         break;
-      case 192: /* item ::= ids cpxName */
+      case 195: /* item ::= ids cpxName */
 {
   toTSDBType(yymsp[-1].minor.yy0.type);
   yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n;
 
-  tVariantCreate(&yylhsminor.yy488, &yymsp[-1].minor.yy0);
+  tVariantCreate(&yylhsminor.yy362, &yymsp[-1].minor.yy0);
 }
-  yymsp[-1].minor.yy488 = yylhsminor.yy488;
+  yymsp[-1].minor.yy362 = yylhsminor.yy362;
         break;
-      case 193: /* sortorder ::= ASC */
-{ yymsp[0].minor.yy20 = TSDB_ORDER_ASC; }
+      case 196: /* sortorder ::= ASC */
+{ yymsp[0].minor.yy460 = TSDB_ORDER_ASC; }
         break;
-      case 194: /* sortorder ::= DESC */
-{ yymsp[0].minor.yy20 = TSDB_ORDER_DESC;}
+      case 197: /* sortorder ::= DESC */
+{ yymsp[0].minor.yy460 = TSDB_ORDER_DESC;}
         break;
-      case 195: /* sortorder ::= */
-{ yymsp[1].minor.yy20 = TSDB_ORDER_ASC; }
+      case 198: /* sortorder ::= */
+{ yymsp[1].minor.yy460 = TSDB_ORDER_ASC; }
         break;
-      case 196: /* groupby_opt ::= */
-{ yymsp[1].minor.yy159 = 0;}
+      case 199: /* groupby_opt ::= */
+{ yymsp[1].minor.yy285 = 0;}
         break;
-      case 197: /* groupby_opt ::= GROUP BY grouplist */
-{ yymsp[-2].minor.yy159 = yymsp[0].minor.yy159;}
+      case 200: /* groupby_opt ::= GROUP BY grouplist */
+{ yymsp[-2].minor.yy285 = yymsp[0].minor.yy285;}
         break;
-      case 198: /* grouplist ::= grouplist COMMA item */
+      case 201: /* grouplist ::= grouplist COMMA item */
 {
-  yylhsminor.yy159 = tVariantListAppend(yymsp[-2].minor.yy159, &yymsp[0].minor.yy488, -1);
+  yylhsminor.yy285 = tVariantListAppend(yymsp[-2].minor.yy285, &yymsp[0].minor.yy362, -1);
 }
-  yymsp[-2].minor.yy159 = yylhsminor.yy159;
+  yymsp[-2].minor.yy285 = yylhsminor.yy285;
         break;
-      case 199: /* grouplist ::= item */
+      case 202: /* grouplist ::= item */
 {
-  yylhsminor.yy159 = tVariantListAppend(NULL, &yymsp[0].minor.yy488, -1);
+  yylhsminor.yy285 = tVariantListAppend(NULL, &yymsp[0].minor.yy362, -1);
 }
-  yymsp[0].minor.yy159 = yylhsminor.yy159;
+  yymsp[0].minor.yy285 = yylhsminor.yy285;
         break;
-      case 200: /* having_opt ::= */
-      case 210: /* where_opt ::= */ yytestcase(yyruleno==210);
-      case 252: /* expritem ::= */ yytestcase(yyruleno==252);
-{yymsp[1].minor.yy118 = 0;}
+      case 203: /* having_opt ::= */
+      case 213: /* where_opt ::= */ yytestcase(yyruleno==213);
+      case 255: /* expritem ::= */ yytestcase(yyruleno==255);
+{yymsp[1].minor.yy178 = 0;}
         break;
-      case 201: /* having_opt ::= HAVING expr */
-      case 211: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==211);
-{yymsp[-1].minor.yy118 = yymsp[0].minor.yy118;}
+      case 204: /* having_opt ::= HAVING expr */
+      case 214: /* where_opt ::= WHERE expr */ yytestcase(yyruleno==214);
+{yymsp[-1].minor.yy178 = yymsp[0].minor.yy178;}
         break;
-      case 202: /* limit_opt ::= */
-      case 206: /* slimit_opt ::= */ yytestcase(yyruleno==206);
-{yymsp[1].minor.yy440.limit = -1; yymsp[1].minor.yy440.offset = 0;}
+      case 205: /* limit_opt ::= */
+      case 209: /* slimit_opt ::= */ yytestcase(yyruleno==209);
+{yymsp[1].minor.yy438.limit = -1; yymsp[1].minor.yy438.offset = 0;}
         break;
-      case 203: /* limit_opt ::= LIMIT signed */
-      case 207: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==207);
-{yymsp[-1].minor.yy440.limit = yymsp[0].minor.yy317;  yymsp[-1].minor.yy440.offset = 0;}
+      case 206: /* limit_opt ::= LIMIT signed */
+      case 210: /* slimit_opt ::= SLIMIT signed */ yytestcase(yyruleno==210);
+{yymsp[-1].minor.yy438.limit = yymsp[0].minor.yy525;  yymsp[-1].minor.yy438.offset = 0;}
         break;
-      case 204: /* limit_opt ::= LIMIT signed OFFSET signed */
-{ yymsp[-3].minor.yy440.limit = yymsp[-2].minor.yy317;  yymsp[-3].minor.yy440.offset = yymsp[0].minor.yy317;}
+      case 207: /* limit_opt ::= LIMIT signed OFFSET signed */
+{ yymsp[-3].minor.yy438.limit = yymsp[-2].minor.yy525;  yymsp[-3].minor.yy438.offset = yymsp[0].minor.yy525;}
         break;
-      case 205: /* limit_opt ::= LIMIT signed COMMA signed */
-{ yymsp[-3].minor.yy440.limit = yymsp[0].minor.yy317;  yymsp[-3].minor.yy440.offset = yymsp[-2].minor.yy317;}
+      case 208: /* limit_opt ::= LIMIT signed COMMA signed */
+{ yymsp[-3].minor.yy438.limit = yymsp[0].minor.yy525;  yymsp[-3].minor.yy438.offset = yymsp[-2].minor.yy525;}
         break;
-      case 208: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
-{yymsp[-3].minor.yy440.limit = yymsp[-2].minor.yy317;  yymsp[-3].minor.yy440.offset = yymsp[0].minor.yy317;}
+      case 211: /* slimit_opt ::= SLIMIT signed SOFFSET signed */
+{yymsp[-3].minor.yy438.limit = yymsp[-2].minor.yy525;  yymsp[-3].minor.yy438.offset = yymsp[0].minor.yy525;}
         break;
-      case 209: /* slimit_opt ::= SLIMIT signed COMMA signed */
-{yymsp[-3].minor.yy440.limit = yymsp[0].minor.yy317;  yymsp[-3].minor.yy440.offset = yymsp[-2].minor.yy317;}
+      case 212: /* slimit_opt ::= SLIMIT signed COMMA signed */
+{yymsp[-3].minor.yy438.limit = yymsp[0].minor.yy525;  yymsp[-3].minor.yy438.offset = yymsp[-2].minor.yy525;}
         break;
-      case 212: /* expr ::= LP expr RP */
-{yylhsminor.yy118 = yymsp[-1].minor.yy118; yylhsminor.yy118->token.z = yymsp[-2].minor.yy0.z; yylhsminor.yy118->token.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
-  yymsp[-2].minor.yy118 = yylhsminor.yy118;
+      case 215: /* expr ::= LP expr RP */
+{yylhsminor.yy178 = yymsp[-1].minor.yy178; yylhsminor.yy178->token.z = yymsp[-2].minor.yy0.z; yylhsminor.yy178->token.n = (yymsp[0].minor.yy0.z - yymsp[-2].minor.yy0.z + 1);}
+  yymsp[-2].minor.yy178 = yylhsminor.yy178;
         break;
-      case 213: /* expr ::= ID */
-{ yylhsminor.yy118 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_ID);}
-  yymsp[0].minor.yy118 = yylhsminor.yy118;
+      case 216: /* expr ::= ID */
+{ yylhsminor.yy178 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_ID);}
+  yymsp[0].minor.yy178 = yylhsminor.yy178;
         break;
-      case 214: /* expr ::= ID DOT ID */
-{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy118 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ID);}
-  yymsp[-2].minor.yy118 = yylhsminor.yy118;
+      case 217: /* expr ::= ID DOT ID */
+{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy178 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ID);}
+  yymsp[-2].minor.yy178 = yylhsminor.yy178;
         break;
-      case 215: /* expr ::= ID DOT STAR */
-{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy118 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ALL);}
-  yymsp[-2].minor.yy118 = yylhsminor.yy118;
+      case 218: /* expr ::= ID DOT STAR */
+{ yymsp[-2].minor.yy0.n += (1+yymsp[0].minor.yy0.n); yylhsminor.yy178 = tSqlExprCreateIdValue(&yymsp[-2].minor.yy0, TK_ALL);}
+  yymsp[-2].minor.yy178 = yylhsminor.yy178;
         break;
-      case 216: /* expr ::= INTEGER */
-{ yylhsminor.yy118 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_INTEGER);}
-  yymsp[0].minor.yy118 = yylhsminor.yy118;
+      case 219: /* expr ::= INTEGER */
+{ yylhsminor.yy178 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_INTEGER);}
+  yymsp[0].minor.yy178 = yylhsminor.yy178;
         break;
-      case 217: /* expr ::= MINUS INTEGER */
-      case 218: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==218);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy118 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_INTEGER);}
-  yymsp[-1].minor.yy118 = yylhsminor.yy118;
+      case 220: /* expr ::= MINUS INTEGER */
+      case 221: /* expr ::= PLUS INTEGER */ yytestcase(yyruleno==221);
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_INTEGER; yylhsminor.yy178 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_INTEGER);}
+  yymsp[-1].minor.yy178 = yylhsminor.yy178;
         break;
-      case 219: /* expr ::= FLOAT */
-{ yylhsminor.yy118 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_FLOAT);}
-  yymsp[0].minor.yy118 = yylhsminor.yy118;
+      case 222: /* expr ::= FLOAT */
+{ yylhsminor.yy178 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_FLOAT);}
+  yymsp[0].minor.yy178 = yylhsminor.yy178;
         break;
-      case 220: /* expr ::= MINUS FLOAT */
-      case 221: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==221);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy118 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_FLOAT);}
-  yymsp[-1].minor.yy118 = yylhsminor.yy118;
+      case 223: /* expr ::= MINUS FLOAT */
+      case 224: /* expr ::= PLUS FLOAT */ yytestcase(yyruleno==224);
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_FLOAT; yylhsminor.yy178 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_FLOAT);}
+  yymsp[-1].minor.yy178 = yylhsminor.yy178;
         break;
-      case 222: /* expr ::= STRING */
-{ yylhsminor.yy118 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_STRING);}
-  yymsp[0].minor.yy118 = yylhsminor.yy118;
+      case 225: /* expr ::= STRING */
+{ yylhsminor.yy178 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_STRING);}
+  yymsp[0].minor.yy178 = yylhsminor.yy178;
         break;
-      case 223: /* expr ::= NOW */
-{ yylhsminor.yy118 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NOW); }
-  yymsp[0].minor.yy118 = yylhsminor.yy118;
+      case 226: /* expr ::= NOW */
+{ yylhsminor.yy178 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NOW); }
+  yymsp[0].minor.yy178 = yylhsminor.yy178;
         break;
-      case 224: /* expr ::= VARIABLE */
-{ yylhsminor.yy118 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_VARIABLE);}
-  yymsp[0].minor.yy118 = yylhsminor.yy118;
+      case 227: /* expr ::= VARIABLE */
+{ yylhsminor.yy178 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_VARIABLE);}
+  yymsp[0].minor.yy178 = yylhsminor.yy178;
         break;
-      case 225: /* expr ::= PLUS VARIABLE */
-      case 226: /* expr ::= MINUS VARIABLE */ yytestcase(yyruleno==226);
-{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_VARIABLE; yylhsminor.yy118 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_VARIABLE);}
-  yymsp[-1].minor.yy118 = yylhsminor.yy118;
+      case 228: /* expr ::= PLUS VARIABLE */
+      case 229: /* expr ::= MINUS VARIABLE */ yytestcase(yyruleno==229);
+{ yymsp[-1].minor.yy0.n += yymsp[0].minor.yy0.n; yymsp[-1].minor.yy0.type = TK_VARIABLE; yylhsminor.yy178 = tSqlExprCreateIdValue(&yymsp[-1].minor.yy0, TK_VARIABLE);}
+  yymsp[-1].minor.yy178 = yylhsminor.yy178;
         break;
-      case 227: /* expr ::= BOOL */
-{ yylhsminor.yy118 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_BOOL);}
-  yymsp[0].minor.yy118 = yylhsminor.yy118;
+      case 230: /* expr ::= BOOL */
+{ yylhsminor.yy178 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_BOOL);}
+  yymsp[0].minor.yy178 = yylhsminor.yy178;
         break;
-      case 228: /* expr ::= NULL */
-{ yylhsminor.yy118 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NULL);}
-  yymsp[0].minor.yy118 = yylhsminor.yy118;
+      case 231: /* expr ::= NULL */
+{ yylhsminor.yy178 = tSqlExprCreateIdValue(&yymsp[0].minor.yy0, TK_NULL);}
+  yymsp[0].minor.yy178 = yylhsminor.yy178;
         break;
-      case 229: /* expr ::= ID LP exprlist RP */
-{ yylhsminor.yy118 = tSqlExprCreateFunction(yymsp[-1].minor.yy159, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
-  yymsp[-3].minor.yy118 = yylhsminor.yy118;
+      case 232: /* expr ::= ID LP exprlist RP */
+{ yylhsminor.yy178 = tSqlExprCreateFunction(yymsp[-1].minor.yy285, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
+  yymsp[-3].minor.yy178 = yylhsminor.yy178;
         break;
-      case 230: /* expr ::= ID LP STAR RP */
-{ yylhsminor.yy118 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
-  yymsp[-3].minor.yy118 = yylhsminor.yy118;
+      case 233: /* expr ::= ID LP STAR RP */
+{ yylhsminor.yy178 = tSqlExprCreateFunction(NULL, &yymsp[-3].minor.yy0, &yymsp[0].minor.yy0, yymsp[-3].minor.yy0.type); }
+  yymsp[-3].minor.yy178 = yylhsminor.yy178;
         break;
-      case 231: /* expr ::= expr IS NULL */
-{yylhsminor.yy118 = tSqlExprCreate(yymsp[-2].minor.yy118, NULL, TK_ISNULL);}
-  yymsp[-2].minor.yy118 = yylhsminor.yy118;
+      case 234: /* expr ::= expr IS NULL */
+{yylhsminor.yy178 = tSqlExprCreate(yymsp[-2].minor.yy178, NULL, TK_ISNULL);}
+  yymsp[-2].minor.yy178 = yylhsminor.yy178;
         break;
-      case 232: /* expr ::= expr IS NOT NULL */
-{yylhsminor.yy118 = tSqlExprCreate(yymsp[-3].minor.yy118, NULL, TK_NOTNULL);}
-  yymsp[-3].minor.yy118 = yylhsminor.yy118;
+      case 235: /* expr ::= expr IS NOT NULL */
+{yylhsminor.yy178 = tSqlExprCreate(yymsp[-3].minor.yy178, NULL, TK_NOTNULL);}
+  yymsp[-3].minor.yy178 = yylhsminor.yy178;
         break;
-      case 233: /* expr ::= expr LT expr */
-{yylhsminor.yy118 = tSqlExprCreate(yymsp[-2].minor.yy118, yymsp[0].minor.yy118, TK_LT);}
-  yymsp[-2].minor.yy118 = yylhsminor.yy118;
+      case 236: /* expr ::= expr LT expr */
+{yylhsminor.yy178 = tSqlExprCreate(yymsp[-2].minor.yy178, yymsp[0].minor.yy178, TK_LT);}
+  yymsp[-2].minor.yy178 = yylhsminor.yy178;
         break;
-      case 234: /* expr ::= expr GT expr */
-{yylhsminor.yy118 = tSqlExprCreate(yymsp[-2].minor.yy118, yymsp[0].minor.yy118, TK_GT);}
-  yymsp[-2].minor.yy118 = yylhsminor.yy118;
+      case 237: /* expr ::= expr GT expr */
+{yylhsminor.yy178 = tSqlExprCreate(yymsp[-2].minor.yy178, yymsp[0].minor.yy178, TK_GT);}
+  yymsp[-2].minor.yy178 = yylhsminor.yy178;
         break;
-      case 235: /* expr ::= expr LE expr */
-{yylhsminor.yy118 = tSqlExprCreate(yymsp[-2].minor.yy118, yymsp[0].minor.yy118, TK_LE);}
-  yymsp[-2].minor.yy118 = yylhsminor.yy118;
+      case 238: /* expr ::= expr LE expr */
+{yylhsminor.yy178 = tSqlExprCreate(yymsp[-2].minor.yy178, yymsp[0].minor.yy178, TK_LE);}
+  yymsp[-2].minor.yy178 = yylhsminor.yy178;
         break;
-      case 236: /* expr ::= expr GE expr */
-{yylhsminor.yy118 = tSqlExprCreate(yymsp[-2].minor.yy118, yymsp[0].minor.yy118, TK_GE);}
-  yymsp[-2].minor.yy118 = yylhsminor.yy118;
+      case 239: /* expr ::= expr GE expr */
+{yylhsminor.yy178 = tSqlExprCreate(yymsp[-2].minor.yy178, yymsp[0].minor.yy178, TK_GE);}
+  yymsp[-2].minor.yy178 = yylhsminor.yy178;
         break;
-      case 237: /* expr ::= expr NE expr */
-{yylhsminor.yy118 = tSqlExprCreate(yymsp[-2].minor.yy118, yymsp[0].minor.yy118, TK_NE);}
-  yymsp[-2].minor.yy118 = yylhsminor.yy118;
+      case 240: /* expr ::= expr NE expr */
+{yylhsminor.yy178 = tSqlExprCreate(yymsp[-2].minor.yy178, yymsp[0].minor.yy178, TK_NE);}
+  yymsp[-2].minor.yy178 = yylhsminor.yy178;
         break;
-      case 238: /* expr ::= expr EQ expr */
-{yylhsminor.yy118 = tSqlExprCreate(yymsp[-2].minor.yy118, yymsp[0].minor.yy118, TK_EQ);}
-  yymsp[-2].minor.yy118 = yylhsminor.yy118;
+      case 241: /* expr ::= expr EQ expr */
+{yylhsminor.yy178 = tSqlExprCreate(yymsp[-2].minor.yy178, yymsp[0].minor.yy178, TK_EQ);}
+  yymsp[-2].minor.yy178 = yylhsminor.yy178;
         break;
-      case 239: /* expr ::= expr BETWEEN expr AND expr */
-{ tSqlExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy118); yylhsminor.yy118 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy118, yymsp[-2].minor.yy118, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy118, TK_LE), TK_AND);}
-  yymsp[-4].minor.yy118 = yylhsminor.yy118;
+      case 242: /* expr ::= expr BETWEEN expr AND expr */
+{ tSqlExpr* X2 = tSqlExprClone(yymsp[-4].minor.yy178); yylhsminor.yy178 = tSqlExprCreate(tSqlExprCreate(yymsp[-4].minor.yy178, yymsp[-2].minor.yy178, TK_GE), tSqlExprCreate(X2, yymsp[0].minor.yy178, TK_LE), TK_AND);}
+  yymsp[-4].minor.yy178 = yylhsminor.yy178;
         break;
-      case 240: /* expr ::= expr AND expr */
-{yylhsminor.yy118 = tSqlExprCreate(yymsp[-2].minor.yy118, yymsp[0].minor.yy118, TK_AND);}
-  yymsp[-2].minor.yy118 = yylhsminor.yy118;
+      case 243: /* expr ::= expr AND expr */
+{yylhsminor.yy178 = tSqlExprCreate(yymsp[-2].minor.yy178, yymsp[0].minor.yy178, TK_AND);}
+  yymsp[-2].minor.yy178 = yylhsminor.yy178;
         break;
-      case 241: /* expr ::= expr OR expr */
-{yylhsminor.yy118 = tSqlExprCreate(yymsp[-2].minor.yy118, yymsp[0].minor.yy118, TK_OR); }
-  yymsp[-2].minor.yy118 = yylhsminor.yy118;
+      case 244: /* expr ::= expr OR expr */
+{yylhsminor.yy178 = tSqlExprCreate(yymsp[-2].minor.yy178, yymsp[0].minor.yy178, TK_OR); }
+  yymsp[-2].minor.yy178 = yylhsminor.yy178;
         break;
-      case 242: /* expr ::= expr PLUS expr */
-{yylhsminor.yy118 = tSqlExprCreate(yymsp[-2].minor.yy118, yymsp[0].minor.yy118, TK_PLUS);  }
-  yymsp[-2].minor.yy118 = yylhsminor.yy118;
+      case 245: /* expr ::= expr PLUS expr */
+{yylhsminor.yy178 = tSqlExprCreate(yymsp[-2].minor.yy178, yymsp[0].minor.yy178, TK_PLUS);  }
+  yymsp[-2].minor.yy178 = yylhsminor.yy178;
         break;
-      case 243: /* expr ::= expr MINUS expr */
-{yylhsminor.yy118 = tSqlExprCreate(yymsp[-2].minor.yy118, yymsp[0].minor.yy118, TK_MINUS); }
-  yymsp[-2].minor.yy118 = yylhsminor.yy118;
+      case 246: /* expr ::= expr MINUS expr */
+{yylhsminor.yy178 = tSqlExprCreate(yymsp[-2].minor.yy178, yymsp[0].minor.yy178, TK_MINUS); }
+  yymsp[-2].minor.yy178 = yylhsminor.yy178;
         break;
-      case 244: /* expr ::= expr STAR expr */
-{yylhsminor.yy118 = tSqlExprCreate(yymsp[-2].minor.yy118, yymsp[0].minor.yy118, TK_STAR);  }
-  yymsp[-2].minor.yy118 = yylhsminor.yy118;
+      case 247: /* expr ::= expr STAR expr */
+{yylhsminor.yy178 = tSqlExprCreate(yymsp[-2].minor.yy178, yymsp[0].minor.yy178, TK_STAR);  }
+  yymsp[-2].minor.yy178 = yylhsminor.yy178;
         break;
-      case 245: /* expr ::= expr SLASH expr */
-{yylhsminor.yy118 = tSqlExprCreate(yymsp[-2].minor.yy118, yymsp[0].minor.yy118, TK_DIVIDE);}
-  yymsp[-2].minor.yy118 = yylhsminor.yy118;
+      case 248: /* expr ::= expr SLASH expr */
+{yylhsminor.yy178 = tSqlExprCreate(yymsp[-2].minor.yy178, yymsp[0].minor.yy178, TK_DIVIDE);}
+  yymsp[-2].minor.yy178 = yylhsminor.yy178;
         break;
-      case 246: /* expr ::= expr REM expr */
-{yylhsminor.yy118 = tSqlExprCreate(yymsp[-2].minor.yy118, yymsp[0].minor.yy118, TK_REM);   }
-  yymsp[-2].minor.yy118 = yylhsminor.yy118;
+      case 249: /* expr ::= expr REM expr */
+{yylhsminor.yy178 = tSqlExprCreate(yymsp[-2].minor.yy178, yymsp[0].minor.yy178, TK_REM);   }
+  yymsp[-2].minor.yy178 = yylhsminor.yy178;
         break;
-      case 247: /* expr ::= expr LIKE expr */
-{yylhsminor.yy118 = tSqlExprCreate(yymsp[-2].minor.yy118, yymsp[0].minor.yy118, TK_LIKE);  }
-  yymsp[-2].minor.yy118 = yylhsminor.yy118;
+      case 250: /* expr ::= expr LIKE expr */
+{yylhsminor.yy178 = tSqlExprCreate(yymsp[-2].minor.yy178, yymsp[0].minor.yy178, TK_LIKE);  }
+  yymsp[-2].minor.yy178 = yylhsminor.yy178;
         break;
-      case 248: /* expr ::= expr IN LP exprlist RP */
-{yylhsminor.yy118 = tSqlExprCreate(yymsp[-4].minor.yy118, (tSqlExpr*)yymsp[-1].minor.yy159, TK_IN); }
-  yymsp[-4].minor.yy118 = yylhsminor.yy118;
+      case 251: /* expr ::= expr IN LP exprlist RP */
+{yylhsminor.yy178 = tSqlExprCreate(yymsp[-4].minor.yy178, (tSqlExpr*)yymsp[-1].minor.yy285, TK_IN); }
+  yymsp[-4].minor.yy178 = yylhsminor.yy178;
         break;
-      case 249: /* exprlist ::= exprlist COMMA expritem */
-{yylhsminor.yy159 = tSqlExprListAppend(yymsp[-2].minor.yy159,yymsp[0].minor.yy118,0, 0);}
-  yymsp[-2].minor.yy159 = yylhsminor.yy159;
+      case 252: /* exprlist ::= exprlist COMMA expritem */
+{yylhsminor.yy285 = tSqlExprListAppend(yymsp[-2].minor.yy285,yymsp[0].minor.yy178,0, 0);}
+  yymsp[-2].minor.yy285 = yylhsminor.yy285;
         break;
-      case 250: /* exprlist ::= expritem */
-{yylhsminor.yy159 = tSqlExprListAppend(0,yymsp[0].minor.yy118,0, 0);}
-  yymsp[0].minor.yy159 = yylhsminor.yy159;
+      case 253: /* exprlist ::= expritem */
+{yylhsminor.yy285 = tSqlExprListAppend(0,yymsp[0].minor.yy178,0, 0);}
+  yymsp[0].minor.yy285 = yylhsminor.yy285;
         break;
-      case 251: /* expritem ::= expr */
-{yylhsminor.yy118 = yymsp[0].minor.yy118;}
-  yymsp[0].minor.yy118 = yylhsminor.yy118;
+      case 254: /* expritem ::= expr */
+{yylhsminor.yy178 = yymsp[0].minor.yy178;}
+  yymsp[0].minor.yy178 = yylhsminor.yy178;
         break;
-      case 253: /* cmd ::= RESET QUERY CACHE */
+      case 256: /* cmd ::= RESET QUERY CACHE */
 { setDCLSqlElems(pInfo, TSDB_SQL_RESET_CACHE, 0);}
         break;
-      case 254: /* cmd ::= SYNCDB ids REPLICA */
+      case 257: /* cmd ::= SYNCDB ids REPLICA */
 { setDCLSqlElems(pInfo, TSDB_SQL_SYNC_DB_REPLICA, 1, &yymsp[-1].minor.yy0);}
         break;
-      case 255: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
+      case 258: /* cmd ::= ALTER TABLE ids cpxName ADD COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy159, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy285, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 256: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
+      case 259: /* cmd ::= ALTER TABLE ids cpxName DROP COLUMN ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -3001,14 +3022,14 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 257: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
+      case 260: /* cmd ::= ALTER TABLE ids cpxName ADD TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy159, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy285, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 258: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
+      case 261: /* cmd ::= ALTER TABLE ids cpxName DROP TAG ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -3019,7 +3040,7 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 259: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
+      case 262: /* cmd ::= ALTER TABLE ids cpxName CHANGE TAG ids ids */
 {
     yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
 
@@ -3033,26 +3054,26 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 260: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
+      case 263: /* cmd ::= ALTER TABLE ids cpxName SET TAG ids EQ tagitem */
 {
     yymsp[-6].minor.yy0.n += yymsp[-5].minor.yy0.n;
 
     toTSDBType(yymsp[-2].minor.yy0.type);
     SArray* A = tVariantListAppendToken(NULL, &yymsp[-2].minor.yy0, -1);
-    A = tVariantListAppend(A, &yymsp[0].minor.yy488, -1);
+    A = tVariantListAppend(A, &yymsp[0].minor.yy362, -1);
 
     SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-6].minor.yy0, NULL, A, TSDB_ALTER_TABLE_UPDATE_TAG_VAL, -1);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 261: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
+      case 264: /* cmd ::= ALTER STABLE ids cpxName ADD COLUMN columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy159, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy285, NULL, TSDB_ALTER_TABLE_ADD_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 262: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
+      case 265: /* cmd ::= ALTER STABLE ids cpxName DROP COLUMN ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -3063,14 +3084,14 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 263: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
+      case 266: /* cmd ::= ALTER STABLE ids cpxName ADD TAG columnlist */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
-    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy159, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE);
+    SAlterTableInfo* pAlterTable = tSetAlterTableInfo(&yymsp[-4].minor.yy0, yymsp[0].minor.yy285, NULL, TSDB_ALTER_TABLE_ADD_TAG_COLUMN, TSDB_SUPER_TABLE);
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 264: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
+      case 267: /* cmd ::= ALTER STABLE ids cpxName DROP TAG ids */
 {
     yymsp[-4].minor.yy0.n += yymsp[-3].minor.yy0.n;
 
@@ -3081,7 +3102,7 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 265: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
+      case 268: /* cmd ::= ALTER STABLE ids cpxName CHANGE TAG ids ids */
 {
     yymsp[-5].minor.yy0.n += yymsp[-4].minor.yy0.n;
 
@@ -3095,13 +3116,13 @@ static void yy_reduce(
     setSqlInfo(pInfo, pAlterTable, NULL, TSDB_SQL_ALTER_TABLE);
 }
         break;
-      case 266: /* cmd ::= KILL CONNECTION INTEGER */
+      case 269: /* cmd ::= KILL CONNECTION INTEGER */
 {setKillSql(pInfo, TSDB_SQL_KILL_CONNECTION, &yymsp[0].minor.yy0);}
         break;
-      case 267: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
+      case 270: /* cmd ::= KILL STREAM INTEGER COLON INTEGER */
 {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_STREAM, &yymsp[-2].minor.yy0);}
         break;
-      case 268: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
+      case 271: /* cmd ::= KILL QUERY INTEGER COLON INTEGER */
 {yymsp[-2].minor.yy0.n += (yymsp[-1].minor.yy0.n + yymsp[0].minor.yy0.n); setKillSql(pInfo, TSDB_SQL_KILL_QUERY, &yymsp[-2].minor.yy0);}
         break;
       default:

From 8497cdee74ffb87b82157e38bfc837120fdb5eed Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Mon, 10 May 2021 15:26:33 +0800
Subject: [PATCH 016/128] fix memory leak

---
 src/tsdb/src/tsdbMeta.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c
index 9b98ca19fc..f4f555e2df 100644
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
@@ -793,6 +793,7 @@ static void tsdbFreeTable(STable *pTable) {
 
     tSkipListDestroy(pTable->pIndex);
     taosTZfree(pTable->lastRow);
+    tfree(pTable->lastCols);
     tfree(pTable->sql);
 
     for (int i = 0; i < pTable->lastColNum; ++i) {

From 186662aa7597b399e0e19cffe608c76d1274ec5f Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Mon, 10 May 2021 15:35:44 +0800
Subject: [PATCH 017/128] [td-225]

---
 src/client/src/tscSQLParser.c | 18 ++++++++++--------
 src/query/inc/qSqlparser.h    |  3 +--
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 63768a41d7..c69d9a698a 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -7189,16 +7189,11 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
 
   if (pSqlNode->from->type == SQL_NODE_FROM_SUBQUERY) {
     // parse the subquery in the first place
-    SArray* list = taosArrayGetP(pSqlNode->from->list, 0);
-    SSqlNode* p = taosArrayGetP(list, 0);
+    SRelElementPair* sub = taosArrayGet(pSqlNode->from->list, 0);
+    SSqlNode* p = taosArrayGetP(sub->pSubquery, 0);
 
-    SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
     code = validateSqlNode(pSql, p, pQueryInfo);
-    if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
-      return code;
-    }
-
-    if (code != TSDB_CODE_SUCCESS) {
+    if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS || code != TSDB_CODE_SUCCESS) {
       return code;
     }
 
@@ -7211,6 +7206,13 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
     STableMetaInfo* pTableMetaInfo1 = calloc(1, sizeof(STableMetaInfo));
     pTableMetaInfo1->pTableMeta = pTableMeta;
 
+    if (sub->aliasName.n > 0) {
+      if (sub->aliasName.n > TSDB_TABLE_FNAME_LEN) {
+        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), "subquery alias name too long");
+      }
+      strncpy(pTableMetaInfo1->aliasName, sub->aliasName.z, sub->aliasName.n);
+    }
+
     current->pTableMetaInfo = calloc(1, POINTER_BYTES);
     current->pTableMetaInfo[0] = pTableMetaInfo1;
     current->numOfTables = 1;
diff --git a/src/query/inc/qSqlparser.h b/src/query/inc/qSqlparser.h
index bbf391659b..d3a422b1f5 100644
--- a/src/query/inc/qSqlparser.h
+++ b/src/query/inc/qSqlparser.h
@@ -111,7 +111,6 @@ typedef struct SRelElementPair {
   union {
     SStrToken  tableName;
     SArray    *pSubquery;
-    //SSqlNode  *pSubquery;
   };
 
   SStrToken aliasName;
@@ -119,7 +118,7 @@ typedef struct SRelElementPair {
 
 typedef struct SRelationInfo {
   int32_t       type;        // nested query|table name list
-  SArray       *list;        // SArray<SRelElementPair>|SArray<SSqlNode*>
+  SArray       *list;        // SArray<SRelElementPair>
 } SRelationInfo;
 
 typedef struct SCreatedTableInfo {

From 00836e137cd23c973667c050a5396c01150ba5bd Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Mon, 10 May 2021 17:01:38 +0800
Subject: [PATCH 018/128] fix memory leak

---
 src/tsdb/src/tsdbMeta.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c
index f4f555e2df..d45f4c2d60 100644
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
@@ -792,8 +792,7 @@ static void tsdbFreeTable(STable *pTable) {
     kvRowFree(pTable->tagVal);
 
     tSkipListDestroy(pTable->pIndex);
-    taosTZfree(pTable->lastRow);
-    tfree(pTable->lastCols);
+    taosTZfree(pTable->lastRow);    
     tfree(pTable->sql);
 
     for (int i = 0; i < pTable->lastColNum; ++i) {
@@ -802,6 +801,8 @@ static void tsdbFreeTable(STable *pTable) {
       }
       free(pTable->lastCols[i].pData);
     }
+    tfree(pTable->lastCols);
+    
     free(pTable);
   }
 }

From 1d002f4aa7f10235d840027e93325058c0e0c61a Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 11 May 2021 10:14:27 +0800
Subject: [PATCH 019/128] [td-225] refactor code.

---
 src/client/inc/tscUtil.h        |   2 +-
 src/client/inc/tsclient.h       |   5 +-
 src/client/src/tscParseInsert.c |   6 +-
 src/client/src/tscSQLParser.c   | 170 +++++++++++++++++++++++++++-----
 src/client/src/tscSql.c         |   2 +-
 src/query/src/qSqlParser.c      |  48 +--------
 6 files changed, 155 insertions(+), 78 deletions(-)

diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index 93041ccca8..eb607f040d 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -156,7 +156,7 @@ bool tscQueryBlockInfo(SQueryInfo* pQueryInfo);
 SExprInfo* tscAddFuncInSelectClause(SQueryInfo* pQueryInfo, int32_t outputColIndex, int16_t functionId,
                                        SColumnIndex* pIndex, SSchema* pColSchema, int16_t colType);
 
-int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SStrToken* pzTableName, SSqlObj* pSql);
+int32_t tscSetTableFullName(SName* pName, SStrToken* pzTableName, SSqlObj* pSql);
 void    tscClearInterpInfo(SQueryInfo* pQueryInfo);
 
 bool tscIsInsertData(char* sqlstr);
diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index c62b830a69..294cbc595a 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -268,15 +268,16 @@ typedef struct {
   char *       payload;
   int32_t      payloadLen;
 
+  SHashObj    *pTableMetaMap;  // local buffer to keep the queried table meta, before validating the AST
   SQueryInfo  *pQueryInfo;
-//  int32_t      numOfClause;
+
   int32_t      clauseIndex;  // index of multiple subclause query
   SQueryInfo  *active;       // current active query info
 
   int32_t      batchSize;    // for parameter ('?') binding and batch processing
   int32_t      numOfParams;
 
-  int8_t       dataSourceType;     // load data from file or not
+  int8_t       dataSourceType; // load data from file or not
   char    reserve4[3];         // fix bus error on arm32
   int8_t       submitSchema;   // submit block is built with table schema
   char    reserve5[3];         // fix bus error on arm32
diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index 7ee5375d23..5509610873 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -803,7 +803,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
     }
 
     STableMetaInfo *pSTableMetaInfo = tscGetMetaInfo(pQueryInfo, STABLE_INDEX);
-    code = tscSetTableFullName(pSTableMetaInfo, &sToken, pSql);
+    code = tscSetTableFullName(&pTableMetaInfo->name, &sToken, pSql);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
     }
@@ -938,7 +938,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
       return tscInvalidSQLErrMsg(pCmd->payload, "invalid table name", *sqlstr);
     }
 
-    int32_t ret = tscSetTableFullName(pTableMetaInfo, &tableToken, pSql);
+    int32_t ret = tscSetTableFullName(&pTableMetaInfo->name, &tableToken, pSql);
     if (ret != TSDB_CODE_SUCCESS) {
       return ret;
     }
@@ -1133,7 +1133,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
       goto _clean;
     }
 
-    if ((code = tscSetTableFullName(pTableMetaInfo, &sTblToken, pSql)) != TSDB_CODE_SUCCESS) {
+    if ((code = tscSetTableFullName(&pTableMetaInfo->name, &sTblToken, pSql)) != TSDB_CODE_SUCCESS) {
       goto _clean;
     }
 
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index c69d9a698a..39a4ff2239 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -131,6 +131,7 @@ static int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQ
 static int32_t exprTreeFromSqlExpr(SSqlCmd* pCmd, tExprNode **pExpr, const tSqlExpr* pSqlExpr, SQueryInfo* pQueryInfo, SArray* pCols, uint64_t *uid);
 static bool    validateDebugFlag(int32_t v);
 static int32_t checkQueryRangeForFill(SSqlCmd* pCmd, SQueryInfo* pQueryInfo);
+static int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo);
 
 static bool    isTimeWindowQuery(SQueryInfo* pQueryInfo) {
   return pQueryInfo->interval.interval > 0 || pQueryInfo->sessionWindow.gap > 0;
@@ -299,7 +300,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       } else if (pInfo->type == TSDB_SQL_DROP_TABLE) {
         assert(taosArrayGetSize(pInfo->pMiscInfo->a) == 1);
 
-        code = tscSetTableFullName(pTableMetaInfo, pzName, pSql);
+        code = tscSetTableFullName(&pTableMetaInfo->name, pzName, pSql);
         if(code != TSDB_CODE_SUCCESS) {
           return code; 
         }
@@ -440,7 +441,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       }
 
       // additional msg has been attached already
-      code = tscSetTableFullName(pTableMetaInfo, pToken, pSql);
+      code = tscSetTableFullName(&pTableMetaInfo->name, pToken, pSql);
       if (code != TSDB_CODE_SUCCESS) {
         return code;
       }
@@ -460,7 +461,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
 
-      code = tscSetTableFullName(pTableMetaInfo, pToken, pSql);
+      code = tscSetTableFullName(&pTableMetaInfo->name, pToken, pSql);
       if (code != TSDB_CODE_SUCCESS) {
         return code;
       }
@@ -479,7 +480,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
-      return tscSetTableFullName(pTableMetaInfo, pToken, pSql);
+      return tscSetTableFullName(&pTableMetaInfo->name, pToken, pSql);
     }
     case TSDB_SQL_CFG_DNODE: {
       const char* msg2 = "invalid configure options or values, such as resetlog / debugFlag 135 / balance 'vnode:2-dnode:2' / monitor 1 ";
@@ -618,6 +619,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
     case TSDB_SQL_SELECT: {
       const char* msg1 = "columns in select clause not identical";
+      loadAllTableMeta(pSql, pInfo);
 
       SQueryInfo* pCurrent = pCmd->pQueryInfo;
       for(int32_t i = 0; i < pCmd->clauseIndex; ++i) {
@@ -983,7 +985,7 @@ int32_t parseSlidingClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SStrToken* pSl
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SStrToken* pTableName, SSqlObj* pSql) {
+int32_t tscSetTableFullName(SName* pName, SStrToken* pTableName, SSqlObj* pSql) {
   const char* msg1 = "name too long";
   const char* msg2 = "acctId too long";
   const char* msg3 = "no acctId";
@@ -997,7 +999,7 @@ int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SStrToken* pTableNam
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
     }
 
-    code = tNameSetAcctId(&pTableMetaInfo->name, acctId);
+    code = tNameSetAcctId(pName, acctId);
     if (code != 0) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
     }
@@ -1005,7 +1007,7 @@ int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SStrToken* pTableNam
     char name[TSDB_TABLE_FNAME_LEN] = {0};
     strncpy(name, pTableName->z, pTableName->n);
 
-    code = tNameFromString(&pTableMetaInfo->name, name, T_NAME_DB|T_NAME_TABLE);
+    code = tNameFromString(pName, name, T_NAME_DB|T_NAME_TABLE);
     if (code != 0) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
@@ -1015,7 +1017,7 @@ int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SStrToken* pTableNam
       return TSDB_CODE_TSC_DB_NOT_SELECTED;
     }
 
-    code = tNameFromString(&pTableMetaInfo->name, t, T_NAME_ACCT | T_NAME_DB);
+    code = tNameFromString(pName, t, T_NAME_ACCT | T_NAME_DB);
     if (code != 0) {
       free(t);
       return TSDB_CODE_TSC_DB_NOT_SELECTED;
@@ -1030,7 +1032,7 @@ int32_t tscSetTableFullName(STableMetaInfo* pTableMetaInfo, SStrToken* pTableNam
     char name[TSDB_TABLE_FNAME_LEN] = {0};
     strncpy(name, pTableName->z, pTableName->n);
 
-    code = tNameFromString(&pTableMetaInfo->name, name, T_NAME_TABLE);
+    code = tNameFromString(pName, name, T_NAME_TABLE);
     if (code != 0) {
       code = invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
@@ -5062,7 +5064,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
-  code = tscSetTableFullName(pTableMetaInfo, &(pAlterSQL->name), pSql);
+  code = tscSetTableFullName(&pTableMetaInfo->name, &(pAlterSQL->name), pSql);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
@@ -6425,7 +6427,7 @@ int32_t doCheckForCreateTable(SSqlObj* pSql, int32_t subClauseIndex, SSqlInfo* p
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
-  int32_t code = tscSetTableFullName(pTableMetaInfo, pzTableName, pSql);
+  int32_t code = tscSetTableFullName(&pTableMetaInfo->name, pzTableName, pSql);
   if(code != TSDB_CODE_SUCCESS) {
     return code;
   }
@@ -6489,7 +6491,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 
-    int32_t code = tscSetTableFullName(pStableMetaInfo, pToken, pSql);
+    int32_t code = tscSetTableFullName(&pStableMetaInfo->name, pToken, pSql);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
     }
@@ -6645,7 +6647,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
     }
 
     STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, TABLE_INDEX);
-    ret = tscSetTableFullName(pTableMetaInfo, &pCreateTableInfo->name, pSql);
+    ret = tscSetTableFullName(&pTableMetaInfo->name, &pCreateTableInfo->name, pSql);
     if (ret != TSDB_CODE_SUCCESS) {
       return ret;
     }
@@ -6695,7 +6697,7 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
-  int32_t code = tscSetTableFullName(pTableMetaInfo, &srcToken, pSql);
+  int32_t code = tscSetTableFullName(&pTableMetaInfo->name, &srcToken, pSql);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
@@ -6730,7 +6732,7 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
   }
 
   // set the created table[stream] name
-  code = tscSetTableFullName(pTableMetaInfo, pName, pSql);
+  code = tscSetTableFullName(&pTableMetaInfo->name, pName, pSql);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
@@ -7072,6 +7074,122 @@ int32_t validateHavingClause(SQueryInfo* pQueryInfo, tSqlExpr* pExpr, SSqlCmd* p
   return TSDB_CODE_SUCCESS;
 }
 
+static int32_t getTableNameFromSqlNode(SSqlNode* pSqlNode, SArray* tableNameList, char* msgBuf, SSqlObj* pSql) {
+  const char* msg1 = "";
+
+  int32_t numOfTables = taosArrayGetSize(pSqlNode->from->list);
+  assert(pSqlNode->from->type == SQL_NODE_FROM_TABLELIST);
+
+  for(int32_t j = 0; j < numOfTables; ++j) {
+    SRelElementPair* item = taosArrayGet(pSqlNode->from->list, j);
+
+    SStrToken* t = &item->tableName;
+    if (t->type == TK_INTEGER || t->type == TK_FLOAT) {
+      return invalidSqlErrMsg(msgBuf, msg1);
+    }
+
+    tscDequoteAndTrimToken(t);
+    if (tscValidateName(t) != TSDB_CODE_SUCCESS) {
+      return invalidSqlErrMsg(msgBuf, msg1);
+    }
+
+    SName name = {0};
+    if (tscSetTableFullName(&name, t, pSql) != TSDB_CODE_SUCCESS) {
+      return invalidSqlErrMsg(msgBuf, msg1);
+    }
+
+    taosArrayPush(tableNameList, &name);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t getTableNameFromSubquery(SSqlNode* pSqlNode, SArray* tableNameList, char* msgBuf, SSqlObj* pSql) {
+  int32_t numOfSub = (int32_t) taosArrayGetSize(pSqlNode->from->list);
+
+  for(int32_t j = 0; j < numOfSub; ++j) {
+    SRelElementPair* sub = taosArrayGet(pSqlNode->from->list, j);
+
+    int32_t num = (int32_t)taosArrayGetSize(sub->pSubquery);
+    for (int32_t i = 0; i < num; ++i) {
+      SSqlNode* p = taosArrayGetP(sub->pSubquery, i);
+      if (p->from->type == SQL_NODE_FROM_TABLELIST) {
+        int32_t code = getTableNameFromSqlNode(p, tableNameList, msgBuf, pSql);
+        if (code != TSDB_CODE_SUCCESS) {
+          return code;
+        }
+      } else {
+        getTableNameFromSubquery(p, tableNameList, msgBuf, pSql);
+      }
+    }
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
+  SSqlCmd* pCmd = &pSql->cmd;
+
+  // the table meta has already been loaded from local buffer or mnode already
+  if (pCmd->pTableMetaMap != NULL) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  pCmd->pTableMetaMap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY),
+      false, HASH_NO_LOCK);
+
+  SArray* tableNameList = taosArrayInit(4, sizeof(SName));
+
+  int32_t size = taosArrayGetSize(pInfo->list);
+  for (int32_t i = 0; i < size; ++i) {
+    SSqlNode* pSqlNode = taosArrayGetP(pInfo->list, i);
+
+    // load the table meta in the from clause
+    if (pSqlNode->from->type == SQL_NODE_FROM_TABLELIST) {
+      int32_t code = getTableNameFromSqlNode(pSqlNode, tableNameList, tscGetErrorMsgPayload(pCmd), pSql);
+      if (code != TSDB_CODE_SUCCESS) {
+        return code;
+      }
+    } else {
+      int32_t code = getTableNameFromSubquery(pSqlNode, tableNameList, tscGetErrorMsgPayload(pCmd), pSql);
+      if (code != TSDB_CODE_SUCCESS) {
+        return code;
+      }
+    }
+  }
+
+  uint32_t maxSize = tscGetTableMetaMaxSize();
+  char name[TSDB_TABLE_FNAME_LEN] = {0};
+
+  int32_t numOfTables = taosArrayGetSize(tableNameList);
+  STableMeta* pTableMeta = calloc(1, maxSize);
+
+  for(int32_t i = 0; i < numOfTables; ++i) {
+    SName* pname = taosArrayGet(tableNameList, i);
+    tNameExtractFullName(pname, name);
+
+    size_t len = strlen(name);
+    memset(pTableMeta, 0, maxSize);
+    taosHashGetClone(tscTableMetaInfo, name, len, NULL, pTableMeta, -1);
+
+    if (pTableMeta->id.uid > 0) {
+      if (pTableMeta->tableType == TSDB_CHILD_TABLE) {
+        int32_t code = tscCreateTableMetaFromCChildMeta(pTableMeta, name);
+        if (code != TSDB_CODE_SUCCESS) {
+          // add to retrieve list
+          continue;
+        }
+      }
+
+      STableMeta* pMeta = tscTableMetaDup(pTableMeta);
+      taosHashPut(pCmd->pTableMetaMap, name, strlen(name), &pMeta, POINTER_BYTES);
+    }
+  }
+
+//  return getTableMetaFromMnode(pSql, pTableMetaInfo);
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t doLoadAllTableMeta(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNode* pSqlNode, int32_t numOfTables) {
   const char* msg1 = "invalid table name";
   const char* msg2 = "invalid table alias name";
@@ -7086,7 +7204,7 @@ static int32_t doLoadAllTableMeta(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNod
     }
 
     SRelElementPair *item = taosArrayGet(pSqlNode->from->list, i);
-    SStrToken      *oriName = &item->tableName;
+    SStrToken       *oriName = &item->tableName;
 
     if (oriName->type == TK_INTEGER || oriName->type == TK_FLOAT) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
@@ -7098,7 +7216,7 @@ static int32_t doLoadAllTableMeta(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNod
     }
 
     STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, i);
-    code = tscSetTableFullName(pTableMetaInfo, oriName, pSql);
+    code = tscSetTableFullName(&pTableMetaInfo->name, oriName, pSql);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
     }
@@ -7110,18 +7228,13 @@ static int32_t doLoadAllTableMeta(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNod
       }
 
       tscDequoteAndTrimToken(aliasName);
-      if (tscValidateName(aliasName) != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
-      }
-
-      if (aliasName->n >= TSDB_TABLE_NAME_LEN) {
+      if (tscValidateName(aliasName) != TSDB_CODE_SUCCESS || aliasName->n >= TSDB_TABLE_NAME_LEN) {
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
       }
 
       strncpy(pTableMetaInfo->aliasName, aliasName->z, aliasName->n);
     } else {
-      strncpy(pTableMetaInfo->aliasName, tNameGetTableName(&pTableMetaInfo->name),
-              tListLen(pTableMetaInfo->aliasName));
+      strncpy(pTableMetaInfo->aliasName, tNameGetTableName(&pTableMetaInfo->name), tListLen(pTableMetaInfo->aliasName));
     }
 
     code = tscGetTableMeta(pSql, pTableMetaInfo);
@@ -7133,7 +7246,7 @@ static int32_t doLoadAllTableMeta(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNod
   return TSDB_CODE_SUCCESS;
 }
 
-static STableMeta* extractTempTableMetaFromNestQuery(SQueryInfo* pUpstream) {
+static STableMeta* extractTempTableMetaFromSubquery(SQueryInfo* pUpstream) {
   int32_t numOfColumns = pUpstream->fieldsInfo.numOfOutput;
 
   STableMeta* meta = calloc(1, sizeof(STableMeta) + sizeof(SSchema) * numOfColumns);
@@ -7189,6 +7302,8 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
 
   if (pSqlNode->from->type == SQL_NODE_FROM_SUBQUERY) {
     // parse the subquery in the first place
+    int32_t numOfSub = taosArrayGetSize(pSqlNode->from->list);
+
     SRelElementPair* sub = taosArrayGet(pSqlNode->from->list, 0);
     SSqlNode* p = taosArrayGetP(sub->pSubquery, 0);
 
@@ -7202,7 +7317,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
     tscInitQueryInfo(current);
     taosArrayPush(current->pUpstream, &pQueryInfo);
 
-    STableMeta* pTableMeta = extractTempTableMetaFromNestQuery(pQueryInfo);
+    STableMeta* pTableMeta = extractTempTableMetaFromSubquery(pQueryInfo);
     STableMetaInfo* pTableMetaInfo1 = calloc(1, sizeof(STableMetaInfo));
     pTableMetaInfo1->pTableMeta = pTableMeta;
 
@@ -7213,7 +7328,8 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
       strncpy(pTableMetaInfo1->aliasName, sub->aliasName.z, sub->aliasName.n);
     }
 
-    current->pTableMetaInfo = calloc(1, POINTER_BYTES);
+    current->pTableMetaInfo = calloc(numOfSub, POINTER_BYTES);
+
     current->pTableMetaInfo[0] = pTableMetaInfo1;
     current->numOfTables = 1;
     current->order = pQueryInfo->order;
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index dd26b8834d..3013b261df 100644
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -975,7 +975,7 @@ static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t t
       return code;
     }
 
-    if ((code = tscSetTableFullName(pTableMetaInfo, &sToken, pSql)) != TSDB_CODE_SUCCESS) {
+    if ((code = tscSetTableFullName(&pTableMetaInfo->name, &sToken, pSql)) != TSDB_CODE_SUCCESS) {
       return code;
     }
 
diff --git a/src/query/src/qSqlParser.c b/src/query/src/qSqlParser.c
index e26b850215..012bd5429b 100644
--- a/src/query/src/qSqlParser.c
+++ b/src/query/src/qSqlParser.c
@@ -324,7 +324,6 @@ static FORCE_INLINE int32_t tStrTokenCompare(SStrToken* left, SStrToken* right)
   return (left->type == right->type && left->n == right->n && strncasecmp(left->z, right->z, left->n) == 0) ? 0 : 1;
 }
 
-
 int32_t tSqlExprCompare(tSqlExpr *left, tSqlExpr *right) {
   if ((left == NULL && right) || (left && right == NULL)) {
     return 1;
@@ -388,8 +387,6 @@ int32_t tSqlExprCompare(tSqlExpr *left, tSqlExpr *right) {
   return 0;
 }
 
-
-
 tSqlExpr *tSqlExprClone(tSqlExpr *pSrc) {
   tSqlExpr *pExpr = calloc(1, sizeof(tSqlExpr));
 
@@ -550,42 +547,6 @@ SRelationInfo *setTableNameList(SRelationInfo* pRelationInfo, SStrToken *pName,
   return pRelationInfo;
 }
 
-//SRelationInfo* setSubquery(SRelationInfo* pRelationInfo, SArray* pList, SStrToken* pAlias) {
-//  if (pRelationInfo == NULL) {
-//    pRelationInfo = calloc(1, sizeof(SRelationInfo));
-//    pRelationInfo->list = taosArrayInit(4, POINTER_BYTES);
-//  }
-//
-//  pRelationInfo->type = SQL_NODE_FROM_SUBQUERY;
-//  SRelElementPair p = {.pSubquery = pList};
-//  if (pAlias != NULL) {
-//    p.aliasName = *pAlias;
-//  } else {
-//    TPARSER_SET_NONE_TOKEN(p.aliasName);
-//  }
-//
-//  taosArrayPush(pRelationInfo->list, &p);
-//  return pRelationInfo;
-//}
-
-//SRelationInfo* setSubquery(SRelationInfo* pRelationInfo, SRelElementPair* p) {
-//  if (pRelationInfo == NULL) {
-//    pRelationInfo = calloc(1, sizeof(SRelationInfo));
-//    pRelationInfo->list = taosArrayInit(4, POINTER_BYTES);
-//  }
-//
-//  pRelationInfo->type = SQL_NODE_FROM_SUBQUERY;
-//  SRelElementPair elem = *p;
-////  if (pAlias != NULL) {
-////    p.aliasName = *pAlias;
-////  } else {
-////    TPARSER_SET_NONE_TOKEN(p.aliasName);
-////  }
-//
-//  taosArrayPush(pRelationInfo->list, &p);
-//  return pRelationInfo;
-//}
-
 void* destroyRelationInfo(SRelationInfo* pRelationInfo) {
   if (pRelationInfo == NULL) {
     return NULL;
@@ -596,7 +557,7 @@ void* destroyRelationInfo(SRelationInfo* pRelationInfo) {
   } else {
     size_t size = taosArrayGetSize(pRelationInfo->list);
     for(int32_t i = 0; i < size; ++i) {
-      SArray* pa = taosArrayGetP(pRelationInfo->list, 0);
+      SArray* pa = taosArrayGetP(pRelationInfo->list, i);
       destroyAllSqlNode(pa);
     }
     taosArrayDestroy(pRelationInfo->list);
@@ -625,7 +586,6 @@ SRelationInfo* addSubqueryElem(SRelationInfo* pRelationInfo, SArray* pSub, SStrT
   return pRelationInfo;
 }
 
-
 void tSetDbName(SStrToken *pCpxName, SStrToken *pDb) {
   pCpxName->type = pDb->type;
   pCpxName->z = pDb->z;
@@ -766,9 +726,9 @@ void tSetColumnType(TAOS_FIELD *pField, SStrToken *type) {
  * extract the select info out of sql string
  */
 SSqlNode *tSetQuerySqlNode(SStrToken *pSelectToken, SArray *pSelNodeList, SRelationInfo *pFrom, tSqlExpr *pWhere,
-                                SArray *pGroupby, SArray *pSortOrder, SIntervalVal *pInterval,
-                                SSessionWindowVal *pSession, SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit,
-                                SLimitVal *psLimit, tSqlExpr *pHaving) {
+                           SArray *pGroupby, SArray *pSortOrder, SIntervalVal *pInterval, SSessionWindowVal *pSession,
+                           SStrToken *pSliding, SArray *pFill, SLimitVal *pLimit, SLimitVal *psLimit,
+                           tSqlExpr *pHaving) {
   assert(pSelNodeList != NULL);
 
   SSqlNode *pSqlNode = calloc(1, sizeof(SSqlNode));

From a901745a032b071ee3f0e1b165643cf242717ef1 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 11 May 2021 20:10:44 +0800
Subject: [PATCH 020/128] [td-225] refactor.

---
 src/client/src/tscSQLParser.c | 8 ++++++++
 src/client/src/tscServer.c    | 2 +-
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 39a4ff2239..e2d582515c 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -7164,6 +7164,7 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   int32_t numOfTables = taosArrayGetSize(tableNameList);
   STableMeta* pTableMeta = calloc(1, maxSize);
 
+  SArray* plist = taosArrayInit(4, sizeof(SName));
   for(int32_t i = 0; i < numOfTables; ++i) {
     SName* pname = taosArrayGet(tableNameList, i);
     tNameExtractFullName(pname, name);
@@ -7183,9 +7184,16 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
       STableMeta* pMeta = tscTableMetaDup(pTableMeta);
       taosHashPut(pCmd->pTableMetaMap, name, strlen(name), &pMeta, POINTER_BYTES);
+    } else {// add to the retrieve table meta array list.
+      taosArrayPush(plist, pname);
     }
   }
 
+  // load the table meta for a given table name list
+  if (taosArrayGetSize(plist) > 0) {
+    doGetTableMetaFromMnode();
+  }
+
 //  return getTableMetaFromMnode(pSql, pTableMetaInfo);
   return TSDB_CODE_SUCCESS;
 }
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 4e4ed1bcf0..0aae068416 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -2411,7 +2411,7 @@ static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaIn
   }
 
   STableMetaInfo *pNewMeterMetaInfo = tscAddEmptyMetaInfo(pNewQueryInfo);
-  assert(/*pNew->cmd.numOfClause == 1 && */pNewQueryInfo->numOfTables == 1);
+  assert(pNewQueryInfo->numOfTables == 1);
 
   tNameAssign(&pNewMeterMetaInfo->name, &pTableMetaInfo->name);
 

From 6c4c8e37fdefcab94b0975ce317511b1aa2747b7 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Wed, 12 May 2021 10:14:49 +0800
Subject: [PATCH 021/128] [td-4151]<enhance>: improve the validation procedure
 of sql statement.

---
 src/client/inc/tscUtil.h      |   2 +
 src/client/src/tscSQLParser.c |  15 ++--
 src/client/src/tscServer.c    | 104 ++++++++++++++++++++--------
 src/client/src/tscSql.c       | 125 +++-------------------------------
 src/client/src/tscUtil.c      |  85 ++++++++++++++++++++++-
 src/inc/taosmsg.h             |   7 +-
 src/mnode/src/mnodeTable.c    |  64 +++++++++++------
 7 files changed, 231 insertions(+), 171 deletions(-)

diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index eb607f040d..79220efb1a 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -305,6 +305,8 @@ void tscTryQueryNextVnode(SSqlObj *pSql, __async_cb_func_t fp);
 void tscAsyncQuerySingleRowForNextVnode(void *param, TAOS_RES *tres, int numOfRows);
 void tscTryQueryNextClause(SSqlObj* pSql, __async_cb_func_t fp);
 int  tscSetMgmtEpSetFromCfg(const char *first, const char *second, SRpcCorEpSet *corEpSet);
+int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, bool loadVgroupInfo);
+int tscTransferTableNameList(SSqlObj *pSql, const char *pNameList, int32_t length);
 
 bool tscSetSqlOwner(SSqlObj* pSql);
 void tscClearSqlOwner(SSqlObj* pSql);
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index e2d582515c..06bf90a122 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -7127,6 +7127,10 @@ static int32_t getTableNameFromSubquery(SSqlNode* pSqlNode, SArray* tableNameLis
   return TSDB_CODE_SUCCESS;
 }
 
+static void freeElem(void* p) {
+  tfree(p);
+}
+
 int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   SSqlCmd* pCmd = &pSql->cmd;
 
@@ -7164,7 +7168,7 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   int32_t numOfTables = taosArrayGetSize(tableNameList);
   STableMeta* pTableMeta = calloc(1, maxSize);
 
-  SArray* plist = taosArrayInit(4, sizeof(SName));
+  SArray* plist = taosArrayInit(4, POINTER_BYTES);
   for(int32_t i = 0; i < numOfTables; ++i) {
     SName* pname = taosArrayGet(tableNameList, i);
     tNameExtractFullName(pname, name);
@@ -7185,16 +7189,19 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       STableMeta* pMeta = tscTableMetaDup(pTableMeta);
       taosHashPut(pCmd->pTableMetaMap, name, strlen(name), &pMeta, POINTER_BYTES);
     } else {// add to the retrieve table meta array list.
-      taosArrayPush(plist, pname);
+      char* t = strdup(name);
+      taosArrayPush(plist, &t);
     }
   }
 
   // load the table meta for a given table name list
   if (taosArrayGetSize(plist) > 0) {
-    doGetTableMetaFromMnode();
+    int32_t code = getMultiTableMetaFromMnode(pSql, plist, true);
+    taosArrayDestroyEx(plist, freeElem);
+
+    return code;
   }
 
-//  return getTableMetaFromMnode(pSql, pTableMetaInfo);
   return TSDB_CODE_SUCCESS;
 }
 
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 0aae068416..1c4e924d02 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -1719,44 +1719,36 @@ int tscBuildTableMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
 /**
  *  multi table meta req pkg format:
- *  | SMgmtHead | SMultiTableInfoMsg | tableId0 | tableId1 | tableId2 | ......
- *      no used         4B
+ *  |SMultiTableInfoMsg | tableId0 | tableId1 | tableId2 | ......
+ *      4B
  **/
-int tscBuildMultiMeterMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
-#if 0
+int tscBuildMultiTableMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
 
-  // copy payload content to temp buff
-  char *tmpData = 0;
-  if (pCmd->payloadLen > 0) {
-    if ((tmpData = calloc(1, pCmd->payloadLen + 1)) == NULL) return -1;
-    memcpy(tmpData, pCmd->payload, pCmd->payloadLen);
-  }
+  // copy payload content to temp buf
+//  char *tmpData = 0;
+//  if (pCmd->payloadLen > 0) {
+//    if ((tmpData = calloc(1, pCmd->payloadLen + 1)) == NULL) return -1;
+//    memcpy(tmpData, pCmd->payload, pCmd->payloadLen);
+//  }
 
-  // fill head info
-  SMgmtHead *pMgmt = (SMgmtHead *)(pCmd->payload + tsRpcHeadSize);
-  memset(pMgmt->db, 0, TSDB_TABLE_FNAME_LEN);  // server don't need the db
+//  SMultiTableInfoMsg *pInfoMsg = (SMultiTableInfoMsg *)(pCmd->payload);
+//  pInfoMsg->numOfTables = htonl((int32_t)pCmd->count);
+//
+//  if (pCmd->payloadLen > 0) {
+//    memcpy(pInfoMsg->tableIds, tmpData, pCmd->payloadLen);
+//  }
+//
+//  tfree(tmpData);
 
-  SMultiTableInfoMsg *pInfoMsg = (SMultiTableInfoMsg *)(pCmd->payload + tsRpcHeadSize + sizeof(SMgmtHead));
-  pInfoMsg->numOfTables = htonl((int32_t)pCmd->count);
-
-  if (pCmd->payloadLen > 0) {
-    memcpy(pInfoMsg->tableIds, tmpData, pCmd->payloadLen);
-  }
-
-  tfree(tmpData);
-
-  pCmd->payloadLen += sizeof(SMgmtHead) + sizeof(SMultiTableInfoMsg);
+//  pCmd->payloadLen += sizeof(SMgmtHead) + sizeof(SMultiTableInfoMsg);
   pCmd->msgType = TSDB_MSG_TYPE_CM_TABLES_META;
-
   assert(pCmd->payloadLen + minMsgSize() <= pCmd->allocSize);
 
-  tscDebug("0x%"PRIx64" build load multi-metermeta msg completed, numOfTables:%d, msg size:%d", pSql->self, pCmd->count,
+  tscDebug("0x%"PRIx64" build load multi-tablemeta msg completed, numOfTables:%d, msg size:%d", pSql->self, pCmd->count,
            pCmd->payloadLen);
 
   return pCmd->payloadLen;
-#endif
-  return 0;  
 }
 
 int tscBuildSTableVgroupMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
@@ -2443,6 +2435,63 @@ static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaIn
   return code;
 }
 
+int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, bool loadVgroupInfo) {
+  SSqlObj *pNew = calloc(1, sizeof(SSqlObj));
+  if (NULL == pNew) {
+    tscError("0x%"PRIx64" failed to allocate sqlobj to get multiple table meta", pSql->self);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  pNew->pTscObj     = pSql->pTscObj;
+  pNew->signature   = pNew;
+  pNew->cmd.command = TSDB_SQL_MULTI_META;
+
+  int32_t numOfTables = taosArrayGetSize(pNameList);
+  int32_t size = numOfTables * TSDB_TABLE_FNAME_LEN + sizeof(SMultiTableInfoMsg);
+  if (TSDB_CODE_SUCCESS != tscAllocPayload(&pNew->cmd, size)) {
+    tscError("0x%"PRIx64" malloc failed for payload to get table meta", pSql->self);
+    tscFreeSqlObj(pNew);
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  SMultiTableInfoMsg* pInfo = (SMultiTableInfoMsg*) pNew->cmd.payload;
+  pInfo->loadVgroup = htonl(loadVgroupInfo? 1:0);
+  pInfo->numOfTables = htonl(numOfTables);
+
+  char* start = pInfo->tableNames;
+  int32_t len = 0;
+  for(int32_t i = 0; i < numOfTables; ++i) {
+    char* name = taosArrayGetP(pNameList, i);
+    if (i < numOfTables - 1) {
+      len = sprintf(start, "%s,", name);
+    } else {
+      len = sprintf(start, "%s", name);
+    }
+
+    start += len;
+  }
+
+  pNew->cmd.payloadLen = (start - pInfo->tableNames) + sizeof(SMultiTableInfoMsg);
+  pNew->cmd.msgType = TSDB_MSG_TYPE_CM_TABLES_META;
+
+  registerSqlObj(pNew);
+  tscDebug("0x%"PRIx64" new pSqlObj:0x%"PRIx64" to get %d tableMeta, loadVgroup:%d, msg size:%d", pSql->self,
+      pNew->self, numOfTables, loadVgroupInfo, pNew->cmd.payloadLen);
+
+  pNew->fp = tscTableMetaCallBack;
+  pNew->param = (void *)pSql->self;
+
+  tscDebug("0x%"PRIx64" metaRid from %" PRId64 " to %" PRId64 , pSql->self, pSql->metaRid, pNew->self);
+
+  pSql->metaRid = pNew->self;
+  int32_t code = tscBuildAndSendRequest(pNew, NULL);
+  if (code == TSDB_CODE_SUCCESS) {
+    code = TSDB_CODE_TSC_ACTION_IN_PROGRESS;  // notify application that current process needs to be terminated
+  }
+
+  return code;
+}
+
 int32_t tscGetTableMeta(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
   assert(tIsValidName(&pTableMetaInfo->name));
 
@@ -2604,7 +2653,6 @@ void tscInitMsgsFp() {
   tscBuildMsg[TSDB_SQL_USE_DB] = tscBuildUseDbMsg;
   tscBuildMsg[TSDB_SQL_META] = tscBuildTableMetaMsg;
   tscBuildMsg[TSDB_SQL_STABLEVGROUP] = tscBuildSTableVgroupMsg;
-  tscBuildMsg[TSDB_SQL_MULTI_META] = tscBuildMultiMeterMetaMsg;
 
   tscBuildMsg[TSDB_SQL_HB] = tscBuildHeartBeatMsg;
   tscBuildMsg[TSDB_SQL_SHOW] = tscBuildShowMsg;
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index 3013b261df..8e89198952 100644
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -924,92 +924,6 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
   return code;
 }
 
-static int tscParseTblNameList(SSqlObj *pSql, const char *tblNameList, int32_t tblListLen) {
-  // must before clean the sqlcmd object
-  tscResetSqlCmd(&pSql->cmd, false);
-
-  SSqlCmd *pCmd = &pSql->cmd;
-
-  pCmd->command = TSDB_SQL_MULTI_META;
-  pCmd->count = 0;
-
-  int   code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
-  char *str = (char *)tblNameList;
-
-  SQueryInfo *pQueryInfo = tscGetQueryInfoS(pCmd, pCmd->clauseIndex);
-  if (pQueryInfo == NULL) {
-    pSql->res.code = terrno;
-    return terrno;
-  }
-
-  STableMetaInfo *pTableMetaInfo = tscAddEmptyMetaInfo(pQueryInfo);
-
-  if ((code = tscAllocPayload(pCmd, tblListLen + 16)) != TSDB_CODE_SUCCESS) {
-    return code;
-  }
-
-  char *nextStr;
-  char  tblName[TSDB_TABLE_FNAME_LEN];
-  int   payloadLen = 0;
-  char *pMsg = pCmd->payload;
-  while (1) {
-    nextStr = strchr(str, ',');
-    if (nextStr == NULL) {
-      break;
-    }
-
-    memcpy(tblName, str, nextStr - str);
-    int32_t len = (int32_t)(nextStr - str);
-    tblName[len] = '\0';
-
-    str = nextStr + 1;
-    len = (int32_t)strtrim(tblName);
-
-    SStrToken sToken = {.n = len, .type = TK_ID, .z = tblName};
-    tSQLGetToken(tblName, &sToken.type);
-
-    // Check if the table name available or not
-    if (tscValidateName(&sToken) != TSDB_CODE_SUCCESS) {
-      code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
-      sprintf(pCmd->payload, "table name is invalid");
-      return code;
-    }
-
-    if ((code = tscSetTableFullName(&pTableMetaInfo->name, &sToken, pSql)) != TSDB_CODE_SUCCESS) {
-      return code;
-    }
-
-    if (++pCmd->count > TSDB_MULTI_TABLEMETA_MAX_NUM) {
-      code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
-      sprintf(pCmd->payload, "tables over the max number");
-      return code;
-    }
-
-    int32_t xlen = tNameLen(&pTableMetaInfo->name);
-    if (payloadLen + xlen + 128 >= pCmd->allocSize) {
-      char *pNewMem = realloc(pCmd->payload, pCmd->allocSize + tblListLen);
-      if (pNewMem == NULL) {
-        code = TSDB_CODE_TSC_OUT_OF_MEMORY;
-        sprintf(pCmd->payload, "failed to allocate memory");
-        return code;
-      }
-
-      pCmd->payload = pNewMem;
-      pCmd->allocSize = pCmd->allocSize + tblListLen;
-      pMsg = pCmd->payload;
-    }
-
-    char n[TSDB_TABLE_FNAME_LEN] = {0};
-    tNameExtractFullName(&pTableMetaInfo->name, n);
-    payloadLen += sprintf(pMsg + payloadLen, "%s,", n);
-  }
-
-  *(pMsg + payloadLen) = '\0';
-  pCmd->payloadLen = payloadLen + 1;
-
-  return TSDB_CODE_SUCCESS;
-}
-
 int taos_load_table_info(TAOS *taos, const char *tableNameList) {
   const int32_t MAX_TABLE_NAME_LENGTH = 12 * 1024 * 1024;  // 12MB list
 
@@ -1022,52 +936,33 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
   SSqlObj* pSql = calloc(1, sizeof(SSqlObj));
   pSql->pTscObj = taos;
   pSql->signature = pSql;
+  pSql->fp = NULL;        // todo set the correct callback function pointer
 
-  SSqlRes *pRes = &pSql->res;
-
-  pRes->code = 0;
-  pRes->numOfTotal = 0;  // the number of getting table meta from server
-  pRes->numOfClauseTotal = 0;
-
-  assert(pSql->fp == NULL);
-  tscDebug("0x%"PRIx64" tableNameList: %s pObj:%p", pSql->self, tableNameList, pObj);
-
-  int32_t tblListLen = (int32_t)strlen(tableNameList);
-  if (tblListLen > MAX_TABLE_NAME_LENGTH) {
-    tscError("0x%"PRIx64" tableNameList too long, length:%d, maximum allowed:%d", pSql->self, tblListLen, MAX_TABLE_NAME_LENGTH);
+  int32_t length = (int32_t)strlen(tableNameList);
+  if (length > MAX_TABLE_NAME_LENGTH) {
+    tscError("0x%"PRIx64" tableNameList too long, length:%d, maximum allowed:%d", pSql->self, length, MAX_TABLE_NAME_LENGTH);
     tscFreeSqlObj(pSql);
     return TSDB_CODE_TSC_INVALID_SQL;
   }
 
-  char *str = calloc(1, tblListLen + 1);
+  char *str = calloc(1, length + 1);
   if (str == NULL) {
-    tscError("0x%"PRIx64" failed to malloc sql string buffer", pSql->self);
+    tscError("0x%"PRIx64" failed to allocate sql string buffer", pSql->self);
     tscFreeSqlObj(pSql);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
   strtolower(str, tableNameList);
-  int32_t code = (uint8_t) tscParseTblNameList(pSql, str, tblListLen);
+  int32_t code = (uint8_t) tscTransferTableNameList(pSql, str, length);
 
-  /*
-   * set the qhandle to 0 before return in order to erase the qhandle value assigned in the previous successful query.
-   * If qhandle is NOT set 0, the function of taos_free_result() will send message to server by calling tscBuildAndSendRequest()
-   * to free connection, which may cause segment fault, when the parse phrase is not even successfully executed.
-   */
-  pRes->qId = 0;
   free(str);
-
   if (code != TSDB_CODE_SUCCESS) {
     tscFreeSqlObj(pSql);
     return code;
   }
 
-  tscDoQuery(pSql);
-
-  tscDebug("0x%"PRIx64" load multi-table meta result:%d %s pObj:%p", pSql->self, pRes->code, taos_errstr(pSql), pObj);
-  if ((code = pRes->code) != TSDB_CODE_SUCCESS) {
-    tscFreeSqlObj(pSql);
-  }
-
+  registerSqlObj(pSql);
+  tscDebug("0x%"PRIx64" load multiple table meta, tableNameList: %s pObj:%p", pSql->self, tableNameList, pObj);
+  executeQuery(pSql, NULL);
   return code;
 }
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 02a0d10124..efeb776ecf 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -2352,7 +2352,6 @@ int32_t tscAddQueryInfo(SSqlCmd* pCmd) {
   }
 
   pCmd->active = pQueryInfo;
-//  pCmd->pQueryInfo[pCmd->numOfClause++] = pQueryInfo;
   return TSDB_CODE_SUCCESS;
 }
 
@@ -3737,3 +3736,87 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
 
   return TSDB_CODE_SUCCESS;
 }
+
+int tscTransferTableNameList(SSqlObj *pSql, const char *pNameList, int32_t length) {
+  SSqlCmd *pCmd = &pSql->cmd;
+
+  pCmd->command = TSDB_SQL_MULTI_META;
+  pCmd->count = 0;
+
+  int   code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
+  char *str = (char *)pNameList;
+
+  SQueryInfo *pQueryInfo = tscGetQueryInfoS(pCmd, pCmd->clauseIndex);
+  if (pQueryInfo == NULL) {
+    pSql->res.code = terrno;
+    return terrno;
+  }
+
+  STableMetaInfo *pTableMetaInfo = tscAddEmptyMetaInfo(pQueryInfo);
+
+  if ((code = tscAllocPayload(pCmd, length + 16)) != TSDB_CODE_SUCCESS) {
+    return code;
+  }
+
+  char *nextStr;
+  char  tblName[TSDB_TABLE_FNAME_LEN];
+  int   payloadLen = 0;
+  char *pMsg = pCmd->payload;
+  while (1) {
+    nextStr = strchr(str, ',');
+    if (nextStr == NULL) {
+      break;
+    }
+
+    memcpy(tblName, str, nextStr - str);
+    int32_t len = (int32_t)(nextStr - str);
+    tblName[len] = '\0';
+
+    str = nextStr + 1;
+    len = (int32_t)strtrim(tblName);
+
+    SStrToken sToken = {.n = len, .type = TK_ID, .z = tblName};
+    tSQLGetToken(tblName, &sToken.type);
+
+    // Check if the table name available or not
+    if (tscValidateName(&sToken) != TSDB_CODE_SUCCESS) {
+      code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
+      sprintf(pCmd->payload, "table name is invalid");
+      return code;
+    }
+
+    if ((code = tscSetTableFullName(&pTableMetaInfo->name, &sToken, pSql)) != TSDB_CODE_SUCCESS) {
+      return code;
+    }
+
+    if (++pCmd->count > TSDB_MULTI_TABLEMETA_MAX_NUM) {
+      code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
+      sprintf(pCmd->payload, "tables over the max number");
+      return code;
+    }
+
+    int32_t xlen = tNameLen(&pTableMetaInfo->name);
+    if (payloadLen + xlen + 128 >= pCmd->allocSize) {
+      char *pNewMem = realloc(pCmd->payload, pCmd->allocSize + length);
+      if (pNewMem == NULL) {
+        code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+        sprintf(pCmd->payload, "failed to allocate memory");
+        return code;
+      }
+
+      pCmd->payload = pNewMem;
+      pCmd->allocSize = pCmd->allocSize + length;
+      pMsg = pCmd->payload;
+    }
+
+    char n[TSDB_TABLE_FNAME_LEN] = {0};
+    tNameExtractFullName(&pTableMetaInfo->name, n);
+    payloadLen += sprintf(pMsg + payloadLen, "%s,", n);
+  }
+
+  *(pMsg + payloadLen) = '\0';
+  pCmd->payloadLen = payloadLen + 1;
+
+  return TSDB_CODE_SUCCESS;
+}
+
diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h
index 3b7022fb88..8c47896a34 100644
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
@@ -84,7 +84,7 @@ TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_DROP_TABLE, "drop-table" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_ALTER_TABLE, "alter-table" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_TABLE_META, "table-meta" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_STABLE_VGROUP, "stable-vgroup" )
-TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_TABLES_META, "tables-meta" )	  
+TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_TABLES_META, "multiTable-meta" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_ALTER_STREAM, "alter-stream" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_SHOW, "show" )
 TAOS_DEFINE_MESSAGE_TYPE( TSDB_MSG_TYPE_CM_RETRIEVE, "retrieve" )     
@@ -703,8 +703,9 @@ typedef struct {
 } STableInfoMsg;
 
 typedef struct {
+  int32_t loadVgroup;
   int32_t numOfTables;
-  char    tableIds[];
+  char    tableNames[];
 } SMultiTableInfoMsg;
 
 typedef struct SSTableVgroupMsg {
@@ -754,7 +755,7 @@ typedef struct STableMetaMsg {
 typedef struct SMultiTableMeta {
   int32_t       numOfTables;
   int32_t       contLen;
-  char          metas[];
+  char          meta[];
 } SMultiTableMeta;
 
 typedef struct {
diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index 2a8e941fcb..0f08ec478a 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -1674,12 +1674,9 @@ static int32_t mnodeSetSchemaFromSuperTable(SSchema *pSchema, SSTableObj *pTable
   return (pTable->numOfColumns + pTable->numOfTags) * sizeof(SSchema);
 }
 
-static int32_t mnodeGetSuperTableMeta(SMnodeMsg *pMsg) {
+static int32_t mnodeDoGetSuperTableMeta(SMnodeMsg *pMsg, STableMetaMsg* pMeta) {
   SSTableObj *pTable = (SSTableObj *)pMsg->pTable;
-  STableMetaMsg *pMeta   = rpcMallocCont(sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16));
-  if (pMeta == NULL) {
-    return TSDB_CODE_MND_OUT_OF_MEMORY;
-  }
+
   pMeta->uid          = htobe64(pTable->uid);
   pMeta->sversion     = htons(pTable->sversion);
   pMeta->tversion     = htons(pTable->tversion);
@@ -1690,6 +1687,18 @@ static int32_t mnodeGetSuperTableMeta(SMnodeMsg *pMsg) {
   pMeta->contLen      = sizeof(STableMetaMsg) + mnodeSetSchemaFromSuperTable(pMeta->schema, pTable);
   tstrncpy(pMeta->tableFname, pTable->info.tableId, sizeof(pMeta->tableFname));
 
+  return TSDB_CODE_SUCCESS;
+}
+
+static int32_t mnodeGetSuperTableMeta(SMnodeMsg *pMsg) {
+  SSTableObj *pTable = (SSTableObj *)pMsg->pTable;
+  STableMetaMsg *pMeta   = rpcMallocCont(sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16));
+  if (pMeta == NULL) {
+    return TSDB_CODE_MND_OUT_OF_MEMORY;
+  }
+
+  mnodeDoGetSuperTableMeta(pMsg, pMeta);
+
   pMsg->rpcRsp.len = pMeta->contLen;
   pMeta->contLen = htons(pMeta->contLen);
 
@@ -2417,7 +2426,7 @@ static int32_t mnodeDoGetChildTableMeta(SMnodeMsg *pMsg, STableMetaMsg *pMeta) {
   }
   pMeta->vgroup.vgId = htonl(pMsg->pVgroup->vgId);
 
-  mDebug("msg:%p, app:%p table:%s, uid:%" PRIu64 " table meta is retrieved, vgId:%d sid:%d", pMsg, pMsg->rpcMsg.ahandle,
+  mDebug("msg:%p, app:%p table:%s, uid:%" PRIu64 " table meta is retrieved, vgId:%d tid:%d", pMsg, pMsg->rpcMsg.ahandle,
          pTable->info.tableId, pTable->uid, pTable->vgId, pTable->tid);
 
   return TSDB_CODE_SUCCESS;
@@ -2809,11 +2818,15 @@ static void mnodeProcessAlterTableRsp(SRpcMsg *rpcMsg) {
   }
 }
 
+//TODO. set the vgroup info for the super table
 static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
   SMultiTableInfoMsg *pInfo = pMsg->rpcMsg.pCont;
   pInfo->numOfTables = htonl(pInfo->numOfTables);
+  pInfo->loadVgroup = htonl(pInfo->loadVgroup);
+
+  // first malloc 4KB, subsequent reallocation will expand the size as twice of the original size
+  int32_t totalMallocLen = 4 * 1024;
 
-  int32_t totalMallocLen = 4 * 1024 * 1024;  // first malloc 4 MB, subsequent reallocation as twice
   SMultiTableMeta *pMultiMeta = rpcMallocCont(totalMallocLen);
   if (pMultiMeta == NULL) {
     return TSDB_CODE_MND_OUT_OF_MEMORY;
@@ -2823,13 +2836,21 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
   pMultiMeta->numOfTables = 0;
 
   for (int32_t t = 0; t < pInfo->numOfTables; ++t) {
-    char * tableId = (char *)(pInfo->tableIds + t * TSDB_TABLE_FNAME_LEN);
-    SCTableObj *pTable = mnodeGetChildTable(tableId);
-    if (pTable == NULL) continue;
+    char *fullName = (char *)(pInfo->tableNames + t * TSDB_TABLE_FNAME_LEN);
+
+    if (pMsg->pTable == NULL) {
+      pMsg->pTable = mnodeGetTable(fullName);
+      if (pMsg->pTable == NULL) {  // TODO: return error to client?
+        continue;
+      }
+    }
+
+    if (pMsg->pDb == NULL) {
+      pMsg->pDb = mnodeGetDbByTableName(fullName);
+    }
 
-    if (pMsg->pDb == NULL) pMsg->pDb = mnodeGetDbByTableName(tableId);
     if (pMsg->pDb == NULL || pMsg->pDb->status != TSDB_DB_STATUS_READY) {
-      mnodeDecTableRef(pTable);
+      mnodeDecTableRef(pMsg->pTable);  // TODO: return error to client?
       continue;
     }
 
@@ -2838,23 +2859,26 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
       totalMallocLen *= 2;
       pMultiMeta = rpcReallocCont(pMultiMeta, totalMallocLen);
       if (pMultiMeta == NULL) {
-        mnodeDecTableRef(pTable);
+        mnodeDecTableRef(pMsg->pTable);
         return TSDB_CODE_MND_OUT_OF_MEMORY;
-      } else {
-        t--;
-        mnodeDecTableRef(pTable);
-        continue;
       }
     }
 
-    STableMetaMsg *pMeta = (STableMetaMsg *)(pMultiMeta->metas + pMultiMeta->contLen);
-    int32_t code = mnodeDoGetChildTableMeta(pMsg, pMeta);
+    STableMetaMsg *pMeta = (STableMetaMsg *)(pMultiMeta->meta + pMultiMeta->contLen);
+
+    int32_t code = 0;
+    if (pMsg->pTable->type != TSDB_SUPER_TABLE) {
+      code = mnodeDoGetChildTableMeta(pMsg, pMeta);
+    } else {
+      code = mnodeDoGetSuperTableMeta(pMsg, pMeta);
+    }
+
     if (code == TSDB_CODE_SUCCESS) {
       pMultiMeta->numOfTables ++;
       pMultiMeta->contLen += pMeta->contLen;
     }
 
-    mnodeDecTableRef(pTable);
+    mnodeDecTableRef(pMsg->pTable);
   }
 
   pMsg->rpcRsp.rsp = pMultiMeta;

From c62e0360425278c178e065b8e952da910e6d5d27 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Wed, 12 May 2021 19:45:39 +0800
Subject: [PATCH 022/128] [td-4151]

---
 src/client/src/tscSQLParser.c |  18 ++-
 src/client/src/tscServer.c    | 226 +++++++++++++++-------------------
 src/inc/taosmsg.h             |   1 +
 src/mnode/src/mnodeTable.c    | 211 ++++++++++++++++++++++---------
 4 files changed, 260 insertions(+), 196 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 06bf90a122..2f22727521 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -619,7 +619,10 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
     case TSDB_SQL_SELECT: {
       const char* msg1 = "columns in select clause not identical";
-      loadAllTableMeta(pSql, pInfo);
+      int32_t code = loadAllTableMeta(pSql, pInfo);
+      if (code != TSDB_CODE_SUCCESS) {
+        return code;
+      }
 
       SQueryInfo* pCurrent = pCmd->pQueryInfo;
       for(int32_t i = 0; i < pCmd->clauseIndex; ++i) {
@@ -7128,7 +7131,7 @@ static int32_t getTableNameFromSubquery(SSqlNode* pSqlNode, SArray* tableNameLis
 }
 
 static void freeElem(void* p) {
-  tfree(p);
+  tfree(*(char**)p);
 }
 
 int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
@@ -7252,7 +7255,10 @@ static int32_t doLoadAllTableMeta(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNod
       strncpy(pTableMetaInfo->aliasName, tNameGetTableName(&pTableMetaInfo->name), tListLen(pTableMetaInfo->aliasName));
     }
 
-    code = tscGetTableMeta(pSql, pTableMetaInfo);
+    const char* name = tNameGetTableName(&pTableMetaInfo->name);
+    pTableMetaInfo->pTableMeta = taosHashGet(pCmd->pTableMetaMap, name, strlen(name));
+    assert(pTableMetaInfo->pTableMeta != NULL);
+
     if (code != TSDB_CODE_SUCCESS) {
       return code;
     }
@@ -7376,13 +7382,13 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
   } else {
     pQueryInfo->command = TSDB_SQL_SELECT;
 
-    size_t fromSize = taosArrayGetSize(pSqlNode->from->list);
-    if (fromSize > TSDB_MAX_JOIN_TABLE_NUM) {
+    size_t numOfTables = taosArrayGetSize(pSqlNode->from->list);
+    if (numOfTables > TSDB_MAX_JOIN_TABLE_NUM) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
     }
 
     // set all query tables, which are maybe more than one.
-    code = doLoadAllTableMeta(pSql, pQueryInfo, pSqlNode, (int32_t) fromSize);
+    code = doLoadAllTableMeta(pSql, pQueryInfo, pSqlNode, (int32_t) numOfTables);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
     }
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 1c4e924d02..23ae03bdc3 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -1822,18 +1822,16 @@ int tscBuildHeartBeatMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   return TSDB_CODE_SUCCESS;
 }
 
-int tscProcessTableMetaRsp(SSqlObj *pSql) {
-  STableMetaMsg *pMetaMsg = (STableMetaMsg *)pSql->res.pRsp;
-
+static int32_t tableMetaMsgConvert(STableMetaMsg* pMetaMsg) {
   pMetaMsg->tid = htonl(pMetaMsg->tid);
   pMetaMsg->sversion = htons(pMetaMsg->sversion);
   pMetaMsg->tversion = htons(pMetaMsg->tversion);
   pMetaMsg->vgroup.vgId = htonl(pMetaMsg->vgroup.vgId);
-  
+
   pMetaMsg->uid = htobe64(pMetaMsg->uid);
   pMetaMsg->contLen = htons(pMetaMsg->contLen);
   pMetaMsg->numOfColumns = htons(pMetaMsg->numOfColumns);
-  
+
   if ((pMetaMsg->tableType != TSDB_SUPER_TABLE) &&
       (pMetaMsg->tid <= 0 || pMetaMsg->vgroup.vgId < 2 || pMetaMsg->vgroup.numOfEps <= 0)) {
     tscError("invalid value in table numOfEps:%d, vgId:%d tid:%d, name:%s", pMetaMsg->vgroup.numOfEps, pMetaMsg->vgroup.vgId,
@@ -1868,21 +1866,34 @@ int tscProcessTableMetaRsp(SSqlObj *pSql) {
 
     pSchema++;
   }
-  
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0, 0);
-  assert(pTableMetaInfo->pTableMeta == NULL);
 
-  STableMeta* pTableMeta = tscCreateTableMetaFromMsg(pMetaMsg);
-  if (!tIsValidSchema(pTableMeta->schema, pTableMeta->tableInfo.numOfColumns, pTableMeta->tableInfo.numOfTags)) {
-    tscError("0x%"PRIx64" invalid table meta from mnode, name:%s", pSql->self, tNameGetTableName(&pTableMetaInfo->name));
-    return TSDB_CODE_TSC_INVALID_VALUE;
+  return TSDB_CODE_SUCCESS;
+}
+
+// update the vgroupInfo if needed
+static void doUpdateVgroupInfo(STableMeta *pTableMeta, SVgroupMsg *pVgroupMsg) {
+  if (pTableMeta->vgId > 0) {
+    int32_t vgId = pTableMeta->vgId;
+    assert(pTableMeta->tableType != TSDB_SUPER_TABLE);
+
+    SNewVgroupInfo vgroupInfo = {.inUse = -1};
+    taosHashGetClone(tscVgroupMap, &vgId, sizeof(vgId), NULL, &vgroupInfo, sizeof(SNewVgroupInfo));
+
+    // vgroup info exists, compare with it
+    if (((vgroupInfo.inUse >= 0) && !vgroupInfoIdentical(&vgroupInfo, pVgroupMsg)) || (vgroupInfo.inUse < 0)) {
+      vgroupInfo = createNewVgroupInfo(pVgroupMsg);
+      taosHashPut(tscVgroupMap, &vgId, sizeof(vgId), &vgroupInfo, sizeof(vgroupInfo));
+      tscDebug("add new VgroupInfo, vgId:%d, total cached:%d", vgId, (int32_t) taosHashGetSize(tscVgroupMap));
+    }
   }
+}
 
+static void doAddTableMetaLocalBuf(STableMeta* pTableMeta, STableMetaMsg* pMetaMsg, bool updateSTable) {
   if (pTableMeta->tableType == TSDB_CHILD_TABLE) {
-    // check if super table hashmap or not
+    // add or update the corresponding super table meta data info
     int32_t len = (int32_t) strnlen(pTableMeta->sTableName, TSDB_TABLE_FNAME_LEN);
 
-    // super tableMeta data alreay exists, create it according to tableMeta and add it to hash map
+    // The super tableMeta already exists, create it according to tableMeta and add it to hash map
     STableMeta* pSupTableMeta = createSuperTableMeta(pMetaMsg);
 
     uint32_t size = tscGetTableMetaSize(pSupTableMeta);
@@ -1892,37 +1903,37 @@ int tscProcessTableMetaRsp(SSqlObj *pSql) {
     tfree(pSupTableMeta);
 
     CChildTableMeta* cMeta = tscCreateChildMeta(pTableMeta);
-
-    char name[TSDB_TABLE_FNAME_LEN] = {0};
-    tNameExtractFullName(&pTableMetaInfo->name, name);
-
-    taosHashPut(tscTableMetaInfo, name, strlen(name), cMeta, sizeof(CChildTableMeta));
+    taosHashPut(tscTableMetaInfo, pMetaMsg->tableFname, strlen(pMetaMsg->tableFname), cMeta, sizeof(CChildTableMeta));
     tfree(cMeta);
   } else {
     uint32_t s = tscGetTableMetaSize(pTableMeta);
+    taosHashPut(tscTableMetaInfo, pMetaMsg->tableFname, strlen(pMetaMsg->tableFname), pTableMeta, s);
+  }
+}
 
-    char name[TSDB_TABLE_FNAME_LEN] = {0};
-    tNameExtractFullName(&pTableMetaInfo->name, name);
-
-    taosHashPut(tscTableMetaInfo, name, strlen(name), pTableMeta, s);
+int tscProcessTableMetaRsp(SSqlObj *pSql) {
+  STableMetaMsg *pMetaMsg = (STableMetaMsg *)pSql->res.pRsp;
+  int32_t code = tableMetaMsgConvert(pMetaMsg);
+  if (code != TSDB_CODE_SUCCESS) {
+    return code;
   }
 
-  // update the vgroupInfo if needed
-  if (pTableMeta->vgId > 0) {
-    int32_t vgId = pTableMeta->vgId;
-    assert(pTableMeta->tableType != TSDB_SUPER_TABLE);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0, 0);
+  assert(pTableMetaInfo->pTableMeta == NULL);
 
-    SNewVgroupInfo vgroupInfo = {.inUse = -1};
-    taosHashGetClone(tscVgroupMap, &vgId, sizeof(vgId), NULL, &vgroupInfo, sizeof(SNewVgroupInfo));
-
-    if (((vgroupInfo.inUse >= 0) && !vgroupInfoIdentical(&vgroupInfo, &pMetaMsg->vgroup)) ||
-        (vgroupInfo.inUse < 0)) {  // vgroup info exists, compare with it
-      vgroupInfo = createNewVgroupInfo(&pMetaMsg->vgroup);
-      taosHashPut(tscVgroupMap, &vgId, sizeof(vgId), &vgroupInfo, sizeof(vgroupInfo));
-      tscDebug("add new VgroupInfo, vgId:%d, total cached:%d", vgId, (int32_t) taosHashGetSize(tscVgroupMap));
-    }
+  STableMeta* pTableMeta = tscCreateTableMetaFromMsg(pMetaMsg);
+  if (!tIsValidSchema(pTableMeta->schema, pTableMeta->tableInfo.numOfColumns, pTableMeta->tableInfo.numOfTags)) {
+    tscError("0x%"PRIx64" invalid table meta from mnode, name:%s", pSql->self, tNameGetTableName(&pTableMetaInfo->name));
+    return TSDB_CODE_TSC_INVALID_VALUE;
   }
 
+  char name[TSDB_TABLE_FNAME_LEN] = {0};
+  tNameExtractFullName(&pTableMetaInfo->name, name);
+  assert(strncmp(pMetaMsg->tableFname, name, tListLen(pMetaMsg->tableFname)) == 0);
+
+  doAddTableMetaLocalBuf(pTableMeta, pMetaMsg, true);
+  doUpdateVgroupInfo(pTableMeta, &pMetaMsg->vgroup);
+
   tscDebug("0x%"PRIx64" recv table meta, uid:%" PRIu64 ", tid:%d, name:%s", pSql->self, pTableMeta->id.uid, pTableMeta->id.tid,
            tNameGetTableName(&pTableMetaInfo->name));
 
@@ -1930,109 +1941,66 @@ int tscProcessTableMetaRsp(SSqlObj *pSql) {
   return TSDB_CODE_SUCCESS;
 }
 
-/**
+/*
  *  multi table meta rsp pkg format:
- *  | STaosRsp | SMultiTableInfoMsg | SMeterMeta0 | SSchema0 | SMeterMeta1 | SSchema1 | SMeterMeta2 | SSchema2
- *  |...... 1B                    4B
- **/
-int tscProcessMultiMeterMetaRsp(SSqlObj *pSql) {
-#if 0
+ *  | SMultiTableInfoMsg | SMeterMeta0 | SSchema0 | SMeterMeta1 | SSchema1 | SMeterMeta2 | SSchema2
+ *  | 4B
+ */
+int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
   char *rsp = pSql->res.pRsp;
 
-  ieType = *rsp;
-  if (ieType != TSDB_IE_TYPE_META) {
-    tscError("invalid ie type:%d", ieType);
-    pSql->res.code = TSDB_CODE_TSC_INVALID_IE;
-    pSql->res.numOfTotal = 0;
-    return TSDB_CODE_TSC_APP_ERROR;
-  }
+  SMultiTableMeta *pMultiMeta = (SMultiTableMeta *)rsp;
+  pMultiMeta->numOfTables = htonl(pMultiMeta->numOfTables);
 
-  rsp++;
+  rsp += sizeof(SMultiTableMeta);
 
-  SMultiTableInfoMsg *pInfo = (SMultiTableInfoMsg *)rsp;
-  totalNum = htonl(pInfo->numOfTables);
-  rsp += sizeof(SMultiTableInfoMsg);
+  SSqlObj* pParentSql = (SSqlObj*)taosAcquireRef(tscObjRef, (int64_t)pSql->param);
+  SSqlCmd *pParentCmd = &pParentSql->cmd;
 
-  for (i = 0; i < totalNum; i++) {
-    SMultiTableMeta *pMultiMeta = (SMultiTableMeta *)rsp;
-    STableMeta *     pMeta = pMultiMeta->metas;
+  SHashObj *pSet = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
 
-    pMeta->sid = htonl(pMeta->sid);
-    pMeta->sversion = htons(pMeta->sversion);
-    pMeta->vgId = htonl(pMeta->vgId);
-    pMeta->uid = htobe64(pMeta->uid);
-
-    if (pMeta->sid <= 0 || pMeta->vgId < 0) {
-      tscError("invalid meter vgId:%d, sid%d", pMeta->vgId, pMeta->sid);
-      pSql->res.code = TSDB_CODE_TSC_INVALID_VALUE;
-      pSql->res.numOfTotal = i;
-      return TSDB_CODE_TSC_APP_ERROR;
+  for (int32_t i = 0; i < pMultiMeta->numOfTables; i++) {
+    STableMetaMsg *pMetaMsg = (STableMetaMsg *)pMultiMeta->meta;
+    int32_t code = tableMetaMsgConvert(pMetaMsg);
+    if (code != TSDB_CODE_SUCCESS) {
+      return code;
     }
 
-    //    pMeta->numOfColumns = htons(pMeta->numOfColumns);
-    //
-    //    if (pMeta->numOfTags > TSDB_MAX_TAGS || pMeta->numOfTags < 0) {
-    //      tscError("invalid tag value count:%d", pMeta->numOfTags);
-    //      pSql->res.code = TSDB_CODE_TSC_INVALID_VALUE;
-    //      pSql->res.numOfTotal = i;
-    //      return TSDB_CODE_TSC_APP_ERROR;
-    //    }
-    //
-    //    if (pMeta->numOfTags > TSDB_MAX_TAGS || pMeta->numOfTags < 0) {
-    //      tscError("invalid numOfTags:%d", pMeta->numOfTags);
-    //      pSql->res.code = TSDB_CODE_TSC_INVALID_VALUE;
-    //      pSql->res.numOfTotal = i;
-    //      return TSDB_CODE_TSC_APP_ERROR;
-    //    }
-    //
-    //    if (pMeta->numOfColumns > TSDB_MAX_COLUMNS || pMeta->numOfColumns < 0) {
-    //      tscError("invalid numOfColumns:%d", pMeta->numOfColumns);
-    //      pSql->res.code = TSDB_CODE_TSC_INVALID_VALUE;
-    //      pSql->res.numOfTotal = i;
-    //      return TSDB_CODE_TSC_APP_ERROR;
-    //    }
-    //
-    //    for (int j = 0; j < TSDB_REPLICA_MAX_NUM; ++j) {
-    //      pMeta->vpeerDesc[j].vnode = htonl(pMeta->vpeerDesc[j].vnode);
-    //    }
-    //
-    //    pMeta->rowSize = 0;
-    //    rsp += sizeof(SMultiTableMeta);
-    //    pSchema = (SSchema *)rsp;
-    //
-    //    int32_t numOfTotalCols = pMeta->numOfColumns + pMeta->numOfTags;
-    //    for (int j = 0; j < numOfTotalCols; ++j) {
-    //      pSchema->bytes = htons(pSchema->bytes);
-    //      pSchema->colId = htons(pSchema->colId);
-    //
-    //      // ignore the tags length
-    //      if (j < pMeta->numOfColumns) {
-    //        pMeta->rowSize += pSchema->bytes;
-    //      }
-    //      pSchema++;
-    //    }
-    //
-    //    rsp += numOfTotalCols * sizeof(SSchema);
-    //
-    //    int32_t  tagLen = 0;
-    //    SSchema *pTagsSchema = tscGetTableTagSchema(pMeta);
-    //
-    //    if (pMeta->tableType == TSDB_CHILD_TABLE) {
-    //      for (int32_t j = 0; j < pMeta->numOfTags; ++j) {
-    //        tagLen += pTagsSchema[j].bytes;
-    //      }
-    //    }
-    //
-    //    rsp += tagLen;
-    //    int32_t size = (int32_t)(rsp - ((char *)pMeta));  // Consistent with STableMeta in cache
-    //  }
+    STableMeta* pTableMeta = tscCreateTableMetaFromMsg(pMetaMsg);
+    if (!tIsValidSchema(pTableMeta->schema, pTableMeta->tableInfo.numOfColumns, pTableMeta->tableInfo.numOfTags)) {
+      tscError("0x%"PRIx64" invalid table meta from mnode, name:%s", pSql->self, pMetaMsg->tableFname);
+      return TSDB_CODE_TSC_INVALID_VALUE;
+    }
+
+    int32_t t = tscGetTableMetaSize(pTableMeta);
+
+    SName sn = {0};
+    tNameFromString(&sn, pMetaMsg->tableFname, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+    const char* tableName = tNameGetTableName(&sn);
+    int32_t keyLen = strlen(tableName);
+    taosHashPut(pParentCmd->pTableMetaMap, tableName, keyLen, pTableMeta, t);
+
+    bool addToBuf = false;
+    if (taosHashGet(pSet, &pMetaMsg->uid, sizeof(pMetaMsg->uid)) == NULL) {
+      addToBuf = true;
+      taosHashPut(pSet, &pMetaMsg->uid, sizeof(pMetaMsg->uid), "", 0);
+    }
+
+    // create the tableMeta and add it into the TableMeta map
+    doAddTableMetaLocalBuf(pTableMeta, pMetaMsg, addToBuf);
+
+    // if the vgroup is not updated in current process, update it.
+    int64_t vgId = pMetaMsg->vgroup.vgId;
+    if (taosHashGet(pSet, &vgId, sizeof(vgId)) == NULL) {
+      doUpdateVgroupInfo(pTableMeta, &pMetaMsg->vgroup);
+      taosHashPut(pSet, &vgId, sizeof(vgId), "", 0);
+    }
   }
-  
+
   pSql->res.code = TSDB_CODE_SUCCESS;
-  pSql->res.numOfTotal = i;
-  tscDebug("0x%"PRIx64" load multi-metermeta resp from complete num:%d", pSql->self, pSql->res.numOfTotal);
-#endif
-  
+  pSql->res.numOfTotal = pMultiMeta->numOfTables;
+  tscDebug("0x%"PRIx64" load multi-tableMeta resp from complete numOfTables:%d", pSql->self, pMultiMeta->numOfTables);
+
   return TSDB_CODE_SUCCESS;
 }
 
@@ -2670,7 +2638,7 @@ void tscInitMsgsFp() {
   tscProcessMsgRsp[TSDB_SQL_USE_DB] = tscProcessUseDbRsp;
   tscProcessMsgRsp[TSDB_SQL_META] = tscProcessTableMetaRsp;
   tscProcessMsgRsp[TSDB_SQL_STABLEVGROUP] = tscProcessSTableVgroupRsp;
-  tscProcessMsgRsp[TSDB_SQL_MULTI_META] = tscProcessMultiMeterMetaRsp;
+  tscProcessMsgRsp[TSDB_SQL_MULTI_META] = tscProcessMultiTableMetaRsp;
 
   tscProcessMsgRsp[TSDB_SQL_SHOW] = tscProcessShowRsp;
   tscProcessMsgRsp[TSDB_SQL_RETRIEVE] = tscProcessRetrieveRspFromNode;  // rsp handled by same function.
diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h
index 8c47896a34..9e96e78cc9 100644
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
@@ -754,6 +754,7 @@ typedef struct STableMetaMsg {
 
 typedef struct SMultiTableMeta {
   int32_t       numOfTables;
+  int32_t       numOfVgroup;
   int32_t       contLen;
   char          meta[];
 } SMultiTableMeta;
diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index 0f08ec478a..3f2e4473a2 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -1709,11 +1709,7 @@ static int32_t mnodeGetSuperTableMeta(SMnodeMsg *pMsg) {
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) {
-  SSTableVgroupMsg *pInfo = pMsg->rpcMsg.pCont;
-  int32_t numOfTable = htonl(pInfo->numOfTables);
-
-  // reserve space
+static int32_t calculateVgroupMsgLength(SSTableVgroupMsg* pInfo, int32_t numOfTable) {
   int32_t contLen = sizeof(SSTableVgroupRspMsg) + 32 * sizeof(SVgroupMsg) + sizeof(SVgroupsMsg);
   for (int32_t i = 0; i < numOfTable; ++i) {
     char *stableName = (char *)pInfo + sizeof(SSTableVgroupMsg) + (TSDB_TABLE_FNAME_LEN)*i;
@@ -1725,6 +1721,72 @@ static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) {
     mnodeDecTableRef(pTable);
   }
 
+  return contLen;
+}
+
+static char* serializeVgroupInfo(SSTableObj *pTable, char* msg,  SMnodeMsg* pMsgBody, void* handle) {
+  *(uint64_t*)msg = htobe64(pTable->uid);
+  msg += sizeof(sizeof(pTable->uid));
+
+  if (pTable->vgHash == NULL) {
+    mDebug("msg:%p, app:%p stable:%s, no vgroup exist while get stable vgroup info", pMsgBody, handle, stableName);
+    mnodeDecTableRef(pTable);
+
+    // even this super table has no corresponding table, still return
+    int64_t uid = htobe64(pTable->uid);
+    SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *)msg;
+    pVgroupMsg->numOfVgroups = 0;
+
+    msg += sizeof(SVgroupsMsg);
+  } else {
+    SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *)msg;
+    mDebug("msg:%p, app:%p stable:%s, hash:%p sizeOfVgList:%d will be returned", pMsgBody, handle,
+           pTable->info.tableId, pTable->vgHash, taosHashGetSize(pTable->vgHash));
+
+    int32_t *pVgId = taosHashIterate(pTable->vgHash, NULL);
+    int32_t  vgSize = 0;
+    while (pVgId) {
+      SVgObj *pVgroup = mnodeGetVgroup(*pVgId);
+      pVgId = taosHashIterate(pTable->vgHash, pVgId);
+      if (pVgroup == NULL) {
+        continue;
+      }
+
+      pVgroupMsg->vgroups[vgSize].vgId = htonl(pVgroup->vgId);
+      pVgroupMsg->vgroups[vgSize].numOfEps = 0;
+
+      for (int32_t vn = 0; vn < pVgroup->numOfVnodes; ++vn) {
+        SDnodeObj *pDnode = pVgroup->vnodeGid[vn].pDnode;
+        if (pDnode == NULL) break;
+
+        tstrncpy(pVgroupMsg->vgroups[vgSize].epAddr[vn].fqdn, pDnode->dnodeFqdn, TSDB_FQDN_LEN);
+        pVgroupMsg->vgroups[vgSize].epAddr[vn].port = htons(pDnode->dnodePort);
+
+        pVgroupMsg->vgroups[vgSize].numOfEps++;
+      }
+
+      vgSize++;
+      mnodeDecVgroupRef(pVgroup);
+    }
+
+    taosHashCancelIterate(pTable->vgHash, pVgId);
+    mnodeDecTableRef(pTable);
+
+    pVgroupMsg->numOfVgroups = htonl(vgSize);
+
+    // one table is done, try the next table
+    msg += sizeof(SVgroupsMsg) + vgSize * sizeof(SVgroupMsg);
+  }
+
+  return msg;
+}
+
+static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) {
+  SSTableVgroupMsg *pInfo = pMsg->rpcMsg.pCont;
+  int32_t numOfTable = htonl(pInfo->numOfTables);
+
+  // calculate the required space.
+  int32_t contLen = calculateVgroupMsgLength(pInfo, numOfTable);
   SSTableVgroupRspMsg *pRsp = rpcMallocCont(contLen);
   if (pRsp == NULL) {
     return TSDB_CODE_MND_OUT_OF_MEMORY;
@@ -1735,62 +1797,67 @@ static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) {
 
   for (int32_t i = 0; i < numOfTable; ++i) {
     char *stableName = (char *)pInfo + sizeof(SSTableVgroupMsg) + (TSDB_TABLE_FNAME_LEN)*i;
+
     SSTableObj *pTable = mnodeGetSuperTable(stableName);
     if (pTable == NULL) {
       mError("msg:%p, app:%p stable:%s, not exist while get stable vgroup info", pMsg, pMsg->rpcMsg.ahandle, stableName);
       mnodeDecTableRef(pTable);
       continue;
     }
-    if (pTable->vgHash == NULL) {
-      mDebug("msg:%p, app:%p stable:%s, no vgroup exist while get stable vgroup info", pMsg, pMsg->rpcMsg.ahandle,
-             stableName);
-      mnodeDecTableRef(pTable);
 
-      // even this super table has no corresponding table, still return
-      pRsp->numOfTables++;
+    msg = serializeVgroupInfo(pTable, msg, pMsg, pMsg->rpcMsg.ahandle);
+    pRsp->numOfTables++;
 
-      SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *)msg;
-      pVgroupMsg->numOfVgroups = 0;
-
-      msg += sizeof(SVgroupsMsg);
-    } else {
-      SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *)msg;
-      mDebug("msg:%p, app:%p stable:%s, hash:%p sizeOfVgList:%d will be returned", pMsg, pMsg->rpcMsg.ahandle,
-             pTable->info.tableId, pTable->vgHash, taosHashGetSize(pTable->vgHash));
-
-      int32_t *pVgId = taosHashIterate(pTable->vgHash, NULL);
-      int32_t  vgSize = 0;
-      while (pVgId) {
-        SVgObj *pVgroup = mnodeGetVgroup(*pVgId);
-        pVgId = taosHashIterate(pTable->vgHash, pVgId);
-        if (pVgroup == NULL) continue;
-
-        pVgroupMsg->vgroups[vgSize].vgId = htonl(pVgroup->vgId);
-        pVgroupMsg->vgroups[vgSize].numOfEps = 0;
-
-        for (int32_t vn = 0; vn < pVgroup->numOfVnodes; ++vn) {
-          SDnodeObj *pDnode = pVgroup->vnodeGid[vn].pDnode;
-          if (pDnode == NULL) break;
-
-          tstrncpy(pVgroupMsg->vgroups[vgSize].epAddr[vn].fqdn, pDnode->dnodeFqdn, TSDB_FQDN_LEN);
-          pVgroupMsg->vgroups[vgSize].epAddr[vn].port = htons(pDnode->dnodePort);
-
-          pVgroupMsg->vgroups[vgSize].numOfEps++;
-        }
-
-        vgSize++;
-        mnodeDecVgroupRef(pVgroup);
-      }
-
-      taosHashCancelIterate(pTable->vgHash, pVgId);
-      mnodeDecTableRef(pTable);
-
-      pVgroupMsg->numOfVgroups = htonl(vgSize);
-
-      // one table is done, try the next table
-      msg += sizeof(SVgroupsMsg) + vgSize * sizeof(SVgroupMsg);
-      pRsp->numOfTables++;
-    }
+//    if (pTable->vgHash == NULL) {
+//      mDebug("msg:%p, app:%p stable:%s, no vgroup exist while get stable vgroup info", pMsg, pMsg->rpcMsg.ahandle,
+//             stableName);
+//      mnodeDecTableRef(pTable);
+//
+//      // even this super table has no corresponding table, still return
+//      pRsp->numOfTables++;
+//
+//      SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *)msg;
+//      pVgroupMsg->numOfVgroups = 0;
+//
+//      msg += sizeof(SVgroupsMsg);
+//    } else {
+//      SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *)msg;
+//      mDebug("msg:%p, app:%p stable:%s, hash:%p sizeOfVgList:%d will be returned", pMsg, pMsg->rpcMsg.ahandle,
+//             pTable->info.tableId, pTable->vgHash, taosHashGetSize(pTable->vgHash));
+//
+//      int32_t *pVgId = taosHashIterate(pTable->vgHash, NULL);
+//      int32_t  vgSize = 0;
+//      while (pVgId) {
+//        SVgObj *pVgroup = mnodeGetVgroup(*pVgId);
+//        pVgId = taosHashIterate(pTable->vgHash, pVgId);
+//        if (pVgroup == NULL) continue;
+//
+//        pVgroupMsg->vgroups[vgSize].vgId = htonl(pVgroup->vgId);
+//        pVgroupMsg->vgroups[vgSize].numOfEps = 0;
+//
+//        for (int32_t vn = 0; vn < pVgroup->numOfVnodes; ++vn) {
+//          SDnodeObj *pDnode = pVgroup->vnodeGid[vn].pDnode;
+//          if (pDnode == NULL) break;
+//
+//          tstrncpy(pVgroupMsg->vgroups[vgSize].epAddr[vn].fqdn, pDnode->dnodeFqdn, TSDB_FQDN_LEN);
+//          pVgroupMsg->vgroups[vgSize].epAddr[vn].port = htons(pDnode->dnodePort);
+//
+//          pVgroupMsg->vgroups[vgSize].numOfEps++;
+//        }
+//
+//        vgSize++;
+//        mnodeDecVgroupRef(pVgroup);
+//      }
+//
+//      taosHashCancelIterate(pTable->vgHash, pVgId);
+//      mnodeDecTableRef(pTable);
+//
+//      pVgroupMsg->numOfVgroups = htonl(vgSize);
+//
+//      // one table is done, try the next table
+//      msg += sizeof(SVgroupsMsg) + vgSize * sizeof(SVgroupMsg);
+//      pRsp->numOfTables++;
+//    }
   }
 
   if (pRsp->numOfTables != numOfTable) {
@@ -2818,14 +2885,13 @@ static void mnodeProcessAlterTableRsp(SRpcMsg *rpcMsg) {
   }
 }
 
-//TODO. set the vgroup info for the super table
 static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
   SMultiTableInfoMsg *pInfo = pMsg->rpcMsg.pCont;
   pInfo->numOfTables = htonl(pInfo->numOfTables);
   pInfo->loadVgroup = htonl(pInfo->loadVgroup);
 
-  // first malloc 4KB, subsequent reallocation will expand the size as twice of the original size
-  int32_t totalMallocLen = 4 * 1024;
+  // first malloc 80KB, subsequent reallocation will expand the size as twice of the original size
+  int32_t totalMallocLen = sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16);
 
   SMultiTableMeta *pMultiMeta = rpcMallocCont(totalMallocLen);
   if (pMultiMeta == NULL) {
@@ -2835,13 +2901,17 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
   pMultiMeta->contLen = sizeof(SMultiTableMeta);
   pMultiMeta->numOfTables = 0;
 
+  SArray* pList = taosArrayInit(4, POINTER_BYTES);
+
   for (int32_t t = 0; t < pInfo->numOfTables; ++t) {
     char *fullName = (char *)(pInfo->tableNames + t * TSDB_TABLE_FNAME_LEN);
 
     if (pMsg->pTable == NULL) {
       pMsg->pTable = mnodeGetTable(fullName);
-      if (pMsg->pTable == NULL) {  // TODO: return error to client?
-        continue;
+      if (pMsg->pTable == NULL) {
+        rpcFreeCont(pMultiMeta);
+        mError("msg:%p, app:%p table:%s, failed to get table meta, table not exist", pMsg, pMsg->rpcMsg.ahandle, fullName);
+        return TSDB_CODE_MND_INVALID_TABLE_NAME;
       }
     }
 
@@ -2850,8 +2920,9 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
     }
 
     if (pMsg->pDb == NULL || pMsg->pDb->status != TSDB_DB_STATUS_READY) {
-      mnodeDecTableRef(pMsg->pTable);  // TODO: return error to client?
-      continue;
+      rpcFreeCont(pMultiMeta);
+      mnodeDecTableRef(pMsg->pTable);
+      return TSDB_CODE_APP_NOT_READY;
     }
 
     int availLen = totalMallocLen - pMultiMeta->contLen;
@@ -2864,13 +2935,14 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
       }
     }
 
-    STableMetaMsg *pMeta = (STableMetaMsg *)(pMultiMeta->meta + pMultiMeta->contLen);
+    STableMetaMsg *pMeta = (STableMetaMsg *)((char*) pMultiMeta + pMultiMeta->contLen);
 
     int32_t code = 0;
     if (pMsg->pTable->type != TSDB_SUPER_TABLE) {
       code = mnodeDoGetChildTableMeta(pMsg, pMeta);
     } else {
       code = mnodeDoGetSuperTableMeta(pMsg, pMeta);
+      taosArrayPush(pList, fullName);   // keep the super table full name
     }
 
     if (code == TSDB_CODE_SUCCESS) {
@@ -2881,6 +2953,23 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
     mnodeDecTableRef(pMsg->pTable);
   }
 
+  char* msg = (char*) pMultiMeta + pMultiMeta->contLen;
+
+  for(int32_t i = 0; i < taosArrayGetSize(pList); ++i) {
+    char* name = taosArrayGet(pList, i);
+    SSTableObj *pTable = mnodeGetSuperTable(name);
+    if (pTable == NULL) {
+      mError("msg:%p, app:%p stable:%s, not exist while get stable vgroup info", pMsg, pMsg->rpcMsg.ahandle, stableName);
+      mnodeDecTableRef(pTable);
+      continue;
+    }
+
+    msg = serializeVgroupInfo(pTable, msg, pMsg, pMsg->rpcMsg.ahandle);
+  }
+
+  pMultiMeta->contLen = (msg - (char*) pMultiMeta);
+
+  pMultiMeta->numOfTables = htonl(pMultiMeta->numOfTables);
   pMsg->rpcRsp.rsp = pMultiMeta;
   pMsg->rpcRsp.len = pMultiMeta->contLen;
 

From 9326bee43064f07b312da32d20b5a44d85390886 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Thu, 13 May 2021 10:54:28 +0800
Subject: [PATCH 023/128] [td-4151] code refactor.

---
 src/client/inc/tscUtil.h      |   2 +-
 src/client/inc/tsclient.h     |   5 ++
 src/client/src/tscSQLParser.c |  40 ++++++-----
 src/client/src/tscServer.c    | 126 +++++++++++++++++++++++++++-------
 src/inc/taosmsg.h             |   2 +-
 src/mnode/src/mnodeTable.c    |  97 +++++++++-----------------
 src/query/src/qAggMain.c      |   2 +-
 src/query/src/qPlan.c         |   2 +-
 src/tsdb/src/tsdbCommit.c     |   2 +-
 src/util/inc/tarray.h         |  12 +++-
 src/util/src/tarray.c         |   6 +-
 11 files changed, 178 insertions(+), 118 deletions(-)

diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index 79220efb1a..adfaec20c4 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -305,7 +305,7 @@ void tscTryQueryNextVnode(SSqlObj *pSql, __async_cb_func_t fp);
 void tscAsyncQuerySingleRowForNextVnode(void *param, TAOS_RES *tres, int numOfRows);
 void tscTryQueryNextClause(SSqlObj* pSql, __async_cb_func_t fp);
 int  tscSetMgmtEpSetFromCfg(const char *first, const char *second, SRpcCorEpSet *corEpSet);
-int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, bool loadVgroupInfo);
+int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVgroupList);
 int tscTransferTableNameList(SSqlObj *pSql, const char *pNameList, int32_t length);
 
 bool tscSetSqlOwner(SSqlObj* pSql);
diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index 294cbc595a..8bced2c9f5 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -246,6 +246,11 @@ typedef struct SQueryInfo {
   bool               onlyTagQuery;
 } SQueryInfo;
 
+typedef struct {
+  STableMeta   *pTableMeta;
+  SVgroupsInfo *pVgroupInfo;
+} STableMetaVgroupInfo;
+
 typedef struct {
   int     command;
   uint8_t msgType;
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 2f22727521..387a348f34 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -5607,10 +5607,8 @@ int32_t validateLimitNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlN
      * And then launching multiple async-queries against all qualified virtual nodes, during the first-stage
      * query operation.
      */
-    int32_t code = tscGetSTableVgroupInfo(pSql, pQueryInfo);
-    if (code != TSDB_CODE_SUCCESS) {
-      return code;
-    }
+//    assert(allVgroupInfoRetrieved(pQueryInfo));
+
 
     // No tables included. No results generated. Query results are empty.
     if (pTableMetaInfo->vgroupList->numOfVgroups == 0) {
@@ -7172,6 +7170,8 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   STableMeta* pTableMeta = calloc(1, maxSize);
 
   SArray* plist = taosArrayInit(4, POINTER_BYTES);
+  SArray* pVgroupList = taosArrayInit(4, POINTER_BYTES);
+
   for(int32_t i = 0; i < numOfTables; ++i) {
     SName* pname = taosArrayGet(tableNameList, i);
     tNameExtractFullName(pname, name);
@@ -7183,14 +7183,19 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     if (pTableMeta->id.uid > 0) {
       if (pTableMeta->tableType == TSDB_CHILD_TABLE) {
         int32_t code = tscCreateTableMetaFromCChildMeta(pTableMeta, name);
-        if (code != TSDB_CODE_SUCCESS) {
-          // add to retrieve list
+        if (code != TSDB_CODE_SUCCESS) { // add to retrieve list
           continue;
         }
+      } else if (pTableMeta->tableType == TSDB_SUPER_TABLE) {
+        // the vgroup list of a super table is not kept in local buffer, so here need retrieve it
+        // from the mnode each time
+        char* t = strdup(name);
+        taosArrayPush(pVgroupList, &t);
       }
 
       STableMeta* pMeta = tscTableMetaDup(pTableMeta);
-      taosHashPut(pCmd->pTableMetaMap, name, strlen(name), &pMeta, POINTER_BYTES);
+      STableMetaVgroupInfo p = {.pTableMeta = pMeta,};
+      taosHashPut(pCmd->pTableMetaMap, name, strlen(name), &p, sizeof(STableMetaVgroupInfo));
     } else {// add to the retrieve table meta array list.
       char* t = strdup(name);
       taosArrayPush(plist, &t);
@@ -7199,7 +7204,7 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
   // load the table meta for a given table name list
   if (taosArrayGetSize(plist) > 0) {
-    int32_t code = getMultiTableMetaFromMnode(pSql, plist, true);
+    int32_t code = getMultiTableMetaFromMnode(pSql, plist, pVgroupList);
     taosArrayDestroyEx(plist, freeElem);
 
     return code;
@@ -7256,7 +7261,11 @@ static int32_t doLoadAllTableMeta(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNod
     }
 
     const char* name = tNameGetTableName(&pTableMetaInfo->name);
-    pTableMetaInfo->pTableMeta = taosHashGet(pCmd->pTableMetaMap, name, strlen(name));
+    STableMetaVgroupInfo* p = taosHashGet(pCmd->pTableMetaMap, name, strlen(name));
+
+    pTableMetaInfo->pTableMeta = p->pTableMeta;
+    pTableMetaInfo->vgroupList = p->pVgroupInfo;
+
     assert(pTableMetaInfo->pTableMeta != NULL);
 
     if (code != TSDB_CODE_SUCCESS) {
@@ -7394,16 +7403,9 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
     }
 
     bool isSTable = UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo);
-    if (isSTable) {
-      code = tscGetSTableVgroupInfo(pSql, pQueryInfo);  // TODO refactor: getTablemeta along with vgroupInfo
-      if (code != TSDB_CODE_SUCCESS) {
-        return code;
-      }
 
-      TSDB_QUERY_SET_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_STABLE_QUERY);
-    } else {
-      TSDB_QUERY_SET_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_TABLE_QUERY);
-    }
+    int32_t type = isSTable? TSDB_QUERY_TYPE_STABLE_QUERY:TSDB_QUERY_TYPE_TABLE_QUERY;
+    TSDB_QUERY_SET_TYPE(pQueryInfo->type, type);
 
     // parse the group by clause in the first place
     if (validateGroupbyNode(pQueryInfo, pSqlNode->pGroupby, pCmd) != TSDB_CODE_SUCCESS) {
@@ -7527,7 +7529,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
       pQueryInfo->exprList1 = taosArrayInit(4, POINTER_BYTES);
     }
 
-    taosArrayPushBatch(pQueryInfo->exprList1, (void*) p, numOfExpr);
+    taosArrayAddBatch(pQueryInfo->exprList1, (void*) p, numOfExpr);
   }
 
 #if 0
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 23ae03bdc3..1b5a0b2445 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -1829,7 +1829,7 @@ static int32_t tableMetaMsgConvert(STableMetaMsg* pMetaMsg) {
   pMetaMsg->vgroup.vgId = htonl(pMetaMsg->vgroup.vgId);
 
   pMetaMsg->uid = htobe64(pMetaMsg->uid);
-  pMetaMsg->contLen = htons(pMetaMsg->contLen);
+//  pMetaMsg->contLen = htonl(pMetaMsg->contLen);
   pMetaMsg->numOfColumns = htons(pMetaMsg->numOfColumns);
 
   if ((pMetaMsg->tableType != TSDB_SUPER_TABLE) &&
@@ -1941,16 +1941,61 @@ int tscProcessTableMetaRsp(SSqlObj *pSql) {
   return TSDB_CODE_SUCCESS;
 }
 
-/*
- *  multi table meta rsp pkg format:
- *  | SMultiTableInfoMsg | SMeterMeta0 | SSchema0 | SMeterMeta1 | SSchema1 | SMeterMeta2 | SSchema2
- *  | 4B
- */
+static SVgroupsInfo* createVgroupInfoFromMsg(char* pMsg, int32_t* size, uint64_t id) {
+  SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *) pMsg;
+  pVgroupMsg->numOfVgroups = htonl(pVgroupMsg->numOfVgroups);
+
+  *size = (int32_t) (sizeof(SVgroupMsg) * pVgroupMsg->numOfVgroups + sizeof(SVgroupsMsg));
+
+  size_t vgroupsz = sizeof(SVgroupInfo) * pVgroupMsg->numOfVgroups + sizeof(SVgroupsInfo);
+  SVgroupsInfo* pVgroupInfo = calloc(1, vgroupsz);
+  assert(pVgroupInfo != NULL);
+
+  pVgroupInfo->numOfVgroups = pVgroupMsg->numOfVgroups;
+  if (pVgroupInfo->numOfVgroups <= 0) {
+    tscDebug("0x%"PRIx64" empty vgroup info, no corresponding tables for stable", id);
+  } else {
+    for (int32_t j = 0; j < pVgroupInfo->numOfVgroups; ++j) {
+      // just init, no need to lock
+      SVgroupInfo *pVgroup = &pVgroupInfo->vgroups[j];
+
+      SVgroupMsg *vmsg = &pVgroupMsg->vgroups[j];
+      vmsg->vgId     = htonl(vmsg->vgId);
+      vmsg->numOfEps = vmsg->numOfEps;
+      for (int32_t k = 0; k < vmsg->numOfEps; ++k) {
+        vmsg->epAddr[k].port = htons(vmsg->epAddr[k].port);
+      }
+
+      SNewVgroupInfo newVi = createNewVgroupInfo(vmsg);
+      pVgroup->numOfEps = newVi.numOfEps;
+      pVgroup->vgId = newVi.vgId;
+      for (int32_t k = 0; k < vmsg->numOfEps; ++k) {
+        pVgroup->epAddr[k].port = newVi.ep[k].port;
+        pVgroup->epAddr[k].fqdn = strndup(newVi.ep[k].fqdn, TSDB_FQDN_LEN);
+      }
+
+      // check if current buffer contains the vgroup info.
+      // If not, add it
+      SNewVgroupInfo existVgroupInfo = {.inUse = -1};
+      taosHashGetClone(tscVgroupMap, &newVi.vgId, sizeof(newVi.vgId), NULL, &existVgroupInfo, sizeof(SNewVgroupInfo));
+
+      if (((existVgroupInfo.inUse >= 0) && !vgroupInfoIdentical(&existVgroupInfo, vmsg)) ||
+          (existVgroupInfo.inUse < 0)) {  // vgroup info exists, compare with it
+        taosHashPut(tscVgroupMap, &newVi.vgId, sizeof(newVi.vgId), &newVi, sizeof(newVi));
+        tscDebug("0x%"PRIx64" add new VgroupInfo, vgId:%d, total cached:%d", id, newVi.vgId, (int32_t) taosHashGetSize(tscVgroupMap));
+      }
+    }
+  }
+
+  return pVgroupInfo;
+}
+
 int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
   char *rsp = pSql->res.pRsp;
 
   SMultiTableMeta *pMultiMeta = (SMultiTableMeta *)rsp;
   pMultiMeta->numOfTables = htonl(pMultiMeta->numOfTables);
+  pMultiMeta->numOfVgroup = htonl(pMultiMeta->numOfVgroup);
 
   rsp += sizeof(SMultiTableMeta);
 
@@ -1959,8 +2004,9 @@ int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
 
   SHashObj *pSet = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
 
+  char* pMsg = pMultiMeta->meta;
   for (int32_t i = 0; i < pMultiMeta->numOfTables; i++) {
-    STableMetaMsg *pMetaMsg = (STableMetaMsg *)pMultiMeta->meta;
+    STableMetaMsg *pMetaMsg = (STableMetaMsg *)pMsg;
     int32_t code = tableMetaMsgConvert(pMetaMsg);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
@@ -1972,13 +2018,14 @@ int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
       return TSDB_CODE_TSC_INVALID_VALUE;
     }
 
-    int32_t t = tscGetTableMetaSize(pTableMeta);
-
     SName sn = {0};
     tNameFromString(&sn, pMetaMsg->tableFname, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+
     const char* tableName = tNameGetTableName(&sn);
     int32_t keyLen = strlen(tableName);
-    taosHashPut(pParentCmd->pTableMetaMap, tableName, keyLen, pTableMeta, t);
+
+    STableMetaVgroupInfo p = {.pTableMeta = pTableMeta,};
+    taosHashPut(pParentCmd->pTableMetaMap, tableName, keyLen, &p, sizeof(STableMetaVgroupInfo));
 
     bool addToBuf = false;
     if (taosHashGet(pSet, &pMetaMsg->uid, sizeof(pMetaMsg->uid)) == NULL) {
@@ -1991,10 +2038,26 @@ int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
 
     // if the vgroup is not updated in current process, update it.
     int64_t vgId = pMetaMsg->vgroup.vgId;
-    if (taosHashGet(pSet, &vgId, sizeof(vgId)) == NULL) {
+    if (pTableMeta->tableType != TSDB_SUPER_TABLE && taosHashGet(pSet, &vgId, sizeof(vgId)) == NULL) {
       doUpdateVgroupInfo(pTableMeta, &pMetaMsg->vgroup);
       taosHashPut(pSet, &vgId, sizeof(vgId), "", 0);
     }
+
+    pMsg += pMetaMsg->contLen;
+  }
+
+  if (pMultiMeta->numOfVgroup > 0) {
+    char* name = pMsg;
+    pMsg += TSDB_TABLE_NAME_LEN;
+
+    STableMetaVgroupInfo* p = taosHashGet(pParentCmd->pTableMetaMap, name, strnlen(name, TSDB_TABLE_NAME_LEN));
+    assert(p != NULL);
+
+    int32_t size = 0;
+    SVgroupsInfo* pVgroupInfo = createVgroupInfoFromMsg(pMsg, &size, pSql->self);
+
+    p->pVgroupInfo = pVgroupInfo;
+    pMsg += size;
   }
 
   pSql->res.code = TSDB_CODE_SUCCESS;
@@ -2024,12 +2087,12 @@ int tscProcessSTableVgroupRsp(SSqlObj *pSql) {
   for(int32_t i = 0; i < pStableVgroup->numOfTables; ++i) {
     STableMetaInfo *pInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, i);
 
-    SVgroupsMsg *  pVgroupMsg = (SVgroupsMsg *) pMsg;
+    SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *) pMsg;
     pVgroupMsg->numOfVgroups = htonl(pVgroupMsg->numOfVgroups);
 
-    size_t size = sizeof(SVgroupMsg) * pVgroupMsg->numOfVgroups + sizeof(SVgroupsMsg);
-
-    size_t vgroupsz = sizeof(SVgroupInfo) * pVgroupMsg->numOfVgroups + sizeof(SVgroupsInfo);
+    int32_t size = 0;
+    pInfo->vgroupList = createVgroupInfoFromMsg(pMsg, &size, pSql->self);
+ /*   size_t vgroupsz = sizeof(SVgroupInfo) * pVgroupMsg->numOfVgroups + sizeof(SVgroupsInfo);
     pInfo->vgroupList = calloc(1, vgroupsz);
     assert(pInfo->vgroupList != NULL);
 
@@ -2068,7 +2131,7 @@ int tscProcessSTableVgroupRsp(SSqlObj *pSql) {
         }
       }
     }
-
+*/
     pMsg += size;
   }
 
@@ -2403,7 +2466,7 @@ static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaIn
   return code;
 }
 
-int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, bool loadVgroupInfo) {
+int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVgroupNameList) {
   SSqlObj *pNew = calloc(1, sizeof(SSqlObj));
   if (NULL == pNew) {
     tscError("0x%"PRIx64" failed to allocate sqlobj to get multiple table meta", pSql->self);
@@ -2414,8 +2477,10 @@ int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, bool loadVg
   pNew->signature   = pNew;
   pNew->cmd.command = TSDB_SQL_MULTI_META;
 
-  int32_t numOfTables = taosArrayGetSize(pNameList);
-  int32_t size = numOfTables * TSDB_TABLE_FNAME_LEN + sizeof(SMultiTableInfoMsg);
+  int32_t numOfTable      = (int32_t) taosArrayGetSize(pNameList);
+  int32_t numOfVgroupList = (int32_t) taosArrayGetSize(pVgroupNameList);
+
+  int32_t size = (numOfTable + numOfVgroupList) * TSDB_TABLE_FNAME_LEN + sizeof(SMultiTableInfoMsg);
   if (TSDB_CODE_SUCCESS != tscAllocPayload(&pNew->cmd, size)) {
     tscError("0x%"PRIx64" malloc failed for payload to get table meta", pSql->self);
     tscFreeSqlObj(pNew);
@@ -2423,14 +2488,14 @@ int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, bool loadVg
   }
 
   SMultiTableInfoMsg* pInfo = (SMultiTableInfoMsg*) pNew->cmd.payload;
-  pInfo->loadVgroup = htonl(loadVgroupInfo? 1:0);
-  pInfo->numOfTables = htonl(numOfTables);
+  pInfo->numOfTables  = htonl((uint32_t) taosArrayGetSize(pNameList));
+  pInfo->numOfVgroups = htonl((uint32_t) taosArrayGetSize(pVgroupNameList));
 
   char* start = pInfo->tableNames;
   int32_t len = 0;
-  for(int32_t i = 0; i < numOfTables; ++i) {
+  for(int32_t i = 0; i < numOfTable; ++i) {
     char* name = taosArrayGetP(pNameList, i);
-    if (i < numOfTables - 1) {
+    if (i < numOfTable - 1 || numOfVgroupList > 0) {
       len = sprintf(start, "%s,", name);
     } else {
       len = sprintf(start, "%s", name);
@@ -2439,12 +2504,23 @@ int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, bool loadVg
     start += len;
   }
 
+  for(int32_t i = 0; i < numOfVgroupList; ++i) {
+    char* name = taosArrayGetP(pVgroupNameList, i);
+    if (i < numOfVgroupList - 1) {
+      len = sprintf(start, "%s, ", name);
+    } else {
+      len = sprintf(start, "%s", name);
+    }
+
+    start += len;
+  }
+
   pNew->cmd.payloadLen = (start - pInfo->tableNames) + sizeof(SMultiTableInfoMsg);
   pNew->cmd.msgType = TSDB_MSG_TYPE_CM_TABLES_META;
 
   registerSqlObj(pNew);
-  tscDebug("0x%"PRIx64" new pSqlObj:0x%"PRIx64" to get %d tableMeta, loadVgroup:%d, msg size:%d", pSql->self,
-      pNew->self, numOfTables, loadVgroupInfo, pNew->cmd.payloadLen);
+  tscDebug("0x%"PRIx64" new pSqlObj:0x%"PRIx64" to get %d tableMeta, vgroupInfo:%d, msg size:%d", pSql->self,
+      pNew->self, numOfTable, numOfVgroupList, pNew->cmd.payloadLen);
 
   pNew->fp = tscTableMetaCallBack;
   pNew->param = (void *)pSql->self;
diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h
index 9e96e78cc9..cc45774b15 100644
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
@@ -703,7 +703,7 @@ typedef struct {
 } STableInfoMsg;
 
 typedef struct {
-  int32_t loadVgroup;
+  int32_t numOfVgroups;
   int32_t numOfTables;
   char    tableNames[];
 } SMultiTableInfoMsg;
diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index 3f2e4473a2..dc1b2072de 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -1724,16 +1724,19 @@ static int32_t calculateVgroupMsgLength(SSTableVgroupMsg* pInfo, int32_t numOfTa
   return contLen;
 }
 
-static char* serializeVgroupInfo(SSTableObj *pTable, char* msg,  SMnodeMsg* pMsgBody, void* handle) {
-  *(uint64_t*)msg = htobe64(pTable->uid);
-  msg += sizeof(sizeof(pTable->uid));
+static char* serializeVgroupInfo(SSTableObj *pTable, char* name, char* msg, SMnodeMsg* pMsgBody, void* handle) {
+  SName sn = {0};
+  tNameFromString(&sn, name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  const char* tableName = tNameGetTableName(&sn);
+
+  strncpy(msg, tableName, TSDB_TABLE_NAME_LEN);
+  msg += TSDB_TABLE_NAME_LEN;
 
   if (pTable->vgHash == NULL) {
-    mDebug("msg:%p, app:%p stable:%s, no vgroup exist while get stable vgroup info", pMsgBody, handle, stableName);
+    mDebug("msg:%p, app:%p stable:%s, no vgroup exist while get stable vgroup info", pMsgBody, handle, name);
     mnodeDecTableRef(pTable);
 
     // even this super table has no corresponding table, still return
-    int64_t uid = htobe64(pTable->uid);
     SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *)msg;
     pVgroupMsg->numOfVgroups = 0;
 
@@ -1805,59 +1808,8 @@ static int32_t mnodeProcessSuperTableVgroupMsg(SMnodeMsg *pMsg) {
       continue;
     }
 
-    msg = serializeVgroupInfo(pTable, msg, pMsg, pMsg->rpcMsg.ahandle);
+    msg = serializeVgroupInfo(pTable, stableName, msg, pMsg, pMsg->rpcMsg.ahandle);
     pRsp->numOfTables++;
-
-//    if (pTable->vgHash == NULL) {
-//      mDebug("msg:%p, app:%p stable:%s, no vgroup exist while get stable vgroup info", pMsg, pMsg->rpcMsg.ahandle,
-//             stableName);
-//      mnodeDecTableRef(pTable);
-//
-//      // even this super table has no corresponding table, still return
-//      pRsp->numOfTables++;
-//
-//      SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *)msg;
-//      pVgroupMsg->numOfVgroups = 0;
-//
-//      msg += sizeof(SVgroupsMsg);
-//    } else {
-//      SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *)msg;
-//      mDebug("msg:%p, app:%p stable:%s, hash:%p sizeOfVgList:%d will be returned", pMsg, pMsg->rpcMsg.ahandle,
-//             pTable->info.tableId, pTable->vgHash, taosHashGetSize(pTable->vgHash));
-//
-//      int32_t *pVgId = taosHashIterate(pTable->vgHash, NULL);
-//      int32_t  vgSize = 0;
-//      while (pVgId) {
-//        SVgObj *pVgroup = mnodeGetVgroup(*pVgId);
-//        pVgId = taosHashIterate(pTable->vgHash, pVgId);
-//        if (pVgroup == NULL) continue;
-//
-//        pVgroupMsg->vgroups[vgSize].vgId = htonl(pVgroup->vgId);
-//        pVgroupMsg->vgroups[vgSize].numOfEps = 0;
-//
-//        for (int32_t vn = 0; vn < pVgroup->numOfVnodes; ++vn) {
-//          SDnodeObj *pDnode = pVgroup->vnodeGid[vn].pDnode;
-//          if (pDnode == NULL) break;
-//
-//          tstrncpy(pVgroupMsg->vgroups[vgSize].epAddr[vn].fqdn, pDnode->dnodeFqdn, TSDB_FQDN_LEN);
-//          pVgroupMsg->vgroups[vgSize].epAddr[vn].port = htons(pDnode->dnodePort);
-//
-//          pVgroupMsg->vgroups[vgSize].numOfEps++;
-//        }
-//
-//        vgSize++;
-//        mnodeDecVgroupRef(pVgroup);
-//      }
-//
-//      taosHashCancelIterate(pTable->vgHash, pVgId);
-//      mnodeDecTableRef(pTable);
-//
-//      pVgroupMsg->numOfVgroups = htonl(vgSize);
-//
-//      // one table is done, try the next table
-//      msg += sizeof(SVgroupsMsg) + vgSize * sizeof(SVgroupMsg);
-//      pRsp->numOfTables++;
-//    }
   }
 
   if (pRsp->numOfTables != numOfTable) {
@@ -2887,8 +2839,9 @@ static void mnodeProcessAlterTableRsp(SRpcMsg *rpcMsg) {
 
 static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
   SMultiTableInfoMsg *pInfo = pMsg->rpcMsg.pCont;
-  pInfo->numOfTables = htonl(pInfo->numOfTables);
-  pInfo->loadVgroup = htonl(pInfo->loadVgroup);
+
+  pInfo->numOfTables  = htonl(pInfo->numOfTables);
+  pInfo->numOfVgroups = htonl(pInfo->numOfVgroups);
 
   // first malloc 80KB, subsequent reallocation will expand the size as twice of the original size
   int32_t totalMallocLen = sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16);
@@ -2925,8 +2878,8 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
       return TSDB_CODE_APP_NOT_READY;
     }
 
-    int availLen = totalMallocLen - pMultiMeta->contLen;
-    if (availLen <= sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16)) {
+    int remain = totalMallocLen - pMultiMeta->contLen;
+    if (remain <= sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16)) {
       totalMallocLen *= 2;
       pMultiMeta = rpcReallocCont(pMultiMeta, totalMallocLen);
       if (pMultiMeta == NULL) {
@@ -2942,7 +2895,9 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
       code = mnodeDoGetChildTableMeta(pMsg, pMeta);
     } else {
       code = mnodeDoGetSuperTableMeta(pMsg, pMeta);
-      taosArrayPush(pList, fullName);   // keep the super table full name
+
+      // keep the full name for each super table for retrieve vgroup list
+      taosArrayPush(pList, &fullName);
     }
 
     if (code == TSDB_CODE_SUCCESS) {
@@ -2955,16 +2910,26 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
 
   char* msg = (char*) pMultiMeta + pMultiMeta->contLen;
 
-  for(int32_t i = 0; i < taosArrayGetSize(pList); ++i) {
-    char* name = taosArrayGet(pList, i);
+  // add the additional super table names that needs the vgroup info
+  for(int32_t i = 0; i < pInfo->numOfVgroups; ++i) {
+    char *fullName = (char *)(pInfo->tableNames + (i + pInfo->numOfTables) * TSDB_TABLE_FNAME_LEN);
+    taosArrayPush(pList, fullName);
+  }
+
+  // add the pVgroupList into the pList
+  int32_t numOfStable = (int32_t) taosArrayGetSize(pList);
+  pMultiMeta->numOfVgroup = htonl(numOfStable);
+
+  for(int32_t i = 0; i < numOfStable; ++i) {
+    char* name = taosArrayGetP(pList, i);
     SSTableObj *pTable = mnodeGetSuperTable(name);
     if (pTable == NULL) {
-      mError("msg:%p, app:%p stable:%s, not exist while get stable vgroup info", pMsg, pMsg->rpcMsg.ahandle, stableName);
+      mError("msg:%p, app:%p stable:%s, not exist while get stable vgroup info", pMsg, pMsg->rpcMsg.ahandle, name);
       mnodeDecTableRef(pTable);
       continue;
     }
 
-    msg = serializeVgroupInfo(pTable, msg, pMsg, pMsg->rpcMsg.ahandle);
+    msg = serializeVgroupInfo(pTable, name, msg, pMsg, pMsg->rpcMsg.ahandle);
   }
 
   pMultiMeta->contLen = (msg - (char*) pMultiMeta);
diff --git a/src/query/src/qAggMain.c b/src/query/src/qAggMain.c
index 844817c144..6218494b48 100644
--- a/src/query/src/qAggMain.c
+++ b/src/query/src/qAggMain.c
@@ -4779,7 +4779,7 @@ static void mergeTableBlockDist(STableBlockDist* pDist, const STableBlockDist* p
     pDist->dataBlockInfos = taosArrayInit(4, sizeof(SFileBlockInfo));
   }
 
-  taosArrayPushBatch(pDist->dataBlockInfos, pSrc->dataBlockInfos->pData, (int32_t) taosArrayGetSize(pSrc->dataBlockInfos));
+  taosArrayAddBatch(pDist->dataBlockInfos, pSrc->dataBlockInfos->pData, (int32_t) taosArrayGetSize(pSrc->dataBlockInfos));
 }
 
 void block_func_merge(SQLFunctionCtx* pCtx) {
diff --git a/src/query/src/qPlan.c b/src/query/src/qPlan.c
index c46257ba9e..9176b4a06b 100644
--- a/src/query/src/qPlan.c
+++ b/src/query/src/qPlan.c
@@ -215,7 +215,7 @@ SArray* createQueryPlanImpl(SQueryInfo* pQueryInfo) {
     for(int32_t i = 0; i < size; ++i) {
       SQueryInfo* pq = taosArrayGet(pQueryInfo->pUpstream, i);
       SArray* p = createQueryPlanImpl(pq);
-      taosArrayPushBatch(upstream, p->pData, (int32_t) taosArrayGetSize(p));
+      taosArrayAddBatch(upstream, p->pData, (int32_t) taosArrayGetSize(p));
     }
   }
 
diff --git a/src/tsdb/src/tsdbCommit.c b/src/tsdb/src/tsdbCommit.c
index 4351cce51c..4cbd3c10f3 100644
--- a/src/tsdb/src/tsdbCommit.c
+++ b/src/tsdb/src/tsdbCommit.c
@@ -1149,7 +1149,7 @@ static int tsdbCommitAddBlock(SCommitH *pCommith, const SBlock *pSupBlock, const
     return -1;
   }
 
-  if (pSubBlocks && taosArrayPushBatch(pCommith->aSubBlk, pSubBlocks, nSubBlocks) == NULL) {
+  if (pSubBlocks && taosArrayAddBatch(pCommith->aSubBlk, pSubBlocks, nSubBlocks) == NULL) {
     terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
     return -1;
   }
diff --git a/src/util/inc/tarray.h b/src/util/inc/tarray.h
index f2e268c2d4..bc25776caa 100644
--- a/src/util/inc/tarray.h
+++ b/src/util/inc/tarray.h
@@ -50,7 +50,15 @@ void* taosArrayInit(size_t size, size_t elemSize);
  * @param nEles
  * @return
  */
-void *taosArrayPushBatch(SArray *pArray, const void *pData, int nEles);
+void *taosArrayAddBatch(SArray *pArray, const void *pData, int nEles);
+
+/**
+ *  add all element from the source array list into the destination
+ * @param pArray
+ * @param pInput
+ * @return
+ */
+void* taosArrayAddAll(SArray* pArray, const SArray* pInput);
 
 /**
  *
@@ -59,7 +67,7 @@ void *taosArrayPushBatch(SArray *pArray, const void *pData, int nEles);
  * @return
  */
 static FORCE_INLINE void* taosArrayPush(SArray* pArray, const void* pData) {
-  return taosArrayPushBatch(pArray, pData, 1);
+  return taosArrayAddBatch(pArray, pData, 1);
 }
 
 /**
diff --git a/src/util/src/tarray.c b/src/util/src/tarray.c
index 4dde5dbba2..87433b4d4e 100644
--- a/src/util/src/tarray.c
+++ b/src/util/src/tarray.c
@@ -55,7 +55,7 @@ static int32_t taosArrayResize(SArray* pArray) {
   return 0;
 }
 
-void* taosArrayPushBatch(SArray* pArray, const void* pData, int nEles) {
+void* taosArrayAddBatch(SArray* pArray, const void* pData, int nEles) {
   if (pArray == NULL || pData == NULL) {
     return NULL;
   }
@@ -81,6 +81,10 @@ void* taosArrayPushBatch(SArray* pArray, const void* pData, int nEles) {
   return dst;
 }
 
+void* taosArrayAddAll(SArray* pArray, const SArray* pInput) {
+  return taosArrayAddBatch(pArray, pInput->pData, (int32_t) taosArrayGetSize(pInput));
+}
+
 void* taosArrayPop(SArray* pArray) {
   assert( pArray != NULL );
 

From 14b699f53bcc07973cb391cb665186d1d30814f1 Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Thu, 13 May 2021 11:24:18 +0800
Subject: [PATCH 024/128] [TD-4034]refactor cache condition

---
 documentation20/cn/11.administrator/docs.md | 2 +-
 src/inc/tsdb.h                              | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/documentation20/cn/11.administrator/docs.md b/documentation20/cn/11.administrator/docs.md
index b9340210d2..26cfa91beb 100644
--- a/documentation20/cn/11.administrator/docs.md
+++ b/documentation20/cn/11.administrator/docs.md
@@ -129,7 +129,7 @@ taosd -C
 - blocks：每个VNODE（TSDB）中有多少cache大小的内存块。因此一个VNODE的用的内存大小粗略为（cache * blocks）。单位为块，默认值：4。（可通过 alter database 修改）
 - replica：副本个数，取值范围：1-3。单位为个，默认值：1。（可通过 alter database 修改）
 - precision：时间戳精度标识，ms表示毫秒，us表示微秒。默认值：ms。
-- cacheLast：是否在内存中缓存子表的最近数据，0：关闭；1：缓存子表最近一行数据；2：缓存子表每一列的最近的非NULL值，设置为3表示同时开启了1和2。默认值：0。（可通过 alter database 修改）（从 2.0.11 版本开始支持此参数）
+- cacheLast：是否在内存中缓存子表的最近数据，0：关闭；1：缓存子表最近一行数据；2：缓存子表每一列的最近的非NULL值，默认值：0。（可通过 alter database 修改）（从 2.0.11 版本开始支持此参数）
 
 对于一个应用场景，可能有多种数据特征的数据并存，最佳的设计是将具有相同数据特征的表放在一个库里，这样一个应用有多个库，而每个库可以配置不同的存储参数，从而保证系统有最优的性能。TDengine允许应用在创建库时指定上述存储参数，如果指定，该参数就将覆盖对应的系统配置参数。举例，有下述SQL：
 
diff --git a/src/inc/tsdb.h b/src/inc/tsdb.h
index 7c28d3e485..d231769c18 100644
--- a/src/inc/tsdb.h
+++ b/src/inc/tsdb.h
@@ -73,8 +73,8 @@ typedef struct {
 } STsdbCfg;
 
 #define CACHE_NO_LAST(c)          ((c)->cacheLastRow == 0)
-#define CACHE_LAST_ROW(c)         (((c)->cacheLastRow & 1) > 0)
-#define CACHE_LAST_NULL_COLUMN(c) (((c)->cacheLastRow & 2) > 0)
+#define CACHE_LAST_ROW(c)         ((c)->cacheLastRow == 1)
+#define CACHE_LAST_NULL_COLUMN(c) ((c)->cacheLastRow == 2)
 
 // --------- TSDB REPOSITORY USAGE STATISTICS
 typedef struct {

From dfcb2f8ef0aaf650aa2b94c479cd4066d919eb77 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Fri, 14 May 2021 15:36:24 +0800
Subject: [PATCH 025/128] [td-225] refactor

---
 src/client/inc/tscUtil.h        |  13 +-
 src/client/inc/tsclient.h       |   6 +-
 src/client/src/tscAsync.c       |  10 +-
 src/client/src/tscLocal.c       |  36 ++--
 src/client/src/tscLocalMerge.c  |   2 +-
 src/client/src/tscParseInsert.c |  10 +-
 src/client/src/tscPrepare.c     |   8 +-
 src/client/src/tscSQLParser.c   | 150 ++++++++++-------
 src/client/src/tscServer.c      |  63 ++++---
 src/client/src/tscSql.c         |  12 +-
 src/client/src/tscStream.c      |  16 +-
 src/client/src/tscSub.c         |  10 +-
 src/client/src/tscSubquery.c    |  99 ++++++-----
 src/client/src/tscUtil.c        | 290 +++++++++++++++++++++++++-------
 src/mnode/src/mnodeTable.c      |  76 +++++----
 15 files changed, 505 insertions(+), 296 deletions(-)

diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index adfaec20c4..d8b9bfab26 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -93,8 +93,8 @@ typedef struct SVgroupTableInfo {
   SArray     *itemList;   // SArray<STableIdInfo>
 } SVgroupTableInfo;
 
-static FORCE_INLINE SQueryInfo* tscGetQueryInfo(SSqlCmd* pCmd, int32_t subClauseIndex) {
-  assert(pCmd != NULL && subClauseIndex >= 0);
+static FORCE_INLINE SQueryInfo* tscGetQueryInfo(SSqlCmd* pCmd) {
+  assert(pCmd != NULL);
   if (pCmd->pQueryInfo == NULL) {
     return NULL;
   }
@@ -175,13 +175,13 @@ void tscFieldInfoUpdateOffset(SQueryInfo* pQueryInfo);
 
 int16_t tscFieldInfoGetOffset(SQueryInfo* pQueryInfo, int32_t index);
 void    tscFieldInfoClear(SFieldInfo* pFieldInfo);
+void    tscFieldInfoCopy(SFieldInfo* pFieldInfo, const SFieldInfo* pSrc);
 
 static FORCE_INLINE int32_t tscNumOfFields(SQueryInfo* pQueryInfo) { return pQueryInfo->fieldsInfo.numOfOutput; }
 
 int32_t tscFieldInfoCompare(const SFieldInfo* pFieldInfo1, const SFieldInfo* pFieldInfo2);
 void tscInsertPrimaryTsSourceColumn(SQueryInfo* pQueryInfo, uint64_t uid);
 
-
 int32_t   tscGetResRowLength(SArray* pExprList);
 
 SExprInfo* tscExprInsert(SQueryInfo* pQueryInfo, int32_t index, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
@@ -211,6 +211,7 @@ bool tscColumnExists(SArray* pColumnList, int32_t columnIndex, uint64_t uid);
 SColumn* tscColumnListInsert(SArray* pColumnList, int32_t columnIndex, uint64_t uid, SSchema* pSchema);
 void tscColumnListDestroy(SArray* pColList);
 void tscColumnListCopy(SArray* dst, const SArray* src, uint64_t tableUid);
+void tscColumnListCopyAll(SArray* dst, const SArray* src);
 
 void convertQueryResult(SSqlRes* pRes, SQueryInfo* pQueryInfo);
 
@@ -232,13 +233,13 @@ void tscGetSrcColumnInfo(SSrcColumnInfo* pColInfo, SQueryInfo* pQueryInfo);
 
 bool tscShouldBeFreed(SSqlObj* pSql);
 
-STableMetaInfo* tscGetTableMetaInfoFromCmd(SSqlCmd *pCmd, int32_t subClauseIndex, int32_t tableIndex);
+STableMetaInfo* tscGetTableMetaInfoFromCmd(SSqlCmd *pCmd, int32_t tableIndex);
 STableMetaInfo* tscGetMetaInfo(SQueryInfo *pQueryInfo, int32_t tableIndex);
 
 void        tscInitQueryInfo(SQueryInfo* pQueryInfo);
 void        tscClearSubqueryInfo(SSqlCmd* pCmd);
 int32_t     tscAddQueryInfo(SSqlCmd *pCmd);
-SQueryInfo *tscGetQueryInfo(SSqlCmd* pCmd, int32_t subClauseIndex);
+SQueryInfo *tscGetQueryInfo(SSqlCmd* pCmd);
 SQueryInfo *tscGetQueryInfoS(SSqlCmd *pCmd, int32_t subClauseIndex);
 
 void tscClearTableMetaInfo(STableMetaInfo* pTableMetaInfo);
@@ -308,6 +309,8 @@ int  tscSetMgmtEpSetFromCfg(const char *first, const char *second, SRpcCorEpSet
 int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVgroupList);
 int tscTransferTableNameList(SSqlObj *pSql, const char *pNameList, int32_t length);
 
+bool subAndCheckDone(SSqlObj *pSql, SSqlObj *pParentSql, int idx);
+
 bool tscSetSqlOwner(SSqlObj* pSql);
 void tscClearSqlOwner(SSqlObj* pSql);
 int32_t doArithmeticCalculate(SQueryInfo* pQueryInfo, tFilePage* pOutput, int32_t rowSize, int32_t finalRowSize);
diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index 8bced2c9f5..13ec02b5d1 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -283,9 +283,9 @@ typedef struct {
   int32_t      numOfParams;
 
   int8_t       dataSourceType; // load data from file or not
-  char    reserve4[3];         // fix bus error on arm32
+  char         reserve4[3];         // fix bus error on arm32
   int8_t       submitSchema;   // submit block is built with table schema
-  char    reserve5[3];         // fix bus error on arm32
+  char         reserve5[3];         // fix bus error on arm32
   STagData     tagData;        // NOTE: pTagData->data is used as a variant length array
 
   SName      **pTableNameList; // all involved tableMeta list of current insert sql statement.
@@ -452,7 +452,7 @@ int32_t tscCreateResPointerInfo(SSqlRes *pRes, SQueryInfo *pQueryInfo);
 void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo);
 void tscSetResRawPtrRv(SSqlRes* pRes, SQueryInfo* pQueryInfo, SSDataBlock* pBlock);
 
-void handleDownstreamOperator(SSqlRes* pRes, SQueryInfo* pQueryInfo);
+void handleDownstreamOperator(SSqlRes* pRes, SQueryInfo* pQueryInfo, SSqlRes* pOutput);
 void destroyTableNameList(SSqlCmd* pCmd);
 
 void tscResetSqlCmd(SSqlCmd *pCmd, bool removeMeta);
diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c
index aa570faa06..28eafa164c 100644
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -69,7 +69,7 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, __async_cb_func_t fp, void* para
     return;
   }
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
   executeQuery(pSql, pQueryInfo);
 }
 
@@ -376,7 +376,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
 
   tscDebug("0x%"PRIx64" get %s successfully", pSql->self, msg);
   if (pSql->pStream == NULL) {
-    SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+    SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
 
     // check if it is a sub-query of super table query first, if true, enter another routine
     if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, (TSDB_QUERY_TYPE_STABLE_SUBQUERY|TSDB_QUERY_TYPE_SUBQUERY|TSDB_QUERY_TYPE_TAG_FILTER_QUERY))) {
@@ -406,7 +406,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
       if (pCmd->parseFinished) {
         tscDebug("0x%"PRIx64" update local table meta, continue to process sql and send corresponding query", pSql->self);
 
-        STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+        STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
         code = tscGetTableMeta(pSql, pTableMetaInfo);
 
         assert(code == TSDB_CODE_TSC_ACTION_IN_PROGRESS || code == TSDB_CODE_SUCCESS);
@@ -449,7 +449,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
         }
 
         if (pCmd->insertType == TSDB_QUERY_TYPE_STMT_INSERT) {
-          STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+          STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
           code = tscGetTableMeta(pSql, pTableMetaInfo);
           if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
             taosReleaseRef(tscObjRef, pSql->self);
@@ -466,7 +466,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
             tscHandleMultivnodeInsert(pSql);
           }
         } else {
-          SQueryInfo* pQueryInfo1 = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+          SQueryInfo* pQueryInfo1 = tscGetQueryInfo(pCmd);
           executeQuery(pSql, pQueryInfo1);
         }
 
diff --git a/src/client/src/tscLocal.c b/src/client/src/tscLocal.c
index 6a4dd79300..89c79ade7e 100644
--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
@@ -53,7 +53,7 @@ static int32_t tscSetValueToResObj(SSqlObj *pSql, int32_t rowLen) {
   SSqlRes *pRes = &pSql->res;
 
   // one column for each row
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   STableMeta *    pMeta = pTableMetaInfo->pTableMeta;
@@ -154,7 +154,7 @@ static int32_t tscBuildTableSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
   
   pSql->cmd.numOfCols = numOfCols;
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   pQueryInfo->order.order = TSDB_ORDER_ASC;
 
   TAOS_FIELD f = {.type = TSDB_DATA_TYPE_BINARY, .bytes = (TSDB_COL_NAME_LEN - 1) + VARSTR_HEADER_SIZE};
@@ -199,7 +199,7 @@ static int32_t tscBuildTableSchemaResultFields(SSqlObj *pSql, int32_t numOfCols,
 }
 
 static int32_t tscProcessDescribeTable(SSqlObj *pSql) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   
   assert(tscGetMetaInfo(pQueryInfo, 0)->pTableMeta != NULL);
 
@@ -389,7 +389,7 @@ static int32_t tscSCreateBuildResultFields(SSqlObj *pSql, BuildType type, const
   SColumnIndex index = {0};
   pSql->cmd.numOfCols = 2;
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   pQueryInfo->order.order = TSDB_ORDER_ASC;
 
   TAOS_FIELD f; 
@@ -427,7 +427,7 @@ static int32_t tscSCreateBuildResultFields(SSqlObj *pSql, BuildType type, const
 static int32_t tscSCreateSetValueToResObj(SSqlObj *pSql, int32_t rowLen, const char *tableName, const char *ddl) {
   SSqlRes *pRes = &pSql->res;
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   int32_t numOfRows = 1;
   if (strlen(ddl) == 0) {
     
@@ -444,7 +444,7 @@ static int32_t tscSCreateSetValueToResObj(SSqlObj *pSql, int32_t rowLen, const c
   return 0;
 }
 static int32_t tscSCreateBuildResult(SSqlObj *pSql, BuildType type, const char *str, const char *result) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   int32_t rowLen = tscSCreateBuildResultFields(pSql, type, result);
 
   tscFieldInfoUpdateOffset(pQueryInfo);
@@ -531,7 +531,7 @@ static int32_t tscGetTableTagColumnName(SSqlObj *pSql, char **result) {
   }
   buf[0] = 0;
 
-  STableMeta *pMeta = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0, 0)->pTableMeta; 
+  STableMeta *pMeta = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0)->pTableMeta;
   if (pMeta->tableType == TSDB_SUPER_TABLE || pMeta->tableType == TSDB_NORMAL_TABLE ||
       pMeta->tableType == TSDB_STREAM_TABLE) {
     free(buf);
@@ -552,7 +552,7 @@ static int32_t tscGetTableTagColumnName(SSqlObj *pSql, char **result) {
   return TSDB_CODE_SUCCESS;
 }  
 static int32_t tscRebuildDDLForSubTable(SSqlObj *pSql, const char *tableName, char *ddl) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   STableMeta *    pMeta = pTableMetaInfo->pTableMeta;
@@ -606,7 +606,7 @@ static int32_t tscRebuildDDLForSubTable(SSqlObj *pSql, const char *tableName, ch
 }
 
 static int32_t tscRebuildDDLForNormalTable(SSqlObj *pSql, const char *tableName, char *ddl) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   STableMeta *    pMeta = pTableMetaInfo->pTableMeta;
 
@@ -633,7 +633,7 @@ static int32_t tscRebuildDDLForNormalTable(SSqlObj *pSql, const char *tableName,
 }
 static int32_t tscRebuildDDLForSuperTable(SSqlObj *pSql, const char *tableName, char *ddl) {
   char *result = ddl;
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   STableMeta *    pMeta = pTableMetaInfo->pTableMeta;
 
@@ -674,7 +674,7 @@ static int32_t tscRebuildDDLForSuperTable(SSqlObj *pSql, const char *tableName,
 }
 
 static int32_t tscProcessShowCreateTable(SSqlObj *pSql) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   assert(pTableMetaInfo->pTableMeta != NULL);
 
@@ -700,7 +700,7 @@ static int32_t tscProcessShowCreateTable(SSqlObj *pSql) {
 }
 
 static int32_t tscProcessShowCreateDatabase(SSqlObj *pSql) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
@@ -727,7 +727,7 @@ static int32_t tscProcessShowCreateDatabase(SSqlObj *pSql) {
   return TSDB_CODE_TSC_ACTION_IN_PROGRESS;
 }
 static int32_t tscProcessCurrentUser(SSqlObj *pSql) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
   SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
   pExpr->resBytes = TSDB_USER_LEN + TSDB_DATA_TYPE_BINARY;
@@ -754,7 +754,7 @@ static int32_t tscProcessCurrentDB(SSqlObj *pSql) {
   extractDBName(pSql->pTscObj->db, db);
   pthread_mutex_unlock(&pSql->pTscObj->mutex);
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, pSql->cmd.clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
   SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
   pExpr->resType = TSDB_DATA_TYPE_BINARY;
@@ -781,7 +781,7 @@ static int32_t tscProcessCurrentDB(SSqlObj *pSql) {
 
 static int32_t tscProcessServerVer(SSqlObj *pSql) {
   const char* v = pSql->pTscObj->sversion;
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, pSql->cmd.clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
   SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
   pExpr->resType = TSDB_DATA_TYPE_BINARY;
@@ -804,7 +804,7 @@ static int32_t tscProcessServerVer(SSqlObj *pSql) {
 }
 
 static int32_t tscProcessClientVer(SSqlObj *pSql) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
   SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
   pExpr->resType = TSDB_DATA_TYPE_BINARY;
@@ -856,7 +856,7 @@ static int32_t tscProcessServStatus(SSqlObj *pSql) {
     return pSql->res.code;
   }
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   SSqlExpr* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
 
   int32_t val = 1;
@@ -870,7 +870,7 @@ void tscSetLocalQueryResult(SSqlObj *pSql, const char *val, const char *columnNa
 
   pCmd->numOfCols = 1;
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
   pQueryInfo->order.order = TSDB_ORDER_ASC;
 
   tscFieldInfoClear(&pQueryInfo->fieldsInfo);
diff --git a/src/client/src/tscLocalMerge.c b/src/client/src/tscLocalMerge.c
index 187352e306..2dbc09f08d 100644
--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -139,7 +139,7 @@ int32_t tscCreateLocalMerger(tExtMemBuffer **pMemBuffer, int32_t numOfBuffer, tO
 #ifdef _DEBUG_VIEW
       printf("load data page into mem for build loser tree: %" PRIu64 " rows\n", ds->filePage.num);
       SSrcColumnInfo colInfo[256] = {0};
-      SQueryInfo *   pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+      SQueryInfo *   pQueryInfo = tscGetQueryInfo(pCmd);
 
       tscGetSrcColumnInfo(colInfo, pQueryInfo);
 
diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index 5509610873..195c310be5 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -748,7 +748,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
   const int32_t STABLE_INDEX = 1;
   
   SSqlCmd *   pCmd = &pSql->cmd;
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
 
   char *sql = *sqlstr;
 
@@ -1071,7 +1071,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
   int32_t totalNum = 0;
   int32_t code = TSDB_CODE_SUCCESS;
 
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
   assert(pQueryInfo != NULL);
 
   STableMetaInfo *pTableMetaInfo = (pQueryInfo->numOfTables == 0)? tscAddEmptyMetaInfo(pQueryInfo):tscGetMetaInfo(pQueryInfo, 0);
@@ -1219,7 +1219,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
         }
       } else {  // bindedColumns != NULL
         // insert into tablename(col1, col2,..., coln) values(v1, v2,... vn);
-        STableMeta *pTableMeta = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0)->pTableMeta;
+        STableMeta *pTableMeta = tscGetTableMetaInfoFromCmd(pCmd, 0)->pTableMeta;
 
         if (validateDataSource(pCmd, DATA_FROM_SQL_STRING, sToken.z) != TSDB_CODE_SUCCESS) {
           goto _clean;
@@ -1363,7 +1363,7 @@ static int doPackSendDataBlock(SSqlObj *pSql, int32_t numOfRows, STableDataBlock
   SSqlCmd *pCmd = &pSql->cmd;
   pSql->res.numOfRows = 0;
 
-  STableMeta *pTableMeta = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0)->pTableMeta;
+  STableMeta *pTableMeta = tscGetTableMetaInfoFromCmd(pCmd, 0)->pTableMeta;
 
   SSubmitBlk *pBlocks = (SSubmitBlk *)(pTableDataBlocks->pData);
   code = tsSetBlockInfo(pBlocks, pTableMeta, numOfRows);
@@ -1425,7 +1425,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int32_t numOfRow
   // accumulate the total submit records
   pParentSql->res.numOfRows += pSql->res.numOfRows;
 
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
   STableMeta *    pTableMeta = pTableMetaInfo->pTableMeta;
   STableComInfo   tinfo = tscGetTableInfo(pTableMeta);
 
diff --git a/src/client/src/tscPrepare.c b/src/client/src/tscPrepare.c
index c25263d399..50c79ccff1 100644
--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -696,7 +696,7 @@ static int doBindParam(char* data, SParamInfo* param, TAOS_BIND* bind) {
 static int insertStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) {
   SSqlCmd* pCmd = &stmt->pSql->cmd;
 
-  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
 
   STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
   if (pCmd->pTableBlockHashList == NULL) {
@@ -763,7 +763,7 @@ static int insertStmtReset(STscStmt* pStmt) {
   }
   pCmd->batchSize = 0;
 
-  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
   pTableMetaInfo->vgroupIndex = 0;
   return TSDB_CODE_SUCCESS;
 }
@@ -778,7 +778,7 @@ static int insertStmtExecute(STscStmt* stmt) {
     return TSDB_CODE_SUCCESS;
   }
 
-  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
 
   STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
   if (pCmd->pTableBlockHashList == NULL) {
@@ -1057,7 +1057,7 @@ int taos_stmt_get_param(TAOS_STMT *stmt, int idx, int *type, int *bytes) {
 
   if (pStmt->isInsert) {
     SSqlCmd* pCmd = &pStmt->pSql->cmd;
-    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0, 0);
+    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
     STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
     if (pCmd->pTableBlockHashList == NULL) {
       pCmd->pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 387a348f34..676dc51cb0 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -619,32 +619,32 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
     case TSDB_SQL_SELECT: {
       const char* msg1 = "columns in select clause not identical";
-      int32_t code = loadAllTableMeta(pSql, pInfo);
+
+      code = loadAllTableMeta(pSql, pInfo);
       if (code != TSDB_CODE_SUCCESS) {
         return code;
       }
 
-      SQueryInfo* pCurrent = pCmd->pQueryInfo;
-      for(int32_t i = 0; i < pCmd->clauseIndex; ++i) {
-        pCurrent = pCurrent->sibling;
-      }
+      pQueryInfo = tscGetQueryInfo(pCmd);
 
       size_t size = taosArrayGetSize(pInfo->list);
-      for (int32_t i = pCmd->clauseIndex; i < size; ++i) {
+      for (int32_t i = 0; i < size; ++i) {
         SSqlNode* pSqlNode = taosArrayGetP(pInfo->list, i);
-        tscTrace("%p start to parse %dth subclause, total:%d", pSql, i, (int32_t) size);
-        if ((code = validateSqlNode(pSql, pSqlNode, pCurrent)) != TSDB_CODE_SUCCESS) {
+
+        tscTrace("%p start to parse %dth subclause, total:%"PRId64, pSql, i, size);
+        if ((code = validateSqlNode(pSql, pSqlNode, pQueryInfo)) != TSDB_CODE_SUCCESS) {
           return code;
         }
 
         tscPrintSelNodeList(pSql, i);
         pCmd->clauseIndex += 1;
-        if (i+1 < size && pCurrent->sibling == NULL) {
+
+        if ((i + 1) < size && pQueryInfo->sibling == NULL) {
           if ((code = tscAddQueryInfo(pCmd)) != TSDB_CODE_SUCCESS) {
             return code;
           }
 
-          pCurrent = pCmd->active;
+          pQueryInfo = pCmd->active;
         }
       }
 
@@ -1202,7 +1202,7 @@ bool validateOneTags(SSqlCmd* pCmd, TAOS_FIELD* pTagField) {
   const char* msg5 = "invalid binary/nchar tag length";
   const char* msg6 = "invalid data type in tags";
 
-  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
   STableMeta*     pTableMeta = pTableMetaInfo->pTableMeta;
 
   int32_t numOfTags = tscGetNumOfTags(pTableMeta);
@@ -1275,7 +1275,7 @@ bool validateOneColumn(SSqlCmd* pCmd, TAOS_FIELD* pColField) {
   const char* msg6 = "invalid column length";
 
 //  assert(pCmd->numOfClause == 1);
-  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
   STableMeta*     pTableMeta = pTableMetaInfo->pTableMeta;
   
   int32_t numOfTags = tscGetNumOfTags(pTableMeta);
@@ -2649,7 +2649,7 @@ int32_t getColumnIndexByName(SSqlCmd* pCmd, const SStrToken* pToken, SQueryInfo*
 
 int32_t setShowInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   SSqlCmd*        pCmd = &pSql->cmd;
-  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
 //  assert(pCmd->numOfClause == 1);
 
   pCmd->command = TSDB_SQL_SHOW;
@@ -5059,7 +5059,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
   SSqlCmd*        pCmd = &pSql->cmd;
   SAlterTableInfo* pAlterSQL = pInfo->pAlterInfo;
-  SQueryInfo*     pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo*     pQueryInfo = tscGetQueryInfo(pCmd);
 
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, DEFAULT_TABLE_INDEX);
 
@@ -5747,10 +5747,10 @@ int32_t parseCreateDBOptions(SSqlCmd* pCmd, SCreateDbInfo* pCreateDbSql) {
 }
 
 void addGroupInfoForSubquery(SSqlObj* pParentObj, SSqlObj* pSql, int32_t subClauseIndex, int32_t tableIndex) {
-  SQueryInfo* pParentQueryInfo = tscGetQueryInfo(&pParentObj->cmd, subClauseIndex);
+  SQueryInfo* pParentQueryInfo = tscGetQueryInfo(&pParentObj->cmd);
 
   if (pParentQueryInfo->groupbyExpr.numOfGroupCols > 0) {
-    SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, subClauseIndex);
+    SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
     SExprInfo* pExpr = NULL;
 
     size_t size = taosArrayGetSize(pQueryInfo->exprList);
@@ -6369,7 +6369,7 @@ int32_t tscCheckCreateDbParams(SSqlCmd* pCmd, SCreateDbMsg* pCreate) {
 
 // for debug purpose
 void tscPrintSelNodeList(SSqlObj* pSql, int32_t subClauseIndex) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, subClauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
   int32_t size = (int32_t)tscNumOfExprs(pQueryInfo);
   if (size == 0) {
@@ -6411,7 +6411,7 @@ int32_t doCheckForCreateTable(SSqlObj* pSql, int32_t subClauseIndex, SSqlInfo* p
   const char* msg1 = "invalid table name";
 
   SSqlCmd*        pCmd = &pSql->cmd;
-  SQueryInfo*     pQueryInfo = tscGetQueryInfo(pCmd, subClauseIndex);
+  SQueryInfo*     pQueryInfo = tscGetQueryInfo(pCmd);
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
   SCreateTableSql* pCreateTable = pInfo->pCreateTableInfo;
@@ -6470,7 +6470,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
   SSqlCmd* pCmd = &pSql->cmd;
 
   SCreateTableSql* pCreateTable = pInfo->pCreateTableInfo;
-  SQueryInfo*      pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo*      pQueryInfo = tscGetQueryInfo(pCmd);
 
   // two table: the first one is for current table, and the secondary is for the super table.
   if (pQueryInfo->numOfTables < 2) {
@@ -6673,7 +6673,7 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
   const char* msg7 = "time interval is required";
   
   SSqlCmd*    pCmd = &pSql->cmd;
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
   assert(pQueryInfo->numOfTables == 1);
 
   SCreateTableSql* pCreateTable = pInfo->pCreateTableInfo;
@@ -7301,6 +7301,57 @@ static STableMeta* extractTempTableMetaFromSubquery(SQueryInfo* pUpstream) {
   return meta;
 }
 
+static int32_t doValidateSubquery(SSqlNode* pSqlNode, int32_t index, SSqlObj* pSql, SQueryInfo* pQueryInfo, char* msgBuf) {
+  SRelElementPair* subInfo = taosArrayGet(pSqlNode->from->list, index);
+
+  // union all is not support currently
+  SSqlNode* p = taosArrayGetP(subInfo->pSubquery, 0);
+
+  SQueryInfo* pSub = calloc(1, sizeof(SQueryInfo));
+  tscInitQueryInfo(pSub);
+
+  int32_t code = validateSqlNode(pSql, p, pSub);
+  assert(code != TSDB_CODE_TSC_ACTION_IN_PROGRESS);
+  if (code != TSDB_CODE_SUCCESS) {
+    return code;
+  }
+
+  pSub->pDownstream = pQueryInfo;
+
+  // create dummy table meta info
+  STableMetaInfo* pTableMetaInfo1 = calloc(1, sizeof(STableMetaInfo));
+  pTableMetaInfo1->pTableMeta = extractTempTableMetaFromSubquery(pSub);
+
+  if (subInfo->aliasName.n > 0) {
+    if (subInfo->aliasName.n >= TSDB_TABLE_FNAME_LEN) {
+      return invalidSqlErrMsg(msgBuf, "subquery alias name too long");
+    }
+
+    strncpy(pTableMetaInfo1->aliasName, subInfo->aliasName.z, subInfo->aliasName.n);
+  }
+
+  taosArrayPush(pQueryInfo->pUpstream, &pSub);
+
+  // NOTE: order mix up in subquery not support yet.
+  pQueryInfo->order = pSub->order;
+
+  char* tmp = realloc(pQueryInfo->pTableMetaInfo, (pQueryInfo->numOfTables + 1) * POINTER_BYTES);
+  if (tmp == NULL) {
+    return TSDB_CODE_TSC_OUT_OF_MEMORY;
+  }
+
+  pQueryInfo->pTableMetaInfo[pQueryInfo->numOfTables] = pTableMetaInfo1;
+  pQueryInfo->numOfTables += 1;
+
+  // all columns are added into the table column list
+  STableMeta* pMeta = pTableMetaInfo1->pTableMeta;
+  for(int32_t i = 0; i < pMeta->tableInfo.numOfColumns; ++i) {
+    tscColumnListInsert(pQueryInfo->colList, i, pMeta->id.uid, &pMeta->schema[i]);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
 int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInfo) {
   assert(pSqlNode != NULL && (pSqlNode->from == NULL || taosArrayGetSize(pSqlNode->from->list) > 0));
 
@@ -7319,10 +7370,10 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
 
   /*
    * handle the sql expression without from subclause
-   * select current_database();
+   * select server_status();
    * select server_version();
    * select client_version();
-   * select server_state();
+   * select current_database();
    */
   if (pSqlNode->from == NULL) {
     assert(pSqlNode->fillType == NULL && pSqlNode->pGroupby == NULL && pSqlNode->pWhere == NULL &&
@@ -7331,61 +7382,30 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
   }
 
   if (pSqlNode->from->type == SQL_NODE_FROM_SUBQUERY) {
+    pQueryInfo->numOfTables = 0;
+
     // parse the subquery in the first place
-    int32_t numOfSub = taosArrayGetSize(pSqlNode->from->list);
-
-    SRelElementPair* sub = taosArrayGet(pSqlNode->from->list, 0);
-    SSqlNode* p = taosArrayGetP(sub->pSubquery, 0);
-
-    code = validateSqlNode(pSql, p, pQueryInfo);
-    if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS || code != TSDB_CODE_SUCCESS) {
-      return code;
-    }
-
-    SQueryInfo* current = calloc(1, sizeof(SQueryInfo));
-
-    tscInitQueryInfo(current);
-    taosArrayPush(current->pUpstream, &pQueryInfo);
-
-    STableMeta* pTableMeta = extractTempTableMetaFromSubquery(pQueryInfo);
-    STableMetaInfo* pTableMetaInfo1 = calloc(1, sizeof(STableMetaInfo));
-    pTableMetaInfo1->pTableMeta = pTableMeta;
-
-    if (sub->aliasName.n > 0) {
-      if (sub->aliasName.n > TSDB_TABLE_FNAME_LEN) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), "subquery alias name too long");
+    int32_t numOfSub = (int32_t) taosArrayGetSize(pSqlNode->from->list);
+    for(int32_t i = 0; i < numOfSub; ++i) {
+      code = doValidateSubquery(pSqlNode, i, pSql, pQueryInfo, tscGetErrorMsgPayload(pCmd));
+      if (code != TSDB_CODE_SUCCESS) {
+        return code;
       }
-      strncpy(pTableMetaInfo1->aliasName, sub->aliasName.z, sub->aliasName.n);
     }
 
-    current->pTableMetaInfo = calloc(numOfSub, POINTER_BYTES);
-
-    current->pTableMetaInfo[0] = pTableMetaInfo1;
-    current->numOfTables = 1;
-    current->order = pQueryInfo->order;
-
-    pCmd->pQueryInfo = current;
-    pQueryInfo->pDownstream = current;
-
-    if (validateSelectNodeList(pCmd, current, pSqlNode->pSelNodeList, false, false, false) != TSDB_CODE_SUCCESS) {
+    if (validateSelectNodeList(pCmd, pQueryInfo, pSqlNode->pSelNodeList, false, false, false) != TSDB_CODE_SUCCESS) {
       return TSDB_CODE_TSC_INVALID_SQL;
     }
 
-    // all columns are added into the table column list
-    for(int32_t i = 0; i < pTableMeta->tableInfo.numOfColumns; ++i) {
-      tscColumnListInsert(current->colList, i, pTableMetaInfo1->pTableMeta->id.uid,
-                          &pTableMetaInfo1->pTableMeta->schema[i]);
-    }
-
     if (pSqlNode->pWhere != NULL) {
-      if (validateWhereNode(current, &pSqlNode->pWhere, pSql) != TSDB_CODE_SUCCESS) {
+      if (validateWhereNode(pQueryInfo, &pSqlNode->pWhere, pSql) != TSDB_CODE_SUCCESS) {
         return TSDB_CODE_TSC_INVALID_SQL;
       }
 
-      pSqlNode->pWhere = NULL;
+      STableMeta* pTableMeta = tscGetMetaInfo(pQueryInfo, 0)->pTableMeta;
       if (pTableMeta->tableInfo.precision == TSDB_TIME_PRECISION_MILLI) {
-        current->window.skey = current->window.skey / 1000;
-        current->window.ekey = current->window.ekey / 1000;
+        pQueryInfo->window.skey = pQueryInfo->window.skey / 1000;
+        pQueryInfo->window.ekey = pQueryInfo->window.ekey / 1000;
       }
     }
   } else {
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 1b5a0b2445..ae836299e1 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -116,7 +116,7 @@ static void tscDumpEpSetFromVgroupInfo(SRpcEpSet *pEpSet, SNewVgroupInfo *pVgrou
 
 static void tscUpdateVgroupInfo(SSqlObj *pSql, SRpcEpSet *pEpSet) {
   SSqlCmd *pCmd = &pSql->cmd;
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
   if (pTableMetaInfo == NULL || pTableMetaInfo->pTableMeta == NULL) {
     return;
   }
@@ -335,7 +335,7 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {
     return;
   }
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  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);
@@ -506,7 +506,7 @@ int tscBuildAndSendRequest(SSqlObj *pSql, SQueryInfo* pQueryInfo) {
   uint32_t type = 0;
 
   if (pQueryInfo == NULL) {
-     pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+     pQueryInfo = tscGetQueryInfo(pCmd);
   }
 
   STableMetaInfo *pTableMetaInfo = NULL;
@@ -581,7 +581,7 @@ int tscBuildFetchMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 }
 
 int tscBuildSubmitMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   STableMeta* pTableMeta = tscGetMetaInfo(pQueryInfo, 0)->pTableMeta;
   
   char* pMsg = pSql->cmd.payload;
@@ -620,7 +620,7 @@ static int32_t tscEstimateQueryMsgSize(SSqlObj *pSql, int32_t clauseIndex) {
   const static int32_t MIN_QUERY_MSG_PKT_SIZE = TSDB_MAX_BYTES_PER_ROW * 5;
 
   SSqlCmd* pCmd = &pSql->cmd;
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, clauseIndex);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
 
   int32_t srcColListSize = (int32_t)(taosArrayGetSize(pQueryInfo->colList) * sizeof(SColumnInfo));
 
@@ -630,7 +630,6 @@ static int32_t tscEstimateQueryMsgSize(SSqlObj *pSql, int32_t clauseIndex) {
   int32_t tsBufSize = (pQueryInfo->tsBuf != NULL) ? pQueryInfo->tsBuf->fileSize : 0;
   int32_t sqlLen = (int32_t) strlen(pSql->sqlstr) + 1;
 
-
   int32_t tableSerialize = 0;
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   if (pTableMetaInfo->pVgroupTables != NULL) {
@@ -1051,7 +1050,7 @@ int32_t tscBuildCreateDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SCreateDbMsg *pCreateDbMsg = (SCreateDbMsg *)pCmd->payload;
 
 //  assert(pCmd->numOfClause == 1);
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
   int32_t code = tNameExtractFullName(&pTableMetaInfo->name, pCreateDbMsg->db);
   assert(code == TSDB_CODE_SUCCESS);
 
@@ -1171,7 +1170,7 @@ int32_t tscBuildDropDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   SDropDbMsg *pDropDbMsg = (SDropDbMsg*)pCmd->payload;
 
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
 
   int32_t code = tNameExtractFullName(&pTableMetaInfo->name, pDropDbMsg->db);
   assert(code == TSDB_CODE_SUCCESS && pTableMetaInfo->name.type == TSDB_DB_NAME_T);
@@ -1192,7 +1191,7 @@ int32_t tscBuildDropTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   }
 
   SCMDropTableMsg *pDropTableMsg = (SCMDropTableMsg*)pCmd->payload;
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
   tNameExtractFullName(&pTableMetaInfo->name, pDropTableMsg->name);
 
   pDropTableMsg->igNotExists = pInfo->pMiscInfo->existsCheck ? 1 : 0;
@@ -1249,7 +1248,7 @@ int32_t tscBuildUseDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   }
 
   SUseDbMsg *pUseDbMsg = (SUseDbMsg *)pCmd->payload;
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
   tNameExtractFullName(&pTableMetaInfo->name, pUseDbMsg->db);
   pCmd->msgType = TSDB_MSG_TYPE_CM_USE_DB;
 
@@ -1266,7 +1265,7 @@ int32_t tscBuildSyncDbReplicaMsg(SSqlObj* pSql, SSqlInfo *pInfo) {
   }
 
   SSyncDbMsg *pSyncMsg = (SSyncDbMsg *)pCmd->payload;
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
   tNameExtractFullName(&pTableMetaInfo->name, pSyncMsg->db);
   pCmd->msgType = TSDB_MSG_TYPE_CM_SYNC_DB;
 
@@ -1286,7 +1285,7 @@ int32_t tscBuildShowMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   SShowMsg *pShowMsg = (SShowMsg *)pCmd->payload;
 
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
 
   if (tNameIsEmpty(&pTableMetaInfo->name)) {    
     pthread_mutex_lock(&pObj->mutex);
@@ -1360,7 +1359,7 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSchema *pSchema;
   SSqlCmd *pCmd = &pSql->cmd;
 
-  SQueryInfo     *pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo     *pQueryInfo = tscGetQueryInfo(pCmd);
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
   // Reallocate the payload size
@@ -1449,7 +1448,7 @@ int tscBuildCreateTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 }
 
 int tscEstimateAlterTableMsgLength(SSqlCmd *pCmd) {
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
   return minMsgSize() + sizeof(SAlterTableMsg) + sizeof(SSchema) * tscNumOfFields(pQueryInfo) + TSDB_EXTRA_PAYLOAD_SIZE;
 }
 
@@ -1458,7 +1457,7 @@ int tscBuildAlterTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   int   msgLen = 0;
 
   SSqlCmd    *pCmd = &pSql->cmd;
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
 
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   
@@ -1507,7 +1506,7 @@ int tscBuildUpdateTagMsg(SSqlObj* pSql, SSqlInfo *pInfo) {
   SUpdateTableTagValMsg* pUpdateMsg = (SUpdateTableTagValMsg*) pCmd->payload;
   pCmd->payloadLen = htonl(pUpdateMsg->head.contLen);
 
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
   STableMeta *pTableMeta = tscGetMetaInfo(pQueryInfo, 0)->pTableMeta;
 
   SNewVgroupInfo vgroupInfo = {.vgId = -1};
@@ -1527,7 +1526,7 @@ int tscAlterDbMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SAlterDbMsg *pAlterDbMsg = (SAlterDbMsg* )pCmd->payload;
   pAlterDbMsg->dbType = -1;
   
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
   tNameExtractFullName(&pTableMetaInfo->name, pAlterDbMsg->db);
 
   return TSDB_CODE_SUCCESS;
@@ -1543,7 +1542,7 @@ int tscBuildRetrieveFromMgmtMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
   SRetrieveTableMsg *pRetrieveMsg = (SRetrieveTableMsg*)pCmd->payload;
   pRetrieveMsg->qId  = htobe64(pSql->res.qId);
   pRetrieveMsg->free = htons(pQueryInfo->type);
@@ -1567,7 +1566,7 @@ static int tscLocalResultCommonBuilder(SSqlObj *pSql, int32_t numOfRes) {
     pRes->row = 0;
     pRes->rspType = 1;
 
-    SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+    SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
     if (tscCreateResPointerInfo(pRes, pQueryInfo) != TSDB_CODE_SUCCESS) {
       return pRes->code;
     }
@@ -1591,7 +1590,7 @@ static int tscLocalResultCommonBuilder(SSqlObj *pSql, int32_t numOfRes) {
 
 int tscProcessDescribeTableRsp(SSqlObj *pSql) {
   SSqlCmd *       pCmd = &pSql->cmd;
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
 
   STableComInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
   
@@ -1645,7 +1644,7 @@ int tscProcessRetrieveLocalMergeRsp(SSqlObj *pSql) {
   qTableQuery(pQueryInfo->pQInfo, &localQueryId);
   convertQueryResult(pRes, pQueryInfo);
 
-  handleDownstreamOperator(pRes, pQueryInfo);
+//  handleDownstreamOperator(pRes, pQueryInfo);
 
   code = pRes->code;
   if (pRes->code == TSDB_CODE_SUCCESS) {
@@ -1693,7 +1692,7 @@ int tscBuildConnectMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
 int tscBuildTableMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd    *pCmd = &pSql->cmd;
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   STableInfoMsg  *pInfoMsg = (STableInfoMsg *)pCmd->payload;
@@ -1755,14 +1754,14 @@ int tscBuildSTableVgroupMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
   
   char* pMsg = pCmd->payload;
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
 
   SSTableVgroupMsg *pStableVgroupMsg = (SSTableVgroupMsg *)pMsg;
   pStableVgroupMsg->numOfTables = htonl(pQueryInfo->numOfTables);
   pMsg += sizeof(SSTableVgroupMsg);
 
   for (int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
-    STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, i);
+    STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, i);
     int32_t code = tNameExtractFullName(&pTableMetaInfo->name, pMsg);
     assert(code == TSDB_CODE_SUCCESS);
 
@@ -1918,7 +1917,7 @@ int tscProcessTableMetaRsp(SSqlObj *pSql) {
     return code;
   }
 
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0);
   assert(pTableMetaInfo->pTableMeta == NULL);
 
   STableMeta* pTableMeta = tscCreateTableMetaFromMsg(pMetaMsg);
@@ -2085,7 +2084,7 @@ int tscProcessSTableVgroupRsp(SSqlObj *pSql) {
   
   SSqlCmd* pCmd = &parent->cmd;
   for(int32_t i = 0; i < pStableVgroup->numOfTables; ++i) {
-    STableMetaInfo *pInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, i);
+    STableMetaInfo *pInfo = tscGetTableMetaInfoFromCmd(pCmd, i);
 
     SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *) pMsg;
     pVgroupMsg->numOfVgroups = htonl(pVgroupMsg->numOfVgroups);
@@ -2148,7 +2147,7 @@ int tscProcessShowRsp(SSqlObj *pSql) {
   SSqlRes *pRes = &pSql->res;
   SSqlCmd *pCmd = &pSql->cmd;
 
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
 
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
@@ -2274,7 +2273,7 @@ int tscProcessConnectRsp(SSqlObj *pSql) {
 
 int tscProcessUseDbRsp(SSqlObj *pSql) {
   STscObj *       pObj = pSql->pTscObj;
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0);
   
   pthread_mutex_lock(&pObj->mutex);
   int ret = tNameExtractFullName(&pTableMetaInfo->name, pObj->db);
@@ -2292,7 +2291,7 @@ int tscProcessDropDbRsp(SSqlObj *pSql) {
 }
 
 int tscProcessDropTableRsp(SSqlObj *pSql) {
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0);
 
   //The cached tableMeta is expired in this case, so clean it in hash table
   char name[TSDB_TABLE_FNAME_LEN] = {0};
@@ -2306,7 +2305,7 @@ int tscProcessDropTableRsp(SSqlObj *pSql) {
 }
 
 int tscProcessAlterTableMsgRsp(SSqlObj *pSql) {
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0);
 
   char name[TSDB_TABLE_FNAME_LEN] = {0};
   tNameExtractFullName(&pTableMetaInfo->name, name);
@@ -2380,7 +2379,7 @@ int tscProcessRetrieveRspFromNode(SSqlObj *pSql) {
     tscSetResRawPtr(pRes, pQueryInfo);
   }
 
-  handleDownstreamOperator(pRes, pQueryInfo);
+//  handleDownstreamOperator(pRes, pQueryInfo);
 
   if (pSql->pSubscription != NULL) {
     int32_t numOfCols = pQueryInfo->fieldsInfo.numOfOutput;
@@ -2583,7 +2582,7 @@ int tscGetTableMetaEx(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo, bool create
 int tscRenewTableMeta(SSqlObj *pSql, int32_t tableIndex) {
   SSqlCmd *pCmd = &pSql->cmd;
 
-  SQueryInfo     *pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo     *pQueryInfo = tscGetQueryInfo(pCmd);
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, tableIndex);
 
   char name[TSDB_TABLE_FNAME_LEN] = {0};
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index 8e89198952..99613b1e77 100644
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -373,7 +373,7 @@ int taos_num_fields(TAOS_RES *res) {
   if (pSql == NULL || pSql->signature != pSql) return 0;
 
   int32_t num = 0;
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   if (pQueryInfo == NULL) {
     return num;
   }
@@ -412,7 +412,7 @@ TAOS_FIELD *taos_fetch_fields(TAOS_RES *res) {
   SSqlRes *pRes = &pSql->res;
   if (pSql == NULL || pSql->signature != pSql) return 0;
 
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   if (pQueryInfo == NULL) {
     return NULL;
   }
@@ -563,7 +563,7 @@ static bool tscKillQueryInDnode(SSqlObj* pSql) {
     return true;
   }
 
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
 
   if ((pQueryInfo == NULL) || tscIsTwoStageSTableQuery(pQueryInfo, 0)) {
     return true;
@@ -676,7 +676,7 @@ char *taos_get_client_info() { return version; }
 static void tscKillSTableQuery(SSqlObj *pSql) {
   SSqlCmd* pCmd = &pSql->cmd;
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
 
   if (!tscIsTwoStageSTableQuery(pQueryInfo, 0)) {
     return;
@@ -727,7 +727,7 @@ void taos_stop_query(TAOS_RES *res) {
   // set the error code for master pSqlObj firstly
   pSql->res.code = TSDB_CODE_TSC_QUERY_CANCELLED;
 
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
 
   if (tscIsTwoStageSTableQuery(pQueryInfo, 0)) {
     assert(pSql->rpcRid <= 0);
@@ -757,7 +757,7 @@ bool taos_is_null(TAOS_RES *res, int32_t row, int32_t col) {
     return true;
   }
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   if (pQueryInfo == NULL) {
     return true;
   }
diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c
index f05956529f..a4bec4c9fc 100644
--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@@ -89,7 +89,7 @@ static void doLaunchQuery(void* param, TAOS_RES* tres, int32_t code) {
     return;
   }
 
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
   code = tscGetTableMeta(pSql, pTableMetaInfo);
@@ -138,7 +138,7 @@ static void tscProcessStreamTimer(void *handle, void *tmrId) {
 
   pStream->numOfRes = 0;  // reset the numOfRes.
   SSqlObj *pSql = pStream->pSql;
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   tscDebug("0x%"PRIx64" timer launch query", pSql->self);
 
   if (pStream->isProject) {
@@ -197,7 +197,7 @@ static void tscProcessStreamQueryCallback(void *param, TAOS_RES *tres, int numOf
     tscError("0x%"PRIx64" stream:%p, query data failed, code:0x%08x, retry in %" PRId64 "ms", pStream->pSql->self,
         pStream, numOfRows, retryDelay);
 
-    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pStream->pSql->cmd, 0, 0);
+    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pStream->pSql->cmd, 0);
 
     char name[TSDB_TABLE_FNAME_LEN] = {0};
     tNameExtractFullName(&pTableMetaInfo->name, name);
@@ -224,7 +224,7 @@ static void tscProcessStreamQueryCallback(void *param, TAOS_RES *tres, int numOf
 static void tscStreamFillTimeGap(SSqlStream* pStream, TSKEY ts) {
 #if 0
   SSqlObj *   pSql = pStream->pSql;
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   
   if (pQueryInfo->fillType != TSDB_FILL_SET_VALUE && pQueryInfo->fillType != TSDB_FILL_NULL) {
     return;
@@ -273,7 +273,7 @@ static void tscProcessStreamRetrieveResult(void *param, TAOS_RES *res, int numOf
     return;
   }
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   STableMetaInfo *pTableMetaInfo = pQueryInfo->pTableMetaInfo[0];
 
   if (numOfRows > 0) { // when reaching here the first execution of stream computing is successful.
@@ -444,7 +444,7 @@ static int32_t tscSetSlidingWindowInfo(SSqlObj *pSql, SSqlStream *pStream) {
   int64_t minIntervalTime =
       (pStream->precision == TSDB_TIME_PRECISION_MICRO) ? tsMinIntervalTime * 1000L : tsMinIntervalTime;
   
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
   if (!pStream->isProject && pQueryInfo->interval.interval == 0) {
     sprintf(pSql->cmd.payload, "the interval value is 0");
@@ -494,7 +494,7 @@ static int32_t tscSetSlidingWindowInfo(SSqlObj *pSql, SSqlStream *pStream) {
 }
 
 static int64_t tscGetStreamStartTimestamp(SSqlObj *pSql, SSqlStream *pStream, int64_t stime) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   
   if (pStream->isProject) {
     // no data in table, flush all data till now to destination meter, 10sec delay
@@ -556,7 +556,7 @@ static void tscCreateStream(void *param, TAOS_RES *res, int code) {
     return;
   }
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   STableComInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
   
diff --git a/src/client/src/tscSub.c b/src/client/src/tscSub.c
index 6928058f23..9743e12c1e 100644
--- a/src/client/src/tscSub.c
+++ b/src/client/src/tscSub.c
@@ -266,7 +266,7 @@ static int tscUpdateSubscription(STscObj* pObj, SSub* pSub) {
 
   pSub->lastSyncTime = taosGetTimestampMs();
 
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
   if (UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo)) {
     STableMeta * pTableMeta = pTableMetaInfo->pTableMeta;
     SSubscriptionProgress target = {.uid = pTableMeta->id.uid, .key = 0};
@@ -284,7 +284,7 @@ static int tscUpdateSubscription(STscObj* pObj, SSub* pSub) {
   }
   size_t numOfTables = taosArrayGetSize(tables);
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
   SArray* progress = taosArrayInit(numOfTables, sizeof(SSubscriptionProgress));
   for( size_t i = 0; i < numOfTables; i++ ) {
     STidTags* tt = taosArrayGet( tables, i );
@@ -304,7 +304,7 @@ static int tscUpdateSubscription(STscObj* pObj, SSub* pSub) {
   }
   taosArrayDestroy(tables);
 
-  TSDB_QUERY_SET_TYPE(tscGetQueryInfo(pCmd, 0)->type, TSDB_QUERY_TYPE_MULTITABLE_QUERY);
+  TSDB_QUERY_SET_TYPE(tscGetQueryInfo(pCmd)->type, TSDB_QUERY_TYPE_MULTITABLE_QUERY);
   return 1;
 }
 
@@ -503,8 +503,8 @@ TAOS_RES *taos_consume(TAOS_SUB *tsub) {
   SSqlObj *pSql = pSub->pSql;
   SSqlRes *pRes = &pSql->res;
   SSqlCmd *pCmd = &pSql->cmd;
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
   if (taosArrayGetSize(pSub->progress) > 0) { // fix crash in single table subscription
 
     size_t size = taosArrayGetSize(pSub->progress);
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index f8384192e0..c4688ca1b0 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -98,7 +98,7 @@ static bool allSubqueryDone(SSqlObj *pParentSql) {
   return done;
 }
 
-static bool subAndCheckDone(SSqlObj *pSql, SSqlObj *pParentSql, int idx) {
+bool subAndCheckDone(SSqlObj *pSql, SSqlObj *pParentSql, int idx) {
   SSubqueryState *subState = &pParentSql->subState;
 
   assert(idx < subState->numOfSub);
@@ -124,7 +124,7 @@ static bool subAndCheckDone(SSqlObj *pSql, SSqlObj *pParentSql, int idx) {
 
 
 static int64_t doTSBlockIntersect(SSqlObj* pSql, STimeWindow * win) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, pSql->cmd.clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
   win->skey = INT64_MAX;
   win->ekey = INT64_MIN;
@@ -149,7 +149,7 @@ static int64_t doTSBlockIntersect(SSqlObj* pSql, STimeWindow * win) {
 
   for (int32_t i = 0; i < joinNum; ++i) {
     STSBuf* output = tsBufCreate(true, pQueryInfo->order.order);
-    SQueryInfo* pSubQueryInfo = tscGetQueryInfo(&pSql->pSubs[i]->cmd, 0);
+    SQueryInfo* pSubQueryInfo = tscGetQueryInfo(&pSql->pSubs[i]->cmd);
 
     pSubQueryInfo->tsBuf = output;
 
@@ -394,12 +394,12 @@ SJoinSupporter* tscCreateJoinSupporter(SSqlObj* pSql, int32_t index) {
   pSupporter->pObj = pSql;
 
   pSupporter->subqueryIndex = index;
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, pSql->cmd.clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   
   memcpy(&pSupporter->interval, &pQueryInfo->interval, sizeof(pSupporter->interval));
   pSupporter->limit = pQueryInfo->limit;
 
-  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, pSql->cmd.clauseIndex, index);
+  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, index);
   pSupporter->uid = pTableMetaInfo->pTableMeta->id.uid;
   assert (pSupporter->uid != 0);
 
@@ -549,7 +549,7 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
       continue;
     }
   
-    SQueryInfo *pSubQueryInfo = tscGetQueryInfo(&pPrevSub->cmd, 0);
+    SQueryInfo *pSubQueryInfo = tscGetQueryInfo(&pPrevSub->cmd);
     STSBuf     *pTsBuf = pSubQueryInfo->tsBuf;
     pSubQueryInfo->tsBuf = NULL;
   
@@ -567,7 +567,7 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
     tscClearSubqueryInfo(&pNew->cmd);
     pSql->pSubs[i] = pNew;
   
-    SQueryInfo *pQueryInfo = tscGetQueryInfo(&pNew->cmd, 0);
+    SQueryInfo *pQueryInfo = tscGetQueryInfo(&pNew->cmd);
     pQueryInfo->tsBuf = pTsBuf;  // transfer the ownership of timestamp comp-z data to the new created object
 
     // set the second stage sub query for join process
@@ -665,7 +665,7 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
       continue;
     }
 
-    SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->pSubs[i]->cmd, 0);
+    SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->pSubs[i]->cmd);
     executeQuery(pSql->pSubs[i], pQueryInfo);
   }
 
@@ -802,7 +802,7 @@ static void issueTsCompQuery(SSqlObj* pSql, SJoinSupporter* pSupporter, SSqlObj*
   tscClearSubqueryInfo(pCmd);
   tscFreeSqlResult(pSql);
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
   assert(pQueryInfo->numOfTables == 1);
 
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
@@ -1091,7 +1091,7 @@ static void tidTagRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
   SSqlCmd* pCmd = &pSql->cmd;
   SSqlRes* pRes = &pSql->res;
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
 
   // todo, the type may not include TSDB_QUERY_TYPE_TAG_FILTER_QUERY
   assert(TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_TAG_FILTER_QUERY));
@@ -1213,7 +1213,7 @@ static void tidTagRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
       SSqlCmd* pSubCmd = &pParentSql->pSubs[m]->cmd;
       SArray** s = taosArrayGet(resList, m);
 
-      SQueryInfo*     pQueryInfo1 = tscGetQueryInfo(pSubCmd, 0);
+      SQueryInfo*     pQueryInfo1 = tscGetQueryInfo(pSubCmd);
       STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo1, 0);
       tscBuildVgroupTableInfo(pParentSql, pTableMetaInfo, *s);
 
@@ -1247,7 +1247,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
   SSqlCmd* pCmd = &pSql->cmd;
   SSqlRes* pRes = &pSql->res;
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
   assert(!TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_JOIN_SEC_STAGE));
 
   if (pParentSql->res.code != TSDB_CODE_SUCCESS) {
@@ -1379,7 +1379,7 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
   }
 
   // launch the query the retrieve actual results from vnode along with the filtered timestamp
-  SQueryInfo* pPQueryInfo = tscGetQueryInfo(&pParentSql->cmd, pParentSql->cmd.clauseIndex);
+  SQueryInfo* pPQueryInfo = tscGetQueryInfo(&pParentSql->cmd);
   updateQueryTimeRange(pPQueryInfo, &win);
 
   //update the vgroup that involved in real data query
@@ -1395,7 +1395,7 @@ static void joinRetrieveFinalResCallback(void* param, TAOS_RES* tres, int numOfR
   SSqlCmd* pCmd = &pSql->cmd;
   SSqlRes* pRes = &pSql->res;
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
 
   if (pParentSql->res.code != TSDB_CODE_SUCCESS) {
     tscError("0x%"PRIx64" abort query due to other subquery failure. code:%d, global code:%d", pSql->self, numOfRows, pParentSql->res.code);
@@ -1504,7 +1504,7 @@ void tscFetchDatablockForSubquery(SSqlObj* pSql) {
 
     SSqlRes *pRes = &pSub->res;
 
-    SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSub->cmd, 0);
+    SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSub->cmd);
     if (!tscHasReachLimitation(pQueryInfo, pRes)) {
       if (pRes->row >= pRes->numOfRows) {
         // no data left in current result buffer
@@ -1556,7 +1556,7 @@ void tscFetchDatablockForSubquery(SSqlObj* pSql) {
         continue;
       }
 
-      SQueryInfo* p = tscGetQueryInfo(&pSub->cmd, 0);
+      SQueryInfo* p = tscGetQueryInfo(&pSub->cmd);
       orderedPrjQuery = tscNonOrderedProjectionQueryOnSTable(p, 0);
       if (orderedPrjQuery) {
         break;
@@ -1580,7 +1580,7 @@ void tscFetchDatablockForSubquery(SSqlObj* pSql) {
         continue;
       }
 
-      SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSub->cmd, 0);
+      SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSub->cmd);
 
       if (tscNonOrderedProjectionQueryOnSTable(pQueryInfo, 0) && pSub->res.row >= pSub->res.numOfRows &&
           pSub->res.completed) {
@@ -1655,7 +1655,7 @@ void tscFetchDatablockForSubquery(SSqlObj* pSql) {
     pSupporter = (SJoinSupporter*)pSql1->param;
 
     // wait for all subqueries completed
-    SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd1, 0);
+    SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd1);
     assert(pRes1->numOfRows >= 0 && pQueryInfo->numOfTables == 1);
 
     STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
@@ -1686,7 +1686,7 @@ void tscSetupOutputColumnIndex(SSqlObj* pSql) {
     return;
   }
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
 
   int32_t numOfExprs = (int32_t)tscNumOfExprs(pQueryInfo);
   pRes->pColumnIndex = calloc(1, sizeof(SColumnIndex) * numOfExprs);
@@ -1710,7 +1710,7 @@ void tscSetupOutputColumnIndex(SSqlObj* pSql) {
     assert(tableIndexOfSub >= 0 && tableIndexOfSub < pQueryInfo->numOfTables);
     
     SSqlCmd* pSubCmd = &pSql->pSubs[tableIndexOfSub]->cmd;
-    SQueryInfo* pSubQueryInfo = tscGetQueryInfo(pSubCmd, 0);
+    SQueryInfo* pSubQueryInfo = tscGetQueryInfo(pSubCmd);
     
     size_t numOfSubExpr = taosArrayGetSize(pSubQueryInfo->exprList);
     for (int32_t k = 0; k < numOfSubExpr; ++k) {
@@ -1734,7 +1734,7 @@ void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {
   SSqlObj* pParentSql = pSupporter->pObj;
   
   // There is only one subquery and table for each subquery.
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
   assert(pQueryInfo->numOfTables == 1);
@@ -1818,7 +1818,7 @@ static SSqlObj *tscCreateSTableSubquery(SSqlObj *pSql, SRetrieveSupport *trsuppo
 
 int32_t tscCreateJoinSubquery(SSqlObj *pSql, int16_t tableIndex, SJoinSupporter *pSupporter) {
   SSqlCmd *   pCmd = &pSql->cmd;
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
   
   pSql->res.qId = 0x1;
   assert(pSql->res.numOfRows == 0);
@@ -1841,7 +1841,7 @@ int32_t tscCreateJoinSubquery(SSqlObj *pSql, int16_t tableIndex, SJoinSupporter
     addGroupInfoForSubquery(pSql, pNew, 0, tableIndex);
     
     // refactor as one method
-    SQueryInfo *pNewQueryInfo = tscGetQueryInfo(&pNew->cmd, 0);
+    SQueryInfo *pNewQueryInfo = tscGetQueryInfo(&pNew->cmd);
     assert(pNewQueryInfo != NULL);
     
     // update the table index
@@ -1952,7 +1952,7 @@ int32_t tscCreateJoinSubquery(SSqlObj *pSql, int16_t tableIndex, SJoinSupporter
     }
   } else {
     assert(0);
-    SQueryInfo *pNewQueryInfo = tscGetQueryInfo(&pNew->cmd, 0);
+    SQueryInfo *pNewQueryInfo = tscGetQueryInfo(&pNew->cmd);
     pNewQueryInfo->type |= TSDB_QUERY_TYPE_SUBQUERY;
   }
 
@@ -1963,7 +1963,7 @@ void tscHandleMasterJoinQuery(SSqlObj* pSql) {
   SSqlCmd* pCmd = &pSql->cmd;
   SSqlRes* pRes = &pSql->res;
 
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
   assert((pQueryInfo->type & TSDB_QUERY_TYPE_SUBQUERY) == 0);
 
   int32_t code = TSDB_CODE_SUCCESS;
@@ -1998,7 +1998,7 @@ void tscHandleMasterJoinQuery(SSqlObj* pSql) {
     }
 
     SSqlObj* pSub = pSql->pSubs[i];
-    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSub->cmd, 0, 0);
+    STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSub->cmd, 0);
     if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo) && (pTableMetaInfo->vgroupList->numOfVgroups == 0)) {
       pSql->cmd.command = TSDB_SQL_RETRIEVE_EMPTY_RESULT;
       break;
@@ -2147,7 +2147,7 @@ void tscFirstRoundRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
   SFirstRoundQuerySup* pSup = param;
 
   SSqlObj*     pParent = pSup->pParent;
-  SQueryInfo*  pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo*  pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
   int32_t code = taos_errno(pSql);
   if (code != TSDB_CODE_SUCCESS) {
@@ -2230,7 +2230,7 @@ void tscFirstRoundRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
 
   // set the parameters for the second round query process
   SSqlCmd    *pPCmd   = &pParent->cmd;
-  SQueryInfo *pQueryInfo1 = tscGetQueryInfo(pPCmd, 0);
+  SQueryInfo *pQueryInfo1 = tscGetQueryInfo(pPCmd);
   int32_t resRows = pSup->numOfRows;
   
   if (pSup->numOfRows > 0) {
@@ -2280,8 +2280,8 @@ void tscFirstRoundCallback(void* param, TAOS_RES* tres, int code) {
 }
 
 int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
-  STableMetaInfo* pTableMetaInfo1 = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
+  STableMetaInfo* pTableMetaInfo1 = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0);
 
   SFirstRoundQuerySup *pSup = calloc(1, sizeof(SFirstRoundQuerySup));
 
@@ -2296,7 +2296,7 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
   tscClearSubqueryInfo(pCmd);
   tscFreeSqlResult(pSql);
 
-  SQueryInfo* pNewQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo* pNewQueryInfo = tscGetQueryInfo(pCmd);
   assert(pQueryInfo->numOfTables == 1);
 
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pNewQueryInfo, 0);
@@ -2495,7 +2495,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
     
     // todo handle multi-vnode situation
     if (pQueryInfo->tsBuf) {
-      SQueryInfo *pNewQueryInfo = tscGetQueryInfo(&pNew->cmd, 0);
+      SQueryInfo *pNewQueryInfo = tscGetQueryInfo(&pNew->cmd);
       pNewQueryInfo->tsBuf = tsBufClone(pQueryInfo->tsBuf);
       assert(pNewQueryInfo->tsBuf != NULL);
     }
@@ -2582,7 +2582,7 @@ static int32_t tscReissueSubquery(SRetrieveSupport *oriTrs, SSqlObj *pSql, int32
   SSqlObj *pParentSql = trsupport->pParentSql;
   int32_t  subqueryIndex = trsupport->subqueryIndex;
 
-  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0);
   SVgroupInfo* pVgroup = &pTableMetaInfo->vgroupList->vgroups[0];
 
   tExtMemBufferClear(trsupport->pExtMemBuffer[subqueryIndex]);
@@ -2685,7 +2685,7 @@ void tscHandleSubqueryError(SRetrieveSupport *trsupport, SSqlObj *pSql, int numO
   tscFreeRetrieveSup(pSql);
 
   // in case of second stage join subquery, invoke its callback function instead of regular QueueAsyncRes
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pParentSql->cmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pParentSql->cmd);
 
   if (!TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_JOIN_SEC_STAGE)) {
     (*pParentSql->fp)(pParentSql->param, pParentSql, pParentSql->res.code);
@@ -2702,7 +2702,7 @@ static void tscAllDataRetrievedFromDnode(SRetrieveSupport *trsupport, SSqlObj* p
   tOrderDescriptor *pDesc = trsupport->pOrderDescriptor;
   
   SSubqueryState* pState = &pParentSql->subState;
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   
   STableMetaInfo* pTableMetaInfo = pQueryInfo->pTableMetaInfo[0];
   
@@ -2751,7 +2751,7 @@ static void tscAllDataRetrievedFromDnode(SRetrieveSupport *trsupport, SSqlObj* p
   tscDebug("0x%"PRIx64" retrieve from %d vnodes completed.final NumOfRows:%" PRId64 ",start to build loser tree",
       pParentSql->self, pState->numOfSub, pState->numOfRetrievedRows);
   
-  SQueryInfo *pPQueryInfo = tscGetQueryInfo(&pParentSql->cmd, 0);
+  SQueryInfo *pPQueryInfo = tscGetQueryInfo(&pParentSql->cmd);
   tscClearInterpInfo(pPQueryInfo);
   
   code = tscCreateLocalMerger(trsupport->pExtMemBuffer, pState->numOfSub, pDesc, pPQueryInfo, &pParentSql->res.pLocalMerger, pParentSql->self);
@@ -2798,7 +2798,7 @@ static void tscRetrieveFromDnodeCallBack(void *param, TAOS_RES *tres, int numOfR
 
   SSubqueryState* pState = &pParentSql->subState;
   
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0);
   SVgroupInfo  *pVgroup = &pTableMetaInfo->vgroupList->vgroups[0];
 
   if (pParentSql->res.code != TSDB_CODE_SUCCESS) {
@@ -2836,7 +2836,7 @@ static void tscRetrieveFromDnodeCallBack(void *param, TAOS_RES *tres, int numOfR
   }
   
   SSqlRes *   pRes = &pSql->res;
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   
   if (numOfRows > 0) {
     assert(pRes->numOfRows == numOfRows);
@@ -2888,7 +2888,7 @@ static SSqlObj *tscCreateSTableSubquery(SSqlObj *pSql, SRetrieveSupport *trsuppo
   
   SSqlObj *pNew = createSubqueryObj(pSql, table_index, tscRetrieveDataRes, trsupport, TSDB_SQL_SELECT, prevSqlObj);
   if (pNew != NULL) {  // the sub query of two-stage super table query
-    SQueryInfo *pQueryInfo = tscGetQueryInfo(&pNew->cmd, 0);
+    SQueryInfo *pQueryInfo = tscGetQueryInfo(&pNew->cmd);
 
     pNew->cmd.active = pQueryInfo;
     pQueryInfo->type |= TSDB_QUERY_TYPE_STABLE_SUBQUERY;
@@ -2923,10 +2923,10 @@ void tscRetrieveDataRes(void *param, TAOS_RES *tres, int code) {
   SSqlObj*  pParentSql = trsupport->pParentSql;
   SSqlObj*  pSql = (SSqlObj *) tres;
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   assert(pQueryInfo->numOfTables == 1);
   
-  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0, 0);
+  STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0);
   SVgroupInfo* pVgroup = &pTableMetaInfo->vgroupList->vgroups[trsupport->subqueryIndex];
 
   // stable query killed or other subquery failed, all query stopped
@@ -2953,7 +2953,6 @@ void tscRetrieveDataRes(void *param, TAOS_RES *tres, int code) {
       tscError("0x%"PRIx64" sub:0x%"PRIx64" failed code:%s, retry:%d", pParentSql->self, pSql->self, tstrerror(code), trsupport->numOfRetry);
       
       int32_t sent = 0;
-
       tscReissueSubquery(trsupport, pSql, code, &sent);
       if (sent) {
         return;
@@ -3062,7 +3061,7 @@ static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int numOfRows)
         // clean up tableMeta in cache
         tscFreeQueryInfo(&pSql->cmd, false);
         SQueryInfo* pQueryInfo = tscGetQueryInfoS(&pSql->cmd, 0);
-        STableMetaInfo* pMasterTableMetaInfo = tscGetTableMetaInfoFromCmd(&pParentObj->cmd, pSql->cmd.clauseIndex, 0);
+        STableMetaInfo* pMasterTableMetaInfo = tscGetTableMetaInfoFromCmd(&pParentObj->cmd, 0);
         tscAddTableMetaInfo(pQueryInfo, &pMasterTableMetaInfo->name, NULL, NULL, NULL, NULL);
 
         subquerySetState(pSql, &pParentObj->subState, i, 0);
@@ -3234,7 +3233,7 @@ int32_t tscHandleMultivnodeInsert(SSqlObj *pSql) {
 }
 
 static char* getResultBlockPosition(SSqlCmd* pCmd, SSqlRes* pRes, int32_t columnIndex, int16_t* bytes) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
 
   SInternalField* pInfo = (SInternalField*) TARRAY_GET_ELEM(pQueryInfo->fieldsInfo.internalField, columnIndex);
   assert(pInfo->pExpr->pExpr == NULL);
@@ -3250,7 +3249,7 @@ static char* getResultBlockPosition(SSqlCmd* pCmd, SSqlRes* pRes, int32_t column
 static void doBuildResFromSubqueries(SSqlObj* pSql) {
   SSqlRes* pRes = &pSql->res;
 
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd, pSql->cmd.clauseIndex);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
   int32_t numOfRes = INT32_MAX;
   for (int32_t i = 0; i < pSql->subState.numOfSub; ++i) {
@@ -3347,7 +3346,7 @@ void tscBuildResFromSubqueries(SSqlObj *pSql) {
   }
 
   if (pRes->tsrow == NULL) {
-    SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd, pSql->cmd.clauseIndex);
+    SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSql->cmd);
     pRes->numOfCols = (int16_t) tscNumOfExprs(pQueryInfo);
 
     pRes->tsrow  = calloc(pRes->numOfCols, POINTER_BYTES);
@@ -3401,7 +3400,7 @@ TAOS_ROW doSetResultRowData(SSqlObj *pSql) {
     return pRes->tsrow;
   }
 
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
 
   size_t size = tscNumOfFields(pQueryInfo);
 
@@ -3434,7 +3433,7 @@ static UNUSED_FUNC bool tscHasRemainDataInSubqueryResultSet(SSqlObj *pSql) {
   bool     hasData = true;
   SSqlCmd *pCmd = &pSql->cmd;
   
-  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
   if (tscNonOrderedProjectionQueryOnSTable(pQueryInfo, 0)) {
     bool allSubqueryExhausted = true;
     
@@ -3446,7 +3445,7 @@ static UNUSED_FUNC bool tscHasRemainDataInSubqueryResultSet(SSqlObj *pSql) {
       SSqlRes *pRes1 = &pSql->pSubs[i]->res;
       SSqlCmd *pCmd1 = &pSql->pSubs[i]->cmd;
       
-      SQueryInfo *pQueryInfo1 = tscGetQueryInfo(pCmd1, pCmd1->clauseIndex);
+      SQueryInfo *pQueryInfo1 = tscGetQueryInfo(pCmd1);
       assert(pQueryInfo1->numOfTables == 1);
       
       STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo1, 0);
@@ -3470,7 +3469,7 @@ static UNUSED_FUNC bool tscHasRemainDataInSubqueryResultSet(SSqlObj *pSql) {
       }
       
       SSqlRes *   pRes1 = &pSql->pSubs[i]->res;
-      SQueryInfo *pQueryInfo1 = tscGetQueryInfo(&pSql->pSubs[i]->cmd, 0);
+      SQueryInfo *pQueryInfo1 = tscGetQueryInfo(&pSql->pSubs[i]->cmd);
       
       if ((pRes1->row >= pRes1->numOfRows && tscHasReachLimitation(pQueryInfo1, pRes1) &&
            tscIsProjectionQuery(pQueryInfo1)) ||
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index efeb776ecf..c12aa4447d 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -743,38 +743,39 @@ void convertQueryResult(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
   pRes->completed = (pRes->numOfRows == 0);
 }
 
-void handleDownstreamOperator(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
+void handleDownstreamOperator(SSqlRes* pRes, SQueryInfo* pQueryInfo, SSqlRes* pOutput) {
   if (pQueryInfo->pDownstream != NULL) {
     // handle the following query process
     SQueryInfo *px = pQueryInfo->pDownstream;
-    SColumnInfo* pColumnInfo = extractColumnInfoFromResult(px->pTableMetaInfo[0]->pTableMeta, px->colList);
-    int32_t numOfOutput = (int32_t) tscNumOfExprs(px);
+    if (px->pQInfo == NULL) {
+      SColumnInfo* pColumnInfo = extractColumnInfoFromResult(px->pTableMetaInfo[0]->pTableMeta, px->colList);
+      int32_t numOfOutput = (int32_t) tscNumOfExprs(px);
 
-    int32_t numOfCols = (int32_t) taosArrayGetSize(px->colList);
-    SQueriedTableInfo info = {.colList = pColumnInfo, .numOfCols = numOfCols,};
-    SSchema* pSchema = tscGetTableSchema(px->pTableMetaInfo[0]->pTableMeta);
+      int32_t numOfCols = (int32_t) taosArrayGetSize(px->colList);
+      SQueriedTableInfo info = {.colList = pColumnInfo, .numOfCols = numOfCols,};
+      SSchema* pSchema = tscGetTableSchema(px->pTableMetaInfo[0]->pTableMeta);
 
-    STableGroupInfo tableGroupInfo = {.numOfTables = 1, .pGroupList = taosArrayInit(1, POINTER_BYTES),};
-    tableGroupInfo.map = taosHashInit(1, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK);
+      STableGroupInfo tableGroupInfo = {.numOfTables = 1, .pGroupList = taosArrayInit(1, POINTER_BYTES),};
+      tableGroupInfo.map = taosHashInit(1, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK);
 
-    STableKeyInfo tableKeyInfo = {.pTable = NULL, .lastKey = INT64_MIN};
+      STableKeyInfo tableKeyInfo = {.pTable = NULL, .lastKey = INT64_MIN};
 
-    SArray* group = taosArrayInit(1, sizeof(STableKeyInfo));
-    taosArrayPush(group, &tableKeyInfo);
+      SArray* group = taosArrayInit(1, sizeof(STableKeyInfo));
+      taosArrayPush(group, &tableKeyInfo);
 
-    taosArrayPush(tableGroupInfo.pGroupList, &group);
+      taosArrayPush(tableGroupInfo.pGroupList, &group);
 
-    SOperatorInfo* pSourceOptr = createDummyInputOperator((char*)pRes, pSchema, numOfCols);
+      SOperatorInfo* pSourceOptr = createDummyInputOperator((char*)pRes, pSchema, numOfCols);
 
-    SExprInfo *exprInfo = NULL;
-    /*int32_t code = */createQueryFunc(&info, numOfOutput, &exprInfo, px->exprList->pData, NULL, px->type, NULL);
-    px->pQInfo = createQueryInfoFromQueryNode(px, exprInfo, &tableGroupInfo, pSourceOptr, NULL, NULL, MASTER_SCAN);
+      SExprInfo *exprInfo = NULL;
+      /*int32_t code = */createQueryFunc(&info, numOfOutput, &exprInfo, px->exprList->pData, NULL, px->type, NULL);
+      px->pQInfo = createQueryInfoFromQueryNode(px, exprInfo, &tableGroupInfo, pSourceOptr, NULL, NULL, MASTER_SCAN);
+      tfree(pColumnInfo);
+    }
 
     uint64_t qId = 0;
     qTableQuery(px->pQInfo, &qId);
-    convertQueryResult(pRes, px);
-
-    tfree(pColumnInfo);
+    convertQueryResult(pOutput, px);
   }
 }
 
@@ -812,7 +813,7 @@ void tscFreeQueryInfo(SSqlCmd* pCmd, bool removeMeta) {
     return;
   }
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
 
   while(pQueryInfo != NULL) {
     SQueryInfo* p = pQueryInfo->sibling;
@@ -1076,7 +1077,7 @@ int32_t tscCopyDataBlockToPayload(SSqlObj* pSql, STableDataBlocks* pDataBlock) {
   pCmd->numOfTablesInSubmit = pDataBlock->numOfTables;
 
 //  assert(pCmd->numOfClause == 1);
-  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, pCmd->clauseIndex, 0);
+  STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
 
   // todo refactor
   // set the correct table meta object, the table meta has been locked in pDataBlocks, so it must be in the cache
@@ -1576,6 +1577,29 @@ void tscFieldInfoClear(SFieldInfo* pFieldInfo) {
   memset(pFieldInfo, 0, sizeof(SFieldInfo));
 }
 
+void tscFieldInfoCopy(SFieldInfo* pFieldInfo, const SFieldInfo* pSrc) {
+  assert(pFieldInfo != NULL && pSrc != NULL);
+  pFieldInfo->numOfOutput = pSrc->numOfOutput;
+
+  if (pSrc->final != NULL) {
+    pFieldInfo->final = calloc(pSrc->numOfOutput, sizeof(TAOS_FIELD));
+    memcpy(pFieldInfo->final, pSrc->final, sizeof(TAOS_FIELD) * pSrc->numOfOutput);
+  }
+
+  if (pSrc->internalField != NULL) {
+    size_t num = taosArrayGetSize(pSrc->internalField);
+    for (int32_t i = 0; i < num; ++i) {
+      SInternalField* pfield = taosArrayGet(pSrc->internalField, i);
+
+      SInternalField p = {.visible = pfield->visible, .field = pfield->field};
+      p.pExpr = calloc(1, sizeof(SExprInfo));
+
+      tscExprAssign(p.pExpr, pfield->pExpr);
+    }
+  }
+}
+
+
 SExprInfo* tscExprCreate(SQueryInfo* pQueryInfo, int16_t functionId, SColumnIndex* pColIndex, int16_t type,
                          int16_t size, int16_t resColId, int16_t interSize, int32_t colType) {
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, pColIndex->tableIndex);
@@ -1731,7 +1755,7 @@ int32_t tscExprCopy(SArray* dst, const SArray* src, uint64_t uid, bool deepcopy)
   for (int32_t i = 0; i < size; ++i) {
     SExprInfo* pExpr = taosArrayGetP(src, i);
     
-    if (pExpr->base.uid == uid) {
+    if (uid != 0 && pExpr->base.uid == uid) {
       if (deepcopy) {
         SExprInfo* p1 = calloc(1, sizeof(SExprInfo));
         tscExprAssign(p1, pExpr);
@@ -1740,7 +1764,8 @@ int32_t tscExprCopy(SArray* dst, const SArray* src, uint64_t uid, bool deepcopy)
       } else {
         taosArrayPush(dst, &pExpr);
       }
-
+    } else {
+      taosArrayPush(dst, &pExpr);
     }
   }
 
@@ -1885,6 +1910,18 @@ void tscColumnListCopy(SArray* dst, const SArray* src, uint64_t tableUid) {
   }
 }
 
+void tscColumnListCopyAll(SArray* dst, const SArray* src) {
+  assert(src != NULL && dst != NULL);
+
+  size_t num = taosArrayGetSize(src);
+  for (int32_t i = 0; i < num; ++i) {
+    SColumn* pCol = taosArrayGetP(src, i);
+    SColumn* p = tscColumnClone(pCol);
+    taosArrayPush(dst, &p);
+  }
+}
+
+
 void tscColumnListDestroy(SArray* pColumnList) {
   if (pColumnList == NULL) {
     return;
@@ -2241,15 +2278,9 @@ bool tscShouldBeFreed(SSqlObj* pSql) {
  * @param tableIndex  denote the table index for join query, where more than one table exists
  * @return
  */
-STableMetaInfo* tscGetTableMetaInfoFromCmd(SSqlCmd* pCmd, int32_t clauseIndex, int32_t tableIndex) {
+STableMetaInfo* tscGetTableMetaInfoFromCmd(SSqlCmd* pCmd, int32_t tableIndex) {
   assert(pCmd != NULL);
-//  if (pCmd == NULL || pCmd->numOfClause == 0) {
-//    return NULL;
-//  }
-
-//  assert(clauseIndex >= 0 && clauseIndex < pCmd->numOfClause);
-
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
   return tscGetMetaInfo(pQueryInfo, tableIndex);
 }
 
@@ -2267,7 +2298,7 @@ STableMetaInfo* tscGetMetaInfo(SQueryInfo* pQueryInfo, int32_t tableIndex) {
 }
 
 SQueryInfo* tscGetQueryInfoS(SSqlCmd* pCmd, int32_t subClauseIndex) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, subClauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
   int32_t ret = TSDB_CODE_SUCCESS;
 
   while ((pQueryInfo) == NULL) {
@@ -2276,7 +2307,7 @@ SQueryInfo* tscGetQueryInfoS(SSqlCmd* pCmd, int32_t subClauseIndex) {
       return NULL;
     }
 
-    pQueryInfo = tscGetQueryInfo(pCmd, subClauseIndex);
+    pQueryInfo = tscGetQueryInfo(pCmd);
   }
 
   return pQueryInfo;
@@ -2316,20 +2347,11 @@ void tscInitQueryInfo(SQueryInfo* pQueryInfo) {
   pQueryInfo->slimit.limit   = -1;
   pQueryInfo->slimit.offset  = 0;
   pQueryInfo->pUpstream      = taosArrayInit(4, POINTER_BYTES);
+  pQueryInfo->window         = TSWINDOW_INITIALIZER;
 }
 
 int32_t tscAddQueryInfo(SSqlCmd* pCmd) {
   assert(pCmd != NULL);
-
-  // todo refactor: remove this structure
-//  size_t s = pCmd->numOfClause + 1;
-//  char*  tmp = realloc(pCmd->pQueryInfo, s * POINTER_BYTES);
-//  if (tmp == NULL) {
-//    return TSDB_CODE_TSC_OUT_OF_MEMORY;
-//  }
-
-//  pCmd->pQueryInfo = (SQueryInfo**)tmp;
-
   SQueryInfo* pQueryInfo = calloc(1, sizeof(SQueryInfo));
   if (pQueryInfo == NULL) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -2337,7 +2359,6 @@ int32_t tscAddQueryInfo(SSqlCmd* pCmd) {
 
   tscInitQueryInfo(pQueryInfo);
 
-  pQueryInfo->window = TSWINDOW_INITIALIZER;
   pQueryInfo->msg = pCmd->payload;  // pointer to the parent error message buffer
 
   if (pCmd->pQueryInfo == NULL) {
@@ -2386,7 +2407,7 @@ static void freeQueryInfoImpl(SQueryInfo* pQueryInfo) {
 }
 
 void tscClearSubqueryInfo(SSqlCmd* pCmd) {
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
   while (pQueryInfo != NULL) {
     SQueryInfo* p = pQueryInfo->sibling;
     freeQueryInfoImpl(pQueryInfo);
@@ -2394,6 +2415,86 @@ void tscClearSubqueryInfo(SSqlCmd* pCmd) {
   }
 }
 
+int32_t tscQueryInfoCopy(SQueryInfo* pQueryInfo, const SQueryInfo* pSrc) {
+  assert(pQueryInfo != NULL && pSrc != NULL);
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  memcpy(&pQueryInfo->interval, &pSrc->interval, sizeof(pQueryInfo->interval));
+
+  pQueryInfo->command        = pSrc->command;
+  pQueryInfo->type           = pSrc->type;
+  pQueryInfo->window         = pSrc->window;
+  pQueryInfo->limit          = pSrc->limit;
+  pQueryInfo->slimit         = pSrc->slimit;
+  pQueryInfo->order          = pSrc->order;
+  pQueryInfo->vgroupLimit    = pSrc->vgroupLimit;
+  pQueryInfo->tsBuf          = NULL;
+  pQueryInfo->fillType       = pSrc->fillType;
+  pQueryInfo->fillVal        = NULL;
+  pQueryInfo->clauseLimit    = pSrc->clauseLimit;
+  pQueryInfo->numOfTables    = pSrc->numOfTables;
+  pQueryInfo->window         = pSrc->window;
+  pQueryInfo->sessionWindow  = pSrc->sessionWindow;
+  pQueryInfo->pTableMetaInfo = NULL;
+
+  pQueryInfo->bufLen         = pSrc->bufLen;
+  pQueryInfo->buf            = malloc(pSrc->bufLen);
+  if (pQueryInfo->buf == NULL) {
+    code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    goto _error;
+  }
+
+  if (pSrc->bufLen > 0) {
+    memcpy(pQueryInfo->buf, pSrc->buf, pSrc->bufLen);
+  }
+
+  pQueryInfo->groupbyExpr = pSrc->groupbyExpr;
+  if (pSrc->groupbyExpr.columnInfo != NULL) {
+    pQueryInfo->groupbyExpr.columnInfo = taosArrayDup(pSrc->groupbyExpr.columnInfo);
+    if (pQueryInfo->groupbyExpr.columnInfo == NULL) {
+      code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+      goto _error;
+    }
+  }
+
+  if (tscTagCondCopy(&pQueryInfo->tagCond, &pSrc->tagCond) != 0) {
+    code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    goto _error;
+  }
+
+  if (pSrc->fillType != TSDB_FILL_NONE) {
+    pQueryInfo->fillVal = malloc(pSrc->fieldsInfo.numOfOutput * sizeof(int64_t));
+    if (pQueryInfo->fillVal == NULL) {
+      code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+      goto _error;
+    }
+
+    memcpy(pQueryInfo->fillVal, pSrc->fillVal, pSrc->fieldsInfo.numOfOutput * sizeof(int64_t));
+  }
+
+  tscColumnListCopyAll(pQueryInfo->colList, pSrc->colList);
+  tscFieldInfoCopy(&pQueryInfo->fieldsInfo, &pSrc->fieldsInfo);
+
+  if (tscExprCopy(pQueryInfo->exprList, pSrc->exprList, 0, true) != 0) {
+    code = TSDB_CODE_TSC_OUT_OF_MEMORY;
+    goto _error;
+  }
+
+  for(int32_t i = 0; i < pSrc->numOfTables; ++i) {
+    STableMetaInfo* p1 = tscGetMetaInfo((SQueryInfo*) pSrc, i);
+
+    STableMeta* pMeta = tscTableMetaDup(p1->pTableMeta);
+    if (pMeta == NULL) {
+      // todo handle the error
+    }
+
+    tscAddTableMetaInfo(pQueryInfo, &p1->name, pMeta, p1->vgroupList, p1->tagColList, p1->pVgroupTables);
+  }
+
+  _error:
+  return code;
+}
+
 void tscFreeVgroupTableInfo(SArray* pVgroupTables) {
   if (pVgroupTables == NULL) {
     return;
@@ -2594,7 +2695,7 @@ SSqlObj* createSimpleSubObj(SSqlObj* pSql, __async_cb_func_t fp, void* param, in
   SQueryInfo* pQueryInfo = tscGetQueryInfoS(pCmd, 0);
 
   assert(pSql->cmd.clauseIndex == 0);
-  STableMetaInfo* pMasterTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, pSql->cmd.clauseIndex, 0);
+  STableMetaInfo* pMasterTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0);
 
   tscAddTableMetaInfo(pQueryInfo, &pMasterTableMetaInfo->name, NULL, NULL, NULL, NULL);
   registerSqlObj(pNew);
@@ -2682,7 +2783,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
     goto _error;
   }
 
-  SQueryInfo* pNewQueryInfo = tscGetQueryInfo(pnCmd, 0);
+  SQueryInfo* pNewQueryInfo = tscGetQueryInfo(pnCmd);
 
   pNewQueryInfo->command = pQueryInfo->command;
   pnCmd->active = pNewQueryInfo;
@@ -2747,7 +2848,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
 
   // set the correct query type
   if (pPrevSql != NULL) {
-    SQueryInfo* pPrevQueryInfo = tscGetQueryInfo(&pPrevSql->cmd, pPrevSql->cmd.clauseIndex);
+    SQueryInfo* pPrevQueryInfo = tscGetQueryInfo(&pPrevSql->cmd);
     pNewQueryInfo->type = pPrevQueryInfo->type;
   } else {
     TSDB_QUERY_SET_TYPE(pNewQueryInfo->type, TSDB_QUERY_TYPE_SUBQUERY);// it must be the subquery
@@ -2774,7 +2875,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
     pFinalInfo = tscAddTableMetaInfo(pNewQueryInfo, &pTableMetaInfo->name, pTableMeta, pTableMetaInfo->vgroupList,
                                      pTableMetaInfo->tagColList, pTableMetaInfo->pVgroupTables);
   } else {  // transfer the ownership of pTableMeta to the newly create sql object.
-    STableMetaInfo* pPrevInfo = tscGetTableMetaInfoFromCmd(&pPrevSql->cmd, pPrevSql->cmd.clauseIndex, 0);
+    STableMetaInfo* pPrevInfo = tscGetTableMetaInfoFromCmd(&pPrevSql->cmd, 0);
     if (pPrevInfo->pTableMeta && pPrevInfo->pTableMeta->tableType < 0) {
       terrno = TSDB_CODE_TSC_APP_ERROR;
       goto _error;
@@ -2848,6 +2949,41 @@ void doExecuteQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
   }
 }
 
+static void tscSubqueryRetrieveCallback(void* param, TAOS_RES* tres, int code) {
+  // handle the pDownStream process
+  SRetrieveSupport* ps = param;
+  SSqlObj* pParentSql = ps->pParentSql;
+  SSqlObj* pSql = tres;
+
+  if (!subAndCheckDone(pSql, pParentSql, ps->subqueryIndex)) {
+    tscDebug("0x%"PRIx64" sub:0x%"PRIx64" orderOfSub:%d freed, not all subquery finished", pParentSql->self, pSql->self, ps->subqueryIndex);
+    return;
+  }
+
+  // merge all subquery result
+  SSqlCmd* pCmd = &pSql->cmd;
+  SSqlRes* pRes = &pSql->res;
+
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
+  /*TAOS_ROW* pRow = */taos_fetch_row(pSql);
+  if (pSql->res.numOfRows > 0) {
+    handleDownstreamOperator(pRes, pQueryInfo, &pParentSql->res);
+  }
+
+  code = pParentSql->res.code;
+  pParentSql->res.qId = -1;
+  if (pParentSql->res.code == TSDB_CODE_SUCCESS) {
+    (*pParentSql->fp)(pParentSql->param, pParentSql, pParentSql->res.numOfRows);
+  } else {
+    tscAsyncResultOnError(pParentSql);
+  }
+}
+
+static void tscSubqueryCompleteCallback(void* param, TAOS_RES* tres, int code) {
+  printf("123\n");
+  taos_fetch_rows_a(tres, tscSubqueryRetrieveCallback, param);
+}
+
 // do execute the query according to the query execution plan
 void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
   if (pSql->cmd.command == TSDB_SQL_RETRIEVE_EMPTY_RESULT) {
@@ -2860,14 +2996,48 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
   }
 
   if (taosArrayGetSize(pQueryInfo->pUpstream) > 0) {  // nest query. do execute it firstly
-    SQueryInfo* pq = taosArrayGetP(pQueryInfo->pUpstream, 0);
+    pSql->subState.numOfSub = taosArrayGetSize(pQueryInfo->pUpstream);
+    pSql->pSubs = calloc(pSql->subState.numOfSub, POINTER_BYTES);
+    pSql->subState.states = calloc(pSql->subState.numOfSub, sizeof(int8_t));
 
-    pSql->cmd.active = pq;
+    SQueryInfo* pSub = taosArrayGetP(pQueryInfo->pUpstream, 0);
+
+    pSql->cmd.active = pSub;
     pSql->cmd.command = TSDB_SQL_SELECT;
 
-    executeQuery(pSql, pq);
+    SSqlObj* pNew = (SSqlObj*)calloc(1, sizeof(SSqlObj));
+    if (pNew == NULL) {
+      terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
+//      return NULL;
+    }
 
-    // merge nest query result and generate final results
+    pNew->pTscObj   = pSql->pTscObj;
+    pNew->signature = pNew;
+    pNew->sqlstr    = strdup(pSql->sqlstr); // todo refactor
+    pNew->fp        = tscSubqueryCompleteCallback;
+
+    SRetrieveSupport* ps = calloc(1, sizeof(SRetrieveSupport));// todo use object id
+    ps->pParentSql    = pSql;
+    ps->subqueryIndex = 0;
+
+    pNew->param    = ps;
+    pSql->pSubs[0] = pNew;
+    registerSqlObj(pNew);
+
+    SSqlCmd* pCmd = &pNew->cmd;
+    pCmd->command = TSDB_SQL_SELECT;
+    pCmd->parseFinished = 1;
+
+    if (tscAddQueryInfo(pCmd) != TSDB_CODE_SUCCESS) {
+    }
+
+    SQueryInfo* pNewQueryInfo = tscGetQueryInfo(pCmd);
+    tscQueryInfoCopy(pNewQueryInfo, pSub);
+
+    // create sub query to handle the sub query.
+    executeQuery(pNew, pSub);
+
+    // merge sub query result and generate final results
     return;
   }
 
@@ -2899,7 +3069,7 @@ void tscDoQuery(SSqlObj* pSql) {
   if (pCmd->dataSourceType == DATA_FROM_DATA_FILE) {
     tscImportDataFromFile(pSql);
   } else {
-    SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+    SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
     uint16_t type = pQueryInfo->type;
 
     if (QUERY_IS_JOIN_QUERY(type)) {
@@ -2990,7 +3160,7 @@ bool tscIsQueryWithLimit(SSqlObj* pSql) {
   }
 
   SSqlCmd* pCmd = &pSql->cmd;
-  SQueryInfo* pqi = tscGetQueryInfo(pCmd, 0);
+  SQueryInfo* pqi = tscGetQueryInfo(pCmd);
   while(pqi != NULL) {
     if (pqi->limit.limit > 0) {
       return true;
@@ -3074,7 +3244,7 @@ bool hasMoreVnodesToTry(SSqlObj* pSql) {
   }
 
   assert(pRes->completed);
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
   // for normal table, no need to try any more if results are all retrieved from one vnode
@@ -3100,7 +3270,7 @@ void tscTryQueryNextVnode(SSqlObj* pSql, __async_cb_func_t fp) {
   SSqlCmd* pCmd = &pSql->cmd;
   SSqlRes* pRes = &pSql->res;
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
 
   /*
    * no result returned from the current virtual node anymore, try the next vnode if exists
@@ -3157,7 +3327,7 @@ void tscTryQueryNextClause(SSqlObj* pSql, __async_cb_func_t fp) {
   SSqlRes* pRes = &pSql->res;
 
   pCmd->clauseIndex++;
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd, pCmd->clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
 
   pSql->cmd.command = pQueryInfo->command;
 
@@ -3465,8 +3635,8 @@ int32_t createProjectionExpr(SQueryInfo* pQueryInfo, STableMetaInfo* pTableMetaI
 
       int32_t numOfOutput = (int32_t) taosArrayGetSize(pQueryInfo->exprList);
       for (int32_t j = 0; j < numOfOutput; ++j) {
-        SExprInfo* px = taosArrayGetP(pQueryInfo->exprList, j);
-        if (px->base.resColId == pse->colInfo.colId) {
+        SExprInfo* p = taosArrayGetP(pQueryInfo->exprList, j);
+        if (p->base.resColId == pse->colInfo.colId) {
           pse->colInfo.colIndex = j;
           break;
         }
diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index dc1b2072de..7e53138ef1 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -2843,12 +2843,26 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
   pInfo->numOfTables  = htonl(pInfo->numOfTables);
   pInfo->numOfVgroups = htonl(pInfo->numOfVgroups);
 
+  int32_t contLen = pMsg->rpcMsg.contLen - sizeof(SMultiTableInfoMsg);
+
+  int32_t num      = 0;
+  int32_t code     = TSDB_CODE_SUCCESS;
+  char*   str      = strndup(pInfo->tableNames, contLen);
+  char**  nameList = strsplit(str, ",", &num);
+  SMultiTableMeta *pMultiMeta = NULL;
+
+  if (num != pInfo->numOfTables + pInfo->numOfVgroups) {
+    mError("msg:%p, app:%p, failed to get multi-tableMeta, msg inconsistent", pMsg, pMsg->rpcMsg.ahandle);
+    code = TSDB_CODE_MND_INVALID_TABLE_NAME;
+    goto _error;
+  }
+
   // first malloc 80KB, subsequent reallocation will expand the size as twice of the original size
   int32_t totalMallocLen = sizeof(STableMetaMsg) + sizeof(SSchema) * (TSDB_MAX_TAGS + TSDB_MAX_COLUMNS + 16);
-
-  SMultiTableMeta *pMultiMeta = rpcMallocCont(totalMallocLen);
+  pMultiMeta = rpcMallocCont(totalMallocLen);
   if (pMultiMeta == NULL) {
-    return TSDB_CODE_MND_OUT_OF_MEMORY;
+    code = TSDB_CODE_MND_OUT_OF_MEMORY;
+    goto _error;
   }
 
   pMultiMeta->contLen = sizeof(SMultiTableMeta);
@@ -2856,16 +2870,15 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
 
   SArray* pList = taosArrayInit(4, POINTER_BYTES);
 
-  for (int32_t t = 0; t < pInfo->numOfTables; ++t) {
-    char *fullName = (char *)(pInfo->tableNames + t * TSDB_TABLE_FNAME_LEN);
+  int32_t t = 0;
+  for (; t < pInfo->numOfTables; ++t) {
+    char *fullName = nameList[t];
 
+    pMsg->pTable = mnodeGetTable(fullName);
     if (pMsg->pTable == NULL) {
-      pMsg->pTable = mnodeGetTable(fullName);
-      if (pMsg->pTable == NULL) {
-        rpcFreeCont(pMultiMeta);
-        mError("msg:%p, app:%p table:%s, failed to get table meta, table not exist", pMsg, pMsg->rpcMsg.ahandle, fullName);
-        return TSDB_CODE_MND_INVALID_TABLE_NAME;
-      }
+      mError("msg:%p, app:%p table:%s, failed to get table meta, table not exist", pMsg, pMsg->rpcMsg.ahandle, fullName);
+      code = TSDB_CODE_MND_INVALID_TABLE_NAME;
+      goto _error;
     }
 
     if (pMsg->pDb == NULL) {
@@ -2873,9 +2886,9 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
     }
 
     if (pMsg->pDb == NULL || pMsg->pDb->status != TSDB_DB_STATUS_READY) {
-      rpcFreeCont(pMultiMeta);
       mnodeDecTableRef(pMsg->pTable);
-      return TSDB_CODE_APP_NOT_READY;
+      code = TSDB_CODE_APP_NOT_READY;
+      goto _error;
     }
 
     int remain = totalMallocLen - pMultiMeta->contLen;
@@ -2884,20 +2897,18 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
       pMultiMeta = rpcReallocCont(pMultiMeta, totalMallocLen);
       if (pMultiMeta == NULL) {
         mnodeDecTableRef(pMsg->pTable);
-        return TSDB_CODE_MND_OUT_OF_MEMORY;
+        code = TSDB_CODE_MND_OUT_OF_MEMORY;
+        goto _error;
       }
     }
 
     STableMetaMsg *pMeta = (STableMetaMsg *)((char*) pMultiMeta + pMultiMeta->contLen);
 
-    int32_t code = 0;
-    if (pMsg->pTable->type != TSDB_SUPER_TABLE) {
-      code = mnodeDoGetChildTableMeta(pMsg, pMeta);
-    } else {
+    if (pMsg->pTable->type == TSDB_SUPER_TABLE) {
       code = mnodeDoGetSuperTableMeta(pMsg, pMeta);
-
-      // keep the full name for each super table for retrieve vgroup list
-      taosArrayPush(pList, &fullName);
+      taosArrayPush(pList, &fullName);// keep the full name for each super table for retrieve vgroup list
+    } else {
+       code = mnodeDoGetChildTableMeta(pMsg, pMeta);
     }
 
     if (code == TSDB_CODE_SUCCESS) {
@@ -2911,22 +2922,21 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
   char* msg = (char*) pMultiMeta + pMultiMeta->contLen;
 
   // add the additional super table names that needs the vgroup info
-  for(int32_t i = 0; i < pInfo->numOfVgroups; ++i) {
-    char *fullName = (char *)(pInfo->tableNames + (i + pInfo->numOfTables) * TSDB_TABLE_FNAME_LEN);
-    taosArrayPush(pList, fullName);
+  for(;t < pInfo->numOfVgroups; ++t) {
+    taosArrayPush(pList, &nameList[t]);
   }
 
   // add the pVgroupList into the pList
-  int32_t numOfStable = (int32_t) taosArrayGetSize(pList);
-  pMultiMeta->numOfVgroup = htonl(numOfStable);
+  int32_t numOfVgroupList = (int32_t) taosArrayGetSize(pList);
+  pMultiMeta->numOfVgroup = htonl(numOfVgroupList);
 
-  for(int32_t i = 0; i < numOfStable; ++i) {
+  for(int32_t i = 0; i < numOfVgroupList; ++i) {
     char* name = taosArrayGetP(pList, i);
     SSTableObj *pTable = mnodeGetSuperTable(name);
     if (pTable == NULL) {
       mError("msg:%p, app:%p stable:%s, not exist while get stable vgroup info", pMsg, pMsg->rpcMsg.ahandle, name);
-      mnodeDecTableRef(pTable);
-      continue;
+      code = TSDB_CODE_MND_INVALID_TABLE_NAME;
+      goto _error;
     }
 
     msg = serializeVgroupInfo(pTable, name, msg, pMsg, pMsg->rpcMsg.ahandle);
@@ -2939,6 +2949,14 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
   pMsg->rpcRsp.len = pMultiMeta->contLen;
 
   return TSDB_CODE_SUCCESS;
+
+  _error:
+  tfree(str);
+  tfree(nameList);
+  rpcFreeCont(pMultiMeta);
+  taosArrayDestroy(pList);
+
+  return code;
 }
 
 static int32_t mnodeGetShowTableMeta(STableMetaMsg *pMeta, SShowObj *pShow, void *pConn) {

From e6e424006770050dc630f825761d37ef6ec0abc9 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Sat, 15 May 2021 13:45:42 +0800
Subject: [PATCH 026/128] [td-4151]refactor code.

---
 src/client/inc/tscUtil.h       |   4 +-
 src/client/inc/tsclient.h      |   6 +-
 src/client/src/tscAsync.c      |   1 +
 src/client/src/tscLocalMerge.c |  10 +-
 src/client/src/tscSQLParser.c  |  89 ++++++------
 src/client/src/tscServer.c     |   4 +-
 src/client/src/tscSubquery.c   |  16 +--
 src/client/src/tscUtil.c       | 253 ++++++++++++++++++++++-----------
 src/query/inc/qExecutor.h      |   8 +-
 src/query/src/qExecutor.c      |  78 +++++-----
 10 files changed, 287 insertions(+), 182 deletions(-)

diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index d8b9bfab26..de69e23b9b 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -154,7 +154,7 @@ bool tscMultiRoundQuery(SQueryInfo* pQueryInfo, int32_t tableIndex);
 bool tscQueryBlockInfo(SQueryInfo* pQueryInfo);
 
 SExprInfo* tscAddFuncInSelectClause(SQueryInfo* pQueryInfo, int32_t outputColIndex, int16_t functionId,
-                                       SColumnIndex* pIndex, SSchema* pColSchema, int16_t colType);
+                                       SColumnIndex* pIndex, SSchema* pColSchema, int16_t colType, int16_t colId);
 
 int32_t tscSetTableFullName(SName* pName, SStrToken* pzTableName, SSqlObj* pSql);
 void    tscClearInterpInfo(SQueryInfo* pQueryInfo);
@@ -290,7 +290,7 @@ void registerSqlObj(SSqlObj* pSql);
 SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t fp, void* param, int32_t cmd, SSqlObj* pPrevSql);
 void     addGroupInfoForSubquery(SSqlObj* pParentObj, SSqlObj* pSql, int32_t subClauseIndex, int32_t tableIndex);
 
-void doAddGroupColumnForSubquery(SQueryInfo* pQueryInfo, int32_t tagIndex);
+void doAddGroupColumnForSubquery(SQueryInfo* pQueryInfo, int32_t tagIndex, SSqlCmd* pCmd);
 
 int16_t tscGetJoinTagColIdByUid(STagCond* pTagCond, uint64_t uid);
 int16_t tscGetTagColIndexById(STableMeta* pTableMeta, int16_t colId);
diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index 13ec02b5d1..87da9c8b00 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -203,7 +203,7 @@ typedef struct SQueryInfo {
   SInterval        interval;      // tumble time window
   SSessionWindow   sessionWindow; // session time window
 
-  SGroupbyExpr  groupbyExpr;   // groupby tags info
+  SGroupbyExpr     groupbyExpr;   // groupby tags info
   SArray *         colList;       // SArray<SColumn*>
   SFieldInfo       fieldsInfo;
   SArray *         exprList;      // SArray<SExprInfo*>
@@ -251,6 +251,7 @@ typedef struct {
   SVgroupsInfo *pVgroupInfo;
 } STableMetaVgroupInfo;
 
+// TODO extract sql parser supporter
 typedef struct {
   int     command;
   uint8_t msgType;
@@ -293,6 +294,7 @@ typedef struct {
 
   SHashObj    *pTableBlockHashList;     // data block for each table
   SArray      *pDataBlocks;             // SArray<STableDataBlocks*>. Merged submit block for each vgroup
+  int32_t      resColumnId;
 } SSqlCmd;
 
 typedef struct SResRec {
@@ -514,7 +516,7 @@ extern int   tscNumOfObj;     // number of existed sqlObj in current process.
 extern int (*tscBuildMsg[TSDB_SQL_MAX])(SSqlObj *pSql, SSqlInfo *pInfo);
 
 void tscBuildVgroupTableInfo(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, SArray* tables);
-int16_t getNewResColId(SQueryInfo* pQueryInfo);
+int16_t getNewResColId(SSqlCmd* pCmd);
 
 #ifdef __cplusplus
 }
diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c
index 28eafa164c..1456a91099 100644
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -59,6 +59,7 @@ void doAsyncQuery(STscObj* pObj, SSqlObj* pSql, __async_cb_func_t fp, void* para
 
   tscDebugL("0x%"PRIx64" SQL: %s", pSql->self, pSql->sqlstr);
   pCmd->curSql = pSql->sqlstr;
+  pCmd->resColumnId = TSDB_RES_COL_ID;
 
   int32_t code = tsParseSql(pSql, true);
   if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) return;
diff --git a/src/client/src/tscLocalMerge.c b/src/client/src/tscLocalMerge.c
index 2dbc09f08d..e1bcf3a792 100644
--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -871,7 +871,7 @@ SSDataBlock* doGlobalAggregate(void* param, bool* newgroup) {
   }
 
   SMultiwayMergeInfo *pAggInfo = pOperator->info;
-  SOperatorInfo      *upstream = pOperator->upstream;
+  SOperatorInfo      *upstream = pOperator->upstream[0];
 
   *newgroup = false;
   bool handleData = false;
@@ -974,7 +974,7 @@ static SSDataBlock* skipGroupBlock(SOperatorInfo* pOperator, bool* newgroup) {
 
   SSDataBlock* pBlock = NULL;
   if (pInfo->currentGroupOffset == 0) {
-    pBlock = pOperator->upstream->exec(pOperator->upstream, newgroup);
+    pBlock = pOperator->upstream[0]->exec(pOperator->upstream, newgroup);
     if (pBlock == NULL) {
       setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
       pOperator->status = OP_EXEC_DONE;
@@ -982,7 +982,7 @@ static SSDataBlock* skipGroupBlock(SOperatorInfo* pOperator, bool* newgroup) {
 
     if (*newgroup == false && pInfo->limit.limit > 0 && pInfo->rowsTotal >= pInfo->limit.limit) {
       while ((*newgroup) == false) {  // ignore the remain blocks
-        pBlock = pOperator->upstream->exec(pOperator->upstream, newgroup);
+        pBlock = pOperator->upstream[0]->exec(pOperator->upstream, newgroup);
         if (pBlock == NULL) {
           setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
           pOperator->status = OP_EXEC_DONE;
@@ -994,7 +994,7 @@ static SSDataBlock* skipGroupBlock(SOperatorInfo* pOperator, bool* newgroup) {
     return pBlock;
   }
 
-    pBlock = pOperator->upstream->exec(pOperator->upstream, newgroup);
+    pBlock = pOperator->upstream[0]->exec(pOperator->upstream, newgroup);
     if (pBlock == NULL) {
       setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
       pOperator->status = OP_EXEC_DONE;
@@ -1008,7 +1008,7 @@ static SSDataBlock* skipGroupBlock(SOperatorInfo* pOperator, bool* newgroup) {
       }
 
       while ((*newgroup) == false) {
-        pBlock = pOperator->upstream->exec(pOperator->upstream, newgroup);
+        pBlock = pOperator->upstream[0]->exec(pOperator->upstream, newgroup);
         if (pBlock == NULL) {
           setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
           pOperator->status = OP_EXEC_DONE;
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 676dc51cb0..c179ed1ec6 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -58,7 +58,7 @@ typedef struct SConvertFunc {
   int32_t execFuncId;
 } SConvertFunc;
 
-static SExprInfo* doAddProjectCol(SQueryInfo* pQueryInfo, int32_t colIndex, int32_t tableIndex);
+static SExprInfo* doAddProjectCol(SQueryInfo* pQueryInfo, int32_t colIndex, int32_t tableIndex, int32_t colId);
 
 static int32_t setShowInfo(SSqlObj* pSql, SSqlInfo* pInfo);
 static char*   getAccountId(SSqlObj* pSql);
@@ -137,8 +137,8 @@ static bool    isTimeWindowQuery(SQueryInfo* pQueryInfo) {
   return pQueryInfo->interval.interval > 0 || pQueryInfo->sessionWindow.gap > 0;
 }
 
-int16_t getNewResColId(SQueryInfo* pQueryInfo) {
-  return pQueryInfo->resColumnId--;
+int16_t getNewResColId(SSqlCmd* pCmd) {
+  return pCmd->resColumnId--;
 }
 
 static uint8_t convertOptr(SStrToken *pToken) {
@@ -730,7 +730,7 @@ static bool isTopBottomQuery(SQueryInfo* pQueryInfo) {
 }
 
 // need to add timestamp column in result set, if it is a time window query
-static int32_t addPrimaryTsColumnForTimeWindowQuery(SQueryInfo* pQueryInfo) {
+static int32_t addPrimaryTsColumnForTimeWindowQuery(SQueryInfo* pQueryInfo, SSqlCmd* pCmd) {
   uint64_t uid = tscExprGet(pQueryInfo, 0)->base.uid;
 
   int32_t  tableIndex = COLUMN_INDEX_INITIAL_VAL;
@@ -750,7 +750,7 @@ static int32_t addPrimaryTsColumnForTimeWindowQuery(SQueryInfo* pQueryInfo) {
   tstrncpy(s.name, aAggs[TSDB_FUNC_TS].name, sizeof(s.name));
 
   SColumnIndex index = {tableIndex, PRIMARYKEY_TIMESTAMP_COL_INDEX};
-  tscAddFuncInSelectClause(pQueryInfo, 0, TSDB_FUNC_TS, &index, &s, TSDB_COL_NORMAL);
+  tscAddFuncInSelectClause(pQueryInfo, 0, TSDB_FUNC_TS, &index, &s, TSDB_COL_NORMAL, getNewResColId(pCmd));
   return TSDB_CODE_SUCCESS;
 }
 
@@ -792,7 +792,7 @@ static int32_t checkInvalidExprForTimeWindow(SSqlCmd* pCmd, SQueryInfo* pQueryIn
     return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
-  return addPrimaryTsColumnForTimeWindowQuery(pQueryInfo);
+  return addPrimaryTsColumnForTimeWindowQuery(pQueryInfo, pCmd);
 }
 
 int32_t validateIntervalNode(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNode* pSqlNode) {
@@ -1442,7 +1442,7 @@ static int32_t handleArithmeticExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32
     SColumnIndex index = {.tableIndex = tableIndex};
 
     SExprInfo* pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_ARITHM, &index, TSDB_DATA_TYPE_DOUBLE, sizeof(double),
-                                       getNewResColId(pQueryInfo), sizeof(double), false);
+                                       getNewResColId(pCmd), sizeof(double), false);
 
     char* name = (pItem->aliasName != NULL)? pItem->aliasName:pItem->pNode->token.z;
     size_t len = MIN(sizeof(pExpr->base.aliasName), pItem->pNode->token.n + 1);
@@ -1516,7 +1516,7 @@ static int32_t handleArithmeticExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32
 
     pExprInfo->base.functionId = TSDB_FUNC_ARITHM;
     pExprInfo->base.numOfParams = 1;
-    pExprInfo->base.resColId = getNewResColId(pQueryInfo);
+    pExprInfo->base.resColId = getNewResColId(pCmd);
     strncpy(pExprInfo->base.aliasName, aliasName, tListLen(pExprInfo->base.aliasName));
     strncpy(pExprInfo->base.token, rawName, tListLen(pExprInfo->base.token));
 
@@ -1549,8 +1549,8 @@ static int32_t handleArithmeticExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32
   return TSDB_CODE_SUCCESS;
 }
 
-static void addProjectQueryCol(SQueryInfo* pQueryInfo, int32_t startPos, SColumnIndex* pIndex, tSqlExprItem* pItem) {
-  SExprInfo* pExpr = doAddProjectCol(pQueryInfo, pIndex->columnIndex, pIndex->tableIndex);
+static void addProjectQueryCol(SQueryInfo* pQueryInfo, int32_t startPos, SColumnIndex* pIndex, tSqlExprItem* pItem, int32_t colId) {
+  SExprInfo* pExpr = doAddProjectCol(pQueryInfo, pIndex->columnIndex, pIndex->tableIndex, colId);
 
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, pIndex->tableIndex);
   STableMeta*     pTableMeta = pTableMetaInfo->pTableMeta;
@@ -1572,7 +1572,7 @@ static void addProjectQueryCol(SQueryInfo* pQueryInfo, int32_t startPos, SColumn
   insertResultField(pQueryInfo, startPos, &ids, pExpr->base.resBytes, (int8_t)pExpr->base.resType, pExpr->base.aliasName, pExpr);
 }
 
-static void addPrimaryTsColIntoResult(SQueryInfo* pQueryInfo) {
+static void addPrimaryTsColIntoResult(SQueryInfo* pQueryInfo, SSqlCmd* pCmd) {
   // primary timestamp column has been added already
   size_t size = tscNumOfExprs(pQueryInfo);
   for (int32_t i = 0; i < size; ++i) {
@@ -1590,7 +1590,7 @@ static void addPrimaryTsColIntoResult(SQueryInfo* pQueryInfo) {
   // add the timestamp column into the output columns
   SColumnIndex index = {0};  // primary timestamp column info
   int32_t numOfCols = (int32_t)tscNumOfExprs(pQueryInfo);
-  tscAddFuncInSelectClause(pQueryInfo, numOfCols, TSDB_FUNC_PRJ, &index, pSchema, TSDB_COL_NORMAL);
+  tscAddFuncInSelectClause(pQueryInfo, numOfCols, TSDB_FUNC_PRJ, &index, pSchema, TSDB_COL_NORMAL, getNewResColId(pCmd));
 
   SInternalField* pSupInfo = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, numOfCols);
   pSupInfo->visible = false;
@@ -1681,7 +1681,7 @@ int32_t validateSelectNodeList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pS
   // there is only one user-defined column in the final result field, add the timestamp column.
   size_t numOfSrcCols = taosArrayGetSize(pQueryInfo->colList);
   if (numOfSrcCols <= 0 && !tscQueryTags(pQueryInfo) && !tscQueryBlockInfo(pQueryInfo)) {
-    addPrimaryTsColIntoResult(pQueryInfo);
+    addPrimaryTsColIntoResult(pQueryInfo, pCmd);
   }
 
   if (!functionCompatibleCheck(pQueryInfo, joinQuery, timeWindowQuery)) {
@@ -1714,7 +1714,7 @@ int32_t insertResultField(SQueryInfo* pQueryInfo, int32_t outputIndex, SColumnLi
   return TSDB_CODE_SUCCESS;
 }
 
-SExprInfo* doAddProjectCol(SQueryInfo* pQueryInfo, int32_t colIndex, int32_t tableIndex) {
+SExprInfo* doAddProjectCol(SQueryInfo* pQueryInfo, int32_t colIndex, int32_t tableIndex, int32_t colId) {
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, tableIndex);
   STableMeta*     pTableMeta = pTableMetaInfo->pTableMeta;
   int32_t numOfCols = tscGetNumOfColumns(pTableMeta);
@@ -1731,15 +1731,12 @@ SExprInfo* doAddProjectCol(SQueryInfo* pQueryInfo, int32_t colIndex, int32_t tab
     index.columnIndex = colIndex;
   }
 
-  int16_t colId = getNewResColId(pQueryInfo);
   return tscExprAppend(pQueryInfo, functionId, &index, pSchema->type, pSchema->bytes, colId, pSchema->bytes,
                           (functionId == TSDB_FUNC_TAGPRJ));
 }
 
 SExprInfo* tscAddFuncInSelectClause(SQueryInfo* pQueryInfo, int32_t outputColIndex, int16_t functionId,
-                                  SColumnIndex* pIndex, SSchema* pColSchema, int16_t flag) {
-  int16_t colId = getNewResColId(pQueryInfo);
-
+                                  SColumnIndex* pIndex, SSchema* pColSchema, int16_t flag, int16_t colId) {
   SExprInfo* pExpr = tscExprInsert(pQueryInfo, outputColIndex, functionId, pIndex, pColSchema->type,
                                      pColSchema->bytes, colId, pColSchema->bytes, TSDB_COL_IS_TAG(flag));
   tstrncpy(pExpr->base.aliasName, pColSchema->name, sizeof(pExpr->base.aliasName));
@@ -1762,7 +1759,7 @@ SExprInfo* tscAddFuncInSelectClause(SQueryInfo* pQueryInfo, int32_t outputColInd
   return pExpr;
 }
 
-static int32_t doAddProjectionExprAndResultFields(SQueryInfo* pQueryInfo, SColumnIndex* pIndex, int32_t startPos) {
+static int32_t doAddProjectionExprAndResultFields(SQueryInfo* pQueryInfo, SColumnIndex* pIndex, int32_t startPos, SSqlCmd* pCmd) {
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, pIndex->tableIndex);
 
   int32_t     numOfTotalColumns = 0;
@@ -1778,7 +1775,7 @@ static int32_t doAddProjectionExprAndResultFields(SQueryInfo* pQueryInfo, SColum
   }
 
   for (int32_t j = 0; j < numOfTotalColumns; ++j) {
-    SExprInfo* pExpr = doAddProjectCol(pQueryInfo, j, pIndex->tableIndex);
+    SExprInfo* pExpr = doAddProjectCol(pQueryInfo, j, pIndex->tableIndex, getNewResColId(pCmd));
     tstrncpy(pExpr->base.aliasName, pSchema[j].name, sizeof(pExpr->base.aliasName));
 
     pIndex->columnIndex = j;
@@ -1811,11 +1808,11 @@ int32_t addProjectionExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
     if (index.tableIndex == COLUMN_INDEX_INITIAL_VAL) {  // all table columns are required.
       for (int32_t i = 0; i < pQueryInfo->numOfTables; ++i) {
         index.tableIndex = i;
-        int32_t inc = doAddProjectionExprAndResultFields(pQueryInfo, &index, startPos);
+        int32_t inc = doAddProjectionExprAndResultFields(pQueryInfo, &index, startPos, pCmd);
         startPos += inc;
       }
     } else {
-      doAddProjectionExprAndResultFields(pQueryInfo, &index, startPos);
+      doAddProjectionExprAndResultFields(pQueryInfo, &index, startPos, pCmd);
     }
 
     // add the primary timestamp column even though it is not required by user
@@ -1832,7 +1829,7 @@ int32_t addProjectionExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
 
     SSchema colSchema = tGetUserSpecifiedColumnSchema(&pItem->pNode->value, &pItem->pNode->token, pItem->aliasName);
     SExprInfo* pExpr =
-        tscAddFuncInSelectClause(pQueryInfo, startPos, TSDB_FUNC_PRJ, &index, &colSchema, TSDB_COL_UDC);
+        tscAddFuncInSelectClause(pQueryInfo, startPos, TSDB_FUNC_PRJ, &index, &colSchema, TSDB_COL_UDC, getNewResColId(pCmd));
 
     // NOTE: the first parameter is reserved for the tag column id during join query process.
     pExpr->base.numOfParams = 2;
@@ -1846,10 +1843,10 @@ int32_t addProjectionExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
 
     if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
       SSchema* colSchema = tGetTbnameColumnSchema();
-      tscAddFuncInSelectClause(pQueryInfo, startPos, TSDB_FUNC_TAGPRJ, &index, colSchema, TSDB_COL_TAG);
+      tscAddFuncInSelectClause(pQueryInfo, startPos, TSDB_FUNC_TAGPRJ, &index, colSchema, TSDB_COL_TAG, getNewResColId(pCmd));
     } else if (index.columnIndex == TSDB_BLOCK_DIST_COLUMN_INDEX) {
       SSchema colSchema = tGetBlockDistColumnSchema();
-      tscAddFuncInSelectClause(pQueryInfo, startPos, TSDB_FUNC_PRJ, &index, &colSchema, TSDB_COL_TAG);
+      tscAddFuncInSelectClause(pQueryInfo, startPos, TSDB_FUNC_PRJ, &index, &colSchema, TSDB_COL_TAG, getNewResColId(pCmd));
     } else {
       STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
       STableMeta*     pTableMeta = pTableMetaInfo->pTableMeta;
@@ -1858,7 +1855,7 @@ int32_t addProjectionExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
-      addProjectQueryCol(pQueryInfo, startPos, &index, pItem);
+      addProjectQueryCol(pQueryInfo, startPos, &index, pItem, getNewResColId(pCmd));
       pQueryInfo->type |= TSDB_QUERY_TYPE_PROJECTION_QUERY;
     }
 
@@ -1896,7 +1893,7 @@ static int32_t setExprInfoForFunctions(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SS
     bytes = pSchema->bytes;
   }
   
-  SExprInfo* pExpr = tscExprAppend(pQueryInfo, functionID, pColIndex, type, bytes, getNewResColId(pQueryInfo), bytes, false);
+  SExprInfo* pExpr = tscExprAppend(pQueryInfo, functionID, pColIndex, type, bytes, getNewResColId(pCmd), bytes, false);
   tstrncpy(pExpr->base.aliasName, name, tListLen(pExpr->base.aliasName));
 
   if (cvtFunc.originFuncId == TSDB_FUNC_LAST_ROW && cvtFunc.originFuncId != functionID) {
@@ -2008,7 +2005,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
 
           index = (SColumnIndex){0, PRIMARYKEY_TIMESTAMP_COL_INDEX};
           int32_t size = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes;
-          pExpr = tscExprAppend(pQueryInfo, functionId, &index, TSDB_DATA_TYPE_BIGINT, size, getNewResColId(pQueryInfo), size, false);
+          pExpr = tscExprAppend(pQueryInfo, functionId, &index, TSDB_DATA_TYPE_BIGINT, size, getNewResColId(pCmd), size, false);
         } else {
           // count the number of table created according to the super table
           if (getColumnIndexByName(pCmd, pToken, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
@@ -2025,12 +2022,12 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
           }
 
           int32_t size = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes;
-          pExpr = tscExprAppend(pQueryInfo, functionId, &index, TSDB_DATA_TYPE_BIGINT, size, getNewResColId(pQueryInfo), size, isTag);
+          pExpr = tscExprAppend(pQueryInfo, functionId, &index, TSDB_DATA_TYPE_BIGINT, size, getNewResColId(pCmd), size, isTag);
         }
       } else {  // count(*) is equalled to count(primary_timestamp_key)
         index = (SColumnIndex){0, PRIMARYKEY_TIMESTAMP_COL_INDEX};
         int32_t size = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes;
-        pExpr = tscExprAppend(pQueryInfo, functionId, &index, TSDB_DATA_TYPE_BIGINT, size, getNewResColId(pQueryInfo), size, false);
+        pExpr = tscExprAppend(pQueryInfo, functionId, &index, TSDB_DATA_TYPE_BIGINT, size, getNewResColId(pCmd), size, false);
       }
 
       pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
@@ -2116,7 +2113,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
         colIndex += 1;
         SColumnIndex indexTS = {.tableIndex = index.tableIndex, .columnIndex = 0};
         SExprInfo* pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &indexTS, TSDB_DATA_TYPE_TIMESTAMP, TSDB_KEYSIZE,
-                                           getNewResColId(pQueryInfo), TSDB_KEYSIZE, false);
+                                           getNewResColId(pCmd), TSDB_KEYSIZE, false);
 
         SColumnList ids = createColumnList(1, 0, 0);
         insertResultField(pQueryInfo, 0, &ids, TSDB_KEYSIZE, TSDB_DATA_TYPE_TIMESTAMP, aAggs[TSDB_FUNC_TS_DUMMY].name, pExpr);
@@ -2127,7 +2124,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
         return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);
       }
 
-      SExprInfo* pExpr = tscExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, getNewResColId(pQueryInfo), resultSize, false);
+      SExprInfo* pExpr = tscExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, getNewResColId(pCmd), resultSize, false);
 
       if (functionId == TSDB_FUNC_LEASTSQR) {
         /* set the leastsquares parameters */
@@ -2341,7 +2338,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
         tscInsertPrimaryTsSourceColumn(pQueryInfo, pTableMetaInfo->pTableMeta->id.uid);
         colIndex += 1;  // the first column is ts
 
-        pExpr = tscExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, getNewResColId(pQueryInfo), resultSize, false);
+        pExpr = tscExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, getNewResColId(pCmd), resultSize, false);
         tscExprAddParams(&pExpr->base, val, TSDB_DATA_TYPE_DOUBLE, sizeof(double));
       } else {
         tVariantDump(pVariant, val, TSDB_DATA_TYPE_BIGINT, true);
@@ -2354,7 +2351,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
         // todo REFACTOR
         // set the first column ts for top/bottom query
         SColumnIndex index1 = {index.tableIndex, PRIMARYKEY_TIMESTAMP_COL_INDEX};
-        pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS, &index1, TSDB_DATA_TYPE_TIMESTAMP, TSDB_KEYSIZE, getNewResColId(pQueryInfo),
+        pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS, &index1, TSDB_DATA_TYPE_TIMESTAMP, TSDB_KEYSIZE, getNewResColId(pCmd),
                                  TSDB_KEYSIZE, false);
         tstrncpy(pExpr->base.aliasName, aAggs[TSDB_FUNC_TS].name, sizeof(pExpr->base.aliasName));
 
@@ -2365,7 +2362,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
 
         colIndex += 1;  // the first column is ts
 
-        pExpr = tscExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, getNewResColId(pQueryInfo), resultSize, false);
+        pExpr = tscExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, getNewResColId(pCmd), resultSize, false);
         tscExprAddParams(&pExpr->base, val, TSDB_DATA_TYPE_BIGINT, sizeof(int64_t));
       }
   
@@ -2451,7 +2448,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
       s.bytes = bytes;
 
       TSDB_QUERY_SET_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_TAG_FILTER_QUERY);
-      tscAddFuncInSelectClause(pQueryInfo, 0, TSDB_FUNC_TID_TAG, &index, &s, TSDB_COL_TAG);
+      tscAddFuncInSelectClause(pQueryInfo, 0, TSDB_FUNC_TID_TAG, &index, &s, TSDB_COL_TAG, getNewResColId(pCmd));
       
       return TSDB_CODE_SUCCESS;
     }
@@ -2472,7 +2469,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
 
       s.bytes = bytes;
       s.type = (uint8_t)resType;
-      SExprInfo* pExpr = tscAddFuncInSelectClause(pQueryInfo, 0, TSDB_FUNC_BLKINFO, &index, &s, TSDB_COL_TAG);
+      SExprInfo* pExpr = tscAddFuncInSelectClause(pQueryInfo, 0, TSDB_FUNC_BLKINFO, &index, &s, TSDB_COL_TAG, getNewResColId(pCmd));
       pExpr->base.numOfParams = 1;
       pExpr->base.param[0].i64 = pTableMetaInfo->pTableMeta->tableInfo.rowSize;
       pExpr->base.param[0].nType = TSDB_DATA_TYPE_BIGINT;
@@ -4966,7 +4963,7 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
 
         // orderby ts query on super table
         if (tscOrderedProjectionQueryOnSTable(pQueryInfo, 0)) {
-          addPrimaryTsColIntoResult(pQueryInfo);
+          addPrimaryTsColIntoResult(pQueryInfo, pCmd);
         }
       }
     }
@@ -5772,7 +5769,7 @@ void addGroupInfoForSubquery(SSqlObj* pParentObj, SSqlObj* pSql, int32_t subClau
       int16_t type = pTagSchema->type;
       int16_t bytes = pTagSchema->bytes;
 
-      pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TAG, &index, type, bytes, getNewResColId(pQueryInfo), bytes, true);
+      pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TAG, &index, type, bytes, getNewResColId(&pSql->cmd), bytes, true);
       pExpr->base.colInfo.flag = TSDB_COL_TAG;
 
       // NOTE: tag column does not add to source column list
@@ -5797,7 +5794,7 @@ static void doLimitOutputNormalColOfGroupby(SExprInfo* pExpr) {
   pExpr->base.numOfParams = 1;
 }
 
-void doAddGroupColumnForSubquery(SQueryInfo* pQueryInfo, int32_t tagIndex) {
+void doAddGroupColumnForSubquery(SQueryInfo* pQueryInfo, int32_t tagIndex, SSqlCmd* pCmd) {
   SColIndex* pColIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, tagIndex);
   size_t size = tscNumOfExprs(pQueryInfo);
 
@@ -5807,7 +5804,7 @@ void doAddGroupColumnForSubquery(SQueryInfo* pQueryInfo, int32_t tagIndex) {
   SColumnIndex colIndex = {.tableIndex = 0, .columnIndex = pColIndex->colIndex};
 
   SExprInfo* pExprInfo = tscAddFuncInSelectClause(pQueryInfo, (int32_t)size, TSDB_FUNC_PRJ, &colIndex, pSchema,
-      TSDB_COL_NORMAL);
+      TSDB_COL_NORMAL, getNewResColId(pCmd));
 
   strncpy(pExprInfo->base.token, pExprInfo->base.colInfo.name, tListLen(pExprInfo->base.token));
 
@@ -6076,7 +6073,7 @@ static int32_t doAddGroupbyColumnsOnDemand(SSqlCmd* pCmd, SQueryInfo* pQueryInfo
     if (TSDB_COL_IS_TAG(pColIndex->flag)) {
       SColumnIndex index = {.tableIndex = pQueryInfo->groupbyExpr.tableIndex, .columnIndex = colIndex};
       SExprInfo*   pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TAG, &index, s->type, s->bytes,
-                                          getNewResColId(pQueryInfo), s->bytes, true);
+                                          getNewResColId(pCmd), s->bytes, true);
 
       memset(pExpr->base.aliasName, 0, sizeof(pExpr->base.aliasName));
       tstrncpy(pExpr->base.aliasName, s->name, sizeof(pExpr->base.aliasName));
@@ -6104,7 +6101,7 @@ static int32_t doAddGroupbyColumnsOnDemand(SSqlCmd* pCmd, SQueryInfo* pQueryInfo
 
       //if the group by column does not required by user, add an invisible column into the final result set.
       if (!hasGroupColumn) {
-        doAddGroupColumnForSubquery(pQueryInfo, i);
+        doAddGroupColumnForSubquery(pQueryInfo, i, pCmd);
       }
     }
   }
@@ -6275,7 +6272,7 @@ int32_t doLocalQueryProcess(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
   
   SColumnIndex ind = {0};
   SExprInfo* pExpr1 = tscExprAppend(pQueryInfo, TSDB_FUNC_TAG_DUMMY, &ind, TSDB_DATA_TYPE_INT,
-                                      tDataTypes[TSDB_DATA_TYPE_INT].bytes, getNewResColId(pQueryInfo), tDataTypes[TSDB_DATA_TYPE_INT].bytes, false);
+                                      tDataTypes[TSDB_DATA_TYPE_INT].bytes, getNewResColId(pCmd), tDataTypes[TSDB_DATA_TYPE_INT].bytes, false);
 
   tSqlExprItem* item = taosArrayGet(pExprList, 0);
   const char* name = (item->aliasName != NULL)? item->aliasName:functionsInfo[index].name;
@@ -7345,8 +7342,10 @@ static int32_t doValidateSubquery(SSqlNode* pSqlNode, int32_t index, SSqlObj* pS
 
   // all columns are added into the table column list
   STableMeta* pMeta = pTableMetaInfo1->pTableMeta;
+  int32_t startOffset = taosArrayGetSize(pQueryInfo->colList);
+
   for(int32_t i = 0; i < pMeta->tableInfo.numOfColumns; ++i) {
-    tscColumnListInsert(pQueryInfo->colList, i, pMeta->id.uid, &pMeta->schema[i]);
+    tscColumnListInsert(pQueryInfo->colList, i + startOffset, pMeta->id.uid, &pMeta->schema[i]);
   }
 
   return TSDB_CODE_SUCCESS;
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index ae836299e1..08085d7216 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -1644,8 +1644,6 @@ int tscProcessRetrieveLocalMergeRsp(SSqlObj *pSql) {
   qTableQuery(pQueryInfo->pQInfo, &localQueryId);
   convertQueryResult(pRes, pQueryInfo);
 
-//  handleDownstreamOperator(pRes, pQueryInfo);
-
   code = pRes->code;
   if (pRes->code == TSDB_CODE_SUCCESS) {
     (*pSql->fp)(pSql->param, pSql, pRes->numOfRows);
@@ -2189,7 +2187,7 @@ int tscProcessShowRsp(SSqlObj *pSql) {
     SInternalField* pInfo = tscFieldInfoAppend(pFieldInfo, &f);
     
     pInfo->pExpr = tscExprAppend(pQueryInfo, TSDB_FUNC_TS_DUMMY, &index,
-                     pTableSchema[i].type, pTableSchema[i].bytes, getNewResColId(pQueryInfo), pTableSchema[i].bytes, false);
+                     pTableSchema[i].type, pTableSchema[i].bytes, getNewResColId(pCmd), pTableSchema[i].bytes, false);
   }
   
   pCmd->numOfCols = pQueryInfo->fieldsInfo.numOfOutput;
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index c4688ca1b0..90bc5c985f 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -614,7 +614,7 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
 
       int16_t functionId = tscIsProjectionQuery(pQueryInfo)? TSDB_FUNC_PRJ : TSDB_FUNC_TS;
 
-      tscAddFuncInSelectClause(pQueryInfo, 0, functionId, &index, s, TSDB_COL_NORMAL);
+      tscAddFuncInSelectClause(pQueryInfo, 0, functionId, &index, s, TSDB_COL_NORMAL, getNewResColId(&pNew->cmd));
       tscPrintSelNodeList(pNew, 0);
       tscFieldInfoUpdateOffset(pQueryInfo);
 
@@ -817,7 +817,7 @@ static void issueTsCompQuery(SSqlObj* pSql, SJoinSupporter* pSupporter, SSqlObj*
   SSchema colSchema = {.type = TSDB_DATA_TYPE_BINARY, .bytes = 1};
   
   SColumnIndex index = {0, PRIMARYKEY_TIMESTAMP_COL_INDEX};
-  tscAddFuncInSelectClause(pQueryInfo, 0, TSDB_FUNC_TS_COMP, &index, &colSchema, TSDB_COL_NORMAL);
+  tscAddFuncInSelectClause(pQueryInfo, 0, TSDB_FUNC_TS_COMP, &index, &colSchema, TSDB_COL_NORMAL, getNewResColId(pCmd));
   
   // set the tags value for ts_comp function
   if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
@@ -1906,7 +1906,7 @@ int32_t tscCreateJoinSubquery(SSqlObj *pSql, int16_t tableIndex, SJoinSupporter
 
       // set get tags query type
       TSDB_QUERY_SET_TYPE(pNewQueryInfo->type, TSDB_QUERY_TYPE_TAG_FILTER_QUERY);
-      tscAddFuncInSelectClause(pNewQueryInfo, 0, TSDB_FUNC_TID_TAG, &colIndex, &s1, TSDB_COL_TAG);
+      tscAddFuncInSelectClause(pNewQueryInfo, 0, TSDB_FUNC_TID_TAG, &colIndex, &s1, TSDB_COL_TAG, getNewResColId(pCmd));
       size_t numOfCols = taosArrayGetSize(pNewQueryInfo->colList);
   
       tscDebug(
@@ -1917,7 +1917,7 @@ int32_t tscCreateJoinSubquery(SSqlObj *pSql, int16_t tableIndex, SJoinSupporter
     } else {
       SSchema      colSchema = {.type = TSDB_DATA_TYPE_BINARY, .bytes = 1};
       SColumnIndex colIndex = {0, PRIMARYKEY_TIMESTAMP_COL_INDEX};
-      tscAddFuncInSelectClause(pNewQueryInfo, 0, TSDB_FUNC_TS_COMP, &colIndex, &colSchema, TSDB_COL_NORMAL);
+      tscAddFuncInSelectClause(pNewQueryInfo, 0, TSDB_FUNC_TS_COMP, &colIndex, &colSchema, TSDB_COL_NORMAL, getNewResColId(pCmd));
 
       // set the tags value for ts_comp function
       SExprInfo *pExpr = tscExprGet(pNewQueryInfo, 0);
@@ -2332,7 +2332,7 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
       SColumnIndex colIndex = {.tableIndex = 0, .columnIndex = PRIMARYKEY_TIMESTAMP_COL_INDEX};
       SSchema* schema = tscGetColumnSchemaById(pTableMetaInfo1->pTableMeta, pExpr->base.colInfo.colId);
 
-      SExprInfo* p = tscAddFuncInSelectClause(pNewQueryInfo, index++, TSDB_FUNC_TS, &colIndex, schema, TSDB_COL_NORMAL);
+      SExprInfo* p = tscAddFuncInSelectClause(pNewQueryInfo, index++, TSDB_FUNC_TS, &colIndex, schema, TSDB_COL_NORMAL, getNewResColId(pCmd));
       p->base.resColId = pExpr->base.resColId;  // update the result column id
     } else if (pExpr->base.functionId == TSDB_FUNC_STDDEV_DST) {
       taosArrayPush(pSup->pColsInfo, &pExpr->base.resColId);
@@ -2341,7 +2341,7 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
       SSchema schema = {.type = TSDB_DATA_TYPE_DOUBLE, .bytes = sizeof(double)};
       tstrncpy(schema.name, pExpr->base.aliasName, tListLen(schema.name));
 
-      SExprInfo* p = tscAddFuncInSelectClause(pNewQueryInfo, index++, TSDB_FUNC_AVG, &colIndex, &schema, TSDB_COL_NORMAL);
+      SExprInfo* p = tscAddFuncInSelectClause(pNewQueryInfo, index++, TSDB_FUNC_AVG, &colIndex, &schema, TSDB_COL_NORMAL, getNewResColId(pCmd));
       p->base.resColId = pExpr->base.resColId;  // update the result column id
     } else if (pExpr->base.functionId == TSDB_FUNC_TAG) {
       pSup->tagLen += pExpr->base.resBytes;
@@ -2354,7 +2354,7 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
         schema = tGetTbnameColumnSchema();
       }
 
-      SExprInfo* p = tscAddFuncInSelectClause(pNewQueryInfo, index++, TSDB_FUNC_TAG, &colIndex, schema, TSDB_COL_TAG);
+      SExprInfo* p = tscAddFuncInSelectClause(pNewQueryInfo, index++, TSDB_FUNC_TAG, &colIndex, schema, TSDB_COL_TAG, getNewResColId(pCmd));
       p->base.resColId = pExpr->base.resColId;
     } else if (pExpr->base.functionId == TSDB_FUNC_PRJ) {
       int32_t num = (int32_t) taosArrayGetSize(pNewQueryInfo->groupbyExpr.columnInfo);
@@ -2368,7 +2368,7 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
           SSchema* schema = tscGetColumnSchemaById(pTableMetaInfo1->pTableMeta, pExpr->base.colInfo.colId);
 
           //doLimitOutputNormalColOfGroupby
-          SExprInfo* p = tscAddFuncInSelectClause(pNewQueryInfo, index++, TSDB_FUNC_PRJ, &colIndex, schema, TSDB_COL_NORMAL);
+          SExprInfo* p = tscAddFuncInSelectClause(pNewQueryInfo, index++, TSDB_FUNC_PRJ, &colIndex, schema, TSDB_COL_NORMAL, getNewResColId(pCmd));
           p->base.numOfParams = 1;
           p->base.param[0].i64 = 1;
           p->base.param[0].nType = TSDB_DATA_TYPE_INT;
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index c12aa4447d..a35d44bba7 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -14,10 +14,11 @@
  */
 
 #include "tscUtil.h"
+#include "tsched.h"
 #include "hash.h"
 #include "os.h"
-#include "texpr.h"
 #include "taosmsg.h"
+#include "texpr.h"
 #include "tkey.h"
 #include "tmd5.h"
 #include "tscLocalMerge.h"
@@ -634,18 +635,12 @@ void tscSetResRawPtrRv(SSqlRes* pRes, SQueryInfo* pQueryInfo, SSDataBlock* pBloc
   }
 }
 
-static SColumnInfo* extractColumnInfoFromResult(STableMeta* pTableMeta, SArray* pTableCols) {
+static SColumnInfo* extractColumnInfoFromResult(SArray* pTableCols) {
   int32_t numOfCols = (int32_t) taosArrayGetSize(pTableCols);
   SColumnInfo* pColInfo = calloc(numOfCols, sizeof(SColumnInfo));
-
-  SSchema *pSchema = pTableMeta->schema;
   for(int32_t i = 0; i < numOfCols; ++i) {
     SColumn* pCol = taosArrayGetP(pTableCols, i);
-    int32_t index = pCol->columnIndex;
-
-    pColInfo[i].type  = pSchema[index].type;
-    pColInfo[i].bytes = pSchema[index].bytes;
-    pColInfo[i].colId = pSchema[index].colId;
+    pColInfo[i] = pCol->info;//[index].type;
   }
 
   return pColInfo;
@@ -656,6 +651,10 @@ typedef struct SDummyInputInfo {
   SSqlRes        *pRes;  // refactor: remove it
 } SDummyInputInfo;
 
+typedef struct SJoinOperatorInfo {
+  int32_t a;
+} SJoinOperatorInfo;
+
 SSDataBlock* doGetDataBlock(void* param, bool* newgroup) {
   SOperatorInfo *pOperator = (SOperatorInfo*) param;
 
@@ -729,6 +728,39 @@ SOperatorInfo* createDummyInputOperator(char* pResult, SSchema* pSchema, int32_t
   return pOptr;
 }
 
+SOperatorInfo* createJoinOperator(SOperatorInfo** pUpstream, int32_t numOfUpstream, SExprInfo* pExprInfo, int32_t numOfOutput) {
+  SJoinInfo* pInfo = calloc(1, sizeof(SJoinInfo));
+/*
+  pInfo->pRes  = (SSqlRes*) pResult;
+  pInfo->block = calloc(numOfCols, sizeof(SSDataBlock));
+  pInfo->block->info.numOfCols = numOfCols;
+
+  pInfo->block->pDataBlock = taosArrayInit(numOfCols, sizeof(SColumnInfoData));
+  for(int32_t i = 0; i < numOfCols; ++i) {
+    SColumnInfoData colData = {{0}};
+    colData.info.bytes = pSchema[i].bytes;
+    colData.info.type  = pSchema[i].type;
+    colData.info.colId = pSchema[i].colId;
+
+    taosArrayPush(pInfo->block->pDataBlock, &colData);
+  }
+*/
+  SOperatorInfo* pOptr = calloc(1, sizeof(SOperatorInfo));
+  pOptr->name          = "JoinOperator";
+  pOptr->operatorType  = OP_Join;
+  pOptr->numOfOutput   = numOfOutput;
+  pOptr->blockingOptr  = false;
+  pOptr->info          = pInfo;
+  pOptr->exec          = doGetDataBlock;
+  pOptr->cleanup       = destroyDummyInputOperator;
+
+  for(int32_t i = 0; i < numOfUpstream; ++i) {
+    appendUpstream(pOptr, pUpstream[0]);
+  }
+
+  return pOptr;
+}
+
 void convertQueryResult(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
   // set the correct result
   SSDataBlock* p = pQueryInfo->pQInfo->runtimeEnv.outputBuf;
@@ -743,40 +775,51 @@ void convertQueryResult(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
   pRes->completed = (pRes->numOfRows == 0);
 }
 
-void handleDownstreamOperator(SSqlRes* pRes, SQueryInfo* pQueryInfo, SSqlRes* pOutput) {
-  if (pQueryInfo->pDownstream != NULL) {
-    // handle the following query process
-    SQueryInfo *px = pQueryInfo->pDownstream;
-    if (px->pQInfo == NULL) {
-      SColumnInfo* pColumnInfo = extractColumnInfoFromResult(px->pTableMetaInfo[0]->pTableMeta, px->colList);
-      int32_t numOfOutput = (int32_t) tscNumOfExprs(px);
+void handleDownstreamOperator(SSqlRes* pRes, SQueryInfo* px, SSqlRes* pOutput) {
+  // handle the following query process
+  if (px->pQInfo == NULL) {
+    SColumnInfo* pColumnInfo = extractColumnInfoFromResult(px->colList);
 
-      int32_t numOfCols = (int32_t) taosArrayGetSize(px->colList);
-      SQueriedTableInfo info = {.colList = pColumnInfo, .numOfCols = numOfCols,};
-      SSchema* pSchema = tscGetTableSchema(px->pTableMetaInfo[0]->pTableMeta);
+    int32_t numOfOutput = (int32_t)tscNumOfExprs(px);
+    int32_t numOfCols = (int32_t)taosArrayGetSize(px->colList);
 
-      STableGroupInfo tableGroupInfo = {.numOfTables = 1, .pGroupList = taosArrayInit(1, POINTER_BYTES),};
-      tableGroupInfo.map = taosHashInit(1, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK);
+    SQueriedTableInfo info = {
+        .colList = pColumnInfo,
+        .numOfCols = numOfCols,
+    };
 
-      STableKeyInfo tableKeyInfo = {.pTable = NULL, .lastKey = INT64_MIN};
+    SSchema* pSchema = tscGetTableSchema(px->pTableMetaInfo[0]->pTableMeta);
 
-      SArray* group = taosArrayInit(1, sizeof(STableKeyInfo));
-      taosArrayPush(group, &tableKeyInfo);
+    STableGroupInfo tableGroupInfo = {
+        .numOfTables = 1,
+        .pGroupList = taosArrayInit(1, POINTER_BYTES),
+    };
 
-      taosArrayPush(tableGroupInfo.pGroupList, &group);
+    tableGroupInfo.map = taosHashInit(1, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK);
 
-      SOperatorInfo* pSourceOptr = createDummyInputOperator((char*)pRes, pSchema, numOfCols);
+    STableKeyInfo tableKeyInfo = {.pTable = NULL, .lastKey = INT64_MIN};
 
-      SExprInfo *exprInfo = NULL;
-      /*int32_t code = */createQueryFunc(&info, numOfOutput, &exprInfo, px->exprList->pData, NULL, px->type, NULL);
-      px->pQInfo = createQueryInfoFromQueryNode(px, exprInfo, &tableGroupInfo, pSourceOptr, NULL, NULL, MASTER_SCAN);
-      tfree(pColumnInfo);
+    SArray* group = taosArrayInit(1, sizeof(STableKeyInfo));
+    taosArrayPush(group, &tableKeyInfo);
+
+    taosArrayPush(tableGroupInfo.pGroupList, &group);
+
+    // if it is a join query, create join operator here
+    SOperatorInfo* pSourceOperator = createDummyInputOperator((char*)pRes, pSchema, numOfCols);
+    if (px->numOfTables > 1) {
+
+      pSourceOperator = createJoinOperator(&pSourceOperator, 1, NULL, pSourceOperator->numOfOutput);
     }
 
-    uint64_t qId = 0;
-    qTableQuery(px->pQInfo, &qId);
-    convertQueryResult(pOutput, px);
+    SExprInfo* exprInfo = NULL;
+    /*int32_t code = */ createQueryFunc(&info, numOfOutput, &exprInfo, px->exprList->pData, NULL, px->type, NULL);
+    px->pQInfo = createQueryInfoFromQueryNode(px, exprInfo, &tableGroupInfo, pSourceOperator, NULL, NULL, MASTER_SCAN);
+    tfree(pColumnInfo);
   }
+
+  uint64_t qId = 0;
+  qTableQuery(px->pQInfo, &qId);
+  convertQueryResult(pOutput, px);
 }
 
 static void tscDestroyResPointerInfo(SSqlRes* pRes) {
@@ -2340,7 +2383,6 @@ void tscInitQueryInfo(SQueryInfo* pQueryInfo) {
   pQueryInfo->exprList       = taosArrayInit(4, POINTER_BYTES);
   pQueryInfo->colList        = taosArrayInit(4, POINTER_BYTES);
   pQueryInfo->udColumnId     = TSDB_UD_COLUMN_INDEX;
-  pQueryInfo->resColumnId    = TSDB_RES_COL_ID;
   pQueryInfo->limit.limit    = -1;
   pQueryInfo->limit.offset   = 0;
 
@@ -2949,6 +2991,40 @@ void doExecuteQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
   }
 }
 
+static void doRetrieveSubqueryData(SSchedMsg *pMsg) {
+  SSqlObj* pSql = (SSqlObj*)taosAcquireRef(tscObjRef, (int64_t)pMsg->ahandle);
+  if (pSql == NULL || pSql->signature != pSql) {
+    tscDebug("%p SqlObj is freed, not add into queue async res", pMsg->ahandle);
+    return;
+  }
+
+  int32_t numOfRows = 0;
+  for(int32_t i = 0; i < pSql->subState.numOfSub; ++i) {
+    SSqlObj*    pSub = pSql->pSubs[i];
+    /*TAOS_ROW row = */taos_fetch_row(pSub);
+//    SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSub->cmd);
+//    int32_t rows = taos_fetch_block(pSub, &row);
+    if (numOfRows == 0) {
+      numOfRows = pSub->res.numOfRows;
+    }
+  }
+
+  if (numOfRows > 0) {
+    SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
+    SSqlObj    *pSub = pSql->pSubs[0];
+    handleDownstreamOperator(&pSub->res, pQueryInfo, &pSql->res);
+  }
+
+//  int32_t code = pSql->res.code;
+  pSql->res.qId = -1;
+  if (pSql->res.code == TSDB_CODE_SUCCESS) {
+    (*pSql->fp)(pSql->param, pSql, pSql->res.numOfRows);
+  } else {
+    tscAsyncResultOnError(pSql);
+  }
+}
+
+// NOTE: the blocking query can not be executed in the rpc message handler thread
 static void tscSubqueryRetrieveCallback(void* param, TAOS_RES* tres, int code) {
   // handle the pDownStream process
   SRetrieveSupport* ps = param;
@@ -2960,27 +3036,37 @@ static void tscSubqueryRetrieveCallback(void* param, TAOS_RES* tres, int code) {
     return;
   }
 
+  pParentSql->cmd.active = pParentSql->cmd.pQueryInfo;
+
+  SSchedMsg schedMsg = {0};
+  schedMsg.fp = doRetrieveSubqueryData;
+  schedMsg.ahandle = (void *)pParentSql->self;
+  schedMsg.thandle = (void *)1;
+  schedMsg.msg = 0;
+  taosScheduleTask(tscQhandle, &schedMsg);
+
   // merge all subquery result
-  SSqlCmd* pCmd = &pSql->cmd;
-  SSqlRes* pRes = &pSql->res;
+//  SSqlCmd* pCmd = &pSql->cmd;
+//  SSqlRes* pRes = &pSql->res;
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
-  /*TAOS_ROW* pRow = */taos_fetch_row(pSql);
-  if (pSql->res.numOfRows > 0) {
-    handleDownstreamOperator(pRes, pQueryInfo, &pParentSql->res);
-  }
+  // add it to the message queue
 
-  code = pParentSql->res.code;
-  pParentSql->res.qId = -1;
-  if (pParentSql->res.code == TSDB_CODE_SUCCESS) {
-    (*pParentSql->fp)(pParentSql->param, pParentSql, pParentSql->res.numOfRows);
-  } else {
-    tscAsyncResultOnError(pParentSql);
-  }
+//  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
+//  /*TAOS_ROW* pRow = */taos_fetch_row(pSql);
+//  if (pSql->res.numOfRows > 0) {
+//    handleDownstreamOperator(pRes, pQueryInfo, &pParentSql->res);
+//  }
+//
+//  code = pParentSql->res.code;
+//  pParentSql->res.qId = -1;
+//  if (pParentSql->res.code == TSDB_CODE_SUCCESS) {
+//    (*pParentSql->fp)(pParentSql->param, pParentSql, pParentSql->res.numOfRows);
+//  } else {
+//    tscAsyncResultOnError(pParentSql);
+//  }
 }
 
 static void tscSubqueryCompleteCallback(void* param, TAOS_RES* tres, int code) {
-  printf("123\n");
   taos_fetch_rows_a(tres, tscSubqueryRetrieveCallback, param);
 }
 
@@ -3000,43 +3086,44 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
     pSql->pSubs = calloc(pSql->subState.numOfSub, POINTER_BYTES);
     pSql->subState.states = calloc(pSql->subState.numOfSub, sizeof(int8_t));
 
-    SQueryInfo* pSub = taosArrayGetP(pQueryInfo->pUpstream, 0);
+    for(int32_t i = 0; i < pSql->subState.numOfSub; ++i) {
+      SQueryInfo* pSub = taosArrayGetP(pQueryInfo->pUpstream, i);
 
-    pSql->cmd.active = pSub;
-    pSql->cmd.command = TSDB_SQL_SELECT;
+      pSql->cmd.active = pSub;
+      pSql->cmd.command = TSDB_SQL_SELECT;
 
-    SSqlObj* pNew = (SSqlObj*)calloc(1, sizeof(SSqlObj));
-    if (pNew == NULL) {
-      terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
-//      return NULL;
+      SSqlObj* pNew = (SSqlObj*)calloc(1, sizeof(SSqlObj));
+      if (pNew == NULL) {
+        terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
+        //      return NULL;
+      }
+
+      pNew->pTscObj = pSql->pTscObj;
+      pNew->signature = pNew;
+      pNew->sqlstr = strdup(pSql->sqlstr);  // todo refactor
+      pNew->fp = tscSubqueryCompleteCallback;
+
+      SRetrieveSupport* ps = calloc(1, sizeof(SRetrieveSupport));  // todo use object id
+      ps->pParentSql = pSql;
+      ps->subqueryIndex = i;
+
+      pNew->param = ps;
+      pSql->pSubs[i] = pNew;
+      registerSqlObj(pNew);
+
+      SSqlCmd* pCmd = &pNew->cmd;
+      pCmd->command = TSDB_SQL_SELECT;
+      pCmd->parseFinished = 1;
+
+      if (tscAddQueryInfo(pCmd) != TSDB_CODE_SUCCESS) {
+      }
+
+      SQueryInfo* pNewQueryInfo = tscGetQueryInfo(pCmd);
+      tscQueryInfoCopy(pNewQueryInfo, pSub);
+
+      // create sub query to handle the sub query.
+      executeQuery(pNew, pSub);
     }
-
-    pNew->pTscObj   = pSql->pTscObj;
-    pNew->signature = pNew;
-    pNew->sqlstr    = strdup(pSql->sqlstr); // todo refactor
-    pNew->fp        = tscSubqueryCompleteCallback;
-
-    SRetrieveSupport* ps = calloc(1, sizeof(SRetrieveSupport));// todo use object id
-    ps->pParentSql    = pSql;
-    ps->subqueryIndex = 0;
-
-    pNew->param    = ps;
-    pSql->pSubs[0] = pNew;
-    registerSqlObj(pNew);
-
-    SSqlCmd* pCmd = &pNew->cmd;
-    pCmd->command = TSDB_SQL_SELECT;
-    pCmd->parseFinished = 1;
-
-    if (tscAddQueryInfo(pCmd) != TSDB_CODE_SUCCESS) {
-    }
-
-    SQueryInfo* pNewQueryInfo = tscGetQueryInfo(pCmd);
-    tscQueryInfoCopy(pNewQueryInfo, pSub);
-
-    // create sub query to handle the sub query.
-    executeQuery(pNew, pSub);
-
     // merge sub query result and generate final results
     return;
   }
diff --git a/src/query/inc/qExecutor.h b/src/query/inc/qExecutor.h
index 3e0f1f5e8f..8e22b4e208 100644
--- a/src/query/inc/qExecutor.h
+++ b/src/query/inc/qExecutor.h
@@ -302,6 +302,7 @@ enum OPERATOR_TYPE_E {
   OP_GlobalAggregate   = 18,   // global merge for the multi-way data sources.
   OP_Filter            = 19,
   OP_Distinct          = 20,
+  OP_Join              = 21,
 };
 
 typedef struct SOperatorInfo {
@@ -314,7 +315,8 @@ typedef struct SOperatorInfo {
   SExprInfo            *pExpr;
   SQueryRuntimeEnv     *pRuntimeEnv;
 
-  struct SOperatorInfo *upstream;
+  struct SOperatorInfo **upstream;     // upstream pointer list
+  int32_t               numOfUpstream; // number of upstream. The value is always ONE expect for join operator
   __operator_fn_t       exec;
   __optr_cleanup_fn_t   cleanup;
 } SOperatorInfo;
@@ -494,6 +496,8 @@ typedef struct SMultiwayMergeInfo {
   bool                 groupMix;
 } SMultiwayMergeInfo;
 
+void appendUpstream(SOperatorInfo* p, SOperatorInfo* pUpstream);
+
 SOperatorInfo* createDataBlocksOptScanInfo(void* pTsdbQueryHandle, SQueryRuntimeEnv* pRuntimeEnv, int32_t repeatTime, int32_t reverseTime);
 SOperatorInfo* createTableScanOperator(void* pTsdbQueryHandle, SQueryRuntimeEnv* pRuntimeEnv, int32_t repeatTime);
 SOperatorInfo* createTableSeqScanOperator(void* pTsdbQueryHandle, SQueryRuntimeEnv* pRuntimeEnv);
@@ -517,6 +521,8 @@ SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperator
 SOperatorInfo* createFilterOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr,
                                         int32_t numOfOutput, SColumnInfo* pCols, int32_t numOfFilter);
 
+SOperatorInfo* createJoinOperator(SOperatorInfo** pUpstream, int32_t numOfUpstream, SExprInfo* pExprInfo, int32_t numOfOutput);
+
 SSDataBlock* doGlobalAggregate(void* param, bool* newgroup);
 SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup);
 SSDataBlock* doSLimit(void* param, bool* newgroup);
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index da857533ac..5035e9cbd7 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -1710,38 +1710,38 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
       case OP_MultiTableTimeInterval: {
         pRuntimeEnv->proot =
             createMultiTableTimeIntervalOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr1, pQueryAttr->numOfOutput);
-        setTableScanFilterOperatorInfo(pRuntimeEnv->proot->upstream->info, pRuntimeEnv->proot);
+        setTableScanFilterOperatorInfo(pRuntimeEnv->proot->upstream[0]->info, pRuntimeEnv->proot);
         break;
       }
       case OP_TimeWindow: {
         pRuntimeEnv->proot =
             createTimeIntervalOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr1, pQueryAttr->numOfOutput);
-        setTableScanFilterOperatorInfo(pRuntimeEnv->proot->upstream->info, pRuntimeEnv->proot);
+        setTableScanFilterOperatorInfo(pRuntimeEnv->proot->upstream[0]->info, pRuntimeEnv->proot);
         break;
       }
       case OP_Groupby: {
         pRuntimeEnv->proot =
             createGroupbyOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr1, pQueryAttr->numOfOutput);
-        setTableScanFilterOperatorInfo(pRuntimeEnv->proot->upstream->info, pRuntimeEnv->proot);
+        setTableScanFilterOperatorInfo(pRuntimeEnv->proot->upstream[0]->info, pRuntimeEnv->proot);
         break;
       }
       case OP_SessionWindow: {
         pRuntimeEnv->proot =
             createSWindowOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr1, pQueryAttr->numOfOutput);
-        setTableScanFilterOperatorInfo(pRuntimeEnv->proot->upstream->info, pRuntimeEnv->proot);
+        setTableScanFilterOperatorInfo(pRuntimeEnv->proot->upstream[0]->info, pRuntimeEnv->proot);
         break;
       }
       case OP_MultiTableAggregate: {
         pRuntimeEnv->proot =
             createMultiTableAggOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr1, pQueryAttr->numOfOutput);
-        setTableScanFilterOperatorInfo(pRuntimeEnv->proot->upstream->info, pRuntimeEnv->proot);
+        setTableScanFilterOperatorInfo(pRuntimeEnv->proot->upstream[0]->info, pRuntimeEnv->proot);
         break;
       }
       case OP_Aggregate: {
         pRuntimeEnv->proot =
             createAggregateOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr1, pQueryAttr->numOfOutput);
-        if (pRuntimeEnv->proot->upstream->operatorType != OP_DummyInput) {
-          setTableScanFilterOperatorInfo(pRuntimeEnv->proot->upstream->info, pRuntimeEnv->proot);
+        if (pRuntimeEnv->proot->upstream[0]->operatorType != OP_DummyInput) {
+          setTableScanFilterOperatorInfo(pRuntimeEnv->proot->upstream[0]->info, pRuntimeEnv->proot);
         }
         break;
       }
@@ -3927,6 +3927,15 @@ void queryCostStatis(SQInfo *pQInfo) {
 //  return true;
 //}
 
+void appendUpstream(SOperatorInfo* p, SOperatorInfo* pUpstream) {
+  if (p->upstream == NULL) {
+    assert(p->numOfOutput == 0);
+  }
+
+  p->upstream = realloc(p->upstream, POINTER_BYTES * (p->numOfOutput + 1));
+  p->upstream[p->numOfOutput++] = pUpstream;
+}
+
 static void doDestroyTableQueryInfo(STableGroupInfo* pTableqinfoGroupInfo);
 
 static int32_t setupQueryHandle(void* tsdb, SQueryRuntimeEnv* pRuntimeEnv, int64_t qId, bool isSTableQuery) {
@@ -4604,13 +4613,14 @@ SOperatorInfo* createGlobalAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv,
   pOperator->blockingOptr = true;
   pOperator->status       = OP_IN_EXECUTING;
   pOperator->info         = pInfo;
-  pOperator->upstream     = upstream;
   pOperator->pExpr        = pExpr;
   pOperator->numOfOutput  = numOfOutput;
   pOperator->pRuntimeEnv  = pRuntimeEnv;
 
   pOperator->exec         = doGlobalAggregate;
   pOperator->cleanup      = destroyGlobalAggOperatorInfo;
+  appendUpstream(pOperator, upstream);
+
   return pOperator;
 }
 
@@ -4675,7 +4685,7 @@ static SSDataBlock* doAggregate(void* param, bool* newgroup) {
   SQueryAttr* pQueryAttr = pRuntimeEnv->pQueryAttr;
   int32_t order = pQueryAttr->order.order;
 
-  SOperatorInfo* upstream = pOperator->upstream;
+  SOperatorInfo* upstream = pOperator->upstream[0];
 
   while(1) {
     SSDataBlock* pBlock = upstream->exec(upstream, newgroup);
@@ -4730,7 +4740,7 @@ static SSDataBlock* doSTableAggregate(void* param, bool* newgroup) {
   SQueryAttr* pQueryAttr = pRuntimeEnv->pQueryAttr;
   int32_t order = pQueryAttr->order.order;
 
-  SOperatorInfo* upstream = pOperator->upstream;
+  SOperatorInfo* upstream = pOperator->upstream[0];
 
   while(1) {
     SSDataBlock* pBlock = upstream->exec(upstream, newgroup);
@@ -4814,7 +4824,7 @@ static SSDataBlock* doArithmeticOperation(void* param, bool* newgroup) {
     bool prevVal = *newgroup;
 
     // The upstream exec may change the value of the newgroup, so use a local variable instead.
-    SSDataBlock* pBlock = pOperator->upstream->exec(pOperator->upstream, newgroup);
+    SSDataBlock* pBlock = pOperator->upstream[0]->exec(pOperator->upstream, newgroup);
     if (pBlock == NULL) {
       assert(*newgroup == false);
 
@@ -4868,7 +4878,7 @@ static SSDataBlock* doLimit(void* param, bool* newgroup) {
 
   SSDataBlock* pBlock = NULL;
   while (1) {
-    pBlock = pOperator->upstream->exec(pOperator->upstream, newgroup);
+    pBlock = pOperator->upstream[0]->exec(pOperator->upstream, newgroup);
     if (pBlock == NULL) {
       setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
       pOperator->status = OP_EXEC_DONE;
@@ -4939,7 +4949,7 @@ static SSDataBlock* doFilter(void* param, bool* newgroup) {
   SQueryRuntimeEnv* pRuntimeEnv = pOperator->pRuntimeEnv;
 
   while (1) {
-    SSDataBlock *pBlock = pOperator->upstream->exec(pOperator->upstream, newgroup);
+    SSDataBlock *pBlock = pOperator->upstream[0]->exec(pOperator->upstream, newgroup);
     if (pBlock == NULL) {
       break;
     }
@@ -4981,7 +4991,7 @@ static SSDataBlock* doIntervalAgg(void* param, bool* newgroup) {
   int32_t order = pQueryAttr->order.order;
   STimeWindow win = pQueryAttr->window;
 
-  SOperatorInfo* upstream = pOperator->upstream;
+  SOperatorInfo* upstream = pOperator->upstream[0];
 
   while(1) {
     SSDataBlock* pBlock = upstream->exec(upstream, newgroup);
@@ -5034,7 +5044,7 @@ static SSDataBlock* doSTableIntervalAgg(void* param, bool* newgroup) {
   SQueryAttr* pQueryAttr = pRuntimeEnv->pQueryAttr;
   int32_t order = pQueryAttr->order.order;
 
-  SOperatorInfo* upstream = pOperator->upstream;
+  SOperatorInfo* upstream = pOperator->upstream[0];
 
   while(1) {
     SSDataBlock* pBlock = upstream->exec(upstream, newgroup);
@@ -5089,7 +5099,7 @@ static SSDataBlock* doSessionWindowAgg(void* param, bool* newgroup) {
   int32_t order = pQueryAttr->order.order;
   STimeWindow win = pQueryAttr->window;
 
-  SOperatorInfo* upstream = pOperator->upstream;
+  SOperatorInfo* upstream = pOperator->upstream[0];
 
   while(1) {
     SSDataBlock* pBlock = upstream->exec(upstream, newgroup);
@@ -5140,7 +5150,7 @@ static SSDataBlock* hashGroupbyAggregate(void* param, bool* newgroup) {
     return pInfo->binfo.pRes;
   }
 
-  SOperatorInfo* upstream = pOperator->upstream;
+  SOperatorInfo* upstream = pOperator->upstream[0];
 
   while(1) {
     SSDataBlock* pBlock = upstream->exec(upstream, newgroup);
@@ -5209,7 +5219,7 @@ static SSDataBlock* doFill(void* param, bool* newgroup) {
   }
 
   while(1) {
-    SSDataBlock* pBlock = pOperator->upstream->exec(pOperator->upstream, newgroup);
+    SSDataBlock* pBlock = pOperator->upstream[0]->exec(pOperator->upstream, newgroup);
     if (*newgroup) {
       assert(pBlock != NULL);
     }
@@ -5285,7 +5295,7 @@ static void destroyOperatorInfo(SOperatorInfo* pOperator) {
     pOperator->cleanup(pOperator->info, pOperator->numOfOutput);
   }
 
-  destroyOperatorInfo(pOperator->upstream);
+  destroyOperatorInfo(pOperator->upstream[0]);
   tfree(pOperator->info);
   tfree(pOperator);
 }
@@ -5310,13 +5320,14 @@ SOperatorInfo* createAggregateOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOpera
   pOperator->blockingOptr = true;
   pOperator->status       = OP_IN_EXECUTING;
   pOperator->info         = pInfo;
-  pOperator->upstream     = upstream;
   pOperator->pExpr        = pExpr;
   pOperator->numOfOutput  = numOfOutput;
   pOperator->pRuntimeEnv  = pRuntimeEnv;
 
   pOperator->exec         = doAggregate;
   pOperator->cleanup      = destroyBasicOperatorInfo;
+  appendUpstream(pOperator, upstream);
+
   return pOperator;
 }
 
@@ -5383,13 +5394,13 @@ SOperatorInfo* createMultiTableAggOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SO
   pOperator->blockingOptr = true;
   pOperator->status       = OP_IN_EXECUTING;
   pOperator->info         = pInfo;
-  pOperator->upstream     = upstream;
   pOperator->pExpr        = pExpr;
   pOperator->numOfOutput  = numOfOutput;
   pOperator->pRuntimeEnv  = pRuntimeEnv;
 
   pOperator->exec         = doSTableAggregate;
   pOperator->cleanup      = destroyBasicOperatorInfo;
+  appendUpstream(pOperator, upstream);
 
   return pOperator;
 }
@@ -5413,13 +5424,13 @@ SOperatorInfo* createArithOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorI
   pOperator->blockingOptr = false;
   pOperator->status       = OP_IN_EXECUTING;
   pOperator->info         = pInfo;
-  pOperator->upstream     = upstream;
   pOperator->pExpr        = pExpr;
   pOperator->numOfOutput  = numOfOutput;
   pOperator->pRuntimeEnv  = pRuntimeEnv;
 
   pOperator->exec         = doArithmeticOperation;
   pOperator->cleanup      = destroyArithOperatorInfo;
+  appendUpstream(pOperator, upstream);
 
   return pOperator;
 }
@@ -5464,11 +5475,11 @@ SOperatorInfo* createFilterOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperator
   pOperator->status       = OP_IN_EXECUTING;
   pOperator->numOfOutput  = numOfOutput;
   pOperator->pExpr        = pExpr;
-  pOperator->upstream     = upstream;
   pOperator->exec         = doFilter;
   pOperator->info         = pInfo;
   pOperator->pRuntimeEnv  = pRuntimeEnv;
   pOperator->cleanup      = destroyConditionOperatorInfo;
+  appendUpstream(pOperator, upstream);
 
   return pOperator;
 }
@@ -5483,10 +5494,10 @@ SOperatorInfo* createLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorI
   pOperator->operatorType = OP_Limit;
   pOperator->blockingOptr = false;
   pOperator->status       = OP_IN_EXECUTING;
-  pOperator->upstream     = upstream;
   pOperator->exec         = doLimit;
   pOperator->info         = pInfo;
   pOperator->pRuntimeEnv  = pRuntimeEnv;
+  appendUpstream(pOperator, upstream);
 
   return pOperator;
 }
@@ -5504,7 +5515,6 @@ SOperatorInfo* createTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOp
   pOperator->operatorType = OP_TimeWindow;
   pOperator->blockingOptr = true;
   pOperator->status       = OP_IN_EXECUTING;
-  pOperator->upstream     = upstream;
   pOperator->pExpr        = pExpr;
   pOperator->numOfOutput  = numOfOutput;
   pOperator->info         = pInfo;
@@ -5512,6 +5522,7 @@ SOperatorInfo* createTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOp
   pOperator->exec         = doIntervalAgg;
   pOperator->cleanup      = destroyBasicOperatorInfo;
 
+  appendUpstream(pOperator, upstream);
   return pOperator;
 }
 
@@ -5529,7 +5540,6 @@ SOperatorInfo* createSWindowOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperato
   pOperator->operatorType = OP_SessionWindow;
   pOperator->blockingOptr = true;
   pOperator->status       = OP_IN_EXECUTING;
-  pOperator->upstream     = upstream;
   pOperator->pExpr        = pExpr;
   pOperator->numOfOutput  = numOfOutput;
   pOperator->info         = pInfo;
@@ -5537,6 +5547,7 @@ SOperatorInfo* createSWindowOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperato
   pOperator->exec         = doSessionWindowAgg;
   pOperator->cleanup      = destroyBasicOperatorInfo;
 
+  appendUpstream(pOperator, upstream);
   return pOperator;
 }
 
@@ -5552,7 +5563,6 @@ SOperatorInfo* createMultiTableTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRunti
   pOperator->operatorType = OP_MultiTableTimeInterval;
   pOperator->blockingOptr = true;
   pOperator->status       = OP_IN_EXECUTING;
-  pOperator->upstream     = upstream;
   pOperator->pExpr        = pExpr;
   pOperator->numOfOutput  = numOfOutput;
   pOperator->info         = pInfo;
@@ -5561,6 +5571,7 @@ SOperatorInfo* createMultiTableTimeIntervalOperatorInfo(SQueryRuntimeEnv* pRunti
   pOperator->exec         = doSTableIntervalAgg;
   pOperator->cleanup      = destroyBasicOperatorInfo;
 
+  appendUpstream(pOperator, upstream);
   return pOperator;
 }
 
@@ -5577,7 +5588,6 @@ SOperatorInfo* createGroupbyOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperato
   pOperator->blockingOptr = true;
   pOperator->status       = OP_IN_EXECUTING;
   pOperator->operatorType = OP_Groupby;
-  pOperator->upstream     = upstream;
   pOperator->pExpr        = pExpr;
   pOperator->numOfOutput  = numOfOutput;
   pOperator->info         = pInfo;
@@ -5585,6 +5595,7 @@ SOperatorInfo* createGroupbyOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperato
   pOperator->exec         = hashGroupbyAggregate;
   pOperator->cleanup      = destroyGroupbyOperatorInfo;
 
+  appendUpstream(pOperator, upstream);
   return pOperator;
 }
 
@@ -5614,8 +5625,6 @@ SOperatorInfo* createFillOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorIn
   pOperator->blockingOptr = false;
   pOperator->status       = OP_IN_EXECUTING;
   pOperator->operatorType = OP_Fill;
-
-  pOperator->upstream     = upstream;
   pOperator->pExpr        = pExpr;
   pOperator->numOfOutput  = numOfOutput;
   pOperator->info         = pInfo;
@@ -5624,6 +5633,7 @@ SOperatorInfo* createFillOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorIn
   pOperator->exec         = doFill;
   pOperator->cleanup      = destroySFillOperatorInfo;
 
+  appendUpstream(pOperator, upstream);
   return pOperator;
 }
 
@@ -5662,11 +5672,12 @@ SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperator
   pOperator->operatorType = OP_SLimit;
   pOperator->blockingOptr = false;
   pOperator->status       = OP_IN_EXECUTING;
-  pOperator->upstream     = upstream;
   pOperator->exec         = doSLimit;
   pOperator->info         = pInfo;
   pOperator->pRuntimeEnv  = pRuntimeEnv;
   pOperator->cleanup      = destroySlimitOperatorInfo;
+
+  appendUpstream(pOperator, upstream);
   return pOperator;
 }
 
@@ -5833,7 +5844,7 @@ static SSDataBlock* hashDistinct(void* param, bool* newgroup) {
   pRes->info.rows = 0;
   SSDataBlock* pBlock = NULL;
   while(1) {
-    pBlock = pOperator->upstream->exec(pOperator->upstream, newgroup);
+    pBlock = pOperator->upstream[0]->exec(pOperator->upstream, newgroup);
     if (pBlock == NULL) {
       setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
       pOperator->status = OP_EXEC_DONE;
@@ -5894,12 +5905,13 @@ SOperatorInfo* createDistinctOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperat
   pOperator->blockingOptr = false;
   pOperator->status       = OP_IN_EXECUTING;
   pOperator->operatorType = OP_Distinct;
-  pOperator->upstream     = upstream;
   pOperator->numOfOutput  = numOfOutput;
   pOperator->info         = pInfo;
   pOperator->pRuntimeEnv  = pRuntimeEnv;
   pOperator->exec         = hashDistinct;
   pOperator->cleanup      = destroyDistinctOperatorInfo;
+
+  appendUpstream(pOperator, upstream);
   return pOperator;
 }
 

From 9d3d129fef2ad42747022e5c96dea2363e31e698 Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Mon, 17 May 2021 13:37:59 +0800
Subject: [PATCH 027/128] [TD-4034]add timestamp in last NULL column

---
 src/common/inc/tdataformat.h | 1 +
 src/tsdb/src/tsdbMemTable.c  | 3 ++-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/common/inc/tdataformat.h b/src/common/inc/tdataformat.h
index 88d5b85010..fcae7a415f 100644
--- a/src/common/inc/tdataformat.h
+++ b/src/common/inc/tdataformat.h
@@ -234,6 +234,7 @@ typedef struct SDataCol {
   int             len;        // column data length
   VarDataOffsetT *dataOff;    // For binary and nchar data, the offset in the data column
   void *          pData;      // Actual data pointer
+  TSKEY           ts;         // only used in last NULL column
 } SDataCol;
 
 static FORCE_INLINE void dataColReset(SDataCol *pDataCol) { pDataCol->len = 0; }
diff --git a/src/tsdb/src/tsdbMemTable.c b/src/tsdb/src/tsdbMemTable.c
index 2409536924..e1f6625ffa 100644
--- a/src/tsdb/src/tsdbMemTable.c
+++ b/src/tsdb/src/tsdbMemTable.c
@@ -985,7 +985,7 @@ static void updateTableLatestColumn(STsdbRepo *pRepo, STable *pTable, SDataRow r
   for (int j = 0; j < schemaNCols(pSchema); j++) {
     if (j >= pTable->lastColNum) {
       pTable->lastCols = realloc(pTable->lastCols, pTable->lastColNum + 10);
-      for (int i = 0; i < 10; ++i) {
+      for (i = 0; i < 10; ++i) {
         pTable->lastCols[i + pTable->lastColNum].bytes = 0;
         pTable->lastCols[i + pTable->lastColNum].pData = NULL;
       }
@@ -1009,6 +1009,7 @@ static void updateTableLatestColumn(STsdbRepo *pRepo, STable *pTable, SDataRow r
     //tsdbDebug("vgId:%d cache column %d for %d,%p", REPO_ID(pRepo), j, pDataCol->bytes, pDataCol->pData);
 
     memcpy(pDataCol->pData, value, pDataCol->bytes);
+    pDataCol->ts = dataRowTKey(row);
   }
 }
 

From 3b2d5f74ed2d7a34dc2d05154da0353265201029 Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Mon, 17 May 2021 14:29:36 +0800
Subject: [PATCH 028/128] [TD-4034]check if STColumn is NULL,then ignore cache
 NULL column

---
 src/tsdb/src/tsdbMemTable.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/tsdb/src/tsdbMemTable.c b/src/tsdb/src/tsdbMemTable.c
index e1f6625ffa..1321d43653 100644
--- a/src/tsdb/src/tsdbMemTable.c
+++ b/src/tsdb/src/tsdbMemTable.c
@@ -993,6 +993,10 @@ static void updateTableLatestColumn(STsdbRepo *pRepo, STable *pTable, SDataRow r
     }
 
     STColumn *pTCol = schemaColAt(pSchema, j);
+    if (pTCol == NULL) {
+      // since schema maybe changed, check if STColumn NULL then ignore
+      continue;
+    }
     SDataCol *pDataCol = &(pLatestCols[j]);
     void* value = tdGetRowDataOfCol(row, (int8_t)pTCol->type, TD_DATA_ROW_HEAD_SIZE + pSchema->columns[j].offset);
     if (isNullN(value, pTCol->type)) {

From 08848116e5958b41efe85f91426387638d3d9917 Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Mon, 17 May 2021 16:32:19 +0800
Subject: [PATCH 029/128] [TD-4034]restore last not NULL column

---
 src/tsdb/src/tsdbMain.c     | 45 +++++++++++++++++++++++++++++++++++++
 src/tsdb/src/tsdbMemTable.c | 23 +++++++++----------
 2 files changed, 55 insertions(+), 13 deletions(-)

diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index bf195bef33..23556df580 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -645,6 +645,8 @@ int tsdbRestoreInfo(STsdbRepo *pRepo) {
       STable *pTable = pMeta->tables[i];
       if (pTable == NULL) continue;
 
+      //tsdbInfo("tsdbRestoreInfo restore vgId:%d,table:%s", REPO_ID(pRepo), pTable->name->data);
+
       if (tsdbSetReadTable(&readh, pTable) < 0) {
         tsdbDestroyReadH(&readh);
         return -1;
@@ -686,6 +688,49 @@ int tsdbRestoreInfo(STsdbRepo *pRepo) {
                            pCol->offset);
           }
         }
+
+        // restore NULL columns
+        if (CACHE_LAST_NULL_COLUMN(pCfg)) {
+          STSchema *pSchema = tsdbGetTableSchema(pTable);
+          int numColumns = schemaNCols(pSchema);
+          pTable->lastCols = (SDataCol*)malloc(numColumns * sizeof(SDataCol));
+          if (pTable->lastCols == NULL) {
+            terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+            return -1;
+          }
+          pTable->lastColNum = numColumns;
+
+          SDataRow row = taosTMalloc(dataRowMaxBytesFromSchema(pSchema));
+          if (row == NULL) {
+            tfree(pTable->lastCols);
+            pTable->lastColNum = 0;
+            terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+            return -1;
+          }
+
+          tdInitDataRow(row, pSchema);
+
+          SDataCol *pLatestCols = pTable->lastCols;
+          for (i = 0; i < pTable->lastColNum; ++i) {
+            STColumn *pTCol = schemaColAt(pSchema, i);
+
+            SDataCol *pDataCol = &(pLatestCols[pTCol->colId]);
+            pDataCol->pData = malloc(pTCol->bytes);
+            pDataCol->bytes = pTCol->bytes;
+            
+            void* value = tdGetRowDataOfCol(row, (int8_t)pTCol->type, TD_DATA_ROW_HEAD_SIZE + pTCol->offset);
+            if (isNullN(value, pTCol->type)) {
+              //tsdbInfo("tsdbRestoreInfo restore vgId:%d,table:%s cache column %d NULL", REPO_ID(pRepo), pTable->name->data, pTCol->colId);
+              continue;
+            }
+
+            memcpy(pDataCol->pData, value, pDataCol->bytes);
+            //tsdbInfo("tsdbRestoreInfo restore vgId:%d,table:%s cache column %d for %d,%s", REPO_ID(pRepo), pTable->name->data, pTCol->colId, pDataCol->bytes, (char*)pDataCol->pData);
+            pDataCol->ts = dataRowTKey(row);   
+          }
+
+          taosTZfree(row);
+        }
       }
       
     }
diff --git a/src/tsdb/src/tsdbMemTable.c b/src/tsdb/src/tsdbMemTable.c
index 1321d43653..70e27a5700 100644
--- a/src/tsdb/src/tsdbMemTable.c
+++ b/src/tsdb/src/tsdbMemTable.c
@@ -965,11 +965,12 @@ static void tsdbFreeRows(STsdbRepo *pRepo, void **rows, int rowCounter) {
 }
 
 static void updateTableLatestColumn(STsdbRepo *pRepo, STable *pTable, SDataRow row) {
-  //tsdbDebug("vgId:%d updateTableLatestColumn, row version:%d", REPO_ID(pRepo), dataRowVersion(row));
+  //tsdbInfo("vgId:%d updateTableLatestColumn, row version:%d", REPO_ID(pRepo), dataRowVersion(row));
 
   if (pTable->numOfSchemas <= 0) {
     return;
   }
+
   STSchema* pSchema = pTable->schema[pTable->numOfSchemas - 1];
   int i = pTable->numOfSchemas - 1;
   while ((pSchema == NULL || pSchema->version != dataRowVersion(row)) && i >= 0) {
@@ -983,21 +984,18 @@ static void updateTableLatestColumn(STsdbRepo *pRepo, STable *pTable, SDataRow r
   SDataCol *pLatestCols = pTable->lastCols;
 
   for (int j = 0; j < schemaNCols(pSchema); j++) {
-    if (j >= pTable->lastColNum) {
-      pTable->lastCols = realloc(pTable->lastCols, pTable->lastColNum + 10);
+    STColumn *pTCol = schemaColAt(pSchema, j);
+
+    if (pTCol->colId >= pTable->lastColNum) {
+      pTable->lastCols = realloc(pTable->lastCols, pTCol->colId + 5);
       for (i = 0; i < 10; ++i) {
         pTable->lastCols[i + pTable->lastColNum].bytes = 0;
         pTable->lastCols[i + pTable->lastColNum].pData = NULL;
       }
-      pTable->lastColNum += 10;
+      pTable->lastColNum += pTCol->colId + 5;
     }
-
-    STColumn *pTCol = schemaColAt(pSchema, j);
-    if (pTCol == NULL) {
-      // since schema maybe changed, check if STColumn NULL then ignore
-      continue;
-    }
-    SDataCol *pDataCol = &(pLatestCols[j]);
+    
+    SDataCol *pDataCol = &(pLatestCols[pTCol->colId]);
     void* value = tdGetRowDataOfCol(row, (int8_t)pTCol->type, TD_DATA_ROW_HEAD_SIZE + pSchema->columns[j].offset);
     if (isNullN(value, pTCol->type)) {
       continue;
@@ -1010,9 +1008,8 @@ static void updateTableLatestColumn(STsdbRepo *pRepo, STable *pTable, SDataRow r
       pDataCol->bytes = pSchema->columns[j].bytes;
     }
 
-    //tsdbDebug("vgId:%d cache column %d for %d,%p", REPO_ID(pRepo), j, pDataCol->bytes, pDataCol->pData);
-
     memcpy(pDataCol->pData, value, pDataCol->bytes);
+    //tsdbInfo("updateTableLatestColumn vgId:%d cache column %d for %d,%s", REPO_ID(pRepo), j, pDataCol->bytes, (char*)pDataCol->pData);
     pDataCol->ts = dataRowTKey(row);
   }
 }

From 312453705fab3ab91568d420038ff7929ea1c8c4 Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Mon, 17 May 2021 16:52:33 +0800
Subject: [PATCH 030/128] [TD-4034]restore last not NULL column

---
 src/tsdb/src/tsdbMain.c | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index 23556df580..44e2bffbe2 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -691,11 +691,24 @@ int tsdbRestoreInfo(STsdbRepo *pRepo) {
 
         // restore NULL columns
         if (CACHE_LAST_NULL_COLUMN(pCfg)) {
+          if (tsdbLoadBlockInfo(&readh, NULL) < 0) {
+            tsdbDestroyReadH(&readh);
+            return -1;
+          }
+
+          pBlock = readh.pBlkInfo->blocks + pIdx->numOfBlocks - 1;
+
+          if (tsdbLoadBlockData(&readh, pBlock, NULL) < 0) {
+            tsdbDestroyReadH(&readh);
+            return -1;
+          }
+
           STSchema *pSchema = tsdbGetTableSchema(pTable);
           int numColumns = schemaNCols(pSchema);
           pTable->lastCols = (SDataCol*)malloc(numColumns * sizeof(SDataCol));
           if (pTable->lastCols == NULL) {
             terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+            tsdbDestroyReadH(&readh);
             return -1;
           }
           pTable->lastColNum = numColumns;
@@ -704,11 +717,18 @@ int tsdbRestoreInfo(STsdbRepo *pRepo) {
           if (row == NULL) {
             tfree(pTable->lastCols);
             pTable->lastColNum = 0;
+            tsdbDestroyReadH(&readh);
             terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
             return -1;
           }
 
           tdInitDataRow(row, pSchema);
+          for (int icol = 0; icol < schemaNCols(pSchema); icol++) {
+            STColumn *pCol = schemaColAt(pSchema, icol);
+            SDataCol *pDataCol = readh.pDCols[0]->cols + icol;
+            tdAppendColVal(row, tdGetColDataOfRow(pDataCol, pBlock->numOfRows - 1), pCol->type, pCol->bytes,
+                           pCol->offset);
+          }
 
           SDataCol *pLatestCols = pTable->lastCols;
           for (i = 0; i < pTable->lastColNum; ++i) {

From 9277029da7607d5c318afd925210e6254e0a1524 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 18 May 2021 10:42:18 +0800
Subject: [PATCH 031/128] [td-3186]

---
 src/client/inc/tscUtil.h      |   2 +-
 src/client/inc/tsclient.h     |   2 +-
 src/client/src/tscSQLParser.c |   4 +-
 src/client/src/tscServer.c    |   2 +-
 src/client/src/tscSubquery.c  |  47 +++++++-----
 src/client/src/tscUtil.c      | 138 ++++++++++++++++++++++++++++------
 src/query/inc/qExecutor.h     |   2 +-
 src/query/src/qExecutor.c     |  30 +++++---
 8 files changed, 173 insertions(+), 54 deletions(-)

diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index de69e23b9b..ca1ea54e16 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -327,7 +327,7 @@ STableMeta* tscTableMetaDup(STableMeta* pTableMeta);
 int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAttr, void* addr);
 
 void tsCreateSQLFunctionCtx(SQueryInfo* pQueryInfo, SQLFunctionCtx* pCtx, SSchema* pSchema);
-void* createQueryInfoFromQueryNode(SQueryInfo* pQueryInfo, SExprInfo* pExprs, STableGroupInfo* pTableGroupInfo, SOperatorInfo* pOperator, char* sql, void* addr, int32_t stage);
+void* createQInfoFromQueryNode(SQueryInfo* pQueryInfo, SExprInfo* pExprs, STableGroupInfo* pTableGroupInfo, SOperatorInfo* pOperator, char* sql, void* addr, int32_t stage);
 
 void* malloc_throw(size_t size);
 void* calloc_throw(size_t nmemb, size_t size);
diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index 87da9c8b00..875b485cf2 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -454,7 +454,7 @@ int32_t tscCreateResPointerInfo(SSqlRes *pRes, SQueryInfo *pQueryInfo);
 void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo);
 void tscSetResRawPtrRv(SSqlRes* pRes, SQueryInfo* pQueryInfo, SSDataBlock* pBlock);
 
-void handleDownstreamOperator(SSqlRes* pRes, SQueryInfo* pQueryInfo, SSqlRes* pOutput);
+void handleDownstreamOperator(SSqlRes** pRes, int32_t numOfUpstream, SQueryInfo* px, SSqlRes* pOutput);
 void destroyTableNameList(SSqlCmd* pCmd);
 
 void tscResetSqlCmd(SSqlCmd *pCmd, bool removeMeta);
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index c179ed1ec6..365ff4147a 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -7192,7 +7192,9 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
       STableMeta* pMeta = tscTableMetaDup(pTableMeta);
       STableMetaVgroupInfo p = {.pTableMeta = pMeta,};
-      taosHashPut(pCmd->pTableMetaMap, name, strlen(name), &p, sizeof(STableMetaVgroupInfo));
+
+      const char* px = tNameGetTableName(pname);
+      taosHashPut(pCmd->pTableMetaMap, px, strlen(px), &p, sizeof(STableMetaVgroupInfo));
     } else {// add to the retrieve table meta array list.
       char* t = strdup(name);
       taosArrayPush(plist, &t);
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 08085d7216..f35be615a4 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -1637,7 +1637,7 @@ int tscProcessRetrieveLocalMergeRsp(SSqlObj *pSql) {
       list[i] = *pExprInfo;
     }
 
-    pQueryInfo->pQInfo = createQueryInfoFromQueryNode(pQueryInfo, list, &tableGroupInfo, NULL, NULL, pRes->pLocalMerger, MERGE_STAGE);
+    pQueryInfo->pQInfo = createQInfoFromQueryNode(pQueryInfo, list, &tableGroupInfo, NULL, NULL, pRes->pLocalMerger, MERGE_STAGE);
   }
 
   uint64_t localQueryId = 0;
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index 90bc5c985f..406214aba0 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -3483,10 +3483,11 @@ static UNUSED_FUNC bool tscHasRemainDataInSubqueryResultSet(SSqlObj *pSql) {
   return hasData;
 }
 
-void* createQueryInfoFromQueryNode(SQueryInfo* pQueryInfo, SExprInfo* pExprs, STableGroupInfo* pTableGroupInfo,
-                                   SOperatorInfo* pSourceOperator, char* sql, void* merger, int32_t stage) {
+// todo remove pExprs
+void* createQInfoFromQueryNode(SQueryInfo* pQueryInfo, SExprInfo* pExprs, STableGroupInfo* pTableGroupInfo,
+                               SOperatorInfo* pSourceOperator, char* sql, void* merger, int32_t stage) {
   assert(pQueryInfo != NULL);
-  int16_t numOfOutput = pQueryInfo->fieldsInfo.numOfOutput;
+//  int16_t numOfOutput = pQueryInfo->fieldsInfo.numOfOutput;
 
   SQInfo *pQInfo = (SQInfo *)calloc(1, sizeof(SQInfo));
   if (pQInfo == NULL) {
@@ -3505,13 +3506,25 @@ void* createQueryInfoFromQueryNode(SQueryInfo* pQueryInfo, SExprInfo* pExprs, ST
   pQueryAttr->tableGroupInfo = *pTableGroupInfo;
 
   // calculate the result row size
-  for (int16_t col = 0; col < numOfOutput; ++col) {
-    assert(pExprs[col].base.resBytes > 0);
-    pQueryAttr->resultRowSize += pExprs[col].base.resBytes;
+  SExprInfo* pei = NULL;
+  int32_t num = 0;
+  if (pQueryAttr->pExpr3 != NULL) {
+    pei = pQueryAttr->pExpr3;
+    num = pQueryAttr->numOfExpr3;
+  } else if (pQueryAttr->pExpr2 != NULL) {
+    pei = pQueryAttr->pExpr2;
+    num = pQueryAttr->numOfExpr2;
+  } else {
+    pei = pQueryAttr->pExpr1;
+    num = pQueryAttr->numOfOutput;
+  }
+
+  for (int16_t col = 0; col < num; ++col) {
+    pQueryAttr->resultRowSize += pei[col].base.resBytes;
 
     // keep the tag length
-    if (TSDB_COL_IS_TAG(pExprs[col].base.colInfo.flag)) {
-      pQueryAttr->tagLen += pExprs[col].base.resBytes;
+    if (TSDB_COL_IS_TAG(pei[col].base.colInfo.flag)) {
+      pQueryAttr->tagLen += pei[col].base.resBytes;
     }
   }
 
@@ -3569,15 +3582,15 @@ void* createQueryInfoFromQueryNode(SQueryInfo* pQueryInfo, SExprInfo* pExprs, ST
     }
   }
 
-  for (int32_t i = 0; i < numOfOutput; ++i) {
-    SExprInfo* pExprInfo = &pExprs[i];
-    if (pExprInfo->pExpr != NULL) {
-      tExprTreeDestroy(pExprInfo->pExpr, NULL);
-      pExprInfo->pExpr = NULL;
-    }
-  }
-
-  tfree(pExprs);
+//  for (int32_t i = 0; i < numOfOutput; ++i) {
+//    SExprInfo* pExprInfo = &pExprs[i];
+//    if (pExprInfo->pExpr != NULL) {
+//      tExprTreeDestroy(pExprInfo->pExpr, NULL);
+//      pExprInfo->pExpr = NULL;
+//    }
+//  }
+//
+//  tfree(pExprs);
 
   createFilterInfo(pQueryAttr, 0);
 
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index a35d44bba7..b1a7a34011 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -651,8 +651,16 @@ typedef struct SDummyInputInfo {
   SSqlRes        *pRes;  // refactor: remove it
 } SDummyInputInfo;
 
+typedef struct SJoinStatus {
+  SSDataBlock* pBlock;   // point to the upstream block
+  int32_t      index;
+  bool         completed;// current upstream is completed or not
+} SJoinStatus;
+
 typedef struct SJoinOperatorInfo {
-  int32_t a;
+  SSDataBlock *pRes;
+  SJoinStatus *status;
+  int32_t      numOfUpstream;
 } SJoinOperatorInfo;
 
 SSDataBlock* doGetDataBlock(void* param, bool* newgroup) {
@@ -685,6 +693,64 @@ SSDataBlock* doGetDataBlock(void* param, bool* newgroup) {
   return pBlock;
 }
 
+SSDataBlock* doBlockJoin(void* param, bool* newgroup) {
+  SOperatorInfo *pOperator = (SOperatorInfo*) param;
+  assert(pOperator->numOfUpstream > 1);
+
+  SSDataBlock* block0 = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
+  SSDataBlock* block1 = pOperator->upstream[1]->exec(pOperator->upstream[1], newgroup);
+
+  if (block1 == NULL || block0 == NULL) {
+    return NULL;
+  }
+
+  assert(block0 != block1);
+
+  SJoinOperatorInfo* pJoinInfo = pOperator->info;
+  pJoinInfo->status[0].pBlock = block0;
+  pJoinInfo->status[1].pBlock = block1;
+
+  SJoinStatus* st0 = &pJoinInfo->status[0];
+  SJoinStatus* st1 = &pJoinInfo->status[1];
+
+  while (st0->index < st0->pBlock->info.rows && st1->index < st1->pBlock->info.rows) {
+    SColumnInfoData* p0 = taosArrayGet(st0->pBlock->pDataBlock, 0);
+    SColumnInfoData* p1 = taosArrayGet(st1->pBlock->pDataBlock, 0);
+
+    int64_t* ts0 = (int64_t*) p0->pData;
+    int64_t* ts1 = (int64_t*) p1->pData;
+    if (ts0[st0->index] == ts1[st1->index]) { // add to the final result buffer
+      // check if current output buffer is over the threshold to pause current loop
+      int32_t rows = pJoinInfo->pRes->info.rows;
+      for(int32_t j = 0; j < st0->pBlock->info.numOfCols; ++j) {
+        SColumnInfoData* pCol1 = taosArrayGet(pJoinInfo->pRes->pDataBlock, j);
+        SColumnInfoData* pSrc = taosArrayGet(st0->pBlock->pDataBlock, j);
+
+        int32_t bytes = pSrc->info.bytes;
+        memcpy(pCol1->pData + rows * bytes, pSrc->pData + st0->index * bytes, bytes);
+      }
+
+      for(int32_t j = 0; j < st1->pBlock->info.numOfCols; ++j) {
+        SColumnInfoData* pCol1 = taosArrayGet(pJoinInfo->pRes->pDataBlock, j + st0->pBlock->info.numOfCols);
+        SColumnInfoData* pSrc = taosArrayGet(st1->pBlock->pDataBlock, j);
+
+        int32_t bytes = pSrc->info.bytes;
+        memcpy(pCol1->pData + rows * bytes, pSrc->pData + st1->index * bytes, bytes);
+      }
+
+      st0->index++;
+      st1->index++;
+      pJoinInfo->pRes->info.rows++;
+    } else if (ts0[st0->index] < ts1[st1->index]) {
+      st0->index++;
+    } else {
+      st1->index++;
+    }
+  }
+
+  return pJoinInfo->pRes;
+}
+
 static void destroyDummyInputOperator(void* param, int32_t numOfOutput) {
   SDummyInputInfo* pInfo = (SDummyInputInfo*) param;
 
@@ -728,34 +794,36 @@ SOperatorInfo* createDummyInputOperator(char* pResult, SSchema* pSchema, int32_t
   return pOptr;
 }
 
-SOperatorInfo* createJoinOperator(SOperatorInfo** pUpstream, int32_t numOfUpstream, SExprInfo* pExprInfo, int32_t numOfOutput) {
-  SJoinInfo* pInfo = calloc(1, sizeof(SJoinInfo));
-/*
-  pInfo->pRes  = (SSqlRes*) pResult;
-  pInfo->block = calloc(numOfCols, sizeof(SSDataBlock));
-  pInfo->block->info.numOfCols = numOfCols;
+SOperatorInfo* createJoinOperator(SOperatorInfo** pUpstream, int32_t numOfUpstream, SSchema* pSchema, int32_t numOfOutput) {
+  SJoinOperatorInfo* pInfo = calloc(1, sizeof(SJoinOperatorInfo));
+  pInfo->numOfUpstream = numOfUpstream;
+  pInfo->status = calloc(numOfUpstream, sizeof(SJoinStatus));
 
-  pInfo->block->pDataBlock = taosArrayInit(numOfCols, sizeof(SColumnInfoData));
-  for(int32_t i = 0; i < numOfCols; ++i) {
+  pInfo->pRes = calloc(1, sizeof(SSDataBlock));
+  pInfo->pRes->info.numOfCols = numOfOutput;
+
+  pInfo->pRes->pDataBlock = taosArrayInit(numOfOutput, sizeof(SColumnInfoData));
+  for(int32_t i = 0; i < numOfOutput; ++i) {
     SColumnInfoData colData = {{0}};
     colData.info.bytes = pSchema[i].bytes;
     colData.info.type  = pSchema[i].type;
     colData.info.colId = pSchema[i].colId;
+    colData.pData = calloc(1, colData.info.bytes * 4096);
 
-    taosArrayPush(pInfo->block->pDataBlock, &colData);
+    taosArrayPush(pInfo->pRes->pDataBlock, &colData);
   }
-*/
+
   SOperatorInfo* pOptr = calloc(1, sizeof(SOperatorInfo));
   pOptr->name          = "JoinOperator";
   pOptr->operatorType  = OP_Join;
   pOptr->numOfOutput   = numOfOutput;
   pOptr->blockingOptr  = false;
   pOptr->info          = pInfo;
-  pOptr->exec          = doGetDataBlock;
+  pOptr->exec          = doBlockJoin;
   pOptr->cleanup       = destroyDummyInputOperator;
 
   for(int32_t i = 0; i < numOfUpstream; ++i) {
-    appendUpstream(pOptr, pUpstream[0]);
+    appendUpstream(pOptr, pUpstream[i]);
   }
 
   return pOptr;
@@ -775,7 +843,7 @@ void convertQueryResult(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
   pRes->completed = (pRes->numOfRows == 0);
 }
 
-void handleDownstreamOperator(SSqlRes* pRes, SQueryInfo* px, SSqlRes* pOutput) {
+void handleDownstreamOperator(SSqlRes** pRes, int32_t numOfUpstream, SQueryInfo* px, SSqlRes* pOutput) {
   // handle the following query process
   if (px->pQInfo == NULL) {
     SColumnInfo* pColumnInfo = extractColumnInfoFromResult(px->colList);
@@ -805,15 +873,44 @@ void handleDownstreamOperator(SSqlRes* pRes, SQueryInfo* px, SSqlRes* pOutput) {
     taosArrayPush(tableGroupInfo.pGroupList, &group);
 
     // if it is a join query, create join operator here
-    SOperatorInfo* pSourceOperator = createDummyInputOperator((char*)pRes, pSchema, numOfCols);
-    if (px->numOfTables > 1) {
+    int32_t numOfCol1 = px->pTableMetaInfo[0]->pTableMeta->tableInfo.numOfColumns;
 
-      pSourceOperator = createJoinOperator(&pSourceOperator, 1, NULL, pSourceOperator->numOfOutput);
+    SOperatorInfo* pSourceOperator = createDummyInputOperator((char*)pRes[0], pSchema, numOfCol1);
+
+    SSchema* schema = NULL;
+    if (px->numOfTables > 1) {
+      SOperatorInfo* p[2] = {0};
+      p[0] = pSourceOperator;
+
+      SSchema* pSchema1 = tscGetTableSchema(px->pTableMetaInfo[1]->pTableMeta);
+      numOfCol1 = px->pTableMetaInfo[1]->pTableMeta->tableInfo.numOfColumns;
+
+      SOperatorInfo* pSourceOperator1 = createDummyInputOperator((char*)pRes[1], pSchema1, numOfCol1);
+      p[1] = pSourceOperator1;
+
+      int32_t num = pSourceOperator->numOfOutput + pSourceOperator1->numOfOutput;
+      schema = calloc(num, sizeof(SSchema));
+
+      memcpy(&schema[0], pSchema, pSourceOperator->numOfOutput * sizeof(SSchema));
+
+      memcpy(&schema[pSourceOperator->numOfOutput], pSchema1, pSourceOperator1->numOfOutput * sizeof(SSchema));
+      pSourceOperator = createJoinOperator(p, px->numOfTables, schema, num);
     }
 
     SExprInfo* exprInfo = NULL;
     /*int32_t code = */ createQueryFunc(&info, numOfOutput, &exprInfo, px->exprList->pData, NULL, px->type, NULL);
-    px->pQInfo = createQueryInfoFromQueryNode(px, exprInfo, &tableGroupInfo, pSourceOperator, NULL, NULL, MASTER_SCAN);
+    for(int32_t i = 0; i < numOfOutput; ++i) {
+      SExprInfo* pex = taosArrayGetP(px->exprList, i);
+      int32_t colId = pex->base.colInfo.colId;
+      for(int32_t j = 0; j < pSourceOperator->numOfOutput; ++j) {
+        if (colId == schema[j].colId) {
+          pex->base.colInfo.colIndex = j;
+          break;
+        }
+      }
+    }
+
+    px->pQInfo = createQInfoFromQueryNode(px, exprInfo, &tableGroupInfo, pSourceOperator, NULL, NULL, MASTER_SCAN);
     tfree(pColumnInfo);
   }
 
@@ -3011,11 +3108,10 @@ static void doRetrieveSubqueryData(SSchedMsg *pMsg) {
 
   if (numOfRows > 0) {
     SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
-    SSqlObj    *pSub = pSql->pSubs[0];
-    handleDownstreamOperator(&pSub->res, pQueryInfo, &pSql->res);
+    SSqlRes* list[2] = {&pSql->pSubs[0]->res, &pSql->pSubs[1]->res};
+    handleDownstreamOperator(list, 2, pQueryInfo, &pSql->res);
   }
 
-//  int32_t code = pSql->res.code;
   pSql->res.qId = -1;
   if (pSql->res.code == TSDB_CODE_SUCCESS) {
     (*pSql->fp)(pSql->param, pSql, pSql->res.numOfRows);
diff --git a/src/query/inc/qExecutor.h b/src/query/inc/qExecutor.h
index 8e22b4e208..a39819cb51 100644
--- a/src/query/inc/qExecutor.h
+++ b/src/query/inc/qExecutor.h
@@ -521,7 +521,7 @@ SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperator
 SOperatorInfo* createFilterOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr,
                                         int32_t numOfOutput, SColumnInfo* pCols, int32_t numOfFilter);
 
-SOperatorInfo* createJoinOperator(SOperatorInfo** pUpstream, int32_t numOfUpstream, SExprInfo* pExprInfo, int32_t numOfOutput);
+SOperatorInfo* createJoinOperator(SOperatorInfo** pUpstream, int32_t numOfUpstream, SSchema* pSchema, int32_t numOfOutput);
 
 SSDataBlock* doGlobalAggregate(void* param, bool* newgroup);
 SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup);
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 5035e9cbd7..6c92293bfd 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -1750,7 +1750,7 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
         SOperatorInfo* prev = pRuntimeEnv->proot;
         if (i == 0) {
           pRuntimeEnv->proot = createArithOperatorInfo(pRuntimeEnv, prev, pQueryAttr->pExpr1, pQueryAttr->numOfOutput);
-          if (pRuntimeEnv->proot != NULL && prev->operatorType != OP_DummyInput) {  // TODO refactor
+          if (pRuntimeEnv->proot != NULL && prev->operatorType != OP_DummyInput && prev->operatorType != OP_Join) {  // TODO refactor
             setTableScanFilterOperatorInfo(prev->info, pRuntimeEnv->proot);
           }
         } else {
@@ -3929,11 +3929,11 @@ void queryCostStatis(SQInfo *pQInfo) {
 
 void appendUpstream(SOperatorInfo* p, SOperatorInfo* pUpstream) {
   if (p->upstream == NULL) {
-    assert(p->numOfOutput == 0);
+    assert(p->numOfUpstream == 0);
   }
 
-  p->upstream = realloc(p->upstream, POINTER_BYTES * (p->numOfOutput + 1));
-  p->upstream[p->numOfOutput++] = pUpstream;
+  p->upstream = realloc(p->upstream, POINTER_BYTES * (p->numOfUpstream + 1));
+  p->upstream[p->numOfUpstream++] = pUpstream;
 }
 
 static void doDestroyTableQueryInfo(STableGroupInfo* pTableqinfoGroupInfo);
@@ -4824,7 +4824,7 @@ static SSDataBlock* doArithmeticOperation(void* param, bool* newgroup) {
     bool prevVal = *newgroup;
 
     // The upstream exec may change the value of the newgroup, so use a local variable instead.
-    SSDataBlock* pBlock = pOperator->upstream[0]->exec(pOperator->upstream, newgroup);
+    SSDataBlock* pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
     if (pBlock == NULL) {
       assert(*newgroup == false);
 
@@ -4878,7 +4878,7 @@ static SSDataBlock* doLimit(void* param, bool* newgroup) {
 
   SSDataBlock* pBlock = NULL;
   while (1) {
-    pBlock = pOperator->upstream[0]->exec(pOperator->upstream, newgroup);
+    pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
     if (pBlock == NULL) {
       setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
       pOperator->status = OP_EXEC_DONE;
@@ -4949,7 +4949,7 @@ static SSDataBlock* doFilter(void* param, bool* newgroup) {
   SQueryRuntimeEnv* pRuntimeEnv = pOperator->pRuntimeEnv;
 
   while (1) {
-    SSDataBlock *pBlock = pOperator->upstream[0]->exec(pOperator->upstream, newgroup);
+    SSDataBlock *pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
     if (pBlock == NULL) {
       break;
     }
@@ -5219,7 +5219,7 @@ static SSDataBlock* doFill(void* param, bool* newgroup) {
   }
 
   while(1) {
-    SSDataBlock* pBlock = pOperator->upstream[0]->exec(pOperator->upstream, newgroup);
+    SSDataBlock* pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
     if (*newgroup) {
       assert(pBlock != NULL);
     }
@@ -5295,7 +5295,15 @@ static void destroyOperatorInfo(SOperatorInfo* pOperator) {
     pOperator->cleanup(pOperator->info, pOperator->numOfOutput);
   }
 
-  destroyOperatorInfo(pOperator->upstream[0]);
+  if (pOperator->upstream != NULL) {
+    for(int32_t i = 0; i < pOperator->numOfUpstream; ++i) {
+      destroyOperatorInfo(pOperator->upstream[i]);
+    }
+
+    tfree(pOperator->upstream);
+    pOperator->numOfUpstream = 0;
+  }
+
   tfree(pOperator->info);
   tfree(pOperator);
 }
@@ -5844,7 +5852,7 @@ static SSDataBlock* hashDistinct(void* param, bool* newgroup) {
   pRes->info.rows = 0;
   SSDataBlock* pBlock = NULL;
   while(1) {
-    pBlock = pOperator->upstream[0]->exec(pOperator->upstream, newgroup);
+    pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
     if (pBlock == NULL) {
       setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
       pOperator->status = OP_EXEC_DONE;
@@ -6458,7 +6466,7 @@ static int32_t updateOutputBufForTopBotQuery(SQueriedTableInfo* pTableInfo, SCol
   return TSDB_CODE_SUCCESS;
 }
 
-// TODO tag length should be passed from client
+// TODO tag length should be passed from client, refactor
 int32_t createQueryFunc(SQueriedTableInfo* pTableInfo, int32_t numOfOutput, SExprInfo** pExprInfo,
                         SSqlExpr** pExprMsg, SColumnInfo* pTagCols, int32_t queryType, void* pMsg) {
   *pExprInfo = NULL;

From cad6e7ec510378f6909ad172d7c311f9eb6de94f Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Tue, 18 May 2021 16:29:26 +0800
Subject: [PATCH 032/128] [TD-4034]restore last not NULL column

---
 src/tsdb/inc/tsdbMeta.h |   1 +
 src/tsdb/src/tsdbMain.c | 190 +++++++++++++++++++++++++++-------------
 src/tsdb/src/tsdbMeta.c |   1 +
 3 files changed, 129 insertions(+), 63 deletions(-)

diff --git a/src/tsdb/inc/tsdbMeta.h b/src/tsdb/inc/tsdbMeta.h
index ff47e0cf39..a8c7a6c358 100644
--- a/src/tsdb/inc/tsdbMeta.h
+++ b/src/tsdb/inc/tsdbMeta.h
@@ -39,6 +39,7 @@ typedef struct STable {
 
   SDataCol      *lastCols;
   int32_t        lastColNum;
+  int32_t        restoreColumnNum;
   T_REF_DECLARE()
 } STable;
 
diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index 44e2bffbe2..3be78e21dd 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -616,6 +616,118 @@ static void tsdbStopStream(STsdbRepo *pRepo) {
   }
 }
 
+static int restoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh) {
+  SBlock* pBlock;
+  int numColumns;
+  int32_t blockIdx;
+  SDataStatis* pBlockStatis = NULL;
+  SDataRow row = NULL;
+  STSchema *pSchema = tsdbGetTableSchema(pTable);
+  int err = 0;
+
+  numColumns = schemaNCols(pSchema);
+  if (numColumns <= pTable->restoreColumnNum) {
+    return 0;
+  }
+
+  row = taosTMalloc(dataRowMaxBytesFromSchema(pSchema));
+  if (row == NULL) {
+    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+    err = -1;
+    goto out;
+  }
+  tdInitDataRow(row, pSchema);
+
+  // first load block index info
+  if (tsdbLoadBlockInfo(pReadh, NULL) < 0) {
+    err = -1;
+    goto out;
+  }
+
+  pBlockStatis = calloc(numColumns, sizeof(SDataStatis));
+  if (pBlockStatis == NULL) {
+    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+    err = -1;
+    goto out;
+  }
+  memset(pBlockStatis, 0, numColumns * sizeof(SDataStatis));
+  for(int32_t i = 0; i < numColumns; ++i) {
+    pBlockStatis[i].colId = i;
+  }
+
+  // load block from backward
+  SBlockIdx *pIdx = pReadh->pBlkIdx;
+  blockIdx = (int32_t)(pIdx->numOfBlocks - 1);
+
+  while (numColumns > pTable->restoreColumnNum && blockIdx >= 0) {
+    bool loadStatisData = false;
+    pBlock = pReadh->pBlkInfo->blocks + blockIdx;
+    blockIdx -= 1;
+
+    // load block data
+    if (tsdbLoadBlockData(pReadh, pBlock, NULL) < 0) {
+      err = -1;
+      goto out;
+    }
+
+    // file block with sub-blocks has no statistics data
+    if (pBlock->numOfSubBlocks <= 1) {
+      tsdbLoadBlockStatis(pReadh, pBlock);
+      tsdbGetBlockStatis(pReadh, pBlockStatis, (int)numColumns);
+      loadStatisData = true;
+    }
+
+    for (uint32_t colId = 0; colId < numColumns && numColumns > pTable->restoreColumnNum; ++colId) {
+      // ignore loaded columns
+      if (pTable->lastCols[colId].bytes != 0) {
+        continue;
+      }
+
+      // ignore block which has no not-null colId column
+      if (loadStatisData && pBlockStatis[colId].numOfNull == pBlock->numOfRows) {
+        continue;
+      }
+
+      // OK,let's load row from backward to get not-null column
+      STColumn *pCol = schemaColAt(pSchema, colId);
+      for (int32_t rowId = pBlock->numOfRows - 1; rowId >= 0; rowId--) {
+        SDataCol *pDataCol = pReadh->pDCols[0]->cols + colId;
+        tdAppendColVal(row, tdGetColDataOfRow(pDataCol, rowId), pCol->type, pCol->bytes, pCol->offset);
+        //SDataCol *pDataCol = readh.pDCols[0]->cols + j;
+        void* value = tdGetRowDataOfCol(row, (int8_t)pCol->type, TD_DATA_ROW_HEAD_SIZE + pCol->offset);
+        if (isNullN(value, pCol->type)) {
+          continue;
+        }
+
+        // save not-null column   
+        SDataCol *pLastCol = &(pTable->lastCols[colId]);
+        pLastCol->pData = malloc(pCol->bytes);
+        pLastCol->bytes = pCol->bytes;
+        pLastCol->offset = pCol->offset;
+        pLastCol->colId = pCol->colId;
+        memcpy(pLastCol->pData, value, pCol->bytes);
+
+        // save row ts(in column 0)
+        pDataCol = pReadh->pDCols[0]->cols + 0;
+        pCol = schemaColAt(pSchema, 0);
+        tdAppendColVal(row, tdGetColDataOfRow(pDataCol, rowId), pCol->type, pCol->bytes, pCol->offset);
+        pLastCol->ts = dataRowTKey(row);
+
+        pTable->restoreColumnNum += 1;
+
+        tsdbInfo("restoreLastColumns restore vgId:%d,table:%s cache column %d, %ld", REPO_ID(pRepo), pTable->name->data, colId, pLastCol->ts);
+        break;
+      }
+    }
+  }
+
+out:
+  taosTZfree(row);
+  tfree(pBlockStatis);
+
+  return err;
+}
+
 int tsdbRestoreInfo(STsdbRepo *pRepo) {
   SFSIter    fsiter;
   SReadH     readh;
@@ -630,6 +742,14 @@ int tsdbRestoreInfo(STsdbRepo *pRepo) {
 
   tsdbFSIterInit(&fsiter, REPO_FS(pRepo), TSDB_FS_ITER_BACKWARD);
 
+  if (CACHE_LAST_NULL_COLUMN(pCfg)) {
+    for (int i = 1; i < pMeta->maxTables; i++) {
+      STable *pTable = pMeta->tables[i];
+      if (pTable == NULL) continue;
+      pTable->restoreColumnNum = 0;  
+    }
+  }
+
   while ((pSet = tsdbFSIterNext(&fsiter)) != NULL) {
     if (tsdbSetAndOpenReadFSet(&readh, pSet) < 0) {
       tsdbDestroyReadH(&readh);
@@ -688,71 +808,15 @@ int tsdbRestoreInfo(STsdbRepo *pRepo) {
                            pCol->offset);
           }
         }
-
-        // restore NULL columns
-        if (CACHE_LAST_NULL_COLUMN(pCfg)) {
-          if (tsdbLoadBlockInfo(&readh, NULL) < 0) {
-            tsdbDestroyReadH(&readh);
-            return -1;
-          }
-
-          pBlock = readh.pBlkInfo->blocks + pIdx->numOfBlocks - 1;
-
-          if (tsdbLoadBlockData(&readh, pBlock, NULL) < 0) {
-            tsdbDestroyReadH(&readh);
-            return -1;
-          }
-
-          STSchema *pSchema = tsdbGetTableSchema(pTable);
-          int numColumns = schemaNCols(pSchema);
-          pTable->lastCols = (SDataCol*)malloc(numColumns * sizeof(SDataCol));
-          if (pTable->lastCols == NULL) {
-            terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-            tsdbDestroyReadH(&readh);
-            return -1;
-          }
-          pTable->lastColNum = numColumns;
-
-          SDataRow row = taosTMalloc(dataRowMaxBytesFromSchema(pSchema));
-          if (row == NULL) {
-            tfree(pTable->lastCols);
-            pTable->lastColNum = 0;
-            tsdbDestroyReadH(&readh);
-            terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-            return -1;
-          }
-
-          tdInitDataRow(row, pSchema);
-          for (int icol = 0; icol < schemaNCols(pSchema); icol++) {
-            STColumn *pCol = schemaColAt(pSchema, icol);
-            SDataCol *pDataCol = readh.pDCols[0]->cols + icol;
-            tdAppendColVal(row, tdGetColDataOfRow(pDataCol, pBlock->numOfRows - 1), pCol->type, pCol->bytes,
-                           pCol->offset);
-          }
-
-          SDataCol *pLatestCols = pTable->lastCols;
-          for (i = 0; i < pTable->lastColNum; ++i) {
-            STColumn *pTCol = schemaColAt(pSchema, i);
-
-            SDataCol *pDataCol = &(pLatestCols[pTCol->colId]);
-            pDataCol->pData = malloc(pTCol->bytes);
-            pDataCol->bytes = pTCol->bytes;
-            
-            void* value = tdGetRowDataOfCol(row, (int8_t)pTCol->type, TD_DATA_ROW_HEAD_SIZE + pTCol->offset);
-            if (isNullN(value, pTCol->type)) {
-              //tsdbInfo("tsdbRestoreInfo restore vgId:%d,table:%s cache column %d NULL", REPO_ID(pRepo), pTable->name->data, pTCol->colId);
-              continue;
-            }
-
-            memcpy(pDataCol->pData, value, pDataCol->bytes);
-            //tsdbInfo("tsdbRestoreInfo restore vgId:%d,table:%s cache column %d for %d,%s", REPO_ID(pRepo), pTable->name->data, pTCol->colId, pDataCol->bytes, (char*)pDataCol->pData);
-            pDataCol->ts = dataRowTKey(row);   
-          }
-
-          taosTZfree(row);
-        }
       }
       
+      // restore NULL columns
+      if (CACHE_LAST_NULL_COLUMN(pCfg)) {
+        if (restoreLastColumns(pRepo, pTable, &readh) != 0) {
+          tsdbDestroyReadH(&readh);
+          return -1;
+        }
+      }
     }
   }
 
diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c
index bdf0cfdfad..5a108a5d06 100644
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
@@ -678,6 +678,7 @@ static STable *tsdbNewTable() {
     pTable->lastCols[i].bytes = 0;
     pTable->lastCols[i].pData = NULL;
   }
+  pTable->restoreColumnNum = 0;
 
   return pTable;
 }

From 6f202d270e66eee02e7d87f314ea2fcc3a281a82 Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Tue, 18 May 2021 19:50:35 +0800
Subject: [PATCH 033/128] [TD-4034]restore last not NULL column

---
 src/tsdb/src/tsdbMain.c | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index 3be78e21dd..8e1207b98a 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -652,7 +652,8 @@ static int restoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh)
   }
   memset(pBlockStatis, 0, numColumns * sizeof(SDataStatis));
   for(int32_t i = 0; i < numColumns; ++i) {
-    pBlockStatis[i].colId = i;
+    STColumn *pCol = schemaColAt(pSchema, i);
+    pBlockStatis[i].colId = pCol->colId;
   }
 
   // load block from backward
@@ -678,6 +679,17 @@ static int restoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh)
     }
 
     for (uint32_t colId = 0; colId < numColumns && numColumns > pTable->restoreColumnNum; ++colId) {
+      STColumn *pCol = schemaColAt(pSchema, colId);
+
+      if (colId >= pTable->lastColNum) {
+        pTable->lastCols = realloc(pTable->lastCols, colId + 5);
+        for (int m = 0; m < 5; ++m) {
+          pTable->lastCols[m + pTable->lastColNum].bytes = 0;
+          pTable->lastCols[m + pTable->lastColNum].pData = NULL;
+        }
+        pTable->lastColNum += colId + 5;
+      }
+
       // ignore loaded columns
       if (pTable->lastCols[colId].bytes != 0) {
         continue;
@@ -689,7 +701,6 @@ static int restoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh)
       }
 
       // OK,let's load row from backward to get not-null column
-      STColumn *pCol = schemaColAt(pSchema, colId);
       for (int32_t rowId = pBlock->numOfRows - 1; rowId >= 0; rowId--) {
         SDataCol *pDataCol = pReadh->pDCols[0]->cols + colId;
         tdAppendColVal(row, tdGetColDataOfRow(pDataCol, rowId), pCol->type, pCol->bytes, pCol->offset);

From 80fc12ea79afdbfed7f0ee8c86a20b0bafa3fd32 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 18 May 2021 23:17:53 +0800
Subject: [PATCH 034/128] [td-4231]<enhance>: report error if only tags of the
 table are retrieved in the select clause when the filter condition only
 includes normal columns.

---
 src/client/src/tscSQLParser.c                    | 11 +++++++++++
 tests/script/general/parser/select_with_tags.sim |  8 +++++++-
 2 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index f73556a890..5fc92dd860 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -7119,6 +7119,7 @@ int32_t doValidateSqlNode(SSqlObj* pSql, SQuerySqlNode* pQuerySqlNode, int32_t i
   const char* msg6 = "too many tables in from clause";
   const char* msg7 = "invalid table alias name";
   const char* msg8 = "alias name too long";
+  const char* msg9 = "only tag query not compatible with normal column filter";
 
   int32_t code = TSDB_CODE_SUCCESS;
 
@@ -7288,6 +7289,16 @@ int32_t doValidateSqlNode(SSqlObj* pSql, SQuerySqlNode* pQuerySqlNode, int32_t i
     if (hasUnsupportFunctionsForSTableQuery(pCmd, pQueryInfo)) {
       return TSDB_CODE_TSC_INVALID_SQL;
     }
+
+    if(tscQueryTags(pQueryInfo)) {
+      int32_t numOfCols = taosArrayGetSize(pQueryInfo->colList);
+      for(int32_t i = 0; i < numOfCols; ++i) {
+        SColumn* pCols = taosArrayGetP(pQueryInfo->colList, i);
+        if (pCols->numOfFilters > 0) {
+          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg9);
+        }
+      }
+    }
   }
 
   if (parseSessionClause(pCmd, pQueryInfo, pQuerySqlNode) != TSDB_CODE_SUCCESS) {
diff --git a/tests/script/general/parser/select_with_tags.sim b/tests/script/general/parser/select_with_tags.sim
index 9f445649e1..11b1d0bc4b 100644
--- a/tests/script/general/parser/select_with_tags.sim
+++ b/tests/script/general/parser/select_with_tags.sim
@@ -847,10 +847,16 @@ sql_error select tbname, t1 from select_tags_mt0 interval(1y);
 #valid sql: select first(c1), last(c2), count(*) from select_tags_mt0 group by tbname, t1;
 #valid sql: select first(c1), tbname, t1 from select_tags_mt0 group by t2;
 
+print ==================================>TD-4231
+sql_error select t1,tbname from select_tags_mt0 where c1<0
+sql_error select t1,tbname from select_tags_mt0 where c1<0 and tbname in ('select_tags_tb12')
+
+sql select tbname from select_tags_mt0 where tbname in ('select_tags_tb12');
+
 sql_error select first(c1), last(c2), t1 from select_tags_mt0 group by tbname;
 sql_error select first(c1), last(c2), tbname, t2 from select_tags_mt0 group by tbname;
 sql_error select first(c1), count(*), t2, t1, tbname from select_tags_mt0 group by tbname;
-# this sql is valid: select first(c1), t2 from select_tags_mt0 group by tbname;
+#valid sql: select first(c1), t2 from select_tags_mt0 group by tbname;
 
 #sql select first(ts), tbname from select_tags_mt0 group by tbname;
 #sql select count(c1) from select_tags_mt0 where c1=99 group by tbname;

From 61ea20334f06cff53ddc4796aa67efa514932fb4 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 18 May 2021 23:27:16 +0800
Subject: [PATCH 035/128] [td-4231]fix compiler error.

---
 src/client/src/tscSQLParser.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 5fc92dd860..722ce7a231 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -7291,7 +7291,7 @@ int32_t doValidateSqlNode(SSqlObj* pSql, SQuerySqlNode* pQuerySqlNode, int32_t i
     }
 
     if(tscQueryTags(pQueryInfo)) {
-      int32_t numOfCols = taosArrayGetSize(pQueryInfo->colList);
+      int32_t numOfCols = (int32_t) taosArrayGetSize(pQueryInfo->colList);
       for(int32_t i = 0; i < numOfCols; ++i) {
         SColumn* pCols = taosArrayGetP(pQueryInfo->colList, i);
         if (pCols->numOfFilters > 0) {

From bec2b58922f5ea25ad9dc6673c533b24bbf10a48 Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Wed, 19 May 2021 09:16:45 +0800
Subject: [PATCH 036/128] [TD-4034]fix compile error

---
 src/tsdb/src/tsdbMain.c | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index 8e1207b98a..a7e1efb5ed 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -678,31 +678,31 @@ static int restoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh)
       loadStatisData = true;
     }
 
-    for (uint32_t colId = 0; colId < numColumns && numColumns > pTable->restoreColumnNum; ++colId) {
-      STColumn *pCol = schemaColAt(pSchema, colId);
+    for (uint32_t i = 0; i < numColumns && numColumns > pTable->restoreColumnNum; ++i) {
+      STColumn *pCol = schemaColAt(pSchema, i);
 
-      if (colId >= pTable->lastColNum) {
-        pTable->lastCols = realloc(pTable->lastCols, colId + 5);
+      if (i >= pTable->lastColNum) {
+        pTable->lastCols = realloc(pTable->lastCols, i + 5);
         for (int m = 0; m < 5; ++m) {
           pTable->lastCols[m + pTable->lastColNum].bytes = 0;
           pTable->lastCols[m + pTable->lastColNum].pData = NULL;
         }
-        pTable->lastColNum += colId + 5;
+        pTable->lastColNum += i + 5;
       }
 
       // ignore loaded columns
-      if (pTable->lastCols[colId].bytes != 0) {
+      if (pTable->lastCols[i].bytes != 0) {
         continue;
       }
 
       // ignore block which has no not-null colId column
-      if (loadStatisData && pBlockStatis[colId].numOfNull == pBlock->numOfRows) {
+      if (loadStatisData && pBlockStatis[i].numOfNull == pBlock->numOfRows) {
         continue;
       }
 
       // OK,let's load row from backward to get not-null column
       for (int32_t rowId = pBlock->numOfRows - 1; rowId >= 0; rowId--) {
-        SDataCol *pDataCol = pReadh->pDCols[0]->cols + colId;
+        SDataCol *pDataCol = pReadh->pDCols[0]->cols + i;
         tdAppendColVal(row, tdGetColDataOfRow(pDataCol, rowId), pCol->type, pCol->bytes, pCol->offset);
         //SDataCol *pDataCol = readh.pDCols[0]->cols + j;
         void* value = tdGetRowDataOfCol(row, (int8_t)pCol->type, TD_DATA_ROW_HEAD_SIZE + pCol->offset);
@@ -710,8 +710,8 @@ static int restoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh)
           continue;
         }
 
-        // save not-null column   
-        SDataCol *pLastCol = &(pTable->lastCols[colId]);
+        // save not-null column
+        SDataCol *pLastCol = &(pTable->lastCols[i]);
         pLastCol->pData = malloc(pCol->bytes);
         pLastCol->bytes = pCol->bytes;
         pLastCol->offset = pCol->offset;
@@ -726,7 +726,7 @@ static int restoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh)
 
         pTable->restoreColumnNum += 1;
 
-        tsdbInfo("restoreLastColumns restore vgId:%d,table:%s cache column %d, %ld", REPO_ID(pRepo), pTable->name->data, colId, pLastCol->ts);
+        tsdbInfo("restoreLastColumns restore vgId:%d,table:%s cache column %d, %d", REPO_ID(pRepo), pTable->name->data, pCol->colId, (int32_t)pLastCol->ts);
         break;
       }
     }

From 0aadc6c996a9a2eaee3d24b7481f8e68763646c4 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Wed, 19 May 2021 13:53:45 +0800
Subject: [PATCH 037/128] [td-225] refactor.

---
 src/client/src/tscUtil.c | 35 ++++++++++++++++++++---------------
 1 file changed, 20 insertions(+), 15 deletions(-)

diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index b1a7a34011..5bd7417f5f 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -658,9 +658,10 @@ typedef struct SJoinStatus {
 } SJoinStatus;
 
 typedef struct SJoinOperatorInfo {
-  SSDataBlock *pRes;
-  SJoinStatus *status;
-  int32_t      numOfUpstream;
+  SSDataBlock   *pRes;
+  SJoinStatus   *status;
+  int32_t        numOfUpstream;
+  SRspResultInfo resultInfo;  // todo refactor, add this info for each operator
 } SJoinOperatorInfo;
 
 SSDataBlock* doGetDataBlock(void* param, bool* newgroup) {
@@ -796,37 +797,41 @@ SOperatorInfo* createDummyInputOperator(char* pResult, SSchema* pSchema, int32_t
 
 SOperatorInfo* createJoinOperator(SOperatorInfo** pUpstream, int32_t numOfUpstream, SSchema* pSchema, int32_t numOfOutput) {
   SJoinOperatorInfo* pInfo = calloc(1, sizeof(SJoinOperatorInfo));
+
   pInfo->numOfUpstream = numOfUpstream;
   pInfo->status = calloc(numOfUpstream, sizeof(SJoinStatus));
 
+  SRspResultInfo* pResInfo = &pInfo->resultInfo;
+  pResInfo->capacity  = 4096;
+  pResInfo->threshold = 4096 * 0.8;
+
   pInfo->pRes = calloc(1, sizeof(SSDataBlock));
   pInfo->pRes->info.numOfCols = numOfOutput;
-
   pInfo->pRes->pDataBlock = taosArrayInit(numOfOutput, sizeof(SColumnInfoData));
   for(int32_t i = 0; i < numOfOutput; ++i) {
     SColumnInfoData colData = {{0}};
     colData.info.bytes = pSchema[i].bytes;
     colData.info.type  = pSchema[i].type;
     colData.info.colId = pSchema[i].colId;
-    colData.pData = calloc(1, colData.info.bytes * 4096);
+    colData.pData = calloc(1, colData.info.bytes * pResInfo->capacity);
 
     taosArrayPush(pInfo->pRes->pDataBlock, &colData);
   }
 
-  SOperatorInfo* pOptr = calloc(1, sizeof(SOperatorInfo));
-  pOptr->name          = "JoinOperator";
-  pOptr->operatorType  = OP_Join;
-  pOptr->numOfOutput   = numOfOutput;
-  pOptr->blockingOptr  = false;
-  pOptr->info          = pInfo;
-  pOptr->exec          = doBlockJoin;
-  pOptr->cleanup       = destroyDummyInputOperator;
+  SOperatorInfo* pOperator = calloc(1, sizeof(SOperatorInfo));
+  pOperator->name          = "JoinOperator";
+  pOperator->operatorType  = OP_Join;
+  pOperator->numOfOutput   = numOfOutput;
+  pOperator->blockingOptr  = false;
+  pOperator->info          = pInfo;
+  pOperator->exec          = doBlockJoin;
+  pOperator->cleanup       = destroyDummyInputOperator;
 
   for(int32_t i = 0; i < numOfUpstream; ++i) {
-    appendUpstream(pOptr, pUpstream[i]);
+    appendUpstream(pOperator, pUpstream[i]);
   }
 
-  return pOptr;
+  return pOperator;
 }
 
 void convertQueryResult(SSqlRes* pRes, SQueryInfo* pQueryInfo) {

From e2f1102622a34be4ff8813338a013a1e893fbcc4 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Wed, 19 May 2021 15:27:16 +0800
Subject: [PATCH 038/128] init

---
 src/query/src/qExecutor.c |  33 +++++++
 src/tsdb/src/tsdbRead.c   | 194 ++++++++++++++++++++++++++++++++++++--
 2 files changed, 217 insertions(+), 10 deletions(-)

diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 40759c93c4..b48436a617 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -1979,6 +1979,37 @@ static bool isFirstLastRowQuery(SQueryAttr *pQueryAttr) {
   return false;
 }
 
+static bool isCachedLastQuery(SQueryAttr *pQueryAttr) {
+  for (int32_t i = 0; i < pQueryAttr->numOfOutput; ++i) {
+    int32_t functionID = pQueryAttr->pExpr1[i].base.functionId;
+    if (functionID == TSDB_FUNC_LAST || functionID == TSDB_FUNC_LAST_DST) {
+      continue;
+    }
+
+    return false;
+  }
+
+  if (!TSWINDOW_IS_EQUAL(pQueryAttr->window, TSWINDOW_INITIALIZER)) {
+    return false;
+  }
+
+  if (pQueryAttr->groupbyColumn) {
+    return false;
+  }
+
+  if (pQueryAttr->interval.interval > 0) {
+    return false;
+  }
+
+  if (pQueryAttr->numOfFilterCols > 0 || pQueryAttr->havingNum > 0) {
+    return false;
+  }
+
+  return true;
+}
+
+
+
 /**
  * The following 4 kinds of query are treated as the tags query
  * tagprj, tid_tag query, count(tbname), 'abc' (user defined constant value column) query
@@ -3963,6 +3994,8 @@ static int32_t setupQueryHandle(void* tsdb, SQueryRuntimeEnv* pRuntimeEnv, int64
         }
       }
     }
+  } else if (isCachedLastQuery(pQueryAttr)) {
+    pRuntimeEnv->pQueryHandle = tsdbQueryCacheLast(tsdb, &cond, &pQueryAttr->tableGroupInfo, qId, &pQueryAttr->memRef);
   } else if (pQueryAttr->pointInterpQuery) {
     pRuntimeEnv->pQueryHandle = tsdbQueryRowsInExternalWindow(tsdb, &cond, &pQueryAttr->tableGroupInfo, qId, &pQueryAttr->memRef);
   } else {
diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 9df25409de..b3460ac3b2 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -62,12 +62,20 @@ typedef struct SLoadCompBlockInfo {
   int32_t fileId;
 } SLoadCompBlockInfo;
 
+typedef struct SCacheLastColInfo {
+  int16_t  size;
+  int16_t  num;
+  int16_t  fetchIdx;
+  int16_t *idx;
+} SCacheLastColInfo;
+
 typedef struct STableCheckInfo {
   STableId      tableId;
   TSKEY         lastKey;
   STable*       pTableObj;
   SBlockInfo*   pCompInfo;
   int32_t       compSize;
+  SCacheLastColInfo cacheLast;  // cache last column chosen
   int32_t       numOfBlocks:29; // number of qualified data blocks not the original blocks
   int8_t        chosen:2;       // indicate which iterator should move forward
   bool          initBuf;        // whether to initialize the in-memory skip list iterator or not
@@ -107,7 +115,7 @@ typedef struct STsdbQueryHandle {
   SArray*        pTableCheckInfo;  // SArray<STableCheckInfo>
   int32_t        activeIndex;
   bool           checkFiles;       // check file stage
-  bool           cachelastrow;     // check if last row cached
+  int8_t         cachelastrow;     // check if last row cached
   bool           loadExternalRow;  // load time window external data rows
   bool           currentLoadExternalRows; // current load external rows
   int32_t        loadType;         // block load type
@@ -512,6 +520,8 @@ void tsdbResetQueryHandleForNewTable(TsdbQueryHandleT queryHandle, STsdbQueryCon
   pQueryHandle->next = doFreeColumnInfoData(pQueryHandle->next);
 }
 
+
+
 TsdbQueryHandleT tsdbQueryLastRow(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId, SMemRef* pMemRef) {
   pCond->twindow = updateLastrowForEachGroup(groupList);
 
@@ -528,10 +538,111 @@ TsdbQueryHandleT tsdbQueryLastRow(STsdbRepo *tsdb, STsdbQueryCond *pCond, STable
   }
 
   assert(pCond->order == TSDB_ORDER_ASC && pCond->twindow.skey <= pCond->twindow.ekey);
-  pQueryHandle->type = TSDB_QUERY_TYPE_LAST;
+  if (pQueryHandle->cachelastrow) {
+    pQueryHandle->type = TSDB_QUERY_TYPE_LAST;
+  }
+  
   return pQueryHandle;
 }
 
+
+
+STimeWindow updateCacheLastForEachGroup(STableGroupInfo *groupList) {
+  STimeWindow window = {INT64_MAX, INT64_MIN};
+
+  int32_t totalNumOfTable = 0;
+
+  // NOTE: starts from the buffer in case of descending timestamp order check data blocks
+  size_t numOfGroups = taosArrayGetSize(groupList->pGroupList);
+  for(int32_t j = 0; j < numOfGroups; ++j) {
+    SArray* pGroup = taosArrayGetP(groupList->pGroupList, j);
+    TSKEY   key = TSKEY_INITIAL_VAL;
+
+    STableKeyInfo keyInfo = {0};
+
+    size_t numOfTables = taosArrayGetSize(pGroup);
+    for(int32_t i = 0; i < numOfTables; ++i) {
+      STableKeyInfo* pInfo = (STableKeyInfo*) taosArrayGet(pGroup, i);
+
+      // if the lastKey equals to INT64_MIN, there is no data in this table
+      TSKEY lastKey = ((STable*)(pInfo->pTable))->lastKey;
+      if (key < lastKey) {
+        key = lastKey;
+
+        keyInfo.pTable  = pInfo->pTable;
+        keyInfo.lastKey = key;
+        pInfo->lastKey  = key;
+
+        if (key < window.skey) {
+          window.skey = key;
+        }
+
+        if (key > window.ekey) {
+          window.ekey = key;
+        }
+      }
+    }
+
+    // clear current group, unref unused table
+    for (int32_t i = 0; i < numOfTables; ++i) {
+      STableKeyInfo* pInfo = (STableKeyInfo*)taosArrayGet(pGroup, i);
+
+      // keyInfo.pTable may be NULL here.
+      if (pInfo->pTable != keyInfo.pTable) {
+        tsdbUnRefTable(pInfo->pTable);
+      }
+    }
+
+    taosArrayClear(pGroup);
+
+    // more than one table in each group, only one table left for each group
+    if (keyInfo.pTable != NULL) {
+      totalNumOfTable++;
+      taosArrayPush(pGroup, &keyInfo);
+    } else {
+      taosArrayDestroy(pGroup);
+
+      taosArrayRemove(groupList->pGroupList, j);
+      numOfGroups -= 1;
+      j -= 1;
+    }
+  }
+
+  // window does not being updated, so set the original
+  if (window.skey == INT64_MAX && window.ekey == INT64_MIN) {
+    window = TSWINDOW_INITIALIZER;
+    assert(totalNumOfTable == 0 && taosArrayGetSize(groupList->pGroupList) == 0);
+  }
+
+  groupList->numOfTables = totalNumOfTable;
+  return window;
+}
+
+
+TsdbQueryHandleT tsdbQueryCacheLast(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId, SMemRef* pMemRef) {
+  pCond->twindow = updateCacheLastForEachGroup(groupList);
+
+  // no qualified table
+  if (groupList->numOfTables == 0) {
+    return NULL;
+  }
+
+  STsdbQueryHandle *pQueryHandle = (STsdbQueryHandle*) tsdbQueryTables(tsdb, pCond, groupList, qId, pMemRef);
+  int32_t code = checkForCachedLastRow(pQueryHandle, groupList);
+  if (code != TSDB_CODE_SUCCESS) { // set the numOfTables to be 0
+    terrno = code;
+    return NULL;
+  }
+
+  assert(pCond->order == TSDB_ORDER_ASC && pCond->twindow.skey <= pCond->twindow.ekey);
+  if (pQueryHandle->cachelastrow == 2) {
+    pQueryHandle->type = TSDB_QUERY_TYPE_LAST;
+  }
+  
+  return pQueryHandle;
+}
+
+
 SArray* tsdbGetQueriedTableList(TsdbQueryHandleT *pHandle) {
   assert(pHandle != NULL);
 
@@ -2460,6 +2571,58 @@ static bool loadCachedLastRow(STsdbQueryHandle* pQueryHandle) {
   return false;
 }
 
+
+static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
+  // the last row is cached in buffer, return it directly.
+  // here note that the pQueryHandle->window must be the TS_INITIALIZER
+  int32_t numOfCols  = (int32_t)(QH_GET_NUM_OF_COLS(pQueryHandle));
+  size_t  numOfTables = taosArrayGetSize(pQueryHandle->pTableCheckInfo);
+  assert(numOfTables > 0 && numOfCols > 0);
+
+  SQueryFilePos* cur = &pQueryHandle->cur;
+
+  SDataRow pRow = NULL;
+  TSKEY    key  = TSKEY_INITIAL_VAL;
+  int32_t  step = ASCENDING_TRAVERSE(pQueryHandle->order)? 1:-1;
+
+  if (pQueryHandle->activeIndex < 0) {
+    updateCacheLastForEachGroup(pQueryHandle);
+  }
+
+  if (pQueryHandle->activeIndex < numOfTables) {
+    STableCheckInfo* pCheckInfo = taosArrayGet(pQueryHandle->pTableCheckInfo, pQueryHandle->activeIndex);
+    
+    if (pQueryHandle->cachelastrow == 1) {
+      int32_t ret = tsdbGetCachedLastRow(pCheckInfo->pTableObj, &pRow, &key);
+      if (ret != TSDB_CODE_SUCCESS) {
+        return false;
+      }
+
+      copyOneRowFromMem(pQueryHandle, pQueryHandle->outputCapacity, 0, pRow, numOfCols, pCheckInfo->pTableObj, NULL);
+      tfree(pRow);
+
+      // update the last key value
+      pCheckInfo->lastKey = key + step;
+
+      cur->rows     = 1;  // only one row
+      cur->lastKey  = key + step;
+      cur->mixBlock = true;
+      cur->win.skey = key;
+      cur->win.ekey = key;
+    } else if (pQueryHandle->cachelastrow == 2) {
+
+    } else {
+      tsdbError("invalid cachelastrow:%d", pQueryHandle->cachelastrow);
+      return false;
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
+
 static bool loadDataBlockFromTableSeq(STsdbQueryHandle* pQueryHandle) {
   size_t numOfTables = taosArrayGetSize(pQueryHandle->pTableCheckInfo);
   assert(numOfTables > 0);
@@ -2496,8 +2659,12 @@ bool tsdbNextDataBlock(TsdbQueryHandleT pHandle) {
   int64_t stime = taosGetTimestampUs();
   int64_t elapsedTime = stime;
 
-  if (pQueryHandle->type == TSDB_QUERY_TYPE_LAST && pQueryHandle->cachelastrow) {
-    return loadCachedLastRow(pQueryHandle);
+  if (pQueryHandle->type == TSDB_QUERY_TYPE_LAST) {
+    if (pQueryHandle->cachelastrow == 1) {
+      return loadCachedLastRow(pQueryHandle);
+    } if (pQueryHandle->cachelastrow == 2) else {
+      return loadCachedLast(pQueryHandle);
+    }
   }
 
   if (pQueryHandle->loadType == BLOCK_LOAD_TABLE_SEQ_ORDER) {
@@ -2683,7 +2850,7 @@ int32_t tsdbGetCachedLastRow(STable* pTable, SDataRow* pRes, TSKEY* lastKey) {
   TSDB_RLOCK_TABLE(pTable);
   *lastKey = pTable->lastKey;
 
-  if ((*lastKey) != TSKEY_INITIAL_VAL && pTable->lastRow) {
+  if ((*lastKey) != TSKEY_INITIAL_VAL && pTable->lastRow == 1) {
     *pRes = tdDataRowDup(pTable->lastRow);
     if (*pRes == NULL) {
       TSDB_RUNLOCK_TABLE(pTable);
@@ -2706,12 +2873,19 @@ int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *g
 
   STableKeyInfo* pInfo = (STableKeyInfo*)taosArrayGet(group, 0);
 
-  int32_t code = tsdbGetCachedLastRow(pInfo->pTable, &pRow, &key);
-  if (code != TSDB_CODE_SUCCESS) {
-    pQueryHandle->cachelastrow = false;
-  } else {
-    pQueryHandle->cachelastrow = (pRow != NULL);
+  int32_t code = 0;
+  
+  if (((STable*)pInfo->pTable)->lastRow == 1) {
+    code = tsdbGetCachedLastRow(pInfo->pTable, &pRow, &key);
+    if (code != TSDB_CODE_SUCCESS) {
+      pQueryHandle->cachelastrow = 0;
+    } else {
+      pQueryHandle->cachelastrow = ((STable*)pInfo->pTable)->lastRow;
+    }
+  } else if (((STable*)pInfo->pTable)->lastCols && ((STable*)pInfo->pTable)->lastColNum > 0 && ((STable*)pInfo->pTable)->lastRow == 2){
+    pQueryHandle->cachelastrow = ((STable*)pInfo->pTable)->lastRow;
   }
+  
 
   // update the tsdb query time range
   if (pQueryHandle->cachelastrow) {

From 865ddbc0268239ea62d0344449e2abdf53557b86 Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Wed, 19 May 2021 20:40:04 +0800
Subject: [PATCH 039/128] [TD-4034]fix schema change

---
 src/tsdb/inc/tsdbMeta.h     |  11 ++-
 src/tsdb/src/tsdbMain.c     |  45 ++++++------
 src/tsdb/src/tsdbMemTable.c |  23 ++++---
 src/tsdb/src/tsdbMeta.c     | 132 +++++++++++++++++++++++++++++++-----
 4 files changed, 161 insertions(+), 50 deletions(-)

diff --git a/src/tsdb/inc/tsdbMeta.h b/src/tsdb/inc/tsdbMeta.h
index a8c7a6c358..43c85d89cb 100644
--- a/src/tsdb/inc/tsdbMeta.h
+++ b/src/tsdb/inc/tsdbMeta.h
@@ -38,11 +38,15 @@ typedef struct STable {
   SRWLatch       latch;  // TODO: implementa latch functions
 
   SDataCol      *lastCols;
-  int32_t        lastColNum;
-  int32_t        restoreColumnNum;
+  int16_t        lastColNum;
+  int16_t        maxColumnNum;
+  int            lastColSVersion;
   T_REF_DECLARE()
 } STable;
 
+#define TSDB_LATEST_COLUMN_ARRAY_SIZE     20
+#define TSDB_LATEST_COLUMN_ARRAY_ADD_SIZE 5
+
 typedef struct {
   pthread_rwlock_t rwLock;
 
@@ -82,6 +86,9 @@ void       tsdbUnRefTable(STable* pTable);
 void       tsdbUpdateTableSchema(STsdbRepo* pRepo, STable* pTable, STSchema* pSchema, bool insertAct);
 int        tsdbRestoreTable(STsdbRepo* pRepo, void* cont, int contLen);
 void       tsdbOrgMeta(STsdbRepo* pRepo);
+int        tsdbInitColIdCacheWithSchema(STable* pTable, STSchema* pSchema);
+int16_t    tsdbGetLastColumnsIndexByColId(STable* pTable, int16_t colId);
+int        tsdbUpdateLastColSchema(STable *pTable, STSchema *pNewSchema);
 
 static FORCE_INLINE int tsdbCompareSchemaVersion(const void *key1, const void *key2) {
   if (*(int16_t *)key1 < schemaVersion(*(STSchema **)key2)) {
diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index a7e1efb5ed..3241d617b6 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -617,18 +617,27 @@ static void tsdbStopStream(STsdbRepo *pRepo) {
 }
 
 static int restoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh) {
+  if (pTable->numOfSchemas == 0) {
+    return 0;
+  }
   SBlock* pBlock;
   int numColumns;
   int32_t blockIdx;
   SDataStatis* pBlockStatis = NULL;
   SDataRow row = NULL;
-  STSchema *pSchema = tsdbGetTableSchema(pTable);
+  // restore last column data with last schema
+  STSchema *pSchema = pTable->schema[pTable->numOfSchemas - 1];
   int err = 0;
 
   numColumns = schemaNCols(pSchema);
-  if (numColumns <= pTable->restoreColumnNum) {
+  if (numColumns <= pTable->maxColumnNum) {
     return 0;
   }
+  if (pTable->lastColSVersion != schemaVersion(pSchema)) {
+    if (tsdbInitColIdCacheWithSchema(pTable, pSchema) < 0) {
+      return -1;
+    }
+  }
 
   row = taosTMalloc(dataRowMaxBytesFromSchema(pSchema));
   if (row == NULL) {
@@ -660,7 +669,7 @@ static int restoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh)
   SBlockIdx *pIdx = pReadh->pBlkIdx;
   blockIdx = (int32_t)(pIdx->numOfBlocks - 1);
 
-  while (numColumns > pTable->restoreColumnNum && blockIdx >= 0) {
+  while (numColumns > pTable->maxColumnNum && blockIdx >= 0) {
     bool loadStatisData = false;
     pBlock = pReadh->pBlkInfo->blocks + blockIdx;
     blockIdx -= 1;
@@ -678,18 +687,8 @@ static int restoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh)
       loadStatisData = true;
     }
 
-    for (uint32_t i = 0; i < numColumns && numColumns > pTable->restoreColumnNum; ++i) {
+    for (int16_t i = 0; i < numColumns && numColumns > pTable->maxColumnNum; ++i) {
       STColumn *pCol = schemaColAt(pSchema, i);
-
-      if (i >= pTable->lastColNum) {
-        pTable->lastCols = realloc(pTable->lastCols, i + 5);
-        for (int m = 0; m < 5; ++m) {
-          pTable->lastCols[m + pTable->lastColNum].bytes = 0;
-          pTable->lastCols[m + pTable->lastColNum].pData = NULL;
-        }
-        pTable->lastColNum += i + 5;
-      }
-
       // ignore loaded columns
       if (pTable->lastCols[i].bytes != 0) {
         continue;
@@ -710,11 +709,15 @@ static int restoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh)
           continue;
         }
 
+        int16_t idx = tsdbGetLastColumnsIndexByColId(pTable, pCol->colId);
+        if (idx == -1) {
+          tsdbError("restoreLastColumns restore vgId:%d,table:%s cache column %d fail", REPO_ID(pRepo), pTable->name->data, pCol->colId);
+          continue;
+        }
         // save not-null column
-        SDataCol *pLastCol = &(pTable->lastCols[i]);
+        SDataCol *pLastCol = &(pTable->lastCols[idx]);
         pLastCol->pData = malloc(pCol->bytes);
         pLastCol->bytes = pCol->bytes;
-        pLastCol->offset = pCol->offset;
         pLastCol->colId = pCol->colId;
         memcpy(pLastCol->pData, value, pCol->bytes);
 
@@ -722,11 +725,11 @@ static int restoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh)
         pDataCol = pReadh->pDCols[0]->cols + 0;
         pCol = schemaColAt(pSchema, 0);
         tdAppendColVal(row, tdGetColDataOfRow(pDataCol, rowId), pCol->type, pCol->bytes, pCol->offset);
-        pLastCol->ts = dataRowTKey(row);
+        pLastCol->ts = dataRowTKey(row);        
 
-        pTable->restoreColumnNum += 1;
+        pTable->maxColumnNum += 1;
 
-        tsdbInfo("restoreLastColumns restore vgId:%d,table:%s cache column %d, %d", REPO_ID(pRepo), pTable->name->data, pCol->colId, (int32_t)pLastCol->ts);
+        tsdbInfo("restoreLastColumns restore vgId:%d,table:%s cache column %d, %" PRId64, REPO_ID(pRepo), pTable->name->data, pLastCol->colId, pLastCol->ts);
         break;
       }
     }
@@ -757,7 +760,7 @@ int tsdbRestoreInfo(STsdbRepo *pRepo) {
     for (int i = 1; i < pMeta->maxTables; i++) {
       STable *pTable = pMeta->tables[i];
       if (pTable == NULL) continue;
-      pTable->restoreColumnNum = 0;  
+      pTable->maxColumnNum = 0;  
     }
   }
 
@@ -822,7 +825,7 @@ int tsdbRestoreInfo(STsdbRepo *pRepo) {
       }
       
       // restore NULL columns
-      if (CACHE_LAST_NULL_COLUMN(pCfg)) {
+      if (pIdx && CACHE_LAST_NULL_COLUMN(pCfg)) {
         if (restoreLastColumns(pRepo, pTable, &readh) != 0) {
           tsdbDestroyReadH(&readh);
           return -1;
diff --git a/src/tsdb/src/tsdbMemTable.c b/src/tsdb/src/tsdbMemTable.c
index 70e27a5700..900c034a22 100644
--- a/src/tsdb/src/tsdbMemTable.c
+++ b/src/tsdb/src/tsdbMemTable.c
@@ -972,7 +972,11 @@ static void updateTableLatestColumn(STsdbRepo *pRepo, STable *pTable, SDataRow r
   }
 
   STSchema* pSchema = pTable->schema[pTable->numOfSchemas - 1];
-  int i = pTable->numOfSchemas - 1;
+  if (tsdbUpdateLastColSchema(pTable, pSchema) < 0) {
+    return;
+  }
+
+  int16_t i = pTable->numOfSchemas - 1;
   while ((pSchema == NULL || pSchema->version != dataRowVersion(row)) && i >= 0) {
     i -= 1;
     pSchema = pTable->schema[i];
@@ -983,23 +987,20 @@ static void updateTableLatestColumn(STsdbRepo *pRepo, STable *pTable, SDataRow r
 
   SDataCol *pLatestCols = pTable->lastCols;
 
-  for (int j = 0; j < schemaNCols(pSchema); j++) {
+  for (int16_t j = 0; j < schemaNCols(pSchema); j++) {
     STColumn *pTCol = schemaColAt(pSchema, j);
-
-    if (pTCol->colId >= pTable->lastColNum) {
-      pTable->lastCols = realloc(pTable->lastCols, pTCol->colId + 5);
-      for (i = 0; i < 10; ++i) {
-        pTable->lastCols[i + pTable->lastColNum].bytes = 0;
-        pTable->lastCols[i + pTable->lastColNum].pData = NULL;
-      }
-      pTable->lastColNum += pTCol->colId + 5;
+    // ignore not exist colId
+    int16_t idx = tsdbGetLastColumnsIndexByColId(pTable, pTCol->colId);
+    if (idx == -1) {
+      continue;
     }
     
-    SDataCol *pDataCol = &(pLatestCols[pTCol->colId]);
     void* value = tdGetRowDataOfCol(row, (int8_t)pTCol->type, TD_DATA_ROW_HEAD_SIZE + pSchema->columns[j].offset);
     if (isNullN(value, pTCol->type)) {
       continue;
     }
+
+    SDataCol *pDataCol = &(pLatestCols[idx]);
     if (pDataCol->pData == NULL) {
       pDataCol->pData = malloc(pSchema->columns[j].bytes);
       pDataCol->bytes = pSchema->columns[j].bytes;
diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c
index 5a108a5d06..d785d259fa 100644
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
@@ -14,7 +14,6 @@
  */
 #include "tsdbint.h"
 
-#define TSDB_LATEST_COLUMN_ARRAY_SIZE 20
 #define TSDB_SUPER_TABLE_SL_LEVEL 5
 #define DEFAULT_TAG_INDEX_COLUMN 0
 
@@ -45,6 +44,7 @@ static int     tsdbRemoveTableFromStore(STsdbRepo *pRepo, STable *pTable);
 static int     tsdbRmTableFromMeta(STsdbRepo *pRepo, STable *pTable);
 static int     tsdbAdjustMetaTables(STsdbRepo *pRepo, int tid);
 static int     tsdbCheckTableTagVal(SKVRow *pKVRow, STSchema *pSchema);
+static void    tsdbFreeLastColumns(STable* pTable);
 
 // ------------------ OUTER FUNCTIONS ------------------
 int tsdbCreateTable(STsdbRepo *repo, STableCfg *pCfg) {
@@ -590,6 +590,116 @@ void tsdbUnRefTable(STable *pTable) {
   }
 }
 
+static void tsdbFreeLastColumns(STable* pTable) {
+  if (pTable->lastCols == NULL) {
+    return;
+  }
+
+  for (int i = 0; i < pTable->lastColNum; ++i) {
+    if (pTable->lastCols[i].bytes == 0) {
+      continue;
+    }
+    tfree(pTable->lastCols[i].pData);
+    pTable->lastCols[i].bytes = 0;
+    pTable->lastCols[i].pData = NULL;
+  }
+  tfree(pTable->lastCols);
+  pTable->lastCols = NULL;
+  pTable->lastColNum = 0;
+}
+
+int16_t tsdbGetLastColumnsIndexByColId(STable* pTable, int16_t colId) {
+  if (pTable->lastCols == NULL) {
+    return -1;
+  }
+  for (int16_t i = 0; i < pTable->lastColNum; ++i) {
+    if (pTable->lastCols[i].colId == colId) {
+      return i;
+    }
+  }
+
+  return -1;
+}
+
+int tsdbInitColIdCacheWithSchema(STable* pTable, STSchema* pSchema) {
+  ASSERT(pTable->lastCols == NULL);
+
+  int16_t numOfColumn = pSchema->numOfCols;
+
+  pTable->lastCols = (SDataCol*)malloc(numOfColumn * sizeof(SDataCol));
+  if (pTable->lastCols == NULL) {
+    return -1;
+  }
+
+  for (int16_t i = 0; i < numOfColumn; ++i) {
+    STColumn *pCol = schemaColAt(pSchema, i);
+    SDataCol* pDataCol = &(pTable->lastCols[i]);
+    pDataCol->bytes = 0;
+    pDataCol->pData = NULL;
+    pDataCol->colId = pCol->colId;
+  }
+
+  pTable->lastColSVersion = schemaVersion(pSchema);
+  pTable->lastColNum = numOfColumn;
+  pTable->maxColumnNum = 0;
+  return 0;
+}
+
+int tsdbUpdateLastColSchema(STable *pTable, STSchema *pNewSchema) {
+  if (pTable->lastColSVersion == schemaVersion(pNewSchema)) {
+    return 0;
+  }
+  
+  tsdbInfo("tsdbUpdateLastColSchema:%s,%d->%d", pTable->name->data, pTable->lastColSVersion, schemaVersion(pNewSchema));
+  
+  int16_t numOfCols = pNewSchema->numOfCols;
+  SDataCol *lastCols = (SDataCol*)malloc(numOfCols * sizeof(SDataCol));
+  if (lastCols == NULL) {
+    return -1;
+  }
+
+  TSDB_WLOCK_TABLE(pTable);
+  
+  int16_t oldIdx = 0;
+  for (int16_t i = 0; i < numOfCols; ++i) {
+    STColumn *pCol = schemaColAt(pNewSchema, i);
+    int16_t idx = tsdbGetLastColumnsIndexByColId(pTable, pCol->colId);
+
+    SDataCol* pDataCol = &(lastCols[i]);
+    if (idx != -1) {
+      SDataCol* pOldDataCol = &(pTable->lastCols[idx]);
+      memcpy(pDataCol, pOldDataCol, sizeof(SDataCol));
+    } else {
+      pDataCol->colId = pCol->colId;
+      pDataCol->bytes = 0;
+      pDataCol->pData = NULL;
+    }
+
+    // free dropped column data
+    while (oldIdx < idx && oldIdx < pTable->lastColNum) {
+      SDataCol* pOldDataCol = &(pTable->lastCols[oldIdx]);
+      if (pOldDataCol->bytes != 0) {
+        tfree(pOldDataCol->pData);
+        pOldDataCol->bytes = 0;
+      }
+      ++oldIdx;
+    }
+    if (idx != -1 && oldIdx == idx) {
+      oldIdx += 1;
+    }
+  }
+
+  // free old schema last column datas
+  tfree(pTable->lastCols);
+
+  pTable->lastColSVersion = schemaVersion(pNewSchema);
+  pTable->lastCols = lastCols;
+  pTable->lastColNum = numOfCols;
+
+  TSDB_WUNLOCK_TABLE(pTable);
+  return 0;
+}
+
 void tsdbUpdateTableSchema(STsdbRepo *pRepo, STable *pTable, STSchema *pSchema, bool insertAct) {
   ASSERT(TABLE_TYPE(pTable) != TSDB_STREAM_TABLE && TABLE_TYPE(pTable) != TSDB_SUPER_TABLE);
   STsdbMeta *pMeta = pRepo->tsdbMeta;
@@ -672,14 +782,11 @@ static STable *tsdbNewTable() {
   }
 
   pTable->lastKey = TSKEY_INITIAL_VAL;
-  pTable->lastCols = (SDataCol*)malloc(TSDB_LATEST_COLUMN_ARRAY_SIZE * sizeof(SDataCol));
-  pTable->lastColNum = TSDB_LATEST_COLUMN_ARRAY_SIZE;
-  for (int i = 0; i < pTable->lastColNum; ++i) {
-    pTable->lastCols[i].bytes = 0;
-    pTable->lastCols[i].pData = NULL;
-  }
-  pTable->restoreColumnNum = 0;
 
+  pTable->lastCols = NULL;
+  pTable->maxColumnNum = 0;
+  pTable->lastColNum = 0;
+  pTable->lastColSVersion = -1;
   return pTable;
 }
 
@@ -796,14 +903,7 @@ static void tsdbFreeTable(STable *pTable) {
     taosTZfree(pTable->lastRow);    
     tfree(pTable->sql);
 
-    for (int i = 0; i < pTable->lastColNum; ++i) {
-      if (pTable->lastCols[i].pData == NULL) {
-        continue;
-      }
-      free(pTable->lastCols[i].pData);
-    }
-    tfree(pTable->lastCols);
-    
+    tsdbFreeLastColumns(pTable);
     free(pTable);
   }
 }

From f182495628bfd32ccdbeb56aed15649544181c11 Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Thu, 20 May 2021 09:29:31 +0800
Subject: [PATCH 040/128] [TD-4034]fix schema change,free not exist column data

---
 src/inc/tsdb.h          |  4 ++--
 src/tsdb/src/tsdbMeta.c | 43 +++++++++++++++++++++++++----------------
 2 files changed, 28 insertions(+), 19 deletions(-)

diff --git a/src/inc/tsdb.h b/src/inc/tsdb.h
index d231769c18..7c28d3e485 100644
--- a/src/inc/tsdb.h
+++ b/src/inc/tsdb.h
@@ -73,8 +73,8 @@ typedef struct {
 } STsdbCfg;
 
 #define CACHE_NO_LAST(c)          ((c)->cacheLastRow == 0)
-#define CACHE_LAST_ROW(c)         ((c)->cacheLastRow == 1)
-#define CACHE_LAST_NULL_COLUMN(c) ((c)->cacheLastRow == 2)
+#define CACHE_LAST_ROW(c)         (((c)->cacheLastRow & 1) > 0)
+#define CACHE_LAST_NULL_COLUMN(c) (((c)->cacheLastRow & 2) > 0)
 
 // --------- TSDB REPOSITORY USAGE STATISTICS
 typedef struct {
diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c
index d785d259fa..fde593b59a 100644
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
@@ -659,44 +659,53 @@ int tsdbUpdateLastColSchema(STable *pTable, STSchema *pNewSchema) {
   }
 
   TSDB_WLOCK_TABLE(pTable);
-  
-  int16_t oldIdx = 0;
+
   for (int16_t i = 0; i < numOfCols; ++i) {
     STColumn *pCol = schemaColAt(pNewSchema, i);
     int16_t idx = tsdbGetLastColumnsIndexByColId(pTable, pCol->colId);
 
     SDataCol* pDataCol = &(lastCols[i]);
     if (idx != -1) {
+      // move col data to new last column array
       SDataCol* pOldDataCol = &(pTable->lastCols[idx]);
       memcpy(pDataCol, pOldDataCol, sizeof(SDataCol));
     } else {
+      // init new colid data
       pDataCol->colId = pCol->colId;
       pDataCol->bytes = 0;
       pDataCol->pData = NULL;
     }
-
-    // free dropped column data
-    while (oldIdx < idx && oldIdx < pTable->lastColNum) {
-      SDataCol* pOldDataCol = &(pTable->lastCols[oldIdx]);
-      if (pOldDataCol->bytes != 0) {
-        tfree(pOldDataCol->pData);
-        pOldDataCol->bytes = 0;
-      }
-      ++oldIdx;
-    }
-    if (idx != -1 && oldIdx == idx) {
-      oldIdx += 1;
-    }
   }
 
-  // free old schema last column datas
-  tfree(pTable->lastCols);
+  SDataCol *oldLastCols = pTable->lastCols;
+  int16_t oldLastColNum = pTable->lastColNum;
 
   pTable->lastColSVersion = schemaVersion(pNewSchema);
   pTable->lastCols = lastCols;
   pTable->lastColNum = numOfCols;
 
+  if (oldLastCols == NULL) {
+    TSDB_WUNLOCK_TABLE(pTable);
+    return 0;
+  }
+
+  // free old schema last column datas
+  for (int16_t i = 0; i < oldLastColNum; ++i) {
+    SDataCol* pDataCol = &(oldLastCols[i]);
+    if (pDataCol->bytes == 0) {
+      continue;
+    }
+    int16_t idx = tsdbGetLastColumnsIndexByColId(pTable, pDataCol->colId);
+    if (idx != -1) {
+      continue;
+    }
+
+    // free not exist column data
+    tfree(pDataCol->pData);
+  }
   TSDB_WUNLOCK_TABLE(pTable);
+  tfree(oldLastCols);
+
   return 0;
 }
 

From 617a7f71896369a3ac39e9eee6efe01ed7e04e7c Mon Sep 17 00:00:00 2001
From: yihaoDeng <yhdeng@taosdata.com>
Date: Thu, 20 May 2021 10:01:24 +0800
Subject: [PATCH 041/128] TD-4241

---
 src/util/src/tcache.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/util/src/tcache.c b/src/util/src/tcache.c
index c0cc8ce339..a8a1f69c1b 100644
--- a/src/util/src/tcache.c
+++ b/src/util/src/tcache.c
@@ -613,7 +613,7 @@ void doCleanupDataCache(SCacheObj *pCacheObj) {
 
   // todo memory leak if there are object with refcount greater than 0 in hash table?
   taosHashCleanup(pCacheObj->pHashTable);
-  taosTrashcanEmpty(pCacheObj, true);
+  taosTrashcanEmpty(pCacheObj, false);
 
   __cache_lock_destroy(pCacheObj);
   

From 0f22b3d41b43f9ada67168c878ec8492e640af47 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Thu, 20 May 2021 10:17:16 +0800
Subject: [PATCH 042/128] [td-3186]

---
 src/client/inc/tscUtil.h      |  13 +-
 src/client/inc/tsclient.h     |   2 +-
 src/client/src/tscAsync.c     |  15 +-
 src/client/src/tscSQLParser.c |   6 +-
 src/client/src/tscServer.c    |   9 +-
 src/client/src/tscSubquery.c  |  39 ++---
 src/client/src/tscUtil.c      | 292 ++++++++++++++++++++++------------
 src/query/src/qExecutor.c     |   2 +-
 8 files changed, 236 insertions(+), 142 deletions(-)

diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index ca1ea54e16..48b1138072 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -20,6 +20,7 @@
 extern "C" {
 #endif
 
+#include <tsched.h>
 #include "exception.h"
 #include "os.h"
 #include "qExtbuffer.h"
@@ -93,22 +94,12 @@ typedef struct SVgroupTableInfo {
   SArray     *itemList;   // SArray<STableIdInfo>
 } SVgroupTableInfo;
 
-static FORCE_INLINE SQueryInfo* tscGetQueryInfo(SSqlCmd* pCmd) {
-  assert(pCmd != NULL);
-  if (pCmd->pQueryInfo == NULL) {
-    return NULL;
-  }
-
-  return pCmd->active;
-}
-
-SQueryInfo* tscGetActiveQueryInfo(SSqlCmd* pCmd);
-
 int32_t tscCreateDataBlock(size_t initialSize, int32_t rowSize, int32_t startOffset, SName* name, STableMeta* pTableMeta, STableDataBlocks** dataBlocks);
 void tscDestroyDataBlock(STableDataBlocks* pDataBlock, bool removeMeta);
 void tscSortRemoveDataBlockDupRows(STableDataBlocks* dataBuf);
 
 void tscDestroyBoundColumnInfo(SParsedDataColInfo* pColInfo);
+void doRetrieveSubqueryData(SSchedMsg *pMsg);
 
 SParamInfo* tscAddParamToDataBlock(STableDataBlocks* pDataBlock, char type, uint8_t timePrec, int16_t bytes,
                                    uint32_t offset);
diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index 875b485cf2..9a22961f30 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -454,7 +454,7 @@ int32_t tscCreateResPointerInfo(SSqlRes *pRes, SQueryInfo *pQueryInfo);
 void tscSetResRawPtr(SSqlRes* pRes, SQueryInfo* pQueryInfo);
 void tscSetResRawPtrRv(SSqlRes* pRes, SQueryInfo* pQueryInfo, SSDataBlock* pBlock);
 
-void handleDownstreamOperator(SSqlRes** pRes, int32_t numOfUpstream, SQueryInfo* px, SSqlRes* pOutput);
+void handleDownstreamOperator(SSqlObj** pSqlList, int32_t numOfUpstream, SQueryInfo* px, SSqlRes* pOutput);
 void destroyTableNameList(SSqlCmd* pCmd);
 
 void tscResetSqlCmd(SSqlCmd *pCmd, bool removeMeta);
diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c
index 1456a91099..20a2164149 100644
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -222,6 +222,17 @@ void taos_fetch_rows_a(TAOS_RES *tres, __async_cb_func_t fp, void *param) {
   tscResetForNextRetrieve(pRes);
   
   // handle the sub queries of join query
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
+  if (pQueryInfo->pUpstream != NULL && taosArrayGetSize(pQueryInfo->pUpstream) > 0) {
+    SSchedMsg schedMsg = {0};
+    schedMsg.fp = doRetrieveSubqueryData;
+    schedMsg.ahandle = (void *)pSql->self;
+    schedMsg.thandle = (void *)1;
+    schedMsg.msg = 0;
+    taosScheduleTask(tscQhandle, &schedMsg);
+    return;
+  }
+
   if (pCmd->command == TSDB_SQL_TABLE_JOIN_RETRIEVE) {
     tscFetchDatablockForSubquery(pSql);
   } else if (pRes->completed) {
@@ -258,7 +269,7 @@ void taos_fetch_rows_a(TAOS_RES *tres, __async_cb_func_t fp, void *param) {
       pCmd->command = (pCmd->command > TSDB_SQL_MGMT) ? TSDB_SQL_RETRIEVE : TSDB_SQL_FETCH;
     }
 
-    SQueryInfo* pQueryInfo1 = tscGetActiveQueryInfo(&pSql->cmd);
+    SQueryInfo* pQueryInfo1 = tscGetQueryInfo(&pSql->cmd);
     tscBuildAndSendRequest(pSql, pQueryInfo1);
   }
 }
@@ -477,7 +488,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
     }
 
   } else {  // stream computing
-    SQueryInfo* pQueryInfo = tscGetActiveQueryInfo(pCmd);
+    SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
     STableMetaInfo *pTableMetaInfo = pQueryInfo->pTableMetaInfo[0];
 
     code = tscGetTableMeta(pSql, pTableMetaInfo);
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 365ff4147a..675ce27de2 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -7201,6 +7201,8 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     }
   }
 
+  tfree(pTableMeta);
+
   // load the table meta for a given table name list
   if (taosArrayGetSize(plist) > 0) {
     int32_t code = getMultiTableMetaFromMnode(pSql, plist, pVgroupList);
@@ -7334,11 +7336,13 @@ static int32_t doValidateSubquery(SSqlNode* pSqlNode, int32_t index, SSqlObj* pS
   // NOTE: order mix up in subquery not support yet.
   pQueryInfo->order = pSub->order;
 
-  char* tmp = realloc(pQueryInfo->pTableMetaInfo, (pQueryInfo->numOfTables + 1) * POINTER_BYTES);
+  STableMetaInfo** tmp = realloc(pQueryInfo->pTableMetaInfo, (pQueryInfo->numOfTables + 1) * POINTER_BYTES);
   if (tmp == NULL) {
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
+  pQueryInfo->pTableMetaInfo = tmp;
+
   pQueryInfo->pTableMetaInfo[pQueryInfo->numOfTables] = pTableMetaInfo1;
   pQueryInfo->numOfTables += 1;
 
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index f35be615a4..eb61894061 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -539,7 +539,7 @@ int tscBuildAndSendRequest(SSqlObj *pSql, SQueryInfo* pQueryInfo) {
 int tscBuildFetchMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SRetrieveTableMsg *pRetrieveMsg = (SRetrieveTableMsg *) pSql->cmd.payload;
 
-  SQueryInfo *pQueryInfo = tscGetActiveQueryInfo(&pSql->cmd);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
   pRetrieveMsg->free = htons(pQueryInfo->type);
   pRetrieveMsg->qId  = htobe64(pSql->res.qId);
@@ -822,7 +822,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
     return TSDB_CODE_TSC_INVALID_SQL;  // todo add test for this
   }
 
-  SQueryInfo *pQueryInfo = tscGetActiveQueryInfo(pCmd);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
 
   SQueryAttr query = {{0}};
   tscCreateQueryFromQueryInfo(pQueryInfo, &query, pSql);
@@ -1620,7 +1620,7 @@ int tscProcessRetrieveLocalMergeRsp(SSqlObj *pSql) {
   }
 
   // global aggregation may be the upstream for parent query
-  SQueryInfo *pQueryInfo = tscGetActiveQueryInfo(pCmd);
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
   if (pQueryInfo->pQInfo == NULL) {
     STableGroupInfo tableGroupInfo = {.numOfTables = 1, .pGroupList = taosArrayInit(1, POINTER_BYTES),};
     tableGroupInfo.map = taosHashInit(1, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), true, HASH_NO_LOCK);
@@ -2061,6 +2061,7 @@ int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
   pSql->res.numOfTotal = pMultiMeta->numOfTables;
   tscDebug("0x%"PRIx64" load multi-tableMeta resp from complete numOfTables:%d", pSql->self, pMultiMeta->numOfTables);
 
+  taosHashCleanup(pSet);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -2363,7 +2364,7 @@ int tscProcessRetrieveRspFromNode(SSqlObj *pSql) {
   pRes->completed = (pRetrieve->completed == 1);
   pRes->data      = pRetrieve->data;
   
-  SQueryInfo* pQueryInfo = tscGetActiveQueryInfo(pCmd);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
   if (tscCreateResPointerInfo(pRes, pQueryInfo) != TSDB_CODE_SUCCESS) {
     return pRes->code;
   }
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index 406214aba0..0ca79bc702 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -82,8 +82,7 @@ static bool allSubqueryDone(SSqlObj *pParentSql) {
   for (int i = 0; i < subState->numOfSub; i++) {
     SSqlObj* pSub = pParentSql->pSubs[i];
     if (0 == subState->states[i]) {
-      tscDebug("0x%"PRIx64" subquery:0x%"PRIx64", index: %d NOT finished, abort query completion check", pParentSql->self,
-               pSub->self, i);
+      tscDebug("0x%"PRIx64" subquery:0x%"PRIx64", index: %d NOT finished yet", pParentSql->self, pSub->self, i);
       done = false;
       break;
     } else {
@@ -100,23 +99,21 @@ static bool allSubqueryDone(SSqlObj *pParentSql) {
 
 bool subAndCheckDone(SSqlObj *pSql, SSqlObj *pParentSql, int idx) {
   SSubqueryState *subState = &pParentSql->subState;
-
   assert(idx < subState->numOfSub);
 
   pthread_mutex_lock(&subState->mutex);
 
-  bool done = allSubqueryDone(pParentSql);
-  if (done) {
-    tscDebug("0x%"PRIx64" subquery:0x%"PRIx64",%d all subs already done", pParentSql->self, pSql->self, idx);
-    pthread_mutex_unlock(&subState->mutex);
-    return false;
-  }
-  
-  tscDebug("0x%"PRIx64" subquery:0x%"PRIx64",%d state set to 1", pParentSql->self, pSql->self, idx);
+//  bool done = allSubqueryDone(pParentSql);
+//  if (done) {
+//    tscDebug("0x%"PRIx64" subquery:0x%"PRIx64",%d all subs already done", pParentSql->self, pSql->self, idx);
+//    pthread_mutex_unlock(&subState->mutex);
+//    return false;
+//  }
   
+  tscDebug("0x%"PRIx64" subquery:0x%"PRIx64", index:%d state set to 1", pParentSql->self, pSql->self, idx);
   subState->states[idx] = 1;
 
-  done = allSubqueryDone(pParentSql);
+  bool done = allSubqueryDone(pParentSql);
   pthread_mutex_unlock(&subState->mutex);
   return done;
 }
@@ -2415,7 +2412,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
   
   const uint32_t nBufferSize = (1u << 16u);  // 64KB
   
-  SQueryInfo     *pQueryInfo = tscGetActiveQueryInfo(pCmd);
+  SQueryInfo     *pQueryInfo = tscGetQueryInfo(pCmd);
   STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
   SSubqueryState *pState = &pSql->subState;
 
@@ -3487,8 +3484,6 @@ static UNUSED_FUNC bool tscHasRemainDataInSubqueryResultSet(SSqlObj *pSql) {
 void* createQInfoFromQueryNode(SQueryInfo* pQueryInfo, SExprInfo* pExprs, STableGroupInfo* pTableGroupInfo,
                                SOperatorInfo* pSourceOperator, char* sql, void* merger, int32_t stage) {
   assert(pQueryInfo != NULL);
-//  int16_t numOfOutput = pQueryInfo->fieldsInfo.numOfOutput;
-
   SQInfo *pQInfo = (SQInfo *)calloc(1, sizeof(SQInfo));
   if (pQInfo == NULL) {
     goto _cleanup;
@@ -3506,25 +3501,25 @@ void* createQInfoFromQueryNode(SQueryInfo* pQueryInfo, SExprInfo* pExprs, STable
   pQueryAttr->tableGroupInfo = *pTableGroupInfo;
 
   // calculate the result row size
-  SExprInfo* pei = NULL;
+  SExprInfo* pEx = NULL;
   int32_t num = 0;
   if (pQueryAttr->pExpr3 != NULL) {
-    pei = pQueryAttr->pExpr3;
+    pEx = pQueryAttr->pExpr3;
     num = pQueryAttr->numOfExpr3;
   } else if (pQueryAttr->pExpr2 != NULL) {
-    pei = pQueryAttr->pExpr2;
+    pEx = pQueryAttr->pExpr2;
     num = pQueryAttr->numOfExpr2;
   } else {
-    pei = pQueryAttr->pExpr1;
+    pEx = pQueryAttr->pExpr1;
     num = pQueryAttr->numOfOutput;
   }
 
   for (int16_t col = 0; col < num; ++col) {
-    pQueryAttr->resultRowSize += pei[col].base.resBytes;
+    pQueryAttr->resultRowSize += pEx[col].base.resBytes;
 
     // keep the tag length
-    if (TSDB_COL_IS_TAG(pei[col].base.colInfo.flag)) {
-      pQueryAttr->tagLen += pei[col].base.resBytes;
+    if (TSDB_COL_IS_TAG(pEx[col].base.colInfo.flag)) {
+      pQueryAttr->tagLen += pEx[col].base.resBytes;
     }
   }
 
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 5bd7417f5f..b73e2e634b 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -648,7 +648,7 @@ static SColumnInfo* extractColumnInfoFromResult(SArray* pTableCols) {
 
 typedef struct SDummyInputInfo {
   SSDataBlock    *block;
-  SSqlRes        *pRes;  // refactor: remove it
+  SSqlObj        *pSql;  // refactor: remove it
 } SDummyInputInfo;
 
 typedef struct SJoinStatus {
@@ -664,92 +664,198 @@ typedef struct SJoinOperatorInfo {
   SRspResultInfo resultInfo;  // todo refactor, add this info for each operator
 } SJoinOperatorInfo;
 
-SSDataBlock* doGetDataBlock(void* param, bool* newgroup) {
-  SOperatorInfo *pOperator = (SOperatorInfo*) param;
-
-  SDummyInputInfo *pInput = pOperator->info;
-  char* pData = pInput->pRes->data;
-
-  SSDataBlock* pBlock = pInput->block;
-  pBlock->info.rows = pInput->pRes->numOfRows;
-  if (pBlock->info.rows == 0) {
-    return NULL;
-  }
-
-  //TODO refactor
+static void doSetupSDataBlock(SSqlRes* pRes, SSDataBlock* pBlock) {
   int32_t offset = 0;
+  char* pData = pRes->data;
   for(int32_t i = 0; i < pBlock->info.numOfCols; ++i) {
     SColumnInfoData* pColData = taosArrayGet(pBlock->pDataBlock, i);
     if (pData != NULL) {
       pColData->pData = pData + offset * pBlock->info.rows;
     } else {
-      pColData->pData = pInput->pRes->urow[i];
+      pColData->pData = pRes->urow[i];
     }
 
     offset += pColData->info.bytes;
   }
 
-  pInput->pRes->numOfRows = 0;
+  pRes->numOfRows = 0;
+}
+
+// NOTE: there is already exists data blocks before this function calls.
+SSDataBlock* doGetDataBlock(void* param, bool* newgroup) {
+  SOperatorInfo *pOperator = (SOperatorInfo*) param;
+  if (pOperator->status == OP_EXEC_DONE) {
+    return NULL;
+  }
+
+  SDummyInputInfo *pInput = pOperator->info;
+  SSqlObj* pSql = pInput->pSql;
+  SSqlRes* pRes = &pSql->res;
+
+  SSDataBlock* pBlock = pInput->block;
+
+  pBlock->info.rows = pRes->numOfRows;
+  if (pRes->numOfRows != 0) {
+    doSetupSDataBlock(pRes, pBlock);
+    *newgroup = false;
+    return pBlock;
+  }
+
+  // No data block exists. So retrieve and transfer it into to SSDataBlock
+  TAOS_ROW pRow = NULL;
+  taos_fetch_block(pSql, &pRow);
+
+  if (pRes->numOfRows == 0) {
+    pOperator->status = OP_EXEC_DONE;
+    return NULL;
+  }
+
+  pBlock->info.rows = pRes->numOfRows;
+  doSetupSDataBlock(pRes, pBlock);
   *newgroup = false;
   return pBlock;
 }
 
-SSDataBlock* doBlockJoin(void* param, bool* newgroup) {
+static int32_t v = 0;
+SSDataBlock* doDataBlockJoin(void* param, bool* newgroup) {
   SOperatorInfo *pOperator = (SOperatorInfo*) param;
-  assert(pOperator->numOfUpstream > 1);
-
-  SSDataBlock* block0 = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
-  SSDataBlock* block1 = pOperator->upstream[1]->exec(pOperator->upstream[1], newgroup);
-
-  if (block1 == NULL || block0 == NULL) {
+  if (pOperator->status == OP_EXEC_DONE) {
     return NULL;
   }
 
-  assert(block0 != block1);
+  assert(pOperator->numOfUpstream > 1);
 
   SJoinOperatorInfo* pJoinInfo = pOperator->info;
-  pJoinInfo->status[0].pBlock = block0;
-  pJoinInfo->status[1].pBlock = block1;
+  pJoinInfo->pRes->info.rows = 0;
 
-  SJoinStatus* st0 = &pJoinInfo->status[0];
-  SJoinStatus* st1 = &pJoinInfo->status[1];
+  while(1) {
+    for (int32_t i = 0; i < pOperator->numOfUpstream; ++i) {
+      SJoinStatus* pStatus = &pJoinInfo->status[i];
+      if (pStatus->pBlock == NULL || pStatus->index >= pStatus->pBlock->info.rows) {
+        pStatus->pBlock = pOperator->upstream[i]->exec(pOperator->upstream[i], newgroup);
+        pStatus->index = 0;
 
-  while (st0->index < st0->pBlock->info.rows && st1->index < st1->pBlock->info.rows) {
-    SColumnInfoData* p0 = taosArrayGet(st0->pBlock->pDataBlock, 0);
-    SColumnInfoData* p1 = taosArrayGet(st1->pBlock->pDataBlock, 0);
+        if (i == 0 && pStatus->pBlock != NULL) {
+          v += pStatus->pBlock->info.rows;
+          printf("---------------%d\n", v);
+        }
 
-    int64_t* ts0 = (int64_t*) p0->pData;
-    int64_t* ts1 = (int64_t*) p1->pData;
-    if (ts0[st0->index] == ts1[st1->index]) { // add to the final result buffer
-      // check if current output buffer is over the threshold to pause current loop
-      int32_t rows = pJoinInfo->pRes->info.rows;
-      for(int32_t j = 0; j < st0->pBlock->info.numOfCols; ++j) {
-        SColumnInfoData* pCol1 = taosArrayGet(pJoinInfo->pRes->pDataBlock, j);
-        SColumnInfoData* pSrc = taosArrayGet(st0->pBlock->pDataBlock, j);
+        if (pStatus->pBlock == NULL) {
+          pOperator->status = OP_EXEC_DONE;
 
-        int32_t bytes = pSrc->info.bytes;
-        memcpy(pCol1->pData + rows * bytes, pSrc->pData + st0->index * bytes, bytes);
+          pJoinInfo->resultInfo.total += pJoinInfo->pRes->info.rows;
+          return pJoinInfo->pRes;
+        }
       }
-
-      for(int32_t j = 0; j < st1->pBlock->info.numOfCols; ++j) {
-        SColumnInfoData* pCol1 = taosArrayGet(pJoinInfo->pRes->pDataBlock, j + st0->pBlock->info.numOfCols);
-        SColumnInfoData* pSrc = taosArrayGet(st1->pBlock->pDataBlock, j);
-
-        int32_t bytes = pSrc->info.bytes;
-        memcpy(pCol1->pData + rows * bytes, pSrc->pData + st1->index * bytes, bytes);
-      }
-
-      st0->index++;
-      st1->index++;
-      pJoinInfo->pRes->info.rows++;
-    } else if (ts0[st0->index] < ts1[st1->index]) {
-      st0->index++;
-    } else {
-      st1->index++;
     }
-  }
 
-  return pJoinInfo->pRes;
+    SJoinStatus* st0 = &pJoinInfo->status[0];
+    SColumnInfoData* p0 = taosArrayGet(st0->pBlock->pDataBlock, 0);
+    int64_t* ts0 = (int64_t*) p0->pData;
+
+    bool prefixEqual = true;
+
+    while(1) {
+      prefixEqual = true;
+      for (int32_t i = 1; i < pJoinInfo->numOfUpstream; ++i) {
+        SJoinStatus* st = &pJoinInfo->status[i];
+
+        SColumnInfoData* p = taosArrayGet(st->pBlock->pDataBlock, 0);
+        int64_t*         ts = (int64_t*)p->pData;
+
+        if (ts[st->index] < ts0[st0->index]) {  // less than the first
+          prefixEqual = false;
+          if ((++(st->index)) >= st->pBlock->info.rows) {
+            break;
+          }
+        } else if (ts[st->index] > ts0[st0->index]) {  // greater than the first;
+          if (prefixEqual == true) {
+            prefixEqual = false;
+            for (int32_t j = 0; j < i; ++j) {
+              SJoinStatus* stx = &pJoinInfo->status[j];
+              if ((++(stx->index)) >= stx->pBlock->info.rows) {
+                break;
+              }
+            }
+          } else {
+            if ((++(st0->index)) >= st0->pBlock->info.rows) {
+              break;
+            }
+          }
+        }
+      }
+
+      if (prefixEqual) {
+        int32_t offset = 0;
+        bool completed = false;
+        for (int32_t i = 0; i < pOperator->numOfUpstream; ++i) {
+          SJoinStatus* st1 = &pJoinInfo->status[i];
+          int32_t      rows = pJoinInfo->pRes->info.rows;
+
+          for (int32_t j = 0; j < st1->pBlock->info.numOfCols; ++j) {
+            SColumnInfoData* pCol1 = taosArrayGet(pJoinInfo->pRes->pDataBlock, j + offset);
+            SColumnInfoData* pSrc = taosArrayGet(st1->pBlock->pDataBlock, j);
+
+            int32_t bytes = pSrc->info.bytes;
+            memcpy(pCol1->pData + rows * bytes, pSrc->pData + st1->index * bytes, bytes);
+          }
+
+          offset += st1->pBlock->info.numOfCols;
+          if ((++(st1->index)) == st1->pBlock->info.rows) {
+            completed = true;
+          }
+        }
+
+        if ((++pJoinInfo->pRes->info.rows) >= pJoinInfo->resultInfo.capacity) {
+          pJoinInfo->resultInfo.total += pJoinInfo->pRes->info.rows;
+          return pJoinInfo->pRes;
+        }
+
+        if (completed == true) {
+          break;
+        }
+      }
+    }
+/*
+    while (st0->index < st0->pBlock->info.rows && st1->index < st1->pBlock->info.rows) {
+      SColumnInfoData* p0 = taosArrayGet(st0->pBlock->pDataBlock, 0);
+      SColumnInfoData* p1 = taosArrayGet(st1->pBlock->pDataBlock, 0);
+
+      int64_t* ts0 = (int64_t*)p0->pData;
+      int64_t* ts1 = (int64_t*)p1->pData;
+      if (ts0[st0->index] == ts1[st1->index]) {  // add to the final result buffer
+        // check if current output buffer is over the threshold to pause current loop
+        int32_t rows = pJoinInfo->pRes->info.rows;
+        for (int32_t j = 0; j < st0->pBlock->info.numOfCols; ++j) {
+          SColumnInfoData* pCol1 = taosArrayGet(pJoinInfo->pRes->pDataBlock, j);
+          SColumnInfoData* pSrc = taosArrayGet(st0->pBlock->pDataBlock, j);
+
+          int32_t bytes = pSrc->info.bytes;
+          memcpy(pCol1->pData + rows * bytes, pSrc->pData + st0->index * bytes, bytes);
+        }
+
+        for (int32_t j = 0; j < st1->pBlock->info.numOfCols; ++j) {
+          SColumnInfoData* pCol1 = taosArrayGet(pJoinInfo->pRes->pDataBlock, j + st0->pBlock->info.numOfCols);
+          SColumnInfoData* pSrc = taosArrayGet(st1->pBlock->pDataBlock, j);
+
+          int32_t bytes = pSrc->info.bytes;
+          memcpy(pCol1->pData + rows * bytes, pSrc->pData + st1->index * bytes, bytes);
+        }
+
+        st0->index++;
+        st1->index++;
+
+        if ((++pJoinInfo->pRes->info.rows) >= pJoinInfo->resultInfo.capacity) {
+          pJoinInfo->resultInfo.total += pJoinInfo->pRes->info.rows;
+          return pJoinInfo->pRes;
+        }
+      } else if (ts0[st0->index] < ts1[st1->index]) {
+        st0->index++;
+      } else {
+        st1->index++;
+      }
+    }*/
+  }
 }
 
 static void destroyDummyInputOperator(void* param, int32_t numOfOutput) {
@@ -762,15 +868,15 @@ static void destroyDummyInputOperator(void* param, int32_t numOfOutput) {
   }
 
   pInfo->block = destroyOutputBuf(pInfo->block);
-  pInfo->pRes = NULL;
+  pInfo->pSql = NULL;
 }
 
 // todo this operator servers as the adapter for Operator tree and SqlRes result, remove it later
-SOperatorInfo* createDummyInputOperator(char* pResult, SSchema* pSchema, int32_t numOfCols) {
+SOperatorInfo* createDummyInputOperator(SSqlObj* pSql, SSchema* pSchema, int32_t numOfCols) {
   assert(numOfCols > 0);
   SDummyInputInfo* pInfo = calloc(1, sizeof(SDummyInputInfo));
 
-  pInfo->pRes  = (SSqlRes*) pResult;
+  pInfo->pSql  = pSql;
   pInfo->block = calloc(numOfCols, sizeof(SSDataBlock));
   pInfo->block->info.numOfCols = numOfCols;
 
@@ -824,7 +930,7 @@ SOperatorInfo* createJoinOperator(SOperatorInfo** pUpstream, int32_t numOfUpstre
   pOperator->numOfOutput   = numOfOutput;
   pOperator->blockingOptr  = false;
   pOperator->info          = pInfo;
-  pOperator->exec          = doBlockJoin;
+  pOperator->exec          = doDataBlockJoin;
   pOperator->cleanup       = destroyDummyInputOperator;
 
   for(int32_t i = 0; i < numOfUpstream; ++i) {
@@ -848,7 +954,7 @@ void convertQueryResult(SSqlRes* pRes, SQueryInfo* pQueryInfo) {
   pRes->completed = (pRes->numOfRows == 0);
 }
 
-void handleDownstreamOperator(SSqlRes** pRes, int32_t numOfUpstream, SQueryInfo* px, SSqlRes* pOutput) {
+void handleDownstreamOperator(SSqlObj** pSqlObjList, int32_t numOfUpstream, SQueryInfo* px, SSqlRes* pOutput) {
   // handle the following query process
   if (px->pQInfo == NULL) {
     SColumnInfo* pColumnInfo = extractColumnInfoFromResult(px->colList);
@@ -879,26 +985,29 @@ void handleDownstreamOperator(SSqlRes** pRes, int32_t numOfUpstream, SQueryInfo*
 
     // if it is a join query, create join operator here
     int32_t numOfCol1 = px->pTableMetaInfo[0]->pTableMeta->tableInfo.numOfColumns;
-
-    SOperatorInfo* pSourceOperator = createDummyInputOperator((char*)pRes[0], pSchema, numOfCol1);
+    SOperatorInfo* pSourceOperator = createDummyInputOperator(pSqlObjList[0], pSchema, numOfCol1);
 
     SSchema* schema = NULL;
     if (px->numOfTables > 1) {
-      SOperatorInfo* p[2] = {0};
+      SOperatorInfo** p = calloc(px->numOfTables, POINTER_BYTES);
       p[0] = pSourceOperator;
 
-      SSchema* pSchema1 = tscGetTableSchema(px->pTableMetaInfo[1]->pTableMeta);
-      numOfCol1 = px->pTableMetaInfo[1]->pTableMeta->tableInfo.numOfColumns;
-
-      SOperatorInfo* pSourceOperator1 = createDummyInputOperator((char*)pRes[1], pSchema1, numOfCol1);
-      p[1] = pSourceOperator1;
-
-      int32_t num = pSourceOperator->numOfOutput + pSourceOperator1->numOfOutput;
+      int32_t num = taosArrayGetSize(px->colList);
       schema = calloc(num, sizeof(SSchema));
+      memcpy(schema, pSchema, numOfCol1*sizeof(SSchema));
 
-      memcpy(&schema[0], pSchema, pSourceOperator->numOfOutput * sizeof(SSchema));
+      int32_t offset = pSourceOperator->numOfOutput;
+
+      for(int32_t i = 1; i < px->numOfTables; ++i) {
+        SSchema* pSchema1 = tscGetTableSchema(px->pTableMetaInfo[i]->pTableMeta);
+        int32_t n = px->pTableMetaInfo[i]->pTableMeta->tableInfo.numOfColumns;
+
+        p[i] = createDummyInputOperator(pSqlObjList[i], pSchema1, n);
+
+        memcpy(&schema[offset], pSchema1, n * sizeof(SSchema));
+        offset += n;
+      }
 
-      memcpy(&schema[pSourceOperator->numOfOutput], pSchema1, pSourceOperator1->numOfOutput * sizeof(SSchema));
       pSourceOperator = createJoinOperator(p, px->numOfTables, schema, num);
     }
 
@@ -917,6 +1026,7 @@ void handleDownstreamOperator(SSqlRes** pRes, int32_t numOfUpstream, SQueryInfo*
 
     px->pQInfo = createQInfoFromQueryNode(px, exprInfo, &tableGroupInfo, pSourceOperator, NULL, NULL, MASTER_SCAN);
     tfree(pColumnInfo);
+    tfree(schema);
   }
 
   uint64_t qId = 0;
@@ -1259,7 +1369,7 @@ int32_t tscCopyDataBlockToPayload(SSqlObj* pSql, STableDataBlocks* pDataBlock) {
   return TSDB_CODE_SUCCESS;
 }
 
-SQueryInfo* tscGetActiveQueryInfo(SSqlCmd* pCmd) {
+SQueryInfo* tscGetQueryInfo(SSqlCmd* pCmd) {
   return pCmd->active;
 }
 
@@ -2897,7 +3007,7 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
     return NULL;
   }
 
-  SQueryInfo* pQueryInfo = tscGetActiveQueryInfo(pCmd);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
   STableMetaInfo* pTableMetaInfo = pQueryInfo->pTableMetaInfo[tableIndex];
 
   pNew->pTscObj   = pSql->pTscObj;
@@ -3093,29 +3203,15 @@ void doExecuteQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
   }
 }
 
-static void doRetrieveSubqueryData(SSchedMsg *pMsg) {
+void doRetrieveSubqueryData(SSchedMsg *pMsg) {
   SSqlObj* pSql = (SSqlObj*)taosAcquireRef(tscObjRef, (int64_t)pMsg->ahandle);
   if (pSql == NULL || pSql->signature != pSql) {
     tscDebug("%p SqlObj is freed, not add into queue async res", pMsg->ahandle);
     return;
   }
 
-  int32_t numOfRows = 0;
-  for(int32_t i = 0; i < pSql->subState.numOfSub; ++i) {
-    SSqlObj*    pSub = pSql->pSubs[i];
-    /*TAOS_ROW row = */taos_fetch_row(pSub);
-//    SQueryInfo* pQueryInfo = tscGetQueryInfo(&pSub->cmd);
-//    int32_t rows = taos_fetch_block(pSub, &row);
-    if (numOfRows == 0) {
-      numOfRows = pSub->res.numOfRows;
-    }
-  }
-
-  if (numOfRows > 0) {
-    SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
-    SSqlRes* list[2] = {&pSql->pSubs[0]->res, &pSql->pSubs[1]->res};
-    handleDownstreamOperator(list, 2, pQueryInfo, &pSql->res);
-  }
+  SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
+  handleDownstreamOperator(pSql->pSubs, pSql->subState.numOfSub, pQueryInfo, &pSql->res);
 
   pSql->res.qId = -1;
   if (pSql->res.code == TSDB_CODE_SUCCESS) {
@@ -3133,7 +3229,7 @@ static void tscSubqueryRetrieveCallback(void* param, TAOS_RES* tres, int code) {
   SSqlObj* pSql = tres;
 
   if (!subAndCheckDone(pSql, pParentSql, ps->subqueryIndex)) {
-    tscDebug("0x%"PRIx64" sub:0x%"PRIx64" orderOfSub:%d freed, not all subquery finished", pParentSql->self, pSql->self, ps->subqueryIndex);
+    tscDebug("0x%"PRIx64" sub:0x%"PRIx64" orderOfSub:%d completed, not all subquery finished", pParentSql->self, pSql->self, ps->subqueryIndex);
     return;
   }
 
@@ -4047,10 +4143,6 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
       tscExprAssign(&pQueryAttr->pExpr2[i], p);
     }
   }
-//  int32_t code = createProjectionExpr(pQueryInfo, pTableMetaInfo, &pQueryAttr->pExpr2, &pQueryAttr->numOfExpr2);
-//  if (code != TSDB_CODE_SUCCESS) {
-//    return code;
-//  }
 
   // tag column info
   int32_t code = createTagColumnInfo(pQueryAttr, pQueryInfo, pTableMetaInfo);
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 6c92293bfd..37cf2ec7e2 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -4858,7 +4858,7 @@ static SSDataBlock* doArithmeticOperation(void* param, bool* newgroup) {
     }
 
     pRes->info.rows = getNumOfResult(pRuntimeEnv, pInfo->pCtx, pOperator->numOfOutput);
-    if (pRes->info.rows >= pRuntimeEnv->resultInfo.threshold) {
+    if (pRes->info.rows >= 1000/*pRuntimeEnv->resultInfo.threshold*/) {
       break;
     }
   }

From cc50dcec6407e798270a7f12cbcd016ac8a24cf2 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Thu, 20 May 2021 10:36:59 +0800
Subject: [PATCH 043/128] update

---
 src/tsdb/src/tsdbRead.c | 281 ++++++++++++++++++++++------------------
 1 file changed, 154 insertions(+), 127 deletions(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index b3460ac3b2..a326bd07fc 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -62,12 +62,6 @@ typedef struct SLoadCompBlockInfo {
   int32_t fileId;
 } SLoadCompBlockInfo;
 
-typedef struct SCacheLastColInfo {
-  int16_t  size;
-  int16_t  num;
-  int16_t  fetchIdx;
-  int16_t *idx;
-} SCacheLastColInfo;
 
 typedef struct STableCheckInfo {
   STableId      tableId;
@@ -75,7 +69,6 @@ typedef struct STableCheckInfo {
   STable*       pTableObj;
   SBlockInfo*   pCompInfo;
   int32_t       compSize;
-  SCacheLastColInfo cacheLast;  // cache last column chosen
   int32_t       numOfBlocks:29; // number of qualified data blocks not the original blocks
   int8_t        chosen:2;       // indicate which iterator should move forward
   bool          initBuf;        // whether to initialize the in-memory skip list iterator or not
@@ -101,6 +94,12 @@ typedef struct SIOCostSummary {
   int64_t checkForNextTime;
 } SIOCostSummary;
 
+
+typedef struct SCacheLastColInfo {
+  int16_t  i;
+  int16_t  j;
+} SCacheLastColInfo;
+
 typedef struct STsdbQueryHandle {
   STsdbRepo*     pTsdb;
   SQueryFilePos  cur;              // current position
@@ -126,6 +125,7 @@ typedef struct STsdbQueryHandle {
   SReadH         rhelper;
   STableBlockInfo* pDataBlockInfo;
 
+  SCacheLastColInfo lastCols;
   SDataCols     *pDataCols;        // in order to hold current file data block
   int32_t        allocSize;        // allocated data block size
   SMemRef       *pMemRef;
@@ -546,98 +546,16 @@ TsdbQueryHandleT tsdbQueryLastRow(STsdbRepo *tsdb, STsdbQueryCond *pCond, STable
 }
 
 
-
-STimeWindow updateCacheLastForEachGroup(STableGroupInfo *groupList) {
-  STimeWindow window = {INT64_MAX, INT64_MIN};
-
-  int32_t totalNumOfTable = 0;
-
-  // NOTE: starts from the buffer in case of descending timestamp order check data blocks
-  size_t numOfGroups = taosArrayGetSize(groupList->pGroupList);
-  for(int32_t j = 0; j < numOfGroups; ++j) {
-    SArray* pGroup = taosArrayGetP(groupList->pGroupList, j);
-    TSKEY   key = TSKEY_INITIAL_VAL;
-
-    STableKeyInfo keyInfo = {0};
-
-    size_t numOfTables = taosArrayGetSize(pGroup);
-    for(int32_t i = 0; i < numOfTables; ++i) {
-      STableKeyInfo* pInfo = (STableKeyInfo*) taosArrayGet(pGroup, i);
-
-      // if the lastKey equals to INT64_MIN, there is no data in this table
-      TSKEY lastKey = ((STable*)(pInfo->pTable))->lastKey;
-      if (key < lastKey) {
-        key = lastKey;
-
-        keyInfo.pTable  = pInfo->pTable;
-        keyInfo.lastKey = key;
-        pInfo->lastKey  = key;
-
-        if (key < window.skey) {
-          window.skey = key;
-        }
-
-        if (key > window.ekey) {
-          window.ekey = key;
-        }
-      }
-    }
-
-    // clear current group, unref unused table
-    for (int32_t i = 0; i < numOfTables; ++i) {
-      STableKeyInfo* pInfo = (STableKeyInfo*)taosArrayGet(pGroup, i);
-
-      // keyInfo.pTable may be NULL here.
-      if (pInfo->pTable != keyInfo.pTable) {
-        tsdbUnRefTable(pInfo->pTable);
-      }
-    }
-
-    taosArrayClear(pGroup);
-
-    // more than one table in each group, only one table left for each group
-    if (keyInfo.pTable != NULL) {
-      totalNumOfTable++;
-      taosArrayPush(pGroup, &keyInfo);
-    } else {
-      taosArrayDestroy(pGroup);
-
-      taosArrayRemove(groupList->pGroupList, j);
-      numOfGroups -= 1;
-      j -= 1;
-    }
-  }
-
-  // window does not being updated, so set the original
-  if (window.skey == INT64_MAX && window.ekey == INT64_MIN) {
-    window = TSWINDOW_INITIALIZER;
-    assert(totalNumOfTable == 0 && taosArrayGetSize(groupList->pGroupList) == 0);
-  }
-
-  groupList->numOfTables = totalNumOfTable;
-  return window;
-}
-
-
 TsdbQueryHandleT tsdbQueryCacheLast(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId, SMemRef* pMemRef) {
-  pCond->twindow = updateCacheLastForEachGroup(groupList);
-
-  // no qualified table
-  if (groupList->numOfTables == 0) {
-    return NULL;
-  }
-
   STsdbQueryHandle *pQueryHandle = (STsdbQueryHandle*) tsdbQueryTables(tsdb, pCond, groupList, qId, pMemRef);
-  int32_t code = checkForCachedLastRow(pQueryHandle, groupList);
+  int32_t code = checkForCachedLast(pQueryHandle, groupList);
   if (code != TSDB_CODE_SUCCESS) { // set the numOfTables to be 0
     terrno = code;
     return NULL;
   }
 
   assert(pCond->order == TSDB_ORDER_ASC && pCond->twindow.skey <= pCond->twindow.ekey);
-  if (pQueryHandle->cachelastrow == 2) {
-    pQueryHandle->type = TSDB_QUERY_TYPE_LAST;
-  }
+  pQueryHandle->type = TSDB_QUERY_TYPE_LAST;
   
   return pQueryHandle;
 }
@@ -2572,6 +2490,115 @@ static bool loadCachedLastRow(STsdbQueryHandle* pQueryHandle) {
 }
 
 
+static int32_t copyColsFromCacheMem(STsdbQueryHandle* pQueryHandle, int32_t capacity, int32_t numOfRows, STable* pTable) {
+  char* pData = NULL;
+
+  STSchema* pSchema = tsdbGetTableSchema(pTable);
+  int32_t numOfCols = schemaNCols(pSchema);
+  int32_t tgNumOfCols = QH_GET_NUM_OF_COLS(pQueryHandle);
+
+  assert(numOfCols == pTable->restoreColumnNum);
+  assert(pTable->lastCols != NULL);
+  
+  int32_t i = pQueryHandle->lastCols.i, j = pQueryHandle->lastCols.j;
+  while(i < tgNumOfCols && j < numOfCols) {
+    SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, i);
+    if (pTable->lastCols[j].colId < pColInfo->info.colId) {
+      j++;
+      continue;
+    } else if (pTable->lastCols[j].colId > pColInfo->info.colId) {
+      i++;
+      continue;
+    }
+
+    if (ASCENDING_TRAVERSE(pQueryHandle->order)) {
+      pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;
+    } else {
+      pData = (char*)pColInfo->pData + (capacity - numOfRows - 1) * pColInfo->info.bytes;
+    }
+
+    if (pTable->lastCols[j].bytes > 0) {
+      void* value = pTable->lastCols[j].pData;
+      switch (pColInfo->info.type) {
+        case TSDB_DATA_TYPE_BINARY:
+        case TSDB_DATA_TYPE_NCHAR:
+          memcpy(pData, value, varDataTLen(value));
+          break;
+        case TSDB_DATA_TYPE_NULL:
+        case TSDB_DATA_TYPE_BOOL:
+        case TSDB_DATA_TYPE_TINYINT:
+        case TSDB_DATA_TYPE_UTINYINT:  
+          *(uint8_t *)pData = *(uint8_t *)value;
+          break;
+        case TSDB_DATA_TYPE_SMALLINT:
+        case TSDB_DATA_TYPE_USMALLINT:
+          *(uint16_t *)pData = *(uint16_t *)value;
+          break;
+        case TSDB_DATA_TYPE_INT:
+        case TSDB_DATA_TYPE_UINT:
+          *(uint32_t *)pData = *(uint32_t *)value;
+          break;
+        case TSDB_DATA_TYPE_BIGINT:
+        case TSDB_DATA_TYPE_UBIGINT:
+          *(uint64_t *)pData = *(uint64_t *)value;
+          break;
+        case TSDB_DATA_TYPE_FLOAT:
+          SET_FLOAT_PTR(pData, value);
+          break;
+        case TSDB_DATA_TYPE_DOUBLE:
+          SET_DOUBLE_PTR(pData, value);
+          break;
+        case TSDB_DATA_TYPE_TIMESTAMP:
+          if (pColInfo->info.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
+            *(TSKEY *)pData = tdGetKey(*(TKEY *)value);
+          } else {
+            *(TSKEY *)pData = *(TSKEY *)value;
+          }
+          break;
+        default:
+          memcpy(pData, value, pColInfo->info.bytes);
+      }
+
+      for (int32_t n = 0; n < tgNumOfCols; ++n) {
+        if (n == i) {
+          continue;
+        }
+        
+        SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, i);
+        if (pColInfo->info.type == TSDB_DATA_TYPE_BINARY || pColInfo->info.type == TSDB_DATA_TYPE_NCHAR) {
+          setVardataNull(pData, pColInfo->info.type);
+        } else {
+          setNull(pData, pColInfo->info.type, pColInfo->info.bytes);
+        }
+      }
+
+      ++i;
+      ++j;
+
+      if (i >= tgNumOfCols || j >= numOfCols) {
+        pQueryHandle->lastCols.i = 0;
+        pQueryHandle->lastCols.j = 0;
+        pQueryHandle->activeIndex++;
+      } else {
+        pQueryHandle->lastCols.i = i;
+        pQueryHandle->lastCols.j = j;
+      }
+
+      return 1;
+    } 
+
+    i++;
+    j++;
+  }
+
+  pQueryHandle->lastCols.i = 0;
+  pQueryHandle->lastCols.j = 0;
+  pQueryHandle->activeIndex++;
+
+  return 0;
+}
+
+
 static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
   // the last row is cached in buffer, return it directly.
   // here note that the pQueryHandle->window must be the TS_INITIALIZER
@@ -2581,42 +2608,15 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
 
   SQueryFilePos* cur = &pQueryHandle->cur;
 
-  SDataRow pRow = NULL;
   TSKEY    key  = TSKEY_INITIAL_VAL;
   int32_t  step = ASCENDING_TRAVERSE(pQueryHandle->order)? 1:-1;
 
-  if (pQueryHandle->activeIndex < 0) {
-    updateCacheLastForEachGroup(pQueryHandle);
-  }
-
-  if (pQueryHandle->activeIndex < numOfTables) {
+  while (pQueryHandle->activeIndex < numOfTables) {
     STableCheckInfo* pCheckInfo = taosArrayGet(pQueryHandle->pTableCheckInfo, pQueryHandle->activeIndex);
     
-    if (pQueryHandle->cachelastrow == 1) {
-      int32_t ret = tsdbGetCachedLastRow(pCheckInfo->pTableObj, &pRow, &key);
-      if (ret != TSDB_CODE_SUCCESS) {
-        return false;
-      }
-
-      copyOneRowFromMem(pQueryHandle, pQueryHandle->outputCapacity, 0, pRow, numOfCols, pCheckInfo->pTableObj, NULL);
-      tfree(pRow);
-
-      // update the last key value
-      pCheckInfo->lastKey = key + step;
-
-      cur->rows     = 1;  // only one row
-      cur->lastKey  = key + step;
-      cur->mixBlock = true;
-      cur->win.skey = key;
-      cur->win.ekey = key;
-    } else if (pQueryHandle->cachelastrow == 2) {
-
-    } else {
-      tsdbError("invalid cachelastrow:%d", pQueryHandle->cachelastrow);
-      return false;
+    if (copyColsFromCacheMem(pQueryHandle, pQueryHandle->outputCapacity, 0, numOfCols, pCheckInfo->pTableObj, NULL)) {
+      return true;
     }
-
-    return true;
   }
 
   return false;
@@ -2662,7 +2662,7 @@ bool tsdbNextDataBlock(TsdbQueryHandleT pHandle) {
   if (pQueryHandle->type == TSDB_QUERY_TYPE_LAST) {
     if (pQueryHandle->cachelastrow == 1) {
       return loadCachedLastRow(pQueryHandle);
-    } if (pQueryHandle->cachelastrow == 2) else {
+    } else if (pQueryHandle->cachelastrow == 2) {
       return loadCachedLast(pQueryHandle);
     }
   }
@@ -2875,17 +2875,14 @@ int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *g
 
   int32_t code = 0;
   
-  if (((STable*)pInfo->pTable)->lastRow == 1) {
+  if (((STable*)pInfo->pTable)->lastRow) {
     code = tsdbGetCachedLastRow(pInfo->pTable, &pRow, &key);
     if (code != TSDB_CODE_SUCCESS) {
       pQueryHandle->cachelastrow = 0;
     } else {
-      pQueryHandle->cachelastrow = ((STable*)pInfo->pTable)->lastRow;
+      pQueryHandle->cachelastrow = 1;
     }
-  } else if (((STable*)pInfo->pTable)->lastCols && ((STable*)pInfo->pTable)->lastColNum > 0 && ((STable*)pInfo->pTable)->lastRow == 2){
-    pQueryHandle->cachelastrow = ((STable*)pInfo->pTable)->lastRow;
   }
-  
 
   // update the tsdb query time range
   if (pQueryHandle->cachelastrow) {
@@ -2898,6 +2895,36 @@ int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *g
   return code;
 }
 
+int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle, STableGroupInfo *groupList) {
+  assert(pQueryHandle != NULL && groupList != NULL);
+
+  SDataRow pRow = NULL;
+  TSKEY    key = TSKEY_INITIAL_VAL;
+
+  SArray* group = taosArrayGetP(groupList->pGroupList, 0);
+  assert(group != NULL);
+
+  STableKeyInfo* pInfo = (STableKeyInfo*)taosArrayGet(group, 0);
+
+  int32_t code = 0;
+  
+  if (((STable*)pInfo->pTable)->lastCols && ((STable*)pInfo->pTable)->lastColNum > 0){
+    pQueryHandle->cachelastrow = 2;
+  }
+  
+
+  // update the tsdb query time range
+  if (pQueryHandle->cachelastrow) {
+    pQueryHandle->window      = TSWINDOW_INITIALIZER;
+    pQueryHandle->checkFiles  = false;
+    pQueryHandle->activeIndex = 0;  // start from -1
+  }
+
+  tfree(pRow);
+  return code;
+}
+
+
 STimeWindow updateLastrowForEachGroup(STableGroupInfo *groupList) {
   STimeWindow window = {INT64_MAX, INT64_MIN};
 

From e9db267bc547ac73efbb08f14f19a422ed13f1ad Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Thu, 20 May 2021 11:49:24 +0800
Subject: [PATCH 044/128] [td-225]fix memory leak.

---
 src/client/src/tscSQLParser.c | 69 +++++++++++++++++++++++------------
 src/client/src/tscUtil.c      | 37 ++++++++-----------
 2 files changed, 60 insertions(+), 46 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 675ce27de2..212ccc9747 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -7137,39 +7137,46 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     return TSDB_CODE_SUCCESS;
   }
 
-  pCmd->pTableMetaMap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY),
-      false, HASH_NO_LOCK);
+  int32_t code = TSDB_CODE_SUCCESS;
 
-  SArray* tableNameList = taosArrayInit(4, sizeof(SName));
+  SArray* tableNameList = NULL;
+  SArray* pVgroupList   = NULL;
+  SArray* plist         = NULL;
 
+  pCmd->pTableMetaMap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
+
+  tableNameList = taosArrayInit(4, sizeof(SName));
   int32_t size = taosArrayGetSize(pInfo->list);
   for (int32_t i = 0; i < size; ++i) {
     SSqlNode* pSqlNode = taosArrayGetP(pInfo->list, i);
 
     // load the table meta in the from clause
     if (pSqlNode->from->type == SQL_NODE_FROM_TABLELIST) {
-      int32_t code = getTableNameFromSqlNode(pSqlNode, tableNameList, tscGetErrorMsgPayload(pCmd), pSql);
+      code = getTableNameFromSqlNode(pSqlNode, tableNameList, tscGetErrorMsgPayload(pCmd), pSql);
       if (code != TSDB_CODE_SUCCESS) {
-        return code;
+        goto _end;
       }
     } else {
-      int32_t code = getTableNameFromSubquery(pSqlNode, tableNameList, tscGetErrorMsgPayload(pCmd), pSql);
+      code = getTableNameFromSubquery(pSqlNode, tableNameList, tscGetErrorMsgPayload(pCmd), pSql);
       if (code != TSDB_CODE_SUCCESS) {
-        return code;
+        goto _end;
       }
     }
   }
 
   uint32_t maxSize = tscGetTableMetaMaxSize();
-  char name[TSDB_TABLE_FNAME_LEN] = {0};
+  char     name[TSDB_TABLE_FNAME_LEN] = {0};
 
   int32_t numOfTables = taosArrayGetSize(tableNameList);
-  STableMeta* pTableMeta = calloc(1, maxSize);
 
-  SArray* plist = taosArrayInit(4, POINTER_BYTES);
-  SArray* pVgroupList = taosArrayInit(4, POINTER_BYTES);
+  char buf[80 * 1024] = {0};
+  assert(maxSize < 80 * 1024);
+  STableMeta* pTableMeta = (STableMeta*)buf;
 
-  for(int32_t i = 0; i < numOfTables; ++i) {
+  plist = taosArrayInit(4, POINTER_BYTES);
+  pVgroupList = taosArrayInit(4, POINTER_BYTES);
+
+  for (int32_t i = 0; i < numOfTables; ++i) {
     SName* pname = taosArrayGet(tableNameList, i);
     tNameExtractFullName(pname, name);
 
@@ -7179,8 +7186,12 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
     if (pTableMeta->id.uid > 0) {
       if (pTableMeta->tableType == TSDB_CHILD_TABLE) {
-        int32_t code = tscCreateTableMetaFromCChildMeta(pTableMeta, name);
-        if (code != TSDB_CODE_SUCCESS) { // add to retrieve list
+        code = tscCreateTableMetaFromCChildMeta(pTableMeta, name);
+
+        // create the child table meta from super table failed, try load it from mnode
+        if (code != TSDB_CODE_SUCCESS) {
+          char* t = strdup(name);
+          taosArrayPush(plist, &t);
           continue;
         }
       } else if (pTableMeta->tableType == TSDB_SUPER_TABLE) {
@@ -7191,27 +7202,37 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       }
 
       STableMeta* pMeta = tscTableMetaDup(pTableMeta);
-      STableMetaVgroupInfo p = {.pTableMeta = pMeta,};
+
+      STableMetaVgroupInfo p = { .pTableMeta = pMeta };
 
       const char* px = tNameGetTableName(pname);
       taosHashPut(pCmd->pTableMetaMap, px, strlen(px), &p, sizeof(STableMetaVgroupInfo));
-    } else {// add to the retrieve table meta array list.
+    } else {  // add to the retrieve table meta array list.
       char* t = strdup(name);
       taosArrayPush(plist, &t);
     }
   }
 
-  tfree(pTableMeta);
-
   // load the table meta for a given table name list
-  if (taosArrayGetSize(plist) > 0) {
-    int32_t code = getMultiTableMetaFromMnode(pSql, plist, pVgroupList);
-    taosArrayDestroyEx(plist, freeElem);
-
-    return code;
+  if (taosArrayGetSize(plist) > 0 || taosArrayGetSize(pVgroupList) > 0) {
+    code = getMultiTableMetaFromMnode(pSql, plist, pVgroupList);
   }
 
-  return TSDB_CODE_SUCCESS;
+_end:
+
+  if (plist != NULL) {
+    taosArrayDestroyEx(plist, freeElem);
+  }
+
+  if (pVgroupList != NULL) {
+    taosArrayDestroy(pVgroupList);
+  }
+
+  if (tableNameList != NULL) {
+    taosArrayDestroy(tableNameList);
+  }
+
+  return code;
 }
 
 static int32_t doLoadAllTableMeta(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNode* pSqlNode, int32_t numOfTables) {
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index b73e2e634b..1d18d7f1e2 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -1009,6 +1009,7 @@ void handleDownstreamOperator(SSqlObj** pSqlObjList, int32_t numOfUpstream, SQue
       }
 
       pSourceOperator = createJoinOperator(p, px->numOfTables, schema, num);
+      tfree(p);
     }
 
     SExprInfo* exprInfo = NULL;
@@ -1027,6 +1028,7 @@ void handleDownstreamOperator(SSqlObj** pSqlObjList, int32_t numOfUpstream, SQue
     px->pQInfo = createQInfoFromQueryNode(px, exprInfo, &tableGroupInfo, pSourceOperator, NULL, NULL, MASTER_SCAN);
     tfree(pColumnInfo);
     tfree(schema);
+    tfree(exprInfo);
   }
 
   uint64_t qId = 0;
@@ -3228,8 +3230,15 @@ static void tscSubqueryRetrieveCallback(void* param, TAOS_RES* tres, int code) {
   SSqlObj* pParentSql = ps->pParentSql;
   SSqlObj* pSql = tres;
 
-  if (!subAndCheckDone(pSql, pParentSql, ps->subqueryIndex)) {
-    tscDebug("0x%"PRIx64" sub:0x%"PRIx64" orderOfSub:%d completed, not all subquery finished", pParentSql->self, pSql->self, ps->subqueryIndex);
+  int32_t index = ps->subqueryIndex;
+  bool ret = subAndCheckDone(pSql, pParentSql, index);
+
+  // TODO refactor
+  tfree(ps);
+  pSql->param = NULL;
+
+  if (!ret) {
+    tscDebug("0x%"PRIx64" sub:0x%"PRIx64" orderOfSub:%d completed, not all subquery finished", pParentSql->self, pSql->self, index);
     return;
   }
 
@@ -3241,28 +3250,9 @@ static void tscSubqueryRetrieveCallback(void* param, TAOS_RES* tres, int code) {
   schedMsg.thandle = (void *)1;
   schedMsg.msg = 0;
   taosScheduleTask(tscQhandle, &schedMsg);
-
-  // merge all subquery result
-//  SSqlCmd* pCmd = &pSql->cmd;
-//  SSqlRes* pRes = &pSql->res;
-
-  // add it to the message queue
-
-//  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
-//  /*TAOS_ROW* pRow = */taos_fetch_row(pSql);
-//  if (pSql->res.numOfRows > 0) {
-//    handleDownstreamOperator(pRes, pQueryInfo, &pParentSql->res);
-//  }
-//
-//  code = pParentSql->res.code;
-//  pParentSql->res.qId = -1;
-//  if (pParentSql->res.code == TSDB_CODE_SUCCESS) {
-//    (*pParentSql->fp)(pParentSql->param, pParentSql, pParentSql->res.numOfRows);
-//  } else {
-//    tscAsyncResultOnError(pParentSql);
-//  }
 }
 
+// todo handle the failure
 static void tscSubqueryCompleteCallback(void* param, TAOS_RES* tres, int code) {
   taos_fetch_rows_a(tres, tscSubqueryRetrieveCallback, param);
 }
@@ -3280,6 +3270,7 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
 
   if (taosArrayGetSize(pQueryInfo->pUpstream) > 0) {  // nest query. do execute it firstly
     pSql->subState.numOfSub = taosArrayGetSize(pQueryInfo->pUpstream);
+
     pSql->pSubs = calloc(pSql->subState.numOfSub, POINTER_BYTES);
     pSql->subState.states = calloc(pSql->subState.numOfSub, sizeof(int8_t));
 
@@ -3289,6 +3280,7 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
       pSql->cmd.active = pSub;
       pSql->cmd.command = TSDB_SQL_SELECT;
 
+      // TODO handle memory failure
       SSqlObj* pNew = (SSqlObj*)calloc(1, sizeof(SSqlObj));
       if (pNew == NULL) {
         terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -3321,6 +3313,7 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
       // create sub query to handle the sub query.
       executeQuery(pNew, pSub);
     }
+
     // merge sub query result and generate final results
     return;
   }

From 61b2473bf927f16d31b319e309fc904ca1e6f086 Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Thu, 20 May 2021 13:35:06 +0800
Subject: [PATCH 045/128] [TD-4034]fix Data column ts type

---
 src/common/inc/tdataformat.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/common/inc/tdataformat.h b/src/common/inc/tdataformat.h
index fcae7a415f..9bb997ddcc 100644
--- a/src/common/inc/tdataformat.h
+++ b/src/common/inc/tdataformat.h
@@ -234,7 +234,7 @@ typedef struct SDataCol {
   int             len;        // column data length
   VarDataOffsetT *dataOff;    // For binary and nchar data, the offset in the data column
   void *          pData;      // Actual data pointer
-  TSKEY           ts;         // only used in last NULL column
+  TKEY            ts;         // only used in last NULL column
 } SDataCol;
 
 static FORCE_INLINE void dataColReset(SDataCol *pDataCol) { pDataCol->len = 0; }

From 3500811178b31c263db6e68043bcaf4beb271969 Mon Sep 17 00:00:00 2001
From: tickduan <417921451@qq.com>
Date: Thu, 20 May 2021 14:23:01 +0800
Subject: [PATCH 046/128] fix memory leak when calloc sqlstr error.

---
 src/client/src/tscStream.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c
index 13e311a0b3..f0f87f26db 100644
--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@@ -623,6 +623,7 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p
   if (pSql->sqlstr == NULL) {
     tscError("0x%"PRIx64" failed to malloc sql string buffer", pSql->self);
     tscFreeSqlObj(pSql);
+    free(pStream);
     return NULL;
   }
 

From cf8be044de5f3ed4b0a6733183700beb3c7b7903 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Thu, 20 May 2021 14:41:21 +0800
Subject: [PATCH 047/128] fix bug

---
 src/inc/taosdef.h         |   2 +
 src/inc/tsdb.h            |   4 +
 src/query/src/qExecutor.c |   4 +-
 src/tsdb/src/tsdbRead.c   | 238 ++++++++++++++++++--------------------
 4 files changed, 119 insertions(+), 129 deletions(-)

diff --git a/src/inc/taosdef.h b/src/inc/taosdef.h
index 2882faf7be..1c63a9a05d 100644
--- a/src/inc/taosdef.h
+++ b/src/inc/taosdef.h
@@ -33,6 +33,8 @@ extern "C" {
 #endif
 
 #define TSWINDOW_INITIALIZER ((STimeWindow) {INT64_MIN, INT64_MAX})
+#define TSWINDOW_DESC_INITIALIZER ((STimeWindow) {INT64_MAX, INT64_MIN})
+
 #define TSKEY_INITIAL_VAL    INT64_MIN
 
 // Bytes for each type.
diff --git a/src/inc/tsdb.h b/src/inc/tsdb.h
index 7c28d3e485..468c5ab271 100644
--- a/src/inc/tsdb.h
+++ b/src/inc/tsdb.h
@@ -265,6 +265,10 @@ TsdbQueryHandleT *tsdbQueryTables(STsdbRepo *tsdb, STsdbQueryCond *pCond, STable
 TsdbQueryHandleT tsdbQueryLastRow(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *tableInfo, uint64_t qId,
                                   SMemRef *pRef);
 
+
+TsdbQueryHandleT tsdbQueryCacheLast(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId, SMemRef* pMemRef);
+
+
 /**
  * get the queried table object list
  * @param pHandle
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index b48436a617..c2a4c7febe 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -33,6 +33,8 @@
 #define SET_MASTER_SCAN_FLAG(runtime)  ((runtime)->scanFlag = MASTER_SCAN)
 #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}
@@ -1989,7 +1991,7 @@ static bool isCachedLastQuery(SQueryAttr *pQueryAttr) {
     return false;
   }
 
-  if (!TSWINDOW_IS_EQUAL(pQueryAttr->window, TSWINDOW_INITIALIZER)) {
+  if (pQueryAttr->order.order != TSDB_ORDER_DESC || !TSWINDOW_IS_EQUAL(pQueryAttr->window, TSWINDOW_DESC_INITIALIZER)) {
     return false;
   }
 
diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index a326bd07fc..54833e5e78 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -94,12 +94,6 @@ typedef struct SIOCostSummary {
   int64_t checkForNextTime;
 } SIOCostSummary;
 
-
-typedef struct SCacheLastColInfo {
-  int16_t  i;
-  int16_t  j;
-} SCacheLastColInfo;
-
 typedef struct STsdbQueryHandle {
   STsdbRepo*     pTsdb;
   SQueryFilePos  cur;              // current position
@@ -124,8 +118,6 @@ typedef struct STsdbQueryHandle {
   SFSIter        fileIter;
   SReadH         rhelper;
   STableBlockInfo* pDataBlockInfo;
-
-  SCacheLastColInfo lastCols;
   SDataCols     *pDataCols;        // in order to hold current file data block
   int32_t        allocSize;        // allocated data block size
   SMemRef       *pMemRef;
@@ -146,6 +138,7 @@ typedef struct STableGroupSupporter {
 
 static STimeWindow updateLastrowForEachGroup(STableGroupInfo *groupList);
 static int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *groupList);
+static int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle, STableGroupInfo *groupList);
 static int32_t tsdbGetCachedLastRow(STable* pTable, SDataRow* pRes, TSKEY* lastKey);
 
 static void    changeQueryHandleForInterpQuery(TsdbQueryHandleT pHandle);
@@ -554,7 +547,6 @@ TsdbQueryHandleT tsdbQueryCacheLast(STsdbRepo *tsdb, STsdbQueryCond *pCond, STab
     return NULL;
   }
 
-  assert(pCond->order == TSDB_ORDER_ASC && pCond->twindow.skey <= pCond->twindow.ekey);
   pQueryHandle->type = TSDB_QUERY_TYPE_LAST;
   
   return pQueryHandle;
@@ -2490,133 +2482,124 @@ static bool loadCachedLastRow(STsdbQueryHandle* pQueryHandle) {
 }
 
 
-static int32_t copyColsFromCacheMem(STsdbQueryHandle* pQueryHandle, int32_t capacity, int32_t numOfRows, STable* pTable) {
-  char* pData = NULL;
-
-  STSchema* pSchema = tsdbGetTableSchema(pTable);
-  int32_t numOfCols = schemaNCols(pSchema);
-  int32_t tgNumOfCols = QH_GET_NUM_OF_COLS(pQueryHandle);
-
-  assert(numOfCols == pTable->restoreColumnNum);
-  assert(pTable->lastCols != NULL);
-  
-  int32_t i = pQueryHandle->lastCols.i, j = pQueryHandle->lastCols.j;
-  while(i < tgNumOfCols && j < numOfCols) {
-    SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, i);
-    if (pTable->lastCols[j].colId < pColInfo->info.colId) {
-      j++;
-      continue;
-    } else if (pTable->lastCols[j].colId > pColInfo->info.colId) {
-      i++;
-      continue;
-    }
-
-    if (ASCENDING_TRAVERSE(pQueryHandle->order)) {
-      pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;
-    } else {
-      pData = (char*)pColInfo->pData + (capacity - numOfRows - 1) * pColInfo->info.bytes;
-    }
-
-    if (pTable->lastCols[j].bytes > 0) {
-      void* value = pTable->lastCols[j].pData;
-      switch (pColInfo->info.type) {
-        case TSDB_DATA_TYPE_BINARY:
-        case TSDB_DATA_TYPE_NCHAR:
-          memcpy(pData, value, varDataTLen(value));
-          break;
-        case TSDB_DATA_TYPE_NULL:
-        case TSDB_DATA_TYPE_BOOL:
-        case TSDB_DATA_TYPE_TINYINT:
-        case TSDB_DATA_TYPE_UTINYINT:  
-          *(uint8_t *)pData = *(uint8_t *)value;
-          break;
-        case TSDB_DATA_TYPE_SMALLINT:
-        case TSDB_DATA_TYPE_USMALLINT:
-          *(uint16_t *)pData = *(uint16_t *)value;
-          break;
-        case TSDB_DATA_TYPE_INT:
-        case TSDB_DATA_TYPE_UINT:
-          *(uint32_t *)pData = *(uint32_t *)value;
-          break;
-        case TSDB_DATA_TYPE_BIGINT:
-        case TSDB_DATA_TYPE_UBIGINT:
-          *(uint64_t *)pData = *(uint64_t *)value;
-          break;
-        case TSDB_DATA_TYPE_FLOAT:
-          SET_FLOAT_PTR(pData, value);
-          break;
-        case TSDB_DATA_TYPE_DOUBLE:
-          SET_DOUBLE_PTR(pData, value);
-          break;
-        case TSDB_DATA_TYPE_TIMESTAMP:
-          if (pColInfo->info.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
-            *(TSKEY *)pData = tdGetKey(*(TKEY *)value);
-          } else {
-            *(TSKEY *)pData = *(TSKEY *)value;
-          }
-          break;
-        default:
-          memcpy(pData, value, pColInfo->info.bytes);
-      }
-
-      for (int32_t n = 0; n < tgNumOfCols; ++n) {
-        if (n == i) {
-          continue;
-        }
-        
-        SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, i);
-        if (pColInfo->info.type == TSDB_DATA_TYPE_BINARY || pColInfo->info.type == TSDB_DATA_TYPE_NCHAR) {
-          setVardataNull(pData, pColInfo->info.type);
-        } else {
-          setNull(pData, pColInfo->info.type, pColInfo->info.bytes);
-        }
-      }
-
-      ++i;
-      ++j;
-
-      if (i >= tgNumOfCols || j >= numOfCols) {
-        pQueryHandle->lastCols.i = 0;
-        pQueryHandle->lastCols.j = 0;
-        pQueryHandle->activeIndex++;
-      } else {
-        pQueryHandle->lastCols.i = i;
-        pQueryHandle->lastCols.j = j;
-      }
-
-      return 1;
-    } 
-
-    i++;
-    j++;
-  }
-
-  pQueryHandle->lastCols.i = 0;
-  pQueryHandle->lastCols.j = 0;
-  pQueryHandle->activeIndex++;
-
-  return 0;
-}
-
 
 static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
   // the last row is cached in buffer, return it directly.
   // here note that the pQueryHandle->window must be the TS_INITIALIZER
-  int32_t numOfCols  = (int32_t)(QH_GET_NUM_OF_COLS(pQueryHandle));
+  int32_t tgNumOfCols = QH_GET_NUM_OF_COLS(pQueryHandle);
   size_t  numOfTables = taosArrayGetSize(pQueryHandle->pTableCheckInfo);
-  assert(numOfTables > 0 && numOfCols > 0);
-
-  SQueryFilePos* cur = &pQueryHandle->cur;
-
-  TSKEY    key  = TSKEY_INITIAL_VAL;
-  int32_t  step = ASCENDING_TRAVERSE(pQueryHandle->order)? 1:-1;
+  int32_t numOfRows = 0;
+  assert(numOfTables > 0 && tgNumOfCols > 0);
 
   while (pQueryHandle->activeIndex < numOfTables) {
     STableCheckInfo* pCheckInfo = taosArrayGet(pQueryHandle->pTableCheckInfo, pQueryHandle->activeIndex);
+    STable* pTable = pCheckInfo->pTableObj;  
+    char* pData = NULL;
+
+    int32_t numOfCols = pTable->lastColNum;
     
-    if (copyColsFromCacheMem(pQueryHandle, pQueryHandle->outputCapacity, 0, numOfCols, pCheckInfo->pTableObj, NULL)) {
-      return true;
+    if (pTable->lastCols == NULL || pTable->lastColNum <= 0) {
+      tsdbWarn("no last cached for table, uid:%" PRIu64 ",tid:%d", pTable->tableId.uid, pTable->tableId.tid);
+      pQueryHandle->activeIndex++;
+      continue;
     }
+    
+    int32_t i = 0, j = 0;
+    while(i < tgNumOfCols && j < numOfCols) {
+      SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, i);
+      if (pTable->lastCols[j].colId < pColInfo->info.colId) {
+        j++;
+        continue;
+      } else if (pTable->lastCols[j].colId > pColInfo->info.colId) {
+        i++;
+        continue;
+      }
+    
+      if (ASCENDING_TRAVERSE(pQueryHandle->order)) {
+        pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
+      } else {
+        pData = (char*)pColInfo->pData + (pQueryHandle->outputCapacity + numOfRows - 1) * pColInfo->info.bytes;
+      }
+    
+      if (pTable->lastCols[j].bytes > 0) {
+        void* value = pTable->lastCols[j].pData;
+        switch (pColInfo->info.type) {
+          case TSDB_DATA_TYPE_BINARY:
+          case TSDB_DATA_TYPE_NCHAR:
+            memcpy(pData, value, varDataTLen(value));
+            break;
+          case TSDB_DATA_TYPE_NULL:
+          case TSDB_DATA_TYPE_BOOL:
+          case TSDB_DATA_TYPE_TINYINT:
+          case TSDB_DATA_TYPE_UTINYINT:  
+            *(uint8_t *)pData = *(uint8_t *)value;
+            break;
+          case TSDB_DATA_TYPE_SMALLINT:
+          case TSDB_DATA_TYPE_USMALLINT:
+            *(uint16_t *)pData = *(uint16_t *)value;
+            break;
+          case TSDB_DATA_TYPE_INT:
+          case TSDB_DATA_TYPE_UINT:
+            *(uint32_t *)pData = *(uint32_t *)value;
+            break;
+          case TSDB_DATA_TYPE_BIGINT:
+          case TSDB_DATA_TYPE_UBIGINT:
+            *(uint64_t *)pData = *(uint64_t *)value;
+            break;
+          case TSDB_DATA_TYPE_FLOAT:
+            SET_FLOAT_PTR(pData, value);
+            break;
+          case TSDB_DATA_TYPE_DOUBLE:
+            SET_DOUBLE_PTR(pData, value);
+            break;
+          case TSDB_DATA_TYPE_TIMESTAMP:
+            if (pColInfo->info.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
+              *(TSKEY *)pData = tdGetKey(*(TKEY *)value);
+            } else {
+              *(TSKEY *)pData = *(TSKEY *)value;
+            }
+            break;
+          default:
+            memcpy(pData, value, pColInfo->info.bytes);
+        }
+    
+        for (int32_t n = 0; n < tgNumOfCols; ++n) {
+          if (n == i) {
+            continue;
+          }
+
+          SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, i);
+          if (ASCENDING_TRAVERSE(pQueryHandle->order)) {
+            pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
+          } else {
+            pData = (char*)pColInfo->pData + (pQueryHandle->outputCapacity + numOfRows - 1) * pColInfo->info.bytes;
+          }
+
+          if (n == 0) {
+            *(TSKEY *)pData = pTable->lastCols[j].ts;
+            continue;
+          }
+          
+          if (pColInfo->info.type == TSDB_DATA_TYPE_BINARY || pColInfo->info.type == TSDB_DATA_TYPE_NCHAR) {
+            setVardataNull(pData, pColInfo->info.type);
+          } else {
+            setNull(pData, pColInfo->info.type, pColInfo->info.bytes);
+          }
+        }
+
+        numOfRows++;
+        assert(numOfRows < pQueryHandle->outputCapacity);
+      } 
+    
+      i++;
+      j++;
+    }
+
+    pQueryHandle->activeIndex++;
+
+    if (numOfRows > 0) {
+      return true;
+    }    
   }
 
   return false;
@@ -2850,7 +2833,7 @@ int32_t tsdbGetCachedLastRow(STable* pTable, SDataRow* pRes, TSKEY* lastKey) {
   TSDB_RLOCK_TABLE(pTable);
   *lastKey = pTable->lastKey;
 
-  if ((*lastKey) != TSKEY_INITIAL_VAL && pTable->lastRow == 1) {
+  if ((*lastKey) != TSKEY_INITIAL_VAL && pTable->lastRow) {
     *pRes = tdDataRowDup(pTable->lastRow);
     if (*pRes == NULL) {
       TSDB_RUNLOCK_TABLE(pTable);
@@ -2899,7 +2882,6 @@ int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle, STableGroupInfo *grou
   assert(pQueryHandle != NULL && groupList != NULL);
 
   SDataRow pRow = NULL;
-  TSKEY    key = TSKEY_INITIAL_VAL;
 
   SArray* group = taosArrayGetP(groupList->pGroupList, 0);
   assert(group != NULL);

From e51fd4bf77b4aa7d9904adcd53fcc592902d3e58 Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Thu, 20 May 2021 15:32:25 +0800
Subject: [PATCH 048/128] [TD-4034]get latest schema from super table

---
 src/tsdb/src/tsdbMain.c | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index 3241d617b6..29842c0c16 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -616,17 +616,34 @@ static void tsdbStopStream(STsdbRepo *pRepo) {
   }
 }
 
+static STSchema* getTableLatestSchema(STable *pTable) {
+  if (pTable->numOfSchemas > 0) {
+    return pTable->schema[pTable->numOfSchemas - 1];
+  }
+
+  if (pTable->type == TSDB_CHILD_TABLE) {
+    if (pTable->pSuper && pTable->pSuper->numOfSchemas) {
+      tsdbInfo("getTableLatestSchema of table %s from super table", pTable->name->data);
+      return pTable->pSuper->schema[pTable->pSuper->numOfSchemas - 1];
+    }
+  }
+  return NULL;
+}
+
 static int restoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh) {
-  if (pTable->numOfSchemas == 0) {
+  STSchema *pSchema = getTableLatestSchema(pTable);
+  if (pSchema == NULL) {
+    tsdbError("getTableLatestSchema of table %s fail", pTable->name->data);
     return 0;
   }
+
   SBlock* pBlock;
   int numColumns;
   int32_t blockIdx;
   SDataStatis* pBlockStatis = NULL;
   SDataRow row = NULL;
   // restore last column data with last schema
-  STSchema *pSchema = pTable->schema[pTable->numOfSchemas - 1];
+  
   int err = 0;
 
   numColumns = schemaNCols(pSchema);

From 220bc3502a023cb7c8a79a5e640798632e379858 Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Thu, 20 May 2021 15:36:44 +0800
Subject: [PATCH 049/128] [TD-4034]get latest schema from super table

---
 src/tsdb/src/tsdbMain.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index 29842c0c16..8e31ae5022 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -623,7 +623,7 @@ static STSchema* getTableLatestSchema(STable *pTable) {
 
   if (pTable->type == TSDB_CHILD_TABLE) {
     if (pTable->pSuper && pTable->pSuper->numOfSchemas) {
-      tsdbInfo("getTableLatestSchema of table %s from super table", pTable->name->data);
+      tsdbDebug("getTableLatestSchema of table %s from super table %s", pTable->name->data, pTable->pSuper->name->data);
       return pTable->pSuper->schema[pTable->pSuper->numOfSchemas - 1];
     }
   }

From 308639a9e333a083ee693ced95d66dbd0b014c56 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Thu, 20 May 2021 15:37:38 +0800
Subject: [PATCH 050/128] fix bug

---
 src/tsdb/src/tsdbRead.c | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 54833e5e78..cf2ab0cc3f 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -2491,7 +2491,7 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
   int32_t numOfRows = 0;
   assert(numOfTables > 0 && tgNumOfCols > 0);
 
-  while (pQueryHandle->activeIndex < numOfTables) {
+  while (++pQueryHandle->activeIndex < numOfTables) {
     STableCheckInfo* pCheckInfo = taosArrayGet(pQueryHandle->pTableCheckInfo, pQueryHandle->activeIndex);
     STable* pTable = pCheckInfo->pTableObj;  
     char* pData = NULL;
@@ -2500,7 +2500,6 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
     
     if (pTable->lastCols == NULL || pTable->lastColNum <= 0) {
       tsdbWarn("no last cached for table, uid:%" PRIu64 ",tid:%d", pTable->tableId.uid, pTable->tableId.tid);
-      pQueryHandle->activeIndex++;
       continue;
     }
     
@@ -2595,8 +2594,6 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
       j++;
     }
 
-    pQueryHandle->activeIndex++;
-
     if (numOfRows > 0) {
       return true;
     }    
@@ -2899,7 +2896,7 @@ int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle, STableGroupInfo *grou
   if (pQueryHandle->cachelastrow) {
     pQueryHandle->window      = TSWINDOW_INITIALIZER;
     pQueryHandle->checkFiles  = false;
-    pQueryHandle->activeIndex = 0;  // start from -1
+    pQueryHandle->activeIndex = -1;  // start from -1
   }
 
   tfree(pRow);

From fcfd4d29d1df853599f73200cf8a6ddc3c254827 Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Thu, 20 May 2021 16:14:16 +0800
Subject: [PATCH 051/128] [TD-4034]fix Data column ts type

---
 src/common/inc/tdataformat.h | 2 +-
 src/tsdb/src/tsdbMain.c      | 2 +-
 src/tsdb/src/tsdbMemTable.c  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/common/inc/tdataformat.h b/src/common/inc/tdataformat.h
index 9bb997ddcc..fcae7a415f 100644
--- a/src/common/inc/tdataformat.h
+++ b/src/common/inc/tdataformat.h
@@ -234,7 +234,7 @@ typedef struct SDataCol {
   int             len;        // column data length
   VarDataOffsetT *dataOff;    // For binary and nchar data, the offset in the data column
   void *          pData;      // Actual data pointer
-  TKEY            ts;         // only used in last NULL column
+  TSKEY           ts;         // only used in last NULL column
 } SDataCol;
 
 static FORCE_INLINE void dataColReset(SDataCol *pDataCol) { pDataCol->len = 0; }
diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index 8e31ae5022..d593997d3c 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -742,7 +742,7 @@ static int restoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh)
         pDataCol = pReadh->pDCols[0]->cols + 0;
         pCol = schemaColAt(pSchema, 0);
         tdAppendColVal(row, tdGetColDataOfRow(pDataCol, rowId), pCol->type, pCol->bytes, pCol->offset);
-        pLastCol->ts = dataRowTKey(row);        
+        pLastCol->ts = dataRowKey(row);
 
         pTable->maxColumnNum += 1;
 
diff --git a/src/tsdb/src/tsdbMemTable.c b/src/tsdb/src/tsdbMemTable.c
index 900c034a22..156bd29ee1 100644
--- a/src/tsdb/src/tsdbMemTable.c
+++ b/src/tsdb/src/tsdbMemTable.c
@@ -1011,7 +1011,7 @@ static void updateTableLatestColumn(STsdbRepo *pRepo, STable *pTable, SDataRow r
 
     memcpy(pDataCol->pData, value, pDataCol->bytes);
     //tsdbInfo("updateTableLatestColumn vgId:%d cache column %d for %d,%s", REPO_ID(pRepo), j, pDataCol->bytes, (char*)pDataCol->pData);
-    pDataCol->ts = dataRowTKey(row);
+    pDataCol->ts = dataRowKey(row);
   }
 }
 

From 80cd7963cd2389a8dcf857dedffaa129932ce68d Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Thu, 20 May 2021 16:16:58 +0800
Subject: [PATCH 052/128] fix bug

---
 src/tsdb/src/tsdbRead.c | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index cf2ab0cc3f..29d400fd56 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -2490,6 +2490,7 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
   size_t  numOfTables = taosArrayGetSize(pQueryHandle->pTableCheckInfo);
   int32_t numOfRows = 0;
   assert(numOfTables > 0 && tgNumOfCols > 0);
+  SQueryFilePos* cur = &pQueryHandle->cur;
 
   while (++pQueryHandle->activeIndex < numOfTables) {
     STableCheckInfo* pCheckInfo = taosArrayGet(pQueryHandle->pTableCheckInfo, pQueryHandle->activeIndex);
@@ -2517,7 +2518,7 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
       if (ASCENDING_TRAVERSE(pQueryHandle->order)) {
         pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
       } else {
-        pData = (char*)pColInfo->pData + (pQueryHandle->outputCapacity + numOfRows - 1) * pColInfo->info.bytes;
+        pData = (char*)pColInfo->pData + (pQueryHandle->outputCapacity - numOfRows - 1) * pColInfo->info.bytes;
       }
     
       if (pTable->lastCols[j].bytes > 0) {
@@ -2567,11 +2568,11 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
             continue;
           }
 
-          SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, i);
+          SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, n);
           if (ASCENDING_TRAVERSE(pQueryHandle->order)) {
             pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
           } else {
-            pData = (char*)pColInfo->pData + (pQueryHandle->outputCapacity + numOfRows - 1) * pColInfo->info.bytes;
+            pData = (char*)pColInfo->pData + (pQueryHandle->outputCapacity - numOfRows - 1) * pColInfo->info.bytes;
           }
 
           if (n == 0) {
@@ -2595,6 +2596,9 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
     }
 
     if (numOfRows > 0) {
+      cur->rows     = numOfRows;
+      cur->mixBlock = true;
+      
       return true;
     }    
   }

From 2d5c2a5f314e4852c4e1739c17f7b933db1b0f84 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Thu, 20 May 2021 18:19:48 +0800
Subject: [PATCH 053/128] [td-225]fix bugs found by regression test.

---
 src/client/inc/tscUtil.h        |  5 +-
 src/client/src/tscAsync.c       |  2 +-
 src/client/src/tscLocalMerge.c  |  8 +--
 src/client/src/tscParseInsert.c |  2 +-
 src/client/src/tscSQLParser.c   |  5 ++
 src/client/src/tscServer.c      | 52 +++--------------
 src/client/src/tscSubquery.c    | 14 +----
 src/client/src/tscUtil.c        | 98 +++++++++++++++++++++++----------
 8 files changed, 95 insertions(+), 91 deletions(-)

diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index 48b1138072..b09d34cd46 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -166,7 +166,7 @@ void tscFieldInfoUpdateOffset(SQueryInfo* pQueryInfo);
 
 int16_t tscFieldInfoGetOffset(SQueryInfo* pQueryInfo, int32_t index);
 void    tscFieldInfoClear(SFieldInfo* pFieldInfo);
-void    tscFieldInfoCopy(SFieldInfo* pFieldInfo, const SFieldInfo* pSrc);
+void tscFieldInfoCopy(SFieldInfo* pFieldInfo, const SFieldInfo* pSrc, const SArray* pExprList);
 
 static FORCE_INLINE int32_t tscNumOfFields(SQueryInfo* pQueryInfo) { return pQueryInfo->fieldsInfo.numOfOutput; }
 
@@ -192,11 +192,14 @@ SExprInfo* tscExprUpdate(SQueryInfo* pQueryInfo, int32_t index, int16_t function
 size_t     tscNumOfExprs(SQueryInfo* pQueryInfo);
 SExprInfo *tscExprGet(SQueryInfo* pQueryInfo, int32_t index);
 int32_t    tscExprCopy(SArray* dst, const SArray* src, uint64_t uid, bool deepcopy);
+int32_t    tscExprCopyAll(SArray* dst, const SArray* src, bool deepcopy);
 void       tscExprAssign(SExprInfo* dst, const SExprInfo* src);
 void       tscExprDestroy(SArray* pExprInfo);
 
 int32_t createProjectionExpr(SQueryInfo* pQueryInfo, STableMetaInfo* pTableMetaInfo, SExprInfo*** pExpr, int32_t* num);
 
+void clearAllTableMetaInfo(SQueryInfo* pQueryInfo, bool removeMeta);
+
 SColumn* tscColumnClone(const SColumn* src);
 bool tscColumnExists(SArray* pColumnList, int32_t columnIndex, uint64_t uid);
 SColumn* tscColumnListInsert(SArray* pColumnList, int32_t columnIndex, uint64_t uid, SSchema* pSchema);
diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c
index 20a2164149..72432f602c 100644
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -226,7 +226,7 @@ void taos_fetch_rows_a(TAOS_RES *tres, __async_cb_func_t fp, void *param) {
   if (pQueryInfo->pUpstream != NULL && taosArrayGetSize(pQueryInfo->pUpstream) > 0) {
     SSchedMsg schedMsg = {0};
     schedMsg.fp = doRetrieveSubqueryData;
-    schedMsg.ahandle = (void *)pSql->self;
+    schedMsg.ahandle = (void *)pSql;
     schedMsg.thandle = (void *)1;
     schedMsg.msg = 0;
     taosScheduleTask(tscQhandle, &schedMsg);
diff --git a/src/client/src/tscLocalMerge.c b/src/client/src/tscLocalMerge.c
index e1bcf3a792..77a4c7fb46 100644
--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -974,7 +974,7 @@ static SSDataBlock* skipGroupBlock(SOperatorInfo* pOperator, bool* newgroup) {
 
   SSDataBlock* pBlock = NULL;
   if (pInfo->currentGroupOffset == 0) {
-    pBlock = pOperator->upstream[0]->exec(pOperator->upstream, newgroup);
+    pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
     if (pBlock == NULL) {
       setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
       pOperator->status = OP_EXEC_DONE;
@@ -982,7 +982,7 @@ static SSDataBlock* skipGroupBlock(SOperatorInfo* pOperator, bool* newgroup) {
 
     if (*newgroup == false && pInfo->limit.limit > 0 && pInfo->rowsTotal >= pInfo->limit.limit) {
       while ((*newgroup) == false) {  // ignore the remain blocks
-        pBlock = pOperator->upstream[0]->exec(pOperator->upstream, newgroup);
+        pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
         if (pBlock == NULL) {
           setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
           pOperator->status = OP_EXEC_DONE;
@@ -994,7 +994,7 @@ static SSDataBlock* skipGroupBlock(SOperatorInfo* pOperator, bool* newgroup) {
     return pBlock;
   }
 
-    pBlock = pOperator->upstream[0]->exec(pOperator->upstream, newgroup);
+    pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
     if (pBlock == NULL) {
       setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
       pOperator->status = OP_EXEC_DONE;
@@ -1008,7 +1008,7 @@ static SSDataBlock* skipGroupBlock(SOperatorInfo* pOperator, bool* newgroup) {
       }
 
       while ((*newgroup) == false) {
-        pBlock = pOperator->upstream[0]->exec(pOperator->upstream, newgroup);
+        pBlock = pOperator->upstream[0]->exec(pOperator->upstream[0], newgroup);
         if (pBlock == NULL) {
           setQueryStatus(pOperator->pRuntimeEnv, QUERY_COMPLETED);
           pOperator->status = OP_EXEC_DONE;
diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index 195c310be5..3866db6c35 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -803,7 +803,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
     }
 
     STableMetaInfo *pSTableMetaInfo = tscGetMetaInfo(pQueryInfo, STABLE_INDEX);
-    code = tscSetTableFullName(&pTableMetaInfo->name, &sToken, pSql);
+    code = tscSetTableFullName(&pSTableMetaInfo->name, &sToken, pSql);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
     }
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 212ccc9747..aeddbda1d6 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -7149,6 +7149,9 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   int32_t size = taosArrayGetSize(pInfo->list);
   for (int32_t i = 0; i < size; ++i) {
     SSqlNode* pSqlNode = taosArrayGetP(pInfo->list, i);
+    if (pSqlNode->from == NULL) {
+      goto _end;
+    }
 
     // load the table meta in the from clause
     if (pSqlNode->from->type == SQL_NODE_FROM_TABLELIST) {
@@ -7330,6 +7333,7 @@ static int32_t doValidateSubquery(SSqlNode* pSqlNode, int32_t index, SSqlObj* pS
   SSqlNode* p = taosArrayGetP(subInfo->pSubquery, 0);
 
   SQueryInfo* pSub = calloc(1, sizeof(SQueryInfo));
+  printf("-------------queryinfo:%p\n", pSub);
   tscInitQueryInfo(pSub);
 
   int32_t code = validateSqlNode(pSql, p, pSub);
@@ -7408,6 +7412,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
   }
 
   if (pSqlNode->from->type == SQL_NODE_FROM_SUBQUERY) {
+    clearAllTableMetaInfo(pQueryInfo, false);
     pQueryInfo->numOfTables = 0;
 
     // parse the subquery in the first place
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index eb61894061..dbe5c8c8fd 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -1997,6 +1997,10 @@ int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
   rsp += sizeof(SMultiTableMeta);
 
   SSqlObj* pParentSql = (SSqlObj*)taosAcquireRef(tscObjRef, (int64_t)pSql->param);
+  if(pParentSql == NULL) {
+    return pSql->res.code;
+  }
+
   SSqlCmd *pParentCmd = &pParentSql->cmd;
 
   SHashObj *pSet = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
@@ -2006,12 +2010,16 @@ int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
     STableMetaMsg *pMetaMsg = (STableMetaMsg *)pMsg;
     int32_t code = tableMetaMsgConvert(pMetaMsg);
     if (code != TSDB_CODE_SUCCESS) {
+      taosHashCleanup(pSet);
+      taosReleaseRef(tscObjRef, pParentSql->self);
       return code;
     }
 
     STableMeta* pTableMeta = tscCreateTableMetaFromMsg(pMetaMsg);
     if (!tIsValidSchema(pTableMeta->schema, pTableMeta->tableInfo.numOfColumns, pTableMeta->tableInfo.numOfTags)) {
       tscError("0x%"PRIx64" invalid table meta from mnode, name:%s", pSql->self, pMetaMsg->tableFname);
+      taosHashCleanup(pSet);
+      taosReleaseRef(tscObjRef, pParentSql->self);
       return TSDB_CODE_TSC_INVALID_VALUE;
     }
 
@@ -2062,6 +2070,7 @@ int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
   tscDebug("0x%"PRIx64" load multi-tableMeta resp from complete numOfTables:%d", pSql->self, pMultiMeta->numOfTables);
 
   taosHashCleanup(pSet);
+  taosReleaseRef(tscObjRef, pParentSql->self);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -2090,51 +2099,10 @@ int tscProcessSTableVgroupRsp(SSqlObj *pSql) {
 
     int32_t size = 0;
     pInfo->vgroupList = createVgroupInfoFromMsg(pMsg, &size, pSql->self);
- /*   size_t vgroupsz = sizeof(SVgroupInfo) * pVgroupMsg->numOfVgroups + sizeof(SVgroupsInfo);
-    pInfo->vgroupList = calloc(1, vgroupsz);
-    assert(pInfo->vgroupList != NULL);
-
-    pInfo->vgroupList->numOfVgroups = pVgroupMsg->numOfVgroups;
-    if (pInfo->vgroupList->numOfVgroups <= 0) {
-      tscDebug("0x%"PRIx64" empty vgroup info, no corresponding tables for stable", pSql->self);
-    } else {
-      for (int32_t j = 0; j < pInfo->vgroupList->numOfVgroups; ++j) {
-        // just init, no need to lock
-        SVgroupInfo *pVgroup = &pInfo->vgroupList->vgroups[j];
-
-        SVgroupMsg *vmsg = &pVgroupMsg->vgroups[j];
-        vmsg->vgId     = htonl(vmsg->vgId);
-        vmsg->numOfEps = vmsg->numOfEps;
-        for (int32_t k = 0; k < vmsg->numOfEps; ++k) {
-          vmsg->epAddr[k].port = htons(vmsg->epAddr[k].port);
-        }
-
-        SNewVgroupInfo newVi = createNewVgroupInfo(vmsg);
-        pVgroup->numOfEps = newVi.numOfEps;
-        pVgroup->vgId = newVi.vgId;
-        for (int32_t k = 0; k < vmsg->numOfEps; ++k) {
-          pVgroup->epAddr[k].port = newVi.ep[k].port;
-          pVgroup->epAddr[k].fqdn = strndup(newVi.ep[k].fqdn, TSDB_FQDN_LEN);
-        }
-
-        // check if current buffer contains the vgroup info.
-        // If not, add it
-        SNewVgroupInfo existVgroupInfo = {.inUse = -1};
-        taosHashGetClone(tscVgroupMap, &newVi.vgId, sizeof(newVi.vgId), NULL, &existVgroupInfo, sizeof(SNewVgroupInfo));
-
-        if (((existVgroupInfo.inUse >= 0) && !vgroupInfoIdentical(&existVgroupInfo, vmsg)) ||
-            (existVgroupInfo.inUse < 0)) {  // vgroup info exists, compare with it
-          taosHashPut(tscVgroupMap, &newVi.vgId, sizeof(newVi.vgId), &newVi, sizeof(newVi));
-          tscDebug("add new VgroupInfo, vgId:%d, total cached:%d", newVi.vgId, (int32_t) taosHashGetSize(tscVgroupMap));
-        }
-      }
-    }
-*/
     pMsg += size;
   }
 
   taosReleaseRef(tscObjRef, parent->self);
-  
   return pSql->res.code;
 }
 
@@ -2378,8 +2346,6 @@ int tscProcessRetrieveRspFromNode(SSqlObj *pSql) {
     tscSetResRawPtr(pRes, pQueryInfo);
   }
 
-//  handleDownstreamOperator(pRes, pQueryInfo);
-
   if (pSql->pSubscription != NULL) {
     int32_t numOfCols = pQueryInfo->fieldsInfo.numOfOutput;
     
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index 0ca79bc702..5df75d0cd2 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -2894,7 +2894,7 @@ static SSqlObj *tscCreateSTableSubquery(SSqlObj *pSql, SRetrieveSupport *trsuppo
     pQueryInfo->limit.limit = -1;
     pQueryInfo->limit.offset = 0;
 
-    assert(/*pQueryInfo->numOfTables == 1 && pNew->cmd.numOfClause == 1 &&*/ trsupport->subqueryIndex < pSql->subState.numOfSub);
+    assert(trsupport->subqueryIndex < pSql->subState.numOfSub);
     
     // launch subquery for each vnode, so the subquery index equals to the vgroupIndex.
     STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, table_index);
@@ -3577,17 +3577,9 @@ void* createQInfoFromQueryNode(SQueryInfo* pQueryInfo, SExprInfo* pExprs, STable
     }
   }
 
-//  for (int32_t i = 0; i < numOfOutput; ++i) {
-//    SExprInfo* pExprInfo = &pExprs[i];
-//    if (pExprInfo->pExpr != NULL) {
-//      tExprTreeDestroy(pExprInfo->pExpr, NULL);
-//      pExprInfo->pExpr = NULL;
-//    }
-//  }
-//
-//  tfree(pExprs);
-
+  // todo refactor: filter should not be applied here.
   createFilterInfo(pQueryAttr, 0);
+  pQueryAttr->numOfFilterCols = 0;
 
   SArray* pa = NULL;
   if (stage == MASTER_SCAN) {
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 1d18d7f1e2..871b105e91 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -31,7 +31,6 @@
 #include "ttokendef.h"
 
 static void freeQueryInfoImpl(SQueryInfo* pQueryInfo);
-static void clearAllTableMetaInfo(SQueryInfo* pQueryInfo, bool removeMeta);
 
 static void tscStrToLower(char *str, int32_t n) {
   if (str == NULL || n <= 0) { return;}
@@ -716,7 +715,6 @@ SSDataBlock* doGetDataBlock(void* param, bool* newgroup) {
   return pBlock;
 }
 
-static int32_t v = 0;
 SSDataBlock* doDataBlockJoin(void* param, bool* newgroup) {
   SOperatorInfo *pOperator = (SOperatorInfo*) param;
   if (pOperator->status == OP_EXEC_DONE) {
@@ -735,11 +733,6 @@ SSDataBlock* doDataBlockJoin(void* param, bool* newgroup) {
         pStatus->pBlock = pOperator->upstream[i]->exec(pOperator->upstream[i], newgroup);
         pStatus->index = 0;
 
-        if (i == 0 && pStatus->pBlock != NULL) {
-          v += pStatus->pBlock->info.rows;
-          printf("---------------%d\n", v);
-        }
-
         if (pStatus->pBlock == NULL) {
           pOperator->status = OP_EXEC_DONE;
 
@@ -901,6 +894,13 @@ SOperatorInfo* createDummyInputOperator(SSqlObj* pSql, SSchema* pSchema, int32_t
   return pOptr;
 }
 
+static void destroyJoinOperator(void* param, int32_t numOfOutput) {
+  SJoinOperatorInfo* pInfo = (SJoinOperatorInfo*) param;
+  tfree(pInfo->status);
+
+  pInfo->pRes = destroyOutputBuf(pInfo->pRes);
+}
+
 SOperatorInfo* createJoinOperator(SOperatorInfo** pUpstream, int32_t numOfUpstream, SSchema* pSchema, int32_t numOfOutput) {
   SJoinOperatorInfo* pInfo = calloc(1, sizeof(SJoinOperatorInfo));
 
@@ -931,7 +931,7 @@ SOperatorInfo* createJoinOperator(SOperatorInfo** pUpstream, int32_t numOfUpstre
   pOperator->blockingOptr  = false;
   pOperator->info          = pInfo;
   pOperator->exec          = doDataBlockJoin;
-  pOperator->cleanup       = destroyDummyInputOperator;
+  pOperator->cleanup       = destroyJoinOperator;
 
   for(int32_t i = 0; i < numOfUpstream; ++i) {
     appendUpstream(pOperator, pUpstream[i]);
@@ -1075,8 +1075,9 @@ void tscFreeQueryInfo(SSqlCmd* pCmd, bool removeMeta) {
   while(pQueryInfo != NULL) {
     SQueryInfo* p = pQueryInfo->sibling;
 
-    if (taosArrayGetSize(pQueryInfo->pUpstream) > 0) {
-      SQueryInfo* pUp = taosArrayGetP(pQueryInfo->pUpstream, 0);
+    int32_t numOfUpstream = taosArrayGetSize(pQueryInfo->pUpstream);
+    for(int32_t i = 0; i < numOfUpstream; ++i) {
+      SQueryInfo* pUp = taosArrayGetP(pQueryInfo->pUpstream, i);
       freeQueryInfoImpl(pUp);
 
       clearAllTableMetaInfo(pUp, removeMeta);
@@ -1097,11 +1098,11 @@ void tscFreeQueryInfo(SSqlCmd* pCmd, bool removeMeta) {
     }
 
     tfree(pQueryInfo);
-
     pQueryInfo = p;
   }
 
   pCmd->pQueryInfo = NULL;
+  pCmd->active = NULL;
 }
 
 void destroyTableNameList(SSqlCmd* pCmd) {
@@ -1132,6 +1133,9 @@ void tscResetSqlCmd(SSqlCmd* pCmd, bool removeMeta) {
   pCmd->pTableBlockHashList = tscDestroyBlockHashTable(pCmd->pTableBlockHashList, removeMeta);
   pCmd->pDataBlocks = tscDestroyBlockArrayList(pCmd->pDataBlocks);
   tscFreeQueryInfo(pCmd, removeMeta);
+
+  taosHashCleanup(pCmd->pTableMetaMap);
+  pCmd->pTableMetaMap = NULL;
 }
 
 void tscFreeSqlResult(SSqlObj* pSql) {
@@ -1834,8 +1838,8 @@ void tscFieldInfoClear(SFieldInfo* pFieldInfo) {
   memset(pFieldInfo, 0, sizeof(SFieldInfo));
 }
 
-void tscFieldInfoCopy(SFieldInfo* pFieldInfo, const SFieldInfo* pSrc) {
-  assert(pFieldInfo != NULL && pSrc != NULL);
+void tscFieldInfoCopy(SFieldInfo* pFieldInfo, const SFieldInfo* pSrc, const SArray* pExprList) {
+  assert(pFieldInfo != NULL && pSrc != NULL && pExprList != NULL);
   pFieldInfo->numOfOutput = pSrc->numOfOutput;
 
   if (pSrc->final != NULL) {
@@ -1845,13 +1849,25 @@ void tscFieldInfoCopy(SFieldInfo* pFieldInfo, const SFieldInfo* pSrc) {
 
   if (pSrc->internalField != NULL) {
     size_t num = taosArrayGetSize(pSrc->internalField);
+    size_t numOfExpr = taosArrayGetSize(pExprList);
+
     for (int32_t i = 0; i < num; ++i) {
       SInternalField* pfield = taosArrayGet(pSrc->internalField, i);
 
       SInternalField p = {.visible = pfield->visible, .field = pfield->field};
-      p.pExpr = calloc(1, sizeof(SExprInfo));
 
-      tscExprAssign(p.pExpr, pfield->pExpr);
+      int32_t resColId = pfield->pExpr->base.resColId;
+      for(int32_t j = 0; j < numOfExpr; ++j) {
+        SExprInfo* pExpr = taosArrayGetP(pExprList, j);
+        if (pExpr->base.resColId == resColId) {
+          p.pExpr = pExpr;
+          break;
+        }
+      }
+//      p.pExpr = calloc(1, sizeof(SExprInfo));
+
+//      tscExprAssign(p.pExpr, pfield->pExpr);
+      taosArrayPush(pFieldInfo->internalField, &p);
     }
   }
 }
@@ -2012,7 +2028,7 @@ int32_t tscExprCopy(SArray* dst, const SArray* src, uint64_t uid, bool deepcopy)
   for (int32_t i = 0; i < size; ++i) {
     SExprInfo* pExpr = taosArrayGetP(src, i);
     
-    if (uid != 0 && pExpr->base.uid == uid) {
+    if (pExpr->base.uid == uid) {
       if (deepcopy) {
         SExprInfo* p1 = calloc(1, sizeof(SExprInfo));
         tscExprAssign(p1, pExpr);
@@ -2029,6 +2045,26 @@ int32_t tscExprCopy(SArray* dst, const SArray* src, uint64_t uid, bool deepcopy)
   return 0;
 }
 
+int32_t tscExprCopyAll(SArray* dst, const SArray* src, bool deepcopy) {
+  assert(src != NULL && dst != NULL);
+
+  size_t size = taosArrayGetSize(src);
+  for (int32_t i = 0; i < size; ++i) {
+    SExprInfo* pExpr = taosArrayGetP(src, i);
+
+    if (deepcopy) {
+      SExprInfo* p1 = calloc(1, sizeof(SExprInfo));
+      tscExprAssign(p1, pExpr);
+
+      taosArrayPush(dst, &p1);
+    } else {
+      taosArrayPush(dst, &pExpr);
+    }
+  }
+
+  return 0;
+}
+
 bool tscColumnExists(SArray* pColumnList, int32_t columnIndex, uint64_t uid) {
   // ignore the tbname columnIndex to be inserted into source list
   if (columnIndex < 0) {
@@ -2688,7 +2724,7 @@ int32_t tscQueryInfoCopy(SQueryInfo* pQueryInfo, const SQueryInfo* pSrc) {
   pQueryInfo->fillType       = pSrc->fillType;
   pQueryInfo->fillVal        = NULL;
   pQueryInfo->clauseLimit    = pSrc->clauseLimit;
-  pQueryInfo->numOfTables    = pSrc->numOfTables;
+  pQueryInfo->numOfTables    = 0;
   pQueryInfo->window         = pSrc->window;
   pQueryInfo->sessionWindow  = pSrc->sessionWindow;
   pQueryInfo->pTableMetaInfo = NULL;
@@ -2728,14 +2764,14 @@ int32_t tscQueryInfoCopy(SQueryInfo* pQueryInfo, const SQueryInfo* pSrc) {
     memcpy(pQueryInfo->fillVal, pSrc->fillVal, pSrc->fieldsInfo.numOfOutput * sizeof(int64_t));
   }
 
-  tscColumnListCopyAll(pQueryInfo->colList, pSrc->colList);
-  tscFieldInfoCopy(&pQueryInfo->fieldsInfo, &pSrc->fieldsInfo);
-
-  if (tscExprCopy(pQueryInfo->exprList, pSrc->exprList, 0, true) != 0) {
+  if (tscExprCopyAll(pQueryInfo->exprList, pSrc->exprList, true) != 0) {
     code = TSDB_CODE_TSC_OUT_OF_MEMORY;
     goto _error;
   }
 
+  tscColumnListCopyAll(pQueryInfo->colList, pSrc->colList);
+  tscFieldInfoCopy(&pQueryInfo->fieldsInfo, &pSrc->fieldsInfo, pQueryInfo->exprList);
+
   for(int32_t i = 0; i < pSrc->numOfTables; ++i) {
     STableMetaInfo* p1 = tscGetMetaInfo((SQueryInfo*) pSrc, i);
 
@@ -2822,28 +2858,29 @@ void clearAllTableMetaInfo(SQueryInfo* pQueryInfo, bool removeMeta) {
     if (removeMeta) {
       char name[TSDB_TABLE_FNAME_LEN] = {0};
       tNameExtractFullName(&pTableMetaInfo->name, name);
-    
       taosHashRemove(tscTableMetaInfo, name, strnlen(name, TSDB_TABLE_FNAME_LEN));
     }
     
     tscFreeVgroupTableInfo(pTableMetaInfo->pVgroupTables);
     tscClearTableMetaInfo(pTableMetaInfo);
+
     free(pTableMetaInfo);
   }
-  
+
   tfree(pQueryInfo->pTableMetaInfo);
 }
 
 STableMetaInfo* tscAddTableMetaInfo(SQueryInfo* pQueryInfo, SName* name, STableMeta* pTableMeta,
                                     SVgroupsInfo* vgroupList, SArray* pTagCols, SArray* pVgroupTables) {
-  void* pAlloc = realloc(pQueryInfo->pTableMetaInfo, (pQueryInfo->numOfTables + 1) * POINTER_BYTES);
-  if (pAlloc == NULL) {
+  void* tmp = realloc(pQueryInfo->pTableMetaInfo, (pQueryInfo->numOfTables + 1) * POINTER_BYTES);
+  if (tmp == NULL) {
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
     return NULL;
   }
 
-  pQueryInfo->pTableMetaInfo = pAlloc;
+  pQueryInfo->pTableMetaInfo = tmp;
   STableMetaInfo* pTableMetaInfo = calloc(1, sizeof(STableMetaInfo));
+
   if (pTableMetaInfo == NULL) {
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
     return NULL;
@@ -3018,10 +3055,11 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
 
   SSqlCmd* pnCmd  = &pNew->cmd;
   memcpy(pnCmd, pCmd, sizeof(SSqlCmd));
-  
+
   pnCmd->command = cmd;
   pnCmd->payload = NULL;
   pnCmd->allocSize = 0;
+  pnCmd->pTableMetaMap = NULL;
 
   pnCmd->pQueryInfo  = NULL;
   pnCmd->clauseIndex = 0;
@@ -3206,7 +3244,7 @@ void doExecuteQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
 }
 
 void doRetrieveSubqueryData(SSchedMsg *pMsg) {
-  SSqlObj* pSql = (SSqlObj*)taosAcquireRef(tscObjRef, (int64_t)pMsg->ahandle);
+  SSqlObj* pSql = (SSqlObj*) pMsg->ahandle;
   if (pSql == NULL || pSql->signature != pSql) {
     tscDebug("%p SqlObj is freed, not add into queue async res", pMsg->ahandle);
     return;
@@ -3246,7 +3284,7 @@ static void tscSubqueryRetrieveCallback(void* param, TAOS_RES* tres, int code) {
 
   SSchedMsg schedMsg = {0};
   schedMsg.fp = doRetrieveSubqueryData;
-  schedMsg.ahandle = (void *)pParentSql->self;
+  schedMsg.ahandle = (void *)pParentSql;
   schedMsg.thandle = (void *)1;
   schedMsg.msg = 0;
   taosScheduleTask(tscQhandle, &schedMsg);
@@ -3311,7 +3349,7 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
       tscQueryInfoCopy(pNewQueryInfo, pSub);
 
       // create sub query to handle the sub query.
-      executeQuery(pNew, pSub);
+      executeQuery(pNew, pNewQueryInfo);
     }
 
     // merge sub query result and generate final results

From 4beb0b4d076b1c2f01d7d086186804013f26db97 Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Thu, 20 May 2021 19:16:12 +0800
Subject: [PATCH 054/128] [TD-4034]fix super table bug

---
 src/tsdb/inc/tsdbMeta.h     |  1 +
 src/tsdb/src/tsdbMain.c     | 27 ++++++++-------------------
 src/tsdb/src/tsdbMemTable.c | 16 ++++------------
 src/tsdb/src/tsdbMeta.c     |  4 ++++
 4 files changed, 17 insertions(+), 31 deletions(-)

diff --git a/src/tsdb/inc/tsdbMeta.h b/src/tsdb/inc/tsdbMeta.h
index 43c85d89cb..45868c002d 100644
--- a/src/tsdb/inc/tsdbMeta.h
+++ b/src/tsdb/inc/tsdbMeta.h
@@ -89,6 +89,7 @@ void       tsdbOrgMeta(STsdbRepo* pRepo);
 int        tsdbInitColIdCacheWithSchema(STable* pTable, STSchema* pSchema);
 int16_t    tsdbGetLastColumnsIndexByColId(STable* pTable, int16_t colId);
 int        tsdbUpdateLastColSchema(STable *pTable, STSchema *pNewSchema);
+STSchema*  tsdbGetTableLatestSchema(STable *pTable);
 
 static FORCE_INLINE int tsdbCompareSchemaVersion(const void *key1, const void *key2) {
   if (*(int16_t *)key1 < schemaVersion(*(STSchema **)key2)) {
diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index d593997d3c..1e6f9eac12 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -26,6 +26,7 @@ static STsdbRepo *tsdbNewRepo(STsdbCfg *pCfg, STsdbAppH *pAppH);
 static void       tsdbFreeRepo(STsdbRepo *pRepo);
 static void       tsdbStartStream(STsdbRepo *pRepo);
 static void       tsdbStopStream(STsdbRepo *pRepo);
+static int        tsdbRestoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh);
 
 // Function declaration
 int32_t tsdbCreateRepo(int repoid) {
@@ -616,24 +617,12 @@ static void tsdbStopStream(STsdbRepo *pRepo) {
   }
 }
 
-static STSchema* getTableLatestSchema(STable *pTable) {
-  if (pTable->numOfSchemas > 0) {
-    return pTable->schema[pTable->numOfSchemas - 1];
-  }
+static int tsdbRestoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh) {
+  //tsdbInfo("tsdbRestoreLastColumns of table %s", pTable->name->data);
 
-  if (pTable->type == TSDB_CHILD_TABLE) {
-    if (pTable->pSuper && pTable->pSuper->numOfSchemas) {
-      tsdbDebug("getTableLatestSchema of table %s from super table %s", pTable->name->data, pTable->pSuper->name->data);
-      return pTable->pSuper->schema[pTable->pSuper->numOfSchemas - 1];
-    }
-  }
-  return NULL;
-}
-
-static int restoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh) {
-  STSchema *pSchema = getTableLatestSchema(pTable);
+  STSchema *pSchema = tsdbGetTableLatestSchema(pTable);
   if (pSchema == NULL) {
-    tsdbError("getTableLatestSchema of table %s fail", pTable->name->data);
+    tsdbError("tsdbGetTableLatestSchema of table %s fail", pTable->name->data);
     return 0;
   }
 
@@ -728,7 +717,7 @@ static int restoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh)
 
         int16_t idx = tsdbGetLastColumnsIndexByColId(pTable, pCol->colId);
         if (idx == -1) {
-          tsdbError("restoreLastColumns restore vgId:%d,table:%s cache column %d fail", REPO_ID(pRepo), pTable->name->data, pCol->colId);
+          tsdbError("tsdbRestoreLastColumns restore vgId:%d,table:%s cache column %d fail", REPO_ID(pRepo), pTable->name->data, pCol->colId);
           continue;
         }
         // save not-null column
@@ -746,7 +735,7 @@ static int restoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh)
 
         pTable->maxColumnNum += 1;
 
-        tsdbInfo("restoreLastColumns restore vgId:%d,table:%s cache column %d, %" PRId64, REPO_ID(pRepo), pTable->name->data, pLastCol->colId, pLastCol->ts);
+        tsdbInfo("tsdbRestoreLastColumns restore vgId:%d,table:%s cache column %d, %" PRId64, REPO_ID(pRepo), pTable->name->data, pLastCol->colId, pLastCol->ts);
         break;
       }
     }
@@ -843,7 +832,7 @@ int tsdbRestoreInfo(STsdbRepo *pRepo) {
       
       // restore NULL columns
       if (pIdx && CACHE_LAST_NULL_COLUMN(pCfg)) {
-        if (restoreLastColumns(pRepo, pTable, &readh) != 0) {
+        if (tsdbRestoreLastColumns(pRepo, pTable, &readh) != 0) {
           tsdbDestroyReadH(&readh);
           return -1;
         }
diff --git a/src/tsdb/src/tsdbMemTable.c b/src/tsdb/src/tsdbMemTable.c
index 156bd29ee1..ff2a870f3f 100644
--- a/src/tsdb/src/tsdbMemTable.c
+++ b/src/tsdb/src/tsdbMemTable.c
@@ -965,23 +965,15 @@ static void tsdbFreeRows(STsdbRepo *pRepo, void **rows, int rowCounter) {
 }
 
 static void updateTableLatestColumn(STsdbRepo *pRepo, STable *pTable, SDataRow row) {
-  //tsdbInfo("vgId:%d updateTableLatestColumn, row version:%d", REPO_ID(pRepo), dataRowVersion(row));
+  tsdbInfo("vgId:%d updateTableLatestColumn, %s row version:%d", REPO_ID(pRepo), pTable->name->data, dataRowVersion(row));
 
-  if (pTable->numOfSchemas <= 0) {
-    return;
-  }
-
-  STSchema* pSchema = pTable->schema[pTable->numOfSchemas - 1];
+  STSchema* pSchema = tsdbGetTableLatestSchema(pTable);
   if (tsdbUpdateLastColSchema(pTable, pSchema) < 0) {
     return;
   }
 
-  int16_t i = pTable->numOfSchemas - 1;
-  while ((pSchema == NULL || pSchema->version != dataRowVersion(row)) && i >= 0) {
-    i -= 1;
-    pSchema = pTable->schema[i];
-  }
-  if (pSchema == NULL || pSchema->version != dataRowVersion(row)) {
+  pSchema = tsdbGetTableSchemaByVersion(pTable, dataRowVersion(row));
+  if (pSchema == NULL) {
     return;
   }
 
diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c
index fde593b59a..5717d52eea 100644
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
@@ -645,6 +645,10 @@ int tsdbInitColIdCacheWithSchema(STable* pTable, STSchema* pSchema) {
   return 0;
 }
 
+STSchema* tsdbGetTableLatestSchema(STable *pTable) {
+  return tsdbGetTableSchemaByVersion(pTable, -1);
+}
+
 int tsdbUpdateLastColSchema(STable *pTable, STSchema *pNewSchema) {
   if (pTable->lastColSVersion == schemaVersion(pNewSchema)) {
     return 0;

From 5507e88752614360abb66ab29e2802d4d42205ea Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Fri, 21 May 2021 08:26:29 +0800
Subject: [PATCH 055/128] move ts to last row

---
 src/tsdb/src/tsdbRead.c | 52 ++++++++++++++++++++++++++++++-----------
 1 file changed, 39 insertions(+), 13 deletions(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 29d400fd56..c78739d7ce 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -2491,6 +2491,8 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
   int32_t numOfRows = 0;
   assert(numOfTables > 0 && tgNumOfCols > 0);
   SQueryFilePos* cur = &pQueryHandle->cur;
+  TSKEY priKey = TSKEY_INITIAL_VAL;
+  int32_t priIdx = -1;
 
   while (++pQueryHandle->activeIndex < numOfTables) {
     STableCheckInfo* pCheckInfo = taosArrayGet(pQueryHandle->pTableCheckInfo, pQueryHandle->activeIndex);
@@ -2515,13 +2517,9 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
         continue;
       }
     
-      if (ASCENDING_TRAVERSE(pQueryHandle->order)) {
-        pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
-      } else {
-        pData = (char*)pColInfo->pData + (pQueryHandle->outputCapacity - numOfRows - 1) * pColInfo->info.bytes;
-      }
+      pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;
     
-      if (pTable->lastCols[j].bytes > 0) {
+      if (pTable->lastCols[j].bytes > 0) {        
         void* value = pTable->lastCols[j].pData;
         switch (pColInfo->info.type) {
           case TSDB_DATA_TYPE_BINARY:
@@ -2554,7 +2552,12 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
             break;
           case TSDB_DATA_TYPE_TIMESTAMP:
             if (pColInfo->info.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
-              *(TSKEY *)pData = tdGetKey(*(TKEY *)value);
+              priKey = tdGetKey(*(TKEY *)value);
+              priIdx = i;
+
+              i++;
+              j++;
+              continue;
             } else {
               *(TSKEY *)pData = *(TSKEY *)value;
             }
@@ -2569,13 +2572,9 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
           }
 
           SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, n);
-          if (ASCENDING_TRAVERSE(pQueryHandle->order)) {
-            pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
-          } else {
-            pData = (char*)pColInfo->pData + (pQueryHandle->outputCapacity - numOfRows - 1) * pColInfo->info.bytes;
-          }
+          pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
 
-          if (n == 0) {
+          if (pColInfo->info.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
             *(TSKEY *)pData = pTable->lastCols[j].ts;
             continue;
           }
@@ -2595,6 +2594,33 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
       j++;
     }
 
+    // leave the real ts column as the last row, because last function only (not stable) use the last row as res
+    if (priKey != TSKEY_INITIAL_VAL) {
+      SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, priIdx);
+      pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;
+    
+      *(TSKEY *)pData = priKey;
+
+      for (int32_t n = 0; n < tgNumOfCols; ++n) {
+        if (n == priIdx) {
+          continue;
+        }
+      
+        SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, n);
+        pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
+      
+        assert (pColInfo->info.colId != PRIMARYKEY_TIMESTAMP_COL_INDEX);
+        
+        if (pColInfo->info.type == TSDB_DATA_TYPE_BINARY || pColInfo->info.type == TSDB_DATA_TYPE_NCHAR) {
+          setVardataNull(pData, pColInfo->info.type);
+        } else {
+          setNull(pData, pColInfo->info.type, pColInfo->info.bytes);
+        }
+      }
+
+      numOfRows++;
+    }
+    
     if (numOfRows > 0) {
       cur->rows     = numOfRows;
       cur->mixBlock = true;

From 5ade893fd9d9fd1ab67a38ef7196356d2e5f62af Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Fri, 21 May 2021 13:57:38 +0800
Subject: [PATCH 056/128] [td-225]fix bugs found by regression test.

---
 src/client/inc/tscUtil.h      |  2 ++
 src/client/inc/tsclient.h     |  6 ++--
 src/client/src/tscSQLParser.c | 17 +++++++----
 src/client/src/tscServer.c    | 33 +++++----------------
 src/client/src/tscSql.c       |  4 +--
 src/client/src/tscSubquery.c  | 37 +++++++++--------------
 src/client/src/tscUtil.c      | 56 ++++++++++++++++++++++-------------
 src/mnode/src/mnodeTable.c    |  2 +-
 src/query/src/qExecutor.c     |  2 +-
 src/util/inc/hash.h           |  1 +
 10 files changed, 78 insertions(+), 82 deletions(-)

diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index 506b579c15..0be65633af 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -321,6 +321,8 @@ CChildTableMeta* tscCreateChildMeta(STableMeta* pTableMeta);
 uint32_t tscGetTableMetaMaxSize();
 int32_t tscCreateTableMetaFromCChildMeta(STableMeta* pChild, const char* name, void* buf);
 STableMeta* tscTableMetaDup(STableMeta* pTableMeta);
+SVgroupsInfo* tscVgroupsInfoDup(SVgroupsInfo* pVgroupsInfo);
+
 int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAttr, void* addr);
 
 void tsCreateSQLFunctionCtx(SQueryInfo* pQueryInfo, SQLFunctionCtx* pCtx, SSchema* pSchema);
diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index fa19deb5cc..b335b7d53d 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -83,10 +83,10 @@ typedef struct STableMeta {
 } STableMeta;
 
 typedef struct STableMetaInfo {
-  STableMeta   *pTableMeta;      // table meta, cached in client side and acquired by name
+  STableMeta    *pTableMeta;      // table meta, cached in client side and acquired by name
   uint32_t       tableMetaSize;
-  SVgroupsInfo *vgroupList;
-  SArray       *pVgroupTables;   // SArray<SVgroupTableInfo>
+  SVgroupsInfo  *vgroupList;
+  SArray        *pVgroupTables;   // SArray<SVgroupTableInfo>
   
   /*
    * 1. keep the vgroup index during the multi-vnode super table projection query
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 4b92f69bd9..ae079e7517 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -7241,7 +7241,6 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       }
 
       STableMeta* pMeta = tscTableMetaDup(pTableMeta);
-
       STableMetaVgroupInfo p = { .pTableMeta = pMeta };
 
       const char* px = tNameGetTableName(pname);
@@ -7279,10 +7278,15 @@ static int32_t doLoadAllTableMeta(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNod
   const char* msg1 = "invalid table name";
   const char* msg2 = "invalid table alias name";
   const char* msg3 = "alias name too long";
+  const char* msg4 = "self join not allowed";
 
   int32_t code = TSDB_CODE_SUCCESS;
-
   SSqlCmd* pCmd = &pSql->cmd;
+
+  if (numOfTables > taosHashGetSize(pCmd->pTableMetaMap)) {
+    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+  }
+
   for (int32_t i = 0; i < numOfTables; ++i) {
     if (pQueryInfo->numOfTables <= i) {  // more than one table
       tscAddEmptyMetaInfo(pQueryInfo);
@@ -7325,11 +7329,13 @@ static int32_t doLoadAllTableMeta(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNod
     const char* name = tNameGetTableName(&pTableMetaInfo->name);
     STableMetaVgroupInfo* p = taosHashGet(pCmd->pTableMetaMap, name, strlen(name));
 
-    pTableMetaInfo->pTableMeta = p->pTableMeta;
-    pTableMetaInfo->vgroupList = p->pVgroupInfo;
-
+    pTableMetaInfo->pTableMeta = tscTableMetaDup(p->pTableMeta);
     assert(pTableMetaInfo->pTableMeta != NULL);
 
+    if (p->pVgroupInfo != NULL) {
+      pTableMetaInfo->vgroupList = tscVgroupsInfoDup(p->pVgroupInfo);
+    }
+
     if (code != TSDB_CODE_SUCCESS) {
       return code;
     }
@@ -7556,7 +7562,6 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
      */
     if (isSTable) {
       tscTansformFuncForSTableQuery(pQueryInfo);
-
       if (hasUnsupportFunctionsForSTableQuery(pCmd, pQueryInfo)) {
         return TSDB_CODE_TSC_INVALID_SQL;
       }
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 37ea6ff8b9..289ce525f2 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -1722,23 +1722,6 @@ int tscBuildTableMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 int tscBuildMultiTableMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
 
-  // copy payload content to temp buf
-//  char *tmpData = 0;
-//  if (pCmd->payloadLen > 0) {
-//    if ((tmpData = calloc(1, pCmd->payloadLen + 1)) == NULL) return -1;
-//    memcpy(tmpData, pCmd->payload, pCmd->payloadLen);
-//  }
-
-//  SMultiTableInfoMsg *pInfoMsg = (SMultiTableInfoMsg *)(pCmd->payload);
-//  pInfoMsg->numOfTables = htonl((int32_t)pCmd->count);
-//
-//  if (pCmd->payloadLen > 0) {
-//    memcpy(pInfoMsg->tableIds, tmpData, pCmd->payloadLen);
-//  }
-//
-//  tfree(tmpData);
-
-//  pCmd->payloadLen += sizeof(SMgmtHead) + sizeof(SMultiTableInfoMsg);
   pCmd->msgType = TSDB_MSG_TYPE_CM_TABLES_META;
   assert(pCmd->payloadLen + minMsgSize() <= pCmd->allocSize);
 
@@ -1885,7 +1868,7 @@ static void doUpdateVgroupInfo(STableMeta *pTableMeta, SVgroupMsg *pVgroupMsg) {
   }
 }
 
-static void doAddTableMetaLocalBuf(STableMeta* pTableMeta, STableMetaMsg* pMetaMsg, bool updateSTable) {
+static void doAddTableMetaToLocalBuf(STableMeta* pTableMeta, STableMetaMsg* pMetaMsg, bool updateSTable) {
   if (pTableMeta->tableType == TSDB_CHILD_TABLE) {
     // add or update the corresponding super table meta data info
     int32_t len = (int32_t) strnlen(pTableMeta->sTableName, TSDB_TABLE_FNAME_LEN);
@@ -1928,7 +1911,7 @@ int tscProcessTableMetaRsp(SSqlObj *pSql) {
   tNameExtractFullName(&pTableMetaInfo->name, name);
   assert(strncmp(pMetaMsg->tableFname, name, tListLen(pMetaMsg->tableFname)) == 0);
 
-  doAddTableMetaLocalBuf(pTableMeta, pMetaMsg, true);
+  doAddTableMetaToLocalBuf(pTableMeta, pMetaMsg, true);
   doUpdateVgroupInfo(pTableMeta, &pMetaMsg->vgroup);
 
   tscDebug("0x%"PRIx64" recv table meta, uid:%" PRIu64 ", tid:%d, name:%s", pSql->self, pTableMeta->id.uid, pTableMeta->id.tid,
@@ -2039,7 +2022,7 @@ int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
     }
 
     // create the tableMeta and add it into the TableMeta map
-    doAddTableMetaLocalBuf(pTableMeta, pMetaMsg, addToBuf);
+    doAddTableMetaToLocalBuf(pTableMeta, pMetaMsg, addToBuf);
 
     // if the vgroup is not updated in current process, update it.
     int64_t vgId = pMetaMsg->vgroup.vgId;
@@ -2051,7 +2034,7 @@ int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
     pMsg += pMetaMsg->contLen;
   }
 
-  if (pMultiMeta->numOfVgroup > 0) {
+  for(int32_t i = 0; i < pMultiMeta->numOfVgroup; ++i) {
     char* name = pMsg;
     pMsg += TSDB_TABLE_NAME_LEN;
 
@@ -2059,15 +2042,13 @@ int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
     assert(p != NULL);
 
     int32_t size = 0;
-    SVgroupsInfo* pVgroupInfo = createVgroupInfoFromMsg(pMsg, &size, pSql->self);
-
-    p->pVgroupInfo = pVgroupInfo;
+    p->pVgroupInfo = createVgroupInfoFromMsg(pMsg, &size, pSql->self);
     pMsg += size;
   }
 
   pSql->res.code = TSDB_CODE_SUCCESS;
   pSql->res.numOfTotal = pMultiMeta->numOfTables;
-  tscDebug("0x%"PRIx64" load multi-tableMeta resp from complete numOfTables:%d", pSql->self, pMultiMeta->numOfTables);
+  tscDebug("0x%"PRIx64" load multi-tableMeta from mnode, numOfTables:%d", pSql->self, pMultiMeta->numOfTables);
 
   taosHashCleanup(pSet);
   taosReleaseRef(tscObjRef, pParentSql->self);
@@ -2471,7 +2452,7 @@ int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVg
   for(int32_t i = 0; i < numOfVgroupList; ++i) {
     char* name = taosArrayGetP(pVgroupNameList, i);
     if (i < numOfVgroupList - 1) {
-      len = sprintf(start, "%s, ", name);
+      len = sprintf(start, "%s,", name);
     } else {
       len = sprintf(start, "%s", name);
     }
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index d8c930d341..8a70502da6 100644
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -833,9 +833,9 @@ int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields)
       case TSDB_DATA_TYPE_NCHAR: {
         int32_t charLen = varDataLen((char*)row[i] - VARSTR_HEADER_SIZE);
         if (fields[i].type == TSDB_DATA_TYPE_BINARY) {
-          assert(charLen <= fields[i].bytes);
+          assert(charLen <= fields[i].bytes && charLen >= 0);
         } else {
-          assert(charLen <= fields[i].bytes * TSDB_NCHAR_SIZE);
+          assert(charLen <= fields[i].bytes * TSDB_NCHAR_SIZE && charLen >= 0);
         }
 
         memcpy(str + len, row[i], charLen);
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index 15100bfb4d..3909b81f59 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -587,7 +587,7 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
     pTableMetaInfo->pVgroupTables = pSupporter->pVgroupTables;
 
     pSupporter->exprList = NULL;
-    pSupporter->colList = NULL;
+    pSupporter->colList  = NULL;
     pSupporter->pVgroupTables = NULL;
     memset(&pSupporter->fieldsInfo, 0, sizeof(SFieldInfo));
     memset(&pSupporter->groupInfo, 0, sizeof(SGroupbyExpr));
@@ -597,8 +597,6 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
      * during the timestamp intersection.
      */
     pSupporter->limit = pQueryInfo->limit;
-//    pQueryInfo->limit = pSupporter->limit;
-
     SColumnIndex index = {.tableIndex = 0, .columnIndex = PRIMARYKEY_TIMESTAMP_COL_INDEX};
     SSchema* s = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, 0);
 
@@ -606,6 +604,7 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
     int16_t funcId = pExpr->base.functionId;
 
     // add the invisible timestamp column
+    printf("--------read:%p\n", pExpr);
     if ((pExpr->base.colInfo.colId != PRIMARYKEY_TIMESTAMP_COL_INDEX) ||
         (funcId != TSDB_FUNC_TS && funcId != TSDB_FUNC_TS_DUMMY && funcId != TSDB_FUNC_PRJ)) {
 
@@ -645,11 +644,11 @@ static int32_t tscLaunchRealSubqueries(SSqlObj* pSql) {
       }
     }
 
-    subquerySetState(pPrevSub, &pSql->subState, i, 0);
+    subquerySetState(pNew, &pSql->subState, i, 0);
     
     size_t numOfCols = taosArrayGetSize(pQueryInfo->colList);
-    tscDebug("0x%"PRIx64" subquery:%p tableIndex:%d, vgroupIndex:%d, type:%d, exprInfo:%" PRIzu ", colList:%" PRIzu ", fieldsInfo:%d, name:%s",
-             pSql->self, pNew, 0, pTableMetaInfo->vgroupIndex, pQueryInfo->type, taosArrayGetSize(pQueryInfo->exprList),
+    tscDebug("0x%"PRIx64" subquery:0x%"PRIx64" tableIndex:%d, vgroupIndex:%d, type:%d, exprInfo:%" PRIzu ", colList:%" PRIzu ", fieldsInfo:%d, name:%s",
+             pSql->self, pNew->self, 0, pTableMetaInfo->vgroupIndex, pQueryInfo->type, taosArrayGetSize(pQueryInfo->exprList),
              numOfCols, pQueryInfo->fieldsInfo.numOfOutput, tNameGetTableName(&pTableMetaInfo->name));
   }
   
@@ -712,8 +711,6 @@ static int32_t quitAllSubquery(SSqlObj* pSqlSub, SSqlObj* pSqlObj, SJoinSupporte
 static void updateQueryTimeRange(SQueryInfo* pQueryInfo, STimeWindow* win) {
   assert(pQueryInfo->window.skey <= win->skey && pQueryInfo->window.ekey >= win->ekey);
   pQueryInfo->window = *win;
-
-
 }
 
 int32_t tidTagsCompar(const void* p1, const void* p2) {
@@ -809,8 +806,10 @@ static void issueTsCompQuery(SSqlObj* pSql, SJoinSupporter* pSupporter, SSqlObj*
   assert(pQueryInfo->numOfTables == 1);
 
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
+  STimeWindow window = pQueryInfo->window;
   tscInitQueryInfo(pQueryInfo);
 
+  pQueryInfo->window = window;
   TSDB_QUERY_CLEAR_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_TAG_FILTER_QUERY);
   TSDB_QUERY_SET_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_MULTITABLE_QUERY);
   
@@ -1285,7 +1284,6 @@ static void tsCompRetrieveCallback(void* param, TAOS_RES* tres, int32_t numOfRow
 
       if (pSupporter->f == NULL) {
         tscError("0x%"PRIx64" failed to create tmp file:%s, reason:%s", pSql->self, pSupporter->path, strerror(errno));
-        
         pParentSql->res.code = TAOS_SYSTEM_ERROR(errno);
 
         if (quitAllSubquery(pSql, pParentSql, pSupporter)) {
@@ -1407,7 +1405,6 @@ static void joinRetrieveFinalResCallback(void* param, TAOS_RES* tres, int numOfR
     }
     
     tscAsyncResultOnError(pParentSql);
-
     return;
   }
 
@@ -1640,7 +1637,6 @@ void tscFetchDatablockForSubquery(SSqlObj* pSql) {
     }
 
     SSqlRes* pRes1 = &pSql1->res;
-
     if (pRes1->row >= pRes1->numOfRows) {
       subquerySetState(pSql1, &pSql->subState, i, 0);
     }
@@ -1726,8 +1722,8 @@ void tscSetupOutputColumnIndex(SSqlObj* pSql) {
   }
 
   // restore the offset value for super table query in case of final result.
-  tscRestoreFuncForSTableQuery(pQueryInfo);
-  tscFieldInfoUpdateOffset(pQueryInfo);
+//  tscRestoreFuncForSTableQuery(pQueryInfo);
+//  tscFieldInfoUpdateOffset(pQueryInfo);
 }
 
 void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {
@@ -1847,12 +1843,6 @@ int32_t tscCreateJoinSubquery(SSqlObj *pSql, int16_t tableIndex, SJoinSupporter
     SQueryInfo *pNewQueryInfo = tscGetQueryInfo(&pNew->cmd);
     assert(pNewQueryInfo != NULL);
     
-    // update the table index
-//    size_t num = taosArrayGetSize(pNewQueryInfo->colList);
-//    for (int32_t i = 0; i < num; ++i) {
-//      SColumn* pCol = taosArrayGetP(pNewQueryInfo->colList, i);
-//    }
-    
     pSupporter->colList = pNewQueryInfo->colList;
     pNewQueryInfo->colList = NULL;
     
@@ -1882,8 +1872,11 @@ int32_t tscCreateJoinSubquery(SSqlObj *pSql, int16_t tableIndex, SJoinSupporter
 
     // backup the data and clear it in the sqlcmd object
     memset(&pNewQueryInfo->groupbyExpr, 0, sizeof(SGroupbyExpr));
-    
+
+    STimeWindow range = pNewQueryInfo->window;
     tscInitQueryInfo(pNewQueryInfo);
+
+    pNewQueryInfo->window = range;
     STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pNewQueryInfo, 0);
     
     if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) { // return the tableId & tag
@@ -3270,7 +3263,7 @@ static void doBuildResFromSubqueries(SSqlObj* pSql) {
     return;
   }
 
-  tscRestoreFuncForSTableQuery(pQueryInfo);
+//  tscRestoreFuncForSTableQuery(pQueryInfo);
   int32_t rowSize = tscGetResRowLength(pQueryInfo->exprList);
 
   assert(numOfRes * rowSize > 0);
@@ -3362,8 +3355,6 @@ void tscBuildResFromSubqueries(SSqlObj *pSql) {
       tscAsyncResultOnError(pSql);
       return;
     }
-
-    tscRestoreFuncForSTableQuery(pQueryInfo);
   }
 
   assert (pRes->row >= pRes->numOfRows);
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index a727731536..32c85ab43f 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -1077,16 +1077,16 @@ void tscFreeQueryInfo(SSqlCmd* pCmd, bool removeMeta) {
 
     int32_t numOfUpstream = taosArrayGetSize(pQueryInfo->pUpstream);
     for(int32_t i = 0; i < numOfUpstream; ++i) {
-      SQueryInfo* pUp = taosArrayGetP(pQueryInfo->pUpstream, i);
-      freeQueryInfoImpl(pUp);
+      SQueryInfo* pUpQueryInfo = taosArrayGetP(pQueryInfo->pUpstream, i);
+      freeQueryInfoImpl(pUpQueryInfo);
 
-      clearAllTableMetaInfo(pUp, removeMeta);
-      if (pUp->pQInfo != NULL) {
-        qDestroyQueryInfo(pUp->pQInfo);
-        pUp->pQInfo = NULL;
+      clearAllTableMetaInfo(pUpQueryInfo, removeMeta);
+      if (pUpQueryInfo->pQInfo != NULL) {
+        qDestroyQueryInfo(pUpQueryInfo->pQInfo);
+        pUpQueryInfo->pQInfo = NULL;
       }
 
-      tfree(pUp);
+      tfree(pUpQueryInfo);
     }
 
     freeQueryInfoImpl(pQueryInfo);
@@ -1134,8 +1134,17 @@ void tscResetSqlCmd(SSqlCmd* pCmd, bool removeMeta) {
   pCmd->pDataBlocks = tscDestroyBlockArrayList(pCmd->pDataBlocks);
   tscFreeQueryInfo(pCmd, removeMeta);
 
-  taosHashCleanup(pCmd->pTableMetaMap);
-  pCmd->pTableMetaMap = NULL;
+  if (pCmd->pTableMetaMap != NULL) {
+    STableMetaVgroupInfo* p = taosHashIterate(pCmd->pTableMetaMap, NULL);
+    while (p) {
+      tfree(p->pVgroupInfo);
+      tfree(p->pTableMeta);
+      p = taosHashIterate(pCmd->pTableMetaMap, p);
+    }
+
+    taosHashCleanup(pCmd->pTableMetaMap);
+    pCmd->pTableMetaMap = NULL;
+  }
 }
 
 void tscFreeSqlResult(SSqlObj* pSql) {
@@ -1189,7 +1198,6 @@ void tscFreeRegisteredSqlObj(void *pSql) {
   tscDebug("0x%"PRIx64" free SqlObj, total in tscObj:%d, total:%d", p->self, num, total);
   tscFreeSqlObj(p);
   taosReleaseRef(tscRefId, pTscObj->rid);
-
 }
 
 void tscFreeMetaSqlObj(int64_t *rid){
@@ -1725,16 +1733,14 @@ SInternalField* tscFieldInfoInsert(SFieldInfo* pFieldInfo, int32_t index, TAOS_F
 }
 
 void tscFieldInfoUpdateOffset(SQueryInfo* pQueryInfo) {
+  int32_t offset = 0;
   size_t numOfExprs = tscNumOfExprs(pQueryInfo);
-  
-  SExprInfo* pExpr = taosArrayGetP(pQueryInfo->exprList, 0);
-  pExpr->base.offset = 0;
 
-  for (int32_t i = 1; i < numOfExprs; ++i) {
-    SExprInfo* prev = taosArrayGetP(pQueryInfo->exprList, i - 1);
+  for (int32_t i = 0; i < numOfExprs; ++i) {
     SExprInfo* p = taosArrayGetP(pQueryInfo->exprList, i);
 
-    p->base.offset = prev->base.offset + prev->base.resBytes;
+    p->base.offset = offset;
+    offset += p->base.resBytes;
   }
 }
 
@@ -1842,6 +1848,7 @@ void* sqlExprDestroy(SExprInfo* pExpr) {
     tExprTreeDestroy(pExpr->pExpr, NULL);
   }
 
+  printf("free---------------%p\n", pExpr);
   tfree(pExpr);
   return NULL;
 }
@@ -1911,6 +1918,7 @@ SExprInfo* tscExprCreate(SQueryInfo* pQueryInfo, int16_t functionId, SColumnInde
     return NULL;
   }
 
+  printf("malloc======================%p\n", pExpr);
   SSqlExpr* p = &pExpr->base;
   p->functionId = functionId;
 
@@ -2056,7 +2064,7 @@ int32_t tscExprCopy(SArray* dst, const SArray* src, uint64_t uid, bool deepcopy)
   size_t size = taosArrayGetSize(src);
   for (int32_t i = 0; i < size; ++i) {
     SExprInfo* pExpr = taosArrayGetP(src, i);
-    
+
     if (pExpr->base.uid == uid) {
       if (deepcopy) {
         SExprInfo* p1 = calloc(1, sizeof(SExprInfo));
@@ -2066,8 +2074,6 @@ int32_t tscExprCopy(SArray* dst, const SArray* src, uint64_t uid, bool deepcopy)
       } else {
         taosArrayPush(dst, &pExpr);
       }
-    } else {
-      taosArrayPush(dst, &pExpr);
     }
   }
 
@@ -3953,12 +3959,22 @@ uint32_t tscGetTableMetaMaxSize() {
 
 STableMeta* tscTableMetaDup(STableMeta* pTableMeta) {
   assert(pTableMeta != NULL);
-  uint32_t size = tscGetTableMetaSize(pTableMeta);
+  size_t size = tscGetTableMetaSize(pTableMeta);
+
   STableMeta* p = calloc(1, size);
   memcpy(p, pTableMeta, size);
   return p;
 }
 
+SVgroupsInfo* tscVgroupsInfoDup(SVgroupsInfo* pVgroupsInfo) {
+  assert(pVgroupsInfo != NULL);
+
+  size_t size = sizeof(SVgroupInfo) * pVgroupsInfo->numOfVgroups + sizeof(SVgroupsInfo);
+  SVgroupsInfo* pInfo = calloc(1, size);
+  memcpy(pInfo, pVgroupsInfo, size);
+  return pInfo;
+}
+
 int32_t createProjectionExpr(SQueryInfo* pQueryInfo, STableMetaInfo* pTableMetaInfo, SExprInfo*** pExpr, int32_t* num) {
   if (!pQueryInfo->arithmeticOnAgg) {
     return TSDB_CODE_SUCCESS;
diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index 7e53138ef1..e35874b585 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -2922,7 +2922,7 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
   char* msg = (char*) pMultiMeta + pMultiMeta->contLen;
 
   // add the additional super table names that needs the vgroup info
-  for(;t < pInfo->numOfVgroups; ++t) {
+  for(;t < num; ++t) {
     taosArrayPush(pList, &nameList[t]);
   }
 
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 992158e1a6..528c65eaed 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -7135,7 +7135,7 @@ void* destroyQueryFuncExpr(SExprInfo* pExprInfo, int32_t numOfExpr) {
 
 void* freeColumnInfo(SColumnInfo* pColumnInfo, int32_t numOfCols) {
   if (pColumnInfo != NULL) {
-    assert(numOfCols > 0);
+    assert(numOfCols >= 0);
 
     for (int32_t i = 0; i < numOfCols; i++) {
       freeColumnFilterInfo(pColumnInfo[i].flist.filterInfo, pColumnInfo[i].flist.numOfFilters);
diff --git a/src/util/inc/hash.h b/src/util/inc/hash.h
index b6b49693f6..cd4850e47e 100644
--- a/src/util/inc/hash.h
+++ b/src/util/inc/hash.h
@@ -148,6 +148,7 @@ int32_t taosHashGetMaxOverflowLinkLength(const SHashObj *pHashObj);
 size_t taosHashGetMemSize(const SHashObj *pHashObj);
 
 void *taosHashIterate(SHashObj *pHashObj, void *p);
+
 void  taosHashCancelIterate(SHashObj *pHashObj, void *p);
 
 #ifdef __cplusplus

From 2f1c18b6c1eff8505968efe82a8dbeeb7db6ca0c Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Fri, 21 May 2021 14:16:03 +0800
Subject: [PATCH 057/128] add test case

---
 tests/script/general/parser/last_cache.sim    |  71 +++
 .../general/parser/last_cache_query.sim       | 416 ++++++++++++++++++
 tests/script/general/parser/testSuite.sim     |   2 +
 3 files changed, 489 insertions(+)
 create mode 100644 tests/script/general/parser/last_cache.sim
 create mode 100644 tests/script/general/parser/last_cache_query.sim

diff --git a/tests/script/general/parser/last_cache.sim b/tests/script/general/parser/last_cache.sim
new file mode 100644
index 0000000000..9d7da9ddba
--- /dev/null
+++ b/tests/script/general/parser/last_cache.sim
@@ -0,0 +1,71 @@
+system sh/stop_dnodes.sh
+system sh/deploy.sh -n dnode1 -i 1
+system sh/cfg.sh -n dnode1 -c walLevel -v 0
+system sh/cfg.sh -n dnode1 -c maxtablesPerVnode -v 4
+system sh/exec.sh -n dnode1 -s start
+
+sleep 100
+sql connect
+print ======================== dnode1 start
+
+$db = testdb
+
+sql create database $db cachelast 2
+sql use $db
+
+sql create stable st2 (ts timestamp, f1 int, f2 double, f3 binary(10), f4 timestamp) tags (id int)
+
+sql create table tb1 using st2 tags (1);
+sql create table tb2 using st2 tags (2);
+sql create table tb3 using st2 tags (3);
+sql create table tb4 using st2 tags (4);
+sql create table tb5 using st2 tags (1);
+sql create table tb6 using st2 tags (2);
+sql create table tb7 using st2 tags (3);
+sql create table tb8 using st2 tags (4);
+sql create table tb9 using st2 tags (5);
+sql create table tba using st2 tags (5);
+sql create table tbb using st2 tags (5);
+sql create table tbc using st2 tags (5);
+sql create table tbd using st2 tags (5);
+sql create table tbe using st2 tags (5);
+ 
+sql insert into tb1 values ("2021-05-09 10:10:10", 1, 2.0, '3',  -1000)
+sql insert into tb1 values ("2021-05-10 10:10:11", 4, 5.0, NULL, -2000)
+sql insert into tb1 values ("2021-05-12 10:10:12", 6,NULL, NULL, -3000)
+
+sql insert into tb2 values ("2021-05-09 10:11:13",-1,-2.0,'-3',  -1001)
+sql insert into tb2 values ("2021-05-10 10:11:14",-4,-5.0, NULL, -2001)
+sql insert into tb2 values ("2021-05-11 10:11:15",-6,  -7, '-8', -3001)
+
+sql insert into tb3 values ("2021-05-09 10:12:17", 7, 8.0, '9' , -1002)
+sql insert into tb3 values ("2021-05-09 10:12:17",10,11.0, NULL, -2002)
+sql insert into tb3 values ("2021-05-09 10:12:18",12,NULL, NULL, -3002)
+
+sql insert into tb4 values ("2021-05-09 10:12:19",13,14.0,'15' , -1003)
+sql insert into tb4 values ("2021-05-10 10:12:20",16,17.0, NULL, -2003)
+sql insert into tb4 values ("2021-05-11 10:12:21",18,NULL, NULL, -3003)
+
+sql insert into tb5 values ("2021-05-09 10:12:22",19,  20, '21', -1004)
+sql insert into tb6 values ("2021-05-11 10:12:23",22,  23, NULL, -2004)
+sql insert into tb7 values ("2021-05-10 10:12:24",24,NULL, '25', -3004)
+sql insert into tb8 values ("2021-05-11 10:12:25",26,NULL, '27', -4004)
+
+sql insert into tb9 values ("2021-05-09 10:12:26",28,  29, '30', -1005)
+sql insert into tba values ("2021-05-10 10:12:27",31,  32, NULL, -2005)
+sql insert into tbb values ("2021-05-10 10:12:28",33,NULL, '35', -3005)
+sql insert into tbc values ("2021-05-11 10:12:29",36,  37, NULL, -4005)
+sql insert into tbd values ("2021-05-11 10:12:29",NULL,NULL,NULL,NULL )
+
+run general/parser/last_cache_query.sim
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
+
+system sh/exec.sh -n dnode1 -s start
+
+run general/parser/last_cache_query.sim
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
+
+
+
diff --git a/tests/script/general/parser/last_cache_query.sim b/tests/script/general/parser/last_cache_query.sim
new file mode 100644
index 0000000000..2acd000585
--- /dev/null
+++ b/tests/script/general/parser/last_cache_query.sim
@@ -0,0 +1,416 @@
+
+sleep 100
+sql connect
+
+$db = testdb
+
+sql use $db
+
+print "test tb1"
+
+sql select last(ts) from tb1
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-12 10:10:12.000@ then 
+  print $data00
+  return -1
+endi
+
+
+sql select last(f1) from tb1
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 6 then 
+  print $data00
+  return -1
+endi
+
+sql select last(*) from tb1
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-12 10:10:12.000@ then 
+  print $data00
+  return -1
+endi
+if $data01 != 6 then 
+  return -1
+endi
+if $data02 != 5.000000000 then 
+  print $data02
+  return -1
+endi
+if $data03 != 3 then 
+  return -1
+endi
+if $data04 != @70-01-01 07:59:57.000@ then 
+  return -1
+endi
+
+
+sql select last(tb1.*,ts,f4) from tb1
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-12 10:10:12.000@ then 
+  print $data00
+  return -1
+endi
+if $data01 != 6 then 
+  return -1
+endi
+if $data02 != 5.000000000 then 
+  print $data02
+  return -1
+endi
+if $data03 != 3 then 
+  return -1
+endi
+if $data04 != @70-01-01 07:59:57.000@ then 
+  return -1
+endi
+if $data05 != @21-05-12 10:10:12.000@ then 
+  print $data00
+  return -1
+endi
+if $data06 != @70-01-01 07:59:57.000@ then 
+  return -1
+endi
+
+
+
+
+print "test tb2"
+
+sql select last(ts) from tb2
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-11 10:11:15.000@ then 
+  print $data00
+  return -1
+endi
+
+
+sql select last(f1) from tb2
+if $rows != 1 then
+  return -1
+endi
+if $data00 != -6 then 
+  print $data00
+  return -1
+endi
+
+sql select last(*) from tb2
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-11 10:11:15.000@ then 
+  print $data00
+  return -1
+endi
+if $data01 != -6 then 
+  return -1
+endi
+if $data02 != -7.000000000 then 
+  print $data02
+  return -1
+endi
+if $data03 != -8 then 
+  return -1
+endi
+if $data04 != @70-01-01 07:59:56.999@ then 
+  if $data04 != @70-01-01 07:59:57.-01@ then
+    return -1
+  endi
+endi
+
+
+sql select last(tb2.*,ts,f4) from tb2
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-11 10:11:15.000@ then 
+  print $data00
+  return -1
+endi
+if $data01 != -6 then 
+  return -1
+endi
+if $data02 != -7.000000000 then 
+  print $data02
+  return -1
+endi
+if $data03 != -8 then 
+  return -1
+endi
+if $data04 != @70-01-01 07:59:56.999@ then 
+  if $data04 != @70-01-01 07:59:57.-01@ then
+    return -1
+  endi
+endi
+if $data05 != @21-05-11 10:11:15.000@ then 
+  print $data00
+  return -1
+endi
+if $data06 != @70-01-01 07:59:56.999@ then 
+  if $data04 != @70-01-01 07:59:57.-01@ then
+    return -1
+  endi
+endi
+
+
+
+
+
+
+
+print "test tbd"
+sql select last(*) from tbd
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-11 10:12:29.000@ then 
+  print $data00
+  return -1
+endi
+if $data01 != NULL then 
+  return -1
+endi
+if $data02 != NULL then 
+  print $data02
+  return -1
+endi
+if $data03 != NULL then 
+  return -1
+endi
+if $data04 != NULL then 
+  return -1
+endi
+
+
+
+print "test tbe"
+sql select last(*) from tbe
+if $rows != 0 then
+  return -1
+endi
+
+
+
+
+
+print "test stable"
+sql select last(ts) from st2
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-12 10:10:12.000@ then 
+  print $data00
+  return -1
+endi
+
+
+sql select last(f1) from st2
+if $rows != 1 then
+  return -1
+endi
+if $data00 != 6 then 
+  print $data00
+  return -1
+endi
+
+sql select last(*) from st2
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-12 10:10:12.000@ then 
+  print $data00
+  return -1
+endi
+if $data01 != 6 then 
+  return -1
+endi
+if $data02 != 37.000000000 then 
+  print $data02
+  return -1
+endi
+if $data03 != 27 then 
+  return -1
+endi
+if $data04 != @70-01-01 07:59:57.000@ then 
+  return -1
+endi
+
+
+sql select last(st2.*,ts,f4) from st2
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-12 10:10:12.000@ then 
+  print $data00
+  return -1
+endi
+if $data01 != 6 then 
+  return -1
+endi
+if $data02 != 37.000000000 then 
+  print $data02
+  return -1
+endi
+if $data03 != 27 then 
+  return -1
+endi
+if $data04 != @70-01-01 07:59:57.000@ then 
+  return -1
+endi
+if $data05 != @21-05-12 10:10:12.000@ then 
+  print $data00
+  return -1
+endi
+if $data06 != @70-01-01 07:59:57.000@ then 
+  return -1
+endi
+
+
+sql select last(*) from st2 group by id
+if $rows != 5 then
+  return -1
+endi
+if $data00 != @21-05-12 10:10:12.000@ then 
+  return -1
+endi
+if $data01 != 6 then 
+  return -1
+endi
+if $data02 != 5.000000000 then 
+  print $data02
+  return -1
+endi
+if $data03 != 21 then 
+  return -1
+endi
+if $data04 != @70-01-01 07:59:57.000@ then 
+  return -1
+endi
+if $data05 != 1 then 
+  return -1
+endi
+if $data10 != @21-05-11 10:12:23.000@ then 
+  return -1
+endi
+if $data11 != 22 then 
+  return -1
+endi
+if $data12 != 23.000000000 then 
+  print $data02
+  return -1
+endi
+if $data13 != -8 then 
+  return -1
+endi
+if $data14 != @70-01-01 07:59:57.996@ then 
+if $data14 != @70-01-01 07:59:58.-04@ then 
+  print $data14
+  return -1
+endi
+endi
+if $data15 != 2 then 
+  return -1
+endi
+if $data20 != @21-05-10 10:12:24.000@ then 
+  return -1
+endi
+if $data21 != 24 then 
+  return -1
+endi
+if $data22 != 8.000000000 then 
+  print $data02
+  return -1
+endi
+if $data23 != 25 then 
+  return -1
+endi
+if $data24 != @70-01-01 07:59:56.996@ then 
+if $data24 != @70-01-01 07:59:57.-04@ then 
+  return -1
+endi
+endi
+if $data25 != 3 then 
+  return -1
+endi
+if $data30 != @21-05-11 10:12:25.000@ then 
+  return -1
+endi
+if $data31 != 26 then 
+  return -1
+endi
+if $data32 != 17.000000000 then 
+  print $data02
+  return -1
+endi
+if $data33 != 27 then 
+  return -1
+endi
+if $data34 != @70-01-01 07:59:55.996@ then 
+if $data34 != @70-01-01 07:59:56.-04@ then 
+  return -1
+endi
+endi
+if $data35 != 4 then 
+  return -1
+endi
+if $data40 != @21-05-11 10:12:29.000@ then 
+  return -1
+endi
+if $data41 != 36 then 
+  return -1
+endi
+if $data42 != 37.000000000 then 
+  print $data02
+  return -1
+endi
+if $data43 != 35 then 
+  return -1
+endi
+if $data44 != @70-01-01 07:59:55.995@ then 
+if $data44 != @70-01-01 07:59:56.-05@ then 
+  return -1
+endi
+endi
+if $data45 != 5 then 
+  return -1
+endi
+
+
+print "test tbn"
+sql create table tbn (ts timestamp, f1 int, f2 double, f3 binary(10), f4 timestamp)
+sql insert into tbn values ("2021-05-09 10:10:10", 1, 2.0, '3',  -1000)
+sql insert into tbn values ("2021-05-10 10:10:11", 4, 5.0, NULL, -2000)
+sql insert into tbn values ("2021-05-12 10:10:12", 6,NULL, NULL, -3000)
+sql insert into tbn values ("2021-05-13 10:10:12", NULL,NULL, NULL,NULL)
+
+sql select last(*) from tbn;
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @21-05-13 10:10:12.000@ then 
+  print $data00
+  return -1
+endi
+if $data01 != 6 then 
+  return -1
+endi
+if $data02 != 5.000000000 then 
+  print $data02
+  return -1
+endi
+if $data03 != 3 then 
+  return -1
+endi
+if $data04 != @70-01-01 07:59:57.000@ then 
+  return -1
+endi
+
diff --git a/tests/script/general/parser/testSuite.sim b/tests/script/general/parser/testSuite.sim
index 1294b093c2..6a3b71e773 100644
--- a/tests/script/general/parser/testSuite.sim
+++ b/tests/script/general/parser/testSuite.sim
@@ -59,4 +59,6 @@ run general/parser/having.sim
 run general/parser/having_child.sim
 run general/parser/slimit_alter_tags.sim
 run general/parser/binary_escapeCharacter.sim
+run general/parser/between_and.sim
+run general/parser/last_cache.sim
 

From 3062b1dabb3aa85ea5088edbfe815d33f01d1114 Mon Sep 17 00:00:00 2001
From: cpwu <cpwu@taosdata.com>
Date: Fri, 21 May 2021 14:37:52 +0800
Subject: [PATCH 058/128] [TD-4153] <test> add case to resolve use taosdemo
 tools insert and query operation

---
 tests/pytest/fulltest.sh                     |   2 +-
 tests/pytest/perfbenchmark/taosdemoInsert.py | 387 +++++++++++++++++++
 2 files changed, 388 insertions(+), 1 deletion(-)
 create mode 100644 tests/pytest/perfbenchmark/taosdemoInsert.py

diff --git a/tests/pytest/fulltest.sh b/tests/pytest/fulltest.sh
index a748c9dd2d..d8e2a31e70 100755
--- a/tests/pytest/fulltest.sh
+++ b/tests/pytest/fulltest.sh
@@ -183,7 +183,7 @@ python3 ./test.py -f stable/query_after_reset.py
 # perfbenchmark
 python3 ./test.py -f perfbenchmark/bug3433.py
 #python3 ./test.py -f perfbenchmark/bug3589.py
-
+python3 ./test.py -f perfbenchmark/taosdemoInsert.py
 
 #query
 python3 ./test.py -f query/filter.py
diff --git a/tests/pytest/perfbenchmark/taosdemoInsert.py b/tests/pytest/perfbenchmark/taosdemoInsert.py
new file mode 100644
index 0000000000..59a8143d5a
--- /dev/null
+++ b/tests/pytest/perfbenchmark/taosdemoInsert.py
@@ -0,0 +1,387 @@
+###################################################################
+#           Copyright (c) 2016 by TAOS Technologies, Inc.
+#                     All rights reserved.
+#
+#  This file is proprietary and confidential to TAOS Technologies.
+#  No part of this file may be reproduced, stored, transmitted,
+#  disclosed or used in any form or by any means other than as
+#  expressly provided by the written permission from Jianhui Tao
+#
+###################################################################
+
+# -*- coding: utf-8 -*-
+
+import taos
+import sys
+import os
+import json
+import argparse
+import subprocess
+import datetime
+import re
+
+
+from multiprocessing import cpu_count
+from util.log import *
+from util.sql import *
+from util.cases import *
+from util.dnodes import *
+from util.dnodes import TDDnode
+
+class Taosdemo:
+    def __init__(self, clearCache, dbName, keep):
+        self.clearCache = clearCache
+        self.dbname = dbName
+        self.drop = "yes"
+        self.keep = keep
+        self.host = "127.0.0.1"
+        self.user = "root"
+        self.password = "taosdata"
+        # self.config = "/etc/taosperf"
+        # self.conn = taos.connect(
+        #     self.host,
+        #     self.user,
+        #     self.password,
+        #     self.config)
+
+    # env config
+    def getBuildPath(self) -> str:
+        selfPath = os.path.dirname(os.path.realpath(__file__))
+
+        if ("community" in selfPath):
+            projPath = selfPath[:selfPath.find("community")]
+        else:
+            projPath = selfPath[:selfPath.find("tests")]
+
+        for root, dirs, files in os.walk(projPath):
+            if ("taosd" in files):
+                rootRealPath = os.path.dirname(os.path.realpath(root))
+                if ("packaging" not in rootRealPath):
+                    buildPath = root[:len(root) - len("/debug/build/bin")]
+                    break
+        return buildPath
+
+    def getExeToolsDir(self) -> str:
+        self.debugdir = self.getBuildPath() + "/debug/build/bin"
+        return self.debugdir
+
+    def getCfgDir(self) -> str:
+        self.config = self.getBuildPath() + "/sim/dnode1/cfg"
+        return self.config
+
+    # taodemo insert file config
+    def dbinfocfg(self) -> dict:
+        return {
+            "name": self.dbname,
+            "drop": self.drop,
+            "replica": 1,
+            "days": 10,
+            "cache": 16,
+            "blocks": 8,
+            "precision": "ms",
+            "keep": self.keep,
+            "minRows": 100,
+            "maxRows": 4096,
+            "comp": 2,
+            "walLevel": 1,
+            "cachelast": 0,
+            "quorum": 1,
+            "fsync": 3000,
+            "update": 0
+        }
+
+    def type_check(func):
+        def wrapper(self, **kwargs):
+            num_types = ["int", "float", "bigint", "tinyint", "smallint", "double"]
+            str_types = ["binary", "nchar"]
+            for k ,v in kwargs.items():
+                if k.lower() not in num_types and k.lower() not in str_types:
+                    return f"args {k} type error, not allowed"
+                elif not isinstance(v, (int, list, tuple)):
+                    return f"value {v} type error, not allowed"
+                elif k.lower() in num_types and not isinstance(v, int):
+                    return f"arg {v} takes 1 positional argument must be type int "
+                elif isinstance(v, (list,tuple)) and len(v) > 2:
+                    return f"arg {v} takes from 1 to 2 positional arguments but more than 2 were given "
+                elif isinstance(v,(list,tuple))  and [ False for _ in v if not isinstance(_, int) ]:
+                    return f"arg {v} takes from 1 to 2 positional arguments must be type int "
+                else:
+                    pass
+            return func(self, **kwargs)
+        return wrapper
+
+    @type_check
+    def column_tag_count(self, **column_tag) -> list :
+        init_column_tag = []
+        for k, v in column_tag.items():
+            if re.search(k, "int, float, bigint, tinyint, smallint, double", re.IGNORECASE):
+                init_column_tag.append({"type": k, "count": v})
+            elif re.search(k, "binary, nchar", re.IGNORECASE):
+                if isinstance(v, int):
+                    init_column_tag.append({"type": k, "count": v, "len":8})
+                elif len(v) == 1:
+                    init_column_tag.append({"type": k, "count": v[0], "len": 8})
+                else:
+                    init_column_tag.append({"type": k, "count": v[0], "len": v[1]})
+        return init_column_tag
+
+    def stbcfg(self, stb: str, child_tab_count: int, rows: int, prechildtab: str, columns: dict, tags: dict) -> dict:
+        return {
+            "name": stb,
+            "child_table_exists": "no",
+            "childtable_count": child_tab_count,
+            "childtable_prefix": prechildtab,
+            "auto_create_table": "no",
+            "batch_create_tbl_num": 10,
+            "data_source": "rand",
+            "insert_mode": "taosc",
+            "insert_rows": rows,
+            "childtable_limit": 0,
+            "childtable_offset": 0,
+            "rows_per_tbl": 1,
+            "max_sql_len": 65480,
+            "disorder_ratio": 0,
+            "disorder_range": 1000,
+            "timestamp_step": 10,
+            "start_timestamp": f"{datetime.datetime.now():%F %X}",
+            "sample_format": "csv",
+            "sample_file": "./sample.csv",
+            "tags_file": "",
+            "columns": self.column_tag_count(**columns),
+            "tags": self.column_tag_count(**tags)
+        }
+
+    def schemecfg(self,intcount=1,floatcount=0,bcount=0,tcount=0,scount=0,doublecount=0,binarycount=0,ncharcount=0):
+        return  {
+            "INT": intcount,
+            "FLOAT": floatcount,
+            "BIGINT": bcount,
+            "TINYINT": tcount,
+            "SMALLINT": scount,
+            "DOUBLE": doublecount,
+            "BINARY": binarycount,
+            "NCHAR": ncharcount
+        }
+
+    def insertcfg(self,db: dict, stbs: list) -> dict:
+        return {
+            "filetype": "insert",
+            "cfgdir": self.config,
+            "host": self.host,
+            "port": 6030,
+            "user": self.user,
+            "password": self.password,
+            "thread_count": cpu_count(),
+            "thread_count_create_tbl": cpu_count(),
+            "result_file": "/tmp/insert_res.txt",
+            "confirm_parameter_prompt": "no",
+            "insert_interval": 0,
+            "num_of_records_per_req": 100,
+            "max_sql_len": 1024000,
+            "databases": [{
+                "dbinfo": db,
+                "super_tables": stbs
+            }]
+        }
+
+    def createinsertfile(self,db: dict, stbs: list) -> str:
+        date = datetime.datetime.now()
+        file_create_table = f"/tmp/insert_{date:%F-%H%M}.json"
+
+        with open(file_create_table, 'w') as f:
+            json.dump(self.insertcfg(db, stbs), f)
+
+        return file_create_table
+
+    # taosdemo query file config
+    def querysqls(self, sql: str) -> list:
+        return [{"sql":sql,"result":""}]
+
+    def querycfg(self, sql: str) -> dict:
+        return {
+            "filetype": "query",
+            "cfgdir": self.config,
+            "host": self.host,
+            "port": 6030,
+            "user": self.user,
+            "password": self.password,
+            "confirm_parameter_prompt": "yes",
+            "query_times": 10,
+            "query_mode": "taosc",
+            "databases": self.dbname,
+            "specified_table_query": {
+                "query_interval": 0,
+                "concurrent": cpu_count(),
+                "sqls": self.querysqls(sql)
+            }
+        }
+
+    def createqueryfile(self, sql: str):
+        date = datetime.datetime.now()
+        file_query_table = f"/tmp/query_{date:%F-%H%M}.json"
+
+        with open(file_query_table,"w") as f:
+            json.dump(self.querycfg(sql), f)
+
+        return file_query_table
+
+    # Execute taosdemo, and delete temporary files when finished
+    def taosdemotable(self, filepath: str, resultfile="/dev/null"):
+        taosdemopath = self.getBuildPath() + "/debug/build/bin"
+        with open(filepath,"r") as f:
+            filetype = json.load(f)["filetype"]
+            if filetype == "insert":
+                taosdemo_table_cmd = f"{taosdemopath}/taosdemo -f {filepath}  > {resultfile} 2>&1"
+            else:
+                taosdemo_table_cmd = f"yes | {taosdemopath}/taosdemo -f {filepath}  > {resultfile} 2>&1"
+        try:
+            _ = subprocess.check_output(taosdemo_table_cmd, shell=True).decode("utf-8")
+        except subprocess.CalledProcessError as e:
+            _ = e.output
+
+    def droptmpfile(self, filepath: str):
+        drop_file_cmd = f"[ -f {filepath} ] && rm -f  {filepath}"
+        try:
+            _ = subprocess.check_output(drop_file_cmd, shell=True).decode("utf-8")
+        except subprocess.CalledProcessError as e:
+            _ = e.output
+
+    # TODO:需要完成TD-4153的数据插入和客户端请求的性能查询。
+    def td4153insert(self):
+
+        tdLog.printNoPrefix("========== start to create table and insert data ==========")
+        self.dbname = "td4153"
+        db = self.dbinfocfg()
+        stblist = []
+
+        columntype = self.schemecfg(intcount=1, ncharcount=100)
+        tagtype = self.schemecfg(intcount=1)
+        stbname = "stb1"
+        prechild = "t1"
+        stable = self.stbcfg(
+            stb=stbname,
+            prechildtab=prechild,
+            child_tab_count=2,
+            rows=10000,
+            columns=columntype,
+            tags=tagtype
+        )
+        stblist.append(stable)
+        insertfile = self.createinsertfile(db=db, stbs=stblist)
+
+        nmon_file = f"/tmp/insert_{datetime.datetime.now():%F-%H%M}.nmon"
+        cmd = f"nmon -s5 -F {nmon_file} -m /tmp/"
+        try:
+            _ = subprocess.check_output(cmd, shell=True).decode("utf-8")
+        except subprocess.CalledProcessError as e:
+            _ = e.output
+
+        self.taosdemotable(insertfile)
+        self.droptmpfile(insertfile)
+        self.droptmpfile("/tmp/insert_res.txt")
+
+        # In order to prevent too many performance files from being generated, the nmon file is deleted.
+        # and the delete statement can be cancelled during the actual test.
+        self.droptmpfile(nmon_file)
+
+        cmd = f"ps -ef|grep -w nmon| grep -v grep | awk '{{print $2}}'"
+        try:
+            time.sleep(10)
+            _ = subprocess.check_output(cmd,shell=True).decode("utf-8")
+        except BaseException as e:
+            raise e
+
+    def td4153query(self):
+        tdLog.printNoPrefix("========== start to query operation ==========")
+
+        sqls = {
+            "select_all": "select * from stb1",
+            "select_join": "select * from t10, t11 where t10.ts=t11.ts"
+        }
+        for type, sql in sqls.items():
+            result_file = f"/tmp/queryResult_{type}.log"
+            query_file = self.createqueryfile(sql)
+            try:
+                self.taosdemotable(query_file, resultfile=result_file)
+            except subprocess.CalledProcessError as e:
+                out_put = e.output
+            if result_file:
+                print(f"execute rows {type.split('_')[1]} sql, the sql is: {sql}")
+                max_sql_time_cmd = f'''
+                grep -o Spent.*s {result_file} |awk 'NR==1{{max=$2;next}}{{max=max>$2?max:$2}}END{{print "Max=",max,"s"}}'
+                 '''
+                max_sql_time = subprocess.check_output(max_sql_time_cmd, shell=True).decode("UTF-8")
+                print(f"{type.split('_')[1]} rows sql time : {max_sql_time}")
+
+                min_sql_time_cmd = f'''
+                grep -o Spent.*s {result_file} |awk 'NR==1{{min=$2;next}}{{min=min<$2?min:$2}}END{{print "Min=",min,"s"}}'
+                '''
+                min_sql_time = subprocess.check_output(min_sql_time_cmd, shell=True).decode("UTF-8")
+                print(f"{type.split('_')[1]} rows sql time : {min_sql_time}")
+
+                avg_sql_time_cmd = f'''
+                grep -o Spent.*s {result_file} |awk '{{sum+=$2}}END{{print "Average=",sum/NR,"s"}}'
+                '''
+                avg_sql_time = subprocess.check_output(avg_sql_time_cmd, shell=True).decode("UTF-8")
+                print(f"{type.split('_')[1]} rows sql time : {avg_sql_time}")
+
+            self.droptmpfile(query_file)
+            self.droptmpfile(result_file)
+
+        drop_query_tmt_file_cmd = " find ./ -name 'querySystemInfo-*'  -type f -exec rm {} \; "
+        try:
+            _ = subprocess.check_output(drop_query_tmt_file_cmd, shell=True).decode("utf-8")
+        except subprocess.CalledProcessError as e:
+            _ = e.output
+        pass
+
+    def td4153(self):
+        self.td4153insert()
+        self.td4153query()
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        '-r',
+        '--remove-cache',
+        action='store_true',
+        default=False,
+        help='clear cache before query (default: False)')
+    parser.add_argument(
+        '-d',
+        '--database-name',
+        action='store',
+        default='db',
+        type=str,
+        help='Database name to be created (default: db)')
+    parser.add_argument(
+        '-k',
+        '--keep-time',
+        action='store',
+        default=3650,
+        type=int,
+        help='Database keep parameters (default: 3650)')
+
+    args = parser.parse_args()
+    taosdemo = Taosdemo(args.remove_cache, args.database_name, args.keep_time)
+    # taosdemo.conn = taos.connect(
+    #     taosdemo.host,
+    #     taosdemo.user,
+    #     taosdemo.password,
+    #     taosdemo.config
+    # )
+
+    debugdir = taosdemo.getExeToolsDir()
+    cfgdir = taosdemo.getCfgDir()
+    cmd = f"{debugdir}/taosd -c {cfgdir} >/dev/null 2>&1 &"
+    try:
+        _ = subprocess.check_output(cmd, shell=True).decode("utf-8")
+    except subprocess.CalledProcessError as e:
+        _ = e.output
+
+    if taosdemo.clearCache:
+        # must be root permission
+        subprocess.check_output("echo 3 > /proc/sys/vm/drop_caches", shell=True).decode("utf-8")
+
+    taosdemo.td4153()

From 210c0ae3f85b182b18237ae53541c95a7fe085fb Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Fri, 21 May 2021 15:08:17 +0800
Subject: [PATCH 059/128] [TD-4034]fix cache last valid range

---
 documentation20/cn/11.administrator/docs.md | 2 +-
 src/inc/taosdef.h                           | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/documentation20/cn/11.administrator/docs.md b/documentation20/cn/11.administrator/docs.md
index 26cfa91beb..ee2f34ff11 100644
--- a/documentation20/cn/11.administrator/docs.md
+++ b/documentation20/cn/11.administrator/docs.md
@@ -129,7 +129,7 @@ taosd -C
 - blocks：每个VNODE（TSDB）中有多少cache大小的内存块。因此一个VNODE的用的内存大小粗略为（cache * blocks）。单位为块，默认值：4。（可通过 alter database 修改）
 - replica：副本个数，取值范围：1-3。单位为个，默认值：1。（可通过 alter database 修改）
 - precision：时间戳精度标识，ms表示毫秒，us表示微秒。默认值：ms。
-- cacheLast：是否在内存中缓存子表的最近数据，0：关闭；1：缓存子表最近一行数据；2：缓存子表每一列的最近的非NULL值，默认值：0。（可通过 alter database 修改）（从 2.0.11 版本开始支持此参数）
+- cacheLast：是否在内存中缓存子表的最近数据，0：关闭；1：缓存子表最近一行数据；2：缓存子表每一列的最近的非NULL值，3：同时打开缓存最近行和列功能，默认值：0。（可通过 alter database 修改）（从 2.0.11 版本开始支持此参数）
 
 对于一个应用场景，可能有多种数据特征的数据并存，最佳的设计是将具有相同数据特征的表放在一个库里，这样一个应用有多个库，而每个库可以配置不同的存储参数，从而保证系统有最优的性能。TDengine允许应用在创建库时指定上述存储参数，如果指定，该参数就将覆盖对应的系统配置参数。举例，有下述SQL：
 
diff --git a/src/inc/taosdef.h b/src/inc/taosdef.h
index 2882faf7be..f888d037b3 100644
--- a/src/inc/taosdef.h
+++ b/src/inc/taosdef.h
@@ -298,7 +298,7 @@ do { \
 #define TSDB_DEFAULT_DB_UPDATE_OPTION   0
 
 #define TSDB_MIN_DB_CACHE_LAST_ROW      0
-#define TSDB_MAX_DB_CACHE_LAST_ROW      2
+#define TSDB_MAX_DB_CACHE_LAST_ROW      3
 #define TSDB_DEFAULT_CACHE_LAST_ROW     0
 
 #define TSDB_MIN_FSYNC_PERIOD           0

From 23313ecf677314f3d9fd373bd5808e6d32fc0c25 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Fri, 21 May 2021 15:14:36 +0800
Subject: [PATCH 060/128] fix bug

---
 src/tsdb/src/tsdbRead.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index c78739d7ce..f40c496bf4 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -2571,7 +2571,7 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
             continue;
           }
 
-          SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, n);
+          pColInfo = taosArrayGet(pQueryHandle->pColumns, n);
           pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
 
           if (pColInfo->info.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
@@ -2596,7 +2596,7 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
 
     // leave the real ts column as the last row, because last function only (not stable) use the last row as res
     if (priKey != TSKEY_INITIAL_VAL) {
-      SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, priIdx);
+      pColInfo = taosArrayGet(pQueryHandle->pColumns, priIdx);
       pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;
     
       *(TSKEY *)pData = priKey;

From 17ee7323815d3bbc8a9f859de4e9ace29f6f400b Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Fri, 21 May 2021 15:15:01 +0800
Subject: [PATCH 061/128] Hotfix/sangshuduo/td 3913 mips compile support
 (#6182)

* [TD-3913]<fix>: mips compile support.

* [TD-3912]<fix>: support mips64 compile.

add mips64 header file and modify tcrc32c.c for mips64.

* [TD-3913]<fix>: mips compile support.

verified on real loongson machine.

* fix cmake.

* fix gcc 4.8 compile error.

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 cmake/platform.inc           | 6 ++++++
 src/os/src/detail/osSignal.c | 6 +++---
 src/util/src/tcrc32c.c       | 2 +-
 3 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/cmake/platform.inc b/cmake/platform.inc
index dcd0183e27..5f7391c996 100755
--- a/cmake/platform.inc
+++ b/cmake/platform.inc
@@ -102,6 +102,12 @@ IF ("${CPUTYPE}" STREQUAL "")
     SET(TD_LINUX TRUE)
     SET(TD_LINUX_64 FALSE)
     SET(TD_ARM_64 TRUE)
+  ELSEIF (CMAKE_SYSTEM_PROCESSOR MATCHES "mips64")
+    SET(CPUTYPE "mips64")
+    MESSAGE(STATUS "Set CPUTYPE to mips64")
+    SET(TD_LINUX TRUE)
+    SET(TD_LINUX_64 FALSE)
+    SET(TD_MIPS_64 TRUE)
   ENDIF ()
 
 ELSE ()
diff --git a/src/os/src/detail/osSignal.c b/src/os/src/detail/osSignal.c
index e1a0e84e7f..38572bdfa1 100644
--- a/src/os/src/detail/osSignal.c
+++ b/src/os/src/detail/osSignal.c
@@ -23,14 +23,14 @@
 typedef void (*FLinuxSignalHandler)(int32_t signum, siginfo_t *sigInfo, void *context);
 
 void taosSetSignal(int32_t signum, FSignalHandler sigfp) {
-  struct sigaction act = {{0}};	
+  struct sigaction act; memset(&act, 0, sizeof(act));
 #if 1
   act.sa_flags = SA_SIGINFO;
   act.sa_sigaction = (FLinuxSignalHandler)sigfp;
 #else  
-  act.sa_handler = sigfp;	
+  act.sa_handler = sigfp;
 #endif  
-  sigaction(signum, &act, NULL);		
+  sigaction(signum, &act, NULL);
 }
 
 void taosIgnSignal(int32_t signum) {
diff --git a/src/util/src/tcrc32c.c b/src/util/src/tcrc32c.c
index 054b8f8171..675f17f900 100644
--- a/src/util/src/tcrc32c.c
+++ b/src/util/src/tcrc32c.c
@@ -17,7 +17,7 @@
 	  misrepresented as being the original software.
 	  3. This notice may not be removed or altered from any source distribution.
 	*/
-#ifndef _TD_ARM_
+#if !defined(_TD_ARM_) && !defined(_TD_MIPS_)
 #include <nmmintrin.h>
 #endif
 

From 9be55c32b127f343457458cc23c4c58a7c7830de Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Fri, 21 May 2021 15:16:53 +0800
Subject: [PATCH 062/128] fix bug

---
 src/tsdb/src/tsdbRead.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index f40c496bf4..491a4b2db0 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -2493,6 +2493,7 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
   SQueryFilePos* cur = &pQueryHandle->cur;
   TSKEY priKey = TSKEY_INITIAL_VAL;
   int32_t priIdx = -1;
+  SColumnInfoData* pColInfo = NULL;
 
   while (++pQueryHandle->activeIndex < numOfTables) {
     STableCheckInfo* pCheckInfo = taosArrayGet(pQueryHandle->pTableCheckInfo, pQueryHandle->activeIndex);
@@ -2508,7 +2509,7 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
     
     int32_t i = 0, j = 0;
     while(i < tgNumOfCols && j < numOfCols) {
-      SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, i);
+      pColInfo = taosArrayGet(pQueryHandle->pColumns, i);
       if (pTable->lastCols[j].colId < pColInfo->info.colId) {
         j++;
         continue;
@@ -2606,7 +2607,7 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
           continue;
         }
       
-        SColumnInfoData* pColInfo = taosArrayGet(pQueryHandle->pColumns, n);
+        pColInfo = taosArrayGet(pQueryHandle->pColumns, n);
         pData = (char*)pColInfo->pData + numOfRows * pColInfo->info.bytes;;
       
         assert (pColInfo->info.colId != PRIMARYKEY_TIMESTAMP_COL_INDEX);

From 4b672b459ce1f20240f32f3c5d4b8ef7ba888add Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Fri, 21 May 2021 17:31:00 +0800
Subject: [PATCH 063/128] [td-225]

---
 src/mnode/src/mnodeTable.c                |  6 +++++-
 tests/script/general/parser/testSuite.sim | 22 +++++++++++-----------
 2 files changed, 16 insertions(+), 12 deletions(-)

diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index e35874b585..5297cbaca1 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -2443,8 +2443,8 @@ static int32_t mnodeDoGetChildTableMeta(SMnodeMsg *pMsg, STableMetaMsg *pMeta) {
     pMeta->vgroup.numOfEps++;
     mnodeDecDnodeRef(pDnode);
   }
-  pMeta->vgroup.vgId = htonl(pMsg->pVgroup->vgId);
 
+  pMeta->vgroup.vgId = htonl(pMsg->pVgroup->vgId);
   mDebug("msg:%p, app:%p table:%s, uid:%" PRIu64 " table meta is retrieved, vgId:%d tid:%d", pMsg, pMsg->rpcMsg.ahandle,
          pTable->info.tableId, pTable->uid, pTable->vgId, pTable->tid);
 
@@ -2917,6 +2917,8 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
     }
 
     mnodeDecTableRef(pMsg->pTable);
+    assert(((SCTableObj*)pMsg->pTable)->refCount >= 1);
+    pMsg->pTable = NULL;
   }
 
   char* msg = (char*) pMultiMeta + pMultiMeta->contLen;
@@ -2932,6 +2934,7 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
 
   for(int32_t i = 0; i < numOfVgroupList; ++i) {
     char* name = taosArrayGetP(pList, i);
+
     SSTableObj *pTable = mnodeGetSuperTable(name);
     if (pTable == NULL) {
       mError("msg:%p, app:%p stable:%s, not exist while get stable vgroup info", pMsg, pMsg->rpcMsg.ahandle, name);
@@ -2955,6 +2958,7 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
   tfree(nameList);
   rpcFreeCont(pMultiMeta);
   taosArrayDestroy(pList);
+  pMsg->pTable = NULL;
 
   return code;
 }
diff --git a/tests/script/general/parser/testSuite.sim b/tests/script/general/parser/testSuite.sim
index d7c6bd4819..f263593b3d 100644
--- a/tests/script/general/parser/testSuite.sim
+++ b/tests/script/general/parser/testSuite.sim
@@ -1,14 +1,14 @@
-#run general/parser/alter.sim
-#run general/parser/alter1.sim
-#run general/parser/alter_stable.sim
-#run general/parser/auto_create_tb.sim
-#run general/parser/auto_create_tb_drop_tb.sim
-#run general/parser/col_arithmetic_operation.sim
-#run general/parser/columnValue.sim
-#run general/parser/commit.sim
-#run general/parser/create_db.sim
-#run general/parser/create_mt.sim
-#run general/parser/create_tb.sim
+run general/parser/alter.sim
+run general/parser/alter1.sim
+run general/parser/alter_stable.sim
+run general/parser/auto_create_tb.sim
+run general/parser/auto_create_tb_drop_tb.sim
+run general/parser/col_arithmetic_operation.sim
+run general/parser/columnValue.sim
+run general/parser/commit.sim
+run general/parser/create_db.sim
+run general/parser/create_mt.sim
+run general/parser/create_tb.sim
 run general/parser/dbtbnameValidate.sim
 run general/parser/fill.sim
 run general/parser/fill_stb.sim

From 3dc445f99f522d2aaa5e03ecf00157bef60ec75c Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Fri, 21 May 2021 17:31:26 +0800
Subject: [PATCH 064/128] [td-225]

---
 src/client/inc/tscUtil.h        |   3 +-
 src/client/inc/tsclient.h       |  33 +++++---
 src/client/src/tscAsync.c       |   2 +-
 src/client/src/tscParseInsert.c |  33 ++++----
 src/client/src/tscPrepare.c     |  72 +++++++++---------
 src/client/src/tscSQLParser.c   |   6 +-
 src/client/src/tscServer.c      |  46 ++++++------
 src/client/src/tscSql.c         |   6 +-
 src/client/src/tscSubquery.c    |   8 +-
 src/client/src/tscUtil.c        | 129 ++++++++------------------------
 10 files changed, 141 insertions(+), 197 deletions(-)

diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index 0be65633af..401eeb5d87 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -237,7 +237,7 @@ void        tscInitQueryInfo(SQueryInfo* pQueryInfo);
 void        tscClearSubqueryInfo(SSqlCmd* pCmd);
 int32_t     tscAddQueryInfo(SSqlCmd *pCmd);
 SQueryInfo *tscGetQueryInfo(SSqlCmd* pCmd);
-SQueryInfo *tscGetQueryInfoS(SSqlCmd *pCmd, int32_t subClauseIndex);
+SQueryInfo *tscGetQueryInfoS(SSqlCmd *pCmd);
 
 void tscClearTableMetaInfo(STableMetaInfo* pTableMetaInfo);
 
@@ -256,7 +256,6 @@ int  tscGetTableMeta(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo);
 int  tscGetTableMetaEx(SSqlObj* pSql, STableMetaInfo* pTableMetaInfo, bool createIfNotExists);
 
 void tscResetForNextRetrieve(SSqlRes* pRes);
-void tscDoQuery(SSqlObj* pSql);
 void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo);
 void doExecuteQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo);
 
diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index b335b7d53d..af8d0a3b80 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -251,19 +251,32 @@ typedef struct {
   SVgroupsInfo *pVgroupInfo;
 } STableMetaVgroupInfo;
 
+typedef struct SInsertStatementParam {
+  SName      **pTableNameList;          // all involved tableMeta list of current insert sql statement.
+  int32_t      numOfTables;
+  SHashObj    *pTableBlockHashList;     // data block for each table
+  SArray      *pDataBlocks;             // SArray<STableDataBlocks*>. Merged submit block for each vgroup
+  int8_t       schemaAttached;          // denote if submit block is built with table schema or not
+  STagData     tagData;                 // NOTE: pTagData->data is used as a variant length array
+  int32_t      dataSourceType;          // from file or from sql statement
+
+  char         msg[512];                // error message
+  char        *sql;                     // current sql statement position
+  uint32_t     insertType;              // TODO remove it
+} SInsertStatementParam;
+
 // TODO extract sql parser supporter
 typedef struct {
   int     command;
   uint8_t msgType;
+  SInsertStatementParam insertParam;
   char    reserve1[3];        // fix bus error on arm32
   bool    autoCreated;        // create table if it is not existed during retrieve table meta in mnode
 
   union {
     int32_t count;
-    int32_t numOfTablesInSubmit;
   };
 
-  uint32_t     insertType;   // TODO remove it
   char *       curSql;       // current sql, resume position of sql after parsing paused
   int8_t       parseFinished;
   char         reserve2[3];        // fix bus error on arm32
@@ -276,24 +289,22 @@ typedef struct {
 
   SHashObj    *pTableMetaMap;  // local buffer to keep the queried table meta, before validating the AST
   SQueryInfo  *pQueryInfo;
-
-  int32_t      clauseIndex;  // index of multiple subclause query
   SQueryInfo  *active;       // current active query info
 
   int32_t      batchSize;    // for parameter ('?') binding and batch processing
   int32_t      numOfParams;
 
   int8_t       dataSourceType; // load data from file or not
-  char         reserve4[3];         // fix bus error on arm32
-  int8_t       submitSchema;   // submit block is built with table schema
-  char         reserve5[3];         // fix bus error on arm32
+  char         reserve4[3];    // fix bus error on arm32
+//  int8_t       submitSchema;   // submit block is built with table schema
+  char         reserve5[3];    // fix bus error on arm32
   STagData     tagData;        // NOTE: pTagData->data is used as a variant length array
 
-  SName      **pTableNameList; // all involved tableMeta list of current insert sql statement.
-  int32_t      numOfTables;
+//  SName      **pTableNameList; // all involved tableMeta list of current insert sql statement.
+//  int32_t      numOfTables;
 
-  SHashObj    *pTableBlockHashList;     // data block for each table
-  SArray      *pDataBlocks;             // SArray<STableDataBlocks*>. Merged submit block for each vgroup
+//  SHashObj    *pTableBlockHashList;     // data block for each table
+//  SArray      *pDataBlocks;             // SArray<STableDataBlocks*>. Merged submit block for each vgroup
   int32_t      resColumnId;
 } SSqlCmd;
 
diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c
index 72432f602c..b968bfc613 100644
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -460,7 +460,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
           goto _error;
         }
 
-        if (pCmd->insertType == TSDB_QUERY_TYPE_STMT_INSERT) {
+        if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_STMT_INSERT)){
           STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
           code = tscGetTableMeta(pSql, pTableMetaInfo);
           if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index d55521c0c8..467d42a731 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -441,7 +441,7 @@ int tsParseOneRow(char **str, STableDataBlocks *pDataBlocks, SSqlCmd *pCmd, int1
     *str += index;
 
     if (sToken.type == TK_QUESTION) {
-      if (pCmd->insertType != TSDB_QUERY_TYPE_STMT_INSERT) {
+      if (pCmd->insertParam.insertType != TSDB_QUERY_TYPE_STMT_INSERT) {
         return tscSQLSyntaxErrMsg(pCmd->payload, "? only allowed in binding insertion", *str);
       }
 
@@ -1120,9 +1120,9 @@ int tsParseInsertSql(SSqlObj *pSql) {
     return code;
   }
 
-  if (NULL == pCmd->pTableBlockHashList) {
-    pCmd->pTableBlockHashList = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
-    if (NULL == pCmd->pTableBlockHashList) {
+  if (NULL == pCmd->insertParam.pTableBlockHashList) {
+    pCmd->insertParam.pTableBlockHashList = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
+    if (NULL == pCmd->insertParam.pTableBlockHashList) {
       code = TSDB_CODE_TSC_OUT_OF_MEMORY;
       goto _clean;
     }
@@ -1130,7 +1130,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
     str = pCmd->curSql;
   }
   
-  tscDebug("0x%"PRIx64" create data block list hashList:%p", pSql->self, pCmd->pTableBlockHashList);
+  tscDebug("0x%"PRIx64" create data block list hashList:%p", pSql->self, pCmd->insertParam.pTableBlockHashList);
 
   while (1) {
     int32_t   index = 0;
@@ -1241,7 +1241,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
         }
 
         STableDataBlocks *dataBuf = NULL;
-        int32_t ret = tscGetDataBlockFromList(pCmd->pTableBlockHashList, pTableMeta->id.uid, TSDB_DEFAULT_PAYLOAD_SIZE,
+        int32_t ret = tscGetDataBlockFromList(pCmd->insertParam.pTableBlockHashList, pTableMeta->id.uid, TSDB_DEFAULT_PAYLOAD_SIZE,
                                               sizeof(SSubmitBlk), tinfo.rowSize, &pTableMetaInfo->name, pTableMeta,
                                               &dataBuf, NULL);
         if (ret != TSDB_CODE_SUCCESS) {
@@ -1261,7 +1261,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
         }
 
         STableDataBlocks *dataBuf = NULL;
-        int32_t ret = tscGetDataBlockFromList(pCmd->pTableBlockHashList, pTableMeta->id.uid, TSDB_DEFAULT_PAYLOAD_SIZE,
+        int32_t ret = tscGetDataBlockFromList(pCmd->insertParam.pTableBlockHashList, pTableMeta->id.uid, TSDB_DEFAULT_PAYLOAD_SIZE,
                                               sizeof(SSubmitBlk), tinfo.rowSize, &pTableMetaInfo->name, pTableMeta,
                                               &dataBuf, NULL);
         if (ret != TSDB_CODE_SUCCESS) {
@@ -1297,7 +1297,8 @@ int tsParseInsertSql(SSqlObj *pSql) {
     goto _clean;
   }
 
-  if ((pCmd->insertType != TSDB_QUERY_TYPE_STMT_INSERT) && taosHashGetSize(pCmd->pTableBlockHashList) > 0) { // merge according to vgId
+  // merge according to vgId
+  if (!TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_STMT_INSERT) && taosHashGetSize(pCmd->insertParam.pTableBlockHashList) > 0) {
     if ((code = tscMergeTableDataBlocks(pSql, true)) != TSDB_CODE_SUCCESS) {
       goto _clean;
     }
@@ -1326,9 +1327,9 @@ int tsInsertInitialCheck(SSqlObj *pSql) {
   pCmd->count = 0;
   pCmd->command = TSDB_SQL_INSERT;
 
-  SQueryInfo *pQueryInfo = tscGetQueryInfoS(pCmd, pCmd->clauseIndex);
+  SQueryInfo *pQueryInfo = tscGetQueryInfoS(pCmd);
 
-  TSDB_QUERY_SET_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_INSERT | pCmd->insertType);
+  TSDB_QUERY_SET_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_INSERT | TSDB_QUERY_TYPE_STMT_INSERT);
 
   sToken = tStrGetToken(pSql->sqlstr, &index, false);
   if (sToken.type != TK_INTO) {
@@ -1410,7 +1411,7 @@ static int doPackSendDataBlock(SSqlObj *pSql, int32_t numOfRows, STableDataBlock
     return code;
   }
 
-  STableDataBlocks *pDataBlock = taosArrayGetP(pCmd->pDataBlocks, 0);
+  STableDataBlocks *pDataBlock = taosArrayGetP(pCmd->insertParam.pDataBlocks, 0);
   if ((code = tscCopyDataBlockToPayload(pSql, pDataBlock)) != TSDB_CODE_SUCCESS) {
     return code;
   }
@@ -1466,11 +1467,11 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int32_t numOfRow
 
   destroyTableNameList(pCmd);
 
-  pCmd->pDataBlocks = tscDestroyBlockArrayList(pCmd->pDataBlocks);
+  pCmd->insertParam.pDataBlocks = tscDestroyBlockArrayList(pCmd->insertParam.pDataBlocks);
 
-  if (pCmd->pTableBlockHashList == NULL) {
-    pCmd->pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
-    if (pCmd->pTableBlockHashList == NULL) {
+  if (pCmd->insertParam.pTableBlockHashList == NULL) {
+    pCmd->insertParam.pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
+    if (pCmd->insertParam.pTableBlockHashList == NULL) {
       code = TSDB_CODE_TSC_OUT_OF_MEMORY;
       goto _error;
     }
@@ -1478,7 +1479,7 @@ static void parseFileSendDataBlock(void *param, TAOS_RES *tres, int32_t numOfRow
 
   STableDataBlocks *pTableDataBlock = NULL;
   int32_t           ret =
-      tscGetDataBlockFromList(pCmd->pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
+      tscGetDataBlockFromList(pCmd->insertParam.pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
                               tinfo.rowSize, &pTableMetaInfo->name, pTableMeta, &pTableDataBlock, NULL);
   if (ret != TSDB_CODE_SUCCESS) {
     pParentSql->res.code = TSDB_CODE_TSC_OUT_OF_MEMORY;
diff --git a/src/client/src/tscPrepare.c b/src/client/src/tscPrepare.c
index e76219b320..b90776d0a8 100644
--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -308,7 +308,7 @@ static int fillColumnsNull(STableDataBlocks* pBlock, int32_t rowNum) {
 int32_t fillTablesColumnsNull(SSqlObj* pSql) {
   SSqlCmd* pCmd = &pSql->cmd;
 
-  STableDataBlocks** p = taosHashIterate(pCmd->pTableBlockHashList, NULL);
+  STableDataBlocks** p = taosHashIterate(pCmd->insertParam.pTableBlockHashList, NULL);
 
   STableDataBlocks* pOneTableBlock = *p;
   while(pOneTableBlock) {
@@ -317,7 +317,7 @@ int32_t fillTablesColumnsNull(SSqlObj* pSql) {
       fillColumnsNull(pOneTableBlock, pBlocks->numOfRows);
     }
 
-    p = taosHashIterate(pCmd->pTableBlockHashList, p);
+    p = taosHashIterate(pCmd->insertParam.pTableBlockHashList, p);
     if (p == NULL) {
       break;
     }
@@ -840,12 +840,12 @@ static int insertStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) {
   STableDataBlocks* pBlock = NULL;
 
   if (pStmt->multiTbInsert) {
-    if (pCmd->pTableBlockHashList == NULL) {
+    if (pCmd->insertParam.pTableBlockHashList == NULL) {
       tscError("0x%"PRIx64" Table block hash list is empty", pStmt->pSql->self);
       return TSDB_CODE_TSC_APP_ERROR;
     }
 
-    STableDataBlocks** t1 = (STableDataBlocks**)taosHashGet(pCmd->pTableBlockHashList, (const char*)&pStmt->mtb.currentUid, sizeof(pStmt->mtb.currentUid));
+    STableDataBlocks** t1 = (STableDataBlocks**)taosHashGet(pCmd->insertParam.pTableBlockHashList, (const char*)&pStmt->mtb.currentUid, sizeof(pStmt->mtb.currentUid));
     if (t1 == NULL) {
       tscError("0x%"PRIx64" no table data block in hash list, uid:%" PRId64 , pStmt->pSql->self, pStmt->mtb.currentUid);
       return TSDB_CODE_TSC_APP_ERROR;
@@ -856,12 +856,12 @@ static int insertStmtBindParam(STscStmt* stmt, TAOS_BIND* bind) {
     STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
 
     STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
-    if (pCmd->pTableBlockHashList == NULL) {
-      pCmd->pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
+    if (pCmd->insertParam.pTableBlockHashList == NULL) {
+      pCmd->insertParam.pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
     }
 
     int32_t ret =
-        tscGetDataBlockFromList(pCmd->pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
+        tscGetDataBlockFromList(pCmd->insertParam.pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
                                 pTableMeta->tableInfo.rowSize, &pTableMetaInfo->name, pTableMeta, &pBlock, NULL);
     if (ret != 0) {
       return ret;
@@ -904,12 +904,12 @@ static int insertStmtBindParamBatch(STscStmt* stmt, TAOS_MULTI_BIND* bind, int c
   STableDataBlocks* pBlock = NULL;
 
   if (pStmt->multiTbInsert) {
-    if (pCmd->pTableBlockHashList == NULL) {
+    if (pCmd->insertParam.pTableBlockHashList == NULL) {
       tscError("0x%"PRIx64" Table block hash list is empty", pStmt->pSql->self);
       return TSDB_CODE_TSC_APP_ERROR;
     }
 
-    STableDataBlocks** t1 = (STableDataBlocks**)taosHashGet(pCmd->pTableBlockHashList, (const char*)&pStmt->mtb.currentUid, sizeof(pStmt->mtb.currentUid));
+    STableDataBlocks** t1 = (STableDataBlocks**)taosHashGet(pCmd->insertParam.pTableBlockHashList, (const char*)&pStmt->mtb.currentUid, sizeof(pStmt->mtb.currentUid));
     if (t1 == NULL) {
       tscError("0x%"PRIx64" no table data block in hash list, uid:%" PRId64 , pStmt->pSql->self, pStmt->mtb.currentUid);
       return TSDB_CODE_TSC_APP_ERROR;
@@ -920,12 +920,12 @@ static int insertStmtBindParamBatch(STscStmt* stmt, TAOS_MULTI_BIND* bind, int c
     STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
 
     STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
-    if (pCmd->pTableBlockHashList == NULL) {
-      pCmd->pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
+    if (pCmd->insertParam.pTableBlockHashList == NULL) {
+      pCmd->insertParam.pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
     }
 
     int32_t ret =
-        tscGetDataBlockFromList(pCmd->pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
+        tscGetDataBlockFromList(pCmd->insertParam.pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
                                 pTableMeta->tableInfo.rowSize, &pTableMetaInfo->name, pTableMeta, &pBlock, NULL);
     if (ret != 0) {
       return ret;
@@ -991,11 +991,11 @@ static int insertStmtUpdateBatch(STscStmt* stmt) {
     return TSDB_CODE_TSC_APP_ERROR;
   }
 
-  if (taosHashGetSize(pCmd->pTableBlockHashList) == 0) {
+  if (taosHashGetSize(pCmd->insertParam.pTableBlockHashList) == 0) {
     return TSDB_CODE_SUCCESS;
   }
 
-  STableDataBlocks** t1 = (STableDataBlocks**)taosHashGet(pCmd->pTableBlockHashList, (const char*)&stmt->mtb.currentUid, sizeof(stmt->mtb.currentUid));
+  STableDataBlocks** t1 = (STableDataBlocks**)taosHashGet(pCmd->insertParam.pTableBlockHashList, (const char*)&stmt->mtb.currentUid, sizeof(stmt->mtb.currentUid));
   if (t1 == NULL) {
     tscError("0x%"PRIx64" no table data block in hash list, uid:%" PRId64 , pSql->self, stmt->mtb.currentUid);
     return TSDB_CODE_TSC_APP_ERROR;
@@ -1031,9 +1031,9 @@ static int insertStmtReset(STscStmt* pStmt) {
   if (pCmd->batchSize > 2) {
     int32_t alloced = (pCmd->batchSize + 1) / 2;
 
-    size_t size = taosArrayGetSize(pCmd->pDataBlocks);
+    size_t size = taosArrayGetSize(pCmd->insertParam.pDataBlocks);
     for (int32_t i = 0; i < size; ++i) {
-      STableDataBlocks* pBlock = taosArrayGetP(pCmd->pDataBlocks, i);
+      STableDataBlocks* pBlock = taosArrayGetP(pCmd->insertParam.pDataBlocks, i);
 
       uint32_t totalDataSize = pBlock->size - sizeof(SSubmitBlk);
       pBlock->size = sizeof(SSubmitBlk) + totalDataSize / alloced;
@@ -1055,21 +1055,21 @@ static int insertStmtExecute(STscStmt* stmt) {
     return TSDB_CODE_TSC_INVALID_VALUE;
   }
 
-  if (taosHashGetSize(pCmd->pTableBlockHashList) == 0) {
+  if (taosHashGetSize(pCmd->insertParam.pTableBlockHashList) == 0) {
     return TSDB_CODE_SUCCESS;
   }
 
   STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
 
   STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
-  if (pCmd->pTableBlockHashList == NULL) {
-    pCmd->pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
+  if (pCmd->insertParam.pTableBlockHashList == NULL) {
+    pCmd->insertParam.pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
   }
 
   STableDataBlocks* pBlock = NULL;
 
   int32_t ret =
-      tscGetDataBlockFromList(pCmd->pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
+      tscGetDataBlockFromList(pCmd->insertParam.pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
                               pTableMeta->tableInfo.rowSize, &pTableMetaInfo->name, pTableMeta, &pBlock, NULL);
   assert(ret == 0);
   pBlock->size = sizeof(SSubmitBlk) + pCmd->batchSize * pBlock->rowSize;
@@ -1086,7 +1086,7 @@ static int insertStmtExecute(STscStmt* stmt) {
     return code;
   }
 
-  STableDataBlocks* pDataBlock = taosArrayGetP(pCmd->pDataBlocks, 0);
+  STableDataBlocks* pDataBlock = taosArrayGetP(pCmd->insertParam.pDataBlocks, 0);
   code = tscCopyDataBlockToPayload(stmt->pSql, pDataBlock);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
@@ -1112,7 +1112,7 @@ static int insertStmtExecute(STscStmt* stmt) {
 
   pCmd->numOfTables = 0;
   tfree(pCmd->pTableNameList);
-  pCmd->pDataBlocks = tscDestroyBlockArrayList(pCmd->pDataBlocks);
+  pCmd->insertParam.pDataBlocks = tscDestroyBlockArrayList(pCmd->insertParam.pDataBlocks);
 
   return pSql->res.code;
 }
@@ -1120,7 +1120,7 @@ static int insertStmtExecute(STscStmt* stmt) {
 static void insertBatchClean(STscStmt* pStmt) {
   SSqlCmd *pCmd = &pStmt->pSql->cmd;
   SSqlObj *pSql = pStmt->pSql;
-  int32_t size = taosHashGetSize(pCmd->pTableBlockHashList);
+  int32_t size = taosHashGetSize(pCmd->insertParam.pTableBlockHashList);
 
   // data block reset
   pCmd->batchSize = 0;
@@ -1134,7 +1134,7 @@ static void insertBatchClean(STscStmt* pStmt) {
   tfree(pCmd->pTableNameList);
 
 /*
-  STableDataBlocks** p = taosHashIterate(pCmd->pTableBlockHashList, NULL);
+  STableDataBlocks** p = taosHashIterate(pCmd->insertParam.pTableBlockHashList, NULL);
 
   STableDataBlocks* pOneTableBlock = *p;
 
@@ -1145,7 +1145,7 @@ static void insertBatchClean(STscStmt* pStmt) {
 
     pBlocks->numOfRows = 0;
 
-    p = taosHashIterate(pCmd->pTableBlockHashList, p);
+    p = taosHashIterate(pCmd->insertParam.pTableBlockHashList, p);
     if (p == NULL) {
       break;
     }
@@ -1154,10 +1154,10 @@ static void insertBatchClean(STscStmt* pStmt) {
   }
 */
 
-  pCmd->pDataBlocks = tscDestroyBlockArrayList(pCmd->pDataBlocks);
+  pCmd->insertParam.pDataBlocks = tscDestroyBlockArrayList(pCmd->insertParam.pDataBlocks);
   pCmd->numOfTables = 0;
 
-  taosHashEmpty(pCmd->pTableBlockHashList);
+  taosHashEmpty(pCmd->insertParam.pTableBlockHashList);
   tscFreeSqlResult(pSql);
   tscFreeSubobj(pSql);
   tfree(pSql->pSubs);
@@ -1376,7 +1376,7 @@ int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
     SSubmitBlk* pBlk = (SSubmitBlk*) (*t1)->pData;
     pCmd->batchSize = pBlk->numOfRows;
 
-    taosHashPut(pCmd->pTableBlockHashList, (void *)&pStmt->mtb.currentUid, sizeof(pStmt->mtb.currentUid), (void*)t1, POINTER_BYTES);
+    taosHashPut(pCmd->insertParam.pTableBlockHashList, (void *)&pStmt->mtb.currentUid, sizeof(pStmt->mtb.currentUid), (void*)t1, POINTER_BYTES);
 
     tscDebug("0x%"PRIx64" table:%s is already prepared, uid:%" PRIu64, pSql->self, name, pStmt->mtb.currentUid);
     return TSDB_CODE_SUCCESS;
@@ -1391,11 +1391,11 @@ int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
   pSql->cmd.numOfParams = 0;
   pSql->cmd.batchSize   = 0;
 
-  if (taosHashGetSize(pCmd->pTableBlockHashList) > 0) {
-    SHashObj* hashList = pCmd->pTableBlockHashList;
-    pCmd->pTableBlockHashList = NULL;
+  if (taosHashGetSize(pCmd->insertParam.pTableBlockHashList) > 0) {
+    SHashObj* hashList = pCmd->insertParam.pTableBlockHashList;
+    pCmd->insertParam.pTableBlockHashList = NULL;
     tscResetSqlCmd(pCmd, true);
-    pCmd->pTableBlockHashList = hashList;
+    pCmd->insertParam.pTableBlockHashList = hashList;
   }
 
   int32_t code = tsParseSql(pStmt->pSql, true);
@@ -1411,7 +1411,7 @@ int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
 
     STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
     STableDataBlocks* pBlock = NULL;
-    code = tscGetDataBlockFromList(pCmd->pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
+    code = tscGetDataBlockFromList(pCmd->insertParam.pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
                               pTableMeta->tableInfo.rowSize, &pTableMetaInfo->name, pTableMeta, &pBlock, NULL);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
@@ -1688,14 +1688,14 @@ int taos_stmt_get_param(TAOS_STMT *stmt, int idx, int *type, int *bytes) {
     SSqlCmd* pCmd = &pStmt->pSql->cmd;
     STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
     STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
-    if (pCmd->pTableBlockHashList == NULL) {
-      pCmd->pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
+    if (pCmd->insertParam.pTableBlockHashList == NULL) {
+      pCmd->insertParam.pTableBlockHashList = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
     }
 
     STableDataBlocks* pBlock = NULL;
 
     int32_t ret =
-      tscGetDataBlockFromList(pCmd->pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
+      tscGetDataBlockFromList(pCmd->insertParam.pTableBlockHashList, pTableMeta->id.uid, TSDB_PAYLOAD_SIZE, sizeof(SSubmitBlk),
           pTableMeta->tableInfo.rowSize, &pTableMetaInfo->name, pTableMeta, &pBlock, NULL);
     if (ret != 0) {
       // todo handle error
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index ae079e7517..0c77b5da0a 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -293,7 +293,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     return tscSQLSyntaxErrMsg(tscGetErrorMsgPayload(pCmd), NULL, pInfo->msg);
   }
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfoS(pCmd, pCmd->clauseIndex);
+  SQueryInfo* pQueryInfo = tscGetQueryInfoS(pCmd);
   if (pQueryInfo == NULL) {
     pRes->code = terrno;
     return pRes->code;
@@ -656,7 +656,6 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
         }
 
         tscPrintSelNodeList(pSql, i);
-        pCmd->clauseIndex += 1;
 
         if ((i + 1) < size && pQueryInfo->sibling == NULL) {
           if ((code = tscAddQueryInfo(pCmd)) != TSDB_CODE_SUCCESS) {
@@ -671,9 +670,6 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
         return code;
       }
 
-      // restore the clause index
-      pCmd->clauseIndex = 0;
-
       // set the command/global limit parameters from the first subclause to the sqlcmd object
       pCmd->active = pCmd->pQueryInfo;
       pCmd->command = pCmd->pQueryInfo->command;
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 289ce525f2..aaf40ec5e3 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -584,22 +584,22 @@ int tscBuildSubmitMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   STableMeta* pTableMeta = tscGetMetaInfo(pQueryInfo, 0)->pTableMeta;
   
-  char* pMsg = pSql->cmd.payload;
-  
-  // NOTE: shell message size should not include SMsgDesc
-  int32_t size = pSql->cmd.payloadLen - sizeof(SMsgDesc);
-
-  SMsgDesc* pMsgDesc = (SMsgDesc*) pMsg;
-  pMsgDesc->numOfVnodes = htonl(1); // always one vnode
-
-  pMsg += sizeof(SMsgDesc);
-  SSubmitMsg *pShellMsg = (SSubmitMsg *)pMsg;
-
-  pShellMsg->header.vgId = htonl(pTableMeta->vgId);
-  pShellMsg->header.contLen = htonl(size);      // the length not includes the size of SMsgDesc
-  pShellMsg->length = pShellMsg->header.contLen;
-  
-  pShellMsg->numOfBlocks = htonl(pSql->cmd.numOfTablesInSubmit);  // number of tables to be inserted
+//  char* pMsg = pSql->cmd.payload;
+//
+//  // NOTE: shell message size should not include SMsgDesc
+//  int32_t size = pSql->cmd.payloadLen - sizeof(SMsgDesc);
+//
+//  SMsgDesc* pMsgDesc = (SMsgDesc*) pMsg;
+//  pMsgDesc->numOfVnodes = htonl(1);    // always one vnode
+//
+//  pMsg += sizeof(SMsgDesc);
+//  SSubmitMsg *pShellMsg = (SSubmitMsg *)pMsg;
+//
+//  pShellMsg->header.vgId    = htonl(pTableMeta->vgId);               // data in current block all routes to the same vgroup
+//  pShellMsg->header.contLen = htonl(size);                           // the length not includes the size of SMsgDesc
+//  pShellMsg->length         = pShellMsg->header.contLen;
+//
+//  pShellMsg->numOfBlocks    = htonl(pSql->cmd.numOfTablesInSubmit);  // the number of tables to be inserted
 
   // pSql->cmd.payloadLen is set during copying data into payload
   pSql->cmd.msgType = TSDB_MSG_TYPE_SUBMIT;
@@ -608,15 +608,15 @@ int tscBuildSubmitMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   taosHashGetClone(tscVgroupMap, &pTableMeta->vgId, sizeof(pTableMeta->vgId), NULL, &vgroupInfo, sizeof(SNewVgroupInfo));
   tscDumpEpSetFromVgroupInfo(&pSql->epSet, &vgroupInfo);
 
-  tscDebug("0x%"PRIx64" build submit msg, vgId:%d numOfTables:%d numberOfEP:%d", pSql->self, pTableMeta->vgId, pSql->cmd.numOfTablesInSubmit,
-      pSql->epSet.numOfEps);
+  tscDebug("0x%"PRIx64" submit msg built, numberOfEP:%d", pSql->self, pSql->epSet.numOfEps);
+
   return TSDB_CODE_SUCCESS;
 }
 
 /*
  * for table query, simply return the size <= 1k
  */
-static int32_t tscEstimateQueryMsgSize(SSqlObj *pSql, int32_t clauseIndex) {
+static int32_t tscEstimateQueryMsgSize(SSqlObj *pSql) {
   const static int32_t MIN_QUERY_MSG_PKT_SIZE = TSDB_MAX_BYTES_PER_ROW * 5;
 
   SSqlCmd* pCmd = &pSql->cmd;
@@ -815,7 +815,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SSqlCmd *pCmd = &pSql->cmd;
 
   int32_t code = TSDB_CODE_SUCCESS;
-  int32_t size = tscEstimateQueryMsgSize(pSql, pCmd->clauseIndex);
+  int32_t size = tscEstimateQueryMsgSize(pSql);
 
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, size)) {
     tscError("%p failed to malloc for query msg", pSql);
@@ -2155,7 +2155,7 @@ static void createHbObj(STscObj* pObj) {
 
   pSql->fp = tscProcessHeartBeatRsp;
 
-  SQueryInfo *pQueryInfo = tscGetQueryInfoS(&pSql->cmd, 0);
+  SQueryInfo *pQueryInfo = tscGetQueryInfoS(&pSql->cmd);
   if (pQueryInfo == NULL) {
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
     tfree(pSql);
@@ -2369,7 +2369,7 @@ static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaIn
 
   tscAddQueryInfo(&pNew->cmd);
 
-  SQueryInfo *pNewQueryInfo = tscGetQueryInfoS(&pNew->cmd, 0);
+  SQueryInfo *pNewQueryInfo = tscGetQueryInfoS(&pNew->cmd);
 
   pNew->cmd.autoCreated = pSql->cmd.autoCreated;  // create table if not exists
   if (TSDB_CODE_SUCCESS != tscAllocPayload(&pNew->cmd, TSDB_DEFAULT_PAYLOAD_SIZE + pSql->cmd.payloadLen)) {
@@ -2592,7 +2592,7 @@ int tscGetSTableVgroupInfo(SSqlObj *pSql, SQueryInfo* pQueryInfo) {
   pNew->cmd.command = TSDB_SQL_STABLEVGROUP;
 
   // TODO TEST IT
-  SQueryInfo *pNewQueryInfo = tscGetQueryInfoS(&pNew->cmd, 0);
+  SQueryInfo *pNewQueryInfo = tscGetQueryInfoS(&pNew->cmd);
   if (pNewQueryInfo == NULL) {
     tscFreeSqlObj(pNew);
     return code;
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index 8a70502da6..09765f5ce6 100644
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -901,9 +901,9 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
   strtolower(pSql->sqlstr, sql);
 
   pCmd->curSql = NULL;
-  if (NULL != pCmd->pTableBlockHashList) {
-    taosHashCleanup(pCmd->pTableBlockHashList);
-    pCmd->pTableBlockHashList = NULL;
+  if (NULL != pCmd->insertParam.pTableBlockHashList) {
+    taosHashCleanup(pCmd->insertParam.pTableBlockHashList);
+    pCmd->insertParam.pTableBlockHashList = NULL;
   }
 
   pSql->fp = asyncCallback;
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index 3909b81f59..2c6eb4f3e2 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -3056,7 +3056,7 @@ static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int numOfRows)
 
         // clean up tableMeta in cache
         tscFreeQueryInfo(&pSql->cmd, false);
-        SQueryInfo* pQueryInfo = tscGetQueryInfoS(&pSql->cmd, 0);
+        SQueryInfo* pQueryInfo = tscGetQueryInfoS(&pSql->cmd);
         STableMetaInfo* pMasterTableMetaInfo = tscGetTableMetaInfoFromCmd(&pParentObj->cmd, 0);
         tscAddTableMetaInfo(pQueryInfo, &pMasterTableMetaInfo->name, NULL, NULL, NULL, NULL);
 
@@ -3145,7 +3145,7 @@ int32_t tscHandleMultivnodeInsert(SSqlObj *pSql) {
     return TSDB_CODE_SUCCESS;
   }
 
-  pSql->subState.numOfSub = (uint16_t)taosArrayGetSize(pCmd->pDataBlocks);
+  pSql->subState.numOfSub = (uint16_t)taosArrayGetSize(pCmd->insertParam.pDataBlocks);
   assert(pSql->subState.numOfSub > 0);
 
   pRes->code = TSDB_CODE_SUCCESS;
@@ -3195,7 +3195,7 @@ int32_t tscHandleMultivnodeInsert(SSqlObj *pSql) {
     pNew->fetchFp = pNew->fp;
     pSql->pSubs[numOfSub] = pNew;
 
-    STableDataBlocks* pTableDataBlock = taosArrayGetP(pCmd->pDataBlocks, numOfSub);
+    STableDataBlocks* pTableDataBlock = taosArrayGetP(pCmd->insertParam.pDataBlocks, numOfSub);
     pRes->code = tscCopyDataBlockToPayload(pNew, pTableDataBlock);
     if (pRes->code == TSDB_CODE_SUCCESS) {
       tscDebug("0x%"PRIx64" sub:%p create subObj success. orderOfSub:%d", pSql->self, pNew, numOfSub);
@@ -3213,7 +3213,7 @@ int32_t tscHandleMultivnodeInsert(SSqlObj *pSql) {
     goto _error;
   }
 
-  pCmd->pDataBlocks = tscDestroyBlockArrayList(pCmd->pDataBlocks);
+  pCmd->insertParam.pDataBlocks = tscDestroyBlockArrayList(pCmd->insertParam.pDataBlocks);
 
   // use the local variable
   for (int32_t j = 0; j < numOfSub; ++j) {
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 32c85ab43f..6f3fd1a253 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -1130,8 +1130,8 @@ void tscResetSqlCmd(SSqlCmd* pCmd, bool removeMeta) {
 
   destroyTableNameList(pCmd);
 
-  pCmd->pTableBlockHashList = tscDestroyBlockHashTable(pCmd->pTableBlockHashList, removeMeta);
-  pCmd->pDataBlocks = tscDestroyBlockArrayList(pCmd->pDataBlocks);
+  pCmd->insertParam.pTableBlockHashList = tscDestroyBlockHashTable(pCmd->insertParam.pTableBlockHashList, removeMeta);
+  pCmd->insertParam.pDataBlocks = tscDestroyBlockArrayList(pCmd->insertParam.pDataBlocks);
   tscFreeQueryInfo(pCmd, removeMeta);
 
   if (pCmd->pTableMetaMap != NULL) {
@@ -1343,12 +1343,9 @@ int32_t tscCopyDataBlockToPayload(SSqlObj* pSql, STableDataBlocks* pDataBlock) {
   SSqlCmd* pCmd = &pSql->cmd;
   assert(pDataBlock->pTableMeta != NULL);
 
-  pCmd->numOfTablesInSubmit = pDataBlock->numOfTables;
-
-//  assert(pCmd->numOfClause == 1);
   STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
 
-  // todo refactor
+  // todo remove it later
   // set the correct table meta object, the table meta has been locked in pDataBlocks, so it must be in the cache
   if (pTableMetaInfo->pTableMeta != pDataBlock->pTableMeta) {
     tNameAssign(&pTableMetaInfo->name, &pDataBlock->tableName);
@@ -1358,13 +1355,13 @@ int32_t tscCopyDataBlockToPayload(SSqlObj* pSql, STableDataBlocks* pDataBlock) {
     }
 
     pTableMetaInfo->pTableMeta    = tscTableMetaDup(pDataBlock->pTableMeta);
-    pTableMetaInfo->tableMetaSize = tscGetTableMetaSize(pDataBlock->pTableMeta); 
+    pTableMetaInfo->tableMetaSize = tscGetTableMetaSize(pDataBlock->pTableMeta);
   }
 
   /*
-   * the submit message consists of : [RPC header|message body|digest]
-   * the dataBlock only includes the RPC Header buffer and actual submit message body, space for digest needs
-   * additional space.
+   * the format of submit message is as follows [RPC header|message body|digest]
+   * the dataBlock only includes the RPC Header buffer and actual submit message body,
+   * space for digest needs additional space.
    */
   int ret = tscAllocPayload(pCmd, pDataBlock->size + 100);
   if (TSDB_CODE_SUCCESS != ret) {
@@ -1374,13 +1371,24 @@ int32_t tscCopyDataBlockToPayload(SSqlObj* pSql, STableDataBlocks* pDataBlock) {
   assert(pDataBlock->size <= pDataBlock->nAllocSize);
   memcpy(pCmd->payload, pDataBlock->pData, pDataBlock->size);
 
-  /*
-   * the payloadLen should be actual message body size
-   * the old value of payloadLen is the allocated payload size
-   */
+  //the payloadLen should be actual message body size, the old value of payloadLen is the allocated payload size
   pCmd->payloadLen = pDataBlock->size;
 
+  // NOTE: shell message size should not include SMsgDesc
+  int32_t size = pCmd->payloadLen - sizeof(SMsgDesc);
+
+  SMsgDesc* pMsgDesc    = (SMsgDesc*) pCmd->payload;
+  pMsgDesc->numOfVnodes = htonl(1);    // always for one vnode
+
+  SSubmitMsg *pShellMsg     = (SSubmitMsg *)(pCmd->payload + sizeof(SMsgDesc));
+  pShellMsg->header.vgId    = htonl(pDataBlock->pTableMeta->vgId);   // data in current block all routes to the same vgroup
+  pShellMsg->header.contLen = htonl(size);                           // the length not includes the size of SMsgDesc
+  pShellMsg->length         = pShellMsg->header.contLen;
+  pShellMsg->numOfBlocks    = htonl(pDataBlock->numOfTables);  // the number of tables to be inserted
+
   assert(pCmd->allocSize >= (uint32_t)(pCmd->payloadLen + 100) && pCmd->payloadLen > 0);
+
+  tscDebug("0x%"PRIx64" submit msg built, vgId:%d numOfTables:%d", pSql->self, pDataBlock->pTableMeta->vgId, pDataBlock->numOfTables);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -1542,25 +1550,25 @@ static int32_t getRowExpandSize(STableMeta* pTableMeta) {
 }
 
 static void extractTableNameList(SSqlCmd* pCmd, bool freeBlockMap) {
-  pCmd->numOfTables = (int32_t) taosHashGetSize(pCmd->pTableBlockHashList);
+  pCmd->numOfTables = (int32_t) taosHashGetSize(pCmd->insertParam.pTableBlockHashList);
   if (pCmd->pTableNameList == NULL) {
     pCmd->pTableNameList = calloc(pCmd->numOfTables, POINTER_BYTES);
   } else {
     memset(pCmd->pTableNameList, 0, pCmd->numOfTables * POINTER_BYTES);
   }
 
-  STableDataBlocks **p1 = taosHashIterate(pCmd->pTableBlockHashList, NULL);
+  STableDataBlocks **p1 = taosHashIterate(pCmd->insertParam.pTableBlockHashList, NULL);
   int32_t i = 0;
   while(p1) {
     STableDataBlocks* pBlocks = *p1;
     tfree(pCmd->pTableNameList[i]);
 
     pCmd->pTableNameList[i++] = tNameDup(&pBlocks->tableName);
-    p1 = taosHashIterate(pCmd->pTableBlockHashList, p1);
+    p1 = taosHashIterate(pCmd->insertParam.pTableBlockHashList, p1);
   }
 
   if (freeBlockMap) {
-    pCmd->pTableBlockHashList = tscDestroyBlockHashTable(pCmd->pTableBlockHashList, false);
+    pCmd->insertParam.pTableBlockHashList = tscDestroyBlockHashTable(pCmd->insertParam.pTableBlockHashList, false);
   }
 }
 
@@ -1571,7 +1579,7 @@ int32_t tscMergeTableDataBlocks(SSqlObj* pSql, bool freeBlockMap) {
   void* pVnodeDataBlockHashList = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, false);
   SArray* pVnodeDataBlockList = taosArrayInit(8, POINTER_BYTES);
 
-  STableDataBlocks** p = taosHashIterate(pCmd->pTableBlockHashList, NULL);
+  STableDataBlocks** p = taosHashIterate(pCmd->insertParam.pTableBlockHashList, NULL);
 
   STableDataBlocks* pOneTableBlock = *p;
   while(pOneTableBlock) {
@@ -1642,7 +1650,7 @@ int32_t tscMergeTableDataBlocks(SSqlObj* pSql, bool freeBlockMap) {
       tscDebug("0x%"PRIx64" table %s data block is empty", pSql->self, pOneTableBlock->tableName.tname);
     }
     
-    p = taosHashIterate(pCmd->pTableBlockHashList, p);
+    p = taosHashIterate(pCmd->insertParam.pTableBlockHashList, p);
     if (p == NULL) {
       break;
     }
@@ -1653,7 +1661,7 @@ int32_t tscMergeTableDataBlocks(SSqlObj* pSql, bool freeBlockMap) {
   extractTableNameList(pCmd, freeBlockMap);
 
   // free the table data blocks;
-  pCmd->pDataBlocks = pVnodeDataBlockList;
+  pCmd->insertParam.pDataBlocks = pVnodeDataBlockList;
   taosHashCleanup(pVnodeDataBlockHashList);
 
   return TSDB_CODE_SUCCESS;
@@ -1848,7 +1856,6 @@ void* sqlExprDestroy(SExprInfo* pExpr) {
     tExprTreeDestroy(pExpr->pExpr, NULL);
   }
 
-  printf("free---------------%p\n", pExpr);
   tfree(pExpr);
   return NULL;
 }
@@ -1918,7 +1925,6 @@ SExprInfo* tscExprCreate(SQueryInfo* pQueryInfo, int16_t functionId, SColumnInde
     return NULL;
   }
 
-  printf("malloc======================%p\n", pExpr);
   SSqlExpr* p = &pExpr->base;
   p->functionId = functionId;
 
@@ -2625,7 +2631,7 @@ STableMetaInfo* tscGetMetaInfo(SQueryInfo* pQueryInfo, int32_t tableIndex) {
   return pQueryInfo->pTableMetaInfo[tableIndex];
 }
 
-SQueryInfo* tscGetQueryInfoS(SSqlCmd* pCmd, int32_t subClauseIndex) {
+SQueryInfo* tscGetQueryInfoS(SSqlCmd* pCmd) {
   SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
   int32_t ret = TSDB_CODE_SUCCESS;
 
@@ -3025,9 +3031,7 @@ SSqlObj* createSimpleSubObj(SSqlObj* pSql, __async_cb_func_t fp, void* param, in
   pNew->sqlstr  = NULL;
   pNew->maxRetry = TSDB_MAX_REPLICA;
 
-  SQueryInfo* pQueryInfo = tscGetQueryInfoS(pCmd, 0);
-
-  assert(pSql->cmd.clauseIndex == 0);
+  SQueryInfo* pQueryInfo = tscGetQueryInfoS(pCmd);
   STableMetaInfo* pMasterTableMetaInfo = tscGetTableMetaInfoFromCmd(&pSql->cmd, 0);
 
   tscAddTableMetaInfo(pQueryInfo, &pMasterTableMetaInfo->name, NULL, NULL, NULL, NULL);
@@ -3102,7 +3106,6 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
   pnCmd->pTableMetaMap = NULL;
 
   pnCmd->pQueryInfo  = NULL;
-  pnCmd->clauseIndex = 0;
   pnCmd->pDataBlocks = NULL;
 
   pnCmd->numOfTables = 0;
@@ -3401,71 +3404,6 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
   doExecuteQuery(pSql, pQueryInfo);
 }
 
-/**
- * todo remove it
- * To decide if current is a two-stage super table query, join query, or insert. And invoke different
- * procedure accordingly
- * @param pSql
- */
-void tscDoQuery(SSqlObj* pSql) {
-  SSqlCmd* pCmd = &pSql->cmd;
-  SSqlRes* pRes = &pSql->res;
-  
-  pRes->code = TSDB_CODE_SUCCESS;
-  
-  if (pCmd->command > TSDB_SQL_LOCAL) {
-    tscProcessLocalCmd(pSql);
-    return;
-  }
-  
-  if (pCmd->dataSourceType == DATA_FROM_DATA_FILE) {
-    tscImportDataFromFile(pSql);
-  } else {
-    SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
-    uint16_t type = pQueryInfo->type;
-
-    if ((pCmd->command == TSDB_SQL_SELECT) && (!TSDB_QUERY_HAS_TYPE(type, TSDB_QUERY_TYPE_SUBQUERY)) && (!TSDB_QUERY_HAS_TYPE(type, TSDB_QUERY_TYPE_STABLE_SUBQUERY))) {
-      tscAddIntoSqlList(pSql);
-    }
-  
-    if (TSDB_QUERY_HAS_TYPE(type, TSDB_QUERY_TYPE_INSERT)) {  // multi-vnodes insertion
-      tscHandleMultivnodeInsert(pSql);
-      return;
-    }
-
-    if (QUERY_IS_JOIN_QUERY(type)) {
-      if (!TSDB_QUERY_HAS_TYPE(type, TSDB_QUERY_TYPE_SUBQUERY)) {
-        tscHandleMasterJoinQuery(pSql);
-      } else { // for first stage sub query, iterate all vnodes to get all timestamp
-        if (!TSDB_QUERY_HAS_TYPE(type, TSDB_QUERY_TYPE_JOIN_SEC_STAGE)) {
-          tscBuildAndSendRequest(pSql, NULL);
-        } else { // secondary stage join query.
-          if (tscIsTwoStageSTableQuery(pQueryInfo, 0)) {  // super table query
-            tscLockByThread(&pSql->squeryLock);
-            tscHandleMasterSTableQuery(pSql);
-            tscUnlockByThread(&pSql->squeryLock);
-          } else {
-            tscBuildAndSendRequest(pSql, NULL);
-          }
-        }
-      }
-
-      return;
-    } else if (tscMultiRoundQuery(pQueryInfo, 0) && pQueryInfo->round == 0) {
-      tscHandleFirstRoundStableQuery(pSql);  // todo lock?
-      return;
-    } else if (tscIsTwoStageSTableQuery(pQueryInfo, 0)) {  // super table query
-      tscLockByThread(&pSql->squeryLock);
-      tscHandleMasterSTableQuery(pSql);
-      tscUnlockByThread(&pSql->squeryLock);
-      return;
-    }
-
-    pCmd->active = pQueryInfo;
-    tscBuildAndSendRequest(pSql, NULL);
-  }
-}
-
 int16_t tscGetJoinTagColIdByUid(STagCond* pTagCond, uint64_t uid) {
   int32_t i = 0;
   while (i < TSDB_MAX_JOIN_TABLE_NUM) {
@@ -3687,7 +3625,6 @@ void tscTryQueryNextClause(SSqlObj* pSql, __async_cb_func_t fp) {
   SSqlCmd* pCmd = &pSql->cmd;
   SSqlRes* pRes = &pSql->res;
 
-  pCmd->clauseIndex++;
   SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
 
   pSql->cmd.command = pQueryInfo->command;
@@ -3708,7 +3645,7 @@ void tscTryQueryNextClause(SSqlObj* pSql, __async_cb_func_t fp) {
   pSql->subState.numOfSub = 0;
   pSql->fp = fp;
 
-  tscDebug("0x%"PRIx64" try data in the next subclause:%d", pSql->self, pCmd->clauseIndex);
+  tscDebug("0x%"PRIx64" try data in the next subclause", pSql->self);
   if (pCmd->command > TSDB_SQL_LOCAL) {
     tscProcessLocalCmd(pSql);
   } else {
@@ -4283,7 +4220,7 @@ int tscTransferTableNameList(SSqlObj *pSql, const char *pNameList, int32_t lengt
   int   code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
   char *str = (char *)pNameList;
 
-  SQueryInfo *pQueryInfo = tscGetQueryInfoS(pCmd, pCmd->clauseIndex);
+  SQueryInfo *pQueryInfo = tscGetQueryInfoS(pCmd);
   if (pQueryInfo == NULL) {
     pSql->res.code = terrno;
     return terrno;

From 9150c57764c4f07eedb44d9b92f76ed6e30b2b0d Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Fri, 21 May 2021 17:49:44 +0800
Subject: [PATCH 065/128] Hotfix/sangshuduo/td 4136 taosdemo records morethan
 32767 (#6188)

* [TD-4136]<fix>: taosdemo max records per req < 32767

* [TD-4136]<fix>: taosdemo check insert rows not more than 32767.

check insert rows for progressive.

* fix with answer_yes.

* add extra prompt.

* fix interlace rows checking position.

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdemo/taosdemo.c | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index 34f5c87c44..4e055bb49c 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -3453,16 +3453,6 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
 
     }
     g_args.interlace_rows = interlaceRows->valueint;
-
-    // rows per table need be less than insert batch
-    if (g_args.interlace_rows > g_args.num_of_RPR) {
-      printf("NOTICE: interlace rows value %"PRIu64" > num_of_records_per_req %"PRIu64"\n\n",
-              g_args.interlace_rows, g_args.num_of_RPR);
-      printf("        interlace rows value will be set to num_of_records_per_req %"PRIu64"\n\n",
-              g_args.num_of_RPR);
-      prompt();
-      g_args.interlace_rows = g_args.num_of_RPR;
-    }
   } else if (!interlaceRows) {
     g_args.interlace_rows = 0; // 0 means progressive mode, > 0 mean interlace mode. max value is less or equ num_of_records_per_req
   } else {
@@ -3528,6 +3518,16 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
     goto PARSE_OVER;
   }
 
+  // rows per table need be less than insert batch
+  if (g_args.interlace_rows > g_args.num_of_RPR) {
+      printf("NOTICE: interlace rows value %"PRIu64" > num_of_records_per_req %"PRIu64"\n\n",
+              g_args.interlace_rows, g_args.num_of_RPR);
+      printf("        interlace rows value will be set to num_of_records_per_req %"PRIu64"\n\n",
+              g_args.num_of_RPR);
+      prompt();
+      g_args.interlace_rows = g_args.num_of_RPR;
+  }
+
   cJSON* dbs = cJSON_GetObjectItem(root, "databases");
   if (!dbs || dbs->type != cJSON_Array) {
     printf("ERROR: failed to read json, databases not found\n");

From dbf565c9e60d00ab6d3f1f0d8106de9318e09f66 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Fri, 21 May 2021 21:35:01 +0800
Subject: [PATCH 066/128] Hotfix/sangshuduo/td 4240 taosdemo subscribe morethan
 100 (#6192)

* [TD-4240]<fix>: taosdemo subscribe more than max query sql count.

* [TD-4240]<fix>: taosdemo subscribe more than 100.

fix tsub sequence bug.

* [TD-4240]<fix>: taosdemo subscribe more than 100.

fix auto create table.

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdemo/taosdemo.c | 102 +++++++++++++++++++++---------------
 1 file changed, 59 insertions(+), 43 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index 4e055bb49c..f9913163b9 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -4825,10 +4825,12 @@ static int64_t execInsert(threadInfo *pThreadInfo, char *buffer, uint64_t k)
   return affectedRows;
 }
 
-static void getTableName(char *pTblName, threadInfo* pThreadInfo, uint64_t tableSeq)
+static void getTableName(char *pTblName,
+        threadInfo* pThreadInfo, uint64_t tableSeq)
 {
   SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
-  if (superTblInfo) {
+  if ((superTblInfo)
+          && (AUTO_CREATE_SUBTBL != superTblInfo->autoCreateTable)) {
     if (superTblInfo->childTblLimit > 0) {
         snprintf(pTblName, TSDB_TABLE_NAME_LEN, "%s",
             superTblInfo->childTblName +
@@ -6601,6 +6603,7 @@ static void *superSubscribe(void *sarg) {
   threadInfo *pThreadInfo = (threadInfo *)sarg;
   char subSqlstr[MAX_QUERY_SQL_LENGTH];
   TAOS_SUB*    tsub[MAX_QUERY_SQL_COUNT] = {0};
+  uint64_t tsubSeq;
 
   if (pThreadInfo->ntables > MAX_QUERY_SQL_COUNT) {
       errorPrint("The table number(%"PRId64") of the thread is more than max query sql count: %d\n",
@@ -6609,6 +6612,15 @@ static void *superSubscribe(void *sarg) {
       exit(-1);
   }
 
+  if (g_queryInfo.superQueryInfo.sqlCount * pThreadInfo->ntables > MAX_QUERY_SQL_COUNT) {
+      errorPrint("The number %"PRId64" of sql count(%"PRIu64") multiple the table number(%"PRId64") of the thread is more than max query sql count: %d\n",
+              g_queryInfo.superQueryInfo.sqlCount * pThreadInfo->ntables,
+              g_queryInfo.superQueryInfo.sqlCount,
+              pThreadInfo->ntables,
+              MAX_QUERY_SQL_COUNT);
+      exit(-1);
+  }
+
   if (pThreadInfo->taos == NULL) {
     TAOS * taos = NULL;
     taos = taos_connect(g_queryInfo.host,
@@ -6637,6 +6649,8 @@ static void *superSubscribe(void *sarg) {
   char topic[32] = {0};
   for (uint64_t i = pThreadInfo->start_table_from;
           i <= pThreadInfo->end_table_to; i++) {
+
+      tsubSeq = i - pThreadInfo->start_table_from;
       verbosePrint("%s() LN%d, [%d], start=%"PRId64" end=%"PRId64" i=%"PRIu64"\n",
               __func__, __LINE__,
               pThreadInfo->threadID,
@@ -6656,12 +6670,12 @@ static void *superSubscribe(void *sarg) {
 
       debugPrint("%s() LN%d, [%d] subSqlstr: %s\n",
               __func__, __LINE__, pThreadInfo->threadID, subSqlstr);
-      tsub[i] = subscribeImpl(
+      tsub[tsubSeq] = subscribeImpl(
               STABLE_CLASS,
               pThreadInfo, subSqlstr, topic,
               g_queryInfo.superQueryInfo.subscribeRestart,
               g_queryInfo.superQueryInfo.subscribeInterval);
-      if (NULL == tsub[i]) {
+      if (NULL == tsub[tsubSeq]) {
         taos_close(pThreadInfo->taos);
         return NULL;
       }
@@ -6677,54 +6691,56 @@ static void *superSubscribe(void *sarg) {
   while(1) {
     for (uint64_t i = pThreadInfo->start_table_from;
             i <= pThreadInfo->end_table_to; i++) {
-        if (ASYNC_MODE == g_queryInfo.superQueryInfo.asyncMode) {
-            continue;
-        }
+      tsubSeq = i - pThreadInfo->start_table_from;
+      if (ASYNC_MODE == g_queryInfo.superQueryInfo.asyncMode) {
+          continue;
+      }
 
-        res = taos_consume(tsub[i]);
-        if (res) {
-            if (g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq][0] != 0) {
-                sprintf(pThreadInfo->fp, "%s-%d",
-                        g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq],
-                        pThreadInfo->threadID);
-                appendResultToFile(res, pThreadInfo->fp);
-            }
-            if (g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq][0] != 0) {
-                sprintf(pThreadInfo->fp, "%s-%d",
-                        g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq],
-                        pThreadInfo->threadID);
-                appendResultToFile(res, pThreadInfo->fp);
-            }
-            consumed[i] ++;
+      res = taos_consume(tsub[tsubSeq]);
+      if (res) {
+          if (g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq][0] != 0) {
+              sprintf(pThreadInfo->fp, "%s-%d",
+                      g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq],
+                      pThreadInfo->threadID);
+              appendResultToFile(res, pThreadInfo->fp);
+          }
+          if (g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq][0] != 0) {
+              sprintf(pThreadInfo->fp, "%s-%d",
+                      g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq],
+                      pThreadInfo->threadID);
+              appendResultToFile(res, pThreadInfo->fp);
+          }
+          consumed[tsubSeq] ++;
 
-            if ((g_queryInfo.superQueryInfo.subscribeKeepProgress)
-                && (consumed[i] >=
-                    g_queryInfo.superQueryInfo.resubAfterConsume[pThreadInfo->querySeq])) {
-                printf("keepProgress:%d, resub super table query: %"PRIu64"\n",
-                    g_queryInfo.superQueryInfo.subscribeKeepProgress,
-                    pThreadInfo->querySeq);
-                taos_unsubscribe(tsub,
+          if ((g_queryInfo.superQueryInfo.subscribeKeepProgress)
+                  && (consumed[tsubSeq] >=
+                      g_queryInfo.superQueryInfo.resubAfterConsume[pThreadInfo->querySeq])) {
+              printf("keepProgress:%d, resub super table query: %"PRIu64"\n",
+                      g_queryInfo.superQueryInfo.subscribeKeepProgress,
+                      pThreadInfo->querySeq);
+              taos_unsubscribe(tsub[tsubSeq],
                     g_queryInfo.superQueryInfo.subscribeKeepProgress);
-                consumed[i]= 0;
-                tsub[i] = subscribeImpl(
-                        STABLE_CLASS,
-                        pThreadInfo, subSqlstr, topic,
-                        g_queryInfo.superQueryInfo.subscribeRestart,
-                        g_queryInfo.superQueryInfo.subscribeInterval
-                    );
-                if (NULL == tsub[i]) {
-                    taos_close(pThreadInfo->taos);
-                    return NULL;
-                }
-            }
-        }
+              consumed[tsubSeq]= 0;
+              tsub[tsubSeq] = subscribeImpl(
+                      STABLE_CLASS,
+                      pThreadInfo, subSqlstr, topic,
+                      g_queryInfo.superQueryInfo.subscribeRestart,
+                      g_queryInfo.superQueryInfo.subscribeInterval
+                      );
+              if (NULL == tsub[tsubSeq]) {
+                  taos_close(pThreadInfo->taos);
+                  return NULL;
+              }
+          }
+      }
     }
   }
   taos_free_result(res);
 
   for (uint64_t i = pThreadInfo->start_table_from;
           i <= pThreadInfo->end_table_to; i++) {
-    taos_unsubscribe(tsub[i], 0);
+    tsubSeq = i - pThreadInfo->start_table_from;
+    taos_unsubscribe(tsub[tsubSeq], 0);
   }
 
   taos_close(pThreadInfo->taos);

From fbb160572efa96495a91a1a60abe5a11425b4f19 Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Sat, 22 May 2021 10:09:29 +0800
Subject: [PATCH 067/128] [TD-4034]debug log

---
 src/tsdb/src/tsdbMain.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index 1e6f9eac12..880400dd9f 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -735,7 +735,7 @@ static int tsdbRestoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pRea
 
         pTable->maxColumnNum += 1;
 
-        tsdbInfo("tsdbRestoreLastColumns restore vgId:%d,table:%s cache column %d, %" PRId64, REPO_ID(pRepo), pTable->name->data, pLastCol->colId, pLastCol->ts);
+        tsdbDebug("tsdbRestoreLastColumns restore vgId:%d,table:%s cache column %d, %" PRId64, REPO_ID(pRepo), pTable->name->data, pLastCol->colId, pLastCol->ts);
         break;
       }
     }

From 4e39ed41a5ba6cd476faa8b3377b1afddc4e29e2 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Sat, 22 May 2021 13:13:55 +0800
Subject: [PATCH 068/128] [TD-3279] Send confirmation message when vnode is
 down

---
 src/sync/src/syncMain.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/sync/src/syncMain.c b/src/sync/src/syncMain.c
index e5f2d94c4a..8818874439 100644
--- a/src/sync/src/syncMain.c
+++ b/src/sync/src/syncMain.c
@@ -1002,6 +1002,7 @@ static void syncProcessForwardFromPeer(char *cont, SSyncPeer *pPeer) {
   if (nodeRole == TAOS_SYNC_ROLE_SLAVE) {
     // nodeVersion = pHead->version;
     code = (*pNode->writeToCacheFp)(pNode->vgId, pHead, TAOS_QTYPE_FWD, NULL);
+    syncConfirmForward(pNode->rid, pHead->version, code, false);
   } else {
     if (nodeSStatus != TAOS_SYNC_STATUS_INIT) {
       code = syncSaveIntoBuffer(pPeer, pHead);
@@ -1404,7 +1405,7 @@ static void syncMonitorFwdInfos(void *param, void *tmrId) {
       pthread_mutex_lock(&pNode->mutex);
       for (int32_t i = 0; i < pSyncFwds->fwds; ++i) {
         SFwdInfo *pFwdInfo = pSyncFwds->fwdInfo + (pSyncFwds->first + i) % SYNC_MAX_FWDS;
-        if (ABS(time - pFwdInfo->time) < 2000) break;
+        if (ABS(time - pFwdInfo->time) < 10000) break;
 
         sDebug("vgId:%d, forward info expired, hver:%" PRIu64 " curtime:%" PRIu64 " savetime:%" PRIu64, pNode->vgId,
                pFwdInfo->version, time, pFwdInfo->time);

From 9ef6b68030f4162ee502f5e9d57d9a2e74669787 Mon Sep 17 00:00:00 2001
From: Ping Xiao <pxiao@taosdata.com>
Date: Sat, 22 May 2021 13:53:36 +0800
Subject: [PATCH 069/128] [TD-4263]<test>: update performance test script

---
 tests/perftest-scripts/perftest-query.sh        | 15 +++++++++++----
 tests/pytest/insert/insertFromCSVPerformance.py |  2 +-
 tests/pytest/tools/taosdemoPerformance.py       |  4 ++--
 3 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/tests/perftest-scripts/perftest-query.sh b/tests/perftest-scripts/perftest-query.sh
index c6d4687ed7..bf62f401bf 100755
--- a/tests/perftest-scripts/perftest-query.sh
+++ b/tests/perftest-scripts/perftest-query.sh
@@ -64,18 +64,25 @@ function runQueryPerfTest {
 	[ -f $PERFORMANCE_TEST_REPORT ] && rm $PERFORMANCE_TEST_REPORT
 	nohup $WORK_DIR/TDengine/debug/build/bin/taosd -c /etc/taosperf/ > /dev/null 2>&1 &
 	echoInfo "Wait TDengine to start"
-	sleep 300
+	sleep 60
 	echoInfo "Run Performance Test"	
 	cd $WORK_DIR/TDengine/tests/pytest
 	
 	python3 query/queryPerformance.py -c $LOCAL_COMMIT | tee -a $PERFORMANCE_TEST_REPORT
 
+	mkdir -p /var/lib/perf/
+	mkdir -p /var/log/perf/
+	rm -rf /var/lib/perf/*
+	rm -rf /var/log/perf/*
+	nohup $WORK_DIR/TDengine/debug/build/bin/taosd -c /etc/perf/ > /dev/null 2>&1 &	
+	echoInfo "Wait TDengine to start"
+	sleep 10
+	echoInfo "Run Performance Test"	
+	cd $WORK_DIR/TDengine/tests/pytest
+
 	python3 insert/insertFromCSVPerformance.py -c $LOCAL_COMMIT | tee -a $PERFORMANCE_TEST_REPORT
 	
 	python3 tools/taosdemoPerformance.py -c $LOCAL_COMMIT | tee -a $PERFORMANCE_TEST_REPORT
-
-	#python3 perfbenchmark/joinPerformance.py  | tee -a $PERFORMANCE_TEST_REPORT
-	
 }
 
 
diff --git a/tests/pytest/insert/insertFromCSVPerformance.py b/tests/pytest/insert/insertFromCSVPerformance.py
index 84fd1d7cca..e1f741bd12 100644
--- a/tests/pytest/insert/insertFromCSVPerformance.py
+++ b/tests/pytest/insert/insertFromCSVPerformance.py
@@ -31,7 +31,7 @@ class insertFromCSVPerformace:
         self.host = "127.0.0.1"
         self.user = "root"
         self.password = "taosdata"
-        self.config = "/etc/taosperf"
+        self.config = "/etc/perf"
         self.conn = taos.connect(
             self.host,
             self.user,
diff --git a/tests/pytest/tools/taosdemoPerformance.py b/tests/pytest/tools/taosdemoPerformance.py
index a32cba167e..a45393e222 100644
--- a/tests/pytest/tools/taosdemoPerformance.py
+++ b/tests/pytest/tools/taosdemoPerformance.py
@@ -24,7 +24,7 @@ class taosdemoPerformace:
         self.host = "127.0.0.1"
         self.user = "root"
         self.password = "taosdata"
-        self.config = "/etc/taosperf"
+        self.config = "/etc/perf"
         self.conn = taos.connect(
             self.host,
             self.user,
@@ -77,7 +77,7 @@ class taosdemoPerformace:
 
         insert_data = {
             "filetype": "insert",
-            "cfgdir": "/etc/taosperf",
+            "cfgdir": "/etc/perf",
             "host": "127.0.0.1",
             "port": 6030,
             "user": "root",

From 6eeb539807eda232ad6300afe1b27c0b1ce5e2a1 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Sat, 22 May 2021 15:04:59 +0800
Subject: [PATCH 070/128] fix bug

---
 src/inc/tsdb.h            | 2 ++
 src/query/src/qExecutor.c | 2 +-
 src/tsdb/src/tsdbRead.c   | 9 +++++++--
 3 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/src/inc/tsdb.h b/src/inc/tsdb.h
index 468c5ab271..7c8819777d 100644
--- a/src/inc/tsdb.h
+++ b/src/inc/tsdb.h
@@ -268,6 +268,8 @@ TsdbQueryHandleT tsdbQueryLastRow(STsdbRepo *tsdb, STsdbQueryCond *pCond, STable
 
 TsdbQueryHandleT tsdbQueryCacheLast(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId, SMemRef* pMemRef);
 
+bool isTsdbCacheLastRow(TsdbQueryHandleT* pQueryHandle);
+
 
 /**
  * get the queried table object list
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index c2a4c7febe..1d41bc42b0 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -4243,7 +4243,7 @@ static SSDataBlock* doTableScan(void* param, bool *newgroup) {
     }
 
     if (++pTableScanInfo->current >= pTableScanInfo->times) {
-      if (pTableScanInfo->reverseTimes <= 0) {
+      if (pTableScanInfo->reverseTimes <= 0 || isTsdbCacheLastRow(pTableScanInfo->pQueryHandle)) {
         return NULL;
       } else {
         break;
diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 491a4b2db0..626602576f 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -547,7 +547,9 @@ TsdbQueryHandleT tsdbQueryCacheLast(STsdbRepo *tsdb, STsdbQueryCond *pCond, STab
     return NULL;
   }
 
-  pQueryHandle->type = TSDB_QUERY_TYPE_LAST;
+  if (pQueryHandle->cachelastrow) {
+    pQueryHandle->type = TSDB_QUERY_TYPE_LAST;
+  }
   
   return pQueryHandle;
 }
@@ -2873,6 +2875,10 @@ int32_t tsdbGetCachedLastRow(STable* pTable, SDataRow* pRes, TSKEY* lastKey) {
   return TSDB_CODE_SUCCESS;
 }
 
+bool isTsdbCacheLastRow(TsdbQueryHandleT* pQueryHandle) {
+  return ((STsdbQueryHandle *)pQueryHandle)->cachelastrow > 0;
+}
+
 int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *groupList) {
   assert(pQueryHandle != NULL && groupList != NULL);
 
@@ -2921,7 +2927,6 @@ int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle, STableGroupInfo *grou
   if (((STable*)pInfo->pTable)->lastCols && ((STable*)pInfo->pTable)->lastColNum > 0){
     pQueryHandle->cachelastrow = 2;
   }
-  
 
   // update the tsdb query time range
   if (pQueryHandle->cachelastrow) {

From 696c784377cd9a3f4cb095b566b7c378660d646d Mon Sep 17 00:00:00 2001
From: zyyang <69311263+zyyang-taosdata@users.noreply.github.com>
Date: Sat, 22 May 2021 15:55:32 +0800
Subject: [PATCH 071/128] Fix/td 4086 (#6153)

* [TD-3086]<fix>: clean out unnecessary file in packaging scripts

* [TD-4224]<enhance>: reduce grafana module size in packaging

* change

* [TD-4228]<fix>: error or warn while lost grafanaplugin or go submodule

Conflicts:
	packaging/deb/makedeb.sh
	packaging/rpm/tdengine.spec
	packaging/tools/make_install.sh
	packaging/tools/makeclient.sh
	packaging/tools/makeclient_power.sh
	packaging/tools/makepkg.sh
	packaging/tools/makepkg_power.sh

Co-authored-by: Huo Linhe <linhehuo@gmail.com>
---
 packaging/deb/makedeb.sh            |  7 +++++-
 packaging/rpm/tdengine.spec         |  7 +++++-
 packaging/tools/make_install.sh     | 12 +++++++++--
 packaging/tools/makeclient.sh       | 16 ++++++++++----
 packaging/tools/makeclient_power.sh | 14 +++++++++---
 packaging/tools/makepkg.sh          | 33 ++++++++++++++++++++++++++---
 packaging/tools/makepkg_power.sh    | 13 ++++++++++--
 src/connector/go                    |  2 +-
 8 files changed, 87 insertions(+), 17 deletions(-)

diff --git a/packaging/deb/makedeb.sh b/packaging/deb/makedeb.sh
index 36870b2ebe..28be037e6c 100755
--- a/packaging/deb/makedeb.sh
+++ b/packaging/deb/makedeb.sh
@@ -58,7 +58,12 @@ cp ${compile_dir}/build/lib/${libfile}              ${pkg_dir}${install_home_pat
 cp ${compile_dir}/../src/inc/taos.h                 ${pkg_dir}${install_home_path}/include
 cp ${compile_dir}/../src/inc/taoserror.h            ${pkg_dir}${install_home_path}/include
 cp -r ${top_dir}/tests/examples/*                   ${pkg_dir}${install_home_path}/examples
-cp -r ${top_dir}/src/connector/grafanaplugin        ${pkg_dir}${install_home_path}/connector
+if [ -d "${top_dir}/src/connector/grafanaplugin/dist" ]; then
+  cp -r ${top_dir}/src/connector/grafanaplugin/dist   ${pkg_dir}${install_home_path}/connector/grafanaplugin
+else
+  echo "grafanaplugin bundled directory not found!"
+  exit 1
+fi
 cp -r ${top_dir}/src/connector/python               ${pkg_dir}${install_home_path}/connector
 cp -r ${top_dir}/src/connector/go                   ${pkg_dir}${install_home_path}/connector
 cp -r ${top_dir}/src/connector/nodejs               ${pkg_dir}${install_home_path}/connector
diff --git a/packaging/rpm/tdengine.spec b/packaging/rpm/tdengine.spec
index 92c917cb3d..9910e20bfe 100644
--- a/packaging/rpm/tdengine.spec
+++ b/packaging/rpm/tdengine.spec
@@ -66,7 +66,12 @@ cp %{_compiledir}/build/bin/taosdump                %{buildroot}%{homepath}/bin
 cp %{_compiledir}/build/lib/${libfile}              %{buildroot}%{homepath}/driver
 cp %{_compiledir}/../src/inc/taos.h                 %{buildroot}%{homepath}/include
 cp %{_compiledir}/../src/inc/taoserror.h            %{buildroot}%{homepath}/include
-cp -r %{_compiledir}/../src/connector/grafanaplugin %{buildroot}%{homepath}/connector
+if [ -d %{_compiledir}/../src/connector/grafanaplugin/dist ]; then
+    cp -r %{_compiledir}/../src/connector/grafanaplugin/dist %{buildroot}%{homepath}/connector/grafanaplugin
+else
+    echo grafanaplugin bundled directory not found!
+    exit 1
+fi
 cp -r %{_compiledir}/../src/connector/python        %{buildroot}%{homepath}/connector
 cp -r %{_compiledir}/../src/connector/go            %{buildroot}%{homepath}/connector
 cp -r %{_compiledir}/../src/connector/nodejs        %{buildroot}%{homepath}/connector
diff --git a/packaging/tools/make_install.sh b/packaging/tools/make_install.sh
index f03065d70c..d6ace0a063 100755
--- a/packaging/tools/make_install.sh
+++ b/packaging/tools/make_install.sh
@@ -243,9 +243,17 @@ function install_data() {
 }
 
 function install_connector() {
-    ${csudo} cp -rf ${source_dir}/src/connector/grafanaplugin ${install_main_dir}/connector
+    if [ -d "${source_dir}/src/connector/grafanaplugin/dist" ]; then
+        ${csudo} cp -rf ${source_dir}/src/connector/grafanaplugin/dist ${install_main_dir}/connector/grafanaplugin
+    else
+        echo "WARNING: grafanaplugin bundled dir not found, please check if want to use it!"
+    fi
+    if find ${source_dir}/src/connector/go -mindepth 1 -maxdepth 1 | read; then
+        ${csudo} cp -r ${source_dir}/src/connector/go ${install_main_dir}/connector
+    else
+        echo "WARNING: go connector not found, please check if want to use it!"
+    fi
     ${csudo} cp -rf ${source_dir}/src/connector/python ${install_main_dir}/connector
-    ${csudo} cp -rf ${source_dir}/src/connector/go ${install_main_dir}/connector
         
     ${csudo} cp ${binary_dir}/build/lib/*.jar ${install_main_dir}/connector &> /dev/null && ${csudo} chmod 777 ${install_main_dir}/connector/*.jar || echo &> /dev/null 
 }
diff --git a/packaging/tools/makeclient.sh b/packaging/tools/makeclient.sh
index 30e9fa51a7..d0eeffc86a 100755
--- a/packaging/tools/makeclient.sh
+++ b/packaging/tools/makeclient.sh
@@ -117,10 +117,18 @@ if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
   if [ "$osType" != "Darwin" ]; then
     cp ${build_dir}/lib/*.jar      ${install_dir}/connector ||:
   fi
-  cp -r ${connector_dir}/grafanaplugin ${install_dir}/connector/
-  cp -r ${connector_dir}/python        ${install_dir}/connector/
-  cp -r ${connector_dir}/go            ${install_dir}/connector
-  cp -r ${connector_dir}/nodejs        ${install_dir}/connector
+  if [ -d "${connector_dir}/grafanaplugin/dist" ]; then
+    cp -r ${connector_dir}/grafanaplugin/dist ${install_dir}/connector/grafanaplugin
+  else
+    echo "WARNING: grafanaplugin bundled dir not found, please check if want to use it!"
+  fi
+  if find ${connector_dir}/go -mindepth 1 -maxdepth 1 | read; then
+    cp -r ${connector_dir}/go ${install_dir}/connector
+  else
+    echo "WARNING: go connector not found, please check if want to use it!"
+  fi
+  cp -r ${connector_dir}/python             ${install_dir}/connector
+  cp -r ${connector_dir}/nodejs             ${install_dir}/connector
 fi
 # Copy release note
 # cp ${script_dir}/release_note ${install_dir}
diff --git a/packaging/tools/makeclient_power.sh b/packaging/tools/makeclient_power.sh
index 181536b7f1..b5649e019e 100755
--- a/packaging/tools/makeclient_power.sh
+++ b/packaging/tools/makeclient_power.sh
@@ -144,9 +144,17 @@ if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
   if [ "$osType" != "Darwin" ]; then
     cp ${build_dir}/lib/*.jar      ${install_dir}/connector ||:
   fi
-  cp -r ${connector_dir}/grafanaplugin ${install_dir}/connector/
-  cp -r ${connector_dir}/python  ${install_dir}/connector/
-  cp -r ${connector_dir}/go      ${install_dir}/connector 
+  if [ -d "${connector_dir}/grafanaplugin/dist" ]; then
+    cp -r ${connector_dir}/grafanaplugin/dist ${install_dir}/connector/grafanaplugin
+  else
+    echo "WARNING: grafanaplugin bunlded dir not found, please check if want to use it!"
+  fi
+  if find ${connector_dir}/go -mindepth 1 -maxdepth 1 | read; then
+    cp -r ${connector_dir}/go ${install_dir}/connector
+  else
+    echo "WARNING: go connector not found, please check if want to use it!"
+  fi
+  cp -r ${connector_dir}/python  ${install_dir}/connector
   
   sed -i '/password/ {s/taosdata/powerdb/g}'  ${install_dir}/connector/python/linux/python2/taos/cinterface.py
   sed -i '/password/ {s/taosdata/powerdb/g}'  ${install_dir}/connector/python/linux/python3/taos/cinterface.py
diff --git a/packaging/tools/makepkg.sh b/packaging/tools/makepkg.sh
index 36b1fe5bd8..e4d2d71b01 100755
--- a/packaging/tools/makepkg.sh
+++ b/packaging/tools/makepkg.sh
@@ -114,6 +114,25 @@ mkdir -p ${install_dir}/examples
 examples_dir="${top_dir}/tests/examples"
   cp -r ${examples_dir}/c      ${install_dir}/examples
 if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
+  if [ -d ${examples_dir}/JDBC/connectionPools/target ]; then
+    rm -rf ${examples_dir}/JDBC/connectionPools/target
+  fi
+  if [ -d ${examples_dir}/JDBC/JDBCDemo/target ]; then
+    rm -rf ${examples_dir}/JDBC/JDBCDemo/target
+  fi
+  if [ -d ${examples_dir}/JDBC/mybatisplus-demo/target ]; then
+    rm -rf ${examples_dir}/JDBC/mybatisplus-demo/target
+  fi
+  if [ -d ${examples_dir}/JDBC/springbootdemo/target ]; then
+    rm -rf ${examples_dir}/JDBC/springbootdemo/target
+  fi
+  if [ -d ${examples_dir}/JDBC/SpringJdbcTemplate/target ]; then
+    rm -rf ${examples_dir}/JDBC/SpringJdbcTemplate/target
+  fi
+  if [ -d ${examples_dir}/JDBC/taosdemo/target ]; then
+    rm -rf ${examples_dir}/JDBC/taosdemo/target
+  fi
+  
   cp -r ${examples_dir}/JDBC   ${install_dir}/examples
   cp -r ${examples_dir}/matlab ${install_dir}/examples
   cp -r ${examples_dir}/python ${install_dir}/examples
@@ -131,9 +150,17 @@ connector_dir="${code_dir}/connector"
 mkdir -p ${install_dir}/connector
 if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
   cp ${build_dir}/lib/*.jar            ${install_dir}/connector ||:
-  cp -r ${connector_dir}/grafanaplugin ${install_dir}/connector/
-  cp -r ${connector_dir}/python        ${install_dir}/connector/
-  cp -r ${connector_dir}/go            ${install_dir}/connector
+  if [ -d "${connector_dir}/grafanaplugin/dist" ]; then
+    cp -r ${connector_dir}/grafanaplugin/dist ${install_dir}/connector/grafanaplugin
+  else
+    echo "WARNING: grafanaplugin bundled dir not found, please check if you want to use it!"
+  fi
+  if find ${connector_dir}/go -mindepth 1 -maxdepth 1 | read; then
+    cp -r ${connector_dir}/go ${install_dir}/connector
+  else
+    echo "WARNING: go connector not found, please check if want to use it!"
+  fi
+  cp -r ${connector_dir}/python        ${install_dir}/connector
   cp -r ${connector_dir}/nodejs        ${install_dir}/connector
 fi
 # Copy release note
diff --git a/packaging/tools/makepkg_power.sh b/packaging/tools/makepkg_power.sh
index 554e7884b1..1e43f775e2 100755
--- a/packaging/tools/makepkg_power.sh
+++ b/packaging/tools/makepkg_power.sh
@@ -166,9 +166,18 @@ connector_dir="${code_dir}/connector"
 mkdir -p ${install_dir}/connector
 if [[ "$pagMode" != "lite" ]] && [[ "$cpuType" != "aarch32" ]]; then
   cp ${build_dir}/lib/*.jar      ${install_dir}/connector ||:
-  cp -r ${connector_dir}/grafanaplugin ${install_dir}/connector/
+
+  if [ -d "${connector_dir}/grafanaplugin/dist" ]; then
+    cp -r ${connector_dir}/grafanaplugin/dist ${install_dir}/connector/grafanaplugin
+  else
+    echo "WARNING: grafanaplugin bundled dir not found, please check if want to use it!"
+  fi
+  if find ${connector_dir}/go -mindepth 1 -maxdepth 1 | read; then
+    cp -r ${connector_dir}/go ${install_dir}/connector
+  else
+    echo "WARNING: go connector not found, please check if want to use it!"
+  fi
   cp -r ${connector_dir}/python  ${install_dir}/connector/
-  cp -r ${connector_dir}/go      ${install_dir}/connector
   
   sed -i '/password/ {s/taosdata/powerdb/g}'  ${install_dir}/connector/python/linux/python2/taos/cinterface.py
   sed -i '/password/ {s/taosdata/powerdb/g}'  ${install_dir}/connector/python/linux/python3/taos/cinterface.py
diff --git a/src/connector/go b/src/connector/go
index 7a26c432f8..050667e5b4 160000
--- a/src/connector/go
+++ b/src/connector/go
@@ -1 +1 @@
-Subproject commit 7a26c432f8b4203e42344ff3290b9b9b01b983d5
+Subproject commit 050667e5b4d0eafa5387e4283e713559b421203f

From db03be64060bce26a4ab60b997c9416147501389 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Sat, 22 May 2021 16:59:19 +0800
Subject: [PATCH 072/128] [TD-4296]<fix>: taosdemo sub keepProgress. (#6200)

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdemo/taosdemo.c | 35 +++++++++++++++++++++--------------
 1 file changed, 21 insertions(+), 14 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index f9913163b9..02d72fc445 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -391,7 +391,7 @@ typedef struct SuperQueryInfo_S {
   uint64_t     sqlCount;
   char         sql[MAX_QUERY_SQL_COUNT][MAX_QUERY_SQL_LENGTH+1];
   char         result[MAX_QUERY_SQL_COUNT][MAX_FILE_NAME_LEN+1];
-  int          resubAfterConsume[MAX_QUERY_SQL_COUNT];
+  int          resubAfterConsume;
   TAOS_SUB*    tsub[MAX_QUERY_SQL_COUNT];
 
   char*        childTblName;
@@ -4447,6 +4447,18 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
       g_queryInfo.superQueryInfo.subscribeKeepProgress = 0;
     }
 
+    cJSON* superResubAfterConsume =
+            cJSON_GetObjectItem(superQuery, "resubAfterConsume");
+    if (superResubAfterConsume
+            && superResubAfterConsume->type == cJSON_Number) {
+        g_queryInfo.superQueryInfo.resubAfterConsume =
+            superResubAfterConsume->valueint;
+    } else if (!superResubAfterConsume) {
+        //printf("failed to read json, subscribe interval no found\n");
+        ////goto PARSE_OVER;
+        g_queryInfo.superQueryInfo.resubAfterConsume = 1;
+    }
+
     // sqls
     cJSON* subsqls = cJSON_GetObjectItem(superQuery, "sqls");
     if (!subsqls) {
@@ -4478,18 +4490,6 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
         tstrncpy(g_queryInfo.superQueryInfo.sql[j], sqlStr->valuestring,
             MAX_QUERY_SQL_LENGTH);
 
-        cJSON* superResubAfterConsume =
-            cJSON_GetObjectItem(sql, "resubAfterConsume");
-        if (superResubAfterConsume
-                && superResubAfterConsume->type == cJSON_Number) {
-            g_queryInfo.superQueryInfo.resubAfterConsume[j] =
-                superResubAfterConsume->valueint;
-        } else if (!superResubAfterConsume) {
-            //printf("failed to read json, subscribe interval no found\n");
-            //goto PARSE_OVER;
-            g_queryInfo.superQueryInfo.resubAfterConsume[j] = 1;
-        }
-
         cJSON *result = cJSON_GetObjectItem(sql, "result");
         if (result != NULL && result->type == cJSON_String
             && result->valuestring != NULL){
@@ -6688,6 +6688,8 @@ static void *superSubscribe(void *sarg) {
   }
   TAOS_RES* res = NULL;
 
+  uint64_t st = 0, et = 0;
+
   while(1) {
     for (uint64_t i = pThreadInfo->start_table_from;
             i <= pThreadInfo->end_table_to; i++) {
@@ -6696,7 +6698,12 @@ static void *superSubscribe(void *sarg) {
           continue;
       }
 
+      st = taosGetTimestampMs();
+      performancePrint("st: %"PRIu64" et: %"PRIu64" st-et: %"PRIu64"\n", st, et, (st - et));
       res = taos_consume(tsub[tsubSeq]);
+      et = taosGetTimestampMs();
+      performancePrint("st: %"PRIu64" et: %"PRIu64" delta: %"PRIu64"\n", st, et, (et - st));
+
       if (res) {
           if (g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq][0] != 0) {
               sprintf(pThreadInfo->fp, "%s-%d",
@@ -6714,7 +6721,7 @@ static void *superSubscribe(void *sarg) {
 
           if ((g_queryInfo.superQueryInfo.subscribeKeepProgress)
                   && (consumed[tsubSeq] >=
-                      g_queryInfo.superQueryInfo.resubAfterConsume[pThreadInfo->querySeq])) {
+                      g_queryInfo.superQueryInfo.resubAfterConsume)) {
               printf("keepProgress:%d, resub super table query: %"PRIu64"\n",
                       g_queryInfo.superQueryInfo.subscribeKeepProgress,
                       pThreadInfo->querySeq);

From 6c9df9d519bc59a84cb83818b93cc77ffd0f460f Mon Sep 17 00:00:00 2001
From: Minglei Jin <stephenk@gmx.us>
Date: Fri, 21 May 2021 21:44:51 +0800
Subject: [PATCH 073/128] [TD-4279]<fix>: fix mnode single online as master

---
 src/sync/src/syncMain.c                                   | 6 ++++--
 tests/script/unique/arbitrator/dn3_mn1_vnode_nomaster.sim | 2 +-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/sync/src/syncMain.c b/src/sync/src/syncMain.c
index e5f2d94c4a..1785f066d4 100644
--- a/src/sync/src/syncMain.c
+++ b/src/sync/src/syncMain.c
@@ -709,7 +709,7 @@ static void syncChooseMaster(SSyncNode *pNode) {
 }
 
 static SSyncPeer *syncCheckMaster(SSyncNode *pNode) {
-  int32_t onlineNum = 0;
+  int32_t onlineNum = 0, arbOnlineNum = 0;
   int32_t masterIndex = -1;
   int32_t replica = pNode->replica;
 
@@ -723,13 +723,15 @@ static SSyncPeer *syncCheckMaster(SSyncNode *pNode) {
   SSyncPeer *pArb = pNode->peerInfo[TAOS_SYNC_MAX_REPLICA];
   if (pArb && pArb->role != TAOS_SYNC_ROLE_OFFLINE) {
     onlineNum++;
+    ++arbOnlineNum;
     replica = pNode->replica + 1;
   }
 
   if (onlineNum <= replica * 0.5) {
     if (nodeRole != TAOS_SYNC_ROLE_UNSYNCED) {
-       if (nodeRole == TAOS_SYNC_ROLE_MASTER && onlineNum == replica * 0.5 && onlineNum >= 1) {
+      if (nodeRole == TAOS_SYNC_ROLE_MASTER && onlineNum == replica * 0.5 && ((replica > 2 && onlineNum - arbOnlineNum > 1) || pNode->replica < 3)) {
          sInfo("vgId:%d, self keep work as master, online:%d replica:%d", pNode->vgId, onlineNum, replica);
+	 masterIndex = pNode->selfIndex;
        } else {
         nodeRole = TAOS_SYNC_ROLE_UNSYNCED;
         sInfo("vgId:%d, self change to unsynced state, online:%d replica:%d", pNode->vgId, onlineNum, replica);
diff --git a/tests/script/unique/arbitrator/dn3_mn1_vnode_nomaster.sim b/tests/script/unique/arbitrator/dn3_mn1_vnode_nomaster.sim
index 8e15c4f527..b9ee508f78 100644
--- a/tests/script/unique/arbitrator/dn3_mn1_vnode_nomaster.sim
+++ b/tests/script/unique/arbitrator/dn3_mn1_vnode_nomaster.sim
@@ -158,7 +158,7 @@ if $dnode4Vtatus != offline then
   sleep 2000
   goto wait_dnode4_vgroup_offline
 endi
-if $dnode3Vtatus != master then
+if $dnode3Vtatus != unsynced then
   sleep 2000
   goto wait_dnode4_vgroup_offline
 endi

From ccdd3213e62cbc73e50dc0d8a25e7412b71ce3ba Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Sat, 22 May 2021 21:07:40 +0800
Subject: [PATCH 074/128] Hotfix/sangshuduo/td 4240 taosdemo subscribe morethan
 100 (#6202)

* [TD-4240]<fix>: taosdemo subscribe more than max query sql count.

* [TD-4240]<fix>: taosdemo subscribe more than 100.

fix tsub sequence bug.

* [TD-4240]<fix>: taosdemo subscribe more than 100.

fix auto create table.

* [TD-4240]<fix>: taosdemo subscribe more than 100.

remove the condition should not be there.

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdemo/taosdemo.c | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index 02d72fc445..d4faecf1f0 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -6612,15 +6612,6 @@ static void *superSubscribe(void *sarg) {
       exit(-1);
   }
 
-  if (g_queryInfo.superQueryInfo.sqlCount * pThreadInfo->ntables > MAX_QUERY_SQL_COUNT) {
-      errorPrint("The number %"PRId64" of sql count(%"PRIu64") multiple the table number(%"PRId64") of the thread is more than max query sql count: %d\n",
-              g_queryInfo.superQueryInfo.sqlCount * pThreadInfo->ntables,
-              g_queryInfo.superQueryInfo.sqlCount,
-              pThreadInfo->ntables,
-              MAX_QUERY_SQL_COUNT);
-      exit(-1);
-  }
-
   if (pThreadInfo->taos == NULL) {
     TAOS * taos = NULL;
     taos = taos_connect(g_queryInfo.host,

From 94d45c3976ee24a8a3232275c197de3ab22b0f49 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Mon, 24 May 2021 11:27:11 +0800
Subject: [PATCH 075/128] [TD-3197]<fix>: taosdemo and taosdump coverity scan
 issues. (#6207)

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdemo/taosdemo.c | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index d4faecf1f0..81f48067d0 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -1114,21 +1114,21 @@ static int queryDbExec(TAOS *taos, char *command, QUERY_TYPE type, bool quiet) {
 
 static void appendResultBufToFile(char *resultBuf, char *resultFile)
 {
-  FILE *fp = NULL;
-  if (resultFile[0] != 0) {
-    fp = fopen(resultFile, "at");
-    if (fp == NULL) {
-      errorPrint(
-              "%s() LN%d, failed to open result file: %s, result will not save to file\n",
-              __func__, __LINE__, resultFile);
-      return;
+    FILE *fp = NULL;
+    if (resultFile[0] != 0) {
+        fp = fopen(resultFile, "at");
+        if (fp == NULL) {
+            errorPrint(
+                    "%s() LN%d, failed to open result file: %s, result will not save to file\n",
+                    __func__, __LINE__, resultFile);
+            return;
+        }
+        fprintf(fp, "%s", resultBuf);
+        tmfclose(fp);
     }
-  }
-
-  fprintf(fp, "%s", resultBuf);
-  tmfclose(fp);
 }
 
+
 static void appendResultToFile(TAOS_RES *res, char* resultFile) {
   TAOS_ROW    row = NULL;
   int         num_rows = 0;

From 5772028d6e8807cf2f617987ed5c300cb46ca8ce Mon Sep 17 00:00:00 2001
From: zyyang <69311263+zyyang-taosdata@users.noreply.github.com>
Date: Mon, 24 May 2021 11:45:23 +0800
Subject: [PATCH 076/128] change version number
 (#6204)https://github.com/taosdata/TDengine/tree/release/ver-2.0.20.5

Co-authored-by: plum-lihui <huili@taosdata.com>
---
 .gitmodules         | 6 +++---
 cmake/version.inc   | 2 +-
 snap/snapcraft.yaml | 4 ++--
 src/connector/go    | 2 +-
 4 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.gitmodules b/.gitmodules
index 74afbbf997..0e65b02221 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,12 +1,12 @@
 [submodule "src/connector/go"]
 	path = src/connector/go
-	url = https://github.com/taosdata/driver-go
+	url = git@github.com:taosdata/driver-go.git
 [submodule "src/connector/grafanaplugin"]
 	path = src/connector/grafanaplugin
-	url = https://github.com/taosdata/grafanaplugin
+	url = git@github.com:taosdata/grafanaplugin.git
 [submodule "src/connector/hivemq-tdengine-extension"]
 	path = src/connector/hivemq-tdengine-extension
-	url = https://github.com/huskar-t/hivemq-tdengine-extension.git
+	url = git@github.com:taosdata/hivemq-tdengine-extension.git
 [submodule "tests/examples/rust"]
 	path = tests/examples/rust
 	url = https://github.com/songtianyi/tdengine-rust-bindings.git
diff --git a/cmake/version.inc b/cmake/version.inc
index a560c7f598..79eacb2d05 100755
--- a/cmake/version.inc
+++ b/cmake/version.inc
@@ -4,7 +4,7 @@ PROJECT(TDengine)
 IF (DEFINED VERNUMBER)
   SET(TD_VER_NUMBER ${VERNUMBER})
 ELSE ()
-  SET(TD_VER_NUMBER "2.0.20.2")
+  SET(TD_VER_NUMBER "2.0.20.5")
 ENDIF ()
 
 IF (DEFINED VERCOMPATIBLE)
diff --git a/snap/snapcraft.yaml b/snap/snapcraft.yaml
index 9c7400c616..49eadd26d7 100644
--- a/snap/snapcraft.yaml
+++ b/snap/snapcraft.yaml
@@ -1,6 +1,6 @@
 name: tdengine
 base: core18
-version: '2.0.20.2'
+version: '2.0.20.5'
 icon: snap/gui/t-dengine.svg
 summary: an open-source big data platform designed and optimized for IoT. 
 description: |
@@ -72,7 +72,7 @@ parts:
       - usr/bin/taosd
       - usr/bin/taos
       - usr/bin/taosdemo
-      - usr/lib/libtaos.so.2.0.20.2
+      - usr/lib/libtaos.so.2.0.20.5
       - usr/lib/libtaos.so.1
       - usr/lib/libtaos.so
 
diff --git a/src/connector/go b/src/connector/go
index 050667e5b4..8ce6d86558 160000
--- a/src/connector/go
+++ b/src/connector/go
@@ -1 +1 @@
-Subproject commit 050667e5b4d0eafa5387e4283e713559b421203f
+Subproject commit 8ce6d86558afc8c0b50c10f990fd2b4270cf06fc

From df588afe847a158f653729d997dd658a512c3104 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Mon, 24 May 2021 13:42:04 +0800
Subject: [PATCH 077/128] [TD-4322]<fix>: taosdemo query then fetch result.
 (#6210)

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdemo/taosdemo.c | 57 ++++++++++++++++++-------------------
 1 file changed, 28 insertions(+), 29 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index 81f48067d0..5be7aea941 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -1114,22 +1114,20 @@ static int queryDbExec(TAOS *taos, char *command, QUERY_TYPE type, bool quiet) {
 
 static void appendResultBufToFile(char *resultBuf, char *resultFile)
 {
-    FILE *fp = NULL;
-    if (resultFile[0] != 0) {
-        fp = fopen(resultFile, "at");
-        if (fp == NULL) {
-            errorPrint(
-                    "%s() LN%d, failed to open result file: %s, result will not save to file\n",
-                    __func__, __LINE__, resultFile);
-            return;
-        }
-        fprintf(fp, "%s", resultBuf);
-        tmfclose(fp);
-    }
+  FILE *fp = NULL;
+  fp = fopen(resultFile, "at");
+  if (fp == NULL) {
+      errorPrint(
+              "%s() LN%d, failed to open result file: %s, result will not save to file\n",
+              __func__, __LINE__, resultFile);
+      return;
+  }
+
+  fprintf(fp, "%s", resultBuf);
+  tmfclose(fp);
 }
 
-
-static void appendResultToFile(TAOS_RES *res, char* resultFile) {
+static void fetchResult(TAOS_RES *res, char* resultFile) {
   TAOS_ROW    row = NULL;
   int         num_rows = 0;
   int         num_fields = taos_field_count(res);
@@ -1147,10 +1145,11 @@ static void appendResultToFile(TAOS_RES *res, char* resultFile) {
 
   // fetch the records row by row
   while((row = taos_fetch_row(res))) {
-    if (totalLen >= 100*1024*1024 - 32000) {
-      appendResultBufToFile(databuf, resultFile);
-      totalLen = 0;
-      memset(databuf, 0, 100*1024*1024);
+    if ((resultFile)
+            && (totalLen >= 100*1024*1024 - 32000)) {
+        appendResultBufToFile(databuf, resultFile);
+        totalLen = 0;
+        memset(databuf, 0, 100*1024*1024);
     }
     num_rows++;
     int len = taos_print_row(temp, row, fields, num_fields);
@@ -1162,7 +1161,9 @@ static void appendResultToFile(TAOS_RES *res, char* resultFile) {
 
   verbosePrint("%s() LN%d, databuf=%s resultFile=%s\n",
           __func__, __LINE__, databuf, resultFile);
-  appendResultBufToFile(databuf, resultFile);
+  if (resultFile) {
+    appendResultBufToFile(databuf, resultFile);
+  }
   free(databuf);
 }
 
@@ -1178,9 +1179,7 @@ static void selectAndGetResult(
         return;
     }
 
-    if ((strlen(pThreadInfo->fp))) {
-      appendResultToFile(res, pThreadInfo->fp);
-    }
+    fetchResult(res, pThreadInfo->fp);
     taos_free_result(res);
 
   } else if (0 == strncasecmp(g_queryInfo.queryMode, "rest", strlen("rest"))) {
@@ -2017,13 +2016,13 @@ static void printfQuerySystemInfo(TAOS * taos) {
 
   // show variables
   res = taos_query(taos, "show variables;");
-  //appendResultToFile(res, filename);
+  //fetchResult(res, filename);
   xDumpResultToFile(filename, res);
 
   // show dnodes
   res = taos_query(taos, "show dnodes;");
   xDumpResultToFile(filename, res);
-  //appendResultToFile(res, filename);
+  //fetchResult(res, filename);
 
   // show databases
   res = taos_query(taos, "show databases;");
@@ -6546,7 +6545,7 @@ static void stable_sub_callback(
   }
 
   if (param)
-    appendResultToFile(res, ((threadInfo *)param)->fp);
+    fetchResult(res, ((threadInfo *)param)->fp);
   // tao_unscribe() will free result.
 }
 
@@ -6559,7 +6558,7 @@ static void specified_sub_callback(
   }
 
   if (param)
-    appendResultToFile(res, ((threadInfo *)param)->fp);
+    fetchResult(res, ((threadInfo *)param)->fp);
   // tao_unscribe() will free result.
 }
 
@@ -6700,13 +6699,13 @@ static void *superSubscribe(void *sarg) {
               sprintf(pThreadInfo->fp, "%s-%d",
                       g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq],
                       pThreadInfo->threadID);
-              appendResultToFile(res, pThreadInfo->fp);
+              fetchResult(res, pThreadInfo->fp);
           }
           if (g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq][0] != 0) {
               sprintf(pThreadInfo->fp, "%s-%d",
                       g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq],
                       pThreadInfo->threadID);
-              appendResultToFile(res, pThreadInfo->fp);
+              fetchResult(res, pThreadInfo->fp);
           }
           consumed[tsubSeq] ++;
 
@@ -6807,7 +6806,7 @@ static void *specifiedSubscribe(void *sarg) {
               sprintf(pThreadInfo->fp, "%s-%d",
                       g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq],
                       pThreadInfo->threadID);
-              appendResultToFile(res, pThreadInfo->fp);
+              fetchResult(res, pThreadInfo->fp);
           }
 
           consumed ++;

From 20fa37c2538667849efb70191130ceb306c1938f Mon Sep 17 00:00:00 2001
From: Steven Li <stevenli@taosdata.com>
Date: Mon, 24 May 2021 06:11:39 +0000
Subject: [PATCH 078/128] Enhanced crash_gen tool with -k option to produce
 valgrind result

---
 tests/pytest/crash_gen/service_manager.py | 58 +++++++++++------------
 tests/pytest/crash_gen/shared/types.py    |  4 +-
 2 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/tests/pytest/crash_gen/service_manager.py b/tests/pytest/crash_gen/service_manager.py
index 95507f0142..1cd65c1dde 100644
--- a/tests/pytest/crash_gen/service_manager.py
+++ b/tests/pytest/crash_gen/service_manager.py
@@ -22,7 +22,7 @@ from queue import Queue, Empty
 from .shared.config import Config
 from .shared.db import DbTarget, DbConn
 from .shared.misc import Logging, Helper, CrashGenError, Status, Progress, Dice
-from .shared.types import DirPath
+from .shared.types import DirPath, IpcStream
 
 # from crash_gen.misc import CrashGenError, Dice, Helper, Logging, Progress, Status
 # from crash_gen.db import DbConn, DbTarget
@@ -177,13 +177,12 @@ quorum 2
         return "127.0.0.1"
 
     def getServiceCmdLine(self): # to start the instance
-        cmdLine = []
         if Config.getConfig().track_memory_leaks:
             Logging.info("Invoking VALGRIND on service...")
-            cmdLine = ['valgrind', '--leak-check=yes']
-        # TODO: move "exec -c" into Popen(), we can both "use shell" and NOT fork so ask to lose kill control
-        cmdLine += ["exec " + self.getExecFile(), '-c', self.getCfgDir()] # used in subproce.Popen()        
-        return cmdLine
+            return ['exec /usr/bin/valgrind', '--leak-check=yes', self.getExecFile(), '-c', self.getCfgDir()]
+        else:
+            # TODO: move "exec -c" into Popen(), we can both "use shell" and NOT fork so ask to lose kill control
+            return ["exec " + self.getExecFile(), '-c', self.getCfgDir()] # used in subproce.Popen()
     
     def _getDnodes(self, dbc):
         dbc.query("show dnodes")
@@ -281,16 +280,16 @@ class TdeSubProcess:
         return '[TdeSubProc: pid = {}, status = {}]'.format(
             self.getPid(), self.getStatus() )
 
-    def getStdOut(self) -> BinaryIO :
+    def getIpcStdOut(self) -> IpcStream :
         if self._popen.universal_newlines : # alias of text_mode
             raise CrashGenError("We need binary mode for STDOUT IPC")
         # Logging.info("Type of stdout is: {}".format(type(self._popen.stdout)))
-        return typing.cast(BinaryIO, self._popen.stdout)
+        return typing.cast(IpcStream, self._popen.stdout)
 
-    def getStdErr(self) -> BinaryIO :
+    def getIpcStdErr(self) -> IpcStream :
         if self._popen.universal_newlines : # alias of text_mode
             raise CrashGenError("We need binary mode for STDERR IPC")
-        return typing.cast(BinaryIO, self._popen.stderr)
+        return typing.cast(IpcStream, self._popen.stderr)
 
     # Now it's always running, since we matched the life cycle
     # def isRunning(self):
@@ -301,11 +300,6 @@ class TdeSubProcess:
 
     def _start(self, cmdLine) -> Popen :
         ON_POSIX = 'posix' in sys.builtin_module_names
-
-        # Sanity check
-        # if self.subProcess:  # already there
-        #     raise RuntimeError("Corrupt process state")
-
         
         # Prepare environment variables for coverage information
         # Ref: https://stackoverflow.com/questions/2231227/python-subprocess-popen-with-a-modified-environment
@@ -314,9 +308,8 @@ class TdeSubProcess:
 
         # print(myEnv)
         # print("Starting TDengine with env: ", myEnv.items())
-        # print("Starting TDengine via Shell: {}".format(cmdLineStr))
+        print("Starting TDengine: {}".format(cmdLine))
 
-        # useShell = True # Needed to pass environments into it
         return Popen(            
             ' '.join(cmdLine), # ' '.join(cmdLine) if useShell else cmdLine,
             shell=True, # Always use shell, since we need to pass ENV vars
@@ -732,19 +725,19 @@ class ServiceManagerThread:
         self._ipcQueue = Queue() # type: Queue
         self._thread = threading.Thread( # First thread captures server OUTPUT
             target=self.svcOutputReader,
-            args=(subProc.getStdOut(), self._ipcQueue, logDir))
+            args=(subProc.getIpcStdOut(), self._ipcQueue, logDir))
         self._thread.daemon = True  # thread dies with the program
         self._thread.start()
         time.sleep(0.01)
         if not self._thread.is_alive(): # What happened?
-            Logging.info("Failed to started process to monitor STDOUT")
+            Logging.info("Failed to start process to monitor STDOUT")
             self.stop()
             raise CrashGenError("Failed to start thread to monitor STDOUT")
         Logging.info("Successfully started process to monitor STDOUT")
 
         self._thread2 = threading.Thread( # 2nd thread captures server ERRORs
             target=self.svcErrorReader,
-            args=(subProc.getStdErr(), self._ipcQueue, logDir))
+            args=(subProc.getIpcStdErr(), self._ipcQueue, logDir))
         self._thread2.daemon = True  # thread dies with the program
         self._thread2.start()
         time.sleep(0.01)
@@ -887,14 +880,19 @@ class ServiceManagerThread:
             print("\nNon-UTF8 server output: {}\n".format(bChunk.decode('cp437')))
             return None
 
-    def _textChunkGenerator(self, streamIn: BinaryIO, logDir: str, logFile: str
+    def _textChunkGenerator(self, streamIn: IpcStream, logDir: str, logFile: str
             ) -> Generator[TextChunk, None, None]:
         '''
-        Take an input stream with binary data, produced a generator of decoded
-        "text chunks", and also save the original binary data in a log file.
+        Take an input stream with binary data (likely from Popen), produced a generator of decoded
+        "text chunks".
+        
+        Side effect: it also save the original binary data in a log file.
         '''
         os.makedirs(logDir, exist_ok=True)
         logF = open(os.path.join(logDir, logFile), 'wb')
+        if logF is None:
+            Logging.error("Failed to open log file (binary write): {}/{}".format(logDir, logFile))
+            return
         for bChunk in iter(streamIn.readline, b''):
             logF.write(bChunk) # Write to log file immediately
             tChunk = self._decodeBinaryChunk(bChunk) # decode
@@ -902,14 +900,14 @@ class ServiceManagerThread:
                 yield tChunk # TODO: split into actual text lines
 
         # At the end...
-        streamIn.close() # Close the stream
-        logF.close() # Close the output file
+        streamIn.close() # Close the incoming stream
+        logF.close() # Close the log file
 
-    def svcOutputReader(self, stdOut: BinaryIO, queue, logDir: str):
+    def svcOutputReader(self, ipcStdOut: IpcStream, queue, logDir: str):
         '''
         The infinite routine that processes the STDOUT stream for the sub process being managed.
 
-        :param stdOut: the IO stream object used to fetch the data from
+        :param ipcStdOut: the IO stream object used to fetch the data from
         :param queue: the queue where we dump the roughly parsed chunk-by-chunk text data
         :param logDir: where we should dump a verbatim output file
         '''
@@ -917,7 +915,7 @@ class ServiceManagerThread:
         # Important Reference: https://stackoverflow.com/questions/375427/non-blocking-read-on-a-subprocess-pipe-in-python
         # print("This is the svcOutput Reader...")
         # stdOut.readline() # Skip the first output? TODO: remove?
-        for tChunk in self._textChunkGenerator(stdOut, logDir, 'stdout.log') :
+        for tChunk in self._textChunkGenerator(ipcStdOut, logDir, 'stdout.log') :
             queue.put(tChunk) # tChunk garanteed not to be None
             self._printProgress("_i")
 
@@ -940,12 +938,12 @@ class ServiceManagerThread:
         Logging.info("EOF found TDengine STDOUT, marking the process as terminated")
         self.setStatus(Status.STATUS_STOPPED)
 
-    def svcErrorReader(self, stdErr: BinaryIO, queue, logDir: str):
+    def svcErrorReader(self, ipcStdErr: IpcStream, queue, logDir: str):
         # os.makedirs(logDir, exist_ok=True)
         # logFile = os.path.join(logDir,'stderr.log')
         # fErr = open(logFile, 'wb')
         # for line in iter(err.readline, b''):
-        for tChunk in self._textChunkGenerator(stdErr, logDir, 'stderr.log') :
+        for tChunk in self._textChunkGenerator(ipcStdErr, logDir, 'stderr.log') :
             queue.put(tChunk) # tChunk garanteed not to be None
             # fErr.write(line)
             Logging.info("TDengine STDERR: {}".format(tChunk))
diff --git a/tests/pytest/crash_gen/shared/types.py b/tests/pytest/crash_gen/shared/types.py
index 814a821917..42fd2a1617 100644
--- a/tests/pytest/crash_gen/shared/types.py
+++ b/tests/pytest/crash_gen/shared/types.py
@@ -1,4 +1,4 @@
-from typing import Any, List, Dict, NewType
+from typing import Any, BinaryIO, List, Dict, NewType
 from enum import Enum
 
 DirPath = NewType('DirPath', str)
@@ -26,3 +26,5 @@ class TdDataType(Enum):
 
 TdColumns = Dict[str, TdDataType]
 TdTags    = Dict[str, TdDataType]
+
+IpcStream = NewType('IpcStream', BinaryIO)
\ No newline at end of file

From 0626a0914df776b336767d8fbd24021d9373e988 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Mon, 24 May 2021 16:32:11 +0800
Subject: [PATCH 079/128] Hotfix/sangshuduo/td 4296 taosdemo subscribe
 keepprogress (#6216)

* [TD-4296]<fix>: taosdemo sub keepProgress.

* make print sqlcount quiet.

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdemo/taosdemo.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index 5be7aea941..26088191cb 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -6915,7 +6915,7 @@ static int subscribeTestProcess() {
 
   //==== create threads for super table query
   if (g_queryInfo.superQueryInfo.sqlCount <= 0) {
-    printf("%s() LN%d, super table query sqlCount %"PRIu64".\n",
+    debugPrint("%s() LN%d, super table query sqlCount %"PRIu64".\n",
               __func__, __LINE__,
               g_queryInfo.superQueryInfo.sqlCount);
   } else {

From 0923ccb3ad5edf7558cb57e0a2b32b1ae3e4aa0f Mon Sep 17 00:00:00 2001
From: liuyq-617 <yqliu@taosdata.com>
Date: Mon, 24 May 2021 17:08:37 +0800
Subject: [PATCH 080/128] [TD-4327]jenkins migration

---
 tests/Jenkinsfile     |   6 +-
 tests/mas/Jenkinsfile | 309 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 312 insertions(+), 3 deletions(-)
 create mode 100644 tests/mas/Jenkinsfile

diff --git a/tests/Jenkinsfile b/tests/Jenkinsfile
index 64a71ef8f9..e785c8e807 100644
--- a/tests/Jenkinsfile
+++ b/tests/Jenkinsfile
@@ -37,7 +37,7 @@ pipeline {
       stage('Parallel test stage') {
       parallel {
         stage('pytest') {
-          agent{label '184'}
+          agent{label 'slad1'}
           steps {
             pre_test()
             sh '''
@@ -62,7 +62,7 @@ pipeline {
         }
 
         stage('test_crash_gen') {
-          agent{label "185"}
+          agent{label "slad2"}
           steps {
             pre_test()
             sh '''
@@ -149,7 +149,7 @@ pipeline {
         }
 
         stage('test_valgrind') {
-          agent{label "186"}
+          agent{label "slad3"}
 
           steps {
             pre_test()
diff --git a/tests/mas/Jenkinsfile b/tests/mas/Jenkinsfile
new file mode 100644
index 0000000000..b2a1a5e116
--- /dev/null
+++ b/tests/mas/Jenkinsfile
@@ -0,0 +1,309 @@
+def pre_test(){
+   
+    sh '''
+    sudo rmtaos||echo 'no taosd installed'
+    '''
+    sh '''
+    cd ${WKC}
+    git reset --hard
+    git checkout $BRANCH_NAME
+    git pull
+    git submodule update
+    cd ${WK}
+    git reset --hard
+    git checkout $BRANCH_NAME
+    git pull
+    export TZ=Asia/Harbin
+    date
+    rm -rf ${WK}/debug
+    mkdir debug
+    cd debug
+    cmake .. > /dev/null
+    make > /dev/null
+    make install > /dev/null
+    pip3 install ${WKC}/src/connector/python/linux/python3/
+    '''
+    return 1
+}
+pipeline {
+  agent none
+  environment{
+    
+      WK = '/var/lib/jenkins/workspace/TDinternal'
+      WKC= '/var/lib/jenkins/workspace/TDinternal/community'
+  }
+
+  stages {
+      stage('Parallel test stage') {
+      parallel {
+        stage('pytest') {
+          agent{label 'slam1'}
+          steps {
+            pre_test()
+            sh '''
+            cd ${WKC}/tests
+            find pytest -name '*'sql|xargs rm -rf
+            ./test-all.sh pytest
+            date'''
+          }
+        }
+        stage('test_b1') {
+          agent{label 'slam2'}
+          steps {
+            pre_test()
+            
+            sh '''
+            cd ${WKC}/tests
+            ./test-all.sh b1
+            date'''
+            
+            
+          }
+        }
+
+        stage('test_crash_gen') {
+          agent{label "slam3"}
+          steps {
+            pre_test()
+            sh '''
+            cd ${WKC}/tests/pytest
+            '''
+            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                cd ${WKC}/tests/pytest
+                ./crash_gen.sh -a -p -t 4 -s 2000
+                '''
+            }
+            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                cd ${WKC}/tests/pytest
+                rm -rf /var/lib/taos/*
+                rm -rf /var/log/taos/*
+                ./handle_crash_gen_val_log.sh
+                '''
+            }
+            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                cd ${WKC}/tests/pytest
+                rm -rf /var/lib/taos/*
+                rm -rf /var/log/taos/*
+                ./handle_taosd_val_log.sh
+                '''
+            }
+            
+            sh'''
+            systemctl start taosd 
+            sleep 10
+            '''
+            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                cd ${WKC}/tests/gotest
+                bash batchtest.sh
+                '''
+            }
+            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                cd ${WKC}/tests/examples/python/PYTHONConnectorChecker
+                python3 PythonChecker.py
+                '''
+            }
+            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                cd ${WKC}/tests/examples/JDBC/JDBCDemo/
+                mvn clean package assembly:single -DskipTests >/dev/null 
+                java -jar target/JDBCDemo-SNAPSHOT-jar-with-dependencies.jar -host 127.0.0.1
+                '''
+            }
+            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                cd ${WKC}/src/connector/jdbc
+                mvn clean package -Dmaven.test.skip=true >/dev/null 
+                cd ${WKC}/tests/examples/JDBC/JDBCDemo/
+                java --class-path=../../../../src/connector/jdbc/target:$JAVA_HOME/jre/lib/ext -jar target/JDBCDemo-SNAPSHOT-jar-with-dependencies.jar -host 127.0.0.1
+                '''
+            }
+            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                cp -rf ${WKC}/tests/examples/nodejs ${JENKINS_HOME}/workspace/
+                cd ${JENKINS_HOME}/workspace/nodejs
+                node nodejsChecker.js host=localhost
+                '''
+            }
+            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                cd ${JENKINS_HOME}/workspace/C#NET/src/CheckC#
+                dotnet run
+                '''
+            }
+            sh '''
+            systemctl stop taosd 
+            cd ${WKC}/tests
+            ./test-all.sh b2
+            date
+            '''
+            sh '''
+            cd ${WKC}/tests
+            ./test-all.sh full unit
+            date'''
+          }
+        }
+
+        stage('test_valgrind') {
+          agent{label "slam4"}
+
+          steps {
+            pre_test()
+            catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                sh '''
+                cd ${WKC}/tests/pytest
+                nohup taosd >/dev/null &
+                sleep 10
+                python3 concurrent_inquiry.py -c 1
+                
+                '''
+            }
+            sh '''
+            cd ${WKC}/tests
+            ./test-all.sh full jdbc
+            date'''
+            sh '''
+            cd ${WKC}/tests/pytest
+            ./valgrind-test.sh 2>&1 > mem-error-out.log
+            ./handle_val_log.sh
+          
+            date
+            cd ${WKC}/tests
+            ./test-all.sh b3
+            date'''
+            sh '''
+            date
+            cd ${WKC}/tests
+            ./test-all.sh full example
+            date'''
+          }
+        }
+       
+       stage('arm64_build'){
+                agent{label 'arm64'}
+                steps{
+                    sh '''
+                    cd ${WK}
+                    git fetch
+                    git checkout develop
+                    git pull
+                    cd ${WKC}
+                    git fetch
+                    git checkout develop
+                    git pull
+                    git submodule update                    
+                    cd ${WKC}/packaging
+                    ./release.sh -v cluster -c aarch64 -n 2.0.0.0 -m 2.0.0.0
+                    
+                    '''
+                }
+            }
+            stage('arm32_build'){
+                agent{label 'arm32'}
+                steps{
+                    catchError(buildResult: 'SUCCESS', stageResult: 'FAILURE') {
+                        sh '''
+                        cd ${WK}
+                        git fetch
+                        git checkout develop
+                        git pull
+                        cd ${WKC}
+                        git fetch
+                        git checkout develop
+                        git pull
+                        git submodule update
+                        cd ${WKC}/packaging
+                        ./release.sh -v cluster -c aarch32 -n 2.0.0.0 -m 2.0.0.0
+                        
+                        '''
+                    }
+                    
+                }
+            }
+      }
+    }
+
+  }
+  post {             
+        success {
+            emailext (
+                subject: "SUCCESSFUL: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]'",
+                body: '''<!DOCTYPE html>
+                <html>
+                <head>
+                <meta charset="UTF-8">
+                </head>
+                <body leftmargin="8" marginwidth="0" topmargin="8" marginheight="4" offset="0">
+                    <table width="95%" cellpadding="0" cellspacing="0" style="font-size: 16pt; font-family: Tahoma, Arial, Helvetica, sans-serif">
+                        <tr>
+                            <td><br />
+                                <b><font color="#0B610B"><font size="6">构建信息</font></font></b>
+                                <hr size="2" width="100%" align="center" /></td>
+                        </tr>
+                        <tr>
+                            <td>
+                                <ul>
+                                <div style="font-size:18px">
+                                    <li>构建名称>>分支：${PROJECT_NAME}</li>
+                                    <li>构建结果：<span style="color:green"> Successful </span></li>
+                                    <li>构建编号：${BUILD_NUMBER}</li>
+                                    <li>触发用户：${CAUSE}</li>
+                                    <li>变更概要：${CHANGES}</li>
+                                    <li>构建地址：<a href=${BUILD_URL}>${BUILD_URL}</a></li>
+                                    <li>构建日志：<a href=${BUILD_URL}console>${BUILD_URL}console</a></li>
+                                    <li>变更集：${JELLY_SCRIPT}</li>
+                                </div>
+                                </ul>
+                            </td>
+                        </tr>
+                    </table></font>
+                </body>
+                </html>''',
+                to: "yqliu@taosdata.com,pxiao@taosdata.com",
+                from: "support@taosdata.com"
+            )
+        }
+        failure {
+            emailext (
+                subject: "FAILED: Job '${env.JOB_NAME} [${env.BUILD_NUMBER}]'",
+                body: '''<!DOCTYPE html>
+                <html>
+                <head>
+                <meta charset="UTF-8">
+                </head>
+                <body leftmargin="8" marginwidth="0" topmargin="8" marginheight="4" offset="0">
+                    <table width="95%" cellpadding="0" cellspacing="0" style="font-size: 16pt; font-family: Tahoma, Arial, Helvetica, sans-serif">
+                        <tr>
+                            <td><br />
+                                <b><font color="#0B610B"><font size="6">构建信息</font></font></b>
+                                <hr size="2" width="100%" align="center" /></td>
+                        </tr>
+                        <tr>
+                            <td>
+                                <ul>
+                                <div style="font-size:18px">
+                                    <li>构建名称>>分支：${PROJECT_NAME}</li>
+                                    <li>构建结果：<span style="color:green"> Successful </span></li>
+                                    <li>构建编号：${BUILD_NUMBER}</li>
+                                    <li>触发用户：${CAUSE}</li>
+                                    <li>变更概要：${CHANGES}</li>
+                                    <li>构建地址：<a href=${BUILD_URL}>${BUILD_URL}</a></li>
+                                    <li>构建日志：<a href=${BUILD_URL}console>${BUILD_URL}console</a></li>
+                                    <li>变更集：${JELLY_SCRIPT}</li>
+                                </div>
+                                </ul>
+                            </td>
+                        </tr>
+                    </table></font>
+                </body>
+                </html>''',
+                to: "yqliu@taosdata.com,pxiao@taosdata.com",
+                from: "support@taosdata.com"
+            )
+        }
+    }
+}
\ No newline at end of file

From 09f3c72455ef52ed637369f94d2244cac290f055 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Mon, 24 May 2021 20:12:20 +0800
Subject: [PATCH 081/128] Hotfix/sangshuduo/td 4322 taosdemo fetch result
 (#6219)

* [TD-4322]<fix>: taosdemo query then fetch result.

* [TD-4322]<fix>: taosdemo fetch result.

check result file name length.

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdemo/taosdemo.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index 26088191cb..b37a3370c5 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -1145,7 +1145,7 @@ static void fetchResult(TAOS_RES *res, char* resultFile) {
 
   // fetch the records row by row
   while((row = taos_fetch_row(res))) {
-    if ((resultFile)
+    if ((resultFile) && (strlen(resultFile) > 0)
             && (totalLen >= 100*1024*1024 - 32000)) {
         appendResultBufToFile(databuf, resultFile);
         totalLen = 0;
@@ -1161,7 +1161,7 @@ static void fetchResult(TAOS_RES *res, char* resultFile) {
 
   verbosePrint("%s() LN%d, databuf=%s resultFile=%s\n",
           __func__, __LINE__, databuf, resultFile);
-  if (resultFile) {
+  if ((resultFile) && (strlen(resultFile) > 0)) {
     appendResultBufToFile(databuf, resultFile);
   }
   free(databuf);
@@ -2194,7 +2194,7 @@ static int postProceSql(char *host, struct sockaddr_in *pServAddr, uint16_t port
     response_buf[RESP_BUF_LEN - 1] = '\0';
     printf("Response:\n%s\n", response_buf);
 
-    if (resultFile) {
+    if ((resultFile) && (strlen(resultFile) > 0)) {
        appendResultBufToFile(response_buf, resultFile);
     }
 

From 40269fba16740ce096493ac7365b1d6e098f933a Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Mon, 24 May 2021 23:04:03 +0800
Subject: [PATCH 082/128] Hotfix/sangshuduo/td 4296 taosdemo subscribe
 keepprogress (#6221)

* [TD-4296]<fix>: taosdemo sub keepProgress.

* make print sqlcount quiet.

* [TD-4296]<fix>: taosdemo subscribe keepprogress.

specified query topic thread safe.

* [TD-4296]<fix>: taosdemo subscribe keepProgress.

specified query thread safe.

* fix compile warning for mac.

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdemo/taosdemo.c | 394 ++++++++++++++++++------------------
 1 file changed, 199 insertions(+), 195 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index b37a3370c5..b162be7739 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -363,7 +363,7 @@ typedef struct SDbs_S {
 
 typedef struct SpecifiedQueryInfo_S {
   uint64_t     queryInterval;  // 0: unlimit  > 0   loop/s
-  uint64_t     concurrent;
+  uint32_t     concurrent;
   uint64_t     sqlCount;
   uint32_t     asyncMode; // 0: sync, 1: async
   uint64_t     subscribeInterval; // ms
@@ -374,6 +374,9 @@ typedef struct SpecifiedQueryInfo_S {
   char         result[MAX_QUERY_SQL_COUNT][MAX_FILE_NAME_LEN+1];
   int          resubAfterConsume[MAX_QUERY_SQL_COUNT];
   TAOS_SUB*    tsub[MAX_QUERY_SQL_COUNT];
+  char         topic[MAX_QUERY_SQL_COUNT][32];
+  int          consumed[MAX_QUERY_SQL_COUNT];
+  TAOS_RES*    res[MAX_QUERY_SQL_COUNT];
   uint64_t     totalQueried;
 } SpecifiedQueryInfo;
 
@@ -418,7 +421,8 @@ typedef struct SThreadInfo_S {
   int       threadID;
   char      db_name[MAX_DB_NAME_SIZE+1];
   uint32_t  time_precision;
-  char      fp[4096];
+  char      filePath[4096];
+  FILE      *fp;
   char      tb_prefix[MAX_TB_NAME_SIZE];
   uint64_t  start_table_from;
   uint64_t  end_table_to;
@@ -451,6 +455,7 @@ typedef struct SThreadInfo_S {
 
   // seq of query or subscribe
   uint64_t  querySeq;   // sequence number of sql command
+  TAOS_SUB*  tsub;
 
 } threadInfo;
 
@@ -532,7 +537,7 @@ static int createDatabasesAndStables();
 static void createChildTables();
 static int queryDbExec(TAOS *taos, char *command, QUERY_TYPE type, bool quiet);
 static int postProceSql(char *host, struct sockaddr_in *pServAddr,
-        uint16_t port, char* sqlstr, char *resultFile);
+        uint16_t port, char* sqlstr, threadInfo *pThreadInfo);
 
 /* ************ Global variables ************  */
 
@@ -1112,22 +1117,22 @@ static int queryDbExec(TAOS *taos, char *command, QUERY_TYPE type, bool quiet) {
   return 0;
 }
 
-static void appendResultBufToFile(char *resultBuf, char *resultFile)
+static void appendResultBufToFile(char *resultBuf, threadInfo *pThreadInfo)
 {
-  FILE *fp = NULL;
-  fp = fopen(resultFile, "at");
-  if (fp == NULL) {
+  pThreadInfo->fp = fopen(pThreadInfo->filePath, "at");
+  if (pThreadInfo->fp == NULL) {
       errorPrint(
               "%s() LN%d, failed to open result file: %s, result will not save to file\n",
-              __func__, __LINE__, resultFile);
+              __func__, __LINE__, pThreadInfo->filePath);
       return;
   }
 
-  fprintf(fp, "%s", resultBuf);
-  tmfclose(fp);
+  fprintf(pThreadInfo->fp, "%s", resultBuf);
+  tmfclose(pThreadInfo->fp);
+  pThreadInfo->fp = NULL;
 }
 
-static void fetchResult(TAOS_RES *res, char* resultFile) {
+static void fetchResult(TAOS_RES *res, threadInfo* pThreadInfo) {
   TAOS_ROW    row = NULL;
   int         num_rows = 0;
   int         num_fields = taos_field_count(res);
@@ -1145,9 +1150,9 @@ static void fetchResult(TAOS_RES *res, char* resultFile) {
 
   // fetch the records row by row
   while((row = taos_fetch_row(res))) {
-    if ((resultFile) && (strlen(resultFile) > 0)
+    if ((strlen(pThreadInfo->filePath) > 0)
             && (totalLen >= 100*1024*1024 - 32000)) {
-        appendResultBufToFile(databuf, resultFile);
+        appendResultBufToFile(databuf, pThreadInfo);
         totalLen = 0;
         memset(databuf, 0, 100*1024*1024);
     }
@@ -1160,9 +1165,9 @@ static void fetchResult(TAOS_RES *res, char* resultFile) {
   }
 
   verbosePrint("%s() LN%d, databuf=%s resultFile=%s\n",
-          __func__, __LINE__, databuf, resultFile);
-  if ((resultFile) && (strlen(resultFile) > 0)) {
-    appendResultBufToFile(databuf, resultFile);
+          __func__, __LINE__, databuf, pThreadInfo->filePath);
+  if (strlen(pThreadInfo->filePath) > 0) {
+    appendResultBufToFile(databuf, pThreadInfo);
   }
   free(databuf);
 }
@@ -1179,14 +1184,14 @@ static void selectAndGetResult(
         return;
     }
 
-    fetchResult(res, pThreadInfo->fp);
+    fetchResult(res, pThreadInfo);
     taos_free_result(res);
 
   } else if (0 == strncasecmp(g_queryInfo.queryMode, "rest", strlen("rest"))) {
       int retCode = postProceSql(
               g_queryInfo.host, &(g_queryInfo.serv_addr), g_queryInfo.port,
               command,
-              pThreadInfo->fp);
+              pThreadInfo);
       if (0 != retCode) {
         printf("====restful return fail, threadID[%d]\n", pThreadInfo->threadID);
       }
@@ -1719,7 +1724,7 @@ static void printfQueryMeta() {
       printf("query interval: \033[33m%"PRIu64" ms\033[0m\n",
         g_queryInfo.specifiedQueryInfo.queryInterval);
       printf("top query times:\033[33m%"PRIu64"\033[0m\n", g_args.query_times);
-      printf("concurrent:     \033[33m%"PRIu64"\033[0m\n",
+      printf("concurrent:     \033[33m%d\033[0m\n",
       g_queryInfo.specifiedQueryInfo.concurrent);
       printf("mod:            \033[33m%s\033[0m\n",
         (g_queryInfo.specifiedQueryInfo.asyncMode)?"async":"sync");
@@ -2058,7 +2063,7 @@ static void printfQuerySystemInfo(TAOS * taos) {
 }
 
 static int postProceSql(char *host, struct sockaddr_in *pServAddr, uint16_t port,
-        char* sqlstr, char *resultFile)
+        char* sqlstr, threadInfo *pThreadInfo)
 {
     char *req_fmt = "POST %s HTTP/1.1\r\nHost: %s:%d\r\nAccept: */*\r\nAuthorization: Basic %s\r\nContent-Length: %d\r\nContent-Type: application/x-www-form-urlencoded\r\n\r\n%s";
 
@@ -2194,8 +2199,8 @@ static int postProceSql(char *host, struct sockaddr_in *pServAddr, uint16_t port
     response_buf[RESP_BUF_LEN - 1] = '\0';
     printf("Response:\n%s\n", response_buf);
 
-    if ((resultFile) && (strlen(resultFile) > 0)) {
-       appendResultBufToFile(response_buf, resultFile);
+    if (strlen(pThreadInfo->filePath) > 0) {
+       appendResultBufToFile(response_buf, pThreadInfo);
     }
 
     free(request_buf);
@@ -2958,18 +2963,18 @@ static int startMultiThreadCreateChildTable(
   b = ntables % threads;
 
   for (int64_t i = 0; i < threads; i++) {
-    threadInfo *t_info = infos + i;
-    t_info->threadID = i;
-    tstrncpy(t_info->db_name, db_name, MAX_DB_NAME_SIZE);
-    t_info->superTblInfo = superTblInfo;
+    threadInfo *pThreadInfo = infos + i;
+    pThreadInfo->threadID = i;
+    tstrncpy(pThreadInfo->db_name, db_name, MAX_DB_NAME_SIZE);
+    pThreadInfo->superTblInfo = superTblInfo;
     verbosePrint("%s() %d db_name: %s\n", __func__, __LINE__, db_name);
-    t_info->taos = taos_connect(
+    pThreadInfo->taos = taos_connect(
             g_Dbs.host,
             g_Dbs.user,
             g_Dbs.password,
             db_name,
             g_Dbs.port);
-    if (t_info->taos == NULL) {
+    if (pThreadInfo->taos == NULL) {
       errorPrint( "%s() LN%d, Failed to connect to TDengine, reason:%s\n",
          __func__, __LINE__, taos_errstr(NULL));
       free(pids);
@@ -2977,14 +2982,14 @@ static int startMultiThreadCreateChildTable(
       return -1;
     }
 
-    t_info->start_table_from = startFrom;
-    t_info->ntables = i<b?a+1:a;
-    t_info->end_table_to = i < b ? startFrom + a : startFrom + a - 1;
-    startFrom = t_info->end_table_to + 1;
-    t_info->use_metric = true;
-    t_info->cols = cols;
-    t_info->minDelay = UINT64_MAX;
-    pthread_create(pids + i, NULL, createTable, t_info);
+    pThreadInfo->start_table_from = startFrom;
+    pThreadInfo->ntables = i<b?a+1:a;
+    pThreadInfo->end_table_to = i < b ? startFrom + a : startFrom + a - 1;
+    startFrom = pThreadInfo->end_table_to + 1;
+    pThreadInfo->use_metric = true;
+    pThreadInfo->cols = cols;
+    pThreadInfo->minDelay = UINT64_MAX;
+    pthread_create(pids + i, NULL, createTable, pThreadInfo);
   }
 
   for (int i = 0; i < threads; i++) {
@@ -2992,8 +2997,8 @@ static int startMultiThreadCreateChildTable(
   }
 
   for (int i = 0; i < threads; i++) {
-    threadInfo *t_info = infos + i;
-    taos_close(t_info->taos);
+    threadInfo *pThreadInfo = infos + i;
+    taos_close(pThreadInfo->taos);
   }
 
   free(pids);
@@ -4198,7 +4203,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
     if (concurrent && concurrent->type == cJSON_Number) {
       if (concurrent->valueint <= 0) {
         errorPrint(
-                "%s() LN%d, query sqlCount %"PRIu64" or concurrent %"PRIu64" is not correct.\n",
+                "%s() LN%d, query sqlCount %"PRIu64" or concurrent %d is not correct.\n",
               __func__, __LINE__,
               g_queryInfo.specifiedQueryInfo.sqlCount,
               g_queryInfo.specifiedQueryInfo.concurrent);
@@ -4265,24 +4270,28 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
     }
 
     // sqls
-    cJSON* superSqls = cJSON_GetObjectItem(specifiedQuery, "sqls");
-    if (!superSqls) {
+    cJSON* specifiedSqls = cJSON_GetObjectItem(specifiedQuery, "sqls");
+    if (!specifiedSqls) {
       g_queryInfo.specifiedQueryInfo.sqlCount = 0;
-    } else if (superSqls->type != cJSON_Array) {
+    } else if (specifiedSqls->type != cJSON_Array) {
       errorPrint("%s() LN%d, failed to read json, super sqls not found\n",
           __func__, __LINE__);
       goto PARSE_OVER;
     } else {
-      int superSqlSize = cJSON_GetArraySize(superSqls);
-      if (superSqlSize > MAX_QUERY_SQL_COUNT) {
-        errorPrint("%s() LN%d, failed to read json, query sql size overflow, max is %d\n",
-           __func__, __LINE__, MAX_QUERY_SQL_COUNT);
+      int superSqlSize = cJSON_GetArraySize(specifiedSqls);
+      if (superSqlSize * g_queryInfo.specifiedQueryInfo.concurrent
+              > MAX_QUERY_SQL_COUNT) {
+        errorPrint("%s() LN%d, failed to read json, query sql(%d) * concurrent(%d) overflow, max is %d\n",
+           __func__, __LINE__,
+           superSqlSize,
+           g_queryInfo.specifiedQueryInfo.concurrent,
+           MAX_QUERY_SQL_COUNT);
         goto PARSE_OVER;
       }
 
       g_queryInfo.specifiedQueryInfo.sqlCount = superSqlSize;
       for (int j = 0; j < superSqlSize; ++j) {
-        cJSON* sql = cJSON_GetArrayItem(superSqls, j);
+        cJSON* sql = cJSON_GetArrayItem(specifiedSqls, j);
         if (sql == NULL) continue;
 
         cJSON *sqlStr = cJSON_GetObjectItem(sql, "sql");
@@ -4458,16 +4467,16 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
         g_queryInfo.superQueryInfo.resubAfterConsume = 1;
     }
 
-    // sqls
-    cJSON* subsqls = cJSON_GetObjectItem(superQuery, "sqls");
-    if (!subsqls) {
+    // supert table sqls
+    cJSON* superSqls = cJSON_GetObjectItem(superQuery, "sqls");
+    if (!superSqls) {
       g_queryInfo.superQueryInfo.sqlCount = 0;
-    } else if (subsqls->type != cJSON_Array) {
+    } else if (superSqls->type != cJSON_Array) {
       errorPrint("%s() LN%d: failed to read json, super sqls not found\n",
           __func__, __LINE__);
       goto PARSE_OVER;
     } else {
-      int superSqlSize = cJSON_GetArraySize(subsqls);
+      int superSqlSize = cJSON_GetArraySize(superSqls);
       if (superSqlSize > MAX_QUERY_SQL_COUNT) {
         errorPrint("%s() LN%d, failed to read json, query sql size overflow, max is %d\n",
            __func__, __LINE__, MAX_QUERY_SQL_COUNT);
@@ -4476,7 +4485,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
 
       g_queryInfo.superQueryInfo.sqlCount = superSqlSize;
       for (int j = 0; j < superSqlSize; ++j) {
-        cJSON* sql = cJSON_GetArrayItem(subsqls, j);
+        cJSON* sql = cJSON_GetArrayItem(superSqls, j);
         if (sql == NULL) continue;
 
         cJSON *sqlStr = cJSON_GetObjectItem(sql, "sql");
@@ -5822,49 +5831,49 @@ static void startMultiThreadInsertData(int threads, char* db_name,
   }
 
   for (int i = 0; i < threads; i++) {
-    threadInfo *t_info = infos + i;
-    t_info->threadID = i;
-    tstrncpy(t_info->db_name, db_name, MAX_DB_NAME_SIZE);
-    t_info->time_precision = timePrec;
-    t_info->superTblInfo = superTblInfo;
+    threadInfo *pThreadInfo = infos + i;
+    pThreadInfo->threadID = i;
+    tstrncpy(pThreadInfo->db_name, db_name, MAX_DB_NAME_SIZE);
+    pThreadInfo->time_precision = timePrec;
+    pThreadInfo->superTblInfo = superTblInfo;
 
-    t_info->start_time = start_time;
-    t_info->minDelay = UINT64_MAX;
+    pThreadInfo->start_time = start_time;
+    pThreadInfo->minDelay = UINT64_MAX;
 
     if ((NULL == superTblInfo) ||
             (0 == strncasecmp(superTblInfo->insertMode, "taosc", 5))) {
-      //t_info->taos = taos;
-      t_info->taos = taos_connect(
+      //pThreadInfo->taos = taos;
+      pThreadInfo->taos = taos_connect(
               g_Dbs.host, g_Dbs.user,
               g_Dbs.password, db_name, g_Dbs.port);
-      if (NULL == t_info->taos) {
+      if (NULL == pThreadInfo->taos) {
         errorPrint(
                 "connect to server fail from insert sub thread, reason: %s\n",
                 taos_errstr(NULL));
         exit(-1);
       }
     } else {
-      t_info->taos = NULL;
+      pThreadInfo->taos = NULL;
     }
 
 /*    if ((NULL == superTblInfo)
             || (0 == superTblInfo->multiThreadWriteOneTbl)) {
             */
-      t_info->start_table_from = startFrom;
-      t_info->ntables = i<b?a+1:a;
-      t_info->end_table_to = i < b ? startFrom + a : startFrom + a - 1;
-      startFrom = t_info->end_table_to + 1;
+      pThreadInfo->start_table_from = startFrom;
+      pThreadInfo->ntables = i<b?a+1:a;
+      pThreadInfo->end_table_to = i < b ? startFrom + a : startFrom + a - 1;
+      startFrom = pThreadInfo->end_table_to + 1;
 /*    } else {
-      t_info->start_table_from = 0;
-      t_info->ntables = superTblInfo->childTblCount;
-      t_info->start_time = t_info->start_time + rand_int() % 10000 - rand_tinyint();
+      pThreadInfo->start_table_from = 0;
+      pThreadInfo->ntables = superTblInfo->childTblCount;
+      pThreadInfo->start_time = pThreadInfo->start_time + rand_int() % 10000 - rand_tinyint();
     }
 */
-    tsem_init(&(t_info->lock_sem), 0, 0);
+    tsem_init(&(pThreadInfo->lock_sem), 0, 0);
     if (ASYNC_MODE == g_Dbs.asyncMode) {
-      pthread_create(pids + i, NULL, asyncWrite, t_info);
+      pthread_create(pids + i, NULL, asyncWrite, pThreadInfo);
     } else {
-      pthread_create(pids + i, NULL, syncWrite, t_info);
+      pthread_create(pids + i, NULL, syncWrite, pThreadInfo);
     }
   }
 
@@ -5879,27 +5888,27 @@ static void startMultiThreadInsertData(int threads, char* db_name,
   double  avgDelay = 0;
 
   for (int i = 0; i < threads; i++) {
-    threadInfo *t_info = infos + i;
+    threadInfo *pThreadInfo = infos + i;
 
-    tsem_destroy(&(t_info->lock_sem));
-    taos_close(t_info->taos);
+    tsem_destroy(&(pThreadInfo->lock_sem));
+    taos_close(pThreadInfo->taos);
 
     debugPrint("%s() LN%d, [%d] totalInsert=%"PRIu64" totalAffected=%"PRIu64"\n",
             __func__, __LINE__,
-            t_info->threadID, t_info->totalInsertRows,
-            t_info->totalAffectedRows);
+            pThreadInfo->threadID, pThreadInfo->totalInsertRows,
+            pThreadInfo->totalAffectedRows);
     if (superTblInfo) {
-        superTblInfo->totalAffectedRows += t_info->totalAffectedRows;
-        superTblInfo->totalInsertRows += t_info->totalInsertRows;
+        superTblInfo->totalAffectedRows += pThreadInfo->totalAffectedRows;
+        superTblInfo->totalInsertRows += pThreadInfo->totalInsertRows;
     } else {
-        g_args.totalAffectedRows += t_info->totalAffectedRows;
-        g_args.totalInsertRows += t_info->totalInsertRows;
+        g_args.totalAffectedRows += pThreadInfo->totalAffectedRows;
+        g_args.totalInsertRows += pThreadInfo->totalInsertRows;
     }
 
-    totalDelay  += t_info->totalDelay;
-    cntDelay   += t_info->cntDelay;
-    if (t_info->maxDelay > maxDelay) maxDelay = t_info->maxDelay;
-    if (t_info->minDelay < minDelay) minDelay = t_info->minDelay;
+    totalDelay  += pThreadInfo->totalDelay;
+    cntDelay   += pThreadInfo->cntDelay;
+    if (pThreadInfo->maxDelay > maxDelay) maxDelay = pThreadInfo->maxDelay;
+    if (pThreadInfo->minDelay < minDelay) minDelay = pThreadInfo->minDelay;
   }
   cntDelay -= 1;
 
@@ -5955,26 +5964,26 @@ static void startMultiThreadInsertData(int threads, char* db_name,
 
 static void *readTable(void *sarg) {
 #if 1
-  threadInfo *rinfo = (threadInfo *)sarg;
-  TAOS *taos = rinfo->taos;
+  threadInfo *pThreadInfo = (threadInfo *)sarg;
+  TAOS *taos = pThreadInfo->taos;
   char command[BUFFER_SIZE] = "\0";
-  uint64_t sTime = rinfo->start_time;
-  char *tb_prefix = rinfo->tb_prefix;
-  FILE *fp = fopen(rinfo->fp, "a");
+  uint64_t sTime = pThreadInfo->start_time;
+  char *tb_prefix = pThreadInfo->tb_prefix;
+  FILE *fp = fopen(pThreadInfo->filePath, "a");
   if (NULL == fp) {
-    errorPrint( "fopen %s fail, reason:%s.\n", rinfo->fp, strerror(errno));
+    errorPrint( "fopen %s fail, reason:%s.\n", pThreadInfo->filePath, strerror(errno));
     return NULL;
   }
 
   int64_t num_of_DPT;
-/*  if (rinfo->superTblInfo) {
-    num_of_DPT = rinfo->superTblInfo->insertRows; //  nrecords_per_table;
+/*  if (pThreadInfo->superTblInfo) {
+    num_of_DPT = pThreadInfo->superTblInfo->insertRows; //  nrecords_per_table;
   } else {
   */
       num_of_DPT = g_args.num_of_DPT;
 //  }
 
-  int64_t num_of_tables = rinfo->ntables; // rinfo->end_table_to - rinfo->start_table_from + 1;
+  int64_t num_of_tables = pThreadInfo->ntables; // rinfo->end_table_to - rinfo->start_table_from + 1;
   int64_t totalData = num_of_DPT * num_of_tables;
   bool do_aggreFunc = g_Dbs.do_aggreFunc;
 
@@ -6027,17 +6036,17 @@ static void *readTable(void *sarg) {
 
 static void *readMetric(void *sarg) {
 #if 1
-  threadInfo *rinfo = (threadInfo *)sarg;
-  TAOS *taos = rinfo->taos;
+  threadInfo *pThreadInfo = (threadInfo *)sarg;
+  TAOS *taos = pThreadInfo->taos;
   char command[BUFFER_SIZE] = "\0";
-  FILE *fp = fopen(rinfo->fp, "a");
+  FILE *fp = fopen(pThreadInfo->filePath, "a");
   if (NULL == fp) {
-    printf("fopen %s fail, reason:%s.\n", rinfo->fp, strerror(errno));
+    printf("fopen %s fail, reason:%s.\n", pThreadInfo->filePath, strerror(errno));
     return NULL;
   }
 
-  int64_t num_of_DPT = rinfo->superTblInfo->insertRows;
-  int64_t num_of_tables = rinfo->ntables; // rinfo->end_table_to - rinfo->start_table_from + 1;
+  int64_t num_of_DPT = pThreadInfo->superTblInfo->insertRows;
+  int64_t num_of_tables = pThreadInfo->ntables; // rinfo->end_table_to - rinfo->start_table_from + 1;
   int64_t totalData = num_of_DPT * num_of_tables;
   bool do_aggreFunc = g_Dbs.do_aggreFunc;
 
@@ -6236,8 +6245,8 @@ static void *specifiedTableQuery(void *sarg) {
   uint64_t lastPrintTime = taosGetTimestampMs();
   uint64_t startTs = taosGetTimestampMs();
 
-  if (g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq][0] != 0) {
-        sprintf(pThreadInfo->fp, "%s-%d",
+  if (g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq] != NULL) {
+    sprintf(pThreadInfo->filePath, "%s-%d",
                 g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq],
                 pThreadInfo->threadID);
   }
@@ -6337,8 +6346,8 @@ static void *superTableQuery(void *sarg) {
       for (int j = 0; j < g_queryInfo.superQueryInfo.sqlCount; j++) {
         memset(sqlstr,0,sizeof(sqlstr));
         replaceChildTblName(g_queryInfo.superQueryInfo.sql[j], sqlstr, i);
-        if (g_queryInfo.superQueryInfo.result[j][0] != 0) {
-          sprintf(pThreadInfo->fp, "%s-%d",
+        if (g_queryInfo.superQueryInfo.result[j] != NULL) {
+          sprintf(pThreadInfo->filePath, "%s-%d",
                   g_queryInfo.superQueryInfo.result[j],
                   pThreadInfo->threadID);
         }
@@ -6428,9 +6437,9 @@ static int queryTestProcess() {
     for (uint64_t i = 0; i < nSqlCount; i++) {
         for (int j = 0; j < nConcurrent; j++) {
             uint64_t seq = i * nConcurrent + j;
-            threadInfo *t_info = infos + seq;
-            t_info->threadID = seq;
-            t_info->querySeq = i;
+            threadInfo *pThreadInfo = infos + seq;
+            pThreadInfo->threadID = seq;
+            pThreadInfo->querySeq = i;
 
             if (0 == strncasecmp(g_queryInfo.queryMode, "taosc", 5)) {
 
@@ -6447,10 +6456,10 @@ static int queryTestProcess() {
                 }
             }
 
-            t_info->taos = NULL;// TODO: workaround to use separate taos connection;
+            pThreadInfo->taos = NULL;// TODO: workaround to use separate taos connection;
 
             pthread_create(pids + seq, NULL, specifiedTableQuery,
-                t_info);
+                pThreadInfo);
         }
     }
   } else {
@@ -6490,15 +6499,15 @@ static int queryTestProcess() {
 
     uint64_t startFrom = 0;
     for (int i = 0; i < threads; i++) {
-      threadInfo *t_info = infosOfSub + i;
-      t_info->threadID = i;
+      threadInfo *pThreadInfo = infosOfSub + i;
+      pThreadInfo->threadID = i;
 
-      t_info->start_table_from = startFrom;
-      t_info->ntables = i<b?a+1:a;
-      t_info->end_table_to = i < b ? startFrom + a : startFrom + a - 1;
-      startFrom = t_info->end_table_to + 1;
-      t_info->taos = NULL; // TODO: workaround to use separate taos connection;
-      pthread_create(pidsOfSub + i, NULL, superTableQuery, t_info);
+      pThreadInfo->start_table_from = startFrom;
+      pThreadInfo->ntables = i<b?a+1:a;
+      pThreadInfo->end_table_to = i < b ? startFrom + a : startFrom + a - 1;
+      startFrom = pThreadInfo->end_table_to + 1;
+      pThreadInfo->taos = NULL; // TODO: workaround to use separate taos connection;
+      pthread_create(pidsOfSub + i, NULL, superTableQuery, pThreadInfo);
     }
 
     g_queryInfo.superQueryInfo.threadCnt = threads;
@@ -6545,7 +6554,7 @@ static void stable_sub_callback(
   }
 
   if (param)
-    fetchResult(res, ((threadInfo *)param)->fp);
+    fetchResult(res, (threadInfo *)param);
   // tao_unscribe() will free result.
 }
 
@@ -6558,7 +6567,7 @@ static void specified_sub_callback(
   }
 
   if (param)
-    fetchResult(res, ((threadInfo *)param)->fp);
+    fetchResult(res, (threadInfo *)param);
   // tao_unscribe() will free result.
 }
 
@@ -6612,18 +6621,15 @@ static void *superSubscribe(void *sarg) {
   }
 
   if (pThreadInfo->taos == NULL) {
-    TAOS * taos = NULL;
-    taos = taos_connect(g_queryInfo.host,
+    pThreadInfo->taos = taos_connect(g_queryInfo.host,
           g_queryInfo.user,
           g_queryInfo.password,
           g_queryInfo.dbName,
           g_queryInfo.port);
-    if (taos == NULL) {
+    if (pThreadInfo->taos == NULL) {
       errorPrint("[%d] Failed to connect to TDengine, reason:%s\n",
             pThreadInfo->threadID, taos_errstr(NULL));
       return NULL;
-    } else {
-      pThreadInfo->taos = taos;
     }
   }
 
@@ -6653,7 +6659,7 @@ static void *superSubscribe(void *sarg) {
               g_queryInfo.superQueryInfo.sql[pThreadInfo->querySeq],
               subSqlstr, i);
       if (g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq][0] != 0) {
-        sprintf(pThreadInfo->fp, "%s-%d",
+        sprintf(pThreadInfo->filePath, "%s-%d",
                 g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq],
                 pThreadInfo->threadID);
       }
@@ -6696,16 +6702,16 @@ static void *superSubscribe(void *sarg) {
 
       if (res) {
           if (g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq][0] != 0) {
-              sprintf(pThreadInfo->fp, "%s-%d",
+              sprintf(pThreadInfo->filePath, "%s-%d",
                       g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq],
                       pThreadInfo->threadID);
-              fetchResult(res, pThreadInfo->fp);
+              fetchResult(res, pThreadInfo);
           }
           if (g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq][0] != 0) {
-              sprintf(pThreadInfo->fp, "%s-%d",
+              sprintf(pThreadInfo->filePath, "%s-%d",
                       g_queryInfo.superQueryInfo.result[pThreadInfo->querySeq],
                       pThreadInfo->threadID);
-              fetchResult(res, pThreadInfo->fp);
+              fetchResult(res, pThreadInfo);
           }
           consumed[tsubSeq] ++;
 
@@ -6746,21 +6752,18 @@ static void *superSubscribe(void *sarg) {
 
 static void *specifiedSubscribe(void *sarg) {
   threadInfo *pThreadInfo = (threadInfo *)sarg;
-  TAOS_SUB*  tsub = NULL;
+//  TAOS_SUB*  tsub = NULL;
 
   if (pThreadInfo->taos == NULL) {
-    TAOS * taos = NULL;
-    taos = taos_connect(g_queryInfo.host,
+    pThreadInfo->taos = taos_connect(g_queryInfo.host,
           g_queryInfo.user,
           g_queryInfo.password,
           g_queryInfo.dbName,
           g_queryInfo.port);
-    if (taos == NULL) {
+    if (pThreadInfo->taos == NULL) {
       errorPrint("[%d] Failed to connect to TDengine, reason:%s\n",
             pThreadInfo->threadID, taos_errstr(NULL));
       return NULL;
-    } else {
-      pThreadInfo->taos = taos;
     }
   }
 
@@ -6772,69 +6775,70 @@ static void *specifiedSubscribe(void *sarg) {
     return NULL;
   }
 
-  char topic[32] = {0};
-  sprintf(topic, "taosdemo-subscribe-%"PRIu64"", pThreadInfo->querySeq);
-  if (g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq][0] != 0) {
-      sprintf(pThreadInfo->fp, "%s-%d",
+  sprintf(g_queryInfo.specifiedQueryInfo.topic[pThreadInfo->threadID],
+          "taosdemo-subscribe-%"PRIu64"-%d",
+          pThreadInfo->querySeq,
+          pThreadInfo->threadID);
+  if (g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq] != NULL) {
+      sprintf(pThreadInfo->filePath, "%s-%d",
                 g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq],
                 pThreadInfo->threadID);
   }
-  tsub = subscribeImpl(
-                      SPECIFIED_CLASS, pThreadInfo,
+  g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->threadID] = subscribeImpl(
+          SPECIFIED_CLASS, pThreadInfo,
           g_queryInfo.specifiedQueryInfo.sql[pThreadInfo->querySeq],
-          topic,
+          g_queryInfo.specifiedQueryInfo.topic[pThreadInfo->threadID],
           g_queryInfo.specifiedQueryInfo.subscribeRestart,
           g_queryInfo.specifiedQueryInfo.subscribeInterval);
-  if (NULL == tsub) {
+  if (NULL == g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->threadID]) {
       taos_close(pThreadInfo->taos);
       return NULL;
   }
 
   // start loop to consume result
-  TAOS_RES* res = NULL;
-
-  int consumed;
 
+  g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID] = 0;
   while(1) {
       if (ASYNC_MODE == g_queryInfo.specifiedQueryInfo.asyncMode) {
         continue;
       }
 
-      res = taos_consume(tsub);
-      if (res) {
+      g_queryInfo.specifiedQueryInfo.res[pThreadInfo->threadID] = taos_consume(
+              g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->threadID]);
+      if (g_queryInfo.specifiedQueryInfo.res[pThreadInfo->threadID]) {
           if (g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq][0] != 0) {
-              sprintf(pThreadInfo->fp, "%s-%d",
+              sprintf(pThreadInfo->filePath, "%s-%d",
                       g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq],
                       pThreadInfo->threadID);
-              fetchResult(res, pThreadInfo->fp);
+              fetchResult(g_queryInfo.specifiedQueryInfo.res[pThreadInfo->threadID], pThreadInfo);
           }
 
-          consumed ++;
+          g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID] ++;
           if ((g_queryInfo.specifiedQueryInfo.subscribeKeepProgress)
-                && (consumed >=
+                && (g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID] >=
                     g_queryInfo.specifiedQueryInfo.resubAfterConsume[pThreadInfo->querySeq])) {
               printf("keepProgress:%d, resub specified query: %"PRIu64"\n",
                     g_queryInfo.specifiedQueryInfo.subscribeKeepProgress,
                     pThreadInfo->querySeq);
-              consumed = 0;
-              taos_unsubscribe(tsub,
+              g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID] = 0;
+              taos_unsubscribe(g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->threadID],
                       g_queryInfo.specifiedQueryInfo.subscribeKeepProgress);
-              tsub = subscribeImpl(
+              g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->threadID] = subscribeImpl(
                       SPECIFIED_CLASS,
                       pThreadInfo,
                       g_queryInfo.specifiedQueryInfo.sql[pThreadInfo->querySeq],
-                      topic,
+                      g_queryInfo.specifiedQueryInfo.topic[pThreadInfo->threadID],
                       g_queryInfo.specifiedQueryInfo.subscribeRestart,
                       g_queryInfo.specifiedQueryInfo.subscribeInterval);
-              if (NULL == tsub) {
+              if (NULL == g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->threadID]) {
                 taos_close(pThreadInfo->taos);
                 return NULL;
               }
           }
       }
   }
-  taos_free_result(res);
-  taos_unsubscribe(tsub, 0);
+  taos_free_result(g_queryInfo.specifiedQueryInfo.res[pThreadInfo->threadID]);
+  taos_unsubscribe(g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->querySeq], 0);
   taos_close(pThreadInfo->taos);
 
   return NULL;
@@ -6904,11 +6908,11 @@ static int subscribeTestProcess() {
     for (int i = 0; i < g_queryInfo.specifiedQueryInfo.sqlCount; i++) {
         for (int j = 0; j < g_queryInfo.specifiedQueryInfo.concurrent; j++) {
             uint64_t seq = i * g_queryInfo.specifiedQueryInfo.concurrent + j;
-            threadInfo *t_info = infos + seq;
-            t_info->threadID = seq;
-            t_info->querySeq = i;
-            t_info->taos = NULL;  // TODO: workaround to use separate taos connection;
-            pthread_create(pids + seq, NULL, specifiedSubscribe, t_info);
+            threadInfo *pThreadInfo = infos + seq;
+            pThreadInfo->threadID = seq;
+            pThreadInfo->querySeq = i;
+            pThreadInfo->taos = NULL;  // TODO: workaround to use separate taos connection;
+            pthread_create(pids + seq, NULL, specifiedSubscribe, pThreadInfo);
         }
     }
   }
@@ -6954,17 +6958,17 @@ static int subscribeTestProcess() {
             uint64_t startFrom = 0;
             for (int j = 0; j < threads; j++) {
                 uint64_t seq = i * threads + j;
-                threadInfo *t_info = infosOfStable + seq;
-                t_info->threadID = seq;
-                t_info->querySeq = i;
+                threadInfo *pThreadInfo = infosOfStable + seq;
+                pThreadInfo->threadID = seq;
+                pThreadInfo->querySeq = i;
 
-                t_info->start_table_from = startFrom;
-                t_info->ntables = j<b?a+1:a;
-                t_info->end_table_to = j<b?startFrom+a:startFrom+a-1;
-                startFrom = t_info->end_table_to + 1;
-                t_info->taos = NULL; // TODO: workaround to use separate taos connection;
+                pThreadInfo->start_table_from = startFrom;
+                pThreadInfo->ntables = j<b?a+1:a;
+                pThreadInfo->end_table_to = j<b?startFrom+a:startFrom+a-1;
+                startFrom = pThreadInfo->end_table_to + 1;
+                pThreadInfo->taos = NULL; // TODO: workaround to use separate taos connection;
                 pthread_create(pidsOfStable + seq,
-                        NULL, superSubscribe, t_info);
+                        NULL, superSubscribe, pThreadInfo);
             }
         }
 
@@ -7243,47 +7247,47 @@ static void queryResult() {
   // query data
 
   pthread_t read_id;
-  threadInfo *rInfo = malloc(sizeof(threadInfo));
-  assert(rInfo);
-  rInfo->start_time = 1500000000000;  // 2017-07-14 10:40:00.000
-  rInfo->start_table_from = 0;
+  threadInfo *pThreadInfo = malloc(sizeof(threadInfo));
+  assert(pThreadInfo);
+  pThreadInfo->start_time = 1500000000000;  // 2017-07-14 10:40:00.000
+  pThreadInfo->start_table_from = 0;
 
-  //rInfo->do_aggreFunc = g_Dbs.do_aggreFunc;
+  //pThreadInfo->do_aggreFunc = g_Dbs.do_aggreFunc;
   if (g_args.use_metric) {
-    rInfo->ntables = g_Dbs.db[0].superTbls[0].childTblCount;
-    rInfo->end_table_to = g_Dbs.db[0].superTbls[0].childTblCount - 1;
-    rInfo->superTblInfo = &g_Dbs.db[0].superTbls[0];
-    tstrncpy(rInfo->tb_prefix,
+    pThreadInfo->ntables = g_Dbs.db[0].superTbls[0].childTblCount;
+    pThreadInfo->end_table_to = g_Dbs.db[0].superTbls[0].childTblCount - 1;
+    pThreadInfo->superTblInfo = &g_Dbs.db[0].superTbls[0];
+    tstrncpy(pThreadInfo->tb_prefix,
           g_Dbs.db[0].superTbls[0].childTblPrefix, MAX_TB_NAME_SIZE);
   } else {
-    rInfo->ntables = g_args.num_of_tables;
-    rInfo->end_table_to = g_args.num_of_tables -1;
-    tstrncpy(rInfo->tb_prefix, g_args.tb_prefix, MAX_TB_NAME_SIZE);
+    pThreadInfo->ntables = g_args.num_of_tables;
+    pThreadInfo->end_table_to = g_args.num_of_tables -1;
+    tstrncpy(pThreadInfo->tb_prefix, g_args.tb_prefix, MAX_TB_NAME_SIZE);
   }
 
-  rInfo->taos = taos_connect(
+  pThreadInfo->taos = taos_connect(
           g_Dbs.host,
           g_Dbs.user,
           g_Dbs.password,
           g_Dbs.db[0].dbName,
           g_Dbs.port);
-  if (rInfo->taos == NULL) {
+  if (pThreadInfo->taos == NULL) {
     errorPrint( "Failed to connect to TDengine, reason:%s\n",
             taos_errstr(NULL));
-    free(rInfo);
+    free(pThreadInfo);
     exit(-1);
   }
 
-  tstrncpy(rInfo->fp, g_Dbs.resultFile, MAX_FILE_NAME_LEN);
+  tstrncpy(pThreadInfo->filePath, g_Dbs.resultFile, MAX_FILE_NAME_LEN);
 
   if (!g_Dbs.use_metric) {
-    pthread_create(&read_id, NULL, readTable, rInfo);
+    pthread_create(&read_id, NULL, readTable, pThreadInfo);
   } else {
-    pthread_create(&read_id, NULL, readMetric, rInfo);
+    pthread_create(&read_id, NULL, readMetric, pThreadInfo);
   }
   pthread_join(read_id, NULL);
-  taos_close(rInfo->taos);
-  free(rInfo);
+  taos_close(pThreadInfo->taos);
+  free(pThreadInfo);
 }
 
 static void testCmdLine() {

From f414d8a9c40749dbeb20b6ca5fe44d93aa177288 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 25 May 2021 10:15:38 +0800
Subject: [PATCH 083/128] [td-4151]

---
 src/client/inc/tsclient.h       |  30 ++-------
 src/client/src/tscAsync.c       | 109 ++++++++++++++------------------
 src/client/src/tscParseInsert.c |  49 +++++++-------
 src/client/src/tscPrepare.c     |  27 ++++----
 src/client/src/tscSQLParser.c   |   2 -
 src/client/src/tscServer.c      |  92 +++++++++++++--------------
 src/client/src/tscSubquery.c    |  14 ++--
 src/client/src/tscUtil.c        |  73 ++++++++++-----------
 src/inc/taosdef.h               |   1 +
 9 files changed, 174 insertions(+), 223 deletions(-)

diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index af8d0a3b80..b5fb90e1e0 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -42,12 +42,6 @@ extern "C" {
 struct SSqlInfo;
 struct SLocalMerger;
 
-// data source from sql string or from file
-enum {
-  DATA_FROM_SQL_STRING = 1,
-  DATA_FROM_DATA_FILE  = 2,
-};
-
 typedef void (*__async_cb_func_t)(void *param, TAOS_RES *tres, int32_t numOfRows);
 
 typedef struct STableComInfo {
@@ -253,16 +247,15 @@ typedef struct {
 
 typedef struct SInsertStatementParam {
   SName      **pTableNameList;          // all involved tableMeta list of current insert sql statement.
-  int32_t      numOfTables;
+  int32_t      numOfTables;             // number of tables in table name list
   SHashObj    *pTableBlockHashList;     // data block for each table
   SArray      *pDataBlocks;             // SArray<STableDataBlocks*>. Merged submit block for each vgroup
   int8_t       schemaAttached;          // denote if submit block is built with table schema or not
   STagData     tagData;                 // NOTE: pTagData->data is used as a variant length array
-  int32_t      dataSourceType;          // from file or from sql statement
 
   char         msg[512];                // error message
   char        *sql;                     // current sql statement position
-  uint32_t     insertType;              // TODO remove it
+  uint32_t     insertType;              // insert data from [file|sql statement| bound statement]
 } SInsertStatementParam;
 
 // TODO extract sql parser supporter
@@ -271,14 +264,11 @@ typedef struct {
   uint8_t msgType;
   SInsertStatementParam insertParam;
   char    reserve1[3];        // fix bus error on arm32
-  bool    autoCreated;        // create table if it is not existed during retrieve table meta in mnode
-
   union {
     int32_t count;
   };
 
   char *       curSql;       // current sql, resume position of sql after parsing paused
-  int8_t       parseFinished;
   char         reserve2[3];        // fix bus error on arm32
 
   int16_t      numOfCols;
@@ -289,22 +279,10 @@ typedef struct {
 
   SHashObj    *pTableMetaMap;  // local buffer to keep the queried table meta, before validating the AST
   SQueryInfo  *pQueryInfo;
-  SQueryInfo  *active;       // current active query info
-
-  int32_t      batchSize;    // for parameter ('?') binding and batch processing
+  SQueryInfo  *active;         // current active query info
+  int32_t      batchSize;      // for parameter ('?') binding and batch processing
   int32_t      numOfParams;
-
-  int8_t       dataSourceType; // load data from file or not
-  char         reserve4[3];    // fix bus error on arm32
-//  int8_t       submitSchema;   // submit block is built with table schema
-  char         reserve5[3];    // fix bus error on arm32
   STagData     tagData;        // NOTE: pTagData->data is used as a variant length array
-
-//  SName      **pTableNameList; // all involved tableMeta list of current insert sql statement.
-//  int32_t      numOfTables;
-
-//  SHashObj    *pTableBlockHashList;     // data block for each table
-//  SArray      *pDataBlocks;             // SArray<STableDataBlocks*>. Merged submit block for each vgroup
   int32_t      resColumnId;
 } SSqlCmd;
 
diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c
index b968bfc613..68e41310c6 100644
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -336,21 +336,33 @@ static int32_t updateMetaBeforeRetryQuery(SSqlObj* pSql, STableMetaInfo* pTableM
     int32_t numOfTags = tscGetNumOfTags(pTableMetaInfo->pTableMeta);
 
     SSchema *pSchema = tscGetTableSchema(pTableMetaInfo->pTableMeta);
+    SSchema *pTagSchema = tscGetTableTagSchema(pTableMetaInfo->pTableMeta);
+
     for (int32_t i = 0; i < numOfExprs; ++i) {
       SSqlExpr *pExpr = &(tscExprGet(pQueryInfo, i)->base);
+
+      // update the table uid
       pExpr->uid = pTableMetaInfo->pTableMeta->id.uid;
 
       if (pExpr->colInfo.colIndex >= 0) {
         int32_t index = pExpr->colInfo.colIndex;
 
         if ((TSDB_COL_IS_NORMAL_COL(pExpr->colInfo.flag) && index >= numOfCols) ||
-            (TSDB_COL_IS_TAG(pExpr->colInfo.flag) && (index < numOfCols || index >= (numOfCols + numOfTags)))) {
+            (TSDB_COL_IS_TAG(pExpr->colInfo.flag) && (index < 0 || index >= numOfTags))) {
           return pSql->retryReason;
         }
 
-        if ((pSchema[pExpr->colInfo.colIndex].colId != pExpr->colInfo.colId) &&
-            strcasecmp(pExpr->colInfo.name, pSchema[pExpr->colInfo.colIndex].name) != 0) {
-          return pSql->retryReason;
+        if (TSDB_COL_IS_TAG(pExpr->colInfo.flag)) {
+          if ((pTagSchema[pExpr->colInfo.colIndex].colId != pExpr->colInfo.colId) &&
+              strcasecmp(pExpr->colInfo.name, pTagSchema[pExpr->colInfo.colIndex].name) != 0) {
+            return pSql->retryReason;
+          }
+        } else if (TSDB_COL_IS_NORMAL_COL(pExpr->colInfo.flag)) {
+          if ((pSchema[pExpr->colInfo.colIndex].colId != pExpr->colInfo.colId) &&
+              strcasecmp(pExpr->colInfo.name, pSchema[pExpr->colInfo.colIndex].name) != 0) {
+            return pSql->retryReason;
+          }
+        } else { // do nothing for udc
         }
       }
     }
@@ -388,12 +400,12 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
 
   tscDebug("0x%"PRIx64" get %s successfully", pSql->self, msg);
   if (pSql->pStream == NULL) {
-    SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
+    SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
 
     // check if it is a sub-query of super table query first, if true, enter another routine
-    if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, (TSDB_QUERY_TYPE_STABLE_SUBQUERY|TSDB_QUERY_TYPE_SUBQUERY|TSDB_QUERY_TYPE_TAG_FILTER_QUERY))) {
-      tscDebug("0x%"PRIx64" update local table meta, continue to process sql and send the corresponding query", pSql->self);
-
+    if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, (TSDB_QUERY_TYPE_STABLE_SUBQUERY | TSDB_QUERY_TYPE_SUBQUERY |
+                                               TSDB_QUERY_TYPE_TAG_FILTER_QUERY))) {
+      tscDebug("0x%" PRIx64 " update cached table-meta, continue to process sql and send the corresponding query", pSql->self);
       STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
       code = tscGetTableMeta(pSql, pTableMetaInfo);
@@ -415,42 +427,8 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
       taosReleaseRef(tscObjRef, pSql->self);
       return;
     } else {  // continue to process normal async query
-      if (pCmd->parseFinished) {
-        tscDebug("0x%"PRIx64" update local table meta, continue to process sql and send corresponding query", pSql->self);
-
-        STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
-        code = tscGetTableMeta(pSql, pTableMetaInfo);
-
-        assert(code == TSDB_CODE_TSC_ACTION_IN_PROGRESS || code == TSDB_CODE_SUCCESS);
-        if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
-          taosReleaseRef(tscObjRef, pSql->self);
-          return;
-        }
-
-        assert(pCmd->command != TSDB_SQL_INSERT);
-
-        if (pCmd->command == TSDB_SQL_SELECT) {
-          tscDebug("0x%"PRIx64" redo parse sql string and proceed", pSql->self);
-          pCmd->parseFinished = false;
-          tscResetSqlCmd(pCmd, true);
-
-          code = tsParseSql(pSql, true);
-          if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
-            taosReleaseRef(tscObjRef, pSql->self);
-            return;
-          } else if (code != TSDB_CODE_SUCCESS) {
-            goto _error;
-          }
-
-          tscBuildAndSendRequest(pSql, NULL);
-        } else {  // in all other cases, simple retry
-          tscBuildAndSendRequest(pSql, NULL);
-        }
-
-        taosReleaseRef(tscObjRef, pSql->self);
-        return;
-      } else {
-        tscDebug("0x%"PRIx64" continue parse sql after get table meta", pSql->self);
+      if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_INSERT)) {
+        tscDebug("0x%" PRIx64 " continue parse sql after get table-meta", pSql->self);
 
         code = tsParseSql(pSql, false);
         if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
@@ -460,8 +438,8 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
           goto _error;
         }
 
-        if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_STMT_INSERT)){
-          STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd, 0);
+        if (TSDB_QUERY_HAS_TYPE(pCmd->insertParam.insertType, TSDB_QUERY_TYPE_STMT_INSERT)) {
+          STableMetaInfo *pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
           code = tscGetTableMeta(pSql, pTableMetaInfo);
           if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
             taosReleaseRef(tscObjRef, pSql->self);
@@ -471,22 +449,38 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
           }
 
           (*pSql->fp)(pSql->param, pSql, code);
-        } else if (TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_INSERT)) {
-          if (pCmd->dataSourceType == DATA_FROM_DATA_FILE) {
+        } else {
+          if (TSDB_QUERY_HAS_TYPE(pCmd->insertParam.insertType, TSDB_QUERY_TYPE_FILE_INSERT)) {
             tscImportDataFromFile(pSql);
           } else {
             tscHandleMultivnodeInsert(pSql);
           }
+        }
+      } else {
+        if (pSql->retryReason != TSDB_CODE_SUCCESS) {
+          tscDebug("0x%" PRIx64 " update cached table-meta, re-validate sql statement and send query again",
+                   pSql->self);
+          tscResetSqlCmd(pCmd, false);
+          pSql->retryReason = TSDB_CODE_SUCCESS;
         } else {
-          SQueryInfo* pQueryInfo1 = tscGetQueryInfo(pCmd);
-          executeQuery(pSql, pQueryInfo1);
+          tscDebug("0x%" PRIx64 " cached table-meta, continue validate sql statement and send query", pSql->self);
         }
 
-        taosReleaseRef(tscObjRef, pSql->self);
-        return;
-      }
-    }
+        code = tsParseSql(pSql, true);
+        if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+          taosReleaseRef(tscObjRef, pSql->self);
+          return;
+        } else if (code != TSDB_CODE_SUCCESS) {
+          goto _error;
+        }
 
+        SQueryInfo *pQueryInfo1 = tscGetQueryInfo(pCmd);
+        executeQuery(pSql, pQueryInfo1);
+      }
+
+      taosReleaseRef(tscObjRef, pSql->self);
+      return;
+    }
   } else {  // stream computing
     SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
     STableMetaInfo *pTableMetaInfo = pQueryInfo->pTableMetaInfo[0];
@@ -510,21 +504,16 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
     }
 
     tscDebug("0x%"PRIx64" stream:%p meta is updated, start new query, command:%d", pSql->self, pSql->pStream, pSql->cmd.command);
-    if (!pSql->cmd.parseFinished) {
+    if (tscNumOfExprs(pQueryInfo) == 0) {
       tsParseSql(pSql, false);
     }
 
     (*pSql->fp)(pSql->param, pSql, code);
-    
     taosReleaseRef(tscObjRef, pSql->self);
-
     return;
   }
 
-//  tscDoQuery(pSql);
-
   taosReleaseRef(tscObjRef, pSql->self);
-  
   return;
 
   _error:
diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index 467d42a731..a5327ef302 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -751,8 +751,6 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
 
   char *sql = *sqlstr;
 
-  pSql->cmd.autoCreated = false;
-  
   // get the token of specified table
   index = 0;
   tableToken = tStrGetToken(sql, &index, false);
@@ -1015,12 +1013,13 @@ int validateTableName(char *tblName, int len, SStrToken* psTblToken) {
   return tscValidateName(psTblToken);
 }
 
-static int32_t validateDataSource(SSqlCmd *pCmd, int8_t type, const char *sql) {
-  if (pCmd->dataSourceType != 0 && pCmd->dataSourceType != type) {
+static int32_t validateDataSource(SSqlCmd *pCmd, int32_t type, const char *sql) {
+  if (pCmd->insertParam.insertType != 0 && !TSDB_QUERY_HAS_TYPE(pCmd->insertParam.insertType, type)) {
     return tscInvalidSQLErrMsg(pCmd->payload, "keyword VALUES and FILE are not allowed to mix up", sql);
   }
 
-  pCmd->dataSourceType = type;
+
+  pCmd->insertParam.insertType = type;
   return TSDB_CODE_SUCCESS;
 }
 
@@ -1090,7 +1089,6 @@ static int32_t parseBoundColumns(SSqlCmd* pCmd, SParsedDataColInfo* pColInfo, SS
 
   _clean:
   pCmd->curSql     = NULL;
-  pCmd->parseFinished  = 1;
   return code;
 }
 
@@ -1142,7 +1140,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
        * if the data is from the data file, no data has been generated yet. So, there no data to
        * merge or submit, save the file path and parse the file in other routines.
        */
-      if (pCmd->dataSourceType == DATA_FROM_DATA_FILE) {
+      if (TSDB_QUERY_HAS_TYPE(pCmd->insertParam.insertType, TSDB_QUERY_TYPE_FILE_INSERT)) {
         goto _clean;
       }
 
@@ -1203,7 +1201,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
 
     STableComInfo tinfo = tscGetTableInfo(pTableMetaInfo->pTableMeta);
     if (sToken.type == TK_FILE) {
-      if (validateDataSource(pCmd, DATA_FROM_DATA_FILE, sToken.z) != TSDB_CODE_SUCCESS) {
+      if (validateDataSource(pCmd, TSDB_QUERY_TYPE_FILE_INSERT, sToken.z) != TSDB_CODE_SUCCESS) {
         goto _clean;
       }
 
@@ -1236,7 +1234,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
       if (bindedColumns == NULL) {
         STableMeta *pTableMeta = pTableMetaInfo->pTableMeta;
 
-        if (validateDataSource(pCmd, DATA_FROM_SQL_STRING, sToken.z) != TSDB_CODE_SUCCESS) {
+        if (validateDataSource(pCmd, TSDB_QUERY_TYPE_INSERT, sToken.z) != TSDB_CODE_SUCCESS) {
           goto _clean;
         }
 
@@ -1256,7 +1254,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
         // insert into tablename(col1, col2,..., coln) values(v1, v2,... vn);
         STableMeta *pTableMeta = tscGetTableMetaInfoFromCmd(pCmd, 0)->pTableMeta;
 
-        if (validateDataSource(pCmd, DATA_FROM_SQL_STRING, sToken.z) != TSDB_CODE_SUCCESS) {
+        if (validateDataSource(pCmd, TSDB_QUERY_TYPE_INSERT, sToken.z) != TSDB_CODE_SUCCESS) {
           goto _clean;
         }
 
@@ -1298,7 +1296,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
   }
 
   // merge according to vgId
-  if (!TSDB_QUERY_HAS_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_STMT_INSERT) && taosHashGetSize(pCmd->insertParam.pTableBlockHashList) > 0) {
+  if (!TSDB_QUERY_HAS_TYPE(pCmd->insertParam.insertType, TSDB_QUERY_TYPE_STMT_INSERT) && taosHashGetSize(pCmd->insertParam.pTableBlockHashList) > 0) {
     if ((code = tscMergeTableDataBlocks(pSql, true)) != TSDB_CODE_SUCCESS) {
       goto _clean;
     }
@@ -1309,7 +1307,6 @@ int tsParseInsertSql(SSqlObj *pSql) {
 
 _clean:
   pCmd->curSql = NULL;
-  pCmd->parseFinished  = 1;
   return code;
 }
 
@@ -1328,8 +1325,7 @@ int tsInsertInitialCheck(SSqlObj *pSql) {
   pCmd->command = TSDB_SQL_INSERT;
 
   SQueryInfo *pQueryInfo = tscGetQueryInfoS(pCmd);
-
-  TSDB_QUERY_SET_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_INSERT | TSDB_QUERY_TYPE_STMT_INSERT);
+  TSDB_QUERY_SET_TYPE(pQueryInfo->type, TSDB_QUERY_TYPE_INSERT);
 
   sToken = tStrGetToken(pSql->sqlstr, &index, false);
   if (sToken.type != TK_INTO) {
@@ -1344,11 +1340,11 @@ int tsParseSql(SSqlObj *pSql, bool initial) {
   int32_t ret = TSDB_CODE_SUCCESS;
   SSqlCmd* pCmd = &pSql->cmd;
 
-  if ((!pCmd->parseFinished) && (!initial)) {
+  if (!initial) {
     tscDebug("0x%"PRIx64" resume to parse sql: %s", pSql->self, pCmd->curSql);
   }
 
-  ret = tscAllocPayload(&pSql->cmd, TSDB_DEFAULT_PAYLOAD_SIZE);
+  ret = tscAllocPayload(pCmd, TSDB_DEFAULT_PAYLOAD_SIZE);
   if (TSDB_CODE_SUCCESS != ret) {
     return ret;
   }
@@ -1358,17 +1354,15 @@ int tsParseSql(SSqlObj *pSql, bool initial) {
       return ret;
     }
 
-    // make a backup as tsParseInsertSql may modify the string
-    char* sqlstr = strdup(pSql->sqlstr);
     ret = tsParseInsertSql(pSql);
-    if ((sqlstr == NULL) || (pSql->parseRetry >= 1) ||
-        (ret != TSDB_CODE_TSC_SQL_SYNTAX_ERROR && ret != TSDB_CODE_TSC_INVALID_SQL)) {
-      free(sqlstr);
-    } else {
+    assert(ret == TSDB_CODE_SUCCESS || ret == TSDB_CODE_TSC_ACTION_IN_PROGRESS || ret == TSDB_CODE_TSC_SQL_SYNTAX_ERROR || ret == TSDB_CODE_TSC_INVALID_SQL);
+
+    if (pSql->parseRetry < 1 && (ret == TSDB_CODE_TSC_SQL_SYNTAX_ERROR || ret == TSDB_CODE_TSC_INVALID_SQL)) {
+      tscDebug("0x%"PRIx64 " parse insert sql statement failed, code:%s, clear meta cache and retry ", pSql->self, tstrerror(ret));
+
       tscResetSqlCmd(pCmd, true);
-      free(pSql->sqlstr);
-      pSql->sqlstr = sqlstr;
       pSql->parseRetry++;
+
       if ((ret = tsInsertInitialCheck(pSql)) == TSDB_CODE_SUCCESS) {
         ret = tsParseInsertSql(pSql);
       }
@@ -1376,9 +1370,12 @@ int tsParseSql(SSqlObj *pSql, bool initial) {
   } else {
     SSqlInfo SQLInfo = qSqlParse(pSql->sqlstr);
     ret = tscToSQLCmd(pSql, &SQLInfo);
-    if (ret == TSDB_CODE_TSC_INVALID_SQL && pSql->parseRetry == 0 && SQLInfo.type == TSDB_SQL_NULL) {
+    if (ret == TSDB_CODE_TSC_INVALID_SQL && pSql->parseRetry < 1 && SQLInfo.type == TSDB_SQL_SELECT) {
+      tscDebug("0x%"PRIx64 " parse query sql statement failed, code:%s, clear meta cache and retry ", pSql->self, tstrerror(ret));
+
       tscResetSqlCmd(pCmd, true);
       pSql->parseRetry++;
+
       ret = tscToSQLCmd(pSql, &SQLInfo);
     }
 
@@ -1561,7 +1558,7 @@ void tscImportDataFromFile(SSqlObj *pSql) {
     return;
   }
 
-  assert(pCmd->dataSourceType == DATA_FROM_DATA_FILE  && strlen(pCmd->payload) != 0);
+  assert(TSDB_QUERY_HAS_TYPE(pCmd->insertParam.insertType, TSDB_QUERY_TYPE_FILE_INSERT) && strlen(pCmd->payload) != 0);
   pCmd->active = pCmd->pQueryInfo;
 
   SImportFileSupport *pSupporter = calloc(1, sizeof(SImportFileSupport));
diff --git a/src/client/src/tscPrepare.c b/src/client/src/tscPrepare.c
index b90776d0a8..9d40e186da 100644
--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -1104,14 +1104,14 @@ static int insertStmtExecute(STscStmt* stmt) {
 
   // data block reset
   pCmd->batchSize = 0;
-  for(int32_t i = 0; i < pCmd->numOfTables; ++i) {
-    if (pCmd->pTableNameList && pCmd->pTableNameList[i]) {
-      tfree(pCmd->pTableNameList[i]);
+  for(int32_t i = 0; i < pCmd->insertParam.numOfTables; ++i) {
+    if (pCmd->insertParam.pTableNameList && pCmd->insertParam.pTableNameList[i]) {
+      tfree(pCmd->insertParam.pTableNameList[i]);
     }
   }
 
-  pCmd->numOfTables = 0;
-  tfree(pCmd->pTableNameList);
+  pCmd->insertParam.numOfTables = 0;
+  tfree(pCmd->insertParam.pTableNameList);
   pCmd->insertParam.pDataBlocks = tscDestroyBlockArrayList(pCmd->insertParam.pDataBlocks);
 
   return pSql->res.code;
@@ -1126,12 +1126,12 @@ static void insertBatchClean(STscStmt* pStmt) {
   pCmd->batchSize = 0;
 
   for(int32_t i = 0; i < size; ++i) {
-    if (pCmd->pTableNameList && pCmd->pTableNameList[i]) {
-      tfree(pCmd->pTableNameList[i]);
+    if (pCmd->insertParam.pTableNameList && pCmd->insertParam.pTableNameList[i]) {
+      tfree(pCmd->insertParam.pTableNameList[i]);
     }
   }
 
-  tfree(pCmd->pTableNameList);
+  tfree(pCmd->insertParam.pTableNameList);
 
 /*
   STableDataBlocks** p = taosHashIterate(pCmd->insertParam.pTableBlockHashList, NULL);
@@ -1155,7 +1155,7 @@ static void insertBatchClean(STscStmt* pStmt) {
 */
 
   pCmd->insertParam.pDataBlocks = tscDestroyBlockArrayList(pCmd->insertParam.pDataBlocks);
-  pCmd->numOfTables = 0;
+  pCmd->insertParam.numOfTables = 0;
 
   taosHashEmpty(pCmd->insertParam.pTableBlockHashList);
   tscFreeSqlResult(pSql);
@@ -1174,7 +1174,7 @@ static int insertBatchStmtExecute(STscStmt* pStmt) {
 
   pStmt->pSql->retry = pStmt->pSql->maxRetry + 1;  //no retry
 
-  if (taosHashGetSize(pStmt->pSql->cmd.pTableBlockHashList) <= 0) { // merge according to vgId
+  if (taosHashGetSize(pStmt->pSql->cmd.insertParam.pTableBlockHashList) <= 0) { // merge according to vgId
     tscError("0x%"PRIx64" no data block to insert", pStmt->pSql->self);
     return TSDB_CODE_TSC_APP_ERROR;
   }
@@ -1261,7 +1261,7 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
   pSql->fp         = waitForQueryRsp;
   pSql->fetchFp    = waitForQueryRsp;
   
-  pCmd->insertType = TSDB_QUERY_TYPE_STMT_INSERT;
+  pCmd->insertParam.insertType = TSDB_QUERY_TYPE_STMT_INSERT;
 
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, TSDB_DEFAULT_PAYLOAD_SIZE)) {
     tscError("%p failed to malloc payload buffer", pSql);
@@ -1387,7 +1387,6 @@ int taos_stmt_set_tbname(TAOS_STMT* stmt, const char* name) {
 
   tscDebug("0x%"PRIx64" SQL: %s", pSql->self, pSql->sqlstr);
 
-  pSql->cmd.parseFinished = 0;
   pSql->cmd.numOfParams = 0;
   pSql->cmd.batchSize   = 0;
 
@@ -1448,8 +1447,8 @@ int taos_stmt_close(TAOS_STMT* stmt) {
     if (pStmt->multiTbInsert) {
       taosHashCleanup(pStmt->mtb.pTableHash);
       pStmt->mtb.pTableBlockHashList = tscDestroyBlockHashTable(pStmt->mtb.pTableBlockHashList, true);
-      taosHashCleanup(pStmt->pSql->cmd.pTableBlockHashList);
-      pStmt->pSql->cmd.pTableBlockHashList = NULL;
+      taosHashCleanup(pStmt->pSql->cmd.insertParam.pTableBlockHashList);
+      pStmt->pSql->cmd.insertParam.pTableNameList = NULL;
     }
   }
 
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 0c77b5da0a..e33f9d6c22 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -674,7 +674,6 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       pCmd->active = pCmd->pQueryInfo;
       pCmd->command = pCmd->pQueryInfo->command;
 
-      pCmd->parseFinished = 1;
       return TSDB_CODE_SUCCESS;  // do not build query message here
     }
 
@@ -711,7 +710,6 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), "not support sql expression");
   }
 
-  pSql->cmd.parseFinished = 1;
   if (tscBuildMsg[pCmd->command] != NULL) {
     return tscBuildMsg[pCmd->command](pSql, pInfo);
   } else {
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index aaf40ec5e3..513b85b2a6 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -360,7 +360,7 @@ void tscProcessMsgFromServer(SRpcMsg *rpcMsg, SRpcEpSet *pEpSet) {
 
   // 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.submitSchema = 1;
+    pSql->cmd.insertParam.schemaAttached = 1;
   }
 
   if ((cmd == TSDB_SQL_SELECT || cmd == TSDB_SQL_UPDATE_TAGS_VAL) &&
@@ -477,7 +477,7 @@ int doBuildAndSendMsg(SSqlObj *pSql) {
       pCmd->command == TSDB_SQL_INSERT ||
       pCmd->command == TSDB_SQL_CONNECT ||
       pCmd->command == TSDB_SQL_HB ||
-      pCmd->command == TSDB_SQL_META ||
+//      pCmd->command == TSDB_SQL_META ||
       pCmd->command == TSDB_SQL_STABLEVGROUP) {
     pRes->code = tscBuildMsg[pCmd->command](pSql, NULL);
   }
@@ -583,23 +583,6 @@ int tscBuildFetchMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 int tscBuildSubmitMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
   STableMeta* pTableMeta = tscGetMetaInfo(pQueryInfo, 0)->pTableMeta;
-  
-//  char* pMsg = pSql->cmd.payload;
-//
-//  // NOTE: shell message size should not include SMsgDesc
-//  int32_t size = pSql->cmd.payloadLen - sizeof(SMsgDesc);
-//
-//  SMsgDesc* pMsgDesc = (SMsgDesc*) pMsg;
-//  pMsgDesc->numOfVnodes = htonl(1);    // always one vnode
-//
-//  pMsg += sizeof(SMsgDesc);
-//  SSubmitMsg *pShellMsg = (SSubmitMsg *)pMsg;
-//
-//  pShellMsg->header.vgId    = htonl(pTableMeta->vgId);               // data in current block all routes to the same vgroup
-//  pShellMsg->header.contLen = htonl(size);                           // the length not includes the size of SMsgDesc
-//  pShellMsg->length         = pShellMsg->header.contLen;
-//
-//  pShellMsg->numOfBlocks    = htonl(pSql->cmd.numOfTablesInSubmit);  // the number of tables to be inserted
 
   // pSql->cmd.payloadLen is set during copying data into payload
   pSql->cmd.msgType = TSDB_MSG_TYPE_SUBMIT;
@@ -1689,6 +1672,7 @@ int tscBuildConnectMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 }
 
 int tscBuildTableMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
+#if 0
   SSqlCmd    *pCmd = &pSql->cmd;
   SQueryInfo *pQueryInfo = tscGetQueryInfo(&pSql->cmd);
 
@@ -1710,6 +1694,7 @@ int tscBuildTableMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   pCmd->payloadLen = (int32_t)(pMsg - (char*)pInfoMsg);
   pCmd->msgType = TSDB_MSG_TYPE_CM_TABLE_META;
+#endif
 
   return TSDB_CODE_SUCCESS;
 }
@@ -2356,53 +2341,60 @@ int tscProcessRetrieveRspFromNode(SSqlObj *pSql) {
 
 void tscTableMetaCallBack(void *param, TAOS_RES *res, int code);
 
-static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
+static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo, bool autocreate) {
   SSqlObj *pNew = calloc(1, sizeof(SSqlObj));
   if (NULL == pNew) {
     tscError("0x%"PRIx64" malloc failed for new sqlobj to get table meta", pSql->self);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
-  pNew->pTscObj = pSql->pTscObj;
-  pNew->signature = pNew;
+  pNew->pTscObj     = pSql->pTscObj;
+  pNew->signature   = pNew;
   pNew->cmd.command = TSDB_SQL_META;
 
   tscAddQueryInfo(&pNew->cmd);
 
   SQueryInfo *pNewQueryInfo = tscGetQueryInfoS(&pNew->cmd);
-
-  pNew->cmd.autoCreated = pSql->cmd.autoCreated;  // create table if not exists
   if (TSDB_CODE_SUCCESS != tscAllocPayload(&pNew->cmd, TSDB_DEFAULT_PAYLOAD_SIZE + pSql->cmd.payloadLen)) {
     tscError("0x%"PRIx64" malloc failed for payload to get table meta", pSql->self);
+
     tscFreeSqlObj(pNew);
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
-  STableMetaInfo *pNewMeterMetaInfo = tscAddEmptyMetaInfo(pNewQueryInfo);
+  STableMetaInfo *pNewTableMetaInfo = tscAddEmptyMetaInfo(pNewQueryInfo);
   assert(pNewQueryInfo->numOfTables == 1);
 
-  tNameAssign(&pNewMeterMetaInfo->name, &pTableMetaInfo->name);
-
-  if (pSql->cmd.autoCreated) {
-    int32_t code = copyTagData(&pNew->cmd.tagData, &pSql->cmd.tagData);
-    if (code != TSDB_CODE_SUCCESS) {
-      tscError("0x%"PRIx64" malloc failed for new tag data to get table meta", pSql->self);
-      tscFreeSqlObj(pNew);
-      return TSDB_CODE_TSC_OUT_OF_MEMORY;
-    }
-  }
+  tNameAssign(&pNewTableMetaInfo->name, &pTableMetaInfo->name);
 
   registerSqlObj(pNew);
-  tscDebug("0x%"PRIx64" new pSqlObj:0x%"PRIx64" to get tableMeta, auto create:%d", pSql->self, pNew->self,
-      pNew->cmd.autoCreated);
 
-  pNew->fp = tscTableMetaCallBack;
+  pNew->fp    = tscTableMetaCallBack;
   pNew->param = (void *)pSql->self;
 
-  tscDebug("0x%"PRIx64" metaRid from %" PRId64 " to %" PRId64 , pSql->self, pSql->metaRid, pNew->self);
-  
+  tscDebug("0x%"PRIx64" new pSqlObj:0x%"PRIx64" to get tableMeta, auto create:%d, metaRid from %"PRId64" to %"PRId64,
+      pSql->self, pNew->self, autocreate, pSql->metaRid, pNew->self);
   pSql->metaRid = pNew->self;
 
+  {
+    STableInfoMsg  *pInfoMsg = (STableInfoMsg *)pNew->cmd.payload;
+    int32_t code = tNameExtractFullName(&pNewTableMetaInfo->name, pInfoMsg->tableFname);
+    if (code != TSDB_CODE_SUCCESS) {
+      return TSDB_CODE_TSC_INVALID_SQL;
+    }
+
+    pInfoMsg->createFlag = htons(autocreate? 1 : 0);
+    char *pMsg = (char *)pInfoMsg + sizeof(STableInfoMsg);
+
+    // tag data exists
+    if (autocreate && pSql->cmd.tagData.dataLen != 0) {
+      pMsg = serializeTagData(&pSql->cmd.tagData, pMsg);
+    }
+
+    pNew->cmd.payloadLen = (int32_t)(pMsg - (char*)pInfoMsg);
+    pNew->cmd.msgType = TSDB_MSG_TYPE_CM_TABLE_META;
+  }
+
   int32_t code = tscBuildAndSendRequest(pNew, NULL);
   if (code == TSDB_CODE_SUCCESS) {
     code = TSDB_CODE_TSC_ACTION_IN_PROGRESS;  // notify application that current process needs to be terminated
@@ -2481,7 +2473,7 @@ int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVg
   return code;
 }
 
-int32_t tscGetTableMeta(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
+int32_t tscGetTableMetaImpl(SSqlObj* pSql, STableMetaInfo *pTableMetaInfo, bool autocreate) {
   assert(tIsValidName(&pTableMetaInfo->name));
 
   uint32_t size = tscGetTableMetaMaxSize();
@@ -2497,7 +2489,6 @@ int32_t tscGetTableMeta(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
     memset(pTableMetaInfo->pTableMeta, 0, size);
     pTableMetaInfo->tableMetaSize = size;
   } else {
-    //uint32_t s = tscGetTableMetaSize(pTableMetaInfo->pTableMeta);
     memset(pTableMetaInfo->pTableMeta, 0, size);
     pTableMetaInfo->tableMetaSize = size;
   }
@@ -2520,23 +2511,26 @@ int32_t tscGetTableMeta(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
     if (pMeta->tableType == TSDB_CHILD_TABLE) {
       int32_t code = tscCreateTableMetaFromCChildMeta(pTableMetaInfo->pTableMeta, name, buf);
       if (code != TSDB_CODE_SUCCESS) {
-        return getTableMetaFromMnode(pSql, pTableMetaInfo);
+        return getTableMetaFromMnode(pSql, pTableMetaInfo, autocreate);
       }
     }
 
     return TSDB_CODE_SUCCESS;
   }
 
-  return getTableMetaFromMnode(pSql, pTableMetaInfo);
+  return getTableMetaFromMnode(pSql, pTableMetaInfo, autocreate);
+}
+
+int32_t tscGetTableMeta(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo) {
+  return tscGetTableMetaImpl(pSql, pTableMetaInfo, false);
 }
 
 int tscGetTableMetaEx(SSqlObj *pSql, STableMetaInfo *pTableMetaInfo, bool createIfNotExists) {
-  pSql->cmd.autoCreated = createIfNotExists;
-  return tscGetTableMeta(pSql, pTableMetaInfo);
+  return tscGetTableMetaImpl(pSql, pTableMetaInfo, createIfNotExists);
 }
 
 /**
- * retrieve table meta from mnode, and update the local table meta hashmap.
+ * retrieve table meta from mnode, and then update the local table meta hashmap.
  * @param pSql          sql object
  * @param tableIndex    table index
  * @return              status code
@@ -2564,7 +2558,7 @@ int tscRenewTableMeta(SSqlObj *pSql, int32_t tableIndex) {
   size_t len = strlen(name);
   taosHashRemove(tscTableMetaInfo, name, len);
 
-  return getTableMetaFromMnode(pSql, pTableMetaInfo);
+  return getTableMetaFromMnode(pSql, pTableMetaInfo, false);
 }
 
 static bool allVgroupInfoRetrieved(SQueryInfo* pQueryInfo) {
@@ -2656,7 +2650,7 @@ void tscInitMsgsFp() {
 
   tscBuildMsg[TSDB_SQL_CONNECT] = tscBuildConnectMsg;
   tscBuildMsg[TSDB_SQL_USE_DB] = tscBuildUseDbMsg;
-  tscBuildMsg[TSDB_SQL_META] = tscBuildTableMetaMsg;
+//  tscBuildMsg[TSDB_SQL_META] = tscBuildTableMetaMsg;
   tscBuildMsg[TSDB_SQL_STABLEVGROUP] = tscBuildSTableVgroupMsg;
 
   tscBuildMsg[TSDB_SQL_HB] = tscBuildHeartBeatMsg;
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index 2c6eb4f3e2..eb2e1757d7 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -3020,8 +3020,8 @@ static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int numOfRows)
     pParentObj->res.code = pSql->res.code;
 
     // set the flag in the parent sqlObj
-    if (pSql->cmd.submitSchema) {
-      pParentObj->cmd.submitSchema = 1;
+    if (pSql->cmd.insertParam.schemaAttached) {
+      pParentObj->cmd.insertParam.schemaAttached = 1;
     }
   }
 
@@ -3069,15 +3069,15 @@ static void multiVnodeInsertFinalize(void* param, TAOS_RES* tres, int numOfRows)
     tscError("0x%"PRIx64" Async insertion completed, total inserted:%d rows, numOfFailed:%d, numOfTotal:%d", pParentObj->self,
              pParentObj->res.numOfRows, numOfFailed, numOfSub);
 
-    tscDebug("0x%"PRIx64" cleanup %d tableMeta in hashTable before reparse sql", pParentObj->self, pParentObj->cmd.numOfTables);
-    for(int32_t i = 0; i < pParentObj->cmd.numOfTables; ++i) {
+    tscDebug("0x%"PRIx64" cleanup %d tableMeta in hashTable before reparse sql", pParentObj->self, pParentObj->cmd.insertParam.numOfTables);
+    for(int32_t i = 0; i < pParentObj->cmd.insertParam.numOfTables; ++i) {
       char name[TSDB_TABLE_FNAME_LEN] = {0};
-      tNameExtractFullName(pParentObj->cmd.pTableNameList[i], name);
+      tNameExtractFullName(pParentObj->cmd.insertParam.pTableNameList[i], name);
       taosHashRemove(tscTableMetaInfo, name, strnlen(name, TSDB_TABLE_FNAME_LEN));
     }
 
     pParentObj->res.code = TSDB_CODE_SUCCESS;
-    pParentObj->cmd.parseFinished = false;
+//    pParentObj->cmd.parseFinished = false;
 
     tscResetSqlCmd(&pParentObj->cmd, false);
 
@@ -3112,7 +3112,7 @@ int32_t tscHandleInsertRetry(SSqlObj* pParent, SSqlObj* pSql) {
   SInsertSupporter* pSupporter = (SInsertSupporter*) pSql->param;
   assert(pSupporter->index < pSupporter->pSql->subState.numOfSub);
 
-  STableDataBlocks* pTableDataBlock = taosArrayGetP(pParent->cmd.pDataBlocks, pSupporter->index);
+  STableDataBlocks* pTableDataBlock = taosArrayGetP(pParent->cmd.insertParam.pDataBlocks, pSupporter->index);
   int32_t code = tscCopyDataBlockToPayload(pSql, pTableDataBlock);
 
   if ((pRes->code = code)!= TSDB_CODE_SUCCESS) {
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 6f3fd1a253..1b36e3cb00 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -1106,33 +1106,31 @@ void tscFreeQueryInfo(SSqlCmd* pCmd, bool removeMeta) {
 }
 
 void destroyTableNameList(SSqlCmd* pCmd) {
-  if (pCmd->numOfTables == 0) {
-    assert(pCmd->pTableNameList == NULL);
+  if (pCmd->insertParam.numOfTables == 0) {
+    assert(pCmd->insertParam.pTableNameList == NULL);
     return;
   }
 
-  for(int32_t i = 0; i < pCmd->numOfTables; ++i) {
-    tfree(pCmd->pTableNameList[i]);
+  for(int32_t i = 0; i < pCmd->insertParam.numOfTables; ++i) {
+    tfree(pCmd->insertParam.pTableNameList[i]);
   }
 
-  pCmd->numOfTables = 0;
-  tfree(pCmd->pTableNameList);
+  pCmd->insertParam.numOfTables = 0;
+  tfree(pCmd->insertParam.pTableNameList);
 }
 
-void tscResetSqlCmd(SSqlCmd* pCmd, bool removeMeta) {
+void tscResetSqlCmd(SSqlCmd* pCmd, bool clearCachedMeta) {
   pCmd->command   = 0;
   pCmd->numOfCols = 0;
   pCmd->count     = 0;
   pCmd->curSql    = NULL;
   pCmd->msgType   = 0;
-  pCmd->parseFinished = 0;
-  pCmd->autoCreated = 0;
 
   destroyTableNameList(pCmd);
 
-  pCmd->insertParam.pTableBlockHashList = tscDestroyBlockHashTable(pCmd->insertParam.pTableBlockHashList, removeMeta);
+  pCmd->insertParam.pTableBlockHashList = tscDestroyBlockHashTable(pCmd->insertParam.pTableBlockHashList, clearCachedMeta);
   pCmd->insertParam.pDataBlocks = tscDestroyBlockArrayList(pCmd->insertParam.pDataBlocks);
-  tscFreeQueryInfo(pCmd, removeMeta);
+  tscFreeQueryInfo(pCmd, clearCachedMeta);
 
   if (pCmd->pTableMetaMap != NULL) {
     STableMetaVgroupInfo* p = taosHashIterate(pCmd->pTableMetaMap, NULL);
@@ -1341,7 +1339,7 @@ void* tscDestroyBlockHashTable(SHashObj* pBlockHashTable, bool removeMeta) {
 
 int32_t tscCopyDataBlockToPayload(SSqlObj* pSql, STableDataBlocks* pDataBlock) {
   SSqlCmd* pCmd = &pSql->cmd;
-  assert(pDataBlock->pTableMeta != NULL);
+  assert(pDataBlock->pTableMeta != NULL && pDataBlock->size <= pDataBlock->nAllocSize && pDataBlock->size > sizeof(SMsgDesc));
 
   STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
 
@@ -1363,22 +1361,22 @@ int32_t tscCopyDataBlockToPayload(SSqlObj* pSql, STableDataBlocks* pDataBlock) {
    * the dataBlock only includes the RPC Header buffer and actual submit message body,
    * space for digest needs additional space.
    */
-  int ret = tscAllocPayload(pCmd, pDataBlock->size + 100);
+  int ret = tscAllocPayload(pCmd, pDataBlock->size);
   if (TSDB_CODE_SUCCESS != ret) {
     return ret;
   }
 
-  assert(pDataBlock->size <= pDataBlock->nAllocSize);
   memcpy(pCmd->payload, pDataBlock->pData, pDataBlock->size);
 
   //the payloadLen should be actual message body size, the old value of payloadLen is the allocated payload size
   pCmd->payloadLen = pDataBlock->size;
+  assert(pCmd->allocSize >= (uint32_t)(pCmd->payloadLen));
 
   // NOTE: shell message size should not include SMsgDesc
   int32_t size = pCmd->payloadLen - sizeof(SMsgDesc);
 
-  SMsgDesc* pMsgDesc    = (SMsgDesc*) pCmd->payload;
-  pMsgDesc->numOfVnodes = htonl(1);    // always for one vnode
+  SMsgDesc* pMsgDesc        = (SMsgDesc*) pCmd->payload;
+  pMsgDesc->numOfVnodes     = htonl(1);    // always for one vnode
 
   SSubmitMsg *pShellMsg     = (SSubmitMsg *)(pCmd->payload + sizeof(SMsgDesc));
   pShellMsg->header.vgId    = htonl(pDataBlock->pTableMeta->vgId);   // data in current block all routes to the same vgroup
@@ -1386,8 +1384,6 @@ int32_t tscCopyDataBlockToPayload(SSqlObj* pSql, STableDataBlocks* pDataBlock) {
   pShellMsg->length         = pShellMsg->header.contLen;
   pShellMsg->numOfBlocks    = htonl(pDataBlock->numOfTables);  // the number of tables to be inserted
 
-  assert(pCmd->allocSize >= (uint32_t)(pCmd->payloadLen + 100) && pCmd->payloadLen > 0);
-
   tscDebug("0x%"PRIx64" submit msg built, vgId:%d numOfTables:%d", pSql->self, pDataBlock->pTableMeta->vgId, pDataBlock->numOfTables);
   return TSDB_CODE_SUCCESS;
 }
@@ -1550,20 +1546,20 @@ static int32_t getRowExpandSize(STableMeta* pTableMeta) {
 }
 
 static void extractTableNameList(SSqlCmd* pCmd, bool freeBlockMap) {
-  pCmd->numOfTables = (int32_t) taosHashGetSize(pCmd->insertParam.pTableBlockHashList);
-  if (pCmd->pTableNameList == NULL) {
-    pCmd->pTableNameList = calloc(pCmd->numOfTables, POINTER_BYTES);
+  pCmd->insertParam.numOfTables = (int32_t) taosHashGetSize(pCmd->insertParam.pTableBlockHashList);
+  if (pCmd->insertParam.pTableNameList == NULL) {
+    pCmd->insertParam.pTableNameList = calloc(pCmd->insertParam.numOfTables, POINTER_BYTES);
   } else {
-    memset(pCmd->pTableNameList, 0, pCmd->numOfTables * POINTER_BYTES);
+    memset(pCmd->insertParam.pTableNameList, 0, pCmd->insertParam.numOfTables * POINTER_BYTES);
   }
 
   STableDataBlocks **p1 = taosHashIterate(pCmd->insertParam.pTableBlockHashList, NULL);
   int32_t i = 0;
   while(p1) {
     STableDataBlocks* pBlocks = *p1;
-    tfree(pCmd->pTableNameList[i]);
+    tfree(pCmd->insertParam.pTableNameList[i]);
 
-    pCmd->pTableNameList[i++] = tNameDup(&pBlocks->tableName);
+    pCmd->insertParam.pTableNameList[i++] = tNameDup(&pBlocks->tableName);
     p1 = taosHashIterate(pCmd->insertParam.pTableBlockHashList, p1);
   }
 
@@ -1635,7 +1631,7 @@ int32_t tscMergeTableDataBlocks(SSqlObj* pSql, bool freeBlockMap) {
       pBlocks->schemaLen = 0;
 
       // erase the empty space reserved for binary data
-      int32_t finalLen = trimDataBlock(dataBuf->pData + dataBuf->size, pOneTableBlock, pCmd->submitSchema);
+      int32_t finalLen = trimDataBlock(dataBuf->pData + dataBuf->size, pOneTableBlock, pCmd->insertParam.schemaAttached);
       assert(finalLen <= len);
 
       dataBuf->size += (finalLen + sizeof(SSubmitBlk));
@@ -1693,18 +1689,22 @@ bool tscIsInsertData(char* sqlstr) {
 }
 
 int tscAllocPayload(SSqlCmd* pCmd, int size) {
-  assert(size > 0);
-
   if (pCmd->payload == NULL) {
     assert(pCmd->allocSize == 0);
 
     pCmd->payload = (char*)calloc(1, size);
-    if (pCmd->payload == NULL) return TSDB_CODE_TSC_OUT_OF_MEMORY;
+    if (pCmd->payload == NULL) {
+      return TSDB_CODE_TSC_OUT_OF_MEMORY;
+    }
+
     pCmd->allocSize = size;
   } else {
     if (pCmd->allocSize < (uint32_t)size) {
       char* b = realloc(pCmd->payload, size);
-      if (b == NULL) return TSDB_CODE_TSC_OUT_OF_MEMORY;
+      if (b == NULL) {
+        return TSDB_CODE_TSC_OUT_OF_MEMORY;
+      }
+
       pCmd->payload = b;
       pCmd->allocSize = size;
     }
@@ -1712,7 +1712,7 @@ int tscAllocPayload(SSqlCmd* pCmd, int size) {
     memset(pCmd->payload, 0, pCmd->allocSize);
   }
 
-  assert(pCmd->allocSize >= (uint32_t)size);
+  assert(pCmd->allocSize >= (uint32_t)size && size > 0);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -3006,8 +3006,6 @@ SSqlObj* createSimpleSubObj(SSqlObj* pSql, __async_cb_func_t fp, void* param, in
 
   SSqlCmd* pCmd = &pNew->cmd;
   pCmd->command = cmd;
-  pCmd->parseFinished = 1;
-  pCmd->autoCreated = pSql->cmd.autoCreated;
 
   int32_t code = copyTagData(&pNew->cmd.tagData, &pSql->cmd.tagData);
   if (code != TSDB_CODE_SUCCESS) {
@@ -3106,12 +3104,11 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, __async_cb_func_t
   pnCmd->pTableMetaMap = NULL;
 
   pnCmd->pQueryInfo  = NULL;
-  pnCmd->pDataBlocks = NULL;
+  pnCmd->insertParam.pDataBlocks = NULL;
 
-  pnCmd->numOfTables = 0;
-  pnCmd->parseFinished = 1;
-  pnCmd->pTableNameList = NULL;
-  pnCmd->pTableBlockHashList = NULL;
+  pnCmd->insertParam.numOfTables = 0;
+  pnCmd->insertParam.pTableNameList = NULL;
+  pnCmd->insertParam.pTableBlockHashList = NULL;
   pnCmd->tagData.data = NULL;
   pnCmd->tagData.dataLen = 0;
 
@@ -3384,8 +3381,6 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
 
       SSqlCmd* pCmd = &pNew->cmd;
       pCmd->command = TSDB_SQL_SELECT;
-      pCmd->parseFinished = 1;
-
       if (tscAddQueryInfo(pCmd) != TSDB_CODE_SUCCESS) {
       }
 
diff --git a/src/inc/taosdef.h b/src/inc/taosdef.h
index e596ee67ec..979559c7e7 100644
--- a/src/inc/taosdef.h
+++ b/src/inc/taosdef.h
@@ -345,6 +345,7 @@ do { \
 #define TSDB_QUERY_TYPE_TAG_FILTER_QUERY       0x400u
 #define TSDB_QUERY_TYPE_INSERT                 0x100u    // insert type
 #define TSDB_QUERY_TYPE_MULTITABLE_QUERY       0x200u
+#define TSDB_QUERY_TYPE_FILE_INSERT            0x400u    // insert data from file
 #define TSDB_QUERY_TYPE_STMT_INSERT            0x800u    // stmt insert type
 
 #define TSDB_QUERY_HAS_TYPE(x, _type)          (((x) & (_type)) != 0)

From 2f2bc6bf56428e8a6bc3a5a567a59b3fddeacfe3 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 25 May 2021 13:41:30 +0800
Subject: [PATCH 084/128] [td-4151]

---
 src/query/src/qExecutor.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 528c65eaed..8a7506cb97 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -1770,10 +1770,10 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
 
       case OP_Filter: {  // todo refactor
         int32_t numOfFilterCols = 0;
-        if (pQueryAttr->numOfFilterCols > 0) {
-          pRuntimeEnv->proot = createFilterOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr1,
-                                                        pQueryAttr->numOfOutput, pQueryAttr->tableCols, pQueryAttr->numOfFilterCols);
-        } else {
+//        if (pQueryAttr->numOfFilterCols > 0) {
+//          pRuntimeEnv->proot = createFilterOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr1,
+//                                                        pQueryAttr->numOfOutput, pQueryAttr->tableCols, pQueryAttr->numOfFilterCols);
+//        } else {
           if (pQueryAttr->stableQuery) {
             SColumnInfo* pColInfo =
                 extractColumnFilterInfo(pQueryAttr->pExpr3, pQueryAttr->numOfExpr3, &numOfFilterCols);
@@ -1787,7 +1787,7 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
                                                           pQueryAttr->numOfOutput, pColInfo, numOfFilterCols);
             freeColumnInfo(pColInfo, pQueryAttr->numOfOutput);
           }
-        }
+//        }
         break;
       }
 

From 6488456b86ed88ef2819a64381115c92b6d41dcb Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 25 May 2021 15:11:11 +0800
Subject: [PATCH 085/128] [td-4231]fix bug by regression test.

---
 src/client/src/tscSQLParser.c | 14 +++++++++-----
 src/client/src/tscSub.c       |  6 +++---
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 722ce7a231..b020432a2e 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -7291,11 +7291,15 @@ int32_t doValidateSqlNode(SSqlObj* pSql, SQuerySqlNode* pQuerySqlNode, int32_t i
     }
 
     if(tscQueryTags(pQueryInfo)) {
-      int32_t numOfCols = (int32_t) taosArrayGetSize(pQueryInfo->colList);
-      for(int32_t i = 0; i < numOfCols; ++i) {
-        SColumn* pCols = taosArrayGetP(pQueryInfo->colList, i);
-        if (pCols->numOfFilters > 0) {
-          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg9);
+      SSqlExpr* pExpr1 = tscSqlExprGet(pQueryInfo, 0);
+
+      if (pExpr1->functionId != TSDB_FUNC_TID_TAG) {
+        int32_t numOfCols = (int32_t)taosArrayGetSize(pQueryInfo->colList);
+        for (int32_t i = 0; i < numOfCols; ++i) {
+          SColumn* pCols = taosArrayGetP(pQueryInfo->colList, i);
+          if (pCols->numOfFilters > 0) {
+            return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg9);
+          }
         }
       }
     }
diff --git a/src/client/src/tscSub.c b/src/client/src/tscSub.c
index 7da98c7885..327ccd0294 100644
--- a/src/client/src/tscSub.c
+++ b/src/client/src/tscSub.c
@@ -215,7 +215,7 @@ static void tscProcessSubscriptionTimer(void *handle, void *tmrId) {
   taosTmrReset(tscProcessSubscriptionTimer, pSub->interval, pSub, tscTmr, &pSub->pTimer);
 }
 
-
+//TODO refactor: extract table list name not simply from the sql
 static SArray* getTableList( SSqlObj* pSql ) {
   const char* p = strstr( pSql->sqlstr, " from " );
   assert(p != NULL); // we are sure this is a 'select' statement
@@ -224,11 +224,11 @@ static SArray* getTableList( SSqlObj* pSql ) {
   
   SSqlObj* pNew = taos_query(pSql->pTscObj, sql);
   if (pNew == NULL) {
-    tscError("0x%"PRIx64"failed to retrieve table id: cannot create new sql object.", pSql->self);
+    tscError("0x%"PRIx64" failed to retrieve table id: cannot create new sql object.", pSql->self);
     return NULL;
 
   } else if (taos_errno(pNew) != TSDB_CODE_SUCCESS) {
-    tscError("0x%"PRIx64"failed to retrieve table id,error: %s", pSql->self, tstrerror(taos_errno(pNew)));
+    tscError("0x%"PRIx64" failed to retrieve table id,error: %s", pSql->self, tstrerror(taos_errno(pNew)));
     return NULL;
   }
 

From 76b8d1b395dd200a1234dfbc150b201d0abbc090 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 25 May 2021 20:11:04 +0800
Subject: [PATCH 086/128] [td-225] add test sim.

---
 tests/script/general/parser/nchar.sim     |  1 -
 tests/script/general/parser/nestquery.sim | 66 +++++++++++++++++++++++
 2 files changed, 66 insertions(+), 1 deletion(-)
 create mode 100644 tests/script/general/parser/nestquery.sim

diff --git a/tests/script/general/parser/nchar.sim b/tests/script/general/parser/nchar.sim
index 786cee651b..84719efcab 100644
--- a/tests/script/general/parser/nchar.sim
+++ b/tests/script/general/parser/nchar.sim
@@ -1,6 +1,5 @@
 system sh/stop_dnodes.sh
 
-
 system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 1
 system sh/exec.sh -n dnode1 -s start
diff --git a/tests/script/general/parser/nestquery.sim b/tests/script/general/parser/nestquery.sim
new file mode 100644
index 0000000000..082457438f
--- /dev/null
+++ b/tests/script/general/parser/nestquery.sim
@@ -0,0 +1,66 @@
+system sh/stop_dnodes.sh
+
+system sh/deploy.sh -n dnode1 -i 1
+system sh/cfg.sh -n dnode1 -c walLevel -v 1
+system sh/exec.sh -n dnode1 -s start
+
+sleep 100
+sql connect
+
+print ======================== dnode1 start
+
+$dbPrefix = nest_query
+$tbPrefix = nest_tb
+$mtPrefix = nest_mt
+$tbNum = 10
+$rowNum = 10000
+$totalNum = $tbNum * $rowNum
+
+print =============== nestquery.sim
+$i = 0
+$db = $dbPrefix . $i
+$mt = $mtPrefix . $i
+
+sql drop database if exists $db -x step1
+step1:
+sql create database if not exists $db
+sql use $db
+sql create table $mt (ts timestamp, c1 int, c2 float, c3 bigint, c4 smallint, c5 tinyint, c6 double, c7 bool, c8 binary(10), c9 nchar(9)) TAGS(t1 int)
+
+$half = $tbNum / 2
+
+$i = 0
+while $i < $half
+  $tb = $tbPrefix . $i
+
+  $nextSuffix = $i + $half
+  $tb1 = $tbPrefix . $nextSuffix
+
+  sql create table $tb using $mt tags( $i )
+  sql create table $tb1 using $mt tags( $nextSuffix )
+
+  $x = 0
+  while $x < $rowNum
+    $y = $x * 60000
+    $ms = 1600099200000 + $y
+    $c = $x / 100
+    $c = $c * 100
+    $c = $x - $c
+    $binary = 'binary . $c
+    $binary = $binary . '
+    $nchar = 'nchar . $c
+    $nchar = $nchar . '
+    sql insert into $tb values ($ms , $c , $c , $c , $c , $c , $c , $c , $binary , $nchar )  $tb1 values ($ms , $c , $c , $c , $c , $c , $c , $c , $binary , $nchar )
+    $x = $x + 1
+  endw
+
+  $i = $i + 1
+endw
+
+sleep 100
+
+$i = 1
+$tb = $tbPrefix . $i
+sql select count(*) from (select
+
+system sh/exec.sh -n dnode1 -s stop -x SIGINT
\ No newline at end of file

From 3da561521fdc2a42ee33d41138576a7ae8e16ae4 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Tue, 25 May 2021 20:37:58 +0800
Subject: [PATCH 087/128] [TD-4323]<fix>:  the deleted vnode does not need to
 commit, so as to speed up the deletion and avoid crash while balance

---
 src/vnode/src/vnodeMain.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/vnode/src/vnodeMain.c b/src/vnode/src/vnodeMain.c
index ee28be3d2f..f4515b6688 100644
--- a/src/vnode/src/vnodeMain.c
+++ b/src/vnode/src/vnodeMain.c
@@ -419,7 +419,11 @@ void vnodeDestroy(SVnodeObj *pVnode) {
   }
 
   if (pVnode->tsdb) {
-    code = tsdbCloseRepo(pVnode->tsdb, 1);
+    // the deleted vnode does not need to commit, so as to speed up the deletion
+    int toCommit = 1;
+    if (pVnode->dropped) toCommit = 0;
+
+    code = tsdbCloseRepo(pVnode->tsdb, toCommit);
     pVnode->tsdb = NULL;
   }
 

From 29746411b57a7949fbd46c631ed4fb4aa730b9e9 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 25 May 2021 22:19:27 +0800
Subject: [PATCH 088/128] [td-225] add log.

---
 src/client/src/tscSQLParser.c | 2 --
 src/client/src/tscServer.c    | 8 ++++----
 src/mnode/src/mnodeTable.c    | 4 ++--
 3 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index b020432a2e..c472b08dc0 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -6494,7 +6494,6 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
 
     size_t valSize = taosArrayGetSize(pValList);
 
-
     // too long tag values will return invalid sql, not be truncated automatically
     SSchema  *pTagSchema = tscGetTableTagSchema(pStableMetaInfo->pTableMeta);
     STagData *pTag = &pCreateTableInfo->tagdata;
@@ -6504,7 +6503,6 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
       return TSDB_CODE_TSC_OUT_OF_MEMORY;
     }
 
-
     SArray* pNameList = NULL;
     size_t nameSize = 0;
     int32_t schemaSize = tscGetNumOfTags(pStableMetaInfo->pTableMeta);
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 0e16369cad..648b95180e 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -2020,8 +2020,9 @@ int tscProcessTableMetaRsp(SSqlObj *pSql) {
     }
   }
 
-  tscDebug("0x%"PRIx64" recv table meta, uid:%" PRIu64 ", tid:%d, name:%s", pSql->self, pTableMeta->id.uid, pTableMeta->id.tid,
-           tNameGetTableName(&pTableMetaInfo->name));
+  tscDebug("0x%"PRIx64" recv table meta, uid:%" PRIu64 ", tid:%d, name:%s, numOfCols:%d, numOfTags:%d", pSql->self,
+      pTableMeta->id.uid, pTableMeta->id.tid, tNameGetTableName(&pTableMetaInfo->name), pTableMeta->tableInfo.numOfColumns,
+      pTableMeta->tableInfo.numOfTags);
 
   free(pTableMeta);
   return TSDB_CODE_SUCCESS;
@@ -2164,8 +2165,7 @@ int tscProcessSTableVgroupRsp(SSqlObj *pSql) {
 
     pInfo->vgroupList->numOfVgroups = pVgroupMsg->numOfVgroups;
     if (pInfo->vgroupList->numOfVgroups <= 0) {
-      //tfree(pInfo->vgroupList);
-      tscError("0x%"PRIx64" empty vgroup info", pSql->self);
+      tscDebug("0x%"PRIx64" empty vgroup info", pSql->self);
     } else {
       for (int32_t j = 0; j < pInfo->vgroupList->numOfVgroups; ++j) {
         // just init, no need to lock
diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index 2a8e941fcb..f098356e5c 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -1189,8 +1189,8 @@ static int32_t mnodeFindSuperTableTagIndex(SSTableObj *pStable, const char *tagN
 
 static int32_t mnodeAddSuperTableTagCb(SMnodeMsg *pMsg, int32_t code) {
   SSTableObj *pStable = (SSTableObj *)pMsg->pTable;
-  mLInfo("msg:%p, app:%p stable %s, add tag result:%s", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
-          tstrerror(code));
+  mLInfo("msg:%p, app:%p stable %s, add tag result:%s, numOfTags:%d", pMsg, pMsg->rpcMsg.ahandle, pStable->info.tableId,
+          tstrerror(code), pStable->numOfTags);
 
   return code;
 }

From 54fcf51600412793872aff3e149291921761ec67 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Tue, 25 May 2021 22:40:10 +0800
Subject: [PATCH 089/128] [td-225] fix compiler error.

---
 src/query/src/qPlan.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/query/src/qPlan.c b/src/query/src/qPlan.c
index 9176b4a06b..9079d830c9 100644
--- a/src/query/src/qPlan.c
+++ b/src/query/src/qPlan.c
@@ -101,7 +101,7 @@ static SQueryNode* createQueryNode(int32_t type, const char* name, SQueryNode**
 static SQueryNode* doAddTableColumnNode(SQueryInfo* pQueryInfo, STableMetaInfo* pTableMetaInfo, SQueryTableInfo* info,
                                         SArray* pExprs, SArray* tableCols) {
   if (pQueryInfo->onlyTagQuery) {
-    int32_t     num = taosArrayGetSize(pExprs);
+    int32_t     num = (int32_t) taosArrayGetSize(pExprs);
     SQueryNode* pNode = createQueryNode(QNODE_TAGSCAN, "TableTagScan", NULL, 0, pExprs->pData, num, info, NULL);
 
     if (pQueryInfo->distinctTag) {
@@ -115,11 +115,11 @@ static SQueryNode* doAddTableColumnNode(SQueryInfo* pQueryInfo, STableMetaInfo*
   SQueryNode*  pNode = createQueryNode(QNODE_TABLESCAN, "TableScan", NULL, 0, NULL, 0,
       info, window);
   if (pQueryInfo->projectionQuery) {
-    int32_t numOfOutput = taosArrayGetSize(pExprs);
+    int32_t numOfOutput = (int32_t) taosArrayGetSize(pExprs);
     pNode = createQueryNode(QNODE_PROJECT, "Projection", &pNode, 1, pExprs->pData, numOfOutput, info, NULL);
   } else {
     // table source column projection, generate the projection expr
-    int32_t     numOfCols = taosArrayGetSize(tableCols);
+    int32_t     numOfCols = (int32_t) taosArrayGetSize(tableCols);
     SExprInfo** pExpr = calloc(numOfCols, POINTER_BYTES);
     SSchema*    pSchema = pTableMetaInfo->pTableMeta->schema;
 
@@ -148,23 +148,23 @@ static SQueryNode* doCreateQueryPlanForOneTableImpl(SQueryInfo* pQueryInfo, SQue
     SArray* pExprs) {
     // check for aggregation
     if (pQueryInfo->interval.interval > 0) {
-      int32_t numOfOutput = taosArrayGetSize(pExprs);
+      int32_t numOfOutput = (int32_t) taosArrayGetSize(pExprs);
 
       pNode = createQueryNode(QNODE_TIMEWINDOW, "TimeWindowAgg", &pNode, 1, pExprs->pData, numOfOutput, info,
                               &pQueryInfo->interval);
     } else if (pQueryInfo->groupbyColumn) {
-      int32_t numOfOutput = taosArrayGetSize(pExprs);
+      int32_t numOfOutput = (int32_t) taosArrayGetSize(pExprs);
       pNode = createQueryNode(QNODE_GROUPBY, "Groupby", &pNode, 1, pExprs->pData, numOfOutput, info,
                               &pQueryInfo->groupbyExpr);
     } else if (pQueryInfo->sessionWindow.gap > 0) {
       pNode = createQueryNode(QNODE_SESSIONWINDOW, "SessionWindowAgg", &pNode, 1, NULL, 0, info, NULL);
     } else if (pQueryInfo->simpleAgg) {
-      int32_t numOfOutput = taosArrayGetSize(pExprs);
+      int32_t numOfOutput = (int32_t) taosArrayGetSize(pExprs);
       pNode = createQueryNode(QNODE_AGGREGATE, "Aggregate", &pNode, 1, pExprs->pData, numOfOutput, info, NULL);
     }
 
     if (pQueryInfo->havingFieldNum > 0 || pQueryInfo->arithmeticOnAgg) {
-      int32_t numOfExpr = taosArrayGetSize(pQueryInfo->exprList1);
+      int32_t numOfExpr = (int32_t) taosArrayGetSize(pQueryInfo->exprList1);
       pNode =
           createQueryNode(QNODE_PROJECT, "Projection", &pNode, 1, pQueryInfo->exprList1->pData, numOfExpr, info, NULL);
     }
@@ -249,7 +249,7 @@ SArray* createQueryPlanImpl(SQueryInfo* pQueryInfo) {
 
     // 3. add the join node here
     SQueryTableInfo info = {0};
-    int32_t num = taosArrayGetSize(pQueryInfo->exprList);
+    int32_t num = (int32_t) taosArrayGetSize(pQueryInfo->exprList);
     SQueryNode* pNode = createQueryNode(QNODE_JOIN, "Join", upstream->pData, pQueryInfo->numOfTables,
         pQueryInfo->exprList->pData, num, &info, NULL);
 
@@ -287,7 +287,7 @@ static void doDestroyQueryNode(SQueryNode* pQueryNode) {
   pQueryNode->pExpr = destroyQueryFuncExpr(pQueryNode->pExpr, pQueryNode->numOfOutput);
 
   if (pQueryNode->pPrevNodes != NULL) {
-    int32_t size = taosArrayGetSize(pQueryNode->pPrevNodes);
+    int32_t size = (int32_t) taosArrayGetSize(pQueryNode->pPrevNodes);
     for(int32_t i = 0; i < size; ++i) {
       SQueryNode* p = taosArrayGetP(pQueryNode->pPrevNodes, i);
       doDestroyQueryNode(p);

From 04d464bdc92d3d62acbca50f3babf94e19036f30 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Wed, 26 May 2021 09:34:45 +0800
Subject: [PATCH 090/128] Hotfix/sangshuduo/td 3783 taosdemo invalid rand
 string (#6228)

* [TD-3783]<fix>: taosdemo for windows generates rand string invalid.

* refactor disorder timestamp.

* refactor debug print.

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdemo/taosdemo.c | 125 +++++++++++++++++-------------------
 1 file changed, 58 insertions(+), 67 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index b162be7739..54dd68de44 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -538,6 +538,8 @@ static void createChildTables();
 static int queryDbExec(TAOS *taos, char *command, QUERY_TYPE type, bool quiet);
 static int postProceSql(char *host, struct sockaddr_in *pServAddr,
         uint16_t port, char* sqlstr, threadInfo *pThreadInfo);
+static int64_t getTSRandTail(int64_t timeStampStep, int32_t seq,
+                  int disorderRatio, int disorderRange);
 
 /* ************ Global variables ************  */
 
@@ -1097,9 +1099,9 @@ static int queryDbExec(TAOS *taos, char *command, QUERY_TYPE type, bool quiet) {
     }
   }
 
+  verbosePrint("%s() LN%d - command: %s\n", __func__, __LINE__, command);
   if (code != 0) {
     if (!quiet) {
-      debugPrint("%s() LN%d - command: %s\n", __func__, __LINE__, command);
       errorPrint("Failed to execute %s, reason: %s\n", command, taos_errstr(res));
     }
     taos_free_result(res);
@@ -2692,8 +2694,6 @@ static int createSuperTable(
   snprintf(command, BUFFER_SIZE,
           "create table if not exists %s.%s (ts timestamp%s) tags %s",
           dbName, superTbl->sTblName, cols, tags);
-  verbosePrint("%s() LN%d: %s\n", __func__, __LINE__, command);
-
   if (0 != queryDbExec(taos, command, NO_INSERT_TYPE, false)) {
       errorPrint( "create supertable %s failed!\n\n",
               superTbl->sTblName);
@@ -2716,7 +2716,6 @@ static int createDatabasesAndStables() {
   for (int i = 0; i < g_Dbs.dbCount; i++) {
     if (g_Dbs.db[i].drop) {
       sprintf(command, "drop database if exists %s;", g_Dbs.db[i].dbName);
-      verbosePrint("%s() %d command: %s\n", __func__, __LINE__, command);
       if (0 != queryDbExec(taos, command, NO_INSERT_TYPE, false)) {
         taos_close(taos);
         return -1;
@@ -2789,7 +2788,6 @@ static int createDatabasesAndStables() {
                 " precision \'%s\';", g_Dbs.db[i].dbCfg.precision);
       }
 
-      debugPrint("%s() %d command: %s\n", __func__, __LINE__, command);
       if (0 != queryDbExec(taos, command, NO_INSERT_TYPE, false)) {
         taos_close(taos);
         errorPrint( "\ncreate database %s failed!\n\n", g_Dbs.db[i].dbName);
@@ -2806,8 +2804,6 @@ static int createDatabasesAndStables() {
     for (int j = 0; j < g_Dbs.db[i].superTblCount; j++) {
       sprintf(command, "describe %s.%s;", g_Dbs.db[i].dbName,
               g_Dbs.db[i].superTbls[j].sTblName);
-      verbosePrint("%s() %d command: %s\n", __func__, __LINE__, command);
-
       ret = queryDbExec(taos, command, NO_INSERT_TYPE, true);
 
       if ((ret != 0) || (g_Dbs.db[i].drop)) {
@@ -2911,7 +2907,6 @@ static void* createTable(void *sarg)
     }
 
     len = 0;
-    verbosePrint("%s() LN%d %s\n", __func__, __LINE__, buffer);
     if (0 != queryDbExec(pThreadInfo->taos, buffer, NO_INSERT_TYPE, false)){
       errorPrint( "queryDbExec() failed. buffer:\n%s\n", buffer);
       free(buffer);
@@ -2927,7 +2922,6 @@ static void* createTable(void *sarg)
   }
 
   if (0 != len) {
-    verbosePrint("%s() %d buffer: %s\n", __func__, __LINE__, buffer);
     if (0 != queryDbExec(pThreadInfo->taos, buffer, NO_INSERT_TYPE, false)) {
       errorPrint( "queryDbExec() failed. buffer:\n%s\n", buffer);
     }
@@ -4877,6 +4871,14 @@ static int64_t generateDataTail(
 
   verbosePrint("%s() LN%d batch=%"PRIu64"\n", __func__, __LINE__, batch);
 
+  bool tsRand;
+  if ((superTblInfo) && (0 == strncasecmp(superTblInfo->dataSource,
+                  "rand", strlen("rand")))) {
+        tsRand = true;
+    } else {
+        tsRand = false;
+  }
+
   uint64_t k = 0;
   for (k = 0; k < batch;) {
     char data[MAX_DATA_SIZE];
@@ -4885,71 +4887,47 @@ static int64_t generateDataTail(
     int64_t retLen = 0;
 
     if (superTblInfo) {
-      if (0 == strncasecmp(superTblInfo->dataSource,
-                    "sample", strlen("sample"))) {
+        if (tsRand) {
+            retLen = generateRowData(
+                    data,
+                    startTime + getTSRandTail(
+                        superTblInfo->timeStampStep, k,
+                        superTblInfo->disorderRatio,
+                        superTblInfo->disorderRange),
+                    superTblInfo);
+        } else {
           retLen = getRowDataFromSample(
                     data,
                     remainderBufLen,
                     startTime + superTblInfo->timeStampStep * k,
                     superTblInfo,
                     pSamplePos);
-      } else if (0 == strncasecmp(superTblInfo->dataSource,
-                   "rand", strlen("rand"))) {
-
-        int64_t randTail = superTblInfo->timeStampStep * k;
-        if (superTblInfo->disorderRatio > 0) {
-          int rand_num = taosRandom() % 100;
-          if(rand_num < superTblInfo->disorderRatio) {
-            randTail = (randTail + (taosRandom() % superTblInfo->disorderRange + 1)) * (-1);
-            debugPrint("rand data generated, back %"PRId64"\n", randTail);
-          }
+        }
+        if (retLen > remainderBufLen) {
+            break;
         }
 
-        int64_t d = startTime
-                + randTail;
-        retLen = generateRowData(
-                      data,
-                      d,
-                      superTblInfo);
-      }
-
-      if (retLen > remainderBufLen) {
-        break;
-      }
-
-      pstr += snprintf(pstr , retLen + 1, "%s", data);
-      k++;
-      len += retLen;
-      remainderBufLen -= retLen;
+        pstr += snprintf(pstr , retLen + 1, "%s", data);
+        k++;
+        len += retLen;
+        remainderBufLen -= retLen;
     } else {
-      char **data_type = g_args.datatype;
-      int lenOfBinary = g_args.len_of_binary;
+        char **data_type = g_args.datatype;
+        int lenOfBinary = g_args.len_of_binary;
+        retLen = generateData(data, data_type,
+                ncols_per_record,
+                startTime + getTSRandTail(
+                    DEFAULT_TIMESTAMP_STEP, k,
+                    g_args.disorderRatio,
+                    g_args.disorderRange),
+                lenOfBinary);
+        if (len > remainderBufLen)
+            break;
 
-      int64_t randTail = DEFAULT_TIMESTAMP_STEP * k;
-
-      if (g_args.disorderRatio != 0) {
-        int rand_num = taosRandom() % 100;
-        if (rand_num < g_args.disorderRatio) {
-          randTail = (randTail + (taosRandom() % g_args.disorderRange + 1)) * (-1);
-
-          debugPrint("rand data generated, back %"PRId64"\n", randTail);
-        }
-      } else {
-        randTail = DEFAULT_TIMESTAMP_STEP * k;
-      }
-
-      retLen = generateData(data, data_type,
-                  ncols_per_record,
-                  startTime + randTail,
-                  lenOfBinary);
-
-      if (len > remainderBufLen)
-        break;
-
-      pstr += sprintf(pstr, "%s", data);
-      k++;
-      len += retLen;
-      remainderBufLen -= retLen;
+        pstr += sprintf(pstr, "%s", data);
+        k++;
+        len += retLen;
+        remainderBufLen -= retLen;
     }
 
     verbosePrint("%s() LN%d len=%"PRIu64" k=%"PRIu64" \nbuffer=%s\n",
@@ -5092,6 +5070,22 @@ static int64_t generateInterlaceDataBuffer(
   return k;
 }
 
+static int64_t getTSRandTail(int64_t timeStampStep, int32_t seq,
+          int disorderRatio, int disorderRange)
+{
+    int64_t randTail = timeStampStep * seq;
+    if (disorderRatio > 0) {
+        int rand_num = taosRandom() % 100;
+        if(rand_num < disorderRatio) {
+            randTail = (randTail +
+                    (taosRandom() % disorderRange + 1)) * (-1);
+            debugPrint("rand data generated, back %"PRId64"\n", randTail);
+        }
+    }
+
+    return randTail;
+}
+
 static int64_t generateProgressiveDataBuffer(
         char *tableName,
         int64_t tableSeq,
@@ -6445,7 +6439,6 @@ static int queryTestProcess() {
 
                 char sqlStr[MAX_TB_NAME_SIZE*2];
                 sprintf(sqlStr, "use %s", g_queryInfo.dbName);
-                verbosePrint("%s() %d sqlStr: %s\n", __func__, __LINE__, sqlStr);
                 if (0 != queryDbExec(taos, sqlStr, NO_INSERT_TYPE, false)) {
                     taos_close(taos);
                     free(infos);
@@ -6769,7 +6762,6 @@ static void *specifiedSubscribe(void *sarg) {
 
   char sqlStr[MAX_TB_NAME_SIZE*2];
   sprintf(sqlStr, "use %s", g_queryInfo.dbName);
-  debugPrint("%s() %d sqlStr: %s\n", __func__, __LINE__, sqlStr);
   if (0 != queryDbExec(pThreadInfo->taos, sqlStr, NO_INSERT_TYPE, false)) {
     taos_close(pThreadInfo->taos);
     return NULL;
@@ -7197,7 +7189,6 @@ static void querySqlFile(TAOS* taos, char* sqlFile)
     }
 
     memcpy(cmd + cmd_len, line, read_len);
-    verbosePrint("%s() LN%d cmd: %s\n", __func__, __LINE__, cmd);
     if (0 != queryDbExec(taos, cmd, NO_INSERT_TYPE, false)) {
         errorPrint("%s() LN%d, queryDbExec %s failed!\n",
                __func__, __LINE__, cmd);

From 2eb18e101c4a74d1cf0b508d75bbd0cf1d91d5b2 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Wed, 26 May 2021 10:05:09 +0800
Subject: [PATCH 091/128] [td-225] add test cases.

---
 src/client/src/tscSQLParser.c             |  1 -
 src/client/src/tscServer.c                |  2 ++
 src/client/src/tscUtil.c                  |  5 +++
 tests/script/general/parser/nestquery.sim | 39 ++++++++++++++++++++++-
 4 files changed, 45 insertions(+), 2 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index e33f9d6c22..d92cae4c92 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -7370,7 +7370,6 @@ static int32_t doValidateSubquery(SSqlNode* pSqlNode, int32_t index, SSqlObj* pS
   SSqlNode* p = taosArrayGetP(subInfo->pSubquery, 0);
 
   SQueryInfo* pSub = calloc(1, sizeof(SQueryInfo));
-  printf("-------------queryinfo:%p\n", pSub);
   tscInitQueryInfo(pSub);
 
   int32_t code = validateSqlNode(pSql, p, pSub);
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 513b85b2a6..9222dc5d57 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -1614,6 +1614,7 @@ int tscProcessRetrieveLocalMergeRsp(SSqlObj *pSql) {
     taosArrayPush(group, &tableKeyInfo);
     taosArrayPush(tableGroupInfo.pGroupList, &group);
 
+    // todo remove it
     SExprInfo* list = calloc(tscNumOfExprs(pQueryInfo), sizeof(SExprInfo));
     for(int32_t i = 0; i < tscNumOfExprs(pQueryInfo); ++i) {
       SExprInfo* pExprInfo = tscExprGet(pQueryInfo, i);
@@ -1621,6 +1622,7 @@ int tscProcessRetrieveLocalMergeRsp(SSqlObj *pSql) {
     }
 
     pQueryInfo->pQInfo = createQInfoFromQueryNode(pQueryInfo, list, &tableGroupInfo, NULL, NULL, pRes->pLocalMerger, MERGE_STAGE);
+    tfree(list);
   }
 
   uint64_t localQueryId = 0;
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 1b36e3cb00..0907961145 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -1010,6 +1010,11 @@ void handleDownstreamOperator(SSqlObj** pSqlObjList, int32_t numOfUpstream, SQue
 
       pSourceOperator = createJoinOperator(p, px->numOfTables, schema, num);
       tfree(p);
+    } else {
+      int32_t num = taosArrayGetSize(px->colList);
+
+      schema = calloc(num, sizeof(SSchema));
+      memcpy(schema, pSchema, numOfCol1*sizeof(SSchema));
     }
 
     SExprInfo* exprInfo = NULL;
diff --git a/tests/script/general/parser/nestquery.sim b/tests/script/general/parser/nestquery.sim
index 082457438f..d6fde199dc 100644
--- a/tests/script/general/parser/nestquery.sim
+++ b/tests/script/general/parser/nestquery.sim
@@ -61,6 +61,43 @@ sleep 100
 
 $i = 1
 $tb = $tbPrefix . $i
-sql select count(*) from (select
+
+print simple nest query test
+sql select count(*) from (select count(*) from nest_mt0))
+if $rows != 1 then
+ return -1
+endi
+
+if $data00 != 1 then
+  return -1
+endi
+
+sql select count(*) from (select count(*) from nest_mt0 group by tbname)
+if $rows != 1 then
+  return -1
+endi
+
+if $data00 != 10 then
+  return -1
+endi
+
+sql select count(*) from (select count(*) from nest_mt0 interval(10h) group by tbname)
+if $rows != 1 then
+  return -1
+endi
+
+if $data00 != 10 then
+  return -1
+endi
+
+print =================> alias name test
+sql select count(a) from (select count(*) a from nest_tb0 interval(1h))
+if $rows != 1 then
+  return -1
+endi
+
+if $data00 != 1 then
+   return -1
+endi
 
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
\ No newline at end of file

From a566615eb7d3d38cb08130ba671f900ba0b77db9 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Wed, 26 May 2021 10:28:58 +0800
Subject: [PATCH 092/128] TD-3279 TD-4328

---
 src/inc/taoserror.h       |  1 +
 src/mnode/src/mnodeSdb.c  | 10 +++++-----
 src/vnode/src/vnodeSync.c |  7 ++++++-
 3 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/src/inc/taoserror.h b/src/inc/taoserror.h
index ce6f7c4f22..936e9860dd 100644
--- a/src/inc/taoserror.h
+++ b/src/inc/taoserror.h
@@ -219,6 +219,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_VND_NO_WRITE_AUTH             TAOS_DEF_ERROR_CODE(0, 0x0512)  //"Database write operation denied")
 #define TSDB_CODE_VND_IS_SYNCING                TAOS_DEF_ERROR_CODE(0, 0x0513)  //"Database is syncing")
 #define TSDB_CODE_VND_INVALID_TSDB_STATE        TAOS_DEF_ERROR_CODE(0, 0x0514)  //"Invalid tsdb state")
+#define TSDB_CODE_VND_IS_CLOSING                TAOS_DEF_ERROR_CODE(0, 0x0515)   //"Database is closing")
 
 // tsdb
 #define TSDB_CODE_TDB_INVALID_TABLE_ID          TAOS_DEF_ERROR_CODE(0, 0x0600)  //"Invalid table ID")
diff --git a/src/mnode/src/mnodeSdb.c b/src/mnode/src/mnodeSdb.c
index 505d3c519c..cc088e3409 100644
--- a/src/mnode/src/mnodeSdb.c
+++ b/src/mnode/src/mnodeSdb.c
@@ -712,13 +712,13 @@ static int32_t sdbProcessWrite(void *wparam, void *hparam, int32_t qtype, void *
   if (action == SDB_ACTION_INSERT) {
     return sdbPerformInsertAction(pHead, pTable);
   } else if (action == SDB_ACTION_DELETE) {
-    if (qtype == TAOS_QTYPE_FWD) {
+    //if (qtype == TAOS_QTYPE_FWD) {
       // Drop database/stable may take a long time and cause a timeout, so we confirm first then reput it into queue
-      sdbWriteFwdToQueue(1, hparam, TAOS_QTYPE_QUERY, unused);
-      return TSDB_CODE_SUCCESS;
-    } else {
+    //  sdbWriteFwdToQueue(1, hparam, TAOS_QTYPE_QUERY, unused);
+    //  return TSDB_CODE_SUCCESS;
+    //} else {
       return sdbPerformDeleteAction(pHead, pTable);
-    }
+    //}
   } else if (action == SDB_ACTION_UPDATE) {
     return sdbPerformUpdateAction(pHead, pTable);
   } else {
diff --git a/src/vnode/src/vnodeSync.c b/src/vnode/src/vnodeSync.c
index e5a1964915..22c2dfffe6 100644
--- a/src/vnode/src/vnodeSync.c
+++ b/src/vnode/src/vnodeSync.c
@@ -126,11 +126,16 @@ void vnodeStopSyncFile(int32_t vgId, uint64_t fversion) {
 }
 
 void vnodeConfirmForard(int32_t vgId, void *wparam, int32_t code) {
-  void *pVnode = vnodeAcquire(vgId);
+  SVnodeObj *pVnode = vnodeAcquire(vgId);
   if (pVnode == NULL) {
     vError("vgId:%d, vnode not found while confirm forward", vgId);
   }
 
+  if (code == TSDB_CODE_SYN_CONFIRM_EXPIRED && pVnode->status == TAOS_VN_STATUS_CLOSING) {
+    vDebug("vgId:%d, db:%s, vnode is closing while confirm forward", vgId, pVnode->db);
+    code = TSDB_CODE_VND_IS_DROPPING;
+  }
+
   dnodeSendRpcVWriteRsp(pVnode, wparam, code);
   vnodeRelease(pVnode);
 }

From c96fb6b0f88f2a595e67bbc313be84e43ab6e709 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Wed, 26 May 2021 11:18:29 +0800
Subject: [PATCH 093/128] TD-4328

---
 src/inc/taoserror.h       | 2 +-
 src/vnode/src/vnodeSync.c | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/inc/taoserror.h b/src/inc/taoserror.h
index 936e9860dd..b3e5b59627 100644
--- a/src/inc/taoserror.h
+++ b/src/inc/taoserror.h
@@ -219,7 +219,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_VND_NO_WRITE_AUTH             TAOS_DEF_ERROR_CODE(0, 0x0512)  //"Database write operation denied")
 #define TSDB_CODE_VND_IS_SYNCING                TAOS_DEF_ERROR_CODE(0, 0x0513)  //"Database is syncing")
 #define TSDB_CODE_VND_INVALID_TSDB_STATE        TAOS_DEF_ERROR_CODE(0, 0x0514)  //"Invalid tsdb state")
-#define TSDB_CODE_VND_IS_CLOSING                TAOS_DEF_ERROR_CODE(0, 0x0515)   //"Database is closing")
+#define TSDB_CODE_VND_IS_CLOSING                TAOS_DEF_ERROR_CODE(0, 0x0515)  //"Database is closing")
 
 // tsdb
 #define TSDB_CODE_TDB_INVALID_TABLE_ID          TAOS_DEF_ERROR_CODE(0, 0x0600)  //"Invalid table ID")
diff --git a/src/vnode/src/vnodeSync.c b/src/vnode/src/vnodeSync.c
index 22c2dfffe6..4197428fec 100644
--- a/src/vnode/src/vnodeSync.c
+++ b/src/vnode/src/vnodeSync.c
@@ -133,7 +133,7 @@ void vnodeConfirmForard(int32_t vgId, void *wparam, int32_t code) {
 
   if (code == TSDB_CODE_SYN_CONFIRM_EXPIRED && pVnode->status == TAOS_VN_STATUS_CLOSING) {
     vDebug("vgId:%d, db:%s, vnode is closing while confirm forward", vgId, pVnode->db);
-    code = TSDB_CODE_VND_IS_DROPPING;
+    code = TSDB_CODE_VND_IS_CLOSING;
   }
 
   dnodeSendRpcVWriteRsp(pVnode, wparam, code);

From cadf32d312aeb5052664c645e2eb6369a33b1286 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Wed, 26 May 2021 12:14:42 +0800
Subject: [PATCH 094/128] refactor each query verbose print. (#6233)

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdemo/taosdemo.c | 17 +++--------------
 1 file changed, 3 insertions(+), 14 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index bae0476b17..d70ff9649b 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -1132,11 +1132,11 @@ static int queryDbExec(TAOS *taos, char *command, QUERY_TYPE type, bool quiet) {
     }
   }
 
+  verbosePrint("%s() LN%d - command: %s\n", __func__, __LINE__, command);
   if (code != 0) {
     if (!quiet) {
-      debugPrint("%s() LN%d - command: %s\n", __func__, __LINE__, command);
-      errorPrint("Failed to execute %s, command length: %d, reason: %s\n",
-              command, (int)strlen(command), taos_errstr(res));
+      errorPrint("Failed to execute %s, reason: %s\n",
+              command, taos_errstr(res));
     }
     taos_free_result(res);
     //taos_close(taos);
@@ -2732,8 +2732,6 @@ static int createSuperTable(
   snprintf(command, BUFFER_SIZE,
           "create table if not exists %s.%s (ts timestamp%s) tags %s",
           dbName, superTbl->sTblName, cols, tags);
-  verbosePrint("%s() LN%d: %s\n", __func__, __LINE__, command);
-
   if (0 != queryDbExec(taos, command, NO_INSERT_TYPE, false)) {
       errorPrint( "create supertable %s failed!\n\n",
               superTbl->sTblName);
@@ -2756,7 +2754,6 @@ static int createDatabasesAndStables() {
   for (int i = 0; i < g_Dbs.dbCount; i++) {
     if (g_Dbs.db[i].drop) {
       sprintf(command, "drop database if exists %s;", g_Dbs.db[i].dbName);
-      verbosePrint("%s() %d command: %s\n", __func__, __LINE__, command);
       if (0 != queryDbExec(taos, command, NO_INSERT_TYPE, false)) {
         taos_close(taos);
         return -1;
@@ -2829,7 +2826,6 @@ static int createDatabasesAndStables() {
                 " precision \'%s\';", g_Dbs.db[i].dbCfg.precision);
       }
 
-      debugPrint("%s() %d command: %s\n", __func__, __LINE__, command);
       if (0 != queryDbExec(taos, command, NO_INSERT_TYPE, false)) {
         taos_close(taos);
         errorPrint( "\ncreate database %s failed!\n\n", g_Dbs.db[i].dbName);
@@ -2846,8 +2842,6 @@ static int createDatabasesAndStables() {
     for (uint64_t j = 0; j < g_Dbs.db[i].superTblCount; j++) {
       sprintf(command, "describe %s.%s;", g_Dbs.db[i].dbName,
               g_Dbs.db[i].superTbls[j].sTblName);
-      verbosePrint("%s() %d command: %s\n", __func__, __LINE__, command);
-
       ret = queryDbExec(taos, command, NO_INSERT_TYPE, true);
 
       if ((ret != 0) || (g_Dbs.db[i].drop)) {
@@ -2951,7 +2945,6 @@ static void* createTable(void *sarg)
     }
 
     len = 0;
-    verbosePrint("%s() LN%d %s\n", __func__, __LINE__, buffer);
     if (0 != queryDbExec(pThreadInfo->taos, buffer, NO_INSERT_TYPE, false)){
       errorPrint( "queryDbExec() failed. buffer:\n%s\n", buffer);
       free(buffer);
@@ -2967,7 +2960,6 @@ static void* createTable(void *sarg)
   }
 
   if (0 != len) {
-    verbosePrint("%s() %d buffer: %s\n", __func__, __LINE__, buffer);
     if (0 != queryDbExec(pThreadInfo->taos, buffer, NO_INSERT_TYPE, false)) {
       errorPrint( "queryDbExec() failed. buffer:\n%s\n", buffer);
     }
@@ -6700,7 +6692,6 @@ static int queryTestProcess() {
 
                 char sqlStr[MAX_TB_NAME_SIZE*2];
                 sprintf(sqlStr, "use %s", g_queryInfo.dbName);
-                verbosePrint("%s() %d sqlStr: %s\n", __func__, __LINE__, sqlStr);
                 if (0 != queryDbExec(taos, sqlStr, NO_INSERT_TYPE, false)) {
                     taos_close(taos);
                     free(infos);
@@ -7024,7 +7015,6 @@ static void *specifiedSubscribe(void *sarg) {
 
   char sqlStr[MAX_TB_NAME_SIZE*2];
   sprintf(sqlStr, "use %s", g_queryInfo.dbName);
-  debugPrint("%s() %d sqlStr: %s\n", __func__, __LINE__, sqlStr);
   if (0 != queryDbExec(pThreadInfo->taos, sqlStr, NO_INSERT_TYPE, false)) {
     taos_close(pThreadInfo->taos);
     return NULL;
@@ -7452,7 +7442,6 @@ static void querySqlFile(TAOS* taos, char* sqlFile)
     }
 
     memcpy(cmd + cmd_len, line, read_len);
-    verbosePrint("%s() LN%d cmd: %s\n", __func__, __LINE__, cmd);
     if (0 != queryDbExec(taos, cmd, NO_INSERT_TYPE, false)) {
         errorPrint("%s() LN%d, queryDbExec %s failed!\n",
                __func__, __LINE__, cmd);

From d21beef464acd9db12516f7be93c3b53b1ae2c57 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Wed, 26 May 2021 13:36:49 +0800
Subject: [PATCH 095/128] [td-4351]<fix>: suppress error msg if super table is
 missing.

---
 src/client/src/tscSQLParser.c | 19 +++++++++----------
 src/client/src/tscServer.c    |  1 +
 src/inc/taosmsg.h             |  2 ++
 src/mnode/src/mnodeTable.c    |  5 +++++
 4 files changed, 17 insertions(+), 10 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index d92cae4c92..3f7a681e4e 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -315,7 +315,6 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     case TSDB_SQL_DROP_DB: {
       const char* msg2 = "invalid name";
       const char* msg3 = "param name too long";
-      const char* msg4 = "table is not super table";
 
       SStrToken* pzName = taosArrayGet(pInfo->pMiscInfo->a, 0);
       if ((pInfo->type != TSDB_SQL_DROP_DNODE) && (tscValidateName(pzName) != TSDB_CODE_SUCCESS)) {
@@ -338,14 +337,14 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
         }
 
         if (pInfo->pMiscInfo->tableType == TSDB_SUPER_TABLE) {
-          code = tscGetTableMeta(pSql, pTableMetaInfo);
-          if (code != TSDB_CODE_SUCCESS) {
-            return code;
-          }
-
-          if (!UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
-            return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
-          }
+////          code = tscGetTableMeta(pSql, pTableMetaInfo);
+////          if (code != TSDB_CODE_SUCCESS) {
+////            return code;
+////          }
+//
+//          if (!UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
+//            return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+//          }
         }
         
       } else if (pInfo->type == TSDB_SQL_DROP_DNODE) {
@@ -7219,7 +7218,7 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
     if (pTableMeta->id.uid > 0) {
       if (pTableMeta->tableType == TSDB_CHILD_TABLE) {
-        code = tscCreateTableMetaFromCChildMeta(pTableMeta, name, buf);
+        code = tscCreateTableMetaFromSTableMeta(pTableMeta, name, buf);
 
         // create the child table meta from super table failed, try load it from mnode
         if (code != TSDB_CODE_SUCCESS) {
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 898975b30f..0905f10308 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -1177,6 +1177,7 @@ int32_t tscBuildDropTableMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   STableMetaInfo *pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
   tNameExtractFullName(&pTableMetaInfo->name, pDropTableMsg->name);
 
+  pDropTableMsg->supertable = (pInfo->pMiscInfo->tableType == TSDB_SUPER_TABLE)? 1:0;
   pDropTableMsg->igNotExists = pInfo->pMiscInfo->existsCheck ? 1 : 0;
   pCmd->msgType = TSDB_MSG_TYPE_CM_DROP_TABLE;
   return TSDB_CODE_SUCCESS;
diff --git a/src/inc/taosmsg.h b/src/inc/taosmsg.h
index cc45774b15..ff3cc6e956 100644
--- a/src/inc/taosmsg.h
+++ b/src/inc/taosmsg.h
@@ -294,6 +294,8 @@ typedef struct {
 
 typedef struct {
   char   name[TSDB_TABLE_FNAME_LEN];
+  // if user specify DROP STABLE, this flag will be set. And an error will be returned if it is not a super table
+  int8_t supertable;
   int8_t igNotExists;
 } SCMDropTableMsg;
 
diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index 6cc3b8b7b1..25d14607f6 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -966,6 +966,11 @@ static int32_t mnodeProcessDropTableMsg(SMnodeMsg *pMsg) {
           pMsg->rpcMsg.ahandle, pDrop->name, pSTable->uid, pSTable->numOfTables, taosHashGetSize(pSTable->vgHash));
     return mnodeProcessDropSuperTableMsg(pMsg);
   } else {
+    // user specify the "DROP STABLE" sql statement, but it is actually a normal table, return error msg.
+    if (pDrop->supertable) {
+      return TSDB_CODE_MND_INVALID_TABLE_TYPE;
+    }
+
     SCTableObj *pCTable = (SCTableObj *)pMsg->pTable;
     mInfo("msg:%p, app:%p table:%s, start to drop ctable, vgId:%d tid:%d uid:%" PRIu64, pMsg, pMsg->rpcMsg.ahandle,
           pDrop->name, pCTable->vgId, pCTable->tid, pCTable->uid);

From 89fd502625adf7b6af1779c9ee341d2116854e69 Mon Sep 17 00:00:00 2001
From: Elias Soong <elias.soong@gmail.com>
Date: Wed, 26 May 2021 13:51:06 +0800
Subject: [PATCH 096/128] [TD-3948] <docs>: column names can be away from table
 name in insert.

---
 documentation20/cn/12.taos-sql/docs.md | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/documentation20/cn/12.taos-sql/docs.md b/documentation20/cn/12.taos-sql/docs.md
index bcf80d8fa2..186287515f 100644
--- a/documentation20/cn/12.taos-sql/docs.md
+++ b/documentation20/cn/12.taos-sql/docs.md
@@ -399,7 +399,12 @@ TDengine 缺省的时间戳是毫秒精度，但通过修改配置参数 enableM
     INSERT INTO tb1_name (tb1_field1_name, ...) [USING stb1_name TAGS (tag_value1, ...)] VALUES (field1_value1, ...) (field1_value2, ...) ...
                 tb2_name (tb2_field1_name, ...) [USING stb2_name TAGS (tag_value2, ...)] VALUES (field1_value1, ...) (field1_value2, ...) ...;
     ```
-    以自动建表的方式，同时向表tb1_name和tb2_name中按列分别插入多条记录。
+    以自动建表的方式，同时向表tb1_name和tb2_name中按列分别插入多条记录。  
+    从 2.0.20.5 版本开始，子表的列名可以不跟在子表名称后面，而是可以放在 TAGS 和 VALUES 之间，例如像下面这样写：
+    ```mysql
+    INSERT INTO tb1_name [USING stb1_name TAGS (tag_value1, ...)] (tb1_field1_name, ...) VALUES (field1_value1, ...) (field1_value2, ...) ...;
+    ```
+    注意：虽然两种写法都可以，但并不能在一条 SQL 语句中混用，否则会报语法错误。
 
 **历史记录写入**：可使用IMPORT或者INSERT命令，IMPORT的语法，功能与INSERT完全一样。
 

From 9673cfb742453a195cdbb10d54806d39eb34ee92 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Wed, 26 May 2021 14:09:25 +0800
Subject: [PATCH 097/128] [td-225] fix compiler error.

---
 src/client/src/tscSQLParser.c | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 3f7a681e4e..cfa8e386e6 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -7101,9 +7101,9 @@ int32_t validateHavingClause(SQueryInfo* pQueryInfo, tSqlExpr* pExpr, SSqlCmd* p
 }
 
 static int32_t getTableNameFromSqlNode(SSqlNode* pSqlNode, SArray* tableNameList, char* msgBuf, SSqlObj* pSql) {
-  const char* msg1 = "";
+  const char* msg1 = "invalid table name";
 
-  int32_t numOfTables = taosArrayGetSize(pSqlNode->from->list);
+  int32_t numOfTables = (int32_t) taosArrayGetSize(pSqlNode->from->list);
   assert(pSqlNode->from->type == SQL_NODE_FROM_TABLELIST);
 
   for(int32_t j = 0; j < numOfTables; ++j) {
@@ -7175,7 +7175,7 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   pCmd->pTableMetaMap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
 
   tableNameList = taosArrayInit(4, sizeof(SName));
-  int32_t size = taosArrayGetSize(pInfo->list);
+  size_t size = taosArrayGetSize(pInfo->list);
   for (int32_t i = 0; i < size; ++i) {
     SSqlNode* pSqlNode = taosArrayGetP(pInfo->list, i);
     if (pSqlNode->from == NULL) {
@@ -7199,8 +7199,6 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   uint32_t maxSize = tscGetTableMetaMaxSize();
   char     name[TSDB_TABLE_FNAME_LEN] = {0};
 
-  int32_t numOfTables = taosArrayGetSize(tableNameList);
-
   char buf[80 * 1024] = {0};
   assert(maxSize < 80 * 1024);
   pTableMeta = calloc(1, maxSize);
@@ -7208,6 +7206,7 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   plist = taosArrayInit(4, POINTER_BYTES);
   pVgroupList = taosArrayInit(4, POINTER_BYTES);
 
+  size_t numOfTables = taosArrayGetSize(tableNameList);
   for (int32_t i = 0; i < numOfTables; ++i) {
     SName* pname = taosArrayGet(tableNameList, i);
     tNameExtractFullName(pname, name);
@@ -7408,7 +7407,7 @@ static int32_t doValidateSubquery(SSqlNode* pSqlNode, int32_t index, SSqlObj* pS
 
   // all columns are added into the table column list
   STableMeta* pMeta = pTableMetaInfo1->pTableMeta;
-  int32_t startOffset = taosArrayGetSize(pQueryInfo->colList);
+  int32_t startOffset = (int32_t) taosArrayGetSize(pQueryInfo->colList);
 
   for(int32_t i = 0; i < pMeta->tableInfo.numOfColumns; ++i) {
     tscColumnListInsert(pQueryInfo->colList, i + startOffset, pMeta->id.uid, &pMeta->schema[i]);

From 649669ec441f1e07aea609b2e8b6f0a352f237af Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Wed, 26 May 2021 14:13:44 +0800
Subject: [PATCH 098/128] [td-225] fix compiler error.

---
 src/client/src/tscServer.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 0905f10308..599445a8f1 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -1998,7 +1998,7 @@ int tscProcessMultiTableMetaRsp(SSqlObj *pSql) {
     tNameFromString(&sn, pMetaMsg->tableFname, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
 
     const char* tableName = tNameGetTableName(&sn);
-    int32_t keyLen = strlen(tableName);
+    size_t keyLen = strlen(tableName);
 
     STableMetaVgroupInfo p = {.pTableMeta = pTableMeta,};
     taosHashPut(pParentCmd->pTableMetaMap, tableName, keyLen, &p, sizeof(STableMetaVgroupInfo));
@@ -2455,7 +2455,7 @@ int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVg
     start += len;
   }
 
-  pNew->cmd.payloadLen = (start - pInfo->tableNames) + sizeof(SMultiTableInfoMsg);
+  pNew->cmd.payloadLen = (int32_t) ((start - pInfo->tableNames) + sizeof(SMultiTableInfoMsg));
   pNew->cmd.msgType = TSDB_MSG_TYPE_CM_TABLES_META;
 
   registerSqlObj(pNew);

From 7fa9ecbd474c2b822cf33d1761aebba32b000d0e Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Wed, 26 May 2021 14:22:28 +0800
Subject: [PATCH 099/128] [td-225]fix compiler error.

---
 src/client/src/tscUtil.c | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index ff7c3aad0e..56de90ef92 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -909,7 +909,7 @@ SOperatorInfo* createJoinOperator(SOperatorInfo** pUpstream, int32_t numOfUpstre
 
   SRspResultInfo* pResInfo = &pInfo->resultInfo;
   pResInfo->capacity  = 4096;
-  pResInfo->threshold = 4096 * 0.8;
+  pResInfo->threshold = (int32_t) (4096 * 0.8);
 
   pInfo->pRes = calloc(1, sizeof(SSDataBlock));
   pInfo->pRes->info.numOfCols = numOfOutput;
@@ -992,7 +992,7 @@ void handleDownstreamOperator(SSqlObj** pSqlObjList, int32_t numOfUpstream, SQue
       SOperatorInfo** p = calloc(px->numOfTables, POINTER_BYTES);
       p[0] = pSourceOperator;
 
-      int32_t num = taosArrayGetSize(px->colList);
+      int32_t num = (int32_t) taosArrayGetSize(px->colList);
       schema = calloc(num, sizeof(SSchema));
       memcpy(schema, pSchema, numOfCol1*sizeof(SSchema));
 
@@ -1011,8 +1011,7 @@ void handleDownstreamOperator(SSqlObj** pSqlObjList, int32_t numOfUpstream, SQue
       pSourceOperator = createJoinOperator(p, px->numOfTables, schema, num);
       tfree(p);
     } else {
-      int32_t num = taosArrayGetSize(px->colList);
-
+      size_t num = taosArrayGetSize(px->colList);
       schema = calloc(num, sizeof(SSchema));
       memcpy(schema, pSchema, numOfCol1*sizeof(SSchema));
     }
@@ -1080,7 +1079,7 @@ void tscFreeQueryInfo(SSqlCmd* pCmd, bool removeMeta) {
   while(pQueryInfo != NULL) {
     SQueryInfo* p = pQueryInfo->sibling;
 
-    int32_t numOfUpstream = taosArrayGetSize(pQueryInfo->pUpstream);
+    size_t numOfUpstream = taosArrayGetSize(pQueryInfo->pUpstream);
     for(int32_t i = 0; i < numOfUpstream; ++i) {
       SQueryInfo* pUpQueryInfo = taosArrayGetP(pQueryInfo->pUpstream, i);
       freeQueryInfoImpl(pUpQueryInfo);
@@ -3353,7 +3352,7 @@ void executeQuery(SSqlObj* pSql, SQueryInfo* pQueryInfo) {
   }
 
   if (taosArrayGetSize(pQueryInfo->pUpstream) > 0) {  // nest query. do execute it firstly
-    pSql->subState.numOfSub = taosArrayGetSize(pQueryInfo->pUpstream);
+    pSql->subState.numOfSub = (int32_t) taosArrayGetSize(pQueryInfo->pUpstream);
 
     pSql->pSubs = calloc(pSql->subState.numOfSub, POINTER_BYTES);
     pSql->subState.states = calloc(pSql->subState.numOfSub, sizeof(int8_t));

From 40910f6b6736763a98c3294fd83ea69ce88f3787 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Wed, 26 May 2021 14:25:50 +0800
Subject: [PATCH 100/128] Feature/sangshuduo/td 4068 taosdemo stmt (#6237)

* merge with develop branch.

change query/tests/CMakeLists.txt to allow unused function and variable.

* refactor data generating.

* refactor.

* refactor.

* refactor.

* refactor.

* refactor

* add prepare stmt function.

* refactor get rand timestamp.

* fix windows compile error.

* copy logic of generate data for stmt.

* insert data basically works now.

* fix windows compile issue.

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdemo/taosdemo.c | 269 ++++++++++++++++++++++++++++--------
 1 file changed, 209 insertions(+), 60 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index d70ff9649b..b33e436aef 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -929,6 +929,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
                 && strcasecmp(argv[i], "BIGINT")
                 && strcasecmp(argv[i], "DOUBLE")
                 && strcasecmp(argv[i], "BINARY")
+                && strcasecmp(argv[i], "TIMESTAMP")
                 && strcasecmp(argv[i], "NCHAR")) {
           printHelp();
           errorPrint("%s", "-b: Invalid data_type!\n");
@@ -950,6 +951,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
                   && strcasecmp(token, "BIGINT")
                   && strcasecmp(token, "DOUBLE")
                   && strcasecmp(token, "BINARY")
+                  && strcasecmp(token, "TIMESTAMP")
                   && strcasecmp(token, "NCHAR")) {
             printHelp();
             free(g_dupstr);
@@ -2970,7 +2972,7 @@ static void* createTable(void *sarg)
 }
 
 static int startMultiThreadCreateChildTable(
-        char* cols, int threads, uint64_t startFrom, int64_t ntables,
+        char* cols, int threads, uint64_t tableFrom, int64_t ntables,
         char* db_name, SSuperTable* superTblInfo) {
 
   pthread_t *pids = malloc(threads * sizeof(pthread_t));
@@ -3014,10 +3016,10 @@ static int startMultiThreadCreateChildTable(
       return -1;
     }
 
-    pThreadInfo->start_table_from = startFrom;
+    pThreadInfo->start_table_from = tableFrom;
     pThreadInfo->ntables = i<b?a+1:a;
-    pThreadInfo->end_table_to = i < b ? startFrom + a : startFrom + a - 1;
-    startFrom = pThreadInfo->end_table_to + 1;
+    pThreadInfo->end_table_to = i < b ? tableFrom + a : tableFrom + a - 1;
+    tableFrom = pThreadInfo->end_table_to + 1;
     pThreadInfo->use_metric = true;
     pThreadInfo->cols = cols;
     pThreadInfo->minDelay = UINT64_MAX;
@@ -3055,15 +3057,15 @@ static void createChildTables() {
 
           verbosePrint("%s() LN%d: %s\n", __func__, __LINE__,
                   g_Dbs.db[i].superTbls[j].colsOfCreateChildTable);
-          uint64_t startFrom = 0;
+          uint64_t tableFrom = 0;
           g_totalChildTables += g_Dbs.db[i].superTbls[j].childTblCount;
 
           verbosePrint("%s() LN%d: create %"PRId64" child tables from %"PRIu64"\n",
-                  __func__, __LINE__, g_totalChildTables, startFrom);
+                  __func__, __LINE__, g_totalChildTables, tableFrom);
           startMultiThreadCreateChildTable(
                 g_Dbs.db[i].superTbls[j].colsOfCreateChildTable,
                 g_Dbs.threadCountByCreateTbl,
-                startFrom,
+                tableFrom,
                 g_Dbs.db[i].superTbls[j].childTblCount,
                 g_Dbs.db[i].dbName, &(g_Dbs.db[i].superTbls[j]));
         }
@@ -4691,8 +4693,8 @@ static int getRowDataFromSample(
 
 static int64_t generateStbRowData(
         SSuperTable* stbInfo,
-        char* recBuf, int64_t timestamp
-        ) {
+        char* recBuf, int64_t timestamp)
+{
   int64_t   dataLen = 0;
   char  *pstr = recBuf;
   int64_t maxLen = MAX_DATA_SIZE;
@@ -4720,23 +4722,23 @@ static int64_t generateStbRowData(
       dataLen += snprintf(pstr + dataLen, maxLen - dataLen, "\'%s\',", buf);
       tmfree(buf);
     } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-                "INT", 3)) {
+                "INT", strlen("INT"))) {
       dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
               "%d,", rand_int());
     } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-                "BIGINT", 6)) {
+                "BIGINT", strlen("BIGINT"))) {
       dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
               "%"PRId64",", rand_bigint());
     }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-                "FLOAT", 5)) {
+                "FLOAT", strlen("FLOAT"))) {
       dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
               "%f,", rand_float());
     }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-                "DOUBLE", 6)) {
+                "DOUBLE", strlen("DOUBLE"))) {
       dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
               "%f,", rand_double());
     }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-                "SMALLINT", 8)) {
+                "SMALLINT", strlen("SMALLINT"))) {
       dataLen += snprintf(pstr + dataLen, maxLen - dataLen,
           "%d,", rand_smallint());
     }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
@@ -4792,6 +4794,8 @@ static int64_t generateData(char *recBuf, char **data_type,
       pstr += sprintf(pstr, ",%d", rand_int());
     } else if (strcasecmp(data_type[i % c], "BIGINT") == 0) {
       pstr += sprintf(pstr, ",%" PRId64, rand_bigint());
+    } else if (strcasecmp(data_type[i % c], "TIMESTAMP") == 0) {
+      pstr += sprintf(pstr, ",%" PRId64, rand_bigint());
     } else if (strcasecmp(data_type[i % c], "FLOAT") == 0) {
       pstr += sprintf(pstr, ",%10.4f", rand_float());
     } else if (strcasecmp(data_type[i % c], "DOUBLE") == 0) {
@@ -4922,7 +4926,7 @@ static void getTableName(char *pTblName,
 static int64_t generateDataTailWithoutStb(
         uint32_t batch, char* buffer,
         int64_t remainderBufLen, int64_t insertRows,
-        uint64_t startFrom, int64_t startTime,
+        uint64_t recordFrom, int64_t startTime,
         /* int64_t *pSamplePos, */int64_t *dataLen) {
 
   uint64_t len = 0;
@@ -4958,9 +4962,9 @@ static int64_t generateDataTailWithoutStb(
     verbosePrint("%s() LN%d len=%"PRIu64" k=%"PRIu64" \nbuffer=%s\n",
             __func__, __LINE__, len, k, buffer);
 
-    startFrom ++;
+    recordFrom ++;
 
-    if (startFrom >= insertRows) {
+    if (recordFrom >= insertRows) {
       break;
     }
   }
@@ -4989,7 +4993,7 @@ static int32_t generateStbDataTail(
         SSuperTable* superTblInfo,
         uint32_t batch, char* buffer,
         int64_t remainderBufLen, int64_t insertRows,
-        uint64_t startFrom, int64_t startTime,
+        uint64_t recordFrom, int64_t startTime,
         int64_t *pSamplePos, int64_t *dataLen) {
   uint64_t len = 0;
 
@@ -5038,9 +5042,9 @@ static int32_t generateStbDataTail(
     verbosePrint("%s() LN%d len=%"PRIu64" k=%ud \nbuffer=%s\n",
             __func__, __LINE__, len, k, buffer);
 
-    startFrom ++;
+    recordFrom ++;
 
-    if (startFrom >= insertRows) {
+    if (recordFrom >= insertRows) {
       break;
     }
   }
@@ -5237,6 +5241,7 @@ static int64_t generateInterlaceDataWithoutStb(
 static int32_t prepareStbStmt(SSuperTable *stbInfo,
         TAOS_STMT *stmt,
         char *tableName, uint32_t batch, uint64_t insertRows,
+        uint64_t recordFrom,
         int64_t startTime, char *buffer)
 {
     uint32_t k;
@@ -5256,7 +5261,7 @@ static int32_t prepareStbStmt(SSuperTable *stbInfo,
         return ret;
     }
 
-    void *bindArray = malloc(sizeof(TAOS_BIND) * (stbInfo->columnCount + 1));
+    char *bindArray = malloc(sizeof(TAOS_BIND) * (stbInfo->columnCount + 1));
     if (bindArray == NULL) {
         errorPrint("Failed to allocate %d bind params\n", batch);
         return -1;
@@ -5268,32 +5273,176 @@ static int32_t prepareStbStmt(SSuperTable *stbInfo,
     } else {
         tsRand = false;
     }
-    for (k = 0; k < batch; k++) {
+    for (k = 0; k < batch;) {
         /* columnCount + 1 (ts) */
-        for (int i = 0; i <= stbInfo->columnCount; i ++) {
-            TAOS_BIND *bind = (TAOS_BIND *)bindArray + (sizeof(TAOS_BIND) * i);
-            if (i == 0) {
-                bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
-                int64_t ts;
-                if (tsRand) {
-                    ts = startTime + getTSRandTail(
-                            stbInfo->timeStampStep, k,
-                            stbInfo->disorderRatio,
-                            stbInfo->disorderRange);
-                } else {
-                    ts = startTime + stbInfo->timeStampStep * k;
-                }
-                bind->buffer = &ts;
-                
-            } else {
+        char data[MAX_DATA_SIZE];
+        memset(data, 0, MAX_DATA_SIZE);
 
+        char *ptr = data;
+        TAOS_BIND *bind = (TAOS_BIND *)(bindArray + 0);
+
+        int64_t *bind_ts;
+
+        bind_ts = (int64_t *)ptr;
+        bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
+        if (tsRand) {
+            *bind_ts = startTime + getTSRandTail(
+                    stbInfo->timeStampStep, k,
+                    stbInfo->disorderRatio,
+                    stbInfo->disorderRange);
+        } else {
+            *bind_ts = startTime + stbInfo->timeStampStep * k;
+        }
+        bind->buffer_length = sizeof(int64_t);
+        bind->buffer = bind_ts;
+        bind->length = &bind->buffer_length;
+        bind->is_null = NULL;
+
+        ptr += bind->buffer_length;
+
+        for (int i = 0; i < stbInfo->columnCount; i ++) {
+            bind = (TAOS_BIND *)((char *)bindArray + (sizeof(TAOS_BIND) * (i + 1)));
+            if (0 == strncasecmp(stbInfo->columns[i].dataType,
+                        "BINARY", strlen("BINARY"))) {
+                if (stbInfo->columns[i].dataLen > TSDB_MAX_BINARY_LEN) {
+                    errorPrint( "binary length overflow, max size:%u\n",
+                            (uint32_t)TSDB_MAX_BINARY_LEN);
+                    return -1;
+                }
+                char *bind_binary = (char *)ptr;
+                rand_string(bind_binary, stbInfo->columns[i].dataLen);
+
+                bind->buffer_type = TSDB_DATA_TYPE_BINARY;
+                bind->buffer_length = stbInfo->columns[i].dataLen;
+                bind->buffer = bind_binary;
+                bind->length = &bind->buffer_length;
+                bind->is_null = NULL;
+
+                ptr += bind->buffer_length;
+            } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
+                        "NCHAR", strlen("NCHAR"))) {
+                if (stbInfo->columns[i].dataLen > TSDB_MAX_BINARY_LEN) {
+                    errorPrint( "nchar length overflow, max size:%u\n",
+                            (uint32_t)TSDB_MAX_BINARY_LEN);
+                    return -1;
+                }
+                char *bind_nchar = (char *)ptr;
+                rand_string(bind_nchar, stbInfo->columns[i].dataLen);
+
+                bind->buffer_type = TSDB_DATA_TYPE_NCHAR;
+                bind->buffer_length = strlen(bind_nchar);
+                bind->buffer = bind_nchar;
+                bind->length = &bind->buffer_length;
+                bind->is_null = NULL;
+
+                ptr += bind->buffer_length;
+            } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
+                        "INT", strlen("INT"))) {
+                int32_t *bind_int = (int32_t *)ptr;
+
+                *bind_int = rand_int();
+                bind->buffer_type = TSDB_DATA_TYPE_INT;
+                bind->buffer_length = sizeof(int32_t);
+                bind->buffer = bind_int;
+                bind->length = &bind->buffer_length;
+                bind->is_null = NULL;
+
+                ptr += bind->buffer_length;
+            } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
+                            "BIGINT", strlen("BIGINT"))) {
+                int64_t *bind_bigint = (int64_t *)ptr;
+
+                *bind_bigint = rand_bigint();
+                bind->buffer_type = TSDB_DATA_TYPE_BIGINT;
+                bind->buffer_length = sizeof(int64_t);
+                bind->buffer = bind_bigint;
+                bind->length = &bind->buffer_length;
+                bind->is_null = NULL;
+                ptr += bind->buffer_length;
+            }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
+                            "FLOAT", strlen("FLOAT"))) {
+                float   *bind_float = (float *)ptr;
+
+                *bind_float = rand_float();
+                bind->buffer_type = TSDB_DATA_TYPE_FLOAT;
+                bind->buffer_length = sizeof(float);
+                bind->buffer = bind_float;
+                bind->length = &bind->buffer_length;
+                bind->is_null = NULL;
+                ptr += bind->buffer_length;
+            }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
+                            "DOUBLE", strlen("DOUBLE"))) {
+                double  *bind_double = (double *)ptr;
+
+                *bind_double = rand_double();
+                bind->buffer_type = TSDB_DATA_TYPE_DOUBLE;
+                bind->buffer_length = sizeof(double);
+                bind->buffer = bind_double;
+                bind->length = &bind->buffer_length;
+                bind->is_null = NULL;
+                ptr += bind->buffer_length;
+            }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
+                            "SMALLINT", strlen("SMALLINT"))) {
+                int16_t *bind_smallint = (int16_t *)ptr;
+
+                *bind_smallint = rand_smallint();
+                bind->buffer_type = TSDB_DATA_TYPE_SMALLINT;
+                bind->buffer_length = sizeof(int16_t);
+                bind->buffer = bind_smallint;
+                bind->length = &bind->buffer_length;
+                bind->is_null = NULL;
+                ptr += bind->buffer_length;
+            }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
+                            "TINYINT", strlen("TINYINT"))) {
+                int8_t  *bind_tinyint = (int8_t *)ptr;
+
+                *bind_tinyint = rand_tinyint();
+                bind->buffer_type = TSDB_DATA_TYPE_TINYINT;
+                bind->buffer_length = sizeof(int8_t);
+                bind->buffer = bind_tinyint;
+                bind->length = &bind->buffer_length;
+                bind->is_null = NULL;
+                ptr += bind->buffer_length;
+            }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
+                            "BOOL", strlen("BOOL"))) {
+                int8_t  *bind_bool = (int8_t *)ptr;
+
+                *bind_bool = rand_bool();
+                bind->buffer_type = TSDB_DATA_TYPE_BOOL;
+                bind->buffer_length = sizeof(int8_t);
+                bind->buffer = bind_bool;
+                bind->length = &bind->buffer_length;
+                bind->is_null = NULL;
+
+                ptr += bind->buffer_length;
+            }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
+                            "TIMESTAMP", strlen("TIMESTAMP"))) {
+                int64_t *bind_ts2 = (int64_t *)ptr;
+
+                *bind_ts2 = rand_bigint();
+                bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
+                bind->buffer_length = sizeof(int64_t);
+                bind->buffer = bind_ts2;
+                bind->length = &bind->buffer_length;
+                bind->is_null = NULL;
+
+                ptr += bind->buffer_length;
+            }  else {
+                    errorPrint( "No support data type: %s\n",
+                            stbInfo->columns[i].dataType);
+                    return -1;
             }
         }
+        taos_stmt_bind_param(stmt, (TAOS_BIND *)bindArray);
         // if msg > 3MB, break
-    }
+        taos_stmt_add_batch(stmt);
 
-    taos_stmt_bind_param(stmt, bindArray);
-    taos_stmt_add_batch(stmt);
+        k++;
+        recordFrom ++;
+        if (recordFrom >= insertRows) {
+            break;
+        }
+    }
 
     return k;
 }
@@ -5304,7 +5453,7 @@ static int32_t generateStbProgressiveData(
         int64_t tableSeq,
         char *dbName, char *buffer,
         int64_t insertRows,
-        uint64_t startFrom, int64_t startTime, int64_t *pSamplePos,
+        uint64_t recordFrom, int64_t startTime, int64_t *pSamplePos,
         int64_t *pRemainderBufLen)
 {
   assert(buffer != NULL);
@@ -5327,7 +5476,7 @@ static int32_t generateStbProgressiveData(
 
   return generateStbDataTail(superTblInfo,
           g_args.num_of_RPR, pstr, *pRemainderBufLen,
-          insertRows, startFrom,
+          insertRows, recordFrom,
           startTime,
           pSamplePos, &dataLen);
 }
@@ -5342,7 +5491,7 @@ static int64_t generateProgressiveDataWithoutStb(
         /* int64_t tableSeq, */
         threadInfo *pThreadInfo, char *buffer,
         int64_t insertRows,
-        uint64_t startFrom, int64_t startTime, /*int64_t *pSamplePos, */
+        uint64_t recordFrom, int64_t startTime, /*int64_t *pSamplePos, */
         int64_t *pRemainderBufLen)
 {
   assert(buffer != NULL);
@@ -5363,7 +5512,7 @@ static int64_t generateProgressiveDataWithoutStb(
   int64_t dataLen;
 
   return generateDataTailWithoutStb(
-          g_args.num_of_RPR, pstr, *pRemainderBufLen, insertRows, startFrom,
+          g_args.num_of_RPR, pstr, *pRemainderBufLen, insertRows, recordFrom,
           startTime,
           /*pSamplePos, */&dataLen);
 }
@@ -5677,7 +5826,7 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
               generated = prepareStbStmt(superTblInfo,
                       pThreadInfo->stmt,
                       tableName, g_args.num_of_RPR,
-                      insertRows, start_time, pstr);
+                      insertRows, i, start_time, pstr);
           } else {
               generated = generateStbProgressiveData(
                       superTblInfo,
@@ -5965,7 +6114,7 @@ static void startMultiThreadInsertData(int threads, char* db_name,
   }
 
   int64_t ntables = 0;
-  uint64_t startFrom;
+  uint64_t tableFrom;
 
   if (superTblInfo) {
     int64_t limit;
@@ -5992,7 +6141,7 @@ static void startMultiThreadInsertData(int threads, char* db_name,
     }
 
     ntables = limit;
-    startFrom = offset;
+    tableFrom = offset;
 
     if ((superTblInfo->childTblExists != TBL_NO_EXISTS)
         && ((superTblInfo->childTblOffset + superTblInfo->childTblLimit )
@@ -6024,7 +6173,7 @@ static void startMultiThreadInsertData(int threads, char* db_name,
         offset);
   } else {
     ntables = g_args.num_of_tables;
-    startFrom = 0;
+    tableFrom = 0;
   }
 
   taos_close(taos0);
@@ -6101,10 +6250,10 @@ static void startMultiThreadInsertData(int threads, char* db_name,
 /*    if ((NULL == superTblInfo)
             || (0 == superTblInfo->multiThreadWriteOneTbl)) {
             */
-      pThreadInfo->start_table_from = startFrom;
+      pThreadInfo->start_table_from = tableFrom;
       pThreadInfo->ntables = i<b?a+1:a;
-      pThreadInfo->end_table_to = i < b ? startFrom + a : startFrom + a - 1;
-      startFrom = pThreadInfo->end_table_to + 1;
+      pThreadInfo->end_table_to = i < b ? tableFrom + a : tableFrom + a - 1;
+      tableFrom = pThreadInfo->end_table_to + 1;
 /*    } else {
       pThreadInfo->start_table_from = 0;
       pThreadInfo->ntables = superTblInfo->childTblCount;
@@ -6743,15 +6892,15 @@ static int queryTestProcess() {
       b = ntables % threads;
     }
 
-    uint64_t startFrom = 0;
+    uint64_t tableFrom = 0;
     for (int i = 0; i < threads; i++) {
       threadInfo *pThreadInfo = infosOfSub + i;
       pThreadInfo->threadID = i;
 
-      pThreadInfo->start_table_from = startFrom;
+      pThreadInfo->start_table_from = tableFrom;
       pThreadInfo->ntables = i<b?a+1:a;
-      pThreadInfo->end_table_to = i < b ? startFrom + a : startFrom + a - 1;
-      startFrom = pThreadInfo->end_table_to + 1;
+      pThreadInfo->end_table_to = i < b ? tableFrom + a : tableFrom + a - 1;
+      tableFrom = pThreadInfo->end_table_to + 1;
       pThreadInfo->taos = NULL; // TODO: workaround to use separate taos connection;
       pthread_create(pidsOfSub + i, NULL, superTableQuery, pThreadInfo);
     }
@@ -7200,17 +7349,17 @@ static int subscribeTestProcess() {
         }
 
         for (uint64_t i = 0; i < g_queryInfo.superQueryInfo.sqlCount; i++) {
-            uint64_t startFrom = 0;
+            uint64_t tableFrom = 0;
             for (int j = 0; j < threads; j++) {
                 uint64_t seq = i * threads + j;
                 threadInfo *pThreadInfo = infosOfStable + seq;
                 pThreadInfo->threadID = seq;
                 pThreadInfo->querySeq = i;
 
-                pThreadInfo->start_table_from = startFrom;
+                pThreadInfo->start_table_from = tableFrom;
                 pThreadInfo->ntables = j<b?a+1:a;
-                pThreadInfo->end_table_to = j<b?startFrom+a:startFrom+a-1;
-                startFrom = pThreadInfo->end_table_to + 1;
+                pThreadInfo->end_table_to = j<b?tableFrom+a:tableFrom+a-1;
+                tableFrom = pThreadInfo->end_table_to + 1;
                 pThreadInfo->taos = NULL; // TODO: workaround to use separate taos connection;
                 pthread_create(pidsOfStable + seq,
                         NULL, superSubscribe, pThreadInfo);

From 010ac0e84ccdbb916510ef4cfea94c9db1bd33e2 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Wed, 26 May 2021 14:26:02 +0800
Subject: [PATCH 101/128] [td-225] fix compiler error.

---
 src/mnode/src/mnodeTable.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index 25d14607f6..e1cae0d054 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -2950,7 +2950,7 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
     msg = serializeVgroupInfo(pTable, name, msg, pMsg, pMsg->rpcMsg.ahandle);
   }
 
-  pMultiMeta->contLen = (msg - (char*) pMultiMeta);
+  pMultiMeta->contLen = (int32_t) (msg - (char*) pMultiMeta);
 
   pMultiMeta->numOfTables = htonl(pMultiMeta->numOfTables);
   pMsg->rpcRsp.rsp = pMultiMeta;

From ede8a4a6f040fb0710f7022da77ff08f7031bb51 Mon Sep 17 00:00:00 2001
From: Elias Soong <elias.soong@gmail.com>
Date: Wed, 26 May 2021 15:08:53 +0800
Subject: [PATCH 102/128] [TD-4089] <docs>: stopping taosd service may take
 remarkable time.

---
 documentation20/cn/02.getting-started/docs.md | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/documentation20/cn/02.getting-started/docs.md b/documentation20/cn/02.getting-started/docs.md
index a98159d8c4..6eb58a1433 100644
--- a/documentation20/cn/02.getting-started/docs.md
+++ b/documentation20/cn/02.getting-started/docs.md
@@ -24,7 +24,7 @@ TDengine的安装非常简单，从下载到安装成功仅仅只要几秒钟。
 
 ## <a class="anchor" id="start"></a>轻松启动
 
-安装成功后，用户可使用`systemctl`命令来启动TDengine的服务进程。
+安装成功后，用户可使用 `systemctl` 命令来启动 TDengine 的服务进程。
 
 ```bash
 $ systemctl start taosd
@@ -35,21 +35,22 @@ $ systemctl start taosd
 $ systemctl status taosd
 ```
 
-如果TDengine服务正常工作，那么您可以通过TDengine的命令行程序`taos`来访问并体验TDengine。  
+如果 TDengine 服务正常工作，那么您可以通过 TDengine 的命令行程序 `taos` 来访问并体验 TDengine。  
 
 **注意：**  
 
-- systemctl命令需要 _root_ 权限来运行，如果您非 _root_ 用户，请在命令前添加 sudo
-- 为更好的获得产品反馈，改善产品，TDengine会采集基本的使用信息，但您可以修改系统配置文件taos.cfg里的配置参数telemetryReporting, 将其设为0，就可将其关闭。
-- TDengine采用FQDN(一般就是hostname)作为节点的ID，为保证正常运行，需要给运行taosd的服务器配置好hostname，在客户端应用运行的机器配置好DNS服务或hosts文件，保证FQDN能够解析。
+- systemctl 命令需要 _root_ 权限来运行，如果您非 _root_ 用户，请在命令前添加 sudo 。
+- 为更好的获得产品反馈，改善产品，TDengine 会采集基本的使用信息，但您可以修改系统配置文件 taos.cfg 里的配置参数 telemetryReporting, 将其设为 0，就可将其关闭。
+- TDengine 采用 FQDN (一般就是 hostname )作为节点的 ID，为保证正常运行，需要给运行 taosd 的服务器配置好 hostname，在客户端应用运行的机器配置好 DNS 服务或 hosts 文件，保证 FQDN 能够解析。
+- `systemctl stop taosd` 指令在执行后并不会马上停止 TDengine 服务，而是会等待系统中必要的落盘工作正常完成。在数据量很大的情况下，这可能会消耗较长时间。
 
-* TDengine 支持在使用[`systemd`](https://en.wikipedia.org/wiki/Systemd)做进程服务管理的linux系统上安装，用`which systemctl`命令来检测系统中是否存在`systemd`包:
+* TDengine 支持在使用 [`systemd`](https://en.wikipedia.org/wiki/Systemd) 做进程服务管理的 linux 系统上安装，用 `which systemctl` 命令来检测系统中是否存在 `systemd` 包:
 
   ```bash
   $ which systemctl
   ```
 
-  如果系统中不支持systemd，也可以用手动运行 /usr/local/taos/bin/taosd 方式启动 TDengine 服务。
+  如果系统中不支持 systemd，也可以用手动运行 /usr/local/taos/bin/taosd 方式启动 TDengine 服务。
 
   
 ## <a class="anchor" id="console"></a>TDengine命令行程序

From 9406b3a414ad31ef67329c5bc702545875eca4e6 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Wed, 26 May 2021 15:11:37 +0800
Subject: [PATCH 103/128] [td-225] fix compiler error on mac.

---
 src/client/src/tscSQLParser.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index cfa8e386e6..524dda6233 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -649,7 +649,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       for (int32_t i = 0; i < size; ++i) {
         SSqlNode* pSqlNode = taosArrayGetP(pInfo->list, i);
 
-        tscTrace("%p start to parse %dth subclause, total:%"PRId64, pSql, i, size);
+        tscTrace("%p start to parse %dth subclause, total:%"PRIu64, pSql, i, size);
         if ((code = validateSqlNode(pSql, pSqlNode, pQueryInfo)) != TSDB_CODE_SUCCESS) {
           return code;
         }

From 8adf685f560bf9906f685bddaef5baed20d5e7f6 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Wed, 26 May 2021 15:24:46 +0800
Subject: [PATCH 104/128] [td-4329]update the error code,add a new error code
 TSDB_CODE_TSC_INVALID_OPERATION, instead of TSDB_CODE_TSC_INVALID_SQL.

---
 src/client/src/tscLocal.c       |   2 +-
 src/client/src/tscParseInsert.c |  24 +-
 src/client/src/tscPrepare.c     |   2 +-
 src/client/src/tscSQLParser.c   | 885 ++++++++++++++++----------------
 src/client/src/tscServer.c      |  12 +-
 src/client/src/tscSql.c         |   4 +-
 src/client/src/tscSub.c         |   2 +-
 src/client/src/tscUtil.c        |  30 +-
 src/inc/taoserror.h             |   2 +-
 src/plugins/http/src/httpResp.c |   2 +-
 src/plugins/http/src/httpSql.c  |   2 +-
 src/query/src/qAggMain.c        |   4 +-
 src/query/tests/unitTest.cpp    | 114 ++--
 src/util/src/terror.c           |   2 +-
 14 files changed, 543 insertions(+), 544 deletions(-)

diff --git a/src/client/src/tscLocal.c b/src/client/src/tscLocal.c
index f8ec36c55a..abac2407fb 100644
--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
@@ -928,7 +928,7 @@ int tscProcessLocalCmd(SSqlObj *pSql) {
   } else if (pCmd->command == TSDB_SQL_SERV_STATUS) {
     pRes->code = tscProcessServStatus(pSql);
   } else {
-    pRes->code = TSDB_CODE_TSC_INVALID_SQL;
+    pRes->code = TSDB_CODE_TSC_INVALID_OPERATION;
     tscError("0x%"PRIx64" not support command:%d", pSql->self, pCmd->command);
   }
 
diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index a5327ef302..a305c3cf82 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -107,7 +107,7 @@ int tsParseTime(SStrToken *pToken, int64_t *time, char **next, char *error, int1
     }
 
     if (parseAbsoluteDuration(valueToken.z, valueToken.n, &interval) != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     if (timePrec == TSDB_TIME_PRECISION_MILLI) {
@@ -647,7 +647,7 @@ static int32_t tsSetBlockInfo(SSubmitBlk *pBlocks, const STableMeta *pTableMeta,
   pBlocks->sversion = pTableMeta->sversion;
 
   if (pBlocks->numOfRows + numOfRows >= INT16_MAX) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   } else {
     pBlocks->numOfRows += numOfRows;
     return TSDB_CODE_SUCCESS;
@@ -708,7 +708,7 @@ static int32_t doParseInsertStatement(SSqlCmd* pCmd, char **str, STableDataBlock
     return TSDB_CODE_TSC_OUT_OF_MEMORY;
   }
 
-  code = TSDB_CODE_TSC_INVALID_SQL;
+  code = TSDB_CODE_TSC_INVALID_OPERATION;
   char tmpTokenBuf[16*1024] = {0};  // used for deleting Escape character: \\, \', \"
 
   int32_t numOfRows = 0;
@@ -784,7 +784,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
   }
 
   if (numOfColList == 0 && (*boundColumn) != NULL) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
   
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, TABLE_INDEX);
@@ -877,7 +877,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
       if (TK_ILLEGAL == sToken.type) {
         tdDestroyKVRowBuilder(&kvRowBuilder);
         tscDestroyBoundColumnInfo(&spd);
-        return TSDB_CODE_TSC_INVALID_SQL;
+        return TSDB_CODE_TSC_INVALID_OPERATION;
       }
 
       if (sToken.n == 0 || sToken.type == TK_RP) {
@@ -959,7 +959,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
       }
 
       if (numOfColsAfterTags == 0 && (*boundColumn) != NULL) {
-        return TSDB_CODE_TSC_INVALID_SQL;
+        return TSDB_CODE_TSC_INVALID_OPERATION;
       }
 
       sToken = tStrGetToken(sql, &index, false);
@@ -977,7 +977,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
     }
 
     if (sql == NULL) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     code = tscGetTableMetaEx(pSql, pTableMetaInfo, true);
@@ -989,7 +989,7 @@ static int32_t tscCheckIfCreateTable(char **sqlstr, SSqlObj *pSql, char** boundC
     sql = sToken.z;
 
     if (sql == NULL) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     code = tscGetTableMetaEx(pSql, pTableMetaInfo, false);
@@ -1149,7 +1149,7 @@ int tsParseInsertSql(SSqlObj *pSql) {
        * Otherwise, create the first submit block and submit to virtual node.
        */
       if (totalNum == 0) {
-        code = TSDB_CODE_TSC_INVALID_SQL;
+        code = TSDB_CODE_TSC_INVALID_OPERATION;
         goto _clean;
       } else {
         break;
@@ -1355,9 +1355,9 @@ int tsParseSql(SSqlObj *pSql, bool initial) {
     }
 
     ret = tsParseInsertSql(pSql);
-    assert(ret == TSDB_CODE_SUCCESS || ret == TSDB_CODE_TSC_ACTION_IN_PROGRESS || ret == TSDB_CODE_TSC_SQL_SYNTAX_ERROR || ret == TSDB_CODE_TSC_INVALID_SQL);
+    assert(ret == TSDB_CODE_SUCCESS || ret == TSDB_CODE_TSC_ACTION_IN_PROGRESS || ret == TSDB_CODE_TSC_SQL_SYNTAX_ERROR || ret == TSDB_CODE_TSC_INVALID_OPERATION);
 
-    if (pSql->parseRetry < 1 && (ret == TSDB_CODE_TSC_SQL_SYNTAX_ERROR || ret == TSDB_CODE_TSC_INVALID_SQL)) {
+    if (pSql->parseRetry < 1 && (ret == TSDB_CODE_TSC_SQL_SYNTAX_ERROR || ret == TSDB_CODE_TSC_INVALID_OPERATION)) {
       tscDebug("0x%"PRIx64 " parse insert sql statement failed, code:%s, clear meta cache and retry ", pSql->self, tstrerror(ret));
 
       tscResetSqlCmd(pCmd, true);
@@ -1370,7 +1370,7 @@ int tsParseSql(SSqlObj *pSql, bool initial) {
   } else {
     SSqlInfo SQLInfo = qSqlParse(pSql->sqlstr);
     ret = tscToSQLCmd(pSql, &SQLInfo);
-    if (ret == TSDB_CODE_TSC_INVALID_SQL && pSql->parseRetry < 1 && SQLInfo.type == TSDB_SQL_SELECT) {
+    if (ret == TSDB_CODE_TSC_INVALID_OPERATION && pSql->parseRetry < 1 && SQLInfo.type == TSDB_SQL_SELECT) {
       tscDebug("0x%"PRIx64 " parse query sql statement failed, code:%s, clear meta cache and retry ", pSql->self, tstrerror(ret));
 
       tscResetSqlCmd(pCmd, true);
diff --git a/src/client/src/tscPrepare.c b/src/client/src/tscPrepare.c
index 9d40e186da..b9950b0776 100644
--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -1300,7 +1300,7 @@ int taos_stmt_prepare(TAOS_STMT* stmt, const char* sql, unsigned long length) {
     SStrToken sToken = tStrGetToken(pCmd->curSql, &index, false);
 
     if (sToken.n == 0) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     if (sToken.n == 1 && sToken.type == TK_QUESTION) {
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 524dda6233..45dde54df0 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -194,7 +194,7 @@ static bool validateDebugFlag(int32_t v) {
  * Used during parsing query sql. Since the query sql usually small in length, error position
  * is not needed in the final error message.
  */
-static int32_t invalidSqlErrMsg(char* dstBuffer, const char* errMsg) {
+static int32_t invalidOperationMsg(char* dstBuffer, const char* errMsg) {
   return tscInvalidSQLErrMsg(dstBuffer, errMsg, NULL);
 }
 
@@ -210,11 +210,11 @@ static int setColumnFilterInfoForTimestamp(SSqlCmd* pCmd, SQueryInfo* pQueryInfo
   
   if (seg != NULL) {
     if (taosParseTime(pVar->pz, &time, pVar->nLen, tinfo.precision, tsDaylight) != TSDB_CODE_SUCCESS) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
     }
   } else {
     if (tVariantDump(pVar, (char*)&time, TSDB_DATA_TYPE_BIGINT, true)) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
     }
   }
 
@@ -230,18 +230,18 @@ static int32_t handlePassword(SSqlCmd* pCmd, SStrToken* pPwd) {
   const char* msg3 = "password needs single quote marks enclosed";
 
   if (pPwd->type != TK_STRING) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
   }
 
   strdequote(pPwd->z);
   pPwd->n = (uint32_t)strtrim(pPwd->z);  // trim space before and after passwords
 
   if (pPwd->n <= 0) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   if (pPwd->n >= TSDB_KEY_LEN) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -260,7 +260,7 @@ static int32_t normalizeVarDataTypeLength(SSqlCmd* pCmd) {
   while(pSibling != NULL) {
     int32_t ret = tscFieldInfoCompare(&pQueryInfo1->fieldsInfo, &pSibling->fieldsInfo, &diffSize);
     if (ret != 0) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 
     pSibling = pSibling->sibling;
@@ -318,14 +318,14 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
       SStrToken* pzName = taosArrayGet(pInfo->pMiscInfo->a, 0);
       if ((pInfo->type != TSDB_SQL_DROP_DNODE) && (tscValidateName(pzName) != TSDB_CODE_SUCCESS)) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
 
       if (pInfo->type == TSDB_SQL_DROP_DB) {
         assert(taosArrayGetSize(pInfo->pMiscInfo->a) == 1);
         code = tNameSetDbName(&pTableMetaInfo->name, getAccountId(pSql), pzName);
         if (code != TSDB_CODE_SUCCESS) {
-          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
         }
 
       } else if (pInfo->type == TSDB_SQL_DROP_TABLE) {
@@ -343,7 +343,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 ////          }
 //
 //          if (!UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
-//            return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+//            return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
 //          }
         }
         
@@ -352,7 +352,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
         strncpy(pCmd->payload, pzName->z, pzName->n);
       } else {  // drop user/account
         if (pzName->n >= TSDB_USER_LEN) {
-          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
         }
 
         strncpy(pCmd->payload, pzName->z, pzName->n);
@@ -366,12 +366,12 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       SStrToken* pToken = taosArrayGet(pInfo->pMiscInfo->a, 0);
 
       if (tscValidateName(pToken) != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
       }
 
       int32_t ret = tNameSetDbName(&pTableMetaInfo->name, getAccountId(pSql), pToken);
       if (ret != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
       }
 
       break;
@@ -383,7 +383,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
     case TSDB_SQL_SHOW: {
       if (setShowInfo(pSql, pInfo) != TSDB_CODE_SUCCESS) {
-        return TSDB_CODE_TSC_INVALID_SQL;
+        return TSDB_CODE_TSC_INVALID_OPERATION;
       }
 
       break;
@@ -396,16 +396,16 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
       SCreateDbInfo* pCreateDB = &(pInfo->pMiscInfo->dbOpt);
       if (tscValidateName(&pCreateDB->dbname) != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
       int32_t ret = tNameSetDbName(&pTableMetaInfo->name, getAccountId(pSql), &(pCreateDB->dbname));
       if (ret != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
 
       if (parseCreateDBOptions(pCmd, pCreateDB) != TSDB_CODE_SUCCESS) {
-        return TSDB_CODE_TSC_INVALID_SQL;
+        return TSDB_CODE_TSC_INVALID_OPERATION;
       }
 
       break;
@@ -415,7 +415,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       const char* msg = "invalid host name (ip address)";
 
       if (taosArrayGetSize(pInfo->pMiscInfo->a) > 1) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
       }
 
       SStrToken* id = taosArrayGet(pInfo->pMiscInfo->a, 0);
@@ -433,15 +433,15 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       SStrToken* pPwd = &pInfo->pMiscInfo->user.passwd;
 
       if (handlePassword(pCmd, pPwd) != TSDB_CODE_SUCCESS) {
-        return TSDB_CODE_TSC_INVALID_SQL;
+        return TSDB_CODE_TSC_INVALID_OPERATION;
       }
 
       if (pName->n >= TSDB_USER_LEN) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
       }
 
       if (tscValidateName(pName) != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
 
       SCreateAcctInfo* pAcctOpt = &pInfo->pMiscInfo->acctOpt;
@@ -451,7 +451,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
         } else if (strncmp(pAcctOpt->stat.z, "all", 3) == 0 && pAcctOpt->stat.n == 3) {
         } else if (strncmp(pAcctOpt->stat.z, "no", 2) == 0 && pAcctOpt->stat.n == 2) {
         } else {
-          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
         }
       }
 
@@ -463,7 +463,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
       SStrToken* pToken = taosArrayGet(pInfo->pMiscInfo->a, 0);
       if (tscValidateName(pToken) != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
       // additional msg has been attached already
       code = tscSetTableFullName(&pTableMetaInfo->name, pToken, pSql);
@@ -479,7 +479,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
       SStrToken* pToken = taosArrayGet(pInfo->pMiscInfo->a, 0);
       if (tscValidateName(pToken) != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
       code = tscSetTableFullName(&pTableMetaInfo->name, pToken, pSql);
@@ -494,11 +494,11 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
       SStrToken* pToken = taosArrayGet(pInfo->pMiscInfo->a, 0);
       if (tscValidateName(pToken) != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
       if (pToken->n > TSDB_DB_NAME_LEN) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
       return tNameSetDbName(&pTableMetaInfo->name, getAccountId(pSql), pToken);
     }
@@ -511,7 +511,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
       /* validate the parameter names and options */
       if (validateDNodeConfig(pMiscInfo) != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
 
       char* pMsg = pCmd->payload;
@@ -525,7 +525,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       strncpy(pCfg->ep, t0->z, t0->n);
 
       if (validateEp(pCfg->ep) != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
       }
 
       strncpy(pCfg->config, t1->z, t1->n);
@@ -554,21 +554,21 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       SStrToken* pPwd = &pUser->passwd;
 
       if (pName->n >= TSDB_USER_LEN) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
       }
 
       if (tscValidateName(pName) != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
 
       if (pCmd->command == TSDB_SQL_CREATE_USER) {
         if (handlePassword(pCmd, pPwd) != TSDB_CODE_SUCCESS) {
-          return TSDB_CODE_TSC_INVALID_SQL;
+          return TSDB_CODE_TSC_INVALID_OPERATION;
         }
       } else {
         if (pUser->type == TSDB_ALTER_USER_PASSWD) {
           if (handlePassword(pCmd, pPwd) != TSDB_CODE_SUCCESS) {
-            return TSDB_CODE_TSC_INVALID_SQL;
+            return TSDB_CODE_TSC_INVALID_OPERATION;
           }
         } else if (pUser->type == TSDB_ALTER_USER_PRIVILEGES) {
           assert(pPwd->type == TSDB_DATA_TYPE_NULL);
@@ -582,10 +582,10 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
           } else if (strncasecmp(pPrivilege->z, "write", 5) == 0 && pPrivilege->n == 5) {
             pCmd->count = 3;
           } else {
-            return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+            return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
           }
         } else {
-          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg7);
+          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg7);
         }
       }
 
@@ -598,7 +598,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
       // validate the parameter names and options
       if (validateLocalConfig(pMiscInfo) != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
       }
 
       int32_t numOfToken = (int32_t) taosArrayGetSize(pMiscInfo->a);
@@ -700,19 +700,19 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       assert(taosArrayGetSize(pInfo->pMiscInfo->a) == 1);
       code = tNameSetDbName(&pTableMetaInfo->name, getAccountId(pSql), pzName);
       if (code != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
       break;
     }
 
     default:
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), "not support sql expression");
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), "not support sql expression");
   }
 
   if (tscBuildMsg[pCmd->command] != NULL) {
     return tscBuildMsg[pCmd->command](pSql, pInfo);
   } else {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), "not support sql expression");
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), "not support sql expression");
   }
 }
 
@@ -748,7 +748,7 @@ static int32_t addPrimaryTsColumnForTimeWindowQuery(SQueryInfo* pQueryInfo, SSql
   }
 
   if (tableIndex == COLUMN_INDEX_INITIAL_VAL) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   SSchema s = {.bytes = TSDB_KEYSIZE, .type = TSDB_DATA_TYPE_TIMESTAMP, .colId = PRIMARYKEY_TIMESTAMP_COL_INDEX};
@@ -771,7 +771,7 @@ static int32_t checkInvalidExprForTimeWindow(SSqlCmd* pCmd, SQueryInfo* pQueryIn
     // order by normal column is not supported
     int32_t colId = pQueryInfo->order.orderColId;
     if (isTimeWindowQuery(pQueryInfo) && colId != PRIMARYKEY_TIMESTAMP_COL_INDEX) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
     }
 
     return TSDB_CODE_SUCCESS;
@@ -785,7 +785,7 @@ static int32_t checkInvalidExprForTimeWindow(SSqlCmd* pCmd, SQueryInfo* pQueryIn
   for (int32_t i = 0; i < size; ++i) {
     SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     if (pExpr->base.functionId == TSDB_FUNC_COUNT && TSDB_COL_IS_TAG(pExpr->base.colInfo.flag)) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
   }
 
@@ -794,7 +794,7 @@ static int32_t checkInvalidExprForTimeWindow(SSqlCmd* pCmd, SQueryInfo* pQueryIn
    * select tbname, tags_fields from super_table_name [interval(1s)|session(ts,1s)]
    */
   if (tscQueryTags(pQueryInfo) && isTimeWindowQuery(pQueryInfo)) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   return addPrimaryTsColumnForTimeWindowQuery(pQueryInfo, pCmd);
@@ -811,7 +811,7 @@ int32_t validateIntervalNode(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNode* pS
   
   if (!TPARSER_HAS_TOKEN(pSqlNode->interval.interval)) {
     if (TPARSER_HAS_TOKEN(pSqlNode->sliding)) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
     }
 
     return TSDB_CODE_SUCCESS;
@@ -825,7 +825,7 @@ int32_t validateIntervalNode(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNode* pS
   // interval is not null
   SStrToken *t = &pSqlNode->interval.interval;
   if (parseNatualDuration(t->z, t->n, &pQueryInfo->interval.interval, &pQueryInfo->interval.intervalUnit) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   if (pQueryInfo->interval.intervalUnit != 'n' && pQueryInfo->interval.intervalUnit != 'y') {
@@ -836,16 +836,16 @@ int32_t validateIntervalNode(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNode* pS
 
     // interval cannot be less than 10 milliseconds
     if (pQueryInfo->interval.interval < tsMinIntervalTime) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
     }
   }
 
   if (parseIntervalOffset(pCmd, pQueryInfo, &pSqlNode->interval.offset) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   if (parseSlidingClause(pCmd, pQueryInfo, &pSqlNode->sliding) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   // The following part is used to check for the invalid query expression.
@@ -868,11 +868,11 @@ int32_t validateSessionNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode * pS
 
   char timeUnit = 0;
   if (parseNatualDuration(gap->z, gap->n, &pQueryInfo->sessionWindow.gap, &timeUnit) != TSDB_CODE_SUCCESS) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
   }
 
   if (timeUnit == 'y' || timeUnit == 'n') {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   // if the unit of time window value is millisecond, change the value from microsecond
@@ -883,12 +883,12 @@ int32_t validateSessionNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode * pS
   }
 
   if (pQueryInfo->sessionWindow.gap != 0 && pQueryInfo->interval.interval != 0) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
   }
 
   SColumnIndex index = COLUMN_INDEX_INITIALIZER;
   if (getColumnIndexByName(pCmd, col, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
   }
 
   pQueryInfo->sessionWindow.primaryColId = PRIMARYKEY_TIMESTAMP_COL_INDEX;
@@ -913,11 +913,11 @@ int32_t parseIntervalOffset(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SStrToken* of
   }
 
   if (parseNatualDuration(t->z, t->n, &pQueryInfo->interval.offset, &pQueryInfo->interval.offsetUnit) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   if (pQueryInfo->interval.offset < 0) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   if (pQueryInfo->interval.offsetUnit != 'n' && pQueryInfo->interval.offsetUnit != 'y') {
@@ -927,18 +927,18 @@ int32_t parseIntervalOffset(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SStrToken* of
     }
     if (pQueryInfo->interval.intervalUnit != 'n' && pQueryInfo->interval.intervalUnit != 'y') {
       if (pQueryInfo->interval.offset >= pQueryInfo->interval.interval) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
     }
   } else if (pQueryInfo->interval.offsetUnit == pQueryInfo->interval.intervalUnit) {
     if (pQueryInfo->interval.offset >= pQueryInfo->interval.interval) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
     }
   } else if (pQueryInfo->interval.intervalUnit == 'n' && pQueryInfo->interval.offsetUnit == 'y') {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
   } else if (pQueryInfo->interval.intervalUnit == 'y' && pQueryInfo->interval.offsetUnit == 'n') {
     if (pQueryInfo->interval.interval * 12 <= pQueryInfo->interval.offset) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
     }
   } else {
     // TODO: offset should be shorter than interval, but how to check
@@ -966,7 +966,7 @@ int32_t parseSlidingClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SStrToken* pSl
   }
 
   if (pQueryInfo->interval.intervalUnit == 'n' || pQueryInfo->interval.intervalUnit == 'y') {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
   }
 
   parseAbsoluteDuration(pSliding->z, pSliding->n, &pQueryInfo->interval.sliding);
@@ -975,19 +975,19 @@ int32_t parseSlidingClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SStrToken* pSl
   }
 
   if (pQueryInfo->interval.sliding < tsMinSlidingTime) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg0);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg0);
   }
 
   if (pQueryInfo->interval.sliding > pQueryInfo->interval.interval) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   if ((pQueryInfo->interval.interval != 0) && (pQueryInfo->interval.interval/pQueryInfo->interval.sliding > INTERVAL_SLIDING_FACTOR)) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
   }
 
 //  if (pQueryInfo->interval.sliding != pQueryInfo->interval.interval && pSql->pStream == NULL) {
-//    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+//    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
 //  }
 
   return TSDB_CODE_SUCCESS;
@@ -1006,19 +1006,19 @@ int32_t tscSetTableFullName(SName* pName, SStrToken* pTableName, SSqlObj* pSql)
   if (idx != -1) { // db has been specified in sql string so we ignore current db path
     char* acctId = getAccountId(pSql);
     if (acctId == NULL || strlen(acctId) <= 0) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
     }
 
     code = tNameSetAcctId(pName, acctId);
     if (code != 0) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
     }
     if (idx >= TSDB_DB_NAME_LEN) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
     }
 
     if (pTableName->n - 1 - idx >= TSDB_TABLE_NAME_LEN) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
     }
 
     char name[TSDB_TABLE_FNAME_LEN] = {0};
@@ -1026,7 +1026,7 @@ int32_t tscSetTableFullName(SName* pName, SStrToken* pTableName, SSqlObj* pSql)
 
     code = tNameFromString(pName, name, T_NAME_DB|T_NAME_TABLE);
     if (code != 0) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
   } else {  // get current DB name first, and then set it into path
     char* t = cloneCurrentDBName(pSql);
@@ -1043,7 +1043,7 @@ int32_t tscSetTableFullName(SName* pName, SStrToken* pTableName, SSqlObj* pSql)
     free(t);
 
     if (pTableName->n >= TSDB_TABLE_NAME_LEN) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 
     char name[TSDB_TABLE_FNAME_LEN] = {0};
@@ -1051,7 +1051,7 @@ int32_t tscSetTableFullName(SName* pName, SStrToken* pTableName, SSqlObj* pSql)
 
     code = tNameFromString(pName, name, T_NAME_TABLE);
     if (code != 0) {
-      code = invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      code = invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
   }
 
@@ -1072,14 +1072,14 @@ static bool validateTableColumnInfo(SArray* pFieldList, SSqlCmd* pCmd) {
   // number of fields no less than 2
   size_t numOfCols = taosArrayGetSize(pFieldList);
   if (numOfCols <= 1 || numOfCols > TSDB_MAX_COLUMNS) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
     return false;
   }
 
   // first column must be timestamp
   TAOS_FIELD* pField = taosArrayGet(pFieldList, 0);
   if (pField->type != TSDB_DATA_TYPE_TIMESTAMP) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     return false;
   }
 
@@ -1087,29 +1087,29 @@ static bool validateTableColumnInfo(SArray* pFieldList, SSqlCmd* pCmd) {
   for (int32_t i = 0; i < numOfCols; ++i) {
     pField = taosArrayGet(pFieldList, i);
     if (!isValidDataType(pField->type)) {
-      invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+      invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
       return false;
     }
 
     if (pField->bytes == 0) {
-      invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+      invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
       return false;
     }
 
     if ((pField->type == TSDB_DATA_TYPE_BINARY && (pField->bytes <= 0 || pField->bytes > TSDB_MAX_BINARY_LEN)) ||
         (pField->type == TSDB_DATA_TYPE_NCHAR && (pField->bytes <= 0 || pField->bytes > TSDB_MAX_NCHAR_LEN))) {
-      invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+      invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
       return false;
     }
 
     if (validateColumnName(pField->name) != TSDB_CODE_SUCCESS) {
-      invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);
+      invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
       return false;
     }
 
     // field name must be unique
     if (has(pFieldList, i + 1, pField->name) == true) {
-      invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
       return false;
     }
 
@@ -1118,7 +1118,7 @@ static bool validateTableColumnInfo(SArray* pFieldList, SSqlCmd* pCmd) {
 
   // max row length must be less than TSDB_MAX_BYTES_PER_ROW
   if (nLen > TSDB_MAX_BYTES_PER_ROW) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
     return false;
   }
 
@@ -1140,7 +1140,7 @@ static bool validateTagParams(SArray* pTagsList, SArray* pFieldList, SSqlCmd* pC
   // number of fields at least 1
   size_t numOfTags = taosArrayGetSize(pTagsList);
   if (numOfTags < 1 || numOfTags > TSDB_MAX_TAGS) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     return false;
   }
 
@@ -1149,28 +1149,28 @@ static bool validateTagParams(SArray* pTagsList, SArray* pFieldList, SSqlCmd* pC
     TAOS_FIELD* p = taosArrayGet(pTagsList, i);
 
     if (p->type == TSDB_DATA_TYPE_TIMESTAMP) {
-      invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+      invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
       return false;
     }
 
     if (!isValidDataType(p->type)) {
-      invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+      invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
       return false;
     }
 
     if ((p->type == TSDB_DATA_TYPE_BINARY && p->bytes <= 0) ||
         (p->type == TSDB_DATA_TYPE_NCHAR && p->bytes <= 0)) {
-      invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg7);
+      invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg7);
       return false;
     }
 
     if (validateColumnName(p->name) != TSDB_CODE_SUCCESS) {
-      invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);
+      invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
       return false;
     }
 
     if (has(pTagsList, i + 1, p->name) == true) {
-      invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
       return false;
     }
   }
@@ -1179,7 +1179,7 @@ static bool validateTagParams(SArray* pTagsList, SArray* pFieldList, SSqlCmd* pC
   for (int32_t i = 0; i < numOfTags; ++i) {
     TAOS_FIELD* p = taosArrayGet(pTagsList, i);
     if (p->bytes == 0) {
-      invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg7);
+      invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg7);
       return false;
     }
 
@@ -1188,7 +1188,7 @@ static bool validateTagParams(SArray* pTagsList, SArray* pFieldList, SSqlCmd* pC
 
   // max tag row length must be less than TSDB_MAX_TAGS_LEN
   if (nLen > TSDB_MAX_TAGS_LEN) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
     return false;
   }
 
@@ -1197,7 +1197,7 @@ static bool validateTagParams(SArray* pTagsList, SArray* pFieldList, SSqlCmd* pC
     TAOS_FIELD* p = taosArrayGet(pTagsList, i);
 
     if (has(pFieldList, 0, p->name) == true) {
-      invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
       return false;
     }
   }
@@ -1227,18 +1227,18 @@ bool validateOneTags(SSqlCmd* pCmd, TAOS_FIELD* pTagField) {
     char msg[128] = {0};
     sprintf(msg, "tags no more than %d", TSDB_MAX_TAGS);
 
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
     return false;
   }
 
   // no timestamp allowable
   if (pTagField->type == TSDB_DATA_TYPE_TIMESTAMP) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     return false;
   }
 
   if ((pTagField->type < TSDB_DATA_TYPE_BOOL) || (pTagField->type > TSDB_DATA_TYPE_UBIGINT)) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
     return false;
   }
 
@@ -1251,19 +1251,19 @@ bool validateOneTags(SSqlCmd* pCmd, TAOS_FIELD* pTagField) {
 
   // length less than TSDB_MAX_TASG_LEN
   if (nLen + pTagField->bytes > TSDB_MAX_TAGS_LEN) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
     return false;
   }
 
   // tags name can not be a keyword
   if (validateColumnName(pTagField->name) != TSDB_CODE_SUCCESS) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
     return false;
   }
 
   // binary(val), val can not be equalled to or less than 0
   if ((pTagField->type == TSDB_DATA_TYPE_BINARY || pTagField->type == TSDB_DATA_TYPE_NCHAR) && pTagField->bytes <= 0) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
     return false;
   }
 
@@ -1272,7 +1272,7 @@ bool validateOneTags(SSqlCmd* pCmd, TAOS_FIELD* pTagField) {
 
   for (int32_t i = 0; i < numOfTags + numOfCols; ++i) {
     if (strncasecmp(pTagField->name, pSchema[i].name, sizeof(pTagField->name) - 1) == 0) {
-      invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       return false;
     }
   }
@@ -1297,17 +1297,17 @@ bool validateOneColumn(SSqlCmd* pCmd, TAOS_FIELD* pColField) {
   
   // no more max columns
   if (numOfCols >= TSDB_MAX_COLUMNS || numOfTags + numOfCols >= TSDB_MAX_COLUMNS) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     return false;
   }
 
   if (pColField->type < TSDB_DATA_TYPE_BOOL || pColField->type > TSDB_DATA_TYPE_UBIGINT) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
     return false;
   }
 
   if (validateColumnName(pColField->name) != TSDB_CODE_SUCCESS) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
     return false;
   }
 
@@ -1319,20 +1319,20 @@ bool validateOneColumn(SSqlCmd* pCmd, TAOS_FIELD* pColField) {
   }
 
   if (pColField->bytes <= 0) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
     return false;
   }
 
   // length less than TSDB_MAX_BYTES_PER_ROW
   if (nLen + pColField->bytes > TSDB_MAX_BYTES_PER_ROW) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
     return false;
   }
 
   // field name must be unique
   for (int32_t i = 0; i < numOfTags + numOfCols; ++i) {
     if (strncasecmp(pColField->name, pSchema[i].name, sizeof(pColField->name) - 1) == 0) {
-      invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       return false;
     }
   }
@@ -1384,7 +1384,7 @@ int32_t setObjFullName(char* fullName, const char* account, SStrToken* pDB, SStr
   /* db name is not specified, the tableName dose not include db name */
   if (pDB != NULL) {
     if (pDB->n >= TSDB_ACCT_ID_LEN + TSDB_DB_NAME_LEN || pDB->n == 0) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     memcpy(&fullName[totalLen], pDB->z, pDB->n);
@@ -1398,12 +1398,12 @@ int32_t setObjFullName(char* fullName, const char* account, SStrToken* pDB, SStr
 
       /* here we only check the table name length limitation */
       if (!tscValidateTableNameLength(tableName->n)) {
-        return TSDB_CODE_TSC_INVALID_SQL;
+        return TSDB_CODE_TSC_INVALID_OPERATION;
       }
     } else {  // pDB == NULL, the db prefix name is specified in tableName
       /* the length limitation includes tablename + dbname + sep */
       if (tableName->n >= TSDB_TABLE_NAME_LEN + TSDB_DB_NAME_LEN) {
-        return TSDB_CODE_TSC_INVALID_SQL;
+        return TSDB_CODE_TSC_INVALID_OPERATION;
       }
     }
 
@@ -1419,7 +1419,7 @@ int32_t setObjFullName(char* fullName, const char* account, SStrToken* pDB, SStr
     fullName[totalLen] = 0;
   }
 
-  return (totalLen < TSDB_TABLE_FNAME_LEN) ? TSDB_CODE_SUCCESS : TSDB_CODE_TSC_INVALID_SQL;
+  return (totalLen < TSDB_TABLE_FNAME_LEN) ? TSDB_CODE_SUCCESS : TSDB_CODE_TSC_INVALID_OPERATION;
 }
 
 void tscInsertPrimaryTsSourceColumn(SQueryInfo* pQueryInfo, uint64_t tableUid) {
@@ -1437,7 +1437,7 @@ static int32_t handleArithmeticExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32
   int32_t     arithmeticType = NON_ARITHMEIC_EXPR;
 
   if (validateArithmeticSQLExpr(pCmd, pItem->pNode, pQueryInfo, &columnList, &arithmeticType) != TSDB_CODE_SUCCESS) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   int32_t tableIndex = columnList.ids[0].tableIndex;
@@ -1447,7 +1447,7 @@ static int32_t handleArithmeticExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32
     // all columns in arithmetic expression must belong to the same table
     for (int32_t f = 1; f < columnList.num; ++f) {
       if (columnList.ids[f].tableIndex != tableIndex) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
       }
     }
 
@@ -1468,7 +1468,7 @@ static int32_t handleArithmeticExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32
     if (ret != TSDB_CODE_SUCCESS) {
       taosArrayDestroy(colList);
       tExprTreeDestroy(pNode, NULL);
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
     }
 
     // check for if there is a tag in the arithmetic express
@@ -1479,7 +1479,7 @@ static int32_t handleArithmeticExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32
         tExprTreeDestroy(pNode, NULL);
         taosArrayDestroy(colList);
 
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
       }
     }
 
@@ -1536,7 +1536,7 @@ static int32_t handleArithmeticExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32
     int32_t ret = exprTreeFromSqlExpr(pCmd, &pExprInfo->pExpr, pItem->pNode, pQueryInfo, NULL, &(pExprInfo->base.uid));
     if (ret != TSDB_CODE_SUCCESS) {
       tExprTreeDestroy(pExprInfo->pExpr, NULL);
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), "invalid expression in select clause");
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), "invalid expression in select clause");
     }
 
     pInfo->pExpr = pExprInfo;
@@ -1652,7 +1652,7 @@ int32_t validateSelectNodeList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pS
 
   // too many result columns not support order by in query
   if (taosArrayGetSize(pSelNodeList) > TSDB_MAX_COLUMNS) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   if (pQueryInfo->colList == NULL) {
@@ -1673,18 +1673,18 @@ int32_t validateSelectNodeList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pS
     if (type == SQL_NODE_SQLFUNCTION) {
       pItem->pNode->functionId = isValidFunction(pItem->pNode->operand.z, pItem->pNode->operand.n);
       if (pItem->pNode->functionId < 0) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
       }
 
       // sql function in selection clause, append sql function info in pSqlCmd structure sequentially
       if (addExprAndResultField(pCmd, pQueryInfo, outputIndex, pItem, true) != TSDB_CODE_SUCCESS) {
-        return TSDB_CODE_TSC_INVALID_SQL;
+        return TSDB_CODE_TSC_INVALID_OPERATION;
       }
     } else if (type == SQL_NODE_TABLE_COLUMN || type == SQL_NODE_VALUE) {
       // use the dynamic array list to decide if the function is valid or not
         // select table_name1.field_name1, table_name2.field_name2  from table_name1, table_name2
         if (addProjectionExprAndResultField(pCmd, pQueryInfo, pItem) != TSDB_CODE_SUCCESS) {
-          return TSDB_CODE_TSC_INVALID_SQL;
+          return TSDB_CODE_TSC_INVALID_OPERATION;
         }
     } else if (type == SQL_NODE_EXPR) {
       int32_t code = handleArithmeticExpr(pCmd, pQueryInfo, i, pItem);
@@ -1692,17 +1692,17 @@ int32_t validateSelectNodeList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pS
         return code;
       }
     } else {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
     }
 
     if (pQueryInfo->fieldsInfo.numOfOutput > TSDB_MAX_COLUMNS) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
   }
 
   if (hasDistinct == true) {
     if (!isValidDistinctSql(pQueryInfo)) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
     }
     pQueryInfo->distinctTag = true;
   }
@@ -1714,7 +1714,7 @@ int32_t validateSelectNodeList(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pS
   }
 
   if (!functionCompatibleCheck(pQueryInfo, joinQuery, timeWindowQuery)) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -1830,7 +1830,7 @@ int32_t addProjectionExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
 
     SColumnIndex index = COLUMN_INDEX_INITIALIZER;
     if (getTableIndexByName(&pItem->pNode->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg0);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg0);
     }
 
     // all meters columns are required
@@ -1867,7 +1867,7 @@ int32_t addProjectionExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
     SColumnIndex index = COLUMN_INDEX_INITIALIZER;
 
     if (getColumnIndexByName(pCmd, &pItem->pNode->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg0);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg0);
     }
 
     if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
@@ -1881,7 +1881,7 @@ int32_t addProjectionExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
       STableMeta*     pTableMeta = pTableMetaInfo->pTableMeta;
 
       if (index.columnIndex >= tscGetNumOfColumns(pTableMeta) && UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo)) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
       addProjectQueryCol(pQueryInfo, startPos, &index, pItem, getNewResColId(pCmd));
@@ -1894,7 +1894,7 @@ int32_t addProjectionExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, t
       tscInsertPrimaryTsSourceColumn(pQueryInfo, pTableMetaInfo->pTableMeta->id.uid);
     }
   } else {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   return TSDB_CODE_SUCCESS;
@@ -1911,7 +1911,7 @@ static int32_t setExprInfoForFunctions(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SS
   if (functionID == TSDB_FUNC_SPREAD) {
     int32_t t1 = pSchema->type;
     if (t1 == TSDB_DATA_TYPE_BINARY || t1 == TSDB_DATA_TYPE_NCHAR || t1 == TSDB_DATA_TYPE_BOOL) {
-      invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       return -1;
     } else {
       type = TSDB_DATA_TYPE_DOUBLE;
@@ -2008,7 +2008,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
     case TSDB_FUNC_COUNT: {
         /* more than one parameter for count() function */
       if (pItem->pNode->pParam != NULL && taosArrayGetSize(pItem->pNode->pParam) != 1) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
 
       SExprInfo* pExpr = NULL;
@@ -2019,7 +2019,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
         SStrToken* pToken = &pParamElem->pNode->colInfo;
         int16_t tokenId = pParamElem->pNode->tokenId;
         if ((pToken->z == NULL || pToken->n == 0) && (TK_INTEGER != tokenId)) {
-          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
         }
 
         // select count(table.*)
@@ -2029,7 +2029,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
           SStrToken tmpToken = pParamElem->pNode->colInfo;
 
           if (getTableIndexByName(&tmpToken, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-            return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+            return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
           }
 
           index = (SColumnIndex){0, PRIMARYKEY_TIMESTAMP_COL_INDEX};
@@ -2038,7 +2038,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
         } else {
           // count the number of table created according to the super table
           if (getColumnIndexByName(pCmd, pToken, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-            return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+            return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
           }
 
           pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
@@ -2101,21 +2101,21 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
       if (pItem->pNode->pParam == NULL || (functionId != TSDB_FUNC_LEASTSQR && taosArrayGetSize(pItem->pNode->pParam) != 1) ||
           (functionId == TSDB_FUNC_LEASTSQR && taosArrayGetSize(pItem->pNode->pParam) != 3)) {
         /* no parameters or more than one parameter for function */
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
 
       tSqlExprItem* pParamElem = taosArrayGet(pItem->pNode->pParam, 0);
       if (pParamElem->pNode->tokenId != TK_ALL && pParamElem->pNode->tokenId != TK_ID) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
 
       SColumnIndex index = COLUMN_INDEX_INITIALIZER;
       if ((getColumnIndexByName(pCmd, &pParamElem->pNode->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS)) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
       }
 
       if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
       }
 
       // 2. check if sql function can be applied on this column data type
@@ -2123,9 +2123,9 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
       SSchema* pSchema = tscGetTableColumnSchema(pTableMetaInfo->pTableMeta, index.columnIndex);
 
       if (!IS_NUMERIC_TYPE(pSchema->type)) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       } else if (IS_UNSIGNED_NUMERIC_TYPE(pSchema->type) && functionId == TSDB_FUNC_DIFF) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg9);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg9);
       }
 
       int16_t resultType = 0;
@@ -2134,7 +2134,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
 
       if (getResultDataInfo(pSchema->type, pSchema->bytes, functionId, 0, &resultType, &resultSize,
                             &intermediateResSize, 0, false) != TSDB_CODE_SUCCESS) {
-        return TSDB_CODE_TSC_INVALID_SQL;
+        return TSDB_CODE_TSC_INVALID_OPERATION;
       }
 
       // set the first column ts for diff query
@@ -2150,7 +2150,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
 
       // functions can not be applied to tags
       if (index.columnIndex >= tscGetNumOfColumns(pTableMetaInfo->pTableMeta)) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
       }
 
       SExprInfo* pExpr = tscExprAppend(pQueryInfo, functionId, &index, resultType, resultSize, getNewResColId(pCmd), resultSize, false);
@@ -2159,14 +2159,14 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
         /* set the leastsquares parameters */
         char val[8] = {0};
         if (tVariantDump(&pParamElem[1].pNode->value, val, TSDB_DATA_TYPE_DOUBLE, true) < 0) {
-          return TSDB_CODE_TSC_INVALID_SQL;
+          return TSDB_CODE_TSC_INVALID_OPERATION;
         }
 
         tscExprAddParams(&pExpr->base, val, TSDB_DATA_TYPE_DOUBLE, DOUBLE_BYTES);
 
         memset(val, 0, tListLen(val));
         if (tVariantDump(&pParamElem[2].pNode->value, val, TSDB_DATA_TYPE_DOUBLE, true) < 0) {
-          return TSDB_CODE_TSC_INVALID_SQL;
+          return TSDB_CODE_TSC_INVALID_OPERATION;
         }
 
         tscExprAddParams(&pExpr->base, val, TSDB_DATA_TYPE_DOUBLE, sizeof(double));
@@ -2204,18 +2204,18 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
 
       if (!requireAllFields) {
         if (taosArrayGetSize(pItem->pNode->pParam) < 1) {
-          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
         }
 
         if (taosArrayGetSize(pItem->pNode->pParam) > 1 && (pItem->aliasName != NULL && strlen(pItem->aliasName) > 0)) {
-          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg8);
+          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg8);
         }
 
         /* in first/last function, multiple columns can be add to resultset */
         for (int32_t i = 0; i < taosArrayGetSize(pItem->pNode->pParam); ++i) {
           tSqlExprItem* pParamElem = taosArrayGet(pItem->pNode->pParam, i);
           if (pParamElem->pNode->tokenId != TK_ALL && pParamElem->pNode->tokenId != TK_ID) {
-            return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+            return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
           }
 
           SColumnIndex index = COLUMN_INDEX_INITIALIZER;
@@ -2224,7 +2224,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
             SStrToken tmpToken = pParamElem->pNode->colInfo;
 
             if (getTableIndexByName(&tmpToken, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-              return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+              return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
             }
 
             pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
@@ -2237,20 +2237,20 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
               setResultColName(name, pItem, cvtFunc.originFuncId, &t, true);
 
               if (setExprInfoForFunctions(pCmd, pQueryInfo, &pSchema[j], cvtFunc, name, colIndex++, &index, finalResult) != 0) {
-                return TSDB_CODE_TSC_INVALID_SQL;
+                return TSDB_CODE_TSC_INVALID_OPERATION;
               }
             }
 
           } else {
             if (getColumnIndexByName(pCmd, &pParamElem->pNode->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-              return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+              return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
             }
 
             pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
 
             // functions can not be applied to tags
             if ((index.columnIndex >= tscGetNumOfColumns(pTableMetaInfo->pTableMeta)) || (index.columnIndex < 0)) {
-              return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);
+              return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
             }
 
             char name[TSDB_COL_NAME_LEN] = {0};
@@ -2260,7 +2260,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
             setResultColName(name, pItem, cvtFunc.originFuncId, &pParamElem->pNode->colInfo, multiColOutput);
 
             if (setExprInfoForFunctions(pCmd, pQueryInfo, pSchema, cvtFunc, name, colIndex++, &index, finalResult) != 0) {
-              return TSDB_CODE_TSC_INVALID_SQL;
+              return TSDB_CODE_TSC_INVALID_OPERATION;
             }
           }
         }
@@ -2271,7 +2271,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
 
         // multicolumn selection does not support alias name
         if (pItem->aliasName != NULL && strlen(pItem->aliasName) > 0) {
-          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg8);
+          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg8);
         }
 
         for (int32_t j = 0; j < pQueryInfo->numOfTables; ++j) {
@@ -2286,7 +2286,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
             setResultColName(name, pItem, cvtFunc.originFuncId, &t, true);
 
             if (setExprInfoForFunctions(pCmd, pQueryInfo, &pSchema[index.columnIndex], cvtFunc, name, colIndex, &index, finalResult) != 0) {
-              return TSDB_CODE_TSC_INVALID_SQL;
+              return TSDB_CODE_TSC_INVALID_OPERATION;
             }
             colIndex++;
           }
@@ -2305,21 +2305,21 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
       // 1. valid the number of parameters
       if (pItem->pNode->pParam == NULL || taosArrayGetSize(pItem->pNode->pParam) != 2) {
         /* no parameters or more than one parameter for function */
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
 
       tSqlExprItem* pParamElem = taosArrayGet(pItem->pNode->pParam, 0);
       if (pParamElem->pNode->tokenId != TK_ID) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
       
       SColumnIndex index = COLUMN_INDEX_INITIALIZER;
       if (getColumnIndexByName(pCmd, &pParamElem->pNode->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
       }
 
       if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
       }
       
       pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
@@ -2327,17 +2327,17 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
 
       // functions can not be applied to tags
       if (index.columnIndex >= tscGetNumOfColumns(pTableMetaInfo->pTableMeta)) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
       }
 
       // 2. valid the column type
       if (!IS_NUMERIC_TYPE(pSchema->type)) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
       // 3. valid the parameters
       if (pParamElem[1].pNode->tokenId == TK_ID) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
 
       tVariant* pVariant = &pParamElem[1].pNode->value;
@@ -2353,7 +2353,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
 
         double dp = GET_DOUBLE_VAL(val);
         if (dp < 0 || dp > TOP_BOTTOM_QUERY_LIMIT) {
-          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
         }
 
         resultSize = sizeof(double);
@@ -2374,7 +2374,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
 
         int64_t nTop = GET_INT32_VAL(val);
         if (nTop <= 0 || nTop > 100) {  // todo use macro
-          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
         }
 
         // todo REFACTOR
@@ -2414,12 +2414,12 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
     case TSDB_FUNC_TID_TAG: {
       pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
       if (UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo)) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg7);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg7);
       }
     
       // no parameters or more than one parameter for function
       if (pItem->pNode->pParam == NULL || taosArrayGetSize(pItem->pNode->pParam) != 1) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
       
       tSqlExprItem* pParamItem = taosArrayGet(pItem->pNode->pParam, 0);
@@ -2427,7 +2427,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
 
       SColumnIndex index = COLUMN_INDEX_INITIALIZER;
       if (getColumnIndexByName(pCmd, &pParam->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
       }
     
       pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
@@ -2436,7 +2436,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
       // functions can not be applied to normal columns
       int32_t numOfCols = tscGetNumOfColumns(pTableMetaInfo->pTableMeta);
       if (index.columnIndex < numOfCols && index.columnIndex != TSDB_TBNAME_COLUMN_INDEX) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
       }
     
       if (index.columnIndex > 0) {
@@ -2452,7 +2452,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
       }
       
       if (colType == TSDB_DATA_TYPE_BOOL) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
       tscColumnListInsert(pTableMetaInfo->tagColList, index.columnIndex, pTableMetaInfo->pTableMeta->id.uid,
@@ -2484,7 +2484,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
     case TSDB_FUNC_BLKINFO: {
       // no parameters or more than one parameter for function
       if (pItem->pNode->pParam != NULL && taosArrayGetSize(pItem->pNode->pParam) != 0) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
 
       SColumnIndex index = {.tableIndex = 0, .columnIndex = TSDB_BLOCK_DIST_COLUMN_INDEX,};
@@ -2507,7 +2507,7 @@ int32_t addExprAndResultField(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, int32_t col
     }
 
     default:
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
   }
   
 }
@@ -2594,7 +2594,7 @@ int32_t doGetColumnIndexByName(SSqlCmd* pCmd, SStrToken* pToken, SQueryInfo* pQu
 
         if (colIndex != COLUMN_INDEX_INITIAL_VAL) {
           if (pIndex->columnIndex != COLUMN_INDEX_INITIAL_VAL) {
-            return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg0);
+            return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg0);
           } else {
             pIndex->tableIndex = i;
             pIndex->columnIndex = colIndex;
@@ -2609,14 +2609,14 @@ int32_t doGetColumnIndexByName(SSqlCmd* pCmd, SStrToken* pToken, SQueryInfo* pQu
     }
 
     if (pIndex->columnIndex == COLUMN_INDEX_INITIAL_VAL) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
   }
 
   if (COLUMN_INDEX_VALIDE(*pIndex)) {
     return TSDB_CODE_SUCCESS;
   } else {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 }
 
@@ -2642,7 +2642,7 @@ int32_t getTableIndexImpl(SStrToken* pTableToken, SQueryInfo* pQueryInfo, SColum
   }
 
   if (pIndex->tableIndex < 0) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   return TSDB_CODE_SUCCESS;
@@ -2653,7 +2653,7 @@ int32_t getTableIndexByName(SStrToken* pToken, SQueryInfo* pQueryInfo, SColumnIn
   extractTableNameFromToken(pToken, &tableToken);
 
   if (getTableIndexImpl(&tableToken, pQueryInfo, pIndex) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   return TSDB_CODE_SUCCESS;
@@ -2661,13 +2661,13 @@ int32_t getTableIndexByName(SStrToken* pToken, SQueryInfo* pQueryInfo, SColumnIn
 
 int32_t getColumnIndexByName(SSqlCmd* pCmd, const SStrToken* pToken, SQueryInfo* pQueryInfo, SColumnIndex* pIndex) {
   if (pQueryInfo->pTableMetaInfo == NULL || pQueryInfo->numOfTables == 0) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   SStrToken tmpToken = *pToken;
 
   if (getTableIndexByName(&tmpToken, pQueryInfo, pIndex) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   return doGetColumnIndexByName(pCmd, &tmpToken, pQueryInfo, pIndex);
@@ -2676,7 +2676,6 @@ int32_t getColumnIndexByName(SSqlCmd* pCmd, const SStrToken* pToken, SQueryInfo*
 int32_t setShowInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   SSqlCmd*        pCmd = &pSql->cmd;
   STableMetaInfo* pTableMetaInfo = tscGetTableMetaInfoFromCmd(pCmd,  0);
-//  assert(pCmd->numOfClause == 1);
 
   pCmd->command = TSDB_SQL_SHOW;
 
@@ -2699,20 +2698,20 @@ int32_t setShowInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     if (pDbPrefixToken->type != 0) {
 
       if (pDbPrefixToken->n >= TSDB_DB_NAME_LEN) {  // db name is too long
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
       }
 
       if (pDbPrefixToken->n <= 0) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
       }
 
       if (tscValidateName(pDbPrefixToken) != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
       int32_t ret = tNameSetDbName(&pTableMetaInfo->name, getAccountId(pSql), pDbPrefixToken);
       if (ret != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
     }
 
@@ -2722,26 +2721,26 @@ int32_t setShowInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       pPattern->n = strdequote(pPattern->z);
 
       if (pPattern->n <= 0) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
       }
 
       if (!tscValidateTableNameLength(pCmd->payloadLen)) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
     }
   } else if (showType == TSDB_MGMT_TABLE_VNODES) {
     if (pShowInfo->prefix.type == 0) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), "No specified ip of dnode");
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), "No specified ip of dnode");
     }
 
     // show vnodes may be ip addr of dnode in payload
     SStrToken* pDnodeIp = &pShowInfo->prefix;
     if (pDnodeIp->n >= TSDB_IPv4ADDR_LEN) {  // ip addr is too long
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
     }
 
     if (!validateIpAddress(pDnodeIp->z, pDnodeIp->n)) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
     }
   } 
   return TSDB_CODE_SUCCESS;
@@ -2757,7 +2756,7 @@ int32_t setKillInfo(SSqlObj* pSql, struct SSqlInfo* pInfo, int32_t killType) {
   
   SStrToken* idStr = &(pInfo->pMiscInfo->id);
   if (idStr->n > TSDB_KILL_MSG_LEN) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   strncpy(pCmd->payload, idStr->z, idStr->n);
@@ -2769,7 +2768,7 @@ int32_t setKillInfo(SSqlObj* pSql, struct SSqlInfo* pInfo, int32_t killType) {
   int32_t connId = (int32_t)strtol(connIdStr, NULL, 10);
   if (connId <= 0) {
     memset(pCmd->payload, 0, strlen(pCmd->payload));
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   if (killType == TSDB_SQL_KILL_CONNECTION) {
@@ -2780,9 +2779,9 @@ int32_t setKillInfo(SSqlObj* pSql, struct SSqlInfo* pInfo, int32_t killType) {
   if (queryId <= 0) {
     memset(pCmd->payload, 0, strlen(pCmd->payload));
     if (killType == TSDB_SQL_KILL_QUERY) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
     } else {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
     }
   }
   
@@ -2804,7 +2803,7 @@ int32_t tscTansformFuncForSTableQuery(SQueryInfo* pQueryInfo) {
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
 
   if (pTableMetaInfo->pTableMeta == NULL || !UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   assert(tscGetNumOfTags(pTableMetaInfo->pTableMeta) >= 0);
@@ -2826,7 +2825,7 @@ int32_t tscTansformFuncForSTableQuery(SQueryInfo* pQueryInfo) {
         (functionId >= TSDB_FUNC_RATE && functionId <= TSDB_FUNC_AVG_IRATE)) {
       if (getResultDataInfo(pSrcSchema->type, pSrcSchema->bytes, functionId, (int32_t)pExpr->base.param[0].i64, &type, &bytes,
                             &interBytes, 0, true) != TSDB_CODE_SUCCESS) {
-        return TSDB_CODE_TSC_INVALID_SQL;
+        return TSDB_CODE_TSC_INVALID_OPERATION;
       }
 
       tscExprUpdate(pQueryInfo, k, functionId, pExpr->base.colInfo.colIndex, TSDB_DATA_TYPE_BINARY, bytes);
@@ -2883,24 +2882,24 @@ bool hasUnsupportFunctionsForSTableQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo)
   for (int32_t i = 0; i < size; ++i) {
     int32_t functionId = tscExprGet(pQueryInfo, i)->base.functionId;
     if ((aAggs[functionId].status & TSDB_FUNCSTATE_STABLE) == 0) {
-      invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
       return true;
     }
   }
 
   if (tscIsTWAQuery(pQueryInfo)) {
     if (pQueryInfo->groupbyExpr.numOfGroupCols == 0) {
-      invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       return true;
     }
 
     if (pQueryInfo->groupbyExpr.numOfGroupCols != 1) {
-      invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       return true;
     } else {
       SColIndex* pColIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, 0);
       if (pColIndex->colIndex != TSDB_TBNAME_COLUMN_INDEX) {
-        invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
         return true;
       }
     }
@@ -3000,11 +2999,11 @@ int32_t validateGroupbyNode(SQueryInfo* pQueryInfo, SArray* pList, SSqlCmd* pCmd
   
   pQueryInfo->groupbyExpr.numOfGroupCols = (int16_t)taosArrayGetSize(pList);
   if (pQueryInfo->groupbyExpr.numOfGroupCols > TSDB_MAX_TAGS) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   if (pQueryInfo->numOfTables > 1) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
   }
 
   STableMeta* pTableMeta = NULL;
@@ -3021,13 +3020,13 @@ int32_t validateGroupbyNode(SQueryInfo* pQueryInfo, SArray* pList, SSqlCmd* pCmd
 
     SColumnIndex index = COLUMN_INDEX_INITIALIZER;
     if (getColumnIndexByName(pCmd, &token, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
     }
 
     if (tableIndex == COLUMN_INDEX_INITIAL_VAL) {
       tableIndex = index.tableIndex;
     } else if (tableIndex != index.tableIndex) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
     }
 
     pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
@@ -3052,7 +3051,7 @@ int32_t validateGroupbyNode(SQueryInfo* pQueryInfo, SArray* pList, SSqlCmd* pCmd
     
     if (groupTag) {
       if (!UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg9);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg9);
       }
 
       int32_t relIndex = index.columnIndex;
@@ -3069,7 +3068,7 @@ int32_t validateGroupbyNode(SQueryInfo* pQueryInfo, SArray* pList, SSqlCmd* pCmd
     } else {
       // check if the column type is valid, here only support the bool/tinyint/smallint/bigint group by
       if (pSchema->type == TSDB_DATA_TYPE_TIMESTAMP || pSchema->type == TSDB_DATA_TYPE_FLOAT || pSchema->type == TSDB_DATA_TYPE_DOUBLE) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg8);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg8);
       }
 
       tscColumnListInsert(pQueryInfo->colList, index.columnIndex, pTableMeta->id.uid, pSchema);
@@ -3081,7 +3080,7 @@ int32_t validateGroupbyNode(SQueryInfo* pQueryInfo, SArray* pList, SSqlCmd* pCmd
       pQueryInfo->groupbyExpr.orderType = TSDB_ORDER_ASC;
 
       if (i == 0 && num > 1) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg7);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg7);
       }
     }
   }
@@ -3160,7 +3159,7 @@ static int32_t doExtractColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo,
   }
 
   if (retVal != TSDB_CODE_SUCCESS) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
   } 
 
   switch (pExpr->tokenId) {
@@ -3192,7 +3191,7 @@ static int32_t doExtractColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo,
       pColumnFilter->lowerRelOptr = TSDB_RELATION_NOTNULL;
       break;
     default:
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -3220,7 +3219,7 @@ static int32_t tablenameListToString(tSqlExpr* pExpr, SStringBuilder* sb) {
 
   int32_t size = (int32_t) taosArrayGetSize(pList);
   if (size <= 0) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   if (size > 0) {
@@ -3238,7 +3237,7 @@ static int32_t tablenameListToString(tSqlExpr* pExpr, SStringBuilder* sb) {
     }
 
     if (pVar->nLen <= 0 || !tscValidateTableNameLength(pVar->nLen)) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
   }
 
@@ -3294,7 +3293,7 @@ static int32_t extractColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SC
       return TSDB_CODE_TSC_OUT_OF_MEMORY;
     }
   } else {  // error;
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   pColFilter->filterstr =
@@ -3307,17 +3306,17 @@ static int32_t extractColumnFilterInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SC
       && pExpr->tokenId != TK_NOTNULL
       && pExpr->tokenId != TK_LIKE
       ) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
     }
   } else {
     if (pExpr->tokenId == TK_LIKE) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
     
     if (pSchema->type == TSDB_DATA_TYPE_BOOL) {
       int32_t t = pExpr->tokenId;
       if (t != TK_EQ && t != TK_NE && t != TK_NOTNULL && t != TK_ISNULL) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
       }
     }
   }
@@ -3341,7 +3340,7 @@ static int32_t getTablenameCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr*
   tSqlExpr* pRight = pTableCond->pRight;
 
   if (!isTablenameToken(&pLeft->colInfo)) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   int32_t ret = TSDB_CODE_SUCCESS;
@@ -3350,14 +3349,14 @@ static int32_t getTablenameCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr*
     ret = tablenameListToString(pRight, sb);
   } else if (pTableCond->tokenId == TK_LIKE) {
     if (pRight->tokenId != TK_STRING) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
     
     ret = tablenameCondToString(pRight, sb);
   }
 
   if (ret != TSDB_CODE_SUCCESS) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg0);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg0);
   }
 
   return ret;
@@ -3378,7 +3377,7 @@ static int32_t getColumnQueryCondInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSq
   } else {  // handle leaf node
     SColumnIndex index = COLUMN_INDEX_INITIALIZER;
     if (getColumnIndexByName(pCmd, &pExpr->pLeft->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     return extractColumnFilterInfo(pCmd, pQueryInfo, &index, pExpr, relOptr);
@@ -3407,7 +3406,7 @@ static int32_t checkAndSetJoinCondInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tS
 
   SColumnIndex index = COLUMN_INDEX_INITIALIZER;
   if (getColumnIndexByName(pCmd, &pExpr->pLeft->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
   }
 
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
@@ -3417,7 +3416,7 @@ static int32_t checkAndSetJoinCondInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tS
 
   SJoinNode **leftNode = &pQueryInfo->tagCond.joinInfo.joinTables[index.tableIndex];
   if (*leftNode == NULL) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   (*leftNode)->uid = pTableMetaInfo->pTableMeta->id.uid;
@@ -3431,7 +3430,7 @@ static int32_t checkAndSetJoinCondInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tS
       tscColumnListInsert(pTableMetaInfo->tagColList, index.columnIndex, pTableMeta->id.uid, pTagSchema1);
 
       if (taosArrayGetSize(pTableMetaInfo->tagColList) > 1) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
     }
   }
@@ -3440,7 +3439,7 @@ static int32_t checkAndSetJoinCondInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tS
 
   index = (SColumnIndex)COLUMN_INDEX_INITIALIZER;
   if (getColumnIndexByName(pCmd, &pExpr->pRight->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
   }
 
   pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
@@ -3450,7 +3449,7 @@ static int32_t checkAndSetJoinCondInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tS
 
   SJoinNode **rightNode = &pQueryInfo->tagCond.joinInfo.joinTables[index.tableIndex];
   if (*rightNode == NULL) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   (*rightNode)->uid = pTableMetaInfo->pTableMeta->id.uid;
@@ -3463,7 +3462,7 @@ static int32_t checkAndSetJoinCondInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tS
 
       tscColumnListInsert(pTableMetaInfo->tagColList, index.columnIndex, pTableMeta->id.uid, pTagSchema2);
       if (taosArrayGetSize(pTableMetaInfo->tagColList) > 1) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
     }
   }
@@ -3471,7 +3470,7 @@ static int32_t checkAndSetJoinCondInfo(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tS
   int16_t rightIdx = index.tableIndex;
 
   if (pTagSchema1->type != pTagSchema2->type) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
   }
 
   if ((*leftNode)->tagJoin == NULL) {
@@ -3505,12 +3504,12 @@ static int32_t validateSQLExpr(SSqlCmd* pCmd, tSqlExpr* pExpr, SQueryInfo* pQuer
     if (*type == NON_ARITHMEIC_EXPR) {
       *type = NORMAL_ARITHMETIC;
     } else if (*type == AGG_ARIGHTMEIC) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     SColumnIndex index = COLUMN_INDEX_INITIALIZER;
     if (getColumnIndexByName(pCmd, &pExpr->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     // if column is timestamp, bool, binary, nchar, not support arithmetic, so return invalid sql
@@ -3519,18 +3518,18 @@ static int32_t validateSQLExpr(SSqlCmd* pCmd, tSqlExpr* pExpr, SQueryInfo* pQuer
     
     if ((pSchema->type == TSDB_DATA_TYPE_TIMESTAMP) || (pSchema->type == TSDB_DATA_TYPE_BOOL) ||
         (pSchema->type == TSDB_DATA_TYPE_BINARY) || (pSchema->type == TSDB_DATA_TYPE_NCHAR)) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     pList->ids[pList->num++] = index;
   } else if ((pExpr->tokenId == TK_FLOAT && (isnan(pExpr->value.dKey) || isinf(pExpr->value.dKey))) ||
              pExpr->tokenId == TK_NULL) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   } else if (pExpr->type == SQL_NODE_SQLFUNCTION) {
     if (*type == NON_ARITHMEIC_EXPR) {
       *type = AGG_ARIGHTMEIC;
     } else if (*type == NORMAL_ARITHMETIC) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     int32_t outputIndex = (int32_t)tscNumOfExprs(pQueryInfo);
@@ -3541,17 +3540,17 @@ static int32_t validateSQLExpr(SSqlCmd* pCmd, tSqlExpr* pExpr, SQueryInfo* pQuer
     // Append the sqlExpr into exprList of pQueryInfo structure sequentially
     pExpr->functionId = isValidFunction(pExpr->operand.z, pExpr->operand.n);
     if (pExpr->functionId < 0) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     if (addExprAndResultField(pCmd, pQueryInfo, outputIndex, &item, false) != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     // It is invalid in case of more than one sqlExpr, such as first(ts, k) - last(ts, k)
     int32_t inc = (int32_t) tscNumOfExprs(pQueryInfo) - outputIndex;
     if (inc > 1) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     // Not supported data type in arithmetic expression
@@ -3560,13 +3559,13 @@ static int32_t validateSQLExpr(SSqlCmd* pCmd, tSqlExpr* pExpr, SQueryInfo* pQuer
       SExprInfo* p1 = tscExprGet(pQueryInfo, i + outputIndex);
       int16_t t = p1->base.resType;
       if (t == TSDB_DATA_TYPE_BINARY || t == TSDB_DATA_TYPE_NCHAR || t == TSDB_DATA_TYPE_BOOL || t == TSDB_DATA_TYPE_TIMESTAMP) {
-        return TSDB_CODE_TSC_INVALID_SQL;
+        return TSDB_CODE_TSC_INVALID_OPERATION;
       }
 
       if (i == 0) {
         id = p1->base.uid;
       } else if (id != p1->base.uid) {
-        return TSDB_CODE_TSC_INVALID_SQL;
+        return TSDB_CODE_TSC_INVALID_OPERATION;
       }
     }
 
@@ -3611,7 +3610,7 @@ static int32_t validateArithmeticSQLExpr(SSqlCmd* pCmd, tSqlExpr* pExpr, SQueryI
 
     // the expression not from the same table, return error
     if (uidLeft != uidRight && uidLeft != 0 && uidRight != 0) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
   }
 
@@ -3695,14 +3694,14 @@ static bool validateJoinExprNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr
   }
 
   if (pExpr->tokenId != TK_EQ) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
     return false;
   }
 
   SColumnIndex rightIndex = COLUMN_INDEX_INITIALIZER;
 
   if (getColumnIndexByName(pCmd, &pRight->colInfo, pQueryInfo, &rightIndex) != TSDB_CODE_SUCCESS) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     return false;
   }
 
@@ -3720,16 +3719,16 @@ static bool validateJoinExprNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr
   tscColumnListInsert(pQueryInfo->colList, rightIndex.columnIndex, pRightMeterMeta->pTableMeta->id.uid, &pRightSchema[rightIndex.columnIndex]);
 
   if (leftType != rightType) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
     return false;
   } else if (pLeftIndex->tableIndex == rightIndex.tableIndex) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
     return false;
   }
 
   // table to table/ super table to super table are allowed
   if (UTIL_TABLE_IS_SUPER_TABLE(pLeftMeterMeta) != UTIL_TABLE_IS_SUPER_TABLE(pRightMeterMeta)) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
     return false;
   }
 
@@ -3751,7 +3750,7 @@ static bool validTableNameOptr(tSqlExpr* pExpr) {
 static int32_t setExprToCond(tSqlExpr** parent, tSqlExpr* pExpr, const char* msg, int32_t parentOptr, char* msgBuf) {
   if (*parent != NULL) {
     if (parentOptr == TK_OR && msg != NULL) {
-      return invalidSqlErrMsg(msgBuf, msg);
+      return invalidOperationMsg(msgBuf, msg);
     }
 
     *parent = tSqlExprCreate((*parent), pExpr, parentOptr);
@@ -3767,7 +3766,7 @@ static int32_t validateNullExpr(tSqlExpr* pExpr, char* msgBuf) {
 
   tSqlExpr* pRight = pExpr->pRight;
   if (pRight->tokenId == TK_NULL && (!(pExpr->tokenId == TK_ISNULL || pExpr->tokenId == TK_NOTNULL))) {
-    return invalidSqlErrMsg(msgBuf, msg);
+    return invalidOperationMsg(msgBuf, msg);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -3783,12 +3782,12 @@ static int32_t validateLikeExpr(tSqlExpr* pExpr, STableMeta* pTableMeta, int32_t
 
   if (pExpr->tokenId == TK_LIKE) {
     if (pRight->value.nLen > TSDB_PATTERN_STRING_MAX_LEN) {
-      return invalidSqlErrMsg(msgBuf, msg1);
+      return invalidOperationMsg(msgBuf, msg1);
     }
 
     SSchema* pSchema = tscGetTableSchema(pTableMeta);
     if ((!isTablenameToken(&pLeft->colInfo)) && !IS_VAR_DATA_TYPE(pSchema[index].type)) {
-      return invalidSqlErrMsg(msgBuf, msg2);
+      return invalidOperationMsg(msgBuf, msg2);
     }
   }
 
@@ -3812,7 +3811,7 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
 
   SColumnIndex index = COLUMN_INDEX_INITIALIZER;
   if (getColumnIndexByName(pCmd, &pLeft->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
   }
 
   assert(tSqlExprIsParentOfLeaf(*pExpr));
@@ -3834,7 +3833,7 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
 
   if (index.columnIndex == PRIMARYKEY_TIMESTAMP_COL_INDEX) {  // query on time range
     if (!validateJoinExprNode(pCmd, pQueryInfo, *pExpr, &index)) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     // set join query condition
@@ -3854,11 +3853,11 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
       int16_t leftIdx = index.tableIndex;
 
       if (getColumnIndexByName(pCmd, &pRight->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
 
       if (index.tableIndex < 0 || index.tableIndex >= TSDB_MAX_JOIN_TABLE_NUM) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
       }
 
       SJoinNode **rightNode = &pQueryInfo->tagCond.joinInfo.joinTables[index.tableIndex];
@@ -3896,17 +3895,17 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
   } else if (index.columnIndex >= tscGetNumOfColumns(pTableMeta) || index.columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
     // query on tags, check for tag query condition
     if (UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo)) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 
     // in case of in operator, keep it in a seprate attribute
     if (index.columnIndex == TSDB_TBNAME_COLUMN_INDEX) {
       if (!validTableNameOptr(*pExpr)) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg7);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg7);
       }
   
       if (!UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
       if (pCondExpr->pTableCond == NULL) {
@@ -3914,7 +3913,7 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
         pCondExpr->relType = parentOptr;
         pCondExpr->tableCondIndex = index.tableIndex;
       } else {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
       }
 
       *type = TSQL_EXPR_TBNAME;
@@ -3922,7 +3921,7 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
     } else {
       if (pRight != NULL && pRight->tokenId == TK_ID) {  // join on tag columns for stable query
         if (!validateJoinExprNode(pCmd, pQueryInfo, *pExpr, &index)) {
-          return TSDB_CODE_TSC_INVALID_SQL;
+          return TSDB_CODE_TSC_INVALID_OPERATION;
         }
 
         pQueryInfo->type |= TSDB_QUERY_TYPE_JOIN_QUERY;
@@ -3941,7 +3940,7 @@ static int32_t handleExprInQueryCond(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSql
     *type = TSQL_EXPR_COLUMN;
 
     if (pRight->tokenId == TK_ID) {  // other column cannot be served as the join column
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
     }
 
     ret = setExprToCond(&pCondExpr->pColumnCond, *pExpr, NULL, parentOptr, pQueryInfo->msg);
@@ -3960,14 +3959,14 @@ int32_t getQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr** pExpr
   const char* msg1 = "query condition between different columns must use 'AND'";
 
   if ((*pExpr)->flags & (1 << EXPR_FLAG_TS_ERROR)) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   tSqlExpr* pLeft = (*pExpr)->pLeft;
   tSqlExpr* pRight = (*pExpr)->pRight;
 
   if (!isValidExpr(pLeft, pRight, (*pExpr)->tokenId)) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   int32_t leftType = -1;
@@ -3990,7 +3989,7 @@ int32_t getQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr** pExpr
      */
     if (leftType != rightType) {
       if ((*pExpr)->tokenId == TK_OR && (leftType + rightType != TSQL_EXPR_TBNAME + TSQL_EXPR_TAG)) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
     }
 
@@ -4001,11 +4000,11 @@ int32_t getQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlExpr** pExpr
   exchangeExpr(*pExpr);
 
   if (pLeft->tokenId == TK_ID && pRight->tokenId == TK_TIMESTAMP && (pRight->flags & (1 << EXPR_FLAG_TIMESTAMP_VAR))) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   if ((pLeft->flags & (1 << EXPR_FLAG_TS_ERROR)) || (pRight->flags & (1 << EXPR_FLAG_TS_ERROR))) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   return handleExprInQueryCond(pCmd, pQueryInfo, pExpr, pCondExpr, type, parentOptr);
@@ -4117,7 +4116,7 @@ static int32_t setTableCondForSTableQuery(SSqlCmd* pCmd, SQueryInfo* pQueryInfo,
       taosStringBuilderDestroy(&sb1);
       tfree(segments);
 
-      invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+      invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
       return ret;
     }
 
@@ -4172,7 +4171,7 @@ static int32_t getTimeRangeFromExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlE
 
   if (!tSqlExprIsParentOfLeaf(pExpr)) {
     if (pExpr->tokenId == TK_OR) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 
     code = getTimeRangeFromExpr(pCmd, pQueryInfo, pExpr->pLeft);
@@ -4184,7 +4183,7 @@ static int32_t getTimeRangeFromExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlE
   } else {
     SColumnIndex index = COLUMN_INDEX_INITIALIZER;
     if (getColumnIndexByName(pCmd, &pExpr->pLeft->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
@@ -4194,7 +4193,7 @@ static int32_t getTimeRangeFromExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, tSqlE
 
     STimeWindow win = {.skey = INT64_MIN, .ekey = INT64_MAX};
     if (getTimeRange(&win, pRight, pExpr->tokenId, tinfo.precision) != TSDB_CODE_SUCCESS) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg0);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg0);
     }
 
     // update the timestamp query range
@@ -4219,7 +4218,7 @@ static int32_t validateJoinExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SCondExpr
     if (pQueryInfo->numOfTables == 1) {
       return TSDB_CODE_SUCCESS;
     } else {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
     }
   }
 
@@ -4227,12 +4226,12 @@ static int32_t validateJoinExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SCondExpr
   if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {  // for stable join, tag columns
                                                    // must be present for join
     if (pCondExpr->pJoinExpr == NULL) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
   }
 
   if (!pCondExpr->tsJoin) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -4303,7 +4302,7 @@ static int32_t validateTagCondExpr(SSqlCmd* pCmd, tExprNode *p) {
     }
     
     if (IS_ARITHMETIC_OPTR(p->_node.optr)) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1); 
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
     
     if (!IS_RELATION_OPTR(p->_node.optr)) {
@@ -4361,7 +4360,7 @@ static int32_t validateTagCondExpr(SSqlCmd* pCmd, tExprNode *p) {
     }
     
     if (retVal != TSDB_CODE_SUCCESS) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
     }
   } while (0);
 
@@ -4422,7 +4421,7 @@ static int32_t getTagQueryCondExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SCondE
     
     taosArrayDestroy(colList);
     if (pQueryInfo->tagCond.pCond != NULL && taosArrayGetSize(pQueryInfo->tagCond.pCond) > 0 && !UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), "filter on tag not supported for normal table");
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), "filter on tag not supported for normal table");
     }
 
     if (ret) {
@@ -4442,7 +4441,7 @@ int32_t validateJoinNodes(SQueryInfo* pQueryInfo, SSqlObj* pSql) {
     SJoinNode *node = pQueryInfo->tagCond.joinInfo.joinTables[i];
 
     if (node == NULL || node->tsJoin == NULL || taosArrayGetSize(node->tsJoin) <= 0) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(&pSql->cmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(&pSql->cmd), msg1);
     }
   }
 
@@ -4452,7 +4451,7 @@ int32_t validateJoinNodes(SQueryInfo* pQueryInfo, SSqlObj* pSql) {
       SJoinNode *node = pQueryInfo->tagCond.joinInfo.joinTables[i];
 
       if (node == NULL || node->tagJoin == NULL || taosArrayGetSize(node->tagJoin) <= 0) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(&pSql->cmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(&pSql->cmd), msg2);
       }
     }
   }
@@ -4500,7 +4499,7 @@ int32_t mergeJoinNodes(SQueryInfo* pQueryInfo, SSqlObj* pSql) {
   }
 
   if (taosArrayGetSize(pQueryInfo->tagCond.joinInfo.joinTables[0]->tsJoin) != pQueryInfo->numOfTables) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(&pSql->cmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(&pSql->cmd), msg1);
   }
 
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, 0);
@@ -4521,7 +4520,7 @@ int32_t mergeJoinNodes(SQueryInfo* pQueryInfo, SSqlObj* pSql) {
     }
 
     if (taosArrayGetSize(pQueryInfo->tagCond.joinInfo.joinTables[0]->tagJoin) != pQueryInfo->numOfTables) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(&pSql->cmd), msg2);
+      return invalidOperationMsg(tscGetErrorMsgPayload(&pSql->cmd), msg2);
     }
 
   }
@@ -4545,7 +4544,7 @@ int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSq
   SCondExpr      condExpr = {0};
 
   if ((*pExpr)->pLeft == NULL || (*pExpr)->pRight == NULL) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(&pSql->cmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(&pSql->cmd), msg1);
   }
 
   int32_t type = 0;
@@ -4598,7 +4597,7 @@ int32_t validateWhereNode(SQueryInfo* pQueryInfo, tSqlExpr** pExpr, SSqlObj* pSq
   }
 
   if (!validateFilterExpr(pQueryInfo)) {
-    ret = invalidSqlErrMsg(tscGetErrorMsgPayload(&pSql->cmd), msg2);
+    ret = invalidOperationMsg(tscGetErrorMsgPayload(&pSql->cmd), msg2);
     goto PARSE_WHERE_EXIT;
   }
 
@@ -4632,7 +4631,7 @@ int32_t getTimeRange(STimeWindow* win, tSqlExpr* pRight, int32_t optr, int16_t t
    * where ts in ('2015-12-12 4:8:12')
    */
   if (pRight->tokenId == TK_SET || optr == TK_IN) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   int64_t val = 0;
@@ -4645,14 +4644,14 @@ int32_t getTimeRange(STimeWindow* win, tSqlExpr* pRight, int32_t optr, int16_t t
       if (taosParseTime(pRight->value.pz, &val, pRight->value.nLen, TSDB_TIME_PRECISION_MICRO, tsDaylight) == TSDB_CODE_SUCCESS) {
         parsed = true;
       } else {
-        return TSDB_CODE_TSC_INVALID_SQL;
+        return TSDB_CODE_TSC_INVALID_OPERATION;
       }
     } else {
       SStrToken token = {.z = pRight->value.pz, .n = pRight->value.nLen, .type = TK_ID};
       int32_t   len = tGetToken(pRight->value.pz, &token.type);
 
       if ((token.type != TK_INTEGER && token.type != TK_FLOAT) || len != pRight->value.nLen) {
-        return TSDB_CODE_TSC_INVALID_SQL;
+        return TSDB_CODE_TSC_INVALID_OPERATION;
       }
     }
   } else if (pRight->tokenId == TK_INTEGER && timePrecision == TSDB_TIME_PRECISION_MILLI) {
@@ -4733,7 +4732,7 @@ int32_t tsRewriteFieldNameIfNecessary(SSqlCmd* pCmd, SQueryInfo* pQueryInfo) {
     for (int32_t j = i + 1; j < pQueryInfo->fieldsInfo.numOfOutput; ++j) {
       if (strncasecmp(fieldName, tscFieldInfoGetField(&pQueryInfo->fieldsInfo, j)->name, (TSDB_COL_NAME_LEN - 1)) == 0) {
         const char* msg = "duplicated column name in new table";
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
       }
     }
   }
@@ -4758,7 +4757,7 @@ int32_t validateFillNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlNo
   const char* msg5 = "fill only available for interval query";
 
   if ((!isTimeWindowQuery(pQueryInfo)) && (!tscIsPointInterpQuery(pQueryInfo))) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
   }
 
   /*
@@ -4766,12 +4765,12 @@ int32_t validateFillNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlNo
    * the columns may be increased due to group by operation
    */
   if (checkQueryRangeForFill(pCmd, pQueryInfo) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
 
   if (pItem->pVar.nType != TSDB_DATA_TYPE_BINARY) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
   }
   
   size_t numOfFields = tscNumOfFields(pQueryInfo);
@@ -4802,7 +4801,7 @@ int32_t validateFillNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlNo
 
     size_t num = taosArrayGetSize(pFillToken);
     if (num == 1) {  // no actual value, return with error code
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 
     int32_t startPos = 1;
@@ -4832,7 +4831,7 @@ int32_t validateFillNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlNo
       tVariant* p = taosArrayGet(pFillToken, j);
       int32_t ret = tVariantDump(p, (char*)&pQueryInfo->fillVal[i], pField->type, true);
       if (ret != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
       }
     }
     
@@ -4850,14 +4849,14 @@ int32_t validateFillNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlNo
       }
     }
   } else {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
   }
 
   size_t numOfExprs = tscNumOfExprs(pQueryInfo);
   for(int32_t i = 0; i < numOfExprs; ++i) {
     SExprInfo* pExpr = tscExprGet(pQueryInfo, i);
     if (pExpr->base.functionId == TSDB_FUNC_TOP || pExpr->base.functionId == TSDB_FUNC_BOTTOM) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
     }
   }
 
@@ -4911,11 +4910,11 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
   size_t size = taosArrayGetSize(pSortorder);
   if (UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo)) {
     if (size > 1) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg0);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg0);
     }
   } else {
     if (size > 2) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
     }
   }
 
@@ -4932,7 +4931,7 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
 
   if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {  // super table query
     if (getColumnIndexByName(pCmd, &columnName, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 
     bool orderByTags = false;
@@ -4943,7 +4942,7 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
       
       // it is a tag column
       if (pQueryInfo->groupbyExpr.columnInfo == NULL) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
       SColIndex* pColIndex = taosArrayGet(pQueryInfo->groupbyExpr.columnInfo, 0);
       if (relTagIndex == pColIndex->colIndex) {
@@ -4958,7 +4957,7 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
     }
 
     if (!(orderByTags || orderByTS) && !isTopBottomQuery(pQueryInfo)) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
     } else {  // order by top/bottom result value column is not supported in case of interval query.
       assert(!(orderByTags && orderByTS));
     }
@@ -4977,7 +4976,7 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
 
         pExpr = tscExprGet(pQueryInfo, 1);
         if (pExpr->base.colInfo.colIndex != index.columnIndex && index.columnIndex != PRIMARYKEY_TIMESTAMP_COL_INDEX) {
-          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
         }
 
         tVariantListItem* p1 = taosArrayGet(pSqlNode->pSortOrder, 0);
@@ -5011,11 +5010,11 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
       tVariant* pVar2 = &pItem->pVar;
       SStrToken cname = {pVar2->nLen, pVar2->nType, pVar2->pz};
       if (getColumnIndexByName(pCmd, &cname, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
       if (index.columnIndex != PRIMARYKEY_TIMESTAMP_COL_INDEX) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       } else {
         tVariantListItem* p1 = taosArrayGet(pSortorder, 1);
         pQueryInfo->order.order = p1->sortOrder;
@@ -5025,11 +5024,11 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
 
   } else {  // meter query
     if (getColumnIndexByName(pCmd, &columnName, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 
     if (index.columnIndex != PRIMARYKEY_TIMESTAMP_COL_INDEX && !isTopBottomQuery(pQueryInfo)) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
     }
 
     if (isTopBottomQuery(pQueryInfo)) {
@@ -5039,7 +5038,7 @@ int32_t validateOrderbyNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
 
       pExpr = tscExprGet(pQueryInfo, 1);
       if (pExpr->base.colInfo.colIndex != index.columnIndex && index.columnIndex != PRIMARYKEY_TIMESTAMP_COL_INDEX) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
 
       tVariantListItem* pItem = taosArrayGet(pSqlNode->pSortOrder, 0);
@@ -5090,7 +5089,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, DEFAULT_TABLE_INDEX);
 
   if (tscValidateName(&(pAlterSQL->name)) != TSDB_CODE_SUCCESS) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   code = tscSetTableFullName(&pTableMetaInfo->name, &(pAlterSQL->name), pSql);
@@ -5106,60 +5105,60 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
 
   if (pAlterSQL->tableType == TSDB_SUPER_TABLE && !(UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo))) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg20);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg20);
   }
 
   if (pAlterSQL->type == TSDB_ALTER_TABLE_ADD_TAG_COLUMN || pAlterSQL->type == TSDB_ALTER_TABLE_DROP_TAG_COLUMN ||
       pAlterSQL->type == TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN) {
     if (UTIL_TABLE_IS_NORMAL_TABLE(pTableMetaInfo)) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
     }
   } else if ((pAlterSQL->type == TSDB_ALTER_TABLE_UPDATE_TAG_VAL) && (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo))) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
   } else if ((pAlterSQL->type == TSDB_ALTER_TABLE_ADD_COLUMN || pAlterSQL->type == TSDB_ALTER_TABLE_DROP_COLUMN) &&
              UTIL_TABLE_IS_CHILD_TABLE(pTableMetaInfo)) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
   }
 
   if (pAlterSQL->type == TSDB_ALTER_TABLE_ADD_TAG_COLUMN) {
     SArray* pFieldList = pAlterSQL->pAddColumns;
     if (taosArrayGetSize(pFieldList) > 1) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
     }
 
     TAOS_FIELD* p = taosArrayGet(pFieldList, 0);
     if (!validateOneTags(pCmd, p)) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
   
     tscFieldInfoAppend(&pQueryInfo->fieldsInfo, p);
   } else if (pAlterSQL->type == TSDB_ALTER_TABLE_DROP_TAG_COLUMN) {
     if (tscGetNumOfTags(pTableMeta) == 1) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg7);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg7);
     }
 
     // numOfTags == 1
     if (taosArrayGetSize(pAlterSQL->varList) > 1) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg8);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg8);
     }
 
     tVariantListItem* pItem = taosArrayGet(pAlterSQL->varList, 0);
     if (pItem->pVar.nLen >= TSDB_COL_NAME_LEN) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg9);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg9);
     }
 
     SColumnIndex index = COLUMN_INDEX_INITIALIZER;
     SStrToken    name = {.z = pItem->pVar.pz, .n = pItem->pVar.nLen, .type = TK_STRING};
 
     if (getColumnIndexByName(pCmd, &name, pQueryInfo, &index) != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     int32_t numOfCols = tscGetNumOfColumns(pTableMeta);
     if (index.columnIndex < numOfCols) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg10);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg10);
     } else if (index.columnIndex == numOfCols) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg11);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg11);
     }
 
     char name1[128] = {0};
@@ -5170,18 +5169,18 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   } else if (pAlterSQL->type == TSDB_ALTER_TABLE_CHANGE_TAG_COLUMN) {
     SArray* pVarList = pAlterSQL->varList;
     if (taosArrayGetSize(pVarList) > 2) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     tVariantListItem* pSrcItem = taosArrayGet(pAlterSQL->varList, 0);
     tVariantListItem* pDstItem = taosArrayGet(pAlterSQL->varList, 1);
 
     if (pSrcItem->pVar.nLen >= TSDB_COL_NAME_LEN || pDstItem->pVar.nLen >= TSDB_COL_NAME_LEN) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg9);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg9);
     }
 
     if (pSrcItem->pVar.nType != TSDB_DATA_TYPE_BINARY || pDstItem->pVar.nType != TSDB_DATA_TYPE_BINARY) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg10);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg10);
     }
 
     SColumnIndex srcIndex = COLUMN_INDEX_INITIALIZER;
@@ -5189,12 +5188,12 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
     SStrToken srcToken = {.z = pSrcItem->pVar.pz, .n = pSrcItem->pVar.nLen, .type = TK_STRING};
     if (getColumnIndexByName(pCmd, &srcToken, pQueryInfo, &srcIndex) != TSDB_CODE_SUCCESS) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg17);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg17);
     }
 
     SStrToken destToken = {.z = pDstItem->pVar.pz, .n = pDstItem->pVar.nLen, .type = TK_STRING};
     if (getColumnIndexByName(pCmd, &destToken, pQueryInfo, &destIndex) == TSDB_CODE_SUCCESS) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg19);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg19);
     }
 
     tVariantListItem* pItem = taosArrayGet(pVarList, 0);
@@ -5222,11 +5221,11 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     SColumnIndex columnIndex = COLUMN_INDEX_INITIALIZER;
     SStrToken    name = {.type = TK_STRING, .z = item->pVar.pz, .n = item->pVar.nLen};
     if (getColumnIndexByName(pCmd, &name, pQueryInfo, &columnIndex) != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     if (columnIndex.columnIndex < tscGetNumOfColumns(pTableMeta)) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg12);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg12);
     }
 
     tVariantListItem* pItem = taosArrayGet(pVarList, 1);
@@ -5234,7 +5233,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     pAlterSQL->tagData.data = calloc(1, pTagsSchema->bytes * TSDB_NCHAR_SIZE + VARSTR_HEADER_SIZE);
 
     if (tVariantDump(&pItem->pVar, pAlterSQL->tagData.data, pTagsSchema->type, true) != TSDB_CODE_SUCCESS) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg13);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg13);
     }
     
     pAlterSQL->tagData.dataLen = pTagsSchema->bytes;
@@ -5242,7 +5241,7 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     // validate the length of binary
     if ((pTagsSchema->type == TSDB_DATA_TYPE_BINARY || pTagsSchema->type == TSDB_DATA_TYPE_NCHAR) &&
         varDataTLen(pAlterSQL->tagData.data) > pTagsSchema->bytes) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg14);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg14);
     }
 
     int32_t schemaLen = sizeof(STColumn) * numOfTags;
@@ -5297,23 +5296,23 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     SArray* pFieldList = pAlterSQL->pAddColumns;
     if (taosArrayGetSize(pFieldList) > 1) {
       const char* msg = "only support add one column";
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
     }
 
     TAOS_FIELD* p = taosArrayGet(pFieldList, 0);
     if (!validateOneColumn(pCmd, p)) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
   
     tscFieldInfoAppend(&pQueryInfo->fieldsInfo, p);
   } else if (pAlterSQL->type == TSDB_ALTER_TABLE_DROP_COLUMN) {
     if (tscGetNumOfColumns(pTableMeta) == TSDB_MIN_COLUMNS) {  //
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg15);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg15);
     }
 
     size_t size = taosArrayGetSize(pAlterSQL->varList);
     if (size > 1) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg16);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg16);
     }
 
     tVariantListItem* pItem = taosArrayGet(pAlterSQL->varList, 0);
@@ -5321,11 +5320,11 @@ int32_t setAlterTableInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
     SColumnIndex columnIndex = COLUMN_INDEX_INITIALIZER;
     SStrToken    name = {.type = TK_STRING, .z = pItem->pVar.pz, .n = pItem->pVar.nLen};
     if (getColumnIndexByName(pCmd, &name, pQueryInfo, &columnIndex) != TSDB_CODE_SUCCESS) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg17);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg17);
     }
 
     if (columnIndex.columnIndex == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg18);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg18);
     }
 
     char name1[TSDB_COL_NAME_LEN] = {0};
@@ -5344,14 +5343,14 @@ int32_t validateSqlFunctionInStreamSql(SSqlCmd* pCmd, SQueryInfo* pQueryInfo) {
   if (pQueryInfo->interval.interval != 0 && pQueryInfo->interval.interval < 10 &&
      pQueryInfo->interval.intervalUnit != 'n' &&
      pQueryInfo->interval.intervalUnit != 'y') {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg0);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg0);
   }
   
   size_t size = taosArrayGetSize(pQueryInfo->exprList);
   for (int32_t i = 0; i < size; ++i) {
     int32_t functId = tscExprGet(pQueryInfo, i)->base.functionId;
     if (!IS_STREAM_QUERY_VALID(aAggs[functId].status)) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
   }
 
@@ -5391,10 +5390,10 @@ int32_t validateFunctionsInIntervalOrGroupbyQuery(SSqlCmd* pCmd, SQueryInfo* pQu
   }
 
   if (isProjectionFunction) {
-    invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
-  return isProjectionFunction == true ? TSDB_CODE_TSC_INVALID_SQL : TSDB_CODE_SUCCESS;
+  return isProjectionFunction == true ? TSDB_CODE_TSC_INVALID_OPERATION : TSDB_CODE_SUCCESS;
 }
 
 typedef struct SDNodeDynConfOption {
@@ -5411,12 +5410,12 @@ int32_t validateEp(char* ep) {
   if (NULL == pos) {
     int32_t val = strtol(ep, NULL, 10);
     if (val <= 0 || val > 65536) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
   } else {
     uint16_t port = atoi(pos + 1);
     if (0 == port) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
   }
 
@@ -5427,7 +5426,7 @@ int32_t validateDNodeConfig(SMiscInfo* pOptions) {
   int32_t numOfToken = (int32_t) taosArrayGetSize(pOptions->a);
 
   if (numOfToken < 2 || numOfToken > 3) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   const int tokenLogEnd = 2;
@@ -5462,7 +5461,7 @@ int32_t validateDNodeConfig(SMiscInfo* pOptions) {
     strdequote(pValToken->z);
     bool parseOk = taosCheckBalanceCfgOptions(pValToken->z, &vnodeId, &dnodeId);
     if (!parseOk) {
-      return TSDB_CODE_TSC_INVALID_SQL;  // options value is invalid
+      return TSDB_CODE_TSC_INVALID_OPERATION;  // options value is invalid
     }
     return TSDB_CODE_SUCCESS;
   } else if ((strncasecmp(cfgOptions[tokenMonitor].name, pOptionToken->z, pOptionToken->n) == 0) &&
@@ -5470,7 +5469,7 @@ int32_t validateDNodeConfig(SMiscInfo* pOptions) {
     SStrToken* pValToken = taosArrayGet(pOptions->a, 2);
     int32_t    val = strtol(pValToken->z, NULL, 10);
     if (val != 0 && val != 1) {
-      return TSDB_CODE_TSC_INVALID_SQL;  // options value is invalid
+      return TSDB_CODE_TSC_INVALID_OPERATION;  // options value is invalid
     }
     return TSDB_CODE_SUCCESS;
   } else {
@@ -5479,7 +5478,7 @@ int32_t validateDNodeConfig(SMiscInfo* pOptions) {
     int32_t val = strtol(pValToken->z, NULL, 10);
     if (val < 0 || val > 256) {
       /* options value is out of valid range */
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     for (int32_t i = tokenDebugFlag; i < tokenDebugFlagEnd; ++i) {
@@ -5492,13 +5491,13 @@ int32_t validateDNodeConfig(SMiscInfo* pOptions) {
     }
   }
 
-  return TSDB_CODE_TSC_INVALID_SQL;
+  return TSDB_CODE_TSC_INVALID_OPERATION;
 }
 
 int32_t validateLocalConfig(SMiscInfo* pOptions) {
   int32_t numOfToken = (int32_t) taosArrayGetSize(pOptions->a);
   if (numOfToken < 1 || numOfToken > 2) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   SDNodeDynConfOption LOCAL_DYNAMIC_CFG_OPTIONS[6] = {{"resetLog", 8},    {"rpcDebugFlag", 12}, {"tmrDebugFlag", 12},
@@ -5521,7 +5520,7 @@ int32_t validateLocalConfig(SMiscInfo* pOptions) {
 
     int32_t val = strtol(pValToken->z, NULL, 10);
     if (!validateDebugFlag(val)) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     for (int32_t i = 1; i < tListLen(LOCAL_DYNAMIC_CFG_OPTIONS); ++i) {
@@ -5532,20 +5531,20 @@ int32_t validateLocalConfig(SMiscInfo* pOptions) {
       }
     }
   }
-  return TSDB_CODE_TSC_INVALID_SQL;
+  return TSDB_CODE_TSC_INVALID_OPERATION;
 }
 
 int32_t validateColumnName(char* name) {
   bool ret = taosIsKeyWordToken(name, (int32_t)strlen(name));
   if (ret) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   SStrToken token = {.z = name};
   token.n = tGetToken(name, &token.type);
 
   if (token.type != TK_STRING && token.type != TK_ID) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   if (token.type == TK_STRING) {
@@ -5555,13 +5554,13 @@ int32_t validateColumnName(char* name) {
 
     int32_t k = tGetToken(token.z, &token.type);
     if (k != token.n) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     return validateColumnName(token.z);
   } else {
     if (isNumber(&token)) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
   }
 
@@ -5596,7 +5595,7 @@ int32_t validateLimitNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlN
       pQueryInfo->limit.limit, pQueryInfo->limit.offset, pQueryInfo->slimit.limit, pQueryInfo->slimit.offset);
   
   if (pQueryInfo->slimit.offset < 0 || pQueryInfo->limit.offset < 0) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg0);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg0);
   }
 
   if (pQueryInfo->limit.limit == 0) {
@@ -5610,7 +5609,7 @@ int32_t validateLimitNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlN
     if (!tscQueryTags(pQueryInfo)) {  // local handle the super table tag query
       if (tscIsProjectionQueryOnSTable(pQueryInfo, 0)) {
         if (pQueryInfo->slimit.limit > 0 || pQueryInfo->slimit.offset > 0) {
-          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
         }
 
         // for projection query on super table, all queries are subqueries
@@ -5663,7 +5662,7 @@ int32_t validateLimitNode(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSqlN
     }
   } else {
     if (pQueryInfo->slimit.limit != -1 || pQueryInfo->slimit.offset != 0) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
   }
 
@@ -5701,7 +5700,7 @@ static int32_t setKeepOption(SSqlCmd* pCmd, SCreateDbMsg* pMsg, SCreateDbInfo* p
         pMsg->daysToKeep2 = htonl((int32_t)p2->pVar.i64);
         break;
       }
-      default: { return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg); }
+      default: { return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg); }
     }
   }
 
@@ -5725,7 +5724,7 @@ static int32_t setTimePrecision(SSqlCmd* pCmd, SCreateDbMsg* pMsg, SCreateDbInfo
                strlen(TSDB_TIME_PRECISION_MICRO_STR) == pToken->n) {
       pMsg->precision = TSDB_TIME_PRECISION_MICRO;
     } else {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
     }
   }
 
@@ -5757,15 +5756,15 @@ int32_t parseCreateDBOptions(SSqlCmd* pCmd, SCreateDbInfo* pCreateDbSql) {
   setCreateDBOption(pMsg, pCreateDbSql);
 
   if (setKeepOption(pCmd, pMsg, pCreateDbSql) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   if (setTimePrecision(pCmd, pMsg, pCreateDbSql) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   if (tscCheckCreateDbParams(pCmd, pMsg) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   return TSDB_CODE_SUCCESS;
@@ -5896,7 +5895,7 @@ static int32_t doUpdateSqlFunctionForColPrj(SQueryInfo* pQueryInfo) {
 
       // it is not a tag column/tbname column/user-defined column, return error
       if (!qualifiedCol) {
-        return TSDB_CODE_TSC_INVALID_SQL;
+        return TSDB_CODE_TSC_INVALID_OPERATION;
       }
     }
   }
@@ -6009,7 +6008,7 @@ static int32_t checkUpdateTagPrjFunctions(SQueryInfo* pQueryInfo, SSqlCmd* pCmd)
     // When the tag projection function on tag column that is not in the group by clause, aggregation function and
     // selectivity function exist in select clause is not allowed.
     if (numOfAggregation > 0) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 
     /*
@@ -6038,7 +6037,7 @@ static int32_t checkUpdateTagPrjFunctions(SQueryInfo* pQueryInfo, SSqlCmd* pCmd)
              (functionId == TSDB_FUNC_LAST_DST && (pExpr->base.colInfo.flag & TSDB_COL_NULL) != 0)) {
           // do nothing
         } else {
-          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
         }
       }
 
@@ -6051,7 +6050,7 @@ static int32_t checkUpdateTagPrjFunctions(SQueryInfo* pQueryInfo, SSqlCmd* pCmd)
   } else {
     if ((pQueryInfo->type & TSDB_QUERY_TYPE_PROJECTION_QUERY) != 0) {
       if (numOfAggregation > 0 && pQueryInfo->groupbyExpr.numOfGroupCols == 0) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
       }
 
       if (numOfAggregation > 0 || numOfSelectivity > 0) {
@@ -6115,7 +6114,7 @@ static int32_t doAddGroupbyColumnsOnDemand(SSqlCmd* pCmd, SQueryInfo* pQueryInfo
     } else {
       // if this query is "group by" normal column, time window query is not allowed
       if (isTimeWindowQuery(pQueryInfo)) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
       bool hasGroupColumn = false;
@@ -6171,11 +6170,11 @@ int32_t doFunctionsCompatibleCheck(SSqlCmd* pCmd, SQueryInfo* pQueryInfo) {
   // only retrieve tags, group by is not supportted
   if (tscQueryTags(pQueryInfo)) {
     if (doTagFunctionCheck(pQueryInfo) != TSDB_CODE_SUCCESS) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
     }
 
     if (pQueryInfo->groupbyExpr.numOfGroupCols > 0 || isTimeWindowQuery(pQueryInfo)) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
     } else {
       return TSDB_CODE_SUCCESS;
     }
@@ -6210,31 +6209,31 @@ int32_t doFunctionsCompatibleCheck(SSqlCmd* pCmd, SQueryInfo* pQueryInfo) {
         }
 
         if (!qualified) {
-          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
         }
       }
 
       if (IS_MULTIOUTPUT(aAggs[functId].status) && functId != TSDB_FUNC_TOP && functId != TSDB_FUNC_BOTTOM &&
           functId != TSDB_FUNC_TAGPRJ && functId != TSDB_FUNC_PRJ) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
       if (functId == TSDB_FUNC_COUNT && pExpr->base.colInfo.colIndex == TSDB_TBNAME_COLUMN_INDEX) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
     }
 
     if (checkUpdateTagPrjFunctions(pQueryInfo, pCmd) != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     if (doAddGroupbyColumnsOnDemand(pCmd, pQueryInfo) != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     // projection query on super table does not compatible with "group by" syntax
     if (tscIsProjectionQuery(pQueryInfo)) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
     }
 
     return TSDB_CODE_SUCCESS;
@@ -6250,7 +6249,7 @@ int32_t doLocalQueryProcess(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
   SArray* pExprList = pSqlNode->pSelNodeList;
   size_t size = taosArrayGetSize(pExprList);
   if (size != 1) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   bool server_status = false;
@@ -6261,7 +6260,7 @@ int32_t doLocalQueryProcess(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
     if (pExpr->token.n == 1 && 0 == strncasecmp(pExpr->token.z, "1", 1)) {
       server_status = true; 
     } else {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
     } 
   } 
   // TODO redefine the function
@@ -6295,7 +6294,7 @@ int32_t doLocalQueryProcess(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SSqlNode* pSq
       pQueryInfo->command = TSDB_SQL_CLI_VERSION;break;
     case 4:
       pQueryInfo->command = TSDB_SQL_CURRENT_USER;break;
-    default: { return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3); }
+    default: { return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3); }
   }
   
   SColumnIndex ind = {0};
@@ -6315,69 +6314,69 @@ int32_t tscCheckCreateDbParams(SSqlCmd* pCmd, SCreateDbMsg* pCreate) {
 
   if (pCreate->walLevel != -1 && (pCreate->walLevel < TSDB_MIN_WAL_LEVEL || pCreate->walLevel > TSDB_MAX_WAL_LEVEL)) {
     snprintf(msg, tListLen(msg), "invalid db option walLevel: %d, only 1-2 allowed", pCreate->walLevel);
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
   }
 
   if (pCreate->replications != -1 &&
       (pCreate->replications < TSDB_MIN_DB_REPLICA_OPTION || pCreate->replications > TSDB_MAX_DB_REPLICA_OPTION)) {
     snprintf(msg, tListLen(msg), "invalid db option replications: %d valid range: [%d, %d]", pCreate->replications,
              TSDB_MIN_DB_REPLICA_OPTION, TSDB_MAX_DB_REPLICA_OPTION);
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
   }
 
   if (pCreate->quorum != -1 &&
       (pCreate->quorum < TSDB_MIN_DB_QUORUM_OPTION || pCreate->quorum > TSDB_MAX_DB_QUORUM_OPTION)) {
     snprintf(msg, tListLen(msg), "invalid db option quorum: %d valid range: [%d, %d]", pCreate->quorum,
              TSDB_MIN_DB_QUORUM_OPTION, TSDB_MAX_DB_QUORUM_OPTION);
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
   }
 
   int32_t val = htonl(pCreate->daysPerFile);
   if (val != -1 && (val < TSDB_MIN_DAYS_PER_FILE || val > TSDB_MAX_DAYS_PER_FILE)) {
     snprintf(msg, tListLen(msg), "invalid db option daysPerFile: %d valid range: [%d, %d]", val,
              TSDB_MIN_DAYS_PER_FILE, TSDB_MAX_DAYS_PER_FILE);
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
   }
 
   val = htonl(pCreate->cacheBlockSize);
   if (val != -1 && (val < TSDB_MIN_CACHE_BLOCK_SIZE || val > TSDB_MAX_CACHE_BLOCK_SIZE)) {
     snprintf(msg, tListLen(msg), "invalid db option cacheBlockSize: %d valid range: [%d, %d]", val,
              TSDB_MIN_CACHE_BLOCK_SIZE, TSDB_MAX_CACHE_BLOCK_SIZE);
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
   }
 
   val = htonl(pCreate->maxTables);
   if (val != -1 && (val < TSDB_MIN_TABLES || val > TSDB_MAX_TABLES)) {
     snprintf(msg, tListLen(msg), "invalid db option maxSessions: %d valid range: [%d, %d]", val,
              TSDB_MIN_TABLES, TSDB_MAX_TABLES);
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
   }
 
   if (pCreate->precision != TSDB_TIME_PRECISION_MILLI && pCreate->precision != TSDB_TIME_PRECISION_MICRO) {
     snprintf(msg, tListLen(msg), "invalid db option timePrecision: %d valid value: [%d, %d]", pCreate->precision,
              TSDB_TIME_PRECISION_MILLI, TSDB_TIME_PRECISION_MICRO);
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
   }
 
   val = htonl(pCreate->commitTime);
   if (val != -1 && (val < TSDB_MIN_COMMIT_TIME || val > TSDB_MAX_COMMIT_TIME)) {
     snprintf(msg, tListLen(msg), "invalid db option commitTime: %d valid range: [%d, %d]", val,
              TSDB_MIN_COMMIT_TIME, TSDB_MAX_COMMIT_TIME);
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
   }
 
   val = htonl(pCreate->fsyncPeriod);
   if (val != -1 && (val < TSDB_MIN_FSYNC_PERIOD || val > TSDB_MAX_FSYNC_PERIOD)) {
     snprintf(msg, tListLen(msg), "invalid db option fsyncPeriod: %d valid range: [%d, %d]", val,
              TSDB_MIN_FSYNC_PERIOD, TSDB_MAX_FSYNC_PERIOD);
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
   }
 
   if (pCreate->compression != -1 &&
       (pCreate->compression < TSDB_MIN_COMP_LEVEL || pCreate->compression > TSDB_MAX_COMP_LEVEL)) {
     snprintf(msg, tListLen(msg), "invalid db option compression: %d valid range: [%d, %d]", pCreate->compression,
              TSDB_MIN_COMP_LEVEL, TSDB_MAX_COMP_LEVEL);
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
   }
 
   val = (int16_t)htons(pCreate->partitions);
@@ -6385,7 +6384,7 @@ int32_t tscCheckCreateDbParams(SSqlCmd* pCmd, SCreateDbMsg* pCreate) {
       (val < TSDB_MIN_DB_PARTITON_OPTION || val > TSDB_MAX_DB_PARTITON_OPTION)) {
     snprintf(msg, tListLen(msg), "invalid topic option partition: %d valid range: [%d, %d]", val,
              TSDB_MIN_DB_PARTITON_OPTION, TSDB_MAX_DB_PARTITON_OPTION);
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg);
   }
 
 
@@ -6450,7 +6449,7 @@ int32_t doCheckForCreateTable(SSqlObj* pSql, int32_t subClauseIndex, SSqlInfo* p
   SStrToken* pzTableName = &(pCreateTable->name);
 
   if (tscValidateName(pzTableName) != TSDB_CODE_SUCCESS) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   int32_t code = tscSetTableFullName(&pTableMetaInfo->name, pzTableName, pSql);
@@ -6460,7 +6459,7 @@ int32_t doCheckForCreateTable(SSqlObj* pSql, int32_t subClauseIndex, SSqlInfo* p
 
   if (!validateTableColumnInfo(pFieldList, pCmd) ||
       (pTagList != NULL && !validateTagParams(pTagList, pFieldList, pCmd))) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   int32_t col = 0;
@@ -6514,7 +6513,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
 
     SStrToken* pToken = &pCreateTableInfo->stableName;
     if (tscValidateName(pToken) != TSDB_CODE_SUCCESS) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 
     int32_t code = tscSetTableFullName(&pStableMetaInfo->name, pToken, pSql);
@@ -6553,12 +6552,12 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
 
       if (valSize != nameSize) {
         tdDestroyKVRowBuilder(&kvRowBuilder);
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
       }
 
       if (schemaSize < valSize) {
         tdDestroyKVRowBuilder(&kvRowBuilder);
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
       }
 
       bool findColumnIndex = false;
@@ -6582,7 +6581,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
             if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) {
               if (pItem->pVar.nLen > pSchema->bytes) {
                 tdDestroyKVRowBuilder(&kvRowBuilder);
-                return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+                return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
               }
             }
 
@@ -6593,13 +6592,13 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
               int16_t len = varDataTLen(tagVal);
               if (len > pSchema->bytes) {
                 tdDestroyKVRowBuilder(&kvRowBuilder);
-                return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+                return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
               }
             }
 
             if (ret != TSDB_CODE_SUCCESS) {
               tdDestroyKVRowBuilder(&kvRowBuilder);
-              return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+              return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
             }
 
             tdAddColToKVRow(&kvRowBuilder, pSchema->colId, pSchema->type, tagVal);
@@ -6617,7 +6616,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
     } else {
       if (schemaSize != valSize) {
         tdDestroyKVRowBuilder(&kvRowBuilder);
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
       }
 
       for (int32_t i = 0; i < valSize; ++i) {
@@ -6628,7 +6627,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
         if (pSchema->type == TSDB_DATA_TYPE_BINARY || pSchema->type == TSDB_DATA_TYPE_NCHAR) {
           if (pItem->pVar.nLen > pSchema->bytes) {
             tdDestroyKVRowBuilder(&kvRowBuilder);
-            return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+            return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
           }
         }
 
@@ -6639,13 +6638,13 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
           int16_t len = varDataTLen(tagVal);
           if (len > pSchema->bytes) {
             tdDestroyKVRowBuilder(&kvRowBuilder);
-            return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+            return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
           }
         }
 
         if (ret != TSDB_CODE_SUCCESS) {
           tdDestroyKVRowBuilder(&kvRowBuilder);
-          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
         }
 
         tdAddColToKVRow(&kvRowBuilder, pSchema->colId, pSchema->type, tagVal);
@@ -6669,7 +6668,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
 
     // table name
     if (tscValidateName(&(pCreateTableInfo->name)) != TSDB_CODE_SUCCESS) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 
     STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, TABLE_INDEX);
@@ -6681,7 +6680,7 @@ int32_t doCheckForCreateFromStable(SSqlObj* pSql, SSqlInfo* pInfo) {
     pCreateTableInfo->fullname = calloc(1, tNameLen(&pTableMetaInfo->name) + 1);
     ret = tNameExtractFullName(&pTableMetaInfo->name, pCreateTableInfo->fullname);
     if (ret != TSDB_CODE_SUCCESS) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
   }
 
@@ -6709,18 +6708,18 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
   SSqlNode* pSqlNode = pCreateTable->pSelect;
 
   if (tscValidateName(pName) != TSDB_CODE_SUCCESS) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
   
   SRelationInfo* pFromInfo = pInfo->pCreateTableInfo->pSelect->from;
   if (pFromInfo == NULL || taosArrayGetSize(pFromInfo->list) == 0) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg6);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg6);
   }
   
   SRelElementPair* p1 = taosArrayGet(pFromInfo->list, 0);
   SStrToken srcToken = {.z = p1->tableName.z, .n = p1->tableName.n, .type = TK_STRING};
   if (tscValidateName(&srcToken) != TSDB_CODE_SUCCESS) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   int32_t code = tscSetTableFullName(&pTableMetaInfo->name, &srcToken, pSql);
@@ -6735,26 +6734,26 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
 
   bool isSTable = UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo);
   if (validateSelectNodeList(&pSql->cmd, pQueryInfo, pSqlNode->pSelNodeList, isSTable, false, false) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   if (pSqlNode->pWhere != NULL) {  // query condition in stream computing
     if (validateWhereNode(pQueryInfo, &pSqlNode->pWhere, pSql) != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
   }
 
   // set interval value
   if (validateIntervalNode(pSql, pQueryInfo, pSqlNode) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   if (isTimeWindowQuery(pQueryInfo) && (validateFunctionsInIntervalOrGroupbyQuery(pCmd, pQueryInfo) != TSDB_CODE_SUCCESS)) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
   }
 
   if (!tscIsProjectionQuery(pQueryInfo) && pQueryInfo->interval.interval == 0) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg7);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg7);
   }
 
   // set the created table[stream] name
@@ -6764,17 +6763,17 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
   }
 
   if (pSqlNode->sqlstr.n > TSDB_MAX_SAVED_SQL_LEN) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg5);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg5);
   }
 
   if (tsRewriteFieldNameIfNecessary(pCmd, pQueryInfo) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   pCmd->numOfCols = pQueryInfo->fieldsInfo.numOfOutput;
 
   if (validateSqlFunctionInStreamSql(pCmd, pQueryInfo) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   /*
@@ -6783,14 +6782,14 @@ int32_t doCheckForStream(SSqlObj* pSql, SSqlInfo* pInfo) {
    */
   if (pSqlNode->fillType != NULL) {
     if (pQueryInfo->interval.interval == 0) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
     }
 
     tVariantListItem* pItem = taosArrayGet(pSqlNode->fillType, 0);
     if (pItem->pVar.nType == TSDB_DATA_TYPE_BINARY) {
       if (!((strncmp(pItem->pVar.pz, "none", 4) == 0 && pItem->pVar.nLen == 4) ||
             (strncmp(pItem->pVar.pz, "null", 4) == 0 && pItem->pVar.nLen == 4))) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
       }
     }
   }
@@ -6809,7 +6808,7 @@ int32_t checkQueryRangeForFill(SSqlCmd* pCmd, SQueryInfo* pQueryInfo) {
 
     bool initialWindows = TSWINDOW_IS_EQUAL(pQueryInfo->window, TSWINDOW_INITIALIZER);
     if (initialWindows) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
     }
 
     int64_t timeRange = ABS(pQueryInfo->window.skey - pQueryInfo->window.ekey);
@@ -6829,7 +6828,7 @@ int32_t checkQueryRangeForFill(SSqlCmd* pCmd, SQueryInfo* pQueryInfo) {
     }
     // number of result is not greater than 10,000,000
     if ((timeRange == 0) || (timeRange / intervalRange) >= MAX_INTERVAL_TIME_WINDOW) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
     }
 
     return TSDB_CODE_SUCCESS;
@@ -6884,7 +6883,7 @@ int32_t tscGetExprFilters(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pSelect
 
   // ADD TRUE FOR TEST
   if (addExprAndResultField(pCmd, pQueryInfo, outputIndex, &item, true) != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   ++pQueryInfo->havingFieldNum;
@@ -6939,7 +6938,7 @@ static int32_t handleExprInHavingClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, S
       return TSDB_CODE_TSC_OUT_OF_MEMORY;
     }
   } else {  // error;
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   pColFilter->filterstr =
@@ -6952,16 +6951,16 @@ static int32_t handleExprInHavingClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, S
         && pExpr->tokenId != TK_NOTNULL
         && pExpr->tokenId != TK_LIKE
         ) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
     }
   } else {
     if (pExpr->tokenId == TK_LIKE) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 
     if (expr->base.resType == TSDB_DATA_TYPE_BOOL) {
       if (pExpr->tokenId != TK_EQ && pExpr->tokenId != TK_NE) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
       }
     }
   }
@@ -6998,11 +6997,11 @@ int32_t getHavingExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pSelectNode
   }
 
   if (pLeft == NULL || pRight == NULL) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   if (pLeft->type == pRight->type) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   exchangeExpr(pExpr);
@@ -7010,15 +7009,15 @@ int32_t getHavingExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pSelectNode
   pLeft  = pExpr->pLeft;
   pRight = pExpr->pRight;
   if (pLeft->type != SQL_NODE_SQLFUNCTION) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   if (pRight->type != SQL_NODE_VALUE) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   if (pExpr->tokenId >= TK_BITAND) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   if (pLeft->pParam) {
@@ -7032,17 +7031,17 @@ int32_t getHavingExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pSelectNode
           pExpr1->tokenId != TK_STRING &&
           pExpr1->tokenId != TK_INTEGER &&
           pExpr1->tokenId != TK_FLOAT) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
       if (pExpr1->tokenId == TK_ID && (pExpr1->colInfo.z == NULL && pExpr1->colInfo.n == 0)) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
       }
 
       if (pExpr1->tokenId == TK_ID) {
         SColumnIndex index = COLUMN_INDEX_INITIALIZER;
         if ((getColumnIndexByName(pCmd, &pExpr1->colInfo, pQueryInfo, &index) != TSDB_CODE_SUCCESS)) {
-          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
         }
 
         STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, index.tableIndex);
@@ -7050,7 +7049,7 @@ int32_t getHavingExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pSelectNode
 
         if (index.columnIndex <= 0 ||
             index.columnIndex >= tscGetNumOfColumns(pTableMeta)) {
-          return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+          return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
         }
       }
     }
@@ -7058,7 +7057,7 @@ int32_t getHavingExpr(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SArray* pSelectNode
 
   pLeft->functionId = isValidFunction(pLeft->operand.z, pLeft->operand.n);
   if (pLeft->functionId < 0) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   return handleExprInHavingClause(pCmd, pQueryInfo, pSelectNodeList, pExpr, parentOptr);
@@ -7075,11 +7074,11 @@ int32_t validateHavingClause(SQueryInfo* pQueryInfo, tSqlExpr* pExpr, SSqlCmd* p
   }
 
   if (pQueryInfo->groupbyExpr.numOfGroupCols <= 0) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
   }
 
   if (pExpr->pLeft == NULL || pExpr->pRight == NULL) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
   }
 
   if (pQueryInfo->colList == NULL) {
@@ -7094,7 +7093,7 @@ int32_t validateHavingClause(SQueryInfo* pQueryInfo, tSqlExpr* pExpr, SSqlCmd* p
 
   //REDO function check
   if (!functionCompatibleCheck(pQueryInfo, joinQuery, timeWindowQuery)) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -7111,17 +7110,17 @@ static int32_t getTableNameFromSqlNode(SSqlNode* pSqlNode, SArray* tableNameList
 
     SStrToken* t = &item->tableName;
     if (t->type == TK_INTEGER || t->type == TK_FLOAT) {
-      return invalidSqlErrMsg(msgBuf, msg1);
+      return invalidOperationMsg(msgBuf, msg1);
     }
 
     tscDequoteAndTrimToken(t);
     if (tscValidateName(t) != TSDB_CODE_SUCCESS) {
-      return invalidSqlErrMsg(msgBuf, msg1);
+      return invalidOperationMsg(msgBuf, msg1);
     }
 
     SName name = {0};
     if (tscSetTableFullName(&name, t, pSql) != TSDB_CODE_SUCCESS) {
-      return invalidSqlErrMsg(msgBuf, msg1);
+      return invalidOperationMsg(msgBuf, msg1);
     }
 
     taosArrayPush(tableNameList, &name);
@@ -7276,7 +7275,7 @@ static int32_t doLoadAllTableMeta(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNod
   SSqlCmd* pCmd = &pSql->cmd;
 
   if (numOfTables > taosHashGetSize(pCmd->pTableMetaMap)) {
-    return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg4);
+    return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg4);
   }
 
   for (int32_t i = 0; i < numOfTables; ++i) {
@@ -7288,12 +7287,12 @@ static int32_t doLoadAllTableMeta(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNod
     SStrToken       *oriName = &item->tableName;
 
     if (oriName->type == TK_INTEGER || oriName->type == TK_FLOAT) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 
     tscDequoteAndTrimToken(oriName);
     if (tscValidateName(oriName) != TSDB_CODE_SUCCESS) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 
     STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pQueryInfo, i);
@@ -7305,12 +7304,12 @@ static int32_t doLoadAllTableMeta(SSqlObj* pSql, SQueryInfo* pQueryInfo, SSqlNod
     SStrToken* aliasName = &item->aliasName;
     if (TPARSER_HAS_TOKEN(*aliasName)) {
       if (aliasName->type == TK_INTEGER || aliasName->type == TK_FLOAT) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
       }
 
       tscDequoteAndTrimToken(aliasName);
       if (tscValidateName(aliasName) != TSDB_CODE_SUCCESS || aliasName->n >= TSDB_TABLE_NAME_LEN) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
       }
 
       strncpy(pTableMetaInfo->aliasName, aliasName->z, aliasName->n);
@@ -7384,7 +7383,7 @@ static int32_t doValidateSubquery(SSqlNode* pSqlNode, int32_t index, SSqlObj* pS
 
   if (subInfo->aliasName.n > 0) {
     if (subInfo->aliasName.n >= TSDB_TABLE_FNAME_LEN) {
-      return invalidSqlErrMsg(msgBuf, "subquery alias name too long");
+      return invalidOperationMsg(msgBuf, "subquery alias name too long");
     }
 
     strncpy(pTableMetaInfo1->aliasName, subInfo->aliasName.z, subInfo->aliasName.n);
@@ -7459,12 +7458,12 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
     }
 
     if (validateSelectNodeList(pCmd, pQueryInfo, pSqlNode->pSelNodeList, false, false, false) != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     if (pSqlNode->pWhere != NULL) {
       if (validateWhereNode(pQueryInfo, &pSqlNode->pWhere, pSql) != TSDB_CODE_SUCCESS) {
-        return TSDB_CODE_TSC_INVALID_SQL;
+        return TSDB_CODE_TSC_INVALID_OPERATION;
       }
 
       STableMeta* pTableMeta = tscGetMetaInfo(pQueryInfo, 0)->pTableMeta;
@@ -7478,7 +7477,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
 
     size_t numOfTables = taosArrayGetSize(pSqlNode->from->list);
     if (numOfTables > TSDB_MAX_JOIN_TABLE_NUM) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg2);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg2);
     }
 
     // set all query tables, which are maybe more than one.
@@ -7494,7 +7493,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
 
     // parse the group by clause in the first place
     if (validateGroupbyNode(pQueryInfo, pSqlNode->pGroupby, pCmd) != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     // set where info
@@ -7502,7 +7501,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
 
     if (pSqlNode->pWhere != NULL) {
       if (validateWhereNode(pQueryInfo, &pSqlNode->pWhere, pSql) != TSDB_CODE_SUCCESS) {
-        return TSDB_CODE_TSC_INVALID_SQL;
+        return TSDB_CODE_TSC_INVALID_OPERATION;
       }
 
       pSqlNode->pWhere = NULL;
@@ -7512,7 +7511,7 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
       }
     } else {
       if (taosArrayGetSize(pSqlNode->from->list) > 1) { // Cross join not allowed yet
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), "cross join not supported yet");
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), "cross join not supported yet");
       }
     }
 
@@ -7522,29 +7521,29 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
 
     if (validateSelectNodeList(pCmd, pQueryInfo, pSqlNode->pSelNodeList, isSTable, joinQuery, timeWindowQuery) !=
         TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     // set order by info
     if (validateOrderbyNode(pCmd, pQueryInfo, pSqlNode, tscGetTableSchema(pTableMetaInfo->pTableMeta)) !=
         TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     // set interval value
     if (validateIntervalNode(pSql, pQueryInfo, pSqlNode) != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     } else {
       if (isTimeWindowQuery(pQueryInfo) &&
           (validateFunctionsInIntervalOrGroupbyQuery(pCmd, pQueryInfo) != TSDB_CODE_SUCCESS)) {
-        return TSDB_CODE_TSC_INVALID_SQL;
+        return TSDB_CODE_TSC_INVALID_OPERATION;
       }
     }
 
     // parse the having clause in the first place
     if (validateHavingClause(pQueryInfo, pSqlNode->pHaving, pCmd, pSqlNode->pSelNodeList, joinQuery, timeWindowQuery) !=
         TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     /*
@@ -7554,12 +7553,12 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
     if (isSTable) {
       tscTansformFuncForSTableQuery(pQueryInfo);
       if (hasUnsupportFunctionsForSTableQuery(pCmd, pQueryInfo)) {
-        return TSDB_CODE_TSC_INVALID_SQL;
+        return TSDB_CODE_TSC_INVALID_OPERATION;
       }
     }
 
     if (validateSessionNode(pCmd, pQueryInfo, pSqlNode) != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     // no result due to invalid query time range
@@ -7569,14 +7568,14 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
     }
 
     if (!hasTimestampForPointInterpQuery(pQueryInfo)) {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg1);
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg1);
     }
 
     // in case of join query, time range is required.
     if (QUERY_IS_JOIN_QUERY(pQueryInfo->type)) {
       int64_t timeRange = ABS(pQueryInfo->window.skey - pQueryInfo->window.ekey);
       if (timeRange == 0 && pQueryInfo->window.skey == 0) {
-        return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg3);
+        return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg3);
       }
     }
 
@@ -7715,7 +7714,7 @@ int32_t exprTreeFromSqlExpr(SSqlCmd* pCmd, tExprNode **pExpr, const tSqlExpr* pS
       
       return TSDB_CODE_SUCCESS;
     } else {
-      return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), "not support filter expression");
+      return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), "not support filter expression");
     }
     
   } else {
@@ -7735,9 +7734,9 @@ int32_t exprTreeFromSqlExpr(SSqlCmd* pCmd, tExprNode **pExpr, const tSqlExpr* pS
     if ((*pExpr)->_node.optr == TSDB_BINARY_OP_DIVIDE) {
       if (pRight->nodeType == TSQL_NODE_VALUE) {
         if (pRight->pVal->nType == TSDB_DATA_TYPE_INT && pRight->pVal->i64 == 0) {
-          return TSDB_CODE_TSC_INVALID_SQL;
+          return TSDB_CODE_TSC_INVALID_OPERATION;
         } else if (pRight->pVal->nType == TSDB_DATA_TYPE_FLOAT && pRight->pVal->dKey == 0) {
-          return TSDB_CODE_TSC_INVALID_SQL;
+          return TSDB_CODE_TSC_INVALID_OPERATION;
         }
       }
     }
@@ -7746,7 +7745,7 @@ int32_t exprTreeFromSqlExpr(SSqlCmd* pCmd, tExprNode **pExpr, const tSqlExpr* pS
     if ((*pExpr)->_node.optr != TSDB_RELATION_EQUAL && (*pExpr)->_node.optr != TSDB_RELATION_NOT_EQUAL) {
       if (pRight != NULL && pRight->nodeType == TSQL_NODE_VALUE) {
         if (pRight->pVal->nType == TSDB_DATA_TYPE_BOOL) {
-          return TSDB_CODE_TSC_INVALID_SQL;
+          return TSDB_CODE_TSC_INVALID_OPERATION;
         }
       }
     }
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index 599445a8f1..a6a23348c2 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -736,7 +736,7 @@ static int32_t serializeColFilterInfo(SColumnFilterInfo* pColFilters, int16_t nu
 
     if (pColFilter->lowerRelOptr == TSDB_RELATION_INVALID && pColFilter->upperRelOptr == TSDB_RELATION_INVALID) {
       tscError("invalid filter info");
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
   }
 
@@ -755,7 +755,7 @@ static int32_t serializeSqlExpr(SSqlExpr* pExpr, STableMetaInfo* pTableMetaInfo,
 
   if (validateColumn && !tscValidateColumnId(pTableMetaInfo, pExpr->colInfo.colId, pExpr->numOfParams)) {
     tscError("0x%"PRIx64" table schema is not matched with parsed sql", id);
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   assert(pExpr->resColId < 0);
@@ -802,7 +802,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   if (TSDB_CODE_SUCCESS != tscAllocPayload(pCmd, size)) {
     tscError("%p failed to malloc for query msg", pSql);
-    return TSDB_CODE_TSC_INVALID_SQL;  // todo add test for this
+    return TSDB_CODE_TSC_INVALID_OPERATION;  // todo add test for this
   }
 
   SQueryInfo *pQueryInfo = tscGetQueryInfo(pCmd);
@@ -1684,7 +1684,7 @@ int tscBuildTableMetaMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
 
   int32_t code = tNameExtractFullName(&pTableMetaInfo->name, pInfoMsg->tableFname);
   if (code != TSDB_CODE_SUCCESS) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   pInfoMsg->createFlag = htons(pSql->cmd.autoCreated ? 1 : 0);
@@ -2383,7 +2383,7 @@ static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaIn
     STableInfoMsg  *pInfoMsg = (STableInfoMsg *)pNew->cmd.payload;
     int32_t code = tNameExtractFullName(&pNewTableMetaInfo->name, pInfoMsg->tableFname);
     if (code != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     pInfoMsg->createFlag = htons(autocreate? 1 : 0);
@@ -2547,7 +2547,7 @@ int tscRenewTableMeta(SSqlObj *pSql, int32_t tableIndex) {
   int32_t code = tNameExtractFullName(&pTableMetaInfo->name, name);
   if (code != TSDB_CODE_SUCCESS) {
     tscError("0x%"PRIx64" failed to generate the table full name", pSql->self);
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   STableMeta* pTableMeta = pTableMetaInfo->pTableMeta;
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index 09765f5ce6..8fe46d9b65 100644
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -618,7 +618,7 @@ int taos_errno(TAOS_RES *tres) {
  * why the sql is invalid
  */
 static bool hasAdditionalErrorInfo(int32_t code, SSqlCmd *pCmd) {
-  if (code != TSDB_CODE_TSC_INVALID_SQL
+  if (code != TSDB_CODE_TSC_INVALID_OPERATION
       && code != TSDB_CODE_TSC_SQL_SYNTAX_ERROR) {
     return false;
   }
@@ -943,7 +943,7 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
   if (length > MAX_TABLE_NAME_LENGTH) {
     tscError("0x%"PRIx64" tableNameList too long, length:%d, maximum allowed:%d", pSql->self, length, MAX_TABLE_NAME_LENGTH);
     tscFreeSqlObj(pSql);
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   char *str = calloc(1, length + 1);
diff --git a/src/client/src/tscSub.c b/src/client/src/tscSub.c
index 9743e12c1e..2d9b3bb141 100644
--- a/src/client/src/tscSub.c
+++ b/src/client/src/tscSub.c
@@ -173,7 +173,7 @@ static SSub* tscCreateSubscription(STscObj* pObj, const char* topic, const char*
 
   if (pSql->cmd.command != TSDB_SQL_SELECT && pSql->cmd.command != TSDB_SQL_RETRIEVE_EMPTY_RESULT) {
     line = __LINE__;
-    code = TSDB_CODE_TSC_INVALID_SQL;
+    code = TSDB_CODE_TSC_INVALID_OPERATION;
     goto fail;
   }
 
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 56de90ef92..1b04b8201e 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -2298,7 +2298,7 @@ static int32_t validateQuoteToken(SStrToken* pToken) {
   }
 
   if (k != pToken->n || pToken->type != TK_ID) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
   return TSDB_CODE_SUCCESS;
 }
@@ -2348,7 +2348,7 @@ void tscDequoteAndTrimToken(SStrToken* pToken) {
 
 int32_t tscValidateName(SStrToken* pToken) {
   if (pToken->type != TK_STRING && pToken->type != TK_ID) {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   char* sep = strnchr(pToken->z, TS_PATH_DELIMITER[0], pToken->n, true);
@@ -2367,14 +2367,14 @@ int32_t tscValidateName(SStrToken* pToken) {
       } else {
         sep = strnchr(pToken->z, TS_PATH_DELIMITER[0], pToken->n, true);
         if (sep == NULL) {
-          return TSDB_CODE_TSC_INVALID_SQL;
+          return TSDB_CODE_TSC_INVALID_OPERATION;
         }
 
         return tscValidateName(pToken);
       }
     } else {
       if (isNumber(pToken)) {
-        return TSDB_CODE_TSC_INVALID_SQL;
+        return TSDB_CODE_TSC_INVALID_OPERATION;
       }
     }
   } else {  // two part
@@ -2387,15 +2387,15 @@ int32_t tscValidateName(SStrToken* pToken) {
 
     pToken->n = tGetToken(pToken->z, &pToken->type);
     if (pToken->z[pToken->n] != TS_PATH_DELIMITER[0]) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     if (pToken->type != TK_STRING && pToken->type != TK_ID) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     if (pToken->type == TK_STRING && validateQuoteToken(pToken) != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     int32_t firstPartLen = pToken->n;
@@ -2404,11 +2404,11 @@ int32_t tscValidateName(SStrToken* pToken) {
     pToken->n = (uint32_t)(oldLen - (sep - pStr) - 1);
     int32_t len = tGetToken(pToken->z, &pToken->type);
     if (len != pToken->n || (pToken->type != TK_STRING && pToken->type != TK_ID)) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     if (pToken->type == TK_STRING && validateQuoteToken(pToken) != TSDB_CODE_SUCCESS) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
     
     // re-build the whole name string
@@ -3508,7 +3508,7 @@ int32_t tscInvalidSQLErrMsg(char* msg, const char* additionalInfo, const char* s
   if (sql == NULL) {
     assert(additionalInfo != NULL);
     sprintf(msg, msgFormat1, additionalInfo);
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   char buf[64] = {0};  // only extract part of sql string
@@ -3520,7 +3520,7 @@ int32_t tscInvalidSQLErrMsg(char* msg, const char* additionalInfo, const char* s
     sprintf(msg, msgFormat3, buf);  // no additional information for invalid sql error
   }
 
-  return TSDB_CODE_TSC_INVALID_SQL;
+  return TSDB_CODE_TSC_INVALID_OPERATION;
 }
 
 bool tscHasReachLimitation(SQueryInfo* pQueryInfo, SSqlRes* pRes) {
@@ -4072,7 +4072,7 @@ static int32_t createTagColumnInfo(SQueryAttr* pQueryAttr, SQueryInfo* pQueryInf
 
     if ((pCol->columnIndex >= numOfTagColumns || pCol->columnIndex < TSDB_TBNAME_COLUMN_INDEX) ||
         (!isValidDataType(pColSchema->type))) {
-      return TSDB_CODE_TSC_INVALID_SQL;
+      return TSDB_CODE_TSC_INVALID_OPERATION;
     }
 
     SColumnInfo* pTagCol = &pQueryAttr->tagColList[i];
@@ -4198,18 +4198,18 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
         tscError("%p illegal value of numOfCols in query msg: %" PRIu64 ", table cols:%d", addr,
         (uint64_t)pQueryAttr->numOfCols, numOfCols);
 
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   if (pQueryAttr->interval.interval < 0) {
     tscError("%p illegal value of aggregation time interval in query msg: %" PRId64, addr,
              (int64_t)pQueryInfo->interval.interval);
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   if (pQueryAttr->pGroupbyExpr->numOfGroupCols < 0) {
     tscError("%p illegal value of numOfGroupCols in query msg: %d", addr, pQueryInfo->groupbyExpr.numOfGroupCols);
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
 
   return TSDB_CODE_SUCCESS;
diff --git a/src/inc/taoserror.h b/src/inc/taoserror.h
index d3ac0ce280..067d911b82 100644
--- a/src/inc/taoserror.h
+++ b/src/inc/taoserror.h
@@ -74,7 +74,7 @@ int32_t* taosGetErrno();
 #define TSDB_CODE_REF_NOT_EXIST                 TAOS_DEF_ERROR_CODE(0, 0x010A)  //"Ref is not there")
 
 //client
-#define TSDB_CODE_TSC_INVALID_SQL               TAOS_DEF_ERROR_CODE(0, 0x0200)  //"Invalid SQL statement")
+#define TSDB_CODE_TSC_INVALID_OPERATION               TAOS_DEF_ERROR_CODE(0, 0x0200)  //"Invalid SQL statement")
 #define TSDB_CODE_TSC_INVALID_QHANDLE           TAOS_DEF_ERROR_CODE(0, 0x0201)  //"Invalid qhandle")
 #define TSDB_CODE_TSC_INVALID_TIME_STAMP        TAOS_DEF_ERROR_CODE(0, 0x0202)  //"Invalid combination of client/service time")
 #define TSDB_CODE_TSC_INVALID_VALUE             TAOS_DEF_ERROR_CODE(0, 0x0203)  //"Invalid value in client")
diff --git a/src/plugins/http/src/httpResp.c b/src/plugins/http/src/httpResp.c
index 063f2bb04e..4fcf236fce 100644
--- a/src/plugins/http/src/httpResp.c
+++ b/src/plugins/http/src/httpResp.c
@@ -165,7 +165,7 @@ void httpSendTaosdInvalidSqlErrorResp(HttpContext *pContext, char *errMsg) {
     }
   }
 
-  httpSendErrorRespImp(pContext, httpCode, "Bad Request", TSDB_CODE_TSC_INVALID_SQL & 0XFFFF, temp);
+  httpSendErrorRespImp(pContext, httpCode, "Bad Request", TSDB_CODE_TSC_INVALID_OPERATION & 0XFFFF, temp);
 }
 
 void httpSendSuccResp(HttpContext *pContext, char *desc) {
diff --git a/src/plugins/http/src/httpSql.c b/src/plugins/http/src/httpSql.c
index b345c1531f..5a0480b694 100644
--- a/src/plugins/http/src/httpSql.c
+++ b/src/plugins/http/src/httpSql.c
@@ -263,7 +263,7 @@ void httpProcessSingleSqlCallBackImp(void *param, TAOS_RES *result, int32_t code
 
   if (code != TSDB_CODE_SUCCESS) {
     SSqlObj *pObj = (SSqlObj *)result;
-    if (code == TSDB_CODE_TSC_INVALID_SQL) {
+    if (code == TSDB_CODE_TSC_INVALID_OPERATION) {
       terrno = code;
       httpError("context:%p, fd:%d, user:%s, query error, code:%s, sqlObj:%p, error:%s", pContext, pContext->fd,
                 pContext->user, tstrerror(code), pObj, taos_errstr(pObj));
diff --git a/src/query/src/qAggMain.c b/src/query/src/qAggMain.c
index 3e5632e4c1..177cea8b62 100644
--- a/src/query/src/qAggMain.c
+++ b/src/query/src/qAggMain.c
@@ -166,7 +166,7 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI
                           int16_t *bytes, int32_t *interBytes, int16_t extLength, bool isSuperTable) {
   if (!isValidDataType(dataType)) {
     qError("Illegal data type %d or data type length %d", dataType, dataBytes);
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
   
   if (functionId == TSDB_FUNC_TS || functionId == TSDB_FUNC_TS_DUMMY || functionId == TSDB_FUNC_TAG_DUMMY ||
@@ -353,7 +353,7 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI
     *interBytes = (*bytes);
 
   } else {
-    return TSDB_CODE_TSC_INVALID_SQL;
+    return TSDB_CODE_TSC_INVALID_OPERATION;
   }
   
   return TSDB_CODE_SUCCESS;
diff --git a/src/query/tests/unitTest.cpp b/src/query/tests/unitTest.cpp
index d2b058cf7c..33ba8200d3 100644
--- a/src/query/tests/unitTest.cpp
+++ b/src/query/tests/unitTest.cpp
@@ -99,47 +99,47 @@ TEST(testCase, db_table_name) {
   EXPECT_EQ(testValidateName(t4), TSDB_CODE_SUCCESS);
 
   char t5[] = "table.'def'";
-  EXPECT_EQ(testValidateName(t5), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t5), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t6[] = "'table'.'def'";
-  EXPECT_EQ(testValidateName(t6), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t6), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t7[] = "'_ab1234'.'def'";
   EXPECT_EQ(testValidateName(t7), TSDB_CODE_SUCCESS);
   printf("%s\n", t7);
 
   char t8[] = "'_ab&^%1234'.'def'";
-  EXPECT_EQ(testValidateName(t8), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t8), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t9[] = "'_123'.'gtest中文'";
-  EXPECT_EQ(testValidateName(t9), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t9), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t10[] = "abc.'gtest中文'";
-  EXPECT_EQ(testValidateName(t10), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t10), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t10_1[] = "abc.'中文gtest'";
-  EXPECT_EQ(testValidateName(t10_1), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t10_1), TSDB_CODE_TSC_INVALID_OPERATION);
   
   char t11[] = "'192.168.0.1'.abc";
-  EXPECT_EQ(testValidateName(t11), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t11), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t12[] = "192.168.0.1.abc";
-  EXPECT_EQ(testValidateName(t12), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t12), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t13[] = "abc.";
-  EXPECT_EQ(testValidateName(t13), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t13), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t14[] = ".abc";
-  EXPECT_EQ(testValidateName(t14), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t14), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t15[] = ".'abc'";
-  EXPECT_EQ(testValidateName(t15), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t15), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t16[] = ".abc'";
-  EXPECT_EQ(testValidateName(t16), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t16), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t17[] = "123a.\"abc\"";
-  EXPECT_EQ(testValidateName(t17), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t17), TSDB_CODE_TSC_INVALID_OPERATION);
   printf("%s\n", t17);
 
   char t18[] = "a.\"abc\"";
@@ -147,13 +147,13 @@ TEST(testCase, db_table_name) {
   printf("%s\n", t18);
 
   char t19[] = "'_ab1234'.'def'.'ab123'";
-  EXPECT_EQ(testValidateName(t19), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t19), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t20[] = "'_ab1234*&^'";
-  EXPECT_EQ(testValidateName(t20), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t20), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t21[] = "'1234_abc'";
-  EXPECT_EQ(testValidateName(t21), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t21), TSDB_CODE_TSC_INVALID_OPERATION);
 
 
   // =======Containing capital letters=================
@@ -167,10 +167,10 @@ TEST(testCase, db_table_name) {
   EXPECT_EQ(testValidateName(t32), TSDB_CODE_SUCCESS);
 
   char t33[] = "'ABC.def";
-  EXPECT_EQ(testValidateName(t33), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t33), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t33_0[] = "abc.DEF'";
-  EXPECT_EQ(testValidateName(t33_0), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t33_0), TSDB_CODE_TSC_INVALID_OPERATION);
   
   char t34[] = "'ABC.def'";
   //int32_t tmp0 = testValidateName(t34);
@@ -193,136 +193,136 @@ TEST(testCase, db_table_name) {
 
   // do not use key words 
   char t39[] = "table.'DEF'";
-  EXPECT_EQ(testValidateName(t39), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t39), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t40[] = "'table'.'DEF'";
-  EXPECT_EQ(testValidateName(t40), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t40), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t41[] = "'_abXYZ1234'.'deFF'";
   EXPECT_EQ(testValidateName(t41), TSDB_CODE_SUCCESS);
 
   char t42[] = "'_abDEF&^%1234'.'DIef'";
-  EXPECT_EQ(testValidateName(t42), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t42), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t43[] = "'_123'.'Gtest中文'";
-  EXPECT_EQ(testValidateName(t43), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t43), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t44[] = "'aABC'.'Gtest中文'";
-  EXPECT_EQ(testValidateName(t44), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t44), TSDB_CODE_TSC_INVALID_OPERATION);
   
   char t45[] = "'ABC'.";
-  EXPECT_EQ(testValidateName(t45), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t45), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t46[] = ".'ABC'";
-  EXPECT_EQ(testValidateName(t46), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t46), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t47[] = "a.\"aTWc\"";
   EXPECT_EQ(testValidateName(t47), TSDB_CODE_SUCCESS);
 
  // ================has space =================
   char t60[] = " ABC ";
-  EXPECT_EQ(testValidateName(t60), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t60), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t60_1[] = "   ABC ";
-  EXPECT_EQ(testValidateName(t60_1), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t60_1), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t61[] = "' ABC '";
-  EXPECT_EQ(testValidateName(t61), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t61), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t61_1[] = "'  ABC '";
-  EXPECT_EQ(testValidateName(t61_1), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t61_1), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t62[] = " ABC . def ";
-  EXPECT_EQ(testValidateName(t62), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t62), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t63[] = "' ABC . def ";
-  EXPECT_EQ(testValidateName(t63), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t63), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t63_0[] = "  abc . DEF ' ";
-  EXPECT_EQ(testValidateName(t63_0), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t63_0), TSDB_CODE_TSC_INVALID_OPERATION);
   
   char t64[] = " '  ABC .  def ' ";
   //int32_t tmp1 = testValidateName(t64);
-  EXPECT_EQ(testValidateName(t64), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t64), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t65[] = " ' ABC  '. def ";
-  EXPECT_EQ(testValidateName(t65), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t65), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t66[] = "' ABC '.'  DEF '";
-  EXPECT_EQ(testValidateName(t66), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t66), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t67[] = "abc . '  DEF  '";
-  EXPECT_EQ(testValidateName(t67), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t67), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t68[] = "'  abc '.'   DEF '";
-  EXPECT_EQ(testValidateName(t68), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t68), TSDB_CODE_TSC_INVALID_OPERATION);
 
   // do not use key words 
   char t69[] = "table.'DEF'";
-  EXPECT_EQ(testValidateName(t69), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t69), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t70[] = "'table'.'DEF'";
-  EXPECT_EQ(testValidateName(t70), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t70), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t71[] = "'_abXYZ1234  '.' deFF  '";
-  EXPECT_EQ(testValidateName(t71), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t71), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t72[] = "'_abDEF&^%1234'.'  DIef'";
-  EXPECT_EQ(testValidateName(t72), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t72), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t73[] = "'_123'.'  Gtest中文'";
-  EXPECT_EQ(testValidateName(t73), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t73), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t74[] = "' aABC'.'Gtest中文'";
-  EXPECT_EQ(testValidateName(t74), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t74), TSDB_CODE_TSC_INVALID_OPERATION);
   
   char t75[] = "' ABC '.";
-  EXPECT_EQ(testValidateName(t75), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t75), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t76[] = ".' ABC'";
-  EXPECT_EQ(testValidateName(t76), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t76), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t77[] = " a . \"aTWc\" ";
-  EXPECT_EQ(testValidateName(t77), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t77), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t78[] = "  a.\"aTWc  \"";
-  EXPECT_EQ(testValidateName(t78), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t78), TSDB_CODE_TSC_INVALID_OPERATION);
 
 
   // ===============muti string by space ===================
   // There's no such case.
   //char t160[] = "A BC";
-  //EXPECT_EQ(testValidateName(t160), TSDB_CODE_TSC_INVALID_SQL);
+  //EXPECT_EQ(testValidateName(t160), TSDB_CODE_TSC_INVALID_OPERATION);
   //printf("end:%s\n", t160);
 
   // There's no such case.
   //char t161[] = "' A BC '";
-  //EXPECT_EQ(testValidateName(t161), TSDB_CODE_TSC_INVALID_SQL);
+  //EXPECT_EQ(testValidateName(t161), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t162[] = " AB C . de f ";
-  EXPECT_EQ(testValidateName(t162), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t162), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t163[] = "' AB C . de f ";
-  EXPECT_EQ(testValidateName(t163), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t163), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t163_0[] = "  ab c . DE F ' ";
-  EXPECT_EQ(testValidateName(t163_0), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t163_0), TSDB_CODE_TSC_INVALID_OPERATION);
   
   char t164[] = " '  AB C .  de f ' ";
   //int32_t tmp2 = testValidateName(t164);
-  EXPECT_EQ(testValidateName(t164), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t164), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t165[] = " ' A BC  '. de f ";
-  EXPECT_EQ(testValidateName(t165), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t165), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t166[] = "' AB C '.'  DE  F '";
-  EXPECT_EQ(testValidateName(t166), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t166), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t167[] = "ab  c . '  D  EF  '";
-  EXPECT_EQ(testValidateName(t167), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t167), TSDB_CODE_TSC_INVALID_OPERATION);
 
   char t168[] = "'  a bc '.'   DE  F '";
-  EXPECT_EQ(testValidateName(t168), TSDB_CODE_TSC_INVALID_SQL);
+  EXPECT_EQ(testValidateName(t168), TSDB_CODE_TSC_INVALID_OPERATION);
   
 }
 
diff --git a/src/util/src/terror.c b/src/util/src/terror.c
index d88393777c..887b231ec6 100644
--- a/src/util/src/terror.c
+++ b/src/util/src/terror.c
@@ -83,7 +83,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_REF_ALREADY_EXIST,            "Ref is already there"
 TAOS_DEFINE_ERROR(TSDB_CODE_REF_NOT_EXIST,                "Ref is not there")
 
 //client
-TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_SQL,              "Invalid SQL statement")
+TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_OPERATION,        "Invalid operation")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_QHANDLE,          "Invalid qhandle")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_TIME_STAMP,       "Invalid combination of client/service time")
 TAOS_DEFINE_ERROR(TSDB_CODE_TSC_INVALID_VALUE,            "Invalid value in client")

From 0a38b29c3d12ee12942432a2bcf8fc215a958966 Mon Sep 17 00:00:00 2001
From: Elias Soong <elias.soong@gmail.com>
Date: Wed, 26 May 2021 16:06:38 +0800
Subject: [PATCH 105/128] [TD-3963] <docs>: allow alter some database
 parameters without reboot server.

---
 documentation20/cn/12.taos-sql/docs.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/documentation20/cn/12.taos-sql/docs.md b/documentation20/cn/12.taos-sql/docs.md
index 186287515f..b130e0544c 100644
--- a/documentation20/cn/12.taos-sql/docs.md
+++ b/documentation20/cn/12.taos-sql/docs.md
@@ -126,7 +126,7 @@ TDengine 缺省的时间戳是毫秒精度，但通过修改配置参数 enableM
     ```mysql
     ALTER DATABASE db_name CACHELAST 0;
     ```
-    CACHELAST 参数控制是否在内存中缓存数据子表的 last_row。缺省值为 0，取值范围 [0, 1]。其中 0 表示不启用、1 表示启用。（从 2.0.11 版本开始支持，修改后需要重启服务器生效。）
+    CACHELAST 参数控制是否在内存中缓存数据子表的 last_row。缺省值为 0，取值范围 [0, 1]。其中 0 表示不启用、1 表示启用。（从 2.0.11.0 版本开始支持。从 2.1.1.0 版本开始，修改此参数后无需重启服务器即可生效。）
 
     **Tips**: 以上所有参数修改后都可以用show databases来确认是否修改成功。
 

From 3b5fc0cb46b93d410836f9501051565523bb7072 Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Wed, 26 May 2021 16:44:31 +0800
Subject: [PATCH 106/128] fix log error

---
 src/mnode/src/mnodeVgroup.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/mnode/src/mnodeVgroup.c b/src/mnode/src/mnodeVgroup.c
index 67532ad85a..a64d256484 100644
--- a/src/mnode/src/mnodeVgroup.c
+++ b/src/mnode/src/mnodeVgroup.c
@@ -121,7 +121,7 @@ static int32_t mnodeVgroupActionDelete(SSdbRow *pRow) {
   SVgObj *pVgroup = pRow->pObj;
 
   if (pVgroup->pDb == NULL) {
-    mError("vgId:%d, db:%s is not exist while insert into hash", pVgroup->vgId, pVgroup->dbName);
+    mError("vgId:%d, db:%s is not exist while delete from hash", pVgroup->vgId, pVgroup->dbName);
     return TSDB_CODE_MND_VGROUP_NOT_EXIST;
   }
 

From 15ba059cea7b59271fa6c45465b64639adc4286d Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Wed, 26 May 2021 17:25:12 +0800
Subject: [PATCH 107/128] [td-225]fix compiler error on mac.

---
 src/client/src/tscSQLParser.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 45dde54df0..2c433e4414 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -649,7 +649,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       for (int32_t i = 0; i < size; ++i) {
         SSqlNode* pSqlNode = taosArrayGetP(pInfo->list, i);
 
-        tscTrace("%p start to parse %dth subclause, total:%"PRIu64, pSql, i, size);
+        tscTrace("%p start to parse %dth subclause, total:%"PRIzu64, pSql, i, size);
         if ((code = validateSqlNode(pSql, pSqlNode, pQueryInfo)) != TSDB_CODE_SUCCESS) {
           return code;
         }

From d61acaa9e7c8f0a78437cb7a49104310a01087eb Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Wed, 26 May 2021 17:29:20 +0800
Subject: [PATCH 108/128] [td-225]fix compiler error on mac.

---
 src/client/src/tscSQLParser.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 2c433e4414..c387f9da34 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -649,7 +649,7 @@ int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
       for (int32_t i = 0; i < size; ++i) {
         SSqlNode* pSqlNode = taosArrayGetP(pInfo->list, i);
 
-        tscTrace("%p start to parse %dth subclause, total:%"PRIzu64, pSql, i, size);
+        tscTrace("%p start to parse %dth subclause, total:%"PRIzu, pSql, i, size);
         if ((code = validateSqlNode(pSql, pSqlNode, pQueryInfo)) != TSDB_CODE_SUCCESS) {
           return code;
         }

From 1062357eeee0cb3eb04064c20c98a3f356f51ad0 Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Wed, 26 May 2021 17:36:51 +0800
Subject: [PATCH 109/128] [TD-4034]when cacheLast option changed,restore or
 free cache last data

---
 src/tsdb/inc/tsdbMeta.h        |   6 +-
 src/tsdb/inc/tsdbint.h         |   4 +
 src/tsdb/src/tsdbCommitQueue.c |  22 +++--
 src/tsdb/src/tsdbMain.c        | 172 ++++++++++++++++++++++++++++++++-
 src/tsdb/src/tsdbMeta.c        |  23 ++---
 5 files changed, 203 insertions(+), 24 deletions(-)

diff --git a/src/tsdb/inc/tsdbMeta.h b/src/tsdb/inc/tsdbMeta.h
index 45868c002d..14d5a41768 100644
--- a/src/tsdb/inc/tsdbMeta.h
+++ b/src/tsdb/inc/tsdbMeta.h
@@ -38,8 +38,9 @@ typedef struct STable {
   SRWLatch       latch;  // TODO: implementa latch functions
 
   SDataCol      *lastCols;
-  int16_t        lastColNum;
-  int16_t        maxColumnNum;
+  int16_t        maxColNum;
+  int16_t        restoreColumnNum;
+  bool           hasRestoreLastColumn;
   int            lastColSVersion;
   T_REF_DECLARE()
 } STable;
@@ -90,6 +91,7 @@ int        tsdbInitColIdCacheWithSchema(STable* pTable, STSchema* pSchema);
 int16_t    tsdbGetLastColumnsIndexByColId(STable* pTable, int16_t colId);
 int        tsdbUpdateLastColSchema(STable *pTable, STSchema *pNewSchema);
 STSchema*  tsdbGetTableLatestSchema(STable *pTable);
+void       tsdbFreeLastColumns(STable* pTable);
 
 static FORCE_INLINE int tsdbCompareSchemaVersion(const void *key1, const void *key2) {
   if (*(int16_t *)key1 < schemaVersion(*(STSchema **)key2)) {
diff --git a/src/tsdb/inc/tsdbint.h b/src/tsdb/inc/tsdbint.h
index 4d62164df9..e74c3238e2 100644
--- a/src/tsdb/inc/tsdbint.h
+++ b/src/tsdb/inc/tsdbint.h
@@ -75,6 +75,9 @@ struct STsdbRepo {
   STsdbCfg        save_config;    // save apply config
   bool            config_changed; // config changed flag
   pthread_mutex_t save_mutex;     // protect save config
+  
+  uint8_t         hasCachedLastRow;
+  uint8_t         hasCachedLastColumn;
 
   STsdbAppH       appH;
   STsdbStat       stat;
@@ -100,6 +103,7 @@ int        tsdbUnlockRepo(STsdbRepo* pRepo);
 STsdbMeta* tsdbGetMeta(STsdbRepo* pRepo);
 int        tsdbCheckCommit(STsdbRepo* pRepo);
 int        tsdbRestoreInfo(STsdbRepo* pRepo);
+int        tsdbCacheLastData(STsdbRepo *pRepo, STsdbCfg* oldCfg);
 void       tsdbGetRootDir(int repoid, char dirName[]);
 void       tsdbGetDataDir(int repoid, char dirName[]);
 
diff --git a/src/tsdb/src/tsdbCommitQueue.c b/src/tsdb/src/tsdbCommitQueue.c
index e753a3211e..abea79bc4f 100644
--- a/src/tsdb/src/tsdbCommitQueue.c
+++ b/src/tsdb/src/tsdbCommitQueue.c
@@ -113,11 +113,15 @@ int tsdbScheduleCommit(STsdbRepo *pRepo) {
 }
 
 static void tsdbApplyRepoConfig(STsdbRepo *pRepo) {
+  pthread_mutex_lock(&pRepo->save_mutex);
+
   pRepo->config_changed = false;
   STsdbCfg * pSaveCfg = &pRepo->save_config;
-
+  STsdbCfg oldCfg;
   int32_t oldTotalBlocks = pRepo->config.totalBlocks;
 
+  memcpy(&oldCfg, &(pRepo->config), sizeof(STsdbCfg));
+
   pRepo->config.compression = pRepo->save_config.compression;
   pRepo->config.keep = pRepo->save_config.keep;
   pRepo->config.keep1 = pRepo->save_config.keep1;
@@ -125,10 +129,12 @@ static void tsdbApplyRepoConfig(STsdbRepo *pRepo) {
   pRepo->config.cacheLastRow = pRepo->save_config.cacheLastRow;
   pRepo->config.totalBlocks = pRepo->save_config.totalBlocks;
 
-  tsdbInfo("vgId:%d apply new config: compression(%d), keep(%d,%d,%d), totalBlocks(%d), cacheLastRow(%d),totalBlocks(%d)",
+  pthread_mutex_unlock(&pRepo->save_mutex);
+
+  tsdbInfo("vgId:%d apply new config: compression(%d), keep(%d,%d,%d), totalBlocks(%d), cacheLastRow(%d->%d),totalBlocks(%d->%d)",
     REPO_ID(pRepo),
     pSaveCfg->compression, pSaveCfg->keep,pSaveCfg->keep1, pSaveCfg->keep2,
-    pSaveCfg->totalBlocks, pSaveCfg->cacheLastRow, pSaveCfg->totalBlocks);
+    pSaveCfg->totalBlocks, oldCfg.cacheLastRow, pSaveCfg->cacheLastRow, oldTotalBlocks, pSaveCfg->totalBlocks);
 
   int err = tsdbExpendPool(pRepo, oldTotalBlocks);
   if (!TAOS_SUCCEEDED(err)) {
@@ -136,6 +142,12 @@ static void tsdbApplyRepoConfig(STsdbRepo *pRepo) {
       REPO_ID(pRepo), oldTotalBlocks, pSaveCfg->totalBlocks, tstrerror(err));
   }
 
+  if (oldCfg.cacheLastRow != pRepo->config.cacheLastRow) {
+    if (tsdbLockRepo(pRepo) < 0) return;
+    tsdbCacheLastData(pRepo, &oldCfg);
+    tsdbUnlockRepo(pRepo);
+  }
+
 }
 
 static void *tsdbLoopCommit(void *arg) {
@@ -165,10 +177,8 @@ static void *tsdbLoopCommit(void *arg) {
     pRepo = ((SCommitReq *)pNode->data)->pRepo;
 
     // check if need to apply new config
-    if (pRepo->config_changed) {
-      pthread_mutex_lock(&pRepo->save_mutex);       
+    if (pRepo->config_changed) {             
       tsdbApplyRepoConfig(pRepo);
-      pthread_mutex_unlock(&pRepo->save_mutex);
     }
 
     tsdbCommitData(pRepo);
diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index 880400dd9f..a8bbd0d69e 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -548,6 +548,8 @@ static STsdbRepo *tsdbNewRepo(STsdbCfg *pCfg, STsdbAppH *pAppH) {
     return NULL;
   }
   pRepo->config_changed = false;
+  atomic_store_8(&pRepo->hasCachedLastRow, 0);
+  atomic_store_8(&pRepo->hasCachedLastColumn, 0);
 
   code = tsem_init(&(pRepo->readyToCommit), 0, 1);
   if (code != 0) {
@@ -636,7 +638,7 @@ static int tsdbRestoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pRea
   int err = 0;
 
   numColumns = schemaNCols(pSchema);
-  if (numColumns <= pTable->maxColumnNum) {
+  if (numColumns <= pTable->restoreColumnNum) {
     return 0;
   }
   if (pTable->lastColSVersion != schemaVersion(pSchema)) {
@@ -675,7 +677,7 @@ static int tsdbRestoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pRea
   SBlockIdx *pIdx = pReadh->pBlkIdx;
   blockIdx = (int32_t)(pIdx->numOfBlocks - 1);
 
-  while (numColumns > pTable->maxColumnNum && blockIdx >= 0) {
+  while (numColumns > pTable->restoreColumnNum && blockIdx >= 0) {
     bool loadStatisData = false;
     pBlock = pReadh->pBlkInfo->blocks + blockIdx;
     blockIdx -= 1;
@@ -693,7 +695,7 @@ static int tsdbRestoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pRea
       loadStatisData = true;
     }
 
-    for (int16_t i = 0; i < numColumns && numColumns > pTable->maxColumnNum; ++i) {
+    for (int16_t i = 0; i < numColumns && numColumns > pTable->restoreColumnNum; ++i) {
       STColumn *pCol = schemaColAt(pSchema, i);
       // ignore loaded columns
       if (pTable->lastCols[i].bytes != 0) {
@@ -733,7 +735,7 @@ static int tsdbRestoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pRea
         tdAppendColVal(row, tdGetColDataOfRow(pDataCol, rowId), pCol->type, pCol->bytes, pCol->offset);
         pLastCol->ts = dataRowKey(row);
 
-        pTable->maxColumnNum += 1;
+        pTable->restoreColumnNum += 1;
 
         tsdbDebug("tsdbRestoreLastColumns restore vgId:%d,table:%s cache column %d, %" PRId64, REPO_ID(pRepo), pTable->name->data, pLastCol->colId, pLastCol->ts);
         break;
@@ -766,7 +768,7 @@ int tsdbRestoreInfo(STsdbRepo *pRepo) {
     for (int i = 1; i < pMeta->maxTables; i++) {
       STable *pTable = pMeta->tables[i];
       if (pTable == NULL) continue;
-      pTable->maxColumnNum = 0;  
+      pTable->restoreColumnNum = 0;  
     }
   }
 
@@ -841,5 +843,165 @@ int tsdbRestoreInfo(STsdbRepo *pRepo) {
   }
 
   tsdbDestroyReadH(&readh);
+  if (CACHE_LAST_ROW(pCfg)) {
+    atomic_store_8(&pRepo->hasCachedLastRow, 1);
+  }
+  if (CACHE_LAST_NULL_COLUMN(pCfg)) {
+    atomic_store_8(&pRepo->hasCachedLastColumn, 1);
+  }
+
   return 0;
 }
+
+int tsdbCacheLastData(STsdbRepo *pRepo, STsdbCfg* oldCfg) {
+  bool cacheLastRow = false, cacheLastCol = false;
+  SFSIter    fsiter;
+  SReadH     readh;
+  SDFileSet *pSet;
+  STsdbMeta *pMeta = pRepo->tsdbMeta;
+  //STsdbCfg * pCfg = REPO_CFG(pRepo);
+  SBlock *   pBlock;
+  int tableNum = 0;
+  int maxTableIdx = 0;
+  int cacheLastRowTableNum = 0;
+  int cacheLastColTableNum = 0;
+
+  bool need_free_last_row = CACHE_LAST_ROW(oldCfg) && !CACHE_LAST_ROW(&(pRepo->config));
+  bool need_free_last_col = CACHE_LAST_NULL_COLUMN(oldCfg) && !CACHE_LAST_NULL_COLUMN(&(pRepo->config));
+
+  if (CACHE_LAST_ROW(&(pRepo->config)) || CACHE_LAST_NULL_COLUMN(&(pRepo->config))) {    
+    tsdbInfo("tsdbCacheLastData cache last data since cacheLast option changed");
+    cacheLastRow = !CACHE_LAST_ROW(oldCfg) && CACHE_LAST_ROW(&(pRepo->config));
+    cacheLastCol = !CACHE_LAST_NULL_COLUMN(oldCfg) && CACHE_LAST_NULL_COLUMN(&(pRepo->config));
+  }
+
+  // calc max table idx and table num
+  for (int i = 1; i < pMeta->maxTables; i++) {
+    STable *pTable = pMeta->tables[i];
+    if (pTable == NULL) continue;
+    tableNum += 1;
+    maxTableIdx = i;
+    if (cacheLastCol) {
+      pTable->restoreColumnNum = 0;
+    } 
+  }
+
+  // if close last option,need to free data
+  if (need_free_last_row || need_free_last_col) {
+    if (need_free_last_row) {
+      atomic_store_8(&pRepo->hasCachedLastRow, 0);
+    }
+    if (need_free_last_col) {
+      atomic_store_8(&pRepo->hasCachedLastColumn, 0);
+    }
+    tsdbInfo("free cache last data since cacheLast option changed");    
+    for (int i = 1; i < maxTableIdx; i++) {
+      STable *pTable = pMeta->tables[i];
+      if (pTable == NULL) continue;   
+      if (need_free_last_row) {
+        taosTZfree(pTable->lastRow);
+        pTable->lastRow = NULL;
+        pTable->lastKey = TSKEY_INITIAL_VAL;
+      }
+      if (need_free_last_col) {
+        tsdbFreeLastColumns(pTable);
+      }
+    }    
+  }
+
+  if (!cacheLastRow && !cacheLastCol) {
+    return 0;
+  }
+
+  cacheLastRowTableNum = cacheLastRow ? tableNum : 0;
+  cacheLastColTableNum = cacheLastCol ? tableNum : 0;
+
+  if (tsdbInitReadH(&readh, pRepo) < 0) {
+    return -1;
+  }
+
+  tsdbFSIterInit(&fsiter, REPO_FS(pRepo), TSDB_FS_ITER_BACKWARD);
+
+  while ((pSet = tsdbFSIterNext(&fsiter)) != NULL && (cacheLastRowTableNum > 0 || cacheLastColTableNum > 0)) {
+    if (tsdbSetAndOpenReadFSet(&readh, pSet) < 0) {
+      tsdbDestroyReadH(&readh);
+      return -1;
+    }
+
+    if (tsdbLoadBlockIdx(&readh) < 0) {
+      tsdbDestroyReadH(&readh);
+      return -1;
+    }
+
+    for (int i = 1; i <= maxTableIdx; i++) {
+      STable *pTable = pMeta->tables[i];
+      if (pTable == NULL) continue;
+
+      //tsdbInfo("tsdbRestoreInfo restore vgId:%d,table:%s", REPO_ID(pRepo), pTable->name->data);
+
+      if (tsdbSetReadTable(&readh, pTable) < 0) {
+        tsdbDestroyReadH(&readh);
+        return -1;
+      }
+
+      SBlockIdx *pIdx = readh.pBlkIdx;
+
+      if (pIdx && cacheLastRowTableNum > 0 && pTable->lastRow == NULL) {                
+        pTable->lastKey = pIdx->maxKey;
+
+        if (tsdbLoadBlockInfo(&readh, NULL) < 0) {
+          tsdbDestroyReadH(&readh);
+          return -1;
+        }
+
+        pBlock = readh.pBlkInfo->blocks + pIdx->numOfBlocks - 1;
+
+        if (tsdbLoadBlockData(&readh, pBlock, NULL) < 0) {
+          tsdbDestroyReadH(&readh);
+          return -1;
+        }
+
+        // Get the data in row
+        ASSERT(pTable->lastRow == NULL);
+        STSchema *pSchema = tsdbGetTableSchema(pTable);
+        pTable->lastRow = taosTMalloc(dataRowMaxBytesFromSchema(pSchema));
+        if (pTable->lastRow == NULL) {
+          terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+          tsdbDestroyReadH(&readh);
+          return -1;
+        }
+
+        tdInitDataRow(pTable->lastRow, pSchema);
+        for (int icol = 0; icol < schemaNCols(pSchema); icol++) {
+          STColumn *pCol = schemaColAt(pSchema, icol);
+          SDataCol *pDataCol = readh.pDCols[0]->cols + icol;
+          tdAppendColVal(pTable->lastRow, tdGetColDataOfRow(pDataCol, pBlock->numOfRows - 1), pCol->type, pCol->bytes,
+                          pCol->offset);
+        }
+        cacheLastRowTableNum -= 1;
+      }
+      
+      // restore NULL columns
+      if (pIdx && cacheLastColTableNum > 0 && !pTable->hasRestoreLastColumn) {
+        if (tsdbRestoreLastColumns(pRepo, pTable, &readh) != 0) {
+          tsdbDestroyReadH(&readh);
+          return -1;
+        }
+        if (pTable->hasRestoreLastColumn) {
+          cacheLastColTableNum -= 1;
+        }
+      }
+    }
+  }
+
+  tsdbDestroyReadH(&readh);
+
+  if (cacheLastRow) {
+    atomic_store_8(&pRepo->hasCachedLastRow, 1);
+  }
+  if (cacheLastCol) {
+    atomic_store_8(&pRepo->hasCachedLastColumn, 1);
+  }
+  
+  return 0;
+}
\ No newline at end of file
diff --git a/src/tsdb/src/tsdbMeta.c b/src/tsdb/src/tsdbMeta.c
index 5717d52eea..324a7c79c5 100644
--- a/src/tsdb/src/tsdbMeta.c
+++ b/src/tsdb/src/tsdbMeta.c
@@ -44,7 +44,6 @@ static int     tsdbRemoveTableFromStore(STsdbRepo *pRepo, STable *pTable);
 static int     tsdbRmTableFromMeta(STsdbRepo *pRepo, STable *pTable);
 static int     tsdbAdjustMetaTables(STsdbRepo *pRepo, int tid);
 static int     tsdbCheckTableTagVal(SKVRow *pKVRow, STSchema *pSchema);
-static void    tsdbFreeLastColumns(STable* pTable);
 
 // ------------------ OUTER FUNCTIONS ------------------
 int tsdbCreateTable(STsdbRepo *repo, STableCfg *pCfg) {
@@ -590,12 +589,12 @@ void tsdbUnRefTable(STable *pTable) {
   }
 }
 
-static void tsdbFreeLastColumns(STable* pTable) {
+void tsdbFreeLastColumns(STable* pTable) {
   if (pTable->lastCols == NULL) {
     return;
   }
 
-  for (int i = 0; i < pTable->lastColNum; ++i) {
+  for (int i = 0; i < pTable->maxColNum; ++i) {
     if (pTable->lastCols[i].bytes == 0) {
       continue;
     }
@@ -605,14 +604,16 @@ static void tsdbFreeLastColumns(STable* pTable) {
   }
   tfree(pTable->lastCols);
   pTable->lastCols = NULL;
-  pTable->lastColNum = 0;
+  pTable->maxColNum = 0;
+  pTable->lastColSVersion = -1;
+  pTable->restoreColumnNum = 0;
 }
 
 int16_t tsdbGetLastColumnsIndexByColId(STable* pTable, int16_t colId) {
   if (pTable->lastCols == NULL) {
     return -1;
   }
-  for (int16_t i = 0; i < pTable->lastColNum; ++i) {
+  for (int16_t i = 0; i < pTable->maxColNum; ++i) {
     if (pTable->lastCols[i].colId == colId) {
       return i;
     }
@@ -640,8 +641,8 @@ int tsdbInitColIdCacheWithSchema(STable* pTable, STSchema* pSchema) {
   }
 
   pTable->lastColSVersion = schemaVersion(pSchema);
-  pTable->lastColNum = numOfColumn;
-  pTable->maxColumnNum = 0;
+  pTable->maxColNum = numOfColumn;
+  pTable->restoreColumnNum = 0;
   return 0;
 }
 
@@ -682,11 +683,11 @@ int tsdbUpdateLastColSchema(STable *pTable, STSchema *pNewSchema) {
   }
 
   SDataCol *oldLastCols = pTable->lastCols;
-  int16_t oldLastColNum = pTable->lastColNum;
+  int16_t oldLastColNum = pTable->maxColNum;
 
   pTable->lastColSVersion = schemaVersion(pNewSchema);
   pTable->lastCols = lastCols;
-  pTable->lastColNum = numOfCols;
+  pTable->maxColNum = numOfCols;
 
   if (oldLastCols == NULL) {
     TSDB_WUNLOCK_TABLE(pTable);
@@ -797,8 +798,8 @@ static STable *tsdbNewTable() {
   pTable->lastKey = TSKEY_INITIAL_VAL;
 
   pTable->lastCols = NULL;
-  pTable->maxColumnNum = 0;
-  pTable->lastColNum = 0;
+  pTable->restoreColumnNum = 0;
+  pTable->maxColNum = 0;
   pTable->lastColSVersion = -1;
   return pTable;
 }

From 013d6f840dc09600aa7510dc459c2eaef5eff012 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Wed, 26 May 2021 17:55:59 +0800
Subject: [PATCH 110/128] [td-225]

---
 src/mnode/src/mnodeTable.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index e1cae0d054..11178a143e 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -2854,6 +2854,7 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
   int32_t code     = TSDB_CODE_SUCCESS;
   char*   str      = strndup(pInfo->tableNames, contLen);
   char**  nameList = strsplit(str, ",", &num);
+  SArray* pList    = taosArrayInit(4, POINTER_BYTES);
   SMultiTableMeta *pMultiMeta = NULL;
 
   if (num != pInfo->numOfTables + pInfo->numOfVgroups) {
@@ -2873,8 +2874,6 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
   pMultiMeta->contLen = sizeof(SMultiTableMeta);
   pMultiMeta->numOfTables = 0;
 
-  SArray* pList = taosArrayInit(4, POINTER_BYTES);
-
   int32_t t = 0;
   for (; t < pInfo->numOfTables; ++t) {
     char *fullName = nameList[t];

From da4b78f1bad71b606461c46066a759249ac50d28 Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Wed, 26 May 2021 18:27:04 +0800
Subject: [PATCH 111/128] [TD-4034]when config changed,apply a commit msg then
 config will be applied

---
 src/tsdb/src/tsdbCommit.c | 3 +++
 src/tsdb/src/tsdbMain.c   | 6 ++++++
 2 files changed, 9 insertions(+)

diff --git a/src/tsdb/src/tsdbCommit.c b/src/tsdb/src/tsdbCommit.c
index 24f1c11628..c43b35492d 100644
--- a/src/tsdb/src/tsdbCommit.c
+++ b/src/tsdb/src/tsdbCommit.c
@@ -90,6 +90,9 @@ static int  tsdbApplyRtn(STsdbRepo *pRepo);
 static int  tsdbApplyRtnOnFSet(STsdbRepo *pRepo, SDFileSet *pSet, SRtn *pRtn);
 
 void *tsdbCommitData(STsdbRepo *pRepo) {
+  if (pRepo->imem == NULL) {
+    return NULL;
+  }
   tsdbStartCommit(pRepo);
 
   // Commit to update meta file
diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index a8bbd0d69e..d4bc712275 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -268,6 +268,12 @@ int32_t tsdbConfigRepo(STsdbRepo *repo, STsdbCfg *pCfg) {
   repo->config_changed = true;
 
   pthread_mutex_unlock(&repo->save_mutex);
+
+  // schedule a commit msg then the new config will be applyed immediatly
+  if (tsdbLockRepo(repo) < 0) return -1;
+  tsdbScheduleCommit(repo);
+  if (tsdbUnlockRepo(repo) < 0) return -1;
+
   return 0;
 #if 0
   STsdbRepo *pRepo = (STsdbRepo *)repo;

From 6213438f2e9056d6e234e711b02c7a724f9451dd Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Wed, 26 May 2021 18:27:22 +0800
Subject: [PATCH 112/128] [TD-4034]when config changed,apply a commit msg then
 config will be applied

---
 src/tsdb/src/tsdbMain.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index d4bc712275..cc2fca420c 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -269,7 +269,7 @@ int32_t tsdbConfigRepo(STsdbRepo *repo, STsdbCfg *pCfg) {
 
   pthread_mutex_unlock(&repo->save_mutex);
 
-  // schedule a commit msg then the new config will be applyed immediatly
+  // schedule a commit msg then the new config will be applied immediatly
   if (tsdbLockRepo(repo) < 0) return -1;
   tsdbScheduleCommit(repo);
   if (tsdbUnlockRepo(repo) < 0) return -1;

From ca4e75b69a6926fe5cc5c741d3f0da70bcdaa776 Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Wed, 26 May 2021 18:30:31 +0800
Subject: [PATCH 113/128] fix bug

---
 src/tsdb/src/tsdbRead.c | 22 +++++++---------------
 1 file changed, 7 insertions(+), 15 deletions(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 626602576f..50acda0d95 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -138,7 +138,7 @@ typedef struct STableGroupSupporter {
 
 static STimeWindow updateLastrowForEachGroup(STableGroupInfo *groupList);
 static int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *groupList);
-static int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle, STableGroupInfo *groupList);
+static int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle);
 static int32_t tsdbGetCachedLastRow(STable* pTable, SDataRow* pRes, TSKEY* lastKey);
 
 static void    changeQueryHandleForInterpQuery(TsdbQueryHandleT pHandle);
@@ -541,7 +541,7 @@ TsdbQueryHandleT tsdbQueryLastRow(STsdbRepo *tsdb, STsdbQueryCond *pCond, STable
 
 TsdbQueryHandleT tsdbQueryCacheLast(STsdbRepo *tsdb, STsdbQueryCond *pCond, STableGroupInfo *groupList, uint64_t qId, SMemRef* pMemRef) {
   STsdbQueryHandle *pQueryHandle = (STsdbQueryHandle*) tsdbQueryTables(tsdb, pCond, groupList, qId, pMemRef);
-  int32_t code = checkForCachedLast(pQueryHandle, groupList);
+  int32_t code = checkForCachedLast(pQueryHandle);
   if (code != TSDB_CODE_SUCCESS) { // set the numOfTables to be 0
     terrno = code;
     return NULL;
@@ -2502,9 +2502,9 @@ static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
     STable* pTable = pCheckInfo->pTableObj;  
     char* pData = NULL;
 
-    int32_t numOfCols = pTable->lastColNum;
+    int32_t numOfCols = pTable->maxColNum;
     
-    if (pTable->lastCols == NULL || pTable->lastColNum <= 0) {
+    if (pTable->lastCols == NULL || pTable->maxColNum <= 0) {
       tsdbWarn("no last cached for table, uid:%" PRIu64 ",tid:%d", pTable->tableId.uid, pTable->tableId.tid);
       continue;
     }
@@ -2912,19 +2912,12 @@ int32_t checkForCachedLastRow(STsdbQueryHandle* pQueryHandle, STableGroupInfo *g
   return code;
 }
 
-int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle, STableGroupInfo *groupList) {
-  assert(pQueryHandle != NULL && groupList != NULL);
-
-  SDataRow pRow = NULL;
-
-  SArray* group = taosArrayGetP(groupList->pGroupList, 0);
-  assert(group != NULL);
-
-  STableKeyInfo* pInfo = (STableKeyInfo*)taosArrayGet(group, 0);
+int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle) {
+  assert(pQueryHandle != NULL);
 
   int32_t code = 0;
   
-  if (((STable*)pInfo->pTable)->lastCols && ((STable*)pInfo->pTable)->lastColNum > 0){
+  if (pQueryHandle->pTsdb && atomic_load_8(&pQueryHandle->pTsdb->hasCachedLastColumn)){
     pQueryHandle->cachelastrow = 2;
   }
 
@@ -2935,7 +2928,6 @@ int32_t checkForCachedLast(STsdbQueryHandle* pQueryHandle, STableGroupInfo *grou
     pQueryHandle->activeIndex = -1;  // start from -1
   }
 
-  tfree(pRow);
   return code;
 }
 

From d66b6e2d850431eb5b98a579952f964b0309e0fe Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Wed, 26 May 2021 19:35:47 +0800
Subject: [PATCH 114/128] [TD-4034]refactor code

---
 src/common/src/ttypes.c     |  61 --------------------
 src/inc/tsdb.h              |   2 +-
 src/inc/ttype.h             |   3 -
 src/tsdb/inc/tsdbMeta.h     |   3 -
 src/tsdb/src/tsdbMain.c     | 109 +++++++++++++++---------------------
 src/tsdb/src/tsdbMemTable.c |   6 +-
 6 files changed, 49 insertions(+), 135 deletions(-)

diff --git a/src/common/src/ttypes.c b/src/common/src/ttypes.c
index 6587a27760..6fa27a029b 100644
--- a/src/common/src/ttypes.c
+++ b/src/common/src/ttypes.c
@@ -417,18 +417,6 @@ void setVardataNull(char* val, int32_t type) {
   }
 }
 
-bool isVardataNull(char* val, int32_t type) {
-  if (type == TSDB_DATA_TYPE_BINARY) {
-    return *(uint8_t*) varDataVal(val) == TSDB_DATA_BINARY_NULL;
-  } else if (type == TSDB_DATA_TYPE_NCHAR) {
-    return *(uint32_t*) varDataVal(val) == TSDB_DATA_NCHAR_NULL;
-  } else {
-    assert(0);
-  }
-
-  return false;
-}
-
 void setNull(char *val, int32_t type, int32_t bytes) { setNullN(val, type, bytes, 1); }
 
 void setNullN(char *val, int32_t type, int32_t bytes, int32_t numOfElems) {
@@ -504,55 +492,6 @@ void setNullN(char *val, int32_t type, int32_t bytes, int32_t numOfElems) {
   }
 }
 
-bool isNullN(char *val, int32_t type) {
-  switch (type) {
-    case TSDB_DATA_TYPE_BOOL:
-      return *(uint8_t *)(val) == TSDB_DATA_BOOL_NULL;
-      break;
-    case TSDB_DATA_TYPE_TINYINT:
-      return *(uint8_t *)(val) == TSDB_DATA_TINYINT_NULL;
-      break;
-    case TSDB_DATA_TYPE_SMALLINT:
-      return *(uint16_t *)(val) == TSDB_DATA_SMALLINT_NULL;
-      break;
-    case TSDB_DATA_TYPE_INT:
-      return *(uint32_t *)(val) == TSDB_DATA_INT_NULL;
-      break;
-    case TSDB_DATA_TYPE_BIGINT:
-    case TSDB_DATA_TYPE_TIMESTAMP:
-      return *(uint64_t *)(val) == TSDB_DATA_BIGINT_NULL;
-      break;
-    case TSDB_DATA_TYPE_UTINYINT:
-      return *(uint8_t *)(val) == TSDB_DATA_UTINYINT_NULL;
-      break;
-    case TSDB_DATA_TYPE_USMALLINT:
-      return *(uint16_t *)(val) == TSDB_DATA_USMALLINT_NULL;
-      break;
-    case TSDB_DATA_TYPE_UINT:
-      return *(uint32_t *)(val) == TSDB_DATA_UINT_NULL;
-      break;
-    case TSDB_DATA_TYPE_UBIGINT:
-      return *(uint64_t *)(val) == TSDB_DATA_UBIGINT_NULL;
-      break;
-    case TSDB_DATA_TYPE_FLOAT:
-      return *(uint32_t *)(val) == TSDB_DATA_FLOAT_NULL;
-      break;
-    case TSDB_DATA_TYPE_DOUBLE:
-      return *(uint64_t *)(val) == TSDB_DATA_DOUBLE_NULL;
-      break;
-    case TSDB_DATA_TYPE_NCHAR:
-    case TSDB_DATA_TYPE_BINARY:
-      return isVardataNull(val, type);
-      break;
-    default: {
-      return *(uint32_t *)(val) == TSDB_DATA_INT_NULL;
-      break;
-    }
-  }
-
-  return false;
-}
-
 static uint8_t   nullBool     = TSDB_DATA_BOOL_NULL;
 static uint8_t   nullTinyInt  = TSDB_DATA_TINYINT_NULL;
 static uint16_t  nullSmallInt = TSDB_DATA_SMALLINT_NULL;
diff --git a/src/inc/tsdb.h b/src/inc/tsdb.h
index 7c28d3e485..5f2d866fdb 100644
--- a/src/inc/tsdb.h
+++ b/src/inc/tsdb.h
@@ -69,7 +69,7 @@ typedef struct {
   int8_t  precision;
   int8_t  compression;
   int8_t  update;
-  int8_t  cacheLastRow;    // 0:no cache, 1: cache last row, 2: cache last NULL column
+  int8_t  cacheLastRow;    // 0:no cache, 1: cache last row, 2: cache last NULL column 3: 1&2
 } STsdbCfg;
 
 #define CACHE_NO_LAST(c)          ((c)->cacheLastRow == 0)
diff --git a/src/inc/ttype.h b/src/inc/ttype.h
index 43dbeb7640..9949f31c59 100644
--- a/src/inc/ttype.h
+++ b/src/inc/ttype.h
@@ -178,9 +178,6 @@ void  setNull(char *val, int32_t type, int32_t bytes);
 void  setNullN(char *val, int32_t type, int32_t bytes, int32_t numOfElems);
 void *getNullValue(int32_t type);
 
-bool isVardataNull(char* val, int32_t type);
-bool isNullN(char *val, int32_t type);
-
 void assignVal(char *val, const char *src, int32_t len, int32_t type);
 void tsDataSwap(void *pLeft, void *pRight, int32_t type, int32_t size, void* buf);
 
diff --git a/src/tsdb/inc/tsdbMeta.h b/src/tsdb/inc/tsdbMeta.h
index 14d5a41768..45bbd5a7c6 100644
--- a/src/tsdb/inc/tsdbMeta.h
+++ b/src/tsdb/inc/tsdbMeta.h
@@ -45,9 +45,6 @@ typedef struct STable {
   T_REF_DECLARE()
 } STable;
 
-#define TSDB_LATEST_COLUMN_ARRAY_SIZE     20
-#define TSDB_LATEST_COLUMN_ARRAY_ADD_SIZE 5
-
 typedef struct {
   pthread_rwlock_t rwLock;
 
diff --git a/src/tsdb/src/tsdbMain.c b/src/tsdb/src/tsdbMain.c
index cc2fca420c..afbedd5b2f 100644
--- a/src/tsdb/src/tsdbMain.c
+++ b/src/tsdb/src/tsdbMain.c
@@ -27,6 +27,7 @@ static void       tsdbFreeRepo(STsdbRepo *pRepo);
 static void       tsdbStartStream(STsdbRepo *pRepo);
 static void       tsdbStopStream(STsdbRepo *pRepo);
 static int        tsdbRestoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh);
+static int        tsdbRestoreLastRow(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh, SBlockIdx *pIdx);
 
 // Function declaration
 int32_t tsdbCreateRepo(int repoid) {
@@ -270,9 +271,7 @@ int32_t tsdbConfigRepo(STsdbRepo *repo, STsdbCfg *pCfg) {
   pthread_mutex_unlock(&repo->save_mutex);
 
   // schedule a commit msg then the new config will be applied immediatly
-  if (tsdbLockRepo(repo) < 0) return -1;
-  tsdbScheduleCommit(repo);
-  if (tsdbUnlockRepo(repo) < 0) return -1;
+  tsdbAsyncCommit(repo);
 
   return 0;
 #if 0
@@ -645,6 +644,7 @@ static int tsdbRestoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pRea
 
   numColumns = schemaNCols(pSchema);
   if (numColumns <= pTable->restoreColumnNum) {
+    pTable->hasRestoreLastColumn = true;
     return 0;
   }
   if (pTable->lastColSVersion != schemaVersion(pSchema)) {
@@ -719,7 +719,7 @@ static int tsdbRestoreLastColumns(STsdbRepo *pRepo, STable *pTable, SReadH* pRea
         tdAppendColVal(row, tdGetColDataOfRow(pDataCol, rowId), pCol->type, pCol->bytes, pCol->offset);
         //SDataCol *pDataCol = readh.pDCols[0]->cols + j;
         void* value = tdGetRowDataOfCol(row, (int8_t)pCol->type, TD_DATA_ROW_HEAD_SIZE + pCol->offset);
-        if (isNullN(value, pCol->type)) {
+        if (isNull(value, pCol->type)) {
           continue;
         }
 
@@ -753,16 +753,51 @@ out:
   taosTZfree(row);
   tfree(pBlockStatis);
 
+  if (err == 0 && numColumns <= pTable->restoreColumnNum) {
+    pTable->hasRestoreLastColumn = true;
+  }
+
   return err;
 }
 
+static int tsdbRestoreLastRow(STsdbRepo *pRepo, STable *pTable, SReadH* pReadh, SBlockIdx *pIdx) {
+  ASSERT(pTable->lastRow == NULL);
+  if (tsdbLoadBlockInfo(pReadh, NULL) < 0) {
+    return -1;
+  }
+
+  SBlock* pBlock = pReadh->pBlkInfo->blocks + pIdx->numOfBlocks - 1;
+
+  if (tsdbLoadBlockData(pReadh, pBlock, NULL) < 0) {
+    return -1;
+  }
+
+  // Get the data in row
+  
+  STSchema *pSchema = tsdbGetTableSchema(pTable);
+  pTable->lastRow = taosTMalloc(dataRowMaxBytesFromSchema(pSchema));
+  if (pTable->lastRow == NULL) {
+    terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
+    return -1;
+  }
+
+  tdInitDataRow(pTable->lastRow, pSchema);
+  for (int icol = 0; icol < schemaNCols(pSchema); icol++) {
+    STColumn *pCol = schemaColAt(pSchema, icol);
+    SDataCol *pDataCol = pReadh->pDCols[0]->cols + icol;
+    tdAppendColVal(pTable->lastRow, tdGetColDataOfRow(pDataCol, pBlock->numOfRows - 1), pCol->type, pCol->bytes,
+                    pCol->offset);
+  }
+
+  return 0;
+}
+
 int tsdbRestoreInfo(STsdbRepo *pRepo) {
   SFSIter    fsiter;
   SReadH     readh;
   SDFileSet *pSet;
   STsdbMeta *pMeta = pRepo->tsdbMeta;
   STsdbCfg * pCfg = REPO_CFG(pRepo);
-  SBlock *   pBlock;
 
   if (tsdbInitReadH(&readh, pRepo) < 0) {
     return -1;
@@ -805,41 +840,14 @@ int tsdbRestoreInfo(STsdbRepo *pRepo) {
       if (pIdx && lastKey < pIdx->maxKey) {
         pTable->lastKey = pIdx->maxKey;
 
-        if (CACHE_LAST_ROW(pCfg)) {
-          if (tsdbLoadBlockInfo(&readh, NULL) < 0) {
-            tsdbDestroyReadH(&readh);
-            return -1;
-          }
-
-          pBlock = readh.pBlkInfo->blocks + pIdx->numOfBlocks - 1;
-
-          if (tsdbLoadBlockData(&readh, pBlock, NULL) < 0) {
-            tsdbDestroyReadH(&readh);
-            return -1;
-          }
-
-          // Get the data in row
-          ASSERT(pTable->lastRow == NULL);
-          STSchema *pSchema = tsdbGetTableSchema(pTable);
-          pTable->lastRow = taosTMalloc(dataRowMaxBytesFromSchema(pSchema));
-          if (pTable->lastRow == NULL) {
-            terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-            tsdbDestroyReadH(&readh);
-            return -1;
-          }
-
-          tdInitDataRow(pTable->lastRow, pSchema);
-          for (int icol = 0; icol < schemaNCols(pSchema); icol++) {
-            STColumn *pCol = schemaColAt(pSchema, icol);
-            SDataCol *pDataCol = readh.pDCols[0]->cols + icol;
-            tdAppendColVal(pTable->lastRow, tdGetColDataOfRow(pDataCol, pBlock->numOfRows - 1), pCol->type, pCol->bytes,
-                           pCol->offset);
-          }
+        if (CACHE_LAST_ROW(pCfg) && tsdbRestoreLastRow(pRepo, pTable, &readh, pIdx) != 0) {
+          tsdbDestroyReadH(&readh);
+          return -1;
         }
       }
       
       // restore NULL columns
-      if (pIdx && CACHE_LAST_NULL_COLUMN(pCfg)) {
+      if (pIdx && CACHE_LAST_NULL_COLUMN(pCfg) && !pTable->hasRestoreLastColumn) {
         if (tsdbRestoreLastColumns(pRepo, pTable, &readh) != 0) {
           tsdbDestroyReadH(&readh);
           return -1;
@@ -865,8 +873,6 @@ int tsdbCacheLastData(STsdbRepo *pRepo, STsdbCfg* oldCfg) {
   SReadH     readh;
   SDFileSet *pSet;
   STsdbMeta *pMeta = pRepo->tsdbMeta;
-  //STsdbCfg * pCfg = REPO_CFG(pRepo);
-  SBlock *   pBlock;
   int tableNum = 0;
   int maxTableIdx = 0;
   int cacheLastRowTableNum = 0;
@@ -955,35 +961,10 @@ int tsdbCacheLastData(STsdbRepo *pRepo, STsdbCfg* oldCfg) {
       if (pIdx && cacheLastRowTableNum > 0 && pTable->lastRow == NULL) {                
         pTable->lastKey = pIdx->maxKey;
 
-        if (tsdbLoadBlockInfo(&readh, NULL) < 0) {
+        if (tsdbRestoreLastRow(pRepo, pTable, &readh, pIdx) != 0) {
           tsdbDestroyReadH(&readh);
           return -1;
         }
-
-        pBlock = readh.pBlkInfo->blocks + pIdx->numOfBlocks - 1;
-
-        if (tsdbLoadBlockData(&readh, pBlock, NULL) < 0) {
-          tsdbDestroyReadH(&readh);
-          return -1;
-        }
-
-        // Get the data in row
-        ASSERT(pTable->lastRow == NULL);
-        STSchema *pSchema = tsdbGetTableSchema(pTable);
-        pTable->lastRow = taosTMalloc(dataRowMaxBytesFromSchema(pSchema));
-        if (pTable->lastRow == NULL) {
-          terrno = TSDB_CODE_TDB_OUT_OF_MEMORY;
-          tsdbDestroyReadH(&readh);
-          return -1;
-        }
-
-        tdInitDataRow(pTable->lastRow, pSchema);
-        for (int icol = 0; icol < schemaNCols(pSchema); icol++) {
-          STColumn *pCol = schemaColAt(pSchema, icol);
-          SDataCol *pDataCol = readh.pDCols[0]->cols + icol;
-          tdAppendColVal(pTable->lastRow, tdGetColDataOfRow(pDataCol, pBlock->numOfRows - 1), pCol->type, pCol->bytes,
-                          pCol->offset);
-        }
         cacheLastRowTableNum -= 1;
       }
       
diff --git a/src/tsdb/src/tsdbMemTable.c b/src/tsdb/src/tsdbMemTable.c
index ff2a870f3f..79dbb8be5d 100644
--- a/src/tsdb/src/tsdbMemTable.c
+++ b/src/tsdb/src/tsdbMemTable.c
@@ -274,7 +274,7 @@ void *tsdbAllocBytes(STsdbRepo *pRepo, int bytes) {
 int tsdbAsyncCommit(STsdbRepo *pRepo) {
   tsem_wait(&(pRepo->readyToCommit));
 
-  ASSERT(pRepo->imem == NULL);
+  //ASSERT(pRepo->imem == NULL);
   if (pRepo->mem == NULL) {
     tsem_post(&(pRepo->readyToCommit));
     return 0;
@@ -965,7 +965,7 @@ static void tsdbFreeRows(STsdbRepo *pRepo, void **rows, int rowCounter) {
 }
 
 static void updateTableLatestColumn(STsdbRepo *pRepo, STable *pTable, SDataRow row) {
-  tsdbInfo("vgId:%d updateTableLatestColumn, %s row version:%d", REPO_ID(pRepo), pTable->name->data, dataRowVersion(row));
+  tsdbDebug("vgId:%d updateTableLatestColumn, %s row version:%d", REPO_ID(pRepo), pTable->name->data, dataRowVersion(row));
 
   STSchema* pSchema = tsdbGetTableLatestSchema(pTable);
   if (tsdbUpdateLastColSchema(pTable, pSchema) < 0) {
@@ -988,7 +988,7 @@ static void updateTableLatestColumn(STsdbRepo *pRepo, STable *pTable, SDataRow r
     }
     
     void* value = tdGetRowDataOfCol(row, (int8_t)pTCol->type, TD_DATA_ROW_HEAD_SIZE + pSchema->columns[j].offset);
-    if (isNullN(value, pTCol->type)) {
+    if (isNull(value, pTCol->type)) {
       continue;
     }
 

From 96b0705a6b45f2897cd81be6c35e629a9c14fa4e Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Wed, 26 May 2021 19:43:51 +0800
Subject: [PATCH 115/128] [td-225]add test cases.

---
 tests/script/general/parser/nestquery.sim | 50 ++++++++++++++++++++---
 1 file changed, 44 insertions(+), 6 deletions(-)

diff --git a/tests/script/general/parser/nestquery.sim b/tests/script/general/parser/nestquery.sim
index d6fde199dc..eab1392d1c 100644
--- a/tests/script/general/parser/nestquery.sim
+++ b/tests/script/general/parser/nestquery.sim
@@ -17,13 +17,14 @@ $rowNum = 10000
 $totalNum = $tbNum * $rowNum
 
 print =============== nestquery.sim
+
 $i = 0
 $db = $dbPrefix . $i
 $mt = $mtPrefix . $i
 
-sql drop database if exists $db -x step1
-step1:
+sql drop database if exists $db
 sql create database if not exists $db
+
 sql use $db
 sql create table $mt (ts timestamp, c1 int, c2 float, c3 bigint, c4 smallint, c5 tinyint, c6 double, c7 bool, c8 binary(10), c9 nchar(9)) TAGS(t1 int)
 
@@ -62,8 +63,8 @@ sleep 100
 $i = 1
 $tb = $tbPrefix . $i
 
-print simple nest query test
-sql select count(*) from (select count(*) from nest_mt0))
+print ==============> simple nest query test
+sql select count(*) from (select count(*) from nest_mt0)
 if $rows != 1 then
  return -1
 endi
@@ -86,18 +87,55 @@ if $rows != 1 then
   return -1
 endi
 
-if $data00 != 10 then
+if $data00 != 170 then
+  return -1
+endi
+
+sql select sum(a) from (select count(*) a from nest_mt0 interval(10h) group by tbname)
+if $rows != 1 then
+  return -1
+endi
+
+if $data00 != 100000 then
   return -1
 endi
 
 print =================> alias name test
+sql select ts from (select count(*) a from nest_tb0 interval(1h))
+if $rows != 167 then
+  return -1
+endi
+
+if $data00 != @20-09-15 00:00:00.000@ then
+  return -1
+endi
+
 sql select count(a) from (select count(*) a from nest_tb0 interval(1h))
 if $rows != 1 then
   return -1
 endi
 
-if $data00 != 1 then
+if $data00 != 167 then
    return -1
 endi
 
+print ================>master query + filter
+sql select * from (select count(*) a from nest_tb0 interval(10h)) where a <= 520;
+if $rows != 2 then
+  return -1
+endi
+
+
+print ==================> nest query join
+
+
+
+print ===================> nest query interval
+
+
+
+print ===================> complex query
+
+
+
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
\ No newline at end of file

From 644bed2dad50d5599406ac754d99a7c60fa3c28a Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Thu, 27 May 2021 10:04:20 +0800
Subject: [PATCH 116/128] [td-225]

---
 src/client/src/tscSQLParser.c |  4 ++--
 src/client/src/tscServer.c    | 26 +++++++++++++-------------
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index adae6fb880..b3ece963bd 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -7546,14 +7546,14 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
     }
 
     if (tscQueryTags(pQueryInfo)) {
-      SExprInfo* pExpr1 = tscSqlExprGet(pQueryInfo, 0);
+      SExprInfo* pExpr1 = tscExprGet(pQueryInfo, 0);
 
       if (pExpr1->base.functionId != TSDB_FUNC_TID_TAG) {
         int32_t numOfCols = (int32_t)taosArrayGetSize(pQueryInfo->colList);
         for (int32_t i = 0; i < numOfCols; ++i) {
           SColumn* pCols = taosArrayGetP(pQueryInfo->colList, i);
           if (pCols->info.flist.numOfFilters > 0) {
-            return invalidSqlErrMsg(tscGetErrorMsgPayload(pCmd), msg9);
+            return invalidOperationMsg(tscGetErrorMsgPayload(pCmd), msg9);
           }
         }
       }
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index a00a6079a6..ddac9f3ba4 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -1911,25 +1911,25 @@ int tscProcessTableMetaRsp(SSqlObj *pSql) {
 }
 
 static SVgroupsInfo* createVgroupInfoFromMsg(char* pMsg, int32_t* size, uint64_t id) {
-  SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *) pMsg;
+  SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *)pMsg;
   pVgroupMsg->numOfVgroups = htonl(pVgroupMsg->numOfVgroups);
 
-  *size = (int32_t) (sizeof(SVgroupMsg) * pVgroupMsg->numOfVgroups + sizeof(SVgroupsMsg));
+  *size = (int32_t)(sizeof(SVgroupMsg) * pVgroupMsg->numOfVgroups + sizeof(SVgroupsMsg));
 
-  size_t vgroupsz = sizeof(SVgroupInfo) * pVgroupMsg->numOfVgroups + sizeof(SVgroupsInfo);
-  SVgroupsInfo* pVgroupInfo = calloc(1, vgroupsz);
+  size_t        vgroupsz = sizeof(SVgroupInfo) * pVgroupMsg->numOfVgroups + sizeof(SVgroupsInfo);
+  SVgroupsInfo *pVgroupInfo = calloc(1, vgroupsz);
   assert(pVgroupInfo != NULL);
 
-    pInfo->vgroupList->numOfVgroups = pVgroupMsg->numOfVgroups;
-    if (pInfo->vgroupList->numOfVgroups <= 0) {
-      tscDebug("0x%" PRIx64 " empty vgroup info, no corresponding tables for stable", pSql->self);
-    } else {
-      for (int32_t j = 0; j < pInfo->vgroupList->numOfVgroups; ++j) {
-        // just init, no need to lock
-        SVgroupInfo *pVgroup = &pInfo->vgroupList->vgroups[j];
+  pVgroupInfo->numOfVgroups = pVgroupMsg->numOfVgroups;
+  if (pVgroupInfo->numOfVgroups <= 0) {
+    tscDebug("0x%" PRIx64 " empty vgroup info, no corresponding tables for stable", id);
+  } else {
+    for (int32_t j = 0; j < pVgroupInfo->numOfVgroups; ++j) {
+      // just init, no need to lock
+      SVgroupInfo *pVgroup = &pVgroupInfo->vgroups[j];
 
       SVgroupMsg *vmsg = &pVgroupMsg->vgroups[j];
-      vmsg->vgId     = htonl(vmsg->vgId);
+      vmsg->vgId = htonl(vmsg->vgId);
       vmsg->numOfEps = vmsg->numOfEps;
       for (int32_t k = 0; k < vmsg->numOfEps; ++k) {
         vmsg->epAddr[k].port = htons(vmsg->epAddr[k].port);
@@ -1951,7 +1951,7 @@ static SVgroupsInfo* createVgroupInfoFromMsg(char* pMsg, int32_t* size, uint64_t
       if (((existVgroupInfo.inUse >= 0) && !vgroupInfoIdentical(&existVgroupInfo, vmsg)) ||
           (existVgroupInfo.inUse < 0)) {  // vgroup info exists, compare with it
         taosHashPut(tscVgroupMap, &newVi.vgId, sizeof(newVi.vgId), &newVi, sizeof(newVi));
-        tscDebug("0x%"PRIx64" add new VgroupInfo, vgId:%d, total cached:%d", id, newVi.vgId, (int32_t) taosHashGetSize(tscVgroupMap));
+        tscDebug("0x%" PRIx64 " add new VgroupInfo, vgId:%d, total cached:%d", id, newVi.vgId, (int32_t)taosHashGetSize(tscVgroupMap));
       }
     }
   }

From 11026023e237bc6f3e039e4fdd3dfa34e952901f Mon Sep 17 00:00:00 2001
From: dapan1121 <89396746@qq.com>
Date: Thu, 27 May 2021 11:52:02 +0800
Subject: [PATCH 117/128] fix windows compile error

---
 src/tsdb/src/tsdbRead.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tsdb/src/tsdbRead.c b/src/tsdb/src/tsdbRead.c
index 50acda0d95..0a39dba021 100644
--- a/src/tsdb/src/tsdbRead.c
+++ b/src/tsdb/src/tsdbRead.c
@@ -2488,7 +2488,7 @@ static bool loadCachedLastRow(STsdbQueryHandle* pQueryHandle) {
 static bool loadCachedLast(STsdbQueryHandle* pQueryHandle) {
   // the last row is cached in buffer, return it directly.
   // here note that the pQueryHandle->window must be the TS_INITIALIZER
-  int32_t tgNumOfCols = QH_GET_NUM_OF_COLS(pQueryHandle);
+  int32_t tgNumOfCols = (int32_t)QH_GET_NUM_OF_COLS(pQueryHandle);
   size_t  numOfTables = taosArrayGetSize(pQueryHandle->pTableCheckInfo);
   int32_t numOfRows = 0;
   assert(numOfTables > 0 && tgNumOfCols > 0);

From f1f7d5564f809afffc83bb71c7384f84ce6246d2 Mon Sep 17 00:00:00 2001
From: lichuang <lichuang1982@gmail.com>
Date: Thu, 27 May 2021 16:02:57 +0800
Subject: [PATCH 118/128] [TD-1920]add mnode_bak and mnode_tmp dir exist check
 when start up

---
 src/dnode/src/dnodeMain.c | 10 ++++++++--
 src/os/inc/osDir.h        |  1 +
 src/os/src/detail/osDir.c |  4 ++++
 3 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/src/dnode/src/dnodeMain.c b/src/dnode/src/dnodeMain.c
index ee4dfcf852..cce382b15f 100644
--- a/src/dnode/src/dnodeMain.c
+++ b/src/dnode/src/dnodeMain.c
@@ -219,14 +219,20 @@ static int32_t dnodeInitStorage() {
 
   if (tsCompactMnodeWal == 1) {
     sprintf(tsMnodeTmpDir, "%s/mnode_tmp", tsDataDir);
-    tfsRmdir(tsMnodeTmpDir);
+    if (taosDirExist(tsMnodeTmpDir)) {
+      dError("mnode_tmp dir already exist in %s,quit compact job", tsMnodeTmpDir);
+      return -1;
+    }
     if (dnodeCreateDir(tsMnodeTmpDir) < 0) {
       dError("failed to create dir: %s, reason: %s", tsMnodeTmpDir, strerror(errno));
       return -1;
     }
 
     sprintf(tsMnodeBakDir, "%s/mnode_bak", tsDataDir);
-    //tfsRmdir(tsMnodeBakDir);   
+    if (taosDirExist(tsMnodeBakDir)) {
+      dError("mnode_bak dir already exist in %s,quit compact job", tsMnodeBakDir);
+      return -1;
+    }
   }
   //TODO(dengyihao): no need to init here 
   if (dnodeCreateDir(tsMnodeDir) < 0) {
diff --git a/src/os/inc/osDir.h b/src/os/inc/osDir.h
index bdc65e4520..7afe126451 100644
--- a/src/os/inc/osDir.h
+++ b/src/os/inc/osDir.h
@@ -21,6 +21,7 @@ extern "C" {
 #endif
 
 void    taosRemoveDir(char *rootDir);
+bool    taosDirExist(const char* dirname);
 int32_t taosMkDir(const char *pathname, mode_t mode);
 void    taosRemoveOldLogFiles(char *rootDir, int32_t keepDays);
 int32_t taosRename(char *oldName, char *newName);
diff --git a/src/os/src/detail/osDir.c b/src/os/src/detail/osDir.c
index 2a2e2519b5..c467c64872 100644
--- a/src/os/src/detail/osDir.c
+++ b/src/os/src/detail/osDir.c
@@ -45,6 +45,10 @@ void taosRemoveDir(char *rootDir) {
   uInfo("dir:%s is removed", rootDir);
 }
 
+bool taosDirExist(const char* dirname) {
+  return access(dirname, F_OK) == 0;
+}
+
 int taosMkDir(const char *path, mode_t mode) {
   int code = mkdir(path, 0755);
   if (code < 0 && errno == EEXIST) code = 0;

From 0e97b397879e5e843a2a1775e7eda64e662b96d9 Mon Sep 17 00:00:00 2001
From: Elias Soong <elias.soong@gmail.com>
Date: Thu, 27 May 2021 17:10:17 +0800
Subject: [PATCH 119/128] [TD-4387] <docs>: fix broken link to server config
 doc.

---
 documentation20/cn/12.taos-sql/docs.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/documentation20/cn/12.taos-sql/docs.md b/documentation20/cn/12.taos-sql/docs.md
index b130e0544c..af78074eb2 100644
--- a/documentation20/cn/12.taos-sql/docs.md
+++ b/documentation20/cn/12.taos-sql/docs.md
@@ -76,7 +76,7 @@ TDengine 缺省的时间戳是毫秒精度，但通过修改配置参数 enableM
  
     4) 一条SQL 语句的最大长度为65480个字符；
  
-    5) 数据库还有更多与存储相关的配置参数，请参见 [服务端配置](https://www.taosdata.com/cn/documentation/taos-sql#management) 章节。
+    5) 数据库还有更多与存储相关的配置参数，请参见 [服务端配置](https://www.taosdata.com/cn/documentation/administrator#config) 章节。
 
 - **显示系统当前参数**
 

From 703cc9a5e187040bcd4957ef35aa426c0a6a0380 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Fri, 28 May 2021 00:00:00 +0800
Subject: [PATCH 120/128] [TD-4382]<fix>: taosdemo query result file is null.
 (#6263)

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdemo/taosdemo.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index 888dc4a04e..2d1e4c03d6 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -6642,7 +6642,7 @@ static void *specifiedTableQuery(void *sarg) {
   uint64_t lastPrintTime = taosGetTimestampMs();
   uint64_t startTs = taosGetTimestampMs();
 
-  if (g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq] != NULL) {
+  if (g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq][0] != '\0') {
     sprintf(pThreadInfo->filePath, "%s-%d",
                 g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq],
                 pThreadInfo->threadID);
@@ -6743,7 +6743,7 @@ static void *superTableQuery(void *sarg) {
       for (int j = 0; j < g_queryInfo.superQueryInfo.sqlCount; j++) {
         memset(sqlstr,0,sizeof(sqlstr));
         replaceChildTblName(g_queryInfo.superQueryInfo.sql[j], sqlstr, i);
-        if (g_queryInfo.superQueryInfo.result[j] != NULL) {
+        if (g_queryInfo.superQueryInfo.result[j][0] != '\0') {
           sprintf(pThreadInfo->filePath, "%s-%d",
                   g_queryInfo.superQueryInfo.result[j],
                   pThreadInfo->threadID);
@@ -7174,7 +7174,7 @@ static void *specifiedSubscribe(void *sarg) {
           "taosdemo-subscribe-%"PRIu64"-%d",
           pThreadInfo->querySeq,
           pThreadInfo->threadID);
-  if (g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq] != NULL) {
+  if (g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq][0] != '\0') {
       sprintf(pThreadInfo->filePath, "%s-%d",
                 g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq],
                 pThreadInfo->threadID);

From dae5a07488cd5183a57b23077cf7ce9c04d02921 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Fri, 28 May 2021 00:00:26 +0800
Subject: [PATCH 121/128] Feature/sangshuduo/td 4068 taosdemo stmt (#6250)

* merge with develop branch.

change query/tests/CMakeLists.txt to allow unused function and variable.

* refactor data generating.

* refactor.

* refactor.

* refactor.

* refactor.

* refactor

* add prepare stmt function.

* refactor get rand timestamp.

* fix windows compile error.

* copy logic of generate data for stmt.

* insert data basically works now.

* fix windows compile issue.

* [TD-4068]<feature>: taosdemo stmt interface.

stb batch insert works.

* [TD-4068]<feature>: taosdemo support stmt.

normal table insert works.

* [TD-4068]<feature>: taosdemo support stmt.

interlace write works.

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdemo/taosdemo.c | 686 ++++++++++++++++++++++--------------
 1 file changed, 417 insertions(+), 269 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index 2d1e4c03d6..6ad5fadf7c 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -1054,6 +1054,19 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
     }
   }
 
+  int columnCount;
+  for (columnCount = 0; columnCount < MAX_NUM_DATATYPE; columnCount ++) {
+    if (g_args.datatype[columnCount] == NULL) {
+      break;
+    }
+  }
+
+  if (0 == columnCount) {
+    perror("data type error!");
+    exit(-1);
+  }
+  g_args.num_of_CPR = columnCount;
+
   if (((arguments->debug_print) && (arguments->metaFile == NULL))
           || arguments->verbose_print) {
     printf("###################################################################\n");
@@ -1076,7 +1089,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
     }
     printf("# Insertion interval:                %"PRIu64"\n",
             arguments->insert_interval);
-    printf("# Number of records per req:         %ud\n",
+    printf("# Number of records per req:         %u\n",
             arguments->num_of_RPR);
     printf("# Max SQL length:                    %"PRIu64"\n",
             arguments->max_sql_len);
@@ -1368,7 +1381,7 @@ static int printfInsertMeta() {
           g_Dbs.threadCountByCreateTbl);
   printf("top insert interval:        \033[33m%"PRIu64"\033[0m\n",
           g_args.insert_interval);
-  printf("number of records per req:  \033[33m%ud\033[0m\n",
+  printf("number of records per req:  \033[33m%u\033[0m\n",
           g_args.num_of_RPR);
   printf("max sql length:             \033[33m%"PRIu64"\033[0m\n",
           g_args.max_sql_len);
@@ -1494,7 +1507,7 @@ static int printfInsertMeta() {
         printf("      multiThreadWriteOneTbl:  \033[33myes\033[0m\n");
       }
       */
-      printf("      interlaceRows:     \033[33m%ud\033[0m\n",
+      printf("      interlaceRows:     \033[33m%u\033[0m\n",
               g_Dbs.db[i].superTbls[j].interlaceRows);
 
       if (g_Dbs.db[i].superTbls[j].interlaceRows > 0) {
@@ -1572,7 +1585,7 @@ static void printfInsertMetaToFile(FILE* fp) {
   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, "number of records per req:  %ud\n", g_args.num_of_RPR);
+  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);
 
@@ -1669,7 +1682,7 @@ static void printfInsertMetaToFile(FILE* fp) {
           (g_Dbs.db[i].superTbls[j].iface==REST_IFACE)?"rest":"stmt");
       fprintf(fp, "      insertRows:        %"PRId64"\n",
               g_Dbs.db[i].superTbls[j].insertRows);
-      fprintf(fp, "      interlace rows:    %ud\n",
+      fprintf(fp, "      interlace rows:    %u\n",
               g_Dbs.db[i].superTbls[j].interlaceRows);
       if (g_Dbs.db[i].superTbls[j].interlaceRows > 0) {
         fprintf(fp, "      stable insert interval:   %"PRIu64"\n",
@@ -1682,7 +1695,7 @@ static void printfInsertMetaToFile(FILE* fp) {
         fprintf(fp, "      multiThreadWriteOneTbl:  yes\n");
       }
       */
-      fprintf(fp, "      interlaceRows:     %ud\n",
+      fprintf(fp, "      interlaceRows:     %u\n",
               g_Dbs.db[i].superTbls[j].interlaceRows);
       fprintf(fp, "      disorderRange:     %d\n",
               g_Dbs.db[i].superTbls[j].disorderRange);
@@ -3075,11 +3088,14 @@ static void createChildTables() {
       // normal table
       len = snprintf(tblColsBuf, MAX_SQL_SIZE, "(TS TIMESTAMP");
       for (int j = 0; j < g_args.num_of_CPR; j++) {
-          if ((strncasecmp(g_args.datatype[j], "BINARY", strlen("BINARY")) == 0)
+          if (g_args.datatype[j]
+                  && ((strncasecmp(g_args.datatype[j],
+                              "BINARY", strlen("BINARY")) == 0)
                   || (strncasecmp(g_args.datatype[j],
-                      "NCHAR", strlen("NCHAR")) == 0)) {
+                      "NCHAR", strlen("NCHAR")) == 0))) {
               snprintf(tblColsBuf + len, MAX_SQL_SIZE - len,
-                      ", COL%d %s(%d)", j, g_args.datatype[j], g_args.len_of_binary);
+                      ", COL%d %s(%d)", j, g_args.datatype[j],
+                      g_args.len_of_binary);
           } else {
               snprintf(tblColsBuf + len, MAX_SQL_SIZE - len,
                       ", COL%d %s", j, g_args.datatype[j]);
@@ -3561,9 +3577,9 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
 
   // rows per table need be less than insert batch
   if (g_args.interlace_rows > g_args.num_of_RPR) {
-      printf("NOTICE: interlace rows value %ud > num_of_records_per_req %ud\n\n",
+      printf("NOTICE: interlace rows value %u > num_of_records_per_req %u\n\n",
               g_args.interlace_rows, g_args.num_of_RPR);
-      printf("        interlace rows value will be set to num_of_records_per_req %ud\n\n",
+      printf("        interlace rows value will be set to num_of_records_per_req %u\n\n",
               g_args.num_of_RPR);
       prompt();
       g_args.interlace_rows = g_args.num_of_RPR;
@@ -4030,10 +4046,10 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
         g_Dbs.db[i].superTbls[j].interlaceRows = stbInterlaceRows->valueint;
         // rows per table need be less than insert batch
         if (g_Dbs.db[i].superTbls[j].interlaceRows > g_args.num_of_RPR) {
-          printf("NOTICE: db[%d].superTbl[%d]'s interlace rows value %ud > num_of_records_per_req %ud\n\n",
+          printf("NOTICE: db[%d].superTbl[%d]'s interlace rows value %u > num_of_records_per_req %u\n\n",
                   i, j, g_Dbs.db[i].superTbls[j].interlaceRows,
                   g_args.num_of_RPR);
-          printf("        interlace rows value will be set to num_of_records_per_req %ud\n\n",
+          printf("        interlace rows value will be set to num_of_records_per_req %u\n\n",
                   g_args.num_of_RPR);
           prompt();
           g_Dbs.db[i].superTbls[j].interlaceRows = g_args.num_of_RPR;
@@ -4773,44 +4789,34 @@ static int64_t generateData(char *recBuf, char **data_type,
   memset(recBuf, 0, MAX_DATA_SIZE);
   char *pstr = recBuf;
   pstr += sprintf(pstr, "(%" PRId64, timestamp);
-  int c = 0;
 
-  for (; c < MAX_NUM_DATATYPE; c++) {
-    if (data_type[c] == NULL) {
-      break;
-    }
-  }
+  int columnCount = g_args.num_of_CPR;
 
-  if (0 == c) {
-    perror("data type error!");
-    exit(-1);
-  }
-
-  for (int i = 0; i < c; i++) {
-    if (strcasecmp(data_type[i % c], "TINYINT") == 0) {
+  for (int i = 0; i < columnCount; i++) {
+    if (strcasecmp(data_type[i % columnCount], "TINYINT") == 0) {
       pstr += sprintf(pstr, ",%d", rand_tinyint() );
-    } else if (strcasecmp(data_type[i % c], "SMALLINT") == 0) {
+    } else if (strcasecmp(data_type[i % columnCount], "SMALLINT") == 0) {
       pstr += sprintf(pstr, ",%d", rand_smallint());
-    } else if (strcasecmp(data_type[i % c], "INT") == 0) {
+    } else if (strcasecmp(data_type[i % columnCount], "INT") == 0) {
       pstr += sprintf(pstr, ",%d", rand_int());
-    } else if (strcasecmp(data_type[i % c], "BIGINT") == 0) {
+    } else if (strcasecmp(data_type[i % columnCount], "BIGINT") == 0) {
       pstr += sprintf(pstr, ",%" PRId64, rand_bigint());
-    } else if (strcasecmp(data_type[i % c], "TIMESTAMP") == 0) {
+    } else if (strcasecmp(data_type[i % columnCount], "TIMESTAMP") == 0) {
       pstr += sprintf(pstr, ",%" PRId64, rand_bigint());
-    } else if (strcasecmp(data_type[i % c], "FLOAT") == 0) {
+    } else if (strcasecmp(data_type[i % columnCount], "FLOAT") == 0) {
       pstr += sprintf(pstr, ",%10.4f", rand_float());
-    } else if (strcasecmp(data_type[i % c], "DOUBLE") == 0) {
+    } else if (strcasecmp(data_type[i % columnCount], "DOUBLE") == 0) {
       double t = rand_double();
       pstr += sprintf(pstr, ",%20.8f", t);
-    } else if (strcasecmp(data_type[i % c], "BOOL") == 0) {
+    } else if (strcasecmp(data_type[i % columnCount], "BOOL") == 0) {
       bool b = rand_bool() & 1;
       pstr += sprintf(pstr, ",%s", b ? "true" : "false");
-    } else if (strcasecmp(data_type[i % c], "BINARY") == 0) {
+    } else if (strcasecmp(data_type[i % columnCount], "BINARY") == 0) {
       char *s = malloc(lenOfBinary);
       rand_string(s, lenOfBinary);
       pstr += sprintf(pstr, ",\"%s\"", s);
       free(s);
-    } else if (strcasecmp(data_type[i % c], "NCHAR") == 0) {
+    } else if (strcasecmp(data_type[i % columnCount], "NCHAR") == 0) {
       char *s = malloc(lenOfBinary);
       rand_string(s, lenOfBinary);
       pstr += sprintf(pstr, ",\"%s\"", s);
@@ -4857,46 +4863,60 @@ static int prepareSampleDataForSTable(SSuperTable *superTblInfo) {
   return 0;
 }
 
-static int64_t execInsert(threadInfo *pThreadInfo, uint64_t k)
+static int32_t execInsert(threadInfo *pThreadInfo, uint32_t k)
 {
-  int affectedRows;
-  SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
+    int32_t affectedRows;
+    SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
 
-  verbosePrint("[%d] %s() LN%d %s\n", pThreadInfo->threadID,
+    verbosePrint("[%d] %s() LN%d %s\n", pThreadInfo->threadID,
             __func__, __LINE__, pThreadInfo->buffer);
-  if (superTblInfo) {
-    if (superTblInfo->iface == TAOSC_IFACE) {
-      affectedRows = queryDbExec(
-              pThreadInfo->taos,
-              pThreadInfo->buffer, INSERT_TYPE, false);
-    } else if (superTblInfo->iface == REST_IFACE) {
-      if (0 != postProceSql(g_Dbs.host, &g_Dbs.serv_addr, g_Dbs.port,
-                  pThreadInfo->buffer, NULL /* not set result file */)) {
-        affectedRows = -1;
-        printf("========restful return fail, threadID[%d]\n",
-            pThreadInfo->threadID);
-      } else {
-        affectedRows = k;
-      }
-    } else if (superTblInfo->iface == STMT_IFACE) {
-      debugPrint("%s() LN%d, stmt=%p", __func__, __LINE__, pThreadInfo->stmt);
-      if (0 != taos_stmt_execute(pThreadInfo->stmt)) {
-        errorPrint("%s() LN%d, failied to execute insert statement\n",
-                    __func__, __LINE__);
-        exit(-1);
-      }
 
-      affectedRows = k;
-    } else {
-      errorPrint("%s() LN%d: unknown insert mode: %d\n",
-        __func__, __LINE__, superTblInfo->iface);
-      affectedRows = 0;
+    uint16_t iface;
+    if (superTblInfo)
+        iface = superTblInfo->iface;
+    else
+        iface = g_args.iface;
+
+    debugPrint("[%d] %s() LN%d %s\n", pThreadInfo->threadID,
+            __func__, __LINE__,
+            (g_args.iface==TAOSC_IFACE)?
+            "taosc":(g_args.iface==REST_IFACE)?"rest":"stmt");
+
+    switch(iface) {
+        case TAOSC_IFACE:
+            affectedRows = queryDbExec(
+                    pThreadInfo->taos,
+                    pThreadInfo->buffer, INSERT_TYPE, false);
+            break;
+
+        case REST_IFACE:
+            if (0 != postProceSql(g_Dbs.host, &g_Dbs.serv_addr, g_Dbs.port,
+                        pThreadInfo->buffer, NULL /* not set result file */)) {
+                affectedRows = -1;
+                printf("========restful return fail, threadID[%d]\n",
+                        pThreadInfo->threadID);
+            } else {
+                affectedRows = k;
+            }
+            break;
+
+        case STMT_IFACE:
+            debugPrint("%s() LN%d, stmt=%p", __func__, __LINE__, pThreadInfo->stmt);
+            if (0 != taos_stmt_execute(pThreadInfo->stmt)) {
+                errorPrint("%s() LN%d, failied to execute insert statement\n",
+                        __func__, __LINE__);
+                exit(-1);
+            }
+            affectedRows = k;
+            break;
+
+        default:
+            errorPrint("%s() LN%d: unknown insert mode: %d\n",
+                    __func__, __LINE__, superTblInfo->iface);
+            affectedRows = 0;
     }
-  } else {
-    affectedRows = queryDbExec(pThreadInfo->taos, pThreadInfo->buffer, INSERT_TYPE, false);
-  }
 
-  return affectedRows;
+    return affectedRows;
 }
 
 static void getTableName(char *pTblName,
@@ -4924,7 +4944,7 @@ static void getTableName(char *pTblName,
   }
 }
 
-static int64_t generateDataTailWithoutStb(
+static int32_t generateDataTailWithoutStb(
         uint32_t batch, char* buffer,
         int64_t remainderBufLen, int64_t insertRows,
         uint64_t recordFrom, int64_t startTime,
@@ -4935,7 +4955,7 @@ static int64_t generateDataTailWithoutStb(
 
   verbosePrint("%s() LN%d batch=%d\n", __func__, __LINE__, batch);
 
-  int64_t k = 0;
+  int32_t k = 0;
   for (k = 0; k < batch;) {
     char data[MAX_DATA_SIZE];
     memset(data, 0, MAX_DATA_SIZE);
@@ -4947,7 +4967,7 @@ static int64_t generateDataTailWithoutStb(
 
     retLen = generateData(data, data_type,
             startTime + getTSRandTail(
-                (int64_t)DEFAULT_TIMESTAMP_STEP, k,
+                (int64_t) DEFAULT_TIMESTAMP_STEP, k,
                 g_args.disorderRatio,
                 g_args.disorderRange),
             lenOfBinary);
@@ -4960,7 +4980,7 @@ static int64_t generateDataTailWithoutStb(
     len += retLen;
     remainderBufLen -= retLen;
 
-    verbosePrint("%s() LN%d len=%"PRIu64" k=%"PRIu64" \nbuffer=%s\n",
+    verbosePrint("%s() LN%d len=%"PRIu64" k=%d \nbuffer=%s\n",
             __func__, __LINE__, len, k, buffer);
 
     recordFrom ++;
@@ -5006,7 +5026,7 @@ static int32_t generateStbDataTail(
   } else {
       tsRand = false;
   }
-  verbosePrint("%s() LN%d batch=%ud\n", __func__, __LINE__, batch);
+  verbosePrint("%s() LN%d batch=%u\n", __func__, __LINE__, batch);
 
   int32_t k = 0;
   for (k = 0; k < batch;) {
@@ -5040,7 +5060,7 @@ static int32_t generateStbDataTail(
     len += retLen;
     remainderBufLen -= retLen;
 
-    verbosePrint("%s() LN%d len=%"PRIu64" k=%ud \nbuffer=%s\n",
+    verbosePrint("%s() LN%d len=%"PRIu64" k=%u \nbuffer=%s\n",
             __func__, __LINE__, len, k, buffer);
 
     recordFrom ++;
@@ -5168,7 +5188,7 @@ static int32_t generateStbInterlaceData(
 
   int64_t dataLen = 0;
 
-  verbosePrint("[%d] %s() LN%d i=%"PRIu64" batchPerTblTimes=%ud batchPerTbl = %ud\n",
+  verbosePrint("[%d] %s() LN%d i=%"PRIu64" batchPerTblTimes=%u batchPerTbl = %u\n",
             pThreadInfo->threadID, __func__, __LINE__,
             i, batchPerTblTimes, batchPerTbl);
 
@@ -5186,7 +5206,7 @@ static int32_t generateStbInterlaceData(
     pstr += dataLen;
     *pRemainderBufLen -= dataLen;
   } else {
-    debugPrint("%s() LN%d, generated data tail: %ud, not equal batch per table: %ud\n",
+    debugPrint("%s() LN%d, generated data tail: %u, not equal batch per table: %u\n",
             __func__, __LINE__, k, batchPerTbl);
     pstr -= headLen;
     pstr[0] = '\0';
@@ -5197,10 +5217,11 @@ static int32_t generateStbInterlaceData(
 }
 
 static int64_t generateInterlaceDataWithoutStb(
-        char *tableName, uint32_t batchPerTbl,
+        char *tableName, uint32_t batch,
         uint64_t tableSeq,
         char *dbName, char *buffer,
         int64_t insertRows,
+        int64_t startTime,
         uint64_t *pRemainderBufLen)
 {
   assert(buffer);
@@ -5219,18 +5240,17 @@ static int64_t generateInterlaceDataWithoutStb(
 
   int64_t dataLen = 0;
 
-  int64_t startTime = 1500000000000;
-  int64_t  k = generateDataTailWithoutStb(
-            batchPerTbl, pstr, *pRemainderBufLen, insertRows, 0,
+  int32_t k = generateDataTailWithoutStb(
+            batch, pstr, *pRemainderBufLen, insertRows, 0,
             startTime,
             &dataLen);
 
-  if (k == batchPerTbl) {
+  if (k == batch) {
     pstr += dataLen;
     *pRemainderBufLen -= dataLen;
   } else {
-    debugPrint("%s() LN%d, generated data tail: %"PRIu64", not equal batch per table: %ud\n",
-            __func__, __LINE__, k, batchPerTbl);
+    debugPrint("%s() LN%d, generated data tail: %d, not equal batch per table: %u\n",
+            __func__, __LINE__, k, batch);
     pstr -= headLen;
     pstr[0] = '\0';
     k = 0;
@@ -5239,32 +5259,237 @@ static int64_t generateInterlaceDataWithoutStb(
   return k;
 }
 
+static int32_t prepareStmtBindArrayByType(TAOS_BIND *bind,
+        char *dataType, int32_t dataLen, char **ptr)
+{
+    if (0 == strncasecmp(dataType,
+                "BINARY", strlen("BINARY"))) {
+        if (dataLen > TSDB_MAX_BINARY_LEN) {
+            errorPrint( "binary length overflow, max size:%u\n",
+                    (uint32_t)TSDB_MAX_BINARY_LEN);
+            return -1;
+        }
+        char *bind_binary = (char *)*ptr;
+        rand_string(bind_binary, dataLen);
+
+        bind->buffer_type = TSDB_DATA_TYPE_BINARY;
+        bind->buffer_length = dataLen;
+        bind->buffer = bind_binary;
+        bind->length = &bind->buffer_length;
+        bind->is_null = NULL;
+
+        *ptr += bind->buffer_length;
+    } else if (0 == strncasecmp(dataType,
+                "NCHAR", strlen("NCHAR"))) {
+        if (dataLen > TSDB_MAX_BINARY_LEN) {
+            errorPrint( "nchar length overflow, max size:%u\n",
+                    (uint32_t)TSDB_MAX_BINARY_LEN);
+            return -1;
+        }
+        char *bind_nchar = (char *)*ptr;
+        rand_string(bind_nchar, dataLen);
+
+        bind->buffer_type = TSDB_DATA_TYPE_NCHAR;
+        bind->buffer_length = strlen(bind_nchar);
+        bind->buffer = bind_nchar;
+        bind->length = &bind->buffer_length;
+        bind->is_null = NULL;
+
+        *ptr += bind->buffer_length;
+    } else if (0 == strncasecmp(dataType,
+                "INT", strlen("INT"))) {
+        int32_t *bind_int = (int32_t *)*ptr;
+
+        *bind_int = rand_int();
+        bind->buffer_type = TSDB_DATA_TYPE_INT;
+        bind->buffer_length = sizeof(int32_t);
+        bind->buffer = bind_int;
+        bind->length = &bind->buffer_length;
+        bind->is_null = NULL;
+
+        *ptr += bind->buffer_length;
+    } else if (0 == strncasecmp(dataType,
+                "BIGINT", strlen("BIGINT"))) {
+        int64_t *bind_bigint = (int64_t *)*ptr;
+
+        *bind_bigint = rand_bigint();
+        bind->buffer_type = TSDB_DATA_TYPE_BIGINT;
+        bind->buffer_length = sizeof(int64_t);
+        bind->buffer = bind_bigint;
+        bind->length = &bind->buffer_length;
+        bind->is_null = NULL;
+
+        *ptr += bind->buffer_length;
+    }  else if (0 == strncasecmp(dataType,
+                "FLOAT", strlen("FLOAT"))) {
+        float   *bind_float = (float *) *ptr;
+
+        *bind_float = rand_float();
+        bind->buffer_type = TSDB_DATA_TYPE_FLOAT;
+        bind->buffer_length = sizeof(float);
+        bind->buffer = bind_float;
+        bind->length = &bind->buffer_length;
+        bind->is_null = NULL;
+
+        *ptr += bind->buffer_length;
+    }  else if (0 == strncasecmp(dataType,
+                "DOUBLE", strlen("DOUBLE"))) {
+        double  *bind_double = (double *)*ptr;
+
+        *bind_double = rand_double();
+        bind->buffer_type = TSDB_DATA_TYPE_DOUBLE;
+        bind->buffer_length = sizeof(double);
+        bind->buffer = bind_double;
+        bind->length = &bind->buffer_length;
+        bind->is_null = NULL;
+
+        *ptr += bind->buffer_length;
+    }  else if (0 == strncasecmp(dataType,
+                "SMALLINT", strlen("SMALLINT"))) {
+        int16_t *bind_smallint = (int16_t *)*ptr;
+
+        *bind_smallint = rand_smallint();
+        bind->buffer_type = TSDB_DATA_TYPE_SMALLINT;
+        bind->buffer_length = sizeof(int16_t);
+        bind->buffer = bind_smallint;
+        bind->length = &bind->buffer_length;
+        bind->is_null = NULL;
+
+        *ptr += bind->buffer_length;
+    }  else if (0 == strncasecmp(dataType,
+                "TINYINT", strlen("TINYINT"))) {
+        int8_t  *bind_tinyint = (int8_t *)*ptr;
+
+        *bind_tinyint = rand_tinyint();
+        bind->buffer_type = TSDB_DATA_TYPE_TINYINT;
+        bind->buffer_length = sizeof(int8_t);
+        bind->buffer = bind_tinyint;
+        bind->length = &bind->buffer_length;
+        bind->is_null = NULL;
+        *ptr += bind->buffer_length;
+    }  else if (0 == strncasecmp(dataType,
+                "BOOL", strlen("BOOL"))) {
+        int8_t  *bind_bool = (int8_t *)*ptr;
+
+        *bind_bool = rand_bool();
+        bind->buffer_type = TSDB_DATA_TYPE_BOOL;
+        bind->buffer_length = sizeof(int8_t);
+        bind->buffer = bind_bool;
+        bind->length = &bind->buffer_length;
+        bind->is_null = NULL;
+
+        *ptr += bind->buffer_length;
+    }  else if (0 == strncasecmp(dataType,
+                "TIMESTAMP", strlen("TIMESTAMP"))) {
+        int64_t *bind_ts2 = (int64_t *) *ptr;
+
+        *bind_ts2 = rand_bigint();
+        bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
+        bind->buffer_length = sizeof(int64_t);
+        bind->buffer = bind_ts2;
+        bind->length = &bind->buffer_length;
+        bind->is_null = NULL;
+
+        *ptr += bind->buffer_length;
+    }  else {
+        errorPrint( "No support data type: %s\n",
+                dataType);
+        return -1;
+    }
+
+    return 0;
+}
+
+static int32_t prepareStmtWithoutStb(
+        TAOS_STMT *stmt,
+        char *tableName,
+        uint32_t batch,
+        int64_t insertRows,
+        int64_t recordFrom,
+        int64_t startTime)
+{
+    int ret = taos_stmt_set_tbname(stmt, tableName);
+    if (ret != 0) {
+        errorPrint("failed to execute taos_stmt_set_tbname(%s). return 0x%x. reason: %s\n",
+                tableName, ret, taos_errstr(NULL));
+        return ret;
+    }
+
+    char **data_type = g_args.datatype;
+
+    char *bindArray = malloc(sizeof(TAOS_BIND) * (g_args.num_of_CPR + 1));
+    if (bindArray == NULL) {
+        errorPrint("Failed to allocate %d bind params\n",
+                (g_args.num_of_CPR + 1));
+        return -1;
+    }
+
+    int32_t k = 0;
+    for (k = 0; k < batch;) {
+        /* columnCount + 1 (ts) */
+        char data[MAX_DATA_SIZE];
+        memset(data, 0, MAX_DATA_SIZE);
+
+        char *ptr = data;
+        TAOS_BIND *bind = (TAOS_BIND *)(bindArray + 0);
+
+        int64_t *bind_ts;
+
+        bind_ts = (int64_t *)ptr;
+        bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
+        *bind_ts = startTime + getTSRandTail(
+                (int64_t)DEFAULT_TIMESTAMP_STEP, k,
+                g_args.disorderRatio,
+                g_args.disorderRange);
+        bind->buffer_length = sizeof(int64_t);
+        bind->buffer = bind_ts;
+        bind->length = &bind->buffer_length;
+        bind->is_null = NULL;
+
+        ptr += bind->buffer_length;
+
+        for (int i = 0; i < g_args.num_of_CPR; i ++) {
+            bind = (TAOS_BIND *)((char *)bindArray + (sizeof(TAOS_BIND) * (i + 1)));
+            if ( -1 == prepareStmtBindArrayByType(
+                        bind,
+                        data_type[i],
+                        g_args.len_of_binary,
+                        &ptr)) {
+                return -1;
+            }
+        }
+        taos_stmt_bind_param(stmt, (TAOS_BIND *)bindArray);
+        // if msg > 3MB, break
+        taos_stmt_add_batch(stmt);
+
+        k++;
+        recordFrom ++;
+        if (recordFrom >= insertRows) {
+            break;
+        }
+    }
+
+    return k;
+}
+
 static int32_t prepareStbStmt(SSuperTable *stbInfo,
         TAOS_STMT *stmt,
-        char *tableName, uint32_t batch, uint64_t insertRows,
+        char *tableName, uint32_t batch,
+        uint64_t insertRows,
         uint64_t recordFrom,
         int64_t startTime, char *buffer)
 {
-    uint32_t k;
-    int      ret;
-    char *pstr = buffer;
-    pstr += sprintf(pstr, "INSERT INTO %s values(?", tableName);
-
-    for (int i = 0; i < stbInfo->columnCount; i++) {
-        pstr += sprintf(pstr, ",?");
-    }
-    pstr += sprintf(pstr, ")");
-
-    ret = taos_stmt_prepare(stmt, buffer, 0);
-    if (ret != 0){
-        errorPrint("failed to execute taos_stmt_prepare. return 0x%x. reason: %s\n",
-                ret, taos_errstr(NULL));
+    int ret = taos_stmt_set_tbname(stmt, tableName);
+    if (ret != 0) {
+        errorPrint("failed to execute taos_stmt_set_tbname(%s). return 0x%x. reason: %s\n",
+                tableName, ret, taos_errstr(NULL));
         return ret;
     }
 
     char *bindArray = malloc(sizeof(TAOS_BIND) * (stbInfo->columnCount + 1));
     if (bindArray == NULL) {
-        errorPrint("Failed to allocate %d bind params\n", batch);
+        errorPrint("Failed to allocate %d bind params\n",
+                (stbInfo->columnCount + 1));
         return -1;
     }
 
@@ -5274,6 +5499,8 @@ static int32_t prepareStbStmt(SSuperTable *stbInfo,
     } else {
         tsRand = false;
     }
+
+    uint32_t k;
     for (k = 0; k < batch;) {
         /* columnCount + 1 (ts) */
         char data[MAX_DATA_SIZE];
@@ -5303,135 +5530,12 @@ static int32_t prepareStbStmt(SSuperTable *stbInfo,
 
         for (int i = 0; i < stbInfo->columnCount; i ++) {
             bind = (TAOS_BIND *)((char *)bindArray + (sizeof(TAOS_BIND) * (i + 1)));
-            if (0 == strncasecmp(stbInfo->columns[i].dataType,
-                        "BINARY", strlen("BINARY"))) {
-                if (stbInfo->columns[i].dataLen > TSDB_MAX_BINARY_LEN) {
-                    errorPrint( "binary length overflow, max size:%u\n",
-                            (uint32_t)TSDB_MAX_BINARY_LEN);
-                    return -1;
-                }
-                char *bind_binary = (char *)ptr;
-                rand_string(bind_binary, stbInfo->columns[i].dataLen);
-
-                bind->buffer_type = TSDB_DATA_TYPE_BINARY;
-                bind->buffer_length = stbInfo->columns[i].dataLen;
-                bind->buffer = bind_binary;
-                bind->length = &bind->buffer_length;
-                bind->is_null = NULL;
-
-                ptr += bind->buffer_length;
-            } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-                        "NCHAR", strlen("NCHAR"))) {
-                if (stbInfo->columns[i].dataLen > TSDB_MAX_BINARY_LEN) {
-                    errorPrint( "nchar length overflow, max size:%u\n",
-                            (uint32_t)TSDB_MAX_BINARY_LEN);
-                    return -1;
-                }
-                char *bind_nchar = (char *)ptr;
-                rand_string(bind_nchar, stbInfo->columns[i].dataLen);
-
-                bind->buffer_type = TSDB_DATA_TYPE_NCHAR;
-                bind->buffer_length = strlen(bind_nchar);
-                bind->buffer = bind_nchar;
-                bind->length = &bind->buffer_length;
-                bind->is_null = NULL;
-
-                ptr += bind->buffer_length;
-            } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-                        "INT", strlen("INT"))) {
-                int32_t *bind_int = (int32_t *)ptr;
-
-                *bind_int = rand_int();
-                bind->buffer_type = TSDB_DATA_TYPE_INT;
-                bind->buffer_length = sizeof(int32_t);
-                bind->buffer = bind_int;
-                bind->length = &bind->buffer_length;
-                bind->is_null = NULL;
-
-                ptr += bind->buffer_length;
-            } else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-                            "BIGINT", strlen("BIGINT"))) {
-                int64_t *bind_bigint = (int64_t *)ptr;
-
-                *bind_bigint = rand_bigint();
-                bind->buffer_type = TSDB_DATA_TYPE_BIGINT;
-                bind->buffer_length = sizeof(int64_t);
-                bind->buffer = bind_bigint;
-                bind->length = &bind->buffer_length;
-                bind->is_null = NULL;
-                ptr += bind->buffer_length;
-            }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-                            "FLOAT", strlen("FLOAT"))) {
-                float   *bind_float = (float *)ptr;
-
-                *bind_float = rand_float();
-                bind->buffer_type = TSDB_DATA_TYPE_FLOAT;
-                bind->buffer_length = sizeof(float);
-                bind->buffer = bind_float;
-                bind->length = &bind->buffer_length;
-                bind->is_null = NULL;
-                ptr += bind->buffer_length;
-            }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-                            "DOUBLE", strlen("DOUBLE"))) {
-                double  *bind_double = (double *)ptr;
-
-                *bind_double = rand_double();
-                bind->buffer_type = TSDB_DATA_TYPE_DOUBLE;
-                bind->buffer_length = sizeof(double);
-                bind->buffer = bind_double;
-                bind->length = &bind->buffer_length;
-                bind->is_null = NULL;
-                ptr += bind->buffer_length;
-            }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-                            "SMALLINT", strlen("SMALLINT"))) {
-                int16_t *bind_smallint = (int16_t *)ptr;
-
-                *bind_smallint = rand_smallint();
-                bind->buffer_type = TSDB_DATA_TYPE_SMALLINT;
-                bind->buffer_length = sizeof(int16_t);
-                bind->buffer = bind_smallint;
-                bind->length = &bind->buffer_length;
-                bind->is_null = NULL;
-                ptr += bind->buffer_length;
-            }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-                            "TINYINT", strlen("TINYINT"))) {
-                int8_t  *bind_tinyint = (int8_t *)ptr;
-
-                *bind_tinyint = rand_tinyint();
-                bind->buffer_type = TSDB_DATA_TYPE_TINYINT;
-                bind->buffer_length = sizeof(int8_t);
-                bind->buffer = bind_tinyint;
-                bind->length = &bind->buffer_length;
-                bind->is_null = NULL;
-                ptr += bind->buffer_length;
-            }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-                            "BOOL", strlen("BOOL"))) {
-                int8_t  *bind_bool = (int8_t *)ptr;
-
-                *bind_bool = rand_bool();
-                bind->buffer_type = TSDB_DATA_TYPE_BOOL;
-                bind->buffer_length = sizeof(int8_t);
-                bind->buffer = bind_bool;
-                bind->length = &bind->buffer_length;
-                bind->is_null = NULL;
-
-                ptr += bind->buffer_length;
-            }  else if (0 == strncasecmp(stbInfo->columns[i].dataType,
-                            "TIMESTAMP", strlen("TIMESTAMP"))) {
-                int64_t *bind_ts2 = (int64_t *)ptr;
-
-                *bind_ts2 = rand_bigint();
-                bind->buffer_type = TSDB_DATA_TYPE_TIMESTAMP;
-                bind->buffer_length = sizeof(int64_t);
-                bind->buffer = bind_ts2;
-                bind->length = &bind->buffer_length;
-                bind->is_null = NULL;
-
-                ptr += bind->buffer_length;
-            }  else {
-                    errorPrint( "No support data type: %s\n",
-                            stbInfo->columns[i].dataType);
-                    return -1;
+            if ( -1 == prepareStmtBindArrayByType(
+                        bind,
+                        stbInfo->columns[i].dataType,
+                        stbInfo->columns[i].dataLen,
+                        &ptr)) {
+                return -1;
             }
         }
         taos_stmt_bind_param(stmt, (TAOS_BIND *)bindArray);
@@ -5482,12 +5586,7 @@ static int32_t generateStbProgressiveData(
           pSamplePos, &dataLen);
 }
 
-static int64_t prepareStmtWithoutStb(char *tableName)
-{
-    return -1;
-}
-
-static int64_t generateProgressiveDataWithoutStb(
+static int32_t generateProgressiveDataWithoutStb(
         char *tableName,
         /* int64_t tableSeq, */
         threadInfo *pThreadInfo, char *buffer,
@@ -5520,7 +5619,7 @@ static int64_t generateProgressiveDataWithoutStb(
 
 static void printStatPerThread(threadInfo *pThreadInfo)
 {
-  fprintf(stderr, "====thread[%d] completed total inserted rows: %"PRIu64 ", total affected rows: %"PRIu64". %.2f records/second====\n",
+    fprintf(stderr, "====thread[%d] completed total inserted rows: %"PRIu64 ", total affected rows: %"PRIu64". %.2f records/second====\n",
           pThreadInfo->threadID,
           pThreadInfo->totalInsertRows,
           pThreadInfo->totalAffectedRows,
@@ -5638,22 +5737,45 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
 
       int32_t generated;
       if (superTblInfo) {
-        generated = generateStbInterlaceData(
-                superTblInfo,
-                tableName, batchPerTbl, i,
-                batchPerTblTimes,
-                tableSeq,
-                pThreadInfo, pstr,
-                insertRows,
-                startTime,
-                &remainderBufLen);
+          if (superTblInfo->iface == STMT_IFACE) {
+              generated = prepareStbStmt(superTblInfo,
+                      pThreadInfo->stmt,
+                      tableName,
+                      batchPerTbl,
+                      insertRows, i,
+                      startTime,
+                      pThreadInfo->buffer);
+          } else {
+              generated = generateStbInterlaceData(
+                      superTblInfo,
+                      tableName, batchPerTbl, i,
+                      batchPerTblTimes,
+                      tableSeq,
+                      pThreadInfo, pstr,
+                      insertRows,
+                      startTime,
+                      &remainderBufLen);
+          }
       } else {
-        generated = generateInterlaceDataWithoutStb(
-                tableName, batchPerTbl,
-                tableSeq,
-                pThreadInfo->db_name, pstr,
-                insertRows,
-                &remainderBufLen);
+          if (g_args.iface == STMT_IFACE) {
+              debugPrint("[%d] %s() LN%d, tableName:%s, batch:%d startTime:%"PRId64"\n",
+                      pThreadInfo->threadID,
+                      __func__, __LINE__,
+                      tableName, batchPerTbl, startTime);
+              generated = prepareStmtWithoutStb(
+                      pThreadInfo->stmt, tableName,
+                      batchPerTbl,
+                      insertRows, i,
+                      startTime);
+          } else {
+              generated = generateInterlaceDataWithoutStb(
+                      tableName, batchPerTbl,
+                      tableSeq,
+                      pThreadInfo->db_name, pstr,
+                      insertRows,
+                      startTime,
+                      &remainderBufLen);
+          }
       }
 
       debugPrint("[%d] %s() LN%d, generated records is %d\n",
@@ -5668,9 +5790,10 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
 
       tableSeq ++;
       recOfBatch += batchPerTbl;
+
       pstr += (oldRemainderLen - remainderBufLen);
-//      startTime += batchPerTbl * superTblInfo->timeStampStep;
       pThreadInfo->totalInsertRows += batchPerTbl;
+
       verbosePrint("[%d] %s() LN%d batchPerTbl=%d recOfBatch=%d\n",
                 pThreadInfo->threadID, __func__, __LINE__,
                 batchPerTbl, recOfBatch);
@@ -5824,9 +5947,11 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
       int32_t generated;
       if (superTblInfo) {
           if (superTblInfo->iface == STMT_IFACE) {
-              generated = prepareStbStmt(superTblInfo,
+              generated = prepareStbStmt(
+                      superTblInfo,
                       pThreadInfo->stmt,
-                      tableName, g_args.num_of_RPR,
+                      tableName,
+                      g_args.num_of_RPR,
                       insertRows, i, start_time, pstr);
           } else {
               generated = generateStbProgressiveData(
@@ -5838,7 +5963,12 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
           }
       } else {
           if (g_args.iface == STMT_IFACE) {
-              generated = prepareStmtWithoutStb(tableName);
+              generated = prepareStmtWithoutStb(
+                      pThreadInfo->stmt,
+                      tableName,
+                      g_args.num_of_RPR,
+                      insertRows, i,
+                      start_time);
           } else {
               generated = generateProgressiveDataWithoutStb(
                       tableName,
@@ -5859,13 +5989,13 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
 
       startTs = taosGetTimestampMs();
 
-      int64_t affectedRows = execInsert(pThreadInfo, generated);
+      int32_t affectedRows = execInsert(pThreadInfo, generated);
 
       endTs = taosGetTimestampMs();
       uint64_t delay = endTs - startTs;
       performancePrint("%s() LN%d, insert execution time is %"PRId64"ms\n",
               __func__, __LINE__, delay);
-      verbosePrint("[%d] %s() LN%d affectedRows=%"PRId64"\n",
+      verbosePrint("[%d] %s() LN%d affectedRows=%d\n",
             pThreadInfo->threadID,
             __func__, __LINE__, affectedRows);
 
@@ -5875,7 +6005,7 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
       pThreadInfo->totalDelay += delay;
 
       if (affectedRows < 0) {
-        errorPrint("%s() LN%d, affected rows: %"PRId64"\n",
+        errorPrint("%s() LN%d, affected rows: %d\n",
                 __func__, __LINE__, affectedRows);
         goto free_of_progressive;
       }
@@ -6045,15 +6175,6 @@ static int convertHostToServAddr(char *host, uint16_t port, struct sockaddr_in *
 static void startMultiThreadInsertData(int threads, char* db_name,
         char* precision,SSuperTable* superTblInfo) {
 
-  //TAOS* taos;
-  //if (0 == strncasecmp(superTblInfo->iface, "taosc", 5)) {
-  //  taos = taos_connect(g_Dbs.host, g_Dbs.user, g_Dbs.password, db_name, g_Dbs.port);
-  //  if (NULL == taos) {
-  //    printf("connect to server fail, reason: %s\n", taos_errstr(NULL));
-  //    exit(-1);
-  //  }
-  //}
-
   int32_t timePrec = TSDB_TIME_PRECISION_MILLI;
   if (0 != precision[0]) {
     if (0 == strncasecmp(precision, "ms", 2)) {
@@ -6232,7 +6353,16 @@ static void startMultiThreadInsertData(int threads, char* db_name,
         exit(-1);
       }
 
-      if ((superTblInfo) && (superTblInfo->iface == STMT_IFACE)) {
+      if ((g_args.iface == STMT_IFACE)
+          || ((superTblInfo) && (superTblInfo->iface == STMT_IFACE))) {
+
+          int columnCount;
+          if (superTblInfo) {
+              columnCount = superTblInfo->columnCount;
+          } else {
+              columnCount = g_args.num_of_CPR;
+          }
+
         pThreadInfo->stmt = taos_stmt_init(pThreadInfo->taos);
         if (NULL == pThreadInfo->stmt) {
             errorPrint(
@@ -6243,6 +6373,24 @@ static void startMultiThreadInsertData(int threads, char* db_name,
             free(infos);
             exit(-1);
         }
+
+        char buffer[3000];
+        char *pstr = buffer;
+        pstr += sprintf(pstr, "INSERT INTO ? values(?");
+
+        for (int col = 0; col < columnCount; col ++) {
+            pstr += sprintf(pstr, ",?");
+        }
+        pstr += sprintf(pstr, ")");
+
+        int ret = taos_stmt_prepare(pThreadInfo->stmt, buffer, 0);
+        if (ret != 0){
+            errorPrint("failed to execute taos_stmt_prepare. return 0x%x. reason: %s\n",
+                    ret, taos_errstr(NULL));
+            free(pids);
+            free(infos);
+            exit(-1);
+        }
       }
     } else {
       pThreadInfo->taos = NULL;
@@ -6563,7 +6711,7 @@ static int insertTestProcess() {
     }
   }
 
-  taosMsleep(1000);
+  // taosMsleep(1000);
   // create sub threads for inserting data
   //start = taosGetTimestampMs();
   for (int i = 0; i < g_Dbs.dbCount; i++) {

From 71319327c237cbb32ddecb82d6753501a5b51cd4 Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Fri, 28 May 2021 11:37:56 +0800
Subject: [PATCH 122/128] [td-225] fix bug found by regression test.

---
 src/client/inc/tscUtil.h                  |   5 +-
 src/client/inc/tsclient.h                 |   2 +-
 src/client/src/tscAsync.c                 |  23 +--
 src/client/src/tscParseInsert.c           |  20 +-
 src/client/src/tscPrepare.c               |   4 +-
 src/client/src/tscSQLParser.c             |  11 +-
 src/client/src/tscServer.c                |  23 ++-
 src/client/src/tscSql.c                   |  49 ++++-
 src/client/src/tscStream.c                |  26 +--
 src/client/src/tscSub.c                   |   1 +
 src/client/src/tscSubquery.c              |  29 ++-
 src/client/src/tscUtil.c                  | 169 ++++++++++------
 src/mnode/src/mnodeTable.c                |   1 +
 src/query/inc/qExecutor.h                 |   7 +-
 src/query/src/qExecutor.c                 | 227 +++++++++++-----------
 tests/examples/c/apitest.c                |  10 +-
 tests/script/general/parser/function.sim  |   2 +
 tests/script/general/parser/nestquery.sim |  76 +++++++-
 18 files changed, 426 insertions(+), 259 deletions(-)

diff --git a/src/client/inc/tscUtil.h b/src/client/inc/tscUtil.h
index 804e8a2920..6de9e8f15a 100644
--- a/src/client/inc/tscUtil.h
+++ b/src/client/inc/tscUtil.h
@@ -302,8 +302,9 @@ void tscTryQueryNextVnode(SSqlObj *pSql, __async_cb_func_t fp);
 void tscAsyncQuerySingleRowForNextVnode(void *param, TAOS_RES *tres, int numOfRows);
 void tscTryQueryNextClause(SSqlObj* pSql, __async_cb_func_t fp);
 int  tscSetMgmtEpSetFromCfg(const char *first, const char *second, SRpcCorEpSet *corEpSet);
-int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVgroupList);
-int tscTransferTableNameList(SSqlObj *pSql, const char *pNameList, int32_t length);
+int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVgroupNameList, __async_cb_func_t fp);
+
+int tscTransferTableNameList(SSqlObj *pSql, const char *pNameList, int32_t length, SArray* pNameArray);
 
 bool subAndCheckDone(SSqlObj *pSql, SSqlObj *pParentSql, int idx);
 
diff --git a/src/client/inc/tsclient.h b/src/client/inc/tsclient.h
index 3e203bb715..c1a85b6d27 100644
--- a/src/client/inc/tsclient.h
+++ b/src/client/inc/tsclient.h
@@ -492,7 +492,7 @@ char *tscGetErrorMsgPayload(SSqlCmd *pCmd);
 int32_t tscInvalidSQLErrMsg(char *msg, const char *additionalInfo, const char *sql);
 int32_t tscSQLSyntaxErrMsg(char* msg, const char* additionalInfo,  const char* sql);
 
-int32_t tscToSQLCmd(SSqlObj *pSql, struct SSqlInfo *pInfo);
+int32_t tscValidateSqlInfo(SSqlObj *pSql, struct SSqlInfo *pInfo);
 
 extern int32_t    sentinel;
 extern SHashObj  *tscVgroupMap;
diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c
index 68e41310c6..47798f4e33 100644
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -482,28 +482,9 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
       return;
     }
   } else {  // stream computing
+    tscDebug("0x%"PRIx64" stream:%p meta is updated, start new query, command:%d", pSql->self, pSql->pStream, pCmd->command);
+
     SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
-    STableMetaInfo *pTableMetaInfo = pQueryInfo->pTableMetaInfo[0];
-
-    code = tscGetTableMeta(pSql, pTableMetaInfo);
-    if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
-      taosReleaseRef(tscObjRef, pSql->self);
-      return;
-    } else if (code != TSDB_CODE_SUCCESS) {
-      goto _error;
-    }
-
-    if (UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
-      code = tscGetSTableVgroupInfo(pSql, pQueryInfo);
-      if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
-        taosReleaseRef(tscObjRef, pSql->self);
-        return;
-      } else if (code != TSDB_CODE_SUCCESS) {
-        goto _error;
-      }
-    }
-
-    tscDebug("0x%"PRIx64" stream:%p meta is updated, start new query, command:%d", pSql->self, pSql->pStream, pSql->cmd.command);
     if (tscNumOfExprs(pQueryInfo) == 0) {
       tsParseSql(pSql, false);
     }
diff --git a/src/client/src/tscParseInsert.c b/src/client/src/tscParseInsert.c
index a305c3cf82..cc89fd6220 100644
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
@@ -1014,12 +1014,16 @@ int validateTableName(char *tblName, int len, SStrToken* psTblToken) {
 }
 
 static int32_t validateDataSource(SSqlCmd *pCmd, int32_t type, const char *sql) {
-  if (pCmd->insertParam.insertType != 0 && !TSDB_QUERY_HAS_TYPE(pCmd->insertParam.insertType, type)) {
-    return tscInvalidSQLErrMsg(pCmd->payload, "keyword VALUES and FILE are not allowed to mix up", sql);
+  uint32_t *insertType = &pCmd->insertParam.insertType;
+  if (*insertType == TSDB_QUERY_TYPE_STMT_INSERT && type == TSDB_QUERY_TYPE_INSERT) {
+    return TSDB_CODE_SUCCESS;
   }
 
+  if ((*insertType) != 0 && (*insertType) != type) {
+    return tscInvalidSQLErrMsg(pCmd->payload, "keyword VALUES and FILE are not allowed to mixed up", sql);
+  }
 
-  pCmd->insertParam.insertType = type;
+  *insertType = type;
   return TSDB_CODE_SUCCESS;
 }
 
@@ -1368,18 +1372,18 @@ int tsParseSql(SSqlObj *pSql, bool initial) {
       }
     }
   } else {
-    SSqlInfo SQLInfo = qSqlParse(pSql->sqlstr);
-    ret = tscToSQLCmd(pSql, &SQLInfo);
-    if (ret == TSDB_CODE_TSC_INVALID_OPERATION && pSql->parseRetry < 1 && SQLInfo.type == TSDB_SQL_SELECT) {
+    SSqlInfo sqlInfo = qSqlParse(pSql->sqlstr);
+    ret = tscValidateSqlInfo(pSql, &sqlInfo);
+    if (ret == TSDB_CODE_TSC_INVALID_OPERATION && pSql->parseRetry < 1 && sqlInfo.type == TSDB_SQL_SELECT) {
       tscDebug("0x%"PRIx64 " parse query sql statement failed, code:%s, clear meta cache and retry ", pSql->self, tstrerror(ret));
 
       tscResetSqlCmd(pCmd, true);
       pSql->parseRetry++;
 
-      ret = tscToSQLCmd(pSql, &SQLInfo);
+      ret = tscValidateSqlInfo(pSql, &sqlInfo);
     }
 
-    SqlInfoDestroy(&SQLInfo);
+    SqlInfoDestroy(&sqlInfo);
   }
 
   /*
diff --git a/src/client/src/tscPrepare.c b/src/client/src/tscPrepare.c
index b9950b0776..4e6285c844 100644
--- a/src/client/src/tscPrepare.c
+++ b/src/client/src/tscPrepare.c
@@ -1219,6 +1219,7 @@ TAOS_STMT* taos_stmt_init(TAOS* taos) {
   pStmt->taos = pObj;
 
   SSqlObj* pSql = calloc(1, sizeof(SSqlObj));
+
   if (pSql == NULL) {
     free(pStmt);
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
@@ -1613,9 +1614,10 @@ int taos_stmt_execute(TAOS_STMT* stmt) {
       ret = TSDB_CODE_TSC_OUT_OF_MEMORY;
     } else {
       if (pStmt->pSql != NULL) {
-        taos_free_result(pStmt->pSql);
+        tscFreeSqlObj(pStmt->pSql);
         pStmt->pSql = NULL;
       }
+
       pStmt->pSql = taos_query((TAOS*)pStmt->taos, sql);
       ret = taos_errno(pStmt->pSql);
       free(sql);
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index b3ece963bd..d9be43b412 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -279,7 +279,7 @@ static int32_t normalizeVarDataTypeLength(SSqlCmd* pCmd) {
   return TSDB_CODE_SUCCESS;
 }
 
-int32_t tscToSQLCmd(SSqlObj* pSql, struct SSqlInfo* pInfo) {
+int32_t tscValidateSqlInfo(SSqlObj* pSql, struct SSqlInfo* pInfo) {
   if (pInfo == NULL || pSql == NULL) {
     return TSDB_CODE_TSC_APP_ERROR;
   }
@@ -7152,6 +7152,7 @@ static int32_t getTableNameFromSubquery(SSqlNode* pSqlNode, SArray* tableNameLis
   return TSDB_CODE_SUCCESS;
 }
 
+void tscTableMetaCallBack(void *param, TAOS_RES *res, int code);
 static void freeElem(void* p) {
   tfree(*(char**)p);
 }
@@ -7244,7 +7245,7 @@ int32_t loadAllTableMeta(SSqlObj* pSql, struct SSqlInfo* pInfo) {
 
   // load the table meta for a given table name list
   if (taosArrayGetSize(plist) > 0 || taosArrayGetSize(pVgroupList) > 0) {
-    code = getMultiTableMetaFromMnode(pSql, plist, pVgroupList);
+    code = getMultiTableMetaFromMnode(pSql, plist, pVgroupList, tscTableMetaCallBack);
   }
 
 _end:
@@ -7253,7 +7254,7 @@ _end:
   }
 
   if (pVgroupList != NULL) {
-    taosArrayDestroy(pVgroupList);
+    taosArrayDestroyEx(pVgroupList, freeElem);
   }
 
   if (tableNameList != NULL) {
@@ -7421,10 +7422,6 @@ int32_t validateSqlNode(SSqlObj* pSql, SSqlNode* pSqlNode, SQueryInfo* pQueryInf
   const char* msg1 = "point interpolation query needs timestamp";
   const char* msg2 = "too many tables in from clause";
   const char* msg3 = "start(end) time of query range required or time range too large";
-  // const char* msg5 = "too many columns in selection clause";
-  // const char* msg6 = "too many tables in from clause";
-  // const char* msg7 = "invalid table alias name";
-  // const char* msg8 = "alias name too long";
   const char* msg9 = "only tag query not compatible with normal column filter";
 
   int32_t code = TSDB_CODE_SUCCESS;
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index ddac9f3ba4..a3032a342e 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -2061,11 +2061,22 @@ int tscProcessSTableVgroupRsp(SSqlObj *pSql) {
   char *pMsg = pRes->pRsp + sizeof(SSTableVgroupRspMsg);
 
   SSqlCmd* pCmd = &parent->cmd;
-  for(int32_t i = 0; i < pStableVgroup->numOfTables; ++i) {
-    STableMetaInfo *pInfo = tscGetTableMetaInfoFromCmd(pCmd, i);
+  SQueryInfo* pQueryInfo = tscGetQueryInfo(pCmd);
 
-    SVgroupsMsg *pVgroupMsg = (SVgroupsMsg *) pMsg;
-    pVgroupMsg->numOfVgroups = htonl(pVgroupMsg->numOfVgroups);
+  for(int32_t i = 0; i < pStableVgroup->numOfTables; ++i) {
+    char* name = pMsg;
+    pMsg += TSDB_TABLE_NAME_LEN;
+
+    STableMetaInfo *pInfo = NULL;
+    for(int32_t j = 0; j < pQueryInfo->numOfTables; ++j) {
+      STableMetaInfo *pInfo1 = tscGetTableMetaInfoFromCmd(pCmd, j);
+      if (strcmp(name, tNameGetTableName(&pInfo1->name)) != 0) {
+        continue;
+      }
+
+      pInfo = pInfo1;
+      break;
+    }
 
     int32_t size = 0;
     pInfo->vgroupList = createVgroupInfoFromMsg(pMsg, &size, pSql->self);
@@ -2407,7 +2418,7 @@ static int32_t getTableMetaFromMnode(SSqlObj *pSql, STableMetaInfo *pTableMetaIn
   return code;
 }
 
-int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVgroupNameList) {
+int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVgroupNameList, __async_cb_func_t fp) {
   SSqlObj *pNew = calloc(1, sizeof(SSqlObj));
   if (NULL == pNew) {
     tscError("0x%"PRIx64" failed to allocate sqlobj to get multiple table meta", pSql->self);
@@ -2463,7 +2474,7 @@ int32_t getMultiTableMetaFromMnode(SSqlObj *pSql, SArray* pNameList, SArray* pVg
   tscDebug("0x%"PRIx64" new pSqlObj:0x%"PRIx64" to get %d tableMeta, vgroupInfo:%d, msg size:%d", pSql->self,
       pNew->self, numOfTable, numOfVgroupList, pNew->cmd.payloadLen);
 
-  pNew->fp = tscTableMetaCallBack;
+  pNew->fp = fp;
   pNew->param = (void *)pSql->self;
 
   tscDebug("0x%"PRIx64" metaRid from %" PRId64 " to %" PRId64 , pSql->self, pSql->metaRid, pNew->self);
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index 8fe46d9b65..1ffa6416b2 100644
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -872,15 +872,11 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
 
   SSqlObj* pSql = calloc(1, sizeof(SSqlObj));
 
-  pSql->pTscObj = taos;
+  pSql->pTscObj  = taos;
   pSql->signature = pSql;
-
-  SSqlRes *pRes = &pSql->res;
   SSqlCmd *pCmd = &pSql->cmd;
   
-  pRes->numOfTotal = 0;
-  pRes->numOfClauseTotal = 0;
-
+  pCmd->resColumnId = TSDB_RES_COL_ID;
 
   tscDebug("0x%"PRIx64" Valid SQL: %s pObj:%p", pSql->self, sql, pObj);
 
@@ -900,7 +896,7 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
 
   strtolower(pSql->sqlstr, sql);
 
-  pCmd->curSql = NULL;
+//  pCmd->curSql = NULL;
   if (NULL != pCmd->insertParam.pTableBlockHashList) {
     taosHashCleanup(pCmd->insertParam.pTableBlockHashList);
     pCmd->insertParam.pTableBlockHashList = NULL;
@@ -925,6 +921,21 @@ int taos_validate_sql(TAOS *taos, const char *sql) {
   return code;
 }
 
+void loadMultiTableMetaCallback(void *param, TAOS_RES *res, int code) {
+  SSqlObj* pSql = (SSqlObj*)taosAcquireRef(tscObjRef, (int64_t)param);
+  if (pSql == NULL) {
+    return;
+  }
+
+  taosReleaseRef(tscObjRef, pSql->self);
+  pSql->res.code = code;
+  tsem_post(&pSql->rspSem);
+}
+
+static void freeElem(void* p) {
+  tfree(*(char**)p);
+}
+
 int taos_load_table_info(TAOS *taos, const char *tableNameList) {
   const int32_t MAX_TABLE_NAME_LENGTH = 12 * 1024 * 1024;  // 12MB list
 
@@ -937,7 +948,9 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
   SSqlObj* pSql = calloc(1, sizeof(SSqlObj));
   pSql->pTscObj = taos;
   pSql->signature = pSql;
+
   pSql->fp = NULL;        // todo set the correct callback function pointer
+  pSql->cmd.pTableMetaMap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_NO_LOCK);
 
   int32_t length = (int32_t)strlen(tableNameList);
   if (length > MAX_TABLE_NAME_LENGTH) {
@@ -954,9 +967,12 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
   }
 
   strtolower(str, tableNameList);
-  int32_t code = (uint8_t) tscTransferTableNameList(pSql, str, length);
+  SArray* plist = taosArrayInit(4, POINTER_BYTES);
+  SArray* vgroupList = taosArrayInit(4, POINTER_BYTES);
 
+  int32_t code = (uint8_t) tscTransferTableNameList(pSql, str, length, plist);
   free(str);
+
   if (code != TSDB_CODE_SUCCESS) {
     tscFreeSqlObj(pSql);
     return code;
@@ -964,6 +980,21 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
 
   registerSqlObj(pSql);
   tscDebug("0x%"PRIx64" load multiple table meta, tableNameList: %s pObj:%p", pSql->self, tableNameList, pObj);
-  executeQuery(pSql, NULL);
+
+  code = getMultiTableMetaFromMnode(pSql, plist, vgroupList, loadMultiTableMetaCallback);
+  if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
+    code = TSDB_CODE_SUCCESS;
+  }
+
+  taosArrayDestroyEx(plist, freeElem);
+  taosArrayDestroyEx(vgroupList, freeElem);
+
+  if (code != TSDB_CODE_SUCCESS) {
+    tscFreeRegisteredSqlObj(pSql);
+    return code;
+  }
+
+  tsem_wait(&pSql->rspSem);
+  tscFreeRegisteredSqlObj(pSql);
   return code;
 }
diff --git a/src/client/src/tscStream.c b/src/client/src/tscStream.c
index 00be5b6e3f..8e11fd0cfb 100644
--- a/src/client/src/tscStream.c
+++ b/src/client/src/tscStream.c
@@ -94,7 +94,7 @@ static void doLaunchQuery(void* param, TAOS_RES* tres, int32_t code) {
 
   code = tscGetTableMeta(pSql, pTableMetaInfo);
   if (code == 0 && UTIL_TABLE_IS_SUPER_TABLE(pTableMetaInfo)) {
-    code = tscGetSTableVgroupInfo(pSql, 0);
+    code = tscGetSTableVgroupInfo(pSql, pQueryInfo);
   }
 
   if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
@@ -614,16 +614,16 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p
     return NULL;
   }
 
-  pStream->stime = stime;
-  pStream->fp = fp;
+  pStream->stime    = stime;
+  pStream->fp       = fp;
   pStream->callback = callback;
-  pStream->param = param;
-  pStream->pSql = pSql;
-  pSql->pStream = pStream;
-  pSql->param = pStream;
-  pSql->maxRetry = TSDB_MAX_REPLICA;
+  pStream->param    = param;
+  pStream->pSql     = pSql;
 
-  pSql->sqlstr = calloc(1, strlen(sqlstr) + 1);
+  pSql->pStream  = pStream;
+  pSql->param    = pStream;
+  pSql->maxRetry = TSDB_MAX_REPLICA;
+  pSql->sqlstr   = calloc(1, strlen(sqlstr) + 1);
   if (pSql->sqlstr == NULL) {
     tscError("0x%"PRIx64" failed to malloc sql string buffer", pSql->self);
     tscFreeSqlObj(pSql);
@@ -632,14 +632,14 @@ TAOS_STREAM *taos_open_stream(TAOS *taos, const char *sqlstr, void (*fp)(void *p
   }
 
   strtolower(pSql->sqlstr, sqlstr);
+  pSql->fp      = tscCreateStream;
+  pSql->fetchFp = tscCreateStream;
+  pSql->cmd.resColumnId = TSDB_RES_COL_ID;
 
+  tsem_init(&pSql->rspSem, 0, 0);
   registerSqlObj(pSql);
 
   tscDebugL("0x%"PRIx64" SQL: %s", pSql->self, pSql->sqlstr);
-  tsem_init(&pSql->rspSem, 0, 0);
-
-  pSql->fp = tscCreateStream;
-  pSql->fetchFp = tscCreateStream;
 
   int32_t code = tsParseSql(pSql, true);
   if (code == TSDB_CODE_SUCCESS) {
diff --git a/src/client/src/tscSub.c b/src/client/src/tscSub.c
index 539ed85ebe..42330aa18e 100644
--- a/src/client/src/tscSub.c
+++ b/src/client/src/tscSub.c
@@ -151,6 +151,7 @@ static SSub* tscCreateSubscription(STscObj* pObj, const char* topic, const char*
   strtolower(pSql->sqlstr, pSql->sqlstr);
   pRes->qId = 0;
   pRes->numOfRows = 1;
+  pCmd->resColumnId = TSDB_RES_COL_ID;
 
   code = tscAllocPayload(pCmd, TSDB_DEFAULT_PAYLOAD_SIZE);
   if (code != TSDB_CODE_SUCCESS) {
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index eb2e1757d7..325281dce5 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -2289,15 +2289,20 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
   SSqlObj *pNew = createSubqueryObj(pSql, 0, tscFirstRoundCallback, pSup, TSDB_SQL_SELECT, NULL);
   SSqlCmd *pCmd = &pNew->cmd;
 
-  tscClearSubqueryInfo(pCmd);
-  tscFreeSqlResult(pSql);
-
   SQueryInfo* pNewQueryInfo = tscGetQueryInfo(pCmd);
   assert(pQueryInfo->numOfTables == 1);
 
+  SArray* pColList = pNewQueryInfo->colList;
+  pNewQueryInfo->colList = NULL;
+
+  tscClearSubqueryInfo(pCmd);
+  tscFreeSqlResult(pSql);
+
   STableMetaInfo* pTableMetaInfo = tscGetMetaInfo(pNewQueryInfo, 0);
 
   tscInitQueryInfo(pNewQueryInfo);
+
+  // add the group cond
   pNewQueryInfo->groupbyExpr = pQueryInfo->groupbyExpr;
   if (pQueryInfo->groupbyExpr.columnInfo != NULL) {
     pNewQueryInfo->groupbyExpr.columnInfo = taosArrayDup(pQueryInfo->groupbyExpr.columnInfo);
@@ -2307,12 +2312,15 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
     }
   }
 
+  // add the tag filter cond
   if (tscTagCondCopy(&pNewQueryInfo->tagCond, &pQueryInfo->tagCond) != 0) {
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
     goto _error;
   }
 
+  pNewQueryInfo->window   = pQueryInfo->window;
   pNewQueryInfo->interval = pQueryInfo->interval;
+  pNewQueryInfo->sessionWindow = pQueryInfo->sessionWindow;
 
   pCmd->command = TSDB_SQL_SELECT;
   pNew->fp = tscFirstRoundCallback;
@@ -2374,6 +2382,21 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
     }
   }
 
+  // add the normal column filter cond
+  if (pColList != NULL) {
+    size_t s = taosArrayGetSize(pColList);
+    for (int32_t i = 0; i < s; ++i) {
+      SColumn *pCol = taosArrayGetP(pColList, i);
+
+      if (pCol->info.flist.numOfFilters > 0) {  // copy to the pNew->cmd.colList if it is filtered.
+        SColumn *p = tscColumnClone(pCol);
+        taosArrayPush(pNewQueryInfo->colList, &p);
+      }
+    }
+
+    tscColumnListDestroy(pColList);
+  }
+
   tscInsertPrimaryTsSourceColumn(pNewQueryInfo, pTableMetaInfo->pTableMeta->id.uid);
   tscTansformFuncForSTableQuery(pNewQueryInfo);
 
diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 1b04b8201e..88615b0740 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -646,8 +646,10 @@ static SColumnInfo* extractColumnInfoFromResult(SArray* pTableCols) {
 }
 
 typedef struct SDummyInputInfo {
-  SSDataBlock    *block;
-  SSqlObj        *pSql;  // refactor: remove it
+  SSDataBlock *block;
+  SSqlObj     *pSql;  // refactor: remove it
+  int32_t      numOfFilterCols;
+  SSingleColumnFilterInfo *pFilterInfo;
 } SDummyInputInfo;
 
 typedef struct SJoinStatus {
@@ -696,6 +698,18 @@ SSDataBlock* doGetDataBlock(void* param, bool* newgroup) {
   pBlock->info.rows = pRes->numOfRows;
   if (pRes->numOfRows != 0) {
     doSetupSDataBlock(pRes, pBlock);
+
+    if (pInput->numOfFilterCols > 0) {
+      doSetFilterColumnInfo(pInput->pFilterInfo, pInput->numOfFilterCols, pBlock);
+      int8_t* p = calloc(pBlock->info.rows, sizeof(int8_t));
+      bool all = doFilterDataBlock(pInput->pFilterInfo, pInput->numOfFilterCols, pBlock->info.rows, p);
+      if (!all) {
+        doCompactSDataBlock(pBlock, pBlock->info.rows, p);
+      }
+
+      tfree(p);
+    }
+
     *newgroup = false;
     return pBlock;
   }
@@ -865,11 +879,14 @@ static void destroyDummyInputOperator(void* param, int32_t numOfOutput) {
 }
 
 // todo this operator servers as the adapter for Operator tree and SqlRes result, remove it later
-SOperatorInfo* createDummyInputOperator(SSqlObj* pSql, SSchema* pSchema, int32_t numOfCols) {
+SOperatorInfo* createDummyInputOperator(SSqlObj* pSql, SSchema* pSchema, int32_t numOfCols, SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFilterCols) {
   assert(numOfCols > 0);
   SDummyInputInfo* pInfo = calloc(1, sizeof(SDummyInputInfo));
 
-  pInfo->pSql  = pSql;
+  pInfo->pSql            = pSql;
+  pInfo->pFilterInfo     = pFilterInfo;
+  pInfo->numOfFilterCols = numOfFilterCols;
+
   pInfo->block = calloc(numOfCols, sizeof(SSDataBlock));
   pInfo->block->info.numOfCols = numOfCols;
 
@@ -901,7 +918,7 @@ static void destroyJoinOperator(void* param, int32_t numOfOutput) {
   pInfo->pRes = destroyOutputBuf(pInfo->pRes);
 }
 
-SOperatorInfo* createJoinOperator(SOperatorInfo** pUpstream, int32_t numOfUpstream, SSchema* pSchema, int32_t numOfOutput) {
+SOperatorInfo* createJoinOperatorInfo(SOperatorInfo** pUpstream, int32_t numOfUpstream, SSchema* pSchema, int32_t numOfOutput) {
   SJoinOperatorInfo* pInfo = calloc(1, sizeof(SJoinOperatorInfo));
 
   pInfo->numOfUpstream = numOfUpstream;
@@ -985,7 +1002,24 @@ void handleDownstreamOperator(SSqlObj** pSqlObjList, int32_t numOfUpstream, SQue
 
     // if it is a join query, create join operator here
     int32_t numOfCol1 = px->pTableMetaInfo[0]->pTableMeta->tableInfo.numOfColumns;
-    SOperatorInfo* pSourceOperator = createDummyInputOperator(pSqlObjList[0], pSchema, numOfCol1);
+
+    int32_t numOfFilterCols = 0;
+    SColumnInfo* tableCols = calloc(numOfCol1, sizeof(SColumnInfo));
+    for(int32_t i = 0; i < numOfCol1; ++i) {
+      SColumn* pCol = taosArrayGetP(px->colList, i);
+      if (pCol->info.flist.numOfFilters > 0) {
+        numOfFilterCols += 1;
+      }
+
+      tableCols[i] = pCol->info;
+    }
+
+    SSingleColumnFilterInfo* pFilterInfo = NULL;
+    if (numOfFilterCols > 0) {
+      doCreateFilterInfo(tableCols, numOfCol1, numOfFilterCols, &pFilterInfo, 0);
+    }
+
+    SOperatorInfo* pSourceOperator = createDummyInputOperator(pSqlObjList[0], pSchema, numOfCol1, pFilterInfo, numOfFilterCols);
 
     SSchema* schema = NULL;
     if (px->numOfTables > 1) {
@@ -1002,13 +1036,28 @@ void handleDownstreamOperator(SSqlObj** pSqlObjList, int32_t numOfUpstream, SQue
         SSchema* pSchema1 = tscGetTableSchema(px->pTableMetaInfo[i]->pTableMeta);
         int32_t n = px->pTableMetaInfo[i]->pTableMeta->tableInfo.numOfColumns;
 
-        p[i] = createDummyInputOperator(pSqlObjList[i], pSchema1, n);
+        int32_t numOfFilterCols1 = 0;
+        SColumnInfo* tableCols1 = calloc(numOfCol1, sizeof(SColumnInfo));
+        for(int32_t j = 0; j < numOfCol1; ++j) {
+          SColumn* pCol = taosArrayGetP(px->colList, j);
+          if (pCol->info.flist.numOfFilters > 0) {
+            numOfFilterCols += 1;
+          }
 
+          tableCols1[j] = pCol->info;
+        }
+
+        SSingleColumnFilterInfo* pFilterInfo1 = NULL;
+        if (numOfFilterCols1 > 0) {
+          doCreateFilterInfo(tableCols1, numOfCol1, numOfFilterCols1, &pFilterInfo1, 0);
+        }
+
+        p[i] = createDummyInputOperator(pSqlObjList[i], pSchema1, n, pFilterInfo1, numOfFilterCols1);
         memcpy(&schema[offset], pSchema1, n * sizeof(SSchema));
         offset += n;
       }
 
-      pSourceOperator = createJoinOperator(p, px->numOfTables, schema, num);
+      pSourceOperator = createJoinOperatorInfo(p, px->numOfTables, schema, num);
       tfree(p);
     } else {
       size_t num = taosArrayGetSize(px->colList);
@@ -2669,6 +2718,7 @@ STableMetaInfo* tscGetTableMetaInfoByUid(SQueryInfo* pQueryInfo, uint64_t uid, i
   return tscGetMetaInfo(pQueryInfo, k);
 }
 
+// todo refactor
 void tscInitQueryInfo(SQueryInfo* pQueryInfo) {
   assert(pQueryInfo->fieldsInfo.internalField == NULL);
   pQueryInfo->fieldsInfo.internalField = taosArrayInit(4, sizeof(SInternalField));
@@ -4215,11 +4265,53 @@ int32_t tscCreateQueryFromQueryInfo(SQueryInfo* pQueryInfo, SQueryAttr* pQueryAt
   return TSDB_CODE_SUCCESS;
 }
 
-int tscTransferTableNameList(SSqlObj *pSql, const char *pNameList, int32_t length) {
+static int32_t doAddTableName(char* nextStr, char** str, SArray* pNameArray, SSqlObj* pSql) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  SSqlCmd* pCmd = &pSql->cmd;
+
+  char  tablename[TSDB_TABLE_FNAME_LEN] = {0};
+  int32_t len = 0;
+
+  if (nextStr == NULL) {
+    strncpy(tablename, *str, TSDB_TABLE_FNAME_LEN);
+    len = strlen(tablename);
+  } else {
+    memcpy(tablename, *str, nextStr - (*str));
+    len = (int32_t)(nextStr - (*str));
+    tablename[len] = '\0';
+  }
+
+  (*str) = nextStr + 1;
+  len = (int32_t)strtrim(tablename);
+
+  SStrToken sToken = {.n = len, .type = TK_ID, .z = tablename};
+  tGetToken(tablename, &sToken.type);
+
+  // Check if the table name available or not
+  if (tscValidateName(&sToken) != TSDB_CODE_SUCCESS) {
+    code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
+    sprintf(pCmd->payload, "table name is invalid");
+    return code;
+  }
+
+  SName name = {0};
+  if ((code = tscSetTableFullName(&name, &sToken, pSql)) != TSDB_CODE_SUCCESS) {
+    return code;
+  }
+
+  memset(tablename, 0, tListLen(tablename));
+  tNameExtractFullName(&name, tablename);
+
+  char* p = strdup(tablename);
+  taosArrayPush(pNameArray, &p);
+  return TSDB_CODE_SUCCESS;
+}
+
+int tscTransferTableNameList(SSqlObj *pSql, const char *pNameList, int32_t length, SArray* pNameArray) {
   SSqlCmd *pCmd = &pSql->cmd;
 
   pCmd->command = TSDB_SQL_MULTI_META;
-  pCmd->count = 0;
+  pCmd->msgType = TSDB_MSG_TYPE_CM_TABLES_META;
 
   int   code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
   char *str = (char *)pNameList;
@@ -4230,70 +4322,31 @@ int tscTransferTableNameList(SSqlObj *pSql, const char *pNameList, int32_t lengt
     return terrno;
   }
 
-  STableMetaInfo *pTableMetaInfo = tscAddEmptyMetaInfo(pQueryInfo);
-
-  if ((code = tscAllocPayload(pCmd, length + 16)) != TSDB_CODE_SUCCESS) {
-    return code;
-  }
-
   char *nextStr;
-  char  tblName[TSDB_TABLE_FNAME_LEN];
-  int   payloadLen = 0;
-  char *pMsg = pCmd->payload;
   while (1) {
     nextStr = strchr(str, ',');
     if (nextStr == NULL) {
+      code = doAddTableName(nextStr, &str, pNameArray, pSql);
       break;
     }
 
-    memcpy(tblName, str, nextStr - str);
-    int32_t len = (int32_t)(nextStr - str);
-    tblName[len] = '\0';
-
-    str = nextStr + 1;
-    len = (int32_t)strtrim(tblName);
-
-    SStrToken sToken = {.n = len, .type = TK_ID, .z = tblName};
-    tGetToken(tblName, &sToken.type);
-
-    // Check if the table name available or not
-    if (tscValidateName(&sToken) != TSDB_CODE_SUCCESS) {
-      code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
-      sprintf(pCmd->payload, "table name is invalid");
+    code = doAddTableName(nextStr, &str, pNameArray, pSql);
+    if (code != TSDB_CODE_SUCCESS) {
       return code;
     }
 
-    if ((code = tscSetTableFullName(&pTableMetaInfo->name, &sToken, pSql)) != TSDB_CODE_SUCCESS) {
-      return code;
-    }
-
-    if (++pCmd->count > TSDB_MULTI_TABLEMETA_MAX_NUM) {
+    if (taosArrayGetSize(pNameArray) > TSDB_MULTI_TABLEMETA_MAX_NUM) {
       code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
       sprintf(pCmd->payload, "tables over the max number");
       return code;
     }
-
-    int32_t xlen = tNameLen(&pTableMetaInfo->name);
-    if (payloadLen + xlen + 128 >= pCmd->allocSize) {
-      char *pNewMem = realloc(pCmd->payload, pCmd->allocSize + length);
-      if (pNewMem == NULL) {
-        code = TSDB_CODE_TSC_OUT_OF_MEMORY;
-        sprintf(pCmd->payload, "failed to allocate memory");
-        return code;
-      }
-
-      pCmd->payload = pNewMem;
-      pCmd->allocSize = pCmd->allocSize + length;
-      pMsg = pCmd->payload;
-    }
-
-    char n[TSDB_TABLE_FNAME_LEN] = {0};
-    tNameExtractFullName(&pTableMetaInfo->name, n);
-    payloadLen += sprintf(pMsg + payloadLen, "%s,", n);
   }
 
-  *(pMsg + payloadLen) = '\0';
-  pCmd->payloadLen = payloadLen + 1;
+  if (taosArrayGetSize(pNameArray) > TSDB_MULTI_TABLEMETA_MAX_NUM) {
+    code = TSDB_CODE_TSC_INVALID_TABLE_ID_LENGTH;
+    sprintf(pCmd->payload, "tables over the max number");
+    return code;
+  }
 
   return TSDB_CODE_SUCCESS;
 }
diff --git a/src/mnode/src/mnodeTable.c b/src/mnode/src/mnodeTable.c
index 429a6a0b57..1584df16fe 100644
--- a/src/mnode/src/mnodeTable.c
+++ b/src/mnode/src/mnodeTable.c
@@ -2878,6 +2878,7 @@ static int32_t mnodeProcessMultiTableMetaMsg(SMnodeMsg *pMsg) {
   for (; t < pInfo->numOfTables; ++t) {
     char *fullName = nameList[t];
 
+    pMsg->pVgroup = NULL;
     pMsg->pTable = mnodeGetTable(fullName);
     if (pMsg->pTable == NULL) {
       mError("msg:%p, app:%p table:%s, failed to get table meta, table not exist", pMsg, pMsg->rpcMsg.ahandle, fullName);
diff --git a/src/query/inc/qExecutor.h b/src/query/inc/qExecutor.h
index a39819cb51..4ab718e09d 100644
--- a/src/query/inc/qExecutor.h
+++ b/src/query/inc/qExecutor.h
@@ -521,12 +521,17 @@ SOperatorInfo* createSLimitOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperator
 SOperatorInfo* createFilterOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorInfo* upstream, SExprInfo* pExpr,
                                         int32_t numOfOutput, SColumnInfo* pCols, int32_t numOfFilter);
 
-SOperatorInfo* createJoinOperator(SOperatorInfo** pUpstream, int32_t numOfUpstream, SSchema* pSchema, int32_t numOfOutput);
+SOperatorInfo* createJoinOperatorInfo(SOperatorInfo** pUpstream, int32_t numOfUpstream, SSchema* pSchema, int32_t numOfOutput);
 
 SSDataBlock* doGlobalAggregate(void* param, bool* newgroup);
 SSDataBlock* doMultiwayMergeSort(void* param, bool* newgroup);
 SSDataBlock* doSLimit(void* param, bool* newgroup);
 
+int32_t doCreateFilterInfo(SColumnInfo* pCols, int32_t numOfCols, int32_t numOfFilterCols, SSingleColumnFilterInfo** pFilterInfo, uint64_t qId);
+void doSetFilterColumnInfo(SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFilterCols, SSDataBlock* pBlock);
+bool doFilterDataBlock(SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFilterCols, int32_t numOfRows, int8_t* p);
+void doCompactSDataBlock(SSDataBlock* pBlock, int32_t numOfRows, int8_t* p);
+
 SSDataBlock* createOutputBuf(SExprInfo* pExpr, int32_t numOfOutput, int32_t numOfRows);
 void* destroyOutputBuf(SSDataBlock* pBlock);
 
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index 8a7506cb97..334edefe1e 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -178,8 +178,6 @@ static STsdbQueryCond createTsdbQueryCond(SQueryAttr* pQueryAttr, STimeWindow* w
 static STableIdInfo createTableIdInfo(STableQueryInfo* pTableQueryInfo);
 
 static void setTableScanFilterOperatorInfo(STableScanInfo* pTableScanInfo, SOperatorInfo* pDownstream);
-static int32_t doCreateFilterInfo(SColumnInfo* pCols, int32_t numOfCols, int32_t numOfFilterCols,
-                                  SSingleColumnFilterInfo** pFilterInfo, uint64_t qId);
 static void* doDestroyFilterInfo(SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFilterCols);
 
 static int32_t getNumOfScanTimes(SQueryAttr* pQueryAttr);
@@ -1742,7 +1740,9 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
       case OP_Aggregate: {
         pRuntimeEnv->proot =
             createAggregateOperatorInfo(pRuntimeEnv, pRuntimeEnv->proot, pQueryAttr->pExpr1, pQueryAttr->numOfOutput);
-        if (pRuntimeEnv->proot->upstream[0]->operatorType != OP_DummyInput) {
+
+        int32_t opType = pRuntimeEnv->proot->upstream[0]->operatorType;
+        if (opType != OP_DummyInput && opType != OP_Join) {
           setTableScanFilterOperatorInfo(pRuntimeEnv->proot->upstream[0]->info, pRuntimeEnv->proot);
         }
         break;
@@ -2099,7 +2099,7 @@ static int32_t updateBlockLoadStatus(SQueryAttr *pQuery, int32_t status) {
   if (hasFirstLastFunc && status == BLK_DATA_NO_NEEDED) {
     if(!hasOtherFunc) {
       return BLK_DATA_DISCARD;
-    } else{
+    } else {
       return BLK_DATA_ALL_NEEDED;
     }
   }
@@ -2374,6 +2374,105 @@ static int32_t doTSJoinFilter(SQueryRuntimeEnv *pRuntimeEnv, TSKEY key, bool asc
   return TS_JOIN_TS_EQUAL;
 }
 
+bool doFilterDataBlock(SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFilterCols, int32_t numOfRows, int8_t* p) {
+  bool all = true;
+
+  for (int32_t i = 0; i < numOfRows; ++i) {
+    bool qualified = false;
+
+    for (int32_t k = 0; k < numOfFilterCols; ++k) {
+      char* pElem = (char*)pFilterInfo[k].pData + pFilterInfo[k].info.bytes * i;
+
+      qualified = false;
+      for (int32_t j = 0; j < pFilterInfo[k].numOfFilters; ++j) {
+        SColumnFilterElem* pFilterElem = &pFilterInfo[k].pFilters[j];
+
+        bool isnull = isNull(pElem, pFilterInfo[k].info.type);
+        if (isnull) {
+          if (pFilterElem->fp == isNullOperator) {
+            qualified = true;
+            break;
+          } else {
+            continue;
+          }
+        } else {
+          if (pFilterElem->fp == notNullOperator) {
+            qualified = true;
+            break;
+          } else if (pFilterElem->fp == isNullOperator) {
+            continue;
+          }
+        }
+
+        if (pFilterElem->fp(pFilterElem, pElem, pElem, pFilterInfo[k].info.type)) {
+          qualified = true;
+          break;
+        }
+      }
+
+      if (!qualified) {
+        break;
+      }
+    }
+
+    p[i] = qualified ? 1 : 0;
+    if (!qualified) {
+      all = false;
+    }
+  }
+
+  return all;
+}
+
+void doCompactSDataBlock(SSDataBlock* pBlock, int32_t numOfRows, int8_t* p) {
+  int32_t len = 0;
+  int32_t start = 0;
+  for (int32_t j = 0; j < numOfRows; ++j) {
+    if (p[j] == 1) {
+      len++;
+    } else {
+      if (len > 0) {
+        int32_t cstart = j - len;
+        for (int32_t i = 0; i < pBlock->info.numOfCols; ++i) {
+          SColumnInfoData* pColumnInfoData = taosArrayGet(pBlock->pDataBlock, i);
+
+          int16_t bytes = pColumnInfoData->info.bytes;
+          memmove(((char*)pColumnInfoData->pData) + start * bytes, pColumnInfoData->pData + cstart * bytes,
+                  len * bytes);
+        }
+
+        start += len;
+        len = 0;
+      }
+    }
+  }
+
+  if (len > 0) {
+    int32_t cstart = numOfRows - len;
+    for (int32_t i = 0; i < pBlock->info.numOfCols; ++i) {
+      SColumnInfoData* pColumnInfoData = taosArrayGet(pBlock->pDataBlock, i);
+
+      int16_t bytes = pColumnInfoData->info.bytes;
+      memmove(pColumnInfoData->pData + start * bytes, pColumnInfoData->pData + cstart * bytes, len * bytes);
+    }
+
+    start += len;
+    len = 0;
+  }
+
+  pBlock->info.rows = start;
+  pBlock->pBlockStatis = NULL;  // clean the block statistics info
+
+  if (start > 0) {
+    SColumnInfoData* pColumnInfoData = taosArrayGet(pBlock->pDataBlock, 0);
+    if (pColumnInfoData->info.type == TSDB_DATA_TYPE_TIMESTAMP &&
+        pColumnInfoData->info.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
+      pBlock->info.window.skey = *(int64_t*)pColumnInfoData->pData;
+      pBlock->info.window.ekey = *(int64_t*)(pColumnInfoData->pData + TSDB_KEYSIZE * (start - 1));
+    }
+  }
+}
+
 void filterRowsInDataBlock(SQueryRuntimeEnv* pRuntimeEnv, SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFilterCols,
                            SSDataBlock* pBlock, bool ascQuery) {
   int32_t numOfRows = pBlock->info.rows;
@@ -2406,97 +2505,11 @@ void filterRowsInDataBlock(SQueryRuntimeEnv* pRuntimeEnv, SSingleColumnFilterInf
     // save the cursor status
     pRuntimeEnv->current->cur = tsBufGetCursor(pRuntimeEnv->pTsBuf);
   } else {
-    for (int32_t i = 0; i < numOfRows; ++i) {
-      bool qualified = false;
-
-      for (int32_t k = 0; k < numOfFilterCols; ++k) {
-        char* pElem = (char*)pFilterInfo[k].pData + pFilterInfo[k].info.bytes * i;
-
-        qualified = false;
-        for (int32_t j = 0; j < pFilterInfo[k].numOfFilters; ++j) {
-          SColumnFilterElem* pFilterElem = &pFilterInfo[k].pFilters[j];
-
-          bool isnull = isNull(pElem, pFilterInfo[k].info.type);
-          if (isnull) {
-            if (pFilterElem->fp == isNullOperator) {
-              qualified = true;
-              break;
-            } else {
-              continue;
-            }
-          } else {
-            if (pFilterElem->fp == notNullOperator) {
-              qualified = true;
-              break;
-            } else if (pFilterElem->fp == isNullOperator) {
-              continue;
-            }
-          }
-
-          if (pFilterElem->fp(pFilterElem, pElem, pElem, pFilterInfo[k].info.type)) {
-            qualified = true;
-            break;
-          }
-        }
-
-        if (!qualified) {
-          break;
-        }
-      }
-
-      p[i] = qualified ? 1 : 0;
-      if (!qualified) {
-        all = false;
-      }
-    }
+    all = doFilterDataBlock(pFilterInfo, numOfFilterCols, numOfRows, p);
   }
 
   if (!all) {
-    int32_t start = 0;
-    int32_t len = 0;
-    for (int32_t j = 0; j < numOfRows; ++j) {
-      if (p[j] == 1) {
-        len++;
-      } else {
-        if (len > 0) {
-          int32_t cstart = j - len;
-          for (int32_t i = 0; i < pBlock->info.numOfCols; ++i) {
-            SColumnInfoData *pColumnInfoData = taosArrayGet(pBlock->pDataBlock, i);
-
-            int16_t bytes = pColumnInfoData->info.bytes;
-            memmove(((char*)pColumnInfoData->pData) + start * bytes, pColumnInfoData->pData + cstart * bytes, len * bytes);
-          }
-
-          start += len;
-          len = 0;
-        }
-      }
-    }
-
-    if (len > 0) {
-      int32_t cstart = numOfRows - len;
-      for (int32_t i = 0; i < pBlock->info.numOfCols; ++i) {
-        SColumnInfoData *pColumnInfoData = taosArrayGet(pBlock->pDataBlock, i);
-
-        int16_t bytes = pColumnInfoData->info.bytes;
-        memmove(pColumnInfoData->pData + start * bytes, pColumnInfoData->pData + cstart * bytes, len * bytes);
-      }
-
-      start += len;
-      len = 0;
-    }
-
-    pBlock->info.rows = start;
-    pBlock->pBlockStatis = NULL;  // clean the block statistics info
-
-    if (start > 0) {
-      SColumnInfoData* pColumnInfoData = taosArrayGet(pBlock->pDataBlock, 0);
-      if (pColumnInfoData->info.type == TSDB_DATA_TYPE_TIMESTAMP &&
-             pColumnInfoData->info.colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
-        pBlock->info.window.skey = *(int64_t*)pColumnInfoData->pData;
-        pBlock->info.window.ekey = *(int64_t*)(pColumnInfoData->pData + TSDB_KEYSIZE * (start - 1));
-      }
-    }
+    doCompactSDataBlock(pBlock, numOfRows, p);
   }
 
   tfree(p);
@@ -2524,7 +2537,7 @@ static uint32_t doFilterByBlockTimeWindow(STableScanInfo* pTableScanInfo, SSData
   return status;
 }
 
-static void doSetFilterColumnInfo(SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFilterCols, SSDataBlock* pBlock) {
+void doSetFilterColumnInfo(SSingleColumnFilterInfo* pFilterInfo, int32_t numOfFilterCols, SSDataBlock* pBlock) {
   if (numOfFilterCols > 0 && pFilterInfo[0].pData != NULL) {
     return;
   }
@@ -4920,27 +4933,6 @@ static SSDataBlock* doLimit(void* param, bool* newgroup) {
   return pBlock;
 }
 
-
-bool doFilterData(SColumnInfoData* p, int32_t rid, SColumnFilterElem *filterElem, __filter_func_t fp) {
-  char* input = p->pData + p->info.bytes * rid;
-  bool isnull = isNull(input, p->info.type);
-  if (isnull) {
-    return (fp == isNullOperator) ? true : false;
-  } else {
-    if (fp == notNullOperator) {
-      return true;
-    } else if (fp == isNullOperator) {
-      return false;
-    }
-  }
-
-  if (fp(filterElem, input, input, p->info.type)) {
-    return true;
-  }
-
-  return false;
-}
-
 static SSDataBlock* doFilter(void* param, bool* newgroup) {
   SOperatorInfo *pOperator = (SOperatorInfo *)param;
   if (pOperator->status == OP_EXEC_DONE) {
@@ -5445,7 +5437,7 @@ SOperatorInfo* createArithOperatorInfo(SQueryRuntimeEnv* pRuntimeEnv, SOperatorI
   return pOperator;
 }
 
-static SColumnInfo* extractColumnFilterInfo(SExprInfo* pExpr, int32_t numOfOutput, int32_t* numOfFilterCols) {
+SColumnInfo* extractColumnFilterInfo(SExprInfo* pExpr, int32_t numOfOutput, int32_t* numOfFilterCols) {
   SColumnInfo* pCols = calloc(numOfOutput, sizeof(SColumnInfo));
 
   int32_t numOfFilter = 0;
@@ -5454,7 +5446,7 @@ static SColumnInfo* extractColumnFilterInfo(SExprInfo* pExpr, int32_t numOfOutpu
       numOfFilter += 1;
     }
 
-    pCols[i].type = pExpr[i].base.resType;
+    pCols[i].type  = pExpr[i].base.resType;
     pCols[i].bytes = pExpr[i].base.resBytes;
     pCols[i].colId = pExpr[i].base.resColId;
 
@@ -6663,8 +6655,7 @@ SGroupbyExpr *createGroupbyExprFromMsg(SQueryTableMsg *pQueryMsg, SColIndex *pCo
   return pGroupbyExpr;
 }
 
-static int32_t doCreateFilterInfo(SColumnInfo* pCols, int32_t numOfCols, int32_t numOfFilterCols,
-                                  SSingleColumnFilterInfo** pFilterInfo, uint64_t qId) {
+int32_t doCreateFilterInfo(SColumnInfo* pCols, int32_t numOfCols, int32_t numOfFilterCols, SSingleColumnFilterInfo** pFilterInfo, uint64_t qId) {
   *pFilterInfo = calloc(1, sizeof(SSingleColumnFilterInfo) * numOfFilterCols);
   if (pFilterInfo == NULL) {
     return TSDB_CODE_QRY_OUT_OF_MEMORY;
diff --git a/tests/examples/c/apitest.c b/tests/examples/c/apitest.c
index f20c0321c4..0ca92eaf1d 100644
--- a/tests/examples/c/apitest.c
+++ b/tests/examples/c/apitest.c
@@ -7,7 +7,6 @@
 #include <taos.h>
 #include <unistd.h>
 
-
 static void prepare_data(TAOS* taos) {
   TAOS_RES *result;
   result = taos_query(taos, "drop database if exists test;");
@@ -69,7 +68,6 @@ static void prepare_data(TAOS* taos) {
   usleep(1000000);
 }
 
-
 static int print_result(TAOS_RES* res, int blockFetch) {
   TAOS_ROW    row = NULL;
   int         num_fields = taos_num_fields(res);
@@ -99,7 +97,6 @@ static int print_result(TAOS_RES* res, int blockFetch) {
   return nRows;
 }
 
-
 static void check_row_count(int line, TAOS_RES* res, int expected) {
   int actual = print_result(res, expected % 2);
   if (actual != expected) {
@@ -109,7 +106,6 @@ static void check_row_count(int line, TAOS_RES* res, int expected) {
   }
 }
 
-
 static void verify_query(TAOS* taos) {
   prepare_data(taos);
 
@@ -153,7 +149,6 @@ static void verify_query(TAOS* taos) {
   taos_free_result(res);
 }
 
-
 void subscribe_callback(TAOS_SUB* tsub, TAOS_RES *res, void* param, int code) {
   int rows = print_result(res, *(int*)param);
   printf("%d rows consumed in subscribe_callback\n", rows);
@@ -235,10 +230,10 @@ static void verify_subscribe(TAOS* taos) {
   taos_unsubscribe(tsub, 0);
 }
 
-
 void verify_prepare(TAOS* taos) {
   TAOS_RES* result = taos_query(taos, "drop database if exists test;");
   taos_free_result(result);
+
   usleep(100000);
   result = taos_query(taos, "create database test;");
 
@@ -248,6 +243,7 @@ void verify_prepare(TAOS* taos) {
     taos_free_result(result);
     return;
   }
+
   taos_free_result(result);
 
   usleep(100000);
@@ -369,6 +365,7 @@ void verify_prepare(TAOS* taos) {
     taos_stmt_add_batch(stmt);
   }
   if (taos_stmt_execute(stmt) != 0) {
+    taos_stmt_close(stmt);
     printf("\033[31mfailed to execute insert statement.\033[0m\n");
     return;
   }
@@ -381,6 +378,7 @@ void verify_prepare(TAOS* taos) {
   v.v2 = 15;
   taos_stmt_bind_param(stmt, params + 2);
   if (taos_stmt_execute(stmt) != 0) {
+    taos_stmt_close(stmt);
     printf("\033[31mfailed to execute select statement.\033[0m\n");
     return;
   }
diff --git a/tests/script/general/parser/function.sim b/tests/script/general/parser/function.sim
index 65058333fb..56ce15c36f 100644
--- a/tests/script/general/parser/function.sim
+++ b/tests/script/general/parser/function.sim
@@ -809,3 +809,5 @@ endi
 if $data00 != 1 then
   return -1
 endi
+
+print ====================> TODO stddev + normal column filter
diff --git a/tests/script/general/parser/nestquery.sim b/tests/script/general/parser/nestquery.sim
index eab1392d1c..9e2736833f 100644
--- a/tests/script/general/parser/nestquery.sim
+++ b/tests/script/general/parser/nestquery.sim
@@ -120,16 +120,12 @@ if $data00 != 167 then
 endi
 
 print ================>master query + filter
-sql select * from (select count(*) a from nest_tb0 interval(10h)) where a <= 520;
+sql select t.* from (select count(*) a from nest_tb0 interval(10h)) t where t.a <= 520;
 if $rows != 2 then
   return -1
 endi
 
 
-print ==================> nest query join
-
-
-
 print ===================> nest query interval
 
 
@@ -138,4 +134,74 @@ print ===================> complex query
 
 
 
+print ===================> group by + having
+
+
+
+
+
+print =========================> nest query join
+sql select a.ts,a.k,b.ts from (select count(*) k from nest_tb0 interval(30a)) a, (select count(*) f from nest_tb1 interval(30a)) b where a.ts = b.ts ;
+if $rows != 10000 then
+  return -1
+endi
+
+if $data00 != @20-09-15 00:00:00.000@ then
+  return -1
+endi
+
+if $data01 != 1 then
+  return -1
+endi
+
+if $data02 != @20-09-15 00:00:00.000@ then
+  return -1
+endi
+
+if $data10 != @20-09-15 00:01:00.000@ then
+  return -1
+endi
+
+if $data11 != 1 then
+  return -1
+endi
+
+if $data12 != @20-09-15 00:01:00.000@ then
+  return -1
+endi
+
+sql select sum(a.k), sum(b.f) from (select count(*) k from nest_tb0 interval(30a)) a, (select count(*) f from nest_tb1 interval(30a)) b where a.ts = b.ts ;
+if $rows != 1 then
+  return -1
+endi
+
+if $data00 != 10000 then
+  return -1
+endi
+
+if $data01 != 10000 then
+  return -1
+endi
+
+sql select a.ts,a.k,b.ts,c.ts,c.ts,c.x from (select count(*) k from nest_tb0 interval(30a)) a, (select count(*) f from nest_tb1 interval(30a)) b, (select count(*) x from nest_tb2 interval(30a)) c where a.ts = b.ts and a.ts = c.ts
+if $rows != 10000 then
+  return -1
+endi
+
+if $data00 != @20-09-15 00:00:00.000@ then
+  return -1
+endi
+
+if $data01 != 1 then
+  return -1
+endi
+
+if $data02 != @20-09-15 00:00:00.000@ then
+  return -1
+endi
+
+if $data03 != @20-09-15 00:00:00.000@ then
+  return -1
+endi
+
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
\ No newline at end of file

From 004ee2999ce348955942cce726f8fc571cd5085e Mon Sep 17 00:00:00 2001
From: Haojun Liao <hjliao@taosdata.com>
Date: Fri, 28 May 2021 12:47:28 +0800
Subject: [PATCH 123/128] [td-225]

---
 src/client/src/tscUtil.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/client/src/tscUtil.c b/src/client/src/tscUtil.c
index 88615b0740..9d44dd1cdc 100644
--- a/src/client/src/tscUtil.c
+++ b/src/client/src/tscUtil.c
@@ -4274,7 +4274,7 @@ static int32_t doAddTableName(char* nextStr, char** str, SArray* pNameArray, SSq
 
   if (nextStr == NULL) {
     strncpy(tablename, *str, TSDB_TABLE_FNAME_LEN);
-    len = strlen(tablename);
+    len = (int32_t) strlen(tablename);
   } else {
     memcpy(tablename, *str, nextStr - (*str));
     len = (int32_t)(nextStr - (*str));

From 4d5e99b890d2e3bf4f120cc92818de5993984358 Mon Sep 17 00:00:00 2001
From: liuyq-617 <yqliu@taosdata.com>
Date: Fri, 28 May 2021 08:32:03 +0000
Subject: [PATCH 124/128] [TD-4415]Add exceptions in valgrind_taos.supp

---
 tests/pytest/crash_gen/valgrind_taos.supp | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/tests/pytest/crash_gen/valgrind_taos.supp b/tests/pytest/crash_gen/valgrind_taos.supp
index a00b2d830c..5f6604ba77 100644
--- a/tests/pytest/crash_gen/valgrind_taos.supp
+++ b/tests/pytest/crash_gen/valgrind_taos.supp
@@ -17496,4 +17496,25 @@
    obj:/usr/bin/python3.8
    obj:/usr/bin/python3.8
    fun:PyVectorcall_Call
+}
+{
+   <insert_a_suppression_name_here>
+   Memcheck:Leak
+   match-leak-kinds: definite
+   fun:malloc
+   fun:__libc_alloc_buffer_allocate
+   fun:alloc_buffer_allocate
+   fun:__resolv_conf_allocate
+   fun:__resolv_conf_load
+   fun:__resolv_conf_get_current
+   fun:__res_vinit
+   fun:maybe_init
+   fun:context_get
+   fun:context_get
+   fun:__resolv_context_get
+   fun:gaih_inet.constprop.0
+   fun:getaddrinfo
+   fun:taosGetFqdn
+   fun:taosCheckGlobalCfg
+   fun:taos_init_imp
 }
\ No newline at end of file

From f0fea88d4f2107589f0265a3006aae36de9f92e1 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Fri, 28 May 2021 19:51:00 +0800
Subject: [PATCH 125/128] Feature/sangshuduo/td 4068 taosdemo stmt (#6274)

* merge with develop branch.

change query/tests/CMakeLists.txt to allow unused function and variable.

* refactor data generating.

* refactor.

* refactor.

* refactor.

* refactor.

* refactor

* add prepare stmt function.

* refactor get rand timestamp.

* fix windows compile error.

* copy logic of generate data for stmt.

* insert data basically works now.

* fix windows compile issue.

* [TD-4068]<feature>: taosdemo stmt interface.

stb batch insert works.

* [TD-4068]<feature>: taosdemo support stmt.

normal table insert works.

* [TD-4068]<feature>: taosdemo support stmt.

interlace write works.

* add compile macro to make taosdemo same with master branch.

* fix clang compile error.

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdemo/taosdemo.c | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index 6ad5fadf7c..b7b2fe0e52 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -53,6 +53,8 @@
 #include "taoserror.h"
 #include "tutil.h"
 
+#define STMT_IFACE_ENABLED  1
+
 #define REQ_EXTRA_BUF_LEN   1024
 #define RESP_BUF_LEN        4096
 
@@ -5259,6 +5261,7 @@ static int64_t generateInterlaceDataWithoutStb(
   return k;
 }
 
+#if STMT_IFACE_ENABLED == 1
 static int32_t prepareStmtBindArrayByType(TAOS_BIND *bind,
         char *dataType, int32_t dataLen, char **ptr)
 {
@@ -5551,6 +5554,7 @@ static int32_t prepareStbStmt(SSuperTable *stbInfo,
 
     return k;
 }
+#endif
 
 static int32_t generateStbProgressiveData(
         SSuperTable *superTblInfo,
@@ -5738,6 +5742,7 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
       int32_t generated;
       if (superTblInfo) {
           if (superTblInfo->iface == STMT_IFACE) {
+#if STMT_IFACE_ENABLED == 1
               generated = prepareStbStmt(superTblInfo,
                       pThreadInfo->stmt,
                       tableName,
@@ -5745,6 +5750,9 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
                       insertRows, i,
                       startTime,
                       pThreadInfo->buffer);
+#else
+              generated = -1;
+#endif
           } else {
               generated = generateStbInterlaceData(
                       superTblInfo,
@@ -5762,11 +5770,15 @@ static void* syncWriteInterlace(threadInfo *pThreadInfo) {
                       pThreadInfo->threadID,
                       __func__, __LINE__,
                       tableName, batchPerTbl, startTime);
+#if STMT_IFACE_ENABLED == 1
               generated = prepareStmtWithoutStb(
                       pThreadInfo->stmt, tableName,
                       batchPerTbl,
                       insertRows, i,
                       startTime);
+#else
+              generated = -1;
+#endif
           } else {
               generated = generateInterlaceDataWithoutStb(
                       tableName, batchPerTbl,
@@ -5947,12 +5959,16 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
       int32_t generated;
       if (superTblInfo) {
           if (superTblInfo->iface == STMT_IFACE) {
+#if STMT_IFACE_ENABLED == 1
               generated = prepareStbStmt(
                       superTblInfo,
                       pThreadInfo->stmt,
                       tableName,
                       g_args.num_of_RPR,
                       insertRows, i, start_time, pstr);
+#else
+              generated = -1;
+#endif
           } else {
               generated = generateStbProgressiveData(
                       superTblInfo,
@@ -5963,12 +5979,16 @@ static void* syncWriteProgressive(threadInfo *pThreadInfo) {
           }
       } else {
           if (g_args.iface == STMT_IFACE) {
+#if STMT_IFACE_ENABLED == 1
               generated = prepareStmtWithoutStb(
                       pThreadInfo->stmt,
                       tableName,
                       g_args.num_of_RPR,
                       insertRows, i,
                       start_time);
+#else
+              generated = -1;
+#endif
           } else {
               generated = generateProgressiveDataWithoutStb(
                       tableName,

From c56825984039798c90b2c9184eb19477755c4707 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Sat, 29 May 2021 00:24:53 +0800
Subject: [PATCH 126/128] Hotfix/sangshuduo/td 3913 mips compile support for
 develop (#6278)

* [TD-3913]<fix>: mips compile support.

* [TD-3913]<fix>: mips64 support.

* fix osSignal.c

* fix tcrc32c.c

* fix cmake.

* fix osInc.h

* fix gcc 4.8 compile error.

* fix clang compile error.

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/os/src/detail/osTime.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/os/src/detail/osTime.c b/src/os/src/detail/osTime.c
index d9d070218e..67e0c2642e 100644
--- a/src/os/src/detail/osTime.c
+++ b/src/os/src/detail/osTime.c
@@ -87,12 +87,12 @@ static int32_t (*parseLocaltimeFp[]) (char* timestr, int64_t* time, int32_t time
 
 int32_t taosGetTimestampSec() { return (int32_t)time(NULL); }
 
-int32_t taosParseTime(char* timestr, int64_t* time, int32_t len, int32_t timePrec, int8_t daylight) {
+int32_t taosParseTime(char* timestr, int64_t* time, int32_t len, int32_t timePrec, int8_t day_light) {
   /* parse datatime string in with tz */
   if (strnchr(timestr, 'T', len, false) != NULL) {
     return parseTimeWithTz(timestr, time, timePrec);
   } else {
-    return (*parseLocaltimeFp[daylight])(timestr, time, timePrec);
+    return (*parseLocaltimeFp[day_light])(timestr, time, timePrec);
   }
 }
 

From 88f3e7aad8f02907c0632d2a5cd47a17f8963978 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Sat, 29 May 2021 09:04:13 +0800
Subject: [PATCH 127/128] [TD-4353]<fix>: taosdemo resub if resubAfterConsume
 != -1 (#6286)

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdemo/taosdemo.c | 72 +++++++++++++++++++++++++------------
 1 file changed, 50 insertions(+), 22 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index b7b2fe0e52..004ea280c4 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -379,7 +379,7 @@ typedef struct SDbs_S {
 typedef struct SpecifiedQueryInfo_S {
   uint64_t     queryInterval;  // 0: unlimit  > 0   loop/s
   uint32_t     concurrent;
-  uint64_t     sqlCount;
+  int          sqlCount;
   uint32_t     asyncMode; // 0: sync, 1: async
   uint64_t     subscribeInterval; // ms
   uint64_t     queryTimes;
@@ -388,6 +388,7 @@ typedef struct SpecifiedQueryInfo_S {
   char         sql[MAX_QUERY_SQL_COUNT][MAX_QUERY_SQL_LENGTH+1];
   char         result[MAX_QUERY_SQL_COUNT][MAX_FILE_NAME_LEN+1];
   int          resubAfterConsume[MAX_QUERY_SQL_COUNT];
+  int          endAfterConsume[MAX_QUERY_SQL_COUNT];
   TAOS_SUB*    tsub[MAX_QUERY_SQL_COUNT];
   char         topic[MAX_QUERY_SQL_COUNT][32];
   int          consumed[MAX_QUERY_SQL_COUNT];
@@ -406,10 +407,11 @@ typedef struct SuperQueryInfo_S {
   uint64_t     queryTimes;
   int64_t      childTblCount;
   char         childTblPrefix[MAX_TB_NAME_SIZE];
-  uint64_t     sqlCount;
+  int          sqlCount;
   char         sql[MAX_QUERY_SQL_COUNT][MAX_QUERY_SQL_LENGTH+1];
   char         result[MAX_QUERY_SQL_COUNT][MAX_FILE_NAME_LEN+1];
   int          resubAfterConsume;
+  int          endAfterConsume;
   TAOS_SUB*    tsub[MAX_QUERY_SQL_COUNT];
 
   char*        childTblName;
@@ -1773,7 +1775,7 @@ static void printfQueryMeta() {
 
   if ((SUBSCRIBE_TEST == g_args.test_mode) || (QUERY_TEST == g_args.test_mode)) {
     printf("specified table query info:                   \n");
-    printf("sqlCount:       \033[33m%"PRIu64"\033[0m\n",
+    printf("sqlCount:       \033[33m%d\033[0m\n",
       g_queryInfo.specifiedQueryInfo.sqlCount);
     if (g_queryInfo.specifiedQueryInfo.sqlCount > 0) {
       printf("specified tbl query times:\n");
@@ -1793,15 +1795,15 @@ static void printfQueryMeta() {
       printf("keepProgress:   \033[33m%d\033[0m\n",
         g_queryInfo.specifiedQueryInfo.subscribeKeepProgress);
 
-      for (uint64_t i = 0; i < g_queryInfo.specifiedQueryInfo.sqlCount; i++) {
-        printf("  sql[%"PRIu64"]: \033[33m%s\033[0m\n",
+      for (int i = 0; i < g_queryInfo.specifiedQueryInfo.sqlCount; i++) {
+        printf("  sql[%d]: \033[33m%s\033[0m\n",
             i, g_queryInfo.specifiedQueryInfo.sql[i]);
       }
       printf("\n");
     }
 
     printf("super table query info:\n");
-    printf("sqlCount:       \033[33m%"PRIu64"\033[0m\n",
+    printf("sqlCount:       \033[33m%d\033[0m\n",
       g_queryInfo.superQueryInfo.sqlCount);
 
     if (g_queryInfo.superQueryInfo.sqlCount > 0) {
@@ -4268,7 +4270,7 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
     if (concurrent && concurrent->type == cJSON_Number) {
       if (concurrent->valueint <= 0) {
         errorPrint(
-                "%s() LN%d, query sqlCount %"PRIu64" or concurrent %d is not correct.\n",
+                "%s() LN%d, query sqlCount %d or concurrent %d is not correct.\n",
               __func__, __LINE__,
               g_queryInfo.specifiedQueryInfo.sqlCount,
               g_queryInfo.specifiedQueryInfo.concurrent);
@@ -4367,6 +4369,17 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
         tstrncpy(g_queryInfo.specifiedQueryInfo.sql[j],
                 sqlStr->valuestring, MAX_QUERY_SQL_LENGTH);
 
+        cJSON* endAfterConsume =
+            cJSON_GetObjectItem(specifiedQuery, "endAfterConsume");
+        if (endAfterConsume
+                && endAfterConsume->type == cJSON_Number) {
+            g_queryInfo.specifiedQueryInfo.endAfterConsume[j]
+                = endAfterConsume->valueint;
+        } else if (!endAfterConsume) {
+            // default value is -1, which mean infinite loop
+            g_queryInfo.specifiedQueryInfo.endAfterConsume[j] = -1;
+        }
+
         cJSON* resubAfterConsume =
             cJSON_GetObjectItem(specifiedQuery, "resubAfterConsume");
         if (resubAfterConsume
@@ -4374,9 +4387,8 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
             g_queryInfo.specifiedQueryInfo.resubAfterConsume[j]
                 = resubAfterConsume->valueint;
         } else if (!resubAfterConsume) {
-            //printf("failed to read json, subscribe interval no found\n");
-            //goto PARSE_OVER;
-            g_queryInfo.specifiedQueryInfo.resubAfterConsume[j] = 1;
+            // default value is -1, which mean do not resub
+            g_queryInfo.specifiedQueryInfo.resubAfterConsume[j] = -1;
         }
 
         cJSON *result = cJSON_GetObjectItem(sql, "result");
@@ -4520,16 +4532,26 @@ static bool getMetaFromQueryJsonFile(cJSON* root) {
       g_queryInfo.superQueryInfo.subscribeKeepProgress = 0;
     }
 
+    cJSON* superEndAfterConsume =
+            cJSON_GetObjectItem(superQuery, "endAfterConsume");
+    if (superEndAfterConsume
+            && superEndAfterConsume->type == cJSON_Number) {
+        g_queryInfo.superQueryInfo.endAfterConsume =
+            superEndAfterConsume->valueint;
+    } else if (!superEndAfterConsume) {
+        // default value is -1, which mean do not resub
+        g_queryInfo.superQueryInfo.endAfterConsume = -1;
+    }
+
     cJSON* superResubAfterConsume =
-            cJSON_GetObjectItem(superQuery, "resubAfterConsume");
+            cJSON_GetObjectItem(superQuery, "endAfterConsume");
     if (superResubAfterConsume
             && superResubAfterConsume->type == cJSON_Number) {
-        g_queryInfo.superQueryInfo.resubAfterConsume =
+        g_queryInfo.superQueryInfo.endAfterConsume =
             superResubAfterConsume->valueint;
     } else if (!superResubAfterConsume) {
-        //printf("failed to read json, subscribe interval no found\n");
-        ////goto PARSE_OVER;
-        g_queryInfo.superQueryInfo.resubAfterConsume = 1;
+        // default value is -1, which mean do not resub
+        g_queryInfo.superQueryInfo.endAfterConsume = -1;
     }
 
     // supert table sqls
@@ -7250,7 +7272,10 @@ static void *superSubscribe(void *sarg) {
 
   uint64_t st = 0, et = 0;
 
-  while(1) {
+  while ((g_queryInfo.superQueryInfo.endAfterConsume == -1)
+          || (g_queryInfo.superQueryInfo.endAfterConsume <
+              consumed[pThreadInfo->end_table_to - pThreadInfo->start_table_from])) {
+
     for (uint64_t i = pThreadInfo->start_table_from;
             i <= pThreadInfo->end_table_to; i++) {
       tsubSeq = i - pThreadInfo->start_table_from;
@@ -7279,7 +7304,7 @@ static void *superSubscribe(void *sarg) {
           }
           consumed[tsubSeq] ++;
 
-          if ((g_queryInfo.superQueryInfo.subscribeKeepProgress)
+          if ((g_queryInfo.superQueryInfo.resubAfterConsume != -1)
                   && (consumed[tsubSeq] >=
                       g_queryInfo.superQueryInfo.resubAfterConsume)) {
               printf("keepProgress:%d, resub super table query: %"PRIu64"\n",
@@ -7361,7 +7386,10 @@ static void *specifiedSubscribe(void *sarg) {
   // start loop to consume result
 
   g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID] = 0;
-  while(1) {
+  while((g_queryInfo.specifiedQueryInfo.endAfterConsume[pThreadInfo->querySeq] == -1)
+          || (g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID] <
+              g_queryInfo.specifiedQueryInfo.endAfterConsume[pThreadInfo->querySeq])) {
+
       if (ASYNC_MODE == g_queryInfo.specifiedQueryInfo.asyncMode) {
         continue;
       }
@@ -7377,7 +7405,7 @@ static void *specifiedSubscribe(void *sarg) {
           }
 
           g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID] ++;
-          if ((g_queryInfo.specifiedQueryInfo.subscribeKeepProgress)
+          if ((g_queryInfo.specifiedQueryInfo.resubAfterConsume[pThreadInfo->querySeq] != -1)
                 && (g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID] >=
                     g_queryInfo.specifiedQueryInfo.resubAfterConsume[pThreadInfo->querySeq])) {
               printf("keepProgress:%d, resub specified query: %"PRIu64"\n",
@@ -7444,12 +7472,12 @@ static int subscribeTestProcess() {
 
   //==== create threads for query for specified table
   if (g_queryInfo.specifiedQueryInfo.sqlCount <= 0) {
-    debugPrint("%s() LN%d, sepcified query sqlCount %"PRIu64".\n",
+    debugPrint("%s() LN%d, sepcified query sqlCount %d.\n",
               __func__, __LINE__,
               g_queryInfo.specifiedQueryInfo.sqlCount);
   } else {
     if (g_queryInfo.specifiedQueryInfo.concurrent <= 0) {
-        errorPrint("%s() LN%d, sepcified query sqlCount %"PRIu64".\n",
+        errorPrint("%s() LN%d, sepcified query sqlCount %d.\n",
               __func__, __LINE__,
               g_queryInfo.specifiedQueryInfo.sqlCount);
         exit(-1);
@@ -7482,7 +7510,7 @@ static int subscribeTestProcess() {
 
   //==== create threads for super table query
   if (g_queryInfo.superQueryInfo.sqlCount <= 0) {
-    debugPrint("%s() LN%d, super table query sqlCount %"PRIu64".\n",
+    debugPrint("%s() LN%d, super table query sqlCount %d.\n",
               __func__, __LINE__,
               g_queryInfo.superQueryInfo.sqlCount);
   } else {

From 889ed47b562aafcc4b08ac870b84cdfeadd20b49 Mon Sep 17 00:00:00 2001
From: Shuduo Sang <sangshuduo@gmail.com>
Date: Sat, 29 May 2021 11:52:36 +0800
Subject: [PATCH 128/128] Hotfix/sangshuduo/td 4406 taosdemo auto create tables
 for develop (#6288)

* cherry-pick from master branch.

* cherry-pick from master branch. c23043c0ced30f7b1f85b0ae65db405e9fc70b5d

Co-authored-by: Shuduo Sang <sdsang@taosdata.com>
---
 src/kit/taosdemo/taosdemo.c | 227 +++++++++++++++++++-----------------
 1 file changed, 121 insertions(+), 106 deletions(-)

diff --git a/src/kit/taosdemo/taosdemo.c b/src/kit/taosdemo/taosdemo.c
index 004ea280c4..ec15a99d14 100644
--- a/src/kit/taosdemo/taosdemo.c
+++ b/src/kit/taosdemo/taosdemo.c
@@ -255,12 +255,13 @@ typedef struct SColumn_S {
 
 typedef struct SSuperTable_S {
   char         sTblName[MAX_TB_NAME_SIZE+1];
+  char         dataSource[MAX_TB_NAME_SIZE+1];  // rand_gen or sample
+  char         childTblPrefix[MAX_TB_NAME_SIZE];
+  char         insertMode[MAX_TB_NAME_SIZE];    // taosc, rest
+  uint16_t     childTblExists;
   int64_t      childTblCount;
-  bool         childTblExists;          // 0: no, 1: yes
   uint64_t     batchCreateTableNum;     // 0: no batch,  > 0: batch table number in one sql
   uint8_t      autoCreateTable;         // 0: create sub table, 1: auto create sub table
-  char         childTblPrefix[MAX_TB_NAME_SIZE];
-  char         dataSource[MAX_TB_NAME_SIZE+1];  // rand_gen or sample
   uint16_t     iface;                   // 0: taosc, 1: rest, 2: stmt
   int64_t      childTblLimit;
   uint64_t     childTblOffset;
@@ -830,7 +831,7 @@ static void parse_args(int argc, char *argv[], SArguments *arguments) {
       if ((argc == i+1)
               || (!isStringNumber(argv[i+1]))) {
         printHelp();
-        errorPrint("%s", "\n\t-q need a number following!\nQuery mode -- 0: SYNC, 1: ASYNC. Default is SYNC.\n");
+        errorPrint("%s", "\n\t-q need a number following!\nQuery mode -- 0: SYNC, not-0: ASYNC. Default is SYNC.\n");
         exit(EXIT_FAILURE);
       }
       arguments->async_mode = atoi(argv[++i]);
@@ -1471,7 +1472,8 @@ static int printfInsertMeta() {
 
       if (PRE_CREATE_SUBTBL == g_Dbs.db[i].superTbls[j].autoCreateTable) {
         printf("      autoCreateTable:   \033[33m%s\033[0m\n",  "no");
-      } else if (AUTO_CREATE_SUBTBL == g_Dbs.db[i].superTbls[j].autoCreateTable) {
+      } else if (AUTO_CREATE_SUBTBL ==
+              g_Dbs.db[i].superTbls[j].autoCreateTable) {
         printf("      autoCreateTable:   \033[33m%s\033[0m\n",  "yes");
       } else {
         printf("      autoCreateTable:   \033[33m%s\033[0m\n",  "error");
@@ -3063,64 +3065,61 @@ static void createChildTables() {
     char tblColsBuf[MAX_SQL_SIZE];
     int len;
 
-  for (int i = 0; i < g_Dbs.dbCount; i++) {
-    if (g_Dbs.use_metric) {
-      if (g_Dbs.db[i].superTblCount > 0) {
-          // with super table
-        for (uint64_t j = 0; j < g_Dbs.db[i].superTblCount; j++) {
-          if ((AUTO_CREATE_SUBTBL == g_Dbs.db[i].superTbls[j].autoCreateTable)
-                || (TBL_ALREADY_EXISTS == g_Dbs.db[i].superTbls[j].childTblExists)) {
-            continue;
-          }
+    for (int i = 0; i < g_Dbs.dbCount; i++) {
+        if (g_Dbs.use_metric) {
+            if (g_Dbs.db[i].superTblCount > 0) {
+                // with super table
+                for (int j = 0; j < g_Dbs.db[i].superTblCount; j++) {
+                    if ((AUTO_CREATE_SUBTBL == g_Dbs.db[i].superTbls[j].autoCreateTable)
+                            || (TBL_ALREADY_EXISTS == g_Dbs.db[i].superTbls[j].childTblExists)) {
+                        continue;
+                    }
+                    verbosePrint("%s() LN%d: %s\n", __func__, __LINE__,
+                          g_Dbs.db[i].superTbls[j].colsOfCreateChildTable);
+                    uint64_t startFrom = 0;
+                    g_totalChildTables += g_Dbs.db[i].superTbls[j].childTblCount;
 
-          verbosePrint("%s() LN%d: %s\n", __func__, __LINE__,
-                  g_Dbs.db[i].superTbls[j].colsOfCreateChildTable);
-          uint64_t tableFrom = 0;
-          g_totalChildTables += g_Dbs.db[i].superTbls[j].childTblCount;
+                    verbosePrint("%s() LN%d: create %"PRId64" child tables from %"PRIu64"\n",
+                            __func__, __LINE__, g_totalChildTables, startFrom);
 
-          verbosePrint("%s() LN%d: create %"PRId64" child tables from %"PRIu64"\n",
-                  __func__, __LINE__, g_totalChildTables, tableFrom);
-          startMultiThreadCreateChildTable(
-                g_Dbs.db[i].superTbls[j].colsOfCreateChildTable,
-                g_Dbs.threadCountByCreateTbl,
-                tableFrom,
-                g_Dbs.db[i].superTbls[j].childTblCount,
-                g_Dbs.db[i].dbName, &(g_Dbs.db[i].superTbls[j]));
+                    startMultiThreadCreateChildTable(
+                            g_Dbs.db[i].superTbls[j].colsOfCreateChildTable,
+                            g_Dbs.threadCountByCreateTbl,
+                            startFrom,
+                            g_Dbs.db[i].superTbls[j].childTblCount,
+                            g_Dbs.db[i].dbName, &(g_Dbs.db[i].superTbls[j]));
+                }
+            }
+        } else {
+            // normal table
+            len = snprintf(tblColsBuf, MAX_SQL_SIZE, "(TS TIMESTAMP");
+            for (int j = 0; j < g_args.num_of_CPR; j++) {
+                if ((strncasecmp(g_args.datatype[j], "BINARY", strlen("BINARY")) == 0)
+                        || (strncasecmp(g_args.datatype[j],
+                                "NCHAR", strlen("NCHAR")) == 0)) {
+                    snprintf(tblColsBuf + len, MAX_SQL_SIZE - len,
+                            ", COL%d %s(%d)", j, g_args.datatype[j], g_args.len_of_binary);
+                } else {
+                    snprintf(tblColsBuf + len, MAX_SQL_SIZE - len,
+                            ", COL%d %s", j, g_args.datatype[j]);
+                }
+                len = strlen(tblColsBuf);
+            }
+
+            snprintf(tblColsBuf + len, MAX_SQL_SIZE - len, ")");
+
+            verbosePrint("%s() LN%d: dbName: %s num of tb: %"PRId64" schema: %s\n",
+                    __func__, __LINE__,
+                    g_Dbs.db[i].dbName, g_args.num_of_tables, tblColsBuf);
+            startMultiThreadCreateChildTable(
+                    tblColsBuf,
+                    g_Dbs.threadCountByCreateTbl,
+                    0,
+                    g_args.num_of_tables,
+                    g_Dbs.db[i].dbName,
+                    NULL);
         }
-      }
-    } else {
-      // normal table
-      len = snprintf(tblColsBuf, MAX_SQL_SIZE, "(TS TIMESTAMP");
-      for (int j = 0; j < g_args.num_of_CPR; j++) {
-          if (g_args.datatype[j]
-                  && ((strncasecmp(g_args.datatype[j],
-                              "BINARY", strlen("BINARY")) == 0)
-                  || (strncasecmp(g_args.datatype[j],
-                      "NCHAR", strlen("NCHAR")) == 0))) {
-              snprintf(tblColsBuf + len, MAX_SQL_SIZE - len,
-                      ", COL%d %s(%d)", j, g_args.datatype[j],
-                      g_args.len_of_binary);
-          } else {
-              snprintf(tblColsBuf + len, MAX_SQL_SIZE - len,
-                      ", COL%d %s", j, g_args.datatype[j]);
-          }
-          len = strlen(tblColsBuf);
-      }
-
-      snprintf(tblColsBuf + len, MAX_SQL_SIZE - len, ")");
-
-      verbosePrint("%s() LN%d: dbName: %s num of tb: %"PRId64" schema: %s\n",
-              __func__, __LINE__,
-              g_Dbs.db[i].dbName, g_args.num_of_tables, tblColsBuf);
-      startMultiThreadCreateChildTable(
-            tblColsBuf,
-            g_Dbs.threadCountByCreateTbl,
-            0,
-            g_args.num_of_tables,
-            g_Dbs.db[i].dbName,
-            NULL);
     }
-  }
 }
 
 /*
@@ -3814,36 +3813,40 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
 
       // dbinfo
       cJSON *stbName = cJSON_GetObjectItem(stbInfo, "name");
-      if (!stbName || stbName->type != cJSON_String || stbName->valuestring == NULL) {
+      if (!stbName || stbName->type != cJSON_String
+              || stbName->valuestring == NULL) {
         errorPrint("%s() LN%d, failed to read json, stb name not found\n",
                 __func__, __LINE__);
         goto PARSE_OVER;
       }
-      tstrncpy(g_Dbs.db[i].superTbls[j].sTblName, stbName->valuestring, MAX_TB_NAME_SIZE);
+      tstrncpy(g_Dbs.db[i].superTbls[j].sTblName, stbName->valuestring,
+              MAX_TB_NAME_SIZE);
 
       cJSON *prefix = cJSON_GetObjectItem(stbInfo, "childtable_prefix");
       if (!prefix || prefix->type != cJSON_String || prefix->valuestring == NULL) {
         printf("ERROR: failed to read json, childtable_prefix not found\n");
         goto PARSE_OVER;
       }
-      tstrncpy(g_Dbs.db[i].superTbls[j].childTblPrefix, prefix->valuestring, MAX_DB_NAME_SIZE);
+      tstrncpy(g_Dbs.db[i].superTbls[j].childTblPrefix, prefix->valuestring,
+              MAX_DB_NAME_SIZE);
 
-      cJSON *autoCreateTbl = cJSON_GetObjectItem(stbInfo, "auto_create_table"); // yes, no, null
+      cJSON *autoCreateTbl = cJSON_GetObjectItem(stbInfo, "auto_create_table");
       if (autoCreateTbl
               && autoCreateTbl->type == cJSON_String
               && autoCreateTbl->valuestring != NULL) {
-        if (0 == strncasecmp(autoCreateTbl->valuestring, "yes", 3)) {
-          g_Dbs.db[i].superTbls[j].autoCreateTable = AUTO_CREATE_SUBTBL;
-        } else if (0 == strncasecmp(autoCreateTbl->valuestring, "no", 2)) {
-          g_Dbs.db[i].superTbls[j].autoCreateTable = PRE_CREATE_SUBTBL;
-        } else {
-          g_Dbs.db[i].superTbls[j].autoCreateTable = PRE_CREATE_SUBTBL;
-        }
+          if ((0 == strncasecmp(autoCreateTbl->valuestring, "yes", 3))
+                  && (TBL_ALREADY_EXISTS != g_Dbs.db[i].superTbls[j].childTblExists)) {
+              g_Dbs.db[i].superTbls[j].autoCreateTable = AUTO_CREATE_SUBTBL;
+          } else if (0 == strncasecmp(autoCreateTbl->valuestring, "no", 2)) {
+              g_Dbs.db[i].superTbls[j].autoCreateTable = PRE_CREATE_SUBTBL;
+          } else {
+              g_Dbs.db[i].superTbls[j].autoCreateTable = PRE_CREATE_SUBTBL;
+          }
       } else if (!autoCreateTbl) {
-        g_Dbs.db[i].superTbls[j].autoCreateTable = PRE_CREATE_SUBTBL;
+          g_Dbs.db[i].superTbls[j].autoCreateTable = PRE_CREATE_SUBTBL;
       } else {
-        printf("ERROR: failed to read json, auto_create_table not found\n");
-        goto PARSE_OVER;
+          printf("ERROR: failed to read json, auto_create_table not found\n");
+          goto PARSE_OVER;
       }
 
       cJSON* batchCreateTbl = cJSON_GetObjectItem(stbInfo, "batch_create_tbl_num");
@@ -3877,6 +3880,10 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
         goto PARSE_OVER;
       }
 
+      if (TBL_ALREADY_EXISTS == g_Dbs.db[i].superTbls[j].childTblExists) {
+          g_Dbs.db[i].superTbls[j].autoCreateTable = PRE_CREATE_SUBTBL;
+      }
+
       cJSON* count = cJSON_GetObjectItem(stbInfo, "childtable_count");
       if (!count || count->type != cJSON_Number || 0 >= count->valueint) {
         errorPrint("%s() LN%d, failed to read json, childtable_count input mistake\n",
@@ -3934,7 +3941,8 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
       cJSON* childTbl_offset = cJSON_GetObjectItem(stbInfo, "childtable_offset");
       if ((childTbl_offset) && (g_Dbs.db[i].drop != true)
           && (g_Dbs.db[i].superTbls[j].childTblExists == TBL_ALREADY_EXISTS)) {
-        if (childTbl_offset->type != cJSON_Number || 0 > childTbl_offset->valueint) {
+        if ((childTbl_offset->type != cJSON_Number)
+                || (0 > childTbl_offset->valueint)) {
             printf("ERROR: failed to read json, childtable_offset\n");
             goto PARSE_OVER;
         }
@@ -3990,7 +3998,8 @@ static bool getMetaFromInsertJsonFile(cJSON* root) {
       }
 
       cJSON *tagsFile = cJSON_GetObjectItem(stbInfo, "tags_file");
-      if (tagsFile && tagsFile->type == cJSON_String && tagsFile->valuestring != NULL) {
+      if ((tagsFile && tagsFile->type == cJSON_String)
+              && (tagsFile->valuestring != NULL)) {
         tstrncpy(g_Dbs.db[i].superTbls[j].tagsFile,
                 tagsFile->valuestring, MAX_FILE_NAME_LEN);
         if (0 == g_Dbs.db[i].superTbls[j].tagsFile[0]) {
@@ -4946,26 +4955,29 @@ static int32_t execInsert(threadInfo *pThreadInfo, uint32_t k)
 static void getTableName(char *pTblName,
         threadInfo* pThreadInfo, uint64_t tableSeq)
 {
-  SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
-  if ((superTblInfo)
-          && (AUTO_CREATE_SUBTBL != superTblInfo->autoCreateTable)) {
-    if (superTblInfo->childTblLimit > 0) {
-        snprintf(pTblName, TSDB_TABLE_NAME_LEN, "%s",
-            superTblInfo->childTblName +
-            (tableSeq - superTblInfo->childTblOffset) * TSDB_TABLE_NAME_LEN);
+    SSuperTable* superTblInfo = pThreadInfo->superTblInfo;
+    if (superTblInfo) {
+        if (AUTO_CREATE_SUBTBL != superTblInfo->autoCreateTable) {
+            if (superTblInfo->childTblLimit > 0) {
+                snprintf(pTblName, TSDB_TABLE_NAME_LEN, "%s",
+                        superTblInfo->childTblName +
+                        (tableSeq - superTblInfo->childTblOffset) * TSDB_TABLE_NAME_LEN);
+            } else {
+                verbosePrint("[%d] %s() LN%d: from=%"PRIu64" count=%"PRId64" seq=%"PRIu64"\n",
+                        pThreadInfo->threadID, __func__, __LINE__,
+                        pThreadInfo->start_table_from,
+                        pThreadInfo->ntables, tableSeq);
+                snprintf(pTblName, TSDB_TABLE_NAME_LEN, "%s",
+                        superTblInfo->childTblName + tableSeq * TSDB_TABLE_NAME_LEN);
+            }
+        } else {
+            snprintf(pTblName, TSDB_TABLE_NAME_LEN, "%s%"PRIu64"",
+                    superTblInfo->childTblPrefix, tableSeq);
+        }
     } else {
-
-        verbosePrint("[%d] %s() LN%d: from=%"PRIu64" count=%"PRId64" seq=%"PRIu64"\n",
-                pThreadInfo->threadID, __func__, __LINE__,
-                pThreadInfo->start_table_from,
-                pThreadInfo->ntables, tableSeq);
-        snprintf(pTblName, TSDB_TABLE_NAME_LEN, "%s",
-            superTblInfo->childTblName + tableSeq * TSDB_TABLE_NAME_LEN);
+        snprintf(pTblName, TSDB_TABLE_NAME_LEN, "%s%"PRIu64"",
+                g_args.tb_prefix, tableSeq);
     }
-  } else {
-    snprintf(pTblName, TSDB_TABLE_NAME_LEN, "%s%"PRIu64"",
-        g_args.tb_prefix, tableSeq);
-  }
 }
 
 static int32_t generateDataTailWithoutStb(
@@ -6753,7 +6765,6 @@ static int insertTestProcess() {
     }
   }
 
-  // taosMsleep(1000);
   // create sub threads for inserting data
   //start = taosGetTimestampMs();
   for (int i = 0; i < g_Dbs.dbCount; i++) {
@@ -7397,11 +7408,14 @@ static void *specifiedSubscribe(void *sarg) {
       g_queryInfo.specifiedQueryInfo.res[pThreadInfo->threadID] = taos_consume(
               g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->threadID]);
       if (g_queryInfo.specifiedQueryInfo.res[pThreadInfo->threadID]) {
-          if (g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq][0] != 0) {
+          if (g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq][0]
+                  != 0) {
               sprintf(pThreadInfo->filePath, "%s-%d",
                       g_queryInfo.specifiedQueryInfo.result[pThreadInfo->querySeq],
                       pThreadInfo->threadID);
-              fetchResult(g_queryInfo.specifiedQueryInfo.res[pThreadInfo->threadID], pThreadInfo);
+              fetchResult(
+                      g_queryInfo.specifiedQueryInfo.res[pThreadInfo->threadID],
+                      pThreadInfo);
           }
 
           g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID] ++;
@@ -7414,16 +7428,17 @@ static void *specifiedSubscribe(void *sarg) {
               g_queryInfo.specifiedQueryInfo.consumed[pThreadInfo->threadID] = 0;
               taos_unsubscribe(g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->threadID],
                       g_queryInfo.specifiedQueryInfo.subscribeKeepProgress);
-              g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->threadID] = subscribeImpl(
-                      SPECIFIED_CLASS,
-                      pThreadInfo,
-                      g_queryInfo.specifiedQueryInfo.sql[pThreadInfo->querySeq],
-                      g_queryInfo.specifiedQueryInfo.topic[pThreadInfo->threadID],
-                      g_queryInfo.specifiedQueryInfo.subscribeRestart,
-                      g_queryInfo.specifiedQueryInfo.subscribeInterval);
+              g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->threadID] =
+                  subscribeImpl(
+                          SPECIFIED_CLASS,
+                          pThreadInfo,
+                          g_queryInfo.specifiedQueryInfo.sql[pThreadInfo->querySeq],
+                          g_queryInfo.specifiedQueryInfo.topic[pThreadInfo->threadID],
+                          g_queryInfo.specifiedQueryInfo.subscribeRestart,
+                          g_queryInfo.specifiedQueryInfo.subscribeInterval);
               if (NULL == g_queryInfo.specifiedQueryInfo.tsub[pThreadInfo->threadID]) {
-                taos_close(pThreadInfo->taos);
-                return NULL;
+                  taos_close(pThreadInfo->taos);
+                  return NULL;
               }
           }
       }
@@ -7636,7 +7651,7 @@ static void setParaFromArg(){
   g_Dbs.threadCountByCreateTbl = g_args.num_of_threads;
 
   g_Dbs.dbCount = 1;
-  g_Dbs.db[0].drop = 1;
+  g_Dbs.db[0].drop = true;
 
   tstrncpy(g_Dbs.db[0].dbName, g_args.database, MAX_DB_NAME_SIZE);
   g_Dbs.db[0].dbCfg.replica = g_args.replica;