Merge branch '3.0' of https://github.com/taosdata/TDengine into enh/TS-30987-15

include/common/tmsg.h

@@ -2828,19 +2828,24 @@ static FORCE_INLINE int32_t tSerializeSCMSubscribeReq(void** buf, const SCMSubsc
   return tlen;
 }
 
-static FORCE_INLINE void* tDeserializeSCMSubscribeReq(void* buf, SCMSubscribeReq* pReq) {
+static FORCE_INLINE int32_t tDeserializeSCMSubscribeReq(void* buf, SCMSubscribeReq* pReq) {
   buf = taosDecodeFixedI64(buf, &pReq->consumerId);
   buf = taosDecodeStringTo(buf, pReq->cgroup);
   buf = taosDecodeStringTo(buf, pReq->clientId);
 
-  int32_t topicNum;
+  int32_t topicNum = 0;
   buf = taosDecodeFixedI32(buf, &topicNum);
 
   pReq->topicNames = taosArrayInit(topicNum, sizeof(void*));
+  if (pReq->topicNames == NULL){
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
   for (int32_t i = 0; i < topicNum; i++) {
-    char* name;
+    char* name = NULL;
     buf = taosDecodeString(buf, &name);
-    taosArrayPush(pReq->topicNames, &name);
+    if (taosArrayPush(pReq->topicNames, &name) == NULL){
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
   }
 
   buf = taosDecodeFixedI8(buf, &pReq->withTbName);
@@ -2849,7 +2854,7 @@ static FORCE_INLINE void* tDeserializeSCMSubscribeReq(void* buf, SCMSubscribeReq
   buf = taosDecodeFixedI8(buf, &pReq->resetOffsetCfg);
   buf = taosDecodeFixedI8(buf, &pReq->enableReplay);
   buf = taosDecodeFixedI8(buf, &pReq->enableBatchMeta);
-  return buf;
+  return 0;
 }
 
 typedef struct {

include/util/tdef.h

@@ -556,7 +556,8 @@ typedef struct {
   char name[TSDB_LOG_VAR_LEN];
 } SLogVar;
 
-#define TMQ_SEPARATOR ':'
+#define TMQ_SEPARATOR ":"
+#define TMQ_SEPARATOR_CHAR ':'
 
 enum {
   SND_WORKER_TYPE__SHARED = 1,

source/client/src/clientTmq.c

@@ -456,11 +456,7 @@ static int32_t doSendCommitMsg(tmq_t* tmq, int32_t vgId, SEpSet* epSet, STqOffse
   pOffset.consumerId = tmq->consumerId;
   pOffset.offset.val = *offset;
 
-  int32_t groupLen = strlen(tmq->groupId);
+  (void)snprintf(pOffset.offset.subKey, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", tmq->groupId, TMQ_SEPARATOR, pTopicName);
-  memcpy(pOffset.offset.subKey, tmq->groupId, groupLen);
-  pOffset.offset.subKey[groupLen] = TMQ_SEPARATOR;
-  strcpy(pOffset.offset.subKey + groupLen + 1, pTopicName);
-
   int32_t len = 0;
   int32_t code = 0;
   tEncodeSize(tEncodeMqVgOffset, &pOffset, len, code);
@@ -1667,11 +1663,7 @@ static bool doUpdateLocalEp(tmq_t* tmq, int32_t epoch, const SMqAskEpRsp* pRsp)
 }
 
 void tmqBuildConsumeReqImpl(SMqPollReq* pReq, tmq_t* tmq, int64_t timeout, SMqClientTopic* pTopic, SMqClientVg* pVg) {
-  int32_t groupLen = strlen(tmq->groupId);
+  (void)snprintf(pReq->subKey, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", tmq->groupId, TMQ_SEPARATOR, pTopic->topicName);
-  memcpy(pReq->subKey, tmq->groupId, groupLen);
-  pReq->subKey[groupLen] = TMQ_SEPARATOR;
-  strcpy(pReq->subKey + groupLen + 1, pTopic->topicName);
-
   pReq->withTbName = tmq->withTbName;
   pReq->consumerId = tmq->consumerId;
   pReq->timeout = timeout;
@@ -2902,11 +2894,7 @@ int64_t getCommittedFromServer(tmq_t* tmq, char* tname, int32_t vgId, SEpSet* ep
   SMqVgOffset pOffset = {0};
 
   pOffset.consumerId = tmq->consumerId;
-
+  (void)snprintf(pOffset.offset.subKey, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", tmq->groupId, TMQ_SEPARATOR, tname);
-  int32_t groupLen = strlen(tmq->groupId);
-  memcpy(pOffset.offset.subKey, tmq->groupId, groupLen);
-  pOffset.offset.subKey[groupLen] = TMQ_SEPARATOR;
-  strcpy(pOffset.offset.subKey + groupLen + 1, tname);
 
   int32_t len = 0;
   tEncodeSize(tEncodeMqVgOffset, &pOffset, len, code);

source/common/src/tmsg.c

@@ -9197,23 +9197,23 @@ int32_t tDecodeSTqOffsetVal(SDecoder *pDecoder, STqOffsetVal *pOffsetVal) {
 
 int32_t tFormatOffset(char *buf, int32_t maxLen, const STqOffsetVal *pVal) {
   if (pVal->type == TMQ_OFFSET__RESET_NONE) {
-    snprintf(buf, maxLen, "none");
+    (void)snprintf(buf, maxLen, "none");
   } else if (pVal->type == TMQ_OFFSET__RESET_EARLIEST) {
-    snprintf(buf, maxLen, "earliest");
+    (void)snprintf(buf, maxLen, "earliest");
   } else if (pVal->type == TMQ_OFFSET__RESET_LATEST) {
-    snprintf(buf, maxLen, "latest");
+    (void)snprintf(buf, maxLen, "latest");
   } else if (pVal->type == TMQ_OFFSET__LOG) {
-    snprintf(buf, maxLen, "wal:%" PRId64, pVal->version);
+    (void)snprintf(buf, maxLen, "wal:%" PRId64, pVal->version);
   } else if (pVal->type == TMQ_OFFSET__SNAPSHOT_DATA || pVal->type == TMQ_OFFSET__SNAPSHOT_META) {
     if (IS_VAR_DATA_TYPE(pVal->primaryKey.type)) {
       char *tmp = taosMemoryCalloc(1, pVal->primaryKey.nData + 1);
       if (tmp == NULL) return TSDB_CODE_OUT_OF_MEMORY;
-      memcpy(tmp, pVal->primaryKey.pData, pVal->primaryKey.nData);
+      (void)memcpy(tmp, pVal->primaryKey.pData, pVal->primaryKey.nData);
-      snprintf(buf, maxLen, "tsdb:%" PRId64 "|%" PRId64 ",pk type:%d,val:%s", pVal->uid, pVal->ts,
+      (void)snprintf(buf, maxLen, "tsdb:%" PRId64 "|%" PRId64 ",pk type:%d,val:%s", pVal->uid, pVal->ts,
                pVal->primaryKey.type, tmp);
       taosMemoryFree(tmp);
     } else {
-      snprintf(buf, maxLen, "tsdb:%" PRId64 "|%" PRId64 ",pk type:%d,val:%" PRId64, pVal->uid, pVal->ts,
+      (void)snprintf(buf, maxLen, "tsdb:%" PRId64 "|%" PRId64 ",pk type:%d,val:%" PRId64, pVal->uid, pVal->ts,
                pVal->primaryKey.type, pVal->primaryKey.val);
     }
   } else {

source/dnode/mnode/impl/inc/mndConsumer.h

@@ -30,9 +30,9 @@ enum {
 
 int32_t mndInitConsumer(SMnode *pMnode);
 void    mndCleanupConsumer(SMnode *pMnode);
-void    mndSendConsumerMsg(SMnode *pMnode, int64_t consumerId, uint16_t msgType, SRpcHandleInfo* info);
+int32_t mndSendConsumerMsg(SMnode *pMnode, int64_t consumerId, uint16_t msgType, SRpcHandleInfo* info);
 
-SMqConsumerObj *mndAcquireConsumer(SMnode *pMnode, int64_t consumerId);
+int32_t mndAcquireConsumer(SMnode *pMnode, int64_t consumerId, SMqConsumerObj** pConsumer);
 void    mndReleaseConsumer(SMnode *pMnode, SMqConsumerObj *pConsumer);
 
 SSdbRaw *mndConsumerActionEncode(SMqConsumerObj *pConsumer);
@@ -43,6 +43,22 @@ int32_t mndSetConsumerDropLogs(STrans *pTrans, SMqConsumerObj *pConsumer);
 
 const char *mndConsumerStatusName(int status);
 
+#define MND_TMQ_NULL_CHECK(c)                \
+  do {                                   \
+    if (c == NULL) {                     \
+      code = TSDB_CODE_OUT_OF_MEMORY;     \
+      goto END;                          \
+    }                                    \
+  } while (0)
+
+#define MND_TMQ_RETURN_CHECK(c)                \
+  do {                                     \
+    code = c;                            \
+    if (code != 0) {                     \
+      goto END;                          \
+    }                                    \
+  } while (0)
+
 #ifdef __cplusplus
 }
 #endif

source/dnode/mnode/impl/inc/mndDef.h

@@ -622,7 +622,8 @@ typedef struct {
   int32_t resetOffsetCfg;
 } SMqConsumerObj;
 
-SMqConsumerObj *tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t updateType, char *topic, SCMSubscribeReq *subscribe);
+int32_t         tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t updateType,
+                           char *topic, SCMSubscribeReq *subscribe, SMqConsumerObj** ppConsumer);
 void            tClearSMqConsumerObj(SMqConsumerObj* pConsumer);
 void            tDeleteSMqConsumerObj(SMqConsumerObj* pConsumer);
 int32_t         tEncodeSMqConsumerObj(void** buf, const SMqConsumerObj* pConsumer);
@@ -665,8 +666,8 @@ typedef struct {
   char*     qmsg;  // SubPlanToString
 } SMqSubscribeObj;
 
-SMqSubscribeObj* tNewSubscribeObj(const char key[TSDB_SUBSCRIBE_KEY_LEN]);
+int32_t          tNewSubscribeObj(const char *key, SMqSubscribeObj **ppSub);
-SMqSubscribeObj* tCloneSubscribeObj(const SMqSubscribeObj* pSub);
+int32_t          tCloneSubscribeObj(const SMqSubscribeObj* pSub, SMqSubscribeObj **ppSub);
 void             tDeleteSubscribeObj(SMqSubscribeObj* pSub);
 int32_t          tEncodeSubscribeObj(void** buf, const SMqSubscribeObj* pSub);
 void*            tDecodeSubscribeObj(const void* buf, SMqSubscribeObj* pSub, int8_t sver);

source/dnode/mnode/impl/inc/mndSubscribe.h

@@ -26,12 +26,9 @@ int32_t mndInitSubscribe(SMnode *pMnode);
 void    mndCleanupSubscribe(SMnode *pMnode);
 
 int32_t          mndGetGroupNumByTopic(SMnode *pMnode, const char *topicName);
-SMqSubscribeObj *mndAcquireSubscribe(SMnode *pMnode, const char *CGroup, const char *topicName);
+int32_t          mndAcquireSubscribeByKey(SMnode *pMnode, const char *key, SMqSubscribeObj** pSub);
-SMqSubscribeObj *mndAcquireSubscribeByKey(SMnode *pMnode, const char *key);
 void             mndReleaseSubscribe(SMnode *pMnode, SMqSubscribeObj *pSub);
 
-void    mndMakeSubscribeKey(char *key, const char *cgroup, const char *topicName);
-
 int32_t mndDropSubByTopic(SMnode *pMnode, STrans *pTrans, const char *topic);
 int32_t mndSetDropSubCommitLogs(SMnode *pMnode, STrans *pTrans, SMqSubscribeObj *pSub);
 

source/dnode/mnode/impl/inc/mndTopic.h

@@ -25,13 +25,12 @@ extern "C" {
 int32_t mndInitTopic(SMnode *pMnode);
 void    mndCleanupTopic(SMnode *pMnode);
 
-SMqTopicObj *mndAcquireTopic(SMnode *pMnode, const char *topicName);
+int32_t      mndAcquireTopic(SMnode *pMnode, const char *topicName, SMqTopicObj **pTopic);
 void         mndReleaseTopic(SMnode *pMnode, SMqTopicObj *pTopic);
 int32_t      mndDropTopicByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb);
 bool         mndTopicExistsForDb(SMnode *pMnode, SDbObj *pDb);
-const char  *mndTopicGetShowName(const char topic[TSDB_TOPIC_FNAME_LEN]);
+void         mndTopicGetShowName(const char* fullTopic, char* topic);
 
-int32_t mndSetTopicCommitLogs(SMnode *pMnode, STrans *pTrans, SMqTopicObj *pTopic);
 int32_t mndGetNumOfTopics(SMnode *pMnode, char *dbName, int32_t *pNumOfTopics);
 
 #ifdef __cplusplus

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

@@ -40,7 +40,6 @@ static int32_t mndProcessSubscribeReq(SRpcMsg *pMsg);
 static int32_t mndProcessAskEpReq(SRpcMsg *pMsg);
 static int32_t mndProcessMqHbReq(SRpcMsg *pMsg);
 static int32_t mndProcessConsumerClearMsg(SRpcMsg *pMsg);
-static int32_t mndProcessConsumerRecoverMsg(SRpcMsg *pMsg);
 
 int32_t mndInitConsumer(SMnode *pMnode) {
   SSdbTable table = {
@@ -57,7 +56,6 @@ int32_t mndInitConsumer(SMnode *pMnode) {
   mndSetMsgHandle(pMnode, TDMT_MND_TMQ_HB, mndProcessMqHbReq);
   mndSetMsgHandle(pMnode, TDMT_MND_TMQ_ASK_EP, mndProcessAskEpReq);
   //  mndSetMsgHandle(pMnode, TDMT_MND_TMQ_TIMER, mndProcessMqTimerMsg);
-  mndSetMsgHandle(pMnode, TDMT_MND_TMQ_CONSUMER_RECOVER, mndProcessConsumerRecoverMsg);
   mndSetMsgHandle(pMnode, TDMT_MND_TMQ_LOST_CONSUMER_CLEAR, mndProcessConsumerClearMsg);
 
   mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_CONSUMERS, mndRetrieveConsumer);
@@ -68,13 +66,10 @@ int32_t mndInitConsumer(SMnode *pMnode) {
 
 void mndCleanupConsumer(SMnode *pMnode) {}
 
-void mndSendConsumerMsg(SMnode *pMnode, int64_t consumerId, uint16_t msgType, SRpcHandleInfo *info) {
+int32_t mndSendConsumerMsg(SMnode *pMnode, int64_t consumerId, uint16_t msgType, SRpcHandleInfo *info) {
+  int32_t code = 0;
   void   *msg  = rpcMallocCont(sizeof(int64_t));
-  if (msg == NULL) {
+  MND_TMQ_NULL_CHECK(msg);
-    mError("consumer:0x%" PRIx64 " failed to clear consumer due to out of memory. alloc size:%d", consumerId,
-           (int32_t)sizeof(int64_t));
-    return;
-  }
 
   *(int64_t*)msg = consumerId;
   SRpcMsg rpcMsg = {
@@ -85,108 +80,51 @@ void mndSendConsumerMsg(SMnode *pMnode, int64_t consumerId, uint16_t msgType, SR
   };
 
   mInfo("mndSendConsumerMsg type:%d consumer:0x%" PRIx64, msgType, consumerId);
-  int32_t code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg);
+  MND_TMQ_RETURN_CHECK(tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg));
-  if (code != 0){
+  return code;
-    mError("consumer:%"PRId64" send consumer msg:%d error:%d", consumerId, msgType, code);
+
-  }
+END:
+  taosMemoryFree(msg);
+  return code;
 }
 
 static int32_t validateTopics(const SArray *pTopicList, SMnode *pMnode, const char *pUser,
                               bool enableReplay) {
   SMqTopicObj *pTopic = NULL;
   int32_t      code = 0;
-  int32_t      lino = 0;
 
   int32_t numOfTopics = taosArrayGetSize(pTopicList);
   for (int32_t i = 0; i < numOfTopics; i++) {
     char *pOneTopic = taosArrayGetP(pTopicList, i);
-    pTopic = mndAcquireTopic(pMnode, pOneTopic);
+    MND_TMQ_RETURN_CHECK(mndAcquireTopic(pMnode, pOneTopic, &pTopic));
-    if (pTopic == NULL) {  // terrno has been set by callee function
+    MND_TMQ_RETURN_CHECK(mndCheckTopicPrivilege(pMnode, pUser, MND_OPER_SUBSCRIBE, pTopic));
-      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    MND_TMQ_RETURN_CHECK(grantCheckExpire(TSDB_GRANT_SUBSCRIPTION));
-      if (terrno != 0) code = terrno;
-      goto FAILED;
-    }
-
-    TAOS_CHECK_GOTO(mndCheckTopicPrivilege(pMnode, pUser, MND_OPER_SUBSCRIBE, pTopic), &lino, FAILED);
-
-    TAOS_CHECK_GOTO(grantCheckExpire(TSDB_GRANT_SUBSCRIPTION), &lino, FAILED);
 
     if (enableReplay) {
       if (pTopic->subType != TOPIC_SUB_TYPE__COLUMN) {
         code = TSDB_CODE_TMQ_REPLAY_NOT_SUPPORT;
-        goto FAILED;
+        goto END;
       } else if (pTopic->ntbUid == 0 && pTopic->ctbStbUid == 0) {
         SDbObj *pDb = mndAcquireDb(pMnode, pTopic->db);
         if (pDb == NULL) {
           code = TSDB_CODE_MND_RETURN_VALUE_NULL;
-          if (terrno != 0) code = terrno;
+          goto END;
-          goto FAILED;
         }
         if (pDb->cfg.numOfVgroups != 1) {
           mndReleaseDb(pMnode, pDb);
           code = TSDB_CODE_TMQ_REPLAY_NEED_ONE_VGROUP;
-          goto FAILED;
+          goto END;
         }
         mndReleaseDb(pMnode, pDb);
       }
     }
-
     mndReleaseTopic(pMnode, pTopic);
   }
-
   return 0;
-FAILED:
-  mndReleaseTopic(pMnode, pTopic);
-  TAOS_RETURN(code);
-}
 
-static int32_t mndProcessConsumerRecoverMsg(SRpcMsg *pMsg) {
-  int32_t                code = 0;
-  int32_t                lino = 0;
-  SMnode                *pMnode = pMsg->info.node;
-  SMqConsumerRecoverMsg *pRecoverMsg = pMsg->pCont;
-  SMqConsumerObj        *pConsumerNew = NULL;
-  STrans                *pTrans = NULL;
-  SMqConsumerObj        *pConsumer = mndAcquireConsumer(pMnode, pRecoverMsg->consumerId);
-  if (pConsumer == NULL) {
-    mError("cannot find consumer %" PRId64 " when processing consumer recover msg", pRecoverMsg->consumerId);
-    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
-    if (terrno != 0) code = terrno;
-    goto END;
-  }
-
-  mInfo("receive consumer recover msg, consumer:0x%" PRIx64 " status:%d(%s)", pRecoverMsg->consumerId,
-        pConsumer->status, mndConsumerStatusName(pConsumer->status));
-
-  if (pConsumer->status != MQ_CONSUMER_STATUS_LOST) {
-    code = TSDB_CODE_MND_CONSUMER_NOT_READY;
-    goto END;
-  }
-
-  pConsumerNew = tNewSMqConsumerObj(pConsumer->consumerId, pConsumer->cgroup, CONSUMER_UPDATE_REC, NULL, NULL);
-  if (pConsumerNew == NULL){
-    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
-    if (terrno != 0) code = terrno;
-    goto END;
-  }
-
-  pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_NOTHING, pMsg, "recover-csm");
-  if (pTrans == NULL) {
-    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
-    if (terrno != 0) code = terrno;
-    goto END;
-  }
-
-  TAOS_CHECK_GOTO(validateTopics(pConsumer->assignedTopics, pMnode, pMsg->info.conn.user, false), &lino, END);
-
-  TAOS_CHECK_GOTO(mndSetConsumerCommitLogs(pTrans, pConsumerNew), &lino, END);
-
-  code = mndTransPrepare(pMnode, pTrans);
 END:
-  mndReleaseConsumer(pMnode, pConsumer);
+  mndReleaseTopic(pMnode, pTopic);
-  tDeleteSMqConsumerObj(pConsumerNew);
+  return code;
-  mndTransDrop(pTrans);
-  TAOS_RETURN(code);
 }
 
 static int32_t mndProcessConsumerClearMsg(SRpcMsg *pMsg) {
@@ -196,55 +134,39 @@ static int32_t mndProcessConsumerClearMsg(SRpcMsg *pMsg) {
   SMqConsumerClearMsg *pClearMsg = pMsg->pCont;
   SMqConsumerObj      *pConsumerNew = NULL;
   STrans              *pTrans = NULL;
+  SMqConsumerObj      *pConsumer = NULL;
 
-  SMqConsumerObj *pConsumer = mndAcquireConsumer(pMnode, pClearMsg->consumerId);
+  MND_TMQ_RETURN_CHECK(mndAcquireConsumer(pMnode, pClearMsg->consumerId, &pConsumer));
-  if (pConsumer == NULL) {
-    mError("consumer:0x%" PRIx64 " failed to be found to clear it", pClearMsg->consumerId);
-    TAOS_RETURN(code);
-  }
-
   mInfo("consumer:0x%" PRIx64 " needs to be cleared, status %s", pClearMsg->consumerId,
         mndConsumerStatusName(pConsumer->status));
 
-  pConsumerNew = tNewSMqConsumerObj(pConsumer->consumerId, pConsumer->cgroup, -1, NULL, NULL);
+  MND_TMQ_RETURN_CHECK(tNewSMqConsumerObj(pConsumer->consumerId, pConsumer->cgroup, -1, NULL, NULL, &pConsumerNew));
-  if (pConsumerNew == NULL){
-    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
-    if (terrno != 0) code = terrno;
-    goto END;
-  }
-
   pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_NOTHING, pMsg, "clear-csm");
-  if (pTrans == NULL) {
+  MND_TMQ_NULL_CHECK(pTrans);
-    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+  MND_TMQ_RETURN_CHECK(mndSetConsumerDropLogs(pTrans, pConsumerNew));
-    if (terrno != 0) code = terrno;
-    goto END;
-  }
-
-  // this is the drop action, not the update action
-  TAOS_CHECK_GOTO(mndSetConsumerDropLogs(pTrans, pConsumerNew), &lino, END);
-
   code = mndTransPrepare(pMnode, pTrans);
 
 END:
   mndReleaseConsumer(pMnode, pConsumer);
   tDeleteSMqConsumerObj(pConsumerNew);
   mndTransDrop(pTrans);
-  TAOS_RETURN(code);
+  return code;
 }
 
 static int32_t checkPrivilege(SMnode *pMnode, SMqConsumerObj *pConsumer, SMqHbRsp *rsp, char *user) {
+  int32_t code = 0;
   rsp->topicPrivileges = taosArrayInit(taosArrayGetSize(pConsumer->currentTopics), sizeof(STopicPrivilege));
-  if (rsp->topicPrivileges == NULL) {
+  MND_TMQ_NULL_CHECK(rsp->topicPrivileges);
-    return TSDB_CODE_OUT_OF_MEMORY;
-  }
   for (int32_t i = 0; i < taosArrayGetSize(pConsumer->currentTopics); i++) {
     char        *topic = taosArrayGetP(pConsumer->currentTopics, i);
-    SMqTopicObj *pTopic = mndAcquireTopic(pMnode, topic);
+    SMqTopicObj *pTopic = NULL;
-    if (pTopic == NULL) {  // terrno has been set by callee function
+    code = mndAcquireTopic(pMnode, topic, &pTopic);
+    if (code != TDB_CODE_SUCCESS) {
       continue;
     }
     STopicPrivilege *data = taosArrayReserve(rsp->topicPrivileges, 1);
-    strcpy(data->topic, topic);
+    MND_TMQ_NULL_CHECK(data);
+    (void)strcpy(data->topic, topic);
     if (mndCheckTopicPrivilege(pMnode, user, MND_OPER_SUBSCRIBE, pTopic) != 0 ||
         grantCheckExpire(TSDB_GRANT_SUBSCRIPTION) < 0) {
       data->noPrivilege = 1;
@@ -253,22 +175,30 @@ static int32_t checkPrivilege(SMnode *pMnode, SMqConsumerObj *pConsumer, SMqHbRs
     }
     mndReleaseTopic(pMnode, pTopic);
   }
-  return 0;
+END:
+  return code;
 }
 
 static void storeOffsetRows(SMnode *pMnode, SMqHbReq *req, SMqConsumerObj *pConsumer){
   for (int i = 0; i < taosArrayGetSize(req->topics); i++) {
     TopicOffsetRows *data = taosArrayGet(req->topics, i);
+    if (data == NULL){
+      continue;
+    }
     mInfo("heartbeat report offset rows.%s:%s", pConsumer->cgroup, data->topicName);
 
-    SMqSubscribeObj *pSub = mndAcquireSubscribe(pMnode, pConsumer->cgroup, data->topicName);
+    SMqSubscribeObj *pSub = NULL;
-    if (pSub == NULL) {
+    char  key[TSDB_SUBSCRIBE_KEY_LEN] = {0};
+    (void)snprintf(key, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", pConsumer->cgroup, TMQ_SEPARATOR, data->topicName);
+    int32_t code = mndAcquireSubscribeByKey(pMnode, key, &pSub);
+    if (code != 0) {
+      mError("failed to acquire subscribe by key:%s, code:%d", key, code);
       continue;
     }
     taosWLockLatch(&pSub->lock);
     SMqConsumerEp *pConsumerEp = taosHashGet(pSub->consumerHash, &pConsumer->consumerId, sizeof(int64_t));
     if (pConsumerEp) {
-      taosArrayDestroy(pConsumerEp->offsetRows);
+      (void)taosArrayDestroy(pConsumerEp->offsetRows);
       pConsumerEp->offsetRows = data->offsetRows;
       data->offsetRows = NULL;
     }
@@ -303,36 +233,24 @@ static int32_t mndProcessMqHbReq(SRpcMsg *pMsg) {
   SMqHbReq        req = {0};
   SMqHbRsp        rsp = {0};
   SMqConsumerObj *pConsumer = NULL;
-
+  MND_TMQ_RETURN_CHECK(tDeserializeSMqHbReq(pMsg->pCont, pMsg->contLen, &req));
-  TAOS_CHECK_GOTO(tDeserializeSMqHbReq(pMsg->pCont, pMsg->contLen, &req), NULL, end);
-
   int64_t consumerId = req.consumerId;
-  pConsumer = mndAcquireConsumer(pMnode, consumerId);
+  MND_TMQ_RETURN_CHECK(mndAcquireConsumer(pMnode, consumerId, &pConsumer));
-  if (pConsumer == NULL) {
+  MND_TMQ_RETURN_CHECK(checkPrivilege(pMnode, pConsumer, &rsp, pMsg->info.conn.user));
-    mError("consumer:0x%" PRIx64 " not exist", consumerId);
-    code = TSDB_CODE_MND_CONSUMER_NOT_EXIST;
-    goto end;
-  }
-
-  TAOS_CHECK_GOTO(checkPrivilege(pMnode, pConsumer, &rsp, pMsg->info.conn.user), NULL, end);
-
   atomic_store_32(&pConsumer->hbStatus, 0);
-
   int32_t status = atomic_load_32(&pConsumer->status);
-
   if (status == MQ_CONSUMER_STATUS_LOST) {
     mInfo("try to recover consumer:0x%" PRIx64, consumerId);
-    mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_CONSUMER_RECOVER, &pMsg->info);
+    MND_TMQ_RETURN_CHECK(mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_CONSUMER_RECOVER, &pMsg->info));
   }
-
   storeOffsetRows(pMnode, &req, pConsumer);
   code = buildMqHbRsp(pMsg, &rsp);
 
-end:
+END:
   tDestroySMqHbRsp(&rsp);
   mndReleaseConsumer(pMnode, pConsumer);
   tDestroySMqHbReq(&req);
-  TAOS_RETURN(code);
+  return code;
 }
 
 static int32_t addEpSetInfo(SMnode *pMnode, SMqConsumerObj *pConsumer, int32_t epoch, SMqAskEpRsp *rsp){
@@ -349,19 +267,22 @@ static int32_t addEpSetInfo(SMnode *pMnode, SMqConsumerObj *pConsumer, int32_t e
   // handle all topics subscribed by this consumer
   for (int32_t i = 0; i < numOfTopics; i++) {
     char            *topic = taosArrayGetP(pConsumer->currentTopics, i);
-    SMqSubscribeObj *pSub = mndAcquireSubscribe(pMnode, pConsumer->cgroup, topic);
+    SMqSubscribeObj *pSub = NULL;
-    // txn guarantees pSub is created
+    char  key[TSDB_SUBSCRIBE_KEY_LEN] = {0};
-    if (pSub == NULL) {
+    (void)snprintf(key, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", pConsumer->cgroup, TMQ_SEPARATOR, topic);
+    int32_t code = mndAcquireSubscribeByKey(pMnode, key, &pSub);
+    if (code != 0) {
       continue;
     }
     taosRLockLatch(&pSub->lock);
 
     SMqSubTopicEp topicEp = {0};
-    strcpy(topicEp.topic, topic);
+    (void)strcpy(topicEp.topic, topic);
 
     // 2.1 fetch topic schema
-    SMqTopicObj *pTopic = mndAcquireTopic(pMnode, topic);
+    SMqTopicObj *pTopic = NULL;
-    if (pTopic == NULL) {
+    code = mndAcquireTopic(pMnode, topic, &pTopic);
+    if (code != TDB_CODE_SUCCESS) {
       taosRUnLockLatch(&pSub->lock);
       mndReleaseSubscribe(pMnode, pSub);
       continue;
@@ -371,16 +292,27 @@ static int32_t addEpSetInfo(SMnode *pMnode, SMqConsumerObj *pConsumer, int32_t e
     topicEp.schema.nCols = pTopic->schema.nCols;
     if (topicEp.schema.nCols) {
       topicEp.schema.pSchema = taosMemoryCalloc(topicEp.schema.nCols, sizeof(SSchema));
-      memcpy(topicEp.schema.pSchema, pTopic->schema.pSchema, topicEp.schema.nCols * sizeof(SSchema));
+      if (topicEp.schema.pSchema == NULL) {
+        taosRUnLockLatch(&pTopic->lock);
+        taosRUnLockLatch(&pSub->lock);
+        mndReleaseSubscribe(pMnode, pSub);
+        mndReleaseTopic(pMnode, pTopic);
+        return TSDB_CODE_OUT_OF_MEMORY;
+      }
+      (void)memcpy(topicEp.schema.pSchema, pTopic->schema.pSchema, topicEp.schema.nCols * sizeof(SSchema));
     }
     taosRUnLockLatch(&pTopic->lock);
     mndReleaseTopic(pMnode, pTopic);
 
     // 2.2 iterate all vg assigned to the consumer of that topic
     SMqConsumerEp *pConsumerEp = taosHashGet(pSub->consumerHash, &pConsumer->consumerId, sizeof(int64_t));
+    if (pConsumerEp == NULL) {
+      taosRUnLockLatch(&pConsumer->lock);
+      taosRUnLockLatch(&pSub->lock);
+      mndReleaseSubscribe(pMnode, pSub);
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
     int32_t vgNum = taosArrayGetSize(pConsumerEp->vgs);
-
-    // this customer assigned vgroups
     topicEp.vgs = taosArrayInit(vgNum, sizeof(SMqSubVgEp));
     if (topicEp.vgs == NULL) {
       taosRUnLockLatch(&pConsumer->lock);
@@ -391,9 +323,9 @@ static int32_t addEpSetInfo(SMnode *pMnode, SMqConsumerObj *pConsumer, int32_t e
 
     for (int32_t j = 0; j < vgNum; j++) {
       SMqVgEp *pVgEp = taosArrayGetP(pConsumerEp->vgs, j);
-      //        char     offsetKey[TSDB_PARTITION_KEY_LEN];
+      if (pVgEp == NULL) {
-      //        mndMakePartitionKey(offsetKey, pConsumer->cgroup, topic, pVgEp->vgId);
+        continue;
-
+      }
       if (epoch == -1) {
         SVgObj *pVgroup = mndAcquireVgroup(pMnode, pVgEp->vgId);
         if (pVgroup) {
@@ -401,17 +333,10 @@ static int32_t addEpSetInfo(SMnode *pMnode, SMqConsumerObj *pConsumer, int32_t e
           mndReleaseVgroup(pMnode, pVgroup);
         }
       }
-      // 2.2.1 build vg ep
+      SMqSubVgEp vgEp = {.epSet = pVgEp->epSet, .vgId = pVgEp->vgId, .offset = -1};
-      SMqSubVgEp vgEp = {
+      (void)taosArrayPush(topicEp.vgs, &vgEp);
-          .epSet = pVgEp->epSet,
-          .vgId = pVgEp->vgId,
-          .offset = -1,
-      };
-
-      taosArrayPush(topicEp.vgs, &vgEp);
     }
-    taosArrayPush(rsp->topics, &topicEp);
+    (void)taosArrayPush(rsp->topics, &topicEp);
-
     taosRUnLockLatch(&pSub->lock);
     mndReleaseSubscribe(pMnode, pSub);
   }
@@ -437,12 +362,15 @@ static int32_t buildAskEpRsp(SRpcMsg *pMsg, SMqAskEpRsp *rsp, int32_t serverEpoc
   pHead->walever = 0;
 
   void *abuf = POINTER_SHIFT(buf, sizeof(SMqRspHead));
-  tEncodeSMqAskEpRsp(&abuf, rsp);
+  if (tEncodeSMqAskEpRsp(&abuf, rsp) < 0) {
+    rpcFreeCont(buf);
+    return TSDB_CODE_TSC_INTERNAL_ERROR;
+  }
 
   // send rsp
   pMsg->info.rsp = buf;
   pMsg->info.rspLen = tlen;
-  TAOS_RETURN(code);
+  return code;
 }
 
 static int32_t mndProcessAskEpReq(SRpcMsg *pMsg) {
@@ -450,33 +378,22 @@ static int32_t mndProcessAskEpReq(SRpcMsg *pMsg) {
   SMqAskEpReq req = {0};
   SMqAskEpRsp rsp = {0};
   int32_t     code = 0;
+  SMqConsumerObj *pConsumer = NULL;
 
-  TAOS_CHECK_RETURN(tDeserializeSMqAskEpReq(pMsg->pCont, pMsg->contLen, &req));
+  MND_TMQ_RETURN_CHECK(tDeserializeSMqAskEpReq(pMsg->pCont, pMsg->contLen, &req));
-
   int64_t consumerId = req.consumerId;
-
+  MND_TMQ_RETURN_CHECK(mndAcquireConsumer(pMnode, consumerId, &pConsumer));
-  SMqConsumerObj *pConsumer = mndAcquireConsumer(pMnode, consumerId);
-  if (pConsumer == NULL) {
-    mError("consumer:0x%" PRIx64 " group:%s not exists in sdb", consumerId, req.cgroup);
-    return TSDB_CODE_MND_CONSUMER_NOT_EXIST;
-  }
-
   if (strncmp(req.cgroup, pConsumer->cgroup, tListLen(pConsumer->cgroup)) != 0) {
     mError("consumer:0x%" PRIx64 " group:%s not consistent with data in sdb, saved cgroup:%s", consumerId, req.cgroup,
            pConsumer->cgroup);
     code = TSDB_CODE_MND_CONSUMER_NOT_EXIST;
     goto END;
   }
-
   atomic_store_32(&pConsumer->hbStatus, 0);
-
-  // 1. check consumer status
   int32_t status = atomic_load_32(&pConsumer->status);
-
   if (status == MQ_CONSUMER_STATUS_LOST) {
-    mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_CONSUMER_RECOVER, &pMsg->info);
+    MND_TMQ_RETURN_CHECK(mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_CONSUMER_RECOVER, &pMsg->info));
   }
-
   if (status != MQ_CONSUMER_STATUS_READY) {
     mInfo("consumer:0x%" PRIx64 " not ready, status: %s", consumerId, mndConsumerStatusName(status));
     code = TSDB_CODE_MND_CONSUMER_NOT_READY;
@@ -490,10 +407,7 @@ static int32_t mndProcessAskEpReq(SRpcMsg *pMsg) {
   if (epoch != serverEpoch) {
     mInfo("process ask ep, consumer:0x%" PRIx64 "(epoch %d) update with server epoch %d",
           consumerId, epoch, serverEpoch);
-    code = addEpSetInfo(pMnode, pConsumer, epoch, &rsp);
+    MND_TMQ_RETURN_CHECK(addEpSetInfo(pMnode, pConsumer, epoch, &rsp));
-    if(code != 0){
-      goto END;
-    }
   }
 
   code = buildAskEpRsp(pMsg, &rsp, serverEpoch, consumerId);
@@ -507,27 +421,29 @@ END:
 int32_t mndSetConsumerDropLogs(STrans *pTrans, SMqConsumerObj *pConsumer) {
   int32_t  code = 0;
   SSdbRaw *pCommitRaw = mndConsumerActionEncode(pConsumer);
-  if (pCommitRaw == NULL) {
+  MND_TMQ_NULL_CHECK(pCommitRaw);
-    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+  code = mndTransAppendCommitlog(pTrans, pCommitRaw);
-    if (terrno != 0) code = terrno;
+  if (code != 0) {
-    TAOS_RETURN(code);
+    sdbFreeRaw(pCommitRaw);
+    goto END;
   }
-  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));
+  MND_TMQ_RETURN_CHECK(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));
-  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));
+END:
-  TAOS_RETURN(code);
+  return code;
 }
 
 int32_t mndSetConsumerCommitLogs(STrans *pTrans, SMqConsumerObj *pConsumer) {
   int32_t  code = 0;
   SSdbRaw *pCommitRaw = mndConsumerActionEncode(pConsumer);
-  if (pCommitRaw == NULL) {
+  MND_TMQ_NULL_CHECK(pCommitRaw);
-    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+  code = mndTransAppendCommitlog(pTrans, pCommitRaw);
-    if (terrno != 0) code = terrno;
+  if (code != 0) {
-    TAOS_RETURN(code);
+    sdbFreeRaw(pCommitRaw);
+    goto END;
   }
-  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));
+  MND_TMQ_RETURN_CHECK(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY));
-  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY));
+END:
-  TAOS_RETURN(code);
+  return code;
 }
 
 static void freeItem(void *param) {
@@ -538,29 +454,35 @@ static void freeItem(void *param) {
 }
 
 static int32_t getTopicAddDelete(SMqConsumerObj *pExistedConsumer, SMqConsumerObj *pConsumerNew){
+  int32_t code = 0;
   pConsumerNew->rebNewTopics = taosArrayInit(0, sizeof(void *));
+  MND_TMQ_NULL_CHECK(pConsumerNew->rebNewTopics);
   pConsumerNew->rebRemovedTopics = taosArrayInit(0, sizeof(void *));
-  if(pConsumerNew->rebNewTopics == NULL || pConsumerNew->rebRemovedTopics == NULL){
+  MND_TMQ_NULL_CHECK(pConsumerNew->rebRemovedTopics);
-    return TSDB_CODE_OUT_OF_MEMORY;
+
-  }
   int32_t newTopicNum = taosArrayGetSize(pConsumerNew->assignedTopics);
   int32_t oldTopicNum = taosArrayGetSize(pExistedConsumer->currentTopics);
-
   int32_t i = 0, j = 0;
   while (i < oldTopicNum || j < newTopicNum) {
     if (i >= oldTopicNum) {
-      char *newTopicCopy = taosStrdup(taosArrayGetP(pConsumerNew->assignedTopics, j));
+      void* tmp = taosArrayGetP(pConsumerNew->assignedTopics, j);
-      taosArrayPush(pConsumerNew->rebNewTopics, &newTopicCopy);
+      MND_TMQ_NULL_CHECK(tmp);
+      char *newTopicCopy = taosStrdup(tmp);
+      MND_TMQ_NULL_CHECK(taosArrayPush(pConsumerNew->rebNewTopics, &newTopicCopy));
       j++;
       continue;
     } else if (j >= newTopicNum) {
-      char *oldTopicCopy = taosStrdup(taosArrayGetP(pExistedConsumer->currentTopics, i));
+      void* tmp = taosArrayGetP(pExistedConsumer->currentTopics, i);
-      taosArrayPush(pConsumerNew->rebRemovedTopics, &oldTopicCopy);
+      MND_TMQ_NULL_CHECK(tmp);
+      char *oldTopicCopy = taosStrdup(tmp);
+      MND_TMQ_NULL_CHECK(taosArrayPush(pConsumerNew->rebRemovedTopics, &oldTopicCopy));
       i++;
       continue;
     } else {
       char *oldTopic = taosArrayGetP(pExistedConsumer->currentTopics, i);
+      MND_TMQ_NULL_CHECK(oldTopic);
       char *newTopic = taosArrayGetP(pConsumerNew->assignedTopics, j);
+      MND_TMQ_NULL_CHECK(newTopic);
       int   comp = strcmp(oldTopic, newTopic);
       if (comp == 0) {
         i++;
@@ -568,22 +490,22 @@ static int32_t getTopicAddDelete(SMqConsumerObj *pExistedConsumer, SMqConsumerOb
         continue;
       } else if (comp < 0) {
         char *oldTopicCopy = taosStrdup(oldTopic);
-        taosArrayPush(pConsumerNew->rebRemovedTopics, &oldTopicCopy);
+        MND_TMQ_NULL_CHECK(taosArrayPush(pConsumerNew->rebRemovedTopics, &oldTopicCopy));
         i++;
         continue;
       } else {
         char *newTopicCopy = taosStrdup(newTopic);
-        taosArrayPush(pConsumerNew->rebNewTopics, &newTopicCopy);
+        MND_TMQ_NULL_CHECK(taosArrayPush(pConsumerNew->rebNewTopics, &newTopicCopy));
         j++;
         continue;
       }
     }
   }
-  return 0;
+END:
+  return code;
 }
 
 static int32_t checkAndSortTopic(SMnode *pMnode, SArray *pTopicList){
-  int32_t code = 0;
   taosArraySort(pTopicList, taosArrayCompareString);
   taosArrayRemoveDuplicate(pTopicList, taosArrayCompareString, freeItem);
 
@@ -594,24 +516,21 @@ static int32_t checkAndSortTopic(SMnode *pMnode, SArray *pTopicList){
       return TSDB_CODE_TMQ_GROUP_OUT_OF_RANGE;
     }
   }
-  TAOS_RETURN(code);
+  return 0;
 }
 
-static SMqConsumerObj* buildSubConsumer(SMnode *pMnode, SCMSubscribeReq *subscribe){
+static int32_t buildSubConsumer(SMnode *pMnode, SCMSubscribeReq *subscribe, SMqConsumerObj** ppConsumer){
   int64_t         consumerId = subscribe->consumerId;
   char           *cgroup     = subscribe->cgroup;
   SMqConsumerObj *pConsumerNew     = NULL;
   SMqConsumerObj *pExistedConsumer = NULL;
-  pExistedConsumer = mndAcquireConsumer(pMnode, consumerId);
+  int32_t code = mndAcquireConsumer(pMnode, consumerId, &pExistedConsumer);
-  if (pExistedConsumer == NULL) {
+  if (code != 0) {
     mInfo("receive subscribe request from new consumer:0x%" PRIx64
               ",cgroup:%s, numOfTopics:%d", consumerId,
           subscribe->cgroup, (int32_t)taosArrayGetSize(subscribe->topicNames));
 
-    pConsumerNew = tNewSMqConsumerObj(consumerId, cgroup, CONSUMER_INSERT_SUB, NULL, subscribe);
+    MND_TMQ_RETURN_CHECK(tNewSMqConsumerObj(consumerId, cgroup, CONSUMER_INSERT_SUB, NULL, subscribe, &pConsumerNew));
-    if (pConsumerNew == NULL) {
-      goto _over;
-    }
   } else {
     int32_t status = atomic_load_32(&pExistedConsumer->status);
 
@@ -621,82 +540,53 @@ static SMqConsumerObj* buildSubConsumer(SMnode *pMnode, SCMSubscribeReq *subscri
           (int32_t)taosArrayGetSize(subscribe->topicNames));
 
     if (status != MQ_CONSUMER_STATUS_READY) {
-      terrno = TSDB_CODE_MND_CONSUMER_NOT_READY;
+      code = TSDB_CODE_MND_CONSUMER_NOT_READY;
-      goto _over;
+      goto END;
-    }
-    pConsumerNew = tNewSMqConsumerObj(consumerId, cgroup, CONSUMER_UPDATE_SUB, NULL, subscribe);
-    if (pConsumerNew == NULL) {
-      goto _over;
-    }
-
-    int32_t code = getTopicAddDelete(pExistedConsumer, pConsumerNew);
-    if (code != 0){
-      terrno = code;
-      goto _over;
     }
+    MND_TMQ_RETURN_CHECK(tNewSMqConsumerObj(consumerId, cgroup, CONSUMER_UPDATE_SUB, NULL, subscribe, &pConsumerNew));
+    MND_TMQ_RETURN_CHECK(getTopicAddDelete(pExistedConsumer, pConsumerNew));
   }
   mndReleaseConsumer(pMnode, pExistedConsumer);
-  return pConsumerNew;
+  if (ppConsumer){
+    *ppConsumer = pConsumerNew;
+  }
+  return code;
 
-_over:
+END:
   mndReleaseConsumer(pMnode, pExistedConsumer);
   tDeleteSMqConsumerObj(pConsumerNew);
-  return NULL;
+  return code;
 }
 
 int32_t mndProcessSubscribeReq(SRpcMsg *pMsg) {
   SMnode *pMnode = pMsg->info.node;
   char   *msgStr = pMsg->pCont;
   int32_t code = 0;
-
-  SCMSubscribeReq subscribe = {0};
-  tDeserializeSCMSubscribeReq(msgStr, &subscribe);
-
   SMqConsumerObj *pConsumerNew = NULL;
   STrans         *pTrans = NULL;
 
+  SCMSubscribeReq subscribe = {0};
+  MND_TMQ_RETURN_CHECK(tDeserializeSCMSubscribeReq(msgStr, &subscribe));
   if(taosArrayGetSize(subscribe.topicNames) == 0){
-    SMqConsumerObj *pConsumerTmp = mndAcquireConsumer(pMnode, subscribe.consumerId);
+    SMqConsumerObj *pConsumerTmp = NULL;
-    if(pConsumerTmp == NULL){
+    MND_TMQ_RETURN_CHECK(mndAcquireConsumer(pMnode, subscribe.consumerId, &pConsumerTmp));
-      goto _over;
-    }
     mndReleaseConsumer(pMnode, pConsumerTmp);
   }
-
+  MND_TMQ_RETURN_CHECK(checkAndSortTopic(pMnode, subscribe.topicNames));
-  code = checkAndSortTopic(pMnode, subscribe.topicNames);
-  if(code != TSDB_CODE_SUCCESS){
-    goto _over;
-  }
-
   pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_NOTHING, pMsg, "subscribe");
-  if (pTrans == NULL) {
+  MND_TMQ_NULL_CHECK(pTrans);
-    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
-    if (terrno != 0) code = terrno;
-    goto _over;
-  }
 
-  code = validateTopics(subscribe.topicNames, pMnode, pMsg->info.conn.user, subscribe.enableReplay);
+  MND_TMQ_RETURN_CHECK(validateTopics(subscribe.topicNames, pMnode, pMsg->info.conn.user, subscribe.enableReplay));
-  if (code != TSDB_CODE_SUCCESS) {
+  MND_TMQ_RETURN_CHECK(buildSubConsumer(pMnode, &subscribe, &pConsumerNew));
-    goto _over;
+  MND_TMQ_RETURN_CHECK(mndSetConsumerCommitLogs(pTrans, pConsumerNew));
-  }
+  MND_TMQ_RETURN_CHECK(mndTransPrepare(pMnode, pTrans));
-
-  pConsumerNew = buildSubConsumer(pMnode, &subscribe);
-  if(pConsumerNew == NULL){
-    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
-    if (terrno != 0) code = terrno;
-    goto _over;
-  }
-
-  TAOS_CHECK_GOTO(mndSetConsumerCommitLogs(pTrans, pConsumerNew), NULL, _over);
-
-  TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _over);
   code = TSDB_CODE_ACTION_IN_PROGRESS;
 
-_over:
+END:
   mndTransDrop(pTrans);
   tDeleteSMqConsumerObj(pConsumerNew);
   taosArrayDestroyP(subscribe.topicNames, (FDelete)taosMemoryFree);
-  TAOS_RETURN(code);
+  return code;
 }
 
 SSdbRaw *mndConsumerActionEncode(SMqConsumerObj *pConsumer) {
@@ -713,7 +603,9 @@ SSdbRaw *mndConsumerActionEncode(SMqConsumerObj *pConsumer) {
   if (buf == NULL) goto CM_ENCODE_OVER;
 
   void *abuf = buf;
-  tEncodeSMqConsumerObj(&abuf, pConsumer);
+  if(tEncodeSMqConsumerObj(&abuf, pConsumer) < 0){
+    goto CM_ENCODE_OVER;
+  }
 
   int32_t dataPos = 0;
   SDB_SET_INT32(pRaw, dataPos, tlen, CM_ENCODE_OVER);
@@ -838,8 +730,7 @@ static bool existInCurrentTopicList(const SMqConsumerObj *pConsumer, const char
   int32_t size = taosArrayGetSize(pConsumer->currentTopics);
   for (int32_t i = 0; i < size; i++) {
     char *topic = taosArrayGetP(pConsumer->currentTopics, i);
-
+    if (topic && strcmp(topic, pTopic) == 0) {
-    if (strcmp(topic, pTopic) == 0) {
       existing = true;
       break;
     }
@@ -865,32 +756,45 @@ static int32_t mndConsumerActionUpdate(SSdb *pSdb, SMqConsumerObj *pOldConsumer,
   } else if (pNewConsumer->updateType == CONSUMER_UPDATE_REC) {
     int32_t sz = taosArrayGetSize(pOldConsumer->assignedTopics);
     for (int32_t i = 0; i < sz; i++) {
-      char *topic = taosStrdup(taosArrayGetP(pOldConsumer->assignedTopics, i));
+      void * tmp = taosArrayGetP(pOldConsumer->assignedTopics, i);
-      taosArrayPush(pOldConsumer->rebNewTopics, &topic);
+      if (tmp == NULL){
+        return TSDB_CODE_TMQ_INVALID_MSG;
+      }
+      char *topic = taosStrdup(tmp);
+      if (taosArrayPush(pOldConsumer->rebNewTopics, &topic) == NULL) {
+        taosMemoryFree(topic);
+        return TSDB_CODE_TMQ_INVALID_MSG;
+      }
     }
     pOldConsumer->status = MQ_CONSUMER_STATUS_REBALANCE;
     mInfo("consumer:0x%" PRIx64 " recover update", pOldConsumer->consumerId);
   } else if (pNewConsumer->updateType == CONSUMER_UPDATE_REB) {
-    atomic_add_fetch_32(&pOldConsumer->epoch, 1);
+    (void)atomic_add_fetch_32(&pOldConsumer->epoch, 1);
-
     pOldConsumer->rebalanceTime = taosGetTimestampMs();
     mInfo("[rebalance] consumer:0x%" PRIx64 " rebalance update, only rebalance time", pOldConsumer->consumerId);
   } else if (pNewConsumer->updateType == CONSUMER_ADD_REB) {
-    char *pNewTopic = taosStrdup(taosArrayGetP(pNewConsumer->rebNewTopics, 0));
+    void *tmp = taosArrayGetP(pNewConsumer->rebNewTopics, 0);
+    if (tmp == NULL){
+      return TSDB_CODE_TMQ_INVALID_MSG;
+    }
+    char *pNewTopic = taosStrdup(tmp);
     removeFromTopicList(pOldConsumer->rebNewTopics, pNewTopic, pOldConsumer->consumerId, "new");
     bool existing = existInCurrentTopicList(pOldConsumer, pNewTopic);
     if (existing) {
       mError("[rebalance] consumer:0x%" PRIx64 " add new topic:%s should not in currentTopics", pOldConsumer->consumerId, pNewTopic);
       taosMemoryFree(pNewTopic);
     } else {
-      taosArrayPush(pOldConsumer->currentTopics, &pNewTopic);
+      if (taosArrayPush(pOldConsumer->currentTopics, &pNewTopic) == NULL) {
+        taosMemoryFree(pNewTopic);
+        return TSDB_CODE_TMQ_INVALID_MSG;
+      }
       taosArraySort(pOldConsumer->currentTopics, taosArrayCompareString);
     }
 
     int32_t status = pOldConsumer->status;
     updateConsumerStatus(pOldConsumer);
     pOldConsumer->rebalanceTime = taosGetTimestampMs();
-    atomic_add_fetch_32(&pOldConsumer->epoch, 1);
+    (void)atomic_add_fetch_32(&pOldConsumer->epoch, 1);
 
     mInfo("[rebalance] consumer:0x%" PRIx64 " rebalance update add, state (%d)%s -> (%d)%s, new epoch:%d, reb-time:%" PRId64
           ", current topics:%d, newTopics:%d, removeTopics:%d",
@@ -901,13 +805,16 @@ static int32_t mndConsumerActionUpdate(SSdb *pSdb, SMqConsumerObj *pOldConsumer,
 
   } else if (pNewConsumer->updateType == CONSUMER_REMOVE_REB) {
     char *topic = taosArrayGetP(pNewConsumer->rebRemovedTopics, 0);
+    if (topic == NULL){
+      return TSDB_CODE_TMQ_INVALID_MSG;
+    }
     removeFromTopicList(pOldConsumer->rebRemovedTopics, topic, pOldConsumer->consumerId, "remove");
     removeFromTopicList(pOldConsumer->currentTopics, topic, pOldConsumer->consumerId, "current");
 
     int32_t status = pOldConsumer->status;
     updateConsumerStatus(pOldConsumer);
     pOldConsumer->rebalanceTime = taosGetTimestampMs();
-    atomic_add_fetch_32(&pOldConsumer->epoch, 1);
+    (void)atomic_add_fetch_32(&pOldConsumer->epoch, 1);
 
     mInfo("[rebalance]consumer:0x%" PRIx64 " rebalance update remove, state (%d)%s -> (%d)%s, new epoch:%d, reb-time:%" PRId64
           ", current topics:%d, newTopics:%d, removeTopics:%d",
@@ -921,13 +828,13 @@ static int32_t mndConsumerActionUpdate(SSdb *pSdb, SMqConsumerObj *pOldConsumer,
   return 0;
 }
 
-SMqConsumerObj *mndAcquireConsumer(SMnode *pMnode, int64_t consumerId) {
+int32_t mndAcquireConsumer(SMnode *pMnode, int64_t consumerId, SMqConsumerObj** pConsumer) {
   SSdb           *pSdb = pMnode->pSdb;
-  SMqConsumerObj *pConsumer = sdbAcquire(pSdb, SDB_CONSUMER, &consumerId);
+  *pConsumer = sdbAcquire(pSdb, SDB_CONSUMER, &consumerId);
-  if (pConsumer == NULL) {
+  if (*pConsumer == NULL) {
-    terrno = TSDB_CODE_MND_CONSUMER_NOT_EXIST;
+    return TSDB_CODE_MND_CONSUMER_NOT_EXIST;
   }
-  return pConsumer;
+  return 0;
 }
 
 void mndReleaseConsumer(SMnode *pMnode, SMqConsumerObj *pConsumer) {
@@ -940,6 +847,7 @@ static int32_t mndRetrieveConsumer(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *
   SSdb           *pSdb = pMnode->pSdb;
   int32_t         numOfRows = 0;
   SMqConsumerObj *pConsumer = NULL;
+  int32_t         code = 0;
 
   while (numOfRows < rowsCapacity) {
     pShow->pIter = sdbFetch(pSdb, SDB_CONSUMER, pShow->pIter, (void **)&pConsumer);
@@ -964,34 +872,37 @@ static int32_t mndRetrieveConsumer(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *
     }
 
     if (numOfRows + topicSz > rowsCapacity) {
-      blockDataEnsureCapacity(pBlock, numOfRows + topicSz);
+      MND_TMQ_RETURN_CHECK(blockDataEnsureCapacity(pBlock, numOfRows + topicSz));
     }
 
     for (int32_t i = 0; i < topicSz; i++) {
-      SColumnInfoData *pColInfo;
+      SColumnInfoData *pColInfo = NULL;
       int32_t          cols = 0;
 
       // consumer id
       char consumerIdHex[32] = {0};
-      sprintf(varDataVal(consumerIdHex), "0x%" PRIx64, pConsumer->consumerId);
+      (void)sprintf(varDataVal(consumerIdHex), "0x%" PRIx64, pConsumer->consumerId);
       varDataSetLen(consumerIdHex, strlen(varDataVal(consumerIdHex)));
 
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)consumerIdHex, false);
+      MND_TMQ_NULL_CHECK(pColInfo);
+      MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)consumerIdHex, false));
 
       // consumer group
       char cgroup[TSDB_CGROUP_LEN + VARSTR_HEADER_SIZE] = {0};
       STR_TO_VARSTR(cgroup, pConsumer->cgroup);
 
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)cgroup, false);
+      MND_TMQ_NULL_CHECK(pColInfo);
+      MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)cgroup, false));
 
       // client id
       char clientId[256 + VARSTR_HEADER_SIZE] = {0};
       STR_TO_VARSTR(clientId, pConsumer->clientId);
 
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)clientId, false);
+      MND_TMQ_NULL_CHECK(pColInfo);
+      MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)clientId, false));
 
       // status
       char        status[20 + VARSTR_HEADER_SIZE] = {0};
@@ -999,46 +910,48 @@ static int32_t mndRetrieveConsumer(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *
       STR_TO_VARSTR(status, pStatusName);
 
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)status, false);
+      MND_TMQ_NULL_CHECK(pColInfo);
+      MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)status, false));
 
       // one subscribed topic
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      MND_TMQ_NULL_CHECK(pColInfo);
       if (hasTopic) {
         char        topic[TSDB_TOPIC_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
-        const char *topicName = mndTopicGetShowName(taosArrayGetP(pConsumer->assignedTopics, i));
+        mndTopicGetShowName(taosArrayGetP(pConsumer->assignedTopics, i), topic + VARSTR_HEADER_SIZE);
-        STR_TO_VARSTR(topic, topicName);
+        *(VarDataLenT *)(topic) = strlen(topic + VARSTR_HEADER_SIZE);
-        colDataSetVal(pColInfo, numOfRows, (const char *)topic, false);
+        MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)topic, false));
       } else {
-        colDataSetVal(pColInfo, numOfRows, NULL, true);
+        MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, NULL, true));
       }
 
-      // end point
-      /*pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);*/
-      /*colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->ep, true);*/
-
       // up time
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->createTime, false);
+      MND_TMQ_NULL_CHECK(pColInfo);
+      MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->createTime, false));
 
       // subscribe time
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->subscribeTime, false);
+      MND_TMQ_NULL_CHECK(pColInfo);
+      MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->subscribeTime, false));
 
       // rebalance time
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->rebalanceTime, pConsumer->rebalanceTime == 0);
+      MND_TMQ_NULL_CHECK(pColInfo);
+      MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->rebalanceTime, pConsumer->rebalanceTime == 0));
 
       char         buf[TSDB_OFFSET_LEN] = {0};
       STqOffsetVal pVal = {.type = pConsumer->resetOffsetCfg};
-      tFormatOffset(buf, TSDB_OFFSET_LEN, &pVal);
+      MND_TMQ_RETURN_CHECK(tFormatOffset(buf, TSDB_OFFSET_LEN, &pVal));
 
       char parasStr[64 + TSDB_OFFSET_LEN + VARSTR_HEADER_SIZE] = {0};
-      sprintf(varDataVal(parasStr), "tbname:%d,commit:%d,interval:%dms,reset:%s", pConsumer->withTbName,
+      (void)sprintf(varDataVal(parasStr), "tbname:%d,commit:%d,interval:%dms,reset:%s", pConsumer->withTbName,
               pConsumer->autoCommit, pConsumer->autoCommitInterval, buf);
       varDataSetLen(parasStr, strlen(varDataVal(parasStr)));
 
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)parasStr, false);
+      MND_TMQ_NULL_CHECK(pColInfo);
+      MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)parasStr, false));
 
       numOfRows++;
     }
@@ -1051,6 +964,9 @@ static int32_t mndRetrieveConsumer(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *
 
   pShow->numOfRows += numOfRows;
   return numOfRows;
+
+END:
+  return code;
 }
 
 static void mndCancelGetNextConsumer(SMnode *pMnode, void *pIter) {

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

@@ -264,16 +264,17 @@ void *tDecodeSMqVgEp(const void *buf, SMqVgEp *pVgEp, int8_t sver) {
 
 static void *topicNameDup(void *p) { return taosStrdup((char *)p); }
 
-SMqConsumerObj *tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t updateType, char *topic, SCMSubscribeReq *subscribe) {
+int32_t tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t updateType,
-  terrno = 0;
+                                   char *topic, SCMSubscribeReq *subscribe, SMqConsumerObj** ppConsumer) {
+  int32_t code = 0;
   SMqConsumerObj *pConsumer = taosMemoryCalloc(1, sizeof(SMqConsumerObj));
   if (pConsumer == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    code = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
+    goto END;
   }
 
   pConsumer->consumerId = consumerId;
-  memcpy(pConsumer->cgroup, cgroup, TSDB_CGROUP_LEN);
+  (void)memcpy(pConsumer->cgroup, cgroup, TSDB_CGROUP_LEN);
 
   pConsumer->epoch = 0;
   pConsumer->status = MQ_CONSUMER_STATUS_REBALANCE;
@@ -286,20 +287,26 @@ SMqConsumerObj *tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t upda
   if (updateType == CONSUMER_ADD_REB){
     pConsumer->rebNewTopics = taosArrayInit(0, sizeof(void *));
     if(pConsumer->rebNewTopics == NULL){
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      code = TSDB_CODE_OUT_OF_MEMORY;
       goto END;
     }
 
     char* topicTmp = taosStrdup(topic);
-    taosArrayPush(pConsumer->rebNewTopics, &topicTmp);
+    if (taosArrayPush(pConsumer->rebNewTopics, &topicTmp) == NULL) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      goto END;
+    }
   }else if (updateType == CONSUMER_REMOVE_REB) {
     pConsumer->rebRemovedTopics = taosArrayInit(0, sizeof(void *));
     if(pConsumer->rebRemovedTopics == NULL){
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      code = TSDB_CODE_OUT_OF_MEMORY;
       goto END;
     }
     char* topicTmp = taosStrdup(topic);
-    taosArrayPush(pConsumer->rebRemovedTopics, &topicTmp);
+    if (taosArrayPush(pConsumer->rebRemovedTopics, &topicTmp) == NULL) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      goto END;
+    }
   }else if (updateType == CONSUMER_INSERT_SUB){
     tstrncpy(pConsumer->clientId, subscribe->clientId, tListLen(pConsumer->clientId));
     pConsumer->withTbName = subscribe->withTbName;
@@ -307,10 +314,9 @@ SMqConsumerObj *tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t upda
     pConsumer->autoCommitInterval = subscribe->autoCommitInterval;
     pConsumer->resetOffsetCfg = subscribe->resetOffsetCfg;
 
-
     pConsumer->rebNewTopics = taosArrayDup(subscribe->topicNames, topicNameDup);
     if (pConsumer->rebNewTopics == NULL){
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      code = TSDB_CODE_OUT_OF_MEMORY;
       goto END;
     }
     pConsumer->assignedTopics = subscribe->topicNames;
@@ -320,11 +326,12 @@ SMqConsumerObj *tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t upda
     subscribe->topicNames = NULL;
   }
 
-  return pConsumer;
+  *ppConsumer = pConsumer;
+  return 0;
 
 END:
   tDeleteSMqConsumerObj(pConsumer);
-  return NULL;
+  return code;
 }
 
 void tClearSMqConsumerObj(SMqConsumerObj *pConsumer) {
@@ -540,33 +547,36 @@ void *tDecodeSMqConsumerEp(const void *buf, SMqConsumerEp *pConsumerEp, int8_t s
   return (void *)buf;
 }
 
-SMqSubscribeObj *tNewSubscribeObj(const char *key) {
+int32_t tNewSubscribeObj(const char *key, SMqSubscribeObj **ppSub) {
-  terrno = 0;
+  int32_t code = 0;
   SMqSubscribeObj *pSubObj = taosMemoryCalloc(1, sizeof(SMqSubscribeObj));
-  if (pSubObj == NULL) {
+  MND_TMQ_NULL_CHECK(pSubObj);
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
-  }
 
-  memcpy(pSubObj->key, key, TSDB_SUBSCRIBE_KEY_LEN);
+  (void)memcpy(pSubObj->key, key, TSDB_SUBSCRIBE_KEY_LEN);
   taosInitRWLatch(&pSubObj->lock);
   pSubObj->vgNum = 0;
   pSubObj->consumerHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK);
-
+  MND_TMQ_NULL_CHECK(pSubObj->consumerHash);
-  // TODO set hash free fp
-  /*taosHashSetFreeFp(pSubObj->consumerHash, tDeleteSMqConsumerEp);*/
   pSubObj->unassignedVgs = taosArrayInit(0, POINTER_BYTES);
-  return pSubObj;
+  MND_TMQ_NULL_CHECK(pSubObj->unassignedVgs);
+  if (ppSub){
+    *ppSub = pSubObj;
+  }
+  return code;
+
+END:
+  taosMemoryFree(pSubObj);
+  return code;
 }
 
-SMqSubscribeObj *tCloneSubscribeObj(const SMqSubscribeObj *pSub) {
+int32_t tCloneSubscribeObj(const SMqSubscribeObj *pSub, SMqSubscribeObj **ppSub) {
-  terrno = 0;
+  int32_t code = 0;
   SMqSubscribeObj *pSubNew = taosMemoryMalloc(sizeof(SMqSubscribeObj));
   if (pSubNew == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    code = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
+    goto END;
   }
-  memcpy(pSubNew->key, pSub->key, TSDB_SUBSCRIBE_KEY_LEN);
+  (void)memcpy(pSubNew->key, pSub->key, TSDB_SUBSCRIBE_KEY_LEN);
   taosInitRWLatch(&pSubNew->lock);
 
   pSubNew->dbUid = pSub->dbUid;
@@ -576,8 +586,7 @@ SMqSubscribeObj *tCloneSubscribeObj(const SMqSubscribeObj *pSub) {
 
   pSubNew->vgNum = pSub->vgNum;
   pSubNew->consumerHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK);
-  // TODO set hash free fp
+
-  /*taosHashSetFreeFp(pSubNew->consumerHash, tDeleteSMqConsumerEp);*/
   void          *pIter = NULL;
   SMqConsumerEp *pConsumerEp = NULL;
   while (1) {
@@ -592,9 +601,13 @@ SMqSubscribeObj *tCloneSubscribeObj(const SMqSubscribeObj *pSub) {
   }
   pSubNew->unassignedVgs = taosArrayDup(pSub->unassignedVgs, (__array_item_dup_fn_t)tCloneSMqVgEp);
   pSubNew->offsetRows = taosArrayDup(pSub->offsetRows, NULL);
-  memcpy(pSubNew->dbName, pSub->dbName, TSDB_DB_FNAME_LEN);
+  (void)memcpy(pSubNew->dbName, pSub->dbName, TSDB_DB_FNAME_LEN);
   pSubNew->qmsg = taosStrdup(pSub->qmsg);
-  return pSubNew;
+  if (ppSub) {
+    *ppSub = pSubNew;
+  }
+END:
+  return code;
 }
 
 void tDeleteSubscribeObj(SMqSubscribeObj *pSub) {

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

@@ -771,21 +771,22 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib
   if (pTopic->subType == TOPIC_SUB_TYPE__COLUMN) {
     pPlan = qStringToQueryPlan(pTopic->physicalPlan);
     if (pPlan == NULL) {
-      code = TSDB_CODE_QRY_INVALID_INPUT;
+      return TSDB_CODE_QRY_INVALID_INPUT;
-      TAOS_RETURN(code);
     }
   } else if (pTopic->subType == TOPIC_SUB_TYPE__TABLE && pTopic->ast != NULL) {
     SNode* pAst = NULL;
-    if ((code = nodesStringToNode(pTopic->ast, &pAst)) != 0) {
+    code = nodesStringToNode(pTopic->ast, &pAst);
+    if (code != 0) {
       mError("topic:%s, failed to create since %s", pTopic->name, terrstr());
-      TAOS_RETURN(code);
+      return code;
     }
 
     SPlanContext cxt = {.pAstRoot = pAst, .topicQuery = true};
-    if ((code = qCreateQueryPlan(&cxt, &pPlan, NULL)) != 0) {
+    code = qCreateQueryPlan(&cxt, &pPlan, NULL);
+    if (code != 0) {
       mError("failed to create topic:%s since %s", pTopic->name, terrstr());
       nodesDestroyNode(pAst);
-      TAOS_RETURN(code);
+      return code;
     }
     nodesDestroyNode(pAst);
   }
@@ -793,18 +794,19 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib
   if (pPlan) {
     int32_t levelNum = LIST_LENGTH(pPlan->pSubplans);
     if (levelNum != 1) {
-      qDestroyQueryPlan(pPlan);
       code = TSDB_CODE_MND_INVALID_TOPIC_QUERY;
-      TAOS_RETURN(code);
+      goto END;
     }
 
     SNodeListNode* pNodeListNode = (SNodeListNode*)nodesListGetNode(pPlan->pSubplans, 0);
-
+    if (pNodeListNode == NULL){
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      goto END;
+    }
     int32_t opNum = LIST_LENGTH(pNodeListNode->pNodeList);
     if (opNum != 1) {
-      qDestroyQueryPlan(pPlan);
       code = TSDB_CODE_MND_INVALID_TOPIC_QUERY;
-      TAOS_RETURN(code);
+      goto END;
     }
 
     pSubplan = (SSubplan*)nodesListGetNode(pNodeListNode->pNodeList, 0);
@@ -825,12 +827,18 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib
     pSub->vgNum++;
 
     SMqVgEp* pVgEp = taosMemoryMalloc(sizeof(SMqVgEp));
+    if (pVgEp == NULL){
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      goto END;
+    }
     pVgEp->epSet = mndGetVgroupEpset(pMnode, pVgroup);
     pVgEp->vgId = pVgroup->vgId;
-    taosArrayPush(pSub->unassignedVgs, &pVgEp);
+    if (taosArrayPush(pSub->unassignedVgs, &pVgEp) == NULL){
-
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      taosMemoryFree(pVgEp);
+      goto END;
+    }
     mInfo("init subscription %s for topic:%s assign vgId:%d", pSub->key, pTopic->name, pVgEp->vgId);
-
     sdbRelease(pSdb, pVgroup);
   }
 
@@ -838,14 +846,14 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib
     int32_t msgLen;
 
     if (qSubPlanToString(pSubplan, &pSub->qmsg, &msgLen) < 0) {
-      qDestroyQueryPlan(pPlan);
       code = TSDB_CODE_QRY_INVALID_INPUT;
-      TAOS_RETURN(code);
+      goto END;
     }
   } else {
     pSub->qmsg = taosStrdup("");
   }
 
+END:
   qDestroyQueryPlan(pPlan);
-  TAOS_RETURN(code);
+  return code;
 }

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

@@ -44,8 +44,6 @@ static int32_t mndProcessDropTopicReq(SRpcMsg *pReq);
 static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows);
 static void    mndCancelGetNextTopic(SMnode *pMnode, void *pIter);
 
-static int32_t mndSetDropTopicCommitLogs(SMnode *pMnode, STrans *pTrans, SMqTopicObj *pTopic);
-
 int32_t mndInitTopic(SMnode *pMnode) {
   SSdbTable table = {
       .sdbType = SDB_TOPIC,
@@ -70,9 +68,16 @@ int32_t mndInitTopic(SMnode *pMnode) {
 
 void mndCleanupTopic(SMnode *pMnode) {}
 
-const char *mndTopicGetShowName(const char topic[TSDB_TOPIC_FNAME_LEN]) {
+void mndTopicGetShowName(const char* fullTopic, char* topic) {
-  //
+  if (fullTopic == NULL) {
-  return strchr(topic, '.') + 1;
+    return;
+  }
+  char* tmp = strchr(fullTopic, '.');
+  if (tmp == NULL) {
+    tstrncpy(topic, fullTopic, TSDB_TOPIC_FNAME_LEN);
+  }else {
+    tstrncpy(topic, tmp+1, TSDB_TOPIC_FNAME_LEN);
+  }
 }
 
 SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) {
@@ -129,7 +134,9 @@ SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) {
       goto TOPIC_ENCODE_OVER;
     }
     void *aswBuf = swBuf;
-    taosEncodeSSchemaWrapper(&aswBuf, &pTopic->schema);
+    if(taosEncodeSSchemaWrapper(&aswBuf, &pTopic->schema) < 0){
+      goto TOPIC_ENCODE_OVER;
+    }
     SDB_SET_BINARY(pRaw, dataPos, swBuf, schemaLen, TOPIC_ENCODE_OVER);
   }
 
@@ -259,7 +266,7 @@ SSdbRow *mndTopicActionDecode(SSdbRaw *pRaw) {
     }
     int16_t colId;
     SDB_GET_INT16(pRaw, dataPos, &colId, TOPIC_DECODE_OVER);
-    taosArrayPush(pTopic->ntbColIds, &colId);
+    (void)taosArrayPush(pTopic->ntbColIds, &colId);
   }
 
   SDB_GET_INT64(pRaw, dataPos, &pTopic->ctbStbUid, TOPIC_DECODE_OVER);
@@ -289,25 +296,25 @@ static int32_t mndTopicActionDelete(SSdb *pSdb, SMqTopicObj *pTopic) {
   taosMemoryFreeClear(pTopic->ast);
   taosMemoryFreeClear(pTopic->physicalPlan);
   if (pTopic->schema.nCols) taosMemoryFreeClear(pTopic->schema.pSchema);
-  taosArrayDestroy(pTopic->ntbColIds);
+  (void)taosArrayDestroy(pTopic->ntbColIds);
   return 0;
 }
 
 static int32_t mndTopicActionUpdate(SSdb *pSdb, SMqTopicObj *pOldTopic, SMqTopicObj *pNewTopic) {
   mTrace("topic:%s perform update action", pOldTopic->name);
-  atomic_exchange_64(&pOldTopic->updateTime, pNewTopic->updateTime);
+  (void)atomic_exchange_64(&pOldTopic->updateTime, pNewTopic->updateTime);
-  atomic_exchange_32(&pOldTopic->version, pNewTopic->version);
+  (void)atomic_exchange_32(&pOldTopic->version, pNewTopic->version);
 
   return 0;
 }
 
-SMqTopicObj *mndAcquireTopic(SMnode *pMnode, const char *topicName) {
+int32_t mndAcquireTopic(SMnode *pMnode, const char *topicName, SMqTopicObj **pTopic) {
   SSdb        *pSdb = pMnode->pSdb;
-  SMqTopicObj *pTopic = sdbAcquire(pSdb, SDB_TOPIC, topicName);
+  *pTopic = sdbAcquire(pSdb, SDB_TOPIC, topicName);
-  if (pTopic == NULL && terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) {
+  if (*pTopic == NULL) {
-    terrno = TSDB_CODE_MND_TOPIC_NOT_EXIST;
+    return TSDB_CODE_MND_TOPIC_NOT_EXIST;
   }
-  return pTopic;
+  return TDB_CODE_SUCCESS;
 }
 
 void mndReleaseTopic(SMnode *pMnode, SMqTopicObj *pTopic) {
@@ -316,25 +323,23 @@ void mndReleaseTopic(SMnode *pMnode, SMqTopicObj *pTopic) {
 }
 
 static int32_t mndCheckCreateTopicReq(SCMCreateTopicReq *pCreate) {
-  terrno = TSDB_CODE_MND_INVALID_TOPIC;
+  if (pCreate->sql == NULL) return TSDB_CODE_MND_INVALID_TOPIC;
-
-  if (pCreate->sql == NULL) return -1;
 
   if (pCreate->subType == TOPIC_SUB_TYPE__COLUMN) {
-    if (pCreate->ast == NULL || pCreate->ast[0] == 0) return -1;
+    if (pCreate->ast == NULL || pCreate->ast[0] == 0) return TSDB_CODE_MND_INVALID_TOPIC;
   } else if (pCreate->subType == TOPIC_SUB_TYPE__TABLE) {
-    if (pCreate->subStbName[0] == 0) return -1;
+    if (pCreate->subStbName[0] == 0) return TSDB_CODE_MND_INVALID_TOPIC;
   } else if (pCreate->subType == TOPIC_SUB_TYPE__DB) {
-    if (pCreate->subDbName[0] == 0) return -1;
+    if (pCreate->subDbName[0] == 0) return TSDB_CODE_MND_INVALID_TOPIC;
   }
 
-  terrno = TSDB_CODE_SUCCESS;
   return 0;
 }
 
 static int32_t extractTopicTbInfo(SNode *pAst, SMqTopicObj *pTopic) {
   SNodeList *pNodeList = NULL;
-  nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList);
+  int32_t   code = 0;
+  MND_TMQ_RETURN_CHECK(nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList));
   int64_t suid = ((SRealTableNode *)((SSelectStmt *)pAst)->pFromTable)->pMeta->suid;
   int8_t  tableType = ((SRealTableNode *)((SSelectStmt *)pAst)->pFromTable)->pMeta->tableType;
   if (tableType == TSDB_CHILD_TABLE) {
@@ -345,17 +350,19 @@ static int32_t extractTopicTbInfo(SNode *pAst, SMqTopicObj *pTopic) {
       SColumnNode *pCol = (SColumnNode *)pNode;
       if (pCol->tableType == TSDB_NORMAL_TABLE) {
         pTopic->ntbUid = pCol->tableId;
-        taosArrayPush(pTopic->ntbColIds, &pCol->colId);
+        MND_TMQ_NULL_CHECK(taosArrayPush(pTopic->ntbColIds, &pCol->colId));
       }
     }
   }
   nodesDestroyList(pNodeList);
-  return 0;
+
+END:
+  return code;
 }
 
 static int32_t sendCheckInfoToVnode(STrans *pTrans, SMnode *pMnode, SMqTopicObj *topicObj){
-  STqCheckInfo info;
+  STqCheckInfo info = {0};
-  memcpy(info.topic, topicObj->name, TSDB_TOPIC_FNAME_LEN);
+  (void)memcpy(info.topic, topicObj->name, TSDB_TOPIC_FNAME_LEN);
   info.ntbUid = topicObj->ntbUid;
   info.colIdList = topicObj->ntbColIds;
   // broadcast forbid alter info
@@ -378,16 +385,17 @@ static int32_t sendCheckInfoToVnode(STrans *pTrans, SMnode *pMnode, SMqTopicObj
     int32_t len;
     tEncodeSize(tEncodeSTqCheckInfo, &info, len, code);
     if (code != 0) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      code = TSDB_CODE_OUT_OF_MEMORY;
       goto END;
     }
     buf = taosMemoryCalloc(1, sizeof(SMsgHead) + len);
+    MND_TMQ_NULL_CHECK(buf);
     void    *abuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
-    SEncoder encoder;
+    SEncoder encoder = {0};
     tEncoderInit(&encoder, abuf, len);
     code = tEncodeSTqCheckInfo(&encoder, &info);
     if (code < 0) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      tEncoderClear(&encoder);
       goto END;
     }
     tEncoderClear(&encoder);
@@ -398,10 +406,7 @@ static int32_t sendCheckInfoToVnode(STrans *pTrans, SMnode *pMnode, SMqTopicObj
     action.pCont = buf;
     action.contLen = sizeof(SMsgHead) + len;
     action.msgType = TDMT_VND_TMQ_ADD_CHECKINFO;
-    code = mndTransAppendRedoAction(pTrans, &action);
+    MND_TMQ_RETURN_CHECK(mndTransAppendRedoAction(pTrans, &action));
-    if (code != 0) {
-      goto END;
-    }
     sdbRelease(pSdb, pVgroup);
     buf = NULL;
   }
@@ -417,33 +422,22 @@ static int32_t mndCreateTopic(SMnode *pMnode, SRpcMsg *pReq, SCMCreateTopicReq *
                               const char *userName) {
   mInfo("start to create topic:%s", pCreate->name);
   STrans *pTrans = NULL;
-  int32_t code = -1;
+  int32_t code = 0;
   SNode  *pAst = NULL;
   SQueryPlan *pPlan = NULL;
   SMqTopicObj topicObj = {0};
 
   pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_DB, pReq, "create-topic");
-  if (pTrans == NULL) {
+  MND_TMQ_NULL_CHECK(pTrans);
-    mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
-    code = -1;
-    goto _OUT;
-  }
-
   mndTransSetDbName(pTrans, pDb->name, NULL);
-  code = mndTransCheckConflict(pMnode, pTrans);
+  MND_TMQ_RETURN_CHECK(mndTransCheckConflict(pMnode, pTrans));
-  if (code != 0) {
-    goto _OUT;
-  }
   mInfo("trans:%d to create topic:%s", pTrans->id, pCreate->name);
 
   tstrncpy(topicObj.name, pCreate->name, TSDB_TOPIC_FNAME_LEN);
   tstrncpy(topicObj.db, pDb->name, TSDB_DB_FNAME_LEN);
   tstrncpy(topicObj.createUser, userName, TSDB_USER_LEN);
 
-  code = mndCheckTopicPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_TOPIC, &topicObj);
+  MND_TMQ_RETURN_CHECK(mndCheckTopicPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_TOPIC, &topicObj));
-  if (code != 0) {
-    goto _OUT;
-  }
 
   topicObj.createTime = taosGetTimestampMs();
   topicObj.updateTime = topicObj.createTime;
@@ -458,56 +452,25 @@ static int32_t mndCreateTopic(SMnode *pMnode, SRpcMsg *pReq, SCMCreateTopicReq *
   if (pCreate->subType == TOPIC_SUB_TYPE__COLUMN) {
     topicObj.ast = taosStrdup(pCreate->ast);
     topicObj.astLen = strlen(pCreate->ast) + 1;
-
     qDebugL("topic:%s ast %s", topicObj.name, topicObj.ast);
-
+    MND_TMQ_RETURN_CHECK(nodesStringToNode(pCreate->ast, &pAst));
-    code = nodesStringToNode(pCreate->ast, &pAst);
-    if (code != 0) {
-      mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
-      goto _OUT;
-    }
-
     SPlanContext cxt = {.pAstRoot = pAst, .topicQuery = true};
-    code = qCreateQueryPlan(&cxt, &pPlan, NULL);
+    MND_TMQ_RETURN_CHECK(qCreateQueryPlan(&cxt, &pPlan, NULL));
-    if (code != 0) {
-      mError("failed to create topic:%s since %s", pCreate->name, terrstr());
-      goto _OUT;
-    }
 
     topicObj.ntbColIds = taosArrayInit(0, sizeof(int16_t));
-    if (topicObj.ntbColIds == NULL) {
+    MND_TMQ_NULL_CHECK(topicObj.ntbColIds);
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
+    MND_TMQ_RETURN_CHECK(extractTopicTbInfo(pAst, &topicObj));
-      code = terrno;
-      goto _OUT;
-    }
-
-    extractTopicTbInfo(pAst, &topicObj);
-
     if (topicObj.ntbUid == 0) {
-      taosArrayDestroy(topicObj.ntbColIds);
+      (void)taosArrayDestroy(topicObj.ntbColIds);
       topicObj.ntbColIds = NULL;
     }
 
-    code = qExtractResultSchema(pAst, &topicObj.schema.nCols, &topicObj.schema.pSchema);
+    MND_TMQ_RETURN_CHECK(qExtractResultSchema(pAst, &topicObj.schema.nCols, &topicObj.schema.pSchema));
-    if (code != 0) {
+    MND_TMQ_RETURN_CHECK(nodesNodeToString((SNode *)pPlan, false, &topicObj.physicalPlan, NULL));
-      mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
-      goto _OUT;
-    }
-
-    code = nodesNodeToString((SNode *)pPlan, false, &topicObj.physicalPlan, NULL);
-    if (code != 0) {
-      mError("topic:%s, failed to create since %s", pCreate->name, terrstr());
-      goto _OUT;
-    }
   } else if (pCreate->subType == TOPIC_SUB_TYPE__TABLE) {
     SStbObj *pStb = mndAcquireStb(pMnode, pCreate->subStbName);
-    if (pStb == NULL) {
+    MND_TMQ_NULL_CHECK(pStb);
-      terrno = TSDB_CODE_MND_STB_NOT_EXIST;
+    tstrncpy(topicObj.stbName, pCreate->subStbName, TSDB_TABLE_FNAME_LEN);
-      code = terrno;
-      goto _OUT;
-    }
-
-    strcpy(topicObj.stbName, pCreate->subStbName);
     topicObj.stbUid = pStb->uid;
     mndReleaseStb(pMnode, pStb);
     if(pCreate->ast != NULL){
@@ -518,34 +481,25 @@ static int32_t mndCreateTopic(SMnode *pMnode, SRpcMsg *pReq, SCMCreateTopicReq *
   }
 
   SSdbRaw *pCommitRaw = mndTopicActionEncode(&topicObj);
-  if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
+  MND_TMQ_NULL_CHECK(pCommitRaw);
-    mError("trans:%d, failed to append commit log since %s", pTrans->id, terrstr());
+  code = mndTransAppendCommitlog(pTrans, pCommitRaw);
-    code = -1;
+  if(code != 0) {
-    goto _OUT;
+    sdbFreeRaw(pCommitRaw);
+    goto END;
   }
 
-  (void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
+  MND_TMQ_RETURN_CHECK(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY));
-
   if (topicObj.ntbUid != 0) {
-    code = sendCheckInfoToVnode(pTrans, pMnode, &topicObj);
+    MND_TMQ_RETURN_CHECK(sendCheckInfoToVnode(pTrans, pMnode, &topicObj));
-    if (code != 0){
-      goto _OUT;
   }
-  }
+  MND_TMQ_RETURN_CHECK(mndTransPrepare(pMnode, pTrans));
-
-  if (mndTransPrepare(pMnode, pTrans) != 0) {
-    mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
-    code = -1;
-    goto _OUT;
-  }
-
   code = TSDB_CODE_ACTION_IN_PROGRESS;
 
-_OUT:
+END:
   taosMemoryFreeClear(topicObj.physicalPlan);
   taosMemoryFreeClear(topicObj.sql);
   taosMemoryFreeClear(topicObj.ast);
-  taosArrayDestroy(topicObj.ntbColIds);
+  (void)taosArrayDestroy(topicObj.ntbColIds);
   if (topicObj.schema.nCols) {
     taosMemoryFreeClear(topicObj.schema.pSchema);
   }
@@ -557,75 +511,64 @@ _OUT:
 
 static int32_t mndProcessCreateTopicReq(SRpcMsg *pReq) {
   SMnode           *pMnode = pReq->info.node;
-  int32_t           code = -1;
+  int32_t           code = TDB_CODE_SUCCESS;
   SMqTopicObj      *pTopic = NULL;
   SDbObj           *pDb = NULL;
   SCMCreateTopicReq createTopicReq = {0};
 
   if (tDeserializeSCMCreateTopicReq(pReq->pCont, pReq->contLen, &createTopicReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
+    code = TSDB_CODE_INVALID_MSG;
-    goto _OVER;
+    goto END;
   }
 
   mInfo("topic:%s start to create, sql:%s", createTopicReq.name, createTopicReq.sql);
 
-  if (mndCheckCreateTopicReq(&createTopicReq) != 0) {
+  MND_TMQ_RETURN_CHECK(mndCheckCreateTopicReq(&createTopicReq));
-    mError("topic:%s failed to create since %s", createTopicReq.name, terrstr());
-    goto _OVER;
-  }
 
-  pTopic = mndAcquireTopic(pMnode, createTopicReq.name);
+  code = mndAcquireTopic(pMnode, createTopicReq.name, &pTopic);
-  if (pTopic != NULL) {
+  if (code == TDB_CODE_SUCCESS) {
     if (createTopicReq.igExists) {
       mInfo("topic:%s already exist, ignore exist is set", createTopicReq.name);
-      code = 0;
+      goto END;
-      goto _OVER;
     } else {
-      terrno = TSDB_CODE_MND_TOPIC_ALREADY_EXIST;
+      code = TSDB_CODE_MND_TOPIC_ALREADY_EXIST;
-      goto _OVER;
+      goto END;
     }
-  } else if (terrno != TSDB_CODE_MND_TOPIC_NOT_EXIST) {
+  } else if (code != TSDB_CODE_MND_TOPIC_NOT_EXIST) {
-    goto _OVER;
+    goto END;
   }
 
   pDb = mndAcquireDb(pMnode, createTopicReq.subDbName);
-  if (pDb == NULL) {
+  MND_TMQ_NULL_CHECK(pDb);
-    terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
-    goto _OVER;
-  }
 
   if (pDb->cfg.walRetentionPeriod == 0) {
-    terrno = TSDB_CODE_MND_DB_RETENTION_PERIOD_ZERO;
+    code = TSDB_CODE_MND_DB_RETENTION_PERIOD_ZERO;
     mError("db:%s, not allowed to create topic when WAL_RETENTION_PERIOD is zero", pDb->name);
-    goto _OVER;
+    goto END;
   }
 
   if (sdbGetSize(pMnode->pSdb, SDB_TOPIC) >= tmqMaxTopicNum){
-    terrno = TSDB_CODE_TMQ_TOPIC_OUT_OF_RANGE;
+    code = TSDB_CODE_TMQ_TOPIC_OUT_OF_RANGE;
     mError("topic num out of range");
-    goto _OVER;
+    goto END;
-  }
-
-  if ((terrno = grantCheck(TSDB_GRANT_SUBSCRIPTION)) < 0) {
-    goto _OVER;
   }
 
+  MND_TMQ_RETURN_CHECK(grantCheck(TSDB_GRANT_SUBSCRIPTION));
   code = mndCreateTopic(pMnode, pReq, &createTopicReq, pDb, pReq->info.conn.user);
   if (code == 0) {
     code = TSDB_CODE_ACTION_IN_PROGRESS;
   }
 
+  {
     SName dbname = {0};
-  tNameFromString(&dbname, createTopicReq.subDbName, T_NAME_ACCT | T_NAME_DB);
+    (void)tNameFromString(&dbname, createTopicReq.subDbName, T_NAME_ACCT | T_NAME_DB);              // ignore error
-
     SName topicName = {0};
-  tNameFromString(&topicName, createTopicReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+    (void)tNameFromString(&topicName, createTopicReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); // ignore error
-  //reuse this function for topic
-
     auditRecord(pReq, pMnode->clusterId, "createTopic", dbname.dbname, topicName.dbname,
                 createTopicReq.sql, strlen(createTopicReq.sql));
+  }
 
-_OVER:
+END:
   if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {
     mError("failed to create topic:%s since %s", createTopicReq.name, terrstr());
   }
@@ -638,22 +581,20 @@ _OVER:
 }
 
 static int32_t mndDropTopic(SMnode *pMnode, STrans *pTrans, SRpcMsg *pReq, SMqTopicObj *pTopic) {
-  int32_t code = -1;
+  int32_t code = 0;
-  if (mndUserRemoveTopic(pMnode, pTrans, pTopic->name) != 0) {
+  SSdbRaw *pCommitRaw = NULL;
-    goto _OVER;
+  MND_TMQ_RETURN_CHECK(mndUserRemoveTopic(pMnode, pTrans, pTopic->name));
+  pCommitRaw = mndTopicActionEncode(pTopic);
+  MND_TMQ_NULL_CHECK(pCommitRaw);
+  code = mndTransAppendCommitlog(pTrans, pCommitRaw);
+  if(code != 0) {
+    sdbFreeRaw(pCommitRaw);
+    goto END;
   }
+  MND_TMQ_RETURN_CHECK(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));
+  MND_TMQ_RETURN_CHECK(mndTransPrepare(pMnode, pTrans));
 
-  SSdbRaw *pCommitRaw = mndTopicActionEncode(pTopic);
+END:
-  if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto _OVER;
-  (void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED);
-
-  if (mndTransPrepare(pMnode, pTrans) != 0) {
-    goto _OVER;
-  }
-
-  code = 0;
-
-_OVER:
   return code;
 }
 
@@ -661,7 +602,7 @@ static bool checkTopic(SArray *topics, char *topicName){
   int32_t sz = taosArrayGetSize(topics);
   for (int32_t i = 0; i < sz; i++) {
     char *name = taosArrayGetP(topics, i);
-    if (strcmp(name, topicName) == 0) {
+    if (name && strcmp(name, topicName) == 0) {
       return true;
     }
   }
@@ -682,29 +623,26 @@ static int32_t mndDropConsumerByTopic(SMnode *pMnode, STrans *pTrans, char *topi
     bool found = checkTopic(pConsumer->assignedTopics, topicName);
     if (found){
       if (pConsumer->status == MQ_CONSUMER_STATUS_LOST) {
-        code = mndSetConsumerDropLogs(pTrans, pConsumer);
+        MND_TMQ_RETURN_CHECK(mndSetConsumerDropLogs(pTrans, pConsumer));
-        if (code != 0) {
-          goto end;
-        }
         sdbRelease(pSdb, pConsumer);
         continue;
       }
       mError("topic:%s, failed to drop since subscribed by consumer:0x%" PRIx64 ", in consumer group %s",
              topicName, pConsumer->consumerId, pConsumer->cgroup);
       code = TSDB_CODE_MND_TOPIC_SUBSCRIBED;
-      goto end;
+      goto END;
     }
 
     if (checkTopic(pConsumer->rebNewTopics, topicName) || checkTopic(pConsumer->rebRemovedTopics, topicName))  {
       code = TSDB_CODE_MND_TOPIC_SUBSCRIBED;
       mError("topic:%s, failed to drop since subscribed by consumer:%" PRId64 ", in consumer group %s (reb new)",
              topicName, pConsumer->consumerId, pConsumer->cgroup);
-      goto end;
+      goto END;
     }
     sdbRelease(pSdb, pConsumer);
   }
 
-end:
+END:
   sdbRelease(pSdb, pConsumer);
   sdbCancelFetch(pSdb, pIter);
   return code;
@@ -726,13 +664,10 @@ static int32_t mndDropCheckInfoByTopic(SMnode *pMnode, STrans *pTrans, SMqTopicO
     }
 
     buf = taosMemoryCalloc(1, sizeof(SMsgHead) + TSDB_TOPIC_FNAME_LEN);
-    if (buf == NULL){
+    MND_TMQ_NULL_CHECK(buf);
-      code = TSDB_CODE_OUT_OF_MEMORY;
-      goto end;
-    }
     void *abuf = POINTER_SHIFT(buf, sizeof(SMsgHead));
     ((SMsgHead *)buf)->vgId = htonl(pVgroup->vgId);
-    memcpy(abuf, pTopic->name, TSDB_TOPIC_FNAME_LEN);
+    (void)memcpy(abuf, pTopic->name, TSDB_TOPIC_FNAME_LEN);
 
     STransAction action = {0};
     action.epSet = mndGetVgroupEpset(pMnode, pVgroup);
@@ -742,12 +677,12 @@ static int32_t mndDropCheckInfoByTopic(SMnode *pMnode, STrans *pTrans, SMqTopicO
     code = mndTransAppendRedoAction(pTrans, &action);
     if (code != 0) {
       taosMemoryFree(buf);
-      goto end;
+      goto END;
     }
     sdbRelease(pSdb, pVgroup);
   }
 
-end:
+END:
   sdbRelease(pSdb, pVgroup);
   sdbCancelFetch(pSdb, pIter);
   return code;
@@ -761,70 +696,40 @@ static int32_t mndProcessDropTopicReq(SRpcMsg *pReq) {
   STrans      *pTrans = NULL;
 
   if (tDeserializeSMDropTopicReq(pReq->pCont, pReq->contLen, &dropReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
+    return TSDB_CODE_INVALID_MSG;
-    return -1;
   }
 
-  pTopic = mndAcquireTopic(pMnode, dropReq.name);
+  code = mndAcquireTopic(pMnode, dropReq.name, &pTopic);
-  if (pTopic == NULL) {
+  if (code != 0) {
     if (dropReq.igNotExists) {
       mInfo("topic:%s, not exist, ignore not exist is set", dropReq.name);
       tFreeSMDropTopicReq(&dropReq);
       return 0;
     } else {
-      terrno = TSDB_CODE_MND_TOPIC_NOT_EXIST;
       mError("topic:%s, failed to drop since %s", dropReq.name, terrstr());
       tFreeSMDropTopicReq(&dropReq);
-      return -1;
+      return code;
     }
   }
 
   pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "drop-topic");
-  if (pTrans == NULL) {
+  MND_TMQ_NULL_CHECK(pTrans);
-    mError("topic:%s, failed to drop since %s", pTopic->name, terrstr());
-    code = -1;
-    goto end;
-  }
 
   mndTransSetDbName(pTrans, pTopic->db, NULL);
-  code = mndTransCheckConflict(pMnode, pTrans);
+  MND_TMQ_RETURN_CHECK(mndTransCheckConflict(pMnode, pTrans));
-  if (code != 0) {
-    goto end;
-  }
-
   mInfo("trans:%d, used to drop topic:%s", pTrans->id, pTopic->name);
-
+  MND_TMQ_RETURN_CHECK(mndCheckTopicPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_TOPIC, pTopic));
-  code = mndCheckTopicPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_TOPIC, pTopic);
+  MND_TMQ_RETURN_CHECK(mndCheckDbPrivilegeByName(pMnode, pReq->info.conn.user, MND_OPER_READ_DB, pTopic->db));
-  if (code != 0) {
+  MND_TMQ_RETURN_CHECK(mndDropConsumerByTopic(pMnode, pTrans, dropReq.name));
-    goto end;
+  MND_TMQ_RETURN_CHECK(mndDropSubByTopic(pMnode, pTrans, dropReq.name));
-  }
-
-  code = mndCheckDbPrivilegeByName(pMnode, pReq->info.conn.user, MND_OPER_READ_DB, pTopic->db);
-  if (code != 0) {
-    goto end;
-  }
-
-  code = mndDropConsumerByTopic(pMnode, pTrans, dropReq.name);
-  if (code != 0) {
-    goto end;
-  }
-
-  code = mndDropSubByTopic(pMnode, pTrans, dropReq.name);
-  if (code < 0) {
-    mError("topic:%s, failed to drop since %s", pTopic->name, terrstr());
-    goto end;
-  }
 
   if (pTopic->ntbUid != 0) {
-    code = mndDropCheckInfoByTopic(pMnode, pTrans, pTopic);
+    MND_TMQ_RETURN_CHECK(mndDropCheckInfoByTopic(pMnode, pTrans, pTopic));
-    if (code != 0) {
-      goto end;
-    }
   }
 
   code = mndDropTopic(pMnode, pTrans, pReq, pTopic);
 
-end:
+END:
   mndReleaseTopic(pMnode, pTopic);
   mndTransDrop(pTrans);
   if (code != 0) {
@@ -834,8 +739,7 @@ end:
   }
 
   SName name = {0};
-  tNameFromString(&name, dropReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  (void)tNameFromString(&name, dropReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);   // ignore error
-
   auditRecord(pReq, pMnode->clusterId, "dropTopic", name.dbname, name.tname, dropReq.sql, dropReq.sqlLen);
 
   tFreeSMDropTopicReq(&dropReq);
@@ -849,8 +753,7 @@ int32_t mndGetNumOfTopics(SMnode *pMnode, char *dbName, int32_t *pNumOfTopics) {
   SSdb   *pSdb = pMnode->pSdb;
   SDbObj *pDb = mndAcquireDb(pMnode, dbName);
   if (pDb == NULL) {
-    terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
+    return TSDB_CODE_MND_DB_NOT_SELECTED;
-    return -1;
   }
 
   int32_t numOfTopics = 0;
@@ -876,17 +779,23 @@ int32_t mndGetNumOfTopics(SMnode *pMnode, char *dbName, int32_t *pNumOfTopics) {
 
 static void schemaToJson(SSchema *schema, int32_t nCols, char *schemaJson){
   char*   string = NULL;
+  int32_t code = 0;
   cJSON* columns = cJSON_CreateArray();
-  if (columns == NULL) {
+  MND_TMQ_NULL_CHECK(columns);
-    return;
-  }
   for (int i = 0; i < nCols; i++) {
     cJSON*   column = cJSON_CreateObject();
+    MND_TMQ_NULL_CHECK(column);
     SSchema* s = schema + i;
     cJSON*   cname = cJSON_CreateString(s->name);
-    cJSON_AddItemToObject(column, "name", cname);
+    MND_TMQ_NULL_CHECK(cname);
+    if (!cJSON_AddItemToObject(column, "name", cname)) {
+      return;
+    }
     cJSON* ctype = cJSON_CreateString(tDataTypes[s->type].name);
-    cJSON_AddItemToObject(column, "type", ctype);
+    MND_TMQ_NULL_CHECK(ctype);
+    if (!cJSON_AddItemToObject(column, "type", ctype)) {
+      return;
+    }
     int32_t length = 0;
     if (s->type == TSDB_DATA_TYPE_BINARY || s->type == TSDB_DATA_TYPE_VARBINARY ||
         s->type == TSDB_DATA_TYPE_GEOMETRY) {
@@ -897,8 +806,13 @@ static void schemaToJson(SSchema *schema, int32_t nCols, char *schemaJson){
       length = s->bytes;
     }
     cJSON*  cbytes = cJSON_CreateNumber(length);
-    cJSON_AddItemToObject(column, "length", cbytes);
+    MND_TMQ_NULL_CHECK(cbytes);
-    cJSON_AddItemToArray(columns, column);
+    if (!cJSON_AddItemToObject(column, "length", cbytes)){
+      return;
+    }
+    if (!cJSON_AddItemToArray(columns, column)){
+      return;
+    }
   }
   string = cJSON_PrintUnformatted(columns);
   cJSON_Delete(columns);
@@ -910,6 +824,9 @@ static void schemaToJson(SSchema *schema, int32_t nCols, char *schemaJson){
     mError("mndRetrieveTopic build schema error json:%p, json len:%zu", string, len);
   }
   taosMemoryFree(string);
+
+END:
+  return;
 }
 
 static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) {
@@ -917,13 +834,16 @@ static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
   SSdb        *pSdb = pMnode->pSdb;
   int32_t      numOfRows = 0;
   SMqTopicObj *pTopic = NULL;
+  int32_t      code = 0;
+  char        *sql  = NULL;
+  char        *schemaJson  = NULL;
 
   while (numOfRows < rowsCapacity) {
     pShow->pIter = sdbFetch(pSdb, SDB_TOPIC, pShow->pIter, (void **)&pTopic);
     if (pShow->pIter == NULL) break;
 
-    SColumnInfoData *pColInfo;
+    SColumnInfoData *pColInfo= NULL;
-    SName            n;
+    SName            n = {0};
     int32_t          cols = 0;
 
     char        topicName[TSDB_TOPIC_NAME_LEN + VARSTR_HEADER_SIZE + 5] = {0};
@@ -931,28 +851,34 @@ static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
     STR_TO_VARSTR(topicName, pName);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)topicName, false);
+    MND_TMQ_NULL_CHECK(pColInfo);
+    MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)topicName, false));
 
     char dbName[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
-    tNameFromString(&n, pTopic->db, T_NAME_ACCT | T_NAME_DB);
+    MND_TMQ_RETURN_CHECK(tNameFromString(&n, pTopic->db, T_NAME_ACCT | T_NAME_DB));
-    tNameGetDbName(&n, varDataVal(dbName));
+    MND_TMQ_RETURN_CHECK(tNameGetDbName(&n, varDataVal(dbName)));
     varDataSetLen(dbName, strlen(varDataVal(dbName)));
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)dbName, false);
+    MND_TMQ_NULL_CHECK(pColInfo);
+    MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)dbName, false));
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pTopic->createTime, false);
+    MND_TMQ_NULL_CHECK(pColInfo);
+    MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)&pTopic->createTime, false));
 
-    char *sql = taosMemoryMalloc(strlen(pTopic->sql) + VARSTR_HEADER_SIZE);
+    sql = taosMemoryMalloc(strlen(pTopic->sql) + VARSTR_HEADER_SIZE);
+    MND_TMQ_NULL_CHECK(sql);
     STR_TO_VARSTR(sql, pTopic->sql);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)sql, false);
+    MND_TMQ_NULL_CHECK(pColInfo);
+    MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)sql, false));
 
-    taosMemoryFree(sql);
+    taosMemoryFreeClear(sql);
 
-    char *schemaJson = taosMemoryMalloc(TSDB_SHOW_SCHEMA_JSON_LEN + VARSTR_HEADER_SIZE);
+    schemaJson = taosMemoryMalloc(TSDB_SHOW_SCHEMA_JSON_LEN + VARSTR_HEADER_SIZE);
+    MND_TMQ_NULL_CHECK(schemaJson);
     if(pTopic->subType == TOPIC_SUB_TYPE__COLUMN){
       schemaToJson(pTopic->schema.pSchema, pTopic->schema.nCols, schemaJson);
     }else if(pTopic->subType == TOPIC_SUB_TYPE__TABLE){
@@ -969,8 +895,9 @@ static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
     }
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)schemaJson, false);
+    MND_TMQ_NULL_CHECK(pColInfo);
-    taosMemoryFree(schemaJson);
+    MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)schemaJson, false));
+    taosMemoryFreeClear(schemaJson);
 
     char mete[4 + VARSTR_HEADER_SIZE] = {0};
     if(pTopic->withMeta){
@@ -980,7 +907,8 @@ static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
     }
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)mete, false);
+    MND_TMQ_NULL_CHECK(pColInfo);
+    MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)mete, false));
 
     char type[8 + VARSTR_HEADER_SIZE] = {0};
     if(pTopic->subType == TOPIC_SUB_TYPE__COLUMN){
@@ -992,7 +920,8 @@ static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
     }
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)type, false);
+    MND_TMQ_NULL_CHECK(pColInfo);
+    MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)type, false));
 
     numOfRows++;
     sdbRelease(pSdb, pTopic);
@@ -1000,24 +929,11 @@ static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
 
   pShow->numOfRows += numOfRows;
   return numOfRows;
-}
 
-int32_t mndSetTopicCommitLogs(SMnode *pMnode, STrans *pTrans, SMqTopicObj *pTopic) {
+END:
-  SSdbRaw *pCommitRaw = mndTopicActionEncode(pTopic);
+  taosMemoryFreeClear(schemaJson);
-  if (pCommitRaw == NULL) return -1;
+  taosMemoryFreeClear(sql);
-  if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1;
+  return code;
-  if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) return -1;
-
-  return 0;
-}
-
-static int32_t mndSetDropTopicCommitLogs(SMnode *pMnode, STrans *pTrans, SMqTopicObj *pTopic) {
-  SSdbRaw *pCommitRaw = mndTopicActionEncode(pTopic);
-  if (pCommitRaw == NULL) return -1;
-  if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1;
-  if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED) != 0) return -1;
-
-  return 0;
 }
 
 static void mndCancelGetNextTopic(SMnode *pMnode, void *pIter) {
@@ -1047,33 +963,3 @@ bool mndTopicExistsForDb(SMnode *pMnode, SDbObj *pDb) {
 
   return false;
 }
-
-#if 0
-int32_t mndDropTopicByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
-  int32_t code = 0;
-  SSdb   *pSdb = pMnode->pSdb;
-
-  void        *pIter = NULL;
-  SMqTopicObj *pTopic = NULL;
-  while (1) {
-    pIter = sdbFetch(pSdb, SDB_TOPIC, pIter, (void **)&pTopic);
-    if (pIter == NULL) break;
-
-    if (pTopic->dbUid != pDb->uid) {
-      sdbRelease(pSdb, pTopic);
-      continue;
-    }
-
-    if (mndSetDropTopicCommitLogs(pMnode, pTrans, pTopic) < 0) {
-      sdbRelease(pSdb, pTopic);
-      sdbCancelFetch(pSdb, pIter);
-      code = -1;
-      break;
-    }
-
-    sdbRelease(pSdb, pTopic);
-  }
-
-  return code;
-}
-#endif

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

@@ -1357,7 +1357,7 @@ SHashObj *mndDupUseDbHash(SHashObj *pOld) {
 }
 
 int32_t mndUserDupObj(SUserObj *pUser, SUserObj *pNew) {
-  memcpy(pNew, pUser, sizeof(SUserObj));
+  (void)memcpy(pNew, pUser, sizeof(SUserObj));
   pNew->authVersion++;
   pNew->updateTime = taosGetTimestampMs();
 
@@ -1377,7 +1377,7 @@ int32_t mndUserDupObj(SUserObj *pUser, SUserObj *pNew) {
   taosRUnLockLatch(&pUser->lock);
 
   if (pNew->readDbs == NULL || pNew->writeDbs == NULL || pNew->topics == NULL) {
-    return -1;
+    return TSDB_CODE_INVALID_PARA;
   }
   return 0;
 }
@@ -1983,10 +1983,11 @@ static int32_t mndProcessAlterUserPrivilegesReq(SAlterUserReq *pAlterReq, SMnode
 
   if (ALTER_USER_ADD_SUBSCRIBE_TOPIC_PRIV(pAlterReq->alterType, pAlterReq->privileges)) {
     int32_t      len = strlen(pAlterReq->objname) + 1;
-    SMqTopicObj *pTopic = mndAcquireTopic(pMnode, pAlterReq->objname);
+    SMqTopicObj *pTopic = NULL;
-    if (pTopic == NULL) {
+    int32_t code = mndAcquireTopic(pMnode, pAlterReq->objname, &pTopic);
+    if (code != 0) {
       mndReleaseTopic(pMnode, pTopic);
-      return -1;
+      return code;
     }
     taosHashPut(pNewUser->topics, pTopic->name, len, pTopic->name, TSDB_TOPIC_FNAME_LEN);
     mndReleaseTopic(pMnode, pTopic);
@@ -1994,10 +1995,11 @@ static int32_t mndProcessAlterUserPrivilegesReq(SAlterUserReq *pAlterReq, SMnode
 
   if (ALTER_USER_DEL_SUBSCRIBE_TOPIC_PRIV(pAlterReq->alterType, pAlterReq->privileges)) {
     int32_t      len = strlen(pAlterReq->objname) + 1;
-    SMqTopicObj *pTopic = mndAcquireTopic(pMnode, pAlterReq->objname);
+    SMqTopicObj *pTopic = NULL;
-    if (pTopic == NULL) {
+    int32_t code = mndAcquireTopic(pMnode, pAlterReq->objname, &pTopic);
+    if (code != 0) {
       mndReleaseTopic(pMnode, pTopic);
-      return -1;
+      return code;
     }
     taosHashRemove(pNewUser->topics, pAlterReq->objname, len);
     mndReleaseTopic(pMnode, pTopic);

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

@@ -2725,15 +2725,6 @@ int32_t mndSplitVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SVgObj *pVgro
   SDbObj  dbObj = {0};
   SArray *pArray = mndBuildDnodesArray(pMnode, 0);
 
-  //  int32_t numOfTopics = 0;
-  //  if (mndGetNumOfTopics(pMnode, pDb->name, &numOfTopics) != 0) {
-  //    goto _OVER;
-  //  }
-  //  if (numOfTopics > 0) {
-  //    terrno = TSDB_CODE_MND_TOPIC_MUST_BE_DELETED;
-  //    goto _OVER;
-  //  }
-
   int32_t numOfStreams = 0;
   if (mndGetNumOfStreams(pMnode, pDb->name, &numOfStreams) != 0) {
     goto _OVER;

source/libs/executor/inc/executil.h

@@ -118,7 +118,7 @@ int32_t createScanTableListInfo(SScanPhysiNode* pScanNode, SNodeList* pGroupTags
                                 SExecTaskInfo* pTaskInfo);
 
 STableListInfo* tableListCreate();
-void*           tableListDestroy(STableListInfo* pTableListInfo);
+void            tableListDestroy(STableListInfo* pTableListInfo);
 void            tableListClear(STableListInfo* pTableListInfo);
 int32_t         tableListGetOutputGroups(const STableListInfo* pTableList);
 bool            oneTableForEachGroup(const STableListInfo* pTableList);
@@ -165,7 +165,8 @@ SSDataBlock* createDataBlockFromDescNode(SDataBlockDescNode* pNode);
 int32_t      prepareDataBlockBuf(SSDataBlock* pDataBlock, SColMatchInfo* pMatchInfo);
 
 EDealRes doTranslateTagExpr(SNode** pNode, void* pContext);
-int32_t  getGroupIdFromTagsVal(void* pVnode, uint64_t uid, SNodeList* pGroupNode, char* keyBuf, uint64_t* pGroupId, SStorageAPI* pAPI);
+int32_t  getGroupIdFromTagsVal(void* pVnode, uint64_t uid, SNodeList* pGroupNode, char* keyBuf, uint64_t* pGroupId,
+                               SStorageAPI* pAPI);
 size_t   getTableTagsBufLen(const SNodeList* pGroups);
 
 SArray* createSortInfo(SNodeList* pNodeList);
@@ -173,18 +174,20 @@ SArray* makeColumnArrayFromList(SNodeList* pNodeList);
 int32_t extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNodeList, int32_t* numOfOutputCols,
                             int32_t type, SColMatchInfo* pMatchInfo);
 
-void       createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId);
+int32_t    createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId);
-void       createExprFromTargetNode(SExprInfo* pExp, STargetNode* pTargetNode);
+int32_t       createExprFromTargetNode(SExprInfo* pExp, STargetNode* pTargetNode);
 SExprInfo* createExprInfo(SNodeList* pNodeList, SNodeList* pGroupKeys, int32_t* numOfExprs);
 
-SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, int32_t** rowEntryInfoOffset, SFunctionStateStore* pStore);
+SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, int32_t** rowEntryInfoOffset,
-void relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray* pCols, bool outputEveryColumn);
+                                     SFunctionStateStore* pStore);
+int32_t relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray* pCols, bool outputEveryColumn);
 int32_t initExecTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pQueryWindow);
 
 SInterval extractIntervalInfo(const STableScanPhysiNode* pTableScanNode);
 SColumn   extractColumnFromColumnNode(SColumnNode* pColNode);
 
-int32_t initQueryTableDataCond(SQueryTableDataCond* pCond, const STableScanPhysiNode* pTableScanNode, const SReadHandle* readHandle);
+int32_t initQueryTableDataCond(SQueryTableDataCond* pCond, const STableScanPhysiNode* pTableScanNode,
+                               const SReadHandle* readHandle);
 void    cleanupQueryTableDataCond(SQueryTableDataCond* pCond);
 
 int32_t convertFillType(int32_t mode);
@@ -214,7 +217,7 @@ int32_t buildKeys(char* keyBuf, const SArray* pSortGroupCols, const SSDataBlock*
 int32_t compKeys(const SArray* pSortGroupCols, const char* oldkeyBuf, int32_t oldKeysLen, const SSDataBlock* pDataBlock,
                  int32_t rowIndex);
 
-uint64_t calcGroupId(char *pData, int32_t len);
+uint64_t calcGroupId(char* pData, int32_t len);
 
 SNodeList* makeColsNodeArrFromSortKeys(SNodeList* pSortKeys);
 

source/libs/executor/inc/executorInt.h

@@ -903,7 +903,7 @@ int32_t appendDataToSpecialBlock(SSDataBlock* pBlock, TSKEY* pStartTs, TSKEY* pE
 
 uint64_t calGroupIdByData(SPartitionBySupporter* pParSup, SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t rowId);
 
-int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, SExprSupp* pSup,
+void finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, SExprSupp* pSup,
                            SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo);
 
 bool    groupbyTbname(SNodeList* pGroupList);

source/libs/executor/inc/tfill.h

@@ -20,6 +20,7 @@
 extern "C" {
 #endif
 
+#include "executil.h"
 #include "os.h"
 #include "taosdef.h"
 #include "tcommon.h"
@@ -77,6 +78,7 @@ typedef struct SFillInfo {
   SFillColInfo*    pFillCol;  // column info for fill operations
   SFillTagColInfo* pTags;     // tags value for filling gap
   const char*      id;
+  SExecTaskInfo*   pTaskInfo;
 } SFillInfo;
 
 typedef struct SResultCellData {
@@ -128,10 +130,10 @@ bool          taosFillHasMoreResults(struct SFillInfo* pFillInfo);
 
 SFillInfo* taosCreateFillInfo(TSKEY skey, int32_t numOfFillCols, int32_t numOfNotFillCols, int32_t capacity,
                               SInterval* pInterval, int32_t fillType, struct SFillColInfo* pCol, int32_t slotId,
-                              int32_t order, const char* id);
+                              int32_t order, const char* id, SExecTaskInfo* pTaskInfo);
 
 void*   taosDestroyFillInfo(struct SFillInfo* pFillInfo);
-void    taosFillResultDataBlock(struct SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity);
+int32_t taosFillResultDataBlock(struct SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity);
 int64_t getFillInfoStart(struct SFillInfo* pFillInfo);
 
 bool fillIfWindowPseudoColumn(SFillInfo* pFillInfo, SFillColInfo* pCol, SColumnInfoData* pDstColInfoData,

source/libs/executor/src/aggregateoperator.c

@@ -194,7 +194,9 @@ static bool nextGroupedResult(SOperatorInfo* pOperator) {
     pBlock = getNextBlockFromDownstream(pOperator, 0);
     if (pBlock == NULL) {
       if (!pAggInfo->hasValidBlock) {
-        createDataBlockForEmptyInput(pOperator, &pBlock);
+        code = createDataBlockForEmptyInput(pOperator, &pBlock);
+        QUERY_CHECK_CODE(code, lino, _end);
+
         if (pBlock == NULL) {
           break;
         }
@@ -251,6 +253,8 @@ _end:
 }
 
 SSDataBlock* getAggregateResult(SOperatorInfo* pOperator) {
+  int32_t           code = TSDB_CODE_SUCCESS;
+  int32_t           lino = 0;
   SAggOperatorInfo* pAggInfo = pOperator->info;
   SOptrBasicInfo*   pInfo = &pAggInfo->binfo;
 
@@ -262,11 +266,13 @@ SSDataBlock* getAggregateResult(SOperatorInfo* pOperator) {
   bool           hasNewGroups = false;
   do {
     hasNewGroups = nextGroupedResult(pOperator);
-    blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
+    code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
+    QUERY_CHECK_CODE(code, lino, _end);
 
     while (1) {
       doBuildResultDatablock(pOperator, pInfo, &pAggInfo->groupResInfo, pAggInfo->aggSup.pResultBuf);
-      doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+      code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+      QUERY_CHECK_CODE(code, lino, _end);
 
       if (!hasRemainResults(&pAggInfo->groupResInfo)) {
         if (!hasNewGroups) setOperatorCompleted(pOperator);
@@ -282,6 +288,12 @@ SSDataBlock* getAggregateResult(SOperatorInfo* pOperator) {
   size_t rows = blockDataGetNumOfRows(pInfo->pRes);
   pOperator->resultInfo.totalRows += rows;
 
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    T_LONG_JMP(pTaskInfo->env, code);
+  }
+
   return (rows == 0) ? NULL : pInfo->pRes;
 }
 
@@ -312,6 +324,8 @@ int32_t doAggregateImpl(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx) {
 }
 
 static int32_t createDataBlockForEmptyInput(SOperatorInfo* pOperator, SSDataBlock** ppBlock) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
   if (!tsCountAlwaysReturnValue) {
     return TSDB_CODE_SUCCESS;
   }
@@ -352,9 +366,12 @@ static int32_t createDataBlockForEmptyInput(SOperatorInfo* pOperator, SSDataBloc
         int32_t slotId = pFuncParam->pCol->slotId;
         int32_t numOfCols = taosArrayGetSize(pBlock->pDataBlock);
         if (slotId >= numOfCols) {
-          taosArrayEnsureCap(pBlock->pDataBlock, slotId + 1);
+          code = taosArrayEnsureCap(pBlock->pDataBlock, slotId + 1);
+          QUERY_CHECK_CODE(code, lino, _end);
+
           for (int32_t k = numOfCols; k < slotId + 1; ++k) {
-            taosArrayPush(pBlock->pDataBlock, &colInfo);
+            void* tmp = taosArrayPush(pBlock->pDataBlock, &colInfo);
+            QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
           }
         }
       } else if (pFuncParam->type == FUNC_PARAM_TYPE_VALUE) {
@@ -363,14 +380,20 @@ static int32_t createDataBlockForEmptyInput(SOperatorInfo* pOperator, SSDataBloc
     }
   }
 
-  blockDataEnsureCapacity(pBlock, pBlock->info.rows);
+  code = blockDataEnsureCapacity(pBlock, pBlock->info.rows);
+  QUERY_CHECK_CODE(code, lino, _end);
+
   for (int32_t i = 0; i < blockDataGetNumOfCols(pBlock); ++i) {
     SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, i);
     colDataSetNULL(pColInfoData, 0);
   }
   *ppBlock = pBlock;
 
-  return TSDB_CODE_SUCCESS;
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+  }
+  return code;
 }
 
 void destroyDataBlockForEmptyInput(bool blockAllocated, SSDataBlock** ppBlock) {
@@ -571,7 +594,12 @@ void applyAggFunctionOnPartialTuples(SExecTaskInfo* taskInfo, SqlFunctionCtx* pC
 
       SScalarParam out = {.columnData = &idata};
       SScalarParam tw = {.numOfRows = 5, .columnData = pTimeWindowData};
-      pCtx[k].sfp.process(&tw, 1, &out);
+      int32_t      code = pCtx[k].sfp.process(&tw, 1, &out);
+      if (code != TSDB_CODE_SUCCESS) {
+        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+        taskInfo->code = code;
+        T_LONG_JMP(taskInfo->env, code);
+      }
       pEntryInfo->numOfRes = 1;
     } else {
       int32_t code = TSDB_CODE_SUCCESS;

source/libs/executor/src/cachescanoperator.c

@@ -13,8 +13,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "os.h"
 #include "function.h"
+#include "os.h"
 #include "tname.h"
 
 #include "tdatablock.h"
@@ -87,6 +87,7 @@ static void setColIdForCacheReadBlock(SSDataBlock* pBlock, SLastRowScanPhysiNode
 SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SReadHandle* readHandle,
                                            STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo) {
   int32_t             code = TSDB_CODE_SUCCESS;
+  int32_t             lino = 0;
   int32_t             numOfCols = 0;
   SNodeList*          pScanCols = pScanNode->scan.pScanCols;
   SCacheRowsScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SCacheRowsScanInfo));
@@ -105,9 +106,7 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe
   pInfo->pRes = createDataBlockFromDescNode(pDescNode);
 
   code = extractColMatchInfo(pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo);
-  if (code != TSDB_CODE_SUCCESS) {
+  QUERY_CHECK_CODE(code, lino, _error);
-    goto _error;
-  }
 
   // todo: the pk information should comes from the physical plan
   // pk info may not in pScanCols, so extract primary key from pInfo->matchInfo may failed
@@ -121,7 +120,7 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe
       pInfo->pkCol.pk = 1;
     }
   } else {
-    for(int32_t i = 0; i < taosArrayGetSize(pInfo->matchInfo.pList); ++i) {
+    for (int32_t i = 0; i < taosArrayGetSize(pInfo->matchInfo.pList); ++i) {
       SColMatchItem* pItem = taosArrayGet(pInfo->matchInfo.pList, i);
       if (pItem->isPk) {
         pInfo->numOfPks += 1;
@@ -133,24 +132,31 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe
   }
 
   SArray* pCidList = taosArrayInit(numOfCols, sizeof(int16_t));
+  QUERY_CHECK_NULL(pCidList, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY);
+
   pInfo->pFuncTypeList = taosArrayInit(taosArrayGetSize(pScanNode->pFuncTypes), sizeof(int32_t));
-  taosArrayAddAll(pInfo->pFuncTypeList, pScanNode->pFuncTypes);
+  QUERY_CHECK_NULL(pInfo->pFuncTypeList, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY);
+
+  void* tmp = taosArrayAddAll(pInfo->pFuncTypeList, pScanNode->pFuncTypes);
+  if (!tmp && taosArrayGetSize(pScanNode->pFuncTypes) > 0) {
+    QUERY_CHECK_NULL(tmp, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY);
+  }
 
   for (int i = 0; i < TARRAY_SIZE(pInfo->matchInfo.pList); ++i) {
     SColMatchItem* pColInfo = taosArrayGet(pInfo->matchInfo.pList, i);
-    taosArrayPush(pCidList, &pColInfo->colId);
+    void* tmp = taosArrayPush(pCidList, &pColInfo->colId);
+    QUERY_CHECK_NULL(tmp, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY);
     if (pInfo->pFuncTypeList != NULL && taosArrayGetSize(pInfo->pFuncTypeList) > i) {
       pColInfo->funcType = *(int32_t*)taosArrayGet(pInfo->pFuncTypeList, i);
     }
   }
   pInfo->pCidList = pCidList;
 
-  removeRedundantTsCol(pScanNode, &pInfo->matchInfo);
+  code = removeRedundantTsCol(pScanNode, &pInfo->matchInfo);
+  QUERY_CHECK_CODE(code, lino, _error);
 
   code = extractCacheScanSlotId(pInfo->matchInfo.pList, pTaskInfo, &pInfo->pSlotIds, &pInfo->pDstSlotIds);
-  if (code != TSDB_CODE_SUCCESS) {
+  QUERY_CHECK_CODE(code, lino, _error);
-    goto _error;
-  }
 
   int32_t totalTables = tableListGetSize(pTableListInfo);
   int32_t capacity = 0;
@@ -166,17 +172,16 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe
     uint64_t suid = tableListGetSuid(pTableListInfo);
     code = pInfo->readHandle.api.cacheFn.openReader(pInfo->readHandle.vnode, pInfo->retrieveType, pList, totalTables,
                                                     taosArrayGetSize(pInfo->matchInfo.pList), pCidList, pInfo->pSlotIds,
-                                                    suid, &pInfo->pLastrowReader, pTaskInfo->id.str, pScanNode->pFuncTypes,
+                                                    suid, &pInfo->pLastrowReader, pTaskInfo->id.str,
-                                                    &pInfo->pkCol, pInfo->numOfPks);
+                                                    pScanNode->pFuncTypes, &pInfo->pkCol, pInfo->numOfPks);
-    if (code != TSDB_CODE_SUCCESS) {
+    QUERY_CHECK_CODE(code, lino, _error);
-      goto _error;
-    }
 
     capacity = TMIN(totalTables, 4096);
 
     pInfo->pBufferedRes = createOneDataBlock(pInfo->pRes, false);
     setColIdForCacheReadBlock(pInfo->pBufferedRes, pScanNode);
-    blockDataEnsureCapacity(pInfo->pBufferedRes, capacity);
+    code = blockDataEnsureCapacity(pInfo->pBufferedRes, capacity);
+    QUERY_CHECK_CODE(code, lino, _error);
   } else {  // by tags
     pInfo->retrieveType = CACHESCAN_RETRIEVE_TYPE_SINGLE | SCAN_ROW_TYPE(pScanNode->ignoreNull);
     capacity = 1;  // only one row output
@@ -184,26 +189,31 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe
   }
 
   initResultSizeInfo(&pOperator->resultInfo, capacity);
-  blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
+  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
+  QUERY_CHECK_CODE(code, lino, _error);
 
   if (pScanNode->scan.pScanPseudoCols != NULL) {
     SExprSupp* p = &pInfo->pseudoExprSup;
     p->pExprInfo = createExprInfo(pScanNode->scan.pScanPseudoCols, NULL, &p->numOfExprs);
-    p->pCtx = createSqlFunctionCtx(p->pExprInfo, p->numOfExprs, &p->rowEntryInfoOffset, &pTaskInfo->storageAPI.functionStore);
+    p->pCtx =
+        createSqlFunctionCtx(p->pExprInfo, p->numOfExprs, &p->rowEntryInfoOffset, &pTaskInfo->storageAPI.functionStore);
   }
 
   setOperatorInfo(pOperator, "CachedRowScanOperator", QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN, false, OP_NOT_OPENED,
                   pInfo, pTaskInfo);
   pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock);
 
-  pOperator->fpSet =
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doScanCache, NULL, destroyCacheScanOperator, optrDefaultBufFn,
-      createOperatorFpSet(optrDummyOpenFn, doScanCache, NULL, destroyCacheScanOperator, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
+                                         NULL, optrDefaultGetNextExtFn, NULL);
 
   pOperator->cost.openCost = 0;
   return pOperator;
 
 _error:
   pTaskInfo->code = code;
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
   destroyCacheScanOperator(pInfo);
   taosMemoryFree(pOperator);
   return NULL;
@@ -268,7 +278,11 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) {
         } else {
           if (pSrc->pData) {
             char*   p = colDataGetData(pSrc, pInfo->indexOfBufferedRes);
-            colDataSetVal(pDst, 0, p, false);
+            int32_t code = colDataSetVal(pDst, 0, p, false);
+            if (code != TSDB_CODE_SUCCESS) {
+              qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+              T_LONG_JMP(pTaskInfo->env, code);
+            }
           }
         }
       }
@@ -320,7 +334,11 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) {
           continue;
         }
       } else {
-        pReaderFn->reuseReader(pInfo->pLastrowReader, pList, num);
+        code = pReaderFn->reuseReader(pInfo->pLastrowReader, pList, num);
+        if (code != TSDB_CODE_SUCCESS) {
+          qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+          T_LONG_JMP(pTaskInfo->env, code);
+        }
       }
 
       taosArrayClear(pInfo->pUidList);
@@ -352,10 +370,10 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) {
           }
         }
 
-        //pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader);
+        // pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader);
         return pInfo->pRes;
       } else {
-        //pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader);
+        // pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader);
       }
     }
 
@@ -429,12 +447,15 @@ int32_t extractCacheScanSlotId(const SArray* pColMatchInfo, SExecTaskInfo* pTask
 }
 
 int32_t removeRedundantTsCol(SLastRowScanPhysiNode* pScanNode, SColMatchInfo* pColMatchInfo) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
   if (!pScanNode->ignoreNull) {  // retrieve cached last value
     return TSDB_CODE_SUCCESS;
   }
 
   size_t  size = taosArrayGetSize(pColMatchInfo->pList);
   SArray* pMatchInfo = taosArrayInit(size, sizeof(SColMatchItem));
+  QUERY_CHECK_NULL(pMatchInfo, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
 
   for (int32_t i = 0; i < size; ++i) {
     SColMatchItem* pColInfo = taosArrayGet(pColMatchInfo->pList, i);
@@ -444,13 +465,20 @@ int32_t removeRedundantTsCol(SLastRowScanPhysiNode* pScanNode, SColMatchInfo* pC
 
     SSlotDescNode* pDesc = (SSlotDescNode*)nodesListGetNode(pList, slotId);
     if (pDesc->dataType.type != TSDB_DATA_TYPE_TIMESTAMP) {
-      taosArrayPush(pMatchInfo, pColInfo);
+      void* tmp = taosArrayPush(pMatchInfo, pColInfo);
-    } else if (FUNCTION_TYPE_CACHE_LAST_ROW == pColInfo->funcType){
+      QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
-      taosArrayPush(pMatchInfo, pColInfo);
+    } else if (FUNCTION_TYPE_CACHE_LAST_ROW == pColInfo->funcType) {
+      void* tmp = taosArrayPush(pMatchInfo, pColInfo);
+      QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
     }
   }
 
   taosArrayDestroy(pColMatchInfo->pList);
   pColMatchInfo->pList = pMatchInfo;
-  return TSDB_CODE_SUCCESS;
+
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  return code;
 }

source/libs/executor/src/countwindowoperator.c

@@ -74,12 +74,15 @@ static SCountWindowResult* getCountWinStateInfo(SCountWindowSupp* pCountSup) {
   return pBuffInfo;
 }
 
-static SCountWindowResult* setCountWindowOutputBuff(SExprSupp* pExprSup, SCountWindowSupp* pCountSup,
+static int32_t setCountWindowOutputBuff(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, SResultRow** pResult,
-                                                    SResultRow** pResult) {
+                                        SCountWindowResult** ppResBuff) {
+  int32_t             code = TSDB_CODE_SUCCESS;
+  int32_t             lino = 0;
   SCountWindowResult* pBuff = getCountWinStateInfo(pCountSup);
   (*pResult) = &pBuff->row;
-  setResultRowInitCtx(*pResult, pExprSup->pCtx, pExprSup->numOfExprs, pExprSup->rowEntryInfoOffset);
+  code = setResultRowInitCtx(*pResult, pExprSup->pCtx, pExprSup->numOfExprs, pExprSup->rowEntryInfoOffset);
-  return pBuff;
+  (*ppResBuff) = pBuff;
+  return code;
 }
 
 static int32_t updateCountWindowInfo(int32_t start, int32_t blockRows, int32_t countWinRows, int32_t* pCurrentRows) {
@@ -88,17 +91,23 @@ static int32_t updateCountWindowInfo(int32_t start, int32_t blockRows, int32_t c
   return rows;
 }
 
-int32_t doCountWindowAggImpl(SOperatorInfo* pOperator, SSDataBlock* pBlock) {
+void doCountWindowAggImpl(SOperatorInfo* pOperator, SSDataBlock* pBlock) {
+  int32_t                   code = TSDB_CODE_SUCCESS;
+  int32_t                   lino = 0;
   SExecTaskInfo*            pTaskInfo = pOperator->pTaskInfo;
   SExprSupp*                pExprSup = &pOperator->exprSupp;
   SCountWindowOperatorInfo* pInfo = pOperator->info;
   SSDataBlock*              pRes = pInfo->binfo.pRes;
   SColumnInfoData*          pColInfoData = taosArrayGet(pBlock->pDataBlock, pInfo->tsSlotId);
   TSKEY*                    tsCols = (TSKEY*)pColInfoData->pData;
-  int32_t                   code = TSDB_CODE_SUCCESS;
 
   for (int32_t i = 0; i < pBlock->info.rows;) {
-    SCountWindowResult* pBuffInfo = setCountWindowOutputBuff(pExprSup, &pInfo->countSup, &pInfo->pRow);
+    SCountWindowResult* pBuffInfo = NULL;
+    code = setCountWindowOutputBuff(pExprSup, &pInfo->countSup, &pInfo->pRow, &pBuffInfo);
+    if (code != TSDB_CODE_SUCCESS) {
+      qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+      T_LONG_JMP(pTaskInfo->env, code);
+    }
     int32_t prevRows = pBuffInfo->winRows;
     int32_t num = updateCountWindowInfo(i, pBlock->info.rows, pInfo->windowCount, &pBuffInfo->winRows);
     int32_t step = num;
@@ -131,15 +140,17 @@ int32_t doCountWindowAggImpl(SOperatorInfo* pOperator, SSDataBlock* pBlock) {
     }
     i += step;
   }
-
-  return code;
 }
 
 static void buildCountResult(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, SExecTaskInfo* pTaskInfo,
                              SFilterInfo* pFilterInfo, SSDataBlock* pBlock) {
   SResultRow* pResultRow = NULL;
+  int32_t        code = TSDB_CODE_SUCCESS;
+  int32_t        lino = 0;
   for (int32_t i = 0; i < taosArrayGetSize(pCountSup->pWinStates); i++) {
-    SCountWindowResult* pBuff = setCountWindowOutputBuff(pExprSup, pCountSup, &pResultRow);
+    SCountWindowResult* pBuff = NULL;
+    code = setCountWindowOutputBuff(pExprSup, pCountSup, &pResultRow, &pBuff);
+    QUERY_CHECK_CODE(code, lino, _end);
     if (pBuff->winRows == 0) {
       continue;
     }
@@ -150,7 +161,14 @@ static void buildCountResult(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, S
     clearWinStateBuff(pBuff);
     clearResultRowInitFlag(pExprSup->pCtx, pExprSup->numOfExprs);
   }
-  doFilter(pBlock, pFilterInfo, NULL);
+  code = doFilter(pBlock, pFilterInfo, NULL);
+  QUERY_CHECK_CODE(code, lino, _end);
+
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    T_LONG_JMP(pTaskInfo->env, code);
+  }
 }
 
 static SSDataBlock* countWindowAggregate(SOperatorInfo* pOperator) {
@@ -243,7 +261,8 @@ SOperatorInfo* createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo
   QUERY_CHECK_CODE(code, lino, _error);
 
   SSDataBlock* pResBlock = createDataBlockFromDescNode(pCountWindowNode->window.node.pOutputDataBlockDesc);
-  blockDataEnsureCapacity(pResBlock, pOperator->resultInfo.capacity);
+  code = blockDataEnsureCapacity(pResBlock, pOperator->resultInfo.capacity);
+  QUERY_CHECK_CODE(code, lino, _error);
 
   initBasicInfo(&pInfo->binfo, pResBlock);
   initResultRowInfo(&pInfo->binfo.resultRowInfo);

source/libs/executor/src/eventwindowoperator.c

@@ -204,8 +204,12 @@ static SSDataBlock* eventWindowAggregate(SOperatorInfo* pOperator) {
       }
     }
 
-    eventWindowAggImpl(pOperator, pInfo, pBlock);
+    code = eventWindowAggImpl(pOperator, pInfo, pBlock);
-    doFilter(pRes, pSup->pFilterInfo, NULL);
+    QUERY_CHECK_CODE(code, lino, _end);
+
+    code = doFilter(pRes, pSup->pFilterInfo, NULL);
+    QUERY_CHECK_CODE(code, lino, _end);
+
     if (pRes->info.rows >= pOperator->resultInfo.threshold) {
       return pRes;
     }
@@ -253,6 +257,8 @@ static void doEventWindowAggImpl(SEventWindowOperatorInfo* pInfo, SExprSupp* pSu
 }
 
 int32_t eventWindowAggImpl(SOperatorInfo* pOperator, SEventWindowOperatorInfo* pInfo, SSDataBlock* pBlock) {
+  int32_t          code = TSDB_CODE_SUCCESS;
+  int32_t          lino = 0;
   SExecTaskInfo*   pTaskInfo = pOperator->pTaskInfo;
   SExprSupp*       pSup = &pOperator->exprSupp;
   SSDataBlock*     pRes = pInfo->binfo.pRes;
@@ -274,22 +280,20 @@ int32_t eventWindowAggImpl(SOperatorInfo* pOperator, SEventWindowOperatorInfo* p
 
   SFilterColumnParam param1 = {.numOfCols = taosArrayGetSize(pBlock->pDataBlock), .pDataBlock = pBlock->pDataBlock};
 
-  int32_t code = filterSetDataFromSlotId(pInfo->pStartCondInfo, &param1);
+  code = filterSetDataFromSlotId(pInfo->pStartCondInfo, &param1);
-  if (code != TSDB_CODE_SUCCESS) {
+  QUERY_CHECK_CODE(code, lino, _return);
-    return code;
-  }
 
   int32_t status1 = 0;
-  filterExecute(pInfo->pStartCondInfo, pBlock, &ps, NULL, param1.numOfCols, &status1);
+  code = filterExecute(pInfo->pStartCondInfo, pBlock, &ps, NULL, param1.numOfCols, &status1);
+  QUERY_CHECK_CODE(code, lino, _return);
 
   SFilterColumnParam param2 = {.numOfCols = taosArrayGetSize(pBlock->pDataBlock), .pDataBlock = pBlock->pDataBlock};
   code = filterSetDataFromSlotId(pInfo->pEndCondInfo, &param2);
-  if (code != TSDB_CODE_SUCCESS) {
+  QUERY_CHECK_CODE(code, lino, _return);
-    goto _return;
-  }
 
   int32_t status2 = 0;
-  filterExecute(pInfo->pEndCondInfo, pBlock, &pe, NULL, param2.numOfCols, &status2);
+  code = filterExecute(pInfo->pEndCondInfo, pBlock, &pe, NULL, param2.numOfCols, &status2);
+  QUERY_CHECK_CODE(code, lino, _return);
 
   int32_t startIndex = pInfo->inWindow ? 0 : -1;
   while (rowIndex < pBlock->info.rows) {
@@ -307,7 +311,8 @@ int32_t eventWindowAggImpl(SOperatorInfo* pOperator, SEventWindowOperatorInfo* p
         // check buffer size
         if (pRes->info.rows + pInfo->pRow->numOfRows >= pRes->info.capacity) {
           int32_t newSize = pRes->info.rows + pInfo->pRow->numOfRows;
-          blockDataEnsureCapacity(pRes, newSize);
+          code = blockDataEnsureCapacity(pRes, newSize);
+          QUERY_CHECK_CODE(code, lino, _return);
         }
 
         copyResultrowToDataBlock(pSup->pExprInfo, pSup->numOfExprs, pInfo->pRow, pSup->pCtx, pRes,
@@ -344,6 +349,9 @@ int32_t eventWindowAggImpl(SOperatorInfo* pOperator, SEventWindowOperatorInfo* p
 
 _return:
 
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
   colDataDestroy(ps);
   taosMemoryFree(ps);
   colDataDestroy(pe);

source/libs/executor/src/exchangeoperator.c

@@ -48,7 +48,7 @@ typedef struct SSourceDataInfo {
 static void destroyExchangeOperatorInfo(void* param);
 static void freeBlock(void* pParam);
 static void freeSourceDataInfo(void* param);
-static void* setAllSourcesCompleted(SOperatorInfo* pOperator);
+static void setAllSourcesCompleted(SOperatorInfo* pOperator);
 
 static int32_t loadRemoteDataCallback(void* param, SDataBuf* pMsg, int32_t code);
 static int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTaskInfo, int32_t sourceIndex);
@@ -171,6 +171,7 @@ _error:
 }
 
 static SSDataBlock* doLoadRemoteDataImpl(SOperatorInfo* pOperator) {
+  int32_t        code = TSDB_CODE_SUCCESS;
   SExchangeInfo* pExchangeInfo = pOperator->info;
   SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
 
@@ -192,11 +193,22 @@ static SSDataBlock* doLoadRemoteDataImpl(SOperatorInfo* pOperator) {
   }
 
   if (p != NULL) {
-    taosArrayPush(pExchangeInfo->pRecycledBlocks, &p);
+    void* tmp = taosArrayPush(pExchangeInfo->pRecycledBlocks, &p);
+    if (!tmp) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+      pTaskInfo->code = code;
+      T_LONG_JMP(pTaskInfo->env, code);
+    }
     return p;
   } else {
     if (pExchangeInfo->seqLoadData) {
-      seqLoadRemoteData(pOperator);
+      code = seqLoadRemoteData(pOperator);
+      if (code != TSDB_CODE_SUCCESS) {
+        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+        pTaskInfo->code = code;
+        T_LONG_JMP(pTaskInfo->env, code);
+      }
     } else {
       concurrentlyLoadRemoteDataImpl(pOperator, pExchangeInfo, pTaskInfo);
     }
@@ -206,7 +218,13 @@ static SSDataBlock* doLoadRemoteDataImpl(SOperatorInfo* pOperator) {
     } else {
       p = taosArrayGetP(pExchangeInfo->pResultBlockList, 0);
       taosArrayRemove(pExchangeInfo->pResultBlockList, 0);
-      taosArrayPush(pExchangeInfo->pRecycledBlocks, &p);
+      void* tmp = taosArrayPush(pExchangeInfo->pRecycledBlocks, &p);
+      if (!tmp) {
+        code = TSDB_CODE_OUT_OF_MEMORY;
+        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+        pTaskInfo->code = code;
+        T_LONG_JMP(pTaskInfo->env, code);
+      }
       return p;
     }
   }
@@ -231,7 +249,11 @@ static SSDataBlock* loadRemoteData(SOperatorInfo* pOperator) {
       return NULL;
     }
 
-    doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL);
+    pTaskInfo->code = doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL);
+    if (pTaskInfo->code != TSDB_CODE_SUCCESS) {
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(pTaskInfo->code));
+      T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+    }
     if (blockDataGetNumOfRows(pBlock) == 0) {
       continue;
     }
@@ -293,21 +315,32 @@ static int32_t initExchangeOperator(SExchangePhysiNode* pExNode, SExchangeInfo*
 
   pInfo->pSources = taosArrayInit(numOfSources, sizeof(SDownstreamSourceNode));
   if (pInfo->pSources == NULL) {
+    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
     return TSDB_CODE_OUT_OF_MEMORY;
   }
 
   if (pExNode->node.dynamicOp) {
     pInfo->pHashSources = tSimpleHashInit(numOfSources * 2, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT));
     if (NULL == pInfo->pHashSources) {
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
       return TSDB_CODE_OUT_OF_MEMORY;
     }
   }
 
   for (int32_t i = 0; i < numOfSources; ++i) {
     SDownstreamSourceNode* pNode = (SDownstreamSourceNode*)nodesListGetNode((SNodeList*)pExNode->pSrcEndPoints, i);
-    taosArrayPush(pInfo->pSources, pNode);
+    void*                  tmp = taosArrayPush(pInfo->pSources, pNode);
+    if (!tmp) {
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
     SExchangeSrcIndex idx = {.srcIdx = i, .inUseIdx = -1};
+    int32_t           code =
         tSimpleHashPut(pInfo->pHashSources, &pNode->addr.nodeId, sizeof(pNode->addr.nodeId), &idx, sizeof(idx));
+    if (pInfo->pHashSources && code != TSDB_CODE_SUCCESS) {
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+      return code;
+    }
   }
 
   initLimitInfo(pExNode->node.pLimit, pExNode->node.pSlimit, &pInfo->limitInfo);
@@ -317,6 +350,8 @@ static int32_t initExchangeOperator(SExchangePhysiNode* pExNode, SExchangeInfo*
 }
 
 SOperatorInfo* createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode* pExNode, SExecTaskInfo* pTaskInfo) {
+  int32_t        code = TSDB_CODE_SUCCESS;
+  int32_t        lino = 0;
   SExchangeInfo* pInfo = taosMemoryCalloc(1, sizeof(SExchangeInfo));
   SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
   if (pInfo == NULL || pOperator == NULL) {
@@ -324,18 +359,19 @@ SOperatorInfo* createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode
   }
 
   pInfo->dynamicOp = pExNode->node.dynamicOp;
-  int32_t code = initExchangeOperator(pExNode, pInfo, GET_TASKID(pTaskInfo));
+  code = initExchangeOperator(pExNode, pInfo, GET_TASKID(pTaskInfo));
-  if (code != TSDB_CODE_SUCCESS) {
+  QUERY_CHECK_CODE(code, lino, _error);
-    goto _error;
+
-  }
+  code = tsem_init(&pInfo->ready, 0, 0);
+  QUERY_CHECK_CODE(code, lino, _error);
 
-  tsem_init(&pInfo->ready, 0, 0);
   pInfo->pDummyBlock = createDataBlockFromDescNode(pExNode->node.pOutputDataBlockDesc);
   pInfo->pResultBlockList = taosArrayInit(64, POINTER_BYTES);
   pInfo->pRecycledBlocks = taosArrayInit(64, POINTER_BYTES);
 
   SExchangeOpStopInfo stopInfo = {QUERY_NODE_PHYSICAL_PLAN_EXCHANGE, pInfo->self};
-  qAppendTaskStopInfo(pTaskInfo, &stopInfo);
+  code = qAppendTaskStopInfo(pTaskInfo, &stopInfo);
+  QUERY_CHECK_CODE(code, lino, _error);
 
   pInfo->seqLoadData = pExNode->seqRecvData;
   pInfo->pTransporter = pTransporter;
@@ -345,15 +381,17 @@ SOperatorInfo* createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode
   pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pDummyBlock->pDataBlock);
 
   code = filterInitFromNode((SNode*)pExNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
-  if (code != TSDB_CODE_SUCCESS) {
+  QUERY_CHECK_CODE(code, lino, _error);
-    goto _error;
-  }
 
   pOperator->fpSet = createOperatorFpSet(prepareLoadRemoteData, loadRemoteData, NULL, destroyExchangeOperatorInfo,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
   return pOperator;
 
 _error:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    pTaskInfo->code = code;
+  }
   if (pInfo != NULL) {
     doDestroyExchangeOperatorInfo(pInfo);
   }
@@ -365,7 +403,7 @@ _error:
 
 void destroyExchangeOperatorInfo(void* param) {
   SExchangeInfo* pExInfo = (SExchangeInfo*)param;
-  taosRemoveRef(exchangeObjRefPool, pExInfo->self);
+  (void)taosRemoveRef(exchangeObjRefPool, pExInfo->self);
 }
 
 void freeBlock(void* pParam) {
@@ -393,7 +431,7 @@ void doDestroyExchangeOperatorInfo(void* param) {
   blockDataDestroy(pExInfo->pDummyBlock);
   tSimpleHashCleanup(pExInfo->pHashSources);
 
-  tsem_destroy(&pExInfo->ready);
+  (void)tsem_destroy(&pExInfo->ready);
   taosMemoryFreeClear(pExInfo->pTaskId);
 
   taosMemoryFreeClear(param);
@@ -445,7 +483,7 @@ int32_t loadRemoteDataCallback(void* param, SDataBuf* pMsg, int32_t code) {
     qError("failed to invoke post when fetch rsp is ready, code:%s, %p", tstrerror(code), pExchangeInfo);
   }
 
-  taosReleaseRef(exchangeObjRefPool, pWrapper->exchangeId);
+  (void)taosReleaseRef(exchangeObjRefPool, pWrapper->exchangeId);
   return code;
 }
 
@@ -478,6 +516,8 @@ int32_t buildTableScanOperatorParam(SOperatorParam** ppRes, SArray* pUidList, in
 }
 
 int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTaskInfo, int32_t sourceIndex) {
+  int32_t          code = TSDB_CODE_SUCCESS;
+  int32_t          lino = 0;
   SSourceDataInfo* pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, sourceIndex);
   if (EX_SOURCE_DATA_NOT_READY != pDataInfo->status) {
     return TSDB_CODE_SUCCESS;
@@ -489,6 +529,7 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas
   size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources);
 
   SFetchRspHandleWrapper* pWrapper = taosMemoryCalloc(1, sizeof(SFetchRspHandleWrapper));
+  QUERY_CHECK_NULL(pWrapper, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
   pWrapper->exchangeId = pExchangeInfo->self;
   pWrapper->sourceIndex = sourceIndex;
 
@@ -497,7 +538,8 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas
     int32_t  code =
         (*pTaskInfo->localFetch.fp)(pTaskInfo->localFetch.handle, pSource->schedId, pTaskInfo->id.queryId,
                                     pSource->taskId, 0, pSource->execId, &pBuf.pData, pTaskInfo->localFetch.explainRes);
-    loadRemoteDataCallback(pWrapper, &pBuf, code);
+    code = loadRemoteDataCallback(pWrapper, &pBuf, code);
+    QUERY_CHECK_CODE(code, lino, _end);
     taosMemoryFree(pWrapper);
   } else {
     SResFetchReq req = {0};
@@ -566,11 +608,15 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas
     pMsgSendInfo->fp = loadRemoteDataCallback;
 
     int64_t transporterId = 0;
-    int32_t code =
+    code = asyncSendMsgToServer(pExchangeInfo->pTransporter, &pSource->addr.epSet, &transporterId, pMsgSendInfo);
-        asyncSendMsgToServer(pExchangeInfo->pTransporter, &pSource->addr.epSet, &transporterId, pMsgSendInfo);
+    QUERY_CHECK_CODE(code, lino, _end);
   }
 
-  return TSDB_CODE_SUCCESS;
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  return code;
 }
 
 void updateLoadRemoteInfo(SLoadRemoteDataInfo* pInfo, int64_t numOfRows, int32_t dataLen, int64_t startTs,
@@ -582,6 +628,8 @@ void updateLoadRemoteInfo(SLoadRemoteDataInfo* pInfo, int64_t numOfRows, int32_t
 }
 
 int32_t extractDataBlockFromFetchRsp(SSDataBlock* pRes, char* pData, SArray* pColList, char** pNextStart) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
   if (pColList == NULL) {  // data from other sources
     blockDataCleanup(pRes);
     *pNextStart = (char*)blockDecode(pRes, pData);
@@ -604,24 +652,32 @@ int32_t extractDataBlockFromFetchRsp(SSDataBlock* pRes, char* pData, SArray* pCo
     SSDataBlock* pBlock = createDataBlock();
     for (int32_t i = 0; i < numOfCols; ++i) {
       SColumnInfoData idata = createColumnInfoData(pSchema[i].type, pSchema[i].bytes, pSchema[i].colId);
-      blockDataAppendColInfo(pBlock, &idata);
+      code = blockDataAppendColInfo(pBlock, &idata);
+      QUERY_CHECK_CODE(code, lino, _end);
     }
 
-    (void) blockDecode(pBlock, pStart);
+    (void)blockDecode(pBlock, pStart);
-    blockDataEnsureCapacity(pRes, pBlock->info.rows);
+    code = blockDataEnsureCapacity(pRes, pBlock->info.rows);
+    QUERY_CHECK_CODE(code, lino, _end);
 
     // data from mnode
     pRes->info.dataLoad = 1;
     pRes->info.rows = pBlock->info.rows;
     pRes->info.scanFlag = MAIN_SCAN;
-    relocateColumnData(pRes, pColList, pBlock->pDataBlock, false);
+    code = relocateColumnData(pRes, pColList, pBlock->pDataBlock, false);
+    QUERY_CHECK_CODE(code, lino, _end);
+
     blockDataDestroy(pBlock);
   }
 
-  return TSDB_CODE_SUCCESS;
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  return code;
 }
 
-void* setAllSourcesCompleted(SOperatorInfo* pOperator) {
+void setAllSourcesCompleted(SOperatorInfo* pOperator) {
   SExchangeInfo* pExchangeInfo = pOperator->info;
   SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
 
@@ -632,7 +688,6 @@ void* setAllSourcesCompleted(SOperatorInfo* pOperator) {
          pLoadInfo->totalElapsed / 1000.0);
 
   setOperatorCompleted(pOperator);
-  return NULL;
 }
 
 int32_t getCompletedSources(const SArray* pArray) {
@@ -679,21 +734,24 @@ int32_t prepareConcurrentlyLoad(SOperatorInfo* pOperator) {
 }
 
 int32_t doExtractResultBlocks(SExchangeInfo* pExchangeInfo, SSourceDataInfo* pDataInfo) {
+  int32_t            code = TSDB_CODE_SUCCESS;
+  int32_t            lino = 0;
   SRetrieveTableRsp* pRetrieveRsp = pDataInfo->pRsp;
 
   char* pNextStart = pRetrieveRsp->data;
   char* pStart = pNextStart;
 
   int32_t index = 0;
-  int32_t code = 0;
 
   if (pRetrieveRsp->compressed) {  // decompress the data
     if (pDataInfo->decompBuf == NULL) {
       pDataInfo->decompBuf = taosMemoryMalloc(pRetrieveRsp->payloadLen);
+      QUERY_CHECK_NULL(pDataInfo->decompBuf, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
       pDataInfo->decompBufSize = pRetrieveRsp->payloadLen;
     } else {
       if (pDataInfo->decompBufSize < pRetrieveRsp->payloadLen) {
         char* p = taosMemoryRealloc(pDataInfo->decompBuf, pRetrieveRsp->payloadLen);
+        QUERY_CHECK_NULL(p, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
         if (p != NULL) {
           pDataInfo->decompBuf = p;
           pDataInfo->decompBufSize = pRetrieveRsp->payloadLen;
@@ -702,7 +760,6 @@ int32_t doExtractResultBlocks(SExchangeInfo* pExchangeInfo, SSourceDataInfo* pDa
     }
   }
 
-
   while (index++ < pRetrieveRsp->numOfBlocks) {
     SSDataBlock* pb = NULL;
     pStart = pNextStart;
@@ -712,12 +769,13 @@ int32_t doExtractResultBlocks(SExchangeInfo* pExchangeInfo, SSourceDataInfo* pDa
       blockDataCleanup(pb);
     } else {
       pb = createOneDataBlock(pExchangeInfo->pDummyBlock, false);
+      QUERY_CHECK_NULL(pb, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
     }
 
-    int32_t compLen = *(int32_t*) pStart;
+    int32_t compLen = *(int32_t*)pStart;
     pStart += sizeof(int32_t);
 
-    int32_t rawLen = *(int32_t*) pStart;
+    int32_t rawLen = *(int32_t*)pStart;
     pStart += sizeof(int32_t);
     ASSERT(compLen <= rawLen && compLen != 0);
 
@@ -734,9 +792,14 @@ int32_t doExtractResultBlocks(SExchangeInfo* pExchangeInfo, SSourceDataInfo* pDa
       return code;
     }
 
-    taosArrayPush(pExchangeInfo->pResultBlockList, &pb);
+    void* tmp = taosArrayPush(pExchangeInfo->pResultBlockList, &pb);
+    QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
   }
 
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
   return code;
 }
 
@@ -757,7 +820,13 @@ int32_t seqLoadRemoteData(SOperatorInfo* pOperator) {
     SSourceDataInfo* pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, pExchangeInfo->current);
     pDataInfo->status = EX_SOURCE_DATA_NOT_READY;
 
-    doSendFetchDataRequest(pExchangeInfo, pTaskInfo, pExchangeInfo->current);
+    code = doSendFetchDataRequest(pExchangeInfo, pTaskInfo, pExchangeInfo->current);
+    if (code != TSDB_CODE_SUCCESS) {
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+      pTaskInfo->code = code;
+      T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+    }
+
     code = exchangeWait(pOperator, pExchangeInfo);
     if (code != TSDB_CODE_SUCCESS || isTaskKilled(pTaskInfo)) {
       T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
@@ -838,7 +907,11 @@ int32_t addSingleExchangeSource(SOperatorInfo* pOperator, SExchangeOperatorBasic
     dataInfo.srcOpType = pBasicParam->srcOpType;
     dataInfo.tableSeq = pBasicParam->tableSeq;
 
-    taosArrayPush(pExchangeInfo->pSourceDataInfo, &dataInfo);
+    void* tmp = taosArrayPush(pExchangeInfo->pSourceDataInfo, &dataInfo);
+    if (!tmp) {
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
     pIdx->inUseIdx = taosArrayGetSize(pExchangeInfo->pSourceDataInfo) - 1;
   } else {
     SSourceDataInfo* pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, pIdx->inUseIdx);
@@ -984,7 +1057,7 @@ static int32_t exchangeWait(SOperatorInfo* pOperator, SExchangeInfo* pExchangeIn
       return pTask->code;
     }
   }
-  tsem_wait(&pExchangeInfo->ready);
+  (void)tsem_wait(&pExchangeInfo->ready);
   if (pTask->pWorkerCb) {
     code = pTask->pWorkerCb->afterRecoverFromBlocking(pTask->pWorkerCb->pPool);
     if (code != TSDB_CODE_SUCCESS) {

source/libs/executor/src/executil.c

@@ -143,7 +143,7 @@ void initGroupedResultInfo(SGroupResInfo* pGroupResInfo, SSHashObj* pHashmap, in
 
   // todo move away and record this during create window
   while ((pData = tSimpleHashIterate(pHashmap, pData, &iter)) != NULL) {
-    /*void* key = */ tSimpleHashGetKey(pData, &keyLen);
+    /*void* key = */ (void)tSimpleHashGetKey(pData, &keyLen);
     bufLen += keyLen + sizeof(SResultRowPosition);
   }
 
@@ -222,7 +222,13 @@ SArray* createSortInfo(SNodeList* pNodeList) {
 
     SColumnNode* pColNode = (SColumnNode*)pSortKey->pExpr;
     bi.slotId = pColNode->slotId;
-    taosArrayPush(pList, &bi);
+    void* tmp = taosArrayPush(pList, &bi);
+    if (!tmp) {
+      taosArrayDestroy(pList);
+      pList = NULL;
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      break;
+    }
   }
 
   return pList;
@@ -245,7 +251,14 @@ SSDataBlock* createDataBlockFromDescNode(SDataBlockDescNode* pNode) {
     idata.info.scale = pDescNode->dataType.scale;
     idata.info.precision = pDescNode->dataType.precision;
 
-    blockDataAppendColInfo(pBlock, &idata);
+    int32_t code = blockDataAppendColInfo(pBlock, &idata);
+    if (code != TSDB_CODE_SUCCESS) {
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+      blockDataDestroy(pBlock);
+      pBlock = NULL;
+      terrno = code;
+      break;
+    }
   }
 
   return pBlock;
@@ -297,8 +310,7 @@ EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) {
       isTagCol = true;
   } else if (nodeType(*pNode) == QUERY_NODE_FUNCTION) {
     SFunctionNode* pFunc = (SFunctionNode*)*pNode;
-    if (pFunc->funcType == FUNCTION_TYPE_TBNAME)
+    if (pFunc->funcType == FUNCTION_TYPE_TBNAME) isTbname = true;
-      isTbname = true;
   }
   if (isTagCol) {
     SColumnNode* pSColumnNode = *(SColumnNode**)pNode;
@@ -325,7 +337,10 @@ EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) {
       memcpy(varDataVal(res->datum.p), tagVal.pData, tagVal.nData);
       varDataSetLen(res->datum.p, tagVal.nData);
     } else {
-      nodesSetValueNodeValue(res, &(tagVal.i64));
+      int32_t code = nodesSetValueNodeValue(res, &(tagVal.i64));
+      if (code != TSDB_CODE_SUCCESS) {
+        return DEAL_RES_ERROR;
+      }
     }
     nodesDestroyNode(*pNode);
     *pNode = (SNode*)res;
@@ -411,7 +426,11 @@ static EDealRes getColumn(SNode** pNode, void* pContext) {
   tagFilterAssist* pData = (tagFilterAssist*)pContext;
   void*            data = taosHashGet(pData->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId));
   if (!data) {
+    int32_t tempRes =
         taosHashPut(pData->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode)));
+    if (tempRes != TSDB_CODE_SUCCESS && tempRes != TSDB_CODE_DUP_KEY) {
+      return DEAL_RES_ERROR;
+    }
     pSColumnNode->slotId = pData->index++;
     SColumnInfo cInfo = {.colId = pSColumnNode->colId,
                          .type = pSColumnNode->node.resType.type,
@@ -420,7 +439,10 @@ static EDealRes getColumn(SNode** pNode, void* pContext) {
 #if TAG_FILTER_DEBUG
     qDebug("tagfilter build column info, slotId:%d, colId:%d, type:%d", pSColumnNode->slotId, cInfo.colId, cInfo.type);
 #endif
-    taosArrayPush(pData->cInfoList, &cInfo);
+    void* tmp = taosArrayPush(pData->cInfoList, &cInfo);
+    if (!tmp) {
+      return DEAL_RES_ERROR;
+    }
   } else {
     SColumnNode* col = *(SColumnNode**)data;
     pSColumnNode->slotId = col->slotId;
@@ -468,28 +490,38 @@ void freeItem(void* p) {
   }
 }
 
-static void genTagFilterDigest(const SNode* pTagCond, T_MD5_CTX* pContext) {
+static int32_t genTagFilterDigest(const SNode* pTagCond, T_MD5_CTX* pContext) {
   if (pTagCond == NULL) {
-    return;
+    return TSDB_CODE_SUCCESS;
   }
 
   char*   payload = NULL;
   int32_t len = 0;
-  nodesNodeToMsg(pTagCond, &payload, &len);
+  int32_t code = nodesNodeToMsg(pTagCond, &payload, &len);
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+    return code;
+  }
 
   tMD5Init(pContext);
   tMD5Update(pContext, (uint8_t*)payload, (uint32_t)len);
   tMD5Final(pContext);
 
   taosMemoryFree(payload);
+  return TSDB_CODE_SUCCESS;
 }
 
-static void genTbGroupDigest(const SNode* pGroup, uint8_t* filterDigest, T_MD5_CTX* pContext) {
+static int32_t genTbGroupDigest(const SNode* pGroup, uint8_t* filterDigest, T_MD5_CTX* pContext) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
   char*   payload = NULL;
   int32_t len = 0;
-  nodesNodeToMsg(pGroup, &payload, &len);
+  code = nodesNodeToMsg(pGroup, &payload, &len);
+  QUERY_CHECK_CODE(code, lino, _end);
+
   if (filterDigest[0]) {
     payload = taosMemoryRealloc(payload, len + tListLen(pContext->digest));
+    QUERY_CHECK_NULL(payload, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
     memcpy(payload + len, filterDigest + 1, tListLen(pContext->digest));
     len += tListLen(pContext->digest);
   }
@@ -498,12 +530,18 @@ static void genTbGroupDigest(const SNode* pGroup, uint8_t* filterDigest, T_MD5_C
   tMD5Update(pContext, (uint8_t*)payload, (uint32_t)len);
   tMD5Final(pContext);
 
+_end:
   taosMemoryFree(payload);
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  return code;
 }
 
 int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInfo* pTableListInfo, uint8_t* digest,
                                    SStorageAPI* pAPI, bool initRemainGroups) {
   int32_t      code = TSDB_CODE_SUCCESS;
+  int32_t      lino = 0;
   SArray*      pBlockList = NULL;
   SSDataBlock* pResBlock = NULL;
   void*        keyBuf = NULL;
@@ -540,11 +578,15 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf
   if (tsTagFilterCache) {
     SNodeListNode* listNode = (SNodeListNode*)nodesMakeNode(QUERY_NODE_NODE_LIST);
     listNode->pNodeList = group;
-    genTbGroupDigest((SNode*)listNode, digest, &context);
+    code = genTbGroupDigest((SNode*)listNode, digest, &context);
+    QUERY_CHECK_CODE(code, lino, end);
+
     nodesFree(listNode);
 
-    pAPI->metaFn.metaGetCachedTbGroup(pVnode, pTableListInfo->idInfo.suid, context.digest, tListLen(context.digest),
+    code = pAPI->metaFn.metaGetCachedTbGroup(pVnode, pTableListInfo->idInfo.suid, context.digest,
-                                      &tableList);
+                                             tListLen(context.digest), &tableList);
+    QUERY_CHECK_CODE(code, lino, end);
+
     if (tableList) {
       taosArrayDestroy(pTableListInfo->pTableList);
       pTableListInfo->pTableList = tableList;
@@ -555,10 +597,13 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf
   }
 
   pUidTagList = taosArrayInit(8, sizeof(STUidTagInfo));
+  QUERY_CHECK_NULL(pUidTagList, code, lino, end, TSDB_CODE_OUT_OF_MEMORY);
+
   for (int32_t i = 0; i < rows; ++i) {
     STableKeyInfo* pkeyInfo = taosArrayGet(pTableListInfo->pTableList, i);
     STUidTagInfo   info = {.uid = pkeyInfo->uid};
-    taosArrayPush(pUidTagList, &info);
+    void*          tmp = taosArrayPush(pUidTagList, &info);
+    QUERY_CHECK_NULL(tmp, code, lino, end, TSDB_CODE_OUT_OF_MEMORY);
   }
 
   code = pAPI->metaFn.getTableTags(pVnode, pTableListInfo->idInfo.suid, pUidTagList);
@@ -577,9 +622,14 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf
   //  qDebug("generate tag block rows:%d, cost:%ld us", rows, st1-st);
 
   pBlockList = taosArrayInit(2, POINTER_BYTES);
-  taosArrayPush(pBlockList, &pResBlock);
+  QUERY_CHECK_NULL(pBlockList, code, lino, end, TSDB_CODE_OUT_OF_MEMORY);
+
+  void* tmp = taosArrayPush(pBlockList, &pResBlock);
+  QUERY_CHECK_NULL(tmp, code, lino, end, TSDB_CODE_OUT_OF_MEMORY);
 
   groupData = taosArrayInit(2, POINTER_BYTES);
+  QUERY_CHECK_NULL(groupData, code, lino, end, TSDB_CODE_OUT_OF_MEMORY);
+
   FOREACH(pNode, group) {
     SScalarParam output = {0};
 
@@ -617,7 +667,8 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf
       goto end;
     }
 
-    taosArrayPush(groupData, &output.columnData);
+    void* tmp = taosArrayPush(groupData, &output.columnData);
+    QUERY_CHECK_NULL(tmp, code, lino, end, TSDB_CODE_OUT_OF_MEMORY);
   }
 
   int32_t keyLen = 0;
@@ -688,15 +739,21 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf
     info->groupId = calcGroupId(keyBuf, len);
     if (initRemainGroups) {
       // groupId ~ table uid
-      taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId), &(info->uid),
+      code = taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId), &(info->uid),
                          sizeof(info->uid));
+      if (code == TSDB_CODE_DUP_KEY) {
+        code = TSDB_CODE_SUCCESS;
+      }
+      QUERY_CHECK_CODE(code, lino, end);
     }
   }
 
   if (tsTagFilterCache) {
     tableList = taosArrayDup(pTableListInfo->pTableList, NULL);
-    pAPI->metaFn.metaPutTbGroupToCache(pVnode, pTableListInfo->idInfo.suid, context.digest, tListLen(context.digest),
+    code = pAPI->metaFn.metaPutTbGroupToCache(pVnode, pTableListInfo->idInfo.suid, context.digest,
-                                       tableList, taosArrayGetSize(tableList) * sizeof(STableKeyInfo));
+                                              tListLen(context.digest), tableList,
+                                              taosArrayGetSize(tableList) * sizeof(STableKeyInfo));
+    QUERY_CHECK_CODE(code, lino, end);
   }
 
   //  int64_t st2 = taosGetTimestampUs();
@@ -710,6 +767,9 @@ end:
   taosArrayDestroy(pBlockList);
   taosArrayDestroyEx(pUidTagList, freeItem);
   taosArrayDestroyP(groupData, releaseColInfoData);
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
   return code;
 }
 
@@ -726,10 +786,14 @@ static int32_t nameComparFn(const void* p1, const void* p2) {
 }
 
 static SArray* getTableNameList(const SNodeListNode* pList) {
+  int32_t    code = TSDB_CODE_SUCCESS;
+  int32_t    lino = 0;
   int32_t    len = LIST_LENGTH(pList->pNodeList);
   SListCell* cell = pList->pNodeList->pHead;
 
   SArray* pTbList = taosArrayInit(len, POINTER_BYTES);
+  QUERY_CHECK_NULL(pTbList, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
   for (int i = 0; i < pList->pNodeList->length; i++) {
     SValueNode* valueNode = (SValueNode*)cell->pNode;
     if (!IS_VAR_DATA_TYPE(valueNode->node.resType.type)) {
@@ -739,7 +803,8 @@ static SArray* getTableNameList(const SNodeListNode* pList) {
     }
 
     char* name = varDataVal(valueNode->datum.p);
-    taosArrayPush(pTbList, &name);
+    void* tmp = taosArrayPush(pTbList, &name);
+    QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
     cell = cell->pNext;
   }
 
@@ -750,7 +815,8 @@ static SArray* getTableNameList(const SNodeListNode* pList) {
 
   // remove the duplicates
   SArray* pNewList = taosArrayInit(taosArrayGetSize(pTbList), sizeof(void*));
-  taosArrayPush(pNewList, taosArrayGet(pTbList, 0));
+  void*   tmp = taosArrayPush(pNewList, taosArrayGet(pTbList, 0));
+  QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
 
   for (int32_t i = 1; i < numOfTables; ++i) {
     char** name = taosArrayGetLast(pNewList);
@@ -759,10 +825,16 @@ static SArray* getTableNameList(const SNodeListNode* pList) {
       continue;
     }
 
-    taosArrayPush(pNewList, nameInOldList);
+    tmp = taosArrayPush(pNewList, nameInOldList);
+    QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
   }
 
+_end:
   taosArrayDestroy(pTbList);
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    return NULL;
+  }
   return pNewList;
 }
 
@@ -868,9 +940,18 @@ static int32_t optimizeTbnameInCondImpl(void* pVnode, SArray* pExistedUidList, S
     size_t numOfExisted = taosArrayGetSize(pExistedUidList);  // len > 0 means there already have uids
     if (numOfExisted > 0) {
       uHash = taosHashInit(numOfExisted / 0.7, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
+      if (!uHash) {
+        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
+        return TSDB_CODE_OUT_OF_MEMORY;
+      }
+
       for (int i = 0; i < numOfExisted; i++) {
         STUidTagInfo* pTInfo = taosArrayGet(pExistedUidList, i);
-        taosHashPut(uHash, &pTInfo->uid, sizeof(uint64_t), &i, sizeof(i));
+        int32_t       tempRes = taosHashPut(uHash, &pTInfo->uid, sizeof(uint64_t), &i, sizeof(i));
+        if (tempRes != TSDB_CODE_SUCCESS && tempRes != TSDB_CODE_DUP_KEY) {
+          qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(tempRes));
+          return tempRes;
+        }
       }
     }
 
@@ -883,7 +964,10 @@ static int32_t optimizeTbnameInCondImpl(void* pVnode, SArray* pExistedUidList, S
         if (pStoreAPI->metaFn.getTableTypeByName(pVnode, name, &tbType) == 0 && tbType == TSDB_CHILD_TABLE) {
           if (NULL == uHash || taosHashGet(uHash, &uid, sizeof(uid)) == NULL) {
             STUidTagInfo s = {.uid = uid, .name = name, .pTagVal = NULL};
-            taosArrayPush(pExistedUidList, &s);
+            void*        tmp = taosArrayPush(pExistedUidList, &s);
+            if (!tmp) {
+              return TSDB_CODE_OUT_OF_MEMORY;
+            }
           }
         } else {
           taosArrayDestroy(pTbList);
@@ -906,6 +990,8 @@ static int32_t optimizeTbnameInCondImpl(void* pVnode, SArray* pExistedUidList, S
 
 SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, SArray* pUidTagList, void* pVnode,
                                         SStorageAPI* pStorageAPI) {
+  int32_t      code = TSDB_CODE_SUCCESS;
+  int32_t      lino = 0;
   SSDataBlock* pResBlock = createDataBlock();
   if (pResBlock == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -915,10 +1001,11 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S
   for (int32_t i = 0; i < taosArrayGetSize(pColList); ++i) {
     SColumnInfoData colInfo = {0};
     colInfo.info = *(SColumnInfo*)taosArrayGet(pColList, i);
-    blockDataAppendColInfo(pResBlock, &colInfo);
+    code = blockDataAppendColInfo(pResBlock, &colInfo);
+    QUERY_CHECK_CODE(code, lino, _end);
   }
 
-  int32_t code = blockDataEnsureCapacity(pResBlock, numOfTables);
+  code = blockDataEnsureCapacity(pResBlock, numOfTables);
   if (code != TSDB_CODE_SUCCESS) {
     terrno = code;
     taosMemoryFree(pResBlock);
@@ -940,10 +1027,12 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S
         if (p1->name != NULL) {
           STR_TO_VARSTR(str, p1->name);
         } else {  // name is not retrieved during filter
-          pStorageAPI->metaFn.getTableNameByUid(pVnode, p1->uid, str);
+          code = pStorageAPI->metaFn.getTableNameByUid(pVnode, p1->uid, str);
+          QUERY_CHECK_CODE(code, lino, _end);
         }
 
-        colDataSetVal(pColInfo, i, str, false);
+        code = colDataSetVal(pColInfo, i, str, false);
+        QUERY_CHECK_CODE(code, lino, _end);
 #if TAG_FILTER_DEBUG
         qDebug("tagfilter uid:%ld, tbname:%s", *uid, str + 2);
 #endif
@@ -958,18 +1047,22 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S
           if (p == NULL || (pColInfo->info.type == TSDB_DATA_TYPE_JSON && ((STag*)p)->nTag == 0)) {
             colDataSetNULL(pColInfo, i);
           } else if (pColInfo->info.type == TSDB_DATA_TYPE_JSON) {
-            colDataSetVal(pColInfo, i, p, false);
+            code = colDataSetVal(pColInfo, i, p, false);
+            QUERY_CHECK_CODE(code, lino, _end);
           } else if (IS_VAR_DATA_TYPE(pColInfo->info.type)) {
             char* tmp = taosMemoryMalloc(tagVal.nData + VARSTR_HEADER_SIZE + 1);
+            QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
             varDataSetLen(tmp, tagVal.nData);
             memcpy(tmp + VARSTR_HEADER_SIZE, tagVal.pData, tagVal.nData);
-            colDataSetVal(pColInfo, i, tmp, false);
+            code = colDataSetVal(pColInfo, i, tmp, false);
+            QUERY_CHECK_CODE(code, lino, _end);
 #if TAG_FILTER_DEBUG
             qDebug("tagfilter varch:%s", tmp + 2);
 #endif
             taosMemoryFree(tmp);
           } else {
-            colDataSetVal(pColInfo, i, (const char*)&tagVal.i64, false);
+            code = colDataSetVal(pColInfo, i, (const char*)&tagVal.i64, false);
+            QUERY_CHECK_CODE(code, lino, _end);
 #if TAG_FILTER_DEBUG
             if (pColInfo->info.type == TSDB_DATA_TYPE_INT) {
               qDebug("tagfilter int:%d", *(int*)(&tagVal.i64));
@@ -983,6 +1076,13 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S
     }
   }
 
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    taosMemoryFree(pResBlock);
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    terrno = code;
+    return NULL;
+  }
   return pResBlock;
 }
 
@@ -1004,7 +1104,10 @@ static int32_t doSetQualifiedUid(STableListInfo* pListInfo, SArray* pUidList, co
       }
 
       if (addUid) {
-        taosArrayPush(pUidList, &uid);
+        void* tmp = taosArrayPush(pUidList, &uid);
+        if (tmp == NULL) {
+          return TSDB_CODE_OUT_OF_MEMORY;
+        }
       }
     }
   }
@@ -1012,17 +1115,23 @@ static int32_t doSetQualifiedUid(STableListInfo* pListInfo, SArray* pUidList, co
   return TSDB_CODE_SUCCESS;
 }
 
-static void copyExistedUids(SArray* pUidTagList, const SArray* pUidList) {
+static int32_t copyExistedUids(SArray* pUidTagList, const SArray* pUidList) {
+  int32_t code = TSDB_CODE_SUCCESS;
   int32_t numOfExisted = taosArrayGetSize(pUidList);
   if (numOfExisted == 0) {
-    return;
+    return code;
   }
 
   for (int32_t i = 0; i < numOfExisted; ++i) {
     uint64_t*    uid = taosArrayGet(pUidList, i);
     STUidTagInfo info = {.uid = *uid};
-    taosArrayPush(pUidTagList, &info);
+    void*        tmp = taosArrayPush(pUidTagList, &info);
+    if (!tmp) {
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
+      return code;
     }
+  }
+  return code;
 }
 
 static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SNode* pTagCond, void* pVnode,
@@ -1034,6 +1143,7 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN
 
   terrno = TSDB_CODE_SUCCESS;
 
+  int32_t      lino = 0;
   int32_t      code = TSDB_CODE_SUCCESS;
   SArray*      pBlockList = NULL;
   SSDataBlock* pResBlock = NULL;
@@ -1044,13 +1154,15 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN
   ctx.colHash = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT), false, HASH_NO_LOCK);
   if (ctx.colHash == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
-    goto end;
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    QUERY_CHECK_CODE(code, lino, end);
   }
 
   ctx.cInfoList = taosArrayInit(4, sizeof(SColumnInfo));
   if (ctx.cInfoList == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
-    goto end;
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    QUERY_CHECK_CODE(code, lino, end);
   }
 
   nodesRewriteExprPostOrder(&pTagCond, getColumn, (void*)&ctx);
@@ -1059,7 +1171,10 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN
 
   //  int64_t stt = taosGetTimestampUs();
   pUidTagList = taosArrayInit(10, sizeof(STUidTagInfo));
-  copyExistedUids(pUidTagList, pUidList);
+  QUERY_CHECK_NULL(pUidTagList, code, lino, end, TSDB_CODE_OUT_OF_MEMORY);
+
+  code = copyExistedUids(pUidTagList, pUidList);
+  QUERY_CHECK_CODE(code, lino, end);
 
   FilterCondType condType = checkTagCond(pTagCond);
 
@@ -1068,10 +1183,13 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN
     taosArrayClear(pUidList);
 
     int32_t numOfRows = taosArrayGetSize(pUidTagList);
-    taosArrayEnsureCap(pUidList, numOfRows);
+    code = taosArrayEnsureCap(pUidList, numOfRows);
+    QUERY_CHECK_CODE(code, lino, end);
+
     for (int32_t i = 0; i < numOfRows; ++i) {
       STUidTagInfo* pInfo = taosArrayGet(pUidTagList, i);
-      taosArrayPush(pUidList, &pInfo->uid);
+      void*         tmp = taosArrayPush(pUidList, &pInfo->uid);
+      QUERY_CHECK_NULL(tmp, code, lino, end, TSDB_CODE_OUT_OF_MEMORY);
     }
     terrno = 0;
   } else {
@@ -1083,7 +1201,7 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN
     if (code != TSDB_CODE_SUCCESS) {
       qError("failed to get table tags from meta, reason:%s, suid:%" PRIu64, tstrerror(code), pListInfo->idInfo.suid);
       terrno = code;
-      goto end;
+      QUERY_CHECK_CODE(code, lino, end);
     }
   }
 
@@ -1095,35 +1213,41 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN
   pResBlock = createTagValBlockForFilter(ctx.cInfoList, numOfTables, pUidTagList, pVnode, pAPI);
   if (pResBlock == NULL) {
     code = terrno;
-    goto end;
+    QUERY_CHECK_CODE(code, lino, end);
   }
 
   //  int64_t st1 = taosGetTimestampUs();
   //  qDebug("generate tag block rows:%d, cost:%ld us", rows, st1-st);
   pBlockList = taosArrayInit(2, POINTER_BYTES);
-  taosArrayPush(pBlockList, &pResBlock);
+  QUERY_CHECK_NULL(pBlockList, code, lino, end, TSDB_CODE_OUT_OF_MEMORY);
+
+  void* tmp = taosArrayPush(pBlockList, &pResBlock);
+  QUERY_CHECK_NULL(tmp, code, lino, end, TSDB_CODE_OUT_OF_MEMORY);
 
   code = createResultData(&type, numOfTables, &output);
   if (code != TSDB_CODE_SUCCESS) {
     terrno = code;
-    goto end;
+    QUERY_CHECK_CODE(code, lino, end);
   }
 
   code = scalarCalculate(pTagCond, pBlockList, &output);
   if (code != TSDB_CODE_SUCCESS) {
     qError("failed to calculate scalar, reason:%s", tstrerror(code));
     terrno = code;
-    goto end;
+    QUERY_CHECK_CODE(code, lino, end);
   }
 
   code = doSetQualifiedUid(pListInfo, pUidList, pUidTagList, (bool*)output.columnData->pData, addUid);
   if (code != TSDB_CODE_SUCCESS) {
     terrno = code;
-    goto end;
+    QUERY_CHECK_CODE(code, lino, end);
   }
   *listAdded = true;
 
 end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
   taosHashCleanup(ctx.colHash);
   taosArrayDestroy(ctx.cInfoList);
   blockDataDestroy(pResBlock);
@@ -1138,6 +1262,7 @@ end:
 int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, SNode* pTagIndexCond,
                      STableListInfo* pListInfo, uint8_t* digest, const char* idstr, SStorageAPI* pStorageAPI) {
   int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
   size_t  numOfTables = 0;
   bool    listAdded = false;
 
@@ -1145,27 +1270,30 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S
   pListInfo->idInfo.tableType = pScanNode->tableType;
 
   SArray* pUidList = taosArrayInit(8, sizeof(uint64_t));
+  QUERY_CHECK_NULL(pUidList, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY);
 
   SIdxFltStatus status = SFLT_NOT_INDEX;
   if (pScanNode->tableType != TSDB_SUPER_TABLE) {
     pListInfo->idInfo.uid = pScanNode->uid;
     if (pStorageAPI->metaFn.isTableExisted(pVnode, pScanNode->uid)) {
-      taosArrayPush(pUidList, &pScanNode->uid);
+      void* tmp = taosArrayPush(pUidList, &pScanNode->uid);
+      QUERY_CHECK_NULL(tmp, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY);
     }
     code = doFilterByTagCond(pListInfo, pUidList, pTagCond, pVnode, status, pStorageAPI, false, &listAdded);
-    if (code != TSDB_CODE_SUCCESS) {
+    QUERY_CHECK_CODE(code, lino, _end);
-      goto _end;
-    }
   } else {
     T_MD5_CTX context = {0};
 
     if (tsTagFilterCache) {
       // try to retrieve the result from meta cache
-      genTagFilterDigest(pTagCond, &context);
+      code = genTagFilterDigest(pTagCond, &context);
+      QUERY_CHECK_CODE(code, lino, _error);
 
       bool acquired = false;
-      pStorageAPI->metaFn.getCachedTableList(pVnode, pScanNode->suid, context.digest, tListLen(context.digest),
+      code = pStorageAPI->metaFn.getCachedTableList(pVnode, pScanNode->suid, context.digest, tListLen(context.digest),
                                                     pUidList, &acquired);
+      QUERY_CHECK_CODE(code, lino, _error);
+
       if (acquired) {
         digest[0] = 1;
         memcpy(digest + 1, context.digest, tListLen(context.digest));
@@ -1175,7 +1303,8 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S
     }
 
     if (!pTagCond) {  // no tag filter condition exists, let's fetch all tables of this super table
-      pStorageAPI->metaFn.getChildTableList(pVnode, pScanNode->suid, pUidList);
+      code = pStorageAPI->metaFn.getChildTableList(pVnode, pScanNode->suid, pUidList);
+      QUERY_CHECK_CODE(code, lino, _error);
     } else {
       // failed to find the result in the cache, let try to calculate the results
       if (pTagIndexCond) {
@@ -1197,9 +1326,7 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S
     }
 
     code = doFilterByTagCond(pListInfo, pUidList, pTagCond, pVnode, status, pStorageAPI, tsTagFilterCache, &listAdded);
-    if (code != TSDB_CODE_SUCCESS) {
+    QUERY_CHECK_CODE(code, lino, _end);
-      goto _end;
-    }
 
     // let's add the filter results into meta-cache
     numOfTables = taosArrayGetSize(pUidList);
@@ -1207,14 +1334,17 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S
     if (tsTagFilterCache) {
       size_t size = numOfTables * sizeof(uint64_t) + sizeof(int32_t);
       char*  pPayload = taosMemoryMalloc(size);
+      QUERY_CHECK_NULL(pPayload, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
 
       *(int32_t*)pPayload = numOfTables;
       if (numOfTables > 0) {
         memcpy(pPayload + sizeof(int32_t), taosArrayGet(pUidList, 0), numOfTables * sizeof(uint64_t));
       }
 
-      pStorageAPI->metaFn.putCachedTableList(pVnode, pScanNode->suid, context.digest, tListLen(context.digest),
+      code = pStorageAPI->metaFn.putCachedTableList(pVnode, pScanNode->suid, context.digest, tListLen(context.digest),
                                                     pPayload, size, 1);
+      QUERY_CHECK_CODE(code, lino, _error);
+
       digest[0] = 1;
       memcpy(digest + 1, context.digest, tListLen(context.digest));
     }
@@ -1236,7 +1366,11 @@ _end:
     }
   }
 
+_error:
   taosArrayDestroy(pUidList);
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
   return code;
 }
 
@@ -1360,7 +1494,12 @@ SArray* makeColumnArrayFromList(SNodeList* pNodeList) {
     c.precision = pColNode->node.resType.precision;
     c.scale = pColNode->node.resType.scale;
 
-    taosArrayPush(pList, &c);
+    void* tmp = taosArrayPush(pList, &c);
+    if (!tmp) {
+      taosArrayDestroy(pList);
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
+      return NULL;
+    }
   }
 
   return pList;
@@ -1369,7 +1508,8 @@ SArray* makeColumnArrayFromList(SNodeList* pNodeList) {
 int32_t extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNodeList, int32_t* numOfOutputCols,
                             int32_t type, SColMatchInfo* pMatchInfo) {
   size_t  numOfCols = LIST_LENGTH(pNodeList);
-  int32_t code = 0;
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
 
   pMatchInfo->matchType = type;
 
@@ -1390,7 +1530,8 @@ int32_t extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNod
       c.dstSlotId = pNode->slotId;
       c.isPk = pColNode->isPk;
       c.dataType = pColNode->node.resType;
-      taosArrayPush(pList, &c);
+      void* tmp = taosArrayPush(pList, &c);
+      QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
     }
   }
 
@@ -1424,6 +1565,11 @@ int32_t extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNod
   }
 
   pMatchInfo->pList = pList;
+
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
   return code;
 }
 
@@ -1458,8 +1604,12 @@ static SColumn* createColumn(int32_t blockId, int32_t slotId, int32_t colId, SDa
   return pCol;
 }
 
-void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
+int32_t createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
   pExp->pExpr = taosMemoryCalloc(1, sizeof(tExprNode));
+  QUERY_CHECK_NULL(pExp->pExpr, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
   pExp->pExpr->_function.num = 1;
   pExp->pExpr->_function.functionId = -1;
 
@@ -1470,6 +1620,8 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
     SColumnNode* pColNode = (SColumnNode*)pNode;
 
     pExp->base.pParam = taosMemoryCalloc(1, sizeof(SFunctParam));
+    QUERY_CHECK_NULL(pExp->base.pParam, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
     pExp->base.numOfParams = 1;
 
     SDataType* pType = &pColNode->node.resType;
@@ -1483,6 +1635,8 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
     SValueNode* pValNode = (SValueNode*)pNode;
 
     pExp->base.pParam = taosMemoryCalloc(1, sizeof(SFunctParam));
+    QUERY_CHECK_NULL(pExp->base.pParam, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
     pExp->base.numOfParams = 1;
 
     SDataType* pType = &pValNode->node.resType;
@@ -1518,7 +1672,8 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
       if (NULL == res) {  // todo handle error
       } else {
         res->node.resType = (SDataType){.bytes = sizeof(int64_t), .type = TSDB_DATA_TYPE_BIGINT};
-        nodesListAppend(pFuncNode->pParameterList, (SNode*)res);
+        code = nodesListAppend(pFuncNode->pParameterList, (SNode*)res);
+        QUERY_CHECK_CODE(code, lino, _end);
       }
     }
 #endif
@@ -1567,10 +1722,16 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) {
   } else {
     ASSERT(0);
   }
+
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  return code;
 }
 
-void createExprFromTargetNode(SExprInfo* pExp, STargetNode* pTargetNode) {
+int32_t createExprFromTargetNode(SExprInfo* pExp, STargetNode* pTargetNode) {
-  createExprFromOneNode(pExp, pTargetNode->pExpr, pTargetNode->slotId);
+  return createExprFromOneNode(pExp, pTargetNode->pExpr, pTargetNode->slotId);
 }
 
 SExprInfo* createExpr(SNodeList* pNodeList, int32_t* numOfExprs) {
@@ -1579,7 +1740,12 @@ SExprInfo* createExpr(SNodeList* pNodeList, int32_t* numOfExprs) {
 
   for (int32_t i = 0; i < (*numOfExprs); ++i) {
     SExprInfo* pExp = &pExprs[i];
-    createExprFromOneNode(pExp, nodesListGetNode(pNodeList, i), i + UD_TAG_COLUMN_INDEX);
+    int32_t    code = createExprFromOneNode(pExp, nodesListGetNode(pNodeList, i), i + UD_TAG_COLUMN_INDEX);
+    if (code != TSDB_CODE_SUCCESS) {
+      taosMemoryFreeClear(pExprs);
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+      return NULL;
+    }
   }
 
   return pExprs;
@@ -1608,7 +1774,12 @@ SExprInfo* createExprInfo(SNodeList* pNodeList, SNodeList* pGroupKeys, int32_t*
     }
 
     SExprInfo* pExp = &pExprs[i];
-    createExprFromTargetNode(pExp, pTargetNode);
+    int32_t    code = createExprFromTargetNode(pExp, pTargetNode);
+    if (code != TSDB_CODE_SUCCESS) {
+      taosMemoryFreeClear(pExprs);
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+      return NULL;
+    }
   }
 
   return pExprs;
@@ -1627,8 +1798,8 @@ static int32_t setSelectValueColumnInfo(SqlFunctionCtx* pCtx, int32_t numOfOutpu
   SHashObj* pSelectFuncs = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_ENTRY_LOCK);
   for (int32_t i = 0; i < numOfOutput; ++i) {
     const char* pName = pCtx[i].pExpr->pExpr->_function.functionName;
-    if ((strcmp(pName, "_select_value") == 0) || (strcmp(pName, "_group_key") == 0)
+    if ((strcmp(pName, "_select_value") == 0) || (strcmp(pName, "_group_key") == 0) ||
-      || (strcmp(pName, "_group_const_value") == 0)) {
+        (strcmp(pName, "_group_const_value") == 0)) {
       pValCtx[num++] = &pCtx[i];
     } else if (fmIsSelectFunc(pCtx[i].functionId)) {
       void* data = taosHashGet(pSelectFuncs, pName, strlen(pName));
@@ -1636,7 +1807,11 @@ static int32_t setSelectValueColumnInfo(SqlFunctionCtx* pCtx, int32_t numOfOutpu
         p = NULL;
         break;
       } else {
-        taosHashPut(pSelectFuncs, pName, strlen(pName), &num, sizeof(num));
+        int32_t tempRes = taosHashPut(pSelectFuncs, pName, strlen(pName), &num, sizeof(num));
+        if (tempRes != TSDB_CODE_SUCCESS && tempRes != TSDB_CODE_DUP_KEY) {
+          qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(tempRes));
+          return tempRes;
+        }
         p = &pCtx[i];
       }
     }
@@ -1655,6 +1830,8 @@ static int32_t setSelectValueColumnInfo(SqlFunctionCtx* pCtx, int32_t numOfOutpu
 
 SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, int32_t** rowEntryInfoOffset,
                                      SFunctionStateStore* pStore) {
+  int32_t         code = TSDB_CODE_SUCCESS;
+  int32_t         lino = 0;
   SqlFunctionCtx* pFuncCtx = (SqlFunctionCtx*)taosMemoryCalloc(numOfOutput, sizeof(SqlFunctionCtx));
   if (pFuncCtx == NULL) {
     return NULL;
@@ -1681,23 +1858,35 @@ SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput,
       pCtx->isPseudoFunc = fmIsWindowPseudoColumnFunc(pCtx->functionId);
       pCtx->isNotNullFunc = fmIsNotNullOutputFunc(pCtx->functionId);
 
-      if (fmIsAggFunc(pCtx->functionId) || fmIsIndefiniteRowsFunc(pCtx->functionId)) {
       bool isUdaf = fmIsUserDefinedFunc(pCtx->functionId);
+      if (fmIsAggFunc(pCtx->functionId) || fmIsIndefiniteRowsFunc(pCtx->functionId)) {
         if (!isUdaf) {
-          // TODO(xxx) : need handle return value of fmGetFuncExecFuncs.
+          code = fmGetFuncExecFuncs(pCtx->functionId, &pCtx->fpSet);
-          fmGetFuncExecFuncs(pCtx->functionId, &pCtx->fpSet);
+          QUERY_CHECK_CODE(code, lino, _end);
         } else {
           char* udfName = pExpr->pExpr->_function.pFunctNode->functionName;
           pCtx->udfName = taosStrdup(udfName);
-          // TODO(xxx) : need handle return value of fmGetUdafExecFuncs.
+          code = fmGetUdafExecFuncs(pCtx->functionId, &pCtx->fpSet);
-          fmGetUdafExecFuncs(pCtx->functionId, &pCtx->fpSet);
+          QUERY_CHECK_CODE(code, lino, _end);
+        }
+        bool tmp = pCtx->fpSet.getEnv(pExpr->pExpr->_function.pFunctNode, &env);
+        if (!tmp) {
+          code = TSDB_CODE_OUT_OF_MEMORY;
+          QUERY_CHECK_CODE(code, lino, _end);
         }
-        pCtx->fpSet.getEnv(pExpr->pExpr->_function.pFunctNode, &env);
       } else {
-        // TODO(xxx) : need handle return value of fmGetScalarFuncExecFuncs.
+        code = fmGetScalarFuncExecFuncs(pCtx->functionId, &pCtx->sfp);
-        fmGetScalarFuncExecFuncs(pCtx->functionId, &pCtx->sfp);
+        if (code != TSDB_CODE_SUCCESS && isUdaf) {
+          code = TSDB_CODE_SUCCESS;
+        }
+        QUERY_CHECK_CODE(code, lino, _end);
+
         if (pCtx->sfp.getEnv != NULL) {
-          pCtx->sfp.getEnv(pExpr->pExpr->_function.pFunctNode, &env);
+          bool tmp = pCtx->sfp.getEnv(pExpr->pExpr->_function.pFunctNode, &env);
+          if (!tmp) {
+            code = TSDB_CODE_OUT_OF_MEMORY;
+            QUERY_CHECK_CODE(code, lino, _end);
+          }
         }
       }
       pCtx->resDataInfo.interBufSize = env.calcMemSize;
@@ -1709,7 +1898,9 @@ SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput,
 
     pCtx->input.numOfInputCols = pFunct->numOfParams;
     pCtx->input.pData = taosMemoryCalloc(pFunct->numOfParams, POINTER_BYTES);
+    QUERY_CHECK_NULL(pCtx->input.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
     pCtx->input.pColumnDataAgg = taosMemoryCalloc(pFunct->numOfParams, POINTER_BYTES);
+    QUERY_CHECK_NULL(pCtx->input.pColumnDataAgg, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
 
     pCtx->pTsOutput = NULL;
     pCtx->resDataInfo.bytes = pFunct->resSchema.bytes;
@@ -1729,13 +1920,26 @@ SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput,
                                          pFuncCtx[i - 1].resDataInfo.interBufSize);
   }
 
-  setSelectValueColumnInfo(pFuncCtx, numOfOutput);
+  code = setSelectValueColumnInfo(pFuncCtx, numOfOutput);
+  QUERY_CHECK_CODE(code, lino, _end);
+
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    for (int32_t i = 0; i < numOfOutput; ++i) {
+      taosMemoryFree(pFuncCtx[i].input.pData);
+      taosMemoryFree(pFuncCtx[i].input.pColumnDataAgg);
+    }
+    taosMemoryFreeClear(pFuncCtx);
+    return NULL;
+  }
   return pFuncCtx;
 }
 
 // NOTE: sources columns are more than the destination SSDatablock columns.
 // doFilter in table scan needs every column even its output is false
-void relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray* pCols, bool outputEveryColumn) {
+int32_t relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray* pCols, bool outputEveryColumn) {
+  int32_t code = TSDB_CODE_SUCCESS;
   size_t  numOfSrcCols = taosArrayGetSize(pCols);
 
   int32_t i = 0, j = 0;
@@ -1745,7 +1949,11 @@ void relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray
 
     if (p->info.colId == pmInfo->colId) {
       SColumnInfoData* pDst = taosArrayGet(pBlock->pDataBlock, pmInfo->dstSlotId);
-      colDataAssign(pDst, p, pBlock->info.rows, &pBlock->info);
+      code = colDataAssign(pDst, p, pBlock->info.rows, &pBlock->info);
+      if (code != TSDB_CODE_SUCCESS) {
+        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+        return code;
+      }
       i++;
       j++;
     } else if (p->info.colId < pmInfo->colId) {
@@ -1754,6 +1962,7 @@ void relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray
       ASSERT(0);
     }
   }
+  return code;
 }
 
 SInterval extractIntervalInfo(const STableScanPhysiNode* pTableScanNode) {
@@ -2038,6 +2247,9 @@ int32_t tableListAddTableInfo(STableListInfo* pTableList, uint64_t uid, uint64_t
 
   int32_t slot = (int32_t)taosArrayGetSize(pTableList->pTableList) - 1;
   code = taosHashPut(pTableList->map, &uid, sizeof(uid), &slot, sizeof(slot));
+  if (code == TSDB_CODE_DUP_KEY) {
+    code = TSDB_CODE_SUCCESS;
+  }
   QUERY_CHECK_CODE(code, lino, _end);
 
 _end:
@@ -2111,9 +2323,9 @@ _error:
   return NULL;
 }
 
-void* tableListDestroy(STableListInfo* pTableListInfo) {
+void tableListDestroy(STableListInfo* pTableListInfo) {
   if (pTableListInfo == NULL) {
-    return NULL;
+    return;
   }
 
   taosArrayDestroy(pTableListInfo->pTableList);
@@ -2125,7 +2337,6 @@ void* tableListDestroy(STableListInfo* pTableListInfo) {
   pTableListInfo->pTableList = NULL;
   pTableListInfo->map = NULL;
   taosMemoryFree(pTableListInfo);
-  return NULL;
 }
 
 void tableListClear(STableListInfo* pTableListInfo) {
@@ -2162,12 +2373,20 @@ static int32_t sortTableGroup(STableListInfo* pTableListInfo) {
   uint64_t       gid = pInfo->groupId;
 
   int32_t start = 0;
-  taosArrayPush(pList, &start);
+  void*   tmp = taosArrayPush(pList, &start);
+  if (!tmp) {
+    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
 
   for (int32_t i = 1; i < size; ++i) {
     pInfo = taosArrayGet(pTableListInfo->pTableList, i);
     if (pInfo->groupId != gid) {
-      taosArrayPush(pList, &i);
+      tmp = taosArrayPush(pList, &i);
+      if (!tmp) {
+        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
+        return TSDB_CODE_OUT_OF_MEMORY;
+      }
       gid = pInfo->groupId;
     }
   }
@@ -2194,7 +2413,8 @@ int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle*
     return code;
   }
   if (group == NULL || groupByTbname) {
-    if (tsCountAlwaysReturnValue && QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN == nodeType(pScanNode) && ((STableScanPhysiNode*)pScanNode)->needCountEmptyTable) {
+    if (tsCountAlwaysReturnValue && QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN == nodeType(pScanNode) &&
+        ((STableScanPhysiNode*)pScanNode)->needCountEmptyTable) {
       pTableListInfo->remainGroups =
           taosHashInit(numOfTables, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
       if (pTableListInfo->remainGroups == NULL) {
@@ -2205,8 +2425,12 @@ int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle*
         STableKeyInfo* info = taosArrayGet(pTableListInfo->pTableList, i);
         info->groupId = groupByTbname ? info->uid : 0;
 
-        taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId), &(info->uid),
+        int32_t tempRes = taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId),
-                    sizeof(info->uid));
+                                      &(info->uid), sizeof(info->uid));
+        if (tempRes != TSDB_CODE_SUCCESS && tempRes != TSDB_CODE_DUP_KEY) {
+          qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(tempRes));
+          return tempRes;
+        }
       }
     } else {
       for (int32_t i = 0; i < numOfTables; i++) {
@@ -2254,7 +2478,11 @@ int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle*
   size_t size = taosArrayGetSize(pTableListInfo->pTableList);
   for (int32_t i = 0; i < size; ++i) {
     STableKeyInfo* p = taosArrayGet(pTableListInfo->pTableList, i);
-    taosHashPut(pTableListInfo->map, &p->uid, sizeof(uint64_t), &i, sizeof(int32_t));
+    int32_t        tempRes = taosHashPut(pTableListInfo->map, &p->uid, sizeof(uint64_t), &i, sizeof(int32_t));
+    if (tempRes != TSDB_CODE_SUCCESS && tempRes != TSDB_CODE_DUP_KEY) {
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(tempRes));
+      return tempRes;
+    }
   }
 
   return code;
@@ -2460,7 +2688,11 @@ SNodeList* makeColsNodeArrFromSortKeys(SNodeList* pSortKeys) {
   SNodeList* ret = NULL;
   FOREACH(node, pSortKeys) {
     SOrderByExprNode* pSortKey = (SOrderByExprNode*)node;
-    nodesListMakeAppend(&ret, pSortKey->pExpr);
+    int32_t           code = nodesListMakeAppend(&ret, pSortKey->pExpr);
+    if (code != TSDB_CODE_SUCCESS) {
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+      return NULL;
+    }
   }
   return ret;
 }

source/libs/executor/src/executor.c

@@ -97,7 +97,7 @@ static int32_t doSetSMABlock(SOperatorInfo* pOperator, void* input, size_t numOf
 
 _end:
   if (code != TSDB_CODE_SUCCESS) {
-    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
   }
   return code;
 }

source/libs/executor/src/executorInt.c

@@ -677,7 +677,7 @@ _end:
 }
 
 // todo refactor. SResultRow has direct pointer in miainfo
-int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, SExprSupp* pSup,
+void finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, SExprSupp* pSup,
                            SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo) {
   SFilePage* page = getBufPage(pBuf, resultRowPosition->pageId);
   if (page == NULL) {
@@ -694,7 +694,7 @@ int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPos
   doUpdateNumOfRows(pCtx, pRow, pSup->numOfExprs, rowEntryOffset);
   if (pRow->numOfRows == 0) {
     releaseBufPage(pBuf, page);
-    return 0;
+    return ;
   }
 
   int32_t size = pBlock->info.capacity;
@@ -713,7 +713,6 @@ int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPos
 
   releaseBufPage(pBuf, page);
   pBlock->info.rows += pRow->numOfRows;
-  return 0;
 }
 
 void doCopyToSDataBlockByHash(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf,

source/libs/executor/src/filloperator.c

@@ -64,6 +64,7 @@ static void doHandleRemainBlockForNewGroupImpl(SOperatorInfo* pOperator, SFillOp
                                                SResultInfo* pResultInfo, int32_t order) {
   pInfo->totalInputRows = pInfo->existNewGroupBlock->info.rows;
   SSDataBlock*   pResBlock = pInfo->pFinalRes;
+  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
 
   //  int32_t order = TSDB_ORDER_ASC;
   int32_t scanFlag = MAIN_SCAN;
@@ -85,7 +86,11 @@ static void doHandleRemainBlockForNewGroupImpl(SOperatorInfo* pOperator, SFillOp
   }
 
   int32_t numOfResultRows = pResultInfo->capacity - pResBlock->info.rows;
-  taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows);
+  int32_t code = taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows);
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+    T_LONG_JMP(pTaskInfo->env, code);
+  }
 
   pInfo->curGroupId = pInfo->existNewGroupBlock->info.id.groupId;
   pInfo->existNewGroupBlock = NULL;
@@ -96,7 +101,11 @@ static void doHandleRemainBlockFromNewGroup(SOperatorInfo* pOperator, SFillOpera
   SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
   if (taosFillHasMoreResults(pInfo->pFillInfo)) {
     int32_t numOfResultRows = pResultInfo->capacity - pInfo->pFinalRes->info.rows;
-    taosFillResultDataBlock(pInfo->pFillInfo, pInfo->pFinalRes, numOfResultRows);
+    int32_t code = taosFillResultDataBlock(pInfo->pFillInfo, pInfo->pFinalRes, numOfResultRows);
+    if (code != TSDB_CODE_SUCCESS) {
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+      T_LONG_JMP(pTaskInfo->env, code);
+    }
     pInfo->pRes->info.id.groupId = pInfo->curGroupId;
     return;
   }
@@ -269,7 +278,8 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) {
     }
 
     int32_t numOfResultRows = pOperator->resultInfo.capacity - pResBlock->info.rows;
-    taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows);
+    code = taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows);
+    QUERY_CHECK_CODE(code, lino, _end);
 
     // current group has no more result to return
     if (pResBlock->info.rows > 0) {
@@ -356,7 +366,8 @@ void destroyFillOperatorInfo(void* param) {
 
 static int32_t initFillInfo(SFillOperatorInfo* pInfo, SExprInfo* pExpr, int32_t numOfCols, SExprInfo* pNotFillExpr,
                             int32_t numOfNotFillCols, SNodeListNode* pValNode, STimeWindow win, int32_t capacity,
-                            const char* id, SInterval* pInterval, int32_t fillType, int32_t order) {
+                            const char* id, SInterval* pInterval, int32_t fillType, int32_t order,
+                            SExecTaskInfo* pTaskInfo) {
   SFillColInfo* pColInfo = createFillColInfo(pExpr, numOfCols, pNotFillExpr, numOfNotFillCols, pValNode);
 
   int64_t startKey = (order == TSDB_ORDER_ASC) ? win.skey : win.ekey;
@@ -364,7 +375,7 @@ static int32_t initFillInfo(SFillOperatorInfo* pInfo, SExprInfo* pExpr, int32_t
   //  STimeWindow w = {0};
   //  getInitialStartTimeWindow(pInterval, startKey, &w, order == TSDB_ORDER_ASC);
   pInfo->pFillInfo = taosCreateFillInfo(startKey, numOfCols, numOfNotFillCols, capacity, pInterval, fillType, pColInfo,
-                                        pInfo->primaryTsCol, order, id);
+                                        pInfo->primaryTsCol, order, id, pTaskInfo);
 
   if (order == TSDB_ORDER_ASC) {
     pInfo->win.skey = win.skey;
@@ -414,7 +425,13 @@ static int32_t createPrimaryTsExprIfNeeded(SFillOperatorInfo* pInfo, SFillPhysiN
       return TSDB_CODE_OUT_OF_MEMORY;
     }
 
-    createExprFromTargetNode(&pExpr[pExprSupp->numOfExprs], (STargetNode*)pPhyFillNode->pWStartTs);
+    int32_t code = createExprFromTargetNode(&pExpr[pExprSupp->numOfExprs], (STargetNode*)pPhyFillNode->pWStartTs);
+    if (code != TSDB_CODE_SUCCESS) {
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+      taosMemoryFreeClear(pExpr);
+      return code;
+    }
+
     pExprSupp->numOfExprs += 1;
     pExprSupp->pExprInfo = pExpr;
   }
@@ -476,7 +493,7 @@ SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode*
 
   code = initFillInfo(pInfo, pExprInfo, pInfo->numOfExpr, pNoFillSupp->pExprInfo, pNoFillSupp->numOfExprs,
                       (SNodeListNode*)pPhyFillNode->pValues, pPhyFillNode->timeRange, pResultInfo->capacity,
-                      pTaskInfo->id.str, pInterval, type, order);
+                      pTaskInfo->id.str, pInterval, type, order, pTaskInfo);
   if (code != TSDB_CODE_SUCCESS) {
     goto _error;
   }

source/libs/executor/src/groupoperator.c

@@ -774,6 +774,9 @@ void* getCurrentDataGroupInfo(const SPartitionOperatorInfo* pInfo, SDataGroupInf
     QUERY_CHECK_NULL(gi.pPageList, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
 
     code = taosHashPut(pInfo->pGroupSet, pInfo->keyBuf, len, &gi, sizeof(SDataGroupInfo));
+    if (code == TSDB_CODE_DUP_KEY) {
+      code = TSDB_CODE_SUCCESS;
+    }
     QUERY_CHECK_CODE(code, lino, _end);
 
     p = taosHashGet(pInfo->pGroupSet, pInfo->keyBuf, len);
@@ -1397,6 +1400,9 @@ static void doStreamHashPartitionImpl(SStreamPartitionOperatorInfo* pInfo, SSDat
 
       code =
           taosHashPut(pInfo->pPartitions, pInfo->partitionSup.keyBuf, keyLen, &newParData, sizeof(SPartitionDataInfo));
+      if (code == TSDB_CODE_DUP_KEY) {
+        code = TSDB_CODE_SUCCESS;
+      }
       QUERY_CHECK_CODE(code, lino, _end);
     }
   }
@@ -1614,7 +1620,9 @@ SOperatorInfo* createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStr
     QUERY_CHECK_NULL(pSubTableExpr, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY);
 
     pInfo->tbnameCalSup.pExprInfo = pSubTableExpr;
-    createExprFromOneNode(pSubTableExpr, pPartNode->pSubtable, 0);
+    code = createExprFromOneNode(pSubTableExpr, pPartNode->pSubtable, 0);
+    QUERY_CHECK_CODE(code, lino, _error);
+
     code = initExprSupp(&pInfo->tbnameCalSup, pSubTableExpr, 1, &pTaskInfo->storageAPI.functionStore);
     QUERY_CHECK_CODE(code, lino, _error);
   }

source/libs/executor/src/scanoperator.c

@@ -175,8 +175,13 @@ static int32_t insertTableToScanIgnoreList(STableScanInfo* pTableScanInfo, uint6
     }
   }
 
-  return taosHashPut(pTableScanInfo->pIgnoreTables, &uid, sizeof(uid), &pTableScanInfo->scanTimes,
+  int32_t tempRes = taosHashPut(pTableScanInfo->pIgnoreTables, &uid, sizeof(uid), &pTableScanInfo->scanTimes,
                                 sizeof(pTableScanInfo->scanTimes));
+  if (tempRes != TSDB_CODE_SUCCESS && tempRes != TSDB_CODE_DUP_KEY) {
+    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(tempRes));
+    return tempRes;
+  }
+  return TSDB_CODE_SUCCESS;
 }
 
 static int32_t doDynamicPruneDataBlock(SOperatorInfo* pOperator, SDataBlockInfo* pBlockInfo, uint32_t* status) {
@@ -279,7 +284,8 @@ bool applyLimitOffset(SLimitInfo* pLimitInfo, SSDataBlock* pBlock, SExecTaskInfo
       int32_t code = blockDataTrimFirstRows(pBlock, pLimitInfo->remainOffset);
       if (code != TSDB_CODE_SUCCESS) {
         qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
-        T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+        pTaskInfo->code = code;
+        T_LONG_JMP(pTaskInfo->env, code);
       }
       pLimitInfo->remainOffset = 0;
     }
@@ -360,11 +366,9 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanBase* pTableSca
     if (success) {
       size_t size = taosArrayGetSize(pBlock->pDataBlock);
       bool   keep = false;
-      int32_t code =
+      code = doFilterByBlockSMA(pOperator->exprSupp.pFilterInfo, pBlock->pBlockAgg, size, pBlockInfo->rows, &keep);
-          doFilterByBlockSMA(pOperator->exprSupp.pFilterInfo, pBlock->pBlockAgg, size, pBlockInfo->rows, &keep);
+      QUERY_CHECK_CODE(code, lino, _end);
-      if (TSDB_CODE_SUCCESS != code) {
+
-        return code;
-      }
       if (!keep) {
         qDebug("%s data block filter out by block SMA, brange:%" PRId64 "-%" PRId64 ", rows:%" PRId64,
                GET_TASKID(pTaskInfo), pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows);
@@ -1002,7 +1006,8 @@ static SSDataBlock* doGroupedTableScan(SOperatorInfo* pOperator) {
 _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
-    T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   return NULL;
 }
@@ -1103,7 +1108,8 @@ static SSDataBlock* startNextGroupScan(SOperatorInfo* pOperator) {
 _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
-    T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   return NULL;
 }
@@ -1126,14 +1132,19 @@ static SSDataBlock* groupSeqTableScan(SOperatorInfo* pOperator) {
 
     taosRLockLatch(&pTaskInfo->lock);
     code = initNextGroupScan(pInfo, &pList, &num);
-    QUERY_CHECK_CODE(code, lino, _end);
 
     taosRUnLockLatch(&pTaskInfo->lock);
+    QUERY_CHECK_CODE(code, lino, _end);
 
     ASSERT(pInfo->base.dataReader == NULL);
 
-    pAPI->tsdReader.tsdReaderOpen(pInfo->base.readHandle.vnode, &pInfo->base.cond, pList, num, pInfo->pResBlock,
+    code = pAPI->tsdReader.tsdReaderOpen(pInfo->base.readHandle.vnode, &pInfo->base.cond, pList, num, pInfo->pResBlock,
                                          (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), &pInfo->pIgnoreTables);
+    if (code != TSDB_CODE_SUCCESS) {
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+      T_LONG_JMP(pTaskInfo->env, code);
+    }
+
     if (pInfo->filesetDelimited) {
       pAPI->tsdReader.tsdSetFilesetDelimited(pInfo->base.dataReader);
     }
@@ -1160,7 +1171,8 @@ static SSDataBlock* groupSeqTableScan(SOperatorInfo* pOperator) {
 _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
-    T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   return result;
 }
@@ -1237,7 +1249,8 @@ static SSDataBlock* doTableScan(SOperatorInfo* pOperator) {
 _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
-    T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   return NULL;
 }
@@ -1261,7 +1274,7 @@ static void destroyTableScanBase(STableScanBase* pBase, TsdReader* pAPI) {
     taosArrayDestroy(pBase->matchInfo.pList);
   }
 
-  (void)tableListDestroy(pBase->pTableListInfo);
+  tableListDestroy(pBase->pTableListInfo);
   taosLRUCacheCleanup(pBase->metaCache.pTableMetaEntryCache);
   cleanupExprSupp(&pBase->pseudoSup);
 }
@@ -3464,7 +3477,8 @@ static SSDataBlock* doRawScan(SOperatorInfo* pOperator) {
 _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
-    T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   return NULL;
 }
@@ -3473,7 +3487,7 @@ static void destroyRawScanOperatorInfo(void* param) {
   SStreamRawScanInfo* pRawScan = (SStreamRawScanInfo*)param;
   pRawScan->pAPI->tsdReader.tsdReaderClose(pRawScan->dataReader);
   (void)pRawScan->pAPI->snapshotFn.destroySnapshot(pRawScan->sContext);
-  (void)tableListDestroy(pRawScan->pTableListInfo);
+  tableListDestroy(pRawScan->pTableListInfo);
   taosMemoryFree(pRawScan);
 }
 
@@ -3618,6 +3632,9 @@ void streamScanReloadState(SOperatorInfo* pOperator) {
         size_t   keySize = 0;
         int64_t* pUid = taosHashGetKey(pIte, &keySize);
         code = taosHashPut(pUpInfo->pMap, pUid, sizeof(int64_t), pIte, sizeof(TSKEY));
+        if (code == TSDB_CODE_DUP_KEY) {
+          code = TSDB_CODE_SUCCESS;
+        }
         QUERY_CHECK_CODE(code, lino, _end);
 
         pIte = taosHashIterate(curMap, pIte);
@@ -3666,7 +3683,7 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys
 
   if (pInfo == NULL || pOperator == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
-    (void)tableListDestroy(pTableListInfo);
+    tableListDestroy(pTableListInfo);
     goto _error;
   }
 
@@ -3679,7 +3696,7 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys
   int32_t numOfCols = 0;
   code = extractColMatchInfo(pScanPhyNode->pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo);
   if (code != TSDB_CODE_SUCCESS) {
-    (void)tableListDestroy(pTableListInfo);
+    tableListDestroy(pTableListInfo);
     goto _error;
   }
 
@@ -3708,14 +3725,16 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys
     SExprInfo* pSubTableExpr = taosMemoryCalloc(1, sizeof(SExprInfo));
     if (pSubTableExpr == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
-      (void)tableListDestroy(pTableListInfo);
+      tableListDestroy(pTableListInfo);
       goto _error;
     }
 
     pInfo->tbnameCalSup.pExprInfo = pSubTableExpr;
-    createExprFromOneNode(pSubTableExpr, pTableScanNode->pSubtable, 0);
+    code = createExprFromOneNode(pSubTableExpr, pTableScanNode->pSubtable, 0);
+    QUERY_CHECK_CODE(code, lino, _error);
+
     if (initExprSupp(&pInfo->tbnameCalSup, pSubTableExpr, 1, &pTaskInfo->storageAPI.functionStore) != 0) {
-      (void)tableListDestroy(pTableListInfo);
+      tableListDestroy(pTableListInfo);
       goto _error;
     }
   }
@@ -3725,12 +3744,12 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys
     SExprInfo* pTagExpr = createExpr(pTableScanNode->pTags, &numOfTags);
     if (pTagExpr == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
-      (void)tableListDestroy(pTableListInfo);
+      tableListDestroy(pTableListInfo);
       goto _error;
     }
     if (initExprSupp(&pInfo->tagCalSup, pTagExpr, numOfTags, &pTaskInfo->storageAPI.functionStore) != 0) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
-      (void)tableListDestroy(pTableListInfo);
+      tableListDestroy(pTableListInfo);
       goto _error;
     }
   }
@@ -3738,7 +3757,7 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys
   pInfo->pBlockLists = taosArrayInit(4, sizeof(SPackedData));
   if (pInfo->pBlockLists == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
-    (void)tableListDestroy(pTableListInfo);
+    tableListDestroy(pTableListInfo);
     goto _error;
   }
 
@@ -3803,7 +3822,7 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys
     memcpy(&pTaskInfo->streamInfo.tableCond, &pTSInfo->base.cond, sizeof(SQueryTableDataCond));
   } else {
     taosArrayDestroy(pColIds);
-    (void)tableListDestroy(pTableListInfo);
+    tableListDestroy(pTableListInfo);
     pColIds = NULL;
   }
 
@@ -3938,7 +3957,8 @@ static void doTagScanOneTable(SOperatorInfo* pOperator, const SSDataBlock* pRes,
 _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
-    T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
 }
 
@@ -4003,6 +4023,9 @@ static EDealRes tagScanRewriteTagColumn(SNode** pNode, void* pContext) {
   void*                  data = taosHashGet(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId));
   if (!data) {
     code = taosHashPut(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode)));
+    if (code == TSDB_CODE_DUP_KEY) {
+      code = TSDB_CODE_SUCCESS;
+    }
     QUERY_CHECK_CODE(code, lino, _end);
     pSColumnNode->slotId = pCtx->index++;
     SColumnInfo cInfo = {.colId = pSColumnNode->colId,
@@ -4241,7 +4264,8 @@ static SSDataBlock* doTagScanFromCtbIdx(SOperatorInfo* pOperator) {
 _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
-    T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   pOperator->resultInfo.totalRows += pRes->info.rows;
   return (pRes->info.rows == 0) ? NULL : pInfo->pRes;
@@ -4308,7 +4332,7 @@ static void destroyTagScanOperatorInfo(void* param) {
   blockDataDestroy(pInfo->pRes);
   pInfo->pRes = NULL;
   taosArrayDestroy(pInfo->matchInfo.pList);
-  pInfo->pTableListInfo = tableListDestroy(pInfo->pTableListInfo);
+  tableListDestroy(pInfo->pTableListInfo);
   taosMemoryFreeClear(param);
 }
 
@@ -4672,7 +4696,8 @@ static void adjustSubTableFromMemBlock(SOperatorInfo* pOperatorInfo, STmsSubTabl
 _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
-    T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
 }
 
@@ -4772,7 +4797,8 @@ static SSDataBlock* getSubTablesSortedBlock(SOperatorInfo* pOperator, SSDataBloc
 _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
-    T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   return (pResBlock->info.rows > 0) ? pResBlock : NULL;
 }
@@ -4890,7 +4916,8 @@ SSDataBlock* doTableMergeScanParaSubTables(SOperatorInfo* pOperator) {
 _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
-    T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   return pBlock;
 }
@@ -4910,13 +4937,17 @@ static void tableMergeScanDoSkipTable(uint64_t uid, void* pTableMergeOpInfo) {
   int bSkip = 1;
   if (pInfo->mSkipTables != NULL) {
     code = taosHashPut(pInfo->mSkipTables, &uid, sizeof(uid), &bSkip, sizeof(bSkip));
+    if (code == TSDB_CODE_DUP_KEY) {
+      code = TSDB_CODE_SUCCESS;
+    }
     QUERY_CHECK_CODE(code, lino, _end);
   }
 
 _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
-    T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
 }
 
@@ -5208,7 +5239,8 @@ void startGroupTableMergeScan(SOperatorInfo* pOperator) {
 _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
-    T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
 }
 
@@ -5342,7 +5374,6 @@ SSDataBlock* doTableMergeScan(SOperatorInfo* pOperator) {
   }
 
   pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;
-  ;
 
   return pBlock;
 }
@@ -5756,7 +5787,8 @@ static void buildSysDbFilterTableCount(SOperatorInfo* pOperator, STableCountScan
 _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
-    T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   setOperatorCompleted(pOperator);
 }
@@ -5797,7 +5829,8 @@ static void buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountSca
 _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
-    T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
 }
 
@@ -5845,7 +5878,8 @@ static SSDataBlock* buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCount
 _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
-    T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   return pRes->info.rows > 0 ? pRes : NULL;
 }
@@ -5892,7 +5926,8 @@ static void buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountSca
 _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
-    T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
 }
 
@@ -5930,7 +5965,8 @@ static void buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanO
 
 _end:
   if (code != TSDB_CODE_SUCCESS) {
-    T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
   }
   setOperatorCompleted(pOperator);

source/libs/executor/src/streamtimewindowoperator.c

@@ -1600,7 +1600,7 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
 
         if (pBlock->info.type != STREAM_CLEAR) {
           void* tmp = taosArrayAddAll(pInfo->pDelWins, delWins);
-          if (!tmp) {
+          if (!tmp && taosArrayGetSize(delWins) > 0) {
             code = TSDB_CODE_OUT_OF_MEMORY;
             QUERY_CHECK_CODE(code, lino, _end);
           }
@@ -1610,7 +1610,7 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) {
       }
       removeResults(delWins, pInfo->pUpdatedMap);
       void* tmp = taosArrayAddAll(pInfo->pDelWins, delWins);
-      if (!tmp) {
+      if (!tmp && taosArrayGetSize(delWins) > 0) {
         code = TSDB_CODE_OUT_OF_MEMORY;
         QUERY_CHECK_CODE(code, lino, _end);
       }
@@ -5313,7 +5313,7 @@ static SSDataBlock* doStreamMidIntervalAgg(SOperatorInfo* pOperator) {
 
       removeResults(delWins, pInfo->pUpdatedMap);
       void* tmp = taosArrayAddAll(pInfo->pDelWins, delWins);
-      if (!tmp) {
+      if (!tmp && taosArrayGetSize(delWins) > 0) {
         code = TSDB_CODE_OUT_OF_MEMORY;
         QUERY_CHECK_CODE(code, lino, _end);
       }

source/libs/executor/src/tfill.c

@@ -28,6 +28,7 @@
 #include "executorInt.h"
 #include "function.h"
 #include "querynodes.h"
+#include "querytask.h"
 #include "tdatablock.h"
 #include "tfill.h"
 
@@ -35,7 +36,7 @@
 #define DO_INTERPOLATION(_v1, _v2, _k1, _k2, _k) \
   ((_v1) + ((_v2) - (_v1)) * (((double)(_k)) - ((double)(_k1))) / (((double)(_k2)) - ((double)(_k1))))
 
-static void doSetVal(SColumnInfoData* pDstColInfoData, int32_t rowIndex, const SGroupKeys* pKey);
+static int32_t doSetVal(SColumnInfoData* pDstColInfoData, int32_t rowIndex, const SGroupKeys* pKey);
 
 static void setNotFillColumn(SFillInfo* pFillInfo, SColumnInfoData* pDstColInfo, int32_t rowIndex, int32_t colIdx) {
   SRowVal* p = NULL;
@@ -46,7 +47,11 @@ static void setNotFillColumn(SFillInfo* pFillInfo, SColumnInfoData* pDstColInfo,
   }
 
   SGroupKeys* pKey = taosArrayGet(p->pRowVal, colIdx);
-  doSetVal(pDstColInfo, rowIndex, pKey);
+  int32_t code = doSetVal(pDstColInfo, rowIndex, pKey);
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__,  __LINE__, tstrerror(code));
+    T_LONG_JMP(pFillInfo->pTaskInfo->env, code);
+  }
 }
 
 static void setNullRow(SSDataBlock* pBlock, SFillInfo* pFillInfo, int32_t rowIndex) {
@@ -65,39 +70,55 @@ static void setNullRow(SSDataBlock* pBlock, SFillInfo* pFillInfo, int32_t rowInd
   }
 }
 
-static void doSetUserSpecifiedValue(SColumnInfoData* pDst, SVariant* pVar, int32_t rowIndex, int64_t currentKey) {
+static int32_t doSetUserSpecifiedValue(SColumnInfoData* pDst, SVariant* pVar, int32_t rowIndex, int64_t currentKey) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
   bool    isNull = (TSDB_DATA_TYPE_NULL == pVar->nType) ? true : false;
   if (pDst->info.type == TSDB_DATA_TYPE_FLOAT) {
     float v = 0;
     GET_TYPED_DATA(v, float, pVar->nType, &pVar->f);
-    colDataSetVal(pDst, rowIndex, (char*)&v, isNull);
+    code = colDataSetVal(pDst, rowIndex, (char*)&v, isNull);
+    QUERY_CHECK_CODE(code, lino, _end);
   } else if (pDst->info.type == TSDB_DATA_TYPE_DOUBLE) {
     double v = 0;
     GET_TYPED_DATA(v, double, pVar->nType, &pVar->d);
-    colDataSetVal(pDst, rowIndex, (char*)&v, isNull);
+    code = colDataSetVal(pDst, rowIndex, (char*)&v, isNull);
+    QUERY_CHECK_CODE(code, lino, _end);
   } else if (IS_SIGNED_NUMERIC_TYPE(pDst->info.type) || pDst->info.type == TSDB_DATA_TYPE_BOOL) {
     int64_t v = 0;
     GET_TYPED_DATA(v, int64_t, pVar->nType, &pVar->i);
-    colDataSetVal(pDst, rowIndex, (char*)&v, isNull);
+    code = colDataSetVal(pDst, rowIndex, (char*)&v, isNull);
+    QUERY_CHECK_CODE(code, lino, _end);
   } else if (IS_UNSIGNED_NUMERIC_TYPE(pDst->info.type)) {
     uint64_t v = 0;
     GET_TYPED_DATA(v, uint64_t, pVar->nType, &pVar->u);
-    colDataSetVal(pDst, rowIndex, (char*)&v, isNull);
+    code = colDataSetVal(pDst, rowIndex, (char*)&v, isNull);
+    QUERY_CHECK_CODE(code, lino, _end);
   } else if (pDst->info.type == TSDB_DATA_TYPE_TIMESTAMP) {
     int64_t v = 0;
     GET_TYPED_DATA(v, int64_t, pVar->nType, &pVar->u);
-    colDataSetVal(pDst, rowIndex, (const char*)&v, isNull);
+    code = colDataSetVal(pDst, rowIndex, (const char*)&v, isNull);
+    QUERY_CHECK_CODE(code, lino, _end);
   } else if (pDst->info.type == TSDB_DATA_TYPE_NCHAR || pDst->info.type == TSDB_DATA_TYPE_VARCHAR ||
              pDst->info.type == TSDB_DATA_TYPE_VARBINARY) {
-    colDataSetVal(pDst, rowIndex, pVar->pz, isNull);
+    code = colDataSetVal(pDst, rowIndex, pVar->pz, isNull);
+    QUERY_CHECK_CODE(code, lino, _end);
   } else {  // others data
     colDataSetNULL(pDst, rowIndex);
   }
+
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  return code;
 }
 
 // fill windows pseudo column, _wstart, _wend, _wduration and return true, otherwise return false
 bool fillIfWindowPseudoColumn(SFillInfo* pFillInfo, SFillColInfo* pCol, SColumnInfoData* pDstColInfoData,
                               int32_t rowIndex) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
   if (!pCol->notFillCol) {
     return false;
   }
@@ -106,26 +127,37 @@ bool fillIfWindowPseudoColumn(SFillInfo* pFillInfo, SFillColInfo* pCol, SColumnI
       return false;
     }
     if (pCol->pExpr->base.pParam[0].pCol->colType == COLUMN_TYPE_WINDOW_START) {
-      colDataSetVal(pDstColInfoData, rowIndex, (const char*)&pFillInfo->currentKey, false);
+      code = colDataSetVal(pDstColInfoData, rowIndex, (const char*)&pFillInfo->currentKey, false);
+      QUERY_CHECK_CODE(code, lino, _end);
       return true;
     } else if (pCol->pExpr->base.pParam[0].pCol->colType == COLUMN_TYPE_WINDOW_END) {
       // TODO: include endpoint
       SInterval* pInterval = &pFillInfo->interval;
       int64_t    windowEnd =
           taosTimeAdd(pFillInfo->currentKey, pInterval->interval, pInterval->intervalUnit, pInterval->precision);
-      colDataSetVal(pDstColInfoData, rowIndex, (const char*)&windowEnd, false);
+      code = colDataSetVal(pDstColInfoData, rowIndex, (const char*)&windowEnd, false);
+      QUERY_CHECK_CODE(code, lino, _end);
       return true;
     } else if (pCol->pExpr->base.pParam[0].pCol->colType == COLUMN_TYPE_WINDOW_DURATION) {
       // TODO: include endpoint
-      colDataSetVal(pDstColInfoData, rowIndex, (const char*)&pFillInfo->interval.sliding, false);
+      code = colDataSetVal(pDstColInfoData, rowIndex, (const char*)&pFillInfo->interval.sliding, false);
+      QUERY_CHECK_CODE(code, lino, _end);
       return true;
     }
   }
+
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    T_LONG_JMP(pFillInfo->pTaskInfo->env, code);
+  }
   return false;
 }
 
 static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock* pSrcBlock, int64_t ts,
                          bool outOfBound) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
   SPoint  point1, point2, point;
   int32_t step = GET_FORWARD_DIRECTION_FACTOR(pFillInfo->order);
 
@@ -193,7 +225,8 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock*
           point = (SPoint){.key = pFillInfo->currentKey, .val = &out};
           taosGetLinearInterpolationVal(&point, type, &point1, &point2, type);
 
-          colDataSetVal(pDstCol, index, (const char*)&out, false);
+          code = colDataSetVal(pDstCol, index, (const char*)&out, false);
+          QUERY_CHECK_CODE(code, lino, _end);
         }
       }
     }
@@ -213,7 +246,8 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock*
         }
       } else {
         SVariant* pVar = &pFillInfo->pFillCol[i].fillVal;
-        doSetUserSpecifiedValue(pDst, pVar, index, pFillInfo->currentKey);
+        code = doSetUserSpecifiedValue(pDst, pVar, index, pFillInfo->currentKey);
+        QUERY_CHECK_CODE(code, lino, _end);
       }
     }
   }
@@ -224,19 +258,36 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock*
       taosTimeAdd(pFillInfo->currentKey, pInterval->sliding * step, pInterval->slidingUnit, pInterval->precision);
   pBlock->info.rows += 1;
   pFillInfo->numOfCurrent++;
-}
 
-void doSetVal(SColumnInfoData* pDstCol, int32_t rowIndex, const SGroupKeys* pKey) {
+_end:
-  if (pKey->isNull) {
+  if (code != TSDB_CODE_SUCCESS) {
-    colDataSetNULL(pDstCol, rowIndex);
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
-  } else {
+    T_LONG_JMP(pFillInfo->pTaskInfo->env, code);
-    colDataSetVal(pDstCol, rowIndex, pKey->pData, false);
   }
 }
 
-static void initBeforeAfterDataBuf(SFillInfo* pFillInfo) {
+int32_t doSetVal(SColumnInfoData* pDstCol, int32_t rowIndex, const SGroupKeys* pKey) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
+  if (pKey->isNull) {
+    colDataSetNULL(pDstCol, rowIndex);
+  } else {
+    code = colDataSetVal(pDstCol, rowIndex, pKey->pData, false);
+    QUERY_CHECK_CODE(code, lino, _end);
+  }
+
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  return code;
+}
+
+static int32_t initBeforeAfterDataBuf(SFillInfo* pFillInfo) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
   if (taosArrayGetSize(pFillInfo->next.pRowVal) > 0) {
-    return;
+    goto _end;
   }
 
   for (int i = 0; i < pFillInfo->numOfCols; i++) {
@@ -245,15 +296,26 @@ static void initBeforeAfterDataBuf(SFillInfo* pFillInfo) {
     SGroupKeys  key = {0};
     SResSchema* pSchema = &pCol->pExpr->base.resSchema;
     key.pData = taosMemoryMalloc(pSchema->bytes);
+    QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
     key.isNull = true;
     key.bytes = pSchema->bytes;
     key.type = pSchema->type;
 
-    taosArrayPush(pFillInfo->next.pRowVal, &key);
+    void* tmp = taosArrayPush(pFillInfo->next.pRowVal, &key);
+    QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
 
     key.pData = taosMemoryMalloc(pSchema->bytes);
-    taosArrayPush(pFillInfo->prev.pRowVal, &key);
+    QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
+    tmp = taosArrayPush(pFillInfo->prev.pRowVal, &key);
+    QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
   }
+
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  return code;
 }
 
 static void saveColData(SArray* rowBuf, int32_t columnIndex, const char* src, bool isNull);
@@ -264,7 +326,7 @@ static void copyCurrentRowIntoBuf(SFillInfo* pFillInfo, int32_t rowIndex, SRowVa
 
   for (int32_t i = 0; i < pFillInfo->numOfCols; ++i) {
     int32_t type = pFillInfo->pFillCol[i].pExpr->pExpr->nodeType;
-    if ( type == QUERY_NODE_COLUMN || type == QUERY_NODE_OPERATOR || type == QUERY_NODE_FUNCTION) {
+    if (type == QUERY_NODE_COLUMN || type == QUERY_NODE_OPERATOR || type == QUERY_NODE_FUNCTION) {
       if (!pFillInfo->pFillCol[i].notFillCol && pFillInfo->type != TSDB_FILL_NEXT) {
         continue;
       }
@@ -288,7 +350,8 @@ static void copyCurrentRowIntoBuf(SFillInfo* pFillInfo, int32_t rowIndex, SRowVa
 
 static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t outputRows) {
   pFillInfo->numOfCurrent = 0;
-
+  int32_t          code = TSDB_CODE_SUCCESS;
+  int32_t          lino = 0;
   SColumnInfoData* pTsCol = taosArrayGet(pFillInfo->pSrcBlock->pDataBlock, pFillInfo->srcTsSlotId);
 
   int32_t step = GET_FORWARD_DIRECTION_FACTOR(pFillInfo->order);
@@ -321,7 +384,7 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t
       // output buffer is full, abort
       if (pFillInfo->numOfCurrent == outputRows) {
         pFillInfo->numOfTotal += pFillInfo->numOfCurrent;
-        return outputRows;
+        goto _end;
       }
     } else {
       ASSERT(pFillInfo->currentKey == ts);
@@ -348,7 +411,8 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t
 
         char* src = colDataGetData(pSrc, pFillInfo->index);
         if (!colDataIsNull_s(pSrc, pFillInfo->index)) {
-          colDataSetVal(pDst, index, src, false);
+          code = colDataSetVal(pDst, index, src, false);
+          QUERY_CHECK_CODE(code, lino, _end);
           SRowVal* pRVal = FILL_IS_ASC_FILL(pFillInfo) ? &pFillInfo->prev : &pFillInfo->next;
           saveColData(pRVal->pRowVal, i, src, false);
           if (pFillInfo->srcTsSlotId == dstSlotId) {
@@ -356,15 +420,19 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t
           }
         } else {  // the value is null
           if (pDst->info.type == TSDB_DATA_TYPE_TIMESTAMP) {
-            colDataSetVal(pDst, index, (const char*)&pFillInfo->currentKey, false);
+            code = colDataSetVal(pDst, index, (const char*)&pFillInfo->currentKey, false);
+            QUERY_CHECK_CODE(code, lino, _end);
           } else {  // i > 0 and data is null , do interpolation
             if (pFillInfo->type == TSDB_FILL_PREV) {
               SArray*     p = FILL_IS_ASC_FILL(pFillInfo) ? pFillInfo->prev.pRowVal : pFillInfo->next.pRowVal;
               SGroupKeys* pKey = taosArrayGet(p, i);
-              doSetVal(pDst, index, pKey);
+              code = doSetVal(pDst, index, pKey);
+              QUERY_CHECK_CODE(code, lino, _end);
             } else if (pFillInfo->type == TSDB_FILL_LINEAR) {
               bool isNull = colDataIsNull_s(pSrc, pFillInfo->index);
-              colDataSetVal(pDst, index, src, isNull);
+              code = colDataSetVal(pDst, index, src, isNull);
+              QUERY_CHECK_CODE(code, lino, _end);
+
               SArray* p = FILL_IS_ASC_FILL(pFillInfo) ? pFillInfo->prev.pRowVal : pFillInfo->next.pRowVal;
               saveColData(p, i, src, isNull);  // todo:
             } else if (pFillInfo->type == TSDB_FILL_NULL || pFillInfo->type == TSDB_FILL_NULL_F) {
@@ -372,10 +440,12 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t
             } else if (pFillInfo->type == TSDB_FILL_NEXT) {
               SArray*     p = FILL_IS_ASC_FILL(pFillInfo) ? pFillInfo->next.pRowVal : pFillInfo->prev.pRowVal;
               SGroupKeys* pKey = taosArrayGet(p, i);
-              doSetVal(pDst, index, pKey);
+              code = doSetVal(pDst, index, pKey);
+              QUERY_CHECK_CODE(code, lino, _end);
             } else {
               SVariant* pVar = &pFillInfo->pFillCol[i].fillVal;
-              doSetUserSpecifiedValue(pDst, pVar, index, pFillInfo->currentKey);
+              code = doSetUserSpecifiedValue(pDst, pVar, index, pFillInfo->currentKey);
+              QUERY_CHECK_CODE(code, lino, _end);
             }
           }
         }
@@ -393,11 +463,15 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t
 
     if (pFillInfo->index >= pFillInfo->numOfRows || pFillInfo->numOfCurrent >= outputRows) {
       pFillInfo->numOfTotal += pFillInfo->numOfCurrent;
-      return pFillInfo->numOfCurrent;
+      goto _end;
     }
   }
 
-  return pFillInfo->numOfCurrent;
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  return code;
 }
 
 static void saveColData(SArray* rowBuf, int32_t columnIndex, const char* src, bool isNull) {
@@ -414,7 +488,7 @@ static void saveColData(SArray* rowBuf, int32_t columnIndex, const char* src, bo
   }
 }
 
-static int64_t appendFilledResult(SFillInfo* pFillInfo, SSDataBlock* pBlock, int64_t resultCapacity) {
+static void appendFilledResult(SFillInfo* pFillInfo, SSDataBlock* pBlock, int64_t resultCapacity) {
   /*
    * These data are generated according to fill strategy, since the current timestamp is out of the time window of
    * real result set. Note that we need to keep the direct previous result rows, to generated the filled data.
@@ -427,7 +501,6 @@ static int64_t appendFilledResult(SFillInfo* pFillInfo, SSDataBlock* pBlock, int
   pFillInfo->numOfTotal += pFillInfo->numOfCurrent;
 
   ASSERT(pFillInfo->numOfCurrent == resultCapacity);
-  return resultCapacity;
 }
 
 static int32_t taosNumOfRemainRows(SFillInfo* pFillInfo) {
@@ -440,7 +513,9 @@ static int32_t taosNumOfRemainRows(SFillInfo* pFillInfo) {
 
 struct SFillInfo* taosCreateFillInfo(TSKEY skey, int32_t numOfFillCols, int32_t numOfNotFillCols, int32_t capacity,
                                      SInterval* pInterval, int32_t fillType, struct SFillColInfo* pCol,
-                                     int32_t primaryTsSlotId, int32_t order, const char* id) {
+                                     int32_t primaryTsSlotId, int32_t order, const char* id, SExecTaskInfo* pTaskInfo) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
   if (fillType == TSDB_FILL_NONE) {
     return NULL;
   }
@@ -473,9 +548,23 @@ struct SFillInfo* taosCreateFillInfo(TSKEY skey, int32_t numOfFillCols, int32_t
   pFillInfo->interval = *pInterval;
 
   pFillInfo->next.pRowVal = taosArrayInit(pFillInfo->numOfCols, sizeof(SGroupKeys));
-  pFillInfo->prev.pRowVal = taosArrayInit(pFillInfo->numOfCols, sizeof(SGroupKeys));
+  QUERY_CHECK_NULL(pFillInfo->next.pRowVal, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
 
-  initBeforeAfterDataBuf(pFillInfo);
+  pFillInfo->prev.pRowVal = taosArrayInit(pFillInfo->numOfCols, sizeof(SGroupKeys));
+  QUERY_CHECK_NULL(pFillInfo->prev.pRowVal, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
+  code = initBeforeAfterDataBuf(pFillInfo);
+  QUERY_CHECK_CODE(code, lino, _end);
+
+  pFillInfo->pTaskInfo = pTaskInfo;
+
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    taosArrayDestroy(pFillInfo->next.pRowVal);
+    taosArrayDestroy(pFillInfo->prev.pRowVal);
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
   return pFillInfo;
 }
 
@@ -559,7 +648,7 @@ void taosFillUpdateStartTimestampInfo(SFillInfo* pFillInfo, int64_t ts) {
   pFillInfo->currentKey = ts;
 }
 
-bool taosFillNotStarted(const SFillInfo* pFillInfo) {return pFillInfo->start == pFillInfo->currentKey;}
+bool taosFillNotStarted(const SFillInfo* pFillInfo) { return pFillInfo->start == pFillInfo->currentKey; }
 
 bool taosFillHasMoreResults(SFillInfo* pFillInfo) {
   int32_t remain = taosNumOfRemainRows(pFillInfo);
@@ -586,7 +675,8 @@ int64_t getNumOfResultsAfterFillGap(SFillInfo* pFillInfo, TSKEY ekey, int32_t ma
     SColumnInfoData* pCol = taosArrayGet(pFillInfo->pSrcBlock->pDataBlock, pFillInfo->srcTsSlotId);
     int64_t*         tsList = (int64_t*)pCol->pData;
     TSKEY            lastKey = tsList[pFillInfo->numOfRows - 1];
-    numOfRes = taosTimeCountIntervalForFill(lastKey, pFillInfo->currentKey, pFillInfo->interval.sliding,
+    numOfRes =
+        taosTimeCountIntervalForFill(lastKey, pFillInfo->currentKey, pFillInfo->interval.sliding,
                                      pFillInfo->interval.slidingUnit, pFillInfo->interval.precision, pFillInfo->order);
     ASSERT(numOfRes >= numOfRows);
   } else {  // reach the end of data
@@ -595,7 +685,8 @@ int64_t getNumOfResultsAfterFillGap(SFillInfo* pFillInfo, TSKEY ekey, int32_t ma
       return 0;
     }
 
-    numOfRes = taosTimeCountIntervalForFill(ekey1, pFillInfo->currentKey, pFillInfo->interval.sliding,
+    numOfRes =
+        taosTimeCountIntervalForFill(ekey1, pFillInfo->currentKey, pFillInfo->interval.sliding,
                                      pFillInfo->interval.slidingUnit, pFillInfo->interval.precision, pFillInfo->order);
   }
 
@@ -617,7 +708,8 @@ void taosGetLinearInterpolationVal(SPoint* point, int32_t outputType, SPoint* po
   SET_TYPED_DATA(point->val, outputType, r);
 }
 
-void taosFillResultDataBlock(SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity) {
+int32_t taosFillResultDataBlock(SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity) {
+  int32_t code = TSDB_CODE_SUCCESS;
   int32_t remain = taosNumOfRemainRows(pFillInfo);
 
   int64_t numOfRes = getNumOfResultsAfterFillGap(pFillInfo, pFillInfo->end, capacity);
@@ -627,7 +719,7 @@ void taosFillResultDataBlock(SFillInfo* pFillInfo, SSDataBlock* p, int32_t capac
   if (remain == 0) {
     appendFilledResult(pFillInfo, p, numOfRes);
   } else {
-    fillResultImpl(pFillInfo, p, (int32_t)numOfRes);
+    code = fillResultImpl(pFillInfo, p, (int32_t)numOfRes);
     ASSERT(numOfRes == pFillInfo->numOfCurrent);
   }
 
@@ -635,6 +727,7 @@ void taosFillResultDataBlock(SFillInfo* pFillInfo, SSDataBlock* p, int32_t capac
          ", current : % d, total : % d, %s",
          pFillInfo, pFillInfo->numOfRows, pFillInfo->index, pFillInfo->start, pFillInfo->end, pFillInfo->currentKey,
          pFillInfo->numOfCurrent, pFillInfo->numOfTotal, pFillInfo->id);
+  return code;
 }
 
 int64_t getFillInfoStart(struct SFillInfo* pFillInfo) { return pFillInfo->start; }

source/libs/executor/src/timesliceoperator.c

@@ -163,18 +163,22 @@ static FORCE_INLINE int32_t timeSliceEnsureBlockCapacity(STimeSliceOperatorInfo*
 
   uint32_t winNum = (pSliceInfo->win.ekey - pSliceInfo->win.skey) / pSliceInfo->interval.interval;
   uint32_t newRowsNum = pBlock->info.rows + TMIN(winNum / 4 + 1, 1048576);
-  blockDataEnsureCapacity(pBlock, newRowsNum);
+  int32_t  code = blockDataEnsureCapacity(pBlock, newRowsNum);
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+    return code;
+  }
 
   return TSDB_CODE_SUCCESS;
 }
 
 static bool isIrowtsPseudoColumn(SExprInfo* pExprInfo) {
-  char *name = pExprInfo->pExpr->_function.functionName;
+  char* name = pExprInfo->pExpr->_function.functionName;
   return (IS_TIMESTAMP_TYPE(pExprInfo->base.resSchema.type) && strcasecmp(name, "_irowts") == 0);
 }
 
 static bool isIsfilledPseudoColumn(SExprInfo* pExprInfo) {
-  char *name = pExprInfo->pExpr->_function.functionName;
+  char* name = pExprInfo->pExpr->_function.functionName;
   return (IS_BOOLEAN_TYPE(pExprInfo->base.resSchema.type) && strcasecmp(name, "_isfilled") == 0);
 }
 
@@ -202,7 +206,7 @@ static bool checkDuplicateTimestamps(STimeSliceOperatorInfo* pSliceInfo, SColumn
     return false;
   }
 
-  SRowKey cur = {.ts = currentTs, .numOfPKs = (pPkCol != NULL)? 1:0};
+  SRowKey cur = {.ts = currentTs, .numOfPKs = (pPkCol != NULL) ? 1 : 0};
   if (pPkCol != NULL) {
     cur.pks[0].type = pPkCol->info.type;
     if (IS_VAR_DATA_TYPE(pPkCol->info.type)) {
@@ -244,7 +248,7 @@ static bool getIgoreNullRes(SExprSupp* pExprSup) {
 
     if (isInterpFunc(pExprInfo)) {
       for (int32_t j = 0; j < pExprInfo->base.numOfParams; ++j) {
-        SFunctParam *pFuncParam = &pExprInfo->base.pParam[j];
+        SFunctParam* pFuncParam = &pExprInfo->base.pParam[j];
         if (pFuncParam->type == FUNC_PARAM_TYPE_VALUE) {
           return pFuncParam->param.i ? true : false;
         }
@@ -276,14 +280,15 @@ static bool checkNullRow(SExprSupp* pExprSup, SSDataBlock* pSrcBlock, int32_t in
   return false;
 }
 
-
 static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp* pExprSup, SSDataBlock* pResBlock,
-                                   SSDataBlock* pSrcBlock, int32_t index, bool beforeTs) {
+                                   SSDataBlock* pSrcBlock, int32_t index, bool beforeTs, SExecTaskInfo* pTaskInfo) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
   int32_t rows = pResBlock->info.rows;
-  timeSliceEnsureBlockCapacity(pSliceInfo, pResBlock);
+  code = timeSliceEnsureBlockCapacity(pSliceInfo, pResBlock);
+  QUERY_CHECK_CODE(code, lino, _end);
   // todo set the correct primary timestamp column
 
-
   // output the result
   int32_t fillColIndex = 0;
   bool    hasInterp = true;
@@ -294,11 +299,13 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
     SColumnInfoData* pDst = taosArrayGet(pResBlock->pDataBlock, dstSlot);
 
     if (isIrowtsPseudoColumn(pExprInfo)) {
-      colDataSetVal(pDst, rows, (char*)&pSliceInfo->current, false);
+      code = colDataSetVal(pDst, rows, (char*)&pSliceInfo->current, false);
+      QUERY_CHECK_CODE(code, lino, _end);
       continue;
     } else if (isIsfilledPseudoColumn(pExprInfo)) {
       bool isFilled = true;
-      colDataSetVal(pDst, pResBlock->info.rows, (char*)&isFilled, false);
+      code = colDataSetVal(pDst, pResBlock->info.rows, (char*)&isFilled, false);
+      QUERY_CHECK_CODE(code, lino, _end);
       continue;
     } else if (!isInterpFunc(pExprInfo)) {
       if (isGroupKeyFunc(pExprInfo) || isSelectGroupConstValueFunc(pExprInfo)) {
@@ -312,12 +319,14 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
           }
 
           char* v = colDataGetData(pSrc, index);
-          colDataSetVal(pDst, pResBlock->info.rows, v, false);
+          code = colDataSetVal(pDst, pResBlock->info.rows, v, false);
+          QUERY_CHECK_CODE(code, lino, _end);
         } else if(!isSelectGroupConstValueFunc(pExprInfo)){
           // use stored group key
           SGroupKeys* pkey = pSliceInfo->pPrevGroupKey;
           if (pkey->isNull == false) {
-            colDataSetVal(pDst, rows, pkey->pData, false);
+            code = colDataSetVal(pDst, rows, pkey->pData, false);
+            QUERY_CHECK_CODE(code, lino, _end);
           } else {
             colDataSetNULL(pDst, rows);
           }
@@ -354,7 +363,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
           } else {
             v = taosStr2Float(varDataVal(pVar->pz), NULL);
           }
-          colDataSetVal(pDst, rows, (char*)&v, isNull);
+          code = colDataSetVal(pDst, rows, (char*)&v, isNull);
+          QUERY_CHECK_CODE(code, lino, _end);
         } else if (pDst->info.type == TSDB_DATA_TYPE_DOUBLE) {
           double v = 0;
           if (!IS_VAR_DATA_TYPE(pVar->nType)) {
@@ -362,7 +372,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
           } else {
             v = taosStr2Double(varDataVal(pVar->pz), NULL);
           }
-          colDataSetVal(pDst, rows, (char*)&v, isNull);
+          code = colDataSetVal(pDst, rows, (char*)&v, isNull);
+          QUERY_CHECK_CODE(code, lino, _end);
         } else if (IS_SIGNED_NUMERIC_TYPE(pDst->info.type)) {
           int64_t v = 0;
           if (!IS_VAR_DATA_TYPE(pVar->nType)) {
@@ -370,7 +381,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
           } else {
             v = taosStr2Int64(varDataVal(pVar->pz), NULL, 10);
           }
-          colDataSetVal(pDst, rows, (char*)&v, isNull);
+          code = colDataSetVal(pDst, rows, (char*)&v, isNull);
+          QUERY_CHECK_CODE(code, lino, _end);
         } else if (IS_UNSIGNED_NUMERIC_TYPE(pDst->info.type)) {
           uint64_t v = 0;
           if (!IS_VAR_DATA_TYPE(pVar->nType)) {
@@ -378,7 +390,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
           } else {
             v = taosStr2UInt64(varDataVal(pVar->pz), NULL, 10);
           }
-          colDataSetVal(pDst, rows, (char*)&v, isNull);
+          code = colDataSetVal(pDst, rows, (char*)&v, isNull);
+          QUERY_CHECK_CODE(code, lino, _end);
         } else if (IS_BOOLEAN_TYPE(pDst->info.type)) {
           bool v = false;
           if (!IS_VAR_DATA_TYPE(pVar->nType)) {
@@ -386,7 +399,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
           } else {
             v = taosStr2Int8(varDataVal(pVar->pz), NULL, 10);
           }
-          colDataSetVal(pDst, rows, (char*)&v, isNull);
+          code = colDataSetVal(pDst, rows, (char*)&v, isNull);
+          QUERY_CHECK_CODE(code, lino, _end);
         }
 
         ++fillColIndex;
@@ -421,8 +435,10 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
         }
 
         current.val = taosMemoryCalloc(pLinearInfo->bytes, 1);
+        QUERY_CHECK_NULL(current.val, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
         taosGetLinearInterpolationVal(&current, pLinearInfo->type, &start, &end, pLinearInfo->type);
-        colDataSetVal(pDst, rows, (char*)current.val, false);
+        code = colDataSetVal(pDst, rows, (char*)current.val, false);
+        QUERY_CHECK_CODE(code, lino, _end);
 
         taosMemoryFree(current.val);
         break;
@@ -435,7 +451,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
 
         SGroupKeys* pkey = taosArrayGet(pSliceInfo->pPrevRow, srcSlot);
         if (pkey->isNull == false) {
-          colDataSetVal(pDst, rows, pkey->pData, false);
+          code = colDataSetVal(pDst, rows, pkey->pData, false);
+          QUERY_CHECK_CODE(code, lino, _end);
         } else {
           colDataSetNULL(pDst, rows);
         }
@@ -450,7 +467,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
 
         SGroupKeys* pkey = taosArrayGet(pSliceInfo->pNextRow, srcSlot);
         if (pkey->isNull == false) {
-          colDataSetVal(pDst, rows, pkey->pData, false);
+          code = colDataSetVal(pDst, rows, pkey->pData, false);
+          QUERY_CHECK_CODE(code, lino, _end);
         } else {
           colDataSetNULL(pDst, rows);
         }
@@ -467,12 +485,21 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp
     pResBlock->info.rows += 1;
   }
 
+_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 hasInterp;
 }
 
-static void addCurrentRowToResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp* pExprSup, SSDataBlock* pResBlock,
+static int32_t addCurrentRowToResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp* pExprSup, SSDataBlock* pResBlock,
                                      SSDataBlock* pSrcBlock, int32_t index) {
-  timeSliceEnsureBlockCapacity(pSliceInfo, pResBlock);
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
+  code = timeSliceEnsureBlockCapacity(pSliceInfo, pResBlock);
+  QUERY_CHECK_CODE(code, lino, _end);
   for (int32_t j = 0; j < pExprSup->numOfExprs; ++j) {
     SExprInfo* pExprInfo = &pExprSup->pExprInfo[j];
 
@@ -480,10 +507,12 @@ static void addCurrentRowToResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp*
     SColumnInfoData* pDst = taosArrayGet(pResBlock->pDataBlock, dstSlot);
 
     if (isIrowtsPseudoColumn(pExprInfo)) {
-      colDataSetVal(pDst, pResBlock->info.rows, (char*)&pSliceInfo->current, false);
+      code = colDataSetVal(pDst, pResBlock->info.rows, (char*)&pSliceInfo->current, false);
+      QUERY_CHECK_CODE(code, lino, _end);
     } else if (isIsfilledPseudoColumn(pExprInfo)) {
       bool isFilled = false;
-      colDataSetVal(pDst, pResBlock->info.rows, (char*)&isFilled, false);
+      code = colDataSetVal(pDst, pResBlock->info.rows, (char*)&isFilled, false);
+      QUERY_CHECK_CODE(code, lino, _end);
     } else {
       int32_t          srcSlot = pExprInfo->base.pParam[0].pCol->slotId;
       SColumnInfoData* pSrc = taosArrayGet(pSrcBlock->pDataBlock, srcSlot);
@@ -494,15 +523,23 @@ static void addCurrentRowToResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp*
       }
 
       char* v = colDataGetData(pSrc, index);
-      colDataSetVal(pDst, pResBlock->info.rows, v, false);
+      code = colDataSetVal(pDst, pResBlock->info.rows, v, false);
+      QUERY_CHECK_CODE(code, lino, _end);
     }
   }
 
   pResBlock->info.rows += 1;
-  return;
+
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  return code;
 }
 
 static int32_t initPrevRowsKeeper(STimeSliceOperatorInfo* pInfo, SSDataBlock* pBlock) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
   if (pInfo->pPrevRow != NULL) {
     return TSDB_CODE_SUCCESS;
   }
@@ -521,14 +558,23 @@ static int32_t initPrevRowsKeeper(STimeSliceOperatorInfo* pInfo, SSDataBlock* pB
     key.type = pColInfo->info.type;
     key.isNull = false;
     key.pData = taosMemoryCalloc(1, pColInfo->info.bytes);
-    taosArrayPush(pInfo->pPrevRow, &key);
+    QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+    void* tmp = taosArrayPush(pInfo->pPrevRow, &key);
+    QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
   }
 
   pInfo->isPrevRowSet = false;
-  return TSDB_CODE_SUCCESS;
+
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  return code;
 }
 
 static int32_t initNextRowsKeeper(STimeSliceOperatorInfo* pInfo, SSDataBlock* pBlock) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
   if (pInfo->pNextRow != NULL) {
     return TSDB_CODE_SUCCESS;
   }
@@ -547,15 +593,24 @@ static int32_t initNextRowsKeeper(STimeSliceOperatorInfo* pInfo, SSDataBlock* pB
     key.type = pColInfo->info.type;
     key.isNull = false;
     key.pData = taosMemoryCalloc(1, pColInfo->info.bytes);
-    taosArrayPush(pInfo->pNextRow, &key);
+    QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
+    void* tmp = taosArrayPush(pInfo->pNextRow, &key);
+    QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
   }
 
   pInfo->isNextRowSet = false;
 
-  return TSDB_CODE_SUCCESS;
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  return code;
 }
 
 static int32_t initFillLinearInfo(STimeSliceOperatorInfo* pInfo, SSDataBlock* pBlock) {
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
   if (pInfo->pLinearInfo != NULL) {
     return TSDB_CODE_SUCCESS;
   }
@@ -573,15 +628,23 @@ static int32_t initFillLinearInfo(STimeSliceOperatorInfo* pInfo, SSDataBlock* pB
     linearInfo.start.key = INT64_MIN;
     linearInfo.end.key = INT64_MIN;
     linearInfo.start.val = taosMemoryCalloc(1, pColInfo->info.bytes);
+    QUERY_CHECK_NULL(linearInfo.start.val, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
     linearInfo.end.val = taosMemoryCalloc(1, pColInfo->info.bytes);
+    QUERY_CHECK_NULL(linearInfo.end.val, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
     linearInfo.isStartSet = false;
     linearInfo.isEndSet = false;
     linearInfo.type = pColInfo->info.type;
     linearInfo.bytes = pColInfo->info.bytes;
-    taosArrayPush(pInfo->pLinearInfo, &linearInfo);
+    void* tmp = taosArrayPush(pInfo->pLinearInfo, &linearInfo);
+    QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
   }
 
-  return TSDB_CODE_SUCCESS;
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
+  return code;
 }
 
 static int32_t initGroupKeyKeeper(STimeSliceOperatorInfo* pInfo, SExprSupp* pExprSup) {
@@ -630,62 +693,59 @@ static int32_t initKeeperInfo(STimeSliceOperatorInfo* pInfo, SSDataBlock* pBlock
     return TSDB_CODE_FAILED;
   }
 
-
   return TSDB_CODE_SUCCESS;
 }
 
-static int32_t resetPrevRowsKeeper(STimeSliceOperatorInfo* pInfo) {
+static void resetPrevRowsKeeper(STimeSliceOperatorInfo* pInfo) {
   if (pInfo->pPrevRow == NULL) {
-    return TSDB_CODE_SUCCESS;
+    return;
   }
 
   for (int32_t i = 0; i < taosArrayGetSize(pInfo->pLinearInfo); ++i) {
-    SGroupKeys *pKey = taosArrayGet(pInfo->pPrevRow, i);
+    SGroupKeys* pKey = taosArrayGet(pInfo->pPrevRow, i);
     pKey->isNull = false;
   }
 
   pInfo->isPrevRowSet = false;
 
-  return TSDB_CODE_SUCCESS;
+  return;
 }
 
-static int32_t resetNextRowsKeeper(STimeSliceOperatorInfo* pInfo) {
+static void resetNextRowsKeeper(STimeSliceOperatorInfo* pInfo) {
   if (pInfo->pNextRow == NULL) {
-    return TSDB_CODE_SUCCESS;
+    return;
   }
 
   for (int32_t i = 0; i < taosArrayGetSize(pInfo->pLinearInfo); ++i) {
-    SGroupKeys *pKey = taosArrayGet(pInfo->pPrevRow, i);
+    SGroupKeys* pKey = taosArrayGet(pInfo->pPrevRow, i);
     pKey->isNull = false;
   }
 
   pInfo->isNextRowSet = false;
 
-  return TSDB_CODE_SUCCESS;
+  return;
 }
 
-static int32_t resetFillLinearInfo(STimeSliceOperatorInfo* pInfo) {
+static void resetFillLinearInfo(STimeSliceOperatorInfo* pInfo) {
   if (pInfo->pLinearInfo == NULL) {
-    return TSDB_CODE_SUCCESS;
+    return;
   }
 
   for (int32_t i = 0; i < taosArrayGetSize(pInfo->pLinearInfo); ++i) {
-    SFillLinearInfo *pLinearInfo = taosArrayGet(pInfo->pLinearInfo, i);
+    SFillLinearInfo* pLinearInfo = taosArrayGet(pInfo->pLinearInfo, i);
     pLinearInfo->start.key = INT64_MIN;
     pLinearInfo->end.key = INT64_MIN;
     pLinearInfo->isStartSet = false;
     pLinearInfo->isEndSet = false;
   }
 
-  return TSDB_CODE_SUCCESS;
+  return;
 }
 
-static int32_t resetKeeperInfo(STimeSliceOperatorInfo* pInfo) {
+static void resetKeeperInfo(STimeSliceOperatorInfo* pInfo) {
   resetPrevRowsKeeper(pInfo);
   resetNextRowsKeeper(pInfo);
   resetFillLinearInfo(pInfo);
-
-  return TSDB_CODE_SUCCESS;
 }
 
 static bool checkThresholdReached(STimeSliceOperatorInfo* pSliceInfo, int32_t threshold) {
@@ -717,11 +777,12 @@ static void saveBlockStatus(STimeSliceOperatorInfo* pSliceInfo, SSDataBlock* pBl
 
   // all data in remaining block processed
   pSliceInfo->pRemainRes = NULL;
-
 }
 
 static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pSliceInfo, SSDataBlock* pBlock,
                             SExecTaskInfo* pTaskInfo, bool ignoreNull) {
+  int32_t        code = TSDB_CODE_SUCCESS;
+  int32_t        lino = 0;
   SSDataBlock*   pResBlock = pSliceInfo->pRes;
   SInterval*     pInterval = &pSliceInfo->interval;
 
@@ -746,7 +807,8 @@ static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pS
     }
 
     if (ts == pSliceInfo->current) {
-      addCurrentRowToResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i);
+      code = addCurrentRowToResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i);
+      QUERY_CHECK_CODE(code, lino, _end);
 
       doKeepPrevRows(pSliceInfo, pBlock, i);
       doKeepLinearInfo(pSliceInfo, pBlock, i);
@@ -773,12 +835,12 @@ static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pS
         int64_t nextTs = *(int64_t*)colDataGetData(pTsCol, i + 1);
         if (nextTs > pSliceInfo->current) {
           while (pSliceInfo->current < nextTs && pSliceInfo->current <= pSliceInfo->win.ekey) {
-            if (!genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i, false) &&
+            if (!genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i, false, pTaskInfo) &&
                 pSliceInfo->fillType == TSDB_FILL_LINEAR) {
               break;
             } else {
-              pSliceInfo->current = taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit,
+              pSliceInfo->current =
-                                                pInterval->precision);
+                  taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit, pInterval->precision);
             }
           }
 
@@ -801,7 +863,7 @@ static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pS
       doKeepLinearInfo(pSliceInfo, pBlock, i);
 
       while (pSliceInfo->current < ts && pSliceInfo->current <= pSliceInfo->win.ekey) {
-        if (!genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i, true) &&
+        if (!genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i, true, pTaskInfo) &&
             pSliceInfo->fillType == TSDB_FILL_LINEAR) {
           break;
         } else {
@@ -812,7 +874,8 @@ static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pS
 
       // add current row if timestamp match
       if (ts == pSliceInfo->current && pSliceInfo->current <= pSliceInfo->win.ekey) {
-        addCurrentRowToResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i);
+        code = addCurrentRowToResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i);
+        QUERY_CHECK_CODE(code, lino, _end);
 
         pSliceInfo->current =
             taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit, pInterval->precision);
@@ -832,6 +895,13 @@ static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pS
   // if reached here, meaning block processing finished naturally,
   // or interpolation reach window upper bound
   pSliceInfo->pRemainRes = NULL;
+
+_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);
+  }
 }
 
 static void genInterpAfterDataBlock(STimeSliceOperatorInfo* pSliceInfo, SOperatorInfo* pOperator, int32_t index) {
@@ -844,7 +914,7 @@ static void genInterpAfterDataBlock(STimeSliceOperatorInfo* pSliceInfo, SOperato
   }
 
   while (pSliceInfo->current <= pSliceInfo->win.ekey) {
-    genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, NULL, index, false);
+    (void)genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, NULL, index, false, pOperator->pTaskInfo);
     pSliceInfo->current =
         taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit, pInterval->precision);
   }
@@ -901,16 +971,27 @@ static void doHandleTimeslice(SOperatorInfo* pOperator, SSDataBlock* pBlock) {
 
   if (pSliceInfo->scalarSup.pExprInfo != NULL) {
     SExprSupp* pExprSup = &pSliceInfo->scalarSup;
-    projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL);
+    code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL);
+    if (code != TSDB_CODE_SUCCESS) {
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+      T_LONG_JMP(pTaskInfo->env, code);
+    }
   }
 
   // the pDataBlock are always the same one, no need to call this again
-  setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true);
+  code = setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true);
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+    T_LONG_JMP(pTaskInfo->env, code);
+  }
   doTimesliceImpl(pOperator, pSliceInfo, pBlock, pTaskInfo, ignoreNull);
   copyPrevGroupKey(&pOperator->exprSupp, pSliceInfo->pPrevGroupKey, pBlock);
 }
 
 static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) {
+  int32_t        code = TSDB_CODE_SUCCESS;
+  int32_t        lino = 0;
+  SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
   if (pOperator->status == OP_EXEC_DONE) {
     return NULL;
   }
@@ -924,7 +1005,8 @@ static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) {
     if (pSliceInfo->pNextGroupRes != NULL) {
       doHandleTimeslice(pOperator, pSliceInfo->pNextGroupRes);
       if (checkWindowBoundReached(pSliceInfo) || checkThresholdReached(pSliceInfo, pOperator->resultInfo.threshold)) {
-        doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL);
+        code = doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL);
+        QUERY_CHECK_CODE(code, lino, _finished);
         if (pSliceInfo->pRemainRes == NULL) {
           pSliceInfo->pNextGroupRes = NULL;
         }
@@ -959,7 +1041,8 @@ static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) {
 
       doHandleTimeslice(pOperator, pBlock);
       if (checkWindowBoundReached(pSliceInfo) || checkThresholdReached(pSliceInfo, pOperator->resultInfo.threshold)) {
-        doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL);
+        code = doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL);
+        QUERY_CHECK_CODE(code, lino, _finished);
         if (pResBlock->info.rows != 0) {
           goto _finished;
         }
@@ -971,7 +1054,8 @@ static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) {
     // except for fill(next), fill(linear)
     genInterpAfterDataBlock(pSliceInfo, pOperator, 0);
 
-    doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL);
+    code = doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL);
+    QUERY_CHECK_CODE(code, lino, _finished);
     if (pOperator->status == OP_EXEC_DONE) {
       break;
     }
@@ -989,6 +1073,11 @@ _finished:
   if (pResBlock->info.rows == 0) {
     pOperator->status = OP_EXEC_DONE;
   }
+  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 pResBlock->info.rows == 0 ? NULL : pResBlock;
 }
@@ -996,8 +1085,7 @@ _finished:
 static int32_t extractPkColumnFromFuncs(SNodeList* pFuncs, bool* pHasPk, SColumn* pPkColumn) {
   SNode* pNode;
   FOREACH(pNode, pFuncs) {
-    if ((nodeType(pNode) == QUERY_NODE_TARGET) && 
+    if ((nodeType(pNode) == QUERY_NODE_TARGET) && (nodeType(((STargetNode*)pNode)->pExpr) == QUERY_NODE_FUNCTION)) {
-        (nodeType(((STargetNode*)pNode)->pExpr) == QUERY_NODE_FUNCTION)) {
       SFunctionNode* pFunc = (SFunctionNode*)((STargetNode*)pNode)->pExpr;
       if (fmIsInterpFunc(pFunc->funcId) && pFunc->hasPk) {
         SNode* pNode2 = (pFunc->pParameterList->pTail->pNode);
@@ -1013,6 +1101,8 @@ static int32_t extractPkColumnFromFuncs(SNodeList* pFuncs, bool* pHasPk, SColumn
 }
 
 SOperatorInfo* createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo) {
+  int32_t                 code = TSDB_CODE_SUCCESS;
+  int32_t                 lino = 0;
   STimeSliceOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STimeSliceOperatorInfo));
   SOperatorInfo*          pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo));
   if (pOperator == NULL || pInfo == NULL) {
@@ -1024,27 +1114,23 @@ SOperatorInfo* createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode
 
   int32_t    numOfExprs = 0;
   SExprInfo* pExprInfo = createExprInfo(pInterpPhyNode->pFuncs, NULL, &numOfExprs);
-  int32_t    code = initExprSupp(pSup, pExprInfo, numOfExprs, &pTaskInfo->storageAPI.functionStore);
+  code = initExprSupp(pSup, pExprInfo, numOfExprs, &pTaskInfo->storageAPI.functionStore);
-  if (code != TSDB_CODE_SUCCESS) {
+  QUERY_CHECK_CODE(code, lino, _error);
-    goto _error;
-  }
 
   if (pInterpPhyNode->pExprs != NULL) {
     int32_t    num = 0;
     SExprInfo* pScalarExprInfo = createExprInfo(pInterpPhyNode->pExprs, NULL, &num);
     code = initExprSupp(&pInfo->scalarSup, pScalarExprInfo, num, &pTaskInfo->storageAPI.functionStore);
-    if (code != TSDB_CODE_SUCCESS) {
+    QUERY_CHECK_CODE(code, lino, _error);
-      goto _error;
-    }
   }
 
   code = filterInitFromNode((SNode*)pInterpPhyNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
-  if (code != TSDB_CODE_SUCCESS) {
+  QUERY_CHECK_CODE(code, lino, _error);
-    goto _error;
-  }
 
   pInfo->tsCol = extractColumnFromColumnNode((SColumnNode*)pInterpPhyNode->pTimeSeries);
-  extractPkColumnFromFuncs(pInterpPhyNode->pFuncs, &pInfo->hasPk, &pInfo->pkCol);
+  code = extractPkColumnFromFuncs(pInterpPhyNode->pFuncs, &pInfo->hasPk, &pInfo->pkCol);
+  QUERY_CHECK_CODE(code, lino, _error);
+
   pInfo->fillType = convertFillType(pInterpPhyNode->fillMode);
   initResultSizeInfo(&pOperator->resultInfo, 4096);
 
@@ -1080,17 +1166,22 @@ SOperatorInfo* createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode
 
   setOperatorInfo(pOperator, "TimeSliceOperator", QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC, false, OP_NOT_OPENED, pInfo,
                   pTaskInfo);
-  pOperator->fpSet =
+  pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTimeslice, NULL, destroyTimeSliceOperatorInfo,
-      createOperatorFpSet(optrDummyOpenFn, doTimeslice, NULL, destroyTimeSliceOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
+                                         optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
 
-  blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
+  code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
+  QUERY_CHECK_CODE(code, lino, _error);
 
-//  int32_t code = initKeeperInfo(pSliceInfo, pBlock, &pOperator->exprSupp);
+  //  int32_t code = initKeeperInfo(pSliceInfo, pBlock, &pOperator->exprSupp);
 
   code = appendDownstream(pOperator, &downstream, 1);
+  QUERY_CHECK_CODE(code, lino, _error);
   return pOperator;
 
 _error:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+  }
   taosMemoryFree(pInfo);
   taosMemoryFree(pOperator);
   pTaskInfo->code = TSDB_CODE_OUT_OF_MEMORY;

source/libs/executor/src/timewindowoperator.c

@@ -62,10 +62,10 @@ typedef struct SOpenWindowInfo {
   uint64_t           groupId;
 } SOpenWindowInfo;
 
-static int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo);
+static int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo, SExecTaskInfo* pTaskInfo);
 
 static SResultRowPosition addToOpenWindowList(SResultRowInfo* pResultRowInfo, const SResultRow* pResult,
-                                              uint64_t groupId);
+                                              uint64_t groupId, SExecTaskInfo* pTaskInfo);
 static void doCloseWindow(SResultRowInfo* pResultRowInfo, const SIntervalAggOperatorInfo* pInfo, SResultRow* pResult);
 
 static int32_t setTimeWindowOutputBuf(SResultRowInfo* pResultRowInfo, STimeWindow* win, bool masterscan,
@@ -707,7 +707,7 @@ static bool hashIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResul
 
   int32_t     startPos = 0;
   int32_t     numOfOutput = pSup->numOfExprs;
-  int64_t*    tsCols = extractTsCol(pBlock, pInfo);
+  int64_t*    tsCols = extractTsCol(pBlock, pInfo, pTaskInfo);
   uint64_t    tableGroupId = pBlock->info.id.groupId;
   bool        ascScan = (pInfo->binfo.inputTsOrder == TSDB_ORDER_ASC);
   TSKEY       ts = getStartTsKey(&pBlock->info.window, tsCols);
@@ -740,7 +740,7 @@ static bool hashIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResul
 
   // prev time window not interpolation yet.
   if (pInfo->timeWindowInterpo) {
-    SResultRowPosition pos = addToOpenWindowList(pResultRowInfo, pResult, tableGroupId);
+    SResultRowPosition pos = addToOpenWindowList(pResultRowInfo, pResult, tableGroupId, pTaskInfo);
     doInterpUnclosedTimeWindow(pOperatorInfo, numOfOutput, pResultRowInfo, pBlock, scanFlag, tsCols, &pos);
 
     // restore current time window
@@ -811,26 +811,36 @@ void doCloseWindow(SResultRowInfo* pResultRowInfo, const SIntervalAggOperatorInf
   }
 }
 
-SResultRowPosition addToOpenWindowList(SResultRowInfo* pResultRowInfo, const SResultRow* pResult, uint64_t groupId) {
+SResultRowPosition addToOpenWindowList(SResultRowInfo* pResultRowInfo, const SResultRow* pResult, uint64_t groupId, SExecTaskInfo* pTaskInfo) {
+    int32_t        code = TSDB_CODE_SUCCESS;
+  int32_t        lino = 0;
   SOpenWindowInfo openWin = {0};
   openWin.pos.pageId = pResult->pageId;
   openWin.pos.offset = pResult->offset;
   openWin.groupId = groupId;
   SListNode* pn = tdListGetTail(pResultRowInfo->openWindow);
   if (pn == NULL) {
-    tdListAppend(pResultRowInfo->openWindow, &openWin);
+    code = tdListAppend(pResultRowInfo->openWindow, &openWin);
+    QUERY_CHECK_CODE(code, lino, _end);
     return openWin.pos;
   }
 
   SOpenWindowInfo* px = (SOpenWindowInfo*)pn->data;
   if (px->pos.pageId != openWin.pos.pageId || px->pos.offset != openWin.pos.offset || px->groupId != openWin.groupId) {
-    tdListAppend(pResultRowInfo->openWindow, &openWin);
+    code = tdListAppend(pResultRowInfo->openWindow, &openWin);
+    QUERY_CHECK_CODE(code, lino, _end);
   }
 
+_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 openWin.pos;
 }
 
-int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo) {
+int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo, SExecTaskInfo* pTaskInfo) {
   TSKEY* tsCols = NULL;
 
   if (pBlock->pDataBlock != NULL && pBlock->info.dataLoad) {
@@ -844,7 +854,12 @@ int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo
     }
 
     if (tsCols[0] != 0 && (pBlock->info.window.skey == 0 && pBlock->info.window.ekey == 0)) {
-      blockDataUpdateTsWindow(pBlock, pInfo->primaryTsIndex);
+      int32_t code = blockDataUpdateTsWindow(pBlock, pInfo->primaryTsIndex);
+      if (code != TSDB_CODE_SUCCESS) {
+        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+        pTaskInfo->code = code;
+        T_LONG_JMP(pTaskInfo->env, code);
+      }
     }
   }
 
@@ -856,6 +871,8 @@ static int32_t doOpenIntervalAgg(SOperatorInfo* pOperator) {
     return TSDB_CODE_SUCCESS;
   }
 
+  int32_t        code = TSDB_CODE_SUCCESS;
+  int32_t        lino = 0;
   SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
   SOperatorInfo* downstream = pOperator->pDownstream[0];
 
@@ -875,11 +892,13 @@ static int32_t doOpenIntervalAgg(SOperatorInfo* pOperator) {
 
     if (pInfo->scalarSupp.pExprInfo != NULL) {
       SExprSupp* pExprSup = &pInfo->scalarSupp;
-      projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL);
+      code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL);
+      QUERY_CHECK_CODE(code, lino, _end);
     }
 
     // the pDataBlock are always the same one, no need to call this again
-    setInputDataBlock(pSup, pBlock, pInfo->binfo.inputTsOrder, scanFlag, true);
+    code = setInputDataBlock(pSup, pBlock, pInfo->binfo.inputTsOrder, scanFlag, true);
+    QUERY_CHECK_CODE(code, lino, _end);
     if (hashIntervalAgg(pOperator, &pInfo->binfo.resultRowInfo, pBlock, scanFlag)) break;
   }
 
@@ -887,7 +906,14 @@ static int32_t doOpenIntervalAgg(SOperatorInfo* pOperator) {
   OPTR_SET_OPENED(pOperator);
 
   pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0;
-  return TSDB_CODE_SUCCESS;
+
+_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 code;
 }
 
 static void doStateWindowAggImpl(SOperatorInfo* pOperator, SStateWindowOperatorInfo* pInfo, SSDataBlock* pBlock) {
@@ -979,6 +1005,8 @@ static int32_t openStateWindowAggOptr(SOperatorInfo* pOperator) {
     return TSDB_CODE_SUCCESS;
   }
 
+  int32_t                   code = TSDB_CODE_SUCCESS;
+  int32_t                   lino = 0;
   SStateWindowOperatorInfo* pInfo = pOperator->info;
   SExecTaskInfo*            pTaskInfo = pOperator->pTaskInfo;
 
@@ -994,8 +1022,11 @@ static int32_t openStateWindowAggOptr(SOperatorInfo* pOperator) {
     }
 
     pInfo->binfo.pRes->info.scanFlag = pBlock->info.scanFlag;
-    setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true);
+    code = setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true);
-    blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId);
+    QUERY_CHECK_CODE(code, lino, _end);
+
+    code = blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId);
+    QUERY_CHECK_CODE(code, lino, _end);
 
     // there is an scalar expression that needs to be calculated right before apply the group aggregation.
     if (pInfo->scalarSup.pExprInfo != NULL) {
@@ -1013,7 +1044,13 @@ static int32_t openStateWindowAggOptr(SOperatorInfo* pOperator) {
   initGroupedResultInfo(&pInfo->groupResInfo, pInfo->aggSup.pResultRowHashTable, TSDB_ORDER_ASC);
   pOperator->status = OP_RES_TO_RETURN;
 
-  return TSDB_CODE_SUCCESS;
+_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 code;
 }
 
 static SSDataBlock* doStateWindowAgg(SOperatorInfo* pOperator) {
@@ -1031,10 +1068,21 @@ static SSDataBlock* doStateWindowAgg(SOperatorInfo* pOperator) {
     return NULL;
   }
 
-  blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity);
+  int32_t code = blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity);
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
+  }
+
   while (1) {
     doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf);
-    doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+    code = doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+    if (code != TSDB_CODE_SUCCESS) {
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+      pTaskInfo->code = code;
+      T_LONG_JMP(pTaskInfo->env, code);
+    }
 
     bool hasRemain = hasRemainResults(&pInfo->groupResInfo);
     if (!hasRemain) {
@@ -1067,7 +1115,12 @@ static SSDataBlock* doBuildIntervalResult(SOperatorInfo* pOperator) {
 
   while (1) {
     doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf);
-    doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL);
+    int32_t code = doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL);
+    if (code != TSDB_CODE_SUCCESS) {
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+      pTaskInfo->code = code;
+      T_LONG_JMP(pTaskInfo->env, code);
+    }
 
     bool hasRemain = hasRemainResults(&pInfo->groupResInfo);
     if (!hasRemain) {
@@ -1086,37 +1139,6 @@ static SSDataBlock* doBuildIntervalResult(SOperatorInfo* pOperator) {
   return (rows == 0) ? NULL : pBlock;
 }
 
-static int32_t doClearWindowImpl(SResultRowPosition* p1, SDiskbasedBuf* pResultBuf, SExprSupp* pSup, int32_t numOfOutput) {
-  SResultRow* pResult = getResultRowByPos(pResultBuf, p1, false);
-  if (NULL == pResult) {
-    return TSDB_CODE_SUCCESS;
-  }
-
-  int32_t code = TSDB_CODE_SUCCESS;
-  SqlFunctionCtx* pCtx = pSup->pCtx;
-  for (int32_t i = 0; i < numOfOutput; ++i) {
-    pCtx[i].resultInfo = getResultEntryInfo(pResult, i, pSup->rowEntryInfoOffset);
-    struct SResultRowEntryInfo* pResInfo = pCtx[i].resultInfo;
-    if (fmIsWindowPseudoColumnFunc(pCtx[i].functionId)) {
-      continue;
-    }
-    pResInfo->initialized = false;
-    if (pCtx[i].functionId != -1) {
-      code = pCtx[i].fpSet.init(&pCtx[i], pResInfo);
-      if (TSDB_CODE_SUCCESS != code) {
-        return code;
-      }
-    }
-  }
-  SFilePage* bufPage = getBufPage(pResultBuf, p1->pageId);
-  if (NULL == bufPage) {
-    return TSDB_CODE_SUCCESS;
-  }
-  setBufPageDirty(bufPage, true);
-  releaseBufPage(pResultBuf, bufPage);
-  return TSDB_CODE_SUCCESS;
-}
-
 static void destroyStateWindowOperatorInfo(void* param) {
   SStateWindowOperatorInfo* pInfo = (SStateWindowOperatorInfo*)param;
   cleanupBasicInfo(&pInfo->binfo);
@@ -1140,7 +1162,7 @@ void destroyIntervalOperatorInfo(void* param) {
   cleanupAggSup(&pInfo->aggSup);
   cleanupExprSupp(&pInfo->scalarSupp);
 
-  tdListFree(pInfo->binfo.resultRowInfo.openWindow);
+  (void)tdListFree(pInfo->binfo.resultRowInfo.openWindow);
 
   taosArrayDestroy(pInfo->pInterpCols);
   pInfo->pInterpCols = NULL;
@@ -1153,9 +1175,13 @@ void destroyIntervalOperatorInfo(void* param) {
   taosMemoryFreeClear(param);
 }
 
-static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SIntervalAggOperatorInfo* pInfo) {
+static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SIntervalAggOperatorInfo* pInfo,
+                                   SExecTaskInfo* pTaskInfo) {
   // the primary timestamp column
   bool    needed = false;
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
+  void*   tmp = NULL;
 
   for (int32_t i = 0; i < numOfCols; ++i) {
     SExprInfo* pExpr = pCtx[i].pExpr;
@@ -1167,7 +1193,10 @@ static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SInt
 
   if (needed) {
     pInfo->pInterpCols = taosArrayInit(4, sizeof(SColumn));
+    QUERY_CHECK_NULL(pInfo->pInterpCols, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
     pInfo->pPrevValues = taosArrayInit(4, sizeof(SGroupKeys));
+    QUERY_CHECK_NULL(pInfo->pPrevValues, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
 
     {  // ts column
       SColumn c = {0};
@@ -1175,14 +1204,18 @@ static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SInt
       c.slotId = pInfo->primaryTsIndex;
       c.type = TSDB_DATA_TYPE_TIMESTAMP;
       c.bytes = sizeof(int64_t);
-      taosArrayPush(pInfo->pInterpCols, &c);
+      tmp = taosArrayPush(pInfo->pInterpCols, &c);
+      QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
 
       SGroupKeys key;
       key.bytes = c.bytes;
       key.type = c.type;
       key.isNull = true;  // to denote no value is assigned yet
       key.pData = taosMemoryCalloc(1, c.bytes);
-      taosArrayPush(pInfo->pPrevValues, &key);
+      QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
+      tmp = taosArrayPush(pInfo->pPrevValues, &key);
+      QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
     }
   }
 
@@ -1193,17 +1226,27 @@ static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SInt
       SFunctParam* pParam = &pExpr->base.pParam[0];
 
       SColumn c = *pParam->pCol;
-      taosArrayPush(pInfo->pInterpCols, &c);
+      tmp = taosArrayPush(pInfo->pInterpCols, &c);
+      QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
 
       SGroupKeys key = {0};
       key.bytes = c.bytes;
       key.type = c.type;
       key.isNull = false;
       key.pData = taosMemoryCalloc(1, c.bytes);
-      taosArrayPush(pInfo->pPrevValues, &key);
+      QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
+
+      tmp = taosArrayPush(pInfo->pPrevValues, &key);
+      QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY);
     }
   }
 
+_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 needed;
 }
 
@@ -1227,15 +1270,14 @@ SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPh
 
   size_t keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES;
   initResultSizeInfo(&pOperator->resultInfo, 512);
-  blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
+  code = blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity);
+  QUERY_CHECK_CODE(code, lino, _error);
 
   int32_t    num = 0;
   SExprInfo* pExprInfo = createExprInfo(pPhyNode->window.pFuncs, NULL, &num);
   code = initAggSup(pSup, &pInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str, pTaskInfo->streamInfo.pState,
                     &pTaskInfo->storageAPI.functionStore);
-  if (code != TSDB_CODE_SUCCESS) {
+  QUERY_CHECK_CODE(code, lino, _error);
-    goto _error;
-  }
 
   SInterval interval = {.interval = pPhyNode->interval,
                         .sliding = pPhyNode->sliding,
@@ -1284,7 +1326,7 @@ SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPh
 
   code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pInfo->win);
   QUERY_CHECK_CODE(code, lino, _error);
-  pInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, pInfo);
+  pInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, pInfo, pTaskInfo);
   if (pInfo->timeWindowInterpo) {
     pInfo->binfo.resultRowInfo.openWindow = tdListNew(sizeof(SOpenWindowInfo));
     if (pInfo->binfo.resultRowInfo.openWindow == NULL) {
@@ -1392,6 +1434,9 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) {
     return NULL;
   }
 
+  int32_t                  code = TSDB_CODE_SUCCESS;
+  int32_t                  lino = 0;
+  SExecTaskInfo*           pTaskInfo = pOperator->pTaskInfo;
   SSessionAggOperatorInfo* pInfo = pOperator->info;
   SOptrBasicInfo*          pBInfo = &pInfo->binfo;
   SExprSupp*               pSup = &pOperator->exprSupp;
@@ -1399,7 +1444,8 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) {
   if (pOperator->status == OP_RES_TO_RETURN) {
     while (1) {
       doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf);
-      doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+      code = doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+      QUERY_CHECK_CODE(code, lino, _end);
 
       bool hasRemain = hasRemainResults(&pInfo->groupResInfo);
       if (!hasRemain) {
@@ -1429,11 +1475,15 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) {
     pBInfo->pRes->info.scanFlag = pBlock->info.scanFlag;
     if (pInfo->scalarSupp.pExprInfo != NULL) {
       SExprSupp* pExprSup = &pInfo->scalarSupp;
-      projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL);
+      code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL);
+      QUERY_CHECK_CODE(code, lino, _end);
     }
     // the pDataBlock are always the same one, no need to call this again
-    setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true);
+    code = setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true);
-    blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId);
+    QUERY_CHECK_CODE(code, lino, _end);
+
+    code = blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId);
+    QUERY_CHECK_CODE(code, lino, _end);
 
     doSessionWindowAggImpl(pOperator, pInfo, pBlock);
   }
@@ -1444,10 +1494,12 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) {
   pOperator->status = OP_RES_TO_RETURN;
 
   initGroupedResultInfo(&pInfo->groupResInfo, pInfo->aggSup.pResultRowHashTable, TSDB_ORDER_ASC);
-  blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity);
+  code = blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity);
+  QUERY_CHECK_CODE(code, lino, _end);
   while (1) {
     doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf);
-    doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+    code = doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
+    QUERY_CHECK_CODE(code, lino, _end);
 
     bool hasRemain = hasRemainResults(&pInfo->groupResInfo);
     if (!hasRemain) {
@@ -1460,6 +1512,13 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) {
     }
   }
   pOperator->resultInfo.totalRows += pBInfo->pRes->info.rows;
+
+_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 (pBInfo->pRes->info.rows == 0) ? NULL : pBInfo->pRes;
 }
 
@@ -1678,7 +1737,7 @@ static void doMergeAlignedIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultR
   SInterval*     pInterval = &iaInfo->interval;
 
   int32_t  startPos = 0;
-  int64_t* tsCols = extractTsCol(pBlock, iaInfo);
+  int64_t* tsCols = extractTsCol(pBlock, iaInfo, pTaskInfo);
 
   TSKEY ts = getStartTsKey(&pBlock->info.window, tsCols);
 
@@ -1743,7 +1802,8 @@ static void cleanupAfterGroupResultGen(SMergeAlignedIntervalAggOperatorInfo* pMi
 
 static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) {
   SExecTaskInfo*                        pTaskInfo = pOperator->pTaskInfo;
-
+  int32_t                               code = TSDB_CODE_SUCCESS;
+  int32_t                               lino = 0;
   SMergeAlignedIntervalAggOperatorInfo* pMiaInfo = pOperator->info;
   SIntervalAggOperatorInfo*             pIaInfo = pMiaInfo->intervalAggOperatorInfo;
 
@@ -1770,7 +1830,8 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) {
         finalizeResultRows(pIaInfo->aggSup.pResultBuf, &pResultRowInfo->cur, pSup, pRes, pTaskInfo);
         resetResultRow(pMiaInfo->pResultRow, pIaInfo->aggSup.resultRowSize - sizeof(SResultRow));
         cleanupAfterGroupResultGen(pMiaInfo, pRes);
-        doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL);
+        code = doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL);
+        QUERY_CHECK_CODE(code, lino, _end);
       }
 
       setOperatorCompleted(pOperator);
@@ -1791,7 +1852,8 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) {
 
         pMiaInfo->prefetchedBlock = pBlock;
         cleanupAfterGroupResultGen(pMiaInfo, pRes);
-        doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL);
+        code = doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL);
+        QUERY_CHECK_CODE(code, lino, _end);
         break;
       } else {
         // continue
@@ -1800,14 +1862,25 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) {
     }
 
     pRes->info.scanFlag = pBlock->info.scanFlag;
-    setInputDataBlock(pSup, pBlock, pIaInfo->binfo.inputTsOrder, pBlock->info.scanFlag, true);
+    code = setInputDataBlock(pSup, pBlock, pIaInfo->binfo.inputTsOrder, pBlock->info.scanFlag, true);
+    QUERY_CHECK_CODE(code, lino, _end);
+
     doMergeAlignedIntervalAggImpl(pOperator, &pIaInfo->binfo.resultRowInfo, pBlock, pRes);
 
-    doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL);
+    code = doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL);
+    QUERY_CHECK_CODE(code, lino, _end);
+
     if (pRes->info.rows >= pOperator->resultInfo.capacity) {
       break;
     }
   }
+
+_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);
+  }
 }
 
 static SSDataBlock* mergeAlignedIntervalAgg(SOperatorInfo* pOperator) {
@@ -1870,9 +1943,7 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream,
   pSup->hasWindowOrGroup = true;
 
   code = filterInitFromNode((SNode*)pNode->window.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
-  if (code != TSDB_CODE_SUCCESS) {
+  QUERY_CHECK_CODE(code, lino, _error);
-    goto _error;
-  }
 
   miaInfo->curTs = INT64_MIN;
   iaInfo->win = pTaskInfo->window;
@@ -1890,22 +1961,21 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream,
 
   code = initAggSup(&pOperator->exprSupp, &iaInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str,
                     pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore);
-  if (code != TSDB_CODE_SUCCESS) {
+  QUERY_CHECK_CODE(code, lino, _error);
-    goto _error;
-  }
 
   SSDataBlock* pResBlock = createDataBlockFromDescNode(pNode->window.node.pOutputDataBlockDesc);
   initBasicInfo(&iaInfo->binfo, pResBlock);
   code = initExecTimeWindowInfo(&iaInfo->twAggSup.timeWindowData, &iaInfo->win);
   QUERY_CHECK_CODE(code, lino, _error);
 
-  iaInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, iaInfo);
+  iaInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, iaInfo, pTaskInfo);
   if (iaInfo->timeWindowInterpo) {
     iaInfo->binfo.resultRowInfo.openWindow = tdListNew(sizeof(SOpenWindowInfo));
   }
 
   initResultRowInfo(&iaInfo->binfo.resultRowInfo);
-  blockDataEnsureCapacity(iaInfo->binfo.pRes, pOperator->resultInfo.capacity);
+  code = blockDataEnsureCapacity(iaInfo->binfo.pRes, pOperator->resultInfo.capacity);
+  QUERY_CHECK_CODE(code, lino, _error);
   setOperatorInfo(pOperator, "TimeMergeAlignedIntervalAggOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL,
                   false, OP_NOT_OPENED, miaInfo, pTaskInfo);
 
@@ -1913,9 +1983,7 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream,
                                          optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL);
 
   code = appendDownstream(pOperator, &downstream, 1);
-  if (code != TSDB_CODE_SUCCESS) {
+  QUERY_CHECK_CODE(code, lino, _error);
-    goto _error;
-  }
 
   return pOperator;
 
@@ -1945,7 +2013,7 @@ typedef struct SGroupTimeWindow {
 
 void destroyMergeIntervalOperatorInfo(void* param) {
   SMergeIntervalAggOperatorInfo* miaInfo = (SMergeIntervalAggOperatorInfo*)param;
-  tdListFree(miaInfo->groupIntervals);
+  (void)tdListFree(miaInfo->groupIntervals);
   destroyIntervalOperatorInfo(&miaInfo->intervalAggOperatorInfo);
 
   taosMemoryFreeClear(param);
@@ -1958,7 +2026,11 @@ static int32_t outputPrevIntervalResult(SOperatorInfo* pOperatorInfo, uint64_t t
   bool                           ascScan = (iaInfo->binfo.inputTsOrder == TSDB_ORDER_ASC);
 
   SGroupTimeWindow groupTimeWindow = {.groupId = tableGroupId, .window = *newWin};
-  tdListAppend(miaInfo->groupIntervals, &groupTimeWindow);
+  int32_t          code = tdListAppend(miaInfo->groupIntervals, &groupTimeWindow);
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+    return code;
+  }
 
   SListIter iter = {0};
   tdListInitIter(miaInfo->groupIntervals, &iter, TD_LIST_FORWARD);
@@ -1971,11 +2043,11 @@ static int32_t outputPrevIntervalResult(SOperatorInfo* pOperatorInfo, uint64_t t
 
     STimeWindow* prevWin = &prevGrpWin->window;
     if ((ascScan && newWin->skey > prevWin->ekey) || ((!ascScan) && newWin->skey < prevWin->ekey)) {
-      tdListPopNode(miaInfo->groupIntervals, listNode);
+      (void)tdListPopNode(miaInfo->groupIntervals, listNode);
     }
   }
 
-  return 0;
+  return TSDB_CODE_SUCCESS;
 }
 
 static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResultRowInfo, SSDataBlock* pBlock,
@@ -1988,7 +2060,7 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo*
 
   int32_t     startPos = 0;
   int32_t     numOfOutput = pExprSup->numOfExprs;
-  int64_t*    tsCols = extractTsCol(pBlock, iaInfo);
+  int64_t*    tsCols = extractTsCol(pBlock, iaInfo, pTaskInfo);
   uint64_t    tableGroupId = pBlock->info.id.groupId;
   bool        ascScan = (iaInfo->binfo.inputTsOrder == TSDB_ORDER_ASC);
   TSKEY       blockStartTs = getStartTsKey(&pBlock->info.window, tsCols);
@@ -2011,7 +2083,7 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo*
 
   // prev time window not interpolation yet.
   if (iaInfo->timeWindowInterpo) {
-    SResultRowPosition pos = addToOpenWindowList(pResultRowInfo, pResult, tableGroupId);
+    SResultRowPosition pos = addToOpenWindowList(pResultRowInfo, pResult, tableGroupId, pTaskInfo);
     doInterpUnclosedTimeWindow(pOperatorInfo, numOfOutput, pResultRowInfo, pBlock, scanFlag, tsCols, &pos);
 
     // restore current time window
@@ -2031,7 +2103,11 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo*
   doCloseWindow(pResultRowInfo, iaInfo, pResult);
 
   // output previous interval results after this interval (&win) is closed
-  outputPrevIntervalResult(pOperatorInfo, tableGroupId, pResultBlock, &win);
+  int32_t code = outputPrevIntervalResult(pOperatorInfo, tableGroupId, pResultBlock, &win);
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+    T_LONG_JMP(pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY);
+  }
 
   STimeWindow nextWin = win;
   while (1) {
@@ -2043,7 +2119,7 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo*
     }
 
     // null data, failed to allocate more memory buffer
-    int32_t code =
+    code =
         setTimeWindowOutputBuf(pResultRowInfo, &nextWin, (scanFlag == MAIN_SCAN), &pResult, tableGroupId,
                                pExprSup->pCtx, numOfOutput, pExprSup->rowEntryInfoOffset, &iaInfo->aggSup, pTaskInfo);
     if (code != TSDB_CODE_SUCCESS || pResult == NULL) {
@@ -2063,7 +2139,11 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo*
     doCloseWindow(pResultRowInfo, iaInfo, pResult);
 
     // output previous interval results after this interval (&nextWin) is closed
-    outputPrevIntervalResult(pOperatorInfo, tableGroupId, pResultBlock, &nextWin);
+    code = outputPrevIntervalResult(pOperatorInfo, tableGroupId, pResultBlock, &nextWin);
+    if (code != TSDB_CODE_SUCCESS) {
+      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+      T_LONG_JMP(pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY);
+    }
   }
 
   if (iaInfo->timeWindowInterpo) {
@@ -2072,6 +2152,8 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo*
 }
 
 static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) {
+  int32_t        code = TSDB_CODE_SUCCESS;
+  int32_t        lino = 0;
   SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
 
   SMergeIntervalAggOperatorInfo* miaInfo = pOperator->info;
@@ -2084,7 +2166,8 @@ static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) {
 
   SSDataBlock* pRes = iaInfo->binfo.pRes;
   blockDataCleanup(pRes);
-  blockDataEnsureCapacity(pRes, pOperator->resultInfo.capacity);
+  code = blockDataEnsureCapacity(pRes, pOperator->resultInfo.capacity);
+  QUERY_CHECK_CODE(code, lino, _end);
 
   if (!miaInfo->inputBlocksFinished) {
     SOperatorInfo* downstream = pOperator->pDownstream[0];
@@ -2113,7 +2196,9 @@ static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) {
       }
 
       pRes->info.scanFlag = pBlock->info.scanFlag;
-      setInputDataBlock(pExpSupp, pBlock, iaInfo->binfo.inputTsOrder, pBlock->info.scanFlag, true);
+      code = setInputDataBlock(pExpSupp, pBlock, iaInfo->binfo.inputTsOrder, pBlock->info.scanFlag, true);
+      QUERY_CHECK_CODE(code, lino, _end);
+
       doMergeIntervalAggImpl(pOperator, &iaInfo->binfo.resultRowInfo, pBlock, pBlock->info.scanFlag, pRes);
 
       if (pRes->info.rows >= pOperator->resultInfo.threshold) {
@@ -2139,6 +2224,13 @@ static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) {
 
   size_t rows = pRes->info.rows;
   pOperator->resultInfo.totalRows += rows;
+
+_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 (rows == 0) ? NULL : pRes;
 }
 
@@ -2189,7 +2281,7 @@ SOperatorInfo* createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SMerge
   code = initExecTimeWindowInfo(&pIntervalInfo->twAggSup.timeWindowData, &pIntervalInfo->win);
   QUERY_CHECK_CODE(code, lino, _error);
 
-  pIntervalInfo->timeWindowInterpo = timeWindowinterpNeeded(pExprSupp->pCtx, num, pIntervalInfo);
+  pIntervalInfo->timeWindowInterpo = timeWindowinterpNeeded(pExprSupp->pCtx, num, pIntervalInfo, pTaskInfo);
   if (pIntervalInfo->timeWindowInterpo) {
     pIntervalInfo->binfo.resultRowInfo.openWindow = tdListNew(sizeof(SOpenWindowInfo));
     if (pIntervalInfo->binfo.resultRowInfo.openWindow == NULL) {

source/libs/executor/test/timewindowTest.cpp

@@ -52,7 +52,7 @@ void printTimeWindow(STimeWindow* pWindow, int8_t precision, int64_t ts) {
   taosFormatUtcTime(bufs, tListLen(bufs), pWindow->skey, precision);
   taosFormatUtcTime(bufe, tListLen(bufe), pWindow->ekey, precision);
 
-  printf("%s [%s - %s]\n", buf, bufs, bufe);
+  (void)printf("%s [%s - %s]\n", buf, bufs, bufe);
 }
 }  // namespace
 
@@ -71,26 +71,26 @@ TEST(testCase, timewindow_gen) {
   printTimeWindow(&w, precision, key);
 
   getNextTimeWindow(&interval, &w, TSDB_ORDER_ASC);
-  printf("next\n");
+  (void)printf("next\n");
   printTimeWindow(&w, precision, key);
 
-  printf("---------------------------------------------------\n");
+  (void)printf("---------------------------------------------------\n");
   SInterval monthInterval =
       createInterval(1, 1, 0, 'n', 'n', 'd', TSDB_TIME_PRECISION_MILLI);
   getInitialStartTimeWindow(&monthInterval, key, &w, true);
   printTimeWindow(&w, precision, key);
 
   getNextTimeWindow(&monthInterval, &w, TSDB_ORDER_ASC);
-  printf("next\n");
+  (void)printf("next\n");
   printTimeWindow(&w, precision, key);
 
-  printf("----------------------------------------------------------\n");
+  (void)printf("----------------------------------------------------------\n");
   SInterval slidingInterval = createInterval(1, 10*86400*1000, 0, 'n', 'd', 'd', TSDB_TIME_PRECISION_MILLI);
   getInitialStartTimeWindow(&slidingInterval, key, &w, true);
   printTimeWindow(&w, precision, key);
 
   getNextTimeWindow(&slidingInterval, &w, TSDB_ORDER_ASC);
-  printf("next\n");
+  (void)printf("next\n");
   printTimeWindow(&w, precision, key);
 
   getNextTimeWindow(&slidingInterval, &w, TSDB_ORDER_ASC);
@@ -114,13 +114,13 @@ TEST(testCase, timewindow_gen) {
   getNextTimeWindow(&slidingInterval, &w, TSDB_ORDER_ASC);
   printTimeWindow(&w, precision, key);
 
-  printf("-----------------calendar_interval_1n_sliding_1d-------\n");
+  (void)printf("-----------------calendar_interval_1n_sliding_1d-------\n");
   SInterval calendar_interval_1n = createInterval(1, 1*86400*1000, 0, 'n', 'd', 'd', TSDB_TIME_PRECISION_MILLI);
   int64_t k1 = 1664409600 * 1000L;
   getInitialStartTimeWindow(&calendar_interval_1n, k1, &w, true);
   printTimeWindow(&w, precision, k1);
 
-  printf("next\n");
+  (void)printf("next\n");
 
   getNextTimeWindow(&calendar_interval_1n, &w, TSDB_ORDER_ASC);
   printTimeWindow(&w, precision, key);
@@ -134,14 +134,14 @@ TEST(testCase, timewindow_gen) {
   getNextTimeWindow(&calendar_interval_1n, &w, TSDB_ORDER_ASC);
   printTimeWindow(&w, precision, key);
 
-  printf("----------------interval_1d_clendar_sliding_1n---------\n");
+  (void)printf("----------------interval_1d_clendar_sliding_1n---------\n");
   SInterval interval_1d_calendar_sliding_1n = createInterval(1*86400*1000L, 1, 0, 'd', 'n', 'd', TSDB_TIME_PRECISION_MILLI);
 
   k1 = 1664409600 * 1000L;
   getInitialStartTimeWindow(&interval_1d_calendar_sliding_1n, k1, &w, true);
   printTimeWindow(&w, precision, k1);
 
-  printf("next time window:\n");
+  (void)printf("next time window:\n");
   getNextTimeWindow(&interval_1d_calendar_sliding_1n, &w, TSDB_ORDER_ASC);
   printTimeWindow(&w, precision, k1);
 
@@ -151,7 +151,7 @@ TEST(testCase, timewindow_gen) {
   getNextTimeWindow(&interval_1d_calendar_sliding_1n, &w, TSDB_ORDER_ASC);
   printTimeWindow(&w, precision, k1);
 
-  printf("----------------interval_1d_sliding_1d_calendar_offset_1n---------\n");
+  (void)printf("----------------interval_1d_sliding_1d_calendar_offset_1n---------\n");
   SInterval offset_1n = createInterval(10*86400*1000L, 10*86400*1000L, 1, 'd', 'd', 'n', TSDB_TIME_PRECISION_MILLI);
     getInitialStartTimeWindow(&offset_1n, k1, &w, true);
     printTimeWindow(&w, precision, k1);
@@ -175,14 +175,14 @@ TEST(testCase, timewindow_natural) {
   getInitialStartTimeWindow(&interval2, key1, &w1, true);
   printTimeWindow(&w1, precision, key1);
   STimeWindow w3 = getAlignQueryTimeWindow(&interval2, key1);
-  printf("%ld win %ld, %ld\n", key1, w3.skey, w3.ekey);  
+  (void)printf("%ld win %ld, %ld\n", key1, w3.skey, w3.ekey);  
 
   int64_t key2 = 1648758398208;
   STimeWindow w2 = {0};
   getInitialStartTimeWindow(&interval2, key2, &w2, true);
   printTimeWindow(&w2, precision, key2);
   STimeWindow w4 = getAlignQueryTimeWindow(&interval2, key2);
-  printf("%ld win %ld, %ld\n", key2, w3.skey, w3.ekey);
+  (void)printf("%ld win %ld, %ld\n", key2, w3.skey, w3.ekey);
 
   ASSERT_EQ(w3.skey, w4.skey);
   ASSERT_EQ(w3.ekey, w4.ekey);  
@@ -199,7 +199,7 @@ TEST(testCase, timewindow_active) {
   int64_t key = (int64_t)1609430400*1000; // 2021-01-01
   STimeWindow win = getActiveTimeWindow(NULL, &dumyInfo, key, &interval, TSDB_ORDER_ASC);
   printTimeWindow(&win, precision, key);
-  printf("%ld win %ld, %ld\n", key, win.skey, win.ekey);
+  (void)printf("%ld win %ld, %ld\n", key, win.skey, win.ekey);
   ASSERT_EQ(win.skey, 1325376000000);
   ASSERT_EQ(win.ekey, 1640908799999);
 }