Merge branch '3.0' into fix/TD-31163-3.0

include/libs/function/functionMgt.h

@@ -295,7 +295,7 @@ typedef enum EFuncDataRequired {
 } EFuncDataRequired;
 
 EFuncDataRequired fmFuncDataRequired(SFunctionNode* pFunc, STimeWindow* pTimeWindow);
-int32_t fmFuncDynDataRequired(int32_t funcId, void* pRes, SDataBlockInfo* pBlockInfo, int32_t *reqStatus);
+EFuncDataRequired fmFuncDynDataRequired(int32_t funcId, void* pRes, SDataBlockInfo* pBlockInfo);
 
 int32_t fmGetFuncExecFuncs(int32_t funcId, SFuncExecFuncs* pFpSet);
 int32_t fmGetScalarFuncExecFuncs(int32_t funcId, SScalarFuncExecFuncs* pFpSet);

include/util/tconfig.h

@@ -84,11 +84,11 @@ typedef struct SConfigItem {
   };
   union {
     int64_t imin;
-    double  fmin;
+    float   fmin;
   };
   union {
     int64_t imax;
-    double  fmax;
+    float   fmax;
   };
   SArray *array;  // SDiskCfg/SLogVar
 } SConfigItem;

include/util/tutil.h

@@ -55,7 +55,7 @@ void     taosIpPort2String(uint32_t ip, uint16_t port, char *str);
 
 void *tmemmem(const char *haystack, int hlen, const char *needle, int nlen);
 
-int32_t parseCfgReal(const char *str, double *out);
+int32_t parseCfgReal(const char *str, float *out);
 
 static FORCE_INLINE void taosEncryptPass(uint8_t *inBuf, size_t inLen, char *target) {
   T_MD5_CTX context;

source/client/src/clientEnv.c

@@ -971,10 +971,6 @@ void taos_init_imp(void) {
 
   tscDebug("starting to initialize TAOS driver");
 
-#ifndef WINDOWS
-  taosSetCoreDump(true);
-#endif
-
   ENV_ERR_RET(initTaskQueue(), "failed to init task queue");
   ENV_ERR_RET(fmFuncMgtInit(), "failed to init funcMgt");
   ENV_ERR_RET(nodesInitAllocatorSet(), "failed to init allocator set");

source/client/src/clientMonitor.c

@@ -696,7 +696,7 @@ static void monitorSendAllSlowLogFromTempDir(int64_t clusterId) {
       continue;
     }
     if (taosLockFile(pFile) < 0) {
-      tscError("failed to lock file:%s since %s, maybe used by other process", filename, terrstr());
+      tscInfo("failed to lock file:%s since %s, maybe used by other process", filename, terrstr());
       (void)taosCloseFile(&pFile);
       continue;
     }

source/common/src/tglobal.c

@@ -638,7 +638,7 @@ static int32_t taosAddSystemCfg(SConfig *pCfg) {
   TAOS_CHECK_RETURN(cfgAddLocale(pCfg, "locale", tsLocale, CFG_SCOPE_BOTH, CFG_DYN_CLIENT));
   TAOS_CHECK_RETURN(cfgAddCharset(pCfg, "charset", tsCharset, CFG_SCOPE_BOTH, CFG_DYN_NONE));
   TAOS_CHECK_RETURN(cfgAddBool(pCfg, "assert", tsAssert, CFG_SCOPE_BOTH, CFG_DYN_CLIENT));
-  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "enableCoreFile", 1, CFG_SCOPE_BOTH, CFG_DYN_CLIENT));
+  TAOS_CHECK_RETURN(cfgAddBool(pCfg, "enableCoreFile", tsEnableCoreFile, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
   TAOS_CHECK_RETURN(cfgAddFloat(pCfg, "numOfCores", tsNumOfCores, 1, 100000, CFG_SCOPE_BOTH, CFG_DYN_NONE));
 
   TAOS_CHECK_RETURN(cfgAddBool(pCfg, "ssd42", tsSSE42Supported, CFG_SCOPE_BOTH, CFG_DYN_NONE));
@@ -1287,8 +1287,8 @@ static int32_t taosSetSystemCfg(SConfig *pCfg) {
   osSetSystemLocale(locale, charset);
 
   TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "enableCoreFile");
-  bool enableCore = pItem->bval;
+  tsEnableCoreFile = pItem->bval;
-  taosSetCoreDump(enableCore);
+  taosSetCoreDump(tsEnableCoreFile);
 
   TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "assert");
   tsAssert = pItem->bval;
@@ -1901,6 +1901,13 @@ static int32_t taosCfgDynamicOptionsForServer(SConfig *pCfg, const char *name) {
     goto _exit;
   }
 
+  if (strncasecmp(name, "enableCoreFile", 9) == 0) {
+    tsEnableCoreFile = pItem->bval;
+    taosSetCoreDump(tsEnableCoreFile);
+    uInfo("%s set to %d", name, tsEnableCoreFile);
+    goto _exit;
+  }
+
   if (strcasecmp("slowLogScope", name) == 0) {
     int32_t scope = 0;
     TAOS_CHECK_GOTO(taosSetSlowLogScope(pItem->str, &scope), NULL, _exit);
@@ -2009,9 +2016,9 @@ static int32_t taosCfgDynamicOptionsForClient(SConfig *pCfg, const char *name) {
     }
     case 'e': {
       if (strcasecmp("enableCoreFile", name) == 0) {
-        bool enableCore = pItem->bval;
+        tsEnableCoreFile = pItem->bval;
-        taosSetCoreDump(enableCore);
+        taosSetCoreDump(tsEnableCoreFile);
-        uInfo("%s set to %d", name, enableCore);
+        uInfo("%s set to %d", name, tsEnableCoreFile);
         matched = true;
       }
       break;
@@ -2205,7 +2212,6 @@ static int32_t taosCfgDynamicOptionsForClient(SConfig *pCfg, const char *name) {
                                          {"compressMsgSize", &tsCompressMsgSize},
                                          {"countAlwaysReturnValue", &tsCountAlwaysReturnValue},
                                          {"crashReporting", &tsEnableCrashReport},
-                                         {"enableCoreFile", &tsAsyncLog},
                                          {"enableQueryHb", &tsEnableQueryHb},
                                          {"keepColumnName", &tsKeepColumnName},
                                          {"keepAliveIdle", &tsKeepAliveIdle},

source/dnode/mnode/impl/src/mndArbGroup.c

@@ -407,7 +407,9 @@ static int32_t mndProcessArbHbTimer(SRpcMsg *pReq) {
         (void)taosHashPut(pDnodeHash, &dnodeId, sizeof(int32_t), &hbMembers, POINTER_BYTES);
       }
       SVArbHbReqMember reqMember = {.vgId = pArbGroup->vgId, .hbSeq = pMember->state.nextHbSeq++};
-      (void)taosArrayPush(hbMembers, &reqMember);
+      if (taosArrayPush(hbMembers, &reqMember) == NULL) {
+        mError("dnodeId:%d, failed to push hb member, but conitnue next at this timer round", dnodeId);
+      }
     }
 
     (void)taosThreadMutexUnlock(&pArbGroup->mutex);
@@ -998,7 +1000,9 @@ static int32_t mndUpdateArbHeartBeat(SMnode *pMnode, int32_t dnodeId, SArray *me
 
     bool updateToken = mndUpdateArbGroupByHeartBeat(pGroup, pRspMember, nowMs, dnodeId, &newGroup);
     if (updateToken) {
-      (void)taosArrayPush(pUpdateArray, &newGroup);
+      if (taosArrayPush(pUpdateArray, &newGroup) == NULL) {
+        mError("failed to push newGroup to updateArray, but continue at this hearbear");
+      }
     }
 
     sdbRelease(pMnode->pSdb, pGroup);

source/dnode/mnode/impl/src/mndCompact.c

@@ -826,7 +826,9 @@ void mndCompactPullup(SMnode *pMnode) {
     SCompactObj *pCompact = NULL;
     pIter = sdbFetch(pMnode->pSdb, SDB_COMPACT, pIter, (void **)&pCompact);
     if (pIter == NULL) break;
-    (void)taosArrayPush(pArray, &pCompact->compactId);
+    if (taosArrayPush(pArray, &pCompact->compactId) == NULL) {
+      mError("failed to push compact id:%d into array, but continue pull up", pCompact->compactId);
+    }
     sdbRelease(pSdb, pCompact);
   }
 

source/dnode/mnode/impl/src/mndConsumer.c

@@ -334,9 +334,21 @@ static int32_t addEpSetInfo(SMnode *pMnode, SMqConsumerObj *pConsumer, int32_t e
         }
       }
       SMqSubVgEp vgEp = {.epSet = pVgEp->epSet, .vgId = pVgEp->vgId, .offset = -1};
-      (void)taosArrayPush(topicEp.vgs, &vgEp);
+      if (taosArrayPush(topicEp.vgs, &vgEp) == NULL) {
+        taosArrayDestroy(topicEp.vgs);
+        taosRUnLockLatch(&pConsumer->lock);
+        taosRUnLockLatch(&pSub->lock);
+        mndReleaseSubscribe(pMnode, pSub);
+        return TSDB_CODE_OUT_OF_MEMORY;
+      }
+    }
+    if (taosArrayPush(rsp->topics, &topicEp) == NULL) {
+      taosArrayDestroy(topicEp.vgs);
+      taosRUnLockLatch(&pConsumer->lock);
+      taosRUnLockLatch(&pSub->lock);
+      mndReleaseSubscribe(pMnode, pSub);
+      return TSDB_CODE_OUT_OF_MEMORY;
     }
-    (void)taosArrayPush(rsp->topics, &topicEp);
     taosRUnLockLatch(&pSub->lock);
     mndReleaseSubscribe(pMnode, pSub);
   }

source/dnode/mnode/impl/src/mndDb.c

@@ -1710,7 +1710,9 @@ void mndBuildDBVgroupInfo(SDbObj *pDb, SMnode *pMnode, SArray *pVgList) {
         }
       }
       vindex++;
-      (void)taosArrayPush(pVgList, &vgInfo);
+      if (taosArrayPush(pVgList, &vgInfo) == NULL) {
+        mError("db:%s, failed to push vgInfo to array, vgId:%d, but continue next", pDb->name, vgInfo.vgId);
+      }
     }
 
     sdbRelease(pSdb, pVgroup);
@@ -1856,7 +1858,10 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
 
       rsp.useDbRsp->vgNum = taosArrayGetSize(rsp.useDbRsp->pVgroupInfos);
 
-      (void)taosArrayPush(batchRsp.pArray, &rsp);
+      if (taosArrayPush(batchRsp.pArray, &rsp) == NULL) {
+        if (terrno != 0) code = terrno;
+        return code;
+      }
 
       continue;
     }
@@ -1868,7 +1873,10 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
       (void)memcpy(rsp.useDbRsp->db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);
       rsp.useDbRsp->uid = pDbCacheInfo->dbId;
       rsp.useDbRsp->vgVersion = -1;
-      (void)taosArrayPush(batchRsp.pArray, &rsp);
+      if (taosArrayPush(batchRsp.pArray, &rsp) == NULL) {
+        if (terrno != 0) code = terrno;
+        return code;
+      }
       continue;
     }
 
@@ -1940,7 +1948,11 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
       rsp.useDbRsp->hashSuffix = pDb->cfg.hashSuffix;
     }
 
-    (void)taosArrayPush(batchRsp.pArray, &rsp);
+    if (taosArrayPush(batchRsp.pArray, &rsp) == NULL) {
+      mndReleaseDb(pMnode, pDb);
+      if (terrno != 0) code = terrno;
+      return code;
+    }
     mndReleaseDb(pMnode, pDb);
   }
 

source/dnode/mnode/impl/src/mndDnode.c

@@ -430,7 +430,9 @@ static void mndGetDnodeEps(SMnode *pMnode, SArray *pDnodeEps) {
     if (mndIsMnode(pMnode, pDnode->id)) {
       dnodeEp.isMnode = 1;
     }
-    (void)taosArrayPush(pDnodeEps, &dnodeEp);
+    if (taosArrayPush(pDnodeEps, &dnodeEp) == NULL) {
+      mError("failed to put ep into array, but continue at this call");
+    }
   }
 }
 
@@ -991,7 +993,12 @@ static int32_t mndProcessDnodeListReq(SRpcMsg *pReq) {
     tstrncpy(epSet.eps[0].fqdn, pObj->fqdn, TSDB_FQDN_LEN);
     epSet.eps[0].port = pObj->port;
 
-    (void)taosArrayPush(rsp.dnodeList, &epSet);
+    if (taosArrayPush(rsp.dnodeList, &epSet) == NULL) {
+      if (terrno != 0) code = terrno;
+      sdbRelease(pSdb, pObj);
+      sdbCancelFetch(pSdb, pIter);
+      goto _OVER;
+    }
 
     sdbRelease(pSdb, pObj);
   }
@@ -1845,7 +1852,9 @@ SArray *mndGetAllDnodeFqdns(SMnode *pMnode) {
     if (pIter == NULL) break;
 
     char *fqdn = taosStrdup(pObj->fqdn);
-    (void)taosArrayPush(fqdns, &fqdn);
+    if (taosArrayPush(fqdns, &fqdn) == NULL) {
+      mError("failed to fqdn into array, but continue at this time");
+    }
     sdbRelease(pSdb, pObj);
   }
   return fqdns;

source/dnode/mnode/impl/src/mndMain.c

@@ -991,7 +991,9 @@ int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgr
     } else {
       tstrncpy(desc.status, "offline", sizeof(desc.status));
     }
-    (void)taosArrayPush(pClusterInfo->dnodes, &desc);
+    if (taosArrayPush(pClusterInfo->dnodes, &desc) == NULL) {
+      mError("failed put dnode into array, but continue at this monitor report")
+    }
     sdbRelease(pSdb, pObj);
   }
 
@@ -1017,7 +1019,9 @@ int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgr
       tstrncpy(desc.role, syncStr(pObj->syncState), sizeof(desc.role));
       desc.syncState = pObj->syncState;
     }
-    (void)taosArrayPush(pClusterInfo->mnodes, &desc);
+    if (taosArrayPush(pClusterInfo->mnodes, &desc) == NULL) {
+      mError("failed to put mnode into array, but continue at this monitor report");
+    }
     sdbRelease(pSdb, pObj);
   }
 
@@ -1057,7 +1061,9 @@ int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgr
       pClusterInfo->vnodes_total++;
     }
 
-    (void)taosArrayPush(pVgroupInfo->vgroups, &desc);
+    if (taosArrayPush(pVgroupInfo->vgroups, &desc) == NULL) {
+      mError("failed to put vgroup into array, but continue at this monitor report")
+    }
     sdbRelease(pSdb, pVgroup);
   }
 
@@ -1078,7 +1084,9 @@ int32_t mndGetMonitorInfo(SMnode *pMnode, SMonClusterInfo *pClusterInfo, SMonVgr
     (void)tNameFromString(&name2, pStb->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
     tstrncpy(desc.stb_name, tNameGetTableName(&name2), TSDB_TABLE_NAME_LEN);
 
-    (void)taosArrayPush(pStbInfo->stbs, &desc);
+    if (taosArrayPush(pStbInfo->stbs, &desc) == NULL) {
+      mError("failed to put stb into array, but continue at this monitor report");
+    }
     sdbRelease(pSdb, pStb);
   }
 

source/dnode/mnode/impl/src/mndProfile.c

@@ -546,8 +546,9 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
 
   int32_t kvNum = taosHashGetSize(pHbReq->info);
   if (NULL == pHbReq->info || kvNum <= 0) {
-    // TODO return value
+    if (taosArrayPush(pBatchRsp->rsps, &hbRsp) == NULL) {
-    (void)taosArrayPush(pBatchRsp->rsps, &hbRsp);
+      mError("failed to put rsp into array, but continue at this heartbeat");
+    }
     return TSDB_CODE_SUCCESS;
   }
 
@@ -597,7 +598,9 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
                                       pObj->ipWhiteListVer);
         if (rspMsg && rspLen > 0) {
           SKv kv1 = {.key = HEARTBEAT_KEY_USER_AUTHINFO, .valueLen = rspLen, .value = rspMsg};
-          (void)taosArrayPush(hbRsp.info, &kv1);
+          if (taosArrayPush(hbRsp.info, &kv1) == NULL) {
+            mError("failed to put kv into array, but continue at this heartbeat");
+          }
         }
         break;
       }
@@ -607,7 +610,9 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
         (void)mndValidateDbInfo(pMnode, kv->value, kv->valueLen / sizeof(SDbCacheInfo), &rspMsg, &rspLen);
         if (rspMsg && rspLen > 0) {
           SKv kv1 = {.key = HEARTBEAT_KEY_DBINFO, .valueLen = rspLen, .value = rspMsg};
-          (void)taosArrayPush(hbRsp.info, &kv1);
+          if (taosArrayPush(hbRsp.info, &kv1) == NULL) {
+            mError("failed to put kv into array, but continue at this heartbeat");
+          }
         }
         break;
       }
@@ -617,7 +622,9 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
         (void)mndValidateStbInfo(pMnode, kv->value, kv->valueLen / sizeof(SSTableVersion), &rspMsg, &rspLen);
         if (rspMsg && rspLen > 0) {
           SKv kv1 = {.key = HEARTBEAT_KEY_STBINFO, .valueLen = rspLen, .value = rspMsg};
-          (void)taosArrayPush(hbRsp.info, &kv1);
+          if (taosArrayPush(hbRsp.info, &kv1) == NULL) {
+            mError("failed to put kv into array, but continue at this heartbeat");
+          }
         }
         break;
       }
@@ -635,7 +642,9 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
         (void)mndValidateViewInfo(pMnode, kv->value, kv->valueLen / sizeof(SViewVersion), &rspMsg, &rspLen);
         if (rspMsg && rspLen > 0) {
           SKv kv1 = {.key = HEARTBEAT_KEY_VIEWINFO, .valueLen = rspLen, .value = rspMsg};
-          (void)taosArrayPush(hbRsp.info, &kv1);
+          if (taosArrayPush(hbRsp.info, &kv1) == NULL) {
+            mError("failed to put kv into array, but continue at this heartbeat");
+          }
         }
         break;
       }
@@ -646,7 +655,9 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
         (void)mndValidateTSMAInfo(pMnode, kv->value, kv->valueLen / sizeof(STSMAVersion), &rspMsg, &rspLen);
         if (rspMsg && rspLen > 0) {
           SKv kv = {.key = HEARTBEAT_KEY_TSMA, .valueLen = rspLen, .value = rspMsg};
-          (void)taosArrayPush(hbRsp.info, &kv);
+          if (taosArrayPush(hbRsp.info, &kv) == NULL) {
+            mError("failed to put kv into array, but continue at this heartbeat");
+          }
         }
         break;
       }
@@ -706,7 +717,9 @@ static int32_t mndProcessHeartBeatReq(SRpcMsg *pReq) {
     } else if (pHbReq->connKey.connType == CONN_TYPE__TMQ) {
       SClientHbRsp *pRsp = mndMqHbBuildRsp(pMnode, pHbReq);
       if (pRsp != NULL) {
-        (void)taosArrayPush(batchRsp.rsps, pRsp);
+        if (taosArrayPush(batchRsp.rsps, pRsp) == NULL) {
+          mError("failed to put kv into array, but continue at this heartbeat");
+        }
         taosMemoryFree(pRsp);
       }
     }

source/dnode/mnode/impl/src/mndQnode.c

@@ -498,7 +498,12 @@ int32_t mndCreateQnodeList(SMnode *pMnode, SArray **pList, int32_t limit) {
     nodeLoad.addr.epSet.eps[0].port = pObj->pDnode->port;
     nodeLoad.load = QNODE_LOAD_VALUE(pObj);
 
-    (void)taosArrayPush(qnodeList, &nodeLoad);
+    if (taosArrayPush(qnodeList, &nodeLoad) == NULL) {
+      sdbRelease(pSdb, pObj);
+      sdbCancelFetch(pSdb, pIter);
+      if (terrno != 0) code = terrno;
+      return code;
+    }
 
     numOfRows++;
     sdbRelease(pSdb, pObj);

source/dnode/mnode/impl/src/mndSma.c

@@ -1845,8 +1845,7 @@ static int32_t mndTSMAGenerateOutputName(const char* tsmaName, char* streamName,
 
 static int32_t mndProcessCreateTSMAReq(SRpcMsg* pReq) {
 #ifdef WINDOWS
-  terrno = TSDB_CODE_MND_INVALID_PLATFORM;
+  TAOS_RETURN(TSDB_CODE_MND_INVALID_PLATFORM);
-  goto _OVER;
 #endif
   SMnode *       pMnode = pReq->info.node;
   int32_t        code = -1;

source/dnode/mnode/impl/src/mndStb.c

@@ -278,7 +278,7 @@ static SSdbRow *mndStbActionDecode(SSdbRaw *pRaw) {
   for (int32_t i = 0; i < pStb->numOfFuncs; ++i) {
     char funcName[TSDB_FUNC_NAME_LEN] = {0};
     SDB_GET_BINARY(pRaw, dataPos, funcName, TSDB_FUNC_NAME_LEN, _OVER)
-    (void)taosArrayPush(pStb->pFuncs, funcName);
+    if (taosArrayPush(pStb->pFuncs, funcName) == NULL) goto _OVER;
   }
 
   if (pStb->commentLen > 0) {
@@ -3069,7 +3069,10 @@ int32_t mndValidateStbInfo(SMnode *pMnode, SSTableVersion *pStbVersions, int32_t
       tstrncpy(metaRsp.dbFName, pStbVersion->dbFName, sizeof(metaRsp.dbFName));
       tstrncpy(metaRsp.tbName, pStbVersion->stbName, sizeof(metaRsp.tbName));
       tstrncpy(metaRsp.stbName, pStbVersion->stbName, sizeof(metaRsp.stbName));
-      (void)taosArrayPush(hbRsp.pMetaRsp, &metaRsp);
+      if (taosArrayPush(hbRsp.pMetaRsp, &metaRsp) == NULL) {
+        code = terrno;
+        return code;
+      }
       continue;
     }
 
@@ -3082,11 +3085,17 @@ int32_t mndValidateStbInfo(SMnode *pMnode, SSTableVersion *pStbVersions, int32_t
         tstrncpy(metaRsp.dbFName, pStbVersion->dbFName, sizeof(metaRsp.dbFName));
         tstrncpy(metaRsp.tbName, pStbVersion->stbName, sizeof(metaRsp.tbName));
         tstrncpy(metaRsp.stbName, pStbVersion->stbName, sizeof(metaRsp.stbName));
-        (void)taosArrayPush(hbRsp.pMetaRsp, &metaRsp);
+        if (taosArrayPush(hbRsp.pMetaRsp, &metaRsp) == NULL) {
+          code = terrno;
+          return code;
+        }
         continue;
       }
 
-      (void)taosArrayPush(hbRsp.pMetaRsp, &metaRsp);
+      if (taosArrayPush(hbRsp.pMetaRsp, &metaRsp) == NULL) {
+        code = terrno;
+        return code;
+      }
     }
 
     if (sma) {
@@ -3110,7 +3119,10 @@ int32_t mndValidateStbInfo(SMnode *pMnode, SSTableVersion *pStbVersions, int32_t
       strcpy(indexRsp.dbFName, pStbVersion->dbFName);
       strcpy(indexRsp.tbName, pStbVersion->stbName);
 
-      (void)taosArrayPush(hbRsp.pIndexRsp, &indexRsp);
+      if (taosArrayPush(hbRsp.pIndexRsp, &indexRsp) == NULL) {
+        code = terrno;
+        return code;
+      }
     }
   }
 
@@ -4313,7 +4325,12 @@ static int32_t mndDropTbAddTsmaResTbsForSingleVg(SMnode *pMnode, SMndDropTbsWith
       } else {
         info.dbInfo = *pDbInfo;
       }
-      (void)taosArrayPush(pInfos->pTsmaInfos, &info);
+      if (taosArrayPush(pInfos->pTsmaInfos, &info) == NULL) {
+        code = terrno;
+        sdbCancelFetch(pMnode->pSdb, pIter);
+        sdbRelease(pMnode->pSdb, pSma);
+        goto _end;
+      }
     }
     sdbRelease(pMnode->pSdb, pSma);
   }
@@ -4333,7 +4350,10 @@ static int32_t mndDropTbAddTsmaResTbsForSingleVg(SMnode *pMnode, SMndDropTbsWith
           taosGetTbHashVal(buf, len, pInfo->dbInfo.hashMethod, pInfo->dbInfo.hashPrefix, pInfo->dbInfo.hashSuffix);
       const SVgroupInfo *pVgInfo = taosArraySearch(pInfo->dbInfo.dbVgInfos, &hashVal, vgHashValCmp, TD_EQ);
       void              *p = taosStrdup(buf + strlen(pInfo->tsmaResTbDbFName) + TSDB_NAME_DELIMITER_LEN);
-      (void)taosArrayPush(pCtx->pResTbNames, &p);
+      if (taosArrayPush(pCtx->pResTbNames, &p) == NULL) {
+        code = terrno;
+        goto _end;
+      }
       TAOS_CHECK_GOTO(mndDropTbAdd(pMnode, pCtx->pVgMap, pVgInfo, p, pInfo->suid, true), NULL, _end);
     }
   }

source/dnode/mnode/impl/src/mndTopic.c

@@ -270,7 +270,9 @@ SSdbRow *mndTopicActionDecode(SSdbRaw *pRaw) {
     }
     int16_t colId;
     SDB_GET_INT16(pRaw, dataPos, &colId, TOPIC_DECODE_OVER);
-    (void)taosArrayPush(pTopic->ntbColIds, &colId);
+    if (taosArrayPush(pTopic->ntbColIds, &colId) == NULL) {
+      goto TOPIC_DECODE_OVER;
+    }
   }
 
   SDB_GET_INT64(pRaw, dataPos, &pTopic->ctbStbUid, TOPIC_DECODE_OVER);

source/dnode/mnode/impl/src/mndTrans.c

@@ -1905,7 +1905,9 @@ void mndTransPullup(SMnode *pMnode) {
     STrans *pTrans = NULL;
     pIter = sdbFetch(pMnode->pSdb, SDB_TRANS, pIter, (void **)&pTrans);
     if (pIter == NULL) break;
-    (void)taosArrayPush(pArray, &pTrans->id);
+    if (taosArrayPush(pArray, &pTrans->id) == NULL) {
+      mError("failed to put trans into array, trans:%d, but pull up will continute", pTrans->id);
+    }
     sdbRelease(pSdb, pTrans);
   }
 

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

@@ -122,7 +122,7 @@ int32_t metaCacheOpen(SMeta* pMeta) {
 
   pMeta->pCache = (SMetaCache*)taosMemoryCalloc(1, sizeof(SMetaCache));
   if (pMeta->pCache == NULL) {
-    TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
+    TSDB_CHECK_CODE(code = terrno, lino, _exit);
   }
 
   // open entry cache
@@ -131,7 +131,7 @@ int32_t metaCacheOpen(SMeta* pMeta) {
   pMeta->pCache->sEntryCache.aBucket =
       (SMetaCacheEntry**)taosMemoryCalloc(pMeta->pCache->sEntryCache.nBucket, sizeof(SMetaCacheEntry*));
   if (pMeta->pCache->sEntryCache.aBucket == NULL) {
-    TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
+    TSDB_CHECK_CODE(code = terrno, lino, _exit);
   }
 
   // open stats cache
@@ -140,7 +140,7 @@ int32_t metaCacheOpen(SMeta* pMeta) {
   pMeta->pCache->sStbStatsCache.aBucket =
       (SMetaStbStatsEntry**)taosMemoryCalloc(pMeta->pCache->sStbStatsCache.nBucket, sizeof(SMetaStbStatsEntry*));
   if (pMeta->pCache->sStbStatsCache.aBucket == NULL) {
-    TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
+    TSDB_CHECK_CODE(code = terrno, lino, _exit);
   }
 
   pMeta->pCache->sTagFilterResCache.pUidResCache = taosLRUCacheInit(5 * 1024 * 1024, -1, 0.5);
@@ -228,7 +228,7 @@ static int32_t metaRehashCache(SMetaCache* pCache, int8_t expand) {
 
   SMetaCacheEntry** aBucket = (SMetaCacheEntry**)taosMemoryCalloc(nBucket, sizeof(SMetaCacheEntry*));
   if (aBucket == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _exit;
   }
 
@@ -361,7 +361,7 @@ static int32_t metaRehashStatsCache(SMetaCache* pCache, int8_t expand) {
 
   SMetaStbStatsEntry** aBucket = (SMetaStbStatsEntry**)taosMemoryCalloc(nBucket, sizeof(SMetaStbStatsEntry*));
   if (aBucket == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _exit;
   }
 

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

@@ -53,7 +53,7 @@ int32_t metaOpen(SVnode *pVnode, SMeta **ppMeta, int8_t rollback) {
   snprintf(path + offset, TSDB_FILENAME_LEN - offset - 1, "%s%s", TD_DIRSEP, VNODE_META_DIR);
 
   if ((pMeta = taosMemoryCalloc(1, sizeof(*pMeta) + strlen(path) + 1)) == NULL) {
-    TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
+    TSDB_CHECK_CODE(code = terrno, lino, _exit);
   }
 
   (void)metaInitLock(pMeta);

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

@@ -1255,7 +1255,7 @@ int32_t metaFilterTableIds(void *pVnode, SMetaFltParam *arg, SArray *pUids) {
   SIdxCursor *pCursor = NULL;
   pCursor = (SIdxCursor *)taosMemoryCalloc(1, sizeof(SIdxCursor));
   if (!pCursor) {
-    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    return terrno;
   }
   pCursor->pMeta = pMeta;
   pCursor->suid = param->suid;

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

@@ -137,7 +137,7 @@ int32_t metaSnapWriterOpen(SMeta* pMeta, int64_t sver, int64_t ever, SMetaSnapWr
   // alloc
   pWriter = (SMetaSnapWriter*)taosMemoryCalloc(1, sizeof(*pWriter));
   if (pWriter == NULL) {
-    TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
+    TSDB_CHECK_CODE(code = terrno, lino, _exit);
   }
   pWriter->pMeta = pMeta;
   pWriter->sver = sver;
@@ -304,7 +304,7 @@ int32_t buildSnapContext(SVnode* pVnode, int64_t snapVersion, int64_t suid, int8
                          SSnapContext** ctxRet) {
   SSnapContext* ctx = taosMemoryCalloc(1, sizeof(SSnapContext));
   if (ctx == NULL) {
-    return TAOS_GET_TERRNO(TSDB_CODE_OUT_OF_MEMORY);
+    return terrno;
   }
   *ctxRet = ctx;
   ctx->pMeta = pVnode->pMeta;

source/dnode/vnode/src/sma/smaEnv.c

@@ -117,10 +117,10 @@ static int32_t tdNewSmaEnv(SSma *pSma, int8_t smaType, SSmaEnv **ppEnv) {
   SSmaEnv *pEnv = NULL;
 
   pEnv = (SSmaEnv *)taosMemoryCalloc(1, sizeof(SSmaEnv));
-  *ppEnv = pEnv;
   if (!pEnv) {
-    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    return terrno;
   }
+  *ppEnv = pEnv;
 
   SMA_ENV_TYPE(pEnv) = smaType;
 
@@ -199,7 +199,7 @@ static int32_t tdInitSmaStat(SSmaStat **pSmaStat, int8_t smaType, const SSma *pS
   if (!(*pSmaStat)) {
     *pSmaStat = (SSmaStat *)taosMemoryCalloc(1, sizeof(SSmaStat) + sizeof(TdThread) * tsNumOfVnodeRsmaThreads);
     if (!(*pSmaStat)) {
-      code = TSDB_CODE_OUT_OF_MEMORY;
+      code = terrno;
       TAOS_CHECK_GOTO(code, &lino, _exit);
     }
 

source/dnode/vnode/src/sma/smaOpen.c

@@ -139,7 +139,7 @@ int32_t smaOpen(SVnode *pVnode, int8_t rollback, bool force) {
 
   SSma *pSma = taosMemoryCalloc(1, sizeof(SSma));
   if (!pSma) {
-    TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY);
+    TAOS_CHECK_EXIT(terrno);
   }
 
   pVnode->pSma = pSma;

source/dnode/vnode/src/sma/smaRollup.c

@@ -123,7 +123,7 @@ void *tdFreeRSmaInfo(SSma *pSma, SRSmaInfo *pInfo) {
 static FORCE_INLINE int32_t tdUidStoreInit(STbUidStore **pStore) {
   *pStore = taosMemoryCalloc(1, sizeof(STbUidStore));
   if (*pStore == NULL) {
-    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    return terrno;
   }
 
   return TSDB_CODE_SUCCESS;
@@ -285,7 +285,7 @@ static int32_t tdSetRSmaInfoItemParams(SSma *pSma, SRSmaParam *param, SRSmaStat
 
     SStreamTask *pStreamTask = taosMemoryCalloc(1, sizeof(*pStreamTask));
     if (!pStreamTask) {
-      TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+      return terrno;
     }
     pItem->pStreamTask = pStreamTask;
     pStreamTask->id.taskId = 0;
@@ -389,7 +389,7 @@ int32_t tdRSmaProcessCreateImpl(SSma *pSma, SRSmaParam *param, int64_t suid, con
   // from write queue: single thead
   pRSmaInfo = (SRSmaInfo *)taosMemoryCalloc(1, sizeof(SRSmaInfo));
   if (!pRSmaInfo) {
-    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    return terrno;
   }
 
   STSchema *pTSchema = metaGetTbTSchema(SMA_META(pSma), suid, -1, 1);

source/dnode/vnode/src/sma/smaSnapshot.c

@@ -38,7 +38,7 @@ int32_t rsmaSnapReaderOpen(SSma* pSma, int64_t sver, int64_t ever, SRSmaSnapRead
   // alloc
   pReader = (SRSmaSnapReader*)taosMemoryCalloc(1, sizeof(*pReader));
   if (pReader == NULL) {
-    TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit);
+    TAOS_CHECK_GOTO(terrno, &lino, _exit);
   }
   pReader->pSma = pSma;
   pReader->sver = sver;
@@ -136,7 +136,7 @@ int32_t rsmaSnapWriterOpen(SSma* pSma, int64_t sver, int64_t ever, void** ppRang
   // alloc
   pWriter = (SRSmaSnapWriter*)taosMemoryCalloc(1, sizeof(*pWriter));
   if (!pWriter) {
-    TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit);
+    TAOS_CHECK_GOTO(terrno, &lino, _exit);
   }
   pWriter->pSma = pSma;
   pWriter->sver = sver;

source/dnode/vnode/src/sma/smaTimeRange.c

@@ -165,7 +165,7 @@ int32_t smaBlockToSubmit(SVnode *pVnode, const SArray *pBlocks, const STSchema *
   pReq = taosMemoryCalloc(1, sizeof(SSubmitReq2));
 
   if (!tagArray || !pReq) {
-    TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY);
+    TAOS_CHECK_EXIT(terrno);
   }
 
   pReq->aSubmitTbData = taosArrayInit(1, sizeof(SSubmitTbData));

source/dnode/vnode/src/tq/tq.c

@@ -66,7 +66,7 @@ static bool tqOffsetEqual(const STqOffset* pLeft, const STqOffset* pRight) {
 int32_t tqOpen(const char* path, SVnode* pVnode) {
   STQ* pTq = taosMemoryCalloc(1, sizeof(STQ));
   if (pTq == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
   pVnode->pTq = pTq;
   pTq->path = taosStrdup(path);

source/dnode/vnode/src/tq/tqMeta.c

@@ -115,7 +115,7 @@ int32_t tqMetaSaveOffset(STQ* pTq, STqOffset* pOffset) {
 
   buf = taosMemoryCalloc(1, vlen);
   if (buf == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto END;
   }
 
@@ -212,7 +212,7 @@ int32_t tqMetaSaveHandle(STQ* pTq, const char* key, const STqHandle* pHandle) {
 
   buf = taosMemoryCalloc(1, vlen);
   if (buf == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto END;
   }
 

source/dnode/vnode/src/tq/tqOffset.c

@@ -20,7 +20,7 @@ int32_t tqBuildFName(char** data, const char* path, char* name) {
   int32_t len = strlen(path) + strlen(name) + 2;
   char*   fname = taosMemoryCalloc(1, len);
   if(fname == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
   int32_t code = snprintf(fname, len, "%s%s%s", path, TD_DIRSEP, name);
   if (code < 0){
@@ -56,7 +56,7 @@ int32_t tqOffsetRestoreFromFile(STQ* pTq, char* name) {
     size = htonl(size);
     pMemBuf = taosMemoryCalloc(1, size);
     if (pMemBuf == NULL) {
-      code = TSDB_CODE_OUT_OF_MEMORY;
+      code = terrno;
       goto END;
     }
 

source/dnode/vnode/src/tq/tqRead.c

@@ -547,7 +547,7 @@ int32_t tqMaskBlock(SSchemaWrapper* pDst, SSDataBlock* pBlock, const SSchemaWrap
   pDst->nCols = cnt;
   pDst->pSchema = taosMemoryCalloc(cnt, sizeof(SSchema));
   if (pDst->pSchema == NULL) {
-    return TAOS_GET_TERRNO(TSDB_CODE_OUT_OF_MEMORY);
+    return TAOS_GET_TERRNO(terrno);
   }
 
   int32_t j = 0;

source/dnode/vnode/src/tq/tqScan.c

@@ -19,7 +19,7 @@ int32_t tqAddBlockDataToRsp(const SSDataBlock* pBlock, void* pRsp, int32_t numOf
   int32_t dataStrLen = sizeof(SRetrieveTableRspForTmq) + blockGetEncodeSize(pBlock);
   void*   buf = taosMemoryCalloc(1, dataStrLen);
   if (buf == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   SRetrieveTableRspForTmq* pRetrieve = (SRetrieveTableRspForTmq*)buf;
@@ -344,7 +344,7 @@ static void tqProcessSubData(STQ* pTq, STqHandle* pHandle, STaosxRsp* pRsp, int3
     }
     void*    createReq = taosMemoryCalloc(1, len);
     if (createReq == NULL){
-      code = TSDB_CODE_OUT_OF_MEMORY;
+      code = terrno;
       goto END;
     }
     SEncoder encoder = {0};

source/dnode/vnode/src/tq/tqSink.c

@@ -549,7 +549,7 @@ int32_t buildAutoCreateTableReq(const char* stbFullName, int64_t suid, int32_t n
 
   SVCreateTbReq* pCreateTbReq = taosMemoryCalloc(1, sizeof(SVCreateTbReq));
   if (pCreateTbReq == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   taosArrayClear(pTagArray);
@@ -802,7 +802,7 @@ int32_t doCreateSinkInfo(const char* pDstTableName, STableSinkInfo** pInfo) {
   int32_t nameLen = strlen(pDstTableName);
   (*pInfo) = taosMemoryCalloc(1, sizeof(STableSinkInfo) + nameLen + 1);
   if (*pInfo == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   (*pInfo)->name.len = nameLen;

source/dnode/vnode/src/tq/tqStreamStateSnap.c

@@ -38,7 +38,7 @@ int32_t streamStateSnapReaderOpen(STQ* pTq, int64_t sver, int64_t ever, SStreamS
   // alloc
   pReader = (SStreamStateReader*)taosMemoryCalloc(1, sizeof(SStreamStateReader));
   if (pReader == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _err;
   }
 
@@ -130,7 +130,7 @@ int32_t streamStateSnapWriterOpen(STQ* pTq, int64_t sver, int64_t ever, SStreamS
   // alloc
   pWriter = (SStreamStateWriter*)taosMemoryCalloc(1, sizeof(*pWriter));
   if (pWriter == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _err;
   }
   pWriter->pTq = pTq;

source/dnode/vnode/src/tq/tqStreamTaskSnap.c

@@ -39,7 +39,7 @@ int32_t streamTaskSnapReaderOpen(STQ* pTq, int64_t sver, int64_t ever, SStreamTa
   // alloc
   pReader = (SStreamTaskReader*)taosMemoryCalloc(1, sizeof(SStreamTaskReader));
   if (pReader == NULL) {
-    TAOS_CHECK_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    TAOS_CHECK_RETURN(terrno);
   }
   pReader->pTq = pTq;
   pReader->sver = sver;
@@ -120,7 +120,7 @@ NextTbl:
     } else {
       pVal = taosMemoryCalloc(1, tLen);
       if (pVal == NULL) {
-        code = TSDB_CODE_OUT_OF_MEMORY;
+        code = terrno;
         goto _err;
       }
       memcpy(pVal, tVal, tLen);
@@ -181,7 +181,7 @@ int32_t streamTaskSnapWriterOpen(STQ* pTq, int64_t sver, int64_t ever, SStreamTa
   // alloc
   pWriter = (SStreamTaskWriter*)taosMemoryCalloc(1, sizeof(*pWriter));
   if (pWriter == NULL) {
-    TAOS_CHECK_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    TAOS_CHECK_RETURN(terrno);
   }
   pWriter->pTq = pTq;
   pWriter->sver = sver;

source/dnode/vnode/src/tqCommon/tqCommon.c

@@ -582,7 +582,7 @@ int32_t tqStreamTaskProcessDeployReq(SStreamMeta* pMeta, SMsgCb* cb, int64_t sve
   SStreamTask* pTask = taosMemoryCalloc(1, size);
   if (pTask == NULL) {
     tqError("vgId:%d failed to create stream task due to out of memory, alloc size:%d", vgId, size);
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   SDecoder decoder;

source/dnode/vnode/src/tsdb/tsdbCache.c

@@ -326,7 +326,7 @@ static int32_t tsdbCacheDeserialize(char const *value, size_t size, SLastCol **p
 
   SLastCol *pLastCol = taosMemoryCalloc(1, sizeof(SLastCol));
   if (NULL == pLastCol) {
-    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    return terrno;
   }
 
   int32_t offset = tsdbCacheDeserializeV0(value, pLastCol);
@@ -632,7 +632,7 @@ static int32_t tsdbCacheNewTableColumn(STsdb *pTsdb, int64_t uid, int16_t cid, i
 
   SLastCol *pLastCol = taosMemoryCalloc(1, sizeof(SLastCol));
   if (!pLastCol) {
-    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    return terrno;
   }
 
   size_t charge = 0;
@@ -679,13 +679,17 @@ int32_t tsdbCacheCommitNoLock(STsdb *pTsdb) {
 static int32_t tsdbCacheGetValuesFromRocks(STsdb *pTsdb, size_t numKeys, const char *const *ppKeysList,
                                            size_t *pKeysListSizes, char ***pppValuesList, size_t **ppValuesListSizes) {
   char  **valuesList = taosMemoryCalloc(numKeys, sizeof(char *));
+  if(!valuesList) return terrno;
   size_t *valuesListSizes = taosMemoryCalloc(numKeys, sizeof(size_t));
+  if(!valuesListSizes) {
+    taosMemoryFreeClear(valuesList);
+    return terrno;
+  }
   char  **errs = taosMemoryCalloc(numKeys, sizeof(char *));
-  if (!valuesList || !valuesListSizes || !errs) {
+  if (!errs) {
     taosMemoryFreeClear(valuesList);
     taosMemoryFreeClear(valuesListSizes);
-    taosMemoryFreeClear(errs);
+    return terrno;
-    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
   rocksdb_multi_get(pTsdb->rCache.db, pTsdb->rCache.readoptions, numKeys, ppKeysList, pKeysListSizes, valuesList,
                     valuesListSizes, errs);
@@ -705,12 +709,12 @@ static int32_t tsdbCacheDropTableColumn(STsdb *pTsdb, int64_t uid, int16_t cid,
   // build keys & multi get from rocks
   char **keys_list = taosMemoryCalloc(2, sizeof(char *));
   if (!keys_list) {
-    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    return terrno;
   }
   size_t *keys_list_sizes = taosMemoryCalloc(2, sizeof(size_t));
   if (!keys_list_sizes) {
     taosMemoryFree(keys_list);
-    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    return terrno;
   }
   const size_t klen = ROCKS_KEY_LEN;
 
@@ -718,7 +722,7 @@ static int32_t tsdbCacheDropTableColumn(STsdb *pTsdb, int64_t uid, int16_t cid,
   if (!keys) {
     taosMemoryFree(keys_list);
     taosMemoryFree(keys_list_sizes);
-    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    return terrno;
   }
   ((SLastKey *)keys)[0] = (SLastKey){.lflag = LFLAG_LAST, .uid = uid, .cid = cid};
   ((SLastKey *)keys)[1] = (SLastKey){.lflag = LFLAG_LAST_ROW, .uid = uid, .cid = cid};
@@ -1003,7 +1007,7 @@ static int32_t tsdbCacheUpdateValue(SValue *pOld, SValue *pNew) {
     if (nData < pNew->nData) {
       pOld->pData = taosMemoryCalloc(1, pNew->nData);
       if (!pOld->pData) {
-        TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+        return terrno;
       }
     } else {
       pOld->pData = pFree;
@@ -1099,7 +1103,7 @@ static int32_t tsdbCachePutToLRU(STsdb *pTsdb, SLastKey *pLastKey, SLastCol *pLa
 
   SLastCol *pLRULastCol = taosMemoryCalloc(1, sizeof(SLastCol));
   if (!pLRULastCol) {
-    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    return terrno;
   }
 
   size_t charge = 0;
@@ -1182,11 +1186,15 @@ static int32_t tsdbCacheUpdate(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, SArray
     size_t *values_list_sizes = NULL;
     char  **errs = NULL;
     keys_list = taosMemoryCalloc(num_keys, sizeof(char *));
+    if(!keys_list) {
+      (void)taosThreadMutexUnlock(&pTsdb->lruMutex);
+      return terrno;
+    }
     keys_list_sizes = taosMemoryCalloc(num_keys, sizeof(size_t));
-    if (!keys_list || !keys_list_sizes) {
+    if (!keys_list_sizes) {
       taosMemoryFree(keys_list);
       (void)taosThreadMutexUnlock(&pTsdb->lruMutex);
-      TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+      return terrno;
     }
     for (int i = 0; i < num_keys; ++i) {
       SIdxKey *idxKey = &((SIdxKey *)TARRAY_DATA(remainCols))[i];
@@ -1578,7 +1586,7 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr
 
     SLastCol *pTmpLastCol = taosMemoryCalloc(1, sizeof(SLastCol));
     if (!pTmpLastCol) {
-      TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY);
+      TAOS_CHECK_EXIT(terrno);
     }
 
     size_t charge = 0;
@@ -1678,7 +1686,7 @@ static int32_t tsdbCacheLoadFromRocks(STsdb *pTsdb, tb_uid_t uid, SArray *pLastA
       SLastCol *pTmpLastCol = taosMemoryCalloc(1, sizeof(SLastCol));
       if (!pTmpLastCol) {
         taosMemoryFreeClear(PToFree);
-        code = TSDB_CODE_OUT_OF_MEMORY;
+        code = terrno;
         goto _exit;
       }
 
@@ -1896,7 +1904,7 @@ int32_t tsdbCacheDel(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, TSKEY sKey, TSKE
   size_t *values_list_sizes = NULL;
 
   if (!keys_list || !keys_list_sizes) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _exit;
   }
   const size_t klen = ROCKS_KEY_LEN;
@@ -1904,7 +1912,7 @@ int32_t tsdbCacheDel(STsdb *pTsdb, tb_uid_t suid, tb_uid_t uid, TSKEY sKey, TSKE
   for (int i = 0; i < numKeys; ++i) {
     char *key = taosMemoryCalloc(1, sizeof(SLastKey));
     if (!key) {
-      code = TSDB_CODE_OUT_OF_MEMORY;
+      code = terrno;
       goto _exit;
     }
     ((SLastKey *)key)[0] = *(SLastKey *)taosArrayGet(remainCols, i);

source/dnode/vnode/src/tsdb/tsdbCacheRead.c

@@ -26,7 +26,7 @@
 static int32_t setFirstLastResColToNull(SColumnInfoData* pCol, int32_t row) {
   char* buf = taosMemoryCalloc(1, pCol->info.bytes);
   if (buf == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   SFirstLastRes* pRes = (SFirstLastRes*)((char*)buf + VARSTR_HEADER_SIZE);
@@ -283,7 +283,7 @@ int32_t tsdbCacherowsReaderOpen(void* pVnode, int32_t type, void* pTableIdList,
   *pReader = NULL;
   SCacheRowsReader* p = taosMemoryCalloc(1, sizeof(SCacheRowsReader));
   if (p == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   p->type = type;
@@ -323,7 +323,7 @@ int32_t tsdbCacherowsReaderOpen(void* pVnode, int32_t type, void* pTableIdList,
   p->transferBuf = taosMemoryCalloc(p->pSchema->numOfCols, POINTER_BYTES);
   if (p->transferBuf == NULL) {
     tsdbCacherowsReaderClose(p);
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   for (int32_t i = 0; i < p->pSchema->numOfCols; ++i) {
@@ -446,7 +446,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
 
   pRes = taosMemoryCalloc(pr->numOfCols, POINTER_BYTES);
   if (pRes == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _end;
   }
 
@@ -456,7 +456,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
 
     pRes[j] = taosMemoryCalloc(1, sizeof(SFirstLastRes) + bytes + pkBufLen + VARSTR_HEADER_SIZE);
     if (pRes[j] == NULL) {
-      code = TSDB_CODE_OUT_OF_MEMORY;
+      code = terrno;
       goto _end;
     }
 
@@ -504,7 +504,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
 
             p.rowKey.pks[j].pData = taosMemoryCalloc(1, pr->pkColumn.bytes);
             if (p.rowKey.pks[j].pData == NULL) {
-              code = TSDB_CODE_OUT_OF_MEMORY;
+              code = terrno;
               goto _end;
             }
           }
@@ -514,7 +514,7 @@ int32_t tsdbRetrieveCacheRows(void* pReader, SSDataBlock* pResBlock, const int32
       if (IS_VAR_DATA_TYPE(pCol->type)) {
         p.colVal.value.pData = taosMemoryCalloc(pCol->bytes, sizeof(char));
         if (p.colVal.value.pData == NULL) {
-          code = TSDB_CODE_OUT_OF_MEMORY;
+          code = terrno;
           goto _end;
         }
       }

source/dnode/vnode/src/tsdb/tsdbCommit2.c

@@ -432,7 +432,7 @@ static int32_t tsdbCommitInfoInit(STsdb *pTsdb) {
 
   pTsdb->commitInfo = taosMemoryCalloc(1, sizeof(*pTsdb->commitInfo));
   if (pTsdb->commitInfo == NULL) {
-    TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit);
+    TAOS_CHECK_GOTO(terrno, &lino, _exit);
   }
 
   TAOS_CHECK_GOTO(vHashInit(&pTsdb->commitInfo->ht, tFileSetCommitInfoHash, tFileSetCommitInfoCompare), &lino, _exit);

source/dnode/vnode/src/tsdb/tsdbDataFileRAW.c

@@ -23,7 +23,7 @@ int32_t tsdbDataFileRAWReaderOpen(const char *fname, const SDataFileRAWReaderCon
 
   reader[0] = taosMemoryCalloc(1, sizeof(SDataFileRAWReader));
   if (reader[0] == NULL) {
-    TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit);
+    TAOS_CHECK_GOTO(terrno, &lino, _exit);
   }
 
   reader[0]->config[0] = config[0];
@@ -94,7 +94,7 @@ int32_t tsdbDataFileRAWWriterOpen(const SDataFileRAWWriterConfig *config, SDataF
 
   SDataFileRAWWriter *writer = taosMemoryCalloc(1, sizeof(SDataFileRAWWriter));
   if (!writer) {
-    TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit);
+    TAOS_CHECK_GOTO(terrno, &lino, _exit);
   }
 
   writer->config[0] = config[0];

source/dnode/vnode/src/tsdb/tsdbDataFileRW.c

@@ -111,7 +111,7 @@ int32_t tsdbDataFileReaderOpen(const char *fname[], const SDataFileReaderConfig
   int32_t lino = 0;
 
   if ((*reader = taosMemoryCalloc(1, sizeof(**reader))) == NULL) {
-    TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit);
+    TAOS_CHECK_GOTO(terrno, &lino, _exit);
   }
 
   for (int32_t i = 0; i < ARRAY_SIZE(reader[0]->local); i++) {
@@ -1803,7 +1803,7 @@ _exit:
 int32_t tsdbDataFileWriterOpen(const SDataFileWriterConfig *config, SDataFileWriter **writer) {
   writer[0] = taosMemoryCalloc(1, sizeof(*writer[0]));
   if (!writer[0]) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   writer[0]->config[0] = config[0];

source/dnode/vnode/src/tsdb/tsdbFS.c

@@ -53,7 +53,7 @@ static int32_t tsdbBinaryToFS(uint8_t *pData, int64_t nData, STsdbFS *pFS) {
   if (hasDel) {
     pFS->pDelFile = (SDelFile *)taosMemoryCalloc(1, sizeof(SDelFile));
     if (pFS->pDelFile == NULL) {
-      code = TSDB_CODE_OUT_OF_MEMORY;
+      code = terrno;
       goto _exit;
     }
 

source/dnode/vnode/src/tsdb/tsdbFS2.c

@@ -42,7 +42,7 @@ static const char *gCurrentFname[] = {
 static int32_t create_fs(STsdb *pTsdb, STFileSystem **fs) {
   fs[0] = taosMemoryCalloc(1, sizeof(*fs[0]));
   if (fs[0] == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   fs[0]->tsdb = pTsdb;
@@ -417,7 +417,7 @@ static int32_t tsdbFSCreateFileObjHash(STFileSystem *fs, STFileHash *hash) {
   hash->numBucket = 4096;
   hash->buckets = taosMemoryCalloc(hash->numBucket, sizeof(STFileHashEntry *));
   if (hash->buckets == NULL) {
-    TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
+    TSDB_CHECK_CODE(code = terrno, lino, _exit);
   }
 
   // vnode.json
@@ -1013,7 +1013,7 @@ int32_t tsdbFSCreateRefSnapshotWithoutLock(STFileSystem *fs, TFileSetArray **fse
   STFileSet *fset, *fset1;
 
   fsetArr[0] = taosMemoryCalloc(1, sizeof(*fsetArr[0]));
-  if (fsetArr[0] == NULL) return TSDB_CODE_OUT_OF_MEMORY;
+  if (fsetArr[0] == NULL) return terrno;
 
   TARRAY2_FOREACH(fs->fSetArr, fset) {
     code = tsdbTFileSetInitRef(fs->tsdb, fset, &fset1);
@@ -1025,6 +1025,7 @@ int32_t tsdbFSCreateRefSnapshotWithoutLock(STFileSystem *fs, TFileSetArray **fse
 
   if (code) {
     TARRAY2_DESTROY(fsetArr[0], tsdbTFileSetClear);
+    taosMemoryFree(fsetArr[0]);
     fsetArr[0] = NULL;
   }
   return code;
@@ -1118,7 +1119,7 @@ int32_t tsdbFSCreateRefRangedSnapshot(STFileSystem *fs, int64_t sver, int64_t ev
 
   fsrArr[0] = taosMemoryCalloc(1, sizeof(*fsrArr[0]));
   if (fsrArr[0] == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _out;
   }
 

source/dnode/vnode/src/tsdb/tsdbFSet2.c

@@ -576,12 +576,17 @@ int32_t tsdbTFileSetInitRef(STsdb *pTsdb, const STFileSet *fset1, STFileSet **fs
     SSttLvl *lvl;
     code = tsdbSttLvlInitRef(pTsdb, lvl1, &lvl);
     if (code) {
+      taosMemoryFree(lvl);
       tsdbTFileSetClear(fset);
       return code;
     }
 
     code = TARRAY2_APPEND(fset[0]->lvlArr, lvl);
-    if (code) return code;
+    if (code) {
+      taosMemoryFree(lvl);
+      tsdbTFileSetClear(fset);
+      return code;
+    }
   }
 
   return 0;

source/dnode/vnode/src/tsdb/tsdbFSetRAW.c

@@ -36,7 +36,7 @@ int32_t tsdbFSetRAWWriterOpen(SFSetRAWWriterConfig *config, SFSetRAWWriter **wri
 
   writer[0] = taosMemoryCalloc(1, sizeof(SFSetRAWWriter));
   if (writer[0] == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   writer[0]->config[0] = config[0];

source/dnode/vnode/src/tsdb/tsdbFSetRW.c

@@ -136,7 +136,7 @@ int32_t tsdbFSetWriterOpen(SFSetWriterConfig *config, SFSetWriter **writer) {
 
   writer[0] = taosMemoryCalloc(1, sizeof(*writer[0]));
   if (writer[0] == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   writer[0]->config[0] = config[0];

source/dnode/vnode/src/tsdb/tsdbFile.c

@@ -181,7 +181,7 @@ int32_t tGetDFileSet(uint8_t *p, SDFileSet *pSet) {
   // head
   pSet->pHeadF = (SHeadFile *)taosMemoryCalloc(1, sizeof(SHeadFile));
   if (pSet->pHeadF == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
   pSet->pHeadF->nRef = 1;
   n += tGetHeadFile(p + n, pSet->pHeadF);
@@ -189,7 +189,7 @@ int32_t tGetDFileSet(uint8_t *p, SDFileSet *pSet) {
   // data
   pSet->pDataF = (SDataFile *)taosMemoryCalloc(1, sizeof(SDataFile));
   if (pSet->pDataF == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
   pSet->pDataF->nRef = 1;
   n += tGetDataFile(p + n, pSet->pDataF);
@@ -197,7 +197,7 @@ int32_t tGetDFileSet(uint8_t *p, SDFileSet *pSet) {
   // sma
   pSet->pSmaF = (SSmaFile *)taosMemoryCalloc(1, sizeof(SSmaFile));
   if (pSet->pSmaF == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
   pSet->pSmaF->nRef = 1;
   n += tGetSmaFile(p + n, pSet->pSmaF);
@@ -207,7 +207,7 @@ int32_t tGetDFileSet(uint8_t *p, SDFileSet *pSet) {
   for (int32_t iStt = 0; iStt < pSet->nSttF; iStt++) {
     pSet->aSttF[iStt] = (SSttFile *)taosMemoryCalloc(1, sizeof(SSttFile));
     if (pSet->aSttF[iStt] == NULL) {
-      return TSDB_CODE_OUT_OF_MEMORY;
+      return terrno;
     }
     pSet->aSttF[iStt]->nRef = 1;
     n += tGetSttFile(p + n, pSet->aSttF[iStt]);

source/dnode/vnode/src/tsdb/tsdbMergeTree.c

@@ -86,14 +86,19 @@ void destroySttBlockLoadInfo(SSttBlockLoadInfo *pLoadInfo) {
   pInfo->sttBlockIndex = -1;
   pInfo->pin = false;
 
-  if (pLoadInfo->info.pCount != NULL) {
+  taosArrayDestroy(pLoadInfo->info.pUid);
-    taosArrayDestroy(pLoadInfo->info.pUid);
+  taosArrayDestroyEx(pLoadInfo->info.pFirstKey, freeItem);
-    taosArrayDestroyEx(pLoadInfo->info.pFirstKey, freeItem);
+  taosArrayDestroyEx(pLoadInfo->info.pLastKey, freeItem);
-    taosArrayDestroyEx(pLoadInfo->info.pLastKey, freeItem);
+  taosArrayDestroy(pLoadInfo->info.pCount);
-    taosArrayDestroy(pLoadInfo->info.pCount);
+  taosArrayDestroy(pLoadInfo->info.pFirstTs);
-    taosArrayDestroy(pLoadInfo->info.pFirstTs);
+  taosArrayDestroy(pLoadInfo->info.pLastTs);
-    taosArrayDestroy(pLoadInfo->info.pLastTs);
+
-  }
+  pLoadInfo->info.pUid = NULL;
+  pLoadInfo->info.pFirstKey = NULL;
+  pLoadInfo->info.pLastKey = NULL;
+  pLoadInfo->info.pCount = NULL;
+  pLoadInfo->info.pFirstTs = NULL;
+  pLoadInfo->info.pLastTs = NULL;
 
   taosArrayDestroy(pLoadInfo->aSttBlk);
   taosMemoryFree(pLoadInfo);
@@ -834,7 +839,6 @@ int32_t tLDataIterNextRow(SLDataIter *pIter, const char *idStr, bool *hasNext) {
   int32_t     lino = 0;
 
   *hasNext = false;
-  terrno = 0;
 
   // no qualified last file block in current file, no need to fetch row
   if (pIter->pSttBlk == NULL) {
@@ -843,6 +847,7 @@ int32_t tLDataIterNextRow(SLDataIter *pIter, const char *idStr, bool *hasNext) {
 
   code = loadLastBlock(pIter, idStr, &pBlockData);
   if (pBlockData == NULL || code != TSDB_CODE_SUCCESS) {
+    lino = __LINE__;
     goto _exit;
   }
 
@@ -888,6 +893,7 @@ int32_t tLDataIterNextRow(SLDataIter *pIter, const char *idStr, bool *hasNext) {
     if (iBlockL != pIter->iSttBlk) {
       code = loadLastBlock(pIter, idStr, &pBlockData);
       if ((pBlockData == NULL) || (code != 0)) {
+        lino = __LINE__;
         goto _exit;
       }
 

source/dnode/vnode/src/tsdb/tsdbOpen.c

@@ -50,7 +50,7 @@ int32_t tsdbOpen(SVnode *pVnode, STsdb **ppTsdb, const char *dir, STsdbKeepCfg *
   // create handle
   pTsdb = (STsdb *)taosMemoryCalloc(1, sizeof(*pTsdb) + slen);
   if (pTsdb == NULL) {
-    TAOS_CHECK_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    TAOS_CHECK_RETURN(terrno);
   }
 
   pTsdb->path = (char *)&pTsdb[1];

source/dnode/vnode/src/tsdb/tsdbRead2.c

@@ -45,7 +45,7 @@ typedef struct {
   bool moreThanCapcity;
 } SDataBlockToLoadInfo;
 
-static int32_t  getCurrentBlockInfo(SDataBlockIter* pBlockIter, SFileDataBlockInfo** pInfo);
+static int32_t  getCurrentBlockInfo(SDataBlockIter* pBlockIter, SFileDataBlockInfo** pInfo, const char* idStr);
 static int32_t  buildDataBlockFromBufImpl(STableBlockScanInfo* pBlockScanInfo, int64_t endKey, int32_t capacity,
                                           STsdbReader* pReader);
 static void     getValidMemRow(SIterInfo* pIter, const SArray* pDelList, STsdbReader* pReader, TSDBROW** pRes);
@@ -257,7 +257,7 @@ static int32_t initFilesetIterator(SFilesetIter* pIter, TFileSetArray* pFileSetA
   if (pIter->pSttBlockReader == NULL) {
     pIter->pSttBlockReader = taosMemoryCalloc(1, sizeof(struct SSttBlockReader));
     if (pIter->pSttBlockReader == NULL) {
-      code = TSDB_CODE_OUT_OF_MEMORY;
+      code = terrno;
       tsdbError("failed to prepare the last block iterator, since:%s %s", tstrerror(code), pReader->idStr);
       return code;
     }
@@ -507,13 +507,13 @@ static int32_t initResBlockInfo(SResultBlockInfo* pResBlockInfo, int64_t capacit
       if (IS_VAR_DATA_TYPE(pSup->pk.type)) {
         p->info.pks[0].pData = taosMemoryCalloc(1, pSup->pk.bytes);
         if (p->info.pks[0].pData == NULL) {
-          return TSDB_CODE_OUT_OF_MEMORY;
+          return terrno;
         }
 
         p->info.pks[1].pData = taosMemoryCalloc(1, pSup->pk.bytes);
         if (p->info.pks[1].pData == NULL) {
           taosMemoryFreeClear(p->info.pks[0].pData);
-          return TSDB_CODE_OUT_OF_MEMORY;
+          return terrno;
         }
 
         p->info.pks[0].nData = pSup->pk.bytes;
@@ -533,7 +533,7 @@ static int32_t tsdbReaderCreate(SVnode* pVnode, SQueryTableDataCond* pCond, void
   int8_t       level = 0;
   STsdbReader* pReader = (STsdbReader*)taosMemoryCalloc(1, sizeof(*pReader));
   if (pReader == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _end;
   }
 
@@ -920,7 +920,7 @@ static int32_t doCopyColVal(SColumnInfoData* pColInfoData, int32_t rowIndex, int
   return code;
 }
 
-static int32_t getCurrentBlockInfo(SDataBlockIter* pBlockIter, SFileDataBlockInfo** pInfo) {
+static int32_t getCurrentBlockInfo(SDataBlockIter* pBlockIter, SFileDataBlockInfo** pInfo, const char* id) {
   *pInfo = NULL;
 
   if (pBlockIter->blockList == NULL) {
@@ -929,8 +929,10 @@ static int32_t getCurrentBlockInfo(SDataBlockIter* pBlockIter, SFileDataBlockInf
 
   size_t num = TARRAY_SIZE(pBlockIter->blockList);
   if (num == 0) {
-    tsdbError("tsdb read failed at: %s:%d", __func__, __LINE__);
+    if (num != pBlockIter->numOfBlocks) {
-    return TSDB_CODE_INTERNAL_ERROR;
+      tsdbError("tsdb read failed at: %s:%d %s", __func__, __LINE__, id);
+    }
+    return TSDB_CODE_FAILED;
   }
 
   *pInfo = taosArrayGet(pBlockIter->blockList, pBlockIter->index);
@@ -1206,7 +1208,7 @@ static int32_t copyBlockDataToSDataBlock(STsdbReader* pReader, SRowKey* pLastPro
   bool                asc = ASCENDING_TRAVERSE(pReader->info.order);
   int32_t             step = asc ? 1 : -1;
 
-  code = getCurrentBlockInfo(pBlockIter, &pBlockInfo);
+  code = getCurrentBlockInfo(pBlockIter, &pBlockInfo, pReader->idStr);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
@@ -1434,7 +1436,7 @@ static int32_t doLoadFileBlockData(STsdbReader* pReader, SDataBlockIter* pBlockI
     }
   }
 
-  code = getCurrentBlockInfo(pBlockIter, &pBlockInfo);
+  code = getCurrentBlockInfo(pBlockIter, &pBlockInfo, pReader->idStr);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
@@ -2786,7 +2788,7 @@ static int32_t buildComposedDataBlock(STsdbReader* pReader) {
   SSttBlockReader*    pSttBlockReader = pReader->status.fileIter.pSttBlockReader;
   SFileBlockDumpInfo* pDumpInfo = &pReader->status.fBlockDumpInfo;
 
-  code = getCurrentBlockInfo(&pReader->status.blockIter, &pBlockInfo);
+  code = getCurrentBlockInfo(&pReader->status.blockIter, &pBlockInfo, pReader->idStr);
   if (code != TSDB_CODE_SUCCESS) {
     return 0;
   }
@@ -2835,7 +2837,8 @@ static int32_t buildComposedDataBlock(STsdbReader* pReader) {
         pDumpInfo->rowIndex += step;
 
         if (pDumpInfo->rowIndex >= pBlockData->nRow || pDumpInfo->rowIndex < 0) {
-          code = getCurrentBlockInfo(&pReader->status.blockIter, &pBlockInfo);  // NOTE: get the new block info
+          // NOTE: get the new block info
+          code = getCurrentBlockInfo(&pReader->status.blockIter, &pBlockInfo, pReader->idStr);
           if (code != TSDB_CODE_SUCCESS) {
             goto _end;
           }
@@ -3309,7 +3312,7 @@ static int32_t doBuildDataBlock(STsdbReader* pReader) {
   bool                 asc = ASCENDING_TRAVERSE(pReader->info.order);
   int32_t              code = TSDB_CODE_SUCCESS;
 
-  code = getCurrentBlockInfo(pBlockIter, &pBlockInfo);
+  code = getCurrentBlockInfo(pBlockIter, &pBlockInfo, pReader->idStr);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
@@ -3529,7 +3532,7 @@ static void initBlockDumpInfo(STsdbReader* pReader, SDataBlockIter* pBlockIter)
   SReaderStatus*      pStatus = &pReader->status;
   SFileBlockDumpInfo* pDumpInfo = &pStatus->fBlockDumpInfo;
 
-  int32_t code = getCurrentBlockInfo(pBlockIter, &pBlockInfo);
+  int32_t code = getCurrentBlockInfo(pBlockIter, &pBlockInfo, pReader->idStr);
   if (code == TSDB_CODE_SUCCESS) {
     pDumpInfo->totalRows = pBlockInfo->numRow;
     pDumpInfo->rowIndex = ASCENDING_TRAVERSE(pReader->info.order) ? 0 : pBlockInfo->numRow - 1;
@@ -4113,7 +4116,7 @@ int32_t doMergeRowsInFileBlocks(SBlockData* pBlockData, STableBlockScanInfo* pSc
       CHECK_FILEBLOCK_STATE st;
 
       SFileDataBlockInfo* pFileBlockInfo = NULL;
-      code = getCurrentBlockInfo(&pReader->status.blockIter, &pFileBlockInfo);
+      code = getCurrentBlockInfo(&pReader->status.blockIter, &pFileBlockInfo, pReader->idStr);
       if (code != TSDB_CODE_SUCCESS) {
         return code;
       }
@@ -4586,6 +4589,8 @@ int32_t tsdbSetTableList2(STsdbReader* pReader, const void* pTableList, int32_t
   STableBlockScanInfo** p = NULL;
   int32_t               iter = 0;
 
+  (void)tsdbAcquireReader(pReader);
+
   while ((p = tSimpleHashIterate(pReader->status.pTableMap, p, &iter)) != NULL) {
     clearBlockScanInfo(*p);
   }
@@ -4593,12 +4598,14 @@ int32_t tsdbSetTableList2(STsdbReader* pReader, const void* pTableList, int32_t
   if (size < num) {
     code = ensureBlockScanInfoBuf(&pReader->blockInfoBuf, num);
     if (code) {
+      (void) tsdbReleaseReader(pReader);
       return code;
     }
 
     char* p1 = taosMemoryRealloc(pReader->status.uidList.tableUidList, sizeof(uint64_t) * num);
     if (p1 == NULL) {
-      return TSDB_CODE_OUT_OF_MEMORY;
+      (void) tsdbReleaseReader(pReader);
+      return terrno;
     }
 
     pReader->status.uidList.tableUidList = (uint64_t*)p1;
@@ -4615,16 +4622,19 @@ int32_t tsdbSetTableList2(STsdbReader* pReader, const void* pTableList, int32_t
     STableBlockScanInfo* pInfo = NULL;
     code = getPosInBlockInfoBuf(&pReader->blockInfoBuf, i, &pInfo);
     if (code != TSDB_CODE_SUCCESS) {
+      (void) tsdbReleaseReader(pReader);
       return code;
     }
 
     code = initTableBlockScanInfo(pInfo, pList[i].uid, pReader->status.pTableMap, pReader);
     if (code != TSDB_CODE_SUCCESS) {
+      (void) tsdbReleaseReader(pReader);
       return code;
     }
   }
 
-  return TDB_CODE_SUCCESS;
+  (void) tsdbReleaseReader(pReader);
+  return code;
 }
 
 uint64_t tsdbGetReaderMaxVersion2(STsdbReader* pReader) { return pReader->info.verRange.maxVer; }
@@ -5370,7 +5380,7 @@ int32_t tsdbRetrieveDatablockSMA2(STsdbReader* pReader, SSDataBlock* pDataBlock,
     return TSDB_CODE_SUCCESS;
   }
 
-  code = getCurrentBlockInfo(&pReader->status.blockIter, &pBlockInfo);
+  code = getCurrentBlockInfo(&pReader->status.blockIter, &pBlockInfo, pReader->idStr);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
@@ -5416,7 +5426,7 @@ int32_t tsdbRetrieveDatablockSMA2(STsdbReader* pReader, SSDataBlock* pDataBlock,
     size_t num = taosArrayGetSize(pResBlock->pDataBlock);
     pResBlock->pBlockAgg = taosMemoryCalloc(num, sizeof(SColumnDataAgg));
     if (pResBlock->pBlockAgg == NULL) {
-      return TSDB_CODE_OUT_OF_MEMORY;
+      return terrno;
     }
     for (int i = 0; i < num; ++i) {
       pResBlock->pBlockAgg[i].colId = -1;
@@ -5460,7 +5470,7 @@ static int32_t doRetrieveDataBlock(STsdbReader* pReader, SSDataBlock** pBlock) {
   SFileDataBlockInfo* pBlockInfo = NULL;
   *pBlock = NULL;
 
-  code = getCurrentBlockInfo(&pStatus->blockIter, &pBlockInfo);
+  code = getCurrentBlockInfo(&pStatus->blockIter, &pBlockInfo, pReader->idStr);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
@@ -5676,7 +5686,7 @@ int32_t tsdbGetFileBlocksDistInfo2(STsdbReader* pReader, STableBlockDistInfo* pT
   while (true) {
     if (hasNext) {
       SFileDataBlockInfo* pBlockInfo = NULL;
-      code = getCurrentBlockInfo(pBlockIter, &pBlockInfo);
+      code = getCurrentBlockInfo(pBlockIter, &pBlockInfo, pReader->idStr);
       if (code != TSDB_CODE_SUCCESS) {
         break;
       }

source/dnode/vnode/src/tsdb/tsdbReadUtil.c

@@ -38,7 +38,7 @@ static int32_t initBlockScanInfoBuf(SBlockInfoBuf* pBuf, int32_t numOfTables) {
   for (int32_t i = 0; i < num; ++i) {
     char* p = taosMemoryCalloc(pBuf->numPerBucket, sizeof(STableBlockScanInfo));
     if (p == NULL) {
-      return TSDB_CODE_OUT_OF_MEMORY;
+      return terrno;
     }
 
     void* px = taosArrayPush(pBuf->pData, &p);
@@ -50,7 +50,7 @@ static int32_t initBlockScanInfoBuf(SBlockInfoBuf* pBuf, int32_t numOfTables) {
   if (remainder > 0) {
     char* p = taosMemoryCalloc(remainder, sizeof(STableBlockScanInfo));
     if (p == NULL) {
-      return TSDB_CODE_OUT_OF_MEMORY;
+      return terrno;
     }
     void* px = taosArrayPush(pBuf->pData, &p);
     if (px == NULL) {
@@ -96,7 +96,7 @@ int32_t ensureBlockScanInfoBuf(SBlockInfoBuf* pBuf, int32_t numOfTables) {
   for (int32_t i = 0; i < num; ++i) {
     char* p = taosMemoryCalloc(pBuf->numPerBucket, sizeof(STableBlockScanInfo));
     if (p == NULL) {
-      return TSDB_CODE_OUT_OF_MEMORY;
+      return terrno;
     }
 
     void* px = taosArrayPush(pBuf->pData, &p);
@@ -108,7 +108,7 @@ int32_t ensureBlockScanInfoBuf(SBlockInfoBuf* pBuf, int32_t numOfTables) {
   if (remainder > 0) {
     char* p = taosMemoryCalloc(remainder, sizeof(STableBlockScanInfo));
     if (p == NULL) {
-      return TSDB_CODE_OUT_OF_MEMORY;
+      return terrno;
     }
     void* px = taosArrayPush(pBuf->pData, &p);
     if (px == NULL) {
@@ -231,7 +231,6 @@ int32_t initRowKey(SRowKey* pKey, int64_t ts, int32_t numOfPks, int32_t type, in
       pKey->pks[0].nData = 0;
 
       if (pKey->pks[0].pData == NULL) {
-        terrno = TSDB_CODE_OUT_OF_MEMORY;
         return terrno;
       }
 
@@ -526,12 +525,22 @@ static void cleanupBlockOrderSupporter(SBlockOrderSupporter* pSup) {
 
 static int32_t initBlockOrderSupporter(SBlockOrderSupporter* pSup, int32_t numOfTables) {
   pSup->numOfBlocksPerTable = taosMemoryCalloc(1, sizeof(int32_t) * numOfTables);
-  pSup->indexPerTable = taosMemoryCalloc(1, sizeof(int32_t) * numOfTables);
+  if(pSup->numOfBlocksPerTable == NULL) {
-  pSup->pDataBlockInfo = taosMemoryCalloc(1, POINTER_BYTES * numOfTables);
-
-  if (pSup->numOfBlocksPerTable == NULL || pSup->indexPerTable == NULL || pSup->pDataBlockInfo == NULL) {
     cleanupBlockOrderSupporter(pSup);
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
+  }
+  pSup->indexPerTable = taosMemoryCalloc(1, sizeof(int32_t) * numOfTables);
+  if(pSup->indexPerTable == NULL) {
+    taosMemoryFree(pSup->numOfBlocksPerTable);
+    cleanupBlockOrderSupporter(pSup);
+    return terrno;
+  }
+  pSup->pDataBlockInfo = taosMemoryCalloc(1, POINTER_BYTES * numOfTables);
+  if (pSup->pDataBlockInfo == NULL) {
+    cleanupBlockOrderSupporter(pSup);
+    taosMemoryFree(pSup->numOfBlocksPerTable);
+    taosMemoryFree(pSup->indexPerTable);
+    return terrno;
   }
 
   return TSDB_CODE_SUCCESS;

source/dnode/vnode/src/tsdb/tsdbReaderWriter.c

@@ -60,7 +60,7 @@ static int32_t tsdbOpenFileImpl(STsdbFD *pFD) {
 
   pFD->pBuf = taosMemoryCalloc(1, szPage);
   if (pFD->pBuf == NULL) {
-    TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
+    TSDB_CHECK_CODE(code = terrno, lino, _exit);
   }
 
   if (lc_size > 0) {
@@ -100,7 +100,7 @@ int32_t tsdbOpenFile(const char *path, STsdb *pTsdb, int32_t flag, STsdbFD **ppF
 
   pFD = (STsdbFD *)taosMemoryCalloc(1, sizeof(*pFD) + strlen(path) + 1);
   if (pFD == NULL) {
-    TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
+    TSDB_CHECK_CODE(code = terrno, lino, _exit);
   }
 
   pFD->path = (char *)&pFD[1];
@@ -363,7 +363,7 @@ static int32_t tsdbReadFileBlock(STsdbFD *pFD, int64_t offset, int64_t size, boo
 
   buf = taosMemoryCalloc(1, size);
   if (buf == NULL) {
-    TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
+    TSDB_CHECK_CODE(code = terrno, lino, _exit);
   }
 
   for (int32_t chunkno = offset / chunksize + 1; n < size; ++chunkno) {
@@ -587,7 +587,7 @@ int32_t tsdbDataFReaderOpen(SDataFReader **ppReader, STsdb *pTsdb, SDFileSet *pS
   // alloc
   pReader = (SDataFReader *)taosMemoryCalloc(1, sizeof(*pReader));
   if (pReader == NULL) {
-    TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
+    TSDB_CHECK_CODE(code = terrno, lino, _exit);
   }
   pReader->pTsdb = pTsdb;
   pReader->pSet = pSet;
@@ -794,7 +794,7 @@ int32_t tsdbDelFReaderOpen(SDelFReader **ppReader, SDelFile *pFile, STsdb *pTsdb
   // alloc
   pDelFReader = (SDelFReader *)taosMemoryCalloc(1, sizeof(*pDelFReader));
   if (pDelFReader == NULL) {
-    TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
+    TSDB_CHECK_CODE(code = terrno, lino, _exit);
   }
 
   // open impl

source/dnode/vnode/src/tsdb/tsdbSnapshot.c

@@ -416,7 +416,7 @@ int32_t tsdbSnapReaderOpen(STsdb* tsdb, int64_t sver, int64_t ever, int8_t type,
   int32_t lino = 0;
 
   reader[0] = (STsdbSnapReader*)taosMemoryCalloc(1, sizeof(*reader[0]));
-  if (reader[0] == NULL) return TSDB_CODE_OUT_OF_MEMORY;
+  if (reader[0] == NULL) return terrno;
 
   reader[0]->tsdb = tsdb;
   reader[0]->sver = sver;
@@ -1047,7 +1047,7 @@ int32_t tsdbSnapWriterOpen(STsdb* pTsdb, int64_t sver, int64_t ever, void* pRang
 
   // start to write
   writer[0] = taosMemoryCalloc(1, sizeof(*writer[0]));
-  if (writer[0] == NULL) return TSDB_CODE_OUT_OF_MEMORY;
+  if (writer[0] == NULL) return terrno;
 
   writer[0]->tsdb = pTsdb;
   writer[0]->sver = sver;

source/dnode/vnode/src/tsdb/tsdbSnapshotRAW.c

@@ -52,7 +52,7 @@ int32_t tsdbSnapRAWReaderOpen(STsdb* tsdb, int64_t ever, int8_t type, STsdbSnapR
   int32_t lino = 0;
 
   reader[0] = taosMemoryCalloc(1, sizeof(STsdbSnapRAWReader));
-  if (reader[0] == NULL) return TSDB_CODE_OUT_OF_MEMORY;
+  if (reader[0] == NULL) return terrno;
 
   reader[0]->tsdb = tsdb;
   reader[0]->ever = ever;
@@ -196,7 +196,7 @@ static int32_t tsdbSnapRAWReadNext(STsdbSnapRAWReader* reader, SSnapDataHdr** pp
 
   void* pBuf = taosMemoryCalloc(1, sizeof(SSnapDataHdr) + sizeof(STsdbDataRAWBlockHeader) + dataLength);
   if (pBuf == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     TSDB_CHECK_CODE(code, lino, _exit);
   }
   SSnapDataHdr* pHdr = pBuf;
@@ -343,7 +343,7 @@ int32_t tsdbSnapRAWWriterOpen(STsdb* pTsdb, int64_t ever, STsdbSnapRAWWriter** w
 
   // start to write
   writer[0] = taosMemoryCalloc(1, sizeof(*writer[0]));
-  if (writer[0] == NULL) return TSDB_CODE_OUT_OF_MEMORY;
+  if (writer[0] == NULL) return terrno;
 
   writer[0]->tsdb = pTsdb;
   writer[0]->ever = ever;

source/dnode/vnode/src/tsdb/tsdbSttFileRW.c

@@ -41,7 +41,7 @@ int32_t tsdbSttFileReaderOpen(const char *fname, const SSttFileReaderConfig *con
 
   reader[0] = taosMemoryCalloc(1, sizeof(*reader[0]));
   if (reader[0] == NULL) {
-    TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit);
+    TAOS_CHECK_GOTO(terrno, &lino, _exit);
   }
 
   reader[0]->config[0] = config[0];
@@ -897,7 +897,7 @@ static int32_t tsdbSttFWriterCloseAbort(SSttFileWriter *writer) {
 int32_t tsdbSttFileWriterOpen(const SSttFileWriterConfig *config, SSttFileWriter **writer) {
   writer[0] = taosMemoryCalloc(1, sizeof(*writer[0]));
   if (writer[0] == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   writer[0]->config[0] = config[0];

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

@@ -326,7 +326,7 @@ static int32_t vnodeAsyncInit(SVAsync **async, const char *label) {
 
   (*async) = (SVAsync *)taosMemoryCalloc(1, sizeof(SVAsync) + strlen(label) + 1);
   if ((*async) == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   strcpy((char *)((*async) + 1), label);
@@ -480,7 +480,7 @@ int32_t vnodeAsync(SVAChannelID *channelID, EVAPriority priority, int32_t (*exec
   // create task object
   SVATask *task = (SVATask *)taosMemoryCalloc(1, sizeof(SVATask));
   if (task == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   task->priority = priority;

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

@@ -372,7 +372,7 @@ int vnodeAsyncCommit(SVnode *pVnode) {
 
   SCommitInfo *pInfo = (SCommitInfo *)taosMemoryCalloc(1, sizeof(*pInfo));
   if (NULL == pInfo) {
-    TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
+    TSDB_CHECK_CODE(code = terrno, lino, _exit);
   }
 
   // prepare to commit

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

@@ -27,7 +27,7 @@ struct SVHashEntry {
 static int32_t vHashRehash(SVHashTable* ht, uint32_t newNumBuckets) {
   SVHashEntry** newBuckets = (SVHashEntry**)taosMemoryCalloc(newNumBuckets, sizeof(SVHashEntry*));
   if (newBuckets == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   for (int32_t i = 0; i < ht->numBuckets; i++) {
@@ -65,7 +65,7 @@ int32_t vHashInit(SVHashTable** ht, uint32_t (*hash)(const void*), int32_t (*com
   (*ht)->buckets = (SVHashEntry**)taosMemoryCalloc((*ht)->numBuckets, sizeof(SVHashEntry*));
   if ((*ht)->buckets == NULL) {
     taosMemoryFree(*ht);
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   return 0;

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

@@ -118,7 +118,7 @@ int32_t vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
   metaRsp.pSchemas = (SSchema *)taosMemoryMalloc(sizeof(SSchema) * (metaRsp.numOfColumns + metaRsp.numOfTags));
   metaRsp.pSchemaExt = (SSchemaExt *)taosMemoryCalloc(metaRsp.numOfColumns, sizeof(SSchemaExt));
   if (NULL == metaRsp.pSchemas || NULL == metaRsp.pSchemaExt) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _exit;
   }
   (void)memcpy(metaRsp.pSchemas, schema.pSchema, sizeof(SSchema) * schema.nCols);
@@ -150,7 +150,7 @@ int32_t vnodeGetTableMeta(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
   }
 
   if (pRsp == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _exit;
   }
 
@@ -309,7 +309,7 @@ int32_t vnodeGetTableCfg(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
   }
 
   if (pRsp == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _exit;
   }
 
@@ -869,7 +869,7 @@ int32_t vnodeGetStreamProgress(SVnode *pVnode, SRpcMsg *pMsg, bool direct) {
       buf = taosMemoryCalloc(1, rspLen);
     }
     if (!buf) {
-      code = TSDB_CODE_OUT_OF_MEMORY;
+      code = terrno;
       goto _OVER;
     }
   }

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

@@ -166,7 +166,7 @@ int32_t vnodeSnapReaderOpen(SVnode *pVnode, SSnapshotParam *pParam, SVSnapReader
 
   pReader = (SVSnapReader *)taosMemoryCalloc(1, sizeof(*pReader));
   if (pReader == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _exit;
   }
   pReader->pVnode = pVnode;
@@ -617,7 +617,7 @@ int32_t vnodeSnapWriterOpen(SVnode *pVnode, SSnapshotParam *pParam, SVSnapWriter
   // alloc
   pWriter = (SVSnapWriter *)taosMemoryCalloc(1, sizeof(*pWriter));
   if (pWriter == NULL) {
-    TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
+    TSDB_CHECK_CODE(code = terrno, lino, _exit);
   }
   pWriter->pVnode = pVnode;
   pWriter->sver = sver;

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

@@ -1527,7 +1527,7 @@ static int32_t vnodeResetTableCxt(SMeta *pMeta, SSubmitReqConvertCxt *pCxt) {
   if (NULL == pCxt->pTbData) {
     pCxt->pTbData = taosMemoryCalloc(1, sizeof(SSubmitTbData));
     if (NULL == pCxt->pTbData) {
-      return TSDB_CODE_OUT_OF_MEMORY;
+      return terrno;
     }
   }
   pCxt->pTbData->flags = 0;
@@ -1610,7 +1610,7 @@ static int32_t vnodeDecodeCreateTbReq(SSubmitReqConvertCxt *pCxt) {
 
   pCxt->pTbData->pCreateTbReq = taosMemoryCalloc(1, sizeof(SVCreateTbReq));
   if (NULL == pCxt->pTbData->pCreateTbReq) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   SDecoder decoder = {0};

source/libs/executor/inc/operator.h

@@ -27,11 +27,8 @@ typedef struct SOperatorCostInfo {
 
 struct SOperatorInfo;
 
-//typedef int32_t (*__optr_encode_fn_t)(struct SOperatorInfo* pOperator, char** result, int32_t* length);
-//typedef int32_t (*__optr_decode_fn_t)(struct SOperatorInfo* pOperator, char* result);
-
 typedef int32_t (*__optr_open_fn_t)(struct SOperatorInfo* pOptr);
-typedef SSDataBlock* (*__optr_fn_t)(struct SOperatorInfo* pOptr);
+typedef int32_t (*__optr_fn_t)(struct SOperatorInfo* pOptr, SSDataBlock** pResBlock);
 typedef void (*__optr_close_fn_t)(void* param);
 typedef int32_t (*__optr_explain_fn_t)(struct SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len);
 typedef int32_t (*__optr_reqBuf_fn_t)(struct SOperatorInfo* pOptr);

source/libs/executor/src/aggregateoperator.c

@@ -56,9 +56,8 @@ static void setExecutionContext(SOperatorInfo* pOperator, int32_t numOfOutput, u
 static int32_t createDataBlockForEmptyInput(SOperatorInfo* pOperator, SSDataBlock** ppBlock);
 static void    destroyDataBlockForEmptyInput(bool blockAllocated, SSDataBlock** ppBlock);
 
-static int32_t      doAggregateImpl(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx);
+static int32_t doAggregateImpl(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx);
-static SSDataBlock* getAggregateResult(SOperatorInfo* pOperator);
+static int32_t getAggregateResultNext(SOperatorInfo* pOperator, SSDataBlock** ppRes);
-
 static int32_t doInitAggInfoSup(SAggSupporter* pAggSup, SqlFunctionCtx* pCtx, int32_t numOfOutput, size_t keyBufSize,
                                 const char* pKey);
 
@@ -123,7 +122,7 @@ int32_t createAggregateOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pA
 
   setOperatorInfo(pOperator, "TableAggregate", QUERY_NODE_PHYSICAL_PLAN_HASH_AGG,
                   !pAggNode->node.forceCreateNonBlockingOptr, OP_NOT_OPENED, pInfo, pTaskInfo);
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, getAggregateResult, NULL, destroyAggOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, getAggregateResultNext, NULL, destroyAggOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
 
   if (downstream->operatorType == QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN) {

source/libs/executor/src/cachescanoperator.c

@@ -50,7 +50,7 @@ typedef struct SCacheRowsScanInfo {
   SColumnInfo     pkCol;
 } SCacheRowsScanInfo;
 
-static SSDataBlock* doScanCache(SOperatorInfo* pOperator);
+static int32_t doScanCacheNext(SOperatorInfo* pOperator, SSDataBlock** ppRes);
 static void    destroyCacheScanOperator(void* param);
 static int32_t extractCacheScanSlotId(const SArray* pColMatchInfo, SExecTaskInfo* pTaskInfo, int32_t** pSlotIds,
                                       int32_t** pDstSlotIds);
@@ -235,7 +235,7 @@ int32_t createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SReadHandl
                   pInfo, pTaskInfo);
   pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock);
 
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doScanCache, NULL, destroyCacheScanOperator, optrDefaultBufFn,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doScanCacheNext, NULL, destroyCacheScanOperator, optrDefaultBufFn,
                                          NULL, optrDefaultGetNextExtFn, NULL);
 
   pOperator->cost.openCost = 0;
@@ -259,7 +259,7 @@ _error:
   return code;
 }
 
-int32_t doScanCacheNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
+static int32_t doScanCacheNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
   int32_t code = TSDB_CODE_SUCCESS;
   int32_t lino = 0;
   if (pOperator->status == OP_EXEC_DONE) {
@@ -445,12 +445,6 @@ _end:
   return code;
 }
 
-static SSDataBlock* doScanCache(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t      code = doScanCacheNext(pOperator, &pRes);
-  return pRes;
-}
-
 void destroyCacheScanOperator(void* param) {
   SCacheRowsScanInfo* pInfo = (SCacheRowsScanInfo*)param;
   blockDataDestroy(pInfo->pRes);

source/libs/executor/src/countwindowoperator.c

@@ -64,6 +64,8 @@ void destroyCountWindowOperatorInfo(void* param) {
   taosMemoryFreeClear(param);
 }
 
+static int32_t countWindowAggregateNext(SOperatorInfo* pOperator, SSDataBlock** ppRes);
+
 static void clearWinStateBuff(SCountWindowResult* pBuff) { pBuff->winRows = 0; }
 
 static SCountWindowResult* getCountWinStateInfo(SCountWindowSupp* pCountSup) {
@@ -227,7 +229,6 @@ static int32_t countWindowAggregateNext(SOperatorInfo* pOperator, SSDataBlock**
   SExprSupp*                pExprSup = &pOperator->exprSupp;
   int32_t                   order = pInfo->binfo.inputTsOrder;
   SSDataBlock*              pRes = pInfo->binfo.pRes;
-  SOperatorInfo*            downstream = pOperator->pDownstream[0];
 
   blockDataCleanup(pRes);
 
@@ -292,12 +293,6 @@ _end:
   return code;
 }
 
-static SSDataBlock* countWindowAggregate(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t code = countWindowAggregateNext(pOperator, &pRes);
-  return pRes;
-}
-
 int32_t createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* physiNode,
                                              SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {
   QRY_OPTR_CHECK(pOptrInfo);
@@ -374,7 +369,7 @@ int32_t createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* phy
 
   setOperatorInfo(pOperator, "CountWindowOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT, true, OP_NOT_OPENED, pInfo,
                   pTaskInfo);
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, countWindowAggregate, NULL, destroyCountWindowOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, countWindowAggregateNext, NULL, destroyCountWindowOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
 
   code = appendDownstream(pOperator, &downstream, 1);

source/libs/executor/src/dynqueryctrloperator.c

@@ -878,20 +878,20 @@ static int32_t seqJoinLaunchNewRetrieve(SOperatorInfo* pOperator, SSDataBlock**
   return TSDB_CODE_SUCCESS;
 }
 
-static FORCE_INLINE SSDataBlock* seqStableJoinComposeRes(SStbJoinDynCtrlInfo*        pStbJoin, SSDataBlock* pBlock) {
+static FORCE_INLINE void seqStableJoinComposeRes(SStbJoinDynCtrlInfo* pStbJoin, SSDataBlock* pBlock) {
-  pBlock->info.id.blockId = pStbJoin->outputBlkId;
+  if (pBlock != NULL) {
-  return pBlock;
+    pBlock->info.id.blockId = pStbJoin->outputBlkId;
+  }
 }
 
-
+int32_t seqStableJoin(SOperatorInfo* pOperator, SSDataBlock** pRes) {
-SSDataBlock* seqStableJoin(SOperatorInfo* pOperator) {
+  int32_t                    code = TSDB_CODE_SUCCESS;
-  int32_t code = TSDB_CODE_SUCCESS;
   SDynQueryCtrlOperatorInfo* pInfo = pOperator->info;
   SStbJoinDynCtrlInfo*       pStbJoin = (SStbJoinDynCtrlInfo*)&pInfo->stbJoin;
-  SSDataBlock* pRes = NULL;
 
+  QRY_OPTR_CHECK(pRes);
   if (pOperator->status == OP_EXEC_DONE) {
-    return pRes;
+    return code;
   }
 
   int64_t st = 0;
@@ -907,25 +907,24 @@ SSDataBlock* seqStableJoin(SOperatorInfo* pOperator) {
     }
   }
 
-  QRY_ERR_JRET(seqJoinContinueCurrRetrieve(pOperator, &pRes));
+  QRY_ERR_JRET(seqJoinContinueCurrRetrieve(pOperator, pRes));
-  if (pRes) {
+  if (*pRes) {
     goto _return;
   }
-  
+
-  QRY_ERR_JRET(seqJoinLaunchNewRetrieve(pOperator, &pRes));
+  QRY_ERR_JRET(seqJoinLaunchNewRetrieve(pOperator, pRes));
 
 _return:
-
   if (pOperator->cost.openCost == 0) {
     pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0;
   }
 
   if (code) {
     pOperator->pTaskInfo->code = code;
-    T_LONG_JMP(pOperator->pTaskInfo->env, pOperator->pTaskInfo->code);
+  } else {
+    seqStableJoinComposeRes(pStbJoin, *pRes);
   }
-  
+  return code;
-  return pRes ? seqStableJoinComposeRes(pStbJoin, pRes) : NULL;
 }
 
 int32_t initSeqStbJoinTableHash(SStbJoinPrevJoinCtx* pPrev, bool batchFetch) {

source/libs/executor/src/eventwindowoperator.c

@@ -39,9 +39,9 @@ typedef struct SEventWindowOperatorInfo {
   SSDataBlock*       pPreDataBlock;
 } SEventWindowOperatorInfo;
 
-static SSDataBlock* eventWindowAggregate(SOperatorInfo* pOperator);
+static int32_t eventWindowAggregateNext(SOperatorInfo* pOperator, SSDataBlock** pRes);
-static void         destroyEWindowOperatorInfo(void* param);
+static void    destroyEWindowOperatorInfo(void* param);
-static int32_t      eventWindowAggImpl(SOperatorInfo* pOperator, SEventWindowOperatorInfo* pInfo, SSDataBlock* pBlock);
+static int32_t eventWindowAggImpl(SOperatorInfo* pOperator, SEventWindowOperatorInfo* pInfo, SSDataBlock* pBlock);
 
 // todo : move to  util
 static void doKeepNewWindowStartInfo(SWindowRowsSup* pRowSup, const int64_t* tsList, int32_t rowIndex,
@@ -131,7 +131,7 @@ int32_t createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* phy
 
   setOperatorInfo(pOperator, "EventWindowOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE, true, OP_NOT_OPENED, pInfo,
                   pTaskInfo);
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, eventWindowAggregate, NULL, destroyEWindowOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, eventWindowAggregateNext, NULL, destroyEWindowOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
 
   code = appendDownstream(pOperator, &downstream, 1);
@@ -250,12 +250,6 @@ _end:
   return code;
 }
 
-static SSDataBlock* eventWindowAggregate(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t code = eventWindowAggregateNext(pOperator, &pRes);
-  return pRes;
-}
-
 static int32_t setSingleOutputTupleBufv1(SResultRowInfo* pResultRowInfo, STimeWindow* win, SResultRow** pResult,
                                          SExprSupp* pExprSup, SAggSupporter* pAggSup) {
   if (*pResult == NULL) {

source/libs/executor/src/exchangeoperator.c

@@ -305,12 +305,6 @@ _end:
   return code;
 }
 
-static SSDataBlock* loadRemoteData(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t      code = loadRemoteDataNext(pOperator, &pRes);
-  return pRes;
-}
-
 static int32_t initDataSource(int32_t numOfSources, SExchangeInfo* pInfo, const char* id) {
   pInfo->pSourceDataInfo = taosArrayInit(numOfSources, sizeof(SSourceDataInfo));
   if (pInfo->pSourceDataInfo == NULL) {
@@ -447,7 +441,7 @@ int32_t createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode* pExNo
   code = filterInitFromNode((SNode*)pExNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
   QUERY_CHECK_CODE(code, lino, _error);
 
-  pOperator->fpSet = createOperatorFpSet(prepareLoadRemoteData, loadRemoteData, NULL, destroyExchangeOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(prepareLoadRemoteData, loadRemoteDataNext, NULL, destroyExchangeOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   *pOptrInfo = pOperator;
   return code;
@@ -465,7 +459,6 @@ _error:
     pOperator->info = NULL;
     destroyOperator(pOperator);
   }
-  pTaskInfo->code = code;
   return code;
 }
 

source/libs/executor/src/executil.c

@@ -435,6 +435,7 @@ int32_t isQualifiedTable(STableKeyInfo* info, SNode* pTagCond, void* metaHandle,
   code = nodesCloneNode(pTagCond, &pTagCondTmp);
   if (TSDB_CODE_SUCCESS != code) {
     *pQualified = false;
+    pAPI->metaReaderFn.clearReader(&mr);
     return code;
   }
   STransTagExprCtx ctx = {.code = 0, .pReader = &mr};
@@ -1746,6 +1747,8 @@ static SColumn* createColumn(int32_t blockId, int32_t slotId, int32_t colId, SDa
 int32_t createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
   int32_t code = TSDB_CODE_SUCCESS;
   int32_t lino = 0;
+  pExp->base.numOfParams = 0;
+  pExp->base.pParam = NULL;
   pExp->pExpr = taosMemoryCalloc(1, sizeof(tExprNode));
   QUERY_CHECK_NULL(pExp->pExpr, code, lino, _end, terrno);
 
@@ -1786,6 +1789,7 @@ int32_t createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
         createResSchema(pType->type, pType->bytes, slotId, pType->scale, pType->precision, pValNode->node.aliasName);
     pExp->base.pParam[0].type = FUNC_PARAM_TYPE_VALUE;
     code = nodesValueNodeToVariant(pValNode, &pExp->base.pParam[0].param);
+    QUERY_CHECK_CODE(code, lino, _end);
   } else if (type == QUERY_NODE_FUNCTION) {
     pExp->pExpr->nodeType = QUERY_NODE_FUNCTION;
     SFunctionNode* pFuncNode = (SFunctionNode*)pNode;

source/libs/executor/src/executor.c

@@ -372,11 +372,11 @@ static int32_t filterUnqualifiedTables(const SStreamScanInfo* pScanInfo, const S
   int32_t code = TSDB_CODE_SUCCESS;
   int32_t lino = 0;
   SArray* qa = taosArrayInit(4, sizeof(tb_uid_t));
-  QUERY_CHECK_NULL(qa, code, lino, _end, terrno);
+  QUERY_CHECK_NULL(qa, code, lino, _error, terrno);
   int32_t numOfUids = taosArrayGetSize(tableIdList);
   if (numOfUids == 0) {
     (*ppArrayRes) = qa;
-    goto _end;
+    goto _error;
   }
 
   STableScanInfo* pTableScanInfo = pScanInfo->pTableScanOp->info;
@@ -437,10 +437,11 @@ static int32_t filterUnqualifiedTables(const SStreamScanInfo* pScanInfo, const S
     QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);
   }
 
+_end:
   pAPI->metaReaderFn.clearReader(&mr);
   (*ppArrayRes) = qa;
 
-_end:
+_error:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
   }
@@ -692,9 +693,11 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo
     pTaskInfo->paramSet = true;
     code = pTaskInfo->pRoot->fpSet.getNextExtFn(pTaskInfo->pRoot, pTaskInfo->pOpParam, &pRes);
   } else {
-    pRes = pTaskInfo->pRoot->fpSet.getNextFn(pTaskInfo->pRoot);
+    code = pTaskInfo->pRoot->fpSet.getNextFn(pTaskInfo->pRoot, &pRes);
   }
 
+  QUERY_CHECK_CODE(code, lino, _end);
+
   if (pRes == NULL) {
     st = taosGetTimestampUs();
   }
@@ -718,6 +721,7 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo
     } else {
       void* tmp = taosArrayGet(pTaskInfo->pResultBlockList, blockIndex);
       QUERY_CHECK_NULL(tmp, code, lino, _end, terrno);
+
       p = *(SSDataBlock**)tmp;
       code = copyDataBlock(p, pRes);
       QUERY_CHECK_CODE(code, lino, _end);
@@ -735,8 +739,10 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo
       break;
     }
 
-    pRes = pTaskInfo->pRoot->fpSet.getNextFn(pTaskInfo->pRoot);
+    code = pTaskInfo->pRoot->fpSet.getNextFn(pTaskInfo->pRoot, &pRes);
+    QUERY_CHECK_CODE(code, lino, _end);
   }
+
   if (pTaskInfo->pSubplan->dynamicRowThreshold) {
     pTaskInfo->pSubplan->rowsThreshold -= current;
   }
@@ -750,7 +756,6 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo
   }
 
 _end:
-
   (void)cleanUpUdfs();
 
   uint64_t total = pTaskInfo->pRoot->resultInfo.totalRows;
@@ -758,6 +763,11 @@ _end:
          GET_TASKID(pTaskInfo), current, (int32_t)taosArrayGetSize(pResList), total, 0, el / 1000.0);
 
   atomic_store_64(&pTaskInfo->owner, 0);
+  if (code) {
+    pTaskInfo->code = code;
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+
   return pTaskInfo->code;
 }
 
@@ -778,9 +788,10 @@ void qCleanExecTaskBlockBuf(qTaskInfo_t tinfo) {
 int32_t qExecTask(qTaskInfo_t tinfo, SSDataBlock** pRes, uint64_t* useconds) {
   SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo;
   int64_t        threadId = taosGetSelfPthreadId();
+  int32_t        lino = 0;
+  int64_t        curOwner = 0;
 
   *pRes = NULL;
-  int64_t curOwner = 0;
 
   // todo extract method
   taosRLockLatch(&pTaskInfo->lock);
@@ -822,7 +833,12 @@ int32_t qExecTask(qTaskInfo_t tinfo, SSDataBlock** pRes, uint64_t* useconds) {
 
   int64_t st = taosGetTimestampUs();
 
-  *pRes = pTaskInfo->pRoot->fpSet.getNextFn(pTaskInfo->pRoot);
+  int32_t code = pTaskInfo->pRoot->fpSet.getNextFn(pTaskInfo->pRoot, pRes);
+  if (code) {
+    pTaskInfo->code = code;
+    qError("%s failed at line %d, code:%s %s", __func__, lino, tstrerror(code), GET_TASKID(pTaskInfo));
+  }
+
   uint64_t el = (taosGetTimestampUs() - st);
 
   pTaskInfo->cost.elapsedTime += el;
@@ -830,8 +846,7 @@ int32_t qExecTask(qTaskInfo_t tinfo, SSDataBlock** pRes, uint64_t* useconds) {
     *useconds = pTaskInfo->cost.elapsedTime;
   }
 
-  int32_t tmpRes = cleanUpUdfs();
+  (void) cleanUpUdfs();
-  qTrace("%s at line %d res:%d", __func__, __LINE__, tmpRes);
 
   int32_t  current = (*pRes != NULL) ? (*pRes)->info.rows : 0;
   uint64_t total = pTaskInfo->pRoot->resultInfo.totalRows;

source/libs/executor/src/executorInt.c

@@ -1291,12 +1291,8 @@ FORCE_INLINE int32_t getNextBlockFromDownstreamImpl(struct SOperatorInfo* pOpera
     return code;
   }
 
-  *pResBlock = pOperator->pDownstream[idx]->fpSet.getNextFn(pOperator->pDownstream[idx]);
+  code = pOperator->pDownstream[idx]->fpSet.getNextFn(pOperator->pDownstream[idx], pResBlock);
-  if (*pResBlock == NULL && terrno != 0) {
+  return code;
-    return terrno;
-  } else {
-    return code;
-  }
 }
 
 bool compareVal(const char* v, const SStateKeys* pKey) {

source/libs/executor/src/filloperator.c

@@ -318,12 +318,6 @@ static int32_t doFillNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
   return code;
 }
 
-static SSDataBlock* doFill(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t      code = doFillNext(pOperator, &pRes);
-  return pRes;
-}
-
 void destroyFillOperatorInfo(void* param) {
   SFillOperatorInfo* pInfo = (SFillOperatorInfo*)param;
   pInfo->pFillInfo = taosDestroyFillInfo(pInfo->pFillInfo);
@@ -513,7 +507,7 @@ int32_t createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* pPhyFi
   }
 
   setOperatorInfo(pOperator, "FillOperator", QUERY_NODE_PHYSICAL_PLAN_FILL, false, OP_NOT_OPENED, pInfo, pTaskInfo);
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doFill, NULL, destroyFillOperatorInfo, optrDefaultBufFn, NULL,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doFillNext, NULL, destroyFillOperatorInfo, optrDefaultBufFn, NULL,
                                          optrDefaultGetNextExtFn, NULL);
 
   code = appendDownstream(pOperator, &downstream, 1);
@@ -522,6 +516,9 @@ int32_t createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* pPhyFi
   return code;
 
 _error:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
   if (pInfo != NULL) {
     destroyFillOperatorInfo(pInfo);
   }

source/libs/executor/src/groupcacheoperator.c

@@ -692,39 +692,48 @@ _return:
   return code;
 }
 
-static FORCE_INLINE int32_t getBlkFromDownstreamOperator(struct SOperatorInfo* pOperator, int32_t downstreamIdx, SSDataBlock** ppRes) {
+static FORCE_INLINE int32_t getBlkFromDownstreamOperator(struct SOperatorInfo* pOperator, int32_t downstreamIdx,
-  int32_t code = TSDB_CODE_SUCCESS;
+                                                         SSDataBlock** ppRes) {
-  SOperatorParam* pDownstreamParam = NULL;
+  int32_t                  code = TSDB_CODE_SUCCESS;
-  SSDataBlock* pBlock = NULL;
+  SOperatorParam*          pDownstreamParam = NULL;
+  SSDataBlock*             pBlock = NULL;
   SGroupCacheOperatorInfo* pGCache = pOperator->info;
+
   code = appendNewGroupToDownstream(pOperator, downstreamIdx, &pDownstreamParam);
   if (code) {
     return code;
   }
 
+  SOperatorInfo* pDownstream = pOperator->pDownstream[downstreamIdx];
   if (pDownstreamParam) {
-    code = pOperator->pDownstream[downstreamIdx]->fpSet.getNextExtFn(pOperator->pDownstream[downstreamIdx], pDownstreamParam, &pBlock);
+    code = pDownstream->fpSet.getNextExtFn(pDownstream, pDownstreamParam, &pBlock);
   } else {
-    pBlock = pOperator->pDownstream[downstreamIdx]->fpSet.getNextFn(pOperator->pDownstream[downstreamIdx]);
+    code = pDownstream->fpSet.getNextFn(pDownstream, &pBlock);
+  }
+
+  if (code) {
+    qError("failed to get block from downstream, code:%s %s", tstrerror(code), GET_TASKID(pOperator->pTaskInfo));
+    return code;
   }
 
   if (pBlock) {
-    qDebug("%s blk retrieved from group %" PRIu64, GET_TASKID(pOperator->pTaskInfo), pBlock->info.id.groupId);
+    qDebug("%s res block retrieved from group %" PRIu64, GET_TASKID(pOperator->pTaskInfo), pBlock->info.id.groupId);
-    
+
     pGCache->execInfo.pDownstreamBlkNum[downstreamIdx]++;
     if (NULL == pGCache->pDownstreams[downstreamIdx].pBaseBlock) {
       code = buildGroupCacheBaseBlock(&pGCache->pDownstreams[downstreamIdx].pBaseBlock, pBlock);
       if (code) {
         return code;
       }
-      if (NULL == taosArrayPush(pGCache->pDownstreams[downstreamIdx].pFreeBlock, &pGCache->pDownstreams[downstreamIdx].pBaseBlock)) {
+
+      if (NULL == taosArrayPush(pGCache->pDownstreams[downstreamIdx].pFreeBlock,
+                                &pGCache->pDownstreams[downstreamIdx].pBaseBlock)) {
         QRY_ERR_RET(terrno);
       }
     }
   }
 
   *ppRes = pBlock;
-  
   return code;
 }
 

source/libs/executor/src/groupoperator.c

@@ -531,12 +531,6 @@ _end:
   return code;
 }
 
-static SSDataBlock* hashGroupbyAggregate(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t code = hashGroupbyAggregateNext(pOperator, &pRes);
-  return pRes;
-}
-
 int32_t createGroupOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pAggNode, SExecTaskInfo* pTaskInfo,
                                 SOperatorInfo** pOptrInfo) {
   QRY_OPTR_CHECK(pOptrInfo);
@@ -600,7 +594,7 @@ int32_t createGroupOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pAggNo
   pInfo->binfo.inputTsOrder = pAggNode->node.inputTsOrder;
   pInfo->binfo.outputTsOrder = pAggNode->node.outputTsOrder;
 
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, hashGroupbyAggregate, NULL, destroyGroupOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, hashGroupbyAggregateNext, NULL, destroyGroupOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   code = appendDownstream(pOperator, &downstream, 1);
   QUERY_CHECK_CODE(code, lino, _error);
@@ -1103,12 +1097,6 @@ _end:
   return code;
 }
 
-static SSDataBlock* hashPartition(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t code = hashPartitionNext(pOperator, &pRes);
-  return pRes;
-}
-
 static void destroyPartitionOperatorInfo(void* param) {
   SPartitionOperatorInfo* pInfo = (SPartitionOperatorInfo*)param;
   cleanupBasicInfo(&pInfo->binfo);
@@ -1232,7 +1220,7 @@ int32_t createPartitionOperatorInfo(SOperatorInfo* downstream, SPartitionPhysiNo
   setOperatorInfo(pOperator, "PartitionOperator", QUERY_NODE_PHYSICAL_PLAN_PARTITION, false, OP_NOT_OPENED, pInfo,
                   pTaskInfo);
 
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, hashPartition, NULL, destroyPartitionOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, hashPartitionNext, NULL, destroyPartitionOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
 
   code = appendDownstream(pOperator, &downstream, 1);
@@ -1583,12 +1571,6 @@ _end:
   return code;
 }
 
-static SSDataBlock* doStreamHashPartition(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t code = doStreamHashPartitionNext(pOperator, &pRes);
-  return pRes;
-}
-
 static void destroyStreamPartitionOperatorInfo(void* param) {
   SStreamPartitionOperatorInfo* pInfo = (SStreamPartitionOperatorInfo*)param;
   cleanupBasicInfo(&pInfo->binfo);
@@ -1785,7 +1767,7 @@ int32_t createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStreamPart
   pOperator->exprSupp.numOfExprs = numOfCols;
   pOperator->exprSupp.pExprInfo = pExprInfo;
   pOperator->fpSet =
-      createOperatorFpSet(optrDummyOpenFn, doStreamHashPartition, NULL, destroyStreamPartitionOperatorInfo,
+      createOperatorFpSet(optrDummyOpenFn, doStreamHashPartitionNext, NULL, destroyStreamPartitionOperatorInfo,
                           optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   setOperatorStreamStateFn(pOperator, streamOpReleaseState, streamOpReloadState);
 

source/libs/executor/src/hashjoinoperator.c

@@ -989,13 +989,14 @@ void hJoinSetDone(struct SOperatorInfo* pOperator) {
   qDebug("hash Join done");  
 }
 
-static SSDataBlock* hJoinMainProcess(struct SOperatorInfo* pOperator) {
+static int32_t hJoinMainProcess(struct SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
   SHJoinOperatorInfo* pJoin = pOperator->info;
-  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
+  SExecTaskInfo*      pTaskInfo = pOperator->pTaskInfo;
-  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t             code = TSDB_CODE_SUCCESS;
-  SSDataBlock* pRes = pJoin->finBlk;
+  SSDataBlock*        pRes = pJoin->finBlk;
-  int64_t st = 0;
+  int64_t             st = 0;
 
+  QRY_OPTR_CHECK(pResBlock);
   if (pOperator->cost.openCost == 0) {
     st = taosGetTimestampUs();
   }
@@ -1004,7 +1005,7 @@ static SSDataBlock* hJoinMainProcess(struct SOperatorInfo* pOperator) {
     pRes->info.rows = 0;
     goto _return;
   }
-  
+
   if (!pJoin->keyHashBuilt) {
     pJoin->keyHashBuilt = true;
 
@@ -1012,7 +1013,7 @@ static SSDataBlock* hJoinMainProcess(struct SOperatorInfo* pOperator) {
     code = hJoinBuildHash(pOperator, &queryDone);
     if (code) {
       pTaskInfo->code = code;
-      T_LONG_JMP(pTaskInfo->env, code);
+      return code;
     }
 
     if (queryDone) {
@@ -1026,18 +1027,20 @@ static SSDataBlock* hJoinMainProcess(struct SOperatorInfo* pOperator) {
     code = (*pJoin->joinFp)(pOperator);
     if (code) {
       pTaskInfo->code = code;
-      T_LONG_JMP(pTaskInfo->env, code);
+      return pTaskInfo->code;
     }
-    
+
     if (pRes->info.rows > 0 && pJoin->pFinFilter != NULL) {
       code = doFilter(pRes, pJoin->pFinFilter, NULL);
       if (code) {
         pTaskInfo->code = code;
-        T_LONG_JMP(pTaskInfo->env, code);
+        return pTaskInfo->code;
       }
     }
+
     if (pRes->info.rows > 0) {
-      return pRes;
+      *pResBlock = pRes;
+      return code;
     }
   }
 
@@ -1050,39 +1053,41 @@ static SSDataBlock* hJoinMainProcess(struct SOperatorInfo* pOperator) {
 
     pJoin->execInfo.probeBlkNum++;
     pJoin->execInfo.probeBlkRows += pBlock->info.rows;
-    
+
     code = hJoinPrepareStart(pOperator, pBlock);
     if (code) {
       pTaskInfo->code = code;
-      T_LONG_JMP(pTaskInfo->env, code);
+      return pTaskInfo->code;
     }
 
     if (!hJoinBlkReachThreshold(pJoin, pRes->info.rows)) {
       continue;
     }
-    
+
     if (pRes->info.rows > 0 && pJoin->pFinFilter != NULL) {
       code = doFilter(pRes, pJoin->pFinFilter, NULL);
       if (code) {
         pTaskInfo->code = code;
-        T_LONG_JMP(pTaskInfo->env, code);
+        return pTaskInfo->code;
       }
     }
-    
+
     if (pRes->info.rows > 0) {
       break;
     }
   }
 
 _return:
-
   if (pOperator->cost.openCost == 0) {
     pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0;
   }
-  
-  return (pRes->info.rows > 0) ? pRes : NULL;
-}
 
+  if (pRes->info.rows > 0) {
+    *pResBlock = pRes;
+  }
+
+  return code;
+}
 
 static void destroyHashJoinOperator(void* param) {
   SHJoinOperatorInfo* pJoinOperator = (SHJoinOperatorInfo*)param;

source/libs/executor/src/mergejoinoperator.c

@@ -1691,13 +1691,13 @@ void mJoinResetOperator(struct SOperatorInfo* pOperator) {
   pOperator->status = OP_OPENED;
 }
 
-SSDataBlock* mJoinMainProcess(struct SOperatorInfo* pOperator) {
+int32_t mJoinMainProcess(struct SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
   SMJoinOperatorInfo* pJoin = pOperator->info;
   int32_t code = TSDB_CODE_SUCCESS;
   if (pOperator->status == OP_EXEC_DONE) {
     if (NULL == pOperator->pDownstreamGetParams || NULL == pOperator->pDownstreamGetParams[0] || NULL == pOperator->pDownstreamGetParams[1]) {
       qDebug("%s merge join done", GET_TASKID(pOperator->pTaskInfo));
-      return NULL;
+      return code;
     } else {
       mJoinResetOperator(pOperator);
       qDebug("%s start new round merge join", GET_TASKID(pOperator->pTaskInfo));
@@ -1739,7 +1739,10 @@ SSDataBlock* mJoinMainProcess(struct SOperatorInfo* pOperator) {
   }
 
   pJoin->execInfo.resRows += pBlock ? pBlock->info.rows : 0;
-  return (pBlock && pBlock->info.rows > 0) ? pBlock : NULL;
+  if (pBlock && pBlock->info.rows > 0) {
+    *pResBlock = pBlock;
+  }
+  return code;
 }
 
 void destroyGrpArray(void* ppArray) {

source/libs/executor/src/mergeoperator.c

@@ -57,18 +57,16 @@ typedef struct SMultiwayMergeOperatorInfo {
   bool           inputWithGroupId;
 } SMultiwayMergeOperatorInfo;
 
-static SSDataBlock* doSortMerge1(SOperatorInfo* pOperator);
+static int32_t doSortMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock);
-static int32_t      doSortMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock);
+static int32_t doMultiwayMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock);
-static SSDataBlock* doMultiwayMerge(SOperatorInfo* pOperator);
 static int32_t doNonSortMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock);
-static SSDataBlock* doNonSortMerge1(SOperatorInfo* pOperator);
-static SSDataBlock* doColsMerge1(SOperatorInfo* pOperator);
 static int32_t doColsMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock);
+static int32_t sortMergeloadNextDataBlock(void* param, SSDataBlock** ppBlock);
 
 int32_t sortMergeloadNextDataBlock(void* param, SSDataBlock** ppBlock) {
   SOperatorInfo* pOperator = (SOperatorInfo*)param;
-  *ppBlock = pOperator->fpSet.getNextFn(pOperator);
+  int32_t code = pOperator->fpSet.getNextFn(pOperator, ppBlock);
-  return TSDB_CODE_SUCCESS;
+  return code;
 }
 
 int32_t openSortMergeOperator(SOperatorInfo* pOperator) {
@@ -185,12 +183,6 @@ static int32_t doGetSortedBlockData(SMultiwayMergeOperatorInfo* pInfo, SSortHand
   return code;
 }
 
-SSDataBlock* doSortMerge1(SOperatorInfo* pOperator) {
-  SSDataBlock* pBlock = NULL;
-  pOperator->pTaskInfo->code = doSortMerge(pOperator, &pBlock);
-  return pBlock;
-}
-
 int32_t doSortMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
   SExecTaskInfo*              pTaskInfo = pOperator->pTaskInfo;
   SMultiwayMergeOperatorInfo* pInfo = pOperator->info;
@@ -343,12 +335,6 @@ int32_t openNonSortMergeOperator(SOperatorInfo* pOperator) {
   return 0;
 }
 
-SSDataBlock* doNonSortMerge1(SOperatorInfo* pOperator) {
-  SSDataBlock* pBlock = NULL;
-  pOperator->pTaskInfo->code = doNonSortMerge(pOperator, &pBlock);
-  return pBlock;
-}
-
 int32_t doNonSortMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
   QRY_OPTR_CHECK(pResBlock);
 
@@ -432,12 +418,6 @@ int32_t copyColumnsValue(SNodeList* pNodeList, uint64_t targetBlkId, SSDataBlock
   return code;
 }
 
-SSDataBlock* doColsMerge1(SOperatorInfo* pOperator) {
-  SSDataBlock* pBlock = NULL;
-  pOperator->pTaskInfo->code = doColsMerge(pOperator, &pBlock);
-  return pBlock;
-}
-
 int32_t doColsMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
   QRY_OPTR_CHECK(pResBlock);
 
@@ -486,9 +466,9 @@ int32_t getColsMergeExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplain, u
 
 SOperatorFpSet gMultiwayMergeFps[MERGE_TYPE_MAX_VALUE] = {
   {0},
-  {._openFn = openSortMergeOperator, .getNextFn = doSortMerge1, .closeFn = destroySortMergeOperatorInfo, .getExplainFn = getSortMergeExplainExecInfo},
+  {._openFn = openSortMergeOperator, .getNextFn = doSortMerge, .closeFn = destroySortMergeOperatorInfo, .getExplainFn = getSortMergeExplainExecInfo},
-  {._openFn = openNonSortMergeOperator, .getNextFn = doNonSortMerge1, .closeFn = destroyNonSortMergeOperatorInfo, .getExplainFn = getNonSortMergeExplainExecInfo},
+  {._openFn = openNonSortMergeOperator, .getNextFn = doNonSortMerge, .closeFn = destroyNonSortMergeOperatorInfo, .getExplainFn = getNonSortMergeExplainExecInfo},
-  {._openFn = openColsMergeOperator, .getNextFn = doColsMerge1, .closeFn = destroyColsMergeOperatorInfo, .getExplainFn = getColsMergeExplainExecInfo},
+  {._openFn = openColsMergeOperator, .getNextFn = doColsMerge, .closeFn = destroyColsMergeOperatorInfo, .getExplainFn = getColsMergeExplainExecInfo},
 };
 
 
@@ -518,30 +498,37 @@ int32_t openMultiwayMergeOperator(SOperatorInfo* pOperator) {
   return code;
 }
 
-SSDataBlock* doMultiwayMerge(SOperatorInfo* pOperator) {
+int32_t doMultiwayMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
+  QRY_OPTR_CHECK(pResBlock);
+
   if (pOperator->status == OP_EXEC_DONE) {
-    return NULL;
+    return 0;
   }
 
-  SSDataBlock* pBlock = NULL;
   SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
   SMultiwayMergeOperatorInfo* pInfo = pOperator->info;
 
   int32_t code = pOperator->fpSet._openFn(pOperator);
   if (code != TSDB_CODE_SUCCESS) {
-    T_LONG_JMP(pTaskInfo->env, code);
+    pTaskInfo->code = code;
+    return code;
   }
 
   if (NULL != gMultiwayMergeFps[pInfo->type].getNextFn) {
-    pBlock = (*gMultiwayMergeFps[pInfo->type].getNextFn)(pOperator);
+    code = (*gMultiwayMergeFps[pInfo->type].getNextFn)(pOperator, pResBlock);
+    if (code) {
+      pTaskInfo->code = code;
+      return code;
+    }
   }
-  if (pBlock != NULL) {
+
-    pOperator->resultInfo.totalRows += pBlock->info.rows;
+  if ((*pResBlock) != NULL) {
+    pOperator->resultInfo.totalRows += (*pResBlock)->info.rows;
   } else {
     setOperatorCompleted(pOperator);
   }
 
-  return pBlock;
+  return code;
 }
 
 void destroyMultiwayMergeOperatorInfo(void* param) {
@@ -599,6 +586,7 @@ int32_t createMultiwayMergeOperatorInfo(SOperatorInfo** downStreams, size_t numS
       SPhysiNode*  pChildNode = (SPhysiNode*)nodesListGetNode(pPhyNode->pChildren, 0);
       SSDataBlock* pInputBlock = createDataBlockFromDescNode(pChildNode->pOutputDataBlockDesc);
       TSDB_CHECK_NULL(pInputBlock, code, lino, _error, terrno);
+      pSortMergeInfo->pInputBlock = pInputBlock;
 
       initResultSizeInfo(&pOperator->resultInfo, 1024);
       code = blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
@@ -611,7 +599,6 @@ int32_t createMultiwayMergeOperatorInfo(SOperatorInfo** downStreams, size_t numS
       pSortMergeInfo->bufPageSize = getProperSortPageSize(rowSize, numOfCols);
       pSortMergeInfo->sortBufSize =
           pSortMergeInfo->bufPageSize * (numStreams + 1);  // one additional is reserved for merged result.
-      pSortMergeInfo->pInputBlock = pInputBlock;
       code = extractColMatchInfo(pMergePhyNode->pTargets, pDescNode, &numOfOutputCols, COL_MATCH_FROM_SLOT_ID,
                                  &pSortMergeInfo->matchInfo);
       if (code != TSDB_CODE_SUCCESS) {

source/libs/executor/src/operator.c

@@ -862,10 +862,13 @@ int32_t optrDefaultGetNextExtFn(struct SOperatorInfo* pOperator, SOperatorParam*
   int32_t code = setOperatorParams(pOperator, pParam, OP_GET_PARAM);
   if (TSDB_CODE_SUCCESS != code) {
     pOperator->pTaskInfo->code = code;
-    T_LONG_JMP(pOperator->pTaskInfo->env, pOperator->pTaskInfo->code);
+  } else {
+    code = pOperator->fpSet.getNextFn(pOperator, pRes);
+    if (code) {
+      pOperator->pTaskInfo->code = code;
+    }
   }
 
-  *pRes = pOperator->fpSet.getNextFn(pOperator);
   return code;
 }
 

source/libs/executor/src/projectoperator.c

@@ -165,7 +165,7 @@ int32_t createProjectOperatorInfo(SOperatorInfo* downstream, SProjectPhysiNode*
 
   setOperatorInfo(pOperator, "ProjectOperator", QUERY_NODE_PHYSICAL_PLAN_PROJECT, false, OP_NOT_OPENED, pInfo,
                   pTaskInfo);
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doProjectOperation1, NULL, destroyProjectOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doProjectOperation, NULL, destroyProjectOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   setOperatorStreamStateFn(pOperator, streamOperatorReleaseState, streamOperatorReloadState);
 
@@ -445,16 +445,6 @@ int32_t doProjectOperation(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
   return code;
 }
 
-SSDataBlock* doProjectOperation1(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t code = doProjectOperation(pOperator, &pRes);
-  if (code && pOperator->pTaskInfo->code == 0) {
-    pOperator->pTaskInfo->code = code;
-  }
-
-  return pRes;
-}
-
 int32_t createIndefinitOutputOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pNode,
                                                  SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {
   QRY_OPTR_CHECK(pOptrInfo);
@@ -526,7 +516,7 @@ int32_t createIndefinitOutputOperatorInfo(SOperatorInfo* downstream, SPhysiNode*
 
   setOperatorInfo(pOperator, "IndefinitOperator", QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC, false, OP_NOT_OPENED, pInfo,
                   pTaskInfo);
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doApplyIndefinitFunction1, NULL, destroyIndefinitOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doApplyIndefinitFunction, NULL, destroyIndefinitOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
 
   code = appendDownstream(pOperator, &downstream, 1);

source/libs/executor/src/scanoperator.c

@@ -68,6 +68,7 @@ typedef struct STableCountScanOperatorInfo {
 } STableCountScanOperatorInfo;
 
 static bool processBlockWithProbability(const SSampleExecInfo* pInfo);
+static int32_t doTableCountScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes);
 
 bool processBlockWithProbability(const SSampleExecInfo* pInfo) {
 #if 0
@@ -226,9 +227,8 @@ static int32_t doDynamicPruneDataBlock(SOperatorInfo* pOperator, SDataBlockInfo*
 
     SResultRowEntryInfo* pEntry = getResultEntryInfo(pRow, i, pTableScanInfo->base.pdInfo.pExprSup->rowEntryInfoOffset);
 
-    int32_t reqStatus;
+    EFuncDataRequired reqStatus  = fmFuncDynDataRequired(functionId, pEntry, pBlockInfo);
-    code = fmFuncDynDataRequired(functionId, pEntry, pBlockInfo, &reqStatus);
+    if (reqStatus != FUNC_DATA_REQUIRED_NOT_LOAD) {
-    if (code != TSDB_CODE_SUCCESS || reqStatus != FUNC_DATA_REQUIRED_NOT_LOAD) {
       notLoadBlock = false;
       break;
     }
@@ -419,7 +419,11 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanBase* pTableSca
       size_t size = taosArrayGetSize(pBlock->pDataBlock);
       bool   keep = false;
       code = doFilterByBlockSMA(pOperator->exprSupp.pFilterInfo, pBlock->pBlockAgg, size, pBlockInfo->rows, &keep);
-      QUERY_CHECK_CODE(code, lino, _end);
+      if (code) {
+        pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->dataReader);
+        qError("%s failed to do filter by block sma, code:%s", GET_TASKID(pTaskInfo), tstrerror(code));
+        QUERY_CHECK_CODE(code, lino, _end);
+      }
 
       if (!keep) {
         qDebug("%s data block filter out by block SMA, brange:%" PRId64 "-%" PRId64 ", rows:%" PRId64,
@@ -640,6 +644,7 @@ int32_t addTagPseudoColumnData(SReadHandle* pHandle, const SExprInfo* pExpr, int
     h = taosLRUCacheLookup(pCache->pTableMetaEntryCache, &pBlock->info.id.uid, sizeof(pBlock->info.id.uid));
     if (h == NULL) {
       pHandle->api.metaReaderFn.initReader(&mr, pHandle->vnode, META_READER_LOCK, &pHandle->api.metaFn);
+      freeReader = true;
       code = pHandle->api.metaReaderFn.getEntryGetUidCache(&mr, pBlock->info.id.uid);
       if (code != TSDB_CODE_SUCCESS) {
         if (code == TSDB_CODE_PAR_TABLE_NOT_EXIST) {
@@ -661,7 +666,6 @@ int32_t addTagPseudoColumnData(SReadHandle* pHandle, const SExprInfo* pExpr, int
       QUERY_CHECK_CODE(code, lino, _end);
 
       val = *pVal;
-      freeReader = true;
     } else {
       pCache->cacheHit += 1;
       STableCachedVal* pVal = taosLRUCacheValue(pCache->pTableMetaEntryCache, h);
@@ -1001,30 +1005,30 @@ _end:
   return code;
 }
 
-static SSDataBlock* doTableScanImpl(SOperatorInfo* pOperator) {
+static int32_t doGroupedTableScan(SOperatorInfo* pOperator, SSDataBlock** pBlock) {
-  SSDataBlock* pRes = NULL;
-  int32_t      code = doTableScanImplNext(pOperator, &pRes);
-  return pRes;
-}
-
-static SSDataBlock* doGroupedTableScan(SOperatorInfo* pOperator) {
   int32_t         code = TSDB_CODE_SUCCESS;
   int32_t         lino = 0;
   STableScanInfo* pTableScanInfo = pOperator->info;
   SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;
   SStorageAPI*    pAPI = &pTaskInfo->storageAPI;
 
+  QRY_OPTR_CHECK(pBlock);
+
   // The read handle is not initialized yet, since no qualified tables exists
   if (pTableScanInfo->base.dataReader == NULL || pOperator->status == OP_EXEC_DONE) {
-    return NULL;
+    return code;
   }
 
   // do the ascending order traverse in the first place.
   while (pTableScanInfo->scanTimes < pTableScanInfo->scanInfo.numOfAsc) {
-    SSDataBlock* p = doTableScanImpl(pOperator);
+    SSDataBlock* p = NULL;
+    code = doTableScanImplNext(pOperator, &p);
+    QUERY_CHECK_CODE(code, lino, _end);
+
     if (p != NULL) {
       markGroupProcessed(pTableScanInfo, p->info.id.groupId);
-      return p;
+      *pBlock = p;
+      return code;
     }
 
     pTableScanInfo->scanTimes += 1;
@@ -1052,10 +1056,14 @@ static SSDataBlock* doGroupedTableScan(SOperatorInfo* pOperator) {
     }
 
     while (pTableScanInfo->scanTimes < total) {
-      SSDataBlock* p = doTableScanImpl(pOperator);
+      SSDataBlock* p = NULL;
+      code = doTableScanImplNext(pOperator, &p);
+      QUERY_CHECK_CODE(code, lino, _end);
+
       if (p != NULL) {
         markGroupProcessed(pTableScanInfo, p->info.id.groupId);
-        return p;
+        *pBlock = p;
+        return code;
       }
 
       pTableScanInfo->scanTimes += 1;
@@ -1079,8 +1087,13 @@ static SSDataBlock* doGroupedTableScan(SOperatorInfo* pOperator) {
         pTableScanInfo->countState = TABLE_COUNT_STATE_PROCESSED;
         STableKeyInfo* pStart =
             (STableKeyInfo*)tableListGetInfo(pTableScanInfo->base.pTableListInfo, pTableScanInfo->tableStartIndex);
-        if (NULL == pStart) return NULL;
+
-        return getBlockForEmptyTable(pOperator, pStart);
+        if (NULL == pStart) {
+          return code;
+        }
+
+        *pBlock = getBlockForEmptyTable(pOperator, pStart);
+        return code;
       }
     } else {  // group by tag + no sort
       int32_t numOfTables = 0;
@@ -1096,7 +1109,9 @@ static SSDataBlock* doGroupedTableScan(SOperatorInfo* pOperator) {
           STableKeyInfo info = {.uid = *(uint64_t*)pIte, .groupId = *pGroupId};
           taosHashCancelIterate(pTableListInfo->remainGroups, pIte);
           markGroupProcessed(pTableScanInfo, *pGroupId);
-          return getBlockForEmptyTable(pOperator, &info);
+          *pBlock = getBlockForEmptyTable(pOperator, &info);
+
+          return code;
         }
       }
     }
@@ -1107,9 +1122,9 @@ _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
     pTaskInfo->code = code;
-    T_LONG_JMP(pTaskInfo->env, code);
   }
-  return NULL;
+
+  return code;
 }
 
 static int32_t createTableListInfoFromParam(SOperatorInfo* pOperator) {
@@ -1169,13 +1184,16 @@ static int32_t createTableListInfoFromParam(SOperatorInfo* pOperator) {
   return code;
 }
 
-static SSDataBlock* startNextGroupScan(SOperatorInfo* pOperator) {
+static int32_t startNextGroupScan(SOperatorInfo* pOperator, SSDataBlock** pResult) {
   int32_t         code = TSDB_CODE_SUCCESS;
   int32_t         lino = 0;
   STableScanInfo* pInfo = pOperator->info;
   SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;
   SStorageAPI*    pAPI = &pTaskInfo->storageAPI;
   int32_t         numOfTables = 0;
+
+  QRY_OPTR_CHECK(pResult);
+
   code = tableListGetSize(pInfo->base.pTableListInfo, &numOfTables);
   QUERY_CHECK_CODE(code, lino, _end);
 
@@ -1185,7 +1203,7 @@ static SSDataBlock* startNextGroupScan(SOperatorInfo* pOperator) {
       taosArrayClear(pInfo->base.pTableListInfo->pTableList);
       taosHashClear(pInfo->base.pTableListInfo->map);
     }
-    return NULL;
+    return code;
   }
 
   // reset value for the next group data output
@@ -1204,21 +1222,22 @@ static SSDataBlock* startNextGroupScan(SOperatorInfo* pOperator) {
   QUERY_CHECK_CODE(code, lino, _end);
   pInfo->scanTimes = 0;
 
-  SSDataBlock* result = doGroupedTableScan(pOperator);
+  code = doGroupedTableScan(pOperator, pResult);
-  if (result != NULL) {
+  QUERY_CHECK_CODE(code, lino, _end);
+
+  if (*pResult != NULL) {
     if (pOperator->dynamicTask) {
-      result->info.id.groupId = result->info.id.uid;
+      (*pResult)->info.id.groupId = (*pResult)->info.id.uid;
     }
-    return result;
+    return code;
   }
 
 _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
     pTaskInfo->code = code;
-    T_LONG_JMP(pTaskInfo->env, code);
   }
-  return NULL;
+  return code;
 }
 
 static SSDataBlock* groupSeqTableScan(SOperatorInfo* pOperator) {
@@ -1257,7 +1276,10 @@ static SSDataBlock* groupSeqTableScan(SOperatorInfo* pOperator) {
     }
   }
 
-  result = doGroupedTableScan(pOperator);
+  result = NULL;
+  code = doGroupedTableScan(pOperator, &result);
+  QUERY_CHECK_CODE(code, lino, _end);
+
   if (result != NULL) {
     if (pOperator->dynamicTask) {
       result->info.id.groupId = result->info.id.uid;
@@ -1266,7 +1288,9 @@ static SSDataBlock* groupSeqTableScan(SOperatorInfo* pOperator) {
   }
 
   while (true) {
-    result = startNextGroupScan(pOperator);
+    code = startNextGroupScan(pOperator, &result);
+    QUERY_CHECK_CODE(code, lino, _end);
+
     if (result || pOperator->status == OP_EXEC_DONE) {
       return result;
     }
@@ -1287,6 +1311,7 @@ static int32_t doTableScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
   STableScanInfo* pInfo = pOperator->info;
   SExecTaskInfo*  pTaskInfo = pOperator->pTaskInfo;
   SStorageAPI*    pAPI = &pTaskInfo->storageAPI;
+  QRY_OPTR_CHECK(ppRes);
 
   if (pOperator->pOperatorGetParam) {
     pOperator->dynamicTask = true;
@@ -1299,8 +1324,11 @@ static int32_t doTableScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
       pInfo->currentGroupId = -1;
       pOperator->status = OP_OPENED;
       SSDataBlock* result = NULL;
+
       while (true) {
-        result = startNextGroupScan(pOperator);
+        code = startNextGroupScan(pOperator, &result);
+        QUERY_CHECK_CODE(code, lino, _end);
+
         if (result || pOperator->status == OP_EXEC_DONE) {
           (*ppRes) = result;
           return code;
@@ -1316,7 +1344,10 @@ static int32_t doTableScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
     pInfo->countState = TABLE_COUNT_STATE_END;
 
     while (1) {
-      SSDataBlock* result = doGroupedTableScan(pOperator);
+      SSDataBlock* result = NULL;
+      code = doGroupedTableScan(pOperator, &result);
+      QUERY_CHECK_CODE(code, lino, _end);
+
       if (result || (pOperator->status == OP_EXEC_DONE) || isTaskKilled(pTaskInfo)) {
         (*ppRes) = result;
         return code;
@@ -1340,6 +1371,7 @@ static int32_t doTableScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
         (*ppRes) = NULL;
         return code;
       }
+
       STableKeyInfo* tmp = (STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->currentTable);
       if (!tmp) {
         qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(terrno));
@@ -1368,16 +1400,9 @@ _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
     pTaskInfo->code = code;
-    T_LONG_JMP(pTaskInfo->env, code);
   }
-  (*ppRes) = NULL;
-  return code;
-}
 
-static SSDataBlock* doTableScan(SOperatorInfo* pOperator) {
+  return code;
-  SSDataBlock* pRes = NULL;
-  int32_t      code = doTableScanNext(pOperator, &pRes);
-  return pRes;
 }
 
 static int32_t getTableScannerExecInfo(struct SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len) {
@@ -1497,7 +1522,7 @@ int32_t createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHa
   pInfo->filesetDelimited = pTableScanNode->filesetDelimited;
 
   taosLRUCacheSetStrictCapacity(pInfo->base.metaCache.pTableMetaEntryCache, false);
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableScan, NULL, destroyTableScanOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableScanNext, NULL, destroyTableScanOperatorInfo,
                                          optrDefaultBufFn, getTableScannerExecInfo, optrDefaultGetNextExtFn, NULL);
 
   // for non-blocking operator, the open cost is always 0
@@ -1535,7 +1560,7 @@ int32_t createTableSeqScanOperatorInfo(void* pReadHandle, SExecTaskInfo* pTaskIn
 
   setOperatorInfo(pOperator, "TableSeqScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN, false, OP_NOT_OPENED,
                   pInfo, pTaskInfo);
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableScanImpl, NULL, NULL, optrDefaultBufFn, NULL,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableScanImplNext, NULL, NULL, optrDefaultBufFn, NULL,
                                          optrDefaultGetNextExtFn, NULL);
   *pOptrInfo = pOperator;
   return code;
@@ -1832,18 +1857,23 @@ static STimeWindow getSlidingWindow(TSKEY* startTsCol, TSKEY* endTsCol, uint64_t
 static int32_t doRangeScan(SStreamScanInfo* pInfo, SSDataBlock* pSDB, int32_t tsColIndex, int32_t* pRowIndex,
                            SSDataBlock** ppRes) {
   qDebug("do stream range scan. windows index:%d", *pRowIndex);
+
   int32_t code = TSDB_CODE_SUCCESS;
   int32_t lino = 0;
   bool    prepareRes = true;
 
   while (1) {
     SSDataBlock* pResult = NULL;
-    pResult = doTableScan(pInfo->pTableScanOp);
+    code = doTableScanNext(pInfo->pTableScanOp, &pResult);
+    QUERY_CHECK_CODE(code, lino, _end);
+
     if (!pResult) {
       prepareRangeScan(pInfo, pSDB, pRowIndex, &prepareRes);
       // scan next window data
-      pResult = doTableScan(pInfo->pTableScanOp);
+      code = doTableScanNext(pInfo->pTableScanOp, &pResult);
+      QUERY_CHECK_CODE(code, lino, _end);
     }
+
     if (!pResult) {
       if (prepareRes) {
         continue;
@@ -2891,7 +2921,9 @@ static int32_t doQueueScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
 
   if (pTaskInfo->streamInfo.currentOffset.type == TMQ_OFFSET__SNAPSHOT_DATA) {
     while (1) {
-      SSDataBlock* pResult = doTableScan(pInfo->pTableScanOp);
+      SSDataBlock* pResult = NULL;
+      code = doTableScanNext(pInfo->pTableScanOp, &pResult);
+      QUERY_CHECK_CODE(code, lino, _end);
 
       if (pResult && pResult->info.rows > 0) {
         bool hasPrimaryKey = pAPI->tqReaderFn.tqGetTablePrimaryKey(pInfo->tqReader);
@@ -3231,7 +3263,9 @@ static int32_t doStreamScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
         break;
     }
 
-    pInfo->pRecoverRes = doTableScan(pInfo->pTableScanOp);
+    code = doTableScanNext(pInfo->pTableScanOp, &pInfo->pRecoverRes);
+    QUERY_CHECK_CODE(code, lino, _end);
+
     if (pInfo->pRecoverRes != NULL) {
       code = calBlockTbName(pInfo, pInfo->pRecoverRes, 0);
       QUERY_CHECK_CODE(code, lino, _end);
@@ -3784,12 +3818,6 @@ _end:
   return code;
 }
 
-static SSDataBlock* doRawScan(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t      code = doRawScanNext(pOperator, &pRes);
-  return pRes;
-}
-
 static void destroyRawScanOperatorInfo(void* param) {
   SStreamRawScanInfo* pRawScan = (SStreamRawScanInfo*)param;
   pRawScan->pAPI->tsdReader.tsdReaderClose(pRawScan->dataReader);
@@ -3828,7 +3856,7 @@ int32_t createRawScanOperatorInfo(SReadHandle* pHandle, SExecTaskInfo* pTaskInfo
   setOperatorInfo(pOperator, "RawScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN, false, OP_NOT_OPENED, pInfo,
                   pTaskInfo);
 
-  pOperator->fpSet = createOperatorFpSet(NULL, doRawScan, NULL, destroyRawScanOperatorInfo, optrDefaultBufFn, NULL,
+  pOperator->fpSet = createOperatorFpSet(NULL, doRawScanNext, NULL, destroyRawScanOperatorInfo, optrDefaultBufFn, NULL,
                                          optrDefaultGetNextExtFn, NULL);
   *pOptrInfo = pOperator;
   return code;
@@ -4207,7 +4235,7 @@ int32_t createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode*
                   pTaskInfo);
   pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock);
 
-  __optr_fn_t nextFn = (pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM) ? doStreamScan : doQueueScan;
+  __optr_fn_t nextFn = (pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM) ? doStreamScanNext : doQueueScanNext;
   pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, nextFn, NULL, destroyStreamScanOperatorInfo, optrDefaultBufFn,
                                          NULL, optrDefaultGetNextExtFn, NULL);
   setOperatorStreamStateFn(pOperator, streamScanReleaseState, streamScanReloadState);
@@ -4779,7 +4807,7 @@ int32_t createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysiNode* p
     }
   }
   //TODO wjm check pInfo->filterCtx.code
-  __optr_fn_t tagScanNextFn = (pTagScanNode->onlyMetaCtbIdx) ? doTagScanFromCtbIdx : doTagScanFromMetaEntry;
+  __optr_fn_t tagScanNextFn = (pTagScanNode->onlyMetaCtbIdx) ? doTagScanFromCtbIdxNext : doTagScanFromMetaEntryNext;
   pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, tagScanNextFn, NULL, destroyTagScanOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   *pOptrInfo = pOperator;
@@ -6044,7 +6072,7 @@ int32_t createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SR
   pOperator->exprSupp.numOfExprs = numOfCols;
 
   pOperator->fpSet = createOperatorFpSet(
-      optrDummyOpenFn, pTableScanNode->paraTablesSort ? doTableMergeScanParaSubTables : doTableMergeScan, NULL,
+      optrDummyOpenFn, pTableScanNode->paraTablesSort ? doTableMergeScanParaSubTablesNext : doTableMergeScanNext, NULL,
       destroyTableMergeScanOperatorInfo, optrDefaultBufFn, getTableMergeScanExplainExecInfo, optrDefaultGetNextExtFn,
       NULL);
   pOperator->cost.openCost = 0;
@@ -6070,7 +6098,6 @@ _error:
 
 // ====================================================================================================================
 // TableCountScanOperator
-static SSDataBlock* doTableCountScan(SOperatorInfo* pOperator);
 static void         destoryTableCountScanOperator(void* param);
 static int32_t      buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp,
                                                    SSDataBlock* pRes, char* dbName, tb_uid_t stbUid, SStorageAPI* pAPI);
@@ -6212,7 +6239,7 @@ int32_t createTableCountScanOperatorInfo(SReadHandle* readHandle, STableCountSca
 
   setOperatorInfo(pOperator, "TableCountScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN, false, OP_NOT_OPENED,
                   pInfo, pTaskInfo);
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableCountScan, NULL, destoryTableCountScanOperator,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableCountScanNext, NULL, destoryTableCountScanOperator,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   *pOptrInfo = pOperator;
   return code;
@@ -6381,12 +6408,6 @@ static int32_t doTableCountScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRe
   return code;
 }
 
-static SSDataBlock* doTableCountScan(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t      code = doTableCountScanNext(pOperator, &pRes);
-  return pRes;
-}
-
 static SSDataBlock* buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo,
                                            STableCountScanSupp* pSupp, SSDataBlock* pRes) {
   int32_t        code = TSDB_CODE_SUCCESS;
@@ -6502,8 +6523,8 @@ static void buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanO
 _end:
   if (code != TSDB_CODE_SUCCESS) {
     pTaskInfo->code = code;
-    T_LONG_JMP(pTaskInfo->env, code);
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   setOperatorCompleted(pOperator);
 }

source/libs/executor/src/sortoperator.c

@@ -43,11 +43,9 @@ typedef struct SSortOperatorInfo {
   SSortOpGroupIdCalc* pGroupIdCalc;
 } SSortOperatorInfo;
 
-static int32_t      doSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock);
+static int32_t doSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock);
-static SSDataBlock* doSort1(SOperatorInfo* pOperator);
+static int32_t doOpenSortOperator(SOperatorInfo* pOperator);
-static int32_t      doOpenSortOperator(SOperatorInfo* pOperator);
+static int32_t getExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len);
-static int32_t      getExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len);
-static SSDataBlock* doGroupSort1(SOperatorInfo* pOperator);
 static int32_t doGroupSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock);
 
 static void destroySortOperatorInfo(void* param);
@@ -149,7 +147,7 @@ int32_t createSortOperatorInfo(SOperatorInfo* downstream, SSortPhysiNode* pSortN
   // TODO dynamic set the available sort buffer
 
   pOperator->fpSet =
-      createOperatorFpSet(doOpenSortOperator, doSort1, NULL, destroySortOperatorInfo, optrDefaultBufFn, getExplainExecInfo, optrDefaultGetNextExtFn, NULL);
+      createOperatorFpSet(doOpenSortOperator, doSort, NULL, destroySortOperatorInfo, optrDefaultBufFn, getExplainExecInfo, optrDefaultGetNextExtFn, NULL);
 
   code = appendDownstream(pOperator, &downstream, 1);
   if (code != TSDB_CODE_SUCCESS) {
@@ -342,8 +340,7 @@ static int32_t getSortedBlockData(SSortHandle* pHandle, SSDataBlock* pDataBlock,
 
 int32_t loadNextDataBlock(void* param, SSDataBlock** ppBlock) {
   SOperatorInfo* pOperator = (SOperatorInfo*)param;
-  *ppBlock = pOperator->fpSet.getNextFn(pOperator);
+  return pOperator->fpSet.getNextFn(pOperator, ppBlock);
-  return TSDB_CODE_SUCCESS;
 }
 
 // todo refactor: merged with fetch fp
@@ -404,12 +401,6 @@ int32_t doOpenSortOperator(SOperatorInfo* pOperator) {
   return code;
 }
 
-SSDataBlock* doSort1(SOperatorInfo* pOperator) {
-  SSDataBlock* pBlock = NULL;
-  pOperator->pTaskInfo->code = doSort(pOperator, &pBlock);
-  return pBlock;
-}
-
 int32_t doSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
   QRY_OPTR_CHECK(pResBlock);
   if (pOperator->status == OP_EXEC_DONE) {
@@ -613,17 +604,23 @@ typedef struct SGroupSortSourceParam {
 } SGroupSortSourceParam;
 
 int32_t fetchNextGroupSortDataBlock(void* param, SSDataBlock** ppBlock) {
-  *ppBlock = NULL;
+  int32_t                 code = 0;
-  
+  int32_t                 lino = 0;
   SGroupSortSourceParam*  source = param;
   SGroupSortOperatorInfo* grpSortOpInfo = source->grpSortOpInfo;
+  SSDataBlock*            block = NULL;
+
+  QRY_OPTR_CHECK(ppBlock);
+
   if (grpSortOpInfo->prefetchedSortInput) {
-    SSDataBlock* block = grpSortOpInfo->prefetchedSortInput;
+    block = grpSortOpInfo->prefetchedSortInput;
     grpSortOpInfo->prefetchedSortInput = NULL;
     *ppBlock = block;
   } else {
     SOperatorInfo* childOp = source->childOpInfo;
-    SSDataBlock*   block = childOp->fpSet.getNextFn(childOp);
+    code = childOp->fpSet.getNextFn(childOp, &block);
+    QUERY_CHECK_CODE(code, lino, _end);
+
     if (block != NULL) {
       if (block->info.id.groupId == grpSortOpInfo->currGroupId) {
         grpSortOpInfo->childOpStatus = CHILD_OP_SAME_GROUP;
@@ -637,7 +634,12 @@ int32_t fetchNextGroupSortDataBlock(void* param, SSDataBlock** ppBlock) {
     }
   }
 
-  return TSDB_CODE_SUCCESS;
+  return code;
+_end:
+  if (code != 0) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  return code;
 }
 
 int32_t beginSortGroup(SOperatorInfo* pOperator) {
@@ -695,12 +697,6 @@ int32_t finishSortGroup(SOperatorInfo* pOperator) {
   return TSDB_CODE_SUCCESS;
 }
 
-SSDataBlock* doGroupSort1(SOperatorInfo* pOperator) {
-  SSDataBlock* pBlock = NULL;
-  pOperator->pTaskInfo->code = doGroupSort(pOperator, &pBlock);
-  return pBlock;
-}
-
 int32_t doGroupSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
   QRY_OPTR_CHECK(pResBlock);
   SExecTaskInfo*          pTaskInfo = pOperator->pTaskInfo;
@@ -836,7 +832,7 @@ int32_t createGroupSortOperatorInfo(SOperatorInfo* downstream, SGroupSortPhysiNo
   pInfo->pSortInfo = createSortInfo(pSortPhyNode->pSortKeys);
   setOperatorInfo(pOperator, "GroupSortOperator", QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT, false, OP_NOT_OPENED, pInfo,
                   pTaskInfo);
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doGroupSort1, NULL, destroyGroupSortOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doGroupSort, NULL, destroyGroupSortOperatorInfo,
                                          optrDefaultBufFn, getGroupSortExplainExecInfo, optrDefaultGetNextExtFn, NULL);
 
   code = appendDownstream(pOperator, &downstream, 1);

source/libs/executor/src/streamcountwindowoperator.c

@@ -658,10 +658,14 @@ static int32_t doStreamCountAggNext(SOperatorInfo* pOperator, SSDataBlock** ppRe
     QUERY_CHECK_NULL(pInfo->pStUpdated, code, lino, _end, terrno);
   }
   while (1) {
-    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
+    SSDataBlock* pBlock = NULL;
+    code = downstream->fpSet.getNextFn(downstream, &pBlock);
+    QUERY_CHECK_CODE(code, lino, _end);
+
     if (pBlock == NULL) {
       break;
     }
+
     printSpecDataBlock(pBlock, getStreamOpName(pOperator->operatorType), "recv", GET_TASKID(pTaskInfo));
     setStreamOperatorState(&pInfo->basic, pBlock->info.type);
 
@@ -745,12 +749,6 @@ _end:
   return code;
 }
 
-static SSDataBlock* doStreamCountAgg(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t      code = doStreamCountAggNext(pOperator, &pRes);
-  return pRes;
-}
-
 void streamCountReleaseState(SOperatorInfo* pOperator) {
   int32_t                      code = TSDB_CODE_SUCCESS;
   int32_t                      lino = 0;
@@ -908,7 +906,7 @@ int32_t createStreamCountAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode*
     QUERY_CHECK_CODE(code, lino, _error);
     taosMemoryFree(buff);
   }
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamCountAgg, NULL, destroyStreamCountAggOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamCountAggNext, NULL, destroyStreamCountAggOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   setOperatorStreamStateFn(pOperator, streamCountReleaseState, streamCountReloadState);
 

source/libs/executor/src/streameventwindowoperator.c

@@ -629,10 +629,15 @@ static int32_t doStreamEventAggNext(SOperatorInfo* pOperator, SSDataBlock** ppRe
     QUERY_CHECK_NULL(pInfo->pSeUpdated, code, lino, _end, terrno);
   }
   while (1) {
-    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
+    SSDataBlock* pBlock = NULL;
+
+    code = downstream->fpSet.getNextFn(downstream, &pBlock);
+    QUERY_CHECK_CODE(code, lino, _end);
+
     if (pBlock == NULL) {
       break;
     }
+
     printSpecDataBlock(pBlock, getStreamOpName(pOperator->operatorType), "recv", GET_TASKID(pTaskInfo));
     setStreamOperatorState(&pInfo->basic, pBlock->info.type);
 
@@ -734,12 +739,6 @@ _end:
   return code;
 }
 
-static SSDataBlock* doStreamEventAgg(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t      code = doStreamEventAggNext(pOperator, &pRes);
-  return pRes;
-}
-
 void streamEventReleaseState(SOperatorInfo* pOperator) {
   SStreamEventAggOperatorInfo* pInfo = pOperator->info;
   int32_t                      winSize = taosArrayGetSize(pInfo->historyWins) * sizeof(SSessionKey);
@@ -966,7 +965,7 @@ int32_t createStreamEventAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode*
     QUERY_CHECK_CODE(code, lino, _error);
   }
 
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamEventAgg, NULL, destroyStreamEventOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamEventAggNext, NULL, destroyStreamEventOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   setOperatorStreamStateFn(pOperator, streamEventReleaseState, streamEventReloadState);
   code = initDownStream(downstream, &pInfo->streamAggSup, pOperator->operatorType, pInfo->primaryTsIndex,

source/libs/executor/src/streamfilloperator.c

@@ -1164,12 +1164,6 @@ _end:
   return code;
 }
 
-static SSDataBlock* doStreamFill(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t      code = doStreamFillNext(pOperator, &pRes);
-  return pRes;
-}
-
 static int32_t initResultBuf(SStreamFillSupporter* pFillSup) {
   pFillSup->rowSize = sizeof(SResultCellData) * pFillSup->numOfAllCols;
   for (int i = 0; i < pFillSup->numOfAllCols; i++) {
@@ -1449,7 +1443,7 @@ int32_t createStreamFillOperatorInfo(SOperatorInfo* downstream, SStreamFillPhysi
   pInfo->srcRowIndex = -1;
   setOperatorInfo(pOperator, "StreamFillOperator", QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL, false, OP_NOT_OPENED, pInfo,
                   pTaskInfo);
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamFill, NULL, destroyStreamFillOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamFillNext, NULL, destroyStreamFillOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   setOperatorStreamStateFn(pOperator, streamOpReleaseState, streamOpReloadState);
 

source/libs/executor/src/streamtimewindowoperator.c

@@ -60,7 +60,7 @@ typedef struct SPullWindowInfo {
   STimeWindow calWin;
 } SPullWindowInfo;
 
-static SSDataBlock* doStreamMidIntervalAgg(SOperatorInfo* pOperator);
+static int32_t doStreamMidIntervalAggNext(SOperatorInfo* pOperator, SSDataBlock** ppRes);
 
 typedef int32_t (*__compare_fn_t)(void* pKey, void* data, int32_t index);
 
@@ -495,8 +495,11 @@ void destroyStreamFinalIntervalOperatorInfo(void* param) {
   nodesDestroyNode((SNode*)pInfo->pPhyNode);
   colDataDestroy(&pInfo->twAggSup.timeWindowData);
   cleanupExprSupp(&pInfo->scalarSupp);
-  tSimpleHashCleanup(pInfo->pUpdatedMap);
+  if (pInfo->pUpdatedMap != NULL) {
-  pInfo->pUpdatedMap = NULL;
+    tSimpleHashSetFreeFp(pInfo->pUpdatedMap, destroyFlusedppPos);
+    tSimpleHashCleanup(pInfo->pUpdatedMap);
+    pInfo->pUpdatedMap = NULL;
+  }
   tSimpleHashCleanup(pInfo->pDeletedMap);
 
   blockDataDestroy(pInfo->pCheckpointRes);
@@ -1603,7 +1606,10 @@ static int32_t doStreamFinalIntervalAggNext(SOperatorInfo* pOperator, SSDataBloc
       return code;
     }
 
-    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
+    SSDataBlock* pBlock = NULL;
+    code = downstream->fpSet.getNextFn(downstream, &pBlock);
+    QUERY_CHECK_CODE(code, lino, _end);
+
     if (pBlock == NULL) {
       pOperator->status = OP_RES_TO_RETURN;
       qDebug("===stream===return data:%s. recv datablock num:%" PRIu64, getStreamOpName(pOperator->operatorType),
@@ -1611,6 +1617,7 @@ static int32_t doStreamFinalIntervalAggNext(SOperatorInfo* pOperator, SSDataBloc
       pInfo->numOfDatapack = 0;
       break;
     }
+
     pInfo->numOfDatapack++;
     printSpecDataBlock(pBlock, getStreamOpName(pOperator->operatorType), "recv", GET_TASKID(pTaskInfo));
     setStreamOperatorState(&pInfo->basic, pBlock->info.type);
@@ -1765,12 +1772,6 @@ _end:
   return code;
 }
 
-static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t      code = doStreamFinalIntervalAggNext(pOperator, &pRes);
-  return pRes;
-}
-
 int64_t getDeleteMark(SWindowPhysiNode* pWinPhyNode, int64_t interval) {
   if (pWinPhyNode->deleteMark <= 0) {
     return DEAULT_DELETE_MARK;
@@ -1997,10 +1998,10 @@ int32_t createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiN
   pOperator->info = pInfo;
 
   if (pPhyNode->type == QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL) {
-    pOperator->fpSet = createOperatorFpSet(NULL, doStreamMidIntervalAgg, NULL, destroyStreamFinalIntervalOperatorInfo,
+    pOperator->fpSet = createOperatorFpSet(NULL, doStreamMidIntervalAggNext, NULL, destroyStreamFinalIntervalOperatorInfo,
                                            optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   } else {
-    pOperator->fpSet = createOperatorFpSet(NULL, doStreamFinalIntervalAgg, NULL, destroyStreamFinalIntervalOperatorInfo,
+    pOperator->fpSet = createOperatorFpSet(NULL, doStreamFinalIntervalAggNext, NULL, destroyStreamFinalIntervalOperatorInfo,
                                            optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   }
   setOperatorStreamStateFn(pOperator, streamIntervalReleaseState, streamIntervalReloadState);
@@ -3397,7 +3398,10 @@ static int32_t doStreamSessionAggNext(SOperatorInfo* pOperator, SSDataBlock** pp
     QUERY_CHECK_NULL(pInfo->pStUpdated, code, lino, _end, terrno);
   }
   while (1) {
-    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
+    SSDataBlock* pBlock = NULL;
+    code = downstream->fpSet.getNextFn(downstream, &pBlock);
+    QUERY_CHECK_CODE(code, lino, _end);
+
     if (pBlock == NULL) {
       break;
     }
@@ -3840,7 +3844,7 @@ int32_t createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode
       QUERY_CHECK_CODE(code, lino, _error);
     }
   }
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamSessionAgg, NULL, destroyStreamSessionAggOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamSessionAggNext, NULL, destroyStreamSessionAggOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   setOperatorStreamStateFn(pOperator, streamSessionReleaseState, streamSessionReloadState);
 
@@ -3966,7 +3970,10 @@ static int32_t doStreamSessionSemiAggNext(SOperatorInfo* pOperator, SSDataBlock*
     QUERY_CHECK_NULL(pInfo->pStUpdated, code, lino, _end, terrno);
   }
   while (1) {
-    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
+    SSDataBlock* pBlock = NULL;
+    code = downstream->fpSet.getNextFn(downstream, &pBlock);
+    QUERY_CHECK_CODE(code, lino, _end);
+
     if (pBlock == NULL) {
       pOperator->status = OP_RES_TO_RETURN;
       break;
@@ -4076,7 +4083,7 @@ int32_t createStreamFinalSessionAggOperatorInfo(SOperatorInfo* downstream, SPhys
 
   if (pPhyNode->type != QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION) {
     pOperator->fpSet =
-        createOperatorFpSet(optrDummyOpenFn, doStreamSessionSemiAgg, NULL, destroyStreamSessionAggOperatorInfo,
+        createOperatorFpSet(optrDummyOpenFn, doStreamSessionSemiAggNext, NULL, destroyStreamSessionAggOperatorInfo,
                             optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
     setOperatorStreamStateFn(pOperator, streamSessionReleaseState, streamSessionSemiReloadState);
   }
@@ -4693,7 +4700,10 @@ static int32_t doStreamStateAggNext(SOperatorInfo* pOperator, SSDataBlock** ppRe
     QUERY_CHECK_NULL(pInfo->pSeUpdated, code, lino, _end, terrno);
   }
   while (1) {
-    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
+    SSDataBlock* pBlock = NULL;
+    code = downstream->fpSet.getNextFn(downstream, &pBlock);
+    QUERY_CHECK_CODE(code, lino, _end);
+
     if (pBlock == NULL) {
       break;
     }
@@ -5014,7 +5024,7 @@ int32_t createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode*
     QUERY_CHECK_CODE(code, lino, _error);
   }
 
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamStateAgg, NULL, destroyStreamStateOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamStateAggNext, NULL, destroyStreamStateOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   setOperatorStreamStateFn(pOperator, streamStateReleaseState, streamStateReloadState);
   code = initDownStream(downstream, &pInfo->streamAggSup, pOperator->operatorType, pInfo->primaryTsIndex,
@@ -5108,7 +5118,10 @@ static int32_t doStreamIntervalAggNext(SOperatorInfo* pOperator, SSDataBlock** p
   }
 
   while (1) {
-    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
+    SSDataBlock* pBlock = NULL;
+    code = downstream->fpSet.getNextFn(downstream, &pBlock);
+    QUERY_CHECK_CODE(code, lino, _end);
+
     if (pBlock == NULL) {
       qDebug("===stream===return data:%s. recv datablock num:%" PRIu64, getStreamOpName(pOperator->operatorType),
              pInfo->numOfDatapack);
@@ -5222,12 +5235,6 @@ _end:
   return code;
 }
 
-static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t      code = doStreamIntervalAggNext(pOperator, &pRes);
-  return pRes;
-}
-
 int32_t createStreamIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo,
                                          SReadHandle* pHandle, SOperatorInfo** pOptrInfo) {
   QRY_OPTR_CHECK(pOptrInfo);
@@ -5338,7 +5345,7 @@ int32_t createStreamIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiNode*
   setOperatorInfo(pOperator, "StreamIntervalOperator", QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL, true, OP_NOT_OPENED,
                   pInfo, pTaskInfo);
   pOperator->fpSet =
-      createOperatorFpSet(optrDummyOpenFn, doStreamIntervalAgg, NULL, destroyStreamFinalIntervalOperatorInfo,
+      createOperatorFpSet(optrDummyOpenFn, doStreamIntervalAggNext, NULL, destroyStreamFinalIntervalOperatorInfo,
                           optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   setOperatorStreamStateFn(pOperator, streamIntervalReleaseState, streamIntervalReloadState);
 
@@ -5603,7 +5610,10 @@ static int32_t doStreamMidIntervalAggNext(SOperatorInfo* pOperator, SSDataBlock*
       return code;
     }
 
-    SSDataBlock* pBlock = downstream->fpSet.getNextFn(downstream);
+    SSDataBlock* pBlock = NULL;
+    code = downstream->fpSet.getNextFn(downstream, &pBlock);
+    QUERY_CHECK_CODE(code, lino, _end);
+
     if (pBlock == NULL) {
       pOperator->status = OP_RES_TO_RETURN;
       qDebug("===stream===return data:%s. recv datablock num:%" PRIu64, getStreamOpName(pOperator->operatorType),

source/libs/executor/src/sysscanoperator.c

@@ -655,16 +655,20 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) {
         }
         SSchemaWrapper* schemaWrapper = tCloneSSchemaWrapper(&smrSuperTable.me.stbEntry.schemaRow);
         if (smrSuperTable.me.stbEntry.schemaRow.pSchema) {
-          QUERY_CHECK_NULL(schemaWrapper, code, lino, _end, terrno);
+          if (schemaWrapper == NULL) {
+            code = terrno;
+            lino = __LINE__;
+            pAPI->metaReaderFn.clearReader(&smrSuperTable);
+            goto _end;
+          }
         }
         code = taosHashPut(pInfo->pSchema, &suid, sizeof(int64_t), &schemaWrapper, POINTER_BYTES);
         if (code == TSDB_CODE_DUP_KEY) {
           code = TSDB_CODE_SUCCESS;
         }
-        QUERY_CHECK_CODE(code, lino, _end);
-
         schemaRow = schemaWrapper;
         pAPI->metaReaderFn.clearReader(&smrSuperTable);
+        QUERY_CHECK_CODE(code, lino, _end);
       }
     } else if (pInfo->pCur->mr.me.type == TSDB_NORMAL_TABLE) {
       qDebug("sysTableScanUserCols cursor get normal table, %s", GET_TASKID(pTaskInfo));
@@ -789,11 +793,12 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
 
     code = sysTableUserTagsFillOneTableTags(pInfo, &smrSuperTable, &smrChildTable, dbname, tableName, &numOfRows,
                                             dataBlock);
-    QUERY_CHECK_CODE(code, lino, _end);
 
     pAPI->metaReaderFn.clearReader(&smrSuperTable);
     pAPI->metaReaderFn.clearReader(&smrChildTable);
 
+    QUERY_CHECK_CODE(code, lino, _end);
+
     if (numOfRows > 0) {
       relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo, pTaskInfo);
       numOfRows = 0;
@@ -831,6 +836,8 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
       pAPI->metaReaderFn.clearReader(&smrSuperTable);
       pAPI->metaFn.closeTableMetaCursor(pInfo->pCur);
       pInfo->pCur = NULL;
+      blockDataDestroy(dataBlock);
+      dataBlock = NULL;
       T_LONG_JMP(pTaskInfo->env, terrno);
     }
 
@@ -846,7 +853,15 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) {
     } else {
       code = sysTableUserTagsFillOneTableTags(pInfo, &smrSuperTable, &pInfo->pCur->mr, dbname, tableName, &numOfRows,
                                               dataBlock);
-      QUERY_CHECK_CODE(code, lino, _end);
+      if (code != TSDB_CODE_SUCCESS) {
+        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+        pAPI->metaReaderFn.clearReader(&smrSuperTable);
+        pAPI->metaFn.closeTableMetaCursor(pInfo->pCur);
+        pInfo->pCur = NULL;
+        blockDataDestroy(dataBlock);
+        dataBlock = NULL;
+        T_LONG_JMP(pTaskInfo->env, terrno);
+      }
     }
     pAPI->metaReaderFn.clearReader(&smrSuperTable);
   }
@@ -1354,6 +1369,171 @@ _end:
   return code;
 }
 
+static int32_t doSetUserTableMetaInfo(SStoreMetaReader* pMetaReaderFn, SStoreMeta* pMetaFn, void* pVnode,
+                                      SMetaReader* pMReader, int64_t uid, const char* dbname, int32_t vgId,
+                                      SSDataBlock* p, int32_t rowIndex, const char* idStr) {
+  char    n[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
+  int32_t lino = 0;
+  int32_t code = pMetaReaderFn->getTableEntryByUid(pMReader, uid);
+  if (code < 0) {
+    qError("failed to get table meta, uid:%" PRId64 ", code:%s, %s", uid, tstrerror(terrno), idStr);
+    return code;
+  }
+
+  STR_TO_VARSTR(n, pMReader->me.name);
+
+  // table name
+  SColumnInfoData* pColInfoData = taosArrayGet(p->pDataBlock, 0);
+  QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
+
+  code = colDataSetVal(pColInfoData, rowIndex, n, false);
+  QUERY_CHECK_CODE(code, lino, _end);
+
+  // database name
+  pColInfoData = taosArrayGet(p->pDataBlock, 1);
+  QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
+  code = colDataSetVal(pColInfoData, rowIndex, dbname, false);
+  QUERY_CHECK_CODE(code, lino, _end);
+
+  // vgId
+  pColInfoData = taosArrayGet(p->pDataBlock, 6);
+  QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
+  code = colDataSetVal(pColInfoData, rowIndex, (char*)&vgId, false);
+  QUERY_CHECK_CODE(code, lino, _end);
+
+  int32_t tableType = pMReader->me.type;
+  if (tableType == TSDB_CHILD_TABLE) {
+    // create time
+    int64_t ts = pMReader->me.ctbEntry.btime;
+    pColInfoData = taosArrayGet(p->pDataBlock, 2);
+    QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
+    code = colDataSetVal(pColInfoData, rowIndex, (char*)&ts, false);
+    QUERY_CHECK_CODE(code, lino, _end);
+
+    SMetaReader mr1 = {0};
+    pMetaReaderFn->initReader(&mr1, pVnode, META_READER_NOLOCK, pMetaFn);
+
+    int64_t suid = pMReader->me.ctbEntry.suid;
+    code = pMetaReaderFn->getTableEntryByUid(&mr1, suid);
+    if (code != TSDB_CODE_SUCCESS) {
+      qError("failed to get super table meta, cname:%s, suid:0x%" PRIx64 ", code:%s, %s", pMReader->me.name, suid,
+             tstrerror(code), idStr);
+      pMetaReaderFn->clearReader(&mr1);
+      QUERY_CHECK_CODE(code, lino, _end);
+    }
+
+    pColInfoData = taosArrayGet(p->pDataBlock, 3);
+    if (pColInfoData == NULL) {
+      pMetaReaderFn->clearReader(&mr1);
+      QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
+    }
+
+    code = colDataSetVal(pColInfoData, rowIndex, (char*)&mr1.me.stbEntry.schemaRow.nCols, false);
+    if (code != 0) {
+      pMetaReaderFn->clearReader(&mr1);
+      QUERY_CHECK_CODE(code, lino, _end);
+    }
+
+    // super table name
+    STR_TO_VARSTR(n, mr1.me.name);
+    pColInfoData = taosArrayGet(p->pDataBlock, 4);
+    if (pColInfoData == NULL) {
+      pMetaReaderFn->clearReader(&mr1);
+      QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
+    }
+
+    code = colDataSetVal(pColInfoData, rowIndex, n, false);
+    pMetaReaderFn->clearReader(&mr1);
+    QUERY_CHECK_CODE(code, lino, _end);
+
+    // table comment
+    pColInfoData = taosArrayGet(p->pDataBlock, 8);
+    QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
+    if (pMReader->me.ctbEntry.commentLen > 0) {
+      char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0};
+      STR_TO_VARSTR(comment, pMReader->me.ctbEntry.comment);
+      code = colDataSetVal(pColInfoData, rowIndex, comment, false);
+      QUERY_CHECK_CODE(code, lino, _end);
+    } else if (pMReader->me.ctbEntry.commentLen == 0) {
+      char comment[VARSTR_HEADER_SIZE + VARSTR_HEADER_SIZE] = {0};
+      STR_TO_VARSTR(comment, "");
+      code = colDataSetVal(pColInfoData, rowIndex, comment, false);
+      QUERY_CHECK_CODE(code, lino, _end);
+    } else {
+      colDataSetNULL(pColInfoData, rowIndex);
+    }
+
+    // uid
+    pColInfoData = taosArrayGet(p->pDataBlock, 5);
+    QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
+    code = colDataSetVal(pColInfoData, rowIndex, (char*)&pMReader->me.uid, false);
+    QUERY_CHECK_CODE(code, lino, _end);
+
+    // ttl
+    pColInfoData = taosArrayGet(p->pDataBlock, 7);
+    QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
+    code = colDataSetVal(pColInfoData, rowIndex, (char*)&pMReader->me.ctbEntry.ttlDays, false);
+    QUERY_CHECK_CODE(code, lino, _end);
+
+    STR_TO_VARSTR(n, "CHILD_TABLE");
+
+  } else if (tableType == TSDB_NORMAL_TABLE) {
+    // create time
+    pColInfoData = taosArrayGet(p->pDataBlock, 2);
+    QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
+    code = colDataSetVal(pColInfoData, rowIndex, (char*)&pMReader->me.ntbEntry.btime, false);
+    QUERY_CHECK_CODE(code, lino, _end);
+
+    // number of columns
+    pColInfoData = taosArrayGet(p->pDataBlock, 3);
+    QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
+
+    code = colDataSetVal(pColInfoData, rowIndex, (char*)&pMReader->me.ntbEntry.schemaRow.nCols, false);
+    QUERY_CHECK_CODE(code, lino, _end);
+
+    // super table name
+    pColInfoData = taosArrayGet(p->pDataBlock, 4);
+    QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
+    colDataSetNULL(pColInfoData, rowIndex);
+
+    // table comment
+    pColInfoData = taosArrayGet(p->pDataBlock, 8);
+    QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
+    if (pMReader->me.ntbEntry.commentLen > 0) {
+      char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0};
+      STR_TO_VARSTR(comment, pMReader->me.ntbEntry.comment);
+      code = colDataSetVal(pColInfoData, rowIndex, comment, false);
+      QUERY_CHECK_CODE(code, lino, _end);
+    } else if (pMReader->me.ntbEntry.commentLen == 0) {
+      char comment[VARSTR_HEADER_SIZE + VARSTR_HEADER_SIZE] = {0};
+      STR_TO_VARSTR(comment, "");
+      code = colDataSetVal(pColInfoData, rowIndex, comment, false);
+      QUERY_CHECK_CODE(code, lino, _end);
+    } else {
+      colDataSetNULL(pColInfoData, rowIndex);
+    }
+
+    // uid
+    pColInfoData = taosArrayGet(p->pDataBlock, 5);
+    QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
+    code = colDataSetVal(pColInfoData, rowIndex, (char*)&pMReader->me.uid, false);
+    QUERY_CHECK_CODE(code, lino, _end);
+
+    // ttl
+    pColInfoData = taosArrayGet(p->pDataBlock, 7);
+    QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
+    code = colDataSetVal(pColInfoData, rowIndex, (char*)&pMReader->me.ntbEntry.ttlDays, false);
+    QUERY_CHECK_CODE(code, lino, _end);
+
+    STR_TO_VARSTR(n, "NORMAL_TABLE");
+    // impl later
+  }
+
+_end:
+  qError("%s failed at line %d since %s, %s", __func__, lino, tstrerror(code), idStr);
+  return code;
+}
+
 static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) {
   int32_t            code = TSDB_CODE_SUCCESS;
   int32_t            lino = 0;
@@ -1395,152 +1575,15 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) {
 
     SMetaReader mr = {0};
     pAPI->metaReaderFn.initReader(&mr, pInfo->readHandle.vnode, META_READER_LOCK, &pAPI->metaFn);
-    ret = pAPI->metaReaderFn.getTableEntryByUid(&mr, *uid);
+    code = doSetUserTableMetaInfo(&pAPI->metaReaderFn, &pAPI->metaFn, pInfo->readHandle.vnode, &mr, *uid, dbname, vgId, p,
-    if (ret < 0) {
+                           numOfRows, GET_TASKID(pTaskInfo));
-      pAPI->metaReaderFn.clearReader(&mr);
-      continue;
-    }
-    STR_TO_VARSTR(n, mr.me.name);
-
-    // table name
-    SColumnInfoData* pColInfoData = taosArrayGet(p->pDataBlock, 0);
-    QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
-
-    code = colDataSetVal(pColInfoData, numOfRows, n, false);
-    QUERY_CHECK_CODE(code, lino, _end);
-
-    // database name
-    pColInfoData = taosArrayGet(p->pDataBlock, 1);
-    QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
-    code = colDataSetVal(pColInfoData, numOfRows, dbname, false);
-    QUERY_CHECK_CODE(code, lino, _end);
-
-    // vgId
-    pColInfoData = taosArrayGet(p->pDataBlock, 6);
-    QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
-    code = colDataSetVal(pColInfoData, numOfRows, (char*)&vgId, false);
-    QUERY_CHECK_CODE(code, lino, _end);
-
-    int32_t tableType = mr.me.type;
-    if (tableType == TSDB_CHILD_TABLE) {
-      // create time
-      int64_t ts = mr.me.ctbEntry.btime;
-      pColInfoData = taosArrayGet(p->pDataBlock, 2);
-      QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
-      code = colDataSetVal(pColInfoData, numOfRows, (char*)&ts, false);
-      QUERY_CHECK_CODE(code, lino, _end);
-
-      SMetaReader mr1 = {0};
-      pAPI->metaReaderFn.initReader(&mr1, pInfo->readHandle.vnode, META_READER_NOLOCK, &pAPI->metaFn);
-
-      int64_t suid = mr.me.ctbEntry.suid;
-      code = pAPI->metaReaderFn.getTableEntryByUid(&mr1, suid);
-      if (code != TSDB_CODE_SUCCESS) {
-        qError("failed to get super table meta, cname:%s, suid:0x%" PRIx64 ", code:%s, %s", mr.me.name,
-               suid, tstrerror(terrno), GET_TASKID(pTaskInfo));
-        pAPI->metaReaderFn.clearReader(&mr1);
-        pAPI->metaReaderFn.clearReader(&mr);
-        T_LONG_JMP(pTaskInfo->env, terrno);
-      }
-      pColInfoData = taosArrayGet(p->pDataBlock, 3);
-      QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
-      code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr1.me.stbEntry.schemaRow.nCols, false);
-      QUERY_CHECK_CODE(code, lino, _end);
-
-      // super table name
-      STR_TO_VARSTR(n, mr1.me.name);
-      pColInfoData = taosArrayGet(p->pDataBlock, 4);
-      QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
-      code = colDataSetVal(pColInfoData, numOfRows, n, false);
-      QUERY_CHECK_CODE(code, lino, _end);
-      pAPI->metaReaderFn.clearReader(&mr1);
-
-      // table comment
-      pColInfoData = taosArrayGet(p->pDataBlock, 8);
-      QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
-      if (mr.me.ctbEntry.commentLen > 0) {
-        char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0};
-        STR_TO_VARSTR(comment, mr.me.ctbEntry.comment);
-        code = colDataSetVal(pColInfoData, numOfRows, comment, false);
-        QUERY_CHECK_CODE(code, lino, _end);
-      } else if (mr.me.ctbEntry.commentLen == 0) {
-        char comment[VARSTR_HEADER_SIZE + VARSTR_HEADER_SIZE] = {0};
-        STR_TO_VARSTR(comment, "");
-        code = colDataSetVal(pColInfoData, numOfRows, comment, false);
-        QUERY_CHECK_CODE(code, lino, _end);
-      } else {
-        colDataSetNULL(pColInfoData, numOfRows);
-      }
-
-      // uid
-      pColInfoData = taosArrayGet(p->pDataBlock, 5);
-      QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
-      code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.uid, false);
-      QUERY_CHECK_CODE(code, lino, _end);
-
-      // ttl
-      pColInfoData = taosArrayGet(p->pDataBlock, 7);
-      QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
-      code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.ctbEntry.ttlDays, false);
-      QUERY_CHECK_CODE(code, lino, _end);
-
-      STR_TO_VARSTR(n, "CHILD_TABLE");
-
-    } else if (tableType == TSDB_NORMAL_TABLE) {
-      // create time
-      pColInfoData = taosArrayGet(p->pDataBlock, 2);
-      QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
-      code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.ntbEntry.btime, false);
-      QUERY_CHECK_CODE(code, lino, _end);
-
-      // number of columns
-      pColInfoData = taosArrayGet(p->pDataBlock, 3);
-      QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
-      code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.ntbEntry.schemaRow.nCols, false);
-      QUERY_CHECK_CODE(code, lino, _end);
-
-      // super table name
-      pColInfoData = taosArrayGet(p->pDataBlock, 4);
-      QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
-      colDataSetNULL(pColInfoData, numOfRows);
-
-      // table comment
-      pColInfoData = taosArrayGet(p->pDataBlock, 8);
-      QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
-      if (mr.me.ntbEntry.commentLen > 0) {
-        char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0};
-        STR_TO_VARSTR(comment, mr.me.ntbEntry.comment);
-        code = colDataSetVal(pColInfoData, numOfRows, comment, false);
-        QUERY_CHECK_CODE(code, lino, _end);
-      } else if (mr.me.ntbEntry.commentLen == 0) {
-        char comment[VARSTR_HEADER_SIZE + VARSTR_HEADER_SIZE] = {0};
-        STR_TO_VARSTR(comment, "");
-        code = colDataSetVal(pColInfoData, numOfRows, comment, false);
-        QUERY_CHECK_CODE(code, lino, _end);
-      } else {
-        colDataSetNULL(pColInfoData, numOfRows);
-      }
-
-      // uid
-      pColInfoData = taosArrayGet(p->pDataBlock, 5);
-      QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
-      code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.uid, false);
-      QUERY_CHECK_CODE(code, lino, _end);
-
-      // ttl
-      pColInfoData = taosArrayGet(p->pDataBlock, 7);
-      QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
-      code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.ntbEntry.ttlDays, false);
-      QUERY_CHECK_CODE(code, lino, _end);
-
-      STR_TO_VARSTR(n, "NORMAL_TABLE");
-      // impl later
-    }
 
     pAPI->metaReaderFn.clearReader(&mr);
+    QUERY_CHECK_CODE(code, lino, _end);
 
-    pColInfoData = taosArrayGet(p->pDataBlock, 9);
+    SColumnInfoData* pColInfoData = taosArrayGet(p->pDataBlock, 9);
     QUERY_CHECK_NULL(pColInfoData, code, lino, _end, terrno);
+
     code = colDataSetVal(pColInfoData, numOfRows, n, false);
     QUERY_CHECK_CODE(code, lino, _end);
 
@@ -2053,15 +2096,6 @@ static int32_t doSysTableScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes)
   }
 }
 
-static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t      code = doSysTableScanNext(pOperator, &pRes);
-  if (code) {
-    terrno = code;
-  }
-  return pRes;
-}
-
 static void sysTableScanFillTbName(SOperatorInfo* pOperator, const SSysTableScanInfo* pInfo, const char* name,
                                    SSDataBlock* pBlock) {
   int32_t        code = TSDB_CODE_SUCCESS;
@@ -2252,7 +2286,7 @@ int32_t createSysTableScanOperatorInfo(void* readHandle, SSystemTableScanPhysiNo
   setOperatorInfo(pOperator, "SysTableScanOperator", QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN, false, OP_NOT_OPENED,
                   pInfo, pTaskInfo);
   pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock);
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doSysTableScan, NULL, destroySysScanOperator,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doSysTableScanNext, NULL, destroySysScanOperator,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   *pOptrInfo = pOperator;
   return code;
@@ -2868,7 +2902,7 @@ int32_t createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDistScanP
 
   setOperatorInfo(pOperator, "DataBlockDistScanOperator", QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN, false,
                   OP_NOT_OPENED, pInfo, pTaskInfo);
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doBlockInfoScan, NULL, destroyBlockDistScanOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doBlockInfoScanNext, NULL, destroyBlockDistScanOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   *pOptrInfo = pOperator;
   return code;

source/libs/executor/src/timesliceoperator.c

@@ -1085,12 +1085,6 @@ _finished:
   return code;
 }
 
-static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t code = doTimesliceNext(pOperator, &pRes);
-  return pRes;
-}
-
 static int32_t extractPkColumnFromFuncs(SNodeList* pFuncs, bool* pHasPk, SColumn* pPkColumn) {
   SNode* pNode;
   FOREACH(pNode, pFuncs) {
@@ -1189,7 +1183,7 @@ int32_t createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyN
 
   setOperatorInfo(pOperator, "TimeSliceOperator", QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC, false, OP_NOT_OPENED, pInfo,
                   pTaskInfo);
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTimeslice, NULL, destroyTimeSliceOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTimesliceNext, NULL, destroyTimeSliceOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
 
   code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);

source/libs/executor/src/timewindowoperator.c

@@ -1161,12 +1161,6 @@ _end:
   return code;
 }
 
-static SSDataBlock* doStateWindowAgg(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t      code = doStateWindowAggNext(pOperator, &pRes);
-  return pRes;
-}
-
 static int32_t doBuildIntervalResultNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
   int32_t                   code = TSDB_CODE_SUCCESS;
   int32_t                   lino = 0;
@@ -1211,12 +1205,6 @@ _end:
   return code;
 }
 
-static SSDataBlock* doBuildIntervalResult(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t      code = doBuildIntervalResultNext(pOperator, &pRes);
-  return pRes;
-}
-
 static void destroyStateWindowOperatorInfo(void* param) {
   SStateWindowOperatorInfo* pInfo = (SStateWindowOperatorInfo*)param;
   cleanupBasicInfo(&pInfo->binfo);
@@ -1431,7 +1419,7 @@ int32_t createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPhysiNode
   setOperatorInfo(pOperator, "TimeIntervalAggOperator", QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL, true, OP_NOT_OPENED,
                   pInfo, pTaskInfo);
 
-  pOperator->fpSet = createOperatorFpSet(doOpenIntervalAgg, doBuildIntervalResult, NULL, destroyIntervalOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(doOpenIntervalAgg, doBuildIntervalResultNext, NULL, destroyIntervalOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
 
   code = appendDownstream(pOperator, &downstream, 1);
@@ -1631,12 +1619,6 @@ _end:
   return code;
 }
 
-static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t      code = doSessionWindowAggNext(pOperator, &pRes);
-  return pRes;
-}
-
 // todo make this as an non-blocking operator
 int32_t createStatewindowOperatorInfo(SOperatorInfo* downstream, SStateWinodwPhysiNode* pStateNode,
                                       SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {
@@ -1712,7 +1694,7 @@ int32_t createStatewindowOperatorInfo(SOperatorInfo* downstream, SStateWinodwPhy
 
   setOperatorInfo(pOperator, "StateWindowOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE, true, OP_NOT_OPENED, pInfo,
                   pTaskInfo);
-  pOperator->fpSet = createOperatorFpSet(openStateWindowAggOptr, doStateWindowAgg, NULL, destroyStateWindowOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(openStateWindowAggOptr, doStateWindowAggNext, NULL, destroyStateWindowOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
 
   code = appendDownstream(pOperator, &downstream, 1);
@@ -1816,7 +1798,7 @@ int32_t createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionWinodwPh
 
   setOperatorInfo(pOperator, "SessionWindowAggOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION, true, OP_NOT_OPENED,
                   pInfo, pTaskInfo);
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doSessionWindowAgg, NULL, destroySWindowOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doSessionWindowAggNext, NULL, destroySWindowOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   pOperator->pTaskInfo = pTaskInfo;
   code = appendDownstream(pOperator, &downstream, 1);
@@ -2061,12 +2043,6 @@ static int32_t mergeAlignedIntervalAggNext(SOperatorInfo* pOperator, SSDataBlock
   return code;
 }
 
-static SSDataBlock* mergeAlignedIntervalAgg(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t      code = mergeAlignedIntervalAggNext(pOperator, &pRes);
-  return pRes;
-}
-
 int32_t createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SMergeAlignedIntervalPhysiNode* pNode,
                                                       SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {
   QRY_OPTR_CHECK(pOptrInfo);
@@ -2139,7 +2115,7 @@ int32_t createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SMerge
   setOperatorInfo(pOperator, "TimeMergeAlignedIntervalAggOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL,
                   false, OP_NOT_OPENED, miaInfo, pTaskInfo);
 
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, mergeAlignedIntervalAgg, NULL, destroyMAIOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, mergeAlignedIntervalAggNext, NULL, destroyMAIOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
 
   code = appendDownstream(pOperator, &downstream, 1);
@@ -2411,12 +2387,6 @@ _end:
   return code;
 }
 
-static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) {
-  SSDataBlock* pRes = NULL;
-  int32_t code = doMergeIntervalAggNext(pOperator, &pRes);
-  return pRes;
-}
-
 int32_t createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SMergeIntervalPhysiNode* pIntervalPhyNode,
                                                SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) {
   QRY_OPTR_CHECK(pOptrInfo);
@@ -2483,7 +2453,7 @@ int32_t createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SMergeInterva
   initResultRowInfo(&pIntervalInfo->binfo.resultRowInfo);
   setOperatorInfo(pOperator, "TimeMergeIntervalAggOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE_INTERVAL, false,
                   OP_NOT_OPENED, pMergeIntervalInfo, pTaskInfo);
-  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doMergeIntervalAgg, NULL, destroyMergeIntervalOperatorInfo,
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doMergeIntervalAggNext, NULL, destroyMergeIntervalOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
 
   code = appendDownstream(pOperator, &downstream, 1);

source/libs/executor/test/joinTests.cpp

@@ -2967,7 +2967,8 @@ void runSingleTest(char* caseName, SJoinTestParam* param) {
 
     jtCtx.startTsUs = taosGetTimestampUs();
     while (true) {
-      SSDataBlock* pBlock = jtCtx.pJoinOp->fpSet.getNextFn(jtCtx.pJoinOp);
+      SSDataBlock* pBlock = NULL;
+      int32_t code = jtCtx.pJoinOp->fpSet.getNextFn(jtCtx.pJoinOp, &pBlock);
       if (NULL == pBlock) {
         checkJoinDone(caseName);
         break;

source/libs/function/src/functionMgt.c

@@ -115,24 +115,20 @@ EFuncDataRequired fmFuncDataRequired(SFunctionNode* pFunc, STimeWindow* pTimeWin
   return funcMgtBuiltins[pFunc->funcId].dataRequiredFunc(pFunc, pTimeWindow);
 }
 
-int32_t fmFuncDynDataRequired(int32_t funcId, void* pRes, SDataBlockInfo* pBlockInfo, int32_t *reqStatus) {
+EFuncDataRequired fmFuncDynDataRequired(int32_t funcId, void* pRes, SDataBlockInfo* pBlockInfo) {
   if (fmIsUserDefinedFunc(funcId) || funcId < 0 || funcId >= funcMgtBuiltinsNum) {
-    *reqStatus = -1;
+    return FUNC_DATA_REQUIRED_DATA_LOAD;
-    return TSDB_CODE_FAILED;
   }
 
   const char* name = funcMgtBuiltins[funcId].name;
   if ((strcmp(name, "_group_key") == 0) || (strcmp(name, "_select_value") == 0)) {
-    *reqStatus = FUNC_DATA_REQUIRED_NOT_LOAD;
+    return FUNC_DATA_REQUIRED_NOT_LOAD;;
-    return TSDB_CODE_SUCCESS;;
   }
 
   if (funcMgtBuiltins[funcId].dynDataRequiredFunc == NULL) {
-    *reqStatus = FUNC_DATA_REQUIRED_DATA_LOAD;
+    return FUNC_DATA_REQUIRED_DATA_LOAD;
-    return TSDB_CODE_SUCCESS;
   } else {
-    *reqStatus = funcMgtBuiltins[funcId].dynDataRequiredFunc(pRes, pBlockInfo);
+    return funcMgtBuiltins[funcId].dynDataRequiredFunc(pRes, pBlockInfo);
-    return TSDB_CODE_SUCCESS;
   }
 }
 

source/libs/scalar/src/scalar.c

@@ -74,15 +74,17 @@ int32_t sclConvertValueToSclParam(SValueNode *pValueNode, SScalarParam *out, int
 
   code = colDataSetVal(in.columnData, 0, nodesGetValueFromNode(pValueNode), false);
   if (code != TSDB_CODE_SUCCESS) {
-    return code;
+    goto  _exit;
   }
 
   code = colInfoDataEnsureCapacity(out->columnData, 1, true);
   if (code != TSDB_CODE_SUCCESS) {
-    return code;
+    goto _exit;
   }
 
   code = vectorConvertSingleColImpl(&in, out, overflow, -1, -1);
+
+_exit:
   sclFreeParam(&in);
 
   return code;

source/libs/scalar/src/sclfunc.c

@@ -581,12 +581,12 @@ static bool isCharStart(char c) {
   return strcasecmp(tsCharset, "UTF-8") == 0 ? ((c & 0xC0) != 0x80) : true;
 }
 
-static int32_t trimHelper(char *orgStr, char* remStr, int32_t orgLen, int32_t remLen, bool trimLeft) {
+static int32_t trimHelper(char *orgStr, char* remStr, int32_t orgLen, int32_t remLen, bool trimLeft, bool isNchar) {
   if (trimLeft) {
     int32_t pos = 0;
     for (int32_t i = 0; i < orgLen; i += remLen) {
       if (memcmp(orgStr + i, remStr, remLen) == 0) {
-        if (isCharStart(orgStr[i + remLen])) {
+        if (isCharStart(orgStr[i + remLen]) || isNchar) {
           pos = i + remLen;
           continue;
         } else {
@@ -601,7 +601,7 @@ static int32_t trimHelper(char *orgStr, char* remStr, int32_t orgLen, int32_t re
     int32_t pos = orgLen;
     for (int32_t i = orgLen - remLen; i >= 0; i -= remLen) {
       if (memcmp(orgStr + i, remStr, remLen) == 0) {
-        if (isCharStart(orgStr[i])) {
+        if (isCharStart(orgStr[i]) || isNchar) {
           pos = i;
           continue;
         } else {
@@ -671,7 +671,7 @@ static int32_t tltrim(char *input, char *remInput, char *output, int32_t inputTy
     return TSDB_CODE_SUCCESS;
   }
 
-  pos = trimHelper(orgStr, remStr, orgLen, remLen, true);
+  pos = trimHelper(orgStr, remStr, orgLen, remLen, true, inputType == TSDB_DATA_TYPE_NCHAR);
 
   if (needFree) {
     taosMemoryFree(remStr);
@@ -735,7 +735,7 @@ static int32_t trtrim(char *input, char *remInput, char *output, int32_t inputTy
     return TSDB_CODE_SUCCESS;
   }
 
-  pos = trimHelper(orgStr, remStr, orgLen, remLen, false);
+  pos = trimHelper(orgStr, remStr, orgLen, remLen, false, inputType == TSDB_DATA_TYPE_NCHAR);
 
   if (needFree) {
     taosMemoryFree(remStr);
@@ -769,8 +769,8 @@ static int32_t tlrtrim(char *input, char *remInput, char *output, int32_t inputT
     return TSDB_CODE_SUCCESS;
   }
 
-  int32_t leftPos = trimHelper(orgStr, remStr, orgLen, remLen, true);
+  int32_t leftPos = trimHelper(orgStr, remStr, orgLen, remLen, true, inputType == TSDB_DATA_TYPE_NCHAR);
-  int32_t rightPos = trimHelper(orgStr, remStr, orgLen, remLen, false);
+  int32_t rightPos = trimHelper(orgStr, remStr, orgLen, remLen, false, inputType == TSDB_DATA_TYPE_NCHAR);
 
   if (needFree) {
     taosMemoryFree(remStr);
@@ -1112,12 +1112,15 @@ _return:
   return code;
 }
 
-static int32_t findPosBytes(char *orgStr, char *delimStr, int32_t orgLen, int32_t delimLen, int32_t charNums) {
+static int32_t findPosBytes(char *orgStr, char *delimStr, int32_t orgLen, int32_t delimLen, int32_t charNums, bool isNchar) {
   int32_t charCount = 0;
   if (charNums > 0) {
     for (int32_t pos = 0; pos < orgLen; pos++) {
       if (delimStr) {
-        if (isCharStart(orgStr[pos]) && memcmp(orgStr + pos, delimStr, delimLen) == 0) {
+        if (pos + delimLen > orgLen)  {
+          return orgLen;
+        }
+        if ((isCharStart(orgStr[pos]) || isNchar) && memcmp(orgStr + pos, delimStr, delimLen) == 0) {
           charCount++;
           if (charCount == charNums) {
             return pos;
@@ -1125,7 +1128,7 @@ static int32_t findPosBytes(char *orgStr, char *delimStr, int32_t orgLen, int32_
           pos = pos + delimLen - 1;
         }
       } else {
-        if (isCharStart(orgStr[pos])) {
+        if ((isCharStart(orgStr[pos]) || isNchar)) {
           charCount++;
           if (charCount == charNums) {
             return pos;
@@ -1136,8 +1139,8 @@ static int32_t findPosBytes(char *orgStr, char *delimStr, int32_t orgLen, int32_
     return orgLen;
   } else {
     if (delimStr) {
-      for (int32_t pos = orgLen - 1; pos >= 0; pos--) {
+      for (int32_t pos = orgLen - delimLen; pos >= 0; pos--) {
-        if (isCharStart(orgStr[pos]) && memcmp(orgStr + pos, delimStr, delimLen) == 0) {
+        if ((isCharStart(orgStr[pos]) || isNchar) && memcmp(orgStr + pos, delimStr, delimLen) == 0) {
           charCount++;
           if (charCount == -charNums) {
             return pos + delimLen;
@@ -1147,7 +1150,7 @@ static int32_t findPosBytes(char *orgStr, char *delimStr, int32_t orgLen, int32_
       }
     } else {
       for (int32_t pos = orgLen - 1; pos >= 0; pos--) {
-        if (isCharStart(orgStr[pos])) {
+        if ((isCharStart(orgStr[pos]) || isNchar)) {
           charCount++;
           if (charCount == -charNums) {
             return pos;
@@ -1224,17 +1227,17 @@ int32_t substrFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu
     int32_t startPosBytes;
     int32_t endPosBytes = len;
     if (subPos > 0) {
-      startPosBytes = (GET_PARAM_TYPE(&pInput[0]) == TSDB_DATA_TYPE_VARCHAR) ? findPosBytes(varDataVal(input), NULL, varDataLen(input), -1, subPos) : (subPos - 1) * TSDB_NCHAR_SIZE;
+      startPosBytes = (GET_PARAM_TYPE(&pInput[0]) == TSDB_DATA_TYPE_VARCHAR) ? findPosBytes(varDataVal(input), NULL, varDataLen(input), -1, subPos, false) : (subPos - 1) * TSDB_NCHAR_SIZE;
       startPosBytes = TMIN(startPosBytes, len);
     } else {
       startPosBytes =
-          (GET_PARAM_TYPE(&pInput[0]) == TSDB_DATA_TYPE_VARCHAR) ? findPosBytes(varDataVal(input), NULL, varDataLen(input), -1, subPos) : len + subPos * TSDB_NCHAR_SIZE;
+          (GET_PARAM_TYPE(&pInput[0]) == TSDB_DATA_TYPE_VARCHAR) ? findPosBytes(varDataVal(input), NULL, varDataLen(input), -1, subPos, false) : len + subPos * TSDB_NCHAR_SIZE;
       startPosBytes = TMAX(startPosBytes, 0);
     }
     if (inputNum == 3) {
       endPosBytes =
           (GET_PARAM_TYPE(&pInput[0]) == TSDB_DATA_TYPE_VARCHAR)
-              ? startPosBytes + findPosBytes(varDataVal(input) + startPosBytes, NULL, varDataLen(input) - startPosBytes, -1, subLen + 1)
+              ? startPosBytes + findPosBytes(varDataVal(input) + startPosBytes, NULL, varDataLen(input) - startPosBytes, -1, subLen + 1, false)
               : startPosBytes + subLen * TSDB_NCHAR_SIZE;
       endPosBytes = TMIN(endPosBytes, len);
     }
@@ -1375,18 +1378,31 @@ int32_t asciiFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOut
       colDataSetNULL(pOutputData, i);
       continue;
     }
-    char *in = colDataGetData(pInputData, i);
+    if (type == TSDB_DATA_TYPE_NCHAR) {
-    out[i] = (uint8_t)(varDataVal(in))[0];
+      char   *in = varDataVal(colDataGetData(pInputData, i));
+      int32_t inLen = varDataLen(colDataGetData(pInputData, i));
+      SCL_ERR_RET(convBetweenNcharAndVarchar(varDataVal(colDataGetData(pInputData, i)), &in,
+                                             varDataLen(colDataGetData(pInputData, i)), &inLen,
+                                             TSDB_DATA_TYPE_VARBINARY));
+      out[i] = (uint8_t)(in)[0];
+      taosMemoryFree(in);
+    } else {
+      char *in = colDataGetData(pInputData, i);
+      out[i] = (uint8_t)(varDataVal(in))[0];
+    }
   }
 
   pOutput->numOfRows = pInput->numOfRows;
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t findPosChars(char *orgStr, char *delimStr, int32_t orgLen, int32_t delimLen, bool isUcs4) {
+static int32_t findPosChars(char *orgStr, char *delimStr, int32_t orgLen, int32_t delimLen, bool isNchar) {
   int32_t charCount = 0;
-  for (int32_t pos = 0; pos < orgLen; pos += isUcs4 ? TSDB_NCHAR_SIZE : 1) {
+  for (int32_t pos = 0; pos < orgLen; pos += isNchar ? TSDB_NCHAR_SIZE : 1) {
-    if (isUcs4 || isCharStart(orgStr[pos])) {
+    if (isNchar || isCharStart(orgStr[pos])) {
+      if (pos + delimLen > orgLen) {
+        return 0;
+      }
       if (memcmp(orgStr + pos, delimStr, delimLen) == 0) {
         return charCount + 1;
       } else {
@@ -1487,19 +1503,14 @@ int32_t replaceFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pO
   }
 
   int8_t  orgType = pInputData[0]->info.type;
-  int8_t  fromType = pInputData[1]->info.type;
   int8_t  toType = pInputData[2]->info.type;
-  int32_t orgLength = pInputData[0]->info.bytes;
+  int32_t orgLength = pInputData[0]->info.bytes - VARSTR_HEADER_SIZE;
-  int32_t fromLength = pInputData[1]->info.bytes;
+  int32_t toLength = pInputData[2]->info.bytes - VARSTR_HEADER_SIZE;
-  int32_t toLength = pInputData[2]->info.bytes;
 
-  if (orgType == TSDB_DATA_TYPE_VARBINARY && fromType != orgType) {
-    fromLength = fromLength / TSDB_NCHAR_SIZE;
-  }
   if (orgType == TSDB_DATA_TYPE_NCHAR && toType != orgType) {
     toLength = toLength * TSDB_NCHAR_SIZE;
   }
-  outputLen = TMAX(orgLength, orgLength + orgLength / fromLength * (toLength - fromLength));
+  outputLen = toLength == 0 ? orgLength : TMIN(TSDB_MAX_FIELD_LEN, orgLength * toLength);
 
   if (GET_PARAM_TYPE(&pInput[0]) == TSDB_DATA_TYPE_NULL ||
       GET_PARAM_TYPE(&pInput[1]) == TSDB_DATA_TYPE_NULL ||
@@ -1528,8 +1539,8 @@ int32_t replaceFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pO
     char   *output = outputBuf + VARSTR_HEADER_SIZE;
     int32_t totalLen = 0;
 
-    char   *orgStr = varDataVal(colDataGetData(pInputData[0], i));
+    char   *orgStr = varDataVal(colDataGetData(pInputData[0], colIdx1));
-    int32_t orgLen = varDataLen(colDataGetData(pInputData[0], i));
+    int32_t orgLen = varDataLen(colDataGetData(pInputData[0], colIdx1));
     char   *fromStr = varDataVal(colDataGetData(pInputData[1], colIdx2));
     int32_t fromLen = varDataLen(colDataGetData(pInputData[1], colIdx2));
     char   *toStr = varDataVal(colDataGetData(pInputData[2], colIdx3));
@@ -1537,6 +1548,14 @@ int32_t replaceFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pO
     bool    needFreeFrom = false;
     bool    needFreeTo = false;
 
+    if (fromLen == 0 || orgLen == 0) {
+      (void)memcpy(output, orgStr, orgLen);
+      totalLen = orgLen;
+      varDataSetLen(outputBuf, totalLen);
+      SCL_ERR_JRET(colDataSetVal(pOutputData, i, outputBuf, false));
+      continue;
+    }
+
     if (GET_PARAM_TYPE(&pInput[1]) != GET_PARAM_TYPE(&pInput[0])) {
       SCL_ERR_JRET(convBetweenNcharAndVarchar(varDataVal(colDataGetData(pInputData[1], colIdx2)), &fromStr,
                                              varDataLen(colDataGetData(pInputData[1], colIdx2)), &fromLen,
@@ -1558,7 +1577,16 @@ int32_t replaceFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pO
 
     int32_t pos = 0;
     while (pos < orgLen) {
-      if (memcmp(orgStr + pos, fromStr, fromLen) == 0) {
+      if (orgLen - pos < fromLen) {
+        (void)memcpy(output, orgStr + pos, orgLen - pos);
+        output += orgLen - pos;
+        totalLen += orgLen - pos;
+        break;
+      }
+      if (memcmp(orgStr + pos, fromStr, fromLen) == 0 &&
+          (pos + fromLen == orgLen ||
+           isCharStart(orgStr[pos + fromLen]) ||
+           GET_PARAM_TYPE(&pInput[0]) == TSDB_DATA_TYPE_NCHAR)) {
         (void)memcpy(output, toStr, toLen);
         output += toLen;
         pos += fromLen;
@@ -1577,6 +1605,9 @@ int32_t replaceFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pO
     if (needFreeFrom) {
       taosMemoryFree(fromStr);
     }
+    if (totalLen > TSDB_MAX_FIELD_LEN) {
+      SCL_ERR_JRET(TSDB_CODE_FUNC_INVALID_RES_LENGTH);
+    }
     varDataSetLen(outputBuf, totalLen);
     SCL_ERR_JRET(colDataSetVal(pOutputData, i, outputBuf, false));
   }
@@ -1646,9 +1677,9 @@ int32_t substrIdxFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *
 
     if (count > 0) {
       startPosBytes = 0;
-      endPosBytes = findPosBytes(orgStr, delimStr, orgLen, delimLen, count);
+      endPosBytes = findPosBytes(orgStr, delimStr, orgLen, delimLen, count, GET_PARAM_TYPE(&pInput[0]) == TSDB_DATA_TYPE_NCHAR);
     } else if (count < 0) {
-      startPosBytes = findPosBytes(orgStr, delimStr, orgLen, delimLen, count);
+      startPosBytes = findPosBytes(orgStr, delimStr, orgLen, delimLen, count, GET_PARAM_TYPE(&pInput[0]) == TSDB_DATA_TYPE_NCHAR);
       endPosBytes = orgLen;
     } else {
       startPosBytes = endPosBytes = 0;
@@ -1692,6 +1723,9 @@ int32_t repeatFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu
 
   for (int32_t i = 0; i < pInput[1].numOfRows; i++) {
     int32_t tmpCount = 0;
+    if (colDataIsNull_s(pInput[1].columnData, i)) {
+      continue;
+    }
     GET_TYPED_DATA(tmpCount, int32_t, GET_PARAM_TYPE(&pInput[1]), colDataGetData(pInput[1].columnData, i));
     maxCount = TMAX(maxCount, tmpCount);
   }
@@ -2926,12 +2960,13 @@ static int32_t doScalarFunction2(SScalarParam *pInput, int32_t inputNum, SScalar
         colDataSetNULL(pOutputData, i);
         continue;
       }
+      double in2;
+      GET_TYPED_DATA(in2, double, GET_PARAM_TYPE(&pInput[1]), colDataGetData(pInputData[1], i));
       switch (GET_PARAM_TYPE(&pInput[0])) {
         case TSDB_DATA_TYPE_DOUBLE: {
           double  *in = (double *)pInputData[0]->pData;
-          int64_t *in2 = (int64_t *)pInputData[1]->pData;
           double  *out = (double *)pOutputData->pData;
-          double  result = d1(in[i], (double)in2[i]);
+          double  result = d1(in[i], in2);
           if (isinf(result) || isnan(result)) {
             colDataSetNULL(pOutputData, i);
           } else {
@@ -2941,9 +2976,8 @@ static int32_t doScalarFunction2(SScalarParam *pInput, int32_t inputNum, SScalar
         }
         case TSDB_DATA_TYPE_FLOAT: {
           float   *in = (float *)pInputData[0]->pData;
-          int64_t *in2 = (int64_t *)pInputData[1]->pData;
           float   *out = (float *)pOutputData->pData;
-          float   result = f1(in[i], (float)in2[i]);
+          float   result = f1(in[i], (float)in2);
           if (isinf(result) || isnan(result)) {
             colDataSetNULL(pOutputData, i);
           } else {
@@ -2956,9 +2990,8 @@ static int32_t doScalarFunction2(SScalarParam *pInput, int32_t inputNum, SScalar
         case TSDB_DATA_TYPE_INT:
         case TSDB_DATA_TYPE_BIGINT:{
           int64_t *in = (int64_t *)pInputData[0]->pData;
-          int64_t *in2 = (int64_t *)pInputData[1]->pData;
           int64_t *out = (int64_t *)pOutputData->pData;
-          int64_t result = (int64_t)d1((double)in[i], (double)in2[i]);
+          int64_t result = (int64_t)d1((double)in[i], in2);
           out[i] = result;
           break;
         }
@@ -2967,9 +3000,8 @@ static int32_t doScalarFunction2(SScalarParam *pInput, int32_t inputNum, SScalar
         case TSDB_DATA_TYPE_UINT:
         case TSDB_DATA_TYPE_UBIGINT:{
           uint64_t *in = (uint64_t *)pInputData[0]->pData;
-          int64_t  *in2 = (int64_t *)pInputData[1]->pData;
           uint64_t *out = (uint64_t *)pOutputData->pData;
-          uint64_t result = (uint64_t)d1((double)in[i], (double)in2[i]);
+          uint64_t result = (uint64_t)d1((double)in[i], in2);
           out[i] = result;
           break;
         }
@@ -2984,12 +3016,13 @@ static int32_t doScalarFunction2(SScalarParam *pInput, int32_t inputNum, SScalar
           colDataSetNULL(pOutputData, i);
           continue;
         }
+        double in2;
+        GET_TYPED_DATA(in2, double, GET_PARAM_TYPE(&pInput[1]), colDataGetData(pInputData[1], i));
         switch (GET_PARAM_TYPE(&pInput[0])) {
           case TSDB_DATA_TYPE_DOUBLE: {
             double   *in = (double *)pInputData[0]->pData;
-            int64_t  *in2 = (int64_t *)pInputData[1]->pData;
             double   *out = (double *)pOutputData->pData;
-            double   result = d1(in[0], (double)in2[i]);
+            double   result = d1(in[0], in2);
             if (isinf(result) || isnan(result)) {
               colDataSetNULL(pOutputData, i);
             } else {
@@ -2999,9 +3032,8 @@ static int32_t doScalarFunction2(SScalarParam *pInput, int32_t inputNum, SScalar
           }
           case TSDB_DATA_TYPE_FLOAT: {
             float   *in = (float *)pInputData[0]->pData;
-            int64_t *in2 = (int64_t *)pInputData[1]->pData;
             float   *out = (float *)pOutputData->pData;
-            float   result = f1(in[0], (float)in2[i]);
+            float   result = f1(in[0], (float)in2);
             if (isinf(result) || isnan(result)) {
               colDataSetNULL(pOutputData, i);
             } else {
@@ -3014,9 +3046,8 @@ static int32_t doScalarFunction2(SScalarParam *pInput, int32_t inputNum, SScalar
           case TSDB_DATA_TYPE_INT:
           case TSDB_DATA_TYPE_BIGINT:{
             int64_t *in = (int64_t *)pInputData[0]->pData;
-            int64_t *in2 = (int64_t *)pInputData[1]->pData;
             int64_t *out = (int64_t *)pOutputData->pData;
-            int64_t result = (int64_t)d1((double)in[0], (double)in2[i]);
+            int64_t result = (int64_t)d1((double)in[0], in2);
             out[i] = result;
             break;
           }
@@ -3025,9 +3056,8 @@ static int32_t doScalarFunction2(SScalarParam *pInput, int32_t inputNum, SScalar
           case TSDB_DATA_TYPE_UINT:
           case TSDB_DATA_TYPE_UBIGINT:{
             uint64_t *in = (uint64_t *)pInputData[0]->pData;
-            int64_t  *in2 = (int64_t *)pInputData[1]->pData;
             uint64_t *out = (uint64_t *)pOutputData->pData;
-            uint64_t result = (uint64_t)d1((double)in[0], (double)in2[i]);
+            uint64_t result = (uint64_t)d1((double)in[0], in2);
             out[i] = result;
             break;
           }
@@ -3043,12 +3073,13 @@ static int32_t doScalarFunction2(SScalarParam *pInput, int32_t inputNum, SScalar
           colDataSetNULL(pOutputData, i);
           continue;
         }
+        double in2;
+        GET_TYPED_DATA(in2, double, GET_PARAM_TYPE(&pInput[1]), colDataGetData(pInputData[1], 0));
         switch (GET_PARAM_TYPE(&pInput[0])) {
           case TSDB_DATA_TYPE_DOUBLE: {
             double   *in = (double *)pInputData[0]->pData;
-            int64_t  *in2 = (int64_t *)pInputData[1]->pData;
             double   *out = (double *)pOutputData->pData;
-            double   result = d1(in[i], (double)in2[0]);
+            double   result = d1(in[i], in2);
             if (isinf(result) || isnan(result)) {
               colDataSetNULL(pOutputData, i);
             } else {
@@ -3058,9 +3089,8 @@ static int32_t doScalarFunction2(SScalarParam *pInput, int32_t inputNum, SScalar
           }
           case TSDB_DATA_TYPE_FLOAT: {
             float   *in = (float *)pInputData[0]->pData;
-            int64_t *in2 = (int64_t *)pInputData[1]->pData;
             float   *out = (float *)pOutputData->pData;
-            float   result = f1(in[i], (float)in2[0]);
+            float   result = f1(in[i], in2);
             if (isinf(result) || isnan(result)) {
               colDataSetNULL(pOutputData, i);
             } else {
@@ -3073,9 +3103,8 @@ static int32_t doScalarFunction2(SScalarParam *pInput, int32_t inputNum, SScalar
           case TSDB_DATA_TYPE_INT:
           case TSDB_DATA_TYPE_BIGINT:{
             int64_t *in = (int64_t *)pInputData[0]->pData;
-            int64_t *in2 = (int64_t *)pInputData[1]->pData;
             int64_t *out = (int64_t *)pOutputData->pData;
-            int64_t result = (int64_t)d1((double)in[i], (double)in2[0]);
+            int64_t result = (int64_t)d1((double)in[i], in2);
             out[i] = result;
             break;
           }
@@ -3084,9 +3113,8 @@ static int32_t doScalarFunction2(SScalarParam *pInput, int32_t inputNum, SScalar
           case TSDB_DATA_TYPE_UINT:
           case TSDB_DATA_TYPE_UBIGINT:{
             uint64_t *in = (uint64_t *)pInputData[0]->pData;
-            int64_t  *in2 = (int64_t *)pInputData[1]->pData;
             uint64_t *out = (uint64_t *)pOutputData->pData;
-            uint64_t result = (uint64_t)d1((double)in[i], (double)in2[0]);
+            uint64_t result = (uint64_t)d1((double)in[i], in2);
             out[i] = result;
             break;
           }

source/libs/sync/inc/syncUtil.h

@@ -32,6 +32,13 @@ extern "C" {
 #define sDebug(...) if (sDebugFlag & DEBUG_DEBUG) { taosPrintLog("SYN ",       DEBUG_DEBUG, sDebugFlag, __VA_ARGS__); }
 #define sTrace(...) if (sDebugFlag & DEBUG_TRACE) { taosPrintLog("SYN ",       DEBUG_TRACE, sDebugFlag, __VA_ARGS__); }
 
+#define sGTrace(param, ...) do { if (sDebugFlag & DEBUG_TRACE) { char buf[40] = {0}; TRACE_TO_STR(trace, buf); sTrace(param ", QID:%s", __VA_ARGS__, buf);}} while(0)
+#define sGFatal(param, ...) do { if (sDebugFlag & DEBUG_FATAL) { char buf[40] = {0}; TRACE_TO_STR(trace, buf); sFatal(param ", QID:%s", __VA_ARGS__, buf);}} while(0)
+#define sGError(param, ...) do { if (sDebugFlag & DEBUG_ERROR) { char buf[40] = {0}; TRACE_TO_STR(trace, buf);sError(param ", QID:%s", __VA_ARGS__, buf);}} while(0)
+#define sGWarn(param, ...)  do { if (sDebugFlag & DEBUG_WARN)  { char buf[40] = {0}; TRACE_TO_STR(trace, buf); sWarn(param ", QID:%s", __VA_ARGS__, buf);}} while(0)
+#define sGInfo(param, ...)  do { if (sDebugFlag & DEBUG_INFO)  { char buf[40] = {0}; TRACE_TO_STR(trace, buf); sInfo(param ", QID:%s", __VA_ARGS__, buf);}} while(0)
+#define sGDebug(param, ...) do { if (sDebugFlag & DEBUG_DEBUG) { char buf[40] = {0}; TRACE_TO_STR(trace, buf); sDebug(param ", QID:%s", __VA_ARGS__, buf);}}    while(0)
+
 #define sLFatal(...) if (sDebugFlag & DEBUG_FATAL) { taosPrintLongString("SYN FATAL ", DEBUG_FATAL, 255,        __VA_ARGS__); }
 #define sLError(...) if (sDebugFlag & DEBUG_ERROR) { taosPrintLongString("SYN ERROR ", DEBUG_ERROR, 255,        __VA_ARGS__); }
 #define sLWarn(...)  if (sDebugFlag & DEBUG_WARN)  { taosPrintLongString("SYN WARN ",  DEBUG_WARN,  255,        __VA_ARGS__); }

source/libs/sync/src/syncMain.c

@@ -2650,7 +2650,9 @@ static void syncNodeEqPeerHeartbeatTimer(void* param, void* tmrId) {
         pSyncTimer->timeStamp = tsNow;
 
         // send msg
-        sTrace("vgId:%d, send heartbeat to dnode:%d", pSyncNode->vgId, DID(&(pSyncMsg->destId)));
+        TRACE_SET_MSGID(&(rpcMsg.info.traceId), tGenIdPI64());
+        STraceId* trace = &(rpcMsg.info.traceId);
+        sGTrace("vgId:%d, send sync-heartbeat to dnode:%d", pSyncNode->vgId, DID(&(pSyncMsg->destId)));
         syncLogSendHeartbeat(pSyncNode, pSyncMsg, false, timerElapsed, pData->execTime);
         (void)syncNodeSendHeartbeat(pSyncNode, &pSyncMsg->destId, &rpcMsg);
       } else {
@@ -3434,7 +3436,7 @@ int32_t syncNodeOnHeartbeat(SSyncNode* ths, const SRpcMsg* pRpcMsg) {
   pMsgReply->startTime = ths->startTime;
   pMsgReply->timeStamp = tsMs;
 
-  sTrace("vgId:%d, heartbeat msg from dnode:%d, cluster:%d, Msgterm:%" PRId64 " currentTerm:%" PRId64, ths->vgId,
+  sGTrace("vgId:%d, process sync-heartbeat msg from dnode:%d, cluster:%d, Msgterm:%" PRId64 " currentTerm:%" PRId64, ths->vgId,
          DID(&(pMsg->srcId)), CID(&(pMsg->srcId)), pMsg->term, currentTerm);
 
   if (pMsg->term > currentTerm && ths->state == TAOS_SYNC_STATE_LEARNER) {

source/libs/sync/src/syncReplication.c

@@ -112,6 +112,9 @@ int32_t syncNodeHeartbeatPeers(SSyncNode* pSyncNode) {
     pSyncMsg->timeStamp = ts;
 
     // send msg
+    TRACE_SET_MSGID(&(rpcMsg.info.traceId), tGenIdPI64());
+    STraceId* trace = &(rpcMsg.info.traceId);
+    sGTrace("vgId:%d, send sync-heartbeat to dnode:%d", pSyncNode->vgId, DID(&(pSyncMsg->destId)));
     syncLogSendHeartbeat(pSyncNode, pSyncMsg, true, 0, 0);
     (void)syncNodeSendHeartbeat(pSyncNode, &pSyncMsg->destId, &rpcMsg);
   }

source/libs/sync/src/syncUtil.c

@@ -394,13 +394,13 @@ void syncLogRecvHeartbeat(SSyncNode* pSyncNode, const SyncHeartbeat* pMsg, int64
 
     sNTrace(pSyncNode,
             "recv sync-heartbeat from dnode:%d slow {term:%" PRId64 ", commit-index:%" PRId64 ", min-match:%" PRId64
-            ", ts:%" PRId64 "}, %s, net elapsed:%" PRId64,
+            ", ts:%" PRId64 "}, QID:%s, net elapsed:%" PRId64,
             DID(&pMsg->srcId), pMsg->term, pMsg->commitIndex, pMsg->minMatchIndex, pMsg->timeStamp, s, timeDiff);
   }
 
   sNTrace(pSyncNode,
           "recv sync-heartbeat from dnode:%d {term:%" PRId64 ", commit-index:%" PRId64 ", min-match:%" PRId64
-          ", ts:%" PRId64 "}, %s, net elapsed:%" PRId64,
+          ", ts:%" PRId64 "}, QID:%s, net elapsed:%" PRId64,
           DID(&pMsg->srcId), pMsg->term, pMsg->commitIndex, pMsg->minMatchIndex, pMsg->timeStamp, s, timeDiff);
 }
 

source/libs/transport/inc/transComm.h

@@ -272,31 +272,19 @@ bool    transAsyncPoolIsEmpty(SAsyncPool* pool);
     }                                                                \
   } while (0)
 
-#define ASYNC_CHECK_HANDLE(exh1, id)                                                                         \
+#define ASYNC_CHECK_HANDLE(exh1, id)                                \
-  do {                                                                                                       \
+  do {                                                              \
-    if (id > 0) {                                                                                            \
+    if (id > 0) {                                                   \
-      SExHandle* exh2 = transAcquireExHandle(transGetRefMgt(), id);                                          \
+      SExHandle* exh2 = transAcquireExHandle(transGetRefMgt(), id); \
-      if (exh2 == NULL || id != exh2->refId) {                                                               \
+      if (exh2 == NULL || id != exh2->refId) {                      \
-        tTrace("handle %p except, may already freed, ignore msg, ref1:%" PRIu64 ", ref2:%" PRIu64, exh1,     \
+        tDebug("ref:%" PRId64 " already released" PRIu64, id);      \
-               exh2 ? exh2->refId : 0, id);                                                                  \
+        code = terrno;                                              \
-        code = terrno;                                                                                       \
+        goto _return1;                                              \
-        goto _return1;                                                                                       \
+      }                                                             \
-      }                                                                                                      \
+    } else {                                                        \
-    } else if (id == 0) {                                                                                    \
+      tWarn("invalid handle to release");                           \
-      tTrace("handle step2");                                                                                \
+      goto _return2;                                                \
-      SExHandle* exh2 = transAcquireExHandle(transGetRefMgt(), id);                                          \
+    }                                                               \
-      if (exh2 == NULL || id == exh2->refId) {                                                               \
-        tTrace("handle %p except, may already freed, ignore msg, ref1:%" PRIu64 ", ref2:%" PRIu64, exh1, id, \
-               exh2 ? exh2->refId : 0);                                                                      \
-        code = terrno;                                                                                       \
-        goto _return1;                                                                                       \
-      } else {                                                                                               \
-        id = exh1->refId;                                                                                    \
-      }                                                                                                      \
-    } else if (id < 0) {                                                                                     \
-      tTrace("handle step3");                                                                                \
-      goto _return2;                                                                                         \
-    }                                                                                                        \
   } while (0)
 
 int32_t transInitBuffer(SConnBuffer* buf);

source/libs/transport/src/transCli.c

@@ -2927,7 +2927,7 @@ int32_t transReleaseCliHandle(void* handle) {
 }
 
 static int32_t transInitMsg(void* shandle, const SEpSet* pEpSet, STransMsg* pReq, STransCtx* ctx, SCliMsg** pCliMsg) {
-  TRACE_SET_MSGID(&pReq->info.traceId, tGenIdPI64());
+  if (pReq->info.traceId.msgId == 0) TRACE_SET_MSGID(&pReq->info.traceId, tGenIdPI64());
   STransConnCtx* pCtx = taosMemoryCalloc(1, sizeof(STransConnCtx));
   if (pCtx == NULL) {
     return TSDB_CODE_OUT_OF_MEMORY;
@@ -3095,7 +3095,7 @@ int32_t transSendRecv(void* shandle, const SEpSet* pEpSet, STransMsg* pReq, STra
     TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), NULL, _RETURN1);
   }
 
-  TRACE_SET_MSGID(&pReq->info.traceId, tGenIdPI64());
+  if (pReq->info.traceId.msgId == 0) TRACE_SET_MSGID(&pReq->info.traceId, tGenIdPI64());
 
   STransConnCtx* pCtx = taosMemoryCalloc(1, sizeof(STransConnCtx));
   if (pCtx == NULL) {
@@ -3207,7 +3207,7 @@ int32_t transSendRecvWithTimeout(void* shandle, SEpSet* pEpSet, STransMsg* pReq,
     TAOS_CHECK_GOTO(TSDB_CODE_RPC_BROKEN_LINK, NULL, _RETURN2);
   }
 
-  TRACE_SET_MSGID(&pReq->info.traceId, tGenIdPI64());
+  if (pReq->info.traceId.msgId == 0) TRACE_SET_MSGID(&pReq->info.traceId, tGenIdPI64());
 
   STransConnCtx* pCtx = taosMemoryCalloc(1, sizeof(STransConnCtx));
   if (pCtx == NULL) {

source/os/src/osDir.c

@@ -294,6 +294,8 @@ void taosRemoveOldFiles(const char *dirname, int32_t keepDays) {
       int32_t len = (int32_t)strlen(filename);
       if (len > 3 && strcmp(filename + len - 3, ".gz") == 0) {
         len -= 3;
+      }else{
+        continue;
       }
 
       int64_t fileSec = 0;
@@ -308,7 +310,7 @@ void taosRemoveOldFiles(const char *dirname, int32_t keepDays) {
       int32_t days = (int32_t)(TABS(sec - fileSec) / 86400 + 1);
       if (days > keepDays) {
         (void)taosRemoveFile(filename);
-        // printf("file:%s is removed, days:%d keepDays:%d", filename, days, keepDays);
+         uInfo("file:%s is removed, days:%d keepDays:%d, sed:%"PRId64, filename, days, keepDays, fileSec);
       } else {
         // printf("file:%s won't be removed, days:%d keepDays:%d", filename, days, keepDays);
       }

source/os/src/osEnv.c

@@ -29,7 +29,7 @@ enum TdTimezone tsTimezone = TdZeroZone;
 char            tsLocale[TD_LOCALE_LEN] = {0};
 char            tsCharset[TD_CHARSET_LEN] = {0};
 int8_t          tsDaylight = 0;
-bool            tsEnableCoreFile = 0;
+bool            tsEnableCoreFile = 1;
 int64_t         tsPageSizeKB = 0;
 int64_t         tsOpenMax = 0;
 int64_t         tsStreamMax = 0;