diff --git a/packaging/cfg/taos.cfg b/packaging/cfg/taos.cfg
index 5ac0e39dcc134260945d5328ac8035559574f277..a1178e2eefd6c4e6a4433a451d2e4e865a39cfe6 100644
--- a/packaging/cfg/taos.cfg
+++ b/packaging/cfg/taos.cfg
@@ -34,7 +34,7 @@
 # 1.0: all CPU cores are available for query processing [default].
 # 0.5: only half of the CPU cores are available for query.
 # 0.0: only one core available.
-# tsRatioOfQueryCores       1.0
+# ratioOfQueryCores        1.0
 
 # the last_row/first/last aggregator will not change the original column name in the result fields
 # keepColumnName            0
diff --git a/src/client/src/tscAsync.c b/src/client/src/tscAsync.c
index 797804252d373d05eea3aff6bc4cd0550e9fb3b6..7d5b76cc2b3be68ae751e61b4b6c9870120c7d66 100644
--- a/src/client/src/tscAsync.c
+++ b/src/client/src/tscAsync.c
@@ -281,7 +281,7 @@ static void tscAsyncResultCallback(SSchedMsg *pMsg) {
   }
 
   assert(pSql->res.code != TSDB_CODE_SUCCESS);
-  tscError("%p invoke user specified function due to error occured, code:%s", pSql, tstrerror(pSql->res.code));
+  tscError("%p invoke user specified function due to error occurred, code:%s", pSql, tstrerror(pSql->res.code));
 
   SSqlRes *pRes = &pSql->res;
   if (pSql->fp == NULL || pSql->fetchFp == NULL){
@@ -333,7 +333,7 @@ void tscTableMetaCallBack(void *param, TAOS_RES *res, int code) {
       code = tscGetTableMeta(pSql, pTableMetaInfo);
       assert(code == TSDB_CODE_TSC_ACTION_IN_PROGRESS || code == TSDB_CODE_SUCCESS);
 
-      if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {        
+      if (code == TSDB_CODE_TSC_ACTION_IN_PROGRESS) {
         taosReleaseRef(tscObjRef, pSql->self);
         return;
       }
diff --git a/src/client/src/tscLocalMerge.c b/src/client/src/tscLocalMerge.c
index da350197d408bf8e2b3c7aaf9f5ebf17894c86a5..23fb0ab67cded77ff737fac4246343486e80eb95 100644
--- a/src/client/src/tscLocalMerge.c
+++ b/src/client/src/tscLocalMerge.c
@@ -86,7 +86,6 @@ static void tscInitSqlContext(SSqlCmd *pCmd, SLocalMerger *pReducer, tOrderDescr
     pCtx->outputBytes = pExpr->resBytes;
     pCtx->outputType = pExpr->resType;
 
-    pCtx->startOffset = 0;
     pCtx->size = 1;
     pCtx->hasNull = true;
     pCtx->currentStage = MERGE_STAGE;
diff --git a/src/client/src/tscSQLParser.c b/src/client/src/tscSQLParser.c
index 3b248a6281f7049076705be624139d2f8e34bbd9..27222b1daab36c3079fcaa9f499f9ca8dddd05d1 100644
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
@@ -2981,7 +2981,6 @@ int32_t parseGroupbyClause(SQueryInfo* pQueryInfo, SArray* pList, SSqlCmd* pCmd)
 
   STableMeta* pTableMeta = NULL;
   SSchema*    pSchema = NULL;
-//  SSchema     s = tGetTbnameColumnSchema();
 
   int32_t tableIndex = COLUMN_INDEX_INITIAL_VAL;
 
@@ -4748,7 +4747,7 @@ static void setDefaultOrderInfo(SQueryInfo* pQueryInfo) {
 int32_t parseOrderbyClause(SSqlCmd* pCmd, SQueryInfo* pQueryInfo, SQuerySQL* pQuerySql, SSchema* pSchema) {
   const char* msg0 = "only support order by primary timestamp";
   const char* msg1 = "invalid column name";
-  const char* msg2 = "only support order by primary timestamp or first tag in groupby clause allowed";
+  const char* msg2 = "order by primary timestamp or first tag in groupby clause allowed";
   const char* msg3 = "invalid column in order by clause, only primary timestamp or first tag in groupby clause allowed";
 
   setDefaultOrderInfo(pQueryInfo);
diff --git a/src/client/src/tscServer.c b/src/client/src/tscServer.c
index eeea513c913dde6102502d7f392bbd61f5bf344d..6328c67940a6ea50239491ef89179914fd26e1b7 100644
--- a/src/client/src/tscServer.c
+++ b/src/client/src/tscServer.c
@@ -451,7 +451,7 @@ int doProcessSql(SSqlObj *pSql) {
   
   if (pRes->code != TSDB_CODE_SUCCESS) {
     tscAsyncResultOnError(pSql);
-    return pRes->code;
+    return TSDB_CODE_SUCCESS;
   }
 
   int32_t code = tscSendMsgToServer(pSql);
@@ -460,7 +460,7 @@ int doProcessSql(SSqlObj *pSql) {
   if (code != TSDB_CODE_SUCCESS) {
     pRes->code = code;
     tscAsyncResultOnError(pSql);
-    return code;
+    return  TSDB_CODE_SUCCESS;
   }
   
   return TSDB_CODE_SUCCESS;
@@ -770,6 +770,7 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
       char n[TSDB_TABLE_FNAME_LEN] = {0};
       tNameExtractFullName(&pTableMetaInfo->name, n);
 
+
       tscError("%p tid:%d uid:%" PRIu64" id:%s, column index out of range, numOfColumns:%d, index:%d, column name:%s",
           pSql, pTableMeta->id.tid, pTableMeta->id.uid, n, tscGetNumOfColumns(pTableMeta), pCol->colIndex.columnIndex,
                pColSchema->name);
@@ -813,6 +814,13 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
   for (int32_t i = 0; i < tscSqlExprNumOfExprs(pQueryInfo); ++i) {
     SSqlExpr *pExpr = tscSqlExprGet(pQueryInfo, i);
 
+    // the queried table has been removed and a new table with the same name has already been created already
+    // return error msg
+    if (pExpr->uid != pTableMeta->id.uid) {
+      tscError("%p table has already been destroyed", pSql);
+      return TSDB_CODE_TSC_INVALID_TABLE_NAME;
+    }
+
     if (!tscValidateColumnId(pTableMetaInfo, pExpr->colInfo.colId, pExpr->numOfParams)) {
       tscError("%p table schema is not matched with parsed sql", pSql);
       return TSDB_CODE_TSC_INVALID_SQL;
@@ -856,6 +864,13 @@ int tscBuildQueryMsg(SSqlObj *pSql, SSqlInfo *pInfo) {
       SInternalField* pField = tscFieldInfoGetInternalField(&pQueryInfo->fieldsInfo, i);
       SSqlExpr *pExpr = pField->pSqlExpr;
       if (pExpr != NULL) {
+        // the queried table has been removed and a new table with the same name has already been created already
+        // return error msg
+        if (pExpr->uid != pTableMeta->id.uid) {
+          tscError("%p table has already been destroyed", pSql);
+          return TSDB_CODE_TSC_INVALID_TABLE_NAME;
+        }
+
         if (!tscValidateColumnId(pTableMetaInfo, pExpr->colInfo.colId, pExpr->numOfParams)) {
           tscError("%p table schema is not matched with parsed sql", pSql);
           return TSDB_CODE_TSC_INVALID_SQL;
diff --git a/src/client/src/tscSql.c b/src/client/src/tscSql.c
index 8a240accecc904675bd305c1966891bbfc62916a..bc2c42cf79eb8f2be91f21ce6fc938dd32e84992 100644
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
@@ -696,7 +696,7 @@ static void tscKillSTableQuery(SSqlObj *pSql) {
     }
 
     tscAsyncResultOnError(pSubObj);
-    taosReleaseRef(tscObjRef, pSubObj->self);
+    // taosRelekaseRef(tscObjRef, pSubObj->self);
   }
 
   if (pSql->subState.numOfSub <= 0) {
diff --git a/src/client/src/tscSubquery.c b/src/client/src/tscSubquery.c
index e7f6c7e08286d7970ab112d1c7afc314b631fa79..41cfb8144226ab60cd6e30fbdcaac9ed5ebbf9e5 100644
--- a/src/client/src/tscSubquery.c
+++ b/src/client/src/tscSubquery.c
@@ -1888,14 +1888,31 @@ void doAppendData(SInterResult* pInterResult, TAOS_ROW row, int32_t numOfCols, S
   }
 }
 
+static void destroySup(SFirstRoundQuerySup* pSup) {
+  taosArrayDestroyEx(pSup->pResult, freeInterResult);
+  taosArrayDestroy(pSup->pColsInfo);
+  tfree(pSup);
+}
+
 void tscFirstRoundRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
   SSqlObj* pSql = (SSqlObj*)tres;
   SSqlRes* pRes = &pSql->res;
 
   SFirstRoundQuerySup* pSup = param;
-  SQueryInfo*          pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
 
-  if (numOfRows > 0) {
+  SSqlObj*     pParent = pSup->pParent;
+  SQueryInfo*  pQueryInfo = tscGetQueryInfoDetail(&pSql->cmd, 0);
+
+  int32_t code = taos_errno(pSql);
+  if (code != TSDB_CODE_SUCCESS) {
+    destroySup(pSup);
+    taos_free_result(pSql);
+    pParent->res.code = code;
+    tscAsyncResultOnError(pParent);
+    return;
+  }
+
+  if (numOfRows > 0) {  // the number is not correct for group by column in super table query
     TAOS_ROW row = NULL;
     int32_t  numOfCols = taos_field_count(tres);
 
@@ -1905,6 +1922,7 @@ void tscFirstRoundRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
 
       while ((row = taos_fetch_row(tres)) != NULL) {
         doAppendData(&interResult, row, numOfCols, pQueryInfo);
+        pSup->numOfRows += 1;
       }
     } else {  // tagLen > 0
       char* p = calloc(1, pSup->tagLen);
@@ -1916,7 +1934,9 @@ void tscFirstRoundRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
         int32_t offset = 0;
         for (int32_t i = 0; i < numOfCols && offset < pSup->tagLen; ++i) {
           SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, i);
-          if (TSDB_COL_IS_TAG(pExpr->colInfo.flag)) {
+
+          // tag or group by column
+          if (TSDB_COL_IS_TAG(pExpr->colInfo.flag) || pExpr->functionId == TSDB_FUNC_PRJ) {
             memcpy(p + offset, row[i], length[i]);
             offset += pExpr->resBytes;
           }
@@ -1945,20 +1965,20 @@ void tscFirstRoundRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
           taosArrayPush(pSup->pResult, &interResult);
           doAppendData(&interResult, row, numOfCols, pQueryInfo);
         }
+
+        pSup->numOfRows += 1;
       }
 
       tfree(p);
     }
   }
 
-  pSup->numOfRows += numOfRows;
   if (!pRes->completed) {
     taos_fetch_rows_a(tres, tscFirstRoundRetrieveCallback, param);
     return;
   }
 
   // set the parameters for the second round query process
-  SSqlObj    *pParent = pSup->pParent;
   SSqlCmd    *pPCmd   = &pParent->cmd;
   SQueryInfo *pQueryInfo1 = tscGetQueryInfoDetail(pPCmd, 0);
 
@@ -1984,9 +2004,19 @@ void tscFirstRoundRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
 }
 
 void tscFirstRoundCallback(void* param, TAOS_RES* tres, int code) {
-  int32_t c = taos_errno(tres);
+  SFirstRoundQuerySup* pSup = (SFirstRoundQuerySup*) param;
+
+  SSqlObj* pSql = (SSqlObj*) tres;
+  int32_t c = taos_errno(pSql);
+
   if (c != TSDB_CODE_SUCCESS) {
-    // TODO HANDLE ERROR
+    SSqlObj* parent = pSup->pParent;
+
+    destroySup(pSup);
+    taos_free_result(pSql);
+    parent->res.code = code;
+    tscAsyncResultOnError(parent);
+    return;
   }
 
   taos_fetch_rows_a(tres, tscFirstRoundRetrieveCallback, param);
@@ -2020,13 +2050,13 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
     pNewQueryInfo->groupbyExpr.columnInfo = taosArrayDup(pQueryInfo->groupbyExpr.columnInfo);
     if (pNewQueryInfo->groupbyExpr.columnInfo == NULL) {
       terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
-//      goto _error;
+      goto _error;
     }
   }
 
   if (tscTagCondCopy(&pNewQueryInfo->tagCond, &pQueryInfo->tagCond) != 0) {
     terrno = TSDB_CODE_TSC_OUT_OF_MEMORY;
-//    goto _error;
+    goto _error;
   }
 
   pNewQueryInfo->interval = pQueryInfo->interval;
@@ -2037,7 +2067,6 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
   int32_t numOfExprs = (int32_t) tscSqlExprNumOfExprs(pQueryInfo);
 
   int32_t index = 0;
-  int32_t numOfTags = 0;
   for(int32_t i = 0; i < numOfExprs; ++i) {
     SSqlExpr* pExpr = tscSqlExprGet(pQueryInfo, i);
     if (pExpr->functionId == TSDB_FUNC_TS && pQueryInfo->interval.interval > 0) {
@@ -2070,7 +2099,25 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
 
       SSqlExpr* p = tscAddFuncInSelectClause(pNewQueryInfo, index++, TSDB_FUNC_TAG, &colIndex, schema, TSDB_COL_TAG);
       p->resColId = pExpr->resColId;
-      numOfTags += 1;
+    } else if (pExpr->functionId == TSDB_FUNC_PRJ) {
+      int32_t num = (int32_t) taosArrayGetSize(pNewQueryInfo->groupbyExpr.columnInfo);
+      for(int32_t k = 0; k < num; ++k) {
+        SColIndex* pIndex = taosArrayGet(pNewQueryInfo->groupbyExpr.columnInfo, k);
+        if (pExpr->colInfo.colId == pIndex->colId) {
+          pSup->tagLen += pExpr->resBytes;
+          taosArrayPush(pSup->pColsInfo, &pExpr->resColId);
+
+          SColumnIndex colIndex = {.tableIndex = 0, .columnIndex = pIndex->colIndex};
+          SSchema* schema = tscGetColumnSchemaById(pTableMetaInfo1->pTableMeta, pExpr->colInfo.colId);
+
+          //doLimitOutputNormalColOfGroupby
+          SSqlExpr* p = tscAddFuncInSelectClause(pNewQueryInfo, index++, TSDB_FUNC_PRJ, &colIndex, schema, TSDB_COL_NORMAL);
+          p->numOfParams = 1;
+          p->param[0].i64 = 1;
+          p->param[0].nType = TSDB_DATA_TYPE_INT;
+          p->resColId = pExpr->resColId;  // update the result column id
+        }
+      }
     }
   }
 
@@ -2087,6 +2134,13 @@ int32_t tscHandleFirstRoundStableQuery(SSqlObj *pSql) {
 
   tscHandleMasterSTableQuery(pNew);
   return TSDB_CODE_SUCCESS;
+
+  _error:
+  destroySup(pSup);
+  taos_free_result(pNew);
+  pSql->res.code = terrno;
+  tscAsyncResultOnError(pSql);
+  return terrno;
 }
 
 int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
@@ -2128,7 +2182,7 @@ int32_t tscHandleMasterSTableQuery(SSqlObj *pSql) {
     tfree(pMemoryBuf);
     return ret;
   }
-  
+
   tscDebug("%p retrieved query data from %d vnode(s)", pSql, pState->numOfSub);
   pSql->pSubs = calloc(pState->numOfSub, POINTER_BYTES);
   if (pSql->pSubs == NULL) {
@@ -2308,7 +2362,7 @@ static int32_t tscReissueSubquery(SRetrieveSupport *oriTrs, SSqlObj *pSql, int32
     taos_free_result(pSql);
     return ret;
   } else {    
-    pSql->pSubs[trsupport->subqueryIndex] = pSql;
+    pParentSql->pSubs[trsupport->subqueryIndex] = pSql;
     tscFreeRetrieveSup(pNew);
     taos_free_result(pNew);
     return ret;
diff --git a/src/client/tests/cliTest.cpp b/src/client/tests/cliTest.cpp
index 5cfe61d92a1ea36cc41585e314e907a10ea9ff59..30f248b5418b54b1be26dfcf15348b03fd70af4d 100644
--- a/src/client/tests/cliTest.cpp
+++ b/src/client/tests/cliTest.cpp
@@ -57,7 +57,7 @@ void stmtInsertTest() {
   v.ts = start_ts + 20;
   v.k = 123;
 
-  char* str = "abc";
+  char str[] = "abc";
   uintptr_t len = strlen(str);
 
   v.a = str;
@@ -65,7 +65,7 @@ void stmtInsertTest() {
   params[2].buffer_length = len;
   params[2].buffer = str;
 
-  char* nstr = "999";
+  char nstr[] = "999";
   uintptr_t len1 = strlen(nstr);
 
   v.b = nstr;
@@ -84,18 +84,18 @@ void stmtInsertTest() {
   v.ts = start_ts + 30;
   v.k = 911;
 
-  str = "92";
-  len = strlen(str);
+  char str1[] = "92";
+  len = strlen(str1);
 
   params[2].length = &len;
   params[2].buffer_length = len;
-  params[2].buffer = str;
+  params[2].buffer = str1;
 
-  nstr = "1920";
-  len1 = strlen(nstr);
+  char nstr1[] = "1920";
+  len1 = strlen(nstr1);
 
   params[3].buffer_length = len1;
-  params[3].buffer = nstr;
+  params[3].buffer = nstr1;
   params[3].length = &len1;
 
   taos_stmt_bind_param(stmt, params);
@@ -103,7 +103,7 @@ void stmtInsertTest() {
 
   ret = taos_stmt_execute(stmt);
   if (ret != 0) {
-    printf("%p\n", ret);
+    printf("%d\n", ret);
     printf("\033[31mfailed to execute insert statement.\033[0m\n");
     return;
   }
diff --git a/src/cq/src/cqMain.c b/src/cq/src/cqMain.c
index 0dc330091157ddf74d620969e3977d89b7c73859..fb0c1508cb051c577fed9bde534d55e297822fe2 100644
--- a/src/cq/src/cqMain.c
+++ b/src/cq/src/cqMain.c
@@ -97,7 +97,7 @@ static void freeSCqContext(void *handle) {
   }
   SCqContext *pContext = handle;
   pthread_mutex_destroy(&pContext->mutex);
-    
+
   taosTmrCleanUp(pContext->tmrCtrl);
   pContext->tmrCtrl = NULL;
   cDebug("vgId:%d, CQ is closed", pContext->vgId);
@@ -203,7 +203,7 @@ void cqClose(void *handle) {
   pContext->delete = 1;
   int32_t hasCq = 0;
   int32_t existLoop = 0;
-  
+
   // stop all CQs
   cqStop(pContext);
 
@@ -223,7 +223,7 @@ void cqClose(void *handle) {
       if (pContext->pHead == NULL) {
         existLoop = 1;
       }
-    } else {      
+    } else {
       pthread_mutex_unlock(&pContext->mutex);
       break;
     }
@@ -267,6 +267,7 @@ void cqStop(void *handle) {
   if (tsEnableStream == 0) {
     return;
   }
+
   SCqContext *pContext = handle;
   cDebug("vgId:%d, stop all CQs", pContext->vgId);
   if (pContext->dbConn == NULL || pContext->master == 0) return;
diff --git a/src/query/inc/qAggMain.h b/src/query/inc/qAggMain.h
index dbdada8952c82ae5ef7d703966f37432a593f7b9..7122f63593c64a6bffd6f3d53cd8ef21eca800ff 100644
--- a/src/query/inc/qAggMain.h
+++ b/src/query/inc/qAggMain.h
@@ -84,7 +84,7 @@ extern "C" {
 #define TSDB_FUNCSTATE_SO           0x1u    // single output
 #define TSDB_FUNCSTATE_MO           0x2u    // dynamic number of output, not multinumber of output e.g., TOP/BOTTOM
 #define TSDB_FUNCSTATE_STREAM       0x4u    // function avail for stream
-#define TSDB_FUNCSTATE_STABLE       0x8u    // function avail for metric
+#define TSDB_FUNCSTATE_STABLE       0x8u    // function avail for super table
 #define TSDB_FUNCSTATE_OF           0x10u   // outer forward
 #define TSDB_FUNCSTATE_NEED_TS      0x20u   // timestamp is required during query processing
 #define TSDB_FUNCSTATE_SELECTIVITY  0x40u   // selectivity functions, can exists along with tag columns
@@ -166,9 +166,8 @@ typedef struct SExtTagsInfo {
 
 // sql function runtime context
 typedef struct SQLFunctionCtx {
-  int32_t      startOffset;  // todo remove it
   int32_t      size;      // number of rows
-  void *       pInput;    //
+  void *       pInput;    // input data buffer
   uint32_t     order;     // asc|desc
   int16_t      inputType;
   int16_t      inputBytes;
@@ -184,7 +183,7 @@ typedef struct SQLFunctionCtx {
   uint8_t      currentStage;  // record current running step, default: 0
   int64_t      startTs;       // timestamp range of current query when function is executed on a specific data block
   int32_t      numOfParams;
-  tVariant     param[4];      // input parameter, e.g., top(k, 20), the number of results for top query is kept in param */
+  tVariant     param[4];      // input parameter, e.g., top(k, 20), the number of results for top query is kept in param
   int64_t     *ptsList;       // corresponding timestamp array list
   void        *ptsOutputBuf;  // corresponding output buffer for timestamp of each result, e.g., top/bottom*/
   SQLPreAggVal preAggVals;
@@ -228,7 +227,7 @@ int32_t getResultDataInfo(int32_t dataType, int32_t dataBytes, int32_t functionI
 #define IS_SINGLEOUTPUT(x)        (((x)&TSDB_FUNCSTATE_SO) != 0)
 #define IS_OUTER_FORWARD(x)       (((x)&TSDB_FUNCSTATE_OF) != 0)
 
-/* determine the real data need to calculated the result */
+// determine the real data need to calculated the result
 enum {
   BLK_DATA_NO_NEEDED     = 0x0,
   BLK_DATA_STATIS_NEEDED = 0x1,
diff --git a/src/query/inc/qExecutor.h b/src/query/inc/qExecutor.h
index 80068588f719816d847f14bcaad714e107958601..ec1261da0a45ad24985ebf51b9b16c2acfad7709 100644
--- a/src/query/inc/qExecutor.h
+++ b/src/query/inc/qExecutor.h
@@ -33,6 +33,36 @@ struct SColumnFilterElem;
 typedef bool (*__filter_func_t)(struct SColumnFilterElem* pFilter, const char* val1, const char* val2, int16_t type);
 typedef int32_t (*__block_search_fn_t)(char* data, int32_t num, int64_t key, int32_t order);
 
+#define IS_QUERY_KILLED(_q) ((_q)->code == TSDB_CODE_TSC_QUERY_CANCELLED)
+#define Q_STATUS_EQUAL(p, s)  (((p) & (s)) != 0u)
+#define QUERY_IS_ASC_QUERY(q) (GET_FORWARD_DIRECTION_FACTOR((q)->order.order) == QUERY_ASC_FORWARD_STEP)
+
+#define SET_STABLE_QUERY_OVER(_q) ((_q)->tableIndex = (int32_t)((_q)->tableqinfoGroupInfo.numOfTables))
+#define IS_STASBLE_QUERY_OVER(_q) ((_q)->tableIndex >= (int32_t)((_q)->tableqinfoGroupInfo.numOfTables))
+
+#define GET_TABLEGROUP(q, _index)   ((SArray*) taosArrayGetP((q)->tableqinfoGroupInfo.pGroupList, (_index)))
+
+enum {
+  // when query starts to execute, this status will set
+      QUERY_NOT_COMPLETED = 0x1u,
+
+  /* result output buffer is full, current query is paused.
+   * this status is only exist in group-by clause and diff/add/division/multiply/ query.
+   */
+      QUERY_RESBUF_FULL = 0x2u,
+
+  /* query is over
+   * 1. this status is used in one row result query process, e.g., count/sum/first/last/ avg...etc.
+   * 2. when all data within queried time window, it is also denoted as query_completed
+   */
+      QUERY_COMPLETED = 0x4u,
+
+  /* when the result is not completed return to client, this status will be
+   * usually used in case of interval query with interpolation option
+   */
+      QUERY_OVER = 0x8u,
+};
+
 typedef struct SResultRowPool {
   int32_t elemSize;
   int32_t blockSize;
@@ -66,7 +96,8 @@ typedef struct SResultRow {
 } SResultRow;
 
 typedef struct SGroupResInfo {
-  int32_t rowId;
+  int32_t totalGroup;
+  int32_t currentGroup;
   int32_t index;
   SArray* pRows;      // SArray<SResultRow*>
 } SGroupResInfo;
@@ -112,7 +143,7 @@ typedef struct STableQueryInfo {
   STimeWindow win;
   STSCursor   cur;
   void*       pTable;         // for retrieve the page id list
-  SResultRowInfo windowResInfo;
+  SResultRowInfo resInfo;
 } STableQueryInfo;
 
 typedef struct SQueryCostInfo {
@@ -193,7 +224,7 @@ typedef struct SQueryRuntimeEnv {
   uint16_t*            offset;
   uint16_t             scanFlag;         // denotes reversed scan of data or not
   SFillInfo*           pFillInfo;
-  SResultRowInfo       windowResInfo;
+  SResultRowInfo       resultRowInfo;
 
   SQueryCostInfo       summary;
   void*                pQueryHandle;
@@ -204,7 +235,8 @@ typedef struct SQueryRuntimeEnv {
   bool                 hasTagResults;    // if there are tag values in final result or not
   bool                 timeWindowInterpo;// if the time window start/end required interpolation
   bool                 queryWindowIdentical; // all query time windows are identical for all tables in one group
-  bool                 queryBlockDist;    // if query data block distribution  
+  bool                 queryBlockDist;    // if query data block distribution
+  bool                 stabledev;        // super table stddev query
   int32_t              interBufSize;     // intermediate buffer sizse
   int32_t              prevGroupId;      // previous executed group id
   SDiskbasedResultBuf* pResultBuf;       // query result buffer based on blocked-wised disk file
@@ -257,4 +289,51 @@ typedef struct SQInfo {
   char*            sql;         // query sql string
 } SQInfo;
 
+typedef struct SQueryParam {
+  char            *sql;
+  char            *tagCond;
+  char            *tbnameCond;
+  char            *prevResult;
+  SArray          *pTableIdList;
+  SSqlFuncMsg    **pExprMsg;
+  SSqlFuncMsg    **pSecExprMsg;
+  SExprInfo       *pExprs;
+  SExprInfo       *pSecExprs;
+
+  SColIndex       *pGroupColIndex;
+  SColumnInfo     *pTagColumnInfo;
+  SSqlGroupbyExpr *pGroupbyExpr;
+} SQueryParam;
+
+void freeParam(SQueryParam *param);
+int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SQueryParam* param);
+int32_t createQueryFuncExprFromMsg(SQueryTableMsg *pQueryMsg, int32_t numOfOutput, SExprInfo **pExprInfo, SSqlFuncMsg **pExprMsg,
+                                   SColumnInfo* pTagCols);
+SSqlGroupbyExpr *createGroupbyExprFromMsg(SQueryTableMsg *pQueryMsg, SColIndex *pColIndex, int32_t *code);
+SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SSqlGroupbyExpr *pGroupbyExpr, SExprInfo *pExprs,
+                        SExprInfo *pSecExprs, STableGroupInfo *pTableGroupInfo, SColumnInfo* pTagCols, bool stableQuery, char* sql);
+int32_t initQInfo(SQueryTableMsg *pQueryMsg, void *tsdb, int32_t vgId, SQInfo *pQInfo, SQueryParam* param, bool isSTable);
+void freeColumnFilterInfo(SColumnFilterInfo* pFilter, int32_t numOfFilters);
+
+bool isQueryKilled(SQInfo *pQInfo);
+int32_t checkForQueryBuf(size_t numOfTables);
+bool doBuildResCheck(SQInfo* pQInfo);
+void setQueryStatus(SQuery *pQuery, int8_t status);
+
+bool onlyQueryTags(SQuery* pQuery);
+void buildTagQueryResult(SQInfo *pQInfo);
+void stableQueryImpl(SQInfo *pQInfo);
+void buildTableBlockDistResult(SQInfo *pQInfo);
+void tableQueryImpl(SQInfo *pQInfo);
+bool isValidQInfo(void *param);
+
+int32_t doDumpQueryResult(SQInfo *pQInfo, char *data);
+
+size_t getResultSize(SQInfo *pQInfo, int64_t *numOfRows);
+void setQueryKilled(SQInfo *pQInfo);
+void queryCostStatis(SQInfo *pQInfo);
+void freeQInfo(SQInfo *pQInfo);
+
+int32_t getMaximumIdleDurationSec();
+
 #endif  // TDENGINE_QUERYEXECUTOR_H
diff --git a/src/query/inc/qUtil.h b/src/query/inc/qUtil.h
index 55311f569444e8b1b8d9f5cd2fe90e37686ead68..d4a0c25886ad63ff5cc3e79cb0a9e84c156197cd 100644
--- a/src/query/inc/qUtil.h
+++ b/src/query/inc/qUtil.h
@@ -85,4 +85,12 @@ void interResToBinary(SBufferWriter* bw, SArray* pRes, int32_t tagLen);
 SArray* interResFromBinary(const char* data, int32_t len);
 void freeInterResult(void* param);
 
+void    initGroupResInfo(SGroupResInfo* pGroupResInfo, SResultRowInfo* pResultInfo, int32_t offset);
+void    cleanupGroupResInfo(SGroupResInfo* pGroupResInfo);
+bool    hasRemainData(SGroupResInfo* pGroupResInfo);
+bool    incNextGroup(SGroupResInfo* pGroupResInfo);
+int32_t getNumOfTotalRes(SGroupResInfo* pGroupResInfo);
+
+int32_t mergeIntoGroupResult(SGroupResInfo* pGroupResInfo, SQInfo *pQInfo);
+
 #endif  // TDENGINE_QUERYUTIL_H
diff --git a/src/query/src/qAggMain.c b/src/query/src/qAggMain.c
index ed66047bbea4df0f2fedea107ef9f63032c3ac2c..fb8b2394f29e6d1a4764b05028489e0da0685876 100644
--- a/src/query/src/qAggMain.c
+++ b/src/query/src/qAggMain.c
@@ -26,10 +26,12 @@
 #include "qTsbuf.h"
 #include "queryLog.h"
 
-#define GET_INPUT_DATA_LIST(x) (((char *)((x)->pInput)) + ((x)->startOffset) * ((x)->inputBytes))
+//#define GET_INPUT_DATA_LIST(x) (((char *)((x)->pInput)) + ((x)->startOffset) * ((x)->inputBytes))
+#define GET_INPUT_DATA_LIST(x) ((char *)((x)->pInput))
 #define GET_INPUT_DATA(x, y) (GET_INPUT_DATA_LIST(x) + (y) * (x)->inputBytes)
 
-#define GET_TS_LIST(x)    ((TSKEY*)&((x)->ptsList[(x)->startOffset]))
+//#define GET_TS_LIST(x)    ((TSKEY*)&((x)->ptsList[(x)->startOffset]))
+#define GET_TS_LIST(x)    ((TSKEY*)((x)->ptsList))
 #define GET_TS_DATA(x, y) (GET_TS_LIST(x)[(y)])
 
 #define GET_TRUE_DATA_TYPE()                          \
@@ -379,11 +381,7 @@ static bool function_setup(SQLFunctionCtx *pCtx) {
 static void function_finalizer(SQLFunctionCtx *pCtx) {
   SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
   if (pResInfo->hasResult != DATA_SET_FLAG) {
-    if (pCtx->outputType == TSDB_DATA_TYPE_BINARY || pCtx->outputType == TSDB_DATA_TYPE_NCHAR) {
-      setVardataNull(pCtx->pOutput, pCtx->outputType);
-    } else {
-      setNull(pCtx->pOutput, pCtx->outputType, pCtx->outputBytes);
-    }
+    setNull(pCtx->pOutput, pCtx->outputType, pCtx->outputBytes);
   }
   
   doFinalizer(pCtx);
@@ -414,10 +412,7 @@ static void count_function(SQLFunctionCtx *pCtx) {
         numOfElem += 1;
       }
     } else {
-      /*
-       * when counting on the primary time stamp column and no statistics data is provided,
-       * simple use the size value
-       */
+      //when counting on the primary time stamp column and no statistics data is presented, use the size value directly.
       numOfElem = pCtx->size;
     }
   }
@@ -944,9 +939,9 @@ static void minMax_function(SQLFunctionCtx *pCtx, char *pOutput, int32_t isMin,
        *
        * The following codes of 3 lines will be removed later.
        */
-      if (index < 0 || index >= pCtx->size + pCtx->startOffset) {
-        index = 0;
-      }
+//      if (index < 0 || index >= pCtx->size + pCtx->startOffset) {
+//        index = 0;
+//      }
 
       // the index is the original position, not the relative position
       key = pCtx->ptsList[index];
@@ -1637,6 +1632,97 @@ static void stddev_dst_function(SQLFunctionCtx *pCtx) {
   memcpy(pCtx->pOutput, GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx)), sizeof(SAvgInfo));
 }
 
+static void stddev_dst_function_f(SQLFunctionCtx *pCtx, int32_t index) {
+  void *pData = GET_INPUT_DATA(pCtx, index);
+  if (pCtx->hasNull && isNull(pData, pCtx->inputType)) {
+    return;
+  }
+
+  // the second stage to calculate standard deviation
+  SStddevdstInfo *pStd = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
+  double *retVal = &pStd->res;
+
+  // all data are null, no need to proceed
+  SArray* resList = (SArray*) pCtx->param[0].pz;
+  if (resList == NULL) {
+    return;
+  }
+
+  // find the correct group average results according to the tag value
+  int32_t len = (int32_t) taosArrayGetSize(resList);
+  assert(len > 0);
+
+  double avg = 0;
+  if (len == 1) {
+    SResPair* p = taosArrayGet(resList, 0);
+    avg = p->avg;
+  } else {  // todo opt performance by using iterator since the timestamp lsit is matched with the output result
+    SResPair* p = bsearch(&pCtx->startTs, resList->pData, len, sizeof(SResPair), tsCompare);
+    assert(p != NULL);
+
+    avg = p->avg;
+  }
+
+  int32_t num = 0;
+  switch (pCtx->inputType) {
+    case TSDB_DATA_TYPE_INT: {
+      for (int32_t i = 0; i < pCtx->size; ++i) {
+        if (pCtx->hasNull && isNull((const char*) (&((int32_t *)pData)[i]), pCtx->inputType)) {
+          continue;
+        }
+        num += 1;
+        *retVal += POW2(((int32_t *)pData)[i] - avg);
+      }
+      break;
+    }
+    case TSDB_DATA_TYPE_FLOAT: {
+      LOOP_STDDEV_IMPL(float, *retVal, pData, pCtx, avg, pCtx->inputType, num);
+      break;
+    }
+    case TSDB_DATA_TYPE_DOUBLE: {
+      LOOP_STDDEV_IMPL(double, *retVal, pData, pCtx, avg, pCtx->inputType, num);
+      break;
+    }
+    case TSDB_DATA_TYPE_TINYINT: {
+      LOOP_STDDEV_IMPL(int8_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
+      break;
+    }
+    case TSDB_DATA_TYPE_UTINYINT: {
+      LOOP_STDDEV_IMPL(int8_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
+      break;
+    }
+    case TSDB_DATA_TYPE_SMALLINT: {
+      LOOP_STDDEV_IMPL(int16_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
+      break;
+    }
+    case TSDB_DATA_TYPE_USMALLINT: {
+      LOOP_STDDEV_IMPL(uint16_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
+      break;
+    }
+    case TSDB_DATA_TYPE_UINT: {
+      LOOP_STDDEV_IMPL(uint32_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
+      break;
+    }
+    case TSDB_DATA_TYPE_BIGINT: {
+      LOOP_STDDEV_IMPL(int64_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
+      break;
+    }
+    case TSDB_DATA_TYPE_UBIGINT: {
+      LOOP_STDDEV_IMPL(uint64_t, *retVal, pData, pCtx, avg, pCtx->inputType, num);
+      break;
+    }
+    default:
+      qError("stddev function not support data type:%d", pCtx->inputType);
+  }
+
+  pStd->num += num;
+  SET_VAL(pCtx, num, 1);
+
+  // copy to the final output buffer for super table
+  memcpy(pCtx->pOutput, GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx)), sizeof(SAvgInfo));
+}
+
+
 static void stddev_dst_merge(SQLFunctionCtx *pCtx) {
   SResultRowCellInfo *pResInfo = GET_RES_INFO(pCtx);
   SStddevdstInfo* pRes = GET_ROWCELL_INTERBUF(pResInfo);
@@ -3489,9 +3575,7 @@ static void arithmetic_function(SQLFunctionCtx *pCtx) {
   SArithmeticSupport *sas = (SArithmeticSupport *)pCtx->param[1].pz;
   
   arithmeticTreeTraverse(sas->pArithExpr->pExpr, pCtx->size, pCtx->pOutput, sas, pCtx->order, getArithColumnData);
-  
   pCtx->pOutput += pCtx->outputBytes * pCtx->size;
-  pCtx->param[1].pz = NULL;
 }
 
 static void arithmetic_function_f(SQLFunctionCtx *pCtx, int32_t index) {
@@ -3979,6 +4063,12 @@ static void interp_function_impl(SQLFunctionCtx *pCtx) {
       } else {
         assignVal(pCtx->pOutput, pCtx->start.ptr, pCtx->outputBytes, pCtx->inputType);
       }
+    } else if (type == TSDB_FILL_NEXT) {
+      if (IS_NUMERIC_TYPE(pCtx->inputType) || pCtx->inputType == TSDB_DATA_TYPE_BOOL) {
+        SET_TYPED_DATA(pCtx->pOutput, pCtx->inputType, pCtx->end.val);
+      } else {
+        assignVal(pCtx->pOutput, pCtx->end.ptr, pCtx->outputBytes, pCtx->inputType);
+      }
     } else if (type == TSDB_FILL_LINEAR) {
       SPoint point1 = {.key = pCtx->start.key, .val = &pCtx->start.val};
       SPoint point2 = {.key = pCtx->end.key, .val = &pCtx->end.val};
@@ -4838,7 +4928,7 @@ SAggFunctionInfo aAggs[] = {{
                               TSDB_FUNCSTATE_SO | TSDB_FUNCSTATE_STABLE,
                               function_setup,
                               stddev_dst_function,
-                              noop2,
+                              stddev_dst_function_f,
                               no_next_step,
                               stddev_dst_finalizer,
                               stddev_dst_merge,
diff --git a/src/query/src/qExecutor.c b/src/query/src/qExecutor.c
index bfca7a63e89cef33c1ce451ed6c9eb2cc4d0e98e..72ae0d566c6437127c5f6b5a255f5a25c3a57d7d 100644
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
@@ -15,7 +15,6 @@
 #include "os.h"
 #include "qFill.h"
 #include "taosmsg.h"
-#include "tcache.h"
 #include "tglobal.h"
 
 #include "exception.h"
@@ -24,11 +23,9 @@
 #include "qExecutor.h"
 #include "qResultbuf.h"
 #include "qUtil.h"
-#include "query.h"
 #include "queryLog.h"
 #include "tlosertree.h"
 #include "ttype.h"
-#include "tcompare.h"
 
 #define MAX_ROWS_PER_RESBUF_PAGE  ((1u<<12) - 1)
 
@@ -36,8 +33,6 @@
  * check if the primary column is load by default, otherwise, the program will
  * forced to load primary column explicitly.
  */
-#define Q_STATUS_EQUAL(p, s)  (((p) & (s)) != 0u)
-#define QUERY_IS_ASC_QUERY(q) (GET_FORWARD_DIRECTION_FACTOR((q)->order.order) == QUERY_ASC_FORWARD_STEP)
 
 #define IS_MASTER_SCAN(runtime)        ((runtime)->scanFlag == MASTER_SCAN)
 #define IS_REVERSE_SCAN(runtime)       ((runtime)->scanFlag == REVERSE_SCAN)
@@ -56,27 +51,6 @@
    (_dst).ekey = (_src).ekey;\
 } while (0)
 
-enum {
-  // when query starts to execute, this status will set
-  QUERY_NOT_COMPLETED = 0x1u,
-
-  /* result output buffer is full, current query is paused.
-   * this status is only exist in group-by clause and diff/add/division/multiply/ query.
-   */
-  QUERY_RESBUF_FULL = 0x2u,
-
-  /* query is over
-   * 1. this status is used in one row result query process, e.g., count/sum/first/last/ avg...etc.
-   * 2. when all data within queried time window, it is also denoted as query_completed
-   */
-  QUERY_COMPLETED = 0x4u,
-
-  /* when the result is not completed return to client, this status will be
-   * usually used in case of interval query with interpolation option
-   */
-  QUERY_OVER = 0x8u,
-};
-
 enum {
   TS_JOIN_TS_EQUAL       = 0,
   TS_JOIN_TS_NOT_EQUALS  = 1,
@@ -134,13 +108,11 @@ static UNUSED_FUNC void* u_realloc(void* p, size_t __size) {
 
 #define CLEAR_QUERY_STATUS(q, st)   ((q)->status &= (~(st)))
 #define GET_NUM_OF_TABLEGROUP(q)    taosArrayGetSize((q)->tableqinfoGroupInfo.pGroupList)
-#define GET_TABLEGROUP(q, _index)   ((SArray*) taosArrayGetP((q)->tableqinfoGroupInfo.pGroupList, (_index)))
 #define QUERY_IS_INTERVAL_QUERY(_q) ((_q)->interval.interval > 0)
 
-static void setQueryStatus(SQuery *pQuery, int8_t status);
 static void finalizeQueryResult(SQueryRuntimeEnv *pRuntimeEnv);
 
-static int32_t getMaximumIdleDurationSec() {
+int32_t getMaximumIdleDurationSec() {
   return tsShellActivityTimer * 2;
 }
 
@@ -181,27 +153,19 @@ static void getNextTimeWindow(SQuery* pQuery, STimeWindow* tw) {
   tw->ekey -= 1;
 }
 
-#define SET_STABLE_QUERY_OVER(_q) ((_q)->tableIndex = (int32_t)((_q)->tableqinfoGroupInfo.numOfTables))
-#define IS_STASBLE_QUERY_OVER(_q) ((_q)->tableIndex >= (int32_t)((_q)->tableqinfoGroupInfo.numOfTables))
-
-// todo move to utility
-static int32_t mergeIntoGroupResultImpl(SGroupResInfo* pGroupResInfo, SArray *pTableList, SQInfo* pQInfo);
-
 static void setResultOutputBuf(SQueryRuntimeEnv *pRuntimeEnv, SResultRow *pResult);
 static void setResultRowOutputBufInitCtx(SQueryRuntimeEnv *pRuntimeEnv, SResultRow *pResult);
 static bool functionNeedToExecute(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx *pCtx, int32_t functionId);
 
 static void setExecParams(SQuery *pQuery, SQLFunctionCtx *pCtx, void* inputData, TSKEY *tsCol, SDataBlockInfo* pBlockInfo,
-                          SDataStatis *pStatis, void *param, int32_t colIndex, int32_t vgId);
+                          SDataStatis *pStatis, SExprInfo* pExprInfo);
 
 static void initCtxOutputBuf(SQueryRuntimeEnv *pRuntimeEnv);
 static void destroyTableQueryInfoImpl(STableQueryInfo *pTableQueryInfo);
 static void resetDefaultResInfoOutputBuf(SQueryRuntimeEnv *pRuntimeEnv);
 static bool hasMainOutput(SQuery *pQuery);
-static void buildTagQueryResult(SQInfo *pQInfo);
 
 static int32_t setTimestampListJoinInfo(SQInfo *pQInfo, STableQueryInfo *pTableQueryInfo);
-static int32_t checkForQueryBuf(size_t numOfTables);
 static void releaseQueryBuf(size_t numOfTables);
 static int32_t binarySearchForKey(char *pValue, int num, TSKEY key, int order);
 static void doRowwiseTimeWindowInterpolation(SQueryRuntimeEnv* pRuntimeEnv, SArray* pDataBlock, TSKEY prevTs, int32_t prevRowIndex, TSKEY curTs, int32_t curRowIndex, TSKEY windowKey, int32_t type);
@@ -296,11 +260,6 @@ void updateNumOfResult(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOfRes) {
   }
 }
 
-static UNUSED_FUNC int32_t getMergeResultGroupId(int32_t groupIndex) {
-  int32_t base = 50000000;
-  return base + (groupIndex * 10000);
-}
-
 bool isGroupbyColumn(SSqlGroupbyExpr *pGroupbyExpr) {
   if (pGroupbyExpr == NULL || pGroupbyExpr->numOfGroupCols == 0) {
     return false;
@@ -321,6 +280,17 @@ bool isGroupbyColumn(SSqlGroupbyExpr *pGroupbyExpr) {
   return false;
 }
 
+bool isStabledev(SQuery* pQuery) {
+  for (int32_t i = 0; i < pQuery->numOfOutput; ++i) {
+    int32_t functId = pQuery->pExpr1[i].base.functionId;
+    if (functId == TSDB_FUNC_STDDEV_DST) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 int16_t getGroupbyColumnType(SQuery *pQuery, SSqlGroupbyExpr *pGroupbyExpr) {
   assert(pGroupbyExpr != NULL);
 
@@ -345,7 +315,7 @@ int16_t getGroupbyColumnType(SQuery *pQuery, SSqlGroupbyExpr *pGroupbyExpr) {
   return type;
 }
 
-bool isSelectivityWithTagsQuery(SQuery *pQuery) {
+static bool isSelectivityWithTagsQuery(SQuery *pQuery) {
   bool    hasTags = false;
   int32_t numOfSelectivity = 0;
 
@@ -368,7 +338,7 @@ bool isSelectivityWithTagsQuery(SQuery *pQuery) {
   return false;
 }
 
-bool isProjQuery(SQuery *pQuery) {
+static bool isProjQuery(SQuery *pQuery) {
   for (int32_t i = 0; i < pQuery->numOfOutput; ++i) {
     int32_t functId = pQuery->pExpr1[i].base.functionId;
     if (functId != TSDB_FUNC_PRJ && functId != TSDB_FUNC_TAGPRJ) {
@@ -379,17 +349,14 @@ bool isProjQuery(SQuery *pQuery) {
   return true;
 }
 
-bool isTsCompQuery(SQuery *pQuery) { return pQuery->pExpr1[0].base.functionId == TSDB_FUNC_TS_COMP; }
-
-static bool limitOperator(SQueryRuntimeEnv* pRuntimeEnv) {
-  SQInfo* pQInfo = GET_QINFO_ADDR(pRuntimeEnv);
-  SQuery* pQuery = pRuntimeEnv->pQuery;
+static bool isTsCompQuery(SQuery *pQuery) { return pQuery->pExpr1[0].base.functionId == TSDB_FUNC_TS_COMP; }
 
+static bool limitOperator(SQuery* pQuery, void* qinfo) {
   if ((pQuery->limit.limit > 0) && (pQuery->rec.total + pQuery->rec.rows > pQuery->limit.limit)) {
     pQuery->rec.rows = pQuery->limit.limit - pQuery->rec.total;
 
     qDebug("QInfo:%p discard remain data due to result limitation, limit:%"PRId64", current return:%" PRId64 ", total:%"PRId64,
-        pQInfo, pQuery->limit.limit, pQuery->rec.rows, pQuery->rec.total + pQuery->rec.rows);
+           qinfo, pQuery->limit.limit, pQuery->rec.rows, pQuery->rec.total + pQuery->rec.rows);
     assert(pQuery->rec.rows >= 0);
     setQueryStatus(pQuery, QUERY_COMPLETED);
     return true;
@@ -643,7 +610,7 @@ static int32_t addNewWindowResultBuf(SResultRow *pWindowRes, SDiskbasedResultBuf
 }
 
 static int32_t setWindowOutputBufByKey(SQueryRuntimeEnv *pRuntimeEnv, SResultRowInfo *pResultRowInfo, STimeWindow *win,
-    bool masterscan, SResultRow** pResult, int64_t groupId) {
+                                       bool masterscan, SResultRow **pResult, int64_t groupId) {
   assert(win->skey <= win->ekey);
   SDiskbasedResultBuf *pResultBuf = pRuntimeEnv->pResultBuf;
 
@@ -826,9 +793,11 @@ static int32_t getNumOfRowsInTimeWindow(SQuery *pQuery, SDataBlockInfo *pDataBlo
   return num;
 }
 
-// TODO decouple the data block and the SQLFunctionCtx
-static void doBlockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, STimeWindow *pWin, int32_t offset, int32_t forwardStep, TSKEY *tsCol, int32_t numOfTotal) {
-  SQuery         *pQuery = pRuntimeEnv->pQuery;
+static char *getDataBlock(SQueryRuntimeEnv *pRuntimeEnv, SArithmeticSupport *sas, int32_t col, int32_t size, SArray *pDataBlock);
+
+static void doBlockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, STimeWindow *pWin, int32_t offset,
+                                      int32_t forwardStep, TSKEY *tsCol, int32_t numOfTotal, SArray *pDataBlock) {
+  SQuery *        pQuery = pRuntimeEnv->pQuery;
   SQLFunctionCtx *pCtx = pRuntimeEnv->pCtx;
 
   bool hasPrev = pCtx[0].preAggVals.isSet;
@@ -836,7 +805,17 @@ static void doBlockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, STimeWindow
   for (int32_t k = 0; k < pQuery->numOfOutput; ++k) {
     pCtx[k].size = forwardStep;
     pCtx[k].startTs = pWin->skey;
-    pCtx[k].startOffset = (QUERY_IS_ASC_QUERY(pQuery)) ? offset : offset - (forwardStep - 1);
+
+    char *dataBlock = getDataBlock(pRuntimeEnv, &pRuntimeEnv->sasArray[k], k, numOfTotal, pDataBlock);
+
+    int32_t pos = (QUERY_IS_ASC_QUERY(pQuery)) ? offset : offset - (forwardStep - 1);
+    if (dataBlock != NULL) {
+      pCtx[k].pInput = (char *)dataBlock + pos * pCtx[k].inputBytes;
+    }
+
+    if (tsCol != NULL) {
+      pCtx[k].ptsList = &tsCol[pos];
+    }
 
     int32_t functionId = pQuery->pExpr1[k].base.functionId;
 
@@ -976,6 +955,7 @@ static void* getDataBlockImpl(SArray* pDataBlock, int32_t colId) {
   return NULL;
 }
 
+// todo refactor
 static char *getDataBlock(SQueryRuntimeEnv *pRuntimeEnv, SArithmeticSupport *sas, int32_t col, int32_t size, SArray *pDataBlock) {
   if (pDataBlock == NULL) {
     return NULL;
@@ -1190,10 +1170,9 @@ static void blockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *
     tsCols = (TSKEY *)(pColInfo->pData);
   }
 
-  SQInfo *pQInfo = GET_QINFO_ADDR(pRuntimeEnv);
   for (int32_t k = 0; k < pQuery->numOfOutput; ++k) {
     char *dataBlock = getDataBlock(pRuntimeEnv, &pRuntimeEnv->sasArray[k], k, pDataBlockInfo->rows, pDataBlock);
-    setExecParams(pQuery, &pCtx[k], dataBlock, tsCols, pDataBlockInfo, pStatis, &pRuntimeEnv->sasArray[k], k, pQInfo->vgId);
+    setExecParams(pQuery, &pCtx[k], dataBlock, tsCols, pDataBlockInfo, pStatis, &pQuery->pExpr1[k]);
   }
 
   int32_t step = GET_FORWARD_DIRECTION_FACTOR(pQuery->order.order);
@@ -1234,7 +1213,7 @@ static void blockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *
         setResultRowInterpo(pResult, RESULT_ROW_END_INTERP);
         setNotInterpoWindowKey(pRuntimeEnv->pCtx, pQuery->numOfOutput, RESULT_ROW_START_INTERP);
 
-        doBlockwiseApplyFunctions(pRuntimeEnv, &w, startPos, 0, tsCols, pDataBlockInfo->rows);
+        doBlockwiseApplyFunctions(pRuntimeEnv, &w, startPos, 0, tsCols, pDataBlockInfo->rows, pDataBlock);
       }
 
       // restore current time window
@@ -1244,7 +1223,7 @@ static void blockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *
 
     // window start key interpolation
     doWindowBorderInterpolation(pRuntimeEnv, pDataBlockInfo, pDataBlock, pResult, &win, pQuery->pos, forwardStep);
-    doBlockwiseApplyFunctions(pRuntimeEnv, &win, startPos, forwardStep, tsCols, pDataBlockInfo->rows);
+    doBlockwiseApplyFunctions(pRuntimeEnv, &win, startPos, forwardStep, tsCols, pDataBlockInfo->rows, pDataBlock);
 
     STimeWindow nextWin = win;
     while (1) {
@@ -1265,7 +1244,7 @@ static void blockwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *
 
       // window start(end) key interpolation
       doWindowBorderInterpolation(pRuntimeEnv, pDataBlockInfo, pDataBlock, pResult, &nextWin, startPos, forwardStep);
-      doBlockwiseApplyFunctions(pRuntimeEnv, &nextWin, startPos, forwardStep, tsCols, pDataBlockInfo->rows);
+      doBlockwiseApplyFunctions(pRuntimeEnv, &nextWin, startPos, forwardStep, tsCols, pDataBlockInfo->rows, pDataBlock);
     }
 
   } else {
@@ -1305,7 +1284,7 @@ static int32_t setGroupResultOutputBuf(SQueryRuntimeEnv *pRuntimeEnv, char *pDat
     return -1;
   }
 
-  SResultRow *pResultRow = doPrepareResultRowFromKey(pRuntimeEnv, &pRuntimeEnv->windowResInfo, d, len, true, groupIndex);
+  SResultRow *pResultRow = doPrepareResultRowFromKey(pRuntimeEnv, &pRuntimeEnv->resultRowInfo, d, len, true, groupIndex);
   assert (pResultRow != NULL);
 
   int64_t v = -1;
@@ -1556,7 +1535,7 @@ static void rowwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *pS
   SQInfo* pQInfo = GET_QINFO_ADDR(pRuntimeEnv);
   for (int32_t k = 0; k < pQuery->numOfOutput; ++k) {
     char *dataBlock = getDataBlock(pRuntimeEnv, &pRuntimeEnv->sasArray[k], k, pDataBlockInfo->rows, pDataBlock);
-    setExecParams(pQuery, &pCtx[k], dataBlock, tsCols, pDataBlockInfo, pStatis, &pRuntimeEnv->sasArray[k], k, pQInfo->vgId);
+    setExecParams(pQuery, &pCtx[k], dataBlock, tsCols, pDataBlockInfo, pStatis, &pQuery->pExpr1[k]);
     pCtx[k].size = 1;
   }
 
@@ -1669,8 +1648,9 @@ static void rowwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *pS
       pWindowResInfo->curIndex = index;
     } else {  // other queries
       // decide which group this rows belongs to according to current state value
+      char* val = NULL;
       if (groupbyColumnValue) {
-        char *val = groupbyColumnData + bytes * offset;
+        val = groupbyColumnData + bytes * offset;
         if (isNull(val, type)) {  // ignore the null value
           continue;
         }
@@ -1681,6 +1661,34 @@ static void rowwiseApplyFunctions(SQueryRuntimeEnv *pRuntimeEnv, SDataStatis *pS
         }
       }
 
+      if (pRuntimeEnv->stabledev) {
+        for (int32_t k = 0; k < pQuery->numOfOutput; ++k) {
+          int32_t functionId = pQuery->pExpr1[k].base.functionId;
+          if (functionId != TSDB_FUNC_STDDEV_DST) {
+            continue;
+          }
+
+          pRuntimeEnv->pCtx[k].param[0].arr = NULL;
+          pRuntimeEnv->pCtx[k].param[0].nType = TSDB_DATA_TYPE_INT;  // avoid freeing the memory by setting the type to be int
+
+          // todo opt perf
+          int32_t numOfGroup = (int32_t)taosArrayGetSize(pRuntimeEnv->prevResult);
+          for (int32_t i = 0; i < numOfGroup; ++i) {
+            SInterResult *p = taosArrayGet(pRuntimeEnv->prevResult, i);
+            if (memcmp(p->tags, val, bytes) == 0) {
+              int32_t numOfCols = (int32_t)taosArrayGetSize(p->pResult);
+              for (int32_t f = 0; f < numOfCols; ++f) {
+                SStddevInterResult *pres = taosArrayGet(p->pResult, f);
+                if (pres->colId == pQuery->pExpr1[k].base.colInfo.colId) {
+                  pRuntimeEnv->pCtx[k].param[0].arr = pres->pResult;
+                  break;
+                }
+              }
+            }
+          }
+        }
+      }
+
       for (int32_t k = 0; k < pQuery->numOfOutput; ++k) {
         int32_t functionId = pQuery->pExpr1[k].base.functionId;
         if (functionNeedToExecute(pRuntimeEnv, &pCtx[k], functionId)) {
@@ -1723,7 +1731,7 @@ static int32_t tableApplyFunctionsOnBlock(SQueryRuntimeEnv *pRuntimeEnv, SDataBl
   SQuery *pQuery = pRuntimeEnv->pQuery;
 
   STableQueryInfo* pTableQueryInfo = pQuery->current;
-  SResultRowInfo*  pResultRowInfo = &pRuntimeEnv->windowResInfo;
+  SResultRowInfo*  pResultRowInfo = &pRuntimeEnv->resultRowInfo;
 
   if (pQuery->numOfFilterCols > 0 || pRuntimeEnv->pTsBuf != NULL || pRuntimeEnv->groupbyColumn) {
     rowwiseApplyFunctions(pRuntimeEnv, pStatis, pDataBlockInfo, pResultRowInfo, pDataBlock);
@@ -1767,14 +1775,13 @@ static int32_t tableApplyFunctionsOnBlock(SQueryRuntimeEnv *pRuntimeEnv, SDataBl
 }
 
 void setExecParams(SQuery *pQuery, SQLFunctionCtx *pCtx, void* inputData, TSKEY *tsCol, SDataBlockInfo* pBlockInfo,
-                   SDataStatis *pStatis, void *param, int32_t colIndex, int32_t vgId) {
+                   SDataStatis *pStatis, SExprInfo* pExprInfo) {
 
-  int32_t functionId = pQuery->pExpr1[colIndex].base.functionId;
-  int32_t colId = pQuery->pExpr1[colIndex].base.colInfo.colId;
+  int32_t functionId = pExprInfo->base.functionId;
+  int32_t colId = pExprInfo->base.colInfo.colId;
 
   SDataStatis *tpField = NULL;
-  pCtx->hasNull = hasNullValue(&pQuery->pExpr1[colIndex].base.colInfo, pStatis, &tpField);
-  pCtx->pInput = inputData;
+  pCtx->hasNull = hasNullValue(&pExprInfo->base.colInfo, pStatis, &tpField);
 
   if (tpField != NULL) {
     pCtx->preAggVals.isSet  = true;
@@ -1789,73 +1796,24 @@ void setExecParams(SQuery *pQuery, SQLFunctionCtx *pCtx, void* inputData, TSKEY
   // limit/offset query will affect this value
   pCtx->size = QUERY_IS_ASC_QUERY(pQuery) ? pBlockInfo->rows - pQuery->pos : pQuery->pos + 1;
 
-  // minimum value no matter ascending/descending order query
-  pCtx->startOffset = QUERY_IS_ASC_QUERY(pQuery) ? pQuery->pos: (pQuery->pos - pCtx->size + 1);
-  assert(pCtx->startOffset >= 0);
+  // set the start position in current block
+  int32_t offset = QUERY_IS_ASC_QUERY(pQuery) ? pQuery->pos: (pQuery->pos - pCtx->size + 1);
+  if (inputData != NULL) {
+    pCtx->pInput = (char*)inputData + offset * pCtx->inputBytes;
+  }
 
   uint32_t status = aAggs[functionId].status;
   if (((status & (TSDB_FUNCSTATE_SELECTIVITY | TSDB_FUNCSTATE_NEED_TS)) != 0) && (tsCol != NULL)) {
-    pCtx->ptsList = tsCol;
+    pCtx->ptsList = tsCol + offset;
   }
 
-  if (functionId >= TSDB_FUNC_FIRST_DST && functionId <= TSDB_FUNC_LAST_DST) {
-    // last_dist or first_dist function
-    // store the first&last timestamp into the intermediate buffer [1], the true
-    // value may be null but timestamp will never be null
-  } else if (functionId == TSDB_FUNC_TOP || functionId == TSDB_FUNC_BOTTOM || functionId == TSDB_FUNC_TWA ||
-             functionId == TSDB_FUNC_DIFF || (functionId >= TSDB_FUNC_RATE && functionId <= TSDB_FUNC_AVG_IRATE)) {
-    /*
-     * least squares function needs two columns of input, currently, the x value of linear equation is set to
-     * timestamp column, and the y-value is the column specified in pQuery->pExpr1[i].colIdxInBuffer
-     *
-     * top/bottom function needs timestamp to indicate when the
-     * top/bottom values emerge, so does diff function
-     */
-    if (functionId == TSDB_FUNC_TWA) {
-       pCtx->param[1].i64 = pQuery->window.skey;
-       pCtx->param[1].nType = TSDB_DATA_TYPE_BIGINT;
-       pCtx->param[2].i64 = pQuery->window.ekey;
-       pCtx->param[2].nType = TSDB_DATA_TYPE_BIGINT;
-    }
-
-  } else if (functionId == TSDB_FUNC_ARITHM) {
-    pCtx->param[1].pz = param;
-  } else if (functionId == TSDB_FUNC_SPREAD) {  // set the statistics data for primary time stamp column
+  if (functionId == TSDB_FUNC_SPREAD) {  // set the statistics data for primary time stamp column
     if (colId == PRIMARYKEY_TIMESTAMP_COL_INDEX) {
       pCtx->preAggVals.isSet  = true;
       pCtx->preAggVals.statis.min = pBlockInfo->window.skey;
       pCtx->preAggVals.statis.max = pBlockInfo->window.ekey;
     }
-  } else if (functionId == TSDB_FUNC_INTERP) {
-    pCtx->param[2].i64 = (int8_t) pQuery->fillType;
-    if (pQuery->fillVal != NULL) {
-      if (isNull((const char*) &pQuery->fillVal[colIndex], pCtx->inputType)) {
-        pCtx->param[1].nType = TSDB_DATA_TYPE_NULL;
-      } else { // todo refactor, tVariantCreateFromBinary should handle the NULL value
-        if (pCtx->inputType != TSDB_DATA_TYPE_BINARY && pCtx->inputType != TSDB_DATA_TYPE_NCHAR) {
-          tVariantCreateFromBinary(&pCtx->param[1], (char*) &pQuery->fillVal[colIndex], pCtx->inputBytes, pCtx->inputType);
-        }
-      }
-    }
-  } else if (functionId == TSDB_FUNC_TS_COMP) {
-    pCtx->param[0].i64 = vgId;
-    pCtx->param[0].nType = TSDB_DATA_TYPE_BIGINT;
   }
-
-#if defined(_DEBUG_VIEW)
-  //  int64_t *tsList = (int64_t *)primaryColumnData;
-//  int64_t  s = tsList[0];
-//  int64_t  e = tsList[size - 1];
-
-//    if (IS_DATA_BLOCK_LOADED(blockStatus)) {
-//        qDebug("QInfo:%p query ts:%lld-%lld, offset:%d, rows:%d, bstatus:%d,
-//        functId:%d", GET_QINFO_ADDR(pQuery),
-//               s, e, startOffset, size, blockStatus, functionId);
-//    } else {
-//        qDebug("QInfo:%p block not loaded, bstatus:%d",
-//        GET_QINFO_ADDR(pQuery), blockStatus);
-//    }
-#endif
 }
 
 // set the output buffer for the selectivity + tag query
@@ -1900,7 +1858,7 @@ static int32_t setCtxTagColumnInfo(SQueryRuntimeEnv *pRuntimeEnv, SQLFunctionCtx
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOfTables, int16_t order) {
+static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOfTables, int16_t order, int32_t vgId) {
   qDebug("QInfo:%p setup runtime env", GET_QINFO_ADDR(pRuntimeEnv));
   SQuery *pQuery = pRuntimeEnv->pQuery;
 
@@ -1908,34 +1866,33 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
   pRuntimeEnv->summary.tableInfoSize += (numOfTables * sizeof(STableQueryInfo));
 
   pRuntimeEnv->pResultRowHashTable = taosHashInit(numOfTables, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
-  pRuntimeEnv->keyBuf = malloc(pQuery->maxSrcColumnSize + sizeof(int64_t));
-  pRuntimeEnv->pool = initResultRowPool(getResultRowSize(pRuntimeEnv));
+  pRuntimeEnv->keyBuf  = malloc(pQuery->maxSrcColumnSize + sizeof(int64_t));
+  pRuntimeEnv->pool    = initResultRowPool(getResultRowSize(pRuntimeEnv));
   pRuntimeEnv->prevRow = malloc(POINTER_BYTES * pQuery->numOfCols + pQuery->srcRowSize);
-  pRuntimeEnv->tagVal = malloc(pQuery->tagLen);
+  pRuntimeEnv->tagVal  = malloc(pQuery->tagLen);
+  pRuntimeEnv->pCtx    = (SQLFunctionCtx *)calloc(pQuery->numOfOutput, sizeof(SQLFunctionCtx));
+  pRuntimeEnv->offset  = calloc(pQuery->numOfOutput, sizeof(int16_t));
+  pRuntimeEnv->rowCellInfoOffset = calloc(pQuery->numOfOutput, sizeof(int32_t));
+  pRuntimeEnv->sasArray = calloc(pQuery->numOfOutput, sizeof(SArithmeticSupport));
+
+  if (pRuntimeEnv->offset == NULL || pRuntimeEnv->pCtx == NULL || pRuntimeEnv->rowCellInfoOffset == NULL ||
+      pRuntimeEnv->sasArray == NULL || pRuntimeEnv->pResultRowHashTable == NULL || pRuntimeEnv->keyBuf == NULL ||
+      pRuntimeEnv->prevRow == NULL || pRuntimeEnv->tagVal == NULL) {
+    goto _clean;
+  }
 
   char* start = POINTER_BYTES * pQuery->numOfCols + (char*) pRuntimeEnv->prevRow;
   pRuntimeEnv->prevRow[0] = start;
-
   for(int32_t i = 1; i < pQuery->numOfCols; ++i) {
     pRuntimeEnv->prevRow[i] = pRuntimeEnv->prevRow[i - 1] + pQuery->colList[i-1].bytes;
   }
 
-  pRuntimeEnv->pCtx = (SQLFunctionCtx *)calloc(pQuery->numOfOutput, sizeof(SQLFunctionCtx));
-  pRuntimeEnv->offset = calloc(pQuery->numOfOutput, sizeof(int16_t));
-  pRuntimeEnv->rowCellInfoOffset = calloc(pQuery->numOfOutput, sizeof(int32_t));
-  pRuntimeEnv->sasArray = calloc(pQuery->numOfOutput, sizeof(SArithmeticSupport));
-
-  // TODO check malloc failure
-  if (pRuntimeEnv->offset == NULL || pRuntimeEnv->pCtx == NULL || pRuntimeEnv->rowCellInfoOffset == NULL || pRuntimeEnv->sasArray == NULL) {
-    goto _clean;
-  }
-
   pRuntimeEnv->offset[0] = 0;
   for (int32_t i = 0; i < pQuery->numOfOutput; ++i) {
     SSqlFuncMsg *pSqlFuncMsg = &pQuery->pExpr1[i].base;
 
     SQLFunctionCtx *pCtx = &pRuntimeEnv->pCtx[i];
-    SColIndex* pIndex = &pSqlFuncMsg->colInfo;
+    SColIndex *     pIndex = &pSqlFuncMsg->colInfo;
 
     if (TSDB_COL_REQ_NULL(pIndex->flag)) {
       pCtx->requireNull = true;
@@ -1947,7 +1904,7 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
     int32_t index = pSqlFuncMsg->colInfo.colIndex;
     if (TSDB_COL_IS_TAG(pIndex->flag)) {
       if (pIndex->colId == TSDB_TBNAME_COLUMN_INDEX) {  // todo refactor
-        SSchema* s = tGetTbnameColumnSchema();
+        SSchema *s = tGetTbnameColumnSchema();
 
         pCtx->inputBytes = s->bytes;
         pCtx->inputType = s->type;
@@ -2008,18 +1965,38 @@ static int32_t setupQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv, int32_t numOf
       pCtx->param[3].nType = TSDB_DATA_TYPE_BIGINT;
 
       pCtx->param[1].i64 = pQuery->order.orderColId;
-    }
-
-    if (functionId == TSDB_FUNC_ARITHM) {
+    } else if (functionId == TSDB_FUNC_INTERP) {
+      pCtx->param[2].i64 = (int8_t)pQuery->fillType;
+      if (pQuery->fillVal != NULL) {
+        if (isNull((const char *)&pQuery->fillVal[i], pCtx->inputType)) {
+          pCtx->param[1].nType = TSDB_DATA_TYPE_NULL;
+        } else {  // todo refactor, tVariantCreateFromBinary should handle the NULL value
+          if (pCtx->inputType != TSDB_DATA_TYPE_BINARY && pCtx->inputType != TSDB_DATA_TYPE_NCHAR) {
+            tVariantCreateFromBinary(&pCtx->param[1], (char *)&pQuery->fillVal[i], pCtx->inputBytes, pCtx->inputType);
+          }
+        }
+      }
+    } else if (functionId == TSDB_FUNC_TS_COMP) {
+      pCtx->param[0].i64 = vgId;
+      pCtx->param[0].nType = TSDB_DATA_TYPE_BIGINT;
+    } else if (functionId == TSDB_FUNC_TWA) {
+      pCtx->param[1].i64 = pQuery->window.skey;
+      pCtx->param[1].nType = TSDB_DATA_TYPE_BIGINT;
+      pCtx->param[2].i64 = pQuery->window.ekey;
+      pCtx->param[2].nType = TSDB_DATA_TYPE_BIGINT;
+    } else if (functionId == TSDB_FUNC_ARITHM) {
       pRuntimeEnv->sasArray[i].data = calloc(pQuery->numOfCols, POINTER_BYTES);
       if (pRuntimeEnv->sasArray[i].data == NULL) {
         goto _clean;
       }
+
+      pCtx->param[1].pz = (char*) &pRuntimeEnv->sasArray[i];
     }
 
     if (i > 0) {
       pRuntimeEnv->offset[i] = pRuntimeEnv->offset[i - 1] + pRuntimeEnv->pCtx[i - 1].outputBytes;
-      pRuntimeEnv->rowCellInfoOffset[i] = pRuntimeEnv->rowCellInfoOffset[i - 1] + sizeof(SResultRowCellInfo) + pQuery->pExpr1[i - 1].interBytes;
+      pRuntimeEnv->rowCellInfoOffset[i] =
+          pRuntimeEnv->rowCellInfoOffset[i - 1] + sizeof(SResultRowCellInfo) + pQuery->pExpr1[i - 1].interBytes;
     }
   }
 
@@ -2043,6 +2020,10 @@ _clean:
   tfree(pRuntimeEnv->offset);
   tfree(pRuntimeEnv->rowCellInfoOffset);
   tfree(pRuntimeEnv->sasArray);
+  tfree(pRuntimeEnv->pResultRowHashTable);
+  tfree(pRuntimeEnv->keyBuf);
+  tfree(pRuntimeEnv->prevRow);
+  tfree(pRuntimeEnv->tagVal);
 
   return TSDB_CODE_QRY_OUT_OF_MEMORY;
 }
@@ -2070,7 +2051,7 @@ static void teardownQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv) {
   SQInfo* pQInfo = (SQInfo*) GET_QINFO_ADDR(pRuntimeEnv);
 
   qDebug("QInfo:%p teardown runtime env", pQInfo);
-  cleanupResultRowInfo(&pRuntimeEnv->windowResInfo);
+  cleanupResultRowInfo(&pRuntimeEnv->resultRowInfo);
 
   if (isTsCompQuery(pQuery)) {
     FILE *f = *(FILE **)pQuery->sdata[0]->data;
@@ -2118,7 +2099,6 @@ static void teardownQueryRuntimeEnv(SQueryRuntimeEnv *pRuntimeEnv) {
   tfree(pRuntimeEnv->prevRow);
   tfree(pRuntimeEnv->tagVal);
 
-
   taosHashCleanup(pRuntimeEnv->pResultRowHashTable);
   pRuntimeEnv->pResultRowHashTable = NULL;
 
@@ -2131,9 +2111,7 @@ static bool needBuildResAfterQueryComplete(SQInfo* pQInfo) {
   return pQInfo->rspContext != NULL;
 }
 
-#define IS_QUERY_KILLED(_q) ((_q)->code == TSDB_CODE_TSC_QUERY_CANCELLED)
-
-static bool isQueryKilled(SQInfo *pQInfo) {
+bool isQueryKilled(SQInfo *pQInfo) {
   if (IS_QUERY_KILLED(pQInfo)) {
     return true;
   }
@@ -2152,7 +2130,7 @@ static bool isQueryKilled(SQInfo *pQInfo) {
   return false;
 }
 
-static void setQueryKilled(SQInfo *pQInfo) { pQInfo->code = TSDB_CODE_TSC_QUERY_CANCELLED;}
+void setQueryKilled(SQInfo *pQInfo) { pQInfo->code = TSDB_CODE_TSC_QUERY_CANCELLED;}
 
 static bool isFixedOutputQuery(SQueryRuntimeEnv* pRuntimeEnv) {
   SQuery* pQuery = pRuntimeEnv->pQuery;
@@ -2253,7 +2231,7 @@ static bool needReverseScan(SQuery *pQuery) {
  * 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
  */
-static bool onlyQueryTags(SQuery* pQuery) {
+bool onlyQueryTags(SQuery* pQuery) {
   for(int32_t i = 0; i < pQuery->numOfOutput; ++i) {
     SExprInfo* pExprInfo = &pQuery->pExpr1[i];
 
@@ -2351,7 +2329,6 @@ static bool onlyFirstQuery(SQuery *pQuery) { return onlyOneQueryType(pQuery, TSD
 
 static bool onlyLastQuery(SQuery *pQuery) { return onlyOneQueryType(pQuery, TSDB_FUNC_LAST, TSDB_FUNC_LAST_DST); }
 
-// todo refactor, add iterator
 static void doExchangeTimeWindow(SQInfo* pQInfo, STimeWindow* win) {
   size_t t = taosArrayGetSize(pQInfo->tableGroupInfo.pGroupList);
   for(int32_t i = 0; i < t; ++i) {
@@ -2769,56 +2746,42 @@ int32_t binarySearchForKey(char *pValue, int num, TSKEY key, int order) {
   return midPos;
 }
 
-static void ensureOutputBufferSimple(SQueryRuntimeEnv* pRuntimeEnv, int32_t capacity) {
+static void expandBuffer(SQueryRuntimeEnv* pRuntimeEnv, int32_t newSize, void* qinfo) {
   SQuery* pQuery = pRuntimeEnv->pQuery;
+  SResultRec *pRec = &pQuery->rec;
 
-  if (capacity < pQuery->rec.capacity) {
-    return;
-  }
+  assert(newSize > 0);
 
   for (int32_t i = 0; i < pQuery->numOfOutput; ++i) {
     int32_t bytes = pQuery->pExpr1[i].bytes;
-    assert(bytes > 0 && capacity > 0);
 
-    char *tmp = realloc(pQuery->sdata[i], bytes * capacity + sizeof(tFilePage));
+    char *tmp = realloc(pQuery->sdata[i], bytes * newSize + sizeof(tFilePage));
     if (tmp == NULL) {
       longjmp(pRuntimeEnv->env, TSDB_CODE_QRY_OUT_OF_MEMORY);
     } else {
+      memset(tmp + sizeof(tFilePage) + bytes * pRec->rows, 0, (size_t)((newSize - pRec->rows) * bytes));
       pQuery->sdata[i] = (tFilePage *)tmp;
     }
-
-    // set the pCtx output buffer position
-    pRuntimeEnv->pCtx[i].pOutput = pQuery->sdata[i]->data;
   }
 
-  qDebug("QInfo:%p realloc output buffer to inc output buffer from: %" PRId64 " rows to:%d rows", GET_QINFO_ADDR(pRuntimeEnv),
-         pQuery->rec.capacity, capacity);
-
-  pQuery->rec.capacity = capacity;
+  pRec->capacity = newSize;
+  qDebug("QInfo:%p realloc output buffer, new size: %d rows, old:%" PRId64 ", remain:%" PRId64, qinfo, newSize,
+      pRec->capacity, newSize - pRec->rows);
 }
 
-// TODO merge with enuserOutputBufferSimple
-static void ensureOutputBuffer(SQueryRuntimeEnv* pRuntimeEnv, SDataBlockInfo* pBlockInfo) {
+static void ensureOutputBuffer(SQueryRuntimeEnv* pRuntimeEnv, int32_t numOfRows) {
   // in case of prj/diff query, ensure the output buffer is sufficient to accommodate the results of current block
   SQuery* pQuery = pRuntimeEnv->pQuery;
   if (!QUERY_IS_INTERVAL_QUERY(pQuery) && !pRuntimeEnv->groupbyColumn && !isFixedOutputQuery(pRuntimeEnv) && !isTsCompQuery(pQuery)) {
     SResultRec *pRec = &pQuery->rec;
 
-    if (pQuery->rec.capacity - pQuery->rec.rows < pBlockInfo->rows) {
-      int32_t remain = (int32_t)(pRec->capacity - pRec->rows);
-      int32_t newSize = (int32_t)(pRec->capacity + (pBlockInfo->rows - remain));
+    int32_t remain  = (int32_t)(pRec->capacity - pRec->rows);
+    if (remain < numOfRows) {
+      int32_t newSize = (int32_t)(pRec->capacity + (numOfRows - remain));
+      expandBuffer(pRuntimeEnv, newSize, GET_QINFO_ADDR(pRuntimeEnv));
 
       for (int32_t i = 0; i < pQuery->numOfOutput; ++i) {
         int32_t bytes = pQuery->pExpr1[i].bytes;
-        assert(bytes > 0 && newSize > 0);
-
-        char *tmp = realloc(pQuery->sdata[i], bytes * newSize + sizeof(tFilePage));
-        if (tmp == NULL) {
-          longjmp(pRuntimeEnv->env, TSDB_CODE_QRY_OUT_OF_MEMORY);
-        } else {
-          memset(tmp + sizeof(tFilePage) + bytes * pRec->rows, 0, (size_t)((newSize - pRec->rows) * bytes));
-          pQuery->sdata[i] = (tFilePage *)tmp;
-        }
 
         // set the pCtx output buffer position
         pRuntimeEnv->pCtx[i].pOutput = pQuery->sdata[i]->data + pRec->rows * bytes;
@@ -2828,11 +2791,6 @@ static void ensureOutputBuffer(SQueryRuntimeEnv* pRuntimeEnv, SDataBlockInfo* pB
           pRuntimeEnv->pCtx[i].ptsOutputBuf = pRuntimeEnv->pCtx[0].pOutput;
         }
       }
-
-      qDebug("QInfo:%p realloc output buffer, new size: %d rows, old:%" PRId64 ", remain:%" PRId64, GET_QINFO_ADDR(pRuntimeEnv),
-             newSize, pRec->capacity, newSize - pRec->rows);
-
-      pRec->capacity = newSize;
     }
   }
 }
@@ -2840,9 +2798,9 @@ static void ensureOutputBuffer(SQueryRuntimeEnv* pRuntimeEnv, SDataBlockInfo* pB
 static void doSetInitialTimewindow(SQueryRuntimeEnv* pRuntimeEnv, SDataBlockInfo* pBlockInfo) {
   SQuery* pQuery = pRuntimeEnv->pQuery;
 
-  if (QUERY_IS_INTERVAL_QUERY(pQuery) && pRuntimeEnv->windowResInfo.prevSKey == TSKEY_INITIAL_VAL) {
+  if (QUERY_IS_INTERVAL_QUERY(pQuery) && pRuntimeEnv->resultRowInfo.prevSKey == TSKEY_INITIAL_VAL) {
     STimeWindow w = TSWINDOW_INITIALIZER;
-    SResultRowInfo *pWindowResInfo = &pRuntimeEnv->windowResInfo;
+    SResultRowInfo *pWindowResInfo = &pRuntimeEnv->resultRowInfo;
 
     if (QUERY_IS_ASC_QUERY(pQuery)) {
       getAlignQueryTimeWindow(pQuery, pBlockInfo->window.skey, pBlockInfo->window.skey, pQuery->window.ekey, &w);
@@ -2882,13 +2840,13 @@ static int64_t doScanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
     doSetInitialTimewindow(pRuntimeEnv, &blockInfo);
 
     // in case of prj/diff query, ensure the output buffer is sufficient to accommodate the results of current block
-    ensureOutputBuffer(pRuntimeEnv, &blockInfo);
+    ensureOutputBuffer(pRuntimeEnv, blockInfo.rows);
 
     SDataStatis *pStatis = NULL;
     SArray *     pDataBlock = NULL;
     uint32_t     status = 0;
 
-    int32_t ret = loadDataBlockOnDemand(pRuntimeEnv, &pRuntimeEnv->windowResInfo, pQueryHandle, &blockInfo, &pStatis, &pDataBlock, &status);
+    int32_t ret = loadDataBlockOnDemand(pRuntimeEnv, &pRuntimeEnv->resultRowInfo, pQueryHandle, &blockInfo, &pStatis, &pDataBlock, &status);
     if (ret != TSDB_CODE_SUCCESS) {
       break;
     }
@@ -2923,8 +2881,8 @@ static int64_t doScanAllDataBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
   }
 
   if (QUERY_IS_INTERVAL_QUERY(pQuery)) {
-    closeAllResultRows(&pRuntimeEnv->windowResInfo);
-    pRuntimeEnv->windowResInfo.curIndex = pRuntimeEnv->windowResInfo.size - 1;  // point to the last time window
+    closeAllResultRows(&pRuntimeEnv->resultRowInfo);
+    pRuntimeEnv->resultRowInfo.curIndex = pRuntimeEnv->resultRowInfo.size - 1;  // point to the last time window
   }
 
   return 0;
@@ -3142,253 +3100,35 @@ void UNUSED_FUNC displayInterResult(tFilePage **pdata, SQueryRuntimeEnv* pRuntim
   }
 }
 
-typedef struct SCompSupporter {
-  STableQueryInfo **pTableQueryInfo;
-  int32_t          *rowIndex;
-  int32_t           order;
-} SCompSupporter;
-
-int32_t tableResultComparFn(const void *pLeft, const void *pRight, void *param) {
-  int32_t left  = *(int32_t *)pLeft;
-  int32_t right = *(int32_t *)pRight;
-
-  SCompSupporter *  supporter = (SCompSupporter *)param;
-
-  int32_t leftPos  = supporter->rowIndex[left];
-  int32_t rightPos = supporter->rowIndex[right];
-
-  /* left source is exhausted */
-  if (leftPos == -1) {
-    return 1;
-  }
-
-  /* right source is exhausted*/
-  if (rightPos == -1) {
-    return -1;
-  }
-
-  STableQueryInfo** pList = supporter->pTableQueryInfo;
-
-  SResultRowInfo *pWindowResInfo1 = &(pList[left]->windowResInfo);
-  SResultRow * pWindowRes1 = getResultRow(pWindowResInfo1, leftPos);
-  TSKEY leftTimestamp = pWindowRes1->win.skey;
-
-  SResultRowInfo *pWindowResInfo2 = &(pList[right]->windowResInfo);
-  SResultRow * pWindowRes2 = getResultRow(pWindowResInfo2, rightPos);
-  TSKEY rightTimestamp = pWindowRes2->win.skey;
-
-  if (leftTimestamp == rightTimestamp) {
-    return 0;
-  }
-
-  if (supporter->order == TSDB_ORDER_ASC) {
-    return (leftTimestamp > rightTimestamp)? 1:-1;
-  } else {
-    return (leftTimestamp < rightTimestamp)? 1:-1;
-  }
-}
-
-int32_t mergeGroupResult(SQInfo *pQInfo) {
-  int64_t st = taosGetTimestampUs();
-
-  SGroupResInfo* pGroupResInfo = &pQInfo->groupResInfo;
-
-  int32_t numOfGroups = (int32_t)(GET_NUM_OF_TABLEGROUP(pQInfo));
-  while (pQInfo->groupIndex < numOfGroups) {
-    SArray *group = GET_TABLEGROUP(pQInfo, pQInfo->groupIndex);
-
-    int32_t ret = mergeIntoGroupResultImpl(pGroupResInfo, group, pQInfo);
-    if (ret != TSDB_CODE_SUCCESS) {
-      return ret;
-    }
-
-    // this group generates at least one result, return results
-    pQInfo->groupIndex += 1;
-    if (taosArrayGetSize(pGroupResInfo->pRows) > 0) {
-      break;
-    }
-
-    qDebug("QInfo:%p no result in group %d, continue", pQInfo, pQInfo->groupIndex - 1);
-    taosArrayClear(pGroupResInfo->pRows);
-
-    pGroupResInfo->index = 0;
-    pGroupResInfo->rowId = 0;
-  }
-
-  if (pQInfo->groupIndex == numOfGroups && taosArrayGetSize(pGroupResInfo->pRows) == 0) {
-    SET_STABLE_QUERY_OVER(pQInfo);
-  }
-
-  int64_t elapsedTime = taosGetTimestampUs() - st;
-  qDebug("QInfo:%p merge res data into group, index:%d, total group:%d, elapsed time:%" PRId64 "us", pQInfo,
-         pQInfo->groupIndex - 1, numOfGroups, elapsedTime);
-
-  pQInfo->runtimeEnv.summary.firstStageMergeTime += elapsedTime;
-  return TSDB_CODE_SUCCESS;
-}
-
-static int32_t doCopyToSData(SQInfo *pQInfo, SResultRow **pRows, int32_t numOfRows, int32_t* index, int32_t orderType);
+static int32_t doCopyToSData(SQueryRuntimeEnv* pRuntimeEnv, SGroupResInfo* pGroupResInfo, int32_t orderType);
 
 void copyResToQueryResultBuf(SQInfo *pQInfo, SQuery *pQuery) {
   SGroupResInfo* pGroupResInfo = &pQInfo->groupResInfo;
 
-  // all results in current group have been returned to client, try next group
-  if (pGroupResInfo->index >= taosArrayGetSize(pGroupResInfo->pRows)) {
-    // current results of group has been sent to client, try next group
-    pGroupResInfo->index = 0;
-    pGroupResInfo->rowId = 0;
-    taosArrayClear(pGroupResInfo->pRows);
-
-    if (mergeGroupResult(pQInfo) != TSDB_CODE_SUCCESS) {
-      return;  // failed to save data in the disk
-    }
-
-    // check if all results has been sent to client
-    int32_t numOfGroup = (int32_t)(GET_NUM_OF_TABLEGROUP(pQInfo));
-    if (taosArrayGetSize(pGroupResInfo->pRows) == 0 && pQInfo->groupIndex == numOfGroup) {
-      SET_STABLE_QUERY_OVER(pQInfo);
-      return;
-    }
-  }
-
-  int32_t size = (int32_t) taosArrayGetSize(pGroupResInfo->pRows);
-  pQuery->rec.rows = doCopyToSData(pQInfo, pGroupResInfo->pRows->pData, size, &pGroupResInfo->index, TSDB_ORDER_ASC);
-}
-
-int64_t getNumOfResultWindowRes(SQueryRuntimeEnv* pRuntimeEnv, SResultRow *pResultRow) {
-  SQuery* pQuery = pRuntimeEnv->pQuery;
-
-  for (int32_t j = 0; j < pQuery->numOfOutput; ++j) {
-    int32_t functionId = pQuery->pExpr1[j].base.functionId;
-
-    /*
-     * ts, tag, tagprj function can not decide the output number of current query
-     * the number of output result is decided by main output
-     */
-    if (functionId == TSDB_FUNC_TS || functionId == TSDB_FUNC_TAG || functionId == TSDB_FUNC_TAGPRJ) {
-      continue;
-    }
-
-    SResultRowCellInfo *pResultInfo = getResultCell(pRuntimeEnv, pResultRow, j);
-    assert(pResultInfo != NULL);
-
-    if (pResultInfo->numOfRes > 0) {
-      return pResultInfo->numOfRes;
-    }
-  }
-
-  return 0;
-}
-
-int32_t mergeIntoGroupResultImpl(SGroupResInfo* pGroupResInfo, SArray *pTableList, SQInfo* pQInfo) {
-  SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
-  bool ascQuery = QUERY_IS_ASC_QUERY(pRuntimeEnv->pQuery);
-
-  int32_t code = TSDB_CODE_SUCCESS;
-
-  int32_t *posList = NULL;
-  SLoserTreeInfo *pTree = NULL;
-  STableQueryInfo **pTableQueryInfoList = NULL;
-
-  size_t size = taosArrayGetSize(pTableList);
-  if (pGroupResInfo->pRows == NULL) {
-    pGroupResInfo->pRows = taosArrayInit(100, POINTER_BYTES);
-  }
-
-  posList = calloc(size, sizeof(int32_t));
-  pTableQueryInfoList = malloc(POINTER_BYTES * size);
-
-  if (pTableQueryInfoList == NULL || posList == NULL || pGroupResInfo->pRows == NULL) {
-    qError("QInfo:%p failed alloc memory", pQInfo);
-    code = TSDB_CODE_QRY_OUT_OF_MEMORY;
-    goto _end;
-  }
-
-  int32_t numOfTables = 0;
-  for (int32_t i = 0; i < size; ++i) {
-    STableQueryInfo *item = taosArrayGetP(pTableList, i);
-    if (item->windowResInfo.size > 0) {
-      pTableQueryInfoList[numOfTables++] = item;
-    }
-  }
-
-  // there is no data in current group
-  // no need to merge results since only one table in each group
-  if (numOfTables == 0) {
-    goto _end;
-  }
-
-  SCompSupporter cs = {pTableQueryInfoList, posList, pRuntimeEnv->pQuery->order.order};
-
-  int32_t ret = tLoserTreeCreate(&pTree, numOfTables, &cs, tableResultComparFn);
-  if (ret != TSDB_CODE_SUCCESS) {
-    code = TSDB_CODE_QRY_OUT_OF_MEMORY;
-    goto _end;
-  }
-
-  int64_t lastTimestamp = ascQuery? INT64_MIN:INT64_MAX;
-  int64_t startt = taosGetTimestampMs();
-
-  while (1) {
-    if (isQueryKilled(pQInfo)) {
-      qDebug("QInfo:%p it is already killed, abort", pQInfo);
-      code = TSDB_CODE_TSC_QUERY_CANCELLED;
-      goto _end;
-    }
-
-    int32_t tableIndex = pTree->pNode[0].index;
-
-    SResultRowInfo *pWindowResInfo = &pTableQueryInfoList[tableIndex]->windowResInfo;
-    SResultRow  *pWindowRes = getResultRow(pWindowResInfo, cs.rowIndex[tableIndex]);
-
-    int64_t num = getNumOfResultWindowRes(pRuntimeEnv, pWindowRes);
-    if (num <= 0) {
-      cs.rowIndex[tableIndex] += 1;
-
-      if (cs.rowIndex[tableIndex] >= pWindowResInfo->size) {
-        cs.rowIndex[tableIndex] = -1;
-        if (--numOfTables == 0) { // all input sources are exhausted
-          break;
-        }
-      }
-    } else {
-      assert((pWindowRes->win.skey >= lastTimestamp && ascQuery) || (pWindowRes->win.skey <= lastTimestamp && !ascQuery));
-
-      if (pWindowRes->win.skey != lastTimestamp) {
-        taosArrayPush(pGroupResInfo->pRows, &pWindowRes);
-        pWindowRes->numOfRows = (uint32_t) num;
+  while(pGroupResInfo->currentGroup < pGroupResInfo->totalGroup) {
+    // all results in current group have been returned to client, try next group
+    if ((pGroupResInfo->pRows == NULL) || taosArrayGetSize(pGroupResInfo->pRows) == 0) {
+      assert(pGroupResInfo->index == 0);
+      if ((pQInfo->code = mergeIntoGroupResult(&pQInfo->groupResInfo, pQInfo)) != TSDB_CODE_SUCCESS) {
+        return;
       }
+    }
 
-      lastTimestamp = pWindowRes->win.skey;
-
-      // move to the next row of current entry
-      if ((++cs.rowIndex[tableIndex]) >= pWindowResInfo->size) {
-        cs.rowIndex[tableIndex] = -1;
+    pQuery->rec.rows = doCopyToSData(&pQInfo->runtimeEnv, pGroupResInfo, TSDB_ORDER_ASC);
 
-        // all input sources are exhausted
-        if ((--numOfTables) == 0) {
-          break;
-        }
+    // current data are all dumped to result buffer, clear it
+    if (!hasRemainData(pGroupResInfo)) {
+      cleanupGroupResInfo(pGroupResInfo);
+      if (!incNextGroup(pGroupResInfo)) {
+        SET_STABLE_QUERY_OVER(pQInfo);
       }
     }
 
-    tLoserTreeAdjust(pTree, tableIndex + pTree->numOfEntries);
+    // enough results in data buffer, return
+    if (pQuery->rec.rows >= pQuery->rec.threshold) {
+      break;
+    }
   }
-
-  int64_t endt = taosGetTimestampMs();
-
-#ifdef _DEBUG_VIEW
-  displayInterResult(pQuery->sdata, pRuntimeEnv, pQuery->sdata[0]->num);
-#endif
-
-  qDebug("QInfo:%p result merge completed for group:%d, elapsed time:%" PRId64 " ms", pQInfo, pQInfo->groupIndex, endt - startt);
-
-  _end:
-  tfree(pTableQueryInfoList);
-  tfree(posList);
-  tfree(pTree);
-
-  return code;
 }
 
 static void updateTableQueryInfoForReverseScan(SQuery *pQuery, STableQueryInfo *pTableQueryInfo) {
@@ -3403,7 +3143,7 @@ static void updateTableQueryInfoForReverseScan(SQuery *pQuery, STableQueryInfo *
   pTableQueryInfo->cur.vgroupIndex = -1;
 
   // set the index at the end of time window
-  pTableQueryInfo->windowResInfo.curIndex = pTableQueryInfo->windowResInfo.size - 1;
+  pTableQueryInfo->resInfo.curIndex = pTableQueryInfo->resInfo.size - 1;
 }
 
 static void disableFuncInReverseScanImpl(SQueryRuntimeEnv* pRuntimeEnv, SResultRowInfo *pWindowResInfo, int32_t order) {
@@ -3438,7 +3178,7 @@ void disableFuncInReverseScan(SQInfo *pQInfo) {
   int32_t order = pQuery->order.order;
 
   // group by normal columns and interval query on normal table
-  SResultRowInfo *pWindowResInfo = &pRuntimeEnv->windowResInfo;
+  SResultRowInfo *pWindowResInfo = &pRuntimeEnv->resultRowInfo;
   if (pRuntimeEnv->groupbyColumn || QUERY_IS_INTERVAL_QUERY(pQuery)) {
     disableFuncInReverseScanImpl(pRuntimeEnv, pWindowResInfo, order);
   } else {  // for simple result of table query,
@@ -3502,7 +3242,7 @@ void resetDefaultResInfoOutputBuf(SQueryRuntimeEnv *pRuntimeEnv) {
 
   int32_t tid = 0;
   int64_t uid = 0;
-  SResultRow* pRow = doPrepareResultRowFromKey(pRuntimeEnv, &pRuntimeEnv->windowResInfo, (char *)&tid, sizeof(tid), true, uid);
+  SResultRow* pRow = doPrepareResultRowFromKey(pRuntimeEnv, &pRuntimeEnv->resultRowInfo, (char *)&tid, sizeof(tid), true, uid);
 
   for (int32_t i = 0; i < pQuery->numOfOutput; ++i) {
     SQLFunctionCtx *pCtx = &pRuntimeEnv->pCtx[i];
@@ -3629,7 +3369,7 @@ bool needRepeatScan(SQueryRuntimeEnv *pRuntimeEnv) {
   bool toContinue = false;
   if (pRuntimeEnv->groupbyColumn || QUERY_IS_INTERVAL_QUERY(pQuery)) {
     // for each group result, call the finalize function for each column
-    SResultRowInfo *pWindowResInfo = &pRuntimeEnv->windowResInfo;
+    SResultRowInfo *pWindowResInfo = &pRuntimeEnv->resultRowInfo;
 
     for (int32_t i = 0; i < pWindowResInfo->size; ++i) {
       SResultRow *pResult = getResultRow(pWindowResInfo, i);
@@ -3673,7 +3413,7 @@ static SQueryStatusInfo getQueryStatusInfo(SQueryRuntimeEnv *pRuntimeEnv, TSKEY
 
   SQueryStatusInfo info = {
       .status      = pQuery->status,
-      .windowIndex = pRuntimeEnv->windowResInfo.curIndex,
+      .windowIndex = pRuntimeEnv->resultRowInfo.curIndex,
       .lastKey     = start,
   };
 
@@ -3858,7 +3598,7 @@ void scanOneTableDataBlocks(SQueryRuntimeEnv *pRuntimeEnv, TSKEY start) {
       longjmp(pRuntimeEnv->env, terrno);
     }
 
-    pRuntimeEnv->windowResInfo.curIndex = qstatus.windowIndex;
+    pRuntimeEnv->resultRowInfo.curIndex = qstatus.windowIndex;
     setQueryStatus(pQuery, QUERY_NOT_COMPLETED);
     pRuntimeEnv->scanFlag = REPEAT_SCAN;
 
@@ -3889,7 +3629,7 @@ void finalizeQueryResult(SQueryRuntimeEnv *pRuntimeEnv) {
 
   if (pRuntimeEnv->groupbyColumn || QUERY_IS_INTERVAL_QUERY(pQuery)) {
     // for each group result, call the finalize function for each column
-    SResultRowInfo *pWindowResInfo = &pRuntimeEnv->windowResInfo;
+    SResultRowInfo *pWindowResInfo = &pRuntimeEnv->resultRowInfo;
     if (pRuntimeEnv->groupbyColumn) {
       closeAllResultRows(pWindowResInfo);
     }
@@ -3944,7 +3684,7 @@ static STableQueryInfo *createTableQueryInfo(SQuery* pQuery, void* pTable, bool
   // set more initial size of interval/groupby query
   if (QUERY_IS_INTERVAL_QUERY(pQuery) || groupbyColumn) {
     int32_t initialSize = 128;
-    int32_t code = initResultRowInfo(&pTableQueryInfo->windowResInfo, initialSize, TSDB_DATA_TYPE_INT);
+    int32_t code = initResultRowInfo(&pTableQueryInfo->resInfo, initialSize, TSDB_DATA_TYPE_INT);
     if (code != TSDB_CODE_SUCCESS) {
       return NULL;
     }
@@ -3960,7 +3700,7 @@ void destroyTableQueryInfoImpl(STableQueryInfo *pTableQueryInfo) {
   }
 
   tVariantDestroy(&pTableQueryInfo->tag);
-  cleanupResultRowInfo(&pTableQueryInfo->windowResInfo);
+  cleanupResultRowInfo(&pTableQueryInfo->resInfo);
 }
 
 /**
@@ -3971,7 +3711,7 @@ void destroyTableQueryInfoImpl(STableQueryInfo *pTableQueryInfo) {
 void setExecutionContext(SQInfo *pQInfo, int32_t groupIndex, TSKEY nextKey) {
   SQueryRuntimeEnv *pRuntimeEnv     = &pQInfo->runtimeEnv;
   STableQueryInfo  *pTableQueryInfo = pRuntimeEnv->pQuery->current;
-  SResultRowInfo   *pWindowResInfo  = &pRuntimeEnv->windowResInfo;
+  SResultRowInfo   *pWindowResInfo  = &pRuntimeEnv->resultRowInfo;
 
   // lastKey needs to be updated
   pTableQueryInfo->lastKey = nextKey;
@@ -4099,7 +3839,7 @@ int32_t setTimestampListJoinInfo(SQInfo *pQInfo, STableQueryInfo *pTableQueryInf
 int32_t setParamValue(SQueryRuntimeEnv* pRuntimeEnv) {
   SQuery* pQuery = pRuntimeEnv->pQuery;
 
-  if (pRuntimeEnv->prevResult == NULL) {
+  if (pRuntimeEnv->prevResult == NULL || pRuntimeEnv->groupbyColumn) {
     return TSDB_CODE_SUCCESS;
   }
 
@@ -4168,7 +3908,7 @@ void setIntervalQueryRange(SQInfo *pQInfo, TSKEY key) {
      * operations involve.
      */
     STimeWindow     w = TSWINDOW_INITIALIZER;
-    SResultRowInfo *pWindowResInfo = &pTableQueryInfo->windowResInfo;
+    SResultRowInfo *pWindowResInfo = &pTableQueryInfo->resInfo;
 
     TSKEY sk = MIN(win.skey, win.ekey);
     TSKEY ek = MAX(win.skey, win.ekey);
@@ -4211,73 +3951,63 @@ bool needPrimaryTimestampCol(SQuery *pQuery, SDataBlockInfo *pDataBlockInfo) {
   return loadPrimaryTS;
 }
 
-static int32_t doCopyToSData(SQInfo *pQInfo, SResultRow **pRows, int32_t numOfRows, int32_t *index, int32_t orderType) {
-  SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
-  SQuery *          pQuery = pRuntimeEnv->pQuery;
+static int32_t doCopyToSData(SQueryRuntimeEnv* pRuntimeEnv, SGroupResInfo* pGroupResInfo, int32_t orderType) {
+  void* qinfo = GET_QINFO_ADDR(pRuntimeEnv);
+  SQuery *pQuery = pRuntimeEnv->pQuery;
+
+  int32_t numOfRows = getNumOfTotalRes(pGroupResInfo);
+  int32_t numOfResult = (int32_t) pQuery->rec.rows; // there are already exists result rows
 
-  int32_t numOfResult = 0;
   int32_t start = 0;
   int32_t step = -1;
 
-  qDebug("QInfo:%p start to copy data from windowResInfo to query buf", pQInfo);
+  qDebug("QInfo:%p start to copy data from windowResInfo to output buf", qinfo);
   if (orderType == TSDB_ORDER_ASC) {
-    start = (*index);
+    start = pGroupResInfo->index;
     step = 1;
   } else {  // desc order copy all data
-    start = numOfRows - (*index) - 1;
+    start = numOfRows - pGroupResInfo->index - 1;
     step = -1;
   }
 
-  SGroupResInfo* pGroupResInfo = &pQInfo->groupResInfo;
-
   for (int32_t i = start; (i < numOfRows) && (i >= 0); i += step) {
-    if (pRows[i]->numOfRows == 0) {
-      (*index) += 1;
-      pGroupResInfo->rowId = 0;
+    SResultRow* pRow = taosArrayGetP(pGroupResInfo->pRows, i);
+    if (pRow->numOfRows == 0) {
+      pGroupResInfo->index += 1;
       continue;
     }
 
-    int32_t numOfRowsToCopy = pRows[i]->numOfRows - pGroupResInfo->rowId;
-    int32_t oldOffset = pGroupResInfo->rowId;
+    int32_t numOfRowsToCopy = pRow->numOfRows;
 
-    /*
-     * current output space is not enough to accommodate all data of this page, only partial results
-     * will be copied to SQuery object's result buffer
-     */
-    if (numOfRowsToCopy > pQuery->rec.capacity - numOfResult) {
-      numOfRowsToCopy = (int32_t) pQuery->rec.capacity - numOfResult;
-      pGroupResInfo->rowId += numOfRowsToCopy;
-    } else {
-      pGroupResInfo->rowId = 0;
-      (*index) += 1;
+    //current output space is not enough to accommodate all data of this page, prepare more space
+    if (numOfRowsToCopy > (pQuery->rec.capacity - numOfResult)) {
+      int32_t newSize = (int32_t) (pQuery->rec.capacity + (numOfRowsToCopy - numOfResult));
+      expandBuffer(pRuntimeEnv, newSize, GET_QINFO_ADDR(pRuntimeEnv));
     }
 
-    tFilePage *page = getResBufPage(pRuntimeEnv->pResultBuf, pRows[i]->pageId);
+    pGroupResInfo->index += 1;
 
+    tFilePage *page = getResBufPage(pRuntimeEnv->pResultBuf, pRow->pageId);
     for (int32_t j = 0; j < pQuery->numOfOutput; ++j) {
       int32_t size = pRuntimeEnv->pCtx[j].outputBytes;
 
       char *out = pQuery->sdata[j]->data + numOfResult * size;
-      char *in  = getPosInResultPage(pRuntimeEnv, j, pRows[i], page);
-      memcpy(out, in + oldOffset * size, size * numOfRowsToCopy);
+      char *in  = getPosInResultPage(pRuntimeEnv, j, pRow, page);
+      memcpy(out, in, size * numOfRowsToCopy);
     }
 
     numOfResult += numOfRowsToCopy;
-    if (numOfResult == pQuery->rec.capacity) {
+    if (numOfResult == pQuery->rec.capacity) {  // output buffer is full
       break;
     }
   }
 
-  qDebug("QInfo:%p copy data to query buf completed", pQInfo);
-
-#ifdef _DEBUG_VIEW
-  displayInterResult(pQuery->sdata, pRuntimeEnv, numOfResult);
-#endif
+  qDebug("QInfo:%p copy data to query buf completed", qinfo);
   return numOfResult;
 }
 
 /**
- * copyFromWindowResToSData support copy data in ascending/descending order
+ * copyToOutputBuf support copy data in ascending/descending order
  * For interval query of both super table and table, copy the data in ascending order, since the output results are
  * ordered in SWindowResutl already. While handling the group by query for both table and super table,
  * all group result are completed already.
@@ -4285,14 +4015,17 @@ static int32_t doCopyToSData(SQInfo *pQInfo, SResultRow **pRows, int32_t numOfRo
  * @param pQInfo
  * @param result
  */
-void copyFromWindowResToSData(SQInfo *pQInfo, SResultRowInfo *pResultInfo) {
-  SQuery *pQuery = pQInfo->runtimeEnv.pQuery;
+void copyToOutputBuf(SQInfo *pQInfo, SResultRowInfo *pResultInfo) {
+  SQuery        *pQuery = pQInfo->runtimeEnv.pQuery;
+  SGroupResInfo *pGroupResInfo = &pQInfo->groupResInfo;
 
-  int32_t orderType = (pQuery->pGroupbyExpr != NULL) ? pQuery->pGroupbyExpr->orderType : TSDB_ORDER_ASC;
-  int32_t numOfResult = doCopyToSData(pQInfo, pResultInfo->pResult, pResultInfo->size, &pQInfo->groupIndex, orderType);
+  assert(pQuery->rec.rows == 0 && pGroupResInfo->currentGroup <= pGroupResInfo->totalGroup);
+  if (!hasRemainData(pGroupResInfo)) {
+    return;
+  }
 
-  pQuery->rec.rows += numOfResult;
-  assert(pQuery->rec.rows <= pQuery->rec.capacity);
+  int32_t orderType = (pQuery->pGroupbyExpr != NULL) ? pQuery->pGroupbyExpr->orderType : TSDB_ORDER_ASC;
+  pQuery->rec.rows = doCopyToSData(&pQInfo->runtimeEnv, pGroupResInfo, orderType);
 }
 
 static void updateWindowResNumOfRes(SQueryRuntimeEnv *pRuntimeEnv) {
@@ -4303,8 +4036,8 @@ static void updateWindowResNumOfRes(SQueryRuntimeEnv *pRuntimeEnv) {
     return;
   }
 
-  for (int32_t i = 0; i < pRuntimeEnv->windowResInfo.size; ++i) {
-    SResultRow *pResult = pRuntimeEnv->windowResInfo.pResult[i];
+  for (int32_t i = 0; i < pRuntimeEnv->resultRowInfo.size; ++i) {
+    SResultRow *pResult = pRuntimeEnv->resultRowInfo.pResult[i];
 
     for (int32_t j = 0; j < pQuery->numOfOutput; ++j) {
       int32_t functionId = pRuntimeEnv->pCtx[j].functionId;
@@ -4323,7 +4056,7 @@ static void stableApplyFunctionsOnBlock(SQueryRuntimeEnv *pRuntimeEnv, SDataBloc
   SQuery *         pQuery = pRuntimeEnv->pQuery;
   STableQueryInfo* pTableQueryInfo = pQuery->current;
 
-  SResultRowInfo * pResultRowInfo = &pTableQueryInfo->windowResInfo;
+  SResultRowInfo * pResultRowInfo = &pTableQueryInfo->resInfo;
   pQuery->pos = QUERY_IS_ASC_QUERY(pQuery)? 0 : pDataBlockInfo->rows - 1;
 
   if (pQuery->numOfFilterCols > 0 || pRuntimeEnv->pTsBuf != NULL || pRuntimeEnv->groupbyColumn) {
@@ -4337,10 +4070,14 @@ static void stableApplyFunctionsOnBlock(SQueryRuntimeEnv *pRuntimeEnv, SDataBloc
   }
 }
 
-bool hasNotReturnedResults(SQueryRuntimeEnv* pRuntimeEnv) {
+bool hasNotReturnedResults(SQueryRuntimeEnv* pRuntimeEnv, SGroupResInfo* pGroupResInfo) {
   SQuery *pQuery = pRuntimeEnv->pQuery;
   SFillInfo *pFillInfo = pRuntimeEnv->pFillInfo;
 
+  if (!Q_STATUS_EQUAL(pQuery->status, QUERY_COMPLETED)) {
+      return false;
+  }
+
   if (pQuery->limit.limit > 0 && pQuery->rec.total >= pQuery->limit.limit) {
     return false;
   }
@@ -4360,16 +4097,11 @@ bool hasNotReturnedResults(SQueryRuntimeEnv* pRuntimeEnv) {
      * set is the FIRST result block, the gap between the start time of query time window and the timestamp of the
      * first result row in the actual result set will fill nothing.
      */
-    if (Q_STATUS_EQUAL(pQuery->status, QUERY_COMPLETED)) {
-      int32_t numOfTotal = (int32_t)getNumOfResultsAfterFillGap(pFillInfo, pQuery->window.ekey, (int32_t)pQuery->rec.capacity);
-      return numOfTotal > 0;
-    }
-
-  } else {
-    // there are results waiting for returned to client.
-    if (Q_STATUS_EQUAL(pQuery->status, QUERY_COMPLETED) &&
-        (pRuntimeEnv->groupbyColumn || QUERY_IS_INTERVAL_QUERY(pQuery)) &&
-        (pRuntimeEnv->windowResInfo.size > 0)) {
+    int32_t numOfTotal = (int32_t)getNumOfResultsAfterFillGap(pFillInfo, pQuery->window.ekey, (int32_t)pQuery->rec.capacity);
+    return numOfTotal > 0;
+  } else { // there are results waiting for returned to client.
+    if (Q_STATUS_EQUAL(pQuery->status, QUERY_COMPLETED) && hasRemainData(pGroupResInfo) &&
+        (pRuntimeEnv->groupbyColumn || QUERY_IS_INTERVAL_QUERY(pQuery))) {
       return true;
     }
   }
@@ -4429,15 +4161,15 @@ static void doCopyQueryResultToMsg(SQInfo *pQInfo, int32_t numOfRows, char *data
         setQueryStatus(pQuery, QUERY_OVER);
       }
     } else {
-      if (!hasNotReturnedResults(&pQInfo->runtimeEnv)) {
+      if (!hasNotReturnedResults(&pQInfo->runtimeEnv, &pQInfo->groupResInfo)) {
         setQueryStatus(pQuery, QUERY_OVER);
       }
     }
   }
 }
 
-int32_t doFillGapsInResults(SQueryRuntimeEnv* pRuntimeEnv, tFilePage **pDst, int32_t *numOfFilled) {
-  SQInfo* pQInfo = GET_QINFO_ADDR(pRuntimeEnv);
+int32_t doFillGapsInResults(SQueryRuntimeEnv* pRuntimeEnv, tFilePage **pDst) {
+  SQInfo *pQInfo = GET_QINFO_ADDR(pRuntimeEnv);
   SQuery *pQuery = pRuntimeEnv->pQuery;
   SFillInfo* pFillInfo = pRuntimeEnv->pFillInfo;
 
@@ -4456,7 +4188,7 @@ int32_t doFillGapsInResults(SQueryRuntimeEnv* pRuntimeEnv, tFilePage **pDst, int
              pQInfo, pFillInfo->numOfRows, ret, pQuery->limit.offset, ret - pQuery->limit.offset, 0);
 
       ret -= (int32_t)pQuery->limit.offset;
-      for (int32_t i = 0; i < pQuery->numOfOutput; ++i) {
+      for (int32_t i = 0; i < pQuery->numOfOutput; ++i) { //???pExpr1 or pExpr2
         memmove(pDst[i]->data, pDst[i]->data + pQuery->pExpr1[i].bytes * pQuery->limit.offset,
                 ret * pQuery->pExpr1[i].bytes);
       }
@@ -4469,17 +4201,18 @@ int32_t doFillGapsInResults(SQueryRuntimeEnv* pRuntimeEnv, tFilePage **pDst, int
           pQuery->limit.offset - ret);
 
       pQuery->limit.offset -= ret;
-      pQuery->rec.rows = 0;
       ret = 0;
     }
 
-    if (!hasNotReturnedResults(pRuntimeEnv)) {
-      return ret;
+    // no data in current data after fill
+    int32_t numOfTotal = (int32_t)getNumOfResultsAfterFillGap(pFillInfo, pFillInfo->end, (int32_t)pQuery->rec.capacity);
+    if (numOfTotal == 0) {
+      return 0;
     }
   }
 }
 
-static void queryCostStatis(SQInfo *pQInfo) {
+void queryCostStatis(SQInfo *pQInfo) {
   SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
   SQueryCostInfo *pSummary = &pRuntimeEnv->summary;
 
@@ -4571,7 +4304,7 @@ static void generateBlockDistResult(STableBlockDist *pTableBlockDist) {
   if (pTableBlockDist == NULL) {
      return;
   }
-  int64_t min = 0, max = 0, avg = 0;    
+  int64_t min = 0, max = 0, avg = 0;
   SArray* blockInfos= pTableBlockDist->dataBlockInfos;  
   int64_t totalRows = 0, totalBlocks = taosArrayGetSize(blockInfos); 
   for (size_t i = 0; i < taosArrayGetSize(blockInfos); i++) {
@@ -4637,7 +4370,7 @@ void skipBlocks(SQueryRuntimeEnv *pRuntimeEnv) {
 
 static TSKEY doSkipIntervalProcess(SQueryRuntimeEnv* pRuntimeEnv, STimeWindow* win, SDataBlockInfo* pBlockInfo, STableQueryInfo* pTableQueryInfo) {
   SQuery *pQuery = pRuntimeEnv->pQuery;
-  SResultRowInfo *pWindowResInfo = &pRuntimeEnv->windowResInfo;
+  SResultRowInfo *pWindowResInfo = &pRuntimeEnv->resultRowInfo;
 
   assert(pQuery->limit.offset == 0);
   STimeWindow tw = *win;
@@ -4665,10 +4398,10 @@ static TSKEY doSkipIntervalProcess(SQueryRuntimeEnv* pRuntimeEnv, STimeWindow* w
     TSKEY key = pTableQueryInfo->win.skey;
 
     pWindowResInfo->prevSKey = tw.skey;
-    int32_t index = pRuntimeEnv->windowResInfo.curIndex;
+    int32_t index = pRuntimeEnv->resultRowInfo.curIndex;
 
     int32_t numOfRes = tableApplyFunctionsOnBlock(pRuntimeEnv, pBlockInfo, NULL, binarySearchForKey, pDataBlock);
-    pRuntimeEnv->windowResInfo.curIndex = index;  // restore the window index
+    pRuntimeEnv->resultRowInfo.curIndex = index;  // restore the window index
 
     qDebug("QInfo:%p check data block, brange:%" PRId64 "-%" PRId64 ", numOfRows:%d, numOfRes:%d, lastKey:%" PRId64,
            GET_QINFO_ADDR(pRuntimeEnv), pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows, numOfRes,
@@ -4704,12 +4437,12 @@ static bool skipTimeInterval(SQueryRuntimeEnv *pRuntimeEnv, TSKEY* start) {
    *    pQuery->limit.offset times. Since hole exists, pQuery->interval.interval*pQuery->limit.offset value is
    *    not valid. otherwise, we only forward pQuery->limit.offset number of points
    */
-  assert(pRuntimeEnv->windowResInfo.prevSKey == TSKEY_INITIAL_VAL);
+  assert(pRuntimeEnv->resultRowInfo.prevSKey == TSKEY_INITIAL_VAL);
 
   STimeWindow w = TSWINDOW_INITIALIZER;
   bool ascQuery = QUERY_IS_ASC_QUERY(pQuery);
 
-  SResultRowInfo *pWindowResInfo = &pRuntimeEnv->windowResInfo;
+  SResultRowInfo *pWindowResInfo = &pRuntimeEnv->resultRowInfo;
   STableQueryInfo *pTableQueryInfo = pQuery->current;
 
   SDataBlockInfo blockInfo = SDATA_BLOCK_INITIALIZER;
@@ -4890,7 +4623,6 @@ int32_t doInitQInfo(SQInfo *pQInfo, STSBuf *pTsBuf, SArray* prevResult, void *ts
   pRuntimeEnv->topBotQuery = isTopBottomQuery(pQuery);
   pRuntimeEnv->hasTagResults = hasTagValOutput(pQuery);
   pRuntimeEnv->timeWindowInterpo = timeWindowInterpoRequired(pQuery);
-
   pRuntimeEnv->prevResult = prevResult;
 
   setScanLimitationByResultBuffer(pQuery);
@@ -4902,6 +4634,7 @@ int32_t doInitQInfo(SQInfo *pQInfo, STSBuf *pTsBuf, SArray* prevResult, void *ts
 
   pQInfo->tsdb = tsdb;
   pQInfo->vgId = vgId;
+  pQInfo->groupResInfo.totalGroup = (int32_t) (isSTableQuery? GET_NUM_OF_TABLEGROUP(pQInfo):0);
 
   pRuntimeEnv->pQuery = pQuery;
   pRuntimeEnv->pTsBuf = pTsBuf;
@@ -4909,6 +4642,7 @@ int32_t doInitQInfo(SQInfo *pQInfo, STSBuf *pTsBuf, SArray* prevResult, void *ts
   pRuntimeEnv->stableQuery = isSTableQuery;
   pRuntimeEnv->prevGroupId = INT32_MIN;
   pRuntimeEnv->groupbyColumn = isGroupbyColumn(pQuery->pGroupbyExpr);
+  pRuntimeEnv->stabledev = isStabledev(pQuery);
 
   if (pTsBuf != NULL) {
     int16_t order = (pQuery->order.order == pRuntimeEnv->pTsBuf->tsOrder) ? TSDB_ORDER_ASC : TSDB_ORDER_DESC;
@@ -4934,7 +4668,7 @@ int32_t doInitQInfo(SQInfo *pQInfo, STSBuf *pTsBuf, SArray* prevResult, void *ts
         type = TSDB_DATA_TYPE_INT;  // group id
       }
 
-      code = initResultRowInfo(&pRuntimeEnv->windowResInfo, 8, type);
+      code = initResultRowInfo(&pRuntimeEnv->resultRowInfo, 8, type);
       if (code != TSDB_CODE_SUCCESS) {
         return code;
       }
@@ -4954,14 +4688,14 @@ int32_t doInitQInfo(SQInfo *pQInfo, STSBuf *pTsBuf, SArray* prevResult, void *ts
       type = TSDB_DATA_TYPE_TIMESTAMP;
     }
 
-    code = initResultRowInfo(&pRuntimeEnv->windowResInfo, numOfResultRows, type);
+    code = initResultRowInfo(&pRuntimeEnv->resultRowInfo, numOfResultRows, type);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
     }
   }
 
   // create runtime environment
-  code = setupQueryRuntimeEnv(pRuntimeEnv, (int32_t) pQInfo->tableGroupInfo.numOfTables, pQuery->order.order);
+  code = setupQueryRuntimeEnv(pRuntimeEnv, (int32_t) pQInfo->tableGroupInfo.numOfTables, pQuery->order.order, pQInfo->vgId);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
@@ -5008,13 +4742,6 @@ static FORCE_INLINE void setEnvForEachBlock(SQInfo* pQInfo, STableQueryInfo* pTa
     setTimestampListJoinInfo(pQInfo, pTableQueryInfo);
   }
 
-  for(int32_t i = 0; i < pQuery->numOfOutput; ++i) {
-    if (pQuery->pExpr1[i].base.functionId == TSDB_FUNC_STDDEV_DST) {
-      setParamValue(pRuntimeEnv);
-      break;
-    }
-  }
-
   if (QUERY_IS_INTERVAL_QUERY(pQuery)) {
     setIntervalQueryRange(pQInfo, pBlockInfo->window.skey);
   } else {  // non-interval query
@@ -5068,11 +4795,20 @@ static int64_t scanMultiTableDataBlocks(SQInfo *pQInfo) {
       setEnvForEachBlock(pQInfo, *pTableQueryInfo, &blockInfo);
     }
 
+    if (pRuntimeEnv->stabledev) {
+      for(int32_t i = 0; i < pQuery->numOfOutput; ++i) {
+        if (pQuery->pExpr1[i].base.functionId == TSDB_FUNC_STDDEV_DST) {
+          setParamValue(pRuntimeEnv);
+          break;
+        }
+      }
+    }
+
     uint32_t     status = 0;
     SDataStatis *pStatis = NULL;
     SArray      *pDataBlock = NULL;
 
-    int32_t ret = loadDataBlockOnDemand(pRuntimeEnv, &pQuery->current->windowResInfo, pQueryHandle, &blockInfo, &pStatis, &pDataBlock, &status);
+    int32_t ret = loadDataBlockOnDemand(pRuntimeEnv, &pQuery->current->resInfo, pQueryHandle, &blockInfo, &pStatis, &pDataBlock, &status);
     if (ret != TSDB_CODE_SUCCESS) {
       break;
     }
@@ -5366,7 +5102,7 @@ static void sequentialTableProcess(SQInfo *pQInfo) {
       taosArrayDestroy(s);
 
       // no results generated for current group, continue to try the next group
-      SResultRowInfo *pWindowResInfo = &pRuntimeEnv->windowResInfo;
+      SResultRowInfo *pWindowResInfo = &pRuntimeEnv->resultRowInfo;
       if (pWindowResInfo->size <= 0) {
         continue;
       }
@@ -5383,17 +5119,18 @@ static void sequentialTableProcess(SQInfo *pQInfo) {
 
       qDebug("QInfo:%p generated groupby columns results %d rows for group %d completed", pQInfo, pWindowResInfo->size,
              pQInfo->groupIndex);
-      int32_t currentGroupIndex = pQInfo->groupIndex;
 
       pQuery->rec.rows = 0;
-      pQInfo->groupIndex = 0;
-
-      ensureOutputBufferSimple(pRuntimeEnv, pWindowResInfo->size);
-      copyFromWindowResToSData(pQInfo, pWindowResInfo);
+      if (pWindowResInfo->size > pQuery->rec.capacity) {
+        expandBuffer(pRuntimeEnv, pWindowResInfo->size, pQInfo);
+      }
 
-      pQInfo->groupIndex = currentGroupIndex;  // restore the group index
+      initGroupResInfo(&pQInfo->groupResInfo, &pRuntimeEnv->resultRowInfo, 0);
+      copyToOutputBuf(pQInfo, pWindowResInfo);
       assert(pQuery->rec.rows == pWindowResInfo->size);
-      resetResultRowInfo(pRuntimeEnv, &pRuntimeEnv->windowResInfo);
+
+      resetResultRowInfo(pRuntimeEnv, &pRuntimeEnv->resultRowInfo);
+      cleanupGroupResInfo(&pQInfo->groupResInfo);
       break;
     }
   } else if (pRuntimeEnv->queryWindowIdentical && pRuntimeEnv->pTsBuf == NULL && !isTsCompQuery(pQuery)) {
@@ -5449,7 +5186,7 @@ static void sequentialTableProcess(SQInfo *pQInfo) {
         setTagVal(pRuntimeEnv, pQuery->current->pTable);
       }
 
-      if (pQuery->prjInfo.vgroupLimit > 0 && pQuery->current->windowResInfo.size > pQuery->prjInfo.vgroupLimit) {
+      if (pQuery->prjInfo.vgroupLimit > 0 && pQuery->current->resInfo.size > pQuery->prjInfo.vgroupLimit) {
         pQuery->current->lastKey =
                 QUERY_IS_ASC_QUERY(pQuery) ? blockInfo.window.ekey + step : blockInfo.window.skey + step;
         continue;
@@ -5472,7 +5209,7 @@ static void sequentialTableProcess(SQInfo *pQInfo) {
       SDataStatis *pStatis = NULL;
       SArray      *pDataBlock = NULL;
 
-      int32_t ret = loadDataBlockOnDemand(pRuntimeEnv, &pQuery->current->windowResInfo, pQueryHandle, &blockInfo,
+      int32_t ret = loadDataBlockOnDemand(pRuntimeEnv, &pQuery->current->resInfo, pQueryHandle, &blockInfo,
                                           &pStatis, &pDataBlock, &status);
       if (ret != TSDB_CODE_SUCCESS) {
         break;
@@ -5484,7 +5221,7 @@ static void sequentialTableProcess(SQInfo *pQInfo) {
         continue;
       }
 
-      ensureOutputBuffer(pRuntimeEnv, &blockInfo);
+      ensureOutputBuffer(pRuntimeEnv, blockInfo.rows);
       int64_t prev = getNumOfResult(pRuntimeEnv);
 
       pQuery->pos = QUERY_IS_ASC_QUERY(pQuery) ? 0 : blockInfo.rows - 1;
@@ -5498,7 +5235,7 @@ static void sequentialTableProcess(SQInfo *pQInfo) {
       pQuery->rec.rows = getNumOfResult(pRuntimeEnv);
 
       int64_t inc = pQuery->rec.rows - prev;
-      pQuery->current->windowResInfo.size += (int32_t) inc;
+      pQuery->current->resInfo.size += (int32_t) inc;
 
       // the flag may be set by tableApplyFunctionsOnBlock, clear it here
       CLEAR_QUERY_STATUS(pQuery, QUERY_COMPLETED);
@@ -5516,8 +5253,7 @@ static void sequentialTableProcess(SQInfo *pQInfo) {
       } else {
         // the limitation of output result is reached, set the query completed
         skipResults(pRuntimeEnv);
-        if (limitOperator(pRuntimeEnv)) {
-          setQueryStatus(pQuery, QUERY_COMPLETED);
+        if (limitOperator(pQuery, pQInfo)) {
           SET_STABLE_QUERY_OVER(pQInfo);
           break;
         }
@@ -5540,8 +5276,8 @@ static void sequentialTableProcess(SQInfo *pQInfo) {
      * If the subgroup index is larger than 0, results generated by group by tbname,k is existed.
      * we need to return it to client in the first place.
      */
-    if (pQInfo->groupIndex > 0) {
-      copyFromWindowResToSData(pQInfo, &pRuntimeEnv->windowResInfo);
+    if (hasRemainData(&pQInfo->groupResInfo)) {
+      copyToOutputBuf(pQInfo, &pRuntimeEnv->resultRowInfo);
       pQuery->rec.total += pQuery->rec.rows;
 
       if (pQuery->rec.rows > 0) {
@@ -5555,7 +5291,7 @@ static void sequentialTableProcess(SQInfo *pQInfo) {
     }
 
     resetDefaultResInfoOutputBuf(pRuntimeEnv);
-    resetResultRowInfo(pRuntimeEnv, &pRuntimeEnv->windowResInfo);
+    resetResultRowInfo(pRuntimeEnv, &pRuntimeEnv->resultRowInfo);
 
     SArray *group = GET_TABLEGROUP(pQInfo, 0);
     assert(taosArrayGetSize(group) == pQInfo->tableqinfoGroupInfo.numOfTables &&
@@ -5584,7 +5320,7 @@ static void sequentialTableProcess(SQInfo *pQInfo) {
       skipResults(pRuntimeEnv);
 
       // the limitation of output result is reached, set the query completed
-      if (limitOperator(pRuntimeEnv)) {
+      if (limitOperator(pQuery, pQInfo)) {
         SET_STABLE_QUERY_OVER(pQInfo);
         break;
       }
@@ -5709,11 +5445,11 @@ static void doCloseAllTimeWindow(SQInfo *pQInfo) {
       size_t num = taosArrayGetSize(group);
       for (int32_t j = 0; j < num; ++j) {
         STableQueryInfo* item = taosArrayGetP(group, j);
-        closeAllResultRows(&item->windowResInfo);
+        closeAllResultRows(&item->resInfo);
       }
     }
   } else {  // close results for group result
-    closeAllResultRows(&pQInfo->runtimeEnv.windowResInfo);
+    closeAllResultRows(&pQInfo->runtimeEnv.resultRowInfo);
   }
 }
 
@@ -5721,18 +5457,14 @@ static void multiTableQueryProcess(SQInfo *pQInfo) {
   SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
   SQuery           *pQuery = pRuntimeEnv->pQuery;
 
-  if (pQInfo->groupIndex > 0) {
-    /*
-     * if the groupIndex > 0, the query process must be completed yet, we only need to
-     * copy the data into output buffer
-     */
+  if (Q_STATUS_EQUAL(pQuery->status, QUERY_COMPLETED)) {
     if (QUERY_IS_INTERVAL_QUERY(pQuery)) {
       copyResToQueryResultBuf(pQInfo, pQuery);
     } else {
-      copyFromWindowResToSData(pQInfo, &pRuntimeEnv->windowResInfo);
+      copyToOutputBuf(pQInfo, &pRuntimeEnv->resultRowInfo);
     }
 
-    qDebug("QInfo:%p current:%"PRId64", total:%"PRId64"", pQInfo, pQuery->rec.rows, pQuery->rec.total);
+    qDebug("QInfo:%p current:%"PRId64", total:%"PRId64, pQInfo, pQuery->rec.rows, pQuery->rec.total);
     return;
   }
 
@@ -5774,18 +5506,10 @@ static void multiTableQueryProcess(SQInfo *pQInfo) {
   }
 
   if (QUERY_IS_INTERVAL_QUERY(pQuery) || isSumAvgRateQuery(pQuery)) {
-    int32_t code = mergeGroupResult(pQInfo);
-    if (code == TSDB_CODE_SUCCESS) {
-      copyResToQueryResultBuf(pQInfo, pQuery);
-
-#ifdef _DEBUG_VIEW
-      displayInterResult(pQuery->sdata, pRuntimeEnv, pQuery->sdata[0]->num);
-#endif
-    } else {  // set the error code
-      pQInfo->code = code;
-    }
+    copyResToQueryResultBuf(pQInfo, pQuery);
   } else {  // not a interval query
-    copyFromWindowResToSData(pQInfo, &pRuntimeEnv->windowResInfo);
+    initGroupResInfo(&pQInfo->groupResInfo, &pRuntimeEnv->resultRowInfo, 0);
+    copyToOutputBuf(pQInfo, &pRuntimeEnv->resultRowInfo);
   }
 
   // handle the limitation of output buffer
@@ -5889,7 +5613,7 @@ static void tableAggregationProcess(SQInfo *pQInfo, STableQueryInfo* pTableInfo)
 
   // TODO limit/offset refactor to be one operator
   skipResults(pRuntimeEnv);
-  limitOperator(pRuntimeEnv);
+  limitOperator(pQuery, pQInfo);
 }
 
 static void tableProjectionProcess(SQInfo *pQInfo, STableQueryInfo* pTableInfo) {
@@ -5931,7 +5655,7 @@ static void tableProjectionProcess(SQInfo *pQInfo, STableQueryInfo* pTableInfo)
     resetDefaultResInfoOutputBuf(pRuntimeEnv);
   }
 
-  limitOperator(pRuntimeEnv);
+  limitOperator(pQuery, pQInfo);
   if (Q_STATUS_EQUAL(pQuery->status, QUERY_RESBUF_FULL)) {
     qDebug("QInfo:%p query paused due to output limitation, next qrange:%" PRId64 "-%" PRId64, pQInfo,
         pQuery->current->lastKey, pQuery->window.ekey);
@@ -5945,6 +5669,40 @@ static void tableProjectionProcess(SQInfo *pQInfo, STableQueryInfo* pTableInfo)
   }
 }
 
+static void copyAndFillResult(SQInfo* pQInfo) {
+  SQueryRuntimeEnv* pRuntimeEnv = &pQInfo->runtimeEnv;
+  SQuery* pQuery = pRuntimeEnv->pQuery;
+
+  while(1) {
+    copyToOutputBuf(pQInfo, &pRuntimeEnv->resultRowInfo);
+    doSecondaryArithmeticProcess(pQuery);
+
+    TSKEY lastKey = 0;
+    if (!hasRemainData(&pQInfo->groupResInfo)) {
+      lastKey = pQuery->window.ekey;
+    } else {
+      lastKey = ((TSKEY*)pQuery->sdata[0]->data)[pQuery->rec.rows - 1];
+    }
+
+    assert(lastKey <= pQuery->window.ekey);
+
+    taosFillSetStartInfo(pRuntimeEnv->pFillInfo, (int32_t)pQuery->rec.rows, lastKey);
+    taosFillSetDataBlockFromFilePage(pRuntimeEnv->pFillInfo, (const tFilePage **)pQuery->sdata);
+
+    pQuery->rec.rows = doFillGapsInResults(pRuntimeEnv, (tFilePage **)pQuery->sdata);
+
+    if (pQuery->rec.rows > 0) {
+      limitOperator(pQuery, pQInfo);
+      break;
+    }
+
+    // here the pQuery->rec.rows == 0
+    if (!hasRemainData(&pQInfo->groupResInfo) && !taosFillHasMoreResults(pRuntimeEnv->pFillInfo)) {
+      break;
+    }
+  }
+}
+
 // handle time interval query on table
 static void tableIntervalProcess(SQInfo *pQInfo, STableQueryInfo* pTableInfo) {
   SQueryRuntimeEnv *pRuntimeEnv = &(pQInfo->runtimeEnv);
@@ -5968,69 +5726,56 @@ static void tableIntervalProcess(SQInfo *pQInfo, STableQueryInfo* pTableInfo) {
   pQuery->rec.rows = 0;
 
   // not fill or no result generated during this query
-  if (pQuery->fillType == TSDB_FILL_NONE || pRuntimeEnv->windowResInfo.size == 0 || isPointInterpoQuery(pQuery)) {
+  if (pQuery->fillType == TSDB_FILL_NONE || pRuntimeEnv->resultRowInfo.size == 0 || isPointInterpoQuery(pQuery)) {
     // all data scanned, the group by normal column can return
-    int32_t numOfClosed = numOfClosedResultRows(&pRuntimeEnv->windowResInfo);
-    if (pQuery->limit.offset > numOfClosed) {
+    int32_t numOfClosed = numOfClosedResultRows(&pRuntimeEnv->resultRowInfo);
+    if (pQuery->limit.offset > numOfClosed || numOfClosed == 0) {
       return;
     }
 
-    pQInfo->groupIndex = (int32_t) pQuery->limit.offset;
-
-    copyFromWindowResToSData(pQInfo, &pRuntimeEnv->windowResInfo);
+    initGroupResInfo(&pQInfo->groupResInfo, &pRuntimeEnv->resultRowInfo, (int32_t) pQuery->limit.offset);
+    copyToOutputBuf(pQInfo, &pRuntimeEnv->resultRowInfo);
     doSecondaryArithmeticProcess(pQuery);
 
-    limitOperator(pRuntimeEnv);
+    limitOperator(pQuery, pQInfo);
   } else {
-
-    copyFromWindowResToSData(pQInfo, &pRuntimeEnv->windowResInfo);
-    doSecondaryArithmeticProcess(pQuery);
-
-    taosFillSetStartInfo(pRuntimeEnv->pFillInfo, (int32_t)pQuery->rec.rows, pQuery->window.ekey);
-    taosFillSetDataBlockFromFilePage(pRuntimeEnv->pFillInfo, (const tFilePage **)pQuery->sdata);
-
-    int32_t numOfFilled = 0;
-    pQuery->rec.rows = doFillGapsInResults(pRuntimeEnv, (tFilePage **)pQuery->sdata, &numOfFilled);
-
-    if (pQuery->rec.rows > 0 || Q_STATUS_EQUAL(pQuery->status, QUERY_COMPLETED)) {
-      limitOperator(pRuntimeEnv);
-    }
+    initGroupResInfo(&pQInfo->groupResInfo, &pRuntimeEnv->resultRowInfo, 0);
+    copyAndFillResult(pQInfo);
   }
 }
 
-static void tableQueryImpl(SQInfo *pQInfo) {
+void tableQueryImpl(SQInfo *pQInfo) {
   SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
   SQuery *          pQuery = pRuntimeEnv->pQuery;
 
-  if (hasNotReturnedResults(pRuntimeEnv)) {
+  if (hasNotReturnedResults(pRuntimeEnv, &pQInfo->groupResInfo)) {
     if (pQuery->fillType != TSDB_FILL_NONE && !isPointInterpoQuery(pQuery)) {
       /*
        * There are remain results that are not returned due to result interpolation
        * So, we do keep in this procedure instead of launching retrieve procedure for next results.
        */
-      int32_t numOfFilled = 0;
-      pQuery->rec.rows = doFillGapsInResults(pRuntimeEnv, (tFilePage **)pQuery->sdata, &numOfFilled);
-
+      pQuery->rec.rows = doFillGapsInResults(pRuntimeEnv, (tFilePage **)pQuery->sdata);
       if (pQuery->rec.rows > 0) {
-        limitOperator(pRuntimeEnv);
+        limitOperator(pQuery, pQInfo);
+        qDebug("QInfo:%p current:%" PRId64 " returned, total:%" PRId64, pQInfo, pQuery->rec.rows, pQuery->rec.total);
+      } else {
+        copyAndFillResult(pQInfo);
       }
 
-      qDebug("QInfo:%p current:%" PRId64 " returned, total:%" PRId64, pQInfo, pQuery->rec.rows, pQuery->rec.total);
     } else {
       pQuery->rec.rows = 0;
-      assert(pRuntimeEnv->windowResInfo.size > 0);
+      assert(pRuntimeEnv->resultRowInfo.size > 0);
+      copyToOutputBuf(pQInfo, &pRuntimeEnv->resultRowInfo);
+      doSecondaryArithmeticProcess(pQuery);
 
-      if (pQInfo->groupIndex < pRuntimeEnv->windowResInfo.size) {
-        copyFromWindowResToSData(pQInfo, &pRuntimeEnv->windowResInfo);
+      if (pQuery->rec.rows > 0) {
+        limitOperator(pQuery, pQInfo);
       }
 
       if (pQuery->rec.rows > 0) {
         qDebug("QInfo:%p %" PRId64 " rows returned from group results, total:%" PRId64 "", pQInfo, pQuery->rec.rows,
                pQuery->rec.total);
-      }
-
-      // there are not data remains
-      if (pQuery->rec.rows <= 0 || pRuntimeEnv->windowResInfo.size <= pQInfo->groupIndex) {
+      } else {
         qDebug("QInfo:%p query over, %" PRId64 " rows are returned", pQInfo, pQuery->rec.total);
       }
     }
@@ -6062,7 +5807,8 @@ static void tableQueryImpl(SQInfo *pQInfo) {
   pRuntimeEnv->summary.elapsedTime += (taosGetTimestampUs() - st);
   assert(pQInfo->tableqinfoGroupInfo.numOfTables == 1);
 }
-static void buildTableBlockDistResult(SQInfo *pQInfo) {
+
+void buildTableBlockDistResult(SQInfo *pQInfo) {
   SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
   SQuery *pQuery = pRuntimeEnv->pQuery;
   pQuery->pos = 0;
@@ -6115,7 +5861,7 @@ static void buildTableBlockDistResult(SQInfo *pQInfo) {
   return;
 }
 
-static void stableQueryImpl(SQInfo *pQInfo) {
+void stableQueryImpl(SQInfo *pQInfo) {
   SQueryRuntimeEnv* pRuntimeEnv = &pQInfo->runtimeEnv;
   SQuery *pQuery = pRuntimeEnv->pQuery;
   pQuery->rec.rows = 0;
@@ -6127,7 +5873,6 @@ static void stableQueryImpl(SQInfo *pQInfo) {
     multiTableQueryProcess(pQInfo);
   } else {
     assert(pQuery->checkResultBuf == 1 || isPointInterpoQuery(pQuery) || pRuntimeEnv->groupbyColumn);
-
     sequentialTableProcess(pQInfo);
   }
 
@@ -6247,37 +5992,6 @@ static char *createTableIdList(SQueryTableMsg *pQueryMsg, char *pMsg, SArray **p
   return pMsg;
 }
 
-typedef struct SQueryParam {
-  char            *sql;
-  char            *tagCond;
-  char            *tbnameCond;
-  char            *prevResult;
-  SArray          *pTableIdList;
-  SSqlFuncMsg    **pExprMsg;
-  SSqlFuncMsg    **pSecExprMsg;
-  SExprInfo       *pExprs;
-  SExprInfo       *pSecExprs;
-
-  SColIndex       *pGroupColIndex;
-  SColumnInfo     *pTagColumnInfo;
-  SSqlGroupbyExpr *pGroupbyExpr;
-} SQueryParam;
-
-static void freeParam(SQueryParam *param) {
-  tfree(param->sql);
-  tfree(param->tagCond);
-  tfree(param->tbnameCond);
-  tfree(param->pTableIdList);
-  tfree(param->pExprMsg);
-  tfree(param->pSecExprMsg);
-  tfree(param->pExprs);
-  tfree(param->pSecExprs);
-  tfree(param->pGroupColIndex);
-  tfree(param->pTagColumnInfo);
-  tfree(param->pGroupbyExpr);
-  tfree(param->prevResult);
-}
-
 /**
  * pQueryMsg->head has been converted before this function is called.
  *
@@ -6286,7 +6000,7 @@ static void freeParam(SQueryParam *param) {
  * @param pExpr
  * @return
  */
-static int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SQueryParam* param) {
+int32_t convertQueryMsg(SQueryTableMsg *pQueryMsg, SQueryParam* param) {
   int32_t code = TSDB_CODE_SUCCESS;
 
   if (taosCheckVersion(pQueryMsg->version, version, 3) != 0) {
@@ -6604,7 +6318,7 @@ static int32_t buildArithmeticExprFromMsg(SExprInfo *pArithExprInfo, SQueryTable
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t createQueryFuncExprFromMsg(SQueryTableMsg *pQueryMsg, int32_t numOfOutput, SExprInfo **pExprInfo, SSqlFuncMsg **pExprMsg,
+int32_t createQueryFuncExprFromMsg(SQueryTableMsg *pQueryMsg, int32_t numOfOutput, SExprInfo **pExprInfo, SSqlFuncMsg **pExprMsg,
     SColumnInfo* pTagCols) {
   *pExprInfo = NULL;
   int32_t code = TSDB_CODE_SUCCESS;
@@ -6714,7 +6428,7 @@ static int32_t createQueryFuncExprFromMsg(SQueryTableMsg *pQueryMsg, int32_t num
   return TSDB_CODE_SUCCESS;
 }
 
-static SSqlGroupbyExpr *createGroupbyExprFromMsg(SQueryTableMsg *pQueryMsg, SColIndex *pColIndex, int32_t *code) {
+SSqlGroupbyExpr *createGroupbyExprFromMsg(SQueryTableMsg *pQueryMsg, SColIndex *pColIndex, int32_t *code) {
   if (pQueryMsg->numOfGroupCols == 0) {
     return NULL;
   }
@@ -6831,8 +6545,6 @@ static void doUpdateExprColumnIndex(SQuery *pQuery) {
   }
 }
 
-static void freeQInfo(SQInfo *pQInfo);
-
 static void calResultBufSize(SQuery* pQuery) {
   const int32_t RESULT_MSG_MIN_SIZE  = 1024 * (1024 + 512);  // bytes
   const int32_t RESULT_MSG_MIN_ROWS  = 8192;
@@ -6852,7 +6564,7 @@ static void calResultBufSize(SQuery* pQuery) {
   }
 }
 
-static SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SSqlGroupbyExpr *pGroupbyExpr, SExprInfo *pExprs,
+SQInfo *createQInfoImpl(SQueryTableMsg *pQueryMsg, SSqlGroupbyExpr *pGroupbyExpr, SExprInfo *pExprs,
                                SExprInfo *pSecExprs, STableGroupInfo *pTableGroupInfo, SColumnInfo* pTagCols, bool stableQuery, char* sql) {
   int16_t numOfCols = pQueryMsg->numOfCols;
   int16_t numOfOutput = pQueryMsg->numOfOutput;
@@ -7060,7 +6772,7 @@ _cleanup:
   return NULL;
 }
 
-static bool isValidQInfo(void *param) {
+bool isValidQInfo(void *param) {
   SQInfo *pQInfo = (SQInfo *)param;
   if (pQInfo == NULL) {
     return false;
@@ -7074,7 +6786,7 @@ static bool isValidQInfo(void *param) {
   return (sig == (uint64_t)pQInfo);
 }
 
-static int32_t initQInfo(SQueryTableMsg *pQueryMsg, void *tsdb, int32_t vgId, SQInfo *pQInfo, SQueryParam* param, bool isSTable) {
+int32_t initQInfo(SQueryTableMsg *pQueryMsg, void *tsdb, int32_t vgId, SQInfo *pQInfo, SQueryParam* param, bool isSTable) {
   int32_t code = TSDB_CODE_SUCCESS;
   SQuery *pQuery = pQInfo->runtimeEnv.pQuery;
 
@@ -7125,7 +6837,7 @@ _error:
   return code;
 }
 
-static void freeColumnFilterInfo(SColumnFilterInfo* pFilter, int32_t numOfFilters) {
+void freeColumnFilterInfo(SColumnFilterInfo* pFilter, int32_t numOfFilters) {
     if (pFilter == NULL || numOfFilters == 0) {
       return;
     }
@@ -7179,7 +6891,7 @@ static void* destroyQueryFuncExpr(SExprInfo* pExprInfo, int32_t numOfExpr) {
   return NULL;
 }
 
-static void freeQInfo(SQInfo *pQInfo) {
+void freeQInfo(SQInfo *pQInfo) {
   if (!isValidQInfo(pQInfo)) {
     return;
   }
@@ -7248,7 +6960,7 @@ static void freeQInfo(SQInfo *pQInfo) {
   tfree(pQInfo);
 }
 
-static size_t getResultSize(SQInfo *pQInfo, int64_t *numOfRows) {
+size_t getResultSize(SQInfo *pQInfo, int64_t *numOfRows) {
   SQuery *pQuery = pQInfo->runtimeEnv.pQuery;
 
   /*
@@ -7271,7 +6983,7 @@ static size_t getResultSize(SQInfo *pQInfo, int64_t *numOfRows) {
   }
 }
 
-static int32_t doDumpQueryResult(SQInfo *pQInfo, char *data) {
+int32_t doDumpQueryResult(SQInfo *pQInfo, char *data) {
   // the remained number of retrieved rows, not the interpolated result
   SQuery *pQuery = pQInfo->runtimeEnv.pQuery;
 
@@ -7326,154 +7038,7 @@ static int32_t doDumpQueryResult(SQInfo *pQInfo, char *data) {
   return TSDB_CODE_SUCCESS;
 }
 
-typedef struct SQueryMgmt {
-  pthread_mutex_t lock;
-  SCacheObj      *qinfoPool;      // query handle pool
-  int32_t         vgId;
-  bool            closed;
-} SQueryMgmt;
-
-int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryMsg, qinfo_t* pQInfo) {
-  assert(pQueryMsg != NULL && tsdb != NULL);
-
-  int32_t code = TSDB_CODE_SUCCESS;
-
-  SQueryParam param = {0};
-  code = convertQueryMsg(pQueryMsg, &param);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _over;
-  }
-
-  if (pQueryMsg->numOfTables <= 0) {
-    qError("Invalid number of tables to query, numOfTables:%d", pQueryMsg->numOfTables);
-    code = TSDB_CODE_QRY_INVALID_MSG;
-    goto _over;
-  }
-
-  if (param.pTableIdList == NULL || taosArrayGetSize(param.pTableIdList) == 0) {
-    qError("qmsg:%p, SQueryTableMsg wrong format", pQueryMsg);
-    code = TSDB_CODE_QRY_INVALID_MSG;
-    goto _over;
-  }
-
-  if ((code = createQueryFuncExprFromMsg(pQueryMsg, pQueryMsg->numOfOutput, &param.pExprs, param.pExprMsg, param.pTagColumnInfo)) != TSDB_CODE_SUCCESS) {
-    goto _over;
-  }
-
-  if (param.pSecExprMsg != NULL) {
-    if ((code = createQueryFuncExprFromMsg(pQueryMsg, pQueryMsg->secondStageOutput, &param.pSecExprs, param.pSecExprMsg, param.pTagColumnInfo)) != TSDB_CODE_SUCCESS) {
-      goto _over;
-    }
-  }
-
-  param.pGroupbyExpr = createGroupbyExprFromMsg(pQueryMsg, param.pGroupColIndex, &code);
-  if ((param.pGroupbyExpr == NULL && pQueryMsg->numOfGroupCols != 0) || code != TSDB_CODE_SUCCESS) {
-    goto _over;
-  }
-
-  bool isSTableQuery = false;
-  STableGroupInfo tableGroupInfo = {0};
-  int64_t st = taosGetTimestampUs();
-
-  if (TSDB_QUERY_HAS_TYPE(pQueryMsg->queryType, TSDB_QUERY_TYPE_TABLE_QUERY)) {
-    STableIdInfo *id = taosArrayGet(param.pTableIdList, 0);
-
-    qDebug("qmsg:%p query normal table, uid:%"PRId64", tid:%d", pQueryMsg, id->uid, id->tid);
-    if ((code = tsdbGetOneTableGroup(tsdb, id->uid, pQueryMsg->window.skey, &tableGroupInfo)) != TSDB_CODE_SUCCESS) {
-      goto _over;
-    }
-  } else if (TSDB_QUERY_HAS_TYPE(pQueryMsg->queryType, TSDB_QUERY_TYPE_MULTITABLE_QUERY|TSDB_QUERY_TYPE_STABLE_QUERY)) {
-    isSTableQuery = true;
-
-    // also note there's possibility that only one table in the super table
-    if (!TSDB_QUERY_HAS_TYPE(pQueryMsg->queryType, TSDB_QUERY_TYPE_MULTITABLE_QUERY)) {
-      STableIdInfo *id = taosArrayGet(param.pTableIdList, 0);
-
-      // group by normal column, do not pass the group by condition to tsdb to group table into different group
-      int32_t numOfGroupByCols = pQueryMsg->numOfGroupCols;
-      if (pQueryMsg->numOfGroupCols == 1 && !TSDB_COL_IS_TAG(param.pGroupColIndex->flag)) {
-        numOfGroupByCols = 0;
-      }
-
-      qDebug("qmsg:%p query stable, uid:%"PRId64", tid:%d", pQueryMsg, id->uid, id->tid);
-      code = tsdbQuerySTableByTagCond(tsdb, id->uid, pQueryMsg->window.skey, param.tagCond, pQueryMsg->tagCondLen,
-          pQueryMsg->tagNameRelType, param.tbnameCond, &tableGroupInfo, param.pGroupColIndex, numOfGroupByCols);
-
-      if (code != TSDB_CODE_SUCCESS) {
-        qError("qmsg:%p failed to query stable, reason: %s", pQueryMsg, tstrerror(code));
-        goto _over;
-      }
-    } else {
-      code = tsdbGetTableGroupFromIdList(tsdb, param.pTableIdList, &tableGroupInfo);
-      if (code != TSDB_CODE_SUCCESS) {
-        goto _over;
-      }
-
-      qDebug("qmsg:%p query on %" PRIzu " tables in one group from client", pQueryMsg, tableGroupInfo.numOfTables);
-    }
-
-    int64_t el = taosGetTimestampUs() - st;
-    qDebug("qmsg:%p tag filter completed, numOfTables:%" PRIzu ", elapsed time:%"PRId64"us", pQueryMsg, tableGroupInfo.numOfTables, el);
-  } else {
-    assert(0);
-  }
-
-  code = checkForQueryBuf(tableGroupInfo.numOfTables);
-  if (code != TSDB_CODE_SUCCESS) {  // not enough query buffer, abort
-    goto _over;
-  }
-
-  (*pQInfo) = createQInfoImpl(pQueryMsg, param.pGroupbyExpr, param.pExprs, param.pSecExprs, &tableGroupInfo, param.pTagColumnInfo, isSTableQuery, param.sql);
-
-  param.sql    = NULL;
-  param.pExprs = NULL;
-  param.pSecExprs = NULL;
-  param.pGroupbyExpr = NULL;
-  param.pTagColumnInfo = NULL;
-
-  if ((*pQInfo) == NULL) {
-    code = TSDB_CODE_QRY_OUT_OF_MEMORY;
-    goto _over;
-  }
-
-  code = initQInfo(pQueryMsg, tsdb, vgId, *pQInfo, &param, isSTableQuery);
-
-_over:
-  if (param.pGroupbyExpr != NULL) {
-    taosArrayDestroy(param.pGroupbyExpr->columnInfo);
-  }
-
-  taosArrayDestroy(param.pTableIdList);
-  param.pTableIdList = NULL;
-
-  freeParam(&param);
-
-  for (int32_t i = 0; i < pQueryMsg->numOfCols; i++) {
-    SColumnInfo* column = pQueryMsg->colList + i;
-    freeColumnFilterInfo(column->filters, column->numOfFilters);
-  }
-
-  //pQInfo already freed in initQInfo, but *pQInfo may not pointer to null;
-  if (code != TSDB_CODE_SUCCESS) {
-    *pQInfo = NULL;
-  }
-
-  // if failed to add ref for all tables in this query, abort current query
-  return code;
-}
-
-void qDestroyQueryInfo(qinfo_t qHandle) {
-  SQInfo* pQInfo = (SQInfo*) qHandle;
-  if (!isValidQInfo(pQInfo)) {
-    return;
-  }
-
-  qDebug("QInfo:%p query completed", pQInfo);
-  queryCostStatis(pQInfo);   // print the query cost summary
-  freeQInfo(pQInfo);
-}
-
-static bool doBuildResCheck(SQInfo* pQInfo) {
+bool doBuildResCheck(SQInfo* pQInfo) {
   bool buildRes = false;
 
   pthread_mutex_lock(&pQInfo->lock);
@@ -7493,215 +7058,20 @@ static bool doBuildResCheck(SQInfo* pQInfo) {
   return buildRes;
 }
 
-bool qTableQuery(qinfo_t qinfo) {
-  SQInfo *pQInfo = (SQInfo *)qinfo;
-  assert(pQInfo && pQInfo->signature == pQInfo);
-  int64_t threadId = taosGetSelfPthreadId();
-
-  int64_t curOwner = 0;
-  if ((curOwner = atomic_val_compare_exchange_64(&pQInfo->owner, 0, threadId)) != 0) {
-    qError("QInfo:%p qhandle is now executed by thread:%p", pQInfo, (void*) curOwner);
-    pQInfo->code = TSDB_CODE_QRY_IN_EXEC;
-    return false;
-  }
-
-  pQInfo->startExecTs = taosGetTimestampSec();
-
-  if (isQueryKilled(pQInfo)) {
-    qDebug("QInfo:%p it is already killed, abort", pQInfo);
-    return doBuildResCheck(pQInfo);
-  }
-
-  if (pQInfo->tableqinfoGroupInfo.numOfTables == 0) {
-    qDebug("QInfo:%p no table exists for query, abort", pQInfo);
-    setQueryStatus(pQInfo->runtimeEnv.pQuery, QUERY_COMPLETED);
-    return doBuildResCheck(pQInfo);
-  }
-
-  // error occurs, record the error code and return to client
-  int32_t ret = setjmp(pQInfo->runtimeEnv.env);
-  if (ret != TSDB_CODE_SUCCESS) {
-    pQInfo->code = ret;
-    qDebug("QInfo:%p query abort due to error/cancel occurs, code:%s", pQInfo, tstrerror(pQInfo->code));
-    return doBuildResCheck(pQInfo);
-  }
-
-  qDebug("QInfo:%p query task is launched", pQInfo);
-
-  SQueryRuntimeEnv* pRuntimeEnv = &pQInfo->runtimeEnv;
-  if (onlyQueryTags(pQInfo->runtimeEnv.pQuery)) {
-    assert(pQInfo->runtimeEnv.pQueryHandle == NULL);
-    buildTagQueryResult(pQInfo);
-  } else if (pQInfo->runtimeEnv.stableQuery) {
-    stableQueryImpl(pQInfo);
-  } else if (pQInfo->runtimeEnv.queryBlockDist){
-    buildTableBlockDistResult(pQInfo);  
-  } else {
-    tableQueryImpl(pQInfo);
-  }
-
-  SQuery* pQuery = pRuntimeEnv->pQuery;
-  if (isQueryKilled(pQInfo)) {
-    qDebug("QInfo:%p query is killed", pQInfo);
-  } else if (pQuery->rec.rows == 0) {
-    qDebug("QInfo:%p over, %" PRIzu " tables queried, %"PRId64" rows are returned", pQInfo, pQInfo->tableqinfoGroupInfo.numOfTables, pQuery->rec.total);
-  } else {
-    qDebug("QInfo:%p query paused, %" PRId64 " rows returned, numOfTotal:%" PRId64 " rows",
-           pQInfo, pQuery->rec.rows, pQuery->rec.total + pQuery->rec.rows);
-  }
-
-  return doBuildResCheck(pQInfo);
-}
-
-int32_t qRetrieveQueryResultInfo(qinfo_t qinfo, bool* buildRes, void* pRspContext) {
-  SQInfo *pQInfo = (SQInfo *)qinfo;
-
-  if (pQInfo == NULL || !isValidQInfo(pQInfo)) {
-    qError("QInfo:%p invalid qhandle", pQInfo);
-    return TSDB_CODE_QRY_INVALID_QHANDLE;
-  }
-
-  *buildRes = false;
-  if (IS_QUERY_KILLED(pQInfo)) {
-    qDebug("QInfo:%p query is killed, code:0x%08x", pQInfo, pQInfo->code);
-    return pQInfo->code;
-  }
-
-  int32_t code = TSDB_CODE_SUCCESS;
-
-  if (tsRetrieveBlockingModel) {
-    pQInfo->rspContext = pRspContext;
-    tsem_wait(&pQInfo->ready);
-    *buildRes = true;
-    code = pQInfo->code;
-  } else {
-    SQuery *pQuery = pQInfo->runtimeEnv.pQuery;
-
-    pthread_mutex_lock(&pQInfo->lock);
-
-    assert(pQInfo->rspContext == NULL);
-    if (pQInfo->dataReady == QUERY_RESULT_READY) {
-      *buildRes = true;
-      qDebug("QInfo:%p retrieve result info, rowsize:%d, rows:%" PRId64 ", code:%s", pQInfo, pQuery->resultRowSize,
-             pQuery->rec.rows, tstrerror(pQInfo->code));
-    } else {
-      *buildRes = false;
-      qDebug("QInfo:%p retrieve req set query return result after paused", pQInfo);
-      pQInfo->rspContext = pRspContext;
-      assert(pQInfo->rspContext != NULL);
-    }
-
-    code = pQInfo->code;
-    pthread_mutex_unlock(&pQInfo->lock);
-  }
-
-  return code;
-}
-
-int32_t qDumpRetrieveResult(qinfo_t qinfo, SRetrieveTableRsp **pRsp, int32_t *contLen, bool* continueExec) {
-  SQInfo *pQInfo = (SQInfo *)qinfo;
-
-  if (pQInfo == NULL || !isValidQInfo(pQInfo)) {
-    return TSDB_CODE_QRY_INVALID_QHANDLE;
-  }
-
-  SQueryRuntimeEnv* pRuntimeEnv = &pQInfo->runtimeEnv;
-  SQuery *pQuery = pQInfo->runtimeEnv.pQuery;
-  size_t  size = getResultSize(pQInfo, &pQuery->rec.rows);
-
-  size += sizeof(int32_t);
-  size += sizeof(STableIdInfo) * taosHashGetSize(pQInfo->arrTableIdInfo);
-
-  *contLen = (int32_t)(size + sizeof(SRetrieveTableRsp));
-
-  // todo proper handle failed to allocate memory,
-  // current solution only avoid crash, but cannot return error code to client
-  *pRsp = (SRetrieveTableRsp *)rpcMallocCont(*contLen);
-  if (*pRsp == NULL) {
-    return TSDB_CODE_QRY_OUT_OF_MEMORY;
-  }
-
-  (*pRsp)->numOfRows = htonl((int32_t)pQuery->rec.rows);
-
-  if (pQInfo->code == TSDB_CODE_SUCCESS) {
-    (*pRsp)->offset   = htobe64(pQuery->limit.offset);
-    (*pRsp)->useconds = htobe64(pRuntimeEnv->summary.elapsedTime);
-  } else {
-    (*pRsp)->offset   = 0;
-    (*pRsp)->useconds = htobe64(pRuntimeEnv->summary.elapsedTime);
-  }
-
-  (*pRsp)->precision = htons(pQuery->precision);
-  if (pQuery->rec.rows > 0 && pQInfo->code == TSDB_CODE_SUCCESS) {
-    doDumpQueryResult(pQInfo, (*pRsp)->data);
-  } else {
-    setQueryStatus(pQuery, QUERY_OVER);
-  }
-
-  pQInfo->rspContext = NULL;
-  pQInfo->dataReady  = QUERY_RESULT_NOT_READY;
-
-  if (IS_QUERY_KILLED(pQInfo) || Q_STATUS_EQUAL(pQuery->status, QUERY_OVER)) {
-    // here current thread hold the refcount, so it is safe to free tsdbQueryHandle.
-    *continueExec = false;
-    (*pRsp)->completed = 1;  // notify no more result to client
-  } else {
-    *continueExec = true;
-    qDebug("QInfo:%p has more results to retrieve", pQInfo);
-  }
-  if (pQInfo->code != TSDB_CODE_SUCCESS) {
-    rpcFreeCont(*pRsp);
-    *pRsp = NULL;
-  }
-  return pQInfo->code;
-}
-
-int32_t qQueryCompleted(qinfo_t qinfo) {
-  SQInfo *pQInfo = (SQInfo *)qinfo;
-
-  if (pQInfo == NULL || !isValidQInfo(pQInfo)) {
-    return TSDB_CODE_QRY_INVALID_QHANDLE;
-  }
-
-  SQuery* pQuery = pQInfo->runtimeEnv.pQuery;
-  return isQueryKilled(pQInfo) || Q_STATUS_EQUAL(pQuery->status, QUERY_OVER);
-}
-
-int32_t qKillQuery(qinfo_t qinfo) {
-  SQInfo *pQInfo = (SQInfo *)qinfo;
-
-  if (pQInfo == NULL || !isValidQInfo(pQInfo)) {
-    return TSDB_CODE_QRY_INVALID_QHANDLE;
-  }
-
-  setQueryKilled(pQInfo);
-
-  // Wait for the query executing thread being stopped/
-  // Once the query is stopped, the owner of qHandle will be cleared immediately.
-  while (pQInfo->owner != 0) {
-    taosMsleep(100);
+static void doSetTagValueToResultBuf(char* output, const char* val, int16_t type, int16_t bytes) {
+  if (val == NULL) {
+    setNull(output, type, bytes);
+    return;
   }
 
-  return TSDB_CODE_SUCCESS;
-}
-
-static void doSetTagValueToResultBuf(char* output, const char* val, int16_t type, int16_t bytes) {
   if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_NCHAR) {
-    if (val == NULL) {
-      setVardataNull(output, type);
-    } else {
-      memcpy(output, val, varDataTLen(val));
-    }
+    memcpy(output, val, varDataTLen(val));
   } else {
-    if (val == NULL) {
-      setNull(output, type, bytes);
-    } else {  // todo here stop will cause client crash
-      memcpy(output, val, bytes);
-    }
+    memcpy(output, val, bytes);
   }
 }
 
-static void buildTagQueryResult(SQInfo* pQInfo) {
+void buildTagQueryResult(SQInfo* pQInfo) {
   SQueryRuntimeEnv *pRuntimeEnv = &pQInfo->runtimeEnv;
   SQuery *          pQuery = pRuntimeEnv->pQuery;
 
@@ -7875,157 +7245,3 @@ void releaseQueryBuf(size_t numOfTables) {
   // restore value is not enough buffer available
   atomic_add_fetch_64(&tsQueryBufferSizeBytes, t);
 }
-
-void* qGetResultRetrieveMsg(qinfo_t qinfo) {
-  SQInfo* pQInfo = (SQInfo*) qinfo;
-  assert(pQInfo != NULL);
-
-  return pQInfo->rspContext;
-}
-
-void freeqinfoFn(void *qhandle) {
-  void** handle = qhandle;
-  if (handle == NULL || *handle == NULL) {
-    return;
-  }
-
-  qKillQuery(*handle);
-  qDestroyQueryInfo(*handle);
-}
-
-void* qOpenQueryMgmt(int32_t vgId) {
-  const int32_t REFRESH_HANDLE_INTERVAL = 30; // every 30 seconds, refresh handle pool
-
-  char cacheName[128] = {0};
-  sprintf(cacheName, "qhandle_%d", vgId);
-
-  SQueryMgmt* pQueryMgmt = calloc(1, sizeof(SQueryMgmt));
-  if (pQueryMgmt == NULL) {
-    terrno = TSDB_CODE_QRY_OUT_OF_MEMORY;
-    return NULL;
-  }
-
-  pQueryMgmt->qinfoPool = taosCacheInit(TSDB_CACHE_PTR_KEY, REFRESH_HANDLE_INTERVAL, true, freeqinfoFn, cacheName);
-  pQueryMgmt->closed    = false;
-  pQueryMgmt->vgId      = vgId;
-
-  pthread_mutex_init(&pQueryMgmt->lock, NULL);
-
-  qDebug("vgId:%d, open querymgmt success", vgId);
-  return pQueryMgmt;
-}
-
-static void queryMgmtKillQueryFn(void* handle) {
-  void** fp = (void**)handle;
-  qKillQuery(*fp);
-}
-
-void qQueryMgmtNotifyClosed(void* pQMgmt) {
-  if (pQMgmt == NULL) {
-    return;
-  }
-
-  SQueryMgmt* pQueryMgmt = pQMgmt;
-  qDebug("vgId:%d, set querymgmt closed, wait for all queries cancelled", pQueryMgmt->vgId);
-
-  pthread_mutex_lock(&pQueryMgmt->lock);
-  pQueryMgmt->closed = true;
-  pthread_mutex_unlock(&pQueryMgmt->lock);
-
-  taosCacheRefresh(pQueryMgmt->qinfoPool, queryMgmtKillQueryFn);
-}
-
-void qQueryMgmtReOpen(void *pQMgmt) {
-  if (pQMgmt == NULL) {
-    return;
-  }
-
-  SQueryMgmt *pQueryMgmt = pQMgmt;
-  qDebug("vgId:%d, set querymgmt reopen", pQueryMgmt->vgId);
-
-  pthread_mutex_lock(&pQueryMgmt->lock);
-  pQueryMgmt->closed = false;
-  pthread_mutex_unlock(&pQueryMgmt->lock);
-}
-
-void qCleanupQueryMgmt(void* pQMgmt) {
-  if (pQMgmt == NULL) {
-    return;
-  }
-
-  SQueryMgmt* pQueryMgmt = pQMgmt;
-  int32_t vgId = pQueryMgmt->vgId;
-
-  assert(pQueryMgmt->closed);
-
-  SCacheObj* pqinfoPool = pQueryMgmt->qinfoPool;
-  pQueryMgmt->qinfoPool = NULL;
-
-  taosCacheCleanup(pqinfoPool);
-  pthread_mutex_destroy(&pQueryMgmt->lock);
-  tfree(pQueryMgmt);
-
-  qDebug("vgId:%d, queryMgmt cleanup completed", vgId);
-}
-
-void** qRegisterQInfo(void* pMgmt, uint64_t qInfo) {
-  if (pMgmt == NULL) {
-    terrno = TSDB_CODE_VND_INVALID_VGROUP_ID;
-    return NULL;
-  }
-
-  SQueryMgmt *pQueryMgmt = pMgmt;
-  if (pQueryMgmt->qinfoPool == NULL) {
-    qError("QInfo:%p failed to add qhandle into qMgmt, since qMgmt is closed", (void *)qInfo);
-    terrno = TSDB_CODE_VND_INVALID_VGROUP_ID;
-    return NULL;
-  }
-
-  pthread_mutex_lock(&pQueryMgmt->lock);
-  if (pQueryMgmt->closed) {
-    pthread_mutex_unlock(&pQueryMgmt->lock);
-    qError("QInfo:%p failed to add qhandle into cache, since qMgmt is colsing", (void *)qInfo);
-    terrno = TSDB_CODE_VND_INVALID_VGROUP_ID;
-    return NULL;
-  } else {
-    TSDB_CACHE_PTR_TYPE handleVal = (TSDB_CACHE_PTR_TYPE) qInfo;
-    void** handle = taosCachePut(pQueryMgmt->qinfoPool, &handleVal, sizeof(TSDB_CACHE_PTR_TYPE), &qInfo, sizeof(TSDB_CACHE_PTR_TYPE),
-        (getMaximumIdleDurationSec()*1000));
-    pthread_mutex_unlock(&pQueryMgmt->lock);
-
-    return handle;
-  }
-}
-
-void** qAcquireQInfo(void* pMgmt, uint64_t _key) {
-  SQueryMgmt *pQueryMgmt = pMgmt;
-
-  if (pQueryMgmt->closed) {
-    terrno = TSDB_CODE_VND_INVALID_VGROUP_ID;
-    return NULL;
-  }
-
-  if (pQueryMgmt->qinfoPool == NULL) {
-    terrno = TSDB_CODE_QRY_INVALID_QHANDLE;
-    return NULL;
-  }
-
-  TSDB_CACHE_PTR_TYPE key = (TSDB_CACHE_PTR_TYPE)_key;
-  void** handle = taosCacheAcquireByKey(pQueryMgmt->qinfoPool, &key, sizeof(TSDB_CACHE_PTR_TYPE));
-  if (handle == NULL || *handle == NULL) {
-    terrno = TSDB_CODE_QRY_INVALID_QHANDLE;
-    return NULL;
-  } else {
-    return handle;
-  }
-}
-
-void** qReleaseQInfo(void* pMgmt, void* pQInfo, bool freeHandle) {
-  SQueryMgmt *pQueryMgmt = pMgmt;
-  if (pQueryMgmt->qinfoPool == NULL) {
-    return NULL;
-  }
-
-  taosCacheRelease(pQueryMgmt->qinfoPool, pQInfo, freeHandle);
-  return 0;
-}
diff --git a/src/query/src/qUtil.c b/src/query/src/qUtil.c
index 46079e6830f91712490bcdcdd61de4902a3a5015..b7a7fd28e9dc2f013457e22446ff7bc41d3fef6c 100644
--- a/src/query/src/qUtil.c
+++ b/src/query/src/qUtil.c
@@ -20,6 +20,14 @@
 #include "qExecutor.h"
 #include "qUtil.h"
 #include "tbuffer.h"
+#include "tlosertree.h"
+#include "queryLog.h"
+
+typedef struct SCompSupporter {
+  STableQueryInfo **pTableQueryInfo;
+  int32_t          *rowIndex;
+  int32_t           order;
+} SCompSupporter;
 
 int32_t getOutputInterResultBufSize(SQuery* pQuery) {
   int32_t size = 0;
@@ -322,4 +330,243 @@ void freeInterResult(void* param) {
   }
 
   taosArrayDestroy(pResult->pResult);
-}
\ No newline at end of file
+}
+
+void cleanupGroupResInfo(SGroupResInfo* pGroupResInfo) {
+  assert(pGroupResInfo != NULL);
+
+  taosArrayDestroy(pGroupResInfo->pRows);
+  pGroupResInfo->pRows     = NULL;
+  pGroupResInfo->index     = 0;
+}
+
+void initGroupResInfo(SGroupResInfo* pGroupResInfo, SResultRowInfo* pResultInfo, int32_t offset) {
+  if (pGroupResInfo->pRows != NULL) {
+    taosArrayDestroy(pGroupResInfo->pRows);
+  }
+
+  pGroupResInfo->pRows = taosArrayFromList(pResultInfo->pResult, pResultInfo->size, POINTER_BYTES);
+  pGroupResInfo->index = offset;
+
+  assert(pGroupResInfo->index <= getNumOfTotalRes(pGroupResInfo));
+}
+
+bool hasRemainData(SGroupResInfo* pGroupResInfo) {
+  if (pGroupResInfo->pRows == NULL) {
+    return false;
+  }
+
+  return pGroupResInfo->index < taosArrayGetSize(pGroupResInfo->pRows);
+}
+
+bool incNextGroup(SGroupResInfo* pGroupResInfo) {
+  return (++pGroupResInfo->currentGroup) < pGroupResInfo->totalGroup;
+}
+
+int32_t getNumOfTotalRes(SGroupResInfo* pGroupResInfo) {
+  assert(pGroupResInfo != NULL);
+  if (pGroupResInfo->pRows == 0) {
+    return 0;
+  }
+
+  return (int32_t) taosArrayGetSize(pGroupResInfo->pRows);
+}
+
+static int64_t getNumOfResultWindowRes(SQueryRuntimeEnv* pRuntimeEnv, SResultRow *pResultRow) {
+  SQuery* pQuery = pRuntimeEnv->pQuery;
+
+  for (int32_t j = 0; j < pQuery->numOfOutput; ++j) {
+    int32_t functionId = pQuery->pExpr1[j].base.functionId;
+
+    /*
+     * ts, tag, tagprj function can not decide the output number of current query
+     * the number of output result is decided by main output
+     */
+    if (functionId == TSDB_FUNC_TS || functionId == TSDB_FUNC_TAG || functionId == TSDB_FUNC_TAGPRJ) {
+      continue;
+    }
+
+    SResultRowCellInfo *pResultInfo = getResultCell(pRuntimeEnv, pResultRow, j);
+    assert(pResultInfo != NULL);
+
+    if (pResultInfo->numOfRes > 0) {
+      return pResultInfo->numOfRes;
+    }
+  }
+
+  return 0;
+}
+
+static int32_t tableResultComparFn(const void *pLeft, const void *pRight, void *param) {
+  int32_t left  = *(int32_t *)pLeft;
+  int32_t right = *(int32_t *)pRight;
+
+  SCompSupporter *  supporter = (SCompSupporter *)param;
+
+  int32_t leftPos  = supporter->rowIndex[left];
+  int32_t rightPos = supporter->rowIndex[right];
+
+  /* left source is exhausted */
+  if (leftPos == -1) {
+    return 1;
+  }
+
+  /* right source is exhausted*/
+  if (rightPos == -1) {
+    return -1;
+  }
+
+  STableQueryInfo** pList = supporter->pTableQueryInfo;
+
+  SResultRowInfo *pWindowResInfo1 = &(pList[left]->resInfo);
+  SResultRow * pWindowRes1 = getResultRow(pWindowResInfo1, leftPos);
+  TSKEY leftTimestamp = pWindowRes1->win.skey;
+
+  SResultRowInfo *pWindowResInfo2 = &(pList[right]->resInfo);
+  SResultRow * pWindowRes2 = getResultRow(pWindowResInfo2, rightPos);
+  TSKEY rightTimestamp = pWindowRes2->win.skey;
+
+  if (leftTimestamp == rightTimestamp) {
+    return 0;
+  }
+
+  if (supporter->order == TSDB_ORDER_ASC) {
+    return (leftTimestamp > rightTimestamp)? 1:-1;
+  } else {
+    return (leftTimestamp < rightTimestamp)? 1:-1;
+  }
+}
+
+static int32_t mergeIntoGroupResultImpl(SQueryRuntimeEnv *pRuntimeEnv, SGroupResInfo* pGroupResInfo, SArray *pTableList, void* qinfo) {
+  bool ascQuery = QUERY_IS_ASC_QUERY(pRuntimeEnv->pQuery);
+
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  int32_t *posList = NULL;
+  SLoserTreeInfo *pTree = NULL;
+  STableQueryInfo **pTableQueryInfoList = NULL;
+
+  size_t size = taosArrayGetSize(pTableList);
+  if (pGroupResInfo->pRows == NULL) {
+    pGroupResInfo->pRows = taosArrayInit(100, POINTER_BYTES);
+  }
+
+  posList = calloc(size, sizeof(int32_t));
+  pTableQueryInfoList = malloc(POINTER_BYTES * size);
+
+  if (pTableQueryInfoList == NULL || posList == NULL || pGroupResInfo->pRows == NULL || pGroupResInfo->pRows == NULL) {
+    qError("QInfo:%p failed alloc memory", qinfo);
+    code = TSDB_CODE_QRY_OUT_OF_MEMORY;
+    goto _end;
+  }
+
+  int32_t numOfTables = 0;
+  for (int32_t i = 0; i < size; ++i) {
+    STableQueryInfo *item = taosArrayGetP(pTableList, i);
+    if (item->resInfo.size > 0) {
+      pTableQueryInfoList[numOfTables++] = item;
+    }
+  }
+
+  // there is no data in current group
+  // no need to merge results since only one table in each group
+  if (numOfTables == 0) {
+    goto _end;
+  }
+
+  SCompSupporter cs = {pTableQueryInfoList, posList, pRuntimeEnv->pQuery->order.order};
+
+  int32_t ret = tLoserTreeCreate(&pTree, numOfTables, &cs, tableResultComparFn);
+  if (ret != TSDB_CODE_SUCCESS) {
+    code = TSDB_CODE_QRY_OUT_OF_MEMORY;
+    goto _end;
+  }
+
+  int64_t lastTimestamp = ascQuery? INT64_MIN:INT64_MAX;
+  int64_t startt = taosGetTimestampMs();
+
+  while (1) {
+    int32_t tableIndex = pTree->pNode[0].index;
+
+    SResultRowInfo *pWindowResInfo = &pTableQueryInfoList[tableIndex]->resInfo;
+    SResultRow  *pWindowRes = getResultRow(pWindowResInfo, cs.rowIndex[tableIndex]);
+
+    int64_t num = getNumOfResultWindowRes(pRuntimeEnv, pWindowRes);
+    if (num <= 0) {
+      cs.rowIndex[tableIndex] += 1;
+
+      if (cs.rowIndex[tableIndex] >= pWindowResInfo->size) {
+        cs.rowIndex[tableIndex] = -1;
+        if (--numOfTables == 0) { // all input sources are exhausted
+          break;
+        }
+      }
+    } else {
+      assert((pWindowRes->win.skey >= lastTimestamp && ascQuery) || (pWindowRes->win.skey <= lastTimestamp && !ascQuery));
+
+      if (pWindowRes->win.skey != lastTimestamp) {
+        taosArrayPush(pGroupResInfo->pRows, &pWindowRes);
+        pWindowRes->numOfRows = (uint32_t) num;
+      }
+
+      lastTimestamp = pWindowRes->win.skey;
+
+      // move to the next row of current entry
+      if ((++cs.rowIndex[tableIndex]) >= pWindowResInfo->size) {
+        cs.rowIndex[tableIndex] = -1;
+
+        // all input sources are exhausted
+        if ((--numOfTables) == 0) {
+          break;
+        }
+      }
+    }
+
+    tLoserTreeAdjust(pTree, tableIndex + pTree->numOfEntries);
+  }
+
+  int64_t endt = taosGetTimestampMs();
+
+  qDebug("QInfo:%p result merge completed for group:%d, elapsed time:%" PRId64 " ms", qinfo,
+         pGroupResInfo->currentGroup, endt - startt);
+
+  _end:
+  tfree(pTableQueryInfoList);
+  tfree(posList);
+  tfree(pTree);
+
+  return code;
+}
+
+int32_t mergeIntoGroupResult(SGroupResInfo* pGroupResInfo, SQInfo *pQInfo) {
+  int64_t st = taosGetTimestampUs();
+
+  while (pGroupResInfo->currentGroup < pGroupResInfo->totalGroup) {
+    SArray *group = GET_TABLEGROUP(pQInfo, pGroupResInfo->currentGroup);
+
+    int32_t ret = mergeIntoGroupResultImpl(&pQInfo->runtimeEnv, pGroupResInfo, group, pQInfo);
+    if (ret != TSDB_CODE_SUCCESS) {
+      return ret;
+    }
+
+    // this group generates at least one result, return results
+    if (taosArrayGetSize(pGroupResInfo->pRows) > 0) {
+      break;
+    }
+
+    qDebug("QInfo:%p no result in group %d, continue", pQInfo, pGroupResInfo->currentGroup);
+    cleanupGroupResInfo(pGroupResInfo);
+    incNextGroup(pGroupResInfo);
+  }
+
+  if (pGroupResInfo->currentGroup >= pGroupResInfo->totalGroup && !hasRemainData(pGroupResInfo)) {
+    SET_STABLE_QUERY_OVER(pQInfo);
+  }
+
+  int64_t elapsedTime = taosGetTimestampUs() - st;
+  qDebug("QInfo:%p merge res data into group, index:%d, total group:%d, elapsed time:%" PRId64 "us", pQInfo,
+         pGroupResInfo->currentGroup, pGroupResInfo->totalGroup, elapsedTime);
+
+  pQInfo->runtimeEnv.summary.firstStageMergeTime += elapsedTime;
+  return TSDB_CODE_SUCCESS;
+}
diff --git a/src/query/src/queryMain.c b/src/query/src/queryMain.c
new file mode 100644
index 0000000000000000000000000000000000000000..e262a3ad385273f6e7f4b3c2cbe9c075e3d4e86d
--- /dev/null
+++ b/src/query/src/queryMain.c
@@ -0,0 +1,542 @@
+/*
+ * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "os.h"
+#include "qFill.h"
+#include "taosmsg.h"
+#include "tcache.h"
+#include "tglobal.h"
+
+#include "exception.h"
+#include "hash.h"
+#include "texpr.h"
+#include "qExecutor.h"
+#include "qResultbuf.h"
+#include "qUtil.h"
+#include "query.h"
+#include "queryLog.h"
+#include "tlosertree.h"
+#include "ttype.h"
+#include "tcompare.h"
+
+typedef struct SQueryMgmt {
+  pthread_mutex_t lock;
+  SCacheObj      *qinfoPool;      // query handle pool
+  int32_t         vgId;
+  bool            closed;
+} SQueryMgmt;
+
+static void queryMgmtKillQueryFn(void* handle) {
+  void** fp = (void**)handle;
+  qKillQuery(*fp);
+}
+
+static void freeqinfoFn(void *qhandle) {
+  void** handle = qhandle;
+  if (handle == NULL || *handle == NULL) {
+    return;
+  }
+
+  qKillQuery(*handle);
+  qDestroyQueryInfo(*handle);
+}
+
+void freeParam(SQueryParam *param) {
+  tfree(param->sql);
+  tfree(param->tagCond);
+  tfree(param->tbnameCond);
+  tfree(param->pTableIdList);
+  tfree(param->pExprMsg);
+  tfree(param->pSecExprMsg);
+  tfree(param->pExprs);
+  tfree(param->pSecExprs);
+  tfree(param->pGroupColIndex);
+  tfree(param->pTagColumnInfo);
+  tfree(param->pGroupbyExpr);
+  tfree(param->prevResult);
+}
+
+int32_t qCreateQueryInfo(void* tsdb, int32_t vgId, SQueryTableMsg* pQueryMsg, qinfo_t* pQInfo) {
+  assert(pQueryMsg != NULL && tsdb != NULL);
+
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  SQueryParam param = {0};
+  code = convertQueryMsg(pQueryMsg, &param);
+  if (code != TSDB_CODE_SUCCESS) {
+    goto _over;
+  }
+
+  if (pQueryMsg->numOfTables <= 0) {
+    qError("Invalid number of tables to query, numOfTables:%d", pQueryMsg->numOfTables);
+    code = TSDB_CODE_QRY_INVALID_MSG;
+    goto _over;
+  }
+
+  if (param.pTableIdList == NULL || taosArrayGetSize(param.pTableIdList) == 0) {
+    qError("qmsg:%p, SQueryTableMsg wrong format", pQueryMsg);
+    code = TSDB_CODE_QRY_INVALID_MSG;
+    goto _over;
+  }
+
+  if ((code = createQueryFuncExprFromMsg(pQueryMsg, pQueryMsg->numOfOutput, &param.pExprs, param.pExprMsg, param.pTagColumnInfo)) != TSDB_CODE_SUCCESS) {
+    goto _over;
+  }
+
+  if (param.pSecExprMsg != NULL) {
+    if ((code = createQueryFuncExprFromMsg(pQueryMsg, pQueryMsg->secondStageOutput, &param.pSecExprs, param.pSecExprMsg, param.pTagColumnInfo)) != TSDB_CODE_SUCCESS) {
+      goto _over;
+    }
+  }
+
+  param.pGroupbyExpr = createGroupbyExprFromMsg(pQueryMsg, param.pGroupColIndex, &code);
+  if ((param.pGroupbyExpr == NULL && pQueryMsg->numOfGroupCols != 0) || code != TSDB_CODE_SUCCESS) {
+    goto _over;
+  }
+
+  bool isSTableQuery = false;
+  STableGroupInfo tableGroupInfo = {0};
+  int64_t st = taosGetTimestampUs();
+
+  if (TSDB_QUERY_HAS_TYPE(pQueryMsg->queryType, TSDB_QUERY_TYPE_TABLE_QUERY)) {
+    STableIdInfo *id = taosArrayGet(param.pTableIdList, 0);
+
+    qDebug("qmsg:%p query normal table, uid:%"PRId64", tid:%d", pQueryMsg, id->uid, id->tid);
+    if ((code = tsdbGetOneTableGroup(tsdb, id->uid, pQueryMsg->window.skey, &tableGroupInfo)) != TSDB_CODE_SUCCESS) {
+      goto _over;
+    }
+  } else if (TSDB_QUERY_HAS_TYPE(pQueryMsg->queryType, TSDB_QUERY_TYPE_MULTITABLE_QUERY|TSDB_QUERY_TYPE_STABLE_QUERY)) {
+    isSTableQuery = true;
+
+    // also note there's possibility that only one table in the super table
+    if (!TSDB_QUERY_HAS_TYPE(pQueryMsg->queryType, TSDB_QUERY_TYPE_MULTITABLE_QUERY)) {
+      STableIdInfo *id = taosArrayGet(param.pTableIdList, 0);
+
+      // group by normal column, do not pass the group by condition to tsdb to group table into different group
+      int32_t numOfGroupByCols = pQueryMsg->numOfGroupCols;
+      if (pQueryMsg->numOfGroupCols == 1 && !TSDB_COL_IS_TAG(param.pGroupColIndex->flag)) {
+        numOfGroupByCols = 0;
+      }
+
+      qDebug("qmsg:%p query stable, uid:%"PRId64", tid:%d", pQueryMsg, id->uid, id->tid);
+      code = tsdbQuerySTableByTagCond(tsdb, id->uid, pQueryMsg->window.skey, param.tagCond, pQueryMsg->tagCondLen,
+                                      pQueryMsg->tagNameRelType, param.tbnameCond, &tableGroupInfo, param.pGroupColIndex, numOfGroupByCols);
+
+      if (code != TSDB_CODE_SUCCESS) {
+        qError("qmsg:%p failed to query stable, reason: %s", pQueryMsg, tstrerror(code));
+        goto _over;
+      }
+    } else {
+      code = tsdbGetTableGroupFromIdList(tsdb, param.pTableIdList, &tableGroupInfo);
+      if (code != TSDB_CODE_SUCCESS) {
+        goto _over;
+      }
+
+      qDebug("qmsg:%p query on %" PRIzu " tables in one group from client", pQueryMsg, tableGroupInfo.numOfTables);
+    }
+
+    int64_t el = taosGetTimestampUs() - st;
+    qDebug("qmsg:%p tag filter completed, numOfTables:%" PRIzu ", elapsed time:%"PRId64"us", pQueryMsg, tableGroupInfo.numOfTables, el);
+  } else {
+    assert(0);
+  }
+
+  code = checkForQueryBuf(tableGroupInfo.numOfTables);
+  if (code != TSDB_CODE_SUCCESS) {  // not enough query buffer, abort
+    goto _over;
+  }
+
+  (*pQInfo) = createQInfoImpl(pQueryMsg, param.pGroupbyExpr, param.pExprs, param.pSecExprs, &tableGroupInfo, param.pTagColumnInfo, isSTableQuery, param.sql);
+
+  param.sql    = NULL;
+  param.pExprs = NULL;
+  param.pSecExprs = NULL;
+  param.pGroupbyExpr = NULL;
+  param.pTagColumnInfo = NULL;
+
+  if ((*pQInfo) == NULL) {
+    code = TSDB_CODE_QRY_OUT_OF_MEMORY;
+    goto _over;
+  }
+
+  code = initQInfo(pQueryMsg, tsdb, vgId, *pQInfo, &param, isSTableQuery);
+
+  _over:
+  if (param.pGroupbyExpr != NULL) {
+    taosArrayDestroy(param.pGroupbyExpr->columnInfo);
+  }
+
+  taosArrayDestroy(param.pTableIdList);
+  param.pTableIdList = NULL;
+
+  freeParam(&param);
+
+  for (int32_t i = 0; i < pQueryMsg->numOfCols; i++) {
+    SColumnInfo* column = pQueryMsg->colList + i;
+    freeColumnFilterInfo(column->filters, column->numOfFilters);
+  }
+
+  //pQInfo already freed in initQInfo, but *pQInfo may not pointer to null;
+  if (code != TSDB_CODE_SUCCESS) {
+    *pQInfo = NULL;
+  }
+
+  // if failed to add ref for all tables in this query, abort current query
+  return code;
+}
+
+bool qTableQuery(qinfo_t qinfo) {
+  SQInfo *pQInfo = (SQInfo *)qinfo;
+  assert(pQInfo && pQInfo->signature == pQInfo);
+  int64_t threadId = taosGetSelfPthreadId();
+
+  int64_t curOwner = 0;
+  if ((curOwner = atomic_val_compare_exchange_64(&pQInfo->owner, 0, threadId)) != 0) {
+    qError("QInfo:%p qhandle is now executed by thread:%p", pQInfo, (void*) curOwner);
+    pQInfo->code = TSDB_CODE_QRY_IN_EXEC;
+    return false;
+  }
+
+  pQInfo->startExecTs = taosGetTimestampSec();
+
+  if (isQueryKilled(pQInfo)) {
+    qDebug("QInfo:%p it is already killed, abort", pQInfo);
+    return doBuildResCheck(pQInfo);
+  }
+
+  if (pQInfo->tableqinfoGroupInfo.numOfTables == 0) {
+    qDebug("QInfo:%p no table exists for query, abort", pQInfo);
+    setQueryStatus(pQInfo->runtimeEnv.pQuery, QUERY_COMPLETED);
+    return doBuildResCheck(pQInfo);
+  }
+
+  // error occurs, record the error code and return to client
+  int32_t ret = setjmp(pQInfo->runtimeEnv.env);
+  if (ret != TSDB_CODE_SUCCESS) {
+    pQInfo->code = ret;
+    qDebug("QInfo:%p query abort due to error/cancel occurs, code:%s", pQInfo, tstrerror(pQInfo->code));
+    return doBuildResCheck(pQInfo);
+  }
+
+  qDebug("QInfo:%p query task is launched", pQInfo);
+
+  SQueryRuntimeEnv* pRuntimeEnv = &pQInfo->runtimeEnv;
+  if (onlyQueryTags(pQInfo->runtimeEnv.pQuery)) {
+    assert(pQInfo->runtimeEnv.pQueryHandle == NULL);
+    buildTagQueryResult(pQInfo);
+  } else if (pQInfo->runtimeEnv.stableQuery) {
+    stableQueryImpl(pQInfo);
+  } else if (pQInfo->runtimeEnv.queryBlockDist){
+    buildTableBlockDistResult(pQInfo);
+  } else {
+    tableQueryImpl(pQInfo);
+  }
+
+  SQuery* pQuery = pRuntimeEnv->pQuery;
+  if (isQueryKilled(pQInfo)) {
+    qDebug("QInfo:%p query is killed", pQInfo);
+  } else if (pQuery->rec.rows == 0) {
+    qDebug("QInfo:%p over, %" PRIzu " tables queried, %"PRId64" rows are returned", pQInfo, pQInfo->tableqinfoGroupInfo.numOfTables, pQuery->rec.total);
+  } else {
+    qDebug("QInfo:%p query paused, %" PRId64 " rows returned, numOfTotal:%" PRId64 " rows",
+           pQInfo, pQuery->rec.rows, pQuery->rec.total + pQuery->rec.rows);
+  }
+
+  return doBuildResCheck(pQInfo);
+}
+
+int32_t qRetrieveQueryResultInfo(qinfo_t qinfo, bool* buildRes, void* pRspContext) {
+  SQInfo *pQInfo = (SQInfo *)qinfo;
+
+  if (pQInfo == NULL || !isValidQInfo(pQInfo)) {
+    qError("QInfo:%p invalid qhandle", pQInfo);
+    return TSDB_CODE_QRY_INVALID_QHANDLE;
+  }
+
+  *buildRes = false;
+  if (IS_QUERY_KILLED(pQInfo)) {
+    qDebug("QInfo:%p query is killed, code:0x%08x", pQInfo, pQInfo->code);
+    return pQInfo->code;
+  }
+
+  int32_t code = TSDB_CODE_SUCCESS;
+
+  if (tsRetrieveBlockingModel) {
+    pQInfo->rspContext = pRspContext;
+    tsem_wait(&pQInfo->ready);
+    *buildRes = true;
+    code = pQInfo->code;
+  } else {
+    SQuery *pQuery = pQInfo->runtimeEnv.pQuery;
+
+    pthread_mutex_lock(&pQInfo->lock);
+
+    assert(pQInfo->rspContext == NULL);
+    if (pQInfo->dataReady == QUERY_RESULT_READY) {
+      *buildRes = true;
+      qDebug("QInfo:%p retrieve result info, rowsize:%d, rows:%" PRId64 ", code:%s", pQInfo, pQuery->resultRowSize,
+             pQuery->rec.rows, tstrerror(pQInfo->code));
+    } else {
+      *buildRes = false;
+      qDebug("QInfo:%p retrieve req set query return result after paused", pQInfo);
+      pQInfo->rspContext = pRspContext;
+      assert(pQInfo->rspContext != NULL);
+    }
+
+    code = pQInfo->code;
+    pthread_mutex_unlock(&pQInfo->lock);
+  }
+
+  return code;
+}
+
+int32_t qDumpRetrieveResult(qinfo_t qinfo, SRetrieveTableRsp **pRsp, int32_t *contLen, bool* continueExec) {
+  SQInfo *pQInfo = (SQInfo *)qinfo;
+
+  if (pQInfo == NULL || !isValidQInfo(pQInfo)) {
+    return TSDB_CODE_QRY_INVALID_QHANDLE;
+  }
+
+  SQueryRuntimeEnv* pRuntimeEnv = &pQInfo->runtimeEnv;
+  SQuery *pQuery = pQInfo->runtimeEnv.pQuery;
+  size_t  size = getResultSize(pQInfo, &pQuery->rec.rows);
+
+  size += sizeof(int32_t);
+  size += sizeof(STableIdInfo) * taosHashGetSize(pQInfo->arrTableIdInfo);
+
+  *contLen = (int32_t)(size + sizeof(SRetrieveTableRsp));
+
+  // current solution only avoid crash, but cannot return error code to client
+  *pRsp = (SRetrieveTableRsp *)rpcMallocCont(*contLen);
+  if (*pRsp == NULL) {
+    return TSDB_CODE_QRY_OUT_OF_MEMORY;
+  }
+
+  (*pRsp)->numOfRows = htonl((int32_t)pQuery->rec.rows);
+
+  if (pQInfo->code == TSDB_CODE_SUCCESS) {
+    (*pRsp)->offset   = htobe64(pQuery->limit.offset);
+    (*pRsp)->useconds = htobe64(pRuntimeEnv->summary.elapsedTime);
+  } else {
+    (*pRsp)->offset   = 0;
+    (*pRsp)->useconds = htobe64(pRuntimeEnv->summary.elapsedTime);
+  }
+
+  (*pRsp)->precision = htons(pQuery->precision);
+  if (pQuery->rec.rows > 0 && pQInfo->code == TSDB_CODE_SUCCESS) {
+    doDumpQueryResult(pQInfo, (*pRsp)->data);
+  } else {
+    setQueryStatus(pQuery, QUERY_OVER);
+  }
+
+  pQInfo->rspContext = NULL;
+  pQInfo->dataReady  = QUERY_RESULT_NOT_READY;
+
+  if (IS_QUERY_KILLED(pQInfo) || Q_STATUS_EQUAL(pQuery->status, QUERY_OVER)) {
+    // here current thread hold the refcount, so it is safe to free tsdbQueryHandle.
+    *continueExec = false;
+    (*pRsp)->completed = 1;  // notify no more result to client
+  } else {
+    *continueExec = true;
+    qDebug("QInfo:%p has more results to retrieve", pQInfo);
+  }
+
+  // the memory should be freed if the code of pQInfo is not TSDB_CODE_SUCCESS
+  if (pQInfo->code != TSDB_CODE_SUCCESS) {
+    rpcFreeCont(*pRsp);
+    *pRsp = NULL;
+  }
+
+  return pQInfo->code;
+}
+
+void* qGetResultRetrieveMsg(qinfo_t qinfo) {
+  SQInfo* pQInfo = (SQInfo*) qinfo;
+  assert(pQInfo != NULL);
+
+  return pQInfo->rspContext;
+}
+
+int32_t qKillQuery(qinfo_t qinfo) {
+  SQInfo *pQInfo = (SQInfo *)qinfo;
+
+  if (pQInfo == NULL || !isValidQInfo(pQInfo)) {
+    return TSDB_CODE_QRY_INVALID_QHANDLE;
+  }
+
+  setQueryKilled(pQInfo);
+
+  // Wait for the query executing thread being stopped/
+  // Once the query is stopped, the owner of qHandle will be cleared immediately.
+  while (pQInfo->owner != 0) {
+    taosMsleep(100);
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+int32_t qQueryCompleted(qinfo_t qinfo) {
+  SQInfo *pQInfo = (SQInfo *)qinfo;
+
+  if (pQInfo == NULL || !isValidQInfo(pQInfo)) {
+    return TSDB_CODE_QRY_INVALID_QHANDLE;
+  }
+
+  SQuery* pQuery = pQInfo->runtimeEnv.pQuery;
+  return isQueryKilled(pQInfo) || Q_STATUS_EQUAL(pQuery->status, QUERY_OVER);
+}
+
+void qDestroyQueryInfo(qinfo_t qHandle) {
+  SQInfo* pQInfo = (SQInfo*) qHandle;
+  if (!isValidQInfo(pQInfo)) {
+    return;
+  }
+
+  qDebug("QInfo:%p query completed", pQInfo);
+  queryCostStatis(pQInfo);   // print the query cost summary
+  freeQInfo(pQInfo);
+}
+
+void* qOpenQueryMgmt(int32_t vgId) {
+  const int32_t refreshHandleInterval = 30; // every 30 seconds, refresh handle pool
+
+  char cacheName[128] = {0};
+  sprintf(cacheName, "qhandle_%d", vgId);
+
+  SQueryMgmt* pQueryMgmt = calloc(1, sizeof(SQueryMgmt));
+  if (pQueryMgmt == NULL) {
+    terrno = TSDB_CODE_QRY_OUT_OF_MEMORY;
+    return NULL;
+  }
+
+  pQueryMgmt->qinfoPool = taosCacheInit(TSDB_CACHE_PTR_KEY, refreshHandleInterval, true, freeqinfoFn, cacheName);
+  pQueryMgmt->closed    = false;
+  pQueryMgmt->vgId      = vgId;
+
+  pthread_mutex_init(&pQueryMgmt->lock, NULL);
+
+  qDebug("vgId:%d, open querymgmt success", vgId);
+  return pQueryMgmt;
+}
+
+void qQueryMgmtNotifyClosed(void* pQMgmt) {
+  if (pQMgmt == NULL) {
+    return;
+  }
+
+  SQueryMgmt* pQueryMgmt = pQMgmt;
+  qDebug("vgId:%d, set querymgmt closed, wait for all queries cancelled", pQueryMgmt->vgId);
+
+  pthread_mutex_lock(&pQueryMgmt->lock);
+  pQueryMgmt->closed = true;
+  pthread_mutex_unlock(&pQueryMgmt->lock);
+
+  taosCacheRefresh(pQueryMgmt->qinfoPool, queryMgmtKillQueryFn);
+}
+
+void qQueryMgmtReOpen(void *pQMgmt) {
+  if (pQMgmt == NULL) {
+    return;
+  }
+
+  SQueryMgmt *pQueryMgmt = pQMgmt;
+  qDebug("vgId:%d, set querymgmt reopen", pQueryMgmt->vgId);
+
+  pthread_mutex_lock(&pQueryMgmt->lock);
+  pQueryMgmt->closed = false;
+  pthread_mutex_unlock(&pQueryMgmt->lock);
+}
+
+void qCleanupQueryMgmt(void* pQMgmt) {
+  if (pQMgmt == NULL) {
+    return;
+  }
+
+  SQueryMgmt* pQueryMgmt = pQMgmt;
+  int32_t vgId = pQueryMgmt->vgId;
+
+  assert(pQueryMgmt->closed);
+
+  SCacheObj* pqinfoPool = pQueryMgmt->qinfoPool;
+  pQueryMgmt->qinfoPool = NULL;
+
+  taosCacheCleanup(pqinfoPool);
+  pthread_mutex_destroy(&pQueryMgmt->lock);
+  tfree(pQueryMgmt);
+
+  qDebug("vgId:%d, queryMgmt cleanup completed", vgId);
+}
+
+void** qRegisterQInfo(void* pMgmt, uint64_t qInfo) {
+  if (pMgmt == NULL) {
+    terrno = TSDB_CODE_VND_INVALID_VGROUP_ID;
+    return NULL;
+  }
+
+  SQueryMgmt *pQueryMgmt = pMgmt;
+  if (pQueryMgmt->qinfoPool == NULL) {
+    qError("QInfo:%p failed to add qhandle into qMgmt, since qMgmt is closed", (void *)qInfo);
+    terrno = TSDB_CODE_VND_INVALID_VGROUP_ID;
+    return NULL;
+  }
+
+  pthread_mutex_lock(&pQueryMgmt->lock);
+  if (pQueryMgmt->closed) {
+    pthread_mutex_unlock(&pQueryMgmt->lock);
+    qError("QInfo:%p failed to add qhandle into cache, since qMgmt is colsing", (void *)qInfo);
+    terrno = TSDB_CODE_VND_INVALID_VGROUP_ID;
+    return NULL;
+  } else {
+    TSDB_CACHE_PTR_TYPE handleVal = (TSDB_CACHE_PTR_TYPE) qInfo;
+    void** handle = taosCachePut(pQueryMgmt->qinfoPool, &handleVal, sizeof(TSDB_CACHE_PTR_TYPE), &qInfo, sizeof(TSDB_CACHE_PTR_TYPE),
+                                 (getMaximumIdleDurationSec()*1000));
+    pthread_mutex_unlock(&pQueryMgmt->lock);
+
+    return handle;
+  }
+}
+
+void** qAcquireQInfo(void* pMgmt, uint64_t _key) {
+  SQueryMgmt *pQueryMgmt = pMgmt;
+
+  if (pQueryMgmt->closed) {
+    terrno = TSDB_CODE_VND_INVALID_VGROUP_ID;
+    return NULL;
+  }
+
+  if (pQueryMgmt->qinfoPool == NULL) {
+    terrno = TSDB_CODE_QRY_INVALID_QHANDLE;
+    return NULL;
+  }
+
+  TSDB_CACHE_PTR_TYPE key = (TSDB_CACHE_PTR_TYPE)_key;
+  void** handle = taosCacheAcquireByKey(pQueryMgmt->qinfoPool, &key, sizeof(TSDB_CACHE_PTR_TYPE));
+  if (handle == NULL || *handle == NULL) {
+    terrno = TSDB_CODE_QRY_INVALID_QHANDLE;
+    return NULL;
+  } else {
+    return handle;
+  }
+}
+
+void** qReleaseQInfo(void* pMgmt, void* pQInfo, bool freeHandle) {
+  SQueryMgmt *pQueryMgmt = pMgmt;
+  if (pQueryMgmt->qinfoPool == NULL) {
+    return NULL;
+  }
+
+  taosCacheRelease(pQueryMgmt->qinfoPool, pQInfo, freeHandle);
+  return 0;
+}
diff --git a/src/util/inc/tarray.h b/src/util/inc/tarray.h
index 9c3fa70b35467158094fe465dffac17f7785babf..63e62a54c2f679920100b7137cb49377da90789f 100644
--- a/src/util/inc/tarray.h
+++ b/src/util/inc/tarray.h
@@ -125,7 +125,7 @@ void taosArrayRemove(SArray* pArray, size_t index);
  * @param pDst
  * @param pSrc
  */
-void taosArrayCopy(SArray* pDst, const SArray* pSrc);
+SArray* taosArrayFromList(const void* src, size_t size, size_t elemSize);
 
 /**
  * clone a new array
diff --git a/src/util/src/tarray.c b/src/util/src/tarray.c
index 2752782376fb4fa13d788af051b19616974a3bb5..4dde5dbba24adfcda0fe794f2f36d6c059354f55 100644
--- a/src/util/src/tarray.c
+++ b/src/util/src/tarray.c
@@ -156,23 +156,14 @@ void taosArrayRemove(SArray* pArray, size_t index) {
   pArray->size -= 1;
 }
 
-void taosArrayCopy(SArray* pDst, const SArray* pSrc) {
-  assert(pSrc != NULL && pDst != NULL);
-  
-  if (pDst->capacity < pSrc->size) {
-    void* pData = realloc(pDst->pData, pSrc->size * pSrc->elemSize);
-    if (pData == NULL) { // todo handle oom
-    
-    } else {
-      pDst->pData = pData;
-      pDst->capacity = pSrc->size;
-    }
-  }
-  
-  memcpy(pDst->pData, pSrc->pData, pSrc->elemSize * pSrc->size);
-  pDst->elemSize = pSrc->elemSize;
-  pDst->capacity = pSrc->size;
-  pDst->size = pSrc->size;
+SArray* taosArrayFromList(const void* src, size_t size, size_t elemSize) {
+  assert(src != NULL && elemSize > 0);
+  SArray* pDst = taosArrayInit(size, elemSize);
+
+  memcpy(pDst->pData, src, elemSize * size);
+  pDst->size = size;
+
+  return pDst;
 }
 
 SArray* taosArrayDup(const SArray* pSrc) {
diff --git a/tests/pytest/crash_gen/crash_gen_main.py b/tests/pytest/crash_gen/crash_gen_main.py
index c6b857b097671b8faf650f4659c2b2990ef67d97..13e59f345e130516b16749392c71c9de076074e0 100755
--- a/tests/pytest/crash_gen/crash_gen_main.py
+++ b/tests/pytest/crash_gen/crash_gen_main.py
@@ -1276,6 +1276,7 @@ class Task():
                 0x510,  # vnode not in ready state
                 0x14,   # db not ready, errno changed
                 0x600,  # Invalid table ID, why?
+                0x218,  # Table does not exist
                 1000  # REST catch-all error
             ]: 
             return True # These are the ALWAYS-ACCEPTABLE ones
diff --git a/tests/script/general/parser/alter.sim b/tests/script/general/parser/alter.sim
index 56a677cc73f35d7656daef6fd3062bbc453007ef..e604d2122e56b4b2d87ca6cd87597abcac02672c 100644
--- a/tests/script/general/parser/alter.sim
+++ b/tests/script/general/parser/alter.sim
@@ -133,7 +133,7 @@ sleep 100
 #  return -1
 #endi
 #sql alter table tb1 drop column c3
-#sleep 2000
+#sleep 500
 #sql insert into tb1 values (now, 2, 'taos')
 #sleep 30000
 #sql select * from strm
@@ -144,7 +144,7 @@ sleep 100
 #  return -1
 #endi
 #sql alter table tb1 add column c3 int
-#sleep 2000
+#sleep 500
 #sql insert into tb1 values (now, 3, 'taos', 3);
 #sleep 100
 #sql select * from strm
diff --git a/tests/script/general/parser/auto_create_tb.sim b/tests/script/general/parser/auto_create_tb.sim
index e19eb0c667d5e667e3a044c9045c0584ec41d4e2..926eb7547694860810e4018d814637c788787e54 100644
--- a/tests/script/general/parser/auto_create_tb.sim
+++ b/tests/script/general/parser/auto_create_tb.sim
@@ -208,7 +208,7 @@ endi
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
diff --git a/tests/script/general/parser/col_arithmetic_operation.sim b/tests/script/general/parser/col_arithmetic_operation.sim
index efea3bfd59a4763109690c9ddacd1c0f84191732..3911c2dca6da3f13dd908b4a0e1cc9f6f7279cfa 100644
--- a/tests/script/general/parser/col_arithmetic_operation.sim
+++ b/tests/script/general/parser/col_arithmetic_operation.sim
@@ -105,7 +105,7 @@ run general/parser/col_arithmetic_query.sim
 #======================================= all in files query =======================================
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 
 print ================== server restart completed
diff --git a/tests/script/general/parser/commit.sim b/tests/script/general/parser/commit.sim
index 533fbf48f068d166ff0d7de440117694c4d48a97..4085ef620d26ac7c869d6f2a298022ac2fe19564 100644
--- a/tests/script/general/parser/commit.sim
+++ b/tests/script/general/parser/commit.sim
@@ -82,7 +82,7 @@ endw
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 sleep 100
 print ================== server restart completed
diff --git a/tests/script/general/parser/first_last.sim b/tests/script/general/parser/first_last.sim
index 9c1f0774badf5edf44cc616f085eb06c8a47c120..aeff740a5f790533e26fda99205d3cffc876deb1 100644
--- a/tests/script/general/parser/first_last.sim
+++ b/tests/script/general/parser/first_last.sim
@@ -77,7 +77,7 @@ run general/parser/first_last_query.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
diff --git a/tests/script/general/parser/import.sim b/tests/script/general/parser/import.sim
index 83751dc6166275d7d61ad9d63b41b0817ecd8a77..d626f4fa74eb3f53a9f9118800494a05320678a7 100644
--- a/tests/script/general/parser/import.sim
+++ b/tests/script/general/parser/import.sim
@@ -25,15 +25,15 @@ sql use $db
 sql create table tb (ts timestamp, c1 int, c2 timestamp)
 sql insert into tb values ('2019-05-05 11:30:00.000', 1, now)
 sql insert into tb values ('2019-05-05 12:00:00.000', 1, now)
-sleep 2000
+sleep 500
 sql import into tb values ('2019-05-05 11:00:00.000', -1, now)
-sleep 2000
+sleep 500
 sql import into tb values ('2019-05-05 11:59:00.000', -1, now)
-sleep 2000
+sleep 500
 sql import into tb values ('2019-05-04 08:00:00.000', -1, now)
-sleep 2000
+sleep 500
 sql import into tb values ('2019-05-04 07:59:00.000', -1, now)
-sleep 2000
+sleep 500
 
 sql select * from tb
 if $rows != 6 then
@@ -60,7 +60,7 @@ endi
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
diff --git a/tests/script/general/parser/import_commit1.sim b/tests/script/general/parser/import_commit1.sim
index 27be5560c5812d3856929d0da7b53a23fda6210c..f330fe4cd94b1cba82ea985b9b4841245753e099 100644
--- a/tests/script/general/parser/import_commit1.sim
+++ b/tests/script/general/parser/import_commit1.sim
@@ -40,7 +40,7 @@ while $x < $rowNum
 endw 
 print ====== tables created
 
-sleep 2000
+sleep 500
 
 $ts = $ts0 + $delta
 $ts = $ts + 1
diff --git a/tests/script/general/parser/import_commit2.sim b/tests/script/general/parser/import_commit2.sim
index 72ee2b3844f09af2dc3c15ba6426c9fd51ad832f..47b30acb49111da69c1c0b8b1927fd7f13f0c31c 100644
--- a/tests/script/general/parser/import_commit2.sim
+++ b/tests/script/general/parser/import_commit2.sim
@@ -39,7 +39,7 @@ while $x < $rowNum
 endw 
 print ====== tables created
 
-sleep 2000
+sleep 500
 
 $ts = $ts0 + $delta
 $ts = $ts + 1
diff --git a/tests/script/general/parser/import_commit3.sim b/tests/script/general/parser/import_commit3.sim
index a9f021b20c42c03535fda4df28fbe1eb3c246a11..1e041375de3da7fc2a5c17ae40caa1251b5d9d1b 100644
--- a/tests/script/general/parser/import_commit3.sim
+++ b/tests/script/general/parser/import_commit3.sim
@@ -39,7 +39,7 @@ while $x < $rowNum
 endw 
 print ====== tables created
 
-sleep 2000
+sleep 500
 
 $ts = $ts + 1
 sql insert into $tb values ( $ts , -1, -1, -1, -1, -1)
@@ -47,7 +47,7 @@ $ts = $ts0 + $delta
 $ts = $ts + 1
 sql import into $tb values ( $ts , -2, -2, -2, -2, -2)
 
-sleep 2000
+sleep 500
 
 sql show databases
 
diff --git a/tests/script/general/parser/import_file.sim b/tests/script/general/parser/import_file.sim
index 6b4dd07c7981ca141765b41cca3d005874a6583f..e50fc92e28ee498989f8b71d1bc5dd50faa7baa3 100644
--- a/tests/script/general/parser/import_file.sim
+++ b/tests/script/general/parser/import_file.sim
@@ -3,9 +3,9 @@ system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/exec.sh -n dnode1 -s start
-sleep 2000
+sleep 500
 sql connect
-sleep 2000
+sleep 500
 
 sql drop database if exists indb
 
diff --git a/tests/script/general/parser/insert_multiTbl.sim b/tests/script/general/parser/insert_multiTbl.sim
index 39223d84e394454b028b40a8dfa3f5457e0e9428..e9ee4fcf98666ddf81816c367927c8e528de3f42 100644
--- a/tests/script/general/parser/insert_multiTbl.sim
+++ b/tests/script/general/parser/insert_multiTbl.sim
@@ -4,7 +4,7 @@ system sh/stop_dnodes.sh
 system sh/deploy.sh -n dnode1 -i 1
 system sh/cfg.sh -n dnode1 -c walLevel -v 0
 system sh/exec.sh -n dnode1 -s start
-sleep 2000
+sleep 500
 sql connect
 sleep 100
 print ======================== dnode1 start
diff --git a/tests/script/general/parser/interp.sim b/tests/script/general/parser/interp.sim
index 36a643c424b9db0bf81f9ab0c7f5d4f093e2183e..13b6a08024206b99b410ac06a913d14078c11bfc 100644
--- a/tests/script/general/parser/interp.sim
+++ b/tests/script/general/parser/interp.sim
@@ -59,7 +59,7 @@ run general/parser/interp_test.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
diff --git a/tests/script/general/parser/lastrow.sim b/tests/script/general/parser/lastrow.sim
index 682a6cd5dfe42fe0d0411416b76faba15ba88f2c..d1eadfb67a43c027b54c66967d8818454cc81d81 100644
--- a/tests/script/general/parser/lastrow.sim
+++ b/tests/script/general/parser/lastrow.sim
@@ -62,7 +62,7 @@ run general/parser/lastrow_query.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
diff --git a/tests/script/general/parser/limit.sim b/tests/script/general/parser/limit.sim
index 22d52c4257f07481e1dcc02119989d277d9e018d..17636dfb74d117187db66f5b66918fdd4ba9500b 100644
--- a/tests/script/general/parser/limit.sim
+++ b/tests/script/general/parser/limit.sim
@@ -66,7 +66,7 @@ run general/parser/limit_stb.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
diff --git a/tests/script/general/parser/limit1.sim b/tests/script/general/parser/limit1.sim
index 0597723490f1c6af3ef6518dfa3b0d8aa005d3c4..2c40f0af2bfd3b38a43cefa4501d992dcbcfa661 100644
--- a/tests/script/general/parser/limit1.sim
+++ b/tests/script/general/parser/limit1.sim
@@ -61,7 +61,7 @@ run general/parser/limit1_stb.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
diff --git a/tests/script/general/parser/limit1_tblocks100.sim b/tests/script/general/parser/limit1_tblocks100.sim
index 43519d2df4ddee99ea5de3a797d5333b10f48f4a..45ead58ba067be400f60c39a15cc58adb2b75a05 100644
--- a/tests/script/general/parser/limit1_tblocks100.sim
+++ b/tests/script/general/parser/limit1_tblocks100.sim
@@ -61,7 +61,7 @@ run general/parser/limit1_stb.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
diff --git a/tests/script/general/parser/limit2.sim b/tests/script/general/parser/limit2.sim
index ddc5c10362a0743381e3f935a9d078c20be31858..0e7e13b6de0ea5eb40fd0609f9591b839157f5d6 100644
--- a/tests/script/general/parser/limit2.sim
+++ b/tests/script/general/parser/limit2.sim
@@ -69,7 +69,7 @@ print ====== tables created
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
diff --git a/tests/script/general/parser/limit2_query.sim b/tests/script/general/parser/limit2_query.sim
index 1e8077d26e03a9fb50425a74bbbe0ca027fb9c66..9fe287960d22642bbea0139246d3f90537fef628 100644
--- a/tests/script/general/parser/limit2_query.sim
+++ b/tests/script/general/parser/limit2_query.sim
@@ -143,6 +143,97 @@ if $data11 != -1 then
   return -1
 endi
 
+sql select max(c1) from lm2_tb0 where ts >= 1537146000000 and ts <= 1543145400000 interval(5m) fill(value, -1000, -2) limit 8200
+if $rows != 8200 then
+  return -1
+endi
+
+sql select max(c1) from lm2_tb0 where ts >= 1537146000000 and ts <= 1543145400000 interval(5m) fill(value, -1000, -2) limit 10 offset 8190;
+if $rows != 10 then
+  return -1
+endi
+
+if $data00 != @18-10-15 19:30:00.000@ then
+  return -1
+endi
+
+if $data01 != 5 then
+  return -1
+endi
+
+if $data10 != @18-10-15 19:35:00.000@ then
+  return -1
+endi
+
+if $data11 != -1000 then
+  return -1
+endi
+
+if $data20 != @18-10-15 19:40:00.000@ then
+  return -1
+endi
+
+if $data21 != 6 then
+  return -1
+endi
+
+if $data30 != @18-10-15 19:45:00.000@ then
+  return -1
+endi
+
+if $data31 != -1000 then
+  return -1
+endi
+
+sql select max(c1) from lm2_tb0 where ts >= 1537146000000 and ts <= 1543145400000 interval(5m) fill(value, -1000, -2) limit 10 offset 10001;
+if $rows != 10 then
+  return -1
+endi
+
+if $data00 != @18-10-22 02:25:00.000@ then
+  return -1
+endi
+
+if $data01 != -1000 then
+  return -1
+endi
+
+if $data10 != @18-10-22 02:30:00.000@ then
+  return -1
+endi
+
+if $data11 != 1 then
+  return -1
+endi
+
+if $data20 != @18-10-22 02:35:00.000@ then
+  return -1
+endi
+
+if $data21 != -1000 then
+  return -1
+endi
+
+if $data30 != @18-10-22 02:40:00.000@ then
+  return -1
+endi
+
+if $data31 != 2 then
+  return -1
+endi
+
+sql select max(c1) from lm2_tb0 where ts >= 1537146000000 and ts <= 1543145400000 interval(5m) fill(value, -1000, -2) limit 10000 offset 10001;
+print ====> needs to validate the last row result
+if $rows != 9998 then
+  return -1
+endi
+
+
+sql select max(c1) from lm2_tb0 where ts >= 1537146000000 and ts <= 1543145400000 interval(5m) fill(value, -1000, -2) limit 100 offset 20001;
+if $rows != 0 then
+  return -1
+endi
+
 # tb + interval + fill(linear) + limit offset
 $limit = $rowNum
 $offset = $limit / 2
diff --git a/tests/script/general/parser/mixed_blocks.sim b/tests/script/general/parser/mixed_blocks.sim
index 79bf65d1475a8f73fb31df35bf5e8e5f31476fca..8208963858721c88262af385fe4d9336012d63e8 100644
--- a/tests/script/general/parser/mixed_blocks.sim
+++ b/tests/script/general/parser/mixed_blocks.sim
@@ -59,7 +59,7 @@ sql show databases
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
@@ -154,7 +154,7 @@ sql insert into t2 values('2020-1-1 1:5:1', 99);
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql select ts from m1 where ts='2020-1-1 1:5:1'
diff --git a/tests/script/general/parser/projection_limit_offset.sim b/tests/script/general/parser/projection_limit_offset.sim
index e8a4c75a12f7ffcbe38cf2bd342dbace5e12cf02..a92493b7f4a9dfa180836360c7c39b37a4991c83 100644
--- a/tests/script/general/parser/projection_limit_offset.sim
+++ b/tests/script/general/parser/projection_limit_offset.sim
@@ -334,6 +334,9 @@ sql insert into tm0 values(10000, 1) (20000, 2)(30000, 3) (40000, NULL) (50000,
 
 #=============================tbase-1205
 sql select count(*) from tm1 where ts<now and ts>= now -1d interval(1h) fill(NULL);
+if $rows != 0 then
+  return -1
+endi
 
 print ===================>TD-1834
 sql select * from tm0 where ts>11000 and ts< 20000 order by ts asc
@@ -409,7 +412,7 @@ sql_error select k, sum(k)+1 from tm0;
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
diff --git a/tests/script/general/parser/selectResNum.sim b/tests/script/general/parser/selectResNum.sim
index 8f18a41d417ce8928dd2a991526641a17fc62d77..20b502447836409ca06c6acaebd7bd55921f7404 100644
--- a/tests/script/general/parser/selectResNum.sim
+++ b/tests/script/general/parser/selectResNum.sim
@@ -118,7 +118,7 @@ endw
 
 print ====== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ====== server restart completed
 sleep 100
diff --git a/tests/script/general/parser/select_from_cache_disk.sim b/tests/script/general/parser/select_from_cache_disk.sim
index 36a749cc3c4aa46bc2d52dd2352905f68a213c87..3d2cc0b70060ed9124205a00e3ea9922f2ed203b 100644
--- a/tests/script/general/parser/select_from_cache_disk.sim
+++ b/tests/script/general/parser/select_from_cache_disk.sim
@@ -35,7 +35,7 @@ sql insert into $tb values ('2018-09-17 09:00:00.030', 3)
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
diff --git a/tests/script/general/parser/set_tag_vals.sim b/tests/script/general/parser/set_tag_vals.sim
index 0b8ffd946f2bb052743faf4a732a06e4a68c5aec..92380ace8419c7756975fa4ce19482b845f804bf 100644
--- a/tests/script/general/parser/set_tag_vals.sim
+++ b/tests/script/general/parser/set_tag_vals.sim
@@ -61,7 +61,7 @@ while $i < $tbNum
 endw 
 print ====== tables created
 
-sleep 2000
+sleep 500
 
 sql show tables
 if $rows != $tbNum then
diff --git a/tests/script/general/parser/single_row_in_tb.sim b/tests/script/general/parser/single_row_in_tb.sim
index 651f44a3a4dac3437e3c95bd3d8b42b632c58abf..bc9362904163c7abf9d32f517a31e503801fcab4 100644
--- a/tests/script/general/parser/single_row_in_tb.sim
+++ b/tests/script/general/parser/single_row_in_tb.sim
@@ -32,7 +32,7 @@ run general/parser/single_row_in_tb_query.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
diff --git a/tests/script/general/parser/slimit.sim b/tests/script/general/parser/slimit.sim
index 426104c1680c777214c5514ecf8dc251540f75b6..bfb97b52618b7167434680c41d16f23786312fea 100644
--- a/tests/script/general/parser/slimit.sim
+++ b/tests/script/general/parser/slimit.sim
@@ -97,7 +97,7 @@ run general/parser/slimit_query.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
diff --git a/tests/script/general/parser/slimit1.sim b/tests/script/general/parser/slimit1.sim
index 85cbe51aad166973367c094ac531fe7e58776468..901da4cab226bfaba705f7a0976731f017b8d941 100644
--- a/tests/script/general/parser/slimit1.sim
+++ b/tests/script/general/parser/slimit1.sim
@@ -56,7 +56,7 @@ run general/parser/slimit1_query.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
diff --git a/tests/script/general/parser/slimit_alter_tags.sim b/tests/script/general/parser/slimit_alter_tags.sim
index 1073e0a3cc254dad66436896216411b026354040..ad557e891b0cb0b715da1c494c98e4a16213db8e 100644
--- a/tests/script/general/parser/slimit_alter_tags.sim
+++ b/tests/script/general/parser/slimit_alter_tags.sim
@@ -93,7 +93,7 @@ if $data02 != tb0 then
   return -1
 endi
 
-sleep 2000
+sleep 500
 sql reset query cache
 sql select count(*), first(ts) from stb group by tg_added order by tg_added asc slimit 5 soffset 3
 if $rows != 5 then
@@ -171,7 +171,7 @@ endi
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
diff --git a/tests/script/general/parser/tbnameIn.sim b/tests/script/general/parser/tbnameIn.sim
index 65ed1ed65d50e96bee1b9185f1ecc5f2e18f376e..2ee5f38ab1b48a485be06376da08612bee9b98e8 100644
--- a/tests/script/general/parser/tbnameIn.sim
+++ b/tests/script/general/parser/tbnameIn.sim
@@ -67,7 +67,7 @@ run general/parser/tbnameIn_query.sim
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 
diff --git a/tests/script/general/parser/testSuite.sim b/tests/script/general/parser/testSuite.sim
index 1dfdf9aac7732005bb9bf09bc456bd8284b20bf3..255389a2df12e470890ca74e9b3872a28bc119c3 100644
--- a/tests/script/general/parser/testSuite.sim
+++ b/tests/script/general/parser/testSuite.sim
@@ -1,84 +1,84 @@
-#run general/parser/alter.sim
-#sleep 100
-#run general/parser/alter1.sim
-#sleep 100
-#run general/parser/alter_stable.sim
-#sleep 100
-#run general/parser/auto_create_tb.sim
-#sleep 100
-#run general/parser/auto_create_tb_drop_tb.sim
-#sleep 100
-#run general/parser/col_arithmetic_operation.sim
-#sleep 100
-#run general/parser/columnValue.sim
-#sleep 100
-#run general/parser/commit.sim
-#sleep 100
-#run general/parser/create_db.sim
-#sleep 100
-#run general/parser/create_mt.sim
-#sleep 100
-#run general/parser/create_tb.sim
-#sleep 100
-#run general/parser/dbtbnameValidate.sim
-#sleep 100
-#run general/parser/fill.sim
-#sleep 100
-#run general/parser/fill_stb.sim
-#sleep 100
-##run general/parser/fill_us.sim               #
-#sleep 100
-#run general/parser/first_last.sim
-#sleep 100
-#run general/parser/import_commit1.sim
-#sleep 100
-#run general/parser/import_commit2.sim
-#sleep 100
-#run general/parser/import_commit3.sim
-#sleep 100
-##run general/parser/import_file.sim
-#sleep 100
-#run general/parser/insert_tb.sim
-#sleep 100
-#run general/parser/tags_dynamically_specifiy.sim
-#sleep 100
-#run general/parser/interp.sim
-#sleep 100
-#run general/parser/lastrow.sim
-#sleep 100
-#run general/parser/limit.sim
-#sleep 100
-#run general/parser/limit1.sim
-#sleep 100
-#run general/parser/limit1_tblocks100.sim
-#sleep 100
-#run general/parser/limit2.sim
-#sleep 100
-#run general/parser/mixed_blocks.sim
-#sleep 100
-#run general/parser/nchar.sim
-#sleep 100
-#run general/parser/null_char.sim
-#sleep 100
-#run general/parser/selectResNum.sim
-#sleep 100
-#run general/parser/select_across_vnodes.sim
-#sleep 100
-#run general/parser/select_from_cache_disk.sim
-#sleep 100
-#run general/parser/set_tag_vals.sim
-#sleep 100
-#run general/parser/single_row_in_tb.sim
-#sleep 100
-#run general/parser/slimit.sim
-#sleep 100
-#run general/parser/slimit1.sim
-#sleep 100
-#run general/parser/slimit_alter_tags.sim
-#sleep 100
-#run general/parser/tbnameIn.sim
-#sleep 100
-#run general/parser/slimit_alter_tags.sim  # persistent failed
+run general/parser/alter.sim
+sleep 100
+run general/parser/alter1.sim
+sleep 100
+run general/parser/alter_stable.sim
+sleep 100
+run general/parser/auto_create_tb.sim
+sleep 100
+run general/parser/auto_create_tb_drop_tb.sim
+sleep 100
+run general/parser/col_arithmetic_operation.sim
+sleep 100
+run general/parser/columnValue.sim
+sleep 100
+run general/parser/commit.sim
+sleep 100
+run general/parser/create_db.sim
+sleep 100
+run general/parser/create_mt.sim
+sleep 100
+run general/parser/create_tb.sim
+sleep 100
+run general/parser/dbtbnameValidate.sim
+sleep 100
+run general/parser/fill.sim
+sleep 100
+run general/parser/fill_stb.sim
+sleep 100
+#run general/parser/fill_us.sim               #
+sleep 100
+run general/parser/first_last.sim
+sleep 100
+run general/parser/import_commit1.sim
+sleep 100
+run general/parser/import_commit2.sim
+sleep 100
+run general/parser/import_commit3.sim
+sleep 100
+#run general/parser/import_file.sim
+sleep 100
+run general/parser/insert_tb.sim
+sleep 100
+run general/parser/tags_dynamically_specifiy.sim
+sleep 100
+run general/parser/interp.sim
+sleep 100
+run general/parser/lastrow.sim
+sleep 100
+run general/parser/limit.sim
+sleep 100
+run general/parser/limit1.sim
+sleep 100
+run general/parser/limit1_tblocks100.sim
+sleep 100
+run general/parser/limit2.sim
+sleep 100
+run general/parser/mixed_blocks.sim
+sleep 100
+run general/parser/nchar.sim
+sleep 100
+run general/parser/null_char.sim
+sleep 100
+run general/parser/selectResNum.sim
+sleep 100
+run general/parser/select_across_vnodes.sim
+sleep 100
+run general/parser/select_from_cache_disk.sim
+sleep 100
+run general/parser/set_tag_vals.sim
+sleep 100
+run general/parser/single_row_in_tb.sim
+sleep 100
+run general/parser/slimit.sim
+sleep 100
+run general/parser/slimit1.sim
+sleep 100
+run general/parser/slimit_alter_tags.sim
+sleep 100
+run general/parser/tbnameIn.sim
+sleep 100
+run general/parser/slimit_alter_tags.sim  # persistent failed
 sleep 100
 run general/parser/join.sim
 sleep 100
diff --git a/tests/script/general/parser/topbot.sim b/tests/script/general/parser/topbot.sim
index 57378331e80489e9c3d3eaaaf321730e7e132f55..f5c78d07a1d362ffdd5ebe5c989d88cc35a33e72 100644
--- a/tests/script/general/parser/topbot.sim
+++ b/tests/script/general/parser/topbot.sim
@@ -128,7 +128,7 @@ sql insert into test values(29999, 1)(70000, 2)(80000, 3)
 
 print ================== restart server to commit data into disk
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 system sh/exec.sh -n dnode1 -s start
 print ================== server restart completed
 sql connect
diff --git a/tests/script/general/parser/where.sim b/tests/script/general/parser/where.sim
index 1f148cbb2cb9a4b9ee4b0eaeffc8dad6e6d576d0..5f9e0ec2083de0ee4acdd3f727189a229e6eaa38 100644
--- a/tests/script/general/parser/where.sim
+++ b/tests/script/general/parser/where.sim
@@ -324,7 +324,7 @@ while $i < 1
 endw
 
 system sh/exec.sh -n dnode1 -s stop -x SIGINT
-sleep 2000
+sleep 500
 
 system sh/exec.sh -n dnode1 -s start