enh: cache necessary file for seq mode

include/libs/nodes/plannodes.h

@@ -169,7 +169,7 @@ typedef struct SGroupCacheLogicNode {
 } SGroupCacheLogicNode;
 
 typedef struct SDynQueryCtrlStbJoin {
-  bool          batchJoin;
+  bool          batchFetch;
   SNodeList*    pVgList;
   SNodeList*    pUidList;
 } SDynQueryCtrlStbJoin;
@@ -460,7 +460,7 @@ typedef struct SGroupCachePhysiNode {
 } SGroupCachePhysiNode;
 
 typedef struct SStbJoinDynCtrlBasic {
-  bool     batchJoin;
+  bool     batchFetch;
   int32_t  vgSlot[2];
   int32_t  uidSlot[2];
 } SStbJoinDynCtrlBasic;

source/libs/executor/inc/dynqueryctrl.h

@@ -37,17 +37,19 @@ typedef struct SStbJoinTableList {
 } SStbJoinTableList;
 
 typedef struct SStbJoinPrevJoinCtx {
-  SSDataBlock*       pLastBlk;
-  int32_t            lastRow;
   bool               joinBuild;
-  SSHashObj*         leftVg;
-  SSHashObj*         rightVg;
+  SSHashObj*         leftHash;
+  SSHashObj*         rightHash;
+  SSHashObj*         tableTimes;
+  SSHashObj*         onceTable;
   int64_t            tableNum;
   SStbJoinTableList* pListHead;
 } SStbJoinPrevJoinCtx;
 
 typedef struct SStbJoinPostJoinCtx {
-  bool isStarted;
+  bool    isStarted;
+  int64_t rightCurrUid;
+  int64_t rightNextUid;
 } SStbJoinPostJoinCtx;
 
 typedef struct SStbJoinDynCtrlCtx {

source/libs/executor/inc/executorInt.h

@@ -110,6 +110,7 @@ typedef struct SGcOperatorParam {
   int32_t             downstreamIdx;
   int32_t             vgId;
   int64_t             tbUid;
+  bool                needCache;
 } SGcOperatorParam;
 
 typedef struct SExprSupp {

source/libs/executor/inc/groupcache.h

@@ -75,6 +75,7 @@ typedef struct SGroupCacheData {
   TdThreadMutex  mutex;
   SArray*        waitQueue;
   bool           fetchDone;
+  bool           needCache;
   SSDataBlock*   pBlock;
   SGcVgroupCtx*  pVgCtx;
   int32_t        downstreamIdx;

source/libs/executor/src/groupcacheoperator.c

@@ -556,22 +556,25 @@ static int32_t handleVgroupTableFetchDone(SGcDownstreamCtx* pCtx, SGroupCacheDat
 }
 
 
-static FORCE_INLINE void initNewGroupData(SGcDownstreamCtx* pCtx, SGroupCacheData* pGroup, int32_t downstreamIdx, int32_t vgId, bool batchFetch) {
+static FORCE_INLINE void initNewGroupData(SGcDownstreamCtx* pCtx, SGroupCacheData* pGroup, int32_t downstreamIdx, int32_t vgId, bool batchFetch, bool needCache) {
   taosThreadMutexInit(&pGroup->mutex, NULL);
   pGroup->downstreamIdx = downstreamIdx;
   pGroup->vgId = vgId;
   pGroup->fileId = -1;
   pGroup->blkList.pList = taosArrayInit(10, sizeof(SGcBlkBufBasic));
   pGroup->startOffset = -1;
+  pGroup->needCache = needCache;
   pGroup->pVgCtx = tSimpleHashGet(pCtx->pVgTbHash, &pGroup->vgId, sizeof(pGroup->vgId));
 }
 
 static int32_t addNewGroupData(struct SOperatorInfo* pOperator, SOperatorParam* pParam, SGroupCacheData** ppGrp, int32_t vgId, int64_t uid) {
   SGroupCacheOperatorInfo* pGCache = pOperator->info;
   SGcDownstreamCtx* pCtx = &pGCache->pDownstreams[pParam->downstreamIdx];
+  SGcOperatorParam* pGcParam = pParam->value;  
   SHashObj* pGrpHash = pGCache->globalGrp ? pGCache->pGrpHash : pCtx->pGrpHash;
   SGroupCacheData grpData = {0};
-  initNewGroupData(pCtx, &grpData, pParam->downstreamIdx, vgId, pGCache->batchFetch);
+
+  initNewGroupData(pCtx, &grpData, pParam->downstreamIdx, vgId, pGCache->batchFetch, pGcParam->needCache);
   
   while (true) {
     if (0 != taosHashPut(pGrpHash, &uid, sizeof(uid), &grpData, sizeof(grpData))) {
@@ -623,12 +626,16 @@ static int32_t handleGroupCacheRetrievedBlk(struct SOperatorInfo* pOperator, SSD
   SGroupCacheOperatorInfo* pGCache = pOperator->info;
   SGcDownstreamCtx* pCtx = &pGCache->pDownstreams[pSession->downstreamIdx];
   SHashObj* pGrpHash = pGCache->globalGrp ? pGCache->pGrpHash : pCtx->pGrpHash;
+  int64_t newBlkIdx = 0;
 
   SGroupCacheData* pGroup = taosHashGet(pGrpHash, &pBlock->info.id.groupId, sizeof(pBlock->info.id.groupId));
   if (NULL == pGroup) {
     if (pGCache->batchFetch) {
+      SGcOperatorParam fakeGcParam = {0};
       SOperatorParam fakeParam = {0};
+      fakeGcParam.needCache = true;
       fakeParam.downstreamIdx = pSession->downstreamIdx;
+      fakeParam.value = &fakeGcParam;
       code = addNewGroupData(pOperator, &fakeParam, &pGroup, -1, pBlock->info.id.groupId);
       if (TSDB_CODE_SUCCESS != code) {
         return code;
@@ -645,22 +652,31 @@ static int32_t handleGroupCacheRetrievedBlk(struct SOperatorInfo* pOperator, SSD
       return code;
     }
   }
-  
-  SGcBlkBufInfo newBlkBuf;    
-  code = addBlkToBufCache(pOperator, pBlock, pCtx, pGroup, &newBlkBuf);
-  if (code) {
-    return code;
-  }
 
-  int64_t blkIdx = 0;
-  code = addBlkToGroupCache(pGCache->batchFetch, pGroup, &newBlkBuf, &blkIdx);
-  if (code) {
-    return code;
+  if (pGroup->needCache) {
+    qError("add block to group cache");
+    
+    SGcBlkBufInfo newBlkBuf;    
+    code = addBlkToBufCache(pOperator, pBlock, pCtx, pGroup, &newBlkBuf);
+    if (code) {
+      return code;
+    }
+
+    code = addBlkToGroupCache(pGCache->batchFetch, pGroup, &newBlkBuf, &newBlkIdx);
+    if (code) {
+      return code;
+    }
+  } else {
+    qError("no need to add block to group cache");
+    
+    pGroup->pBlock = pBlock;
   }
 
   notifyWaitingSessions(pGroup->waitQueue);
   if (pGroup == pSession->pGroupData) {
-    pSession->lastBlkId = blkIdx;
+    if (pGroup->needCache) {
+      pSession->lastBlkId = newBlkIdx;
+    }
     
     *continueFetch = false;
   }
@@ -746,26 +762,31 @@ static int32_t getBlkFromSessionCacheImpl(struct SOperatorInfo* pOperator, int64
   int32_t code = TSDB_CODE_SUCCESS;
   SGroupCacheOperatorInfo* pGCache = pOperator->info;
   *got = true;
-  
-  SGcBlkList* pBlkList = &pSession->pGroupData->blkList;
-  taosRLockLatch(&pBlkList->lock);
-  int64_t blkNum = taosArrayGetSize(pBlkList->pList);
-  if (pSession->lastBlkId < 0) {
-    if (blkNum > 0) {
-      SGcBlkBufBasic* pBasic = taosArrayGet(pBlkList->pList, 0);
+
+  if (pSession->pGroupData->needCache) {
+    SGcBlkList* pBlkList = &pSession->pGroupData->blkList;
+    taosRLockLatch(&pBlkList->lock);
+    int64_t blkNum = taosArrayGetSize(pBlkList->pList);
+    if (pSession->lastBlkId < 0) {
+      if (blkNum > 0) {
+        SGcBlkBufBasic* pBasic = taosArrayGet(pBlkList->pList, 0);
+        taosRUnLockLatch(&pBlkList->lock);
+        code = retrieveBlkFromBufCache(pGCache, pSession->pGroupData, sessionId, pBasic, ppRes);
+        pSession->lastBlkId = 0;
+        return code;
+      }
+    } else if ((pSession->lastBlkId + 1) < blkNum) {
+      SGcBlkBufBasic* pBasic = taosArrayGet(pBlkList->pList, pSession->lastBlkId + 1);
       taosRUnLockLatch(&pBlkList->lock);
       code = retrieveBlkFromBufCache(pGCache, pSession->pGroupData, sessionId, pBasic, ppRes);
-      pSession->lastBlkId = 0;
+      pSession->lastBlkId++;
       return code;
     }
-  } else if ((pSession->lastBlkId + 1) < blkNum) {
-    SGcBlkBufBasic* pBasic = taosArrayGet(pBlkList->pList, pSession->lastBlkId + 1);
     taosRUnLockLatch(&pBlkList->lock);
-    code = retrieveBlkFromBufCache(pGCache, pSession->pGroupData, sessionId, pBasic, ppRes);
-    pSession->lastBlkId++;
-    return code;
+  } else if (pSession->pGroupData->pBlock) {
+    *ppRes = pSession->pGroupData->pBlock;
+    pSession->pGroupData->pBlock = NULL;
   }
-  taosRUnLockLatch(&pBlkList->lock);
 
   if (atomic_load_8((int8_t*)&pSession->pGroupData->fetchDone)) {
     *ppRes = NULL;
@@ -929,7 +950,7 @@ static int32_t getBlkFromGroupCache(struct SOperatorInfo* pOperator, SSDataBlock
     if (TSDB_CODE_SUCCESS != code) {
       return code;
     }
-  } else {
+  } else if (pSession->pGroupData->needCache) {
     SSDataBlock** ppBlock = taosHashGet(pGCache->blkCache.pReadBlk, &pGcParam->sessionId, sizeof(pGcParam->sessionId));
     if (ppBlock) {
       releaseBaseBlockToList(pCtx, *ppBlock);

source/libs/nodes/src/nodesCloneFuncs.c

@@ -550,7 +550,7 @@ static int32_t logicGroupCacheCopy(const SGroupCacheLogicNode* pSrc, SGroupCache
 static int32_t logicDynQueryCtrlCopy(const SDynQueryCtrlLogicNode* pSrc, SDynQueryCtrlLogicNode* pDst) {
   COPY_BASE_OBJECT_FIELD(node, logicNodeCopy);
   COPY_SCALAR_FIELD(qType);
-  COPY_SCALAR_FIELD(stbJoin.batchJoin);
+  COPY_SCALAR_FIELD(stbJoin.batchFetch);
   CLONE_NODE_LIST_FIELD(stbJoin.pVgList);
   CLONE_NODE_LIST_FIELD(stbJoin.pUidList);
   return TSDB_CODE_SUCCESS;

source/libs/nodes/src/nodesCodeFuncs.c

@@ -1228,7 +1228,7 @@ static int32_t jsonToLogicGroupCacheNode(const SJson* pJson, void* pObj) {
 }
 
 static const char* jkDynQueryCtrlLogicPlanQueryType = "QueryType";
-static const char* jkDynQueryCtrlLogicPlanStbJoinBatchJoin = "BatchJoin";
+static const char* jkDynQueryCtrlLogicPlanStbJoinBatchFetch = "BatchFetch";
 static const char* jkDynQueryCtrlLogicPlanStbJoinVgList = "VgroupList";
 static const char* jkDynQueryCtrlLogicPlanStbJoinUidList = "UidList";
 
@@ -1240,7 +1240,7 @@ static int32_t logicDynQueryCtrlNodeToJson(const void* pObj, SJson* pJson) {
     code = tjsonAddIntegerToObject(pJson, jkDynQueryCtrlLogicPlanQueryType, pNode->qType);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = tjsonAddBoolToObject(pJson, jkDynQueryCtrlLogicPlanStbJoinBatchJoin, pNode->stbJoin.batchJoin);
+    code = tjsonAddBoolToObject(pJson, jkDynQueryCtrlLogicPlanStbJoinBatchFetch, pNode->stbJoin.batchFetch);
   }
   if (TSDB_CODE_SUCCESS == code) {
     code = nodeListToJson(pJson, jkDynQueryCtrlLogicPlanStbJoinVgList, pNode->stbJoin.pVgList);
@@ -1260,7 +1260,7 @@ static int32_t jsonToLogicDynQueryCtrlNode(const SJson* pJson, void* pObj) {
     tjsonGetNumberValue(pJson, jkDynQueryCtrlLogicPlanQueryType, pNode->qType, code);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    tjsonGetBoolValue(pJson, jkDynQueryCtrlLogicPlanStbJoinBatchJoin, &pNode->stbJoin.batchJoin);
+    tjsonGetBoolValue(pJson, jkDynQueryCtrlLogicPlanStbJoinBatchFetch, &pNode->stbJoin.batchFetch);
   }
   if (TSDB_CODE_SUCCESS == code) {
     code = jsonToNodeList(pJson, jkDynQueryCtrlLogicPlanStbJoinVgList, &pNode->stbJoin.pVgList);
@@ -3005,7 +3005,7 @@ static int32_t jsonToPhysiGroupCacheNode(const SJson* pJson, void* pObj) {
 }
 
 static const char* jkDynQueryCtrlPhysiPlanQueryType = "QueryType";
-static const char* jkDynQueryCtrlPhysiPlanBatchJoin = "BatchJoin";
+static const char* jkDynQueryCtrlPhysiPlanBatchFetch = "BatchFetch";
 static const char* jkDynQueryCtrlPhysiPlanVgSlot0 = "VgSlot[0]";
 static const char* jkDynQueryCtrlPhysiPlanVgSlot1 = "VgSlot[1]";
 static const char* jkDynQueryCtrlPhysiPlanUidSlot0 = "UidSlot[0]";
@@ -3021,7 +3021,7 @@ static int32_t physiDynQueryCtrlNodeToJson(const void* pObj, SJson* pJson) {
   if (TSDB_CODE_SUCCESS == code) {
     switch (pNode->qType) {
       case DYN_QTYPE_STB_HASH: {
-        code = tjsonAddBoolToObject(pJson, jkDynQueryCtrlPhysiPlanBatchJoin, pNode->stbJoin.batchJoin);
+        code = tjsonAddBoolToObject(pJson, jkDynQueryCtrlPhysiPlanBatchFetch, pNode->stbJoin.batchFetch);
         if (TSDB_CODE_SUCCESS == code) {
           code = tjsonAddIntegerToObject(pJson, jkDynQueryCtrlPhysiPlanVgSlot0, pNode->stbJoin.vgSlot[0]);
         }
@@ -3055,7 +3055,7 @@ static int32_t jsonToPhysiDynQueryCtrlNode(const SJson* pJson, void* pObj) {
       case DYN_QTYPE_STB_HASH: {
         tjsonGetNumberValue(pJson, jkDynQueryCtrlPhysiPlanQueryType, pNode->qType, code);
         if (TSDB_CODE_SUCCESS == code) {
-          code = tjsonGetBoolValue(pJson, jkDynQueryCtrlPhysiPlanBatchJoin, &pNode->stbJoin.batchJoin);
+          code = tjsonGetBoolValue(pJson, jkDynQueryCtrlPhysiPlanBatchFetch, &pNode->stbJoin.batchFetch);
         }
         if (TSDB_CODE_SUCCESS == code) {
           tjsonGetNumberValue(pJson, jkDynQueryCtrlPhysiPlanVgSlot0, pNode->stbJoin.vgSlot[0], code);

source/libs/nodes/src/nodesMsgFuncs.c

@@ -3608,7 +3608,7 @@ static int32_t msgToPhysiGroupCacheNode(STlvDecoder* pDecoder, void* pObj) {
 enum {
   PHY_DYN_QUERY_CTRL_CODE_BASE_NODE = 1,
   PHY_DYN_QUERY_CTRL_CODE_QUERY_TYPE,
-  PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_BATCH_JOIN,
+  PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_BATCH_FETCH,
   PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT0,
   PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT1,
   PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_UID_SLOT0,
@@ -3625,7 +3625,7 @@ static int32_t physiDynQueryCtrlNodeToMsg(const void* pObj, STlvEncoder* pEncode
   if (TSDB_CODE_SUCCESS == code) {
     switch (pNode->qType) {
       case DYN_QTYPE_STB_HASH: {
-        code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_BATCH_JOIN, pNode->stbJoin.batchJoin);
+        code = tlvEncodeBool(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_BATCH_FETCH, pNode->stbJoin.batchFetch);
         if (TSDB_CODE_SUCCESS == code) {
           code = tlvEncodeEnum(pEncoder, PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT0, pNode->stbJoin.vgSlot[0]);
         }
@@ -3660,8 +3660,8 @@ static int32_t msgToPhysiDynQueryCtrlNode(STlvDecoder* pDecoder, void* pObj) {
       case PHY_DYN_QUERY_CTRL_CODE_QUERY_TYPE:
         code = tlvDecodeEnum(pTlv, &pNode->qType, sizeof(pNode->qType));
         break;
-      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_BATCH_JOIN:
-        code = tlvDecodeBool(pTlv, &pNode->stbJoin.batchJoin);
+      case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_BATCH_FETCH:
+        code = tlvDecodeBool(pTlv, &pNode->stbJoin.batchFetch);
         break;
       case PHY_DYN_QUERY_CTRL_CODE_STB_JOIN_VG_SLOT0:
         code = tlvDecodeEnum(pTlv, &pNode->stbJoin.vgSlot[0], sizeof(pNode->stbJoin.vgSlot[0]));

source/libs/planner/src/planOptimizer.c

@@ -3352,7 +3352,7 @@ static int32_t stbJoinOptCreateDynQueryCtrlNode(SLogicNode* pPrev, SLogicNode* p
   }
 
   pDynCtrl->qType = DYN_QTYPE_STB_HASH;
-  pDynCtrl->stbJoin.batchJoin = true;
+  pDynCtrl->stbJoin.batchFetch = true;
   
   if (TSDB_CODE_SUCCESS == code) {  
     pDynCtrl->node.pChildren = nodesMakeList();

source/libs/planner/src/planPhysiCreater.c

@@ -1026,7 +1026,7 @@ static int32_t updateDynQueryCtrlStbJoinInfo(SPhysiPlanContext* pCxt, SNodeList*
       pDynCtrl->stbJoin.uidSlot[i] = ((SColumnNode*)pNode)->slotId;
       ++i;
     }
-    pDynCtrl->stbJoin.batchJoin = pLogicNode->stbJoin.batchJoin;
+    pDynCtrl->stbJoin.batchFetch = pLogicNode->stbJoin.batchFetch;
   }
 
   return code;