[tbase-1282]

src/client/inc/tscUtil.h

@@ -95,6 +95,8 @@ SMeterSidExtInfo* tscGetMeterSidInfo(SVnodeSidList* pSidList, int32_t idx);
 bool tscIsPointInterpQuery(SSqlCmd* pCmd);
 bool tscIsTWAQuery(SSqlCmd* pCmd);
 bool tscProjectionQueryOnMetric(SSqlCmd* pCmd);
+bool tscProjectionQueryOnTable(SSqlCmd* pCmd);
+
 bool tscIsTwoStageMergeMetricQuery(SSqlCmd* pCmd);
 bool tscQueryOnMetric(SSqlCmd* pCmd);
 bool tscQueryMetricTags(SSqlCmd* pCmd);

src/client/inc/tsclient.h

@@ -477,6 +477,8 @@ void    tscProcessMultiVnodesInsertForFile(SSqlObj *pSql);
 void    tscKillMetricQuery(SSqlObj *pSql);
 void    tscInitResObjForLocalQuery(SSqlObj *pObj, int32_t numOfRes, int32_t rowLen);
 bool    tscIsUpdateQuery(STscObj *pObj);
+bool    tscHasReachLimitation(SSqlObj* pSql);
+
 int32_t tscInvalidSQLErrMsg(char *msg, const char *additionalInfo, const char *sql);
 
 // transfer SSqlInfo to SqlCmd struct

src/client/src/tscAst.c

@@ -112,8 +112,9 @@ static tSQLSyntaxNode *tSQLSyntaxNodeCreate(SSchema *pSchema, int32_t numOfCols,
   tSQLSyntaxNode *pNode = NULL;
 
   if (pToken->type == TK_ID || pToken->type == TK_TBNAME) {
-    if (pToken->type == TK_ID) {
     int32_t i = 0;
+    
+    if (pToken->type == TK_ID) {
       do {
         size_t len = strlen(pSchema[i].name);
         if (strncmp(pToken->z, pSchema[i].name, pToken->n) == 0 && pToken->n == len) break;
@@ -326,8 +327,8 @@ static tSQLSyntaxNode *createSyntaxTree(SSchema *pSchema, int32_t numOfCols, cha
     uint8_t localOptr = getBinaryExprOptr(&t0); 
     if (localOptr == 0) {
       pError("not support binary operator:%d", t0.type);
+      free(pBinExpr);
       return NULL;
-      free(pBinExpr)
     }
 
     return parseRemainStr(str, pBinExpr, pSchema, localOptr, numOfCols, i);
@@ -652,7 +653,6 @@ void tSQLListTraverseOnResult(struct tSQLBinaryExpr *pExpr, bool (*fp)(tSkipList
   // brutal force search
   int64_t num = pResult->num;
   for (int32_t i = 0, j = 0; i < pResult->num; ++i) {
-    //if (fp == NULL || (fp != NULL && fp(pResult->pRes[i], pExpr->info) == true)) {
     if (fp == NULL || (fp(pResult->pRes[i], pExpr->info) == true)) {
       pResult->pRes[j++] = pResult->pRes[i];
     } else {

src/client/src/tscJoinProcess.c

@@ -13,9 +13,9 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include "tscJoinProcess.h"
 #include "os.h"
 #include "tcache.h"
-#include "tscJoinProcess.h"
 #include "tscUtil.h"
 #include "tsclient.h"
 #include "tscompression.h"
@@ -45,8 +45,8 @@ static bool doCompare(int32_t order, int64_t left, int64_t right) {
   }
 }
 
-static int64_t doTSBlockIntersect(SSqlObj* pSql, SJoinSubquerySupporter* pSupporter1, SJoinSubquerySupporter* pSupporter2,
+static int64_t doTSBlockIntersect(SSqlObj* pSql, SJoinSubquerySupporter* pSupporter1,
-                               TSKEY* st, TSKEY* et) {
+                                  SJoinSubquerySupporter* pSupporter2, TSKEY* st, TSKEY* et) {
   STSBuf* output1 = tsBufCreate(true);
   STSBuf* output2 = tsBufCreate(true);
 
@@ -150,14 +150,15 @@ static int64_t doTSBlockIntersect(SSqlObj* pSql, SJoinSubquerySupporter* pSuppor
   tsBufDestory(pSupporter1->pTSBuf);
   tsBufDestory(pSupporter2->pTSBuf);
 
-  tscTrace("%p input1:%lld, input2:%lld, final:%lld for secondary query after ts blocks intersecting",
+  tscTrace("%p input1:%lld, input2:%lld, final:%lld for secondary query after ts blocks intersecting", pSql,
-           pSql, numOfInput1, numOfInput2, output1->numOfTotal);
+           numOfInput1, numOfInput2, output1->numOfTotal);
 
   return output1->numOfTotal;
 }
 
 // todo handle failed to create sub query
-SJoinSubquerySupporter* tscCreateJoinSupporter(SSqlObj* pSql, SSubqueryState* pState, /*int32_t* numOfComplete, int32_t* gc,*/ int32_t index) {
+SJoinSubquerySupporter* tscCreateJoinSupporter(SSqlObj* pSql, SSubqueryState* pState,
+                                               /*int32_t* numOfComplete, int32_t* gc,*/ int32_t index) {
   SJoinSubquerySupporter* pSupporter = calloc(1, sizeof(SJoinSubquerySupporter));
   if (pSupporter == NULL) {
     return NULL;
@@ -241,8 +242,10 @@ int32_t tscLaunchSecondSubquery(SSqlObj* pSql) {
   }
 
   // scan all subquery, if one sub query has only ts, ignore it
-  tscTrace("%p start to launch secondary subqueries, total:%d, only:%d needs to query, others are not retrieve in "
+  tscTrace(
-           "select clause", pSql, pSql->numOfSubs, numOfSub);
+      "%p start to launch secondary subqueries, total:%d, only:%d needs to query, others are not retrieve in "
+      "select clause",
+      pSql, pSql->numOfSubs, numOfSub);
 
   int32_t j = 0;
   for (int32_t i = 0; i < pSql->numOfSubs; ++i) {
@@ -434,7 +437,6 @@ static void joinRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
       }
 
       if (atomic_add_fetch_32(&pSupporter->pState->numOfCompleted, 1) >= pSupporter->pState->numOfTotal) {
-
         if (pSupporter->pState->code != TSDB_CODE_SUCCESS) {
           tscTrace("%p sub:%p, numOfSub:%d, quit from further procedure due to other queries failure", pParentSql, tres,
                    pSupporter->subqueryIndex);
@@ -472,13 +474,16 @@ static void joinRetrieveCallback(void* param, TAOS_RES* tres, int numOfRows) {
       tscError("%p retrieve failed, code:%d, index:%d", pSql, numOfRows, pSupporter->subqueryIndex);
     }
 
+    if (numOfRows >= 0) {
+      pSql->res.numOfTotal += pSql->res.numOfRows;
+    }
+
     if (tscProjectionQueryOnMetric(&pSql->cmd) && numOfRows == 0) {
       SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0);
       assert(pSql->cmd.numOfTables == 1);
 
       // for projection query, need to try next vnode if current vnode is exhausted
       if ((++pMeterMetaInfo->vnodeIndex) < pMeterMetaInfo->pMetricMeta->numOfVnodes) {
-  
         pSupporter->pState->numOfCompleted = 0;
         pSupporter->pState->numOfTotal = 1;
 
@@ -513,20 +518,28 @@ void tscFetchDatablockFromSubquery(SSqlObj* pSql) {
 
   for (int32_t i = 0; i < pSql->numOfSubs; ++i) {
     SSqlRes *pRes = &pSql->pSubs[i]->res;
-    SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->pSubs[i]->cmd, 0);
+    SSqlCmd *pCmd = &pSql->pSubs[i]->cmd;
   
-    if (UTIL_METER_IS_METRIC(pMeterMetaInfo)) {
+    SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
-      if (pRes->row >= pRes->numOfRows && pMeterMetaInfo->vnodeIndex < pMeterMetaInfo->pMetricMeta->numOfVnodes) {
+  
+    if (tscProjectionQueryOnMetric(pCmd)) {
+      if (pRes->row >= pRes->numOfRows && pMeterMetaInfo->vnodeIndex < pMeterMetaInfo->pMetricMeta->numOfVnodes &&
+          (!tscHasReachLimitation(pSql->pSubs[i]))) {
         numOfFetch++;
       }
     } else {
-      if (pRes->row >= pRes->numOfRows) {
+      if ((pRes->row >= pRes->numOfRows && (!tscHasReachLimitation(pSql->pSubs[i])) && tscProjectionQueryOnTable(pSql))
+      || (pRes->numOfRows == 0)) {
         numOfFetch++;
       }
     }
   }
 
-  if (numOfFetch > 0) {
+  if (numOfFetch <= 0) {
+    return ;
+  }
+
+  // TODO multi-vnode retrieve for projection query with limitation has bugs, since the global limiation is not handled
   tscTrace("%p retrieve data from %d subqueries", pSql, numOfFetch);
 
   SJoinSubquerySupporter* pSupporter = (SJoinSubquerySupporter*)pSql->pSubs[0]->param;
@@ -543,16 +556,15 @@ void tscFetchDatablockFromSubquery(SSqlObj* pSql) {
 
     // wait for all subqueries completed
     pSupporter->pState->numOfTotal = numOfFetch;
-      
     assert(pRes1->numOfRows >= 0 && pCmd1->numOfTables == 1);
 
     SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(pCmd1, 0);
+    
     if (pRes1->row >= pRes1->numOfRows) {
       tscTrace("%p subquery:%p retrieve data from vnode, subquery:%d, vnodeIndex:%d", pSql, pSql1,
                pSupporter->subqueryIndex, pMeterMetaInfo->vnodeIndex);
 
       tscResetForNextRetrieve(pRes1);
-
       pSql1->fp = joinRetrieveCallback;
 
       if (pCmd1->command < TSDB_SQL_LOCAL) {
@@ -566,7 +578,6 @@ void tscFetchDatablockFromSubquery(SSqlObj* pSql) {
   // wait for all subquery completed
   tsem_wait(&pSql->rspSem);
 }
-}
 
 // all subqueries return, set the result output index
 void tscSetupOutputColumnIndex(SSqlObj* pSql) {
@@ -671,7 +682,8 @@ void tscJoinQueryCallback(void* param, TAOS_RES* tres, int code) {
         SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->cmd, 0);
 
         /**
-         * if the query is a continue query (vnodeIndex > 0 for projection query) for next vnode, do the retrieval of data instead of returning to its invoker
+         * if the query is a continue query (vnodeIndex > 0 for projection query) for next vnode, do the retrieval of
+         * data instead of returning to its invoker
          */
         if (pMeterMetaInfo->vnodeIndex > 0 && tscProjectionQueryOnMetric(&pSql->cmd)) {
           assert(pMeterMetaInfo->vnodeIndex < pMeterMetaInfo->pMetricMeta->numOfVnodes);
@@ -899,7 +911,6 @@ void tsBufDestory(STSBuf* pTSBuf) {
   }
 
   free(pTSBuf);
-  
 }
 
 static STSVnodeBlockInfoEx* tsBufGetLastVnodeInfo(STSBuf* pTSBuf) {
@@ -944,8 +955,8 @@ static STSVnodeBlockInfoEx* addOneVnodeInfo(STSBuf* pTSBuf, int32_t vnodeId) {
   pTSBuf->numOfVnodes += 1;
 
   // update the header info
-  STSBufFileHeader header =
+  STSBufFileHeader header = {
-      {.magic = TS_COMP_FILE_MAGIC, .numOfVnode = pTSBuf->numOfVnodes, .tsOrder = pTSBuf->tsOrder};
+      .magic = TS_COMP_FILE_MAGIC, .numOfVnode = pTSBuf->numOfVnodes, .tsOrder = pTSBuf->tsOrder};
 
   STSBufUpdateHeader(pTSBuf, &header);
   return tsBufGetLastVnodeInfo(pTSBuf);
@@ -1397,8 +1408,6 @@ STSElem tsBufGetElem(STSBuf* pTSBuf) {
   return elem1;
 }
 
-
-
 /**
  * current only support ts comp data from two vnode merge
  * @param pDestBuf
@@ -1491,8 +1500,8 @@ int32_t tsBufMerge(STSBuf* pDestBuf, const STSBuf* pSrcBuf, int32_t vnodeId) {
 
   assert(pDestBuf->fileSize == oldSize + size);
 
-  tscTrace("tsBuf merge success, %p, path:%s, fd:%d, file size:%d, numOfVnode:%d, autoDelete:%d", pDestBuf, pDestBuf->path,
+  tscTrace("tsBuf merge success, %p, path:%s, fd:%d, file size:%d, numOfVnode:%d, autoDelete:%d", pDestBuf,
-      fileno(pDestBuf->f), pDestBuf->fileSize, pDestBuf->numOfVnodes, pDestBuf->autoDelete);
+           pDestBuf->path, fileno(pDestBuf->f), pDestBuf->fileSize, pDestBuf->numOfVnodes, pDestBuf->autoDelete);
 
   return 0;
 }

src/client/src/tscSQLParser.c

@@ -5008,6 +5008,8 @@ int32_t parseLimitClause(SSqlObj* pSql, SQuerySQL* pQuerySql) {
 
   // handle the limit offset value, validate the limit
   pCmd->limit = pQuerySql->limit;
+  pCmd->globalLimit = pCmd->limit.limit;
+  
   pCmd->slimit = pQuerySql->slimit;
 
   if (pCmd->slimit.offset < 0 || pCmd->limit.offset < 0) {

src/client/src/tscSql.c

@@ -16,21 +16,21 @@
 #include "os.h"
 #include "tcache.h"
 #include "tlog.h"
+#include "tnote.h"
 #include "trpc.h"
 #include "tscJoinProcess.h"
 #include "tscProfile.h"
+#include "tscSQLParser.h"
 #include "tscSecondaryMerge.h"
 #include "tscUtil.h"
 #include "tsclient.h"
 #include "tscompression.h"
 #include "tsocket.h"
-#include "tscSQLParser.h"
 #include "ttimer.h"
 #include "tutil.h"
-#include "tnote.h"
 
-TAOS *taos_connect_imp(const char *ip, const char *user, const char *pass, const char *db, uint16_t port, void (*fp)(void *, TAOS_RES *, int),
+TAOS *taos_connect_imp(const char *ip, const char *user, const char *pass, const char *db, uint16_t port,
-                       void *param, void **taos) {
+                       void (*fp)(void *, TAOS_RES *, int), void *param, void **taos) {
   STscObj *pObj;
 
   taos_init();
@@ -271,7 +271,8 @@ int taos_query(TAOS *taos, const char *sqlstr) {
 
   size_t sqlLen = strlen(sqlstr);
   if (sqlLen > tsMaxSQLStringLen) {
-    pRes->code = tscInvalidSQLErrMsg(pSql->cmd.payload, "sql too long", NULL);  // set the additional error msg for invalid sql
+    pRes->code =
+        tscInvalidSQLErrMsg(pSql->cmd.payload, "sql too long", NULL);  // set the additional error msg for invalid sql
     tscError("%p SQL result:%d, %s pObj:%p", pSql, pRes->code, taos_errstr(taos), pObj);
 
     return pRes->code;
@@ -451,19 +452,26 @@ static void **getOneRowFromBuf(SSqlObj *pSql) {
   return pRes->tsrow;
 }
 
-static void **tscJoinResultsetFromBuf(SSqlObj *pSql) {
+static bool tscHashRemainDataInSubqueryResultSet(SSqlObj *pSql) {
-  SSqlCmd *pCmd = &pSql->cmd;
-  SSqlRes *pRes = &pSql->res;
-
-  while (1) {
   bool     hasData = true;
+  SSqlCmd *pCmd = &pSql->cmd;
 
   if (tscProjectionQueryOnMetric(pCmd)) {
     bool allSubqueryExhausted = true;
 
     for (int32_t i = 0; i < pSql->numOfSubs; ++i) {
-        SMeterMetaInfo* pMeterMetaInfo = tscGetMeterMetaInfo(&pSql->pSubs[i]->cmd, 0);
+      SSqlRes *pRes1 = &pSql->pSubs[i]->res;
-        if (pMeterMetaInfo->vnodeIndex < pMeterMetaInfo->pMetricMeta->numOfVnodes) {
+      SSqlCmd *pCmd1 = &pSql->pSubs[i]->cmd;
+
+      SMeterMetaInfo *pMetaInfo = tscGetMeterMetaInfo(pCmd1, 0);
+      assert(pCmd1->numOfTables == 1);
+
+      /*
+       * if the global limitation is not reached, and current result has not exhausted, or next more vnodes are
+       * available, go on
+       */
+      if (pMetaInfo->vnodeIndex < pMetaInfo->pMetricMeta->numOfVnodes && pRes1->row < pRes1->numOfRows &&
+          (!tscHasReachLimitation(pSql->pSubs[i]))) {
         allSubqueryExhausted = false;
         break;
       }
@@ -473,37 +481,27 @@ static void **tscJoinResultsetFromBuf(SSqlObj *pSql) {
   } else {  // otherwise, in case inner join, if any subquery exhausted, query completed.
     for (int32_t i = 0; i < pSql->numOfSubs; ++i) {
       SSqlRes *pRes1 = &pSql->pSubs[i]->res;
-        if (pRes1->numOfRows == 0) {
+
+      if ((pRes1->row >= pRes1->numOfRows && tscHasReachLimitation(pSql->pSubs[i]) &&
+           tscProjectionQueryOnTable(&pSql->pSubs[i]->cmd)) ||
+          (pRes1->numOfRows == 0)) {
+        
         hasData = false;
         break;
       }
     }
   }
 
-    for (int32_t i = 0; i < pSql->numOfSubs; ++i) {
+  return hasData;
-      SSqlRes *pRes1 = &pSql->pSubs[i]->res;
-      SMeterMetaInfo* pMeterMeta = tscGetMeterMetaInfo(&pSql->pSubs[i]->cmd, 0);
-      
-      if (tscProjectionQueryOnMetric(pCmd)) {
-        //For multi-vnode projection query, the results may locate in following vnode, so we needs to go on
-        if (pMeterMeta->vnodeIndex < pMeterMeta->pMetricMeta->numOfVnodes) {
-          break;
-        }
-      } else { //otherwise, in case inner join, if any subquery exhausted, query completed.
-        if (pRes1->numOfRows == 0) {
-          hasData = false;
-          break;
-        }
-      }
-//      if (pRes1->numOfRows == 0 && !tscProjectionQueryOnMetric(pCmd) ||
-//        (pMeterMeta->vnodeIndex >= pMeterMeta->pMetricMeta->numOfVnodes && )) {
-//        hasData = false;
-//        break;
-//      }
 }
 
-    if (!hasData) {  // free all sub sqlobj
+static void **tscJoinResultsetFromBuf(SSqlObj *pSql) {
-      tscTrace("%p one subquery exhausted, free other %d subquery", pSql, pSql->numOfSubs - 1);
+  SSqlCmd *pCmd = &pSql->cmd;
+  SSqlRes *pRes = &pSql->res;
+
+  while (1) {
+    if (!tscHashRemainDataInSubqueryResultSet(pSql)) {  // free all sub sqlobj
+      tscTrace("%p at least one subquery exhausted, free all other %d subqueries", pSql, pSql->numOfSubs - 1);
 
       SSubqueryState *pState = NULL;
 
@@ -539,7 +537,6 @@ static void **tscJoinResultsetFromBuf(SSqlObj *pSql) {
         pRes1->row++;
         pRes2->row++;
       }
-      
     } else {  // only one subquery
       SSqlRes *pRes1 = &pSql->pSubs[0]->res;
       doSetResultRowData(pSql->pSubs[0]);
@@ -547,7 +544,7 @@ static void **tscJoinResultsetFromBuf(SSqlObj *pSql) {
       success = (pRes1->row++ < pRes1->numOfRows);
     }
 
-    if (success) {
+    if (success) {  // current row of final output has been built, return to app
       for (int32_t i = 0; i < pCmd->exprsInfo.numOfExprs; ++i) {
         int32_t tableIndex = pRes->pColumnIndex[i].tableIndex;
         int32_t columnIndex = pRes->pColumnIndex[i].columnIndex;
@@ -557,7 +554,7 @@ static void **tscJoinResultsetFromBuf(SSqlObj *pSql) {
       }
 
       break;
-    } else {
+    } else {  // continue retrieve data from vnode
       tscFetchDatablockFromSubquery(pSql);
       if (pRes->code != TSDB_CODE_SUCCESS) {
         return NULL;
@@ -625,7 +622,7 @@ TAOS_ROW taos_fetch_row(TAOS_RES *res) {
     SMeterMetaInfo *pMeterMetaInfo = tscGetMeterMetaInfo(pCmd, 0);
 
     // reach the maximum number of output rows, abort
-    if (pCmd->globalLimit > 0 && pRes->numOfTotal >= pCmd->globalLimit) {
+    if (tscHasReachLimitation(pSql)) {
       return NULL;
     }
 
@@ -680,7 +677,7 @@ int taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows) {
   nRows = taos_fetch_block_impl(res, rows);
   while (*rows == NULL && tscProjectionQueryOnMetric(pCmd)) {
     /* reach the maximum number of output rows, abort */
-    if (pCmd->globalLimit > 0 && pRes->numOfTotal >= pCmd->globalLimit) {
+    if (tscHasReachLimitation(pSql)) {
       return 0;
     }
 
@@ -690,7 +687,6 @@ int taos_fetch_block(TAOS_RES *res, TAOS_ROW *rows) {
     pCmd->limit.limit = pSql->cmd.globalLimit - pRes->numOfTotal;
     pCmd->limit.offset = pRes->offset;
 
-
     if ((++pMeterMetaInfo->vnodeIndex) < pMeterMetaInfo->pMetricMeta->numOfVnodes) {
       pSql->cmd.command = TSDB_SQL_SELECT;
       assert(pSql->fp == NULL);
@@ -929,8 +925,7 @@ int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields)
 
         str[len + trueLen] = ' ';
         len += (trueLen + 1);
-      }
+      } break;
-        break;
 
       case TSDB_DATA_TYPE_TIMESTAMP:
         len += sprintf(str + len, "%lld ", *((int64_t *)row[i]));

src/client/src/tscUtil.c

@@ -244,8 +244,7 @@ bool tscProjectionQueryOnMetric(SSqlCmd* pCmd) {
 
   //for project query, only the following two function is allowed
   for (int32_t i = 0; i < pCmd->fieldsInfo.numOfOutputCols; ++i) {
-    SSqlExpr* pExpr = tscSqlExprGet(pCmd, i);
+    int32_t functionId = tscSqlExprGet(pCmd, i)->functionId;
-    int32_t functionId = pExpr->functionId;
     if (functionId != TSDB_FUNC_PRJ && functionId != TSDB_FUNC_TAGPRJ &&
         functionId != TSDB_FUNC_TAG && functionId != TSDB_FUNC_TS) {
       return false;
@@ -255,6 +254,17 @@ bool tscProjectionQueryOnMetric(SSqlCmd* pCmd) {
   return true;
 }
 
+bool tscProjectionQueryOnTable(SSqlCmd* pCmd) {
+  for (int32_t i = 0; i < pCmd->fieldsInfo.numOfOutputCols; ++i) {
+    int32_t functionId = tscSqlExprGet(pCmd, i)->functionId;
+    if (functionId != TSDB_FUNC_PRJ && functionId != TSDB_FUNC_TS) {
+      return false;
+    }
+  }
+  
+  return true;
+}
+
 bool tscIsPointInterpQuery(SSqlCmd* pCmd) {
   for (int32_t i = 0; i < pCmd->exprsInfo.numOfExprs; ++i) {
     SSqlExpr* pExpr = tscSqlExprGet(pCmd, i);
@@ -1673,7 +1683,10 @@ SSqlObj* createSubqueryObj(SSqlObj* pSql, int16_t tableIndex, void (*fp)(), void
 
   char key[TSDB_MAX_TAGS_LEN + 1] = {0};
   tscGetMetricMetaCacheKey(pCmd, key, pMetermetaInfo->pMeterMeta->uid);
-  printf("-----%s\n", key);
+  
+#ifdef _DEBUG_VIEW
+  printf("the metricmeta key is:%s\n", key);
+#endif
   
   char*           name = pMeterMetaInfo->name;
   SMeterMetaInfo* pFinalInfo = NULL;
@@ -1768,3 +1781,12 @@ int32_t tscInvalidSQLErrMsg(char *msg, const char *additionalInfo, const char *s
   return TSDB_CODE_INVALID_SQL;
 }
 
+bool tscHasReachLimitation(SSqlObj* pSql) {
+  assert(pSql != NULL && pSql->cmd.globalLimit != 0);
+  
+  SSqlCmd* pCmd = &pSql->cmd;
+  SSqlRes* pRes = &pSql->res;
+  
+  return (pCmd->globalLimit > 0 && pRes->numOfTotal >= pCmd->globalLimit);
+}
+