diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index e9cde9e99b..0629e8ee37 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -4041,7 +4041,9 @@ static FORCE_INLINE void* tDecodeSMqAskEpRsp(void* buf, SMqAskEpRsp* pRsp) {
   for (int32_t i = 0; i < sz; i++) {
     SMqSubTopicEp topicEp;
     buf = tDecodeMqSubTopicEp(buf, &topicEp);
-    taosArrayPush(pRsp->topics, &topicEp);
+    if (taosArrayPush(pRsp->topics, &topicEp) == NULL) {
+      return NULL;
+    }
   }
   return buf;
 }
diff --git a/include/common/ttime.h b/include/common/ttime.h
index 2d40bd93a6..cec5b15761 100644
--- a/include/common/ttime.h
+++ b/include/common/ttime.h
@@ -117,7 +117,7 @@ int32_t taosTs2Char(const char* format, SArray** formats, int64_t ts, int32_t pr
 int32_t taosChar2Ts(const char* format, SArray** formats, const char* tsStr, int64_t* ts, int32_t precision, char* errMsg,
                     int32_t errMsgLen);
 
-void    TEST_ts2char(const char* format, int64_t ts, int32_t precision, char* out, int32_t outLen);
+int32_t TEST_ts2char(const char* format, int64_t ts, int32_t precision, char* out, int32_t outLen);
 int32_t TEST_char2ts(const char* format, int64_t* ts, int32_t precision, const char* tsStr);
 
 /// @brief get offset seconds from zero timezone to input timezone
diff --git a/include/util/tRealloc.h b/include/util/tRealloc.h
index 3229c53039..b830fac284 100644
--- a/include/util/tRealloc.h
+++ b/include/util/tRealloc.h
@@ -41,7 +41,7 @@ static FORCE_INLINE int32_t tRealloc(uint8_t **ppBuf, int64_t size) {
 
   pBuf = (uint8_t *)taosMemoryRealloc(pBuf, bsize + sizeof(int64_t));
   if (pBuf == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _exit;
   }
 
diff --git a/include/util/tarray2.h b/include/util/tarray2.h
index 2e9b0c7cb5..0d1ceded6c 100644
--- a/include/util/tarray2.h
+++ b/include/util/tarray2.h
@@ -55,7 +55,7 @@ static FORCE_INLINE int32_t tarray2_make_room(void *arr, int32_t expSize, int32_
     capacity <<= 1;
   }
   void *p = taosMemoryRealloc(a->data, capacity * eleSize);
-  if (p == NULL) return TSDB_CODE_OUT_OF_MEMORY;
+  if (p == NULL) return terrno;
   a->capacity = capacity;
   a->data = p;
   return 0;
diff --git a/include/util/tconfig.h b/include/util/tconfig.h
index 8373e00085..f109153384 100644
--- a/include/util/tconfig.h
+++ b/include/util/tconfig.h
@@ -101,7 +101,7 @@ typedef struct {
 typedef struct SConfig SConfig;
 typedef struct SConfigIter SConfigIter;
 
-SConfig     *cfgInit();
+int32_t      cfgInit(SConfig **ppCfg);
 int32_t      cfgLoad(SConfig *pCfg, ECfgSrcType cfgType, const void *sourceStr);
 int32_t      cfgLoadFromArray(SConfig *pCfg, SArray *pArgs);  // SConfigPair
 void         cfgCleanup(SConfig *pCfg);
@@ -110,7 +110,7 @@ SConfigItem *cfgGetItem(SConfig *pCfg, const char *pName);
 int32_t      cfgSetItem(SConfig *pCfg, const char *name, const char *value, ECfgSrcType stype, bool lock);
 int32_t      cfgCheckRangeForDynUpdate(SConfig *pCfg, const char *name, const char *pVal, bool isServer);
 
-SConfigIter *cfgCreateIter(SConfig *pConf);
+int32_t      cfgCreateIter(SConfig *pConf, SConfigIter **ppIter);
 SConfigItem *cfgNextIter(SConfigIter *pIter);
 void         cfgDestroyIter(SConfigIter *pIter);
 void         cfgLock(SConfig *pCfg);
@@ -131,8 +131,8 @@ int32_t cfgAddTimezone(SConfig *pCfg, const char *name, const char *defaultVal,
 const char *cfgStypeStr(ECfgSrcType type);
 const char *cfgDtypeStr(ECfgDataType type);
 
-void cfgDumpItemValue(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen);
-void cfgDumpItemScope(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen);
+int32_t cfgDumpItemValue(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen);
+int32_t cfgDumpItemScope(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen);
 
 void cfgDumpCfg(SConfig *pCfg, bool tsc, bool dump);
 void cfgDumpCfgS3(SConfig *pCfg, bool tsc, bool dump);
diff --git a/include/util/tutil.h b/include/util/tutil.h
index 5af79dfc49..a41f7d5860 100644
--- a/include/util/tutil.h
+++ b/include/util/tutil.h
@@ -152,9 +152,9 @@ static FORCE_INLINE int32_t taosGetTbHashVal(const char *tbname, int32_t tblen,
 
 #define TCONTAINER_OF(ptr, type, member) ((type *)((char *)(ptr)-offsetof(type, member)))
 
-#define TAOS_RETURN(code)     \
+#define TAOS_RETURN(CODE)     \
   do {                        \
-    return (terrno = (code)); \
+    return (terrno = (CODE)); \
   } while (0)
 
 #define TAOS_CHECK_RETURN(CMD)       \
diff --git a/source/client/inc/clientInt.h b/source/client/inc/clientInt.h
index 7c342b85d4..507738acc9 100644
--- a/source/client/inc/clientInt.h
+++ b/source/client/inc/clientInt.h
@@ -332,8 +332,7 @@ static FORCE_INLINE SReqResultInfo* tmqGetCurResInfo(TAOS_RES* res) {
   return (SReqResultInfo*)&msg->common.resInfo;
 }
 
-SReqResultInfo* tmqGetNextResInfo(TAOS_RES* res, bool convertUcs4);
-
+int32_t tmqGetNextResInfo(TAOS_RES* res, bool convertUcs4, SReqResultInfo** pResInfo);
 static FORCE_INLINE SReqResultInfo* tscGetCurResInfo(TAOS_RES* res) {
   if (TD_RES_QUERY(res)) return &(((SRequestObj*)res)->body.resInfo);
   return tmqGetCurResInfo(res);
diff --git a/source/client/src/clientMain.c b/source/client/src/clientMain.c
index 35e0b61114..0618e233a0 100644
--- a/source/client/src/clientMain.c
+++ b/source/client/src/clientMain.c
@@ -426,9 +426,11 @@ TAOS_ROW taos_fetch_row(TAOS_RES *res) {
     return doAsyncFetchRows(pRequest, true, true);
   } else if (TD_RES_TMQ(res) || TD_RES_TMQ_METADATA(res)) {
     SMqRspObj      *msg = ((SMqRspObj *)res);
-    SReqResultInfo *pResultInfo;
+    SReqResultInfo *pResultInfo = NULL;
     if (msg->common.resIter == -1) {
-      pResultInfo = tmqGetNextResInfo(res, true);
+      if(tmqGetNextResInfo(res, true, &pResultInfo) != 0){
+        return NULL;
+      }
     } else {
       pResultInfo = tmqGetCurResInfo(res);
     }
@@ -438,8 +440,7 @@ TAOS_ROW taos_fetch_row(TAOS_RES *res) {
       pResultInfo->current += 1;
       return pResultInfo->row;
     } else {
-      pResultInfo = tmqGetNextResInfo(res, true);
-      if (pResultInfo == NULL) {
+      if (tmqGetNextResInfo(res, true, &pResultInfo) != 0){
         return NULL;
       }
 
@@ -754,8 +755,9 @@ int taos_fetch_block_s(TAOS_RES *res, int *numOfRows, TAOS_ROW *rows) {
     (*numOfRows) = pResultInfo->numOfRows;
     return pRequest->code;
   } else if (TD_RES_TMQ(res) || TD_RES_TMQ_METADATA(res)) {
-    SReqResultInfo *pResultInfo = tmqGetNextResInfo(res, true);
-    if (pResultInfo == NULL) return -1;
+    SReqResultInfo *pResultInfo = NULL;
+    int32_t code = tmqGetNextResInfo(res, true, &pResultInfo);
+    if (code != 0) return code;
 
     pResultInfo->current = pResultInfo->numOfRows;
     (*rows) = pResultInfo->row;
@@ -776,8 +778,9 @@ int taos_fetch_raw_block(TAOS_RES *res, int *numOfRows, void **pData) {
   }
 
   if (TD_RES_TMQ(res) || TD_RES_TMQ_METADATA(res)) {
-    SReqResultInfo *pResultInfo = tmqGetNextResInfo(res, false);
-    if (pResultInfo == NULL) {
+    SReqResultInfo *pResultInfo = NULL;
+    int32_t code = tmqGetNextResInfo(res, false, &pResultInfo);
+    if (code != 0) {
       (*numOfRows) = 0;
       return 0;
     }
diff --git a/source/client/src/clientTmq.c b/source/client/src/clientTmq.c
index 09fbed4ba4..650d262870 100644
--- a/source/client/src/clientTmq.c
+++ b/source/client/src/clientTmq.c
@@ -112,7 +112,7 @@ struct tmq_t {
 
 typedef struct SAskEpInfo {
   int32_t code;
-  tsem_t  sem;
+  tsem2_t  sem;
 } SAskEpInfo;
 
 enum {
@@ -125,6 +125,7 @@ enum {
   TMQ_CONSUMER_STATUS__READY,
   TMQ_CONSUMER_STATUS__NO_TOPIC,
   TMQ_CONSUMER_STATUS__RECOVER,
+  TMQ_CONSUMER_STATUS__CLOSED,
 };
 
 enum {
@@ -181,9 +182,7 @@ typedef struct {
 } SMqPollRspWrapper;
 
 typedef struct {
-  //  int64_t refId;
-  //  int32_t epoch;
-  tsem_t  rspSem;
+  tsem2_t  rspSem;
   int32_t rspErr;
 } SMqSubscribeCbParam;
 
@@ -201,7 +200,7 @@ typedef struct {
 } SMqPollCbParam;
 
 typedef struct SMqVgCommon {
-  tsem_t        rsp;
+  tsem2_t       rsp;
   int32_t       numOfRsp;
   SArray*       pList;
   TdThreadMutex mutex;
@@ -211,12 +210,12 @@ typedef struct SMqVgCommon {
 } SMqVgCommon;
 
 typedef struct SMqSeekParam {
-  tsem_t  sem;
+  tsem2_t  sem;
   int32_t code;
 } SMqSeekParam;
 
 typedef struct SMqCommittedParam {
-  tsem_t      sem;
+  tsem2_t      sem;
   int32_t     code;
   SMqVgOffset vgOffset;
 } SMqCommittedParam;
@@ -234,36 +233,31 @@ typedef struct {
   int32_t        waitingRspNum;
   int32_t        code;
   tmq_commit_cb* callbackFn;
-  /*SArray*        successfulOffsets;*/
-  /*SArray*        failedOffsets;*/
   void* userParam;
 } SMqCommitCbParamSet;
 
 typedef struct {
   SMqCommitCbParamSet* params;
-  //  SMqVgOffset*         pOffset;
   char    topicName[TSDB_TOPIC_FNAME_LEN];
   int32_t vgId;
   tmq_t*  pTmq;
 } SMqCommitCbParam;
 
 typedef struct SSyncCommitInfo {
-  tsem_t  sem;
+  tsem2_t  sem;
   int32_t code;
 } SSyncCommitInfo;
 
 static int32_t syncAskEp(tmq_t* tmq);
-static int32_t makeTopicVgroupKey(char* dst, const char* topicName, int32_t vg);
 static int32_t tmqCommitDone(SMqCommitCbParamSet* pParamSet);
 static int32_t doSendCommitMsg(tmq_t* tmq, int32_t vgId, SEpSet* epSet, STqOffsetVal* offset, const char* pTopicName,
                                SMqCommitCbParamSet* pParamSet);
-static void    commitRspCountDown(SMqCommitCbParamSet* pParamSet, int64_t consumerId, const char* pTopic, int32_t vgId);
+static int32_t commitRspCountDown(SMqCommitCbParamSet* pParamSet, int64_t consumerId, const char* pTopic, int32_t vgId);
 static int32_t askEp(tmq_t* pTmq, void* param, bool sync, bool updateEpset);
 
 tmq_conf_t* tmq_conf_new() {
   tmq_conf_t* conf = taosMemoryCalloc(1, sizeof(tmq_conf_t));
   if (conf == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
     return conf;
   }
 
@@ -445,8 +439,7 @@ static int32_t tmqCommitCb(void* param, SDataBuf* pBuf, int32_t code) {
   taosMemoryFree(pBuf->pData);
   taosMemoryFree(pBuf->pEpSet);
 
-  commitRspCountDown(pParamSet, pParam->pTmq->consumerId, pParam->topicName, pParam->vgId);
-  return 0;
+  return commitRspCountDown(pParamSet, pParam->pTmq->consumerId, pParam->topicName, pParam->vgId);
 }
 
 static int32_t doSendCommitMsg(tmq_t* tmq, int32_t vgId, SEpSet* epSet, STqOffsetVal* offset, const char* pTopicName,
@@ -455,7 +448,6 @@ static int32_t doSendCommitMsg(tmq_t* tmq, int32_t vgId, SEpSet* epSet, STqOffse
 
   pOffset.consumerId = tmq->consumerId;
   pOffset.offset.val = *offset;
-
   (void)snprintf(pOffset.offset.subKey, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", tmq->groupId, TMQ_SEPARATOR, pTopicName);
   int32_t len = 0;
   int32_t code = 0;
@@ -475,7 +467,11 @@ static int32_t doSendCommitMsg(tmq_t* tmq, int32_t vgId, SEpSet* epSet, STqOffse
 
   SEncoder encoder;
   tEncoderInit(&encoder, abuf, len);
-  tEncodeMqVgOffset(&encoder, &pOffset);
+  if(tEncodeMqVgOffset(&encoder, &pOffset) < 0) {
+    tEncoderClear(&encoder);
+    taosMemoryFree(buf);
+    return TSDB_CODE_INVALID_PARA;
+  }
   tEncoderClear(&encoder);
 
   // build param
@@ -486,7 +482,6 @@ static int32_t doSendCommitMsg(tmq_t* tmq, int32_t vgId, SEpSet* epSet, STqOffse
   }
 
   pParam->params = pParamSet;
-  //  pParam->pOffset = pOffset;
   pParam->vgId = vgId;
   pParam->pTmq = tmq;
 
@@ -510,35 +505,35 @@ static int32_t doSendCommitMsg(tmq_t* tmq, int32_t vgId, SEpSet* epSet, STqOffse
   pMsgSendInfo->msgType = TDMT_VND_TMQ_COMMIT_OFFSET;
 
   int64_t transporterId = 0;
-  atomic_add_fetch_32(&pParamSet->waitingRspNum, 1);
+  (void)atomic_add_fetch_32(&pParamSet->waitingRspNum, 1);
   code = asyncSendMsgToServer(tmq->pTscObj->pAppInfo->pTransporter, epSet, &transporterId, pMsgSendInfo);
   if (code != 0) {
-    atomic_sub_fetch_32(&pParamSet->waitingRspNum, 1);
+    (void)atomic_sub_fetch_32(&pParamSet->waitingRspNum, 1);
     return code;
   }
   return code;
 }
 
-static SMqClientTopic* getTopicByName(tmq_t* tmq, const char* pTopicName) {
+static int32_t getTopicByName(tmq_t* tmq, const char* pTopicName, SMqClientTopic **topic) {
   int32_t numOfTopics = taosArrayGetSize(tmq->clientTopics);
   for (int32_t i = 0; i < numOfTopics; ++i) {
     SMqClientTopic* pTopic = taosArrayGet(tmq->clientTopics, i);
-    if (strcmp(pTopic->topicName, pTopicName) != 0) {
+    if (pTopic == NULL || strcmp(pTopic->topicName, pTopicName) != 0) {
       continue;
     }
-
-    return pTopic;
+    *topic = pTopic;
+    return 0;
   }
 
   tscError("consumer:0x%" PRIx64 ", total:%d, failed to find topic:%s", tmq->consumerId, numOfTopics, pTopicName);
-  return NULL;
+  return TSDB_CODE_TMQ_INVALID_TOPIC;
 }
 
-static SMqCommitCbParamSet* prepareCommitCbParamSet(tmq_t* tmq, tmq_commit_cb* pCommitFp, void* userParam,
-                                                    int32_t rspNum) {
+static int32_t prepareCommitCbParamSet(tmq_t* tmq, tmq_commit_cb* pCommitFp, void* userParam,
+                                       int32_t rspNum, SMqCommitCbParamSet** ppParamSet) {
   SMqCommitCbParamSet* pParamSet = taosMemoryCalloc(1, sizeof(SMqCommitCbParamSet));
   if (pParamSet == NULL) {
-    return NULL;
+    return TSDB_CODE_OUT_OF_MEMORY;
   }
 
   pParamSet->refId = tmq->refId;
@@ -546,21 +541,22 @@ static SMqCommitCbParamSet* prepareCommitCbParamSet(tmq_t* tmq, tmq_commit_cb* p
   pParamSet->callbackFn = pCommitFp;
   pParamSet->userParam = userParam;
   pParamSet->waitingRspNum = rspNum;
-
-  return pParamSet;
+  *ppParamSet = pParamSet;
+  return 0;
 }
 
 static int32_t getClientVg(tmq_t* tmq, char* pTopicName, int32_t vgId, SMqClientVg** pVg) {
-  SMqClientTopic* pTopic = getTopicByName(tmq, pTopicName);
-  if (pTopic == NULL) {
+  SMqClientTopic* pTopic = NULL;
+  int32_t code = getTopicByName(tmq, pTopicName, &pTopic);
+  if (code != 0) {
     tscError("consumer:0x%" PRIx64 " invalid topic name:%s", tmq->consumerId, pTopicName);
-    return TSDB_CODE_TMQ_INVALID_TOPIC;
+    return code;
   }
 
   int32_t numOfVgs = taosArrayGetSize(pTopic->vgs);
   for (int32_t i = 0; i < numOfVgs; ++i) {
     SMqClientVg* pClientVg = taosArrayGet(pTopic->vgs, i);
-    if (pClientVg->vgId == vgId) {
+    if (pClientVg && pClientVg->vgId == vgId) {
       *pVg = pClientVg;
       break;
     }
@@ -587,16 +583,23 @@ static int32_t asyncCommitOffset(tmq_t* tmq, char* pTopicName, int32_t vgId, STq
     goto end;
   }
   char offsetBuf[TSDB_OFFSET_LEN] = {0};
-  tFormatOffset(offsetBuf, tListLen(offsetBuf), offsetVal);
-
-  char commitBuf[TSDB_OFFSET_LEN] = {0};
-  tFormatOffset(commitBuf, tListLen(commitBuf), &pVg->offsetInfo.committedOffset);
-
-  SMqCommitCbParamSet* pParamSet = prepareCommitCbParamSet(tmq, pCommitFp, userParam, 0);
-  if (pParamSet == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+  code = tFormatOffset(offsetBuf, tListLen(offsetBuf), offsetVal);
+  if (code != 0) {
     goto end;
   }
+
+  char commitBuf[TSDB_OFFSET_LEN] = {0};
+  code = tFormatOffset(commitBuf, tListLen(commitBuf), &pVg->offsetInfo.committedOffset);
+  if (code != 0) {
+    goto end;
+  }
+
+  SMqCommitCbParamSet* pParamSet = NULL;
+  code = prepareCommitCbParamSet(tmq, pCommitFp, userParam, 0, &pParamSet);
+  if (code != 0) {
+    goto end;
+  }
+
   code = doSendCommitMsg(tmq, pVg->vgId, &pVg->epSet, offsetVal, pTopicName, pParamSet);
   if (code != TSDB_CODE_SUCCESS) {
     tscError("consumer:0x%" PRIx64 " topic:%s on vgId:%d end commit msg failed, send offset:%s committed:%s, code:%s",
@@ -662,32 +665,39 @@ end:
 static void asyncCommitAllOffsets(tmq_t* tmq, tmq_commit_cb* pCommitFp, void* userParam) {
   int32_t code = 0;
   // init as 1 to prevent concurrency issue
-  SMqCommitCbParamSet* pParamSet = prepareCommitCbParamSet(tmq, pCommitFp, userParam, 1);
-  if (pParamSet == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+  SMqCommitCbParamSet* pParamSet = NULL;
+  code = prepareCommitCbParamSet(tmq, pCommitFp, userParam, 1, &pParamSet);
+  if (code != 0) {
     goto end;
   }
-
   taosRLockLatch(&tmq->lock);
   int32_t numOfTopics = taosArrayGetSize(tmq->clientTopics);
   tscDebug("consumer:0x%" PRIx64 " start to commit offset for %d topics", tmq->consumerId, numOfTopics);
 
   for (int32_t i = 0; i < numOfTopics; i++) {
     SMqClientTopic* pTopic = taosArrayGet(tmq->clientTopics, i);
+    if (pTopic == NULL) {
+      code = TSDB_CODE_TMQ_INVALID_TOPIC;
+      taosRUnLockLatch(&tmq->lock);
+      goto end;
+    }
     int32_t         numOfVgroups = taosArrayGetSize(pTopic->vgs);
-
     tscDebug("consumer:0x%" PRIx64 " commit offset for topics:%s, numOfVgs:%d", tmq->consumerId, pTopic->topicName,
              numOfVgroups);
     for (int32_t j = 0; j < numOfVgroups; j++) {
       SMqClientVg* pVg = taosArrayGet(pTopic->vgs, j);
-
+      if (pVg == NULL) {
+        code = TSDB_CODE_INVALID_PARA;
+        taosRUnLockLatch(&tmq->lock);
+        goto end;
+      }
       if (pVg->offsetInfo.endOffset.type > 0 &&
           !tOffsetEqual(&pVg->offsetInfo.endOffset, &pVg->offsetInfo.committedOffset)) {
         char offsetBuf[TSDB_OFFSET_LEN] = {0};
-        tFormatOffset(offsetBuf, tListLen(offsetBuf), &pVg->offsetInfo.endOffset);
+        (void)tFormatOffset(offsetBuf, tListLen(offsetBuf), &pVg->offsetInfo.endOffset);
 
         char commitBuf[TSDB_OFFSET_LEN] = {0};
-        tFormatOffset(commitBuf, tListLen(commitBuf), &pVg->offsetInfo.committedOffset);
+        (void)tFormatOffset(commitBuf, tListLen(commitBuf), &pVg->offsetInfo.committedOffset);
 
         code = doSendCommitMsg(tmq, pVg->vgId, &pVg->epSet, &pVg->offsetInfo.endOffset, pTopic->topicName, pParamSet);
         if (code != TSDB_CODE_SUCCESS) {
@@ -716,7 +726,12 @@ static void asyncCommitAllOffsets(tmq_t* tmq, tmq_commit_cb* pCommitFp, void* us
   // request is sent
   if (pParamSet->waitingRspNum != 1) {
     // count down since waiting rsp num init as 1
-    commitRspCountDown(pParamSet, tmq->consumerId, "", 0);
+    code = commitRspCountDown(pParamSet, tmq->consumerId, "", 0);
+    if (code != 0){
+      tscError("consumer:0x%" PRIx64 " commit rsp count down failed, code:%s", tmq->consumerId, tstrerror(code));
+      pParamSet = NULL;
+      goto end;
+    }
     return;
   }
 
@@ -729,9 +744,9 @@ end:
 }
 
 static void generateTimedTask(int64_t refId, int32_t type) {
-  tmq_t*  tmq;
-  int8_t* pTaskType;
-  int32_t code;
+  tmq_t*  tmq = NULL;
+  int8_t* pTaskType = NULL;
+  int32_t code = 0;
 
   tmq = taosAcquireRef(tmqMgmt.rsetId, refId);
   if (tmq == NULL) return;
@@ -740,11 +755,11 @@ static void generateTimedTask(int64_t refId, int32_t type) {
   if (code == TSDB_CODE_SUCCESS) {
     *pTaskType = type;
     if (taosWriteQitem(tmq->delayedTask, pTaskType) == 0) {
-      tsem2_post(&tmq->rspSem);
+      (void)tsem2_post(&tmq->rspSem);
     }
   }
 
-  taosReleaseRef(tmqMgmt.rsetId, refId);
+  (void)taosReleaseRef(tmqMgmt.rsetId, refId);
 }
 
 void tmqAssignAskEpTask(void* param, void* tmrId) {
@@ -757,8 +772,8 @@ void tmqReplayTask(void* param, void* tmrId) {
   tmq_t*  tmq = taosAcquireRef(tmqMgmt.rsetId, refId);
   if (tmq == NULL) return;
 
-  tsem2_post(&tmq->rspSem);
-  taosReleaseRef(tmqMgmt.rsetId, refId);
+  (void)tsem2_post(&tmq->rspSem);
+  (void)taosReleaseRef(tmqMgmt.rsetId, refId);
 }
 
 void tmqAssignDelayedCommitTask(void* param, void* tmrId) {
@@ -767,23 +782,29 @@ void tmqAssignDelayedCommitTask(void* param, void* tmrId) {
 }
 
 int32_t tmqHbCb(void* param, SDataBuf* pMsg, int32_t code) {
-  if (pMsg == NULL) {
+  if (code != 0){
     return code;
   }
+  if (pMsg == NULL || param == NULL) {
+    return TSDB_CODE_INVALID_PARA;
+  }
   SMqHbRsp rsp = {0};
-  tDeserializeSMqHbRsp(pMsg->pData, pMsg->len, &rsp);
+  code = tDeserializeSMqHbRsp(pMsg->pData, pMsg->len, &rsp);
+  if (code != 0) {
+    return code;
+  }
 
-  int64_t refId = *(int64_t*)param;
+  int64_t refId = (int64_t)param;
   tmq_t*  tmq = taosAcquireRef(tmqMgmt.rsetId, refId);
   if (tmq != NULL) {
     taosWLockLatch(&tmq->lock);
     for (int32_t i = 0; i < taosArrayGetSize(rsp.topicPrivileges); i++) {
       STopicPrivilege* privilege = taosArrayGet(rsp.topicPrivileges, i);
-      if (privilege->noPrivilege == 1) {
+      if (privilege && privilege->noPrivilege == 1) {
         int32_t topicNumCur = taosArrayGetSize(tmq->clientTopics);
         for (int32_t j = 0; j < topicNumCur; j++) {
           SMqClientTopic* pTopicCur = taosArrayGet(tmq->clientTopics, j);
-          if (strcmp(pTopicCur->topicName, privilege->topic) == 0) {
+          if (pTopicCur && strcmp(pTopicCur->topicName, privilege->topic) == 0) {
             tscInfo("consumer:0x%" PRIx64 ", has no privilege, topic:%s", tmq->consumerId, privilege->topic);
             pTopicCur->noPrivilege = 1;
           }
@@ -791,7 +812,7 @@ int32_t tmqHbCb(void* param, SDataBuf* pMsg, int32_t code) {
       }
     }
     taosWUnLockLatch(&tmq->lock);
-    taosReleaseRef(tmqMgmt.rsetId, refId);
+    (void)taosReleaseRef(tmqMgmt.rsetId, refId);
   }
   tDestroySMqHbRsp(&rsp);
   taosMemoryFree(pMsg->pData);
@@ -810,23 +831,41 @@ void tmqSendHbReq(void* param, void* tmrId) {
   SMqHbReq req = {0};
   req.consumerId = tmq->consumerId;
   req.epoch = tmq->epoch;
-  taosRLockLatch(&tmq->lock);
   req.topics = taosArrayInit(taosArrayGetSize(tmq->clientTopics), sizeof(TopicOffsetRows));
+  if (req.topics == NULL){
+    return;
+  }
+  taosRLockLatch(&tmq->lock);
   for (int i = 0; i < taosArrayGetSize(tmq->clientTopics); i++) {
     SMqClientTopic*  pTopic = taosArrayGet(tmq->clientTopics, i);
+    if (pTopic == NULL) {
+      continue;
+    }
     int32_t          numOfVgroups = taosArrayGetSize(pTopic->vgs);
     TopicOffsetRows* data = taosArrayReserve(req.topics, 1);
-    strcpy(data->topicName, pTopic->topicName);
+    if (data == NULL){
+      continue;
+    }
+    (void)strcpy(data->topicName, pTopic->topicName);
     data->offsetRows = taosArrayInit(numOfVgroups, sizeof(OffsetRows));
+    if (data->offsetRows == NULL){
+      continue;
+    }
     for (int j = 0; j < numOfVgroups; j++) {
       SMqClientVg* pVg = taosArrayGet(pTopic->vgs, j);
+      if (pVg == NULL){
+        continue;
+      }
       OffsetRows*  offRows = taosArrayReserve(data->offsetRows, 1);
+      if (offRows == NULL){
+        continue;
+      }
       offRows->vgId = pVg->vgId;
       offRows->rows = pVg->numOfRows;
       offRows->offset = pVg->offsetInfo.endOffset;
       offRows->ever = pVg->offsetInfo.walVerEnd == -1 ? 0 : pVg->offsetInfo.walVerEnd;
       char buf[TSDB_OFFSET_LEN] = {0};
-      tFormatOffset(buf, TSDB_OFFSET_LEN, &offRows->offset);
+      (void)tFormatOffset(buf, TSDB_OFFSET_LEN, &offRows->offset);
       tscDebug("consumer:0x%" PRIx64 ",report offset, group:%s vgId:%d, offset:%s/%" PRId64 ", rows:%" PRId64,
                tmq->consumerId, tmq->groupId, offRows->vgId, buf, offRows->ever, offRows->rows);
     }
@@ -861,9 +900,7 @@ void tmqSendHbReq(void* param, void* tmrId) {
 
   sendInfo->requestId = generateRequestId();
   sendInfo->requestObjRefId = 0;
-  sendInfo->paramFreeFp = taosMemoryFree;
-  sendInfo->param = taosMemoryMalloc(sizeof(int64_t));
-  *(int64_t*)sendInfo->param = refId;
+  sendInfo->param = (void*)refId;
   sendInfo->fp = tmqHbCb;
   sendInfo->msgType = TDMT_MND_TMQ_HB;
 
@@ -878,9 +915,9 @@ void tmqSendHbReq(void* param, void* tmrId) {
 OVER:
   tDestroySMqHbReq(&req);
   if (tmrId != NULL) {
-    taosTmrReset(tmqSendHbReq, DEFAULT_HEARTBEAT_INTERVAL, param, tmqMgmt.timer, &tmq->hbLiveTimer);
+    (void)taosTmrReset(tmqSendHbReq, DEFAULT_HEARTBEAT_INTERVAL, param, tmqMgmt.timer, &tmq->hbLiveTimer);
   }
-  taosReleaseRef(tmqMgmt.rsetId, refId);
+  (void)taosReleaseRef(tmqMgmt.rsetId, refId);
 }
 
 static void defaultCommitCbFn(tmq_t* pTmq, int32_t code, void* param) {
@@ -889,48 +926,53 @@ static void defaultCommitCbFn(tmq_t* pTmq, int32_t code, void* param) {
   }
 }
 
-int32_t tmqHandleAllDelayedTask(tmq_t* pTmq) {
-  STaosQall* qall;
-  int32_t    code;
+void tmqHandleAllDelayedTask(tmq_t* pTmq) {
+  STaosQall* qall = NULL;
+  int32_t    code = 0;
 
   code = taosAllocateQall(&qall);
-  if (code) return code;
+  if (code) {
+    tscError("consumer:0x%" PRIx64 ", failed to allocate qall, code:%s", pTmq->consumerId, tstrerror(code));
+    return;
+  }
 
-  taosReadAllQitems(pTmq->delayedTask, qall);
+  (void)taosReadAllQitems(pTmq->delayedTask, qall);
 
   int32_t numOfItems = taosQallItemSize(qall);
   if (numOfItems == 0) {
     taosFreeQall(qall);
-    return TSDB_CODE_SUCCESS;
+    return;
   }
 
   tscDebug("consumer:0x%" PRIx64 " handle delayed %d tasks before poll data", pTmq->consumerId, numOfItems);
   int8_t* pTaskType = NULL;
-  taosGetQitem(qall, (void**)&pTaskType);
+  (void)taosGetQitem(qall, (void**)&pTaskType);
 
   while (pTaskType != NULL) {
     if (*pTaskType == TMQ_DELAYED_TASK__ASK_EP) {
-      askEp(pTmq, NULL, false, false);
-
+      code = askEp(pTmq, NULL, false, false);
+      if (code != 0) {
+        tscError("consumer:0x%" PRIx64 " failed to ask ep, code:%s", pTmq->consumerId, tstrerror(code));
+        continue;
+      }
       tscDebug("consumer:0x%" PRIx64 " retrieve ep from mnode in 1s", pTmq->consumerId);
-      taosTmrReset(tmqAssignAskEpTask, DEFAULT_ASKEP_INTERVAL, (void*)(pTmq->refId), tmqMgmt.timer, &pTmq->epTimer);
+      (void)taosTmrReset(tmqAssignAskEpTask, DEFAULT_ASKEP_INTERVAL, (void*)(pTmq->refId), tmqMgmt.timer, &pTmq->epTimer);
     } else if (*pTaskType == TMQ_DELAYED_TASK__COMMIT) {
       tmq_commit_cb* pCallbackFn = pTmq->commitCb ? pTmq->commitCb : defaultCommitCbFn;
       asyncCommitAllOffsets(pTmq, pCallbackFn, pTmq->commitCbUserParam);
       tscDebug("consumer:0x%" PRIx64 " next commit to vnode(s) in %.2fs", pTmq->consumerId,
                pTmq->autoCommitInterval / 1000.0);
-      taosTmrReset(tmqAssignDelayedCommitTask, pTmq->autoCommitInterval, (void*)(pTmq->refId), tmqMgmt.timer,
+      (void)taosTmrReset(tmqAssignDelayedCommitTask, pTmq->autoCommitInterval, (void*)(pTmq->refId), tmqMgmt.timer,
                    &pTmq->commitTimer);
     } else {
       tscError("consumer:0x%" PRIx64 " invalid task type:%d", pTmq->consumerId, *pTaskType);
     }
 
     taosFreeQitem(pTaskType);
-    taosGetQitem(qall, (void**)&pTaskType);
+    (void)taosGetQitem(qall, (void**)&pTaskType);
   }
 
   taosFreeQall(qall);
-  return 0;
 }
 
 static void tmqFreeRspWrapper(SMqRspWrapper* rspWrapper) {
@@ -960,7 +1002,7 @@ static void tmqFreeRspWrapper(SMqRspWrapper* rspWrapper) {
 void tmqClearUnhandleMsg(tmq_t* tmq) {
   SMqRspWrapper* rspWrapper = NULL;
   while (1) {
-    taosGetQitem(tmq->qall, (void**)&rspWrapper);
+    (void)taosGetQitem(tmq->qall, (void**)&rspWrapper);
     if (rspWrapper) {
       tmqFreeRspWrapper(rspWrapper);
       taosFreeQitem(rspWrapper);
@@ -970,9 +1012,9 @@ void tmqClearUnhandleMsg(tmq_t* tmq) {
   }
 
   rspWrapper = NULL;
-  taosReadAllQitems(tmq->mqueue, tmq->qall);
+  (void)taosReadAllQitems(tmq->mqueue, tmq->qall);
   while (1) {
-    taosGetQitem(tmq->qall, (void**)&rspWrapper);
+    (void)taosGetQitem(tmq->qall, (void**)&rspWrapper);
     if (rspWrapper) {
       tmqFreeRspWrapper(rspWrapper);
       taosFreeQitem(rspWrapper);
@@ -993,7 +1035,7 @@ int32_t tmqSubscribeCb(void* param, SDataBuf* pMsg, int32_t code) {
   if (pMsg) {
     taosMemoryFree(pMsg->pEpSet);
   }
-  tsem_post(&pParam->rspSem);
+  (void)tsem2_post(&pParam->rspSem);
   return 0;
 }
 
@@ -1001,43 +1043,38 @@ int32_t tmq_subscription(tmq_t* tmq, tmq_list_t** topics) {
   if (tmq == NULL) return TSDB_CODE_INVALID_PARA;
   if (*topics == NULL) {
     *topics = tmq_list_new();
+    if (*topics == NULL) {
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
   }
   taosRLockLatch(&tmq->lock);
   for (int i = 0; i < taosArrayGetSize(tmq->clientTopics); i++) {
     SMqClientTopic* topic = taosArrayGet(tmq->clientTopics, i);
-    tmq_list_append(*topics, strchr(topic->topicName, '.') + 1);
+    if(topic == NULL) {
+      tscError("topic is null");
+      continue;
+    }
+    char* tmp = strchr(topic->topicName, '.');
+    if(tmp == NULL) {
+      tscError("topic name is invalid:%s", topic->topicName);
+      continue;
+    }
+    if(tmq_list_append(*topics,  tmp+ 1) != 0) {
+      tscError("failed to append topic:%s", tmp + 1);
+      continue;
+    }
   }
   taosRUnLockLatch(&tmq->lock);
   return 0;
 }
 
-int32_t tmq_unsubscribe(tmq_t* tmq) {
-  if (tmq == NULL) return TSDB_CODE_INVALID_PARA;
-  if (tmq->status != TMQ_CONSUMER_STATUS__READY) {
-    tscInfo("consumer:0x%" PRIx64 " not in ready state, unsubscribe it directly", tmq->consumerId);
-    return 0;
-  }
-  if (tmq->autoCommit) {
-    int32_t rsp = tmq_commit_sync(tmq, NULL);
-    if (rsp != 0) {
-      return rsp;
-    }
-  }
-  taosSsleep(2);  // sleep 2s for hb to send offset and rows to server
-
-  tmq_list_t* lst = tmq_list_new();
-  int32_t     rsp = tmq_subscribe(tmq, lst);
-  tmq_list_destroy(lst);
-  return rsp;
-}
-
 static void freeClientVg(void* param) {
   SMqClientVg* pVg = param;
   tOffsetDestroy(&pVg->offsetInfo.endOffset);
   tOffsetDestroy(&pVg->offsetInfo.beginOffset);
   tOffsetDestroy(&pVg->offsetInfo.committedOffset);
 }
-static void freeClientVgImpl(void* param) {
+static void freeClientTopic(void* param) {
   SMqClientTopic* pTopic = param;
   taosMemoryFreeClear(pTopic->schema.pSchema);
   taosArrayDestroyEx(pTopic->vgs, freeClientVg);
@@ -1047,7 +1084,6 @@ void tmqFreeImpl(void* handle) {
   tmq_t*  tmq = (tmq_t*)handle;
   int64_t id = tmq->consumerId;
 
-  // TODO stop timer
   if (tmq->mqueue) {
     tmqClearUnhandleMsg(tmq);
     taosCloseQueue(tmq->mqueue);
@@ -1058,19 +1094,19 @@ void tmqFreeImpl(void* handle) {
   }
 
   taosFreeQall(tmq->qall);
-  tsem2_destroy(&tmq->rspSem);
+  (void)tsem2_destroy(&tmq->rspSem);
 
-  taosArrayDestroyEx(tmq->clientTopics, freeClientVgImpl);
+  taosArrayDestroyEx(tmq->clientTopics, freeClientTopic);
   taos_close_internal(tmq->pTscObj);
 
   if (tmq->commitTimer) {
-    taosTmrStopA(&tmq->commitTimer);
+    (void)taosTmrStopA(&tmq->commitTimer);
   }
   if (tmq->epTimer) {
-    taosTmrStopA(&tmq->epTimer);
+    (void)taosTmrStopA(&tmq->epTimer);
   }
   if (tmq->hbLiveTimer) {
-    taosTmrStopA(&tmq->hbLiveTimer);
+    (void)taosTmrStopA(&tmq->hbLiveTimer);
   }
   taosMemoryFree(tmq);
 
@@ -1098,32 +1134,34 @@ void tmqMgmtClose(void) {
   }
 
   if (tmqMgmt.rsetId >= 0) {
-    taosCloseRef(tmqMgmt.rsetId);
+    (void)taosCloseRef(tmqMgmt.rsetId);
     tmqMgmt.rsetId = -1;
   }
 }
 
 #define SET_ERROR_MSG_TMQ(MSG) \
-  if (errstr != NULL) snprintf(errstr, errstrLen, MSG);
+  if (errstr != NULL) (void)snprintf(errstr, errstrLen, MSG);
 
 tmq_t* tmq_consumer_new(tmq_conf_t* conf, char* errstr, int32_t errstrLen) {
-  int32_t code;
+  int32_t code = 0;
 
   if (conf == NULL) {
     SET_ERROR_MSG_TMQ("configure is null")
     return NULL;
   }
-  taosThreadOnce(&tmqInit, tmqMgmtInit);
+  code = taosThreadOnce(&tmqInit, tmqMgmtInit);
+  if (code != 0) {
+    SET_ERROR_MSG_TMQ("tmq init error")
+    return NULL;
+  }
   if (tmqInitRes != 0) {
-    terrno = tmqInitRes;
     SET_ERROR_MSG_TMQ("tmq timer init error")
     return NULL;
   }
 
   tmq_t* pTmq = taosMemoryCalloc(1, sizeof(tmq_t));
   if (pTmq == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    tscError("failed to create consumer, groupId:%s, code:%s", conf->groupId, terrstr());
+    tscError("failed to create consumer, groupId:%s", conf->groupId);
     SET_ERROR_MSG_TMQ("malloc tmq failed")
     return NULL;
   }
@@ -1132,33 +1170,34 @@ tmq_t* tmq_consumer_new(tmq_conf_t* conf, char* errstr, int32_t errstrLen) {
   const char* pass = conf->pass == NULL ? TSDB_DEFAULT_PASS : conf->pass;
 
   pTmq->clientTopics = taosArrayInit(0, sizeof(SMqClientTopic));
+  if (pTmq->clientTopics == NULL) {
+    tscError("failed to create consumer, groupId:%s", conf->groupId);
+    SET_ERROR_MSG_TMQ("malloc client topics failed")
+    goto _failed;
+  }
   code = taosOpenQueue(&pTmq->mqueue);
   if (code) {
-    terrno = code;
-    tscError("consumer:0x%" PRIx64 " setup failed since %s, groupId:%s", pTmq->consumerId, terrstr(), pTmq->groupId);
+    tscError("consumer:0x%" PRIx64 " setup failed since %s, groupId:%s", pTmq->consumerId, tstrerror(code), pTmq->groupId);
     SET_ERROR_MSG_TMQ("open queue failed")
     goto _failed;
   }
 
   code = taosOpenQueue(&pTmq->delayedTask);
   if (code) {
-    terrno = code;
-    tscError("consumer:0x%" PRIx64 " setup failed since %s, groupId:%s", pTmq->consumerId, terrstr(), pTmq->groupId);
+    tscError("consumer:0x%" PRIx64 " setup failed since %s, groupId:%s", pTmq->consumerId, tstrerror(code), pTmq->groupId);
     SET_ERROR_MSG_TMQ("open delayed task queue failed")
     goto _failed;
   }
 
   code = taosAllocateQall(&pTmq->qall);
   if (code) {
-    terrno = code;
-    tscError("consumer:0x%" PRIx64 " setup failed since %s, groupId:%s", pTmq->consumerId, terrstr(), pTmq->groupId);
+    tscError("consumer:0x%" PRIx64 " setup failed since %s, groupId:%s", pTmq->consumerId, tstrerror(code), pTmq->groupId);
     SET_ERROR_MSG_TMQ("allocate qall failed")
     goto _failed;
   }
 
   if (conf->groupId[0] == 0) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    tscError("consumer:0x%" PRIx64 " setup failed since %s, groupId:%s", pTmq->consumerId, terrstr(), pTmq->groupId);
+    tscError("consumer:0x%" PRIx64 " setup failed since %s, groupId:%s", pTmq->consumerId, tstrerror(code), pTmq->groupId);
     SET_ERROR_MSG_TMQ("malloc tmq element failed or group is empty")
     goto _failed;
   }
@@ -1169,8 +1208,8 @@ tmq_t* tmq_consumer_new(tmq_conf_t* conf, char* errstr, int32_t errstrLen) {
   pTmq->epoch = 0;
 
   // set conf
-  strcpy(pTmq->clientId, conf->clientId);
-  strcpy(pTmq->groupId, conf->groupId);
+  (void)strcpy(pTmq->clientId, conf->clientId);
+  (void)strcpy(pTmq->groupId, conf->groupId);
   pTmq->withTbName = conf->withTbName;
   pTmq->useSnapshot = conf->snapEnable;
   pTmq->autoCommit = conf->autoCommit;
@@ -1201,7 +1240,7 @@ tmq_t* tmq_consumer_new(tmq_conf_t* conf, char* errstr, int32_t errstrLen) {
   pTmq->pTscObj = taos_connect_internal(conf->ip, user, pass, NULL, NULL, conf->port, CONN_TYPE__TMQ);
   if (pTmq->pTscObj == NULL) {
     tscError("consumer:0x%" PRIx64 " setup failed since %s, groupId:%s", pTmq->consumerId, terrstr(), pTmq->groupId);
-    tsem2_destroy(&pTmq->rspSem);
+    (void)tsem2_destroy(&pTmq->rspSem);
     SET_ERROR_MSG_TMQ("init tscObj failed")
     goto _failed;
   }
@@ -1213,10 +1252,13 @@ tmq_t* tmq_consumer_new(tmq_conf_t* conf, char* errstr, int32_t errstrLen) {
   }
 
   pTmq->hbLiveTimer = taosTmrStart(tmqSendHbReq, DEFAULT_HEARTBEAT_INTERVAL, (void*)pTmq->refId, tmqMgmt.timer);
-
+  if (pTmq->hbLiveTimer == NULL) {
+    SET_ERROR_MSG_TMQ("start heartbeat timer failed")
+    goto _failed;
+  }
   char         buf[TSDB_OFFSET_LEN] = {0};
   STqOffsetVal offset = {.type = pTmq->resetOffsetCfg};
-  tFormatOffset(buf, tListLen(buf), &offset);
+  (void)tFormatOffset(buf, tListLen(buf), &offset);
   tscInfo("consumer:0x%" PRIx64 " is setup, refId:%" PRId64
           ", groupId:%s, snapshot:%d, autoCommit:%d, commitInterval:%dms, offset:%s",
           pTmq->consumerId, pTmq->refId, pTmq->groupId, pTmq->useSnapshot, pTmq->autoCommit, pTmq->autoCommitInterval,
@@ -1244,8 +1286,8 @@ int32_t tmq_subscribe(tmq_t* tmq, const tmq_list_t* topic_list) {
   req.consumerId = tmq->consumerId;
   tstrncpy(req.clientId, tmq->clientId, 256);
   tstrncpy(req.cgroup, tmq->groupId, TSDB_CGROUP_LEN);
-  req.topicNames = taosArrayInit(sz, sizeof(void*));
 
+  req.topicNames = taosArrayInit(sz, sizeof(void*));
   if (req.topicNames == NULL) {
     code = TSDB_CODE_OUT_OF_MEMORY;
     goto FAIL;
@@ -1260,22 +1302,38 @@ int32_t tmq_subscribe(tmq_t* tmq, const tmq_list_t* topic_list) {
 
   for (int32_t i = 0; i < sz; i++) {
     char* topic = taosArrayGetP(container, i);
-
+    if (topic == NULL) {
+      code = TSDB_CODE_INVALID_PARA;
+      goto FAIL;
+    }
     SName name = {0};
-    tNameSetDbName(&name, tmq->pTscObj->acctId, topic, strlen(topic));
+    code = tNameSetDbName(&name, tmq->pTscObj->acctId, topic, strlen(topic));
+    if (code) {
+      tscError("consumer:0x%" PRIx64 " cgroup:%s, failed to set topic name, code:%d", tmq->consumerId, tmq->groupId, code);
+      goto FAIL;
+    }
     char* topicFName = taosMemoryCalloc(1, TSDB_TOPIC_FNAME_LEN);
     if (topicFName == NULL) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
       goto FAIL;
     }
 
-    tNameExtractFullName(&name, topicFName);
-    tscInfo("consumer:0x%" PRIx64 " subscribe topic:%s", tmq->consumerId, topicFName);
+    code = tNameExtractFullName(&name, topicFName);
+    if (code) {
+      tscError("consumer:0x%" PRIx64 " cgroup:%s, failed to extract topic name, code:%d", tmq->consumerId, tmq->groupId, code);
+      taosMemoryFree(topicFName);
+      goto FAIL;
+    }
 
-    taosArrayPush(req.topicNames, &topicFName);
+    if (taosArrayPush(req.topicNames, &topicFName) == NULL) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      taosMemoryFree(topicFName);
+      goto FAIL;
+    }
+    tscInfo("consumer:0x%" PRIx64 " subscribe topic:%s", tmq->consumerId, topicFName);
   }
 
   int32_t tlen = tSerializeSCMSubscribeReq(NULL, &req);
-
   buf = taosMemoryMalloc(tlen);
   if (buf == NULL) {
     code = TSDB_CODE_OUT_OF_MEMORY;
@@ -1283,7 +1341,7 @@ int32_t tmq_subscribe(tmq_t* tmq, const tmq_list_t* topic_list) {
   }
 
   void* abuf = buf;
-  tSerializeSCMSubscribeReq(&abuf, &req);
+  (void)tSerializeSCMSubscribeReq(&abuf, &req);
 
   sendInfo = taosMemoryCalloc(1, sizeof(SMsgSendInfo));
   if (sendInfo == NULL) {
@@ -1293,7 +1351,7 @@ int32_t tmq_subscribe(tmq_t* tmq, const tmq_list_t* topic_list) {
   }
 
   SMqSubscribeCbParam param = {.rspErr = 0};
-  if (tsem_init(&param.rspSem, 0, 0) != 0) {
+  if (tsem2_init(&param.rspSem, 0, 0) != 0) {
     code = TSDB_CODE_TSC_INTERNAL_ERROR;
     taosMemoryFree(buf);
     taosMemoryFree(sendInfo);
@@ -1301,7 +1359,6 @@ int32_t tmq_subscribe(tmq_t* tmq, const tmq_list_t* topic_list) {
   }
 
   sendInfo->msgInfo = (SDataBuf){.pData = buf, .len = tlen, .handle = NULL};
-
   sendInfo->requestId = generateRequestId();
   sendInfo->requestObjRefId = 0;
   sendInfo->param = &param;
@@ -1316,8 +1373,8 @@ int32_t tmq_subscribe(tmq_t* tmq, const tmq_list_t* topic_list) {
     goto FAIL;
   }
 
-  tsem_wait(&param.rspSem);
-  tsem_destroy(&param.rspSem);
+  (void)tsem2_wait(&param.rspSem);
+  (void)tsem2_destroy(&param.rspSem);
 
   if (param.rspErr != 0) {
     code = param.rspErr;
@@ -1339,11 +1396,12 @@ int32_t tmq_subscribe(tmq_t* tmq, const tmq_list_t* topic_list) {
     taosMsleep(500);
   }
 
-  // init ep timer
   tmq->epTimer = taosTmrStart(tmqAssignAskEpTask, DEFAULT_ASKEP_INTERVAL, (void*)(tmq->refId), tmqMgmt.timer);
-  // init auto commit timer
-  tmq->commitTimer =
-      taosTmrStart(tmqAssignDelayedCommitTask, tmq->autoCommitInterval, (void*)(tmq->refId), tmqMgmt.timer);
+  tmq->commitTimer =taosTmrStart(tmqAssignDelayedCommitTask, tmq->autoCommitInterval, (void*)(tmq->refId), tmqMgmt.timer);
+  if (tmq->epTimer == NULL || tmq->commitTimer == NULL) {
+    code = TSDB_CODE_TSC_INTERNAL_ERROR;
+    goto FAIL;
+  }
 
 FAIL:
   taosArrayDestroyP(req.topicNames, taosMemoryFree);
@@ -1357,21 +1415,21 @@ void tmq_conf_set_auto_commit_cb(tmq_conf_t* conf, tmq_commit_cb* cb, void* para
   conf->commitCbUserParam = param;
 }
 
-static SMqClientVg* getVgInfo(tmq_t* tmq, char* topicName, int32_t vgId) {
+static void getVgInfo(tmq_t* tmq, char* topicName, int32_t vgId, SMqClientVg** pVg) {
   int32_t topicNumCur = taosArrayGetSize(tmq->clientTopics);
   for (int i = 0; i < topicNumCur; i++) {
     SMqClientTopic* pTopicCur = taosArrayGet(tmq->clientTopics, i);
-    if (strcmp(pTopicCur->topicName, topicName) == 0) {
+    if (pTopicCur && strcmp(pTopicCur->topicName, topicName) == 0) {
       int32_t vgNumCur = taosArrayGetSize(pTopicCur->vgs);
       for (int32_t j = 0; j < vgNumCur; j++) {
         SMqClientVg* pVgCur = taosArrayGet(pTopicCur->vgs, j);
-        if (pVgCur->vgId == vgId) {
-          return pVgCur;
+        if (pVgCur && pVgCur->vgId == vgId) {
+          *pVg = pVgCur;
+          return;
         }
       }
     }
   }
-  return NULL;
 }
 
 static SMqClientTopic* getTopicInfo(tmq_t* tmq, char* topicName) {
@@ -1387,7 +1445,8 @@ static SMqClientTopic* getTopicInfo(tmq_t* tmq, char* topicName) {
 
 static void setVgIdle(tmq_t* tmq, char* topicName, int32_t vgId) {
   taosWLockLatch(&tmq->lock);
-  SMqClientVg* pVg = getVgInfo(tmq, topicName, vgId);
+  SMqClientVg* pVg = NULL;
+  getVgInfo(tmq, topicName, vgId, &pVg);
   if (pVg) {
     atomic_store_32(&pVg->vgStatus, TMQ_VG_STATUS__IDLE);
   }
@@ -1398,7 +1457,7 @@ int32_t tmqPollCb(void* param, SDataBuf* pMsg, int32_t code) {
   tmq_t*          tmq = NULL;
   SMqPollCbParam* pParam = (SMqPollCbParam*)param;
   if (pParam == NULL || pMsg == NULL) {
-    goto FAIL;
+    goto FAIL2;
   }
   int64_t  refId = pParam->refId;
   int32_t  vgId = pParam->vgId;
@@ -1406,15 +1465,14 @@ int32_t tmqPollCb(void* param, SDataBuf* pMsg, int32_t code) {
   tmq = taosAcquireRef(tmqMgmt.rsetId, refId);
   if (tmq == NULL) {
     code = TSDB_CODE_TMQ_CONSUMER_CLOSED;
-    goto FAIL;
+    goto FAIL2;
   }
 
-  SMqPollRspWrapper* pRspWrapper;
+  SMqPollRspWrapper* pRspWrapper = NULL;
   code = taosAllocateQitem(sizeof(SMqPollRspWrapper), DEF_QITEM, 0, (void**)&pRspWrapper);
   if (code) {
     tscWarn("consumer:0x%" PRIx64 " msg discard from vgId:%d, since out of memory", tmq->consumerId, vgId);
-    taosReleaseRef(tmqMgmt.rsetId, refId);
-    goto FAIL;
+    goto FAIL1;
   }
 
   if (code != 0) {
@@ -1434,7 +1492,7 @@ int32_t tmqPollCb(void* param, SDataBuf* pMsg, int32_t code) {
     tscWarn("consumer:0x%" PRIx64
             " msg discard from vgId:%d since from earlier epoch, rsp epoch %d, current epoch %d, reqId:0x%" PRIx64,
             tmq->consumerId, vgId, msgEpoch, clientEpoch, requestId);
-    code = -1;
+    code = TSDB_CODE_TMQ_CONSUMER_MISMATCH;
     goto END;
   }
 
@@ -1447,56 +1505,51 @@ int32_t tmqPollCb(void* param, SDataBuf* pMsg, int32_t code) {
   pMsg->pEpSet = NULL;
 
   if (rspType == TMQ_MSG_TYPE__POLL_DATA_RSP) {
-    SDecoder decoder;
+    SDecoder decoder = {0};
     tDecoderInit(&decoder, POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), pMsg->len - sizeof(SMqRspHead));
     if (tDecodeMqDataRsp(&decoder, &pRspWrapper->dataRsp) < 0) {
       tDecoderClear(&decoder);
-      taosReleaseRef(tmqMgmt.rsetId, refId);
       code = TSDB_CODE_OUT_OF_MEMORY;
       goto END;
     }
     tDecoderClear(&decoder);
-    memcpy(&pRspWrapper->dataRsp, pMsg->pData, sizeof(SMqRspHead));
+    (void)memcpy(&pRspWrapper->dataRsp, pMsg->pData, sizeof(SMqRspHead));
 
     char buf[TSDB_OFFSET_LEN] = {0};
-    tFormatOffset(buf, TSDB_OFFSET_LEN, &pRspWrapper->dataRsp.common.rspOffset);
+    (void)tFormatOffset(buf, TSDB_OFFSET_LEN, &pRspWrapper->dataRsp.common.rspOffset);
     tscDebug("consumer:0x%" PRIx64 " recv poll rsp, vgId:%d, req ver:%" PRId64 ", rsp:%s type %d, reqId:0x%" PRIx64,
              tmq->consumerId, vgId, pRspWrapper->dataRsp.common.reqOffset.version, buf, rspType, requestId);
   } else if (rspType == TMQ_MSG_TYPE__POLL_META_RSP) {
-    SDecoder decoder;
+    SDecoder decoder = {0};
     tDecoderInit(&decoder, POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), pMsg->len - sizeof(SMqRspHead));
     if (tDecodeMqMetaRsp(&decoder, &pRspWrapper->metaRsp) < 0) {
       tDecoderClear(&decoder);
-      taosReleaseRef(tmqMgmt.rsetId, refId);
       code = TSDB_CODE_OUT_OF_MEMORY;
       goto END;
     }
     tDecoderClear(&decoder);
-    memcpy(&pRspWrapper->metaRsp, pMsg->pData, sizeof(SMqRspHead));
+    (void)memcpy(&pRspWrapper->metaRsp, pMsg->pData, sizeof(SMqRspHead));
   } else if (rspType == TMQ_MSG_TYPE__POLL_DATA_META_RSP) {
-    SDecoder decoder;
+    SDecoder decoder = {0};
     tDecoderInit(&decoder, POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), pMsg->len - sizeof(SMqRspHead));
     if (tDecodeSTaosxRsp(&decoder, &pRspWrapper->taosxRsp) < 0) {
       tDecoderClear(&decoder);
-      taosReleaseRef(tmqMgmt.rsetId, refId);
       code = TSDB_CODE_OUT_OF_MEMORY;
       goto END;
     }
     tDecoderClear(&decoder);
-    memcpy(&pRspWrapper->taosxRsp, pMsg->pData, sizeof(SMqRspHead));
+    (void)memcpy(&pRspWrapper->taosxRsp, pMsg->pData, sizeof(SMqRspHead));
   } else if (rspType == TMQ_MSG_TYPE__POLL_BATCH_META_RSP) {
-    SDecoder decoder;
+    SDecoder decoder = {0};
     tDecoderInit(&decoder, POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), pMsg->len - sizeof(SMqRspHead));
     if (tSemiDecodeMqBatchMetaRsp(&decoder, &pRspWrapper->batchMetaRsp) < 0) {
       tDecoderClear(&decoder);
-      taosReleaseRef(tmqMgmt.rsetId, refId);
       code = TSDB_CODE_OUT_OF_MEMORY;
-      goto FAIL;
+      goto END;
     }
     tDecoderClear(&decoder);
-    memcpy(&pRspWrapper->batchMetaRsp, pMsg->pData, sizeof(SMqRspHead));
-    tscDebug("consumer:0x%" PRIx64 " recv poll batchmeta rsp, vgId:%d, reqId:0x%" PRIx64, tmq->consumerId, vgId,
-             requestId);
+    (void)memcpy(&pRspWrapper->batchMetaRsp, pMsg->pData, sizeof(SMqRspHead));
+    tscDebug("consumer:0x%" PRIx64 " recv poll batchmeta rsp, vgId:%d, reqId:0x%" PRIx64, tmq->consumerId, vgId,requestId);
   } else {  // invalid rspType
     tscError("consumer:0x%" PRIx64 " invalid rsp msg received, type:%d ignored", tmq->consumerId, rspType);
   }
@@ -1504,16 +1557,21 @@ int32_t tmqPollCb(void* param, SDataBuf* pMsg, int32_t code) {
 END:
   pRspWrapper->code = code;
   pRspWrapper->vgId = vgId;
-  strcpy(pRspWrapper->topicName, pParam->topicName);
-  taosWriteQitem(tmq->mqueue, pRspWrapper);
+  (void)strcpy(pRspWrapper->topicName, pParam->topicName);
+  code = taosWriteQitem(tmq->mqueue, pRspWrapper);
+  if(code != 0){
+    tscError("consumer:0x%" PRIx64 " put poll res into mqueue failed, code:%d", tmq->consumerId, code);
+  }
 
   int32_t total = taosQueueItemSize(tmq->mqueue);
   tscDebug("consumer:0x%" PRIx64 " put poll res into mqueue, type:%d, vgId:%d, total in queue:%d, reqId:0x%" PRIx64,
            tmq->consumerId, rspType, vgId, total, requestId);
-  taosReleaseRef(tmqMgmt.rsetId, refId);
 
-FAIL:
-  if (tmq) tsem2_post(&tmq->rspSem);
+FAIL1:
+  (void)taosReleaseRef(tmqMgmt.rsetId, refId);
+
+FAIL2:
+  if (tmq) (void)tsem2_post(&tmq->rspSem);
   if (pMsg) taosMemoryFreeClear(pMsg->pData);
   if (pMsg) taosMemoryFreeClear(pMsg->pEpSet);
 
@@ -1542,11 +1600,16 @@ static void initClientTopicFromRsp(SMqClientTopic* pTopic, SMqSubTopicEp* pTopic
 
   tscInfo("consumer:0x%" PRIx64 ", update topic:%s, new numOfVgs:%d", tmq->consumerId, pTopic->topicName, vgNumGet);
   pTopic->vgs = taosArrayInit(vgNumGet, sizeof(SMqClientVg));
-
+  if (pTopic->vgs == NULL) {
+    tscError("consumer:0x%" PRIx64 ", failed to init vgs for topic:%s", tmq->consumerId, pTopic->topicName);
+    return;
+  }
   for (int32_t j = 0; j < vgNumGet; j++) {
     SMqSubVgEp* pVgEp = taosArrayGet(pTopicEp->vgs, j);
-
-    makeTopicVgroupKey(vgKey, pTopic->topicName, pVgEp->vgId);
+    if (pVgEp == NULL){
+      continue;
+    }
+    (void)sprintf(vgKey, "%s:%d", pTopic->topicName, pVgEp->vgId);
     SVgroupSaveInfo* pInfo = taosHashGet(pVgOffsetHashMap, vgKey, strlen(vgKey));
 
     STqOffsetVal offsetNew = {0};
@@ -1579,7 +1642,11 @@ static void initClientTopicFromRsp(SMqClientTopic* pTopic, SMqSubTopicEp* pTopic
       clientVg.offsetInfo.committedOffset = offsetNew;
       clientVg.offsetInfo.beginOffset = offsetNew;
     }
-    taosArrayPush(pTopic->vgs, &clientVg);
+    if (taosArrayPush(pTopic->vgs, &clientVg) == NULL){
+      tscError("consumer:0x%" PRIx64 ", failed to push vg:%d into topic:%s", tmq->consumerId, pVgEp->vgId,
+               pTopic->topicName);
+      freeClientVg(&clientVg);
+    }
   }
 }
 
@@ -1603,7 +1670,7 @@ static bool doUpdateLocalEp(tmq_t* tmq, int32_t epoch, const SMqAskEpRsp* pRsp)
 
   SHashObj* pVgOffsetHashMap = taosHashInit(64, MurmurHash3_32, false, HASH_NO_LOCK);
   if (pVgOffsetHashMap == NULL) {
-    taosArrayDestroy(newTopics);
+    (void)taosArrayDestroy(newTopics);
     return false;
   }
 
@@ -1616,15 +1683,18 @@ static bool doUpdateLocalEp(tmq_t* tmq, int32_t epoch, const SMqAskEpRsp* pRsp)
   for (int32_t i = 0; i < topicNumCur; i++) {
     // find old topic
     SMqClientTopic* pTopicCur = taosArrayGet(tmq->clientTopics, i);
-    if (pTopicCur->vgs) {
+    if (pTopicCur && pTopicCur->vgs) {
       int32_t vgNumCur = taosArrayGetSize(pTopicCur->vgs);
       tscInfo("consumer:0x%" PRIx64 ", current vg num: %d", tmq->consumerId, vgNumCur);
       for (int32_t j = 0; j < vgNumCur; j++) {
         SMqClientVg* pVgCur = taosArrayGet(pTopicCur->vgs, j);
-        makeTopicVgroupKey(vgKey, pTopicCur->topicName, pVgCur->vgId);
+        if (pVgCur == NULL) {
+          continue;
+        }
+        (void)sprintf(vgKey, "%s:%d", pTopicCur->topicName, pVgCur->vgId);
 
         char buf[TSDB_OFFSET_LEN] = {0};
-        tFormatOffset(buf, TSDB_OFFSET_LEN, &pVgCur->offsetInfo.endOffset);
+        (void)tFormatOffset(buf, TSDB_OFFSET_LEN, &pVgCur->offsetInfo.endOffset);
         tscInfo("consumer:0x%" PRIx64 ", epoch:%d vgId:%d vgKey:%s, offset:%s", tmq->consumerId, epoch, pVgCur->vgId,
                 vgKey, buf);
 
@@ -1633,7 +1703,9 @@ static bool doUpdateLocalEp(tmq_t* tmq, int32_t epoch, const SMqAskEpRsp* pRsp)
                                 .commitOffset = pVgCur->offsetInfo.committedOffset,
                                 .numOfRows = pVgCur->numOfRows,
                                 .vgStatus = pVgCur->vgStatus};
-        taosHashPut(pVgOffsetHashMap, vgKey, strlen(vgKey), &info, sizeof(SVgroupSaveInfo));
+        if(taosHashPut(pVgOffsetHashMap, vgKey, strlen(vgKey), &info, sizeof(SVgroupSaveInfo)) != 0){
+          tscError("consumer:0x%" PRIx64 ", failed to put vg:%d into hashmap", tmq->consumerId, pVgCur->vgId);
+        }
       }
     }
   }
@@ -1641,15 +1713,21 @@ static bool doUpdateLocalEp(tmq_t* tmq, int32_t epoch, const SMqAskEpRsp* pRsp)
   for (int32_t i = 0; i < topicNumGet; i++) {
     SMqClientTopic topic = {0};
     SMqSubTopicEp* pTopicEp = taosArrayGet(pRsp->topics, i);
+    if (pTopicEp == NULL) {
+      continue;
+    }
     initClientTopicFromRsp(&topic, pTopicEp, pVgOffsetHashMap, tmq);
-    taosArrayPush(newTopics, &topic);
+    if(taosArrayPush(newTopics, &topic) == NULL){
+      tscError("consumer:0x%" PRIx64 ", failed to push topic:%s into new topics", tmq->consumerId, topic.topicName);
+      freeClientTopic(&topic);
+    }
   }
 
   taosHashCleanup(pVgOffsetHashMap);
 
   // destroy current buffered existed topics info
   if (tmq->clientTopics) {
-    taosArrayDestroyEx(tmq->clientTopics, freeClientVgImpl);
+    taosArrayDestroyEx(tmq->clientTopics, freeClientTopic);
   }
   tmq->clientTopics = newTopics;
   taosWUnLockLatch(&tmq->lock);
@@ -1677,36 +1755,41 @@ void tmqBuildConsumeReqImpl(SMqPollReq* pReq, tmq_t* tmq, int64_t timeout, SMqCl
   pReq->enableBatchMeta = tmq->enableBatchMeta;
 }
 
-SMqMetaRspObj* tmqBuildMetaRspFromWrapper(SMqPollRspWrapper* pWrapper) {
+int32_t tmqBuildMetaRspFromWrapper(SMqPollRspWrapper* pWrapper, SMqMetaRspObj** ppRspObj) {
   SMqMetaRspObj* pRspObj = taosMemoryCalloc(1, sizeof(SMqMetaRspObj));
   if (pRspObj == NULL) {
-    return NULL;
+    return TSDB_CODE_OUT_OF_MEMORY;
   }
   pRspObj->resType = RES_TYPE__TMQ_META;
   tstrncpy(pRspObj->topic, pWrapper->topicHandle->topicName, TSDB_TOPIC_FNAME_LEN);
   tstrncpy(pRspObj->db, pWrapper->topicHandle->db, TSDB_DB_FNAME_LEN);
   pRspObj->vgId = pWrapper->vgHandle->vgId;
 
-  memcpy(&pRspObj->metaRsp, &pWrapper->metaRsp, sizeof(SMqMetaRsp));
-  return pRspObj;
+  (void)memcpy(&pRspObj->metaRsp, &pWrapper->metaRsp, sizeof(SMqMetaRsp));
+  *ppRspObj = pRspObj;
+  return 0;
 }
 
-SMqBatchMetaRspObj* tmqBuildBatchMetaRspFromWrapper(SMqPollRspWrapper* pWrapper) {
+int32_t tmqBuildBatchMetaRspFromWrapper(SMqPollRspWrapper* pWrapper, SMqBatchMetaRspObj** ppRspObj) {
   SMqBatchMetaRspObj* pRspObj = taosMemoryCalloc(1, sizeof(SMqBatchMetaRspObj));
   if (pRspObj == NULL) {
-    return NULL;
+    return TSDB_CODE_OUT_OF_MEMORY;
   }
   pRspObj->common.resType = RES_TYPE__TMQ_BATCH_META;
   tstrncpy(pRspObj->common.topic, pWrapper->topicHandle->topicName, TSDB_TOPIC_FNAME_LEN);
   tstrncpy(pRspObj->common.db, pWrapper->topicHandle->db, TSDB_DB_FNAME_LEN);
   pRspObj->common.vgId = pWrapper->vgHandle->vgId;
 
-  memcpy(&pRspObj->rsp, &pWrapper->batchMetaRsp, sizeof(SMqBatchMetaRsp));
+  (void)memcpy(&pRspObj->rsp, &pWrapper->batchMetaRsp, sizeof(SMqBatchMetaRsp));
   tscDebug("build batchmeta Rsp from wrapper");
-  return pRspObj;
+  *ppRspObj = pRspObj;
+  return 0;
 }
 
 void changeByteEndian(char* pData) {
+  if (pData == NULL) {
+    return;
+  }
   char* p = pData;
 
   // | version | total length | total rows | total columns | flag seg| block group id | column schema | each column
@@ -1732,6 +1815,9 @@ void changeByteEndian(char* pData) {
 }
 
 static void tmqGetRawDataRowsPrecisionFromRes(void* pRetrieve, void** rawData, int64_t* rows, int32_t* precision) {
+  if (pRetrieve == NULL) {
+    return;
+  }
   if (*(int64_t*)pRetrieve == 0) {
     *rawData = ((SRetrieveTableRsp*)pRetrieve)->data;
     *rows = htobe64(((SRetrieveTableRsp*)pRetrieve)->numOfRows);
@@ -1763,6 +1849,10 @@ static void tmqBuildRspFromWrapperInner(SMqPollRspWrapper* pWrapper, SMqClientVg
   if (!pDataRsp->withSchema) {  // withSchema is false if subscribe subquery, true if subscribe db or stable
     pDataRsp->withSchema = true;
     pDataRsp->blockSchema = taosArrayInit(pDataRsp->blockNum, sizeof(void*));
+    if (pDataRsp->blockSchema == NULL){
+      tscError("failed to allocate memory for blockSchema");
+      return;
+    }
   }
   // extract the rows in this data packet
   for (int32_t i = 0; i < pDataRsp->blockNum; ++i) {
@@ -1778,33 +1868,38 @@ static void tmqBuildRspFromWrapperInner(SMqPollRspWrapper* pWrapper, SMqClientVg
     if (needTransformSchema) {  // withSchema is false if subscribe subquery, true if subscribe db or stable
       SSchemaWrapper* schema = tCloneSSchemaWrapper(&pWrapper->topicHandle->schema);
       if (schema) {
-        taosArrayPush(pDataRsp->blockSchema, &schema);
+        if (taosArrayPush(pDataRsp->blockSchema, &schema) == NULL){
+          tscError("failed to push schema into blockSchema");
+          continue;
+        }
       }
     }
   }
 }
 
-SMqRspObj* tmqBuildRspFromWrapper(SMqPollRspWrapper* pWrapper, SMqClientVg* pVg, int64_t* numOfRows) {
+int32_t tmqBuildRspFromWrapper(SMqPollRspWrapper* pWrapper, SMqClientVg* pVg, int64_t* numOfRows, SMqRspObj** ppRspObj) {
   SMqRspObj* pRspObj = taosMemoryCalloc(1, sizeof(SMqRspObj));
   if (pRspObj == NULL) {
-    return NULL;
+    return TSDB_CODE_OUT_OF_MEMORY;
   }
   pRspObj->common.resType = RES_TYPE__TMQ;
-  memcpy(&pRspObj->rsp, &pWrapper->dataRsp, sizeof(SMqDataRsp));
+  (void)memcpy(&pRspObj->rsp, &pWrapper->dataRsp, sizeof(SMqDataRsp));
   tmqBuildRspFromWrapperInner(pWrapper, pVg, numOfRows, &pRspObj->common, &pRspObj->rsp.common);
-  return pRspObj;
+  *ppRspObj = pRspObj;
+  return 0;
 }
 
-SMqTaosxRspObj* tmqBuildTaosxRspFromWrapper(SMqPollRspWrapper* pWrapper, SMqClientVg* pVg, int64_t* numOfRows) {
+int32_t tmqBuildTaosxRspFromWrapper(SMqPollRspWrapper* pWrapper, SMqClientVg* pVg, int64_t* numOfRows, SMqTaosxRspObj** ppRspObj) {
   SMqTaosxRspObj* pRspObj = taosMemoryCalloc(1, sizeof(SMqTaosxRspObj));
   if (pRspObj == NULL) {
-    return NULL;
+    return TSDB_CODE_OUT_OF_MEMORY;
   }
   pRspObj->common.resType = RES_TYPE__TMQ_METADATA;
-  memcpy(&pRspObj->rsp, &pWrapper->taosxRsp, sizeof(STaosxRsp));
+  (void)memcpy(&pRspObj->rsp, &pWrapper->taosxRsp, sizeof(STaosxRsp));
 
   tmqBuildRspFromWrapperInner(pWrapper, pVg, numOfRows, &pRspObj->common, &pRspObj->rsp.common);
-  return pRspObj;
+  *ppRspObj = pRspObj;
+  return 0;
 }
 
 static int32_t doTmqPollImpl(tmq_t* pTmq, SMqClientTopic* pTopic, SMqClientVg* pVg, int64_t timeout) {
@@ -1841,13 +1936,14 @@ static int32_t doTmqPollImpl(tmq_t* pTmq, SMqClientTopic* pTopic, SMqClientVg* p
   }
 
   pParam->refId = pTmq->refId;
-  strcpy(pParam->topicName, pTopic->topicName);
+  (void)strcpy(pParam->topicName, pTopic->topicName);
   pParam->vgId = pVg->vgId;
   pParam->requestId = req.reqId;
 
   sendInfo = taosMemoryCalloc(1, sizeof(SMsgSendInfo));
   if (sendInfo == NULL) {
     code = TSDB_CODE_OUT_OF_MEMORY;
+    taosMemoryFreeClear(pParam);
     taosMemoryFreeClear(msg);
     return code;
   }
@@ -1862,7 +1958,7 @@ static int32_t doTmqPollImpl(tmq_t* pTmq, SMqClientTopic* pTopic, SMqClientVg* p
 
   int64_t transporterId = 0;
   char    offsetFormatBuf[TSDB_OFFSET_LEN] = {0};
-  tFormatOffset(offsetFormatBuf, tListLen(offsetFormatBuf), &pVg->offsetInfo.endOffset);
+  (void)tFormatOffset(offsetFormatBuf, tListLen(offsetFormatBuf), &pVg->offsetInfo.endOffset);
   code = asyncSendMsgToServer(pTmq->pTscObj->pAppInfo->pTransporter, &pVg->epSet, &transporterId, sendInfo);
   tscDebug("consumer:0x%" PRIx64 " send poll to %s vgId:%d, code:%d, epoch %d, req:%s, reqId:0x%" PRIx64,
            pTmq->consumerId, pTopic->topicName, pVg->vgId, code, pTmq->epoch, offsetFormatBuf, req.reqId);
@@ -1890,6 +1986,9 @@ static int32_t tmqPollImpl(tmq_t* tmq, int64_t timeout) {
 
   for (int i = 0; i < numOfTopics; i++) {
     SMqClientTopic* pTopic = taosArrayGet(tmq->clientTopics, i);
+    if (pTopic == NULL){
+      continue;
+    }
     int32_t         numOfVg = taosArrayGetSize(pTopic->vgs);
     if (pTopic->noPrivilege) {
       tscDebug("consumer:0x%" PRIx64 " has no privilegr for topic:%s", tmq->consumerId, pTopic->topicName);
@@ -1897,6 +1996,9 @@ static int32_t tmqPollImpl(tmq_t* tmq, int64_t timeout) {
     }
     for (int j = 0; j < numOfVg; j++) {
       SMqClientVg* pVg = taosArrayGet(pTopic->vgs, j);
+      if (pVg == NULL) {
+        continue;
+      }
       int64_t      elapsed = taosGetTimestampMs() - pVg->emptyBlockReceiveTs;
       if (elapsed < EMPTY_BLOCK_POLL_IDLE_DURATION && elapsed >= 0) {  // less than 10ms
         tscDebug("consumer:0x%" PRIx64 " epoch %d, vgId:%d idle for 10ms before start next poll", tmq->consumerId,
@@ -1958,11 +2060,11 @@ static void* tmqHandleAllRsp(tmq_t* tmq, int64_t timeout) {
 
   while (1) {
     SMqRspWrapper* pRspWrapper = NULL;
-    taosGetQitem(tmq->qall, (void**)&pRspWrapper);
+    (void)taosGetQitem(tmq->qall, (void**)&pRspWrapper);
 
     if (pRspWrapper == NULL) {
-      taosReadAllQitems(tmq->mqueue, tmq->qall);
-      taosGetQitem(tmq->qall, (void**)&pRspWrapper);
+      (void)taosReadAllQitems(tmq->mqueue, tmq->qall);
+      (void)taosGetQitem(tmq->qall, (void**)&pRspWrapper);
       if (pRspWrapper == NULL) {
         return NULL;
       }
@@ -1976,17 +2078,19 @@ static void* tmqHandleAllRsp(tmq_t* tmq, int64_t timeout) {
         atomic_store_8(&tmq->status, TMQ_CONSUMER_STATUS__RECOVER);
         tscDebug("consumer:0x%" PRIx64 " wait for the rebalance, set status to be RECOVER", tmq->consumerId);
       } else if (pRspWrapper->code == TSDB_CODE_TQ_NO_COMMITTED_OFFSET) {
-        terrno = pRspWrapper->code;
-        tscError("consumer:0x%" PRIx64 " unexpected rsp from poll, code:%s", tmq->consumerId,
-                 tstrerror(pRspWrapper->code));
+        tscInfo("consumer:0x%" PRIx64 " return null since no committed offset", tmq->consumerId);
       } else {
         if (pRspWrapper->code == TSDB_CODE_VND_INVALID_VGROUP_ID) {  // for vnode transform
-          askEp(tmq, NULL, false, true);
+          int32_t code = askEp(tmq, NULL, false, true);
+          if (code != 0) {
+            tscError("consumer:0x%" PRIx64 " failed to ask ep, code:%s", tmq->consumerId, tstrerror(code));
+          }
         }
         tscError("consumer:0x%" PRIx64 " msg from vgId:%d discarded, since %s", tmq->consumerId, pollRspWrapper->vgId,
                  tstrerror(pRspWrapper->code));
         taosWLockLatch(&tmq->lock);
-        SMqClientVg* pVg = getVgInfo(tmq, pollRspWrapper->topicName, pollRspWrapper->vgId);
+        SMqClientVg* pVg = NULL;
+        getVgInfo(tmq, pollRspWrapper->topicName, pollRspWrapper->vgId, &pVg);
         if (pVg) pVg->emptyBlockReceiveTs = taosGetTimestampMs();
         taosWUnLockLatch(&tmq->lock);
       }
@@ -2000,7 +2104,8 @@ static void* tmqHandleAllRsp(tmq_t* tmq, int64_t timeout) {
 
       if (pDataRsp->head.epoch == consumerEpoch) {
         taosWLockLatch(&tmq->lock);
-        SMqClientVg* pVg = getVgInfo(tmq, pollRspWrapper->topicName, pollRspWrapper->vgId);
+        SMqClientVg* pVg = NULL;
+        getVgInfo(tmq, pollRspWrapper->topicName, pollRspWrapper->vgId, &pVg);
         pollRspWrapper->vgHandle = pVg;
         pollRspWrapper->topicHandle = getTopicInfo(tmq, pollRspWrapper->topicName);
         if (pollRspWrapper->vgHandle == NULL || pollRspWrapper->topicHandle == NULL) {
@@ -2024,7 +2129,7 @@ static void* tmqHandleAllRsp(tmq_t* tmq, int64_t timeout) {
                      tmq->consumerId, pDataRsp->blockNum != 0);
 
         char buf[TSDB_OFFSET_LEN] = {0};
-        tFormatOffset(buf, TSDB_OFFSET_LEN, &pDataRsp->rspOffset);
+        (void)tFormatOffset(buf, TSDB_OFFSET_LEN, &pDataRsp->rspOffset);
         if (pDataRsp->blockNum == 0) {
           tscDebug("consumer:0x%" PRIx64 " empty block received, vgId:%d, offset:%s, vg total:%" PRId64
                    ", total:%" PRId64 ", reqId:0x%" PRIx64,
@@ -2035,14 +2140,18 @@ static void* tmqHandleAllRsp(tmq_t* tmq, int64_t timeout) {
           taosWUnLockLatch(&tmq->lock);
         } else {  // build rsp
           int64_t    numOfRows = 0;
-          SMqRspObj* pRsp = tmqBuildRspFromWrapper(pollRspWrapper, pVg, &numOfRows);
+          SMqRspObj* pRsp = NULL;
+          (void)tmqBuildRspFromWrapper(pollRspWrapper, pVg, &numOfRows, &pRsp);
           tmq->totalRows += numOfRows;
           pVg->emptyBlockReceiveTs = 0;
-          if (tmq->replayEnable) {
+          if (pRsp && tmq->replayEnable) {
             pVg->blockReceiveTs = taosGetTimestampMs();
             pVg->blockSleepForReplay = pRsp->rsp.sleepTime;
             if (pVg->blockSleepForReplay > 0) {
-              taosTmrStart(tmqReplayTask, pVg->blockSleepForReplay, (void*)(tmq->refId), tmqMgmt.timer);
+              if (taosTmrStart(tmqReplayTask, pVg->blockSleepForReplay, (void*)(tmq->refId), tmqMgmt.timer) == NULL) {
+                tscError("consumer:0x%" PRIx64 " failed to start replay timer, vgId:%d, sleep:%"PRId64, tmq->consumerId,
+                         pVg->vgId, pVg->blockSleepForReplay);
+              }
             }
           }
           tscDebug("consumer:0x%" PRIx64 " process poll rsp, vgId:%d, offset:%s, blocks:%d, rows:%" PRId64
@@ -2068,7 +2177,8 @@ static void* tmqHandleAllRsp(tmq_t* tmq, int64_t timeout) {
 
       if (pollRspWrapper->metaRsp.head.epoch == consumerEpoch) {
         taosWLockLatch(&tmq->lock);
-        SMqClientVg* pVg = getVgInfo(tmq, pollRspWrapper->topicName, pollRspWrapper->vgId);
+        SMqClientVg* pVg = NULL;
+        getVgInfo(tmq, pollRspWrapper->topicName, pollRspWrapper->vgId, &pVg);
         pollRspWrapper->vgHandle = pVg;
         pollRspWrapper->topicHandle = getTopicInfo(tmq, pollRspWrapper->topicName);
         if (pollRspWrapper->vgHandle == NULL || pollRspWrapper->topicHandle == NULL) {
@@ -2083,7 +2193,8 @@ static void* tmqHandleAllRsp(tmq_t* tmq, int64_t timeout) {
         updateVgInfo(pVg, &pollRspWrapper->metaRsp.rspOffset, &pollRspWrapper->metaRsp.rspOffset,
                      pollRspWrapper->metaRsp.head.walsver, pollRspWrapper->metaRsp.head.walever, tmq->consumerId, true);
         // build rsp
-        SMqMetaRspObj* pRsp = tmqBuildMetaRspFromWrapper(pollRspWrapper);
+        SMqMetaRspObj* pRsp = NULL;
+        (void)tmqBuildMetaRspFromWrapper(pollRspWrapper, &pRsp);
         taosFreeQitem(pRspWrapper);
         taosWUnLockLatch(&tmq->lock);
         return pRsp;
@@ -2102,7 +2213,8 @@ static void* tmqHandleAllRsp(tmq_t* tmq, int64_t timeout) {
 
       if (pollRspWrapper->batchMetaRsp.head.epoch == consumerEpoch) {
         taosWLockLatch(&tmq->lock);
-        SMqClientVg* pVg = getVgInfo(tmq, pollRspWrapper->topicName, pollRspWrapper->vgId);
+        SMqClientVg* pVg = NULL;
+        getVgInfo(tmq, pollRspWrapper->topicName, pollRspWrapper->vgId, &pVg);
         pollRspWrapper->vgHandle = pVg;
         pollRspWrapper->topicHandle = getTopicInfo(tmq, pollRspWrapper->topicName);
         if (pollRspWrapper->vgHandle == NULL || pollRspWrapper->topicHandle == NULL) {
@@ -2115,11 +2227,11 @@ static void* tmqHandleAllRsp(tmq_t* tmq, int64_t timeout) {
         }
 
         // build rsp
-        void* pRsp = NULL;
         updateVgInfo(pVg, &pollRspWrapper->batchMetaRsp.rspOffset, &pollRspWrapper->batchMetaRsp.rspOffset,
                      pollRspWrapper->batchMetaRsp.head.walsver, pollRspWrapper->batchMetaRsp.head.walever,
                      tmq->consumerId, true);
-        pRsp = tmqBuildBatchMetaRspFromWrapper(pollRspWrapper);
+        SMqBatchMetaRspObj* pRsp = NULL;
+        (void)tmqBuildBatchMetaRspFromWrapper(pollRspWrapper, &pRsp) ;
         taosFreeQitem(pRspWrapper);
         taosWUnLockLatch(&tmq->lock);
         return pRsp;
@@ -2137,7 +2249,8 @@ static void* tmqHandleAllRsp(tmq_t* tmq, int64_t timeout) {
 
       if (pDataRsp->head.epoch == consumerEpoch) {
         taosWLockLatch(&tmq->lock);
-        SMqClientVg* pVg = getVgInfo(tmq, pollRspWrapper->topicName, pollRspWrapper->vgId);
+        SMqClientVg* pVg = NULL;
+        getVgInfo(tmq, pollRspWrapper->topicName, pollRspWrapper->vgId, &pVg);
         pollRspWrapper->vgHandle = pVg;
         pollRspWrapper->topicHandle = getTopicInfo(tmq, pollRspWrapper->topicName);
         if (pollRspWrapper->vgHandle == NULL || pollRspWrapper->topicHandle == NULL) {
@@ -2166,11 +2279,14 @@ static void* tmqHandleAllRsp(tmq_t* tmq, int64_t timeout) {
 
         // build rsp
         int64_t numOfRows = 0;
-        void*   pRsp = tmqBuildTaosxRspFromWrapper(pollRspWrapper, pVg, &numOfRows);
+        SMqTaosxRspObj*   pRsp = NULL;
+        if (tmqBuildTaosxRspFromWrapper(pollRspWrapper, pVg, &numOfRows, &pRsp) !=0 ) {
+          tscError("consumer:0x%" PRIx64 " build taosx rsp failed, vgId:%d", tmq->consumerId, pVg->vgId);
+        }
         tmq->totalRows += numOfRows;
 
         char buf[TSDB_OFFSET_LEN] = {0};
-        tFormatOffset(buf, TSDB_OFFSET_LEN, &pVg->offsetInfo.endOffset);
+        (void)tFormatOffset(buf, TSDB_OFFSET_LEN, &pVg->offsetInfo.endOffset);
         tscDebug("consumer:0x%" PRIx64 " process taosx poll rsp, vgId:%d, offset:%s, blocks:%d, rows:%" PRId64
                  ", vg total:%" PRId64 ", total:%" PRId64 ", reqId:0x%" PRIx64,
                  tmq->consumerId, pVg->vgId, buf, pDataRsp->blockNum, numOfRows, pVg->numOfRows, tmq->totalRows,
@@ -2190,7 +2306,7 @@ static void* tmqHandleAllRsp(tmq_t* tmq, int64_t timeout) {
       tscDebug("consumer:0x%" PRIx64 " ep msg received", tmq->consumerId);
       SMqAskEpRspWrapper* pEpRspWrapper = (SMqAskEpRspWrapper*)pRspWrapper;
       SMqAskEpRsp*        rspMsg = &pEpRspWrapper->msg;
-      doUpdateLocalEp(tmq, pEpRspWrapper->epoch, rspMsg);
+      (void)doUpdateLocalEp(tmq, pEpRspWrapper->epoch, rspMsg);
       tmqFreeRspWrapper(pRspWrapper);
       taosFreeQitem(pRspWrapper);
     } else {
@@ -2243,9 +2359,6 @@ TAOS_RES* tmq_consumer_poll(tmq_t* tmq, int64_t timeout) {
     if (rspObj) {
       tscDebug("consumer:0x%" PRIx64 " return rsp %p", tmq->consumerId, rspObj);
       return (TAOS_RES*)rspObj;
-    } else if (terrno == TSDB_CODE_TQ_NO_COMMITTED_OFFSET) {
-      tscInfo("consumer:0x%" PRIx64 " return null since no committed offset", tmq->consumerId);
-      return NULL;
     }
 
     if (timeout >= 0) {
@@ -2256,10 +2369,9 @@ TAOS_RES* tmq_consumer_poll(tmq_t* tmq, int64_t timeout) {
                  tmq->consumerId, tmq->epoch, startTime, currentTime);
         return NULL;
       }
-      tsem2_timewait(&tmq->rspSem, (timeout - elapsedTime));
+      (void)tsem2_timewait(&tmq->rspSem, (timeout - elapsedTime));
     } else {
-      // use tsem_timewait instead of tsem_wait to avoid unexpected stuck
-      tsem2_timewait(&tmq->rspSem, 1000);
+      (void)tsem2_timewait(&tmq->rspSem, 1000);
     }
   }
 }
@@ -2273,11 +2385,12 @@ static void displayConsumeStatistics(tmq_t* pTmq) {
   tscDebug("consumer:0x%" PRIx64 " rows dist begin: ", pTmq->consumerId);
   for (int32_t i = 0; i < numOfTopics; ++i) {
     SMqClientTopic* pTopics = taosArrayGet(pTmq->clientTopics, i);
-
+    if (pTopics == NULL) continue;
     tscDebug("consumer:0x%" PRIx64 " topic:%d", pTmq->consumerId, i);
     int32_t numOfVgs = taosArrayGetSize(pTopics->vgs);
     for (int32_t j = 0; j < numOfVgs; ++j) {
       SMqClientVg* pVg = taosArrayGet(pTopics->vgs, j);
+      if (pVg == NULL) continue;
       tscDebug("topic:%s, %d. vgId:%d rows:%" PRId64, pTopics->topicName, j, pVg->vgId, pVg->numOfRows);
     }
   }
@@ -2285,34 +2398,58 @@ static void displayConsumeStatistics(tmq_t* pTmq) {
   tscDebug("consumer:0x%" PRIx64 " rows dist end", pTmq->consumerId);
 }
 
+static int32_t innerClose(tmq_t* tmq){
+  if (tmq->status != TMQ_CONSUMER_STATUS__READY) {
+    tscInfo("consumer:0x%" PRIx64 " not in ready state, unsubscribe it directly", tmq->consumerId);
+    return 0;
+  }
+  if (tmq->autoCommit) {
+    int32_t code = tmq_commit_sync(tmq, NULL);
+    if (code != 0) {
+      return code;
+    }
+  }
+  tmqSendHbReq((void*)(tmq->refId), NULL);
+
+  tmq_list_t* lst = tmq_list_new();
+  if (lst == NULL){
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  int32_t code = tmq_subscribe(tmq, lst);
+  tmq_list_destroy(lst);
+  return code;
+}
+int32_t tmq_unsubscribe(tmq_t* tmq) {
+  if (tmq == NULL) return TSDB_CODE_INVALID_PARA;
+
+  tscInfo("consumer:0x%" PRIx64 " start to unsubscribe consumer, status:%d", tmq->consumerId, tmq->status);
+  int32_t code = 0;
+  if (atomic_load_8(&tmq->status) != TMQ_CONSUMER_STATUS__CLOSED) {
+    code = innerClose(tmq);
+    if(code == 0){
+      atomic_store_8(&tmq->status, TMQ_CONSUMER_STATUS__CLOSED);
+    }
+  }
+  return code;
+}
+
 int32_t tmq_consumer_close(tmq_t* tmq) {
   if (tmq == NULL) return TSDB_CODE_INVALID_PARA;
 
   tscInfo("consumer:0x%" PRIx64 " start to close consumer, status:%d", tmq->consumerId, tmq->status);
   displayConsumeStatistics(tmq);
-
-  if (tmq->status == TMQ_CONSUMER_STATUS__READY) {
-    // if auto commit is set, commit before close consumer. Otherwise, do nothing.
-    if (tmq->autoCommit) {
-      int32_t code = tmq_commit_sync(tmq, NULL);
-      if (code != 0) {
-        return code;
-      }
+  int32_t code = 0;
+  if (atomic_load_8(&tmq->status) != TMQ_CONSUMER_STATUS__CLOSED) {
+    code = innerClose(tmq);
+    if(code == 0){
+      atomic_store_8(&tmq->status, TMQ_CONSUMER_STATUS__CLOSED);
     }
-    tmqSendHbReq((void*)(tmq->refId), NULL);
-
-    tmq_list_t* lst = tmq_list_new();
-    int32_t     code = tmq_subscribe(tmq, lst);
-    tmq_list_destroy(lst);
-    if (code != 0) {
-      return code;
-    }
-  } else {
-    tscInfo("consumer:0x%" PRIx64 " not in ready state, close it directly", tmq->consumerId);
   }
 
-  taosRemoveRef(tmqMgmt.rsetId, tmq->refId);
-  return 0;
+  if (code == 0){
+    (void)taosRemoveRef(tmqMgmt.rsetId, tmq->refId);
+  }
+  return code;
 }
 
 const char* tmq_err2str(int32_t err) {
@@ -2324,7 +2461,7 @@ const char* tmq_err2str(int32_t err) {
     if (*(taosGetErrMsg()) == 0) {
       return tstrerror(err);
     } else {
-      snprintf(taosGetErrMsgReturn(), ERR_MSG_LEN, "%s,detail:%s", tstrerror(err), taosGetErrMsg());
+      (void)snprintf(taosGetErrMsgReturn(), ERR_MSG_LEN, "%s,detail:%s", tstrerror(err), taosGetErrMsg());
       return (const char*)taosGetErrMsgReturn();
     }
   }
@@ -2352,10 +2489,17 @@ const char* tmq_get_topic_name(TAOS_RES* res) {
     return NULL;
   }
   if (TD_RES_TMQ(res) || TD_RES_TMQ_METADATA(res) || TD_RES_TMQ_BATCH_META(res)) {
-    return strchr(((SMqRspObjCommon*)res)->topic, '.') + 1;
+    char *tmp = strchr(((SMqRspObjCommon*)res)->topic, '.');
+    if (tmp == NULL) {
+      return NULL;
+    }
+    return tmp + 1;
   } else if (TD_RES_TMQ_META(res)) {
-    SMqMetaRspObj* pMetaRspObj = (SMqMetaRspObj*)res;
-    return strchr(pMetaRspObj->topic, '.') + 1;
+    char *tmp = strchr(((SMqMetaRspObj*)res)->topic, '.');
+    if (tmp == NULL) {
+      return NULL;
+    }
+    return tmp + 1;
   } else {
     return NULL;
   }
@@ -2367,10 +2511,17 @@ const char* tmq_get_db_name(TAOS_RES* res) {
   }
 
   if (TD_RES_TMQ(res) || TD_RES_TMQ_METADATA(res) || TD_RES_TMQ_BATCH_META(res)) {
-    return strchr(((SMqRspObjCommon*)res)->db, '.') + 1;
+    char *tmp = strchr(((SMqRspObjCommon*)res)->db, '.');
+    if (tmp == NULL) {
+      return NULL;
+    }
+    return tmp + 1;
   } else if (TD_RES_TMQ_META(res)) {
-    SMqMetaRspObj* pMetaRspObj = (SMqMetaRspObj*)res;
-    return strchr(pMetaRspObj->db, '.') + 1;
+    char *tmp = strchr(((SMqMetaRspObj*)res)->db, '.');
+    if (tmp == NULL) {
+      return NULL;
+    }
+    return tmp + 1;
   } else {
     return NULL;
   }
@@ -2383,8 +2534,7 @@ int32_t tmq_get_vgroup_id(TAOS_RES* res) {
   if (TD_RES_TMQ(res) || TD_RES_TMQ_METADATA(res) || TD_RES_TMQ_BATCH_META(res)) {
     return ((SMqRspObjCommon*)res)->vgId;
   } else if (TD_RES_TMQ_META(res)) {
-    SMqMetaRspObj* pMetaRspObj = (SMqMetaRspObj*)res;
-    return pMetaRspObj->vgId;
+    return ((SMqMetaRspObj*)res)->vgId;
   } else {
     return TSDB_CODE_INVALID_PARA;
   }
@@ -2455,7 +2605,7 @@ void tmq_commit_async(tmq_t* tmq, const TAOS_RES* pRes, tmq_commit_cb* cb, void*
 static void commitCallBackFn(tmq_t* UNUSED_PARAM(tmq), int32_t code, void* param) {
   SSyncCommitInfo* pInfo = (SSyncCommitInfo*)param;
   pInfo->code = code;
-  tsem_post(&pInfo->sem);
+  (void)tsem2_post(&pInfo->sem);
 }
 
 int32_t tmq_commit_sync(tmq_t* tmq, const TAOS_RES* pRes) {
@@ -2467,7 +2617,15 @@ int32_t tmq_commit_sync(tmq_t* tmq, const TAOS_RES* pRes) {
   int32_t code = 0;
 
   SSyncCommitInfo* pInfo = taosMemoryMalloc(sizeof(SSyncCommitInfo));
-  tsem_init(&pInfo->sem, 0, 0);
+  if(pInfo == NULL) {
+    tscError("failed to allocate memory for sync commit");
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  if (tsem2_init(&pInfo->sem, 0, 0) != 0) {
+    tscError("failed to init sem for sync commit");
+    taosMemoryFree(pInfo);
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
   pInfo->code = 0;
 
   if (pRes == NULL) {
@@ -2476,10 +2634,10 @@ int32_t tmq_commit_sync(tmq_t* tmq, const TAOS_RES* pRes) {
     asyncCommitFromResult(tmq, pRes, commitCallBackFn, pInfo);
   }
 
-  tsem_wait(&pInfo->sem);
+  (void)tsem2_wait(&pInfo->sem);
   code = pInfo->code;
 
-  tsem_destroy(&pInfo->sem);
+  (void)tsem2_destroy(&pInfo->sem);
   taosMemoryFree(pInfo);
 
   tscInfo("consumer:0x%" PRIx64 " sync res commit done, code:%s", tmq->consumerId, tstrerror(code));
@@ -2510,7 +2668,7 @@ int32_t tmq_commit_offset_sync(tmq_t* tmq, const char* pTopicName, int32_t vgId,
 
   int32_t accId = tmq->pTscObj->acctId;
   char    tname[TSDB_TOPIC_FNAME_LEN] = {0};
-  sprintf(tname, "%d.%s", accId, pTopicName);
+  (void)snprintf(tname, TSDB_TOPIC_FNAME_LEN, "%d.%s", accId, pTopicName);
 
   taosWLockLatch(&tmq->lock);
   SMqClientVg* pVg = NULL;
@@ -2536,17 +2694,20 @@ int32_t tmq_commit_offset_sync(tmq_t* tmq, const char* pTopicName, int32_t vgId,
     return TSDB_CODE_OUT_OF_MEMORY;
   }
 
-  tsem_init(&pInfo->sem, 0, 0);
+  if (tsem2_init(&pInfo->sem, 0, 0) != 0) {
+    taosMemoryFree(pInfo);
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
   pInfo->code = 0;
 
   code = asyncCommitOffset(tmq, tname, vgId, &offsetVal, commitCallBackFn, pInfo);
   if (code == 0) {
-    tsem_wait(&pInfo->sem);
+    (void)tsem2_wait(&pInfo->sem);
     code = pInfo->code;
   }
 
   if (code == TSDB_CODE_TMQ_SAME_COMMITTED_VALUE) code = TSDB_CODE_SUCCESS;
-  tsem_destroy(&pInfo->sem);
+  (void)tsem2_destroy(&pInfo->sem);
   taosMemoryFree(pInfo);
 
   tscInfo("consumer:0x%" PRIx64 " sync send commit to vgId:%d, offset:%" PRId64 " code:%s", tmq->consumerId, vgId,
@@ -2566,7 +2727,7 @@ void tmq_commit_offset_async(tmq_t* tmq, const char* pTopicName, int32_t vgId, i
 
   int32_t accId = tmq->pTscObj->acctId;
   char    tname[TSDB_TOPIC_FNAME_LEN] = {0};
-  sprintf(tname, "%d.%s", accId, pTopicName);
+  (void)snprintf(tname, TSDB_TOPIC_FNAME_LEN, "%d.%s", accId, pTopicName);
 
   taosWLockLatch(&tmq->lock);
   SMqClientVg* pVg = NULL;
@@ -2620,11 +2781,12 @@ int32_t askEpCb(void* param, SDataBuf* pMsg, int32_t code) {
   tscDebug("consumer:0x%" PRIx64 ", recv ep, msg epoch %d, current epoch %d", tmq->consumerId, head->epoch, epoch);
   if (pParam->sync) {
     SMqAskEpRsp rsp = {0};
-    tDecodeSMqAskEpRsp(POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), &rsp);
-    doUpdateLocalEp(tmq, head->epoch, &rsp);
+    if(tDecodeSMqAskEpRsp(POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), &rsp) != NULL){
+      (void)doUpdateLocalEp(tmq, head->epoch, &rsp);
+    }
     tDeleteSMqAskEpRsp(&rsp);
   } else {
-    SMqAskEpRspWrapper* pWrapper;
+    SMqAskEpRspWrapper* pWrapper = NULL;
     code = taosAllocateQitem(sizeof(SMqAskEpRspWrapper), DEF_QITEM, 0, (void**)&pWrapper);
     if (code) {
       goto END;
@@ -2632,21 +2794,23 @@ int32_t askEpCb(void* param, SDataBuf* pMsg, int32_t code) {
 
     pWrapper->tmqRspType = TMQ_MSG_TYPE__EP_RSP;
     pWrapper->epoch = head->epoch;
-    memcpy(&pWrapper->msg, pMsg->pData, sizeof(SMqRspHead));
-    tDecodeSMqAskEpRsp(POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), &pWrapper->msg);
-
-    taosWriteQitem(tmq->mqueue, pWrapper);
+    (void)memcpy(&pWrapper->msg, pMsg->pData, sizeof(SMqRspHead));
+    if (tDecodeSMqAskEpRsp(POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), &pWrapper->msg) == NULL){
+      taosFreeQitem(pWrapper);
+    }else{
+      (void)taosWriteQitem(tmq->mqueue, pWrapper);
+    }
   }
 
 END:
-  taosReleaseRef(tmqMgmt.rsetId, pParam->refId);
+  (void)taosReleaseRef(tmqMgmt.rsetId, pParam->refId);
 
 FAIL:
   if (pParam->sync) {
     SAskEpInfo* pInfo = pParam->pParam;
     if (pInfo) {
       pInfo->code = code;
-      tsem_post(&pInfo->sem);
+      (void)tsem2_post(&pInfo->sem);
     }
   }
 
@@ -2661,15 +2825,18 @@ FAIL:
 int32_t syncAskEp(tmq_t* pTmq) {
   SAskEpInfo* pInfo = taosMemoryMalloc(sizeof(SAskEpInfo));
   if (pInfo == NULL) return TSDB_CODE_OUT_OF_MEMORY;
-  tsem_init(&pInfo->sem, 0, 0);
+  if (tsem2_init(&pInfo->sem, 0, 0) != 0) {
+    taosMemoryFree(pInfo);
+    return TSDB_CODE_TSC_INTERNAL_ERROR;
+  }
 
   int32_t code = askEp(pTmq, pInfo, true, false);
   if (code == 0) {
-    tsem_wait(&pInfo->sem);
+    (void)tsem2_wait(&pInfo->sem);
     code = pInfo->code;
   }
 
-  tsem_destroy(&pInfo->sem);
+  (void)tsem2_destroy(&pInfo->sem);
   taosMemoryFree(pInfo);
   return code;
 }
@@ -2678,7 +2845,7 @@ int32_t askEp(tmq_t* pTmq, void* param, bool sync, bool updateEpSet) {
   SMqAskEpReq req = {0};
   req.consumerId = pTmq->consumerId;
   req.epoch = updateEpSet ? -1 : pTmq->epoch;
-  strcpy(req.cgroup, pTmq->groupId);
+  (void)strcpy(req.cgroup, pTmq->groupId);
   int              code = 0;
   SMqAskEpCbParam* pParam = NULL;
   void*            pReq = NULL;
@@ -2732,18 +2899,13 @@ int32_t askEp(tmq_t* pTmq, void* param, bool sync, bool updateEpSet) {
   return asyncSendMsgToServer(pTmq->pTscObj->pAppInfo->pTransporter, &epSet, NULL, sendInfo);
 }
 
-int32_t makeTopicVgroupKey(char* dst, const char* topicName, int32_t vg) {
-  return sprintf(dst, "%s:%d", topicName, vg);
-}
-
 int32_t tmqCommitDone(SMqCommitCbParamSet* pParamSet) {
   int64_t refId = pParamSet->refId;
 
   tmq_t* tmq = taosAcquireRef(tmqMgmt.rsetId, refId);
   if (tmq == NULL) {
     taosMemoryFree(pParamSet);
-    terrno = TSDB_CODE_TMQ_CONSUMER_CLOSED;
-    return terrno;
+    return TSDB_CODE_TMQ_CONSUMER_CLOSED;
   }
 
   // if no more waiting rsp
@@ -2752,23 +2914,23 @@ int32_t tmqCommitDone(SMqCommitCbParamSet* pParamSet) {
   }
 
   taosMemoryFree(pParamSet);
-  taosReleaseRef(tmqMgmt.rsetId, refId);
-  return 0;
+  return taosReleaseRef(tmqMgmt.rsetId, refId);
 }
 
-void commitRspCountDown(SMqCommitCbParamSet* pParamSet, int64_t consumerId, const char* pTopic, int32_t vgId) {
+int32_t commitRspCountDown(SMqCommitCbParamSet* pParamSet, int64_t consumerId, const char* pTopic, int32_t vgId) {
   int32_t waitingRspNum = atomic_sub_fetch_32(&pParamSet->waitingRspNum, 1);
   if (waitingRspNum == 0) {
     tscInfo("consumer:0x%" PRIx64 " topic:%s vgId:%d all commit-rsp received, commit completed", consumerId, pTopic,
             vgId);
-    tmqCommitDone(pParamSet);
+    return tmqCommitDone(pParamSet);
   } else {
     tscInfo("consumer:0x%" PRIx64 " topic:%s vgId:%d commit-rsp received, remain:%d", consumerId, pTopic, vgId,
             waitingRspNum);
   }
+  return 0;
 }
 
-SReqResultInfo* tmqGetNextResInfo(TAOS_RES* res, bool convertUcs4) {
+int32_t tmqGetNextResInfo(TAOS_RES* res, bool convertUcs4, SReqResultInfo** pResInfo) {
   SMqDataRspCommon* common = (SMqDataRspCommon*)POINTER_SHIFT(res, sizeof(SMqRspObjCommon));
   SMqRspObjCommon*  pRspObj = (SMqRspObjCommon*)res;
   pRspObj->resIter++;
@@ -2776,7 +2938,9 @@ SReqResultInfo* tmqGetNextResInfo(TAOS_RES* res, bool convertUcs4) {
     if (common->withSchema) {
       doFreeReqResultInfo(&pRspObj->resInfo);
       SSchemaWrapper* pSW = (SSchemaWrapper*)taosArrayGetP(common->blockSchema, pRspObj->resIter);
-      setResSchemaInfo(&pRspObj->resInfo, pSW->pSchema, pSW->nCols);
+      if (pSW){
+        setResSchemaInfo(&pRspObj->resInfo, pSW->pSchema, pSW->nCols);
+      }
     }
 
     void*   pRetrieve = taosArrayGetP(common->blockData, pRspObj->resIter);
@@ -2790,15 +2954,17 @@ SReqResultInfo* tmqGetNextResInfo(TAOS_RES* res, bool convertUcs4) {
     pRspObj->resInfo.current = 0;
     pRspObj->resInfo.precision = precision;
 
-    // TODO handle the compressed case
     pRspObj->resInfo.totalRows += pRspObj->resInfo.numOfRows;
-    setResultDataPtr(&pRspObj->resInfo, pRspObj->resInfo.fields, pRspObj->resInfo.numOfCols, pRspObj->resInfo.numOfRows,
+    int32_t code = setResultDataPtr(&pRspObj->resInfo, pRspObj->resInfo.fields, pRspObj->resInfo.numOfCols, pRspObj->resInfo.numOfRows,
                      convertUcs4);
-
-    return &pRspObj->resInfo;
+    if (code != 0){
+      return code;
+    }
+    *pResInfo = &pRspObj->resInfo;
+    return code;
   }
 
-  return NULL;
+  return TSDB_CODE_TSC_INTERNAL_ERROR;
 }
 
 static int32_t tmqGetWalInfoCb(void* param, SDataBuf* pMsg, int32_t code) {
@@ -2812,28 +2978,36 @@ static int32_t tmqGetWalInfoCb(void* param, SDataBuf* pMsg, int32_t code) {
   if (code != TSDB_CODE_SUCCESS) {
     tscError("consumer:0x%" PRIx64 " failed to get the wal info from vgId:%d for topic:%s", pCommon->consumerId,
              pParam->vgId, pCommon->pTopicName);
-    pCommon->code = code;
+
   } else {
-    SMqDataRsp rsp;
-    SDecoder   decoder;
+    SMqDataRsp rsp = {0};
+    SDecoder   decoder = {0};
     tDecoderInit(&decoder, POINTER_SHIFT(pMsg->pData, sizeof(SMqRspHead)), pMsg->len - sizeof(SMqRspHead));
-    tDecodeMqDataRsp(&decoder, &rsp);
+    code = tDecodeMqDataRsp(&decoder, &rsp);
     tDecoderClear(&decoder);
+    if (code != 0){
+      goto END;
+    }
 
     SMqRspHead* pHead = pMsg->pData;
-
     tmq_topic_assignment assignment = {.begin = pHead->walsver,
                                        .end = pHead->walever + 1,
                                        .currentOffset = rsp.common.rspOffset.version,
                                        .vgId = pParam->vgId};
 
-    taosThreadMutexLock(&pCommon->mutex);
-    taosArrayPush(pCommon->pList, &assignment);
-    taosThreadMutexUnlock(&pCommon->mutex);
+    (void)taosThreadMutexLock(&pCommon->mutex);
+    if(taosArrayPush(pCommon->pList, &assignment) == NULL){
+      tscError("consumer:0x%" PRIx64 " failed to push the wal info from vgId:%d for topic:%s", pCommon->consumerId,
+               pParam->vgId, pCommon->pTopicName);
+      code = TSDB_CODE_TSC_INTERNAL_ERROR;
+    }
+    (void)taosThreadMutexUnlock(&pCommon->mutex);
   }
 
+END:
+  pCommon->code = code;
   if (total == pParam->totalReq) {
-    tsem_post(&pCommon->rsp);
+    (void)tsem2_post(&pCommon->rsp);
   }
 
   if (pMsg) {
@@ -2841,16 +3015,16 @@ static int32_t tmqGetWalInfoCb(void* param, SDataBuf* pMsg, int32_t code) {
     taosMemoryFree(pMsg->pEpSet);
   }
 
-  return 0;
+  return code;
 }
 
 static void destroyCommonInfo(SMqVgCommon* pCommon) {
   if (pCommon == NULL) {
     return;
   }
-  taosArrayDestroy(pCommon->pList);
-  tsem_destroy(&pCommon->rsp);
-  taosThreadMutexDestroy(&pCommon->mutex);
+  (void)taosArrayDestroy(pCommon->pList);
+  (void)tsem2_destroy(&pCommon->rsp);
+  (void)taosThreadMutexDestroy(&pCommon->mutex);
   taosMemoryFree(pCommon->pTopicName);
   taosMemoryFree(pCommon);
 }
@@ -2869,7 +3043,7 @@ static int32_t tmCommittedCb(void* param, SDataBuf* pMsg, int32_t code) {
     goto end;
   }
   if (pMsg) {
-    SDecoder decoder;
+    SDecoder decoder = {0};
     tDecoderInit(&decoder, (uint8_t*)pMsg->pData, pMsg->len);
     if (tDecodeMqVgOffset(&decoder, &pParam->vgOffset) < 0) {
       tOffsetDestroy(&pParam->vgOffset.offset);
@@ -2885,8 +3059,8 @@ end:
     taosMemoryFree(pMsg->pEpSet);
   }
   pParam->code = code;
-  tsem_post(&pParam->sem);
-  return 0;
+  (void)tsem2_post(&pParam->sem);
+  return code;
 }
 
 int64_t getCommittedFromServer(tmq_t* tmq, char* tname, int32_t vgId, SEpSet* epSet) {
@@ -2913,7 +3087,12 @@ int64_t getCommittedFromServer(tmq_t* tmq, char* tname, int32_t vgId, SEpSet* ep
 
   SEncoder encoder;
   tEncoderInit(&encoder, abuf, len);
-  tEncodeMqVgOffset(&encoder, &pOffset);
+  code = tEncodeMqVgOffset(&encoder, &pOffset);
+  if (code < 0) {
+    taosMemoryFree(buf);
+    tEncoderClear(&encoder);
+    return code;
+  }
   tEncoderClear(&encoder);
 
   SMsgSendInfo* sendInfo = taosMemoryCalloc(1, sizeof(SMsgSendInfo));
@@ -2928,7 +3107,12 @@ int64_t getCommittedFromServer(tmq_t* tmq, char* tname, int32_t vgId, SEpSet* ep
     taosMemoryFree(sendInfo);
     return TSDB_CODE_OUT_OF_MEMORY;
   }
-  tsem_init(&pParam->sem, 0, 0);
+  if (tsem2_init(&pParam->sem, 0, 0) != 0){
+    taosMemoryFree(buf);
+    taosMemoryFree(sendInfo);
+    taosMemoryFree(pParam);
+    return TSDB_CODE_TSC_INTERNAL_ERROR;
+  }
 
   sendInfo->msgInfo = (SDataBuf){.pData = buf, .len = sizeof(SMsgHead) + len, .handle = NULL};
   sendInfo->requestId = generateRequestId();
@@ -2940,12 +3124,12 @@ int64_t getCommittedFromServer(tmq_t* tmq, char* tname, int32_t vgId, SEpSet* ep
   int64_t transporterId = 0;
   code = asyncSendMsgToServer(tmq->pTscObj->pAppInfo->pTransporter, epSet, &transporterId, sendInfo);
   if (code != 0) {
-    tsem_destroy(&pParam->sem);
+    (void)tsem2_destroy(&pParam->sem);
     taosMemoryFree(pParam);
     return code;
   }
 
-  tsem_wait(&pParam->sem);
+  (void)tsem2_wait(&pParam->sem);
   code = pParam->code;
   if (code == TSDB_CODE_SUCCESS) {
     if (pParam->vgOffset.offset.val.type == TMQ_OFFSET__LOG) {
@@ -2955,7 +3139,7 @@ int64_t getCommittedFromServer(tmq_t* tmq, char* tname, int32_t vgId, SEpSet* ep
       code = TSDB_CODE_TMQ_SNAPSHOT_ERROR;
     }
   }
-  tsem_destroy(&pParam->sem);
+  (void)tsem2_destroy(&pParam->sem);
   taosMemoryFree(pParam);
 
   return code;
@@ -2969,7 +3153,7 @@ int64_t tmq_position(tmq_t* tmq, const char* pTopicName, int32_t vgId) {
 
   int32_t accId = tmq->pTscObj->acctId;
   char    tname[TSDB_TOPIC_FNAME_LEN] = {0};
-  sprintf(tname, "%d.%s", accId, pTopicName);
+  (void)snprintf(tname, TSDB_TOPIC_FNAME_LEN, "%d.%s", accId, pTopicName);
 
   taosWLockLatch(&tmq->lock);
 
@@ -3028,7 +3212,7 @@ int64_t tmq_committed(tmq_t* tmq, const char* pTopicName, int32_t vgId) {
 
   int32_t accId = tmq->pTscObj->acctId;
   char    tname[TSDB_TOPIC_FNAME_LEN] = {0};
-  sprintf(tname, "%d.%s", accId, pTopicName);
+  (void)snprintf(tname, TSDB_TOPIC_FNAME_LEN, "%d.%s", accId, pTopicName);
 
   taosWLockLatch(&tmq->lock);
 
@@ -3082,13 +3266,14 @@ int32_t tmq_get_topic_assignment(tmq_t* tmq, const char* pTopicName, tmq_topic_a
 
   int32_t accId = tmq->pTscObj->acctId;
   char    tname[TSDB_TOPIC_FNAME_LEN] = {0};
-  sprintf(tname, "%d.%s", accId, pTopicName);
-  int32_t code = TSDB_CODE_SUCCESS;
+  (void)snprintf(tname, TSDB_TOPIC_FNAME_LEN, "%d.%s", accId, pTopicName);
 
   taosWLockLatch(&tmq->lock);
-  SMqClientTopic* pTopic = getTopicByName(tmq, tname);
-  if (pTopic == NULL) {
-    code = TSDB_CODE_TMQ_INVALID_TOPIC;
+
+  SMqClientTopic* pTopic = NULL;
+  int32_t code = getTopicByName(tmq, tname, &pTopic);
+  if (code != 0) {
+    tscError("consumer:0x%" PRIx64 " invalid topic name:%s", tmq->consumerId, pTopicName);
     goto end;
   }
 
@@ -3096,6 +3281,9 @@ int32_t tmq_get_topic_assignment(tmq_t* tmq, const char* pTopicName, tmq_topic_a
   *numOfAssignment = taosArrayGetSize(pTopic->vgs);
   for (int32_t j = 0; j < (*numOfAssignment); ++j) {
     SMqClientVg* pClientVg = taosArrayGet(pTopic->vgs, j);
+    if (pClientVg == NULL){
+      continue;
+    }
     int32_t      type = pClientVg->offsetInfo.beginOffset.type;
     if (isInSnapshotMode(type, tmq->useSnapshot)) {
       tscError("consumer:0x%" PRIx64 " offset type:%d not wal version, assignment not allowed", tmq->consumerId, type);
@@ -3116,6 +3304,9 @@ int32_t tmq_get_topic_assignment(tmq_t* tmq, const char* pTopicName, tmq_topic_a
 
   for (int32_t j = 0; j < (*numOfAssignment); ++j) {
     SMqClientVg* pClientVg = taosArrayGet(pTopic->vgs, j);
+    if (pClientVg == NULL){
+      continue;
+    }
     if (pClientVg->offsetInfo.beginOffset.type != TMQ_OFFSET__LOG) {
       needFetch = true;
       break;
@@ -3133,24 +3324,31 @@ int32_t tmq_get_topic_assignment(tmq_t* tmq, const char* pTopicName, tmq_topic_a
   if (needFetch) {
     pCommon = taosMemoryCalloc(1, sizeof(SMqVgCommon));
     if (pCommon == NULL) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      code = terrno;
+      code = TSDB_CODE_OUT_OF_MEMORY;
       goto end;
     }
 
     pCommon->pList = taosArrayInit(4, sizeof(tmq_topic_assignment));
-    tsem_init(&pCommon->rsp, 0, 0);
-    taosThreadMutexInit(&pCommon->mutex, 0);
+    if (pCommon->pList == NULL) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      goto end;
+    }
+    if (tsem2_init(&pCommon->rsp, 0, 0) != 0){
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      goto end;
+    }
+    (void)taosThreadMutexInit(&pCommon->mutex, 0);
     pCommon->pTopicName = taosStrdup(pTopic->topicName);
     pCommon->consumerId = tmq->consumerId;
 
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
     for (int32_t i = 0; i < (*numOfAssignment); ++i) {
       SMqClientVg* pClientVg = taosArrayGet(pTopic->vgs, i);
-
+      if (pClientVg == NULL){
+        continue;
+      }
       SMqVgWalInfoParam* pParam = taosMemoryMalloc(sizeof(SMqVgWalInfoParam));
       if (pParam == NULL) {
-        code = terrno;
+        code = TSDB_CODE_OUT_OF_MEMORY;
         goto end;
       }
 
@@ -3166,21 +3364,21 @@ int32_t tmq_get_topic_assignment(tmq_t* tmq, const char* pTopicName, tmq_topic_a
       int32_t msgSize = tSerializeSMqPollReq(NULL, 0, &req);
       if (msgSize < 0) {
         taosMemoryFree(pParam);
-        code = terrno;
+        code = TSDB_CODE_OUT_OF_MEMORY;
         goto end;
       }
 
       char* msg = taosMemoryCalloc(1, msgSize);
       if (NULL == msg) {
         taosMemoryFree(pParam);
-        code = terrno;
+        code = TSDB_CODE_OUT_OF_MEMORY;
         goto end;
       }
 
       if (tSerializeSMqPollReq(msg, msgSize, &req) < 0) {
         taosMemoryFree(msg);
         taosMemoryFree(pParam);
-        code = terrno;
+        code = TSDB_CODE_OUT_OF_MEMORY;
         goto end;
       }
 
@@ -3188,7 +3386,7 @@ int32_t tmq_get_topic_assignment(tmq_t* tmq, const char* pTopicName, tmq_topic_a
       if (sendInfo == NULL) {
         taosMemoryFree(pParam);
         taosMemoryFree(msg);
-        code = terrno;
+        code = TSDB_CODE_OUT_OF_MEMORY;
         goto end;
       }
 
@@ -3202,7 +3400,7 @@ int32_t tmq_get_topic_assignment(tmq_t* tmq, const char* pTopicName, tmq_topic_a
 
       int64_t transporterId = 0;
       char    offsetFormatBuf[TSDB_OFFSET_LEN] = {0};
-      tFormatOffset(offsetFormatBuf, tListLen(offsetFormatBuf), &pClientVg->offsetInfo.beginOffset);
+      (void)tFormatOffset(offsetFormatBuf, tListLen(offsetFormatBuf), &pClientVg->offsetInfo.beginOffset);
 
       tscInfo("consumer:0x%" PRIx64 " %s retrieve wal info vgId:%d, epoch %d, req:%s, reqId:0x%" PRIx64,
               tmq->consumerId, pTopic->topicName, pClientVg->vgId, tmq->epoch, offsetFormatBuf, req.reqId);
@@ -3212,10 +3410,9 @@ int32_t tmq_get_topic_assignment(tmq_t* tmq, const char* pTopicName, tmq_topic_a
       }
     }
 
-    tsem_wait(&pCommon->rsp);
+    (void)tsem2_wait(&pCommon->rsp);
     code = pCommon->code;
 
-    terrno = code;
     if (code != TSDB_CODE_SUCCESS) {
       goto end;
     }
@@ -3230,6 +3427,9 @@ int32_t tmq_get_topic_assignment(tmq_t* tmq, const char* pTopicName, tmq_topic_a
 
       for (int32_t i = 0; i < taosArrayGetSize(pTopic->vgs); ++i) {
         SMqClientVg* pClientVg = taosArrayGet(pTopic->vgs, i);
+        if (pClientVg == NULL){
+          continue;
+        }
         if (pClientVg->vgId != p->vgId) {
           continue;
         }
@@ -3273,7 +3473,7 @@ static int32_t tmqSeekCb(void* param, SDataBuf* pMsg, int32_t code) {
   }
   SMqSeekParam* pParam = param;
   pParam->code = code;
-  tsem_post(&pParam->sem);
+  (void)tsem2_post(&pParam->sem);
   return 0;
 }
 
@@ -3287,7 +3487,7 @@ int32_t tmq_offset_seek(tmq_t* tmq, const char* pTopicName, int32_t vgId, int64_
 
   int32_t accId = tmq->pTscObj->acctId;
   char    tname[TSDB_TOPIC_FNAME_LEN] = {0};
-  sprintf(tname, "%d.%s", accId, pTopicName);
+  (void)snprintf(tname, TSDB_TOPIC_FNAME_LEN, "%d.%s", accId, pTopicName);
 
   taosWLockLatch(&tmq->lock);
 
@@ -3323,7 +3523,7 @@ int32_t tmq_offset_seek(tmq_t* tmq, const char* pTopicName, int32_t vgId, int64_
   taosWUnLockLatch(&tmq->lock);
 
   SMqSeekReq req = {0};
-  snprintf(req.subKey, TSDB_SUBSCRIBE_KEY_LEN, "%s:%s", tmq->groupId, tname);
+  (void)snprintf(req.subKey, TSDB_SUBSCRIBE_KEY_LEN, "%s:%s", tmq->groupId, tname);
   req.head.vgId = vgId;
   req.consumerId = tmq->consumerId;
 
@@ -3354,7 +3554,12 @@ int32_t tmq_offset_seek(tmq_t* tmq, const char* pTopicName, int32_t vgId, int64_
     taosMemoryFree(sendInfo);
     return TSDB_CODE_OUT_OF_MEMORY;
   }
-  tsem_init(&pParam->sem, 0, 0);
+  if (tsem2_init(&pParam->sem, 0, 0) != 0){
+    taosMemoryFree(msg);
+    taosMemoryFree(sendInfo);
+    taosMemoryFree(pParam);
+    return TSDB_CODE_TSC_INTERNAL_ERROR;
+  }
 
   sendInfo->msgInfo = (SDataBuf){.pData = msg, .len = msgSize, .handle = NULL};
   sendInfo->requestId = generateRequestId();
@@ -3366,14 +3571,14 @@ int32_t tmq_offset_seek(tmq_t* tmq, const char* pTopicName, int32_t vgId, int64_
   int64_t transporterId = 0;
   code = asyncSendMsgToServer(tmq->pTscObj->pAppInfo->pTransporter, &epSet, &transporterId, sendInfo);
   if (code != 0) {
-    tsem_destroy(&pParam->sem);
+    (void)tsem2_destroy(&pParam->sem);
     taosMemoryFree(pParam);
     return code;
   }
 
-  tsem_wait(&pParam->sem);
+  (void)tsem2_wait(&pParam->sem);
   code = pParam->code;
-  tsem_destroy(&pParam->sem);
+  (void)tsem2_destroy(&pParam->sem);
   taosMemoryFree(pParam);
 
   tscInfo("consumer:0x%" PRIx64 "send seek to vgId:%d, return code:%s", tmq->consumerId, vgId, tstrerror(code));
diff --git a/source/common/src/tglobal.c b/source/common/src/tglobal.c
index 44eec0852d..3007214ae8 100644
--- a/source/common/src/tglobal.c
+++ b/source/common/src/tglobal.c
@@ -1263,8 +1263,8 @@ int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDi
                       const char *envFile, char *apolloUrl, SArray *pArgs, bool tsc) {
   if (tsCfg == NULL) osDefaultInit();
 
-  SConfig *pCfg = cfgInit();
-  if (pCfg == NULL) return -1;
+  SConfig *pCfg = NULL;
+  TAOS_CHECK_RETURN(cfgInit(&pCfg));
 
   if (tsc) {
     tsLogEmbedded = 0;
@@ -1325,8 +1325,8 @@ int32_t taosReadDataFolder(const char *cfgDir, const char **envCmd, const char *
                            SArray *pArgs) {
   if (tsCfg == NULL) osDefaultInit();
 
-  SConfig *pCfg = cfgInit();
-  if (pCfg == NULL) return -1;
+  SConfig *pCfg = NULL;
+  TAOS_CHECK_RETURN(cfgInit(&pCfg));
 
   if (cfgAddDir(pCfg, "dataDir", tsDataDir, CFG_SCOPE_SERVER, CFG_DYN_NONE) != 0) return -1;
   if (cfgAddInt32(pCfg, "dDebugFlag", dDebugFlag, 0, 255, CFG_SCOPE_SERVER, CFG_DYN_SERVER) != 0) return -1;
@@ -1371,10 +1371,7 @@ static int32_t taosCheckGlobalCfg() {
 
 static int32_t cfgInitWrapper(SConfig **pCfg) {
   if (*pCfg == NULL) {
-    *pCfg = cfgInit();
-    if (*pCfg == NULL) {
-      return terrno;
-    }
+    TAOS_CHECK_RETURN(cfgInit(pCfg));
   }
   return 0;
 }
diff --git a/source/common/src/tmisce.c b/source/common/src/tmisce.c
index 154fcc3f6b..dd371c6a2a 100644
--- a/source/common/src/tmisce.c
+++ b/source/common/src/tmisce.c
@@ -270,11 +270,7 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
 
   TAOS_CHECK_GOTO(blockDataEnsureCapacity(pBlock, cfgGetSize(pConf)), NULL, _exit);
 
-  pIter = cfgCreateIter(pConf);
-  if (pIter == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
-    TAOS_CHECK_GOTO(code, NULL, _exit);
-  }
+  TAOS_CHECK_GOTO(cfgCreateIter(pConf, &pIter), NULL, _exit);
 
   cfgLock(pConf);
   locked = 1;
@@ -296,7 +292,7 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
 
     char    value[TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE] = {0};
     int32_t valueLen = 0;
-    cfgDumpItemValue(pItem, &value[VARSTR_HEADER_SIZE], TSDB_CONFIG_VALUE_LEN, &valueLen);
+    TAOS_CHECK_GOTO(cfgDumpItemValue(pItem, &value[VARSTR_HEADER_SIZE], TSDB_CONFIG_VALUE_LEN, &valueLen), NULL, _exit);
     varDataSetLen(value, valueLen);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, col++);
@@ -308,7 +304,7 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
     TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, value, false), NULL, _exit);
 
     char scope[TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE] = {0};
-    cfgDumpItemScope(pItem, &scope[VARSTR_HEADER_SIZE], TSDB_CONFIG_SCOPE_LEN, &valueLen);
+    TAOS_CHECK_GOTO(cfgDumpItemScope(pItem, &scope[VARSTR_HEADER_SIZE], TSDB_CONFIG_SCOPE_LEN, &valueLen), NULL, _exit);
     varDataSetLen(scope, valueLen);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, col++);
diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c
index a15afa64db..0b26f5e888 100644
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -9248,7 +9248,7 @@ void tOffsetCopy(STqOffsetVal *pLeft, const STqOffsetVal *pRight) {
   *pLeft = *pRight;
   if (IS_VAR_DATA_TYPE(pRight->primaryKey.type)) {
     pLeft->primaryKey.pData = taosMemoryMalloc(pRight->primaryKey.nData);
-    memcpy(pLeft->primaryKey.pData, pRight->primaryKey.pData, pRight->primaryKey.nData);
+    (void)memcpy(pLeft->primaryKey.pData, pRight->primaryKey.pData, pRight->primaryKey.nData);
   }
 }
 
diff --git a/source/common/src/ttime.c b/source/common/src/ttime.c
index 4fca564804..d3207a1912 100644
--- a/source/common/src/ttime.c
+++ b/source/common/src/ttime.c
@@ -96,8 +96,6 @@ char* forwardToTimeStringEnd(char* str) {
 }
 
 int32_t parseFraction(char* str, char** end, int32_t timePrec, int64_t* pFraction) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   int32_t i = 0;
   int64_t fraction = 0;
 
@@ -147,8 +145,6 @@ int32_t parseFraction(char* str, char** end, int32_t timePrec, int64_t* pFractio
 }
 
 int32_t parseTimezone(char* str, int64_t* tzOffset) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   int64_t hour = 0;
 
   int32_t i = 0;
@@ -224,8 +220,6 @@ int32_t offsetOfTimezone(char* tzStr, int64_t* offset) {
  * 2013-04-12T15:52:01.123+0800
  */
 int32_t parseTimeWithTz(const char* timestr, int64_t* time, int32_t timePrec, char delim) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   int64_t factor = TSDB_TICK_PER_SECOND(timePrec);
   int64_t tzOffset = 0;
 
@@ -315,8 +309,6 @@ static FORCE_INLINE bool validateTm(struct tm* pTm) {
 }
 
 int32_t parseLocaltime(char* timestr, int32_t len, int64_t* utime, int32_t timePrec, char delim) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   *utime = 0;
   struct tm tm = {0};
 
@@ -358,8 +350,6 @@ int32_t parseLocaltime(char* timestr, int32_t len, int64_t* utime, int32_t timeP
 }
 
 int32_t parseLocaltimeDst(char* timestr, int32_t len, int64_t* utime, int32_t timePrec, char delim) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   *utime = 0;
   struct tm tm = {0};
   tm.tm_isdst = -1;
@@ -484,8 +474,6 @@ int64_t convertTimePrecision(int64_t utime, int32_t fromPrecision, int32_t toPre
 // !!!!notice: double lose precison if time is too large, for example: 1626006833631000000*1.0 = double =
 // 1626006833631000064
 int32_t convertTimeFromPrecisionToUnit(int64_t time, int32_t fromPrecision, char toUnit, int64_t* pRes) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   if (fromPrecision != TSDB_TIME_PRECISION_MILLI && fromPrecision != TSDB_TIME_PRECISION_MICRO &&
       fromPrecision != TSDB_TIME_PRECISION_NANO) {
     TAOS_RETURN(TSDB_CODE_INVALID_PARA);
@@ -559,13 +547,14 @@ int32_t convertTimeFromPrecisionToUnit(int64_t time, int32_t fromPrecision, char
 }
 
 int32_t convertStringToTimestamp(int16_t type, char* inputData, int64_t timePrec, int64_t* timeVal) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   int32_t charLen = varDataLen(inputData);
   char*   newColData;
   if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_VARBINARY) {
     newColData = taosMemoryCalloc(1, charLen + 1);
-    memcpy(newColData, varDataVal(inputData), charLen);
+    if (NULL == newColData) {
+      TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    }
+    (void)memcpy(newColData, varDataVal(inputData), charLen);
     int32_t ret = taosParseTime(newColData, timeVal, charLen, (int32_t)timePrec, tsDaylight);
     if (ret != TSDB_CODE_SUCCESS) {
       taosMemoryFree(newColData);
@@ -574,6 +563,9 @@ int32_t convertStringToTimestamp(int16_t type, char* inputData, int64_t timePrec
     taosMemoryFree(newColData);
   } else if (type == TSDB_DATA_TYPE_NCHAR) {
     newColData = taosMemoryCalloc(1, charLen + TSDB_NCHAR_SIZE);
+    if (NULL == newColData) {
+      TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    }
     int len = taosUcs4ToMbs((TdUcs4*)varDataVal(inputData), charLen, newColData);
     if (len < 0) {
       taosMemoryFree(newColData);
@@ -593,8 +585,6 @@ int32_t convertStringToTimestamp(int16_t type, char* inputData, int64_t timePrec
 }
 
 int32_t getDuration(int64_t val, char unit, int64_t* result, int32_t timePrecision) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   switch (unit) {
     case 's':
       if (val > INT64_MAX / MILLISECOND_PER_SECOND) {
@@ -658,8 +648,6 @@ int32_t getDuration(int64_t val, char unit, int64_t* result, int32_t timePrecisi
  */
 int32_t parseAbsoluteDuration(const char* token, int32_t tokenlen, int64_t* duration, char* unit,
                               int32_t timePrecision) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   errno = 0;
   char* endPtr = NULL;
 
@@ -680,8 +668,6 @@ int32_t parseAbsoluteDuration(const char* token, int32_t tokenlen, int64_t* dura
 
 int32_t parseNatualDuration(const char* token, int32_t tokenLen, int64_t* duration, char* unit, int32_t timePrecision,
                             bool negativeAllow) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   errno = 0;
 
   /* get the basic numeric value */
@@ -718,7 +704,7 @@ int64_t taosTimeAdd(int64_t t, int64_t duration, char unit, int32_t precision) {
 
   struct tm tm;
   time_t    tt = (time_t)(t / TSDB_TICK_PER_SECOND(precision));
-  taosLocalTime(&tt, &tm, NULL);
+  (void)taosLocalTime(&tt, &tm, NULL);
   int32_t mon = tm.tm_year * 12 + tm.tm_mon + (int32_t)numOfMonth;
   tm.tm_year = mon / 12;
   tm.tm_mon = mon % 12;
@@ -779,11 +765,11 @@ int32_t taosTimeCountIntervalForFill(int64_t skey, int64_t ekey, int64_t interva
 
     struct tm tm;
     time_t    t = (time_t)skey;
-    taosLocalTime(&t, &tm, NULL);
+    (void)taosLocalTime(&t, &tm, NULL);
     int32_t smon = tm.tm_year * 12 + tm.tm_mon;
 
     t = (time_t)ekey;
-    taosLocalTime(&t, &tm, NULL);
+    (void)taosLocalTime(&t, &tm, NULL);
     int32_t emon = tm.tm_year * 12 + tm.tm_mon;
 
     if (unit == 'y') {
@@ -808,7 +794,7 @@ int64_t taosTimeTruncate(int64_t ts, const SInterval* pInterval) {
     start /= (int64_t)(TSDB_TICK_PER_SECOND(precision));
     struct tm tm;
     time_t    tt = (time_t)start;
-    taosLocalTime(&tt, &tm, NULL);
+    (void)taosLocalTime(&tt, &tm, NULL);
     tm.tm_sec = 0;
     tm.tm_min = 0;
     tm.tm_hour = 0;
@@ -978,8 +964,6 @@ const char* fmtts(int64_t ts) {
 }
 
 int32_t taosFormatUtcTime(char* buf, int32_t bufLen, int64_t t, int32_t precision) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   char      ts[40] = {0};
   struct tm ptm;
 
@@ -1018,7 +1002,7 @@ int32_t taosFormatUtcTime(char* buf, int32_t bufLen, int64_t t, int32_t precisio
       TAOS_RETURN(TSDB_CODE_INVALID_PARA);
   }
 
-  if (taosLocalTime(&quot, &ptm, buf) == NULL) {
+  if (NULL == taosLocalTime(&quot, &ptm, buf)) {
     TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
   }
   int32_t length = (int32_t)strftime(ts, 40, "%Y-%m-%dT%H:%M:%S", &ptm);
@@ -1032,7 +1016,9 @@ int32_t taosFormatUtcTime(char* buf, int32_t bufLen, int64_t t, int32_t precisio
 int32_t taosTs2Tm(int64_t ts, int32_t precision, struct STm* tm) {
   tm->fsec = ts % TICK_PER_SECOND[precision] * (TICK_PER_SECOND[TSDB_TIME_PRECISION_NANO] / TICK_PER_SECOND[precision]);
   time_t t = ts / TICK_PER_SECOND[precision];
-  taosLocalTime(&t, &tm->tm, NULL);
+  if (NULL == taosLocalTime(&t, &tm->tm, NULL)) {
+    TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
+  }
   return TSDB_CODE_SUCCESS;
 }
 
@@ -1344,7 +1330,7 @@ static int32_t tm2char(const SArray* formats, const struct STm* tm, char* s, int
     TSFormatNode* format = taosArrayGet(formats, i);
     if (format->type != TS_FORMAT_NODE_TYPE_KEYWORD) {
       if (s - start + format->len + 1 > outLen) break;
-      strncpy(s, format->c, format->len);
+      (void)strncpy(s, format->c, format->len);
       s += format->len;
       continue;
     }
@@ -1353,37 +1339,37 @@ static int32_t tm2char(const SArray* formats, const struct STm* tm, char* s, int
     switch (format->key->id) {
       case TSFKW_AM:
       case TSFKW_PM:
-        sprintf(s, tm->tm.tm_hour % 24 >= 12 ? "PM" : "AM");
+        (void)sprintf(s, tm->tm.tm_hour % 24 >= 12 ? "PM" : "AM");
         s += 2;
         break;
       case TSFKW_A_M:
       case TSFKW_P_M:
-        sprintf(s, tm->tm.tm_hour % 24 >= 12 ? "P.M." : "A.M.");
+        (void)sprintf(s, tm->tm.tm_hour % 24 >= 12 ? "P.M." : "A.M.");
         s += 4;
         break;
       case TSFKW_am:
       case TSFKW_pm:
-        sprintf(s, tm->tm.tm_hour % 24 >= 12 ? "pm" : "am");
+        (void)sprintf(s, tm->tm.tm_hour % 24 >= 12 ? "pm" : "am");
         s += 2;
         break;
       case TSFKW_a_m:
       case TSFKW_p_m:
-        sprintf(s, tm->tm.tm_hour % 24 >= 12 ? "p.m." : "a.m.");
+        (void)sprintf(s, tm->tm.tm_hour % 24 >= 12 ? "p.m." : "a.m.");
         s += 4;
         break;
       case TSFKW_DDD:
 #ifdef WINDOWS
         return TSDB_CODE_FUNC_TO_CHAR_NOT_SUPPORTED;
 #endif
-        sprintf(s, "%03d", tm->tm.tm_yday + 1);
+        (void)sprintf(s, "%03d", tm->tm.tm_yday + 1);
         s += strlen(s);
         break;
       case TSFKW_DD:
-        sprintf(s, "%02d", tm->tm.tm_mday);
+        (void)sprintf(s, "%02d", tm->tm.tm_mday);
         s += 2;
         break;
       case TSFKW_D:
-        sprintf(s, "%d", tm->tm.tm_wday + 1);
+        (void)sprintf(s, "%d", tm->tm.tm_wday + 1);
         s += 1;
         break;
       case TSFKW_DAY: {
@@ -1391,20 +1377,20 @@ static int32_t tm2char(const SArray* formats, const struct STm* tm, char* s, int
         const char* wd = weekDays[tm->tm.tm_wday];
         char        buf[10] = {0};
         for (int32_t i = 0; i < strlen(wd); ++i) buf[i] = toupper(wd[i]);
-        sprintf(s, "%-9s", buf);
+        (void)sprintf(s, "%-9s", buf);
         s += strlen(s);
         break;
       }
       case TSFKW_Day:
         // Monday, TuesDay...
-        sprintf(s, "%-9s", weekDays[tm->tm.tm_wday]);
+        (void)sprintf(s, "%-9s", weekDays[tm->tm.tm_wday]);
         s += strlen(s);
         break;
       case TSFKW_day: {
         const char* wd = weekDays[tm->tm.tm_wday];
         char        buf[10] = {0};
         for (int32_t i = 0; i < strlen(wd); ++i) buf[i] = tolower(wd[i]);
-        sprintf(s, "%-9s", buf);
+        (void)sprintf(s, "%-9s", buf);
         s += strlen(s);
         break;
       }
@@ -1413,13 +1399,13 @@ static int32_t tm2char(const SArray* formats, const struct STm* tm, char* s, int
         const char* wd = shortWeekDays[tm->tm.tm_wday];
         char        buf[8] = {0};
         for (int32_t i = 0; i < strlen(wd); ++i) buf[i] = toupper(wd[i]);
-        sprintf(s, "%3s", buf);
+        (void)sprintf(s, "%3s", buf);
         s += 3;
         break;
       }
       case TSFKW_Dy:
         // Mon, Tue
-        sprintf(s, "%3s", shortWeekDays[tm->tm.tm_wday]);
+        (void)sprintf(s, "%3s", shortWeekDays[tm->tm.tm_wday]);
         s += 3;
         break;
       case TSFKW_dy: {
@@ -1427,33 +1413,33 @@ static int32_t tm2char(const SArray* formats, const struct STm* tm, char* s, int
         const char* wd = shortWeekDays[tm->tm.tm_wday];
         char        buf[8] = {0};
         for (int32_t i = 0; i < strlen(wd); ++i) buf[i] = tolower(wd[i]);
-        sprintf(s, "%3s", buf);
+        (void)sprintf(s, "%3s", buf);
         s += 3;
         break;
       }
       case TSFKW_HH24:
-        sprintf(s, "%02d", tm->tm.tm_hour);
+        (void)sprintf(s, "%02d", tm->tm.tm_hour);
         s += 2;
         break;
       case TSFKW_HH:
       case TSFKW_HH12:
         // 0 or 12 o'clock in 24H coresponds to 12 o'clock (AM/PM) in 12H
-        sprintf(s, "%02d", tm->tm.tm_hour % 12 == 0 ? 12 : tm->tm.tm_hour % 12);
+        (void)sprintf(s, "%02d", tm->tm.tm_hour % 12 == 0 ? 12 : tm->tm.tm_hour % 12);
         s += 2;
         break;
       case TSFKW_MI:
-        sprintf(s, "%02d", tm->tm.tm_min);
+        (void)sprintf(s, "%02d", tm->tm.tm_min);
         s += 2;
         break;
       case TSFKW_MM:
-        sprintf(s, "%02d", tm->tm.tm_mon + 1);
+        (void)sprintf(s, "%02d", tm->tm.tm_mon + 1);
         s += 2;
         break;
       case TSFKW_MONTH: {
         const char* mon = fullMonths[tm->tm.tm_mon];
         char        buf[10] = {0};
         for (int32_t i = 0; i < strlen(mon); ++i) buf[i] = toupper(mon[i]);
-        sprintf(s, "%-9s", buf);
+        (void)sprintf(s, "%-9s", buf);
         s += strlen(s);
         break;
       }
@@ -1461,44 +1447,44 @@ static int32_t tm2char(const SArray* formats, const struct STm* tm, char* s, int
         const char* mon = months[tm->tm.tm_mon];
         char        buf[10] = {0};
         for (int32_t i = 0; i < strlen(mon); ++i) buf[i] = toupper(mon[i]);
-        sprintf(s, "%s", buf);
+        (void)sprintf(s, "%s", buf);
         s += strlen(s);
         break;
       }
       case TSFKW_Month:
-        sprintf(s, "%-9s", fullMonths[tm->tm.tm_mon]);
+        (void)sprintf(s, "%-9s", fullMonths[tm->tm.tm_mon]);
         s += strlen(s);
         break;
       case TSFKW_month: {
         const char* mon = fullMonths[tm->tm.tm_mon];
         char        buf[10] = {0};
         for (int32_t i = 0; i < strlen(mon); ++i) buf[i] = tolower(mon[i]);
-        sprintf(s, "%-9s", buf);
+        (void)sprintf(s, "%-9s", buf);
         s += strlen(s);
         break;
       }
       case TSFKW_Mon:
-        sprintf(s, "%s", months[tm->tm.tm_mon]);
+        (void)sprintf(s, "%s", months[tm->tm.tm_mon]);
         s += strlen(s);
         break;
       case TSFKW_mon: {
         const char* mon = months[tm->tm.tm_mon];
         char        buf[10] = {0};
         for (int32_t i = 0; i < strlen(mon); ++i) buf[i] = tolower(mon[i]);
-        sprintf(s, "%s", buf);
+        (void)sprintf(s, "%s", buf);
         s += strlen(s);
         break;
       }
       case TSFKW_SS:
-        sprintf(s, "%02d", tm->tm.tm_sec);
+        (void)sprintf(s, "%02d", tm->tm.tm_sec);
         s += 2;
         break;
       case TSFKW_MS:
-        sprintf(s, "%03" PRId64, tm->fsec / 1000000L);
+        (void)sprintf(s, "%03" PRId64, tm->fsec / 1000000L);
         s += 3;
         break;
       case TSFKW_US:
-        sprintf(s, "%06" PRId64, tm->fsec / 1000L);
+        (void)sprintf(s, "%06" PRId64, tm->fsec / 1000L);
         s += 6;
         break;
       case TSFKW_NS:
@@ -1506,23 +1492,23 @@ static int32_t tm2char(const SArray* formats, const struct STm* tm, char* s, int
         s += 9;
         break;
       case TSFKW_TZH:
-        sprintf(s, "%s%02d", tsTimezone < 0 ? "-" : "+", tsTimezone);
+        (void)sprintf(s, "%s%02d", tsTimezone < 0 ? "-" : "+", tsTimezone);
         s += strlen(s);
         break;
       case TSFKW_YYYY:
-        sprintf(s, "%04d", tm->tm.tm_year + 1900);
+        (void)sprintf(s, "%04d", tm->tm.tm_year + 1900);
         s += strlen(s);
         break;
       case TSFKW_YYY:
-        sprintf(s, "%03d", (tm->tm.tm_year + 1900) % 1000);
+        (void)sprintf(s, "%03d", (tm->tm.tm_year + 1900) % 1000);
         s += strlen(s);
         break;
       case TSFKW_YY:
-        sprintf(s, "%02d", (tm->tm.tm_year + 1900) % 100);
+        (void)sprintf(s, "%02d", (tm->tm.tm_year + 1900) % 100);
         s += strlen(s);
         break;
       case TSFKW_Y:
-        sprintf(s, "%01d", (tm->tm.tm_year + 1900) % 10);
+        (void)sprintf(s, "%01d", (tm->tm.tm_year + 1900) % 10);
         s += strlen(s);
         break;
       default:
@@ -1557,7 +1543,7 @@ static const char* tsFormatStr2Int32(int32_t* dest, const char* str, int32_t len
     s = last;
   } else {
     char buf[16] = {0};
-    strncpy(buf, s, len);
+    (void)strncpy(buf, s, len);
     int32_t copiedLen = strlen(buf);
     if (copiedLen < len) {
       if (!needMoreDigit) {
@@ -1936,10 +1922,13 @@ static int32_t char2ts(const char* s, SArray* formats, int64_t* ts, int32_t prec
 int32_t taosTs2Char(const char* format, SArray** formats, int64_t ts, int32_t precision, char* out, int32_t outLen) {
   if (!*formats) {
     *formats = taosArrayInit(8, sizeof(TSFormatNode));
+    if (!*formats){
+      TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    }
     parseTsFormat(format, *formats);
   }
   struct STm tm;
-  taosTs2Tm(ts, precision, &tm);
+  TAOS_CHECK_RETURN(taosTs2Tm(ts, precision, &tm));
   return tm2char(*formats, &tm, out, outLen);
 }
 
@@ -1949,6 +1938,9 @@ int32_t taosChar2Ts(const char* format, SArray** formats, const char* tsStr, int
   int32_t     fErrIdx;
   if (!*formats) {
     *formats = taosArrayInit(4, sizeof(TSFormatNode));
+    if (!*formats) {
+      TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    }
     parseTsFormat(format, *formats);
   }
   int32_t code = char2ts(tsStr, *formats, ts, precision, &sErrPos, &fErrIdx);
@@ -1964,16 +1956,24 @@ int32_t taosChar2Ts(const char* format, SArray** formats, const char* tsStr, int
     snprintf(errMsg, errMsgLen, "timestamp format not supported");
     code = TSDB_CODE_FUNC_TO_TIMESTAMP_FAILED_NOT_SUPPORTED;
   }
-  return code;
+  TAOS_RETURN(code);
 }
 
-void TEST_ts2char(const char* format, int64_t ts, int32_t precision, char* out, int32_t outLen) {
+int32_t TEST_ts2char(const char* format, int64_t ts, int32_t precision, char* out, int32_t outLen) {
+  int32_t code = TSDB_CODE_SUCCESS;
+
   SArray* formats = taosArrayInit(4, sizeof(TSFormatNode));
+  if (!formats) {
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+  }
   parseTsFormat(format, formats);
   struct STm tm;
-  taosTs2Tm(ts, precision, &tm);
-  tm2char(formats, &tm, out, outLen);
+  TAOS_CHECK_GOTO(taosTs2Tm(ts, precision, &tm), NULL, _exit);
+  TAOS_CHECK_GOTO(tm2char(formats, &tm, out, outLen), NULL, _exit);
+
+_exit:
   taosArrayDestroy(formats);
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t TEST_char2ts(const char* format, int64_t* ts, int32_t precision, const char* tsStr) {
@@ -1997,17 +1997,19 @@ static int8_t UNIT_INDEX[26] = {/*a*/ 2,  0,  -1, 6,  -1, -1, -1,
 
 #define GET_UNIT_INDEX(idx) UNIT_INDEX[(idx) - 97]
 
-static int64_t UNIT_MATRIX[10][11] = {/*  ns,   us,   ms,    s,   min,   h,   d,   w, month, y*/
-                                      /*ns*/ {1, 1000, 0},
-                                      /*us*/ {1000, 1, 1000, 0},
-                                      /*ms*/ {0, 1000, 1, 1000, 0},
-                                      /*s*/ {0, 0, 1000, 1, 60, 0},
-                                      /*min*/ {0, 0, 0, 60, 1, 60, 0},
-                                      /*h*/ {0, 0, 0, 0, 60, 1, 1, 0},
-                                      /*d*/ {0, 0, 0, 0, 0, 24, 1, 7, 1, 0},
-                                      /*w*/ {0, 0, 0, 0, 0, 0, 7, 1, -1, 0},
-                                      /*mon*/ {0, 0, 0, 0, 0, 0, 0, 0, 1, 12, 0},
-                                      /*y*/ {0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 0}};
+// clang-format off
+static int64_t UNIT_MATRIX[10][11] = {     /*  ns,   us,   ms,    s,   min,   h,   d,   w, month, y*/
+                                /*ns*/ {   1, 1000,    0},
+                                /*us*/ {1000,    1, 1000,    0},
+                                /*ms*/ {   0, 1000,    1, 1000,    0},
+                                 /*s*/ {   0,    0, 1000,    1,   60,    0},
+                               /*min*/ {   0,    0,    0,   60,    1,   60,   0},
+                                 /*h*/ {   0,    0,    0,    0,   60,    1,   1,   0},
+                                 /*d*/ {   0,    0,    0,    0,    0,   24,   1,   7,   1,   0},
+                                 /*w*/ {   0,    0,    0,    0,    0,    0,   7,   1,  -1,   0},
+                               /*mon*/ {   0,    0,    0,    0,    0,    0,   0,   0,   1,  12,  0},
+                                 /*y*/ {   0,    0,    0,    0,    0,    0,   0,   0,   12,   1,  0}};
+// clang-format on
 
 static bool recursiveTsmaCheckRecursive(int64_t baseInterval, int8_t baseIdx, int64_t interval, int8_t idx,
                                         bool checkEq) {
diff --git a/source/common/test/commonTests.cpp b/source/common/test/commonTests.cpp
index 360d1ed31a..b539d6731f 100644
--- a/source/common/test/commonTests.cpp
+++ b/source/common/test/commonTests.cpp
@@ -465,7 +465,8 @@ TEST(timeTest, timestamp2tm) {
 
 void test_ts2char(int64_t ts, const char* format, int32_t precison, const char* expected) {
   char buf[256] = {0};
-  TEST_ts2char(format, ts, precison, buf, 256);
+  int32_t code = TEST_ts2char(format, ts, precison, buf, 256);
+  ASSERT_EQ(code, 0);
   printf("ts: %ld format: %s res: [%s], expected: [%s]\n", ts, format, buf, expected);
   ASSERT_STREQ(expected, buf);
 }
diff --git a/source/dnode/mnode/impl/src/mndVgroup.c b/source/dnode/mnode/impl/src/mndVgroup.c
index d100f84d5a..240837d8ce 100644
--- a/source/dnode/mnode/impl/src/mndVgroup.c
+++ b/source/dnode/mnode/impl/src/mndVgroup.c
@@ -189,9 +189,17 @@ static int32_t mndNewVgActionValidate(SMnode *pMnode, STrans *pTrans, SSdbRaw *p
   int      code = -1;
 
   pRow = mndVgroupActionDecode(pRaw);
-  if (pRow == NULL) goto _OVER;
+  if (pRow == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    goto _OVER;
+  }
   pVgroup = sdbGetRowObj(pRow);
-  if (pVgroup == NULL) goto _OVER;
+  if (pVgroup == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    goto _OVER;
+  }
 
   int32_t maxVgId = sdbGetMaxId(pMnode->pSdb, SDB_VGROUP);
   if (maxVgId > pVgroup->vgId) {
@@ -203,7 +211,7 @@ static int32_t mndNewVgActionValidate(SMnode *pMnode, STrans *pTrans, SSdbRaw *p
 _OVER:
   if (pVgroup) mndVgroupActionDelete(pSdb, pVgroup);
   taosMemoryFreeClear(pRow);
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndVgroupActionInsert(SSdb *pSdb, SVgObj *pVgroup) {
@@ -756,28 +764,24 @@ static int32_t mndGetAvailableDnode(SMnode *pMnode, SDbObj *pDb, SVgObj *pVgroup
   if (size < pVgroup->replica) {
     mError("db:%s, vgId:%d, no enough online dnodes:%d to alloc %d replica", pVgroup->dbName, pVgroup->vgId, size,
            pVgroup->replica);
-    terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_MND_NO_ENOUGH_DNODES);
   }
 
   for (int32_t v = 0; v < pVgroup->replica; ++v) {
     SVnodeGid *pVgid = &pVgroup->vnodeGid[v];
     SDnodeObj *pDnode = taosArrayGet(pArray, v);
     if (pDnode == NULL) {
-      terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;
-      return -1;
+      TAOS_RETURN(TSDB_CODE_MND_NO_ENOUGH_DNODES);
     }
     if (pDnode->numOfVnodes >= pDnode->numOfSupportVnodes) {
-      terrno = TSDB_CODE_MND_NO_ENOUGH_VNODES;
-      return -1;
+      TAOS_RETURN(TSDB_CODE_MND_NO_ENOUGH_VNODES);
     }
 
     int64_t vgMem = mndGetVgroupMemory(pMnode, pDb, pVgroup);
     if (pDnode->memAvail - vgMem - pDnode->memUsed <= 0) {
       mError("db:%s, vgId:%d, no enough memory:%" PRId64 " in dnode:%d, avail:%" PRId64 " used:%" PRId64,
              pVgroup->dbName, pVgroup->vgId, vgMem, pDnode->id, pDnode->memAvail, pDnode->memUsed);
-      terrno = TSDB_CODE_MND_NO_ENOUGH_MEM_IN_DNODE;
-      return -1;
+      TAOS_RETURN(TSDB_CODE_MND_NO_ENOUGH_MEM_IN_DNODE);
     } else {
       pDnode->memUsed += vgMem;
     }
@@ -799,8 +803,13 @@ static int32_t mndGetAvailableDnode(SMnode *pMnode, SDbObj *pDb, SVgObj *pVgroup
 }
 
 int32_t mndAllocSmaVgroup(SMnode *pMnode, SDbObj *pDb, SVgObj *pVgroup) {
+  int32_t code = 0;
   SArray *pArray = mndBuildDnodesArray(pMnode, 0);
-  if (pArray == NULL) return -1;
+  if (pArray == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
 
   pVgroup->vgId = sdbGetMaxId(pMnode->pSdb, SDB_VGROUP);
   pVgroup->isTsma = 1;
@@ -825,12 +834,16 @@ int32_t mndAllocVgroup(SMnode *pMnode, SDbObj *pDb, SVgObj **ppVgroups) {
 
   pVgroups = taosMemoryCalloc(pDb->cfg.numOfVgroups, sizeof(SVgObj));
   if (pVgroups == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    code = TSDB_CODE_OUT_OF_MEMORY;
     goto _OVER;
   }
 
   pArray = mndBuildDnodesArray(pMnode, 0);
-  if (pArray == NULL) goto _OVER;
+  if (pArray == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    goto _OVER;
+  }
 
   mInfo("db:%s, total %d dnodes used to create %d vgroups (%d vnodes)", pDb->name, (int32_t)taosArrayGetSize(pArray),
         pDb->cfg.numOfVgroups, pDb->cfg.numOfVgroups * pDb->cfg.replications);
@@ -875,7 +888,7 @@ int32_t mndAllocVgroup(SMnode *pMnode, SDbObj *pDb, SVgObj **ppVgroups) {
 _OVER:
   if (code != 0) taosMemoryFree(pVgroups);
   taosArrayDestroy(pArray);
-  return code;
+  TAOS_RETURN(code);
 }
 
 SEpSet mndGetVgroupEpset(SMnode *pMnode, const SVgObj *pVgroup) {
@@ -901,7 +914,7 @@ SEpSet mndGetVgroupEpset(SMnode *pMnode, const SVgObj *pVgroup) {
 SEpSet mndGetVgroupEpsetById(SMnode *pMnode, int32_t vgId) {
   SEpSet epset = {0};
 
-  SVgObj * pVgroup = mndAcquireVgroup(pMnode, vgId);
+  SVgObj *pVgroup = mndAcquireVgroup(pMnode, vgId);
   if (!pVgroup) return epset;
 
   for (int32_t v = 0; v < pVgroup->replica; ++v) {
@@ -1199,6 +1212,7 @@ static void mndCancelGetNextVnode(SMnode *pMnode, void *pIter) {
 }
 
 static int32_t mndAddVnodeToVgroup(SMnode *pMnode, STrans *pTrans, SVgObj *pVgroup, SArray *pArray) {
+  int32_t code = 0;
   taosArraySort(pArray, (__compar_fn_t)mndCompareDnodeVnodes);
   for (int32_t i = 0; i < taosArrayGetSize(pArray); ++i) {
     SDnodeObj *pDnode = taosArrayGet(pArray, i);
@@ -1219,20 +1233,17 @@ static int32_t mndAddVnodeToVgroup(SMnode *pMnode, STrans *pTrans, SVgObj *pVgro
     if (used) continue;
 
     if (pDnode == NULL) {
-      terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;
-      return -1;
+      TAOS_RETURN(TSDB_CODE_MND_NO_ENOUGH_DNODES);
     }
     if (pDnode->numOfVnodes >= pDnode->numOfSupportVnodes) {
-      terrno = TSDB_CODE_MND_NO_ENOUGH_VNODES;
-      return -1;
+      TAOS_RETURN(TSDB_CODE_MND_NO_ENOUGH_VNODES);
     }
 
     int64_t vgMem = mndGetVgroupMemory(pMnode, NULL, pVgroup);
     if (pDnode->memAvail - vgMem - pDnode->memUsed <= 0) {
       mError("db:%s, vgId:%d, no enough memory:%" PRId64 " in dnode:%d avail:%" PRId64 " used:%" PRId64,
              pVgroup->dbName, pVgroup->vgId, vgMem, pDnode->id, pDnode->memAvail, pDnode->memUsed);
-      terrno = TSDB_CODE_MND_NO_ENOUGH_MEM_IN_DNODE;
-      return -1;
+      TAOS_RETURN(TSDB_CODE_MND_NO_ENOUGH_MEM_IN_DNODE);
     } else {
       pDnode->memUsed += vgMem;
     }
@@ -1246,19 +1257,23 @@ static int32_t mndAddVnodeToVgroup(SMnode *pMnode, STrans *pTrans, SVgObj *pVgro
     pDnode->numOfVnodes++;
 
     SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroup);
-    if (pVgRaw == NULL) return -1;
-    if (mndTransAppendRedolog(pTrans, pVgRaw) != 0) {
+    if (pVgRaw == NULL) {
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
+      TAOS_RETURN(code);
+    }
+    if ((code = mndTransAppendRedolog(pTrans, pVgRaw)) != 0) {
       sdbFreeRaw(pVgRaw);
-      return -1;
+      TAOS_RETURN(code);
     }
     (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY);
 
-    return 0;
+    TAOS_RETURN(code);
   }
 
-  terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;
-  mError("db:%s, failed to add vnode to vgId:%d since %s", pVgroup->dbName, pVgroup->vgId, terrstr());
-  return -1;
+  code = TSDB_CODE_MND_NO_ENOUGH_DNODES;
+  mError("db:%s, failed to add vnode to vgId:%d since %s", pVgroup->dbName, pVgroup->vgId, tstrerror(code));
+  TAOS_RETURN(code);
 }
 
 static int32_t mndRemoveVnodeFromVgroup(SMnode *pMnode, STrans *pTrans, SVgObj *pVgroup, SArray *pArray,
@@ -1293,9 +1308,9 @@ static int32_t mndRemoveVnodeFromVgroup(SMnode *pMnode, STrans *pTrans, SVgObj *
 
 _OVER:
   if (code != 0) {
-    terrno = TSDB_CODE_APP_ERROR;
-    mError("db:%s, failed to remove vnode from vgId:%d since %s", pVgroup->dbName, pVgroup->vgId, terrstr());
-    return -1;
+    code = TSDB_CODE_APP_ERROR;
+    mError("db:%s, failed to remove vnode from vgId:%d since %s", pVgroup->dbName, pVgroup->vgId, tstrerror(code));
+    TAOS_RETURN(code);
   }
 
   for (int32_t vn = 0; vn < pVgroup->replica; ++vn) {
@@ -1304,14 +1319,18 @@ _OVER:
   }
 
   SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroup);
-  if (pVgRaw == NULL) return -1;
+  if (pVgRaw == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
   if (mndTransAppendRedolog(pTrans, pVgRaw) != 0) {
     sdbFreeRaw(pVgRaw);
-    return -1;
+    TAOS_RETURN(code);
   }
   (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY);
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndRemoveVnodeFromVgroupWithoutSave(SMnode *pMnode, STrans *pTrans, SVgObj *pVgroup, SArray *pArray,
@@ -1346,9 +1365,9 @@ static int32_t mndRemoveVnodeFromVgroupWithoutSave(SMnode *pMnode, STrans *pTran
 
 _OVER:
   if (code != 0) {
-    terrno = TSDB_CODE_APP_ERROR;
-    mError("db:%s, failed to remove vnode from vgId:%d since %s", pVgroup->dbName, pVgroup->vgId, terrstr());
-    return -1;
+    code = TSDB_CODE_APP_ERROR;
+    mError("db:%s, failed to remove vnode from vgId:%d since %s", pVgroup->dbName, pVgroup->vgId, tstrerror(code));
+    TAOS_RETURN(code);
   }
 
   for (int32_t vn = 0; vn < pVgroup->replica; ++vn) {
@@ -1356,10 +1375,11 @@ _OVER:
     mInfo("db:%s, vgId:%d, vn:%d dnode:%d is reserved", pVgroup->dbName, pVgroup->vgId, vn, pVgid->dnodeId);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndAddCreateVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, SVnodeGid *pVgid) {
+  int32_t      code = 0;
   STransAction action = {0};
 
   SDnodeObj *pDnode = mndAcquireDnode(pMnode, pVgid->dnodeId);
@@ -1376,38 +1396,44 @@ int32_t mndAddCreateVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVg
   action.msgType = TDMT_DND_CREATE_VNODE;
   action.acceptableCode = TSDB_CODE_VND_ALREADY_EXIST;
 
-  if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+  if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {
     taosMemoryFree(pReq);
-    return -1;
+    TAOS_RETURN(code);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndRestoreAddCreateVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup,
                                        SDnodeObj *pDnode) {
+  int32_t      code = 0;
   STransAction action = {0};
 
   action.epSet = mndGetDnodeEpset(pDnode);
 
   int32_t contLen = 0;
   void   *pReq = mndBuildCreateVnodeReq(pMnode, pDnode, pDb, pVgroup, &contLen);
-  if (pReq == NULL) return -1;
+  if (pReq == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
 
   action.pCont = pReq;
   action.contLen = contLen;
   action.msgType = TDMT_DND_CREATE_VNODE;
   action.acceptableCode = TSDB_CODE_VND_ALREADY_EXIST;
 
-  if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+  if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {
     taosMemoryFree(pReq);
-    return -1;
+    TAOS_RETURN(code);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndAddAlterVnodeConfirmAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup) {
+  int32_t      code = 0;
   STransAction action = {0};
   action.epSet = mndGetVgroupEpset(pMnode, pVgroup);
 
@@ -1415,8 +1441,7 @@ int32_t mndAddAlterVnodeConfirmAction(SMnode *pMnode, STrans *pTrans, SDbObj *pD
   int32_t   contLen = sizeof(SMsgHead);
   SMsgHead *pHead = taosMemoryMalloc(contLen);
   if (pHead == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   pHead->contLen = htonl(contLen);
@@ -1428,30 +1453,34 @@ int32_t mndAddAlterVnodeConfirmAction(SMnode *pMnode, STrans *pTrans, SDbObj *pD
   // incorrect redirect result will cause this erro
   action.retryCode = TSDB_CODE_VND_INVALID_VGROUP_ID;
 
-  if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+  if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {
     taosMemoryFree(pHead);
-    return -1;
+    TAOS_RETURN(code);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndAddChangeConfigAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pOldVgroup, SVgObj *pNewVgroup,
                                  int32_t dnodeId) {
+  int32_t      code = 0;
   STransAction action = {0};
   action.epSet = mndGetVgroupEpset(pMnode, pNewVgroup);
 
   int32_t contLen = 0;
   void   *pReq = mndBuildAlterVnodeReplicaReq(pMnode, pDb, pNewVgroup, dnodeId, &contLen);
-  if (pReq == NULL) return -1;
+  if (pReq == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
 
   int32_t totallen = contLen + sizeof(SMsgHead);
 
   SMsgHead *pHead = taosMemoryMalloc(totallen);
   if (pHead == NULL) {
     taosMemoryFree(pReq);
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   pHead->contLen = htonl(totallen);
@@ -1464,73 +1493,93 @@ int32_t mndAddChangeConfigAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SV
   action.contLen = totallen;
   action.msgType = TDMT_SYNC_CONFIG_CHANGE;
 
-  if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+  if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {
     taosMemoryFree(pHead);
-    return -1;
+    TAOS_RETURN(code);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndAddAlterVnodeHashRangeAction(SMnode *pMnode, STrans *pTrans, int32_t srcVgId, SVgObj *pVgroup) {
+  int32_t      code = 0;
   STransAction action = {0};
   action.epSet = mndGetVgroupEpset(pMnode, pVgroup);
 
   int32_t contLen = 0;
   void   *pReq = mndBuildAlterVnodeHashRangeReq(pMnode, srcVgId, pVgroup, &contLen);
-  if (pReq == NULL) return -1;
+  if (pReq == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
 
   action.pCont = pReq;
   action.contLen = contLen;
   action.msgType = TDMT_VND_ALTER_HASHRANGE;
   action.acceptableCode = TSDB_CODE_VND_ALREADY_EXIST;
 
-  if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+  if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {
     taosMemoryFree(pReq);
-    return -1;
+    TAOS_RETURN(code);
   }
 
   mInfo("trans:%d, add alter vnode hash range action for from vgId:%d to vgId:%d", pTrans->id, srcVgId, pVgroup->vgId);
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndAddAlterVnodeConfigAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup) {
+  int32_t      code = 0;
   STransAction action = {0};
   action.epSet = mndGetVgroupEpset(pMnode, pVgroup);
 
   int32_t contLen = 0;
   void   *pReq = mndBuildAlterVnodeConfigReq(pMnode, pDb, pVgroup, &contLen);
-  if (pReq == NULL) return -1;
+  if (pReq == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
 
   action.pCont = pReq;
   action.contLen = contLen;
   action.msgType = TDMT_VND_ALTER_CONFIG;
 
-  if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+  if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {
     taosMemoryFree(pReq);
-    return -1;
+    TAOS_RETURN(code);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndAddNewVgPrepareAction(SMnode *pMnode, STrans *pTrans, SVgObj *pVg) {
+  int32_t  code = 0;
   SSdbRaw *pRaw = mndVgroupActionEncode(pVg);
-  if (pRaw == NULL) goto _err;
+  if (pRaw == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    goto _err;
+  }
 
-  if (mndTransAppendPrepareLog(pTrans, pRaw) != 0) goto _err;
+  TAOS_CHECK_GOTO(mndTransAppendPrepareLog(pTrans, pRaw), NULL, _err);
   (void)sdbSetRawStatus(pRaw, SDB_STATUS_CREATING);
   pRaw = NULL;
-  return 0;
+  TAOS_RETURN(code);
 
 _err:
   sdbFreeRaw(pRaw);
-  return -1;
+  TAOS_RETURN(code);
 }
 
 int32_t mndAddAlterVnodeReplicaAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, int32_t dnodeId) {
+  int32_t    code = 0;
   SDnodeObj *pDnode = mndAcquireDnode(pMnode, dnodeId);
-  if (pDnode == NULL) return -1;
+  if (pDnode == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
 
   STransAction action = {0};
   action.epSet = mndGetDnodeEpset(pDnode);
@@ -1538,23 +1587,32 @@ int32_t mndAddAlterVnodeReplicaAction(SMnode *pMnode, STrans *pTrans, SDbObj *pD
 
   int32_t contLen = 0;
   void   *pReq = mndBuildAlterVnodeReplicaReq(pMnode, pDb, pVgroup, dnodeId, &contLen);
-  if (pReq == NULL) return -1;
+  if (pReq == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
 
   action.pCont = pReq;
   action.contLen = contLen;
   action.msgType = TDMT_VND_ALTER_REPLICA;
 
-  if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+  if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {
     taosMemoryFree(pReq);
-    return -1;
+    TAOS_RETURN(code);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndAddCheckLearnerCatchupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, int32_t dnodeId) {
+  int32_t    code = 0;
   SDnodeObj *pDnode = mndAcquireDnode(pMnode, dnodeId);
-  if (pDnode == NULL) return -1;
+  if (pDnode == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
 
   STransAction action = {0};
   action.epSet = mndGetDnodeEpset(pDnode);
@@ -1562,7 +1620,11 @@ int32_t mndAddCheckLearnerCatchupAction(SMnode *pMnode, STrans *pTrans, SDbObj *
 
   int32_t contLen = 0;
   void   *pReq = mndBuildCheckLearnCatchupReq(pMnode, pDb, pVgroup, dnodeId, &contLen);
-  if (pReq == NULL) return -1;
+  if (pReq == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
 
   action.pCont = pReq;
   action.contLen = contLen;
@@ -1570,17 +1632,22 @@ int32_t mndAddCheckLearnerCatchupAction(SMnode *pMnode, STrans *pTrans, SDbObj *
   action.acceptableCode = TSDB_CODE_VND_ALREADY_IS_VOTER;
   action.retryCode = TSDB_CODE_VND_NOT_CATCH_UP;
 
-  if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+  if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {
     taosMemoryFree(pReq);
-    return -1;
+    TAOS_RETURN(code);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndAddAlterVnodeTypeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, int32_t dnodeId) {
+  int32_t    code = 0;
   SDnodeObj *pDnode = mndAcquireDnode(pMnode, dnodeId);
-  if (pDnode == NULL) return -1;
+  if (pDnode == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
 
   STransAction action = {0};
   action.epSet = mndGetDnodeEpset(pDnode);
@@ -1588,7 +1655,11 @@ int32_t mndAddAlterVnodeTypeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb,
 
   int32_t contLen = 0;
   void   *pReq = mndBuildAlterVnodeReplicaReq(pMnode, pDb, pVgroup, dnodeId, &contLen);
-  if (pReq == NULL) return -1;
+  if (pReq == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
 
   action.pCont = pReq;
   action.contLen = contLen;
@@ -1596,22 +1667,27 @@ int32_t mndAddAlterVnodeTypeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb,
   action.acceptableCode = TSDB_CODE_VND_ALREADY_IS_VOTER;
   action.retryCode = TSDB_CODE_VND_NOT_CATCH_UP;
 
-  if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+  if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {
     taosMemoryFree(pReq);
-    return -1;
+    TAOS_RETURN(code);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndRestoreAddAlterVnodeTypeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup,
                                           SDnodeObj *pDnode) {
+  int32_t      code = 0;
   STransAction action = {0};
   action.epSet = mndGetDnodeEpset(pDnode);
 
   int32_t contLen = 0;
   void   *pReq = mndBuildAlterVnodeReplicaReq(pMnode, pDb, pVgroup, pDnode->id, &contLen);
-  if (pReq == NULL) return -1;
+  if (pReq == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
 
   action.pCont = pReq;
   action.contLen = contLen;
@@ -1619,18 +1695,23 @@ int32_t mndRestoreAddAlterVnodeTypeAction(SMnode *pMnode, STrans *pTrans, SDbObj
   action.acceptableCode = TSDB_CODE_VND_ALREADY_IS_VOTER;
   action.retryCode = TSDB_CODE_VND_NOT_CATCH_UP;
 
-  if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+  if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {
     taosMemoryFree(pReq);
-    return -1;
+    TAOS_RETURN(code);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndAddDisableVnodeWriteAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup,
                                              int32_t dnodeId) {
+  int32_t    code = 0;
   SDnodeObj *pDnode = mndAcquireDnode(pMnode, dnodeId);
-  if (pDnode == NULL) return -1;
+  if (pDnode == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
 
   STransAction action = {0};
   action.epSet = mndGetDnodeEpset(pDnode);
@@ -1638,32 +1719,45 @@ static int32_t mndAddDisableVnodeWriteAction(SMnode *pMnode, STrans *pTrans, SDb
 
   int32_t contLen = 0;
   void   *pReq = mndBuildDisableVnodeWriteReq(pMnode, pDb, pVgroup->vgId, &contLen);
-  if (pReq == NULL) return -1;
+  if (pReq == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
 
   action.pCont = pReq;
   action.contLen = contLen;
   action.msgType = TDMT_VND_DISABLE_WRITE;
 
-  if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+  if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {
     taosMemoryFree(pReq);
-    return -1;
+    TAOS_RETURN(code);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndAddDropVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, SVnodeGid *pVgid,
                               bool isRedo) {
+  int32_t      code = 0;
   STransAction action = {0};
 
   SDnodeObj *pDnode = mndAcquireDnode(pMnode, pVgid->dnodeId);
-  if (pDnode == NULL) return -1;
+  if (pDnode == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
   action.epSet = mndGetDnodeEpset(pDnode);
   mndReleaseDnode(pMnode, pDnode);
 
   int32_t contLen = 0;
   void   *pReq = mndBuildDropVnodeReq(pMnode, pDnode, pDb, pVgroup, &contLen);
-  if (pReq == NULL) return -1;
+  if (pReq == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
 
   action.pCont = pReq;
   action.contLen = contLen;
@@ -1671,23 +1765,24 @@ int32_t mndAddDropVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgOb
   action.acceptableCode = TSDB_CODE_VND_NOT_EXIST;
 
   if (isRedo) {
-    if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+    if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {
       taosMemoryFree(pReq);
-      return -1;
+      TAOS_RETURN(code);
     }
   } else {
-    if (mndTransAppendUndoAction(pTrans, &action) != 0) {
+    if ((code = mndTransAppendUndoAction(pTrans, &action)) != 0) {
       taosMemoryFree(pReq);
-      return -1;
+      TAOS_RETURN(code);
     }
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndSetMoveVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, int32_t vnIndex,
                                     SArray *pArray, bool force, bool unsafe) {
-  SVgObj newVg = {0};
+  int32_t code = 0;
+  SVgObj  newVg = {0};
   memcpy(&newVg, pVgroup, sizeof(SVgObj));
 
   mInfo("vgId:%d, vgroup info before move, replica:%d", newVg.vgId, newVg.replica);
@@ -1702,12 +1797,12 @@ int32_t mndSetMoveVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb,
     if (newVg.replica == 1) {
 #endif
       mInfo("vgId:%d, will add 1 vnode, replca:%d", pVgroup->vgId, newVg.replica);
-      if (mndAddVnodeToVgroup(pMnode, pTrans, &newVg, pArray) != 0) return -1;
+      TAOS_CHECK_RETURN(mndAddVnodeToVgroup(pMnode, pTrans, &newVg, pArray));
       for (int32_t i = 0; i < newVg.replica - 1; ++i) {
-        if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg, newVg.vnodeGid[i].dnodeId) != 0) return -1;
+        TAOS_CHECK_RETURN(mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg, newVg.vnodeGid[i].dnodeId));
       }
-      if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, &newVg, &newVg.vnodeGid[newVg.replica - 1]) != 0) return -1;
-      if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, &newVg) != 0) return -1;
+      TAOS_CHECK_RETURN(mndAddCreateVnodeAction(pMnode, pTrans, pDb, &newVg, &newVg.vnodeGid[newVg.replica - 1]));
+      TAOS_CHECK_RETURN(mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, &newVg));
 
       mInfo("vgId:%d, will remove 1 vnode, replca:2", pVgroup->vgId);
       newVg.replica--;
@@ -1716,19 +1811,23 @@ int32_t mndSetMoveVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb,
       memset(&newVg.vnodeGid[newVg.replica], 0, sizeof(SVnodeGid));
       {
         SSdbRaw *pRaw = mndVgroupActionEncode(&newVg);
-        if (pRaw == NULL) return -1;
-        if (mndTransAppendRedolog(pTrans, pRaw) != 0) {
+        if (pRaw == NULL) {
+          code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+          if (terrno != 0) code = terrno;
+          TAOS_RETURN(code);
+        }
+        if ((code = mndTransAppendRedolog(pTrans, pRaw)) != 0) {
           sdbFreeRaw(pRaw);
-          return -1;
+          TAOS_RETURN(code);
         }
         (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY);
       }
 
-      if (mndAddDropVnodeAction(pMnode, pTrans, pDb, &newVg, &del, true) != 0) return -1;
+      TAOS_CHECK_RETURN(mndAddDropVnodeAction(pMnode, pTrans, pDb, &newVg, &del, true));
       for (int32_t i = 0; i < newVg.replica; ++i) {
-        if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg, newVg.vnodeGid[i].dnodeId) != 0) return -1;
+        TAOS_CHECK_RETURN(mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg, newVg.vnodeGid[i].dnodeId));
       }
-      if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, &newVg) != 0) return -1;
+      TAOS_CHECK_RETURN(mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, &newVg));
 #if 1
     }
 #else
@@ -1761,33 +1860,36 @@ int32_t mndSetMoveVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb,
 #endif
   } else {
     mInfo("vgId:%d, will add 1 vnode and force remove 1 vnode", pVgroup->vgId);
-    if (mndAddVnodeToVgroup(pMnode, pTrans, &newVg, pArray) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddVnodeToVgroup(pMnode, pTrans, &newVg, pArray));
     newVg.replica--;
     // SVnodeGid del = newVg.vnodeGid[vnIndex];
     newVg.vnodeGid[vnIndex] = newVg.vnodeGid[newVg.replica];
     memset(&newVg.vnodeGid[newVg.replica], 0, sizeof(SVnodeGid));
     {
       SSdbRaw *pRaw = mndVgroupActionEncode(&newVg);
-      if (pRaw == NULL) return -1;
-      if (mndTransAppendRedolog(pTrans, pRaw) != 0) {
+      if (pRaw == NULL) {
+        code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+        if (terrno != 0) code = terrno;
+        TAOS_RETURN(code);
+      }
+      if ((code = mndTransAppendRedolog(pTrans, pRaw)) != 0) {
         sdbFreeRaw(pRaw);
-        return -1;
+        TAOS_RETURN(code);
       }
       (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY);
     }
 
     for (int32_t i = 0; i < newVg.replica; ++i) {
       if (i != vnIndex) {
-        if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg, newVg.vnodeGid[i].dnodeId) != 0) return -1;
+        TAOS_CHECK_RETURN(mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg, newVg.vnodeGid[i].dnodeId));
       }
     }
-    if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, &newVg, &newVg.vnodeGid[vnIndex]) != 0) return -1;
-    if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, &newVg) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddCreateVnodeAction(pMnode, pTrans, pDb, &newVg, &newVg.vnodeGid[vnIndex]));
+    TAOS_CHECK_RETURN(mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, &newVg));
 
     if (newVg.replica == 1) {
       if (force && !unsafe) {
-        terrno = TSDB_CODE_VND_META_DATA_UNSAFE_DELETE;
-        return -1;
+        TAOS_RETURN(TSDB_CODE_VND_META_DATA_UNSAFE_DELETE);
       }
 
       SSdb *pSdb = pMnode->pSdb;
@@ -1799,10 +1901,10 @@ int32_t mndSetMoveVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb,
         if (pIter == NULL) break;
 
         if (strcmp(pStb->db, pDb->name) == 0) {
-          if (mndSetForceDropCreateStbRedoActions(pMnode, pTrans, &newVg, pStb) != 0) {
+          if ((code = mndSetForceDropCreateStbRedoActions(pMnode, pTrans, &newVg, pStb)) != 0) {
             sdbCancelFetch(pSdb, pIter);
             sdbRelease(pSdb, pStb);
-            return -1;
+            TAOS_RETURN(code);
           }
         }
 
@@ -1815,10 +1917,14 @@ int32_t mndSetMoveVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb,
 
   {
     SSdbRaw *pRaw = mndVgroupActionEncode(&newVg);
-    if (pRaw == NULL) return -1;
-    if (mndTransAppendCommitlog(pTrans, pRaw) != 0) {
+    if (pRaw == NULL) {
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
+      TAOS_RETURN(code);
+    }
+    if ((code = mndTransAppendCommitlog(pTrans, pRaw)) != 0) {
       sdbFreeRaw(pRaw);
-      return -1;
+      TAOS_RETURN(code);
     }
     (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY);
   }
@@ -1827,13 +1933,17 @@ int32_t mndSetMoveVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb,
   for (int32_t i = 0; i < newVg.replica; ++i) {
     mInfo("vgId:%d, vnode:%d dnode:%d", newVg.vgId, i, newVg.vnodeGid[i].dnodeId);
   }
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndSetMoveVgroupsInfoToTrans(SMnode *pMnode, STrans *pTrans, int32_t delDnodeId, bool force, bool unsafe) {
   int32_t code = 0;
   SArray *pArray = mndBuildDnodesArray(pMnode, delDnodeId);
-  if (pArray == NULL) return -1;
+  if (pArray == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
 
   void *pIter = NULL;
   while (1) {
@@ -1866,11 +1976,12 @@ int32_t mndSetMoveVgroupsInfoToTrans(SMnode *pMnode, STrans *pTrans, int32_t del
   }
 
   taosArrayDestroy(pArray);
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndAddIncVgroupReplicaToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup,
                                              int32_t newDnodeId) {
+  int32_t code = 0;
   mInfo("vgId:%d, will add 1 vnode, replica:%d dnode:%d", pVgroup->vgId, pVgroup->replica, newDnodeId);
 
   // assoc dnode
@@ -1881,34 +1992,39 @@ static int32_t mndAddIncVgroupReplicaToTrans(SMnode *pMnode, STrans *pTrans, SDb
   pGid->nodeRole = TAOS_SYNC_ROLE_LEARNER;
 
   SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroup);
-  if (pVgRaw == NULL) return -1;
-  if (mndTransAppendRedolog(pTrans, pVgRaw) != 0) {
+  if (pVgRaw == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
+  if ((code = mndTransAppendRedolog(pTrans, pVgRaw)) != 0) {
     sdbFreeRaw(pVgRaw);
-    return -1;
+    TAOS_RETURN(code);
   }
   (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY);
 
   // learner
   for (int32_t i = 0; i < pVgroup->replica - 1; ++i) {
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, pVgroup, pVgroup->vnodeGid[i].dnodeId) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, pVgroup, pVgroup->vnodeGid[i].dnodeId));
   }
-  if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, pVgroup, pGid) != 0) return -1;
+  TAOS_CHECK_RETURN(mndAddCreateVnodeAction(pMnode, pTrans, pDb, pVgroup, pGid));
 
   // voter
   pGid->nodeRole = TAOS_SYNC_ROLE_VOTER;
-  if (mndAddAlterVnodeTypeAction(pMnode, pTrans, pDb, pVgroup, pGid->dnodeId) != 0) return -1;
+  TAOS_CHECK_RETURN(mndAddAlterVnodeTypeAction(pMnode, pTrans, pDb, pVgroup, pGid->dnodeId));
   for (int32_t i = 0; i < pVgroup->replica - 1; ++i) {
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, pVgroup, pVgroup->vnodeGid[i].dnodeId) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, pVgroup, pVgroup->vnodeGid[i].dnodeId));
   }
 
   // confirm
-  if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, pVgroup) != 0) return -1;
+  TAOS_CHECK_RETURN(mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, pVgroup));
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndAddDecVgroupReplicaFromTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup,
                                                int32_t delDnodeId) {
+  int32_t code = 0;
   mInfo("vgId:%d, will remove 1 vnode, replica:%d dnode:%d", pVgroup->vgId, pVgroup->replica, delDnodeId);
 
   SVnodeGid *pGid = NULL;
@@ -1928,20 +2044,24 @@ static int32_t mndAddDecVgroupReplicaFromTrans(SMnode *pMnode, STrans *pTrans, S
   memset(&pVgroup->vnodeGid[pVgroup->replica], 0, sizeof(SVnodeGid));
 
   SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroup);
-  if (pVgRaw == NULL) return -1;
-  if (mndTransAppendRedolog(pTrans, pVgRaw) != 0) {
+  if (pVgRaw == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
+  if ((code = mndTransAppendRedolog(pTrans, pVgRaw)) != 0) {
     sdbFreeRaw(pVgRaw);
-    return -1;
+    TAOS_RETURN(code);
   }
   (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY);
 
-  if (mndAddDropVnodeAction(pMnode, pTrans, pDb, pVgroup, &delGid, true) != 0) return -1;
+  TAOS_CHECK_RETURN(mndAddDropVnodeAction(pMnode, pTrans, pDb, pVgroup, &delGid, true));
   for (int32_t i = 0; i < pVgroup->replica; ++i) {
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, pVgroup, pVgroup->vnodeGid[i].dnodeId) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, pVgroup, pVgroup->vnodeGid[i].dnodeId));
   }
-  if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, pVgroup) != 0) return -1;
+  TAOS_CHECK_RETURN(mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, pVgroup));
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndRedistributeVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SVgObj *pVgroup, SDnodeObj *pNew1,
@@ -1951,10 +2071,14 @@ static int32_t mndRedistributeVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb,
   STrans *pTrans = NULL;
 
   pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_GLOBAL, pReq, "red-vgroup");
-  if (pTrans == NULL) goto _OVER;
+  if (pTrans == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    goto _OVER;
+  }
 
   mndTransSetDbName(pTrans, pVgroup->dbName, NULL);
-  if (mndTransCheckConflictWithCompact(pMnode, pTrans) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndTransCheckConflictWithCompact(pMnode, pTrans), NULL, _OVER);
 
   mndTransSetSerial(pTrans);
   mInfo("trans:%d, used to redistribute vgroup, vgId:%d", pTrans->id, pVgroup->vgId);
@@ -1972,7 +2096,7 @@ static int32_t mndRedistributeVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb,
     if (numOfVnodes >= pNew1->numOfSupportVnodes) {
       mError("vgId:%d, no enough vnodes in dnode:%d, numOfVnodes:%d support:%d", newVg.vgId, pNew1->id, numOfVnodes,
              pNew1->numOfSupportVnodes);
-      terrno = TSDB_CODE_MND_NO_ENOUGH_VNODES;
+      code = TSDB_CODE_MND_NO_ENOUGH_VNODES;
       goto _OVER;
     }
 
@@ -1980,14 +2104,14 @@ static int32_t mndRedistributeVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb,
     if (pNew1->memAvail - vgMem - pNew1->memUsed <= 0) {
       mError("db:%s, vgId:%d, no enough memory:%" PRId64 " in dnode:%d avail:%" PRId64 " used:%" PRId64,
              pVgroup->dbName, pVgroup->vgId, vgMem, pNew1->id, pNew1->memAvail, pNew1->memUsed);
-      terrno = TSDB_CODE_MND_NO_ENOUGH_MEM_IN_DNODE;
+      code = TSDB_CODE_MND_NO_ENOUGH_MEM_IN_DNODE;
       goto _OVER;
     } else {
       pNew1->memUsed += vgMem;
     }
 
-    if (mndAddIncVgroupReplicaToTrans(pMnode, pTrans, pDb, &newVg, pNew1->id) != 0) goto _OVER;
-    if (mndAddDecVgroupReplicaFromTrans(pMnode, pTrans, pDb, &newVg, pOld1->id) != 0) goto _OVER;
+    TAOS_CHECK_GOTO(mndAddIncVgroupReplicaToTrans(pMnode, pTrans, pDb, &newVg, pNew1->id), NULL, _OVER);
+    TAOS_CHECK_GOTO(mndAddDecVgroupReplicaFromTrans(pMnode, pTrans, pDb, &newVg, pOld1->id), NULL, _OVER);
   }
 
   if (pNew2 != NULL && pOld2 != NULL) {
@@ -1995,20 +2119,20 @@ static int32_t mndRedistributeVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb,
     if (numOfVnodes >= pNew2->numOfSupportVnodes) {
       mError("vgId:%d, no enough vnodes in dnode:%d, numOfVnodes:%d support:%d", newVg.vgId, pNew2->id, numOfVnodes,
              pNew2->numOfSupportVnodes);
-      terrno = TSDB_CODE_MND_NO_ENOUGH_VNODES;
+      code = TSDB_CODE_MND_NO_ENOUGH_VNODES;
       goto _OVER;
     }
     int64_t vgMem = mndGetVgroupMemory(pMnode, NULL, pVgroup);
     if (pNew2->memAvail - vgMem - pNew2->memUsed <= 0) {
       mError("db:%s, vgId:%d, no enough memory:%" PRId64 " in dnode:%d avail:%" PRId64 " used:%" PRId64,
              pVgroup->dbName, pVgroup->vgId, vgMem, pNew2->id, pNew2->memAvail, pNew2->memUsed);
-      terrno = TSDB_CODE_MND_NO_ENOUGH_MEM_IN_DNODE;
+      code = TSDB_CODE_MND_NO_ENOUGH_MEM_IN_DNODE;
       goto _OVER;
     } else {
       pNew2->memUsed += vgMem;
     }
-    if (mndAddIncVgroupReplicaToTrans(pMnode, pTrans, pDb, &newVg, pNew2->id) != 0) goto _OVER;
-    if (mndAddDecVgroupReplicaFromTrans(pMnode, pTrans, pDb, &newVg, pOld2->id) != 0) goto _OVER;
+    TAOS_CHECK_GOTO(mndAddIncVgroupReplicaToTrans(pMnode, pTrans, pDb, &newVg, pNew2->id), NULL, _OVER);
+    TAOS_CHECK_GOTO(mndAddDecVgroupReplicaFromTrans(pMnode, pTrans, pDb, &newVg, pOld2->id), NULL, _OVER);
   }
 
   if (pNew3 != NULL && pOld3 != NULL) {
@@ -2016,26 +2140,30 @@ static int32_t mndRedistributeVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb,
     if (numOfVnodes >= pNew3->numOfSupportVnodes) {
       mError("vgId:%d, no enough vnodes in dnode:%d, numOfVnodes:%d support:%d", newVg.vgId, pNew3->id, numOfVnodes,
              pNew3->numOfSupportVnodes);
-      terrno = TSDB_CODE_MND_NO_ENOUGH_VNODES;
+      code = TSDB_CODE_MND_NO_ENOUGH_VNODES;
       goto _OVER;
     }
     int64_t vgMem = mndGetVgroupMemory(pMnode, NULL, pVgroup);
     if (pNew3->memAvail - vgMem - pNew3->memUsed <= 0) {
       mError("db:%s, vgId:%d, no enough memory:%" PRId64 " in dnode:%d avail:%" PRId64 " used:%" PRId64,
              pVgroup->dbName, pVgroup->vgId, vgMem, pNew3->id, pNew3->memAvail, pNew3->memUsed);
-      terrno = TSDB_CODE_MND_NO_ENOUGH_MEM_IN_DNODE;
+      code = TSDB_CODE_MND_NO_ENOUGH_MEM_IN_DNODE;
       goto _OVER;
     } else {
       pNew3->memUsed += vgMem;
     }
-    if (mndAddIncVgroupReplicaToTrans(pMnode, pTrans, pDb, &newVg, pNew3->id) != 0) goto _OVER;
-    if (mndAddDecVgroupReplicaFromTrans(pMnode, pTrans, pDb, &newVg, pOld3->id) != 0) goto _OVER;
+    TAOS_CHECK_GOTO(mndAddIncVgroupReplicaToTrans(pMnode, pTrans, pDb, &newVg, pNew3->id), NULL, _OVER);
+    TAOS_CHECK_GOTO(mndAddDecVgroupReplicaFromTrans(pMnode, pTrans, pDb, &newVg, pOld3->id), NULL, _OVER);
   }
 
   {
     SSdbRaw *pRaw = mndVgroupActionEncode(&newVg);
-    if (pRaw == NULL) goto _OVER;
-    if (mndTransAppendCommitlog(pTrans, pRaw) != 0) {
+    if (pRaw == NULL) {
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
+      goto _OVER;
+    }
+    if ((code = mndTransAppendCommitlog(pTrans, pRaw)) != 0) {
       sdbFreeRaw(pRaw);
       goto _OVER;
     }
@@ -2047,13 +2175,13 @@ static int32_t mndRedistributeVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb,
     mInfo("vgId:%d, vnode:%d dnode:%d", newVg.vgId, i, newVg.vnodeGid[i].dnodeId);
   }
 
-  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
   code = 0;
 
 _OVER:
   mndTransDrop(pTrans);
   mndReleaseDb(pMnode, pDb);
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndProcessRedistributeVgroupMsg(SRpcMsg *pReq) {
@@ -2075,24 +2203,32 @@ static int32_t mndProcessRedistributeVgroupMsg(SRpcMsg *pReq) {
 
   SRedistributeVgroupReq req = {0};
   if (tDeserializeSRedistributeVgroupReq(pReq->pCont, pReq->contLen, &req) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
+    code = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
 
   mInfo("vgId:%d, start to redistribute vgroup to dnode %d:%d:%d", req.vgId, req.dnodeId1, req.dnodeId2, req.dnodeId3);
-  if (mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_REDISTRIBUTE_VGROUP) != 0) {
+  if ((code = mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_REDISTRIBUTE_VGROUP)) != 0) {
     goto _OVER;
   }
 
   pVgroup = mndAcquireVgroup(pMnode, req.vgId);
-  if (pVgroup == NULL) goto _OVER;
+  if (pVgroup == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    goto _OVER;
+  }
 
   pDb = mndAcquireDb(pMnode, pVgroup->dbName);
-  if (pDb == NULL) goto _OVER;
+  if (pDb == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    goto _OVER;
+  }
 
   if (pVgroup->replica == 1) {
     if (req.dnodeId1 <= 0 || req.dnodeId2 > 0 || req.dnodeId3 > 0) {
-      terrno = TSDB_CODE_MND_INVALID_REPLICA;
+      code = TSDB_CODE_MND_INVALID_REPLICA;
       goto _OVER;
     }
 
@@ -2103,16 +2239,24 @@ static int32_t mndProcessRedistributeVgroupMsg(SRpcMsg *pReq) {
     }
 
     pNew1 = mndAcquireDnode(pMnode, req.dnodeId1);
-    if (pNew1 == NULL) goto _OVER;
+    if (pNew1 == NULL) {
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
+      goto _OVER;
+    }
     if (!mndIsDnodeOnline(pNew1, curMs)) {
-      terrno = TSDB_CODE_MND_HAS_OFFLINE_DNODE;
+      code = TSDB_CODE_MND_HAS_OFFLINE_DNODE;
       goto _OVER;
     }
 
     pOld1 = mndAcquireDnode(pMnode, pVgroup->vnodeGid[0].dnodeId);
-    if (pOld1 == NULL) goto _OVER;
+    if (pOld1 == NULL) {
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
+      goto _OVER;
+    }
     if (!mndIsDnodeOnline(pOld1, curMs)) {
-      terrno = TSDB_CODE_MND_HAS_OFFLINE_DNODE;
+      code = TSDB_CODE_MND_HAS_OFFLINE_DNODE;
       goto _OVER;
     }
 
@@ -2120,12 +2264,12 @@ static int32_t mndProcessRedistributeVgroupMsg(SRpcMsg *pReq) {
 
   } else if (pVgroup->replica == 3) {
     if (req.dnodeId1 <= 0 || req.dnodeId2 <= 0 || req.dnodeId3 <= 0) {
-      terrno = TSDB_CODE_MND_INVALID_REPLICA;
+      code = TSDB_CODE_MND_INVALID_REPLICA;
       goto _OVER;
     }
 
     if (req.dnodeId1 == req.dnodeId2 || req.dnodeId1 == req.dnodeId3 || req.dnodeId2 == req.dnodeId3) {
-      terrno = TSDB_CODE_MND_INVALID_REPLICA;
+      code = TSDB_CODE_MND_INVALID_REPLICA;
       goto _OVER;
     }
 
@@ -2167,54 +2311,78 @@ static int32_t mndProcessRedistributeVgroupMsg(SRpcMsg *pReq) {
 
     if (newDnodeId[0] != 0) {
       pNew1 = mndAcquireDnode(pMnode, newDnodeId[0]);
-      if (pNew1 == NULL) goto _OVER;
+      if (pNew1 == NULL) {
+        code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+        if (terrno != 0) code = terrno;
+        goto _OVER;
+      }
       if (!mndIsDnodeOnline(pNew1, curMs)) {
-        terrno = TSDB_CODE_MND_HAS_OFFLINE_DNODE;
+        code = TSDB_CODE_MND_HAS_OFFLINE_DNODE;
         goto _OVER;
       }
     }
 
     if (newDnodeId[1] != 0) {
       pNew2 = mndAcquireDnode(pMnode, newDnodeId[1]);
-      if (pNew2 == NULL) goto _OVER;
+      if (pNew2 == NULL) {
+        code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+        if (terrno != 0) code = terrno;
+        goto _OVER;
+      }
       if (!mndIsDnodeOnline(pNew2, curMs)) {
-        terrno = TSDB_CODE_MND_HAS_OFFLINE_DNODE;
+        code = TSDB_CODE_MND_HAS_OFFLINE_DNODE;
         goto _OVER;
       }
     }
 
     if (newDnodeId[2] != 0) {
       pNew3 = mndAcquireDnode(pMnode, newDnodeId[2]);
-      if (pNew3 == NULL) goto _OVER;
+      if (pNew3 == NULL) {
+        code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+        if (terrno != 0) code = terrno;
+        goto _OVER;
+      }
       if (!mndIsDnodeOnline(pNew3, curMs)) {
-        terrno = TSDB_CODE_MND_HAS_OFFLINE_DNODE;
+        code = TSDB_CODE_MND_HAS_OFFLINE_DNODE;
         goto _OVER;
       }
     }
 
     if (oldDnodeId[0] != 0) {
       pOld1 = mndAcquireDnode(pMnode, oldDnodeId[0]);
-      if (pOld1 == NULL) goto _OVER;
+      if (pOld1 == NULL) {
+        code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+        if (terrno != 0) code = terrno;
+        goto _OVER;
+      }
       if (!mndIsDnodeOnline(pOld1, curMs)) {
-        terrno = TSDB_CODE_MND_HAS_OFFLINE_DNODE;
+        code = TSDB_CODE_MND_HAS_OFFLINE_DNODE;
         goto _OVER;
       }
     }
 
     if (oldDnodeId[1] != 0) {
       pOld2 = mndAcquireDnode(pMnode, oldDnodeId[1]);
-      if (pOld2 == NULL) goto _OVER;
+      if (pOld2 == NULL) {
+        code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+        if (terrno != 0) code = terrno;
+        goto _OVER;
+      }
       if (!mndIsDnodeOnline(pOld2, curMs)) {
-        terrno = TSDB_CODE_MND_HAS_OFFLINE_DNODE;
+        code = TSDB_CODE_MND_HAS_OFFLINE_DNODE;
         goto _OVER;
       }
     }
 
     if (oldDnodeId[2] != 0) {
       pOld3 = mndAcquireDnode(pMnode, oldDnodeId[2]);
-      if (pOld3 == NULL) goto _OVER;
+      if (pOld3 == NULL) {
+        code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+        if (terrno != 0) code = terrno;
+        goto _OVER;
+      }
       if (!mndIsDnodeOnline(pOld3, curMs)) {
-        terrno = TSDB_CODE_MND_HAS_OFFLINE_DNODE;
+        code = TSDB_CODE_MND_HAS_OFFLINE_DNODE;
         goto _OVER;
       }
     }
@@ -2228,7 +2396,7 @@ static int32_t mndProcessRedistributeVgroupMsg(SRpcMsg *pReq) {
     code = mndRedistributeVgroup(pMnode, pReq, pDb, pVgroup, pNew1, pOld1, pNew2, pOld2, pNew3, pOld3);
 
   } else {
-    terrno = TSDB_CODE_MND_REQ_REJECTED;
+    code = TSDB_CODE_MND_REQ_REJECTED;
     goto _OVER;
   }
 
@@ -2242,7 +2410,7 @@ static int32_t mndProcessRedistributeVgroupMsg(SRpcMsg *pReq) {
 _OVER:
   if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {
     mError("vgId:%d, failed to redistribute to dnode %d:%d:%d since %s", req.vgId, req.dnodeId1, req.dnodeId2,
-           req.dnodeId3, terrstr());
+           req.dnodeId3, tstrerror(code));
   }
 
   mndReleaseDnode(pMnode, pNew1);
@@ -2255,7 +2423,7 @@ _OVER:
   mndReleaseDb(pMnode, pDb);
   tFreeSRedistributeVgroupReq(&req);
 
-  return code;
+  TAOS_RETURN(code);
 }
 
 static void *mndBuildSForceBecomeFollowerReq(SMnode *pMnode, SVgObj *pVgroup, int32_t dnodeId, int32_t *pContLen) {
@@ -2286,8 +2454,13 @@ static void *mndBuildSForceBecomeFollowerReq(SMnode *pMnode, SVgObj *pVgroup, in
 }
 
 int32_t mndAddBalanceVgroupLeaderAction(SMnode *pMnode, STrans *pTrans, SVgObj *pVgroup, int32_t dnodeId) {
+  int32_t    code = 0;
   SDnodeObj *pDnode = mndAcquireDnode(pMnode, dnodeId);
-  if (pDnode == NULL) return -1;
+  if (pDnode == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
 
   STransAction action = {0};
   action.epSet = mndGetDnodeEpset(pDnode);
@@ -2295,22 +2468,27 @@ int32_t mndAddBalanceVgroupLeaderAction(SMnode *pMnode, STrans *pTrans, SVgObj *
 
   int32_t contLen = 0;
   void   *pReq = mndBuildSForceBecomeFollowerReq(pMnode, pVgroup, dnodeId, &contLen);
-  if (pReq == NULL) return -1;
+  if (pReq == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
 
   action.pCont = pReq;
   action.contLen = contLen;
   action.msgType = TDMT_SYNC_FORCE_FOLLOWER;
 
-  if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+  if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {
     taosMemoryFree(pReq);
-    return -1;
+    TAOS_RETURN(code);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndAddVgroupBalanceToTrans(SMnode *pMnode, SVgObj *pVgroup, STrans *pTrans) {
-  SSdb *pSdb = pMnode->pSdb;
+  int32_t code = 0;
+  SSdb   *pSdb = pMnode->pSdb;
 
   int32_t vgid = pVgroup->vgId;
   int8_t  replica = pVgroup->replica;
@@ -2342,15 +2520,17 @@ int32_t mndAddVgroupBalanceToTrans(SMnode *pMnode, SVgObj *pVgroup, STrans *pTra
   if (exist && online) {
     mInfo("trans:%d, vgid:%d leader to dnode:%d", pTrans->id, vgid, dnodeId);
 
-    if (mndAddBalanceVgroupLeaderAction(pMnode, pTrans, pVgroup, dnodeId) != 0) {
+    if ((code = mndAddBalanceVgroupLeaderAction(pMnode, pTrans, pVgroup, dnodeId)) != 0) {
       mError("trans:%d, vgid:%d failed to be balanced to dnode:%d", pTrans->id, vgid, dnodeId);
-      return -1;
+      TAOS_RETURN(code);
     }
 
     SDbObj *pDb = mndAcquireDb(pMnode, pVgroup->dbName);
     if (pDb == NULL) {
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
       mError("trans:%d, vgid:%d failed to be balanced to dnode:%d, because db not exist", pTrans->id, vgid, dnodeId);
-      return -1;
+      TAOS_RETURN(code);
     }
 
     mndReleaseDb(pMnode, pDb);
@@ -2359,7 +2539,7 @@ int32_t mndAddVgroupBalanceToTrans(SMnode *pMnode, SVgObj *pVgroup, STrans *pTra
           online);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 extern int32_t mndProcessVgroupBalanceLeaderMsgImp(SRpcMsg *pReq);
@@ -2392,8 +2572,7 @@ static int32_t mndCheckDnodeMemory(SMnode *pMnode, SDbObj *pOldDb, SDbObj *pNewD
     if (pDnode->memAvail - pDnode->memUsed <= 0) {
       mError("db:%s, vgId:%d, no enough memory in dnode:%d, avail:%" PRId64 " used:%" PRId64, pNewVgroup->dbName,
              pNewVgroup->vgId, pDnode->id, pDnode->memAvail, pDnode->memUsed);
-      terrno = TSDB_CODE_MND_NO_ENOUGH_MEM_IN_DNODE;
-      return -1;
+      TAOS_RETURN(TSDB_CODE_MND_NO_ENOUGH_MEM_IN_DNODE);
     } else if (inVgroup) {
       mInfo("db:%s, vgId:%d, memory in dnode:%d, avail:%" PRId64 " used:%" PRId64, pNewVgroup->dbName, pNewVgroup->vgId,
             pDnode->id, pDnode->memAvail, pDnode->memUsed);
@@ -2405,11 +2584,12 @@ static int32_t mndCheckDnodeMemory(SMnode *pMnode, SDbObj *pOldDb, SDbObj *pNewD
 
 int32_t mndBuildAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb, SDbObj *pNewDb, SVgObj *pVgroup,
                                   SArray *pArray, SVgObj *pNewVgroup) {
+  int32_t code = 0;
   memcpy(pNewVgroup, pVgroup, sizeof(SVgObj));
 
   if (pVgroup->replica <= 0 || pVgroup->replica == pNewDb->cfg.replications) {
-    if (mndAddAlterVnodeConfigAction(pMnode, pTrans, pNewDb, pVgroup) != 0) return -1;
-    if (mndCheckDnodeMemory(pMnode, pOldDb, pNewDb, pNewVgroup, pVgroup, pArray) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddAlterVnodeConfigAction(pMnode, pTrans, pNewDb, pVgroup));
+    TAOS_CHECK_RETURN(mndCheckDnodeMemory(pMnode, pOldDb, pNewDb, pNewVgroup, pVgroup, pArray));
     return 0;
   }
 
@@ -2420,78 +2600,78 @@ int32_t mndBuildAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb
           pVgroup->vnodeGid[0].dnodeId);
 
     // add second
-    if (mndAddVnodeToVgroup(pMnode, pTrans, pNewVgroup, pArray) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddVnodeToVgroup(pMnode, pTrans, pNewVgroup, pArray));
 
     // learner stage
     pNewVgroup->vnodeGid[0].nodeRole = TAOS_SYNC_ROLE_VOTER;
     pNewVgroup->vnodeGid[1].nodeRole = TAOS_SYNC_ROLE_LEARNER;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[0].dnodeId) != 0)
-      return -1;
+    TAOS_CHECK_RETURN(
+        mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[0].dnodeId));
 
-    if (mndAddCreateVnodeAction(pMnode, pTrans, pNewDb, pNewVgroup, &pNewVgroup->vnodeGid[1]) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddCreateVnodeAction(pMnode, pTrans, pNewDb, pNewVgroup, &pNewVgroup->vnodeGid[1]));
 
     // follower stage
     pNewVgroup->vnodeGid[1].nodeRole = TAOS_SYNC_ROLE_VOTER;
-    if (mndAddAlterVnodeTypeAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[1].dnodeId) != 0) return -1;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[0].dnodeId) != 0)
-      return -1;
+    TAOS_CHECK_RETURN(mndAddAlterVnodeTypeAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[1].dnodeId));
+    TAOS_CHECK_RETURN(
+        mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[0].dnodeId));
 
-    if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, pNewVgroup) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, pNewVgroup));
 
     // add third
-    if (mndAddVnodeToVgroup(pMnode, pTrans, pNewVgroup, pArray) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddVnodeToVgroup(pMnode, pTrans, pNewVgroup, pArray));
 
     pNewVgroup->vnodeGid[0].nodeRole = TAOS_SYNC_ROLE_VOTER;
     pNewVgroup->vnodeGid[1].nodeRole = TAOS_SYNC_ROLE_VOTER;
     pNewVgroup->vnodeGid[2].nodeRole = TAOS_SYNC_ROLE_VOTER;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[0].dnodeId) != 0)
-      return -1;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[1].dnodeId) != 0)
-      return -1;
-    if (mndAddCreateVnodeAction(pMnode, pTrans, pNewDb, pNewVgroup, &pNewVgroup->vnodeGid[2]) != 0) return -1;
+    TAOS_CHECK_RETURN(
+        mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[0].dnodeId));
+    TAOS_CHECK_RETURN(
+        mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[1].dnodeId));
+    TAOS_CHECK_RETURN(mndAddCreateVnodeAction(pMnode, pTrans, pNewDb, pNewVgroup, &pNewVgroup->vnodeGid[2]));
 
-    if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, pNewVgroup) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, pNewVgroup));
   } else if (pNewVgroup->replica == 3 && pNewDb->cfg.replications == 1) {
     mInfo("db:%s, vgId:%d, will remove 2 vnodes, vn:0 dnode:%d vn:1 dnode:%d vn:2 dnode:%d", pVgroup->dbName,
           pVgroup->vgId, pVgroup->vnodeGid[0].dnodeId, pVgroup->vnodeGid[1].dnodeId, pVgroup->vnodeGid[2].dnodeId);
 
     SVnodeGid del1 = {0};
     SVnodeGid del2 = {0};
-    if (mndRemoveVnodeFromVgroup(pMnode, pTrans, pNewVgroup, pArray, &del1) != 0) return -1;
-    if (mndAddDropVnodeAction(pMnode, pTrans, pNewDb, pNewVgroup, &del1, true) != 0) return -1;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[0].dnodeId) != 0)
-      return -1;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[1].dnodeId) != 0)
-      return -1;
-    if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, pNewVgroup) != 0) return -1;
+    TAOS_CHECK_RETURN(mndRemoveVnodeFromVgroup(pMnode, pTrans, pNewVgroup, pArray, &del1));
+    TAOS_CHECK_RETURN(mndAddDropVnodeAction(pMnode, pTrans, pNewDb, pNewVgroup, &del1, true));
+    TAOS_CHECK_RETURN(
+        mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[0].dnodeId));
+    TAOS_CHECK_RETURN(
+        mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[1].dnodeId));
+    TAOS_CHECK_RETURN(mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, pNewVgroup));
 
-    if (mndRemoveVnodeFromVgroup(pMnode, pTrans, pNewVgroup, pArray, &del2) != 0) return -1;
-    if (mndAddDropVnodeAction(pMnode, pTrans, pNewDb, pNewVgroup, &del2, true) != 0) return -1;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[0].dnodeId) != 0)
-      return -1;
-    if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, pNewVgroup) != 0) return -1;
+    TAOS_CHECK_RETURN(mndRemoveVnodeFromVgroup(pMnode, pTrans, pNewVgroup, pArray, &del2));
+    TAOS_CHECK_RETURN(mndAddDropVnodeAction(pMnode, pTrans, pNewDb, pNewVgroup, &del2, true));
+    TAOS_CHECK_RETURN(
+        mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[0].dnodeId));
+    TAOS_CHECK_RETURN(mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, pNewVgroup));
   } else if (pNewVgroup->replica == 1 && pNewDb->cfg.replications == 2) {
     mInfo("db:%s, vgId:%d, will add 1 vnode, vn:0 dnode:%d", pVgroup->dbName, pVgroup->vgId,
           pVgroup->vnodeGid[0].dnodeId);
 
     // add second
-    if (mndAddVnodeToVgroup(pMnode, pTrans, pNewVgroup, pArray) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddVnodeToVgroup(pMnode, pTrans, pNewVgroup, pArray));
 
     // learner stage
     pNewVgroup->vnodeGid[0].nodeRole = TAOS_SYNC_ROLE_VOTER;
     pNewVgroup->vnodeGid[1].nodeRole = TAOS_SYNC_ROLE_LEARNER;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[0].dnodeId) != 0)
-      return -1;
+    TAOS_CHECK_RETURN(
+        mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[0].dnodeId));
 
-    if (mndAddCreateVnodeAction(pMnode, pTrans, pNewDb, pNewVgroup, &pNewVgroup->vnodeGid[1]) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddCreateVnodeAction(pMnode, pTrans, pNewDb, pNewVgroup, &pNewVgroup->vnodeGid[1]));
 
     // follower stage
     pNewVgroup->vnodeGid[1].nodeRole = TAOS_SYNC_ROLE_VOTER;
-    if (mndAddAlterVnodeTypeAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[1].dnodeId) != 0) return -1;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[0].dnodeId) != 0)
-      return -1;
+    TAOS_CHECK_RETURN(mndAddAlterVnodeTypeAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[1].dnodeId));
+    TAOS_CHECK_RETURN(
+        mndAddAlterVnodeReplicaAction(pMnode, pTrans, pNewDb, pNewVgroup, pNewVgroup->vnodeGid[0].dnodeId));
 
-    if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, pNewVgroup) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, pNewVgroup));
   } else {
     return -1;
   }
@@ -2500,25 +2680,30 @@ int32_t mndBuildAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb
 
   {
     SSdbRaw *pVgRaw = mndVgroupActionEncode(pNewVgroup);
-    if (pVgRaw == NULL) return -1;
-    if (mndTransAppendCommitlog(pTrans, pVgRaw) != 0) {
+    if (pVgRaw == NULL) {
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
+      TAOS_RETURN(code);
+    }
+    if ((code = mndTransAppendCommitlog(pTrans, pVgRaw)) != 0) {
       sdbFreeRaw(pVgRaw);
-      return -1;
+      TAOS_RETURN(code);
     }
     (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndBuildRaftAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb, SDbObj *pNewDb, SVgObj *pVgroup,
                                       SArray *pArray) {
-  SVgObj newVgroup = {0};
+  int32_t code = 0;
+  SVgObj  newVgroup = {0};
   memcpy(&newVgroup, pVgroup, sizeof(SVgObj));
 
   if (pVgroup->replica <= 0 || pVgroup->replica == pNewDb->cfg.replications) {
-    if (mndAddAlterVnodeConfigAction(pMnode, pTrans, pNewDb, pVgroup) != 0) return -1;
-    if (mndCheckDnodeMemory(pMnode, pOldDb, pNewDb, &newVgroup, pVgroup, pArray) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddAlterVnodeConfigAction(pMnode, pTrans, pNewDb, pVgroup));
+    TAOS_CHECK_RETURN(mndCheckDnodeMemory(pMnode, pOldDb, pNewDb, &newVgroup, pVgroup, pArray));
     return 0;
   }
 
@@ -2532,22 +2717,22 @@ int32_t mndBuildRaftAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pO
           pVgroup->vnodeGid[0].dnodeId);
 
     // add second
-    if (mndAddVnodeToVgroup(pMnode, pTrans, &newVgroup, pArray) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddVnodeToVgroup(pMnode, pTrans, &newVgroup, pArray));
     // add third
-    if (mndAddVnodeToVgroup(pMnode, pTrans, &newVgroup, pArray) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddVnodeToVgroup(pMnode, pTrans, &newVgroup, pArray));
 
     // add learner stage
     newVgroup.vnodeGid[0].nodeRole = TAOS_SYNC_ROLE_VOTER;
     newVgroup.vnodeGid[1].nodeRole = TAOS_SYNC_ROLE_LEARNER;
     newVgroup.vnodeGid[2].nodeRole = TAOS_SYNC_ROLE_LEARNER;
-    if (mndAddChangeConfigAction(pMnode, pTrans, pNewDb, pVgroup, &newVgroup, newVgroup.vnodeGid[0].dnodeId) != 0)
-      return -1;
+    TAOS_CHECK_RETURN(
+        mndAddChangeConfigAction(pMnode, pTrans, pNewDb, pVgroup, &newVgroup, newVgroup.vnodeGid[0].dnodeId));
     mInfo("trans:%d, vgId:%d, add change config, syncConfChangeVer:%d, version:%d, replica:%d", pTrans->id,
           pVgroup->vgId, newVgroup.syncConfChangeVer, pVgroup->version, pVgroup->replica);
-    if (mndAddCreateVnodeAction(pMnode, pTrans, pNewDb, &newVgroup, &newVgroup.vnodeGid[1]) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddCreateVnodeAction(pMnode, pTrans, pNewDb, &newVgroup, &newVgroup.vnodeGid[1]));
     mInfo("trans:%d, vgId:%d, create vnode, syncConfChangeVer:%d, version:%d, replica:%d", pTrans->id, pVgroup->vgId,
           newVgroup.syncConfChangeVer, pVgroup->version, pVgroup->replica);
-    if (mndAddCreateVnodeAction(pMnode, pTrans, pNewDb, &newVgroup, &newVgroup.vnodeGid[2]) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddCreateVnodeAction(pMnode, pTrans, pNewDb, &newVgroup, &newVgroup.vnodeGid[2]));
     mInfo("trans:%d, vgId:%d, create vnode, syncConfChangeVer:%d, version:%d, replica:%d", pTrans->id, pVgroup->vgId,
           newVgroup.syncConfChangeVer, pVgroup->version, pVgroup->replica);
 
@@ -2555,33 +2740,37 @@ int32_t mndBuildRaftAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pO
     newVgroup.vnodeGid[0].nodeRole = TAOS_SYNC_ROLE_VOTER;
     newVgroup.vnodeGid[1].nodeRole = TAOS_SYNC_ROLE_VOTER;
     newVgroup.vnodeGid[2].nodeRole = TAOS_SYNC_ROLE_VOTER;
-    if (mndAddCheckLearnerCatchupAction(pMnode, pTrans, pNewDb, &newVgroup, newVgroup.vnodeGid[1].dnodeId) != 0)
-      return -1;
-    if (mndAddCheckLearnerCatchupAction(pMnode, pTrans, pNewDb, &newVgroup, newVgroup.vnodeGid[2].dnodeId) != 0)
-      return -1;
+    TAOS_CHECK_RETURN(
+        mndAddCheckLearnerCatchupAction(pMnode, pTrans, pNewDb, &newVgroup, newVgroup.vnodeGid[1].dnodeId));
+    TAOS_CHECK_RETURN(
+        mndAddCheckLearnerCatchupAction(pMnode, pTrans, pNewDb, &newVgroup, newVgroup.vnodeGid[2].dnodeId));
 
     // change raft type
     newVgroup.vnodeGid[0].nodeRole = TAOS_SYNC_ROLE_VOTER;
     newVgroup.vnodeGid[1].nodeRole = TAOS_SYNC_ROLE_VOTER;
     newVgroup.vnodeGid[2].nodeRole = TAOS_SYNC_ROLE_LEARNER;
-    if (mndAddChangeConfigAction(pMnode, pTrans, pNewDb, pVgroup, &newVgroup, newVgroup.vnodeGid[0].dnodeId) != 0)
-      return -1;
+    TAOS_CHECK_RETURN(
+        mndAddChangeConfigAction(pMnode, pTrans, pNewDb, pVgroup, &newVgroup, newVgroup.vnodeGid[0].dnodeId));
 
-    if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, &newVgroup) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, &newVgroup));
 
     newVgroup.vnodeGid[0].nodeRole = TAOS_SYNC_ROLE_VOTER;
     newVgroup.vnodeGid[1].nodeRole = TAOS_SYNC_ROLE_VOTER;
     newVgroup.vnodeGid[2].nodeRole = TAOS_SYNC_ROLE_VOTER;
-    if (mndAddChangeConfigAction(pMnode, pTrans, pNewDb, pVgroup, &newVgroup, newVgroup.vnodeGid[0].dnodeId) != 0)
-      return -1;
+    TAOS_CHECK_RETURN(
+        mndAddChangeConfigAction(pMnode, pTrans, pNewDb, pVgroup, &newVgroup, newVgroup.vnodeGid[0].dnodeId));
 
-    if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, &newVgroup) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, &newVgroup));
 
     SSdbRaw *pVgRaw = mndVgroupActionEncode(&newVgroup);
-    if (pVgRaw == NULL) return -1;
-    if (mndTransAppendRedolog(pTrans, pVgRaw) != 0) {
+    if (pVgRaw == NULL) {
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
+      TAOS_RETURN(code);
+    }
+    if ((code = mndTransAppendRedolog(pTrans, pVgRaw)) != 0) {
       sdbFreeRaw(pVgRaw);
-      return -1;
+      TAOS_RETURN(code);
     }
     (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY);
   } else if (newVgroup.replica == 3 && pNewDb->cfg.replications == 1) {
@@ -2589,38 +2778,46 @@ int32_t mndBuildRaftAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pO
           pVgroup->vgId, pVgroup->vnodeGid[0].dnodeId, pVgroup->vnodeGid[1].dnodeId, pVgroup->vnodeGid[2].dnodeId);
 
     SVnodeGid del1 = {0};
-    if (mndRemoveVnodeFromVgroupWithoutSave(pMnode, pTrans, &newVgroup, pArray, &del1) != 0) return -1;
+    TAOS_CHECK_RETURN(mndRemoveVnodeFromVgroupWithoutSave(pMnode, pTrans, &newVgroup, pArray, &del1));
 
-    if (mndAddChangeConfigAction(pMnode, pTrans, pNewDb, pVgroup, &newVgroup, newVgroup.vnodeGid[0].dnodeId) != 0)
-      return -1;
+    TAOS_CHECK_RETURN(
+        mndAddChangeConfigAction(pMnode, pTrans, pNewDb, pVgroup, &newVgroup, newVgroup.vnodeGid[0].dnodeId));
 
-    if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, &newVgroup) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, &newVgroup));
 
-    if (mndAddDropVnodeAction(pMnode, pTrans, pNewDb, &newVgroup, &del1, true) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddDropVnodeAction(pMnode, pTrans, pNewDb, &newVgroup, &del1, true));
 
     SSdbRaw *pVgRaw = mndVgroupActionEncode(&newVgroup);
-    if (pVgRaw == NULL) return -1;
-    if (mndTransAppendRedolog(pTrans, pVgRaw) != 0) {
+    if (pVgRaw == NULL) {
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
+      TAOS_RETURN(code);
+    }
+    if ((code = mndTransAppendRedolog(pTrans, pVgRaw)) != 0) {
       sdbFreeRaw(pVgRaw);
-      return -1;
+      TAOS_RETURN(code);
     }
     (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY);
 
     SVnodeGid del2 = {0};
-    if (mndRemoveVnodeFromVgroupWithoutSave(pMnode, pTrans, &newVgroup, pArray, &del2) != 0) return -1;
+    TAOS_CHECK_RETURN(mndRemoveVnodeFromVgroupWithoutSave(pMnode, pTrans, &newVgroup, pArray, &del2));
 
-    if (mndAddChangeConfigAction(pMnode, pTrans, pNewDb, pVgroup, &newVgroup, newVgroup.vnodeGid[0].dnodeId) != 0)
-      return -1;
+    TAOS_CHECK_RETURN(
+        mndAddChangeConfigAction(pMnode, pTrans, pNewDb, pVgroup, &newVgroup, newVgroup.vnodeGid[0].dnodeId));
 
-    if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, &newVgroup) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddAlterVnodeConfirmAction(pMnode, pTrans, pNewDb, &newVgroup));
 
-    if (mndAddDropVnodeAction(pMnode, pTrans, pNewDb, &newVgroup, &del2, true) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddDropVnodeAction(pMnode, pTrans, pNewDb, &newVgroup, &del2, true));
 
     pVgRaw = mndVgroupActionEncode(&newVgroup);
-    if (pVgRaw == NULL) return -1;
-    if (mndTransAppendRedolog(pTrans, pVgRaw) != 0) {
+    if (pVgRaw == NULL) {
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
+      TAOS_RETURN(code);
+    }
+    if ((code = mndTransAppendRedolog(pTrans, pVgRaw)) != 0) {
       sdbFreeRaw(pVgRaw);
-      return -1;
+      TAOS_RETURN(code);
     }
     (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY);
   } else {
@@ -2631,20 +2828,25 @@ int32_t mndBuildRaftAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pO
 
   {
     SSdbRaw *pVgRaw = mndVgroupActionEncode(&newVgroup);
-    if (pVgRaw == NULL) return -1;
-    if (mndTransAppendCommitlog(pTrans, pVgRaw) != 0) {
+    if (pVgRaw == NULL) {
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
+      TAOS_RETURN(code);
+    }
+    if ((code = mndTransAppendCommitlog(pTrans, pVgRaw)) != 0) {
       sdbFreeRaw(pVgRaw);
-      return -1;
+      TAOS_RETURN(code);
     }
     (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndBuildRestoreAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *db, SVgObj *pVgroup,
                                          SDnodeObj *pDnode) {
-  SVgObj newVgroup = {0};
+  int32_t code = 0;
+  SVgObj  newVgroup = {0};
   memcpy(&newVgroup, pVgroup, sizeof(SVgObj));
 
   mInfo("db:%s, vgId:%d, restore vnodes, vn:0 dnode:%d", pVgroup->dbName, pVgroup->vgId, pVgroup->vnodeGid[0].dnodeId);
@@ -2657,7 +2859,7 @@ int32_t mndBuildRestoreAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj
         selected = i;
       }
     }
-    if (mndAddCreateVnodeAction(pMnode, pTrans, db, &newVgroup, &newVgroup.vnodeGid[selected]) != 0) return -1;
+    TAOS_CHECK_RETURN(mndAddCreateVnodeAction(pMnode, pTrans, db, &newVgroup, &newVgroup.vnodeGid[selected]));
   } else if (newVgroup.replica == 2 || newVgroup.replica == 3) {
     for (int i = 0; i < newVgroup.replica; i++) {
       if (newVgroup.vnodeGid[i].dnodeId == pDnode->id) {
@@ -2666,25 +2868,29 @@ int32_t mndBuildRestoreAlterVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj
         newVgroup.vnodeGid[i].nodeRole = TAOS_SYNC_ROLE_VOTER;
       }
     }
-    if (mndRestoreAddCreateVnodeAction(pMnode, pTrans, db, &newVgroup, pDnode) != 0) return -1;
+    TAOS_CHECK_RETURN(mndRestoreAddCreateVnodeAction(pMnode, pTrans, db, &newVgroup, pDnode));
 
     for (int i = 0; i < newVgroup.replica; i++) {
       newVgroup.vnodeGid[i].nodeRole = TAOS_SYNC_ROLE_VOTER;
       if (newVgroup.vnodeGid[i].dnodeId == pDnode->id) {
       }
     }
-    if (mndRestoreAddAlterVnodeTypeAction(pMnode, pTrans, db, &newVgroup, pDnode) != 0) return -1;
+    TAOS_CHECK_RETURN(mndRestoreAddAlterVnodeTypeAction(pMnode, pTrans, db, &newVgroup, pDnode));
   }
 
   SSdbRaw *pVgRaw = mndVgroupActionEncode(&newVgroup);
-  if (pVgRaw == NULL) return -1;
-  if (mndTransAppendCommitlog(pTrans, pVgRaw) != 0) {
+  if (pVgRaw == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
+  if ((code = mndTransAppendCommitlog(pTrans, pVgRaw)) != 0) {
     sdbFreeRaw(pVgRaw);
-    return -1;
+    TAOS_RETURN(code);
   }
   (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_READY);
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndAddAdjustVnodeHashRangeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup) {
@@ -2694,29 +2900,39 @@ static int32_t mndAddAdjustVnodeHashRangeAction(SMnode *pMnode, STrans *pTrans,
 typedef int32_t (*FpTransActionCb)(STrans *pTrans, SSdbRaw *pRaw);
 
 static int32_t mndAddVgStatusAction(STrans *pTrans, SVgObj *pVg, ESdbStatus vgStatus, ETrnStage stage) {
+  int32_t         code = 0;
   FpTransActionCb appendActionCb = (stage == TRN_STAGE_COMMIT_ACTION) ? mndTransAppendCommitlog : mndTransAppendRedolog;
   SSdbRaw        *pRaw = mndVgroupActionEncode(pVg);
-  if (pRaw == NULL) goto _err;
-  if (appendActionCb(pTrans, pRaw) != 0) goto _err;
+  if (pRaw == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    goto _err;
+  }
+  if ((code = appendActionCb(pTrans, pRaw)) != 0) goto _err;
   (void)sdbSetRawStatus(pRaw, vgStatus);
   pRaw = NULL;
-  return 0;
+  TAOS_RETURN(code);
 _err:
   sdbFreeRaw(pRaw);
-  return -1;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndAddDbStatusAction(STrans *pTrans, SDbObj *pDb, ESdbStatus dbStatus, ETrnStage stage) {
+  int32_t         code = 0;
   FpTransActionCb appendActionCb = (stage == TRN_STAGE_COMMIT_ACTION) ? mndTransAppendCommitlog : mndTransAppendRedolog;
   SSdbRaw        *pRaw = mndDbActionEncode(pDb);
-  if (pRaw == NULL) goto _err;
-  if (appendActionCb(pTrans, pRaw) != 0) goto _err;
+  if (pRaw == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    goto _err;
+  }
+  if ((code = appendActionCb(pTrans, pRaw)) != 0) goto _err;
   (void)sdbSetRawStatus(pRaw, dbStatus);
   pRaw = NULL;
-  return 0;
+  TAOS_RETURN(code);
 _err:
   sdbFreeRaw(pRaw);
-  return -1;
+  TAOS_RETURN(code);
 }
 
 int32_t mndSplitVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SVgObj *pVgroup) {
@@ -2726,11 +2942,11 @@ int32_t mndSplitVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SVgObj *pVgro
   SArray *pArray = mndBuildDnodesArray(pMnode, 0);
 
   int32_t numOfStreams = 0;
-  if (mndGetNumOfStreams(pMnode, pDb->name, &numOfStreams) != 0) {
+  if ((code = mndGetNumOfStreams(pMnode, pDb->name, &numOfStreams)) != 0) {
     goto _OVER;
   }
   if (numOfStreams > 0) {
-    terrno = TSDB_CODE_MND_STREAM_MUST_BE_DELETED;
+    code = TSDB_CODE_MND_STREAM_MUST_BE_DELETED;
     goto _OVER;
   }
 
@@ -2750,7 +2966,11 @@ int32_t mndSplitVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SVgObj *pVgro
   }
 
   pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "split-vgroup");
-  if (pTrans == NULL) goto _OVER;
+  if (pTrans == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    goto _OVER;
+  }
   mndTransSetSerial(pTrans);
   mInfo("trans:%d, used to split vgroup, vgId:%d", pTrans->id, pVgroup->vgId);
 
@@ -2765,31 +2985,36 @@ int32_t mndSplitVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SVgObj *pVgro
   }
 
   if (newVg1.replica == 1) {
-    if (mndAddVnodeToVgroup(pMnode, pTrans, &newVg1, pArray) != 0) goto _OVER;
+    TAOS_CHECK_GOTO(mndAddVnodeToVgroup(pMnode, pTrans, &newVg1, pArray), NULL, _OVER);
 
     newVg1.vnodeGid[1].nodeRole = TAOS_SYNC_ROLE_LEARNER;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg1, newVg1.vnodeGid[0].dnodeId) != 0) goto _OVER;
-    if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, &newVg1, &newVg1.vnodeGid[1]) != 0) goto _OVER;
+    TAOS_CHECK_GOTO(mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg1, newVg1.vnodeGid[0].dnodeId), NULL,
+                    _OVER);
+    TAOS_CHECK_GOTO(mndAddCreateVnodeAction(pMnode, pTrans, pDb, &newVg1, &newVg1.vnodeGid[1]), NULL, _OVER);
 
     newVg1.vnodeGid[1].nodeRole = TAOS_SYNC_ROLE_VOTER;
-    if (mndAddAlterVnodeTypeAction(pMnode, pTrans, pDb, &newVg1, newVg1.vnodeGid[1].dnodeId) != 0) goto _OVER;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg1, newVg1.vnodeGid[0].dnodeId) != 0) goto _OVER;
+    TAOS_CHECK_GOTO(mndAddAlterVnodeTypeAction(pMnode, pTrans, pDb, &newVg1, newVg1.vnodeGid[1].dnodeId), NULL, _OVER);
+    TAOS_CHECK_GOTO(mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg1, newVg1.vnodeGid[0].dnodeId), NULL,
+                    _OVER);
 
-    if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, &newVg1) != 0) goto _OVER;
+    TAOS_CHECK_GOTO(mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, &newVg1), NULL, _OVER);
   } else if (newVg1.replica == 3) {
     SVnodeGid del1 = {0};
-    if (mndRemoveVnodeFromVgroup(pMnode, pTrans, &newVg1, pArray, &del1) != 0) goto _OVER;
-    if (mndAddDropVnodeAction(pMnode, pTrans, pDb, &newVg1, &del1, true) != 0) goto _OVER;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg1, newVg1.vnodeGid[0].dnodeId) != 0) goto _OVER;
-    if (mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg1, newVg1.vnodeGid[1].dnodeId) != 0) goto _OVER;
+    TAOS_CHECK_GOTO(mndRemoveVnodeFromVgroup(pMnode, pTrans, &newVg1, pArray, &del1), NULL, _OVER);
+    TAOS_CHECK_GOTO(mndAddDropVnodeAction(pMnode, pTrans, pDb, &newVg1, &del1, true), NULL, _OVER);
+    TAOS_CHECK_GOTO(mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg1, newVg1.vnodeGid[0].dnodeId), NULL,
+                    _OVER);
+    TAOS_CHECK_GOTO(mndAddAlterVnodeReplicaAction(pMnode, pTrans, pDb, &newVg1, newVg1.vnodeGid[1].dnodeId), NULL,
+                    _OVER);
   } else {
     goto _OVER;
   }
 
   for (int32_t i = 0; i < newVg1.replica; ++i) {
-    if (mndAddDisableVnodeWriteAction(pMnode, pTrans, pDb, &newVg1, newVg1.vnodeGid[i].dnodeId) != 0) goto _OVER;
+    TAOS_CHECK_GOTO(mndAddDisableVnodeWriteAction(pMnode, pTrans, pDb, &newVg1, newVg1.vnodeGid[i].dnodeId), NULL,
+                    _OVER);
   }
-  if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, &newVg1) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, &newVg1), NULL, _OVER);
 
   SVgObj newVg2 = {0};
   memcpy(&newVg2, &newVg1, sizeof(SVgObj));
@@ -2817,63 +3042,66 @@ int32_t mndSplitVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SVgObj *pVgro
   int32_t maxVgId = sdbGetMaxId(pMnode->pSdb, SDB_VGROUP);
   int32_t srcVgId = newVg1.vgId;
   newVg1.vgId = maxVgId;
-  if (mndAddNewVgPrepareAction(pMnode, pTrans, &newVg1) != 0) goto _OVER;
-  if (mndAddAlterVnodeHashRangeAction(pMnode, pTrans, srcVgId, &newVg1) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndAddNewVgPrepareAction(pMnode, pTrans, &newVg1), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndAddAlterVnodeHashRangeAction(pMnode, pTrans, srcVgId, &newVg1), NULL, _OVER);
 
   maxVgId++;
   srcVgId = newVg2.vgId;
   newVg2.vgId = maxVgId;
-  if (mndAddNewVgPrepareAction(pMnode, pTrans, &newVg2) != 0) goto _OVER;
-  if (mndAddAlterVnodeHashRangeAction(pMnode, pTrans, srcVgId, &newVg2) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndAddNewVgPrepareAction(pMnode, pTrans, &newVg2), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndAddAlterVnodeHashRangeAction(pMnode, pTrans, srcVgId, &newVg2), NULL, _OVER);
 
-  if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, &newVg1) != 0) goto _OVER;
-  if (mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, &newVg2) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, &newVg1), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndAddAlterVnodeConfirmAction(pMnode, pTrans, pDb, &newVg2), NULL, _OVER);
 
-  if (mndAddVgStatusAction(pTrans, &newVg1, SDB_STATUS_READY, TRN_STAGE_REDO_ACTION) < 0) goto _OVER;
-  if (mndAddVgStatusAction(pTrans, &newVg2, SDB_STATUS_READY, TRN_STAGE_REDO_ACTION) < 0) goto _OVER;
-  if (mndAddVgStatusAction(pTrans, pVgroup, SDB_STATUS_DROPPED, TRN_STAGE_REDO_ACTION) < 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndAddVgStatusAction(pTrans, &newVg1, SDB_STATUS_READY, TRN_STAGE_REDO_ACTION), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndAddVgStatusAction(pTrans, &newVg2, SDB_STATUS_READY, TRN_STAGE_REDO_ACTION), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndAddVgStatusAction(pTrans, pVgroup, SDB_STATUS_DROPPED, TRN_STAGE_REDO_ACTION), NULL, _OVER);
 
   // update db status
   memcpy(&dbObj, pDb, sizeof(SDbObj));
   if (dbObj.cfg.pRetensions != NULL) {
     dbObj.cfg.pRetensions = taosArrayDup(pDb->cfg.pRetensions, NULL);
-    if (dbObj.cfg.pRetensions == NULL) goto _OVER;
+    if (dbObj.cfg.pRetensions == NULL) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      goto _OVER;
+    }
   }
   dbObj.vgVersion++;
   dbObj.updateTime = taosGetTimestampMs();
   dbObj.cfg.numOfVgroups++;
-  if (mndAddDbStatusAction(pTrans, &dbObj, SDB_STATUS_READY, TRN_STAGE_REDO_ACTION) < 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndAddDbStatusAction(pTrans, &dbObj, SDB_STATUS_READY, TRN_STAGE_REDO_ACTION), NULL, _OVER);
 
   // adjust vgroup replica
   if (pDb->cfg.replications != newVg1.replica) {
     SVgObj tmpGroup = {0};
-    if (mndBuildAlterVgroupAction(pMnode, pTrans, pDb, pDb, &newVg1, pArray, &tmpGroup) != 0) goto _OVER;
+    TAOS_CHECK_GOTO(mndBuildAlterVgroupAction(pMnode, pTrans, pDb, pDb, &newVg1, pArray, &tmpGroup), NULL, _OVER);
   } else {
-    if (mndAddVgStatusAction(pTrans, &newVg1, SDB_STATUS_READY, TRN_STAGE_COMMIT_ACTION) < 0) goto _OVER;
+    TAOS_CHECK_GOTO(mndAddVgStatusAction(pTrans, &newVg1, SDB_STATUS_READY, TRN_STAGE_COMMIT_ACTION), NULL, _OVER);
   }
 
   if (pDb->cfg.replications != newVg2.replica) {
     SVgObj tmpGroup = {0};
-    if (mndBuildAlterVgroupAction(pMnode, pTrans, pDb, pDb, &newVg2, pArray, &tmpGroup) != 0) goto _OVER;
+    TAOS_CHECK_GOTO(mndBuildAlterVgroupAction(pMnode, pTrans, pDb, pDb, &newVg2, pArray, &tmpGroup), NULL, _OVER);
   } else {
-    if (mndAddVgStatusAction(pTrans, &newVg2, SDB_STATUS_READY, TRN_STAGE_COMMIT_ACTION) < 0) goto _OVER;
+    TAOS_CHECK_GOTO(mndAddVgStatusAction(pTrans, &newVg2, SDB_STATUS_READY, TRN_STAGE_COMMIT_ACTION), NULL, _OVER);
   }
 
-  if (mndAddVgStatusAction(pTrans, pVgroup, SDB_STATUS_DROPPED, TRN_STAGE_COMMIT_ACTION) < 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndAddVgStatusAction(pTrans, pVgroup, SDB_STATUS_DROPPED, TRN_STAGE_COMMIT_ACTION), NULL, _OVER);
 
   // commit db status
   dbObj.vgVersion++;
   dbObj.updateTime = taosGetTimestampMs();
-  if (mndAddDbStatusAction(pTrans, &dbObj, SDB_STATUS_READY, TRN_STAGE_COMMIT_ACTION) < 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndAddDbStatusAction(pTrans, &dbObj, SDB_STATUS_READY, TRN_STAGE_COMMIT_ACTION), NULL, _OVER);
 
-  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
   code = 0;
 
 _OVER:
   taosArrayDestroy(pArray);
   mndTransDrop(pTrans);
   taosArrayDestroy(dbObj.cfg.pRetensions);
-  return code;
+  TAOS_RETURN(code);
 }
 
 extern int32_t mndProcessSplitVgroupMsgImp(SRpcMsg *pReq);
@@ -2886,22 +3114,27 @@ int32_t mndProcessSplitVgroupMsgImp(SRpcMsg *pReq) { return 0; }
 
 static int32_t mndSetBalanceVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup,
                                               SDnodeObj *pSrc, SDnodeObj *pDst) {
-  SVgObj newVg = {0};
+  int32_t code = 0;
+  SVgObj  newVg = {0};
   memcpy(&newVg, pVgroup, sizeof(SVgObj));
   mInfo("vgId:%d, vgroup info before balance, replica:%d", newVg.vgId, newVg.replica);
   for (int32_t i = 0; i < newVg.replica; ++i) {
     mInfo("vgId:%d, vnode:%d dnode:%d", newVg.vgId, i, newVg.vnodeGid[i].dnodeId);
   }
 
-  if (mndAddIncVgroupReplicaToTrans(pMnode, pTrans, pDb, &newVg, pDst->id) != 0) return -1;
-  if (mndAddDecVgroupReplicaFromTrans(pMnode, pTrans, pDb, &newVg, pSrc->id) != 0) return -1;
+  TAOS_CHECK_RETURN(mndAddIncVgroupReplicaToTrans(pMnode, pTrans, pDb, &newVg, pDst->id));
+  TAOS_CHECK_RETURN(mndAddDecVgroupReplicaFromTrans(pMnode, pTrans, pDb, &newVg, pSrc->id));
 
   {
     SSdbRaw *pRaw = mndVgroupActionEncode(&newVg);
-    if (pRaw == NULL) return -1;
-    if (mndTransAppendCommitlog(pTrans, pRaw) != 0) {
+    if (pRaw == NULL) {
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
+      TAOS_RETURN(code);
+    }
+    if ((code = mndTransAppendCommitlog(pTrans, pRaw)) != 0) {
       sdbFreeRaw(pRaw);
-      return -1;
+      TAOS_RETURN(code);
     }
     (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY);
   }
@@ -2910,7 +3143,7 @@ static int32_t mndSetBalanceVgroupInfoToTrans(SMnode *pMnode, STrans *pTrans, SD
   for (int32_t i = 0; i < newVg.replica; ++i) {
     mInfo("vgId:%d, vnode:%d dnode:%d", newVg.vgId, i, newVg.vnodeGid[i].dnodeId);
   }
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndBalanceVgroupBetweenDnode(SMnode *pMnode, STrans *pTrans, SDnodeObj *pSrc, SDnodeObj *pDst,
@@ -2943,6 +3176,8 @@ static int32_t mndBalanceVgroupBetweenDnode(SMnode *pMnode, STrans *pTrans, SDno
 
     SDbObj *pDb = mndAcquireDb(pMnode, pVgroup->dbName);
     if (pDb == NULL) {
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
       mError("vgId:%d, balance vgroup can't find db obj dbName:%s", pVgroup->vgId, pVgroup->dbName);
       goto _OUT;
     }
@@ -2977,7 +3212,11 @@ static int32_t mndBalanceVgroup(SMnode *pMnode, SRpcMsg *pReq, SArray *pArray) {
   if (pBalancedVgroups == NULL) goto _OVER;
 
   pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_GLOBAL, pReq, "balance-vgroup");
-  if (pTrans == NULL) goto _OVER;
+  if (pTrans == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    goto _OVER;
+  }
   mndTransSetSerial(pTrans);
   mInfo("trans:%d, used to balance vgroup", pTrans->id);
 
@@ -3026,7 +3265,7 @@ static int32_t mndBalanceVgroup(SMnode *pMnode, SRpcMsg *pReq, SArray *pArray) {
 _OVER:
   taosHashCleanup(pBalancedVgroups);
   mndTransDrop(pTrans);
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndProcessBalanceVgroupMsg(SRpcMsg *pReq) {
@@ -3038,12 +3277,12 @@ static int32_t mndProcessBalanceVgroupMsg(SRpcMsg *pReq) {
 
   SBalanceVgroupReq req = {0};
   if (tDeserializeSBalanceVgroupReq(pReq->pCont, pReq->contLen, &req) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
+    code = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
 
   mInfo("start to balance vgroup");
-  if (mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_BALANCE_VGROUP) != 0) {
+  if ((code = mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_BALANCE_VGROUP)) != 0) {
     goto _OVER;
   }
 
@@ -3053,7 +3292,7 @@ static int32_t mndProcessBalanceVgroupMsg(SRpcMsg *pReq) {
     if (pIter == NULL) break;
     if (!mndIsDnodeOnline(pDnode, curMs)) {
       sdbCancelFetch(pMnode->pSdb, pIter);
-      terrno = TSDB_CODE_MND_HAS_OFFLINE_DNODE;
+      code = TSDB_CODE_MND_HAS_OFFLINE_DNODE;
       mError("failed to balance vgroup since %s, dnode:%d", terrstr(), pDnode->id);
       sdbRelease(pMnode->pSdb, pDnode);
       goto _OVER;
@@ -3063,7 +3302,11 @@ static int32_t mndProcessBalanceVgroupMsg(SRpcMsg *pReq) {
   }
 
   pArray = mndBuildDnodesArray(pMnode, 0);
-  if (pArray == NULL) goto _OVER;
+  if (pArray == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    goto _OVER;
+  }
 
   if (taosArrayGetSize(pArray) < 2) {
     mInfo("no need to balance vgroup since dnode num less than 2");
@@ -3076,12 +3319,12 @@ static int32_t mndProcessBalanceVgroupMsg(SRpcMsg *pReq) {
 
 _OVER:
   if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {
-    mError("failed to balance vgroup since %s", terrstr());
+    mError("failed to balance vgroup since %s", tstrerror(code));
   }
 
   taosArrayDestroy(pArray);
   tFreeSBalanceVgroupReq(&req);
-  return code;
+  TAOS_RETURN(code);
 }
 
 bool mndVgroupInDb(SVgObj *pVgroup, int64_t dbUid) { return !pVgroup->isTsma && pVgroup->dbUid == dbUid; }
@@ -3126,27 +3369,32 @@ static void *mndBuildCompactVnodeReq(SMnode *pMnode, SDbObj *pDb, SVgObj *pVgrou
 
 static int32_t mndAddCompactVnodeAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, int64_t compactTs,
                                         STimeWindow tw) {
+  int32_t      code = 0;
   STransAction action = {0};
   action.epSet = mndGetVgroupEpset(pMnode, pVgroup);
 
   int32_t contLen = 0;
   void   *pReq = mndBuildCompactVnodeReq(pMnode, pDb, pVgroup, &contLen, compactTs, tw);
-  if (pReq == NULL) return -1;
+  if (pReq == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
 
   action.pCont = pReq;
   action.contLen = contLen;
   action.msgType = TDMT_VND_COMPACT;
 
-  if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+  if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {
     taosMemoryFree(pReq);
-    return -1;
+    TAOS_RETURN(code);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndBuildCompactVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup, int64_t compactTs,
                                     STimeWindow tw) {
-  if (mndAddCompactVnodeAction(pMnode, pTrans, pDb, pVgroup, compactTs, tw) != 0) return -1;
+  TAOS_CHECK_RETURN(mndAddCompactVnodeAction(pMnode, pTrans, pDb, pVgroup, compactTs, tw));
   return 0;
 }
diff --git a/source/dnode/mnode/impl/src/mndView.c b/source/dnode/mnode/impl/src/mndView.c
index d53e740736..f4138b2afe 100755
--- a/source/dnode/mnode/impl/src/mndView.c
+++ b/source/dnode/mnode/impl/src/mndView.c
@@ -43,18 +43,15 @@ int32_t mndInitView(SMnode *pMnode) {
 #endif
 }
 
-void mndCleanupView(SMnode *pMnode) {
-  mDebug("mnd view cleanup");
-}
+void mndCleanupView(SMnode *pMnode) { mDebug("mnd view cleanup"); }
 
 int32_t mndProcessCreateViewReq(SRpcMsg *pReq) {
 #ifndef TD_ENTERPRISE
   return TSDB_CODE_OPS_NOT_SUPPORT;
 #else
-  SCMCreateViewReq   createViewReq = {0};
+  SCMCreateViewReq createViewReq = {0};
   if (tDeserializeSCMCreateViewReq(pReq->pCont, pReq->contLen, &createViewReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_INVALID_MSG);
   }
 
   mInfo("start to create view:%s, sql:%s", createViewReq.fullname, createViewReq.sql);
@@ -65,17 +62,16 @@ int32_t mndProcessCreateViewReq(SRpcMsg *pReq) {
 
 int32_t mndProcessDropViewReq(SRpcMsg *pReq) {
 #ifndef TD_ENTERPRISE
-    return TSDB_CODE_OPS_NOT_SUPPORT;
+  return TSDB_CODE_OPS_NOT_SUPPORT;
 #else
-    SCMDropViewReq dropViewReq = {0};
-    if (tDeserializeSCMDropViewReq(pReq->pCont, pReq->contLen, &dropViewReq) != 0) {
-      terrno = TSDB_CODE_INVALID_MSG;
-      return -1;
-    }
-  
-    mInfo("start to drop view:%s, sql:%s", dropViewReq.name, dropViewReq.sql);
-  
-    return mndProcessDropViewReqImpl(&dropViewReq, pReq);
+  SCMDropViewReq dropViewReq = {0};
+  if (tDeserializeSCMDropViewReq(pReq->pCont, pReq->contLen, &dropViewReq) != 0) {
+    TAOS_RETURN(TSDB_CODE_INVALID_MSG);
+  }
+
+  mInfo("start to drop view:%s, sql:%s", dropViewReq.name, dropViewReq.sql);
+
+  return mndProcessDropViewReqImpl(&dropViewReq, pReq);
 #endif
 }
 
@@ -83,18 +79,16 @@ int32_t mndProcessGetViewMetaReq(SRpcMsg *pReq) {
 #ifndef TD_ENTERPRISE
   return TSDB_CODE_OPS_NOT_SUPPORT;
 #else
-  SViewMetaReq  req = {0};
+  SViewMetaReq req = {0};
 
   if (tDeserializeSViewMetaReq(pReq->pCont, pReq->contLen, &req) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_INVALID_MSG);
   }
 
   return mndProcessViewMetaReqImpl(&req, pReq);
-#endif  
+#endif
 }
 
-
 int32_t mndRetrieveView(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
 #ifndef TD_ENTERPRISE
   return 0;
@@ -107,6 +101,3 @@ void mndCancelGetNextView(SMnode *pMnode, void *pIter) {
   SSdb *pSdb = pMnode->pSdb;
   sdbCancelFetch(pSdb, pIter);
 }
-
-
-
diff --git a/source/dnode/qnode/src/qnode.c b/source/dnode/qnode/src/qnode.c
index b0fcd3400d..3a326657c9 100644
--- a/source/dnode/qnode/src/qnode.c
+++ b/source/dnode/qnode/src/qnode.c
@@ -14,6 +14,7 @@
  */
 
 #include "tqueue.h"
+
 #include "executor.h"
 #include "qndInt.h"
 #include "query.h"
@@ -23,7 +24,7 @@ int32_t qndOpen(const SQnodeOpt *pOption, SQnode **pQnode) {
   *pQnode = taosMemoryCalloc(1, sizeof(SQnode));
   if (NULL == *pQnode) {
     qError("calloc SQnode failed");
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
   (*pQnode)->qndId = QNODE_HANDLE;
 
@@ -75,9 +76,9 @@ int32_t qndPreprocessQueryMsg(SQnode *pQnode, SRpcMsg *pMsg) {
   return qWorkerPreprocessQueryMsg(pQnode->pQuery, pMsg, false);
 }
 
-int32_t qndProcessQueryMsg(SQnode *pQnode, SQueueInfo* pInfo, SRpcMsg *pMsg) {
+int32_t qndProcessQueryMsg(SQnode *pQnode, SQueueInfo *pInfo, SRpcMsg *pMsg) {
   int32_t     code = -1;
-  int64_t ts = pInfo->timestamp;
+  int64_t     ts = pInfo->timestamp;
   SReadHandle handle = {.pMsgCb = &pQnode->msgCb, .pWorkerCb = pInfo->workerCb};
   qTrace("message in qnode queue is processing");
 
@@ -113,6 +114,9 @@ int32_t qndProcessQueryMsg(SQnode *pQnode, SQueueInfo* pInfo, SRpcMsg *pMsg) {
       terrno = TSDB_CODE_APP_ERROR;
   }
 
-  if (code == 0) return TSDB_CODE_ACTION_IN_PROGRESS;
-  return code;
+  if (code == 0) {
+    return TSDB_CODE_ACTION_IN_PROGRESS;
+  } else {
+    return code;
+  }
 }
diff --git a/source/dnode/snode/src/snode.c b/source/dnode/snode/src/snode.c
index 3f2ebccdba..5e536e5fbf 100644
--- a/source/dnode/snode/src/snode.c
+++ b/source/dnode/snode/src/snode.c
@@ -64,7 +64,6 @@ SSnode *sndOpen(const char *path, const SSnodeOpt *pOption) {
   int32_t code = 0;
   SSnode *pSnode = taosMemoryCalloc(1, sizeof(SSnode));
   if (pSnode == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
   }
 
diff --git a/source/dnode/vnode/src/inc/tsdb.h b/source/dnode/vnode/src/inc/tsdb.h
index d496853cd5..978821f890 100644
--- a/source/dnode/vnode/src/inc/tsdb.h
+++ b/source/dnode/vnode/src/inc/tsdb.h
@@ -244,7 +244,6 @@ void     tsdbMemTableDestroy(SMemTable *pMemTable, bool proactive);
 STbData *tsdbGetTbDataFromMemTable(SMemTable *pMemTable, tb_uid_t suid, tb_uid_t uid);
 int32_t  tsdbRefMemTable(SMemTable *pMemTable, SQueryNode *pQNode);
 int32_t  tsdbUnrefMemTable(SMemTable *pMemTable, SQueryNode *pNode, bool proactive);
-SArray  *tsdbMemTableGetTbDataArray(SMemTable *pMemTable);
 // STbDataIter
 int32_t tsdbTbDataIterCreate(STbData *pTbData, STsdbRowKey *pFrom, int8_t backward, STbDataIter **ppIter);
 void   *tsdbTbDataIterDestroy(STbDataIter *pIter);
diff --git a/source/dnode/vnode/src/tsdb/tsdbFSet2.c b/source/dnode/vnode/src/tsdb/tsdbFSet2.c
index 2c0662b83b..305ce6b56f 100644
--- a/source/dnode/vnode/src/tsdb/tsdbFSet2.c
+++ b/source/dnode/vnode/src/tsdb/tsdbFSet2.c
@@ -18,14 +18,14 @@
 
 int32_t tsdbSttLvlInit(int32_t level, SSttLvl **lvl) {
   if (!(lvl[0] = taosMemoryMalloc(sizeof(SSttLvl)))) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
   lvl[0]->level = level;
   TARRAY2_INIT(lvl[0]->fobjArr);
   return 0;
 }
 
-static void tsdbSttLvlClearFObj(void *data) { tsdbTFileObjUnref(*(STFileObj **)data); }
+static void tsdbSttLvlClearFObj(void *data) { TAOS_UNUSED(tsdbTFileObjUnref(*(STFileObj **)data)); }
 
 int32_t tsdbSttLvlClear(SSttLvl **lvl) {
   if (lvl[0] != NULL) {
@@ -451,7 +451,9 @@ int32_t tsdbTFileSetApplyEdit(STsdb *pTsdb, const STFileSet *fset1, STFileSet *f
 
 int32_t tsdbTFileSetInit(int32_t fid, STFileSet **fset) {
   fset[0] = taosMemoryCalloc(1, sizeof(STFileSet));
-  if (fset[0] == NULL) return TSDB_CODE_OUT_OF_MEMORY;
+  if (fset[0] == NULL) {
+    return terrno;
+  }
 
   fset[0]->fid = fid;
   fset[0]->maxVerValid = VERSION_MAX;
@@ -543,7 +545,9 @@ int32_t tsdbTFileSetFilteredInitDup(STsdb *pTsdb, const STFileSet *fset1, int64_
 int32_t tsdbTFileSetRangeInitRef(STsdb *pTsdb, const STFileSet *fset1, int64_t sver, int64_t ever,
                                  STFileSetRange **fsr) {
   fsr[0] = taosMemoryCalloc(1, sizeof(*fsr[0]));
-  if (fsr[0] == NULL) return TSDB_CODE_OUT_OF_MEMORY;
+  if (fsr[0] == NULL) {
+    return terrno;
+  }
   fsr[0]->fid = fset1->fid;
   fsr[0]->sver = sver;
   fsr[0]->ever = ever;
diff --git a/source/dnode/vnode/src/tsdb/tsdbFile2.c b/source/dnode/vnode/src/tsdb/tsdbFile2.c
index a500074a65..52f1ef72ee 100644
--- a/source/dnode/vnode/src/tsdb/tsdbFile2.c
+++ b/source/dnode/vnode/src/tsdb/tsdbFile2.c
@@ -227,7 +227,7 @@ int32_t tsdbJsonToTFile(const cJSON *json, tsdb_ftype_t ftype, STFile *f) {
 int32_t tsdbTFileObjInit(STsdb *pTsdb, const STFile *f, STFileObj **fobj) {
   fobj[0] = taosMemoryMalloc(sizeof(*fobj[0]));
   if (!fobj[0]) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   taosThreadMutexInit(&fobj[0]->mutex, NULL);
diff --git a/source/dnode/vnode/src/tsdb/tsdbIter.c b/source/dnode/vnode/src/tsdb/tsdbIter.c
index 42afe1cdc0..d97a5153f3 100644
--- a/source/dnode/vnode/src/tsdb/tsdbIter.c
+++ b/source/dnode/vnode/src/tsdb/tsdbIter.c
@@ -507,7 +507,7 @@ int32_t tsdbIterOpen(const STsdbIterConfig *config, STsdbIter **iter) {
 
   iter[0] = taosMemoryCalloc(1, sizeof(*iter[0]));
   if (iter[0] == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   iter[0]->type = config->type;
@@ -677,7 +677,7 @@ int32_t tsdbIterMergerOpen(const TTsdbIterArray *iterArray, SIterMerger **merger
 
   merger[0] = taosMemoryCalloc(1, sizeof(*merger[0]));
   if (merger[0] == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   merger[0]->isTomb = isTomb;
diff --git a/source/dnode/vnode/src/tsdb/tsdbMemTable.c b/source/dnode/vnode/src/tsdb/tsdbMemTable.c
index e5bcf65bd7..3114c0fa04 100644
--- a/source/dnode/vnode/src/tsdb/tsdbMemTable.c
+++ b/source/dnode/vnode/src/tsdb/tsdbMemTable.c
@@ -54,7 +54,7 @@ int32_t tsdbMemTableCreate(STsdb *pTsdb, SMemTable **ppMemTable) {
 
   pMemTable = (SMemTable *)taosMemoryCalloc(1, sizeof(*pMemTable));
   if (pMemTable == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _err;
   }
   taosInitRWLatch(&pMemTable->latch);
@@ -71,7 +71,7 @@ int32_t tsdbMemTableCreate(STsdb *pTsdb, SMemTable **ppMemTable) {
   pMemTable->nBucket = MEM_MIN_HASH;
   pMemTable->aBucket = (STbData **)taosMemoryCalloc(pMemTable->nBucket, sizeof(STbData *));
   if (pMemTable->aBucket == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     taosMemoryFree(pMemTable);
     goto _err;
   }
@@ -174,7 +174,7 @@ int32_t tsdbDeleteTableData(STsdb *pTsdb, int64_t version, tb_uid_t suid, tb_uid
   // do delete
   SDelData *pDelData = (SDelData *)vnodeBufPoolMalloc(pPool, sizeof(*pDelData));
   if (pDelData == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _err;
   }
   pDelData->version = version;
@@ -195,7 +195,7 @@ int32_t tsdbDeleteTableData(STsdb *pTsdb, int64_t version, tb_uid_t suid, tb_uid
   pMemTable->minVer = TMIN(pMemTable->minVer, version);
   pMemTable->maxVer = TMAX(pMemTable->maxVer, version);
 
-  tsdbCacheDel(pTsdb, suid, uid, sKey, eKey);
+  TAOS_UNUSED(tsdbCacheDel(pTsdb, suid, uid, sKey, eKey));
 
   tsdbTrace("vgId:%d, delete data from table suid:%" PRId64 " uid:%" PRId64 " skey:%" PRId64 " eKey:%" PRId64
             " at version %" PRId64,
@@ -214,7 +214,7 @@ int32_t tsdbTbDataIterCreate(STbData *pTbData, STsdbRowKey *pFrom, int8_t backwa
 
   (*ppIter) = (STbDataIter *)taosMemoryCalloc(1, sizeof(STbDataIter));
   if ((*ppIter) == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _exit;
   }
 
@@ -329,7 +329,7 @@ static int32_t tsdbMemTableRehash(SMemTable *pMemTable) {
   int32_t   nBucket = pMemTable->nBucket * 2;
   STbData **aBucket = (STbData **)taosMemoryCalloc(nBucket, sizeof(STbData *));
   if (aBucket == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _exit;
   }
 
@@ -369,7 +369,7 @@ static int32_t tsdbGetOrCreateTbData(SMemTable *pMemTable, tb_uid_t suid, tb_uid
   ASSERT(pPool != NULL);
   pTbData = vnodeBufPoolMallocAligned(pPool, sizeof(*pTbData) + SL_NODE_SIZE(maxLevel) * 2);
   if (pTbData == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _exit;
   }
   pTbData->suid = suid;
@@ -520,7 +520,7 @@ static int32_t tbDataDoPut(SMemTable *pMemTable, STbData *pTbData, SMemSkipListN
     ASSERT(0);
   }
   if (pNode == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _exit;
   }
 
@@ -589,7 +589,7 @@ static int32_t tsdbInsertColDataToTable(SMemTable *pMemTable, STbData *pTbData,
   // copy and construct block data
   SBlockData *pBlockData = vnodeBufPoolMalloc(pPool, sizeof(*pBlockData));
   if (pBlockData == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _exit;
   }
 
@@ -599,7 +599,7 @@ static int32_t tsdbInsertColDataToTable(SMemTable *pMemTable, STbData *pTbData,
   pBlockData->aUid = NULL;
   pBlockData->aVersion = vnodeBufPoolMalloc(pPool, aColData[0].nData);
   if (pBlockData->aVersion == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _exit;
   }
   for (int32_t i = 0; i < pBlockData->nRow; i++) {  // todo: here can be optimized
@@ -608,7 +608,7 @@ static int32_t tsdbInsertColDataToTable(SMemTable *pMemTable, STbData *pTbData,
 
   pBlockData->aTSKEY = vnodeBufPoolMalloc(pPool, aColData[0].nData);
   if (pBlockData->aTSKEY == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _exit;
   }
   memcpy(pBlockData->aTSKEY, aColData[0].pData, aColData[0].nData);
@@ -616,7 +616,7 @@ static int32_t tsdbInsertColDataToTable(SMemTable *pMemTable, STbData *pTbData,
   pBlockData->nColData = nColData - 1;
   pBlockData->aColData = vnodeBufPoolMalloc(pPool, sizeof(SColData) * pBlockData->nColData);
   if (pBlockData->aColData == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _exit;
   }
 
@@ -661,7 +661,7 @@ static int32_t tsdbInsertColDataToTable(SMemTable *pMemTable, STbData *pTbData,
   }
 
   if (!TSDB_CACHE_NO(pMemTable->pTsdb->pVnode->config)) {
-    tsdbCacheColFormatUpdate(pMemTable->pTsdb, pTbData->suid, pTbData->uid, pBlockData);
+    TAOS_UNUSED(tsdbCacheColFormatUpdate(pMemTable->pTsdb, pTbData->suid, pTbData->uid, pBlockData));
   }
 
   // SMemTable
@@ -720,7 +720,7 @@ static int32_t tsdbInsertRowDataToTable(SMemTable *pMemTable, STbData *pTbData,
     pTbData->maxKey = key.key.ts;
   }
   if (!TSDB_CACHE_NO(pMemTable->pTsdb->pVnode->config)) {
-    tsdbCacheRowFormatUpdate(pMemTable->pTsdb, pTbData->suid, pTbData->uid, version, nRow, aRow);
+    TAOS_UNUSED(tsdbCacheRowFormatUpdate(pMemTable->pTsdb, pTbData->suid, pTbData->uid, version, nRow, aRow));
   }
 
   // SMemTable
@@ -780,22 +780,3 @@ static FORCE_INLINE int32_t tbDataPCmprFn(const void *p1, const void *p2) {
 
   return 0;
 }
-
-SArray *tsdbMemTableGetTbDataArray(SMemTable *pMemTable) {
-  SArray *aTbDataP = taosArrayInit(pMemTable->nTbData, sizeof(STbData *));
-  if (aTbDataP == NULL) goto _exit;
-
-  for (int32_t iBucket = 0; iBucket < pMemTable->nBucket; iBucket++) {
-    STbData *pTbData = pMemTable->aBucket[iBucket];
-
-    while (pTbData) {
-      taosArrayPush(aTbDataP, &pTbData);
-      pTbData = pTbData->next;
-    }
-  }
-
-  taosArraySort(aTbDataP, tbDataPCmprFn);
-
-_exit:
-  return aTbDataP;
-}
\ No newline at end of file
diff --git a/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c b/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c
index f515cd5352..56364fbc6a 100644
--- a/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c
@@ -42,7 +42,6 @@ static int32_t tsdbTFileSetRangeCmprFn(STFileSetRange* x, STFileSetRange* y) {
 STsdbFSetPartition* tsdbFSetPartitionCreate() {
   STsdbFSetPartition* pSP = taosMemoryCalloc(1, sizeof(STsdbFSetPartition));
   if (pSP == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
   }
   for (int32_t i = 0; i < TSDB_FSET_RANGE_TYP_MAX; i++) {
@@ -140,7 +139,6 @@ static int32_t tsdbTFileSetToFSetPartition(STFileSet* fset, STsdbFSetPartition**
 STsdbFSetPartList* tsdbFSetPartListCreate() {
   STsdbFSetPartList* pList = taosMemoryCalloc(1, sizeof(STsdbFSetPartList));
   if (pList == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
   }
   TARRAY2_INIT(pList);
@@ -160,7 +158,7 @@ int32_t tsdbFSetPartListToRangeDiff(STsdbFSetPartList* pList, TFileSetRangeArray
 
   TFileSetRangeArray* pDiff = taosMemoryCalloc(1, sizeof(TFileSetRangeArray));
   if (pDiff == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _err;
   }
   TARRAY2_INIT(pDiff);
@@ -169,7 +167,7 @@ int32_t tsdbFSetPartListToRangeDiff(STsdbFSetPartList* pList, TFileSetRangeArray
   TARRAY2_FOREACH(pList, part) {
     STFileSetRange* r = taosMemoryCalloc(1, sizeof(STFileSetRange));
     if (r == NULL) {
-      code = TSDB_CODE_OUT_OF_MEMORY;
+      code = terrno;
       goto _err;
     }
     int64_t maxVerValid = -1;
diff --git a/source/dnode/vnode/src/tsdb/tsdbUtil.c b/source/dnode/vnode/src/tsdb/tsdbUtil.c
index 66db7baab9..a1ca8ccda2 100644
--- a/source/dnode/vnode/src/tsdb/tsdbUtil.c
+++ b/source/dnode/vnode/src/tsdb/tsdbUtil.c
@@ -154,14 +154,16 @@ int32_t tPutMapData(uint8_t *p, SMapData *pMapData) {
 
 int32_t tGetMapData(uint8_t *p, SMapData *pMapData, int32_t *decodedSize) {
   int32_t n = 0;
+  int32_t code;
   int32_t offset;
 
   tMapDataReset(pMapData);
 
   n += tGetI32v(p + n, &pMapData->nItem);
   if (pMapData->nItem) {
-    if (tRealloc((uint8_t **)&pMapData->aOffset, sizeof(int32_t) * pMapData->nItem)) {
-      return TSDB_CODE_OUT_OF_MEMORY;
+    code = tRealloc((uint8_t **)&pMapData->aOffset, sizeof(int32_t) * pMapData->nItem);
+    if (code) {
+      return code;
     }
 
     int32_t lOffset = 0;
@@ -172,8 +174,9 @@ int32_t tGetMapData(uint8_t *p, SMapData *pMapData, int32_t *decodedSize) {
     }
 
     n += tGetI32v(p + n, &pMapData->nData);
-    if (tRealloc(&pMapData->pData, pMapData->nData)) {
-      return TSDB_CODE_OUT_OF_MEMORY;
+    code = tRealloc(&pMapData->pData, pMapData->nData);
+    if (code) {
+      return code;
     }
     memcpy(pMapData->pData, p + n, pMapData->nData);
     n += pMapData->nData;
@@ -753,7 +756,7 @@ int32_t tsdbRowMergerAdd(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema)
 
     *pColVal = COL_VAL_VALUE(pTColumn->colId, ((SValue){.type = pTColumn->type, .val = key.ts}));
     if (taosArrayPush(pMerger->pArray, pColVal) == NULL) {
-      code = TSDB_CODE_OUT_OF_MEMORY;
+      code = terrno;
       return code;
     }
 
@@ -766,7 +769,7 @@ int32_t tsdbRowMergerAdd(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema)
         continue;
       } else if (pTSchema->columns[jCol].colId > pTColumn->colId) {
         if (taosArrayPush(pMerger->pArray, &COL_VAL_NONE(pTColumn->colId, pTColumn->type)) == NULL) {
-          return TSDB_CODE_OUT_OF_MEMORY;
+          return terrno;
         }
         continue;
       }
@@ -778,7 +781,7 @@ int32_t tsdbRowMergerAdd(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema)
         pColVal->value.pData = NULL;
         code = tRealloc(&pColVal->value.pData, pColVal->value.nData);
         if (code) {
-          return TSDB_CODE_OUT_OF_MEMORY;
+          return code;
         }
 
         if (pColVal->value.nData) {
@@ -787,14 +790,14 @@ int32_t tsdbRowMergerAdd(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema)
       }
 
       if (taosArrayPush(pMerger->pArray, pColVal) == NULL) {
-        return TSDB_CODE_OUT_OF_MEMORY;
+        return terrno;
       }
     }
 
     for (; iCol < pMerger->pTSchema->numOfCols; ++iCol) {
       pTColumn = &pMerger->pTSchema->columns[iCol];
       if (taosArrayPush(pMerger->pArray, &COL_VAL_NONE(pTColumn->colId, pTColumn->type)) == NULL) {
-        return TSDB_CODE_OUT_OF_MEMORY;
+        return terrno;
       }
     }
 
@@ -866,7 +869,7 @@ int32_t tsdbRowMergerInit(SRowMerger *pMerger, STSchema *pSchema) {
   pMerger->pTSchema = pSchema;
   pMerger->pArray = taosArrayInit(pSchema->numOfCols, sizeof(SColVal));
   if (pMerger->pArray == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   } else {
     return TSDB_CODE_SUCCESS;
   }
@@ -1036,11 +1039,11 @@ int32_t tsdbBuildDeleteSkylineImpl(SArray *aSkyline, int32_t sidx, int32_t eidx,
     TSDBKEY *pItem1 = taosArrayGet(aSkyline, sidx * 2);
     TSDBKEY *pItem2 = taosArrayGet(aSkyline, sidx * 2 + 1);
     if (taosArrayPush(pSkyline, &pItem1) == NULL) {
-      return TSDB_CODE_OUT_OF_MEMORY;
+      return terrno;
     }
 
     if (taosArrayPush(pSkyline, &pItem2) == NULL) {
-      return TSDB_CODE_OUT_OF_MEMORY;
+      return terrno;
     }
   } else {
     SArray *pSkyline1 = NULL;
@@ -1048,10 +1051,13 @@ int32_t tsdbBuildDeleteSkylineImpl(SArray *aSkyline, int32_t sidx, int32_t eidx,
     midx = (sidx + eidx) / 2;
 
     pSkyline1 = taosArrayInit((midx - sidx + 1) * 2, POINTER_BYTES);
+    if (pSkyline1 == NULL) {
+      return terrno;
+    }
     pSkyline2 = taosArrayInit((eidx - midx) * 2, POINTER_BYTES);
-    if (pSkyline1 == NULL || pSkyline1 == NULL) {
-      code = TSDB_CODE_OUT_OF_MEMORY;
-      goto _clear;
+    if (pSkyline2 == NULL) {
+      taosArrayDestroy(pSkyline1);
+      return terrno;
     }
 
     code = tsdbBuildDeleteSkylineImpl(aSkyline, sidx, midx, pSkyline1);
@@ -1076,25 +1082,25 @@ int32_t tsdbBuildDeleteSkyline(SArray *aDelData, int32_t sidx, int32_t eidx, SAr
   int32_t   dataNum = eidx - sidx + 1;
   SArray   *aTmpSkyline = taosArrayInit(dataNum * 2, sizeof(TSDBKEY));
   if (aTmpSkyline == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   SArray *pSkyline = taosArrayInit(dataNum * 2, POINTER_BYTES);
   if (pSkyline == NULL) {
     taosArrayDestroy(aTmpSkyline);
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   taosArrayClear(aSkyline);
   for (int32_t i = sidx; i <= eidx; ++i) {
     pDelData = (SDelData *)taosArrayGet(aDelData, i);
     if (taosArrayPush(aTmpSkyline, &(TSDBKEY){.ts = pDelData->sKey, .version = pDelData->version}) == NULL) {
-      code = TSDB_CODE_OUT_OF_MEMORY;
+      code = terrno;
       goto _clear;
     }
 
     if (taosArrayPush(aTmpSkyline, &(TSDBKEY){.ts = pDelData->eKey, .version = 0}) == NULL) {
-      code = TSDB_CODE_OUT_OF_MEMORY;
+      code = terrno;
       goto _clear;
     }
   }
@@ -1106,7 +1112,7 @@ int32_t tsdbBuildDeleteSkyline(SArray *aDelData, int32_t sidx, int32_t eidx, SAr
   for (int32_t i = 0; i < skylineNum; ++i) {
     TSDBKEY *p = taosArrayGetP(pSkyline, i);
     if (taosArrayPush(aSkyline, p) == NULL) {
-      code = TSDB_CODE_OUT_OF_MEMORY;
+      code = terrno;
       goto _clear;
     }
   }
@@ -1196,7 +1202,7 @@ static int32_t tBlockDataAdjustColData(SBlockData *pBlockData, int32_t nColData)
   } else if (pBlockData->nColData < nColData) {
     SColData *aColData = taosMemoryRealloc(pBlockData->aColData, sizeof(SBlockData) * nColData);
     if (aColData == NULL) {
-      code = TSDB_CODE_OUT_OF_MEMORY;
+      code = terrno;
       goto _exit;
     }
 
@@ -1284,7 +1290,7 @@ int32_t tBlockDataAddColData(SBlockData *pBlockData, int16_t cid, int8_t type, i
 
   SColData *newColData = taosMemoryRealloc(pBlockData->aColData, sizeof(SColData) * (pBlockData->nColData + 1));
   if (newColData == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
 
   pBlockData->aColData = newColData;
@@ -1452,6 +1458,7 @@ int32_t tBlockDataCompress(SBlockData *bData, void *pCompr, SBuffer *buffers, SB
 
   SColCompressInfo *pInfo = pCompr;
   code = tsdbGetColCmprAlgFromSet(pInfo->pColCmpr, 1, &pInfo->defaultCmprAlg);
+  TAOS_UNUSED(code);
 
   SDiskDataHdr hdr = {
       .delimiter = TSDB_FILE_DLMT,
diff --git a/source/dnode/vnode/src/vnd/vnodeBufPool.c b/source/dnode/vnode/src/vnd/vnodeBufPool.c
index ad183839d7..f3c2693b75 100644
--- a/source/dnode/vnode/src/vnd/vnodeBufPool.c
+++ b/source/dnode/vnode/src/vnd/vnodeBufPool.c
@@ -140,8 +140,9 @@ void *vnodeBufPoolMallocAligned(SVBufPool *pPool, int size) {
     // allocate a new node
     pNode = taosMemoryMalloc(sizeof(*pNode) + size);
     if (pNode == NULL) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      if (pPool->lock) taosThreadSpinUnlock(pPool->lock);
+      if (pPool->lock) {
+        taosThreadSpinUnlock(pPool->lock);
+      }
       return NULL;
     }
 
@@ -173,7 +174,6 @@ void *vnodeBufPoolMalloc(SVBufPool *pPool, int size) {
     // allocate a new node
     pNode = taosMemoryMalloc(sizeof(*pNode) + size);
     if (pNode == NULL) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
       if (pPool->lock) taosThreadSpinUnlock(pPool->lock);
       return NULL;
     }
diff --git a/source/libs/geometry/src/geomFunc.c b/source/libs/geometry/src/geomFunc.c
index 601588571e..194590c06c 100644
--- a/source/libs/geometry/src/geomFunc.c
+++ b/source/libs/geometry/src/geomFunc.c
@@ -21,8 +21,8 @@
 #include "sclInt.h"
 #include "sclvector.h"
 
-typedef int32_t (*_geomDoRelationFunc_t)(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1, const GEOSGeometry *geom2,
-                                         bool swapped, char *res);
+typedef int32_t (*_geomDoRelationFunc_t)(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1,
+                                         const GEOSGeometry *geom2, bool swapped, char *res);
 
 typedef int32_t (*_geomInitCtxFunc_t)();
 typedef int32_t (*_geomExecuteOneParamFunc_t)(SColumnInfoData *pInputData, int32_t i, SColumnInfoData *pOutputData);
@@ -35,7 +35,7 @@ int32_t doMakePointFunc(double x, double y, unsigned char **output) {
   int32_t code = TSDB_CODE_FAILED;
 
   unsigned char *outputGeom = NULL;
-  size_t size = 0;
+  size_t         size = 0;
   code = doMakePoint(x, y, &outputGeom, &size);
   if (code != TSDB_CODE_SUCCESS) {
     goto _exit;
@@ -47,7 +47,7 @@ int32_t doMakePointFunc(double x, double y, unsigned char **output) {
     goto _exit;
   }
 
-  memcpy(varDataVal(*output), outputGeom, size);
+  (void)memcpy(varDataVal(*output), outputGeom, size);
   varDataSetLen(*output, size);
   code = TSDB_CODE_SUCCESS;
 
@@ -62,14 +62,14 @@ _exit:
 int32_t doGeomFromTextFunc(const char *input, unsigned char **output) {
   int32_t code = TSDB_CODE_FAILED;
 
-  if ((varDataLen(input)) == 0) { //empty value
+  if ((varDataLen(input)) == 0) {  // empty value
     *output = NULL;
     return TSDB_CODE_SUCCESS;
   }
 
-  char *inputGeom = NULL;
+  char          *inputGeom = NULL;
   unsigned char *outputGeom = NULL;
-  size_t size = 0;
+  size_t         size = 0;
 
   // make a zero ending string
   inputGeom = taosMemoryCalloc(1, varDataLen(input) + 1);
@@ -77,12 +77,9 @@ int32_t doGeomFromTextFunc(const char *input, unsigned char **output) {
     code = TSDB_CODE_OUT_OF_MEMORY;
     goto _exit;
   }
-  memcpy(inputGeom, varDataVal(input), varDataLen(input));
+  (void)memcpy(inputGeom, varDataVal(input), varDataLen(input));
 
-  code = doGeomFromText(inputGeom, &outputGeom, &size);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _exit;
-  }
+  TAOS_CHECK_GOTO(doGeomFromText(inputGeom, &outputGeom, &size), NULL, _exit);
 
   *output = taosMemoryCalloc(1, size + VARSTR_HEADER_SIZE);
   if (*output == NULL) {
@@ -90,7 +87,7 @@ int32_t doGeomFromTextFunc(const char *input, unsigned char **output) {
     goto _exit;
   }
 
-  memcpy(varDataVal(*output), outputGeom, size);
+  (void)memcpy(varDataVal(*output), outputGeom, size);
   varDataSetLen(*output, size);
   code = TSDB_CODE_SUCCESS;
 
@@ -106,16 +103,13 @@ _exit:
 int32_t doAsTextFunc(unsigned char *input, char **output) {
   int32_t code = TSDB_CODE_FAILED;
 
-  if ((varDataLen(input)) == 0) { //empty value
+  if ((varDataLen(input)) == 0) {  // empty value
     *output = NULL;
     return TSDB_CODE_SUCCESS;
   }
 
   char *outputWKT = NULL;
-  code = doAsText(varDataVal(input), varDataLen(input), &outputWKT);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _exit;
-  }
+  TAOS_CHECK_GOTO(doAsText(varDataVal(input), varDataLen(input), &outputWKT), NULL, _exit);
 
   size_t size = strlen(outputWKT);
   *output = taosMemoryCalloc(1, size + VARSTR_HEADER_SIZE);
@@ -124,7 +118,7 @@ int32_t doAsTextFunc(unsigned char *input, char **output) {
     goto _exit;
   }
 
-  memcpy(varDataVal(*output), outputWKT, size);
+  (void)memcpy(varDataVal(*output), outputWKT, size);
   varDataSetLen(*output, size);
   code = TSDB_CODE_SUCCESS;
 
@@ -139,28 +133,17 @@ int32_t executeMakePointFunc(SColumnInfoData *pInputData[], int32_t iLeft, int32
   int32_t code = TSDB_CODE_FAILED;
 
   _getDoubleValue_fn_t getDoubleValueFn[2];
-  getDoubleValueFn[0]= getVectorDoubleValueFn(pInputData[0]->info.type);
-  getDoubleValueFn[1]= getVectorDoubleValueFn(pInputData[1]->info.type);
+  getDoubleValueFn[0] = getVectorDoubleValueFn(pInputData[0]->info.type);
+  getDoubleValueFn[1] = getVectorDoubleValueFn(pInputData[1]->info.type);
 
   unsigned char *output = NULL;
-  double leftRes = 0;
-  double rightRes = 0;
-  code = getDoubleValueFn[0](pInputData[0]->pData, iLeft, &leftRes);
-  if (TSDB_CODE_SUCCESS != code) {
-    goto _exit;
-  }
-  code = getDoubleValueFn[1](pInputData[1]->pData, iRight, &rightRes);
-  if (TSDB_CODE_SUCCESS != code) {
-    goto _exit;
-  }
-  code = doMakePointFunc(leftRes, rightRes, &output);
-  if (TSDB_CODE_SUCCESS != code) {
-    goto _exit;
-  }
-  code = colDataSetVal(pOutputData, TMAX(iLeft, iRight), output, (output == NULL));
-  if (TSDB_CODE_SUCCESS != code) {
-    goto _exit;
-  }
+  double         leftRes = 0;
+  double         rightRes = 0;
+
+  TAOS_CHECK_GOTO(getDoubleValueFn[0](pInputData[0]->pData, iLeft, &leftRes), NULL, _exit);
+  TAOS_CHECK_GOTO(getDoubleValueFn[1](pInputData[1]->pData, iRight, &rightRes), NULL, _exit);
+  TAOS_CHECK_GOTO(doMakePointFunc(leftRes, rightRes, &output), NULL, _exit);
+  TAOS_CHECK_GOTO(colDataSetVal(pOutputData, TMAX(iLeft, iRight), output, (output == NULL)), NULL, _exit);
 
 _exit:
   if (output) {
@@ -173,14 +156,11 @@ _exit:
 int32_t executeGeomFromTextFunc(SColumnInfoData *pInputData, int32_t i, SColumnInfoData *pOutputData) {
   int32_t code = TSDB_CODE_FAILED;
 
-  char *input = colDataGetData(pInputData, i);
+  char          *input = colDataGetData(pInputData, i);
   unsigned char *output = NULL;
-  code = doGeomFromTextFunc(input, &output);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _exit;
-  }
 
-  code = colDataSetVal(pOutputData, i, output, (output == NULL));
+  TAOS_CHECK_GOTO(doGeomFromTextFunc(input, &output), NULL, _exit);
+  TAOS_CHECK_GOTO(colDataSetVal(pOutputData, i, output, (output == NULL)), NULL, _exit);
 
 _exit:
   if (output) {
@@ -194,13 +174,10 @@ int32_t executeAsTextFunc(SColumnInfoData *pInputData, int32_t i, SColumnInfoDat
   int32_t code = TSDB_CODE_FAILED;
 
   unsigned char *input = colDataGetData(pInputData, i);
-  char *output = NULL;
-  code = doAsTextFunc(input, &output);
-  if (code != TSDB_CODE_SUCCESS) {
-    goto _exit;
-  }
+  char          *output = NULL;
 
-  code = colDataSetVal(pOutputData, i, output, (output == NULL));
+  TAOS_CHECK_GOTO(doAsTextFunc(input, &output), NULL, _exit);
+  TAOS_CHECK_GOTO(colDataSetVal(pOutputData, i, output, (output == NULL)), NULL, _exit);
 
 _exit:
   if (output) {
@@ -211,36 +188,22 @@ _exit:
 }
 
 int32_t executeRelationFunc(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1,
-                            const GEOSGeometry *geom2, int32_t i,
-                            bool swapped, SColumnInfoData *pOutputData,
+                            const GEOSGeometry *geom2, int32_t i, bool swapped, SColumnInfoData *pOutputData,
                             _geomDoRelationFunc_t doRelationFn) {
-  int32_t code = TSDB_CODE_FAILED;
   char res = 0;
 
-  if (!geom1 || !geom2) { //if empty input value
+  if (!geom1 || !geom2) {  // if empty input value
     res = -1;
-    code = TSDB_CODE_SUCCESS;
-  }
-  else {
-    code = doRelationFn(geom1, preparedGeom1, geom2, swapped, &res);
-    if (code != TSDB_CODE_SUCCESS) {
-      return code;
-    }
+  } else {
+    TAOS_CHECK_RETURN(doRelationFn(geom1, preparedGeom1, geom2, swapped, &res));
   }
 
-  code = colDataSetVal(pOutputData, i, &res, (res==-1));
-
-  return code;
+  return colDataSetVal(pOutputData, i, &res, (res == -1));
 }
 
-int32_t geomOneParamFunction(SScalarParam *pInput, SScalarParam *pOutput,
-                             _geomInitCtxFunc_t initCtxFn, _geomExecuteOneParamFunc_t executeOneParamFn) {
-  int32_t code = TSDB_CODE_FAILED;
-
-  code = initCtxFn();
-  if (code != TSDB_CODE_SUCCESS) {
-    return code;
-  }
+int32_t geomOneParamFunction(SScalarParam *pInput, SScalarParam *pOutput, _geomInitCtxFunc_t initCtxFn,
+                             _geomExecuteOneParamFunc_t executeOneParamFn) {
+  TAOS_CHECK_RETURN(initCtxFn());
 
   SColumnInfoData *pInputData = pInput->columnData;
   SColumnInfoData *pOutputData = pOutput->columnData;
@@ -248,54 +211,40 @@ int32_t geomOneParamFunction(SScalarParam *pInput, SScalarParam *pOutput,
 
   if (IS_NULL_TYPE(GET_PARAM_TYPE(pInput))) {
     colDataSetNNULL(pOutputData, 0, pInput->numOfRows);
-    code = TSDB_CODE_SUCCESS;
-  }
-  else {
+  } else {
     for (int32_t i = 0; i < pInput->numOfRows; ++i) {
       if (colDataIsNull_s(pInputData, i)) {
         colDataSetNULL(pOutputData, i);
-        code = TSDB_CODE_SUCCESS;
         continue;
       }
 
-      code = executeOneParamFn(pInputData, i, pOutputData);
-      if (code != TSDB_CODE_SUCCESS) {
-        return code;
-      }
+      TAOS_CHECK_RETURN(executeOneParamFn(pInputData, i, pOutputData));
     }
   }
 
-  return code;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
-int32_t geomTwoParamsFunction(SScalarParam *pInput, SScalarParam *pOutput,
-                              _geomInitCtxFunc_t initCtxFn, _geomExecuteTwoParamsFunc_t executeTwoParamsFn) {
-  int32_t code = TSDB_CODE_FAILED;
-
-  code = initCtxFn();
-  if (code != TSDB_CODE_SUCCESS) {
-    return code;
-  }
+int32_t geomTwoParamsFunction(SScalarParam *pInput, SScalarParam *pOutput, _geomInitCtxFunc_t initCtxFn,
+                              _geomExecuteTwoParamsFunc_t executeTwoParamsFn) {
+  TAOS_CHECK_RETURN(initCtxFn());
 
   SColumnInfoData *pInputData[2];
   SColumnInfoData *pOutputData = pOutput->columnData;
   pInputData[0] = pInput[0].columnData;
   pInputData[1] = pInput[1].columnData;
 
-  bool hasNullType = (IS_NULL_TYPE(GET_PARAM_TYPE(&pInput[0])) ||
-                      IS_NULL_TYPE(GET_PARAM_TYPE(&pInput[1])));
-  bool isConstantLeft = (pInput[0].numOfRows == 1);
-  bool isConstantRight = (pInput[1].numOfRows == 1);
+  bool    hasNullType = (IS_NULL_TYPE(GET_PARAM_TYPE(&pInput[0])) || IS_NULL_TYPE(GET_PARAM_TYPE(&pInput[1])));
+  bool    isConstantLeft = (pInput[0].numOfRows == 1);
+  bool    isConstantRight = (pInput[1].numOfRows == 1);
   int32_t numOfRows = TMAX(pInput[0].numOfRows, pInput[1].numOfRows);
   pOutput->numOfRows = numOfRows;
 
-  if (hasNullType ||                                           // one of operant is NULL type
-     (isConstantLeft && colDataIsNull_s(pInputData[0], 0)) ||  // left operand is constant NULL
-     (isConstantRight && colDataIsNull_s(pInputData[1], 0))) { // right operand is constant NULL
+  if (hasNullType ||                                             // one of operant is NULL type
+      (isConstantLeft && colDataIsNull_s(pInputData[0], 0)) ||   // left operand is constant NULL
+      (isConstantRight && colDataIsNull_s(pInputData[1], 0))) {  // right operand is constant NULL
     colDataSetNNULL(pOutputData, 0, numOfRows);
-    code = TSDB_CODE_SUCCESS;
-  }
-  else {
+  } else {
     int32_t iLeft = 0;
     int32_t iRight = 0;
     for (int32_t i = 0; i < numOfRows; ++i) {
@@ -305,107 +254,80 @@ int32_t geomTwoParamsFunction(SScalarParam *pInput, SScalarParam *pOutput,
       if ((!isConstantLeft && colDataIsNull_s(pInputData[0], iLeft)) ||
           (!isConstantRight && colDataIsNull_s(pInputData[1], iRight))) {
         colDataSetNULL(pOutputData, i);
-        code = TSDB_CODE_SUCCESS;
         continue;
       }
 
-      code = executeTwoParamsFn(pInputData, iLeft, iRight, pOutputData);
-      if (code != TSDB_CODE_SUCCESS) {
-        return code;
-      }
+      TAOS_CHECK_RETURN(executeTwoParamsFn(pInputData, iLeft, iRight, pOutputData));
     }
   }
 
-  return code;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
-int32_t geomRelationFunction(SScalarParam *pInput, SScalarParam *pOutput,
-                             bool swapAllowed, _geomDoRelationFunc_t doRelationFn) {
+int32_t geomRelationFunction(SScalarParam *pInput, SScalarParam *pOutput, bool swapAllowed,
+                             _geomDoRelationFunc_t doRelationFn) {
   int32_t code = TSDB_CODE_FAILED;
 
-  code = initCtxRelationFunc();
-  if (code != TSDB_CODE_SUCCESS) {
-    return code;
-  }
+  TAOS_CHECK_RETURN(initCtxRelationFunc());
 
   // handle with all NULL output
-  bool hasNullType = (IS_NULL_TYPE(GET_PARAM_TYPE(&pInput[0])) ||
-                      IS_NULL_TYPE(GET_PARAM_TYPE(&pInput[1])));
-  bool isConstant1 = (pInput[0].numOfRows == 1);
-  bool isConstant2 = (pInput[1].numOfRows == 1);
+  bool    hasNullType = (IS_NULL_TYPE(GET_PARAM_TYPE(&pInput[0])) || IS_NULL_TYPE(GET_PARAM_TYPE(&pInput[1])));
+  bool    isConstant1 = (pInput[0].numOfRows == 1);
+  bool    isConstant2 = (pInput[1].numOfRows == 1);
   int32_t numOfRows = TMAX(pInput[0].numOfRows, pInput[1].numOfRows);
   pOutput->numOfRows = numOfRows;
   SColumnInfoData *pOutputData = pOutput->columnData;
 
-  if (hasNullType || // at least one of operant is NULL type
-     (isConstant1 && colDataIsNull_s(pInput[0].columnData, 0)) || // left operand is constant NULL
-     (isConstant2 && colDataIsNull_s(pInput[1].columnData, 0))) { // right operand is constant NULL
+  if (hasNullType ||                                                // at least one of operant is NULL type
+      (isConstant1 && colDataIsNull_s(pInput[0].columnData, 0)) ||  // left operand is constant NULL
+      (isConstant2 && colDataIsNull_s(pInput[1].columnData, 0))) {  // right operand is constant NULL
     colDataSetNNULL(pOutputData, 0, numOfRows);
-    code = TSDB_CODE_SUCCESS;
-    return code;
+    TAOS_RETURN(TSDB_CODE_SUCCESS);
   }
 
-  bool swapped = false;
+  bool             swapped = false;
   SColumnInfoData *pInputData[2];
 
   // swap two input data to make sure input data 0 is constant if swapAllowed and only isConstant2 is true
-  if (swapAllowed &&
-     !isConstant1 && isConstant2) {
+  if (swapAllowed && !isConstant1 && isConstant2) {
     pInputData[0] = pInput[1].columnData;
     pInputData[1] = pInput[0].columnData;
 
     isConstant1 = true;
     isConstant2 = false;
     swapped = true;
-  }
-  else {
+  } else {
     pInputData[0] = pInput[0].columnData;
     pInputData[1] = pInput[1].columnData;
   }
 
-  GEOSGeometry *geom1 = NULL;
-  GEOSGeometry *geom2 = NULL;
+  GEOSGeometry               *geom1 = NULL;
+  GEOSGeometry               *geom2 = NULL;
   const GEOSPreparedGeometry *preparedGeom1 = NULL;
 
   // if there is constant, make PreparedGeometry from pInputData 0
   if (isConstant1) {
-    code = readGeometry(colDataGetData(pInputData[0], 0), &geom1, &preparedGeom1);
-    if (code != TSDB_CODE_SUCCESS) {
-      goto _exit;
-    }
+    TAOS_CHECK_GOTO(readGeometry(colDataGetData(pInputData[0], 0), &geom1, &preparedGeom1), NULL, _exit);
   }
   if (isConstant2) {
-    code = readGeometry(colDataGetData(pInputData[1], 0), &geom2, NULL);
-    if (code != TSDB_CODE_SUCCESS) {
-      goto _exit;
-    }
+    TAOS_CHECK_GOTO(readGeometry(colDataGetData(pInputData[1], 0), &geom2, NULL), NULL, _exit);
   }
 
   for (int32_t i = 0; i < numOfRows; ++i) {
-    if ((!isConstant1 && colDataIsNull_s(pInputData[0], i)) ||
-        (!isConstant2 && colDataIsNull_s(pInputData[1], i))) {
+    if ((!isConstant1 && colDataIsNull_s(pInputData[0], i)) || (!isConstant2 && colDataIsNull_s(pInputData[1], i))) {
       colDataSetNULL(pOutputData, i);
-      code = TSDB_CODE_SUCCESS;
       continue;
     }
 
     if (!isConstant1) {
-      code = readGeometry(colDataGetData(pInputData[0], i), &geom1, &preparedGeom1);
-      if (code != TSDB_CODE_SUCCESS) {
-        goto _exit;
-      }
+      TAOS_CHECK_GOTO(readGeometry(colDataGetData(pInputData[0], i), &geom1, &preparedGeom1), NULL, _exit);
     }
     if (!isConstant2) {
-      code = readGeometry(colDataGetData(pInputData[1], i), &geom2, NULL);
-      if (code != TSDB_CODE_SUCCESS) {
-        goto _exit;
-      }
+      TAOS_CHECK_GOTO(readGeometry(colDataGetData(pInputData[1], i), &geom2, NULL), NULL, _exit);
     }
 
-    code = executeRelationFunc(geom1, preparedGeom1, geom2, i, swapped, pOutputData, doRelationFn);
-    if (code != TSDB_CODE_SUCCESS) {
-      goto _exit;
-    }
+    TAOS_CHECK_GOTO(executeRelationFunc(geom1, preparedGeom1, geom2, i, swapped, pOutputData, doRelationFn), NULL,
+                    _exit);
 
     if (!isConstant1) {
       destroyGeometry(&geom1, &preparedGeom1);
@@ -415,11 +337,13 @@ int32_t geomRelationFunction(SScalarParam *pInput, SScalarParam *pOutput,
     }
   }
 
+  code = TSDB_CODE_SUCCESS;
+
 _exit:
   destroyGeometry(&geom1, &preparedGeom1);
   destroyGeometry(&geom2, NULL);
 
-  return code;
+  TAOS_RETURN(code);
 }
 
 int32_t makePointFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) {
diff --git a/source/libs/geometry/src/geosWrapper.c b/source/libs/geometry/src/geosWrapper.c
index c5250c8481..2142b3d62d 100644
--- a/source/libs/geometry/src/geosWrapper.c
+++ b/source/libs/geometry/src/geosWrapper.c
@@ -18,7 +18,8 @@
 #include "types.h"
 
 typedef char (*_geosRelationFunc_t)(GEOSContextHandle_t handle, const GEOSGeometry *g1, const GEOSGeometry *g2);
-typedef char (*_geosPreparedRelationFunc_t)(GEOSContextHandle_t handle, const GEOSPreparedGeometry *pg1, const GEOSGeometry *g2);
+typedef char (*_geosPreparedRelationFunc_t)(GEOSContextHandle_t handle, const GEOSPreparedGeometry *pg1,
+                                            const GEOSGeometry *g2);
 
 void geosFreeBuffer(void *buffer) {
   if (buffer) {
@@ -27,13 +28,13 @@ void geosFreeBuffer(void *buffer) {
 }
 
 void geosErrMsgeHandler(const char *errMsg, void *userData) {
-  char* targetErrMsg = userData;
+  char *targetErrMsg = userData;
   snprintf(targetErrMsg, 512, "%s", errMsg);
 }
 
 int32_t initCtxMakePoint() {
-  int32_t code = TSDB_CODE_FAILED;
-  SGeosContext* geosCtx = getThreadLocalGeosCtx();
+  int32_t       code = TSDB_CODE_FAILED;
+  SGeosContext *geosCtx = getThreadLocalGeosCtx();
 
   if (geosCtx->handle == NULL) {
     geosCtx->handle = GEOS_init_r();
@@ -41,7 +42,7 @@ int32_t initCtxMakePoint() {
       return code;
     }
 
-    GEOSContext_setErrorMessageHandler_r(geosCtx->handle, geosErrMsgeHandler, geosCtx->errMsg);
+    (void)GEOSContext_setErrorMessageHandler_r(geosCtx->handle, geosErrMsgeHandler, geosCtx->errMsg);
   }
 
   if (geosCtx->WKBWriter == NULL) {
@@ -57,10 +58,10 @@ int32_t initCtxMakePoint() {
 // outputWKT is a zero ending string
 // need to call geosFreeBuffer(*outputGeom) later
 int32_t doMakePoint(double x, double y, unsigned char **outputGeom, size_t *size) {
-  int32_t code = TSDB_CODE_FAILED;
-  SGeosContext* geosCtx = getThreadLocalGeosCtx();
+  int32_t       code = TSDB_CODE_FAILED;
+  SGeosContext *geosCtx = getThreadLocalGeosCtx();
 
-  GEOSGeometry *geom = NULL;
+  GEOSGeometry  *geom = NULL;
   unsigned char *wkb = NULL;
 
   geom = GEOSGeom_createPointFromXY_r(geosCtx->handle, x, y);
@@ -89,6 +90,10 @@ _exit:
 static int32_t initWktRegex(pcre2_code **ppRegex, pcre2_match_data **ppMatchData) {
   int32_t code = 0;
   char   *wktPatternWithSpace = taosMemoryCalloc(4, 1024);
+  if (NULL == wktPatternWithSpace) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
   sprintf(
       wktPatternWithSpace,
       "^( *)point( *)z?m?( *)((empty)|(\\(( *)(([-+]?[0-9]+\\.?[0-9]*)|([-+]?[0-9]*\\.?[0-9]+))(e[-+]?[0-9]+)?(( "
@@ -148,8 +153,8 @@ static int32_t initWktRegex(pcre2_code **ppRegex, pcre2_match_data **ppMatchData
 }
 
 int32_t initCtxGeomFromText() {
-  int32_t code = TSDB_CODE_FAILED;
-  SGeosContext* geosCtx = getThreadLocalGeosCtx();
+  int32_t       code = TSDB_CODE_FAILED;
+  SGeosContext *geosCtx = getThreadLocalGeosCtx();
 
   if (geosCtx->handle == NULL) {
     geosCtx->handle = GEOS_init_r();
@@ -157,7 +162,7 @@ int32_t initCtxGeomFromText() {
       return code;
     }
 
-    GEOSContext_setErrorMessageHandler_r(geosCtx->handle, geosErrMsgeHandler, geosCtx->errMsg);
+    (void)GEOSContext_setErrorMessageHandler_r(geosCtx->handle, geosErrMsgeHandler, geosCtx->errMsg);
   }
 
   if (geosCtx->WKTReader == NULL) {
@@ -184,15 +189,15 @@ int32_t initCtxGeomFromText() {
 // inputWKT is a zero ending string
 // need to call geosFreeBuffer(*outputGeom) later
 int32_t doGeomFromText(const char *inputWKT, unsigned char **outputGeom, size_t *size) {
-  int32_t code = TSDB_CODE_FAILED;
-  SGeosContext* geosCtx = getThreadLocalGeosCtx();
+  int32_t       code = TSDB_CODE_FAILED;
+  SGeosContext *geosCtx = getThreadLocalGeosCtx();
 
-  GEOSGeometry *geom = NULL;
+  GEOSGeometry  *geom = NULL;
   unsigned char *wkb = NULL;
 
   if (doRegExec(inputWKT, geosCtx->WKTRegex, geosCtx->WKTMatchData) != 0) {
-     code = TSDB_CODE_FUNC_FUNTION_PARA_VALUE;
-     goto _exit;
+    code = TSDB_CODE_FUNC_FUNTION_PARA_VALUE;
+    goto _exit;
   }
 
   geom = GEOSWKTReader_read_r(geosCtx->handle, geosCtx->WKTReader, inputWKT);
@@ -219,8 +224,8 @@ _exit:
 }
 
 int32_t initCtxAsText() {
-  int32_t code = TSDB_CODE_FAILED;
-  SGeosContext* geosCtx = getThreadLocalGeosCtx();
+  int32_t       code = TSDB_CODE_FAILED;
+  SGeosContext *geosCtx = getThreadLocalGeosCtx();
 
   if (geosCtx->handle == NULL) {
     geosCtx->handle = GEOS_init_r();
@@ -228,7 +233,7 @@ int32_t initCtxAsText() {
       return code;
     }
 
-    GEOSContext_setErrorMessageHandler_r(geosCtx->handle, geosErrMsgeHandler, geosCtx->errMsg);
+    (void)GEOSContext_setErrorMessageHandler_r(geosCtx->handle, geosErrMsgeHandler, geosCtx->errMsg);
   }
 
   if (geosCtx->WKBReader == NULL) {
@@ -255,10 +260,10 @@ int32_t initCtxAsText() {
 // outputWKT is a zero ending string
 // need to call geosFreeBuffer(*outputWKT) later
 int32_t doAsText(const unsigned char *inputGeom, size_t size, char **outputWKT) {
-  int32_t code = TSDB_CODE_FAILED;
-  SGeosContext* geosCtx = getThreadLocalGeosCtx();
+  int32_t       code = TSDB_CODE_FAILED;
+  SGeosContext *geosCtx = getThreadLocalGeosCtx();
 
-  GEOSGeometry *geom = NULL;
+  GEOSGeometry  *geom = NULL;
   unsigned char *wkt = NULL;
 
   geom = GEOSWKBReader_read_r(geosCtx->handle, geosCtx->WKBReader, inputGeom, size);
@@ -286,8 +291,8 @@ _exit:
 }
 
 int32_t initCtxRelationFunc() {
-  int32_t code = TSDB_CODE_FAILED;
-  SGeosContext* geosCtx = getThreadLocalGeosCtx();
+  int32_t       code = TSDB_CODE_FAILED;
+  SGeosContext *geosCtx = getThreadLocalGeosCtx();
 
   if (geosCtx->handle == NULL) {
     geosCtx->handle = GEOS_init_r();
@@ -295,7 +300,7 @@ int32_t initCtxRelationFunc() {
       return code;
     }
 
-    GEOSContext_setErrorMessageHandler_r(geosCtx->handle, geosErrMsgeHandler, geosCtx->errMsg);
+    (void)GEOSContext_setErrorMessageHandler_r(geosCtx->handle, geosErrMsgeHandler, geosCtx->errMsg);
   }
 
   if (geosCtx->WKBReader == NULL) {
@@ -309,88 +314,81 @@ int32_t initCtxRelationFunc() {
 }
 
 int32_t doGeosRelation(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1, const GEOSGeometry *geom2,
-                       bool swapped, char *res,
-                       _geosRelationFunc_t relationFn,
-                       _geosRelationFunc_t swappedRelationFn,
+                       bool swapped, char *res, _geosRelationFunc_t relationFn, _geosRelationFunc_t swappedRelationFn,
                        _geosPreparedRelationFunc_t preparedRelationFn,
                        _geosPreparedRelationFunc_t swappedPreparedRelationFn) {
-  int32_t code = TSDB_CODE_FAILED;
-  SGeosContext* geosCtx = getThreadLocalGeosCtx();
+  SGeosContext *geosCtx = getThreadLocalGeosCtx();
 
   if (!preparedGeom1) {
     if (!swapped) {
       ASSERT(relationFn);
       *res = relationFn(geosCtx->handle, geom1, geom2);
-    }
-    else {
+    } else {
       ASSERT(swappedRelationFn);
       *res = swappedRelationFn(geosCtx->handle, geom1, geom2);
     }
-  }
-  else {
+  } else {
     if (!swapped) {
       ASSERT(preparedRelationFn);
       *res = preparedRelationFn(geosCtx->handle, preparedGeom1, geom2);
-    }
-    else {
+    } else {
       ASSERT(swappedPreparedRelationFn);
       *res = swappedPreparedRelationFn(geosCtx->handle, preparedGeom1, geom2);
     }
   }
 
-  code = TSDB_CODE_SUCCESS;
-  return code;
+  return TSDB_CODE_SUCCESS;
 }
 
 int32_t doIntersects(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1, const GEOSGeometry *geom2,
                      bool swapped, char *res) {
-  return doGeosRelation(geom1, preparedGeom1, geom2, swapped, res,
-                        GEOSIntersects_r, GEOSIntersects_r, GEOSPreparedIntersects_r, GEOSPreparedIntersects_r);
+  return doGeosRelation(geom1, preparedGeom1, geom2, swapped, res, GEOSIntersects_r, GEOSIntersects_r,
+                        GEOSPreparedIntersects_r, GEOSPreparedIntersects_r);
 }
 
 int32_t doEquals(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1, const GEOSGeometry *geom2,
                  bool swapped, char *res) {
-  return doGeosRelation(geom1, NULL, geom2, swapped, res,
-                        GEOSEquals_r, GEOSEquals_r, NULL, NULL);  // no prepared version for eguals()
+  return doGeosRelation(geom1, NULL, geom2, swapped, res, GEOSEquals_r, GEOSEquals_r, NULL,
+                        NULL);  // no prepared version for eguals()
 }
 
 int32_t doTouches(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1, const GEOSGeometry *geom2,
                   bool swapped, char *res) {
-  return doGeosRelation(geom1, preparedGeom1, geom2, swapped, res,
-                        GEOSTouches_r, GEOSTouches_r, GEOSPreparedTouches_r, GEOSPreparedTouches_r);
+  return doGeosRelation(geom1, preparedGeom1, geom2, swapped, res, GEOSTouches_r, GEOSTouches_r, GEOSPreparedTouches_r,
+                        GEOSPreparedTouches_r);
 }
 
 int32_t doCovers(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1, const GEOSGeometry *geom2,
                  bool swapped, char *res) {
-  return doGeosRelation(geom1, preparedGeom1, geom2, swapped, res,
-                        GEOSCovers_r, GEOSCoveredBy_r, GEOSPreparedCovers_r, GEOSPreparedCoveredBy_r);
+  return doGeosRelation(geom1, preparedGeom1, geom2, swapped, res, GEOSCovers_r, GEOSCoveredBy_r, GEOSPreparedCovers_r,
+                        GEOSPreparedCoveredBy_r);
 }
 
 int32_t doContains(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1, const GEOSGeometry *geom2,
                    bool swapped, char *res) {
-  return doGeosRelation(geom1, preparedGeom1, geom2, swapped, res,
-                        GEOSContains_r, GEOSWithin_r, GEOSPreparedContains_r, GEOSPreparedWithin_r);
+  return doGeosRelation(geom1, preparedGeom1, geom2, swapped, res, GEOSContains_r, GEOSWithin_r, GEOSPreparedContains_r,
+                        GEOSPreparedWithin_r);
 }
 
-int32_t doContainsProperly(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1, const GEOSGeometry *geom2,
-                           bool swapped, char *res) {
-  return doGeosRelation(geom1, preparedGeom1, geom2, swapped, res,
-                        NULL, NULL, GEOSPreparedContainsProperly_r, NULL);
+int32_t doContainsProperly(const GEOSGeometry *geom1, const GEOSPreparedGeometry *preparedGeom1,
+                           const GEOSGeometry *geom2, bool swapped, char *res) {
+  return doGeosRelation(geom1, preparedGeom1, geom2, swapped, res, NULL, NULL, GEOSPreparedContainsProperly_r, NULL);
 }
 
 // input is with VARSTR format
 // need to call destroyGeometry(outputGeom, outputPreparedGeom) later
-int32_t readGeometry(const unsigned char *input, GEOSGeometry **outputGeom, const GEOSPreparedGeometry **outputPreparedGeom) {
-  SGeosContext* geosCtx = getThreadLocalGeosCtx();
+int32_t readGeometry(const unsigned char *input, GEOSGeometry **outputGeom,
+                     const GEOSPreparedGeometry **outputPreparedGeom) {
+  SGeosContext *geosCtx = getThreadLocalGeosCtx();
 
-  ASSERT(outputGeom); //it is not allowed if outputGeom is NULL
+  ASSERT(outputGeom);  // it is not allowed if outputGeom is NULL
   *outputGeom = NULL;
 
-  if (outputPreparedGeom) {  //it means not to generate PreparedGeometry if outputPreparedGeom is NULL
+  if (outputPreparedGeom) {  // it means not to generate PreparedGeometry if outputPreparedGeom is NULL
     *outputPreparedGeom = NULL;
   }
 
-  if (varDataLen(input) == 0) { //empty value
+  if (varDataLen(input) == 0) {  // empty value
     return TSDB_CODE_SUCCESS;
   }
 
@@ -410,7 +408,7 @@ int32_t readGeometry(const unsigned char *input, GEOSGeometry **outputGeom, cons
 }
 
 void destroyGeometry(GEOSGeometry **geom, const GEOSPreparedGeometry **preparedGeom) {
-  SGeosContext* geosCtx = getThreadLocalGeosCtx();
+  SGeosContext *geosCtx = getThreadLocalGeosCtx();
 
   if (preparedGeom && *preparedGeom) {
     GEOSPreparedGeom_destroy_r(geosCtx->handle, *preparedGeom);
diff --git a/source/libs/monitor/src/monMain.c b/source/libs/monitor/src/monMain.c
index 3389780916..6cba9b0727 100644
--- a/source/libs/monitor/src/monMain.c
+++ b/source/libs/monitor/src/monMain.c
@@ -15,17 +15,17 @@
 
 #define _DEFAULT_SOURCE
 #include "monInt.h"
+#include "taos_monitor.h"
 #include "taoserror.h"
+#include "tglobal.h"
 #include "thttp.h"
 #include "ttime.h"
-#include "taos_monitor.h"
-#include "tglobal.h"
 
 SMonitor tsMonitor = {0};
-char* tsMonUri = "/report";
-char* tsMonFwUri = "/general-metric";
-char* tsMonSlowLogUri = "/slow-sql-detail-batch";
-char* tsMonFwBasicUri = "/taosd-cluster-basic";
+char    *tsMonUri = "/report";
+char    *tsMonFwUri = "/general-metric";
+char    *tsMonSlowLogUri = "/slow-sql-detail-batch";
+char    *tsMonFwBasicUri = "/taosd-cluster-basic";
 
 void monRecordLog(int64_t ts, ELogLevel level, const char *content) {
   taosThreadMutexLock(&tsMonitor.lock);
@@ -54,8 +54,7 @@ int32_t monGetLogs(SMonLogs *logs) {
   taosArrayClear(tsMonitor.logs);
   taosThreadMutexUnlock(&tsMonitor.lock);
   if (logs->logs == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
   return 0;
 }
@@ -105,8 +104,7 @@ void monSetBmInfo(SMonBmInfo *pInfo) {
 int32_t monInit(const SMonCfg *pCfg) {
   tsMonitor.logs = taosArrayInit(16, sizeof(SMonLogItem));
   if (tsMonitor.logs == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   tsMonitor.cfg = *pCfg;
@@ -146,6 +144,7 @@ static void monCleanupMonitorInfo(SMonInfo *pMonitor) {
 }
 
 static SMonInfo *monCreateMonitorInfo() {
+  terrno = 0;
   SMonInfo *pMonitor = taosMemoryCalloc(1, sizeof(SMonInfo));
   if (pMonitor == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -274,11 +273,11 @@ static void monGenClusterJsonBasic(SMonInfo *pMonitor) {
   SMonClusterInfo *pInfo = &pMonitor->mmInfo.cluster;
   if (pMonitor->mmInfo.cluster.first_ep_dnode_id == 0) return;
 
-  //tjsonAddStringToObject(pMonitor->pJson, "first_ep", pInfo->first_ep);
+  // tjsonAddStringToObject(pMonitor->pJson, "first_ep", pInfo->first_ep);
   tjsonAddStringToObject(pMonitor->pJson, "first_ep", tsFirst);
   tjsonAddDoubleToObject(pMonitor->pJson, "first_ep_dnode_id", pInfo->first_ep_dnode_id);
   tjsonAddStringToObject(pMonitor->pJson, "cluster_version", pInfo->version);
-  //tjsonAddDoubleToObject(pMonitor->pJson, "monitor_interval", pInfo->monitor_interval);
+  // tjsonAddDoubleToObject(pMonitor->pJson, "monitor_interval", pInfo->monitor_interval);
 }
 
 static void monGenVgroupJson(SMonInfo *pMonitor) {
@@ -554,9 +553,9 @@ static void monGenLogJson(SMonInfo *pMonitor) {
   if (tjsonAddItemToArray(pSummaryJson, pLogTrace) != 0) tjsonDelete(pLogTrace);
 }
 
-void monSendReport(SMonInfo *pMonitor){
+void monSendReport(SMonInfo *pMonitor) {
   char *pCont = tjsonToString(pMonitor->pJson);
-  if(tsMonitorLogProtocol){
+  if (tsMonitorLogProtocol) {
     uInfoL("report cont:\n%s", pCont);
   }
   if (pCont != NULL) {
@@ -591,7 +590,7 @@ void monGenAndSendReport() {
   SMonInfo *pMonitor = monCreateMonitorInfo();
   if (pMonitor == NULL) return;
 
-  if(!tsMonitorForceV2){
+  if (!tsMonitorForceV2) {
     monGenBasicJson(pMonitor);
     monGenClusterJson(pMonitor);
     monGenVgroupJson(pMonitor);
@@ -602,8 +601,7 @@ void monGenAndSendReport() {
     monGenLogJson(pMonitor);
 
     monSendReport(pMonitor);
-  }
-  else{
+  } else {
     monGenClusterInfoTable(pMonitor);
     monGenVgroupInfoTable(pMonitor);
     monGenDnodeInfoTable(pMonitor);
@@ -624,10 +622,10 @@ void monGenAndSendReport() {
   monCleanupMonitorInfo(pMonitor);
 }
 
-void monSendContent(char *pCont, const char* uri) {
+void monSendContent(char *pCont, const char *uri) {
   if (!tsEnableMonitor || tsMonitorFqdn[0] == 0 || tsMonitorPort == 0) return;
-  if(tsMonitorLogProtocol){
-    if (pCont != NULL){
+  if (tsMonitorLogProtocol) {
+    if (pCont != NULL) {
       uInfoL("report client cont:\n%s\n", pCont);
     }
   }
diff --git a/source/util/src/tconfig.c b/source/util/src/tconfig.c
index 268b0b8497..83a185adae 100644
--- a/source/util/src/tconfig.c
+++ b/source/util/src/tconfig.c
@@ -42,22 +42,21 @@ int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url);
 
 extern char **environ;
 
-SConfig *cfgInit() {
+int32_t cfgInit(SConfig ** ppCfg) {
   SConfig *pCfg = taosMemoryCalloc(1, sizeof(SConfig));
   if (pCfg == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   pCfg->array = taosArrayInit(32, sizeof(SConfigItem));
   if (pCfg->array == NULL) {
     taosMemoryFree(pCfg);
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   taosThreadMutexInit(&pCfg->lock, NULL);
-  return pCfg;
+  *ppCfg = pCfg;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t cfgLoad(SConfig *pCfg, ECfgSrcType cfgType, const void *sourceStr) {
@@ -73,7 +72,7 @@ int32_t cfgLoad(SConfig *pCfg, ECfgSrcType cfgType, const void *sourceStr) {
     case CFG_STYPE_ENV_CMD:
       return cfgLoadFromEnvCmd(pCfg, (const char **)sourceStr);
     default:
-      return -1;
+      return TSDB_CODE_INVALID_PARA;
   }
 }
 
@@ -82,11 +81,11 @@ int32_t cfgLoadFromArray(SConfig *pCfg, SArray *pArgs) {
   for (int32_t i = 0; i < size; ++i) {
     SConfigPair *pPair = taosArrayGet(pArgs, i);
     if (cfgSetItem(pCfg, pPair->name, pPair->value, CFG_STYPE_ARG_LIST, true) != 0) {
-      return -1;
+      return TSDB_CODE_INVALID_PARA;
     }
   }
 
-  return 0;
+  return TSDB_CODE_SUCCESS;
 }
 
 void cfgItemFreeVal(SConfigItem *pItem) {
@@ -126,28 +125,27 @@ static int32_t cfgCheckAndSetConf(SConfigItem *pItem, const char *conf) {
 
   pItem->str = taosStrdup(conf);
   if (pItem->str == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
 
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 static int32_t cfgCheckAndSetDir(SConfigItem *pItem, const char *inputDir) {
   char fullDir[PATH_MAX] = {0};
   if (taosExpandDir(inputDir, fullDir, PATH_MAX) != 0) {
-    uError("failed to expand dir:%s", inputDir);
-    return -1;
+    int32_t code = TAOS_SYSTEM_ERROR(errno);
+    uError("failed to expand dir:%s since %s", inputDir, tstrerror(code));
+    TAOS_RETURN(code);
   }
 
   taosMemoryFreeClear(pItem->str);
   pItem->str = taosStrdup(fullDir);
   if (pItem->str == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
 
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 static int32_t cfgSetBool(SConfigItem *pItem, const char *value, ECfgSrcType stype) {
@@ -166,97 +164,88 @@ static int32_t cfgSetBool(SConfigItem *pItem, const char *value, ECfgSrcType sty
 
 static int32_t cfgSetInt32(SConfigItem *pItem, const char *value, ECfgSrcType stype) {
   int32_t ival;
-  int32_t code = taosStrHumanToInt32(value, &ival);
-  if (code != TSDB_CODE_SUCCESS) return code;
+  TAOS_CHECK_RETURN(taosStrHumanToInt32(value, &ival));
   if (ival < pItem->imin || ival > pItem->imax) {
     uError("cfg:%s, type:%s src:%s value:%d out of range[%" PRId64 ", %" PRId64 "]", pItem->name,
            cfgDtypeStr(pItem->dtype), cfgStypeStr(stype), ival, pItem->imin, pItem->imax);
-    terrno = TSDB_CODE_OUT_OF_RANGE;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
   }
 
   pItem->i32 = ival;
   pItem->stype = stype;
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 static int32_t cfgSetInt64(SConfigItem *pItem, const char *value, ECfgSrcType stype) {
   int64_t ival;
-  int32_t code = taosStrHumanToInt64(value, &ival);
-  if (code != TSDB_CODE_SUCCESS) return code;
+  TAOS_CHECK_RETURN(taosStrHumanToInt64(value, &ival));
   if (ival < pItem->imin || ival > pItem->imax) {
     uError("cfg:%s, type:%s src:%s value:%" PRId64 " out of range[%" PRId64 ", %" PRId64 "]", pItem->name,
            cfgDtypeStr(pItem->dtype), cfgStypeStr(stype), ival, pItem->imin, pItem->imax);
-    terrno = TSDB_CODE_OUT_OF_RANGE;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
   }
 
   pItem->i64 = ival;
   pItem->stype = stype;
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 static int32_t cfgSetFloat(SConfigItem *pItem, const char *value, ECfgSrcType stype) {
   double dval;
-  int32_t code = parseCfgReal(value, &dval);
+  TAOS_CHECK_RETURN(parseCfgReal(value, &dval));
   if (dval < pItem->fmin || dval > pItem->fmax) {
     uError("cfg:%s, type:%s src:%s value:%f out of range[%f, %f]", pItem->name, cfgDtypeStr(pItem->dtype),
            cfgStypeStr(stype), dval, pItem->fmin, pItem->fmax);
-    terrno = TSDB_CODE_OUT_OF_RANGE;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
   }
 
   pItem->fval = (float)dval;
   pItem->stype = stype;
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 static int32_t cfgSetString(SConfigItem *pItem, const char *value, ECfgSrcType stype) {
   char *tmp = taosStrdup(value);
   if (tmp == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
     uError("cfg:%s, type:%s src:%s value:%s failed to dup since %s", pItem->name, cfgDtypeStr(pItem->dtype),
-           cfgStypeStr(stype), value, terrstr());
-    return -1;
+           cfgStypeStr(stype), value, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   taosMemoryFreeClear(pItem->str);
   pItem->str = tmp;
   pItem->stype = stype;
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 static int32_t cfgSetDir(SConfigItem *pItem, const char *value, ECfgSrcType stype) {
-  if (cfgCheckAndSetDir(pItem, value) != 0) {
+  int32_t code = cfgCheckAndSetDir(pItem, value);
+  if (TSDB_CODE_SUCCESS != code) {
     uError("cfg:%s, type:%s src:%s value:%s failed to dup since %s", pItem->name, cfgDtypeStr(pItem->dtype),
-           cfgStypeStr(stype), value, terrstr());
-    return -1;
+           cfgStypeStr(stype), value, tstrerror(code));
+    TAOS_RETURN(code);
   }
 
   pItem->stype = stype;
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 static int32_t doSetConf(SConfigItem *pItem, const char *value, ECfgSrcType stype) {
-  if (cfgCheckAndSetConf(pItem, value) != 0) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
+  int32_t code = cfgCheckAndSetConf(pItem, value);
+  if (TSDB_CODE_SUCCESS != code) {
     uError("cfg:%s, type:%s src:%s value:%s failed to dup since %s", pItem->name, cfgDtypeStr(pItem->dtype),
-           cfgStypeStr(stype), value, terrstr());
-    return -1;
+           cfgStypeStr(stype), value, tstrerror(TSDB_CODE_OUT_OF_MEMORY));
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   pItem->stype = stype;
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 static int32_t cfgSetTimezone(SConfigItem *pItem, const char *value, ECfgSrcType stype) {
-  int32_t code = doSetConf(pItem, value, stype);
-  if (code != TSDB_CODE_SUCCESS) {
-    return code;
-  }
-
+  TAOS_CHECK_RETURN(doSetConf(pItem, value, stype));
   osSetTimezone(value);
-  return code;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 static int32_t cfgSetTfsItem(SConfig *pCfg, const char *name, const char *value, const char *level, const char *primary,
@@ -267,16 +256,15 @@ static int32_t cfgSetTfsItem(SConfig *pCfg, const char *name, const char *value,
   if (pItem == NULL) {
     taosThreadMutexUnlock(&pCfg->lock);
 
-    return -1;
+    TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);
   }
 
   if (pItem->array == NULL) {
     pItem->array = taosArrayInit(16, sizeof(SDiskCfg));
     if (pItem->array == NULL) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
       taosThreadMutexUnlock(&pCfg->lock);
 
-      return -1;
+      TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
     }
   }
 
@@ -287,34 +275,32 @@ static int32_t cfgSetTfsItem(SConfig *pCfg, const char *name, const char *value,
   cfg.disable = disable ? atoi(disable) : 0;
   void *ret = taosArrayPush(pItem->array, &cfg);
   if (ret == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
     taosThreadMutexUnlock(&pCfg->lock);
 
-    return -1;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   pItem->stype = stype;
   taosThreadMutexUnlock(&pCfg->lock);
 
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 static int32_t cfgUpdateDebugFlagItem(SConfig *pCfg, const char *name, bool resetArray) {
   SConfigItem *pDebugFlagItem = cfgGetItem(pCfg, "debugFlag");
   if (resetArray) {
     // reset
-    if (pDebugFlagItem == NULL) return -1;
+    if (pDebugFlagItem == NULL) TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);
 
     // logflag names that should 'not' be set by 'debugFlag'
     if (pDebugFlagItem->array == NULL) {
       pDebugFlagItem->array = taosArrayInit(16, sizeof(SLogVar));
       if (pDebugFlagItem->array == NULL) {
-        terrno = TSDB_CODE_OUT_OF_MEMORY;
-        return -1;
+        TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
       }
     }
     taosArrayClear(pDebugFlagItem->array);
-    return 0;
+    TAOS_RETURN(TSDB_CODE_SUCCESS);
   }
 
   // update
@@ -322,9 +308,11 @@ static int32_t cfgUpdateDebugFlagItem(SConfig *pCfg, const char *name, bool rese
   if (pDebugFlagItem->array != NULL) {
     SLogVar logVar = {0};
     strncpy(logVar.name, name, TSDB_LOG_VAR_LEN - 1);
-    taosArrayPush(pDebugFlagItem->array, &logVar);
+    if (NULL == taosArrayPush(pDebugFlagItem->array, &logVar)) {
+      TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    }
   }
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t cfgSetItem(SConfig *pCfg, const char *name, const char *value, ECfgSrcType stype, bool lock) {
@@ -337,9 +325,8 @@ int32_t cfgSetItem(SConfig *pCfg, const char *name, const char *value, ECfgSrcTy
 
   SConfigItem *pItem = cfgGetItem(pCfg, name);
   if (pItem == NULL) {
-    terrno = TSDB_CODE_CFG_NOT_FOUND;
     taosThreadMutexUnlock(&pCfg->lock);
-    return -1;
+    TAOS_RETURN(TSDB_CODE_CFG_NOT_FOUND);
   }
 
   switch (pItem->dtype) {
@@ -382,7 +369,7 @@ int32_t cfgSetItem(SConfig *pCfg, const char *name, const char *value, ECfgSrcTy
     }
     case CFG_DTYPE_NONE:
     default:
-      terrno = TSDB_CODE_INVALID_CFG;
+      code = TSDB_CODE_INVALID_CFG;
       break;
   }
 
@@ -390,7 +377,7 @@ int32_t cfgSetItem(SConfig *pCfg, const char *name, const char *value, ECfgSrcTy
     taosThreadMutexUnlock(&pCfg->lock);
   }
 
-  return code;
+  TAOS_RETURN(code);
 }
 
 SConfigItem *cfgGetItem(SConfig *pCfg, const char *pName) {
@@ -403,7 +390,6 @@ SConfigItem *cfgGetItem(SConfig *pCfg, const char *pName) {
     }
   }
 
-  terrno = TSDB_CODE_CFG_NOT_FOUND;
   return NULL;
 }
 
@@ -420,27 +406,25 @@ void cfgUnLock(SConfig *pCfg) {
 }
 
 int32_t cfgCheckRangeForDynUpdate(SConfig *pCfg, const char *name, const char *pVal, bool isServer) {
-  ECfgDynType  dynType = isServer ? CFG_DYN_SERVER : CFG_DYN_CLIENT;
+  ECfgDynType dynType = isServer ? CFG_DYN_SERVER : CFG_DYN_CLIENT;
 
   cfgLock(pCfg);
 
   SConfigItem *pItem = cfgGetItem(pCfg, name);
   if (!pItem || (pItem->dynScope & dynType) == 0) {
     uError("failed to config:%s, not support update this config", name);
-    terrno = TSDB_CODE_INVALID_CFG;
     cfgUnLock(pCfg);
-    return -1;
+    TAOS_RETURN(TSDB_CODE_INVALID_CFG);
   }
 
   switch (pItem->dtype) {
-    case CFG_DTYPE_STRING:{
-      if(strcasecmp(name, "slowLogScope") == 0){
-        char* tmp = taosStrdup(pVal);
-        if(taosSetSlowLogScope(tmp) < 0){
-          terrno = TSDB_CODE_INVALID_CFG;
+    case CFG_DTYPE_STRING: {
+      if (strcasecmp(name, "slowLogScope") == 0) {
+        char *tmp = taosStrdup(pVal);
+        if (taosSetSlowLogScope(tmp) < 0) {
           cfgUnLock(pCfg);
           taosMemoryFree(tmp);
-          return -1;
+          TAOS_RETURN(TSDB_CODE_INVALID_CFG);
         }
         taosMemoryFree(tmp);
       }
@@ -449,9 +433,8 @@ int32_t cfgCheckRangeForDynUpdate(SConfig *pCfg, const char *name, const char *p
       int32_t ival = (int32_t)atoi(pVal);
       if (ival != 0 && ival != 1) {
         uError("cfg:%s, type:%s value:%d out of range[0, 1]", pItem->name, cfgDtypeStr(pItem->dtype), ival);
-        terrno = TSDB_CODE_OUT_OF_RANGE;
         cfgUnLock(pCfg);
-        return -1;
+        TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
       }
     } break;
     case CFG_DTYPE_INT32: {
@@ -464,9 +447,8 @@ int32_t cfgCheckRangeForDynUpdate(SConfig *pCfg, const char *name, const char *p
       if (ival < pItem->imin || ival > pItem->imax) {
         uError("cfg:%s, type:%s value:%d out of range[%" PRId64 ", %" PRId64 "]", pItem->name,
                cfgDtypeStr(pItem->dtype), ival, pItem->imin, pItem->imax);
-        terrno = TSDB_CODE_OUT_OF_RANGE;
         cfgUnLock(pCfg);
-        return -1;
+        TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
       }
     } break;
     case CFG_DTYPE_INT64: {
@@ -474,30 +456,28 @@ int32_t cfgCheckRangeForDynUpdate(SConfig *pCfg, const char *name, const char *p
       int32_t code = taosStrHumanToInt64(pVal, &ival);
       if (code != TSDB_CODE_SUCCESS) {
         cfgUnLock(pCfg);
-        return code;
+        TAOS_RETURN(code);
       }
       if (ival < pItem->imin || ival > pItem->imax) {
         uError("cfg:%s, type:%s value:%" PRId64 " out of range[%" PRId64 ", %" PRId64 "]", pItem->name,
                cfgDtypeStr(pItem->dtype), ival, pItem->imin, pItem->imax);
-        terrno = TSDB_CODE_OUT_OF_RANGE;
         cfgUnLock(pCfg);
-        return -1;
+        TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
       }
     } break;
     case CFG_DTYPE_FLOAT:
     case CFG_DTYPE_DOUBLE: {
-      double dval;
+      double  dval;
       int32_t code = parseCfgReal(pVal, &dval);
       if (code != TSDB_CODE_SUCCESS) {
         cfgUnLock(pCfg);
-        return code;
+        TAOS_RETURN(code);
       }
       if (dval < pItem->fmin || dval > pItem->fmax) {
         uError("cfg:%s, type:%s value:%f out of range[%f, %f]", pItem->name, cfgDtypeStr(pItem->dtype), dval,
                pItem->fmin, pItem->fmax);
-        terrno = TSDB_CODE_OUT_OF_RANGE;
         cfgUnLock(pCfg);
-        return -1;
+        TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
       }
     } break;
     default:
@@ -505,15 +485,14 @@ int32_t cfgCheckRangeForDynUpdate(SConfig *pCfg, const char *name, const char *p
   }
 
   cfgUnLock(pCfg);
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 static int32_t cfgAddItem(SConfig *pCfg, SConfigItem *pItem, const char *name) {
   pItem->stype = CFG_STYPE_DEFAULT;
   pItem->name = taosStrdup(name);
   if (pItem->name == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   int32_t size = taosArrayGetSize(pCfg->array);
@@ -521,7 +500,7 @@ static int32_t cfgAddItem(SConfig *pCfg, SConfigItem *pItem, const char *name) {
     SConfigItem *existItem = taosArrayGet(pCfg->array, i);
     if (existItem != NULL && strcmp(existItem->name, pItem->name) == 0) {
       taosMemoryFree(pItem->name);
-      return TSDB_CODE_INVALID_CFG;
+      TAOS_RETURN(TSDB_CODE_INVALID_CFG);
     }
   }
 
@@ -535,11 +514,10 @@ static int32_t cfgAddItem(SConfig *pCfg, SConfigItem *pItem, const char *name) {
     }
 
     taosMemoryFree(pItem->name);
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
 
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t cfgAddBool(SConfig *pCfg, const char *name, bool defaultVal, int8_t scope, int8_t dynScope) {
@@ -550,8 +528,7 @@ int32_t cfgAddBool(SConfig *pCfg, const char *name, bool defaultVal, int8_t scop
 int32_t cfgAddInt32(SConfig *pCfg, const char *name, int32_t defaultVal, int64_t minval, int64_t maxval, int8_t scope,
                     int8_t dynScope) {
   if (defaultVal < minval || defaultVal > maxval) {
-    terrno = TSDB_CODE_OUT_OF_RANGE;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
   }
 
   SConfigItem item = {.dtype = CFG_DTYPE_INT32,
@@ -566,8 +543,7 @@ int32_t cfgAddInt32(SConfig *pCfg, const char *name, int32_t defaultVal, int64_t
 int32_t cfgAddInt64(SConfig *pCfg, const char *name, int64_t defaultVal, int64_t minval, int64_t maxval, int8_t scope,
                     int8_t dynScope) {
   if (defaultVal < minval || defaultVal > maxval) {
-    terrno = TSDB_CODE_OUT_OF_RANGE;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
   }
 
   SConfigItem item = {.dtype = CFG_DTYPE_INT64,
@@ -582,8 +558,7 @@ int32_t cfgAddInt64(SConfig *pCfg, const char *name, int64_t defaultVal, int64_t
 int32_t cfgAddFloat(SConfig *pCfg, const char *name, float defaultVal, float minval, float maxval, int8_t scope,
                     int8_t dynScope) {
   if (defaultVal < minval || defaultVal > maxval) {
-    terrno = TSDB_CODE_OUT_OF_RANGE;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
   }
 
   SConfigItem item = {.dtype = CFG_DTYPE_FLOAT,
@@ -599,45 +574,32 @@ int32_t cfgAddString(SConfig *pCfg, const char *name, const char *defaultVal, in
   SConfigItem item = {.dtype = CFG_DTYPE_STRING, .scope = scope, .dynScope = dynScope};
   item.str = taosStrdup(defaultVal);
   if (item.str == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
   return cfgAddItem(pCfg, &item, name);
 }
 
 int32_t cfgAddDir(SConfig *pCfg, const char *name, const char *defaultVal, int8_t scope, int8_t dynScope) {
   SConfigItem item = {.dtype = CFG_DTYPE_DIR, .scope = scope, .dynScope = dynScope};
-  if (cfgCheckAndSetDir(&item, defaultVal) != 0) {
-    return -1;
-  }
-
+  TAOS_CHECK_RETURN(cfgCheckAndSetDir(&item, defaultVal));
   return cfgAddItem(pCfg, &item, name);
 }
 
 int32_t cfgAddLocale(SConfig *pCfg, const char *name, const char *defaultVal, int8_t scope, int8_t dynScope) {
   SConfigItem item = {.dtype = CFG_DTYPE_LOCALE, .scope = scope, .dynScope = dynScope};
-  if (cfgCheckAndSetConf(&item, defaultVal) != 0) {
-    return -1;
-  }
-
+  TAOS_CHECK_RETURN(cfgCheckAndSetConf(&item, defaultVal));
   return cfgAddItem(pCfg, &item, name);
 }
 
 int32_t cfgAddCharset(SConfig *pCfg, const char *name, const char *defaultVal, int8_t scope, int8_t dynScope) {
   SConfigItem item = {.dtype = CFG_DTYPE_CHARSET, .scope = scope, .dynScope = dynScope};
-  if (cfgCheckAndSetConf(&item, defaultVal) != 0) {
-    return -1;
-  }
-
+  TAOS_CHECK_RETURN(cfgCheckAndSetConf(&item, defaultVal));
   return cfgAddItem(pCfg, &item, name);
 }
 
 int32_t cfgAddTimezone(SConfig *pCfg, const char *name, const char *defaultVal, int8_t scope, int8_t dynScope) {
   SConfigItem item = {.dtype = CFG_DTYPE_TIMEZONE, .scope = scope, .dynScope = dynScope};
-  if (cfgCheckAndSetConf(&item, defaultVal) != 0) {
-    return -1;
-  }
-
+  TAOS_CHECK_RETURN(cfgCheckAndSetConf(&item, defaultVal));
   return cfgAddItem(pCfg, &item, name);
 }
 
@@ -693,7 +655,7 @@ const char *cfgDtypeStr(ECfgDataType type) {
   }
 }
 
-void cfgDumpItemValue(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen) {
+int32_t cfgDumpItemValue(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen) {
   int32_t len = 0;
   switch (pItem->dtype) {
     case CFG_DTYPE_BOOL:
@@ -719,14 +681,19 @@ void cfgDumpItemValue(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *p
       break;
   }
 
+  if (len < 0) {
+    TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
+  }
+
   if (len > bufSize) {
     len = bufSize;
   }
 
   *pLen = len;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
-void cfgDumpItemScope(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen) {
+int32_t cfgDumpItemScope(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen) {
   int32_t len = 0;
   switch (pItem->scope) {
     case CFG_SCOPE_SERVER:
@@ -740,11 +707,16 @@ void cfgDumpItemScope(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *p
       break;
   }
 
+  if (len < 0) {
+    TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
+  }
+
   if (len > bufSize) {
     len = bufSize;
   }
 
   *pLen = len;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 void cfgDumpCfgS3(SConfig *pCfg, bool tsc, bool dump) {
@@ -919,14 +891,14 @@ int32_t cfgLoadFromEnvVar(SConfig *pConfig) {
   char  **pEnv = environ;
   line[1023] = 0;
 
-  if (pEnv == NULL) return 0;
+  if (pEnv == NULL) TAOS_RETURN(TSDB_CODE_SUCCESS);
   while (*pEnv != NULL) {
     name = value = value2 = value3 = value4 = NULL;
     olen = vlen = vlen2 = vlen3 = vlen4 = 0;
 
     strncpy(line, *pEnv, sizeof(line) - 1);
     pEnv++;
-    taosEnvToCfg(line, line);
+    (void)taosEnvToCfg(line, line);
 
     paGetToken(line, &name, &olen);
     if (olen == 0) continue;
@@ -943,21 +915,21 @@ int32_t cfgLoadFromEnvVar(SConfig *pConfig) {
       if (vlen3 != 0) {
         value3[vlen3] = 0;
         paGetToken(value3 + vlen3 + 1, &value4, &vlen4);
-        if(vlen4 != 0) value4[vlen4] = 0;
+        if (vlen4 != 0) value4[vlen4] = 0;
       }
     }
 
     code = cfgSetItem(pConfig, name, value, CFG_STYPE_ENV_VAR, true);
-    if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break;
+    if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
 
     if (strcasecmp(name, "dataDir") == 0) {
       code = cfgSetTfsItem(pConfig, name, value, value2, value3, value4, CFG_STYPE_ENV_VAR);
-      if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break;
+      if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
     }
   }
 
   uInfo("load from env variables cfg success");
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t cfgLoadFromEnvCmd(SConfig *pConfig, const char **envCmd) {
@@ -965,11 +937,11 @@ int32_t cfgLoadFromEnvCmd(SConfig *pConfig, const char **envCmd) {
   int32_t olen, vlen, vlen2, vlen3, vlen4;
   int32_t code = 0;
   int32_t index = 0;
-  if (envCmd == NULL) return 0;
+  if (envCmd == NULL) TAOS_RETURN(TSDB_CODE_SUCCESS);
   while (envCmd[index] != NULL) {
     strncpy(buf, envCmd[index], sizeof(buf) - 1);
     buf[sizeof(buf) - 1] = 0;
-    taosEnvToCfg(buf, buf);
+    (void)taosEnvToCfg(buf, buf);
     index++;
 
     name = value = value2 = value3 = value4 = NULL;
@@ -990,21 +962,21 @@ int32_t cfgLoadFromEnvCmd(SConfig *pConfig, const char **envCmd) {
       if (vlen3 != 0) {
         value3[vlen3] = 0;
         paGetToken(value3 + vlen3 + 1, &value4, &vlen4);
-        if(vlen4 != 0) value4[vlen4] = 0;
+        if (vlen4 != 0) value4[vlen4] = 0;
       }
     }
 
     code = cfgSetItem(pConfig, name, value, CFG_STYPE_ENV_CMD, true);
-    if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break;
+    if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
 
     if (strcasecmp(name, "dataDir") == 0) {
       code = cfgSetTfsItem(pConfig, name, value, value2, value3, value4, CFG_STYPE_ENV_CMD);
-      if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break;
+      if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
     }
   }
 
   uInfo("load from env cmd cfg success");
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t cfgLoadFromEnvFile(SConfig *pConfig, const char *envFile) {
@@ -1017,20 +989,19 @@ int32_t cfgLoadFromEnvFile(SConfig *pConfig, const char *envFile) {
   if (envFile != NULL && strlen(envFile) > 0) {
     if (!taosCheckExistFile(envFile)) {
       uError("failed to load env file:%s", envFile);
-      return -1;
+      TAOS_RETURN(TSDB_CODE_NOT_FOUND);
     }
     filepath = envFile;
   } else {
     if (!taosCheckExistFile(filepath)) {
       uInfo("env file:%s not load", filepath);
-      return 0;
+      TAOS_RETURN(TSDB_CODE_SUCCESS);
     }
   }
 
   TdFilePtr pFile = taosOpenFile(filepath, TD_FILE_READ | TD_FILE_STREAM);
   if (pFile == NULL) {
-    terrno = TAOS_SYSTEM_ERROR(errno);
-    return -1;
+    TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
   }
 
   while (!taosEOFFile(pFile)) {
@@ -1042,7 +1013,7 @@ int32_t cfgLoadFromEnvFile(SConfig *pConfig, const char *envFile) {
       break;
     }
     if (line[_bytes - 1] == '\n') line[_bytes - 1] = 0;
-    taosEnvToCfg(line, line);
+    (void)taosEnvToCfg(line, line);
 
     paGetToken(line, &name, &olen);
     if (olen == 0) continue;
@@ -1059,23 +1030,23 @@ int32_t cfgLoadFromEnvFile(SConfig *pConfig, const char *envFile) {
       if (vlen3 != 0) {
         value3[vlen3] = 0;
         paGetToken(value3 + vlen3 + 1, &value4, &vlen4);
-        if(vlen4 != 0) value4[vlen4] = 0;
+        if (vlen4 != 0) value4[vlen4] = 0;
       }
     }
 
     code = cfgSetItem(pConfig, name, value, CFG_STYPE_ENV_FILE, true);
-    if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break;
+    if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
 
     if (strcasecmp(name, "dataDir") == 0) {
       code = cfgSetTfsItem(pConfig, name, value, value2, value3, value4, CFG_STYPE_ENV_FILE);
-      if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break;
+      if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
     }
   }
 
   taosCloseFile(&pFile);
 
   uInfo("load from env cfg file %s success", filepath);
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath) {
@@ -1087,13 +1058,13 @@ int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath) {
   TdFilePtr pFile = taosOpenFile(filepath, TD_FILE_READ | TD_FILE_STREAM);
   if (pFile == NULL) {
     // success when the file does not exist
+    code = TAOS_SYSTEM_ERROR(errno);
     if (errno == ENOENT) {
-      terrno = TAOS_SYSTEM_ERROR(errno);
-      uInfo("failed to load from cfg file %s since %s, use default parameters", filepath, terrstr());
-      return 0;
+      uInfo("failed to load from cfg file %s since %s, use default parameters", filepath, tstrerror(code));
+      TAOS_RETURN(TSDB_CODE_SUCCESS);
     } else {
-      uError("failed to load from cfg file %s since %s", filepath, terrstr());
-      return -1;
+      uError("failed to load from cfg file %s since %s", filepath, tstrerror(code));
+      TAOS_RETURN(code);
     }
   }
 
@@ -1134,7 +1105,7 @@ int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath) {
       }
 
       code = cfgSetItem(pConfig, name, newValue, CFG_STYPE_CFG_FILE, true);
-      if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break;
+      if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
     } else {
       paGetToken(value + vlen + 1, &value2, &vlen2);
       if (vlen2 != 0) {
@@ -1148,12 +1119,12 @@ int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath) {
       }
 
       code = cfgSetItem(pConfig, name, value, CFG_STYPE_CFG_FILE, true);
-      if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break;
+      if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
     }
 
     if (strcasecmp(name, "dataDir") == 0) {
       code = cfgSetTfsItem(pConfig, name, value, value2, value3, value4, CFG_STYPE_CFG_FILE);
-      if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break;
+      if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
     }
 
     size_t       len = strlen(name);
@@ -1161,18 +1132,18 @@ int32_t cfgLoadFromCfgFile(SConfig *pConfig, const char *filepath) {
     const size_t debugFlagLen = strlen(debugFlagStr);
     if (len >= debugFlagLen && strcasecmp(name + len - debugFlagLen, debugFlagStr) == 0) {
       code = cfgUpdateDebugFlagItem(pConfig, name, len == debugFlagLen);
-      if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break;
+      if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
     }
   }
 
   taosCloseFile(&pFile);
 
-  if (code == 0 || (code != 0 && terrno == TSDB_CODE_CFG_NOT_FOUND)) {
+  if (TSDB_CODE_SUCCESS == code || TSDB_CODE_CFG_NOT_FOUND == code) {
     uInfo("load from cfg file %s success", filepath);
-    return 0;
+    TAOS_RETURN(TSDB_CODE_SUCCESS);
   } else {
-    uError("failed to load from cfg file %s since %s", filepath, terrstr());
-    return -1;
+    uError("failed to load from cfg file %s since %s", filepath, tstrerror(code));
+    TAOS_RETURN(code);
   }
 }
 
@@ -1247,46 +1218,52 @@ int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url) {
   int32_t code = 0;
   if (url == NULL || strlen(url) == 0) {
     uInfo("apoll url not load");
-    return 0;
+    TAOS_RETURN(TSDB_CODE_SUCCESS);
   }
 
   char *p = strchr(url, ':');
   if (p == NULL) {
     uError("fail to load apoll url: %s, unknown format", url);
-    return -1;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
   }
   p++;
 
+  SJson *pJson = NULL;
   if (strncmp(url, "jsonFile", 8) == 0) {
     char *filepath = p;
     if (!taosCheckExistFile(filepath)) {
       uError("failed to load json file:%s", filepath);
-      return -1;
+      TAOS_RETURN(TSDB_CODE_NOT_FOUND);
     }
 
     TdFilePtr pFile = taosOpenFile(filepath, TD_FILE_READ);
     if (pFile == NULL) {
-      terrno = TAOS_SYSTEM_ERROR(errno);
-      return -1;
+      TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
     }
     size_t fileSize = taosLSeekFile(pFile, 0, SEEK_END);
     char  *buf = taosMemoryMalloc(fileSize);
+    if (!buf) {
+      taosCloseFile(&pFile);
+      uError("load json file error: %s, failed to alloc memory", filepath);
+      TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    }
+
     taosLSeekFile(pFile, 0, SEEK_SET);
     if (taosReadFile(pFile, buf, fileSize) <= 0) {
       taosCloseFile(&pFile);
       uError("load json file error: %s", filepath);
       taosMemoryFreeClear(buf);
-      return -1;
+      TAOS_RETURN(TSDB_CODE_INVALID_DATA_FMT);
     }
     taosCloseFile(&pFile);
-    SJson *pJson = tjsonParse(buf);
+    pJson = tjsonParse(buf);
     if (NULL == pJson) {
       const char *jsonParseError = tjsonGetError();
       if (jsonParseError != NULL) {
         uError("load json file parse error: %s", jsonParseError);
       }
       taosMemoryFreeClear(buf);
-      return -1;
+      TAOS_RETURN(TSDB_CODE_INVALID_DATA_FMT);
     }
     taosMemoryFreeClear(buf);
 
@@ -1295,13 +1272,17 @@ int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url) {
       cJSON *item = tjsonGetArrayItem(pJson, i);
       if (item == NULL) break;
       char *itemName = NULL, *itemValueString = NULL;
-      tjsonGetObjectName(item, &itemName);
-      tjsonGetObjectName(item, &itemName);
-      tjsonGetObjectValueString(item, &itemValueString);
+      TAOS_CHECK_GOTO(tjsonGetObjectName(item, &itemName), NULL, _err_json);
+      TAOS_CHECK_GOTO(tjsonGetObjectValueString(item, &itemValueString), NULL, _err_json);
       if (itemValueString != NULL && itemName != NULL) {
         size_t itemNameLen = strlen(itemName);
         size_t itemValueStringLen = strlen(itemValueString);
         cfgLineBuf = taosMemoryMalloc(itemNameLen + itemValueStringLen + 2);
+        if (NULL == cfgLineBuf) {
+          code = TSDB_CODE_OUT_OF_MEMORY;
+          goto _err_json;
+        }
+
         memcpy(cfgLineBuf, itemName, itemNameLen);
         cfgLineBuf[itemNameLen] = ' ';
         memcpy(&cfgLineBuf[itemNameLen + 1], itemValueString, itemValueStringLen);
@@ -1327,11 +1308,11 @@ int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url) {
         }
 
         code = cfgSetItem(pConfig, name, value, CFG_STYPE_APOLLO_URL, true);
-        if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break;
+        if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
 
         if (strcasecmp(name, "dataDir") == 0) {
           code = cfgSetTfsItem(pConfig, name, value, value2, value3, value4, CFG_STYPE_APOLLO_URL);
-          if (code != 0 && terrno != TSDB_CODE_CFG_NOT_FOUND) break;
+          if (TSDB_CODE_SUCCESS != code && TSDB_CODE_CFG_NOT_FOUND != code) break;
         }
       }
     }
@@ -1341,16 +1322,20 @@ int32_t cfgLoadFromApollUrl(SConfig *pConfig, const char *url) {
     // } else if (strncmp(url, "etcdUrl", 7) == 0) {
   } else {
     uError("Unsupported url: %s", url);
-    return -1;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
   }
 
   uInfo("load from apoll url not implemented yet");
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
+
+_err_json:
+  tjsonDelete(pJson);
+  TAOS_RETURN(code);
 }
 
 int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char *apolloUrl) {
   int32_t index = 0;
-  if (envCmd == NULL) return 0;
+  if (envCmd == NULL) TAOS_RETURN(TSDB_CODE_SUCCESS);
   while (envCmd[index] != NULL) {
     if (strncmp(envCmd[index], "TAOS_APOLLO_URL", 14) == 0) {
       char *p = strchr(envCmd[index], '=');
@@ -1362,7 +1347,7 @@ int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char *apolloUrl
         }
         memcpy(apolloUrl, p, TMIN(strlen(p) + 1, PATH_MAX));
         uInfo("get apollo url from env cmd success");
-        return 0;
+        TAOS_RETURN(TSDB_CODE_SUCCESS);
       }
     }
     index++;
@@ -1384,7 +1369,7 @@ int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char *apolloUrl
         }
         memcpy(apolloUrl, p, TMIN(strlen(p) + 1, PATH_MAX));
         uInfo("get apollo url from env variables success, apolloUrl=%s", apolloUrl);
-        return 0;
+        TAOS_RETURN(TSDB_CODE_SUCCESS);
       }
     }
   }
@@ -1393,13 +1378,13 @@ int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char *apolloUrl
   if (envFile != NULL && strlen(envFile) > 0) {
     if (!taosCheckExistFile(envFile)) {
       uError("failed to load env file:%s", envFile);
-      return -1;
+      TAOS_RETURN(TSDB_CODE_NOT_FOUND);
     }
     filepath = envFile;
   } else {
     if (!taosCheckExistFile(filepath)) {
       uInfo("env file:%s not load", filepath);
-      return 0;
+      TAOS_RETURN(TSDB_CODE_SUCCESS);
     }
   }
   int64_t   _bytes;
@@ -1422,7 +1407,7 @@ int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char *apolloUrl
           memcpy(apolloUrl, p, TMIN(strlen(p) + 1, PATH_MAX));
           taosCloseFile(&pFile);
           uInfo("get apollo url from env file success");
-          return 0;
+          TAOS_RETURN(TSDB_CODE_SUCCESS);
         }
       }
     }
@@ -1430,7 +1415,7 @@ int32_t cfgGetApollUrl(const char **envCmd, const char *envFile, char *apolloUrl
   }
 
   uInfo("fail get apollo url from cmd env file");
-  return -1;
+  TAOS_RETURN(TSDB_CODE_INVALID_PARA);
 }
 
 struct SConfigIter {
@@ -1438,15 +1423,16 @@ struct SConfigIter {
   SConfig *pConf;
 };
 
-SConfigIter *cfgCreateIter(SConfig *pConf) {
-  SConfigIter* pIter = taosMemoryCalloc(1, sizeof(SConfigIter));
+int32_t cfgCreateIter(SConfig *pConf, SConfigIter **ppIter) {
+  SConfigIter *pIter = taosMemoryCalloc(1, sizeof(SConfigIter));
   if (pIter == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   pIter->pConf = pConf;
-  return pIter;
+
+  *ppIter = pIter;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 SConfigItem *cfgNextIter(SConfigIter* pIter) {
@@ -1463,4 +1449,4 @@ void cfgDestroyIter(SConfigIter *pIter) {
   }
 
   taosMemoryFree(pIter);
-}
\ No newline at end of file
+}
diff --git a/source/util/test/cfgTest.cpp b/source/util/test/cfgTest.cpp
index 9f8645b14c..33ababef10 100644
--- a/source/util/test/cfgTest.cpp
+++ b/source/util/test/cfgTest.cpp
@@ -51,7 +51,10 @@ TEST_F(CfgTest, 01_Str) {
 }
 
 TEST_F(CfgTest, 02_Basic) {
-  SConfig *pConfig = cfgInit();
+  SConfig *pConfig = NULL;
+  int32_t  code = cfgInit(&pConfig);
+
+  ASSERT_EQ(code, TSDB_CODE_SUCCESS);
   ASSERT_NE(pConfig, nullptr);
 
   EXPECT_EQ(cfgAddBool(pConfig, "test_bool", 0, 0, 0), 0);
@@ -66,7 +69,11 @@ TEST_F(CfgTest, 02_Basic) {
   int32_t size = cfgGetSize(pConfig);
 
   SConfigItem* pItem = NULL;
-  SConfigIter* pIter = cfgCreateIter(pConfig);
+  SConfigIter *pIter = NULL;
+  code = cfgCreateIter(pConfig, &pIter);
+  ASSERT_EQ(code, TSDB_CODE_SUCCESS);
+  ASSERT_NE(pIter, nullptr);
+
   while((pItem = cfgNextIter(pIter)) != NULL) {
     switch (pItem->dtype) {
       case CFG_DTYPE_BOOL: