enh: support concurrent fetch from group cache

include/libs/nodes/plannodes.h

@@ -160,6 +160,8 @@ typedef struct SInterpFuncLogicNode {
 typedef struct SGroupCacheLogicNode {
   SLogicNode  node;
   bool        grpColsMayBeNull;  
+  bool        grpByUid;
+  bool        globalGrp;
   SNodeList*  pGroupCols;
 } SGroupCacheLogicNode;
 
@@ -441,8 +443,8 @@ typedef struct SHashJoinPhysiNode {
 typedef struct SGroupCachePhysiNode {
   SPhysiNode node;
   bool       grpColsMayBeNull;
-  SArray*    pDownstreamKey;
   bool       grpByUid;
+  bool       globalGrp;
   SNodeList* pGroupCols;
 } SGroupCachePhysiNode;
 

source/libs/executor/inc/executorInt.h

@@ -109,8 +109,8 @@ typedef struct SGcOperatorParam {
   int64_t             sessionId;
   int32_t             downstreamIdx;
   bool                needCache;
-  void*               pGroupValue;
-  int32_t             groupValueSize;
+  int32_t             vgId;
+  int64_t             tbUid;
 } SGcOperatorParam;
 
 typedef struct SExprSupp {
@@ -158,7 +158,7 @@ typedef struct SExchangeOperatorBasicParam {
 
 typedef struct SExchangeOperatorBatchParam {
   bool            multiParams;
-  SArray*         pBatchs; // SArray<SExchangeOperatorBasicParam>
+  SSHashObj*      pBatchs; // SExchangeOperatorBasicParam
 } SExchangeOperatorBatchParam;
 
 typedef struct SExchangeOperatorParam {
@@ -717,6 +717,9 @@ uint64_t calcGroupId(char* pData, int32_t len);
 void streamOpReleaseState(struct SOperatorInfo* pOperator);
 void streamOpReloadState(struct SOperatorInfo* pOperator);
 
+void destroyOperatorParamValue(void* pValues);
+int32_t mergeOperatorParams(SOperatorParam* pDst, SOperatorParam* pSrc);
+
 #ifdef __cplusplus
 }
 #endif

source/libs/executor/inc/groupcache.h

@@ -19,21 +19,27 @@
 extern "C" {
 #endif
 
-#define GROUP_CACHE_DEFAULT_PAGE_SIZE 10485760
+#define GROUP_CACHE_DEFAULT_MAX_FILE_SIZE 104857600
 
 #pragma pack(push, 1) 
 typedef struct SGcBlkBufInfo {
+  void*    prev;
   void*    next;
-  uint16_t pageId;
-  int32_t  offset;
+  int64_t  blkId;
+  int64_t  offset;
+  int64_t  bufSize;
+  void*    pBuf;
+  uint32_t fileId;
 } SGcBlkBufInfo;
 #pragma pack(pop)
 
-typedef struct SGcBufPageInfo {
-  int32_t pageSize;
-  int32_t offset;
-  char*   data;
-} SGcBufPageInfo;
+
+typedef struct SGcVgroupCtx {
+  SArray*  pTbList;
+  uint64_t lastUid;
+  int64_t  fileSize;
+  uint32_t fileId;
+} SGcVgroupCtx;
 
 typedef struct SGroupCacheData {
   TdThreadMutex  mutex;
@@ -41,8 +47,13 @@ typedef struct SGroupCacheData {
   bool           fetchDone;
   bool           needCache;
   SSDataBlock*   pBlock;
-  SGcBlkBufInfo* pFirstBlk;
-  SGcBlkBufInfo* pLastBlk;
+  SGcVgroupCtx*  pVgCtx;
+  int32_t        downstreamIdx;
+  int32_t        vgId;
+  uint32_t       fileId;
+  int64_t        startBlkId;
+  int64_t        endBlkId;
+  int64_t        startOffset;
 } SGroupCacheData;
 
 typedef struct SGroupColInfo {
@@ -62,15 +73,22 @@ typedef struct SGroupColsInfo {
 } SGroupColsInfo;
 
 typedef struct SGcNewGroupInfo {
-  int64_t         uid;
-  SOperatorParam* pParam;
+  int32_t          vgId;
+  int64_t          uid;
+  SGroupCacheData* pGroup;
+  SOperatorParam*  pParam;
 } SGcNewGroupInfo;
 
 typedef struct SGcDownstreamCtx {
-  SRWLatch      lock;
+  SRWLatch      grpLock;
   int64_t       fetchSessionId;
   SArray*       pNewGrpList; // SArray<SGcNewGroupInfo>
-  SArray*       pGrpUidList;
+  SSHashObj*    pVgTbHash;
+  SHashObj*     pGrpHash;
+  SRWLatch      blkLock;
+  SSDataBlock*  pBaseBlock;
+  SArray*       pFreeBlock;
+  int64_t       lastBlkUid;
 } SGcDownstreamCtx;
 
 typedef struct SGcSessionCtx {
@@ -78,7 +96,8 @@ typedef struct SGcSessionCtx {
   bool              needCache;
   SGcOperatorParam* pParam;
   SGroupCacheData*  pGroupData;
-  SGcBlkBufInfo*    pLastBlk; 
+  int64_t           lastBlkId;
+  int64_t           nextOffset;
   bool              semInit;
   tsem_t            waitSem;
 } SGcSessionCtx;
@@ -88,14 +107,38 @@ typedef struct SGcExecInfo {
   int64_t* pDownstreamBlkNum;
 } SGcExecInfo;
 
+typedef struct SGcCacheFile {
+  uint32_t grpNum;
+  uint32_t grpDone;
+  int64_t  fileSize;
+} SGcCacheFile;
+
+typedef struct SGcReadBlkInfo {
+  SSDataBlock* pBlock;
+  int64_t      nextOffset;
+} SGcReadBlkInfo;
+
+typedef struct SGcBlkCacheInfo {
+  SRWLatch       dirtyLock;
+  SSHashObj*     pCacheFile;
+  SHashObj*      pDirtyBlk;
+  SGcBlkBufInfo* pDirtyHead;
+  SGcBlkBufInfo* pDirtyTail; 
+  SHashObj*      pReadBlk;
+  int64_t        blkCacheSize;
+} SGcBlkCacheInfo;
+
 typedef struct SGroupCacheOperatorInfo {
   TdThreadMutex     sessionMutex;
-  SSHashObj*        pSessionHash;  
+  int64_t           maxCacheSize;
+  int64_t           currentBlkId;
+  SHashObj*         pSessionHash;  
   SGroupColsInfo    groupColsInfo;
+  bool              globalGrp;
   bool              grpByUid;
   SGcDownstreamCtx* pDownstreams;
-  SArray*           pBlkBufs;
-  SHashObj*         pBlkHash;  
+  SGcBlkCacheInfo   blkCache;
+  SHashObj*         pGrpHash;  
   SGcExecInfo       execInfo;
 } SGroupCacheOperatorInfo;
 

source/libs/executor/src/dynqueryctrloperator.c

@@ -36,7 +36,7 @@ static void destroyDynQueryCtrlOperator(void* param) {
   taosMemoryFreeClear(param);
 }
 
-static FORCE_INLINE int32_t buildGroupCacheOperatorParam(SOperatorParam** ppRes, int32_t downstreamIdx, bool needCache, void* pGrpValue, int32_t grpValSize, SOperatorParam* pChild) {
+static FORCE_INLINE int32_t buildGroupCacheOperatorParam(SOperatorParam** ppRes, int32_t downstreamIdx, bool needCache, int32_t vgId, int64_t tbUid, SOperatorParam* pChild) {
   *ppRes = taosMemoryMalloc(sizeof(SOperatorParam));
   if (NULL == *ppRes) {
     return TSDB_CODE_OUT_OF_MEMORY;
@@ -57,8 +57,8 @@ static FORCE_INLINE int32_t buildGroupCacheOperatorParam(SOperatorParam** ppRes,
   pGc->sessionId = atomic_add_fetch_64(&gSessionId, 1);
   pGc->downstreamIdx = downstreamIdx;
   pGc->needCache = needCache;
-  pGc->pGroupValue = pGrpValue;
-  pGc->groupValueSize = grpValSize;
+  pGc->vgId = vgId;
+  pGc->tbUid = tbUid;
 
   (*ppRes)->opType = QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE;
   (*ppRes)->downstreamIdx = downstreamIdx;
@@ -78,15 +78,16 @@ static FORCE_INLINE int32_t buildExchangeOperatorParam(SOperatorParam** ppRes, i
   if (NULL == pExc) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
-  
-  pExc->vgId = *pVgId;
-  pExc->srcOpType = QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN;
-  pExc->uidList = taosArrayInit(1, sizeof(int64_t));
-  if (NULL == pExc->uidList) {
+
+  pExc->multiParams = false;
+  pExc->basic.vgId = *pVgId;
+  pExc->basic.srcOpType = QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN;
+  pExc->basic.uidList = taosArrayInit(1, sizeof(int64_t));
+  if (NULL == pExc->basic.uidList) {
     taosMemoryFree(pExc);
     return TSDB_CODE_OUT_OF_MEMORY;
   }
-  taosArrayPush(pExc->uidList, pUid);
+  taosArrayPush(pExc->basic.uidList, pUid);
 
   (*ppRes)->opType = QUERY_NODE_PHYSICAL_PLAN_EXCHANGE;
   (*ppRes)->downstreamIdx = downstreamIdx;
@@ -145,10 +146,10 @@ static int32_t buildStbJoinOperatorParam(SDynQueryCtrlOperatorInfo* pInfo, SStbJ
     code = buildExchangeOperatorParam(&pExcParam1, 1, rightVg, rightUid, NULL);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = buildGroupCacheOperatorParam(&pGcParam0, 0, false, leftUid, pUid0->info.bytes, pExcParam0);
+    code = buildGroupCacheOperatorParam(&pGcParam0, 0, false, *leftVg, *leftUid, pExcParam0);
   }
   if (TSDB_CODE_SUCCESS == code) {
-    code = buildGroupCacheOperatorParam(&pGcParam1, 1, false, rightUid, pUid1->info.bytes, pExcParam1);
+    code = buildGroupCacheOperatorParam(&pGcParam1, 1, false, *rightVg, *rightUid, pExcParam1);
   }
   if (TSDB_CODE_SUCCESS == code) {
     code = buildMergeJoinOperatorParam(ppParam, pGcParam0, pGcParam1);

source/libs/executor/src/exchangeoperator.c

@@ -745,24 +745,45 @@ _error:
   return code;
 }
 
-int32_t addDynamicExchangeSource(SOperatorInfo* pOperator) {
+int32_t addSingleExchangeSource(SOperatorInfo* pOperator, SExchangeOperatorBasicParam* pBasicParam) {
   SExchangeInfo* pExchangeInfo = pOperator->info;
-  SExchangeOperatorParam* pParam = (SExchangeOperatorParam*)pOperator->pOperatorParam->value;
-  int32_t* pIdx = tSimpleHashGet(pExchangeInfo->pHashSources, &pParam->vgId, sizeof(pParam->vgId));
+  int32_t* pIdx = tSimpleHashGet(pExchangeInfo->pHashSources, &pBasicParam->vgId, sizeof(pBasicParam->vgId));
   if (NULL == pIdx) {
-    qError("No exchange source for vgId: %d", pParam->vgId);
-    pOperator->pTaskInfo->code = TSDB_CODE_INVALID_PARA;
-    T_LONG_JMP(pOperator->pTaskInfo->env, pOperator->pTaskInfo->code);
+    qError("No exchange source for vgId: %d", pBasicParam->vgId);
+    return TSDB_CODE_INVALID_PARA;
   }
-
+  
   SSourceDataInfo dataInfo = {0};
   dataInfo.status = EX_SOURCE_DATA_NOT_READY;
   dataInfo.taskId = GET_TASKID(pOperator->pTaskInfo);
   dataInfo.index = *pIdx;
-  dataInfo.pSrcUidList = taosArrayDup(pParam->uidList, NULL);
-  dataInfo.srcOpType = pParam->srcOpType;
+  dataInfo.pSrcUidList = taosArrayDup(pBasicParam->uidList, NULL);
+  dataInfo.srcOpType = pBasicParam->srcOpType;
   taosArrayPush(pExchangeInfo->pSourceDataInfo, &dataInfo);
 
+  return TSDB_CODE_SUCCESS;
+}
+
+
+int32_t addDynamicExchangeSource(SOperatorInfo* pOperator) {
+  SExchangeInfo* pExchangeInfo = pOperator->info;
+  int32_t code = TSDB_CODE_SUCCESS;
+  SExchangeOperatorBasicParam* pBasicParam = NULL;
+  SExchangeOperatorParam* pParam = (SExchangeOperatorParam*)pOperator->pOperatorParam->value;
+  if (pParam->multiParams) {
+    SExchangeOperatorBatchParam* pBatch = (SExchangeOperatorBatchParam*)pOperator->pOperatorParam->value;
+    int32_t iter = 0;
+    while (pBasicParam = tSimpleHashIterate(pBatch->pBatchs, pBasicParam, &iter)) {
+      code = addSingleExchangeSource(pOperator, pBasicParam);
+      if (code) {
+        return code;
+      }
+    }
+  } else {
+    pBasicParam = &pParam->basic;
+    code = addSingleExchangeSource(pOperator, pBasicParam);
+  }
+
   pOperator->pOperatorParam = NULL;
 
   return TSDB_CODE_SUCCESS;

source/libs/executor/src/operator.c

@@ -616,28 +616,37 @@ int32_t mergeOperatorParams(SOperatorParam* pDst, SOperatorParam* pSrc) {
       SExchangeOperatorParam* pDExc = pDst->value;
       SExchangeOperatorParam* pSExc = pSrc->value;
       if (!pDExc->multiParams) {
-        SExchangeOperatorBatchParam* pBatch = taosMemoryMalloc(sizeof(SExchangeOperatorBatchParam));
-        if (NULL == pBatch) {
-          return TSDB_CODE_OUT_OF_MEMORY;
+        if (pSExc->basic.vgId != pDExc->basic.vgId) {
+          SExchangeOperatorBatchParam* pBatch = taosMemoryMalloc(sizeof(SExchangeOperatorBatchParam));
+          if (NULL == pBatch) {
+            return TSDB_CODE_OUT_OF_MEMORY;
+          }
+          pBatch->multiParams = true;
+          pBatch->pBatchs = tSimpleHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT));
+          if (NULL == pBatch->pBatchs) {
+            taosMemoryFree(pBatch);
+            return TSDB_CODE_OUT_OF_MEMORY;
+          }
+          tSimpleHashPut(pBatch->pBatchs, &pDExc->basic.vgId, sizeof(pDExc->basic.vgId), &pDExc->basic, sizeof(pDExc->basic));        
+          tSimpleHashPut(pBatch->pBatchs, &pSExc->basic.vgId, sizeof(pSExc->basic.vgId), &pSExc->basic, sizeof(pSExc->basic));        
+          destroyOperatorParamValue(pDst->value);
+          pDst->value = pBatch;
+        } else {
+          taosArrayAddAll(pDExc->basic.uidList, pSExc->basic.uidList);
         }
-        pBatch->multiParams = true;
-        pBatch->pBatchs = taosArrayInit(4, sizeof(SExchangeOperatorBasicParam));
-        if (NULL == pBatch->pBatchs) {
-          taosMemoryFree(pBatch);
-          return TSDB_CODE_OUT_OF_MEMORY;
-        }
-        taosArrayPush(pBatch->pBatchs, &pDExc->basic);        
-        taosArrayPush(pBatch->pBatchs, &pSExc->basic);
-        destroyOperatorParamValue(pDst->value);
-        pDst->value = pBatch;
       } else {
         SExchangeOperatorBatchParam* pBatch = pDst->value;
-        taosArrayPush(pBatch->pBatchs, &pSExc->basic);
+        SExchangeOperatorBasicParam* pBasic = tSimpleHashGet(pBatch->pBatchs, &pSExc->basic.vgId, sizeof(pSExc->basic.vgId));
+        if (pBasic) {
+          taosArrayAddAll(pBasic->uidList, pSExc->basic.uidList);          
+        } else {
+          tSimpleHashPut(pBatch->pBatchs, &pSExc->basic.vgId, sizeof(pSExc->basic.vgId), &pSExc->basic, sizeof(pSExc->basic));        
+        }
       }
       break;
     }
     default:
-      qError("invalid optype %d for merge operator params", (*ppDst)->opType);
+      qError("invalid optype %d for merge operator params", pDst->opType);
       return TSDB_CODE_INVALID_PARA;
   }
 
@@ -678,7 +687,7 @@ int32_t setOperatorParams(struct SOperatorInfo* pOperator, SOperatorParam* pPara
   for (int32_t i = 0; i < childrenNum; ++i) {
     SOperatorParam* pChild = *(SOperatorParam**)taosArrayGet(pOperator->pOperatorParam->pChildren, i);
     if (pOperator->pDownstreamParams[pChild->downstreamIdx]) {
-      int32_t code = mergeOperatorParams(&pOperator->pDownstreamParams[pChild->downstreamIdx], pChild);
+      int32_t code = mergeOperatorParams(pOperator->pDownstreamParams[pChild->downstreamIdx], pChild);
       if (code) {
         return code;
       }

source/libs/nodes/src/nodesCodeFuncs.c

@@ -1183,6 +1183,8 @@ static int32_t jsonToLogicInterpFuncNode(const SJson* pJson, void* pObj) {
 }
 
 static const char* jkGroupCacheLogicPlanGrpColsMayBeNull = "GroupColsMayBeNull";
+static const char* jkGroupCacheLogicPlanGroupByUid = "GroupByUid";
+static const char* jkGroupCacheLogicPlanGlobalGroup = "GlobalGroup";
 static const char* jkGroupCacheLogicPlanGroupCols = "GroupCols";
 
 static int32_t logicGroupCacheNodeToJson(const void* pObj, SJson* pJson) {
@@ -1192,6 +1194,12 @@ static int32_t logicGroupCacheNodeToJson(const void* pObj, SJson* pJson) {
   if (TSDB_CODE_SUCCESS == code) {
     code = tjsonAddBoolToObject(pJson, jkGroupCacheLogicPlanGrpColsMayBeNull, pNode->grpColsMayBeNull);
   }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddBoolToObject(pJson, jkGroupCacheLogicPlanGroupByUid, pNode->grpByUid);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddBoolToObject(pJson, jkGroupCacheLogicPlanGlobalGroup, pNode->globalGrp);
+  }
   if (TSDB_CODE_SUCCESS == code) {
     code = nodeListToJson(pJson, jkGroupCacheLogicPlanGroupCols, pNode->pGroupCols);
   }
@@ -1206,6 +1214,12 @@ static int32_t jsonToLogicGroupCacheNode(const SJson* pJson, void* pObj) {
   if (TSDB_CODE_SUCCESS == code) {
     code = tjsonGetBoolValue(pJson, jkGroupCacheLogicPlanGrpColsMayBeNull, &pNode->grpColsMayBeNull);
   }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonGetBoolValue(pJson, jkGroupCacheLogicPlanGroupByUid, &pNode->grpByUid);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonGetBoolValue(pJson, jkGroupCacheLogicPlanGlobalGroup, &pNode->globalGrp);
+  }
   if (TSDB_CODE_SUCCESS == code) {
     code = jsonToNodeList(pJson, jkGroupCacheLogicPlanGroupCols, &pNode->pGroupCols);
   }
@@ -2912,12 +2926,24 @@ static int32_t jsonToPhysiDeleteNode(const SJson* pJson, void* pObj) {
 }
 
 static const char* jkGroupCachePhysiPlanGroupCols = "GroupColumns";
+static const char* jkGroupCachePhysiPlanGrpColsMayBeNull = "GroupColumnsMayBeNull";
+static const char* jkGroupCachePhysiPlanGroupByUid = "GroupByUid";
+static const char* jkGroupCachePhysiPlanGlobalGroup = "GlobalGroup";
 
 
 static int32_t physiGroupCacheNodeToJson(const void* pObj, SJson* pJson) {
   const SGroupCachePhysiNode* pNode = (const SGroupCachePhysiNode*)pObj;
 
   int32_t code = physicPlanNodeToJson(pObj, pJson);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddBoolToObject(pJson, jkGroupCachePhysiPlanGrpColsMayBeNull, pNode->grpColsMayBeNull);
+  }  
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddBoolToObject(pJson, jkGroupCachePhysiPlanGroupByUid, pNode->grpByUid);
+  }  
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonAddBoolToObject(pJson, jkGroupCachePhysiPlanGlobalGroup, pNode->globalGrp);
+  }  
   if (TSDB_CODE_SUCCESS == code) {
     code = nodeListToJson(pJson, jkGroupCachePhysiPlanGroupCols, pNode->pGroupCols);
   }
@@ -2928,6 +2954,15 @@ static int32_t jsonToPhysiGroupCacheNode(const SJson* pJson, void* pObj) {
   SGroupCachePhysiNode* pNode = (SGroupCachePhysiNode*)pObj;
 
   int32_t code = jsonToPhysicPlanNode(pJson, pObj);
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonGetBoolValue(pJson, jkGroupCachePhysiPlanGrpColsMayBeNull, &pNode->grpColsMayBeNull);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonGetBoolValue(pJson, jkGroupCachePhysiPlanGroupByUid, &pNode->grpByUid);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tjsonGetBoolValue(pJson, jkGroupCachePhysiPlanGlobalGroup, &pNode->globalGrp);
+  }
   if (TSDB_CODE_SUCCESS == code) {
     code = jsonToNodeList(pJson, jkGroupCachePhysiPlanGroupCols, &pNode->pGroupCols);
   }

source/libs/nodes/src/nodesMsgFuncs.c

@@ -3527,6 +3527,9 @@ static int32_t msgToPhysiDeleteNode(STlvDecoder* pDecoder, void* pObj) {
 
 enum {
   PHY_GROUP_CACHE_CODE_BASE_NODE = 1,
+  PHY_GROUP_CACHE_CODE_GROUP_COLS_MAY_BE_NULL,
+  PHY_GROUP_CACHE_CODE_GROUP_BY_UID,
+  PHY_GROUP_CACHE_CODE_GLOBAL_GROUP,
   PHY_GROUP_CACHE_CODE_GROUP_COLUMNS
 };
 
@@ -3537,6 +3540,16 @@ static int32_t physiGroupCacheNodeToMsg(const void* pObj, STlvEncoder* pEncoder)
   if (TSDB_CODE_SUCCESS == code) {
     code = tlvEncodeObj(pEncoder, PHY_GROUP_CACHE_CODE_GROUP_COLUMNS, nodeListToMsg, pNode->pGroupCols);
   }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tlvEncodeBool(pEncoder, PHY_GROUP_CACHE_CODE_GROUP_COLS_MAY_BE_NULL, pNode->grpColsMayBeNull);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tlvEncodeBool(pEncoder, PHY_GROUP_CACHE_CODE_GROUP_BY_UID, pNode->grpByUid);
+  }
+  if (TSDB_CODE_SUCCESS == code) {
+    code = tlvEncodeBool(pEncoder, PHY_GROUP_CACHE_CODE_GLOBAL_GROUP, pNode->globalGrp);
+  }
+
   return code;
 }
 
@@ -3553,6 +3566,15 @@ static int32_t msgToPhysiGroupCacheNode(STlvDecoder* pDecoder, void* pObj) {
       case PHY_GROUP_CACHE_CODE_GROUP_COLUMNS:
         code = msgToNodeListFromTlv(pTlv, (void**)&pNode->pGroupCols);
         break;
+      case PHY_GROUP_CACHE_CODE_GROUP_COLS_MAY_BE_NULL:
+        code = tlvDecodeBool(pTlv, &pNode->grpColsMayBeNull);
+        break;    
+      case PHY_GROUP_CACHE_CODE_GROUP_BY_UID:
+        code = tlvDecodeBool(pTlv, &pNode->grpByUid);
+        break;    
+      case PHY_GROUP_CACHE_CODE_GLOBAL_GROUP:
+        code = tlvDecodeBool(pTlv, &pNode->globalGrp);
+        break;    
       default:
         break;
     }

source/libs/planner/src/planOptimizer.c

@@ -3231,6 +3231,7 @@ static int32_t stbJoinOptCreateGroupCacheNode(SNodeList* pChildren, SLogicNode**
   
   pGrpCache->node.dynamicOp = true;
   pGrpCache->grpColsMayBeNull = false;
+  pGrpCache->grpByUid = true;
   pGrpCache->node.pChildren = pChildren;
   pGrpCache->node.pTargets = nodesMakeList();
   if (NULL == pGrpCache->node.pTargets) {
@@ -3252,11 +3253,16 @@ static int32_t stbJoinOptCreateGroupCacheNode(SNodeList* pChildren, SLogicNode**
     }
   }
 
+  bool hasCond = false;
   SNode* pNode = NULL;
   FOREACH(pNode, pChildren) {
     SScanLogicNode* pScan = (SScanLogicNode*)pNode;
+    if (pScan->node.pConditions) {
+      hasCond = true;
+    }
     pScan->node.pParent = (SLogicNode*)pGrpCache;
   }
+  pGrpCache->globalGrp = !hasCond;
 
   if (TSDB_CODE_SUCCESS == code) {
     *ppLogic = (SLogicNode*)pGrpCache;

source/libs/planner/src/planPhysiCreater.c

@@ -986,6 +986,8 @@ static int32_t createGroupCachePhysiNode(SPhysiPlanContext* pCxt, SNodeList* pCh
   }
 
   pGrpCache->grpColsMayBeNull = pLogicNode->grpColsMayBeNull;
+  pGrpCache->grpByUid = pLogicNode->grpByUid;
+  pGrpCache->globalGrp = pLogicNode->globalGrp;
   SDataBlockDescNode* pChildDesc = ((SPhysiNode*)nodesListGetNode(pChildren, 0))->pOutputDataBlockDesc;
   int32_t             code = TSDB_CODE_SUCCESS;
   if (TSDB_CODE_SUCCESS == code) {