Merge pull request #22443 from taosdata/szhou/select-tags-scan

feature: tags scan with select tags

include/common/ttokendef.h

@@ -354,7 +354,6 @@
 #define TK_VIEW                           336
 #define TK_WAL                            337
 
-
 #define TK_NK_SPACE   600
 #define TK_NK_COMMENT 601
 #define TK_NK_ILLEGAL 602

include/libs/executor/storageapi.h

@@ -106,6 +106,8 @@ typedef struct SMCtbCursor {
   void    *pVal;
   int      kLen;
   int      vLen;
+  int8_t     paused;
+  int      lock;
 } SMCtbCursor;
 
 typedef struct SRowBuffPos {
@@ -295,7 +297,9 @@ int32_t vnodeGetCtbIdListByFilter(void *pVnode, int64_t suid, SArray *list, bool
 int32_t vnodeGetStbIdList(void *pVnode, int64_t suid, SArray *list);
  */
   SMCtbCursor* (*openCtbCursor)(void *pVnode, tb_uid_t uid, int lock);
-  void         (*closeCtbCursor)(SMCtbCursor *pCtbCur, int lock);
+  int32_t      (*resumeCtbCursor)(SMCtbCursor* pCtbCur, int8_t first);
+  void         (*pauseCtbCursor)(SMCtbCursor* pCtbCur);
+  void         (*closeCtbCursor)(SMCtbCursor *pCtbCur);
   tb_uid_t     (*ctbCursorNext)(SMCtbCursor* pCur);
 } SStoreMeta;
 

source/dnode/vnode/src/inc/vnodeInt.h

@@ -168,7 +168,9 @@ int metaDropIndexFromSTable(SMeta* pMeta, int64_t version, SDropIndexReq* pReq);
 
 int64_t       metaGetTimeSeriesNum(SMeta* pMeta);
 SMCtbCursor*  metaOpenCtbCursor(void* pVnode, tb_uid_t uid, int lock);
-void          metaCloseCtbCursor(SMCtbCursor* pCtbCur, int lock);
+int32_t       metaResumeCtbCursor(SMCtbCursor* pCtbCur, int8_t first);
+void          metaPauseCtbCursor(SMCtbCursor* pCtbCur);
+void          metaCloseCtbCursor(SMCtbCursor* pCtbCur);
 tb_uid_t      metaCtbCursorNext(SMCtbCursor* pCtbCur);
 SMStbCursor*  metaOpenStbCursor(SMeta* pMeta, tb_uid_t uid);
 void          metaCloseStbCursor(SMStbCursor* pStbCur);

source/dnode/vnode/src/meta/metaQuery.c

@@ -423,40 +423,75 @@ SMCtbCursor *metaOpenCtbCursor(void* pVnode, tb_uid_t uid, int lock) {
 
   pCtbCur->pMeta = pMeta;
   pCtbCur->suid = uid;
-  if (lock) {
+  pCtbCur->lock = lock;
-    metaRLock(pMeta);
+  pCtbCur->paused = 1;
-  }
 
-  ret = tdbTbcOpen(pMeta->pCtbIdx, (TBC**)&pCtbCur->pCur, NULL);
+  ret = metaResumeCtbCursor(pCtbCur, 1);
   if (ret < 0) {
-    metaULock(pMeta);
-    taosMemoryFree(pCtbCur);
     return NULL;
   }
+  return pCtbCur;
+}
 
+void metaCloseCtbCursor(SMCtbCursor *pCtbCur) {
+  if (pCtbCur) {
+    if (!pCtbCur->paused) {
+      if (pCtbCur->pMeta && pCtbCur->lock) metaULock(pCtbCur->pMeta);
+      if (pCtbCur->pCur) {
+        tdbTbcClose(pCtbCur->pCur);
+      }
+    }
+    tdbFree(pCtbCur->pKey);
+    tdbFree(pCtbCur->pVal);
+  }
+  taosMemoryFree(pCtbCur);
+}
+
+void metaPauseCtbCursor(SMCtbCursor* pCtbCur) {
+  if (!pCtbCur->paused) {
+    tdbTbcClose((TBC*)pCtbCur->pCur);
+    if (pCtbCur->lock) {
+      metaULock(pCtbCur->pMeta);
+    }
+    pCtbCur->paused = 1;
+  }
+}
+
+int32_t metaResumeCtbCursor(SMCtbCursor* pCtbCur, int8_t first) {
+  if (pCtbCur->paused) {
+    pCtbCur->paused = 0;
+
+    if (pCtbCur->lock) {
+      metaRLock(pCtbCur->pMeta);
+    }
+    int ret = 0;
+    ret = tdbTbcOpen(pCtbCur->pMeta->pCtbIdx, (TBC**)&pCtbCur->pCur, NULL);
+    if (ret < 0) {
+      metaCloseCtbCursor(pCtbCur);
+      return -1;
+    }
+
+    if (first) {
+      SCtbIdxKey   ctbIdxKey;
       // move to the suid
-  ctbIdxKey.suid = uid;
+      ctbIdxKey.suid = pCtbCur->suid;
       ctbIdxKey.uid = INT64_MIN;
+      int c = 0;
       tdbTbcMoveTo(pCtbCur->pCur, &ctbIdxKey, sizeof(ctbIdxKey), &c);
       if (c > 0) {
         tdbTbcMoveToNext(pCtbCur->pCur);
       }
-
+    } else {
-  return pCtbCur;
+      int c = 0;
+      ret = tdbTbcMoveTo(pCtbCur->pCur, pCtbCur->pKey, pCtbCur->kLen, &c);
+      if (c < 0) {
+        tdbTbcMoveToPrev(pCtbCur->pCur);
+      } else {
+        tdbTbcMoveToNext(pCtbCur->pCur);
       }
-
-void metaCloseCtbCursor(SMCtbCursor *pCtbCur, int lock) {
-  if (pCtbCur) {
-    if (pCtbCur->pMeta && lock) metaULock(pCtbCur->pMeta);
-    if (pCtbCur->pCur) {
-      tdbTbcClose(pCtbCur->pCur);
-
-      tdbFree(pCtbCur->pKey);
-      tdbFree(pCtbCur->pVal);
     }
-
-    taosMemoryFree(pCtbCur);
   }
+  return 0;
 }
 
 tb_uid_t metaCtbCursorNext(SMCtbCursor *pCtbCur) {
@@ -1414,7 +1449,7 @@ int32_t metaGetTableTags(void *pVnode, uint64_t suid, SArray *pUidTagInfo) {
   }
 
   taosHashCleanup(pSepecifiedUidMap);
-  metaCloseCtbCursor(pCur, 1);
+  metaCloseCtbCursor(pCur);
   return TSDB_CODE_SUCCESS;
 }
 

source/dnode/vnode/src/vnd/vnodeInitApi.c

@@ -98,6 +98,8 @@ void initMetadataAPI(SStoreMeta* pMeta) {
   pMeta->metaPutTbGroupToCache = metaPutTbGroupToCache;
 
   pMeta->openCtbCursor = metaOpenCtbCursor;
+  pMeta->resumeCtbCursor = metaResumeCtbCursor;
+  pMeta->pauseCtbCursor = metaPauseCtbCursor;
   pMeta->closeCtbCursor = metaCloseCtbCursor;
   pMeta->ctbCursorNext = metaCtbCursorNext;
 }

source/dnode/vnode/src/vnd/vnodeQuery.c

@@ -455,7 +455,7 @@ int32_t vnodeGetAllTableList(SVnode *pVnode, uint64_t uid, SArray *list) {
     taosArrayPush(list, &info);
   }
 
-  metaCloseCtbCursor(pCur, 1);
+  metaCloseCtbCursor(pCur);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -476,7 +476,7 @@ int32_t vnodeGetCtbIdList(void *pVnode, int64_t suid, SArray *list) {
     taosArrayPush(list, &id);
   }
 
-  metaCloseCtbCursor(pCur, 1);
+  metaCloseCtbCursor(pCur);
   return TSDB_CODE_SUCCESS;
 }
 
@@ -539,7 +539,7 @@ int32_t vnodeGetCtbNum(SVnode *pVnode, int64_t suid, int64_t *num) {
     ++(*num);
   }
 
-  metaCloseCtbCursor(pCur, 0);
+  metaCloseCtbCursor(pCur);
   return TSDB_CODE_SUCCESS;
 }
 

source/libs/executor/inc/executil.h

@@ -117,7 +117,7 @@ void*           tableListDestroy(STableListInfo* pTableListInfo);
 void            tableListClear(STableListInfo* pTableListInfo);
 int32_t         tableListGetOutputGroups(const STableListInfo* pTableList);
 bool            oneTableForEachGroup(const STableListInfo* pTableList);
-uint64_t        getTableGroupId(const STableListInfo* pTableList, uint64_t tableUid);
+uint64_t        tableListGetTableGroupId(const STableListInfo* pTableList, uint64_t tableUid);
 int32_t         tableListAddTableInfo(STableListInfo* pTableList, uint64_t uid, uint64_t gid);
 int32_t         tableListGetGroupList(const STableListInfo* pTableList, int32_t ordinalIndex, STableKeyInfo** pKeyInfo,
                                       int32_t* num);

source/libs/executor/src/cachescanoperator.c

@@ -218,7 +218,7 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) {
         return NULL;
       }
 
-      pRes->info.id.groupId = getTableGroupId(pTableList, pRes->info.id.uid);
+      pRes->info.id.groupId = tableListGetTableGroupId(pTableList, pRes->info.id.uid);
       pInfo->indexOfBufferedRes += 1;
       return pRes;
     } else {

source/libs/executor/src/executil.c

@@ -1931,7 +1931,7 @@ void tableListGetSourceTableInfo(const STableListInfo* pTableList, uint64_t* psu
   *type = pTableList->idInfo.tableType;
 }
 
-uint64_t getTableGroupId(const STableListInfo* pTableList, uint64_t tableUid) {
+uint64_t tableListGetTableGroupId(const STableListInfo* pTableList, uint64_t tableUid) {
   int32_t* slot = taosHashGet(pTableList->map, &tableUid, sizeof(tableUid));
   ASSERT(pTableList->map != NULL && slot != NULL);
 

source/libs/executor/src/scanoperator.c

@@ -693,7 +693,7 @@ static SSDataBlock* doTableScanImpl(SOperatorInfo* pOperator) {
     }
 
     if (pBlock->info.id.uid) {
-      pBlock->info.id.groupId = getTableGroupId(pTableScanInfo->base.pTableListInfo, pBlock->info.id.uid);
+      pBlock->info.id.groupId = tableListGetTableGroupId(pTableScanInfo->base.pTableListInfo, pBlock->info.id.uid);
     }
 
     uint32_t status = 0;
@@ -1088,7 +1088,7 @@ static SSDataBlock* readPreVersionData(SOperatorInfo* pTableScanOp, uint64_t tbU
   if (hasNext) {
     /*SSDataBlock* p = */ pAPI->tsdReader.tsdReaderRetrieveDataBlock(pReader, NULL);
     doSetTagColumnData(&pTableScanInfo->base, pBlock, pTaskInfo, pBlock->info.rows);
-    pBlock->info.id.groupId = getTableGroupId(pTableScanInfo->base.pTableListInfo, pBlock->info.id.uid);
+    pBlock->info.id.groupId = tableListGetTableGroupId(pTableScanInfo->base.pTableListInfo, pBlock->info.id.uid);
   }
 
   pAPI->tsdReader.tsdReaderClose(pReader);
@@ -1110,7 +1110,7 @@ static uint64_t getGroupIdByCol(SStreamScanInfo* pInfo, uint64_t uid, TSKEY ts,
 
 static uint64_t getGroupIdByUid(SStreamScanInfo* pInfo, uint64_t uid) {
   STableScanInfo* pTableScanInfo = pInfo->pTableScanOp->info;
-  return getTableGroupId(pTableScanInfo->base.pTableListInfo, uid);
+  return tableListGetTableGroupId(pTableScanInfo->base.pTableListInfo, uid);
 }
 
 static uint64_t getGroupIdByData(SStreamScanInfo* pInfo, uint64_t uid, TSKEY ts, int64_t maxVersion) {
@@ -1651,7 +1651,7 @@ static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock
   pBlockInfo->version = pBlock->info.version;
 
   STableScanInfo* pTableScanInfo = pInfo->pTableScanOp->info;
-  pBlockInfo->id.groupId = getTableGroupId(pTableScanInfo->base.pTableListInfo, pBlock->info.id.uid);
+  pBlockInfo->id.groupId = tableListGetTableGroupId(pTableScanInfo->base.pTableListInfo, pBlock->info.id.uid);
 
   // todo extract method
   for (int32_t i = 0; i < taosArrayGetSize(pInfo->matchInfo.pList); ++i) {
@@ -2761,11 +2761,6 @@ static void tagScanFilterByTagCond(SArray* aUidTags, SNode* pTagCond, SArray* aF
 static void tagScanFillOneCellWithTag(const STUidTagInfo* pUidTagInfo, SExprInfo* pExprInfo, SColumnInfoData* pColInfo, int rowIndex, const SStorageAPI* pAPI, void* pVnode) {
   if (fmIsScanPseudoColumnFunc(pExprInfo->pExpr->_function.functionId)) {  // tbname
     char str[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
-//    if (pUidTagInfo->name != NULL) {
-//      STR_TO_VARSTR(str, pUidTagInfo->name);
-//    } else {  // name is not retrieved during filter
-//      pAPI->metaFn.getTableNameByUid(pVnode, pUidTagInfo->uid, str);
-//    }
     STR_TO_VARSTR(str, "ctbidx");
 
     colDataSetVal(pColInfo, rowIndex, str, false);
@@ -2834,12 +2829,14 @@ static SSDataBlock* doTagScanFromCtbIdx(SOperatorInfo* pOperator) {
 
   if (pInfo->pCtbCursor == NULL) {
     pInfo->pCtbCursor = pAPI->metaFn.openCtbCursor(pInfo->readHandle.vnode, pInfo->suid, 1);
+  } else {
+    pAPI->metaFn.resumeCtbCursor(pInfo->pCtbCursor, 0);
   }
 
   SArray* aUidTags = pInfo->aUidTags;
   SArray* aFilterIdxs = pInfo->aFilterIdxs;
   int32_t count = 0;
-
+  bool ctbCursorFinished = false;
   while (1) {
     taosArrayClearEx(aUidTags, tagScanFreeUidTag);
     taosArrayClear(aFilterIdxs);
@@ -2849,6 +2846,7 @@ static SSDataBlock* doTagScanFromCtbIdx(SOperatorInfo* pOperator) {
       SMCtbCursor* pCur = pInfo->pCtbCursor;
       tb_uid_t     uid = pAPI->metaFn.ctbCursorNext(pInfo->pCtbCursor);
       if (uid == 0) {
+        ctbCursorFinished = true;
         break;
       }
       STUidTagInfo info = {.uid = uid, .pTagVal = pCur->pVal};
@@ -2878,6 +2876,14 @@ static SSDataBlock* doTagScanFromCtbIdx(SOperatorInfo* pOperator) {
     }
   }
 
+  if (count > 0) {
+    pAPI->metaFn.pauseCtbCursor(pInfo->pCtbCursor);
+  }
+  if (count == 0 || ctbCursorFinished) {
+    pAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);
+    pInfo->pCtbCursor = NULL;
+    setOperatorCompleted(pOperator);
+  }
   pRes->info.rows = count;
   pOperator->resultInfo.totalRows += count;
   return (pRes->info.rows == 0) ? NULL : pInfo->pRes;
@@ -2942,7 +2948,7 @@ static SSDataBlock* doTagScanFromMetaEntry(SOperatorInfo* pOperator) {
 static void destroyTagScanOperatorInfo(void* param) {
   STagScanInfo* pInfo = (STagScanInfo*)param;
   if (pInfo->pCtbCursor != NULL) {
-    pInfo->pStorageAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor, 1);
+    pInfo->pStorageAPI->metaFn.closeCtbCursor(pInfo->pCtbCursor);
   }
   taosHashCleanup(pInfo->filterCtx.colHash);
   taosArrayDestroy(pInfo->filterCtx.cInfoList);
@@ -3072,7 +3078,7 @@ static SSDataBlock* getBlockForTableMergeScan(void* param) {
       continue;
     }
 
-    pBlock->info.id.groupId = getTableGroupId(pInfo->base.pTableListInfo, pBlock->info.id.uid);
+    pBlock->info.id.groupId = tableListGetTableGroupId(pInfo->base.pTableListInfo, pBlock->info.id.uid);
 
     pOperator->resultInfo.totalRows += pBlock->info.rows;
     pInfo->base.readRecorder.elapsedTime += (taosGetTimestampUs() - st) / 1000.0;

source/libs/nodes/src/nodesCloneFuncs.c

@@ -399,6 +399,7 @@ static int32_t logicScanCopy(const SScanLogicNode* pSrc, SScanLogicNode* pDst) {
   CLONE_NODE_FIELD(pSubtable);
   COPY_SCALAR_FIELD(igLastNull);
   COPY_SCALAR_FIELD(groupOrderScan);
+  COPY_SCALAR_FIELD(onlyMetaCtbIdx);
   return TSDB_CODE_SUCCESS;
 }
 

source/libs/parser/inc/parAst.h

@@ -143,6 +143,7 @@ SNode* addRangeClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pRange);
 SNode* addEveryClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pEvery);
 SNode* addFillClause(SAstCreateContext* pCxt, SNode* pStmt, SNode* pFill);
 SNode* createSelectStmt(SAstCreateContext* pCxt, bool isDistinct, SNodeList* pProjectionList, SNode* pTable);
+SNode* setSelectStmtTagMode(SAstCreateContext* pCxt, SNode* pStmt, bool bSelectTags);
 SNode* createSetOperator(SAstCreateContext* pCxt, ESetOperatorType type, SNode* pLeft, SNode* pRight);
 
 SDataType createDataType(uint8_t type);

source/libs/parser/inc/sql.y

@@ -1009,10 +1009,11 @@ join_type(A) ::= INNER.
 
 /************************************************ query_specification *************************************************/
 query_specification(A) ::=
-  SELECT set_quantifier_opt(B) select_list(C) from_clause_opt(D) 
+  SELECT tag_mode_opt(M) set_quantifier_opt(B) select_list(C) from_clause_opt(D)
   where_clause_opt(E) partition_by_clause_opt(F) range_opt(J) every_opt(K)
   fill_opt(L) twindow_clause_opt(G) group_by_clause_opt(H) having_clause_opt(I).  {
                                                                                     A = createSelectStmt(pCxt, B, C, D);
+                                                                                    A = setSelectStmtTagMode(pCxt, A, M);
                                                                                     A = addWhereClause(pCxt, A, E);
                                                                                     A = addPartitionByClause(pCxt, A, F);
                                                                                     A = addWindowClauseClause(pCxt, A, G);
@@ -1023,6 +1024,11 @@ query_specification(A) ::=
                                                                                     A = addFillClause(pCxt, A, L);
                                                                                   }
 
+%type tag_mode_opt                                                                { bool }
+%destructor tag_mode_opt                                                          { }
+tag_mode_opt(A) ::= .                                                             { A = false; }
+tag_mode_opt(A) ::= TAGS.                                                         { A = true; }
+
 %type set_quantifier_opt                                                          { bool }
 %destructor set_quantifier_opt                                                    { }
 set_quantifier_opt(A) ::= .                                                       { A = false; }

source/libs/parser/src/parAstCreater.c

@@ -852,6 +852,13 @@ SNode* createSelectStmt(SAstCreateContext* pCxt, bool isDistinct, SNodeList* pPr
   return select;  
 }
 
+SNode* setSelectStmtTagMode(SAstCreateContext* pCxt, SNode* pStmt, bool bSelectTags) {
+  if (pStmt && QUERY_NODE_SELECT_STMT == nodeType(pStmt)) {
+    ((SSelectStmt*)pStmt)->tagScan = bSelectTags;
+  }
+  return pStmt;
+}
+
 static void setSubquery(SNode* pStmt) {
   if (QUERY_NODE_SELECT_STMT == nodeType(pStmt)) {
     ((SSelectStmt*)pStmt)->isSubquery = true;

source/libs/planner/src/planLogicCreater.c

@@ -14,7 +14,7 @@
  */
 
 #include "planInt.h"
-
+#include "filter.h"
 #include "functionMgt.h"
 
 typedef struct SLogicPlanContext {
@@ -253,7 +253,7 @@ static EScanType getScanType(SLogicPlanContext* pCxt, SNodeList* pScanPseudoCols
     return SCAN_TYPE_SYSTEM_TABLE;
   }
 
-  if (tagScan) {
+  if (tagScan && 0 == LIST_LENGTH(pScanCols) && 0 != LIST_LENGTH(pScanPseudoCols)) {
     return SCAN_TYPE_TAG;
   }
 
@@ -344,6 +344,55 @@ static int32_t makeScanLogicNode(SLogicPlanContext* pCxt, SRealTableNode* pRealT
 
 static bool needScanDefaultCol(EScanType scanType) { return SCAN_TYPE_TABLE_COUNT != scanType; }
 
+static EDealRes tagScanNodeHasTbnameFunc(SNode* pNode, void* pContext) {
+  if (QUERY_NODE_FUNCTION == nodeType(pNode) && FUNCTION_TYPE_TBNAME == ((SFunctionNode*)pNode)->funcType ||
+        (QUERY_NODE_COLUMN == nodeType(pNode) && COLUMN_TYPE_TBNAME == ((SColumnNode*)pNode)->colType)) {
+    *(bool*)pContext = true;
+    return DEAL_RES_END;
+  }
+  return DEAL_RES_CONTINUE;
+}
+
+static bool tagScanNodeListHasTbname(SNodeList* pCols) {
+  bool hasTbname = false;
+  nodesWalkExprs(pCols, tagScanNodeHasTbnameFunc, &hasTbname);
+  return hasTbname;
+}
+
+static bool tagScanNodeHasTbname(SNode* pKeys) {
+  bool hasTbname = false;
+  nodesWalkExpr(pKeys, tagScanNodeHasTbnameFunc, &hasTbname);
+  return hasTbname;
+}
+
+static int32_t tagScanSetExecutionMode(SScanLogicNode* pScan) {
+  pScan->onlyMetaCtbIdx = false;
+
+  if (tagScanNodeListHasTbname(pScan->pScanPseudoCols)) {
+    pScan->onlyMetaCtbIdx = false;
+    return TSDB_CODE_SUCCESS;
+  }
+
+  if (pScan->node.pConditions == NULL) {
+    pScan->onlyMetaCtbIdx = true;
+    return TSDB_CODE_SUCCESS;
+  }
+
+  SNode* pCond = nodesCloneNode(pScan->node.pConditions);
+  SNode* pTagCond = NULL;
+  SNode* pTagIndexCond = NULL;
+  filterPartitionCond(&pCond, NULL, &pTagIndexCond, &pTagCond, NULL);
+  if (pTagIndexCond || tagScanNodeHasTbname(pTagCond)) {
+    pScan->onlyMetaCtbIdx = false;
+  } else {
+    pScan->onlyMetaCtbIdx = true;
+  }
+  nodesDestroyNode(pCond);
+  nodesDestroyNode(pTagIndexCond);
+  nodesDestroyNode(pTagCond);
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t createScanLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, SRealTableNode* pRealTable,
                                    SLogicNode** pLogicNode) {
   SScanLogicNode* pScan = NULL;
@@ -411,6 +460,10 @@ static int32_t createScanLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
     code = createColumnByRewriteExprs(pScan->pScanPseudoCols, &pScan->node.pTargets);
   }
 
+  if (pScan->scanType == SCAN_TYPE_TAG) {
+    code = tagScanSetExecutionMode(pScan);
+  }
+
   if (TSDB_CODE_SUCCESS == code) {
     *pLogicNode = (SLogicNode*)pScan;
   } else {

source/libs/planner/src/planOptimizer.c

@@ -1563,7 +1563,8 @@ static bool planOptNodeListHasTbname(SNodeList* pKeys) {
 
 static bool partTagsIsOptimizableNode(SLogicNode* pNode) {
   bool ret = 1 == LIST_LENGTH(pNode->pChildren) &&
-             QUERY_NODE_LOGIC_PLAN_SCAN == nodeType(nodesListGetNode(pNode->pChildren, 0));
+             QUERY_NODE_LOGIC_PLAN_SCAN == nodeType(nodesListGetNode(pNode->pChildren, 0)) &&
+             SCAN_TYPE_TAG != ((SScanLogicNode*)nodesListGetNode(pNode->pChildren, 0))->scanType;
   if (!ret) return ret;
   switch (nodeType(pNode)) {
     case QUERY_NODE_LOGIC_PLAN_PARTITION: {

tests/script/tsim/query/tag_scan.sim

@@ -45,4 +45,86 @@ if $rows != 4 then
   return -1
 endi
 
+sql create table stt1(ts timestamp, f int) tags (t int, b varchar(10));
+sql insert into ctt11 using stt1 tags(1, '1aa') values(now, 1);
+sql insert into ctt12 using stt1 tags(2, '1bb') values(now, 2);
+sql insert into ctt13 using stt1 tags(3, '1cc') values(now, 3);
+sql insert into ctt14 using stt1 tags(4, '1dd') values(now, 4);
+sql insert into ctt14 values(now, 5);
+
+sql create table stt2(ts timestamp, f int) tags (t int, b varchar(10));
+sql insert into ctt21 using stt2 tags(1, '2aa') values(now, 1);
+sql insert into ctt22 using stt2 tags(2, '2bb') values(now, 2);
+sql insert into ctt23 using stt2 tags(3, '2cc') values(now, 3);
+sql insert into ctt24 using stt2 tags(4, '2dd') values(now, 4);
+
+sql select tags t, b from stt1 order by t
+print $rows
+print $data00 $data01 $data10 $data11 $data20 $data21 $data30 $data31
+if $rows != 4 then
+  return -1
+endi
+if $data31 != @1dd@ then
+  return -1
+endi
+
+sql select tags t, b from stt2 order by t
+print $rows
+print $data00 $data01 $data10 $data11 $data20 $data21 $data30 $data31
+if $rows != 4 then
+  return -1
+endi
+if $data31 != @2dd@ then
+  return -1
+endi
+
+sql select tags t,b,f from stt1 order by t
+print $rows
+print $data00 $data01 $data02 $data10 $data11 $data12 $data20 $data21 $data22 $data30 $data31 $data32 $data40 $data41 $data42
+if $rows != 5 then
+  return -1
+endi
+if $data42 != 5 then
+  return -1
+endi
+
+sql select tags tbname,t,b from stt1 order by t
+print $rows
+print $data00 $data01 $data02 $data10 $data11 $data12 $data20 $data21 $data22 $data30 $data31 $data32 
+if $rows != 4 then
+  return -1
+endi
+if $data30 != @ctt14@ then
+  return -1
+endi
+if $data32 != @1dd@ then
+  return -1
+endi
+
+sql select tags t,b from stt1 where t=1
+print $rows
+print $data00 $data01 
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @1@ then
+  return -1
+endi
+if $data01 != @1aa@ then
+  return -1
+endi
+
+sql select tags t,b from stt1 where tbname='ctt11'
+print $rows
+print $data00 $data01 
+if $rows != 1 then
+  return -1
+endi
+if $data00 != @1@ then
+  return -1
+endi
+if $data01 != @1aa@ then
+  return -1
+endi
+
 system sh/exec.sh -n dnode1 -s stop -x SIGINT