From e96718b43bc7c50f23e9f315323acfe131cbf6ac Mon Sep 17 00:00:00 2001
From: dmchen <cademfly@hotmail.com>
Date: Sun, 21 Jul 2024 05:14:16 +0000
Subject: [PATCH] fix/TD-30989

---
 source/dnode/mnode/impl/src/mndStb.c | 930 ++++++++++++++-------------
 1 file changed, 488 insertions(+), 442 deletions(-)

diff --git a/source/dnode/mnode/impl/src/mndStb.c b/source/dnode/mnode/impl/src/mndStb.c
index 73542bbb1e..efbe906d79 100644
--- a/source/dnode/mnode/impl/src/mndStb.c
+++ b/source/dnode/mnode/impl/src/mndStb.c
@@ -625,87 +625,99 @@ static void *mndBuildVDropStbReq(SMnode *pMnode, SVgObj *pVgroup, SStbObj *pStb,
 }
 
 int32_t mndCheckCreateStbReq(SMCreateStbReq *pCreate) {
+  int32_t code = 0;
   if (pCreate->igExists < 0 || pCreate->igExists > 1) {
-    terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
-    return -1;
+    code = TSDB_CODE_MND_INVALID_STB_OPTION;
+    TAOS_RETURN(code);
   }
 
   if (pCreate->numOfColumns < TSDB_MIN_COLUMNS || pCreate->numOfTags + pCreate->numOfColumns > TSDB_MAX_COLUMNS) {
-    terrno = TSDB_CODE_PAR_INVALID_COLUMNS_NUM;
-    return -1;
+    code = TSDB_CODE_PAR_INVALID_COLUMNS_NUM;
+    TAOS_RETURN(code);
   }
 
   if (pCreate->numOfTags <= 0 || pCreate->numOfTags > TSDB_MAX_TAGS) {
-    terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
-    return -1;
+    code = TSDB_CODE_MND_INVALID_STB_OPTION;
+    TAOS_RETURN(code);
   }
 
   SField *pField = taosArrayGet(pCreate->pColumns, 0);
   if (pField->type != TSDB_DATA_TYPE_TIMESTAMP) {
-    terrno = TSDB_CODE_PAR_INVALID_FIRST_COLUMN;
-    return -1;
+    code = TSDB_CODE_PAR_INVALID_FIRST_COLUMN;
+    TAOS_RETURN(code);
   }
 
   for (int32_t i = 0; i < pCreate->numOfColumns; ++i) {
     SFieldWithOptions *pField1 = taosArrayGet(pCreate->pColumns, i);
     if (pField1->type >= TSDB_DATA_TYPE_MAX) {
-      terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
-      return -1;
+      code = TSDB_CODE_MND_INVALID_STB_OPTION;
+      TAOS_RETURN(code);
     }
     if (pField1->bytes <= 0) {
-      terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
-      return -1;
+      code = TSDB_CODE_MND_INVALID_STB_OPTION;
+      TAOS_RETURN(code);
     }
     if (pField1->name[0] == 0) {
-      terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
-      return -1;
+      code = TSDB_CODE_MND_INVALID_STB_OPTION;
+      TAOS_RETURN(code);
     }
   }
 
   for (int32_t i = 0; i < pCreate->numOfTags; ++i) {
     SField *pField1 = taosArrayGet(pCreate->pTags, i);
     if (pField1->type >= TSDB_DATA_TYPE_MAX) {
-      terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
-      return -1;
+      code = TSDB_CODE_MND_INVALID_STB_OPTION;
+      TAOS_RETURN(code);
     }
     if (pField1->bytes <= 0) {
-      terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
-      return -1;
+      code = TSDB_CODE_MND_INVALID_STB_OPTION;
+      TAOS_RETURN(code);
     }
     if (pField1->name[0] == 0) {
-      terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
-      return -1;
+      code = TSDB_CODE_MND_INVALID_STB_OPTION;
+      TAOS_RETURN(code);
     }
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSetCreateStbPrepareLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb) {
+  int32_t  code = 0;
   SSdbRaw *pRedoRaw = mndStbActionEncode(pStb);
-  if (pRedoRaw == NULL) return -1;
-  if (mndTransAppendPrepareLog(pTrans, pRedoRaw) != 0) {
-    sdbFreeRaw(pRedoRaw);
-    return -1;
+  if (pRedoRaw == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
   }
-  if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING) != 0) return -1;
+  if ((code = mndTransAppendPrepareLog(pTrans, pRedoRaw)) != 0) {
+    sdbFreeRaw(pRedoRaw);
+    TAOS_RETURN(code);
+  }
+  TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_CREATING));
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSetCreateStbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb) {
+  int32_t  code = 0;
   SSdbRaw *pCommitRaw = mndStbActionEncode(pStb);
-  if (pCommitRaw == NULL) return -1;
-  if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
-    sdbFreeRaw(pCommitRaw);
-    return -1;
+  if (pCommitRaw == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
   }
-  if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) return -1;
+  if ((code = mndTransAppendCommitlog(pTrans, pCommitRaw)) != 0) {
+    sdbFreeRaw(pCommitRaw);
+    TAOS_RETURN(code);
+  }
+  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY));
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSetCreateStbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb) {
+  int32_t code = 0;
   SSdb   *pSdb = pMnode->pSdb;
   SVgObj *pVgroup = NULL;
   void   *pIter = NULL;
@@ -723,7 +735,9 @@ static int32_t mndSetCreateStbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj
     if (pReq == NULL) {
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pVgroup);
-      return -1;
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
+      TAOS_RETURN(code);
     }
 
     STransAction action = {0};
@@ -734,25 +748,28 @@ static int32_t mndSetCreateStbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj
     action.msgType = TDMT_VND_CREATE_STB;
     action.acceptableCode = TSDB_CODE_TDB_STB_ALREADY_EXIST;
     action.retryCode = TSDB_CODE_TDB_STB_NOT_EXIST;
-    if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+    if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {
       taosMemoryFree(pReq);
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pVgroup);
-      return -1;
+      TAOS_RETURN(code);
     }
     sdbRelease(pSdb, pVgroup);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndSetForceDropCreateStbRedoActions(SMnode *pMnode, STrans *pTrans, SVgObj *pVgroup, SStbObj *pStb) {
+  int32_t code = 0;
   SSdb   *pSdb = pMnode->pSdb;
   int32_t contLen;
 
   void *pReq = mndBuildVCreateStbReq(pMnode, pVgroup, pStb, &contLen, NULL, 0);
   if (pReq == NULL) {
-    return -1;
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
   }
 
   STransAction action = {0};
@@ -763,15 +780,16 @@ int32_t mndSetForceDropCreateStbRedoActions(SMnode *pMnode, STrans *pTrans, SVgO
   action.msgType = TDMT_VND_CREATE_STB;
   action.acceptableCode = TSDB_CODE_TDB_STB_ALREADY_EXIST;
   action.retryCode = TSDB_CODE_TDB_STB_NOT_EXIST;
-  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 mndSetCreateStbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb) {
+  int32_t code = 0;
   SSdb   *pSdb = pMnode->pSdb;
   SVgObj *pVgroup = NULL;
   void   *pIter = NULL;
@@ -789,8 +807,8 @@ static int32_t mndSetCreateStbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj
     if (pReq == NULL) {
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pVgroup);
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      return -1;
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      TAOS_RETURN(code);
     }
 
     STransAction action = {0};
@@ -799,16 +817,16 @@ static int32_t mndSetCreateStbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj
     action.contLen = contLen;
     action.msgType = TDMT_VND_DROP_STB;
     action.acceptableCode = TSDB_CODE_TDB_STB_NOT_EXIST;
-    if (mndTransAppendUndoAction(pTrans, &action) != 0) {
+    if ((code = mndTransAppendUndoAction(pTrans, &action)) != 0) {
       taosMemoryFree(pReq);
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pVgroup);
-      return -1;
+      TAOS_RETURN(code);
     }
     sdbRelease(pSdb, pVgroup);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static SSchema *mndFindStbColumns(const SStbObj *pStb, const char *colName) {
@@ -822,6 +840,7 @@ static SSchema *mndFindStbColumns(const SStbObj *pStb, const char *colName) {
 }
 
 int32_t mndBuildStbFromReq(SMnode *pMnode, SStbObj *pDst, SMCreateStbReq *pCreate, SDbObj *pDb) {
+  int32_t code = 0;
   memcpy(pDst->name, pCreate->name, TSDB_TABLE_FNAME_LEN);
   memcpy(pDst->db, pDb->name, TSDB_DB_FNAME_LEN);
   pDst->createdTime = taosGetTimestampMs();
@@ -850,8 +869,8 @@ int32_t mndBuildStbFromReq(SMnode *pMnode, SStbObj *pDst, SMCreateStbReq *pCreat
   if (pDst->commentLen > 0) {
     pDst->comment = taosMemoryCalloc(pDst->commentLen + 1, 1);
     if (pDst->comment == NULL) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      return -1;
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      TAOS_RETURN(code);
     }
     memcpy(pDst->comment, pCreate->pComment, pDst->commentLen + 1);
   }
@@ -860,8 +879,8 @@ int32_t mndBuildStbFromReq(SMnode *pMnode, SStbObj *pDst, SMCreateStbReq *pCreat
   if (pDst->ast1Len > 0) {
     pDst->pAst1 = taosMemoryCalloc(pDst->ast1Len, 1);
     if (pDst->pAst1 == NULL) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      return -1;
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      TAOS_RETURN(code);
     }
     memcpy(pDst->pAst1, pCreate->pAst1, pDst->ast1Len);
   }
@@ -870,8 +889,8 @@ int32_t mndBuildStbFromReq(SMnode *pMnode, SStbObj *pDst, SMCreateStbReq *pCreat
   if (pDst->ast2Len > 0) {
     pDst->pAst2 = taosMemoryCalloc(pDst->ast2Len, 1);
     if (pDst->pAst2 == NULL) {
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      return -1;
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      TAOS_RETURN(code);
     }
     memcpy(pDst->pAst2, pCreate->pAst2, pDst->ast2Len);
   }
@@ -879,13 +898,13 @@ int32_t mndBuildStbFromReq(SMnode *pMnode, SStbObj *pDst, SMCreateStbReq *pCreat
   pDst->pColumns = taosMemoryCalloc(1, pDst->numOfColumns * sizeof(SSchema));
   pDst->pTags = taosMemoryCalloc(1, pDst->numOfTags * sizeof(SSchema));
   if (pDst->pColumns == NULL || pDst->pTags == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    TAOS_RETURN(code);
   }
 
   if (pDst->nextColId < 0 || pDst->nextColId >= 0x7fff - pDst->numOfColumns - pDst->numOfTags) {
-    terrno = TSDB_CODE_OUT_OF_RANGE;
-    return -1;
+    code = TSDB_CODE_OUT_OF_RANGE;
+    TAOS_RETURN(code);
   }
 
   for (int32_t i = 0; i < pDst->numOfColumns; ++i) {
@@ -921,7 +940,7 @@ int32_t mndBuildStbFromReq(SMnode *pMnode, SStbObj *pDst, SMCreateStbReq *pCreat
     pColCmpr->id = pSchema->colId;
     pColCmpr->alg = pField->compress;
   }
-  return 0;
+  TAOS_RETURN(code);
 }
 static int32_t mndGenIdxNameForFirstTag(char *fullname, char *dbname, char *stbname, char *tagname) {
   SName name = {0};
@@ -936,16 +955,20 @@ static int32_t mndCreateStb(SMnode *pMnode, SRpcMsg *pReq, SMCreateStbReq *pCrea
   char fullIdxName[TSDB_INDEX_FNAME_LEN * 2] = {0};
 
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_DB_INSIDE, pReq, "create-stb");
-  if (pTrans == NULL) goto _OVER;
+  if (pTrans == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    goto _OVER;
+  }
 
   mInfo("trans:%d, used to create stb:%s", pTrans->id, pCreate->name);
-  if (mndBuildStbFromReq(pMnode, &stbObj, pCreate, pDb) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndBuildStbFromReq(pMnode, &stbObj, pCreate, pDb), NULL, _OVER);
 
   SSchema *pSchema = &(stbObj.pTags[0]);
   mndGenIdxNameForFirstTag(fullIdxName, pDb->name, stbObj.name, pSchema->name);
   SSIdx idx = {0};
   if (mndAcquireGlobalIdx(pMnode, fullIdxName, SDB_IDX, &idx) == 0 && idx.pIdx != NULL) {
-    terrno = TSDB_CODE_MND_TAG_INDEX_ALREADY_EXIST;
+    code = TSDB_CODE_MND_TAG_INDEX_ALREADY_EXIST;
     mndReleaseIdx(pMnode, idx.pIdx);
     goto _OVER;
   }
@@ -960,16 +983,16 @@ static int32_t mndCreateStb(SMnode *pMnode, SRpcMsg *pReq, SMCreateStbReq *pCrea
   idxObj.stbUid = stbObj.uid;
   idxObj.dbUid = stbObj.dbUid;
 
-  if (mndSetCreateIdxCommitLogs(pMnode, pTrans, &idxObj) < 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndSetCreateIdxCommitLogs(pMnode, pTrans, &idxObj), NULL, _OVER);
 
-  if (mndAddStbToTrans(pMnode, pTrans, pDb, &stbObj) < 0) goto _OVER;
-  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndAddStbToTrans(pMnode, pTrans, pDb, &stbObj), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
   code = 0;
 
 _OVER:
   mndTransDrop(pTrans);
   mndStbActionDelete(pMnode->pSdb, &stbObj);
-  return code;
+  TAOS_RETURN(code);
 }
 
 int32_t mndAddStbToTrans(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb) {
@@ -1130,6 +1153,7 @@ static bool mndValidateSchema(SSchema *pSchemas, int32_t nSchema, SArray *pField
 }
 
 static int32_t mndBuildStbFromAlter(SStbObj *pStb, SStbObj *pDst, SMCreateStbReq *createReq) {
+  int32_t code = 0;
   taosRLockLatch(&pStb->lock);
   memcpy(pDst, pStb, sizeof(SStbObj));
   taosRUnLockLatch(&pStb->lock);
@@ -1143,13 +1167,13 @@ static int32_t mndBuildStbFromAlter(SStbObj *pStb, SStbObj *pDst, SMCreateStbReq
   pDst->pCmpr = taosMemoryCalloc(1, pDst->numOfColumns * sizeof(SColCmpr));
 
   if (pDst->pColumns == NULL || pDst->pTags == NULL || pDst->pCmpr == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    TAOS_RETURN(code);
   }
 
   if (pDst->nextColId < 0 || pDst->nextColId >= 0x7fff - pDst->numOfColumns - pDst->numOfTags) {
-    terrno = TSDB_CODE_OUT_OF_RANGE;
-    return -1;
+    code = TSDB_CODE_OUT_OF_RANGE;
+    TAOS_RETURN(code);
   }
 
   for (int32_t i = 0; i < pDst->numOfColumns; ++i) {
@@ -1205,13 +1229,13 @@ static int32_t mndProcessCreateStbReq(SRpcMsg *pReq) {
   bool           isAlter = false;
 
   if (tDeserializeSMCreateStbReq(pReq->pCont, pReq->contLen, &createReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
+    code = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
 
   mInfo("stb:%s, start to create", createReq.name);
   if (mndCheckCreateStbReq(&createReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
+    code = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
 
@@ -1241,17 +1265,17 @@ static int32_t mndProcessCreateStbReq(SRpcMsg *pReq) {
           mInfo("stb:%s, schema version is only increased by 1 number, do alter operation", createReq.name);
         } else {
           mError("stb:%s, schema version increase more than 1 number, error is returned", createReq.name);
-          terrno = TSDB_CODE_MND_INVALID_SCHEMA_VER;
+          code = TSDB_CODE_MND_INVALID_SCHEMA_VER;
           goto _OVER;
         }
       } else {
         mError("stb:%s, already exist while create, input tagVer:%d colVer:%d is invalid, origin tagVer:%d colVer:%d",
                createReq.name, createReq.tagVer, createReq.colVer, pStb->tagVer, pStb->colVer);
-        terrno = TSDB_CODE_MND_INVALID_SCHEMA_VER;
+        code = TSDB_CODE_MND_INVALID_SCHEMA_VER;
         goto _OVER;
       }
     } else {
-      terrno = TSDB_CODE_MND_STB_ALREADY_EXIST;
+      code = TSDB_CODE_MND_STB_ALREADY_EXIST;
       goto _OVER;
     }
   } else if (terrno != TSDB_CODE_MND_STB_NOT_EXIST) {
@@ -1265,33 +1289,32 @@ static int32_t mndProcessCreateStbReq(SRpcMsg *pReq) {
 
   pDb = mndAcquireDbByStb(pMnode, createReq.name);
   if (pDb == NULL) {
-    terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
+    code = TSDB_CODE_MND_DB_NOT_SELECTED;
     goto _OVER;
   }
 
-  if (mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_WRITE_DB, pDb) != 0) {
+  if ((code = mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_WRITE_DB, pDb)) != 0) {
     goto _OVER;
   }
 
   int32_t numOfStbs = -1;
-  if (mndGetNumOfStbs(pMnode, pDb->name, &numOfStbs) != 0) {
+  if ((code = mndGetNumOfStbs(pMnode, pDb->name, &numOfStbs)) != 0) {
     goto _OVER;
   }
 
   if (pDb->cfg.numOfStables == 1 && numOfStbs != 0) {
-    terrno = TSDB_CODE_MND_SINGLE_STB_MODE_DB;
+    code = TSDB_CODE_MND_SINGLE_STB_MODE_DB;
     goto _OVER;
   }
 
-  if ((terrno = grantCheck(TSDB_GRANT_STABLE)) < 0) {
-    code = -1;
+  if ((code = grantCheck(TSDB_GRANT_STABLE)) < 0) {
     goto _OVER;
   }
 
   if (isAlter) {
     bool    needRsp = false;
     SStbObj pDst = {0};
-    if (mndBuildStbFromAlter(pStb, &pDst, &createReq) != 0) {
+    if ((code = mndBuildStbFromAlter(pStb, &pDst, &createReq)) != 0) {
       taosMemoryFreeClear(pDst.pTags);
       taosMemoryFreeClear(pDst.pColumns);
       taosMemoryFreeClear(pDst.pCmpr);
@@ -1328,27 +1351,28 @@ _OVER:
   mndReleaseDb(pMnode, pDb);
   tFreeSMCreateStbReq(&createReq);
 
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndCheckAlterStbReq(SMAlterStbReq *pAlter) {
+  int32_t code = 0;
   if (pAlter->commentLen >= 0) return 0;
   if (pAlter->ttl != 0) return 0;
 
   if (pAlter->numOfFields < 1 || pAlter->numOfFields != (int32_t)taosArrayGetSize(pAlter->pFields)) {
-    terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
-    return -1;
+    code = TSDB_CODE_MND_INVALID_STB_OPTION;
+    TAOS_RETURN(code);
   }
 
   for (int32_t i = 0; i < pAlter->numOfFields; ++i) {
     SField *pField = taosArrayGet(pAlter->pFields, i);
     if (pField->name[0] == 0) {
-      terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
-      return -1;
+      code = TSDB_CODE_MND_INVALID_STB_OPTION;
+      TAOS_RETURN(code);
     }
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndAllocStbSchemas(const SStbObj *pOld, SStbObj *pNew) {
@@ -1356,19 +1380,19 @@ int32_t mndAllocStbSchemas(const SStbObj *pOld, SStbObj *pNew) {
   pNew->pColumns = taosMemoryCalloc(pNew->numOfColumns, sizeof(SSchema));
   pNew->pCmpr = taosMemoryCalloc(pNew->numOfColumns, sizeof(SColCmpr));
   if (pNew->pTags == NULL || pNew->pColumns == NULL || pNew->pCmpr == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   memcpy(pNew->pColumns, pOld->pColumns, sizeof(SSchema) * pOld->numOfColumns);
   memcpy(pNew->pTags, pOld->pTags, sizeof(SSchema) * pOld->numOfTags);
   memcpy(pNew->pCmpr, pOld->pCmpr, sizeof(SColCmpr) * pOld->numOfColumns);
 
-  return 0;
+  TAOS_RETURN(0);
 }
 
 static int32_t mndUpdateStbCommentAndTTL(const SStbObj *pOld, SStbObj *pNew, char *pComment, int32_t commentLen,
                                          int32_t ttl) {
+  int32_t code = 0;
   if (commentLen > 0) {
     pNew->commentLen = commentLen;
     pNew->comment = taosMemoryCalloc(1, commentLen + 1);
@@ -1386,48 +1410,49 @@ static int32_t mndUpdateStbCommentAndTTL(const SStbObj *pOld, SStbObj *pNew, cha
     pNew->ttl = ttl;
   }
 
-  if (mndAllocStbSchemas(pOld, pNew) != 0) {
-    return -1;
+  if ((code = mndAllocStbSchemas(pOld, pNew)) != 0) {
+    TAOS_RETURN(code);
   }
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndAddSuperTableTag(const SStbObj *pOld, SStbObj *pNew, SArray *pFields, int32_t ntags) {
+  int32_t code = 0;
   if (pOld->numOfTags + ntags > TSDB_MAX_TAGS) {
-    terrno = TSDB_CODE_MND_TOO_MANY_TAGS;
-    return -1;
+    code = TSDB_CODE_MND_TOO_MANY_TAGS;
+    TAOS_RETURN(code);
   }
 
   if (pOld->numOfColumns + ntags + pOld->numOfTags > TSDB_MAX_COLUMNS) {
-    terrno = TSDB_CODE_MND_TOO_MANY_COLUMNS;
-    return -1;
+    code = TSDB_CODE_MND_TOO_MANY_COLUMNS;
+    TAOS_RETURN(code);
   }
 
   if (!mndValidateSchema(pOld->pTags, pOld->numOfTags, pFields, TSDB_MAX_TAGS_LEN)) {
-    terrno = TSDB_CODE_PAR_INVALID_TAGS_LENGTH;
-    return -1;
+    code = TSDB_CODE_PAR_INVALID_TAGS_LENGTH;
+    TAOS_RETURN(code);
   }
 
   pNew->numOfTags = pNew->numOfTags + ntags;
-  if (mndAllocStbSchemas(pOld, pNew) != 0) {
-    return -1;
+  if ((code = mndAllocStbSchemas(pOld, pNew)) != 0) {
+    TAOS_RETURN(code);
   }
 
   if (pNew->nextColId < 0 || pNew->nextColId >= 0x7fff - ntags) {
-    terrno = TSDB_CODE_OUT_OF_RANGE;
-    return -1;
+    code = TSDB_CODE_OUT_OF_RANGE;
+    TAOS_RETURN(code);
   }
 
   for (int32_t i = 0; i < ntags; i++) {
     SField *pField = taosArrayGet(pFields, i);
     if (mndFindSuperTableColumnIndex(pOld, pField->name) >= 0) {
-      terrno = TSDB_CODE_MND_COLUMN_ALREADY_EXIST;
-      return -1;
+      code = TSDB_CODE_MND_COLUMN_ALREADY_EXIST;
+      TAOS_RETURN(code);
     }
 
     if (mndFindSuperTableTagIndex(pOld, pField->name) >= 0) {
-      terrno = TSDB_CODE_MND_TAG_ALREADY_EXIST;
-      return -1;
+      code = TSDB_CODE_MND_TAG_ALREADY_EXIST;
+      TAOS_RETURN(code);
     }
 
     SSchema *pSchema = &pNew->pTags[pOld->numOfTags + i];
@@ -1441,10 +1466,11 @@ static int32_t mndAddSuperTableTag(const SStbObj *pOld, SStbObj *pNew, SArray *p
   }
 
   pNew->tagVer++;
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndCheckAlterColForTopic(SMnode *pMnode, const char *stbFullName, int64_t suid, col_id_t colId) {
+  int32_t code = 0;
   SSdb *pSdb = pMnode->pSdb;
   void *pIter = NULL;
   while (1) {
@@ -1461,11 +1487,11 @@ static int32_t mndCheckAlterColForTopic(SMnode *pMnode, const char *stbFullName,
 
     SNode *pAst = NULL;
     if (nodesStringToNode(pTopic->ast, &pAst) != 0) {
-      terrno = TSDB_CODE_MND_FIELD_CONFLICT_WITH_TOPIC;
+      code = TSDB_CODE_MND_FIELD_CONFLICT_WITH_TOPIC;
       mError("topic:%s, create ast error", pTopic->name);
       sdbRelease(pSdb, pTopic);
       sdbCancelFetch(pSdb, pIter);
-      return -1;
+      TAOS_RETURN(code);
     }
 
     SNodeList *pNodeList = NULL;
@@ -1481,13 +1507,13 @@ static int32_t mndCheckAlterColForTopic(SMnode *pMnode, const char *stbFullName,
         goto NEXT;
       }
       if (pCol->colId > 0 && pCol->colId == colId) {
-        terrno = TSDB_CODE_MND_FIELD_CONFLICT_WITH_TOPIC;
+        code = TSDB_CODE_MND_FIELD_CONFLICT_WITH_TOPIC;
         mError("topic:%s, check colId:%d conflicted", pTopic->name, pCol->colId);
         nodesDestroyNode(pAst);
         nodesDestroyList(pNodeList);
         sdbCancelFetch(pSdb, pIter);
         sdbRelease(pSdb, pTopic);
-        return -1;
+        TAOS_RETURN(code);
       }
       mInfo("topic:%s, check colId:%d passed", pTopic->name, pCol->colId);
     }
@@ -1497,10 +1523,11 @@ static int32_t mndCheckAlterColForTopic(SMnode *pMnode, const char *stbFullName,
     nodesDestroyNode(pAst);
     nodesDestroyList(pNodeList);
   }
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndCheckAlterColForStream(SMnode *pMnode, const char *stbFullName, int64_t suid, col_id_t colId) {
+  int32_t code = 0;
   SSdb *pSdb = pMnode->pSdb;
   void *pIter = NULL;
   while (1) {
@@ -1510,11 +1537,11 @@ static int32_t mndCheckAlterColForStream(SMnode *pMnode, const char *stbFullName
 
     SNode *pAst = NULL;
     if (nodesStringToNode(pStream->ast, &pAst) != 0) {
-      terrno = TSDB_CODE_MND_INVALID_STREAM_OPTION;
+      code = TSDB_CODE_MND_INVALID_STREAM_OPTION;
       mError("stream:%s, create ast error", pStream->name);
       sdbRelease(pSdb, pStream);
       sdbCancelFetch(pSdb, pIter);
-      return -1;
+      TAOS_RETURN(code);
     }
 
     SNodeList *pNodeList = NULL;
@@ -1528,13 +1555,13 @@ static int32_t mndCheckAlterColForStream(SMnode *pMnode, const char *stbFullName
         goto NEXT;
       }
       if (pCol->colId > 0 && pCol->colId == colId) {
-        terrno = TSDB_CODE_MND_STREAM_MUST_BE_DELETED;
+        code = TSDB_CODE_MND_STREAM_MUST_BE_DELETED;
         mError("stream:%s, check colId:%d conflicted", pStream->name, pCol->colId);
         nodesDestroyNode(pAst);
         nodesDestroyList(pNodeList);
         sdbRelease(pSdb, pStream);
         sdbCancelFetch(pSdb, pIter);
-        return -1;
+        TAOS_RETURN(code);
       }
       mInfo("stream:%s, check colId:%d passed", pStream->name, pCol->colId);
     }
@@ -1544,10 +1571,11 @@ static int32_t mndCheckAlterColForStream(SMnode *pMnode, const char *stbFullName
     nodesDestroyNode(pAst);
     nodesDestroyList(pNodeList);
   }
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndCheckAlterColForTSma(SMnode *pMnode, const char *stbFullName, int64_t suid, col_id_t colId) {
+  int32_t code = 0;
   SSdb *pSdb = pMnode->pSdb;
   void *pIter = NULL;
   while (1) {
@@ -1560,11 +1588,11 @@ static int32_t mndCheckAlterColForTSma(SMnode *pMnode, const char *stbFullName,
 
     SNode *pAst = NULL;
     if (nodesStringToNode(pSma->ast, &pAst) != 0) {
-      terrno = TSDB_CODE_SDB_INVALID_DATA_CONTENT;
+      code = TSDB_CODE_SDB_INVALID_DATA_CONTENT;
       mError("tsma:%s, check tag and column modifiable, stb:%s suid:%" PRId64 " colId:%d failed since parse AST err",
              pSma->name, stbFullName, suid, colId);
       sdbCancelFetch(pSdb, pIter);
-      return -1;
+      TAOS_RETURN(code);
     }
 
     SNodeList *pNodeList = NULL;
@@ -1579,13 +1607,13 @@ static int32_t mndCheckAlterColForTSma(SMnode *pMnode, const char *stbFullName,
         goto NEXT;
       }
       if ((pCol->colId) > 0 && (pCol->colId == colId)) {
-        terrno = TSDB_CODE_MND_FIELD_CONFLICT_WITH_TSMA;
+        code = TSDB_CODE_MND_FIELD_CONFLICT_WITH_TSMA;
         mError("tsma:%s, check colId:%d conflicted", pSma->name, pCol->colId);
         nodesDestroyNode(pAst);
         nodesDestroyList(pNodeList);
         sdbRelease(pSdb, pSma);
         sdbCancelFetch(pSdb, pIter);
-        return -1;
+        TAOS_RETURN(code);
       }
       mInfo("tsma:%s, check colId:%d passed", pSma->name, pCol->colId);
     }
@@ -1595,38 +1623,28 @@ static int32_t mndCheckAlterColForTSma(SMnode *pMnode, const char *stbFullName,
     nodesDestroyNode(pAst);
     nodesDestroyList(pNodeList);
   }
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndCheckColAndTagModifiable(SMnode *pMnode, const char *stbFullName, int64_t suid, col_id_t colId) {
-  if (mndCheckAlterColForTopic(pMnode, stbFullName, suid, colId) < 0) {
-    return -1;
-  }
-  if (mndCheckAlterColForStream(pMnode, stbFullName, suid, colId) < 0) {
-    return -1;
-  }
-
-  if (mndCheckAlterColForTSma(pMnode, stbFullName, suid, colId) < 0) {
-    return -1;
-  }
-  return 0;
+  TAOS_CHECK_RETURN(mndCheckAlterColForTopic(pMnode, stbFullName, suid, colId));
+  TAOS_CHECK_RETURN(mndCheckAlterColForStream(pMnode, stbFullName, suid, colId));
+  TAOS_CHECK_RETURN(mndCheckAlterColForTSma(pMnode, stbFullName, suid, colId));
+  TAOS_RETURN(0);
 }
 
 static int32_t mndDropSuperTableTag(SMnode *pMnode, const SStbObj *pOld, SStbObj *pNew, const char *tagName) {
+  int32_t code = 0;
   int32_t tag = mndFindSuperTableTagIndex(pOld, tagName);
   if (tag < 0) {
-    terrno = TSDB_CODE_MND_TAG_NOT_EXIST;
-    return -1;
+    code = TSDB_CODE_MND_TAG_NOT_EXIST;
+    TAOS_RETURN(code);
   }
 
   col_id_t colId = pOld->pTags[tag].colId;
-  if (mndCheckColAndTagModifiable(pMnode, pOld->name, pOld->uid, colId) != 0) {
-    return -1;
-  }
+  TAOS_CHECK_RETURN(mndCheckColAndTagModifiable(pMnode, pOld->name, pOld->uid, colId));
 
-  if (mndAllocStbSchemas(pOld, pNew) != 0) {
-    return -1;
-  }
+  TAOS_CHECK_RETURN(mndAllocStbSchemas(pOld, pNew));
 
   memmove(pNew->pTags + tag, pNew->pTags + tag + 1, sizeof(SSchema) * (pNew->numOfTags - tag - 1));
   pNew->numOfTags--;
@@ -1637,13 +1655,14 @@ static int32_t mndDropSuperTableTag(SMnode *pMnode, const SStbObj *pOld, SStbObj
   //   return -1;
   // }
   mInfo("stb:%s, start to drop tag %s", pNew->name, tagName);
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndAlterStbTagName(SMnode *pMnode, const SStbObj *pOld, SStbObj *pNew, SArray *pFields) {
+  int32_t code = 0;
   if ((int32_t)taosArrayGetSize(pFields) != 2) {
-    terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
-    return -1;
+    code = TSDB_CODE_MND_INVALID_STB_OPTION;
+    TAOS_RETURN(code);
   }
 
   SField *pField0 = taosArrayGet(pFields, 0);
@@ -1654,48 +1673,43 @@ static int32_t mndAlterStbTagName(SMnode *pMnode, const SStbObj *pOld, SStbObj *
 
   int32_t tag = mndFindSuperTableTagIndex(pOld, oldTagName);
   if (tag < 0) {
-    terrno = TSDB_CODE_MND_TAG_NOT_EXIST;
-    return -1;
+    code = TSDB_CODE_MND_TAG_NOT_EXIST;
+    TAOS_RETURN(code);
   }
 
   col_id_t colId = pOld->pTags[tag].colId;
-  if (mndCheckColAndTagModifiable(pMnode, pOld->name, pOld->uid, colId) != 0) {
-    return -1;
-  }
+  TAOS_CHECK_RETURN(mndCheckColAndTagModifiable(pMnode, pOld->name, pOld->uid, colId));
 
   if (mndFindSuperTableTagIndex(pOld, newTagName) >= 0) {
-    terrno = TSDB_CODE_MND_TAG_ALREADY_EXIST;
-    return -1;
+    code = TSDB_CODE_MND_TAG_ALREADY_EXIST;
+    TAOS_RETURN(code);
   }
 
   if (mndFindSuperTableColumnIndex(pOld, newTagName) >= 0) {
-    terrno = TSDB_CODE_MND_COLUMN_ALREADY_EXIST;
-    return -1;
+    code = TSDB_CODE_MND_COLUMN_ALREADY_EXIST;
+    TAOS_RETURN(code);
   }
 
-  if (mndAllocStbSchemas(pOld, pNew) != 0) {
-    return -1;
-  }
+  TAOS_CHECK_RETURN(mndAllocStbSchemas(pOld, pNew));
 
   SSchema *pSchema = (SSchema *)(pNew->pTags + tag);
   memcpy(pSchema->name, newTagName, TSDB_COL_NAME_LEN);
 
   pNew->tagVer++;
   mInfo("stb:%s, start to modify tag %s to %s", pNew->name, oldTagName, newTagName);
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndAlterStbTagBytes(SMnode *pMnode, const SStbObj *pOld, SStbObj *pNew, const SField *pField) {
+  int32_t code = 0;
   int32_t tag = mndFindSuperTableTagIndex(pOld, pField->name);
   if (tag < 0) {
-    terrno = TSDB_CODE_MND_TAG_NOT_EXIST;
-    return -1;
+    code = TSDB_CODE_MND_TAG_NOT_EXIST;
+    TAOS_RETURN(code);
   }
 
   col_id_t colId = pOld->pTags[tag].colId;
-  if (mndCheckColAndTagModifiable(pMnode, pOld->name, pOld->uid, colId) != 0) {
-    return -1;
-  }
+  TAOS_CHECK_RETURN(mndCheckColAndTagModifiable(pMnode, pOld->name, pOld->uid, colId));
 
   uint32_t nLen = 0;
   for (int32_t i = 0; i < pOld->numOfTags; ++i) {
@@ -1703,32 +1717,30 @@ static int32_t mndAlterStbTagBytes(SMnode *pMnode, const SStbObj *pOld, SStbObj
   }
 
   if (nLen > TSDB_MAX_TAGS_LEN) {
-    terrno = TSDB_CODE_PAR_INVALID_TAGS_LENGTH;
-    return -1;
+    code = TSDB_CODE_PAR_INVALID_TAGS_LENGTH;
+    TAOS_RETURN(code);
   }
 
-  if (mndAllocStbSchemas(pOld, pNew) != 0) {
-    return -1;
-  }
+  TAOS_CHECK_RETURN(mndAllocStbSchemas(pOld, pNew));
 
   SSchema *pTag = pNew->pTags + tag;
 
   if (!(pTag->type == TSDB_DATA_TYPE_BINARY || pTag->type == TSDB_DATA_TYPE_VARBINARY ||
         pTag->type == TSDB_DATA_TYPE_NCHAR || pTag->type == TSDB_DATA_TYPE_GEOMETRY)) {
-    terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
-    return -1;
+    code = TSDB_CODE_MND_INVALID_STB_OPTION;
+    TAOS_RETURN(code);
   }
 
   if (pField->bytes <= pTag->bytes) {
-    terrno = TSDB_CODE_MND_INVALID_ROW_BYTES;
-    return -1;
+    code = TSDB_CODE_MND_INVALID_ROW_BYTES;
+    TAOS_RETURN(code);
   }
 
   pTag->bytes = pField->bytes;
   pNew->tagVer++;
 
   mInfo("stb:%s, start to modify tag len %s to %d", pNew->name, pField->name, pField->bytes);
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndUpdateSuperTableColumnCompress(SMnode *pMnode, const SStbObj *pOld, SStbObj *pNew, SArray *pField,
@@ -1741,22 +1753,17 @@ static int32_t mndUpdateSuperTableColumnCompress(SMnode *pMnode, const SStbObj *
   int32_t code = 0;
   int32_t idx = mndFindSuperTableColumnIndex(pOld, p->name);
   if (idx == -1) {
-    terrno = TSDB_CODE_MND_COLUMN_NOT_EXIST;
-    return -1;
+    code = TSDB_CODE_MND_COLUMN_NOT_EXIST;
+    TAOS_RETURN(code);
   }
   SSchema *pTarget = &pOld->pColumns[idx];
   col_id_t colId = pTarget->colId;
-  if (mndCheckColAndTagModifiable(pMnode, pOld->name, pOld->uid, colId) != 0) {
-    return -1;
-  }
+  TAOS_CHECK_RETURN(mndCheckColAndTagModifiable(pMnode, pOld->name, pOld->uid, colId));
 
-  if (mndAllocStbSchemas(pOld, pNew) != 0) {
-    return -1;
-  }
+  TAOS_CHECK_RETURN(mndAllocStbSchemas(pOld, pNew));
   code = validColCmprByType(pTarget->type, p->bytes);
   if (code != TSDB_CODE_SUCCESS) {
-    terrno = code;
-    return code;
+    TAOS_RETURN(code);
   }
 
   int8_t updated = 0;
@@ -1772,55 +1779,54 @@ static int32_t mndUpdateSuperTableColumnCompress(SMnode *pMnode, const SStbObj *
   }
 
   if (updated == 0) {
-    terrno = TSDB_CODE_MND_COLUMN_COMPRESS_ALREADY_EXIST;
-    return -1;
+    code = TSDB_CODE_MND_COLUMN_COMPRESS_ALREADY_EXIST;
+    TAOS_RETURN(code);
   } else if (updated == -1) {
-    terrno = TSDB_CODE_TSC_COMPRESS_LEVEL_ERROR;
-    return -1;
+    code = TSDB_CODE_TSC_COMPRESS_LEVEL_ERROR;
+    TAOS_RETURN(code);
   }
 
   pNew->colVer++;
 
-  return 0;
+  TAOS_RETURN(code);
 }
 static int32_t mndAddSuperTableColumn(const SStbObj *pOld, SStbObj *pNew, SArray *pFields, int32_t ncols,
                                       int8_t withCompress) {
+  int32_t code = 0;
   if (pOld->numOfColumns + ncols + pOld->numOfTags > TSDB_MAX_COLUMNS) {
-    terrno = TSDB_CODE_MND_TOO_MANY_COLUMNS;
-    return -1;
+    code = TSDB_CODE_MND_TOO_MANY_COLUMNS;
+    TAOS_RETURN(code);
   }
 
-  if ((terrno = grantCheck(TSDB_GRANT_TIMESERIES)) != 0) {
-    return -1;
+  if ((code = grantCheck(TSDB_GRANT_TIMESERIES)) != 0) {
+    TAOS_RETURN(code);
   }
 
   if (!mndValidateSchema(pOld->pColumns, pOld->numOfColumns, pFields, TSDB_MAX_BYTES_PER_ROW)) {
-    terrno = TSDB_CODE_PAR_INVALID_ROW_LENGTH;
-    return -1;
+    code = TSDB_CODE_PAR_INVALID_ROW_LENGTH;
+    TAOS_RETURN(code);
   }
 
   pNew->numOfColumns = pNew->numOfColumns + ncols;
 
-  if (mndAllocStbSchemas(pOld, pNew) != 0) {
-    return -1;
-  }
+  TAOS_CHECK_RETURN(mndAllocStbSchemas(pOld, pNew));
 
   if (pNew->nextColId < 0 || pNew->nextColId >= 0x7fff - ncols) {
-    terrno = TSDB_CODE_OUT_OF_RANGE;
-    return -1;
+    code = TSDB_CODE_OUT_OF_RANGE;
+    TAOS_RETURN(code);
   }
 
   for (int32_t i = 0; i < ncols; i++) {
     if (withCompress) {
       SFieldWithOptions *pField = taosArrayGet(pFields, i);
       if (mndFindSuperTableColumnIndex(pOld, pField->name) >= 0) {
-        terrno = TSDB_CODE_MND_COLUMN_ALREADY_EXIST;
-        return -1;
+        code = TSDB_CODE_MND_COLUMN_ALREADY_EXIST;
+        TAOS_RETURN(code);
       }
 
       if (mndFindSuperTableTagIndex(pOld, pField->name) >= 0) {
-        terrno = TSDB_CODE_MND_TAG_ALREADY_EXIST;
-        return -1;
+        code = TSDB_CODE_MND_TAG_ALREADY_EXIST;
+        TAOS_RETURN(code);
       }
 
       SSchema *pSchema = &pNew->pColumns[pOld->numOfColumns + i];
@@ -1837,13 +1843,13 @@ static int32_t mndAddSuperTableColumn(const SStbObj *pOld, SStbObj *pNew, SArray
     } else {
       SField *pField = taosArrayGet(pFields, i);
       if (mndFindSuperTableColumnIndex(pOld, pField->name) >= 0) {
-        terrno = TSDB_CODE_MND_COLUMN_ALREADY_EXIST;
-        return -1;
+        code = TSDB_CODE_MND_COLUMN_ALREADY_EXIST;
+        TAOS_RETURN(code);
       }
 
       if (mndFindSuperTableTagIndex(pOld, pField->name) >= 0) {
-        terrno = TSDB_CODE_MND_TAG_ALREADY_EXIST;
-        return -1;
+        code = TSDB_CODE_MND_TAG_ALREADY_EXIST;
+        TAOS_RETURN(code);
       }
 
       SSchema *pSchema = &pNew->pColumns[pOld->numOfColumns + i];
@@ -1861,34 +1867,31 @@ static int32_t mndAddSuperTableColumn(const SStbObj *pOld, SStbObj *pNew, SArray
   }
 
   pNew->colVer++;
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndDropSuperTableColumn(SMnode *pMnode, const SStbObj *pOld, SStbObj *pNew, const char *colName) {
+  int32_t code = 0;
   int32_t col = mndFindSuperTableColumnIndex(pOld, colName);
   if (col < 0) {
-    terrno = TSDB_CODE_MND_COLUMN_NOT_EXIST;
-    return -1;
+    code = TSDB_CODE_MND_COLUMN_NOT_EXIST;
+    TAOS_RETURN(code);
   }
 
   if (col == 0) {
-    terrno = TSDB_CODE_MND_INVALID_STB_ALTER_OPTION;
-    return -1;
+    code = TSDB_CODE_MND_INVALID_STB_ALTER_OPTION;
+    TAOS_RETURN(code);
   }
 
   if (pOld->numOfColumns == 2) {
-    terrno = TSDB_CODE_MND_INVALID_STB_ALTER_OPTION;
-    return -1;
+    code = TSDB_CODE_MND_INVALID_STB_ALTER_OPTION;
+    TAOS_RETURN(code);
   }
 
   col_id_t colId = pOld->pColumns[col].colId;
-  if (mndCheckColAndTagModifiable(pMnode, pOld->name, pOld->uid, colId) != 0) {
-    return -1;
-  }
+  TAOS_CHECK_RETURN(mndCheckColAndTagModifiable(pMnode, pOld->name, pOld->uid, colId));
 
-  if (mndAllocStbSchemas(pOld, pNew) != 0) {
-    return -1;
-  }
+  TAOS_CHECK_RETURN(mndAllocStbSchemas(pOld, pNew));
 
   int32_t sz = pNew->numOfColumns - col - 1;
   memmove(pNew->pColumns + col, pNew->pColumns + col + 1, sizeof(SSchema) * sz);
@@ -1897,14 +1900,15 @@ static int32_t mndDropSuperTableColumn(SMnode *pMnode, const SStbObj *pOld, SStb
 
   pNew->colVer++;
   mInfo("stb:%s, start to drop col %s", pNew->name, colName);
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndAlterStbColumnBytes(SMnode *pMnode, const SStbObj *pOld, SStbObj *pNew, const SField *pField) {
+  int32_t code = 0;
   int32_t col = mndFindSuperTableColumnIndex(pOld, pField->name);
   if (col < 0) {
-    terrno = TSDB_CODE_MND_COLUMN_NOT_EXIST;
-    return -1;
+    code = TSDB_CODE_MND_COLUMN_NOT_EXIST;
+    TAOS_RETURN(code);
   }
 
   col_id_t colId = pOld->pColumns[col].colId;
@@ -1915,63 +1919,70 @@ static int32_t mndAlterStbColumnBytes(SMnode *pMnode, const SStbObj *pOld, SStbO
   }
 
   if (nLen > TSDB_MAX_BYTES_PER_ROW) {
-    terrno = TSDB_CODE_MND_INVALID_ROW_BYTES;
-    return -1;
+    code = TSDB_CODE_MND_INVALID_ROW_BYTES;
+    TAOS_RETURN(code);
   }
 
-  if (mndCheckColAndTagModifiable(pMnode, pOld->name, pOld->uid, colId) != 0) {
-    return -1;
-  }
+  TAOS_CHECK_RETURN(mndCheckColAndTagModifiable(pMnode, pOld->name, pOld->uid, colId));
 
-  if (mndAllocStbSchemas(pOld, pNew) != 0) {
-    return -1;
-  }
+  TAOS_CHECK_RETURN(mndAllocStbSchemas(pOld, pNew));
 
   SSchema *pCol = pNew->pColumns + col;
   if (!(pCol->type == TSDB_DATA_TYPE_BINARY || pCol->type == TSDB_DATA_TYPE_VARBINARY ||
         pCol->type == TSDB_DATA_TYPE_NCHAR || pCol->type == TSDB_DATA_TYPE_GEOMETRY)) {
-    terrno = TSDB_CODE_MND_INVALID_STB_OPTION;
-    return -1;
+    code = TSDB_CODE_MND_INVALID_STB_OPTION;
+    TAOS_RETURN(code);
   }
 
   if (pField->bytes <= pCol->bytes) {
-    terrno = TSDB_CODE_MND_INVALID_ROW_BYTES;
-    return -1;
+    code = TSDB_CODE_MND_INVALID_ROW_BYTES;
+    TAOS_RETURN(code);
   }
 
   pCol->bytes = pField->bytes;
   pNew->colVer++;
 
   mInfo("stb:%s, start to modify col len %s to %d", pNew->name, pField->name, pField->bytes);
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSetAlterStbPrepareLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb) {
+  int32_t  code = 0;
   SSdbRaw *pRedoRaw = mndStbActionEncode(pStb);
-  if (pRedoRaw == NULL) return -1;
-  if (mndTransAppendPrepareLog(pTrans, pRedoRaw) != 0) {
-    sdbFreeRaw(pRedoRaw);
-    return -1;
+  if (pRedoRaw == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
   }
-  if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY) != 0) return -1;
+  if ((code = mndTransAppendPrepareLog(pTrans, pRedoRaw)) != 0) {
+    sdbFreeRaw(pRedoRaw);
+    TAOS_RETURN(code);
+  }
+  TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY));
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSetAlterStbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb) {
+  int32_t  code = 0;
   SSdbRaw *pCommitRaw = mndStbActionEncode(pStb);
-  if (pCommitRaw == NULL) return -1;
-  if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
-    sdbFreeRaw(pCommitRaw);
-    return -1;
+  if (pCommitRaw == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
   }
-  if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) return -1;
+  if ((code = mndTransAppendCommitlog(pTrans, pCommitRaw)) != 0) {
+    sdbFreeRaw(pCommitRaw);
+    TAOS_RETURN(code);
+  }
+  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY));
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSetAlterStbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb, void *alterOriData,
                                          int32_t alterOriDataLen) {
+  int32_t code = 0;
   SSdb   *pSdb = pMnode->pSdb;
   SVgObj *pVgroup = NULL;
   void   *pIter = NULL;
@@ -1989,27 +2000,30 @@ static int32_t mndSetAlterStbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj
     if (pReq == NULL) {
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pVgroup);
-      return -1;
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
+      TAOS_RETURN(code);
     }
     STransAction action = {0};
     action.epSet = mndGetVgroupEpset(pMnode, pVgroup);
     action.pCont = pReq;
     action.contLen = contLen;
     action.msgType = TDMT_VND_ALTER_STB;
-    if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+    if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {
       taosMemoryFree(pReq);
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pVgroup);
-      return -1;
+      TAOS_RETURN(code);
     }
     sdbRelease(pSdb, pVgroup);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSetAlterStbRedoActions2(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb,
                                           void *alterOriData, int32_t alterOriDataLen) {
+  int32_t code = 0;
   SSdb   *pSdb = pMnode->pSdb;
   SVgObj *pVgroup = NULL;
   void   *pIter = NULL;
@@ -2027,39 +2041,42 @@ static int32_t mndSetAlterStbRedoActions2(SMnode *pMnode, STrans *pTrans, SDbObj
     if (pReq == NULL) {
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pVgroup);
-      return -1;
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
+      TAOS_RETURN(code);
     }
     STransAction action = {0};
     action.epSet = mndGetVgroupEpset(pMnode, pVgroup);
     action.pCont = pReq;
     action.contLen = contLen;
     action.msgType = TDMT_VND_CREATE_INDEX;
-    if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+    if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {
       taosMemoryFree(pReq);
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pVgroup);
-      return -1;
+      TAOS_RETURN(code);
     }
     sdbRelease(pSdb, pVgroup);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 static int32_t mndBuildStbSchemaImp(SDbObj *pDb, SStbObj *pStb, const char *tbName, STableMetaRsp *pRsp) {
+  int32_t code = 0;
   taosRLockLatch(&pStb->lock);
 
   int32_t totalCols = pStb->numOfColumns + pStb->numOfTags;
   pRsp->pSchemas = taosMemoryCalloc(totalCols, sizeof(SSchema));
   if (pRsp->pSchemas == NULL) {
     taosRUnLockLatch(&pStb->lock);
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    TAOS_RETURN(code);
   }
   pRsp->pSchemaExt = taosMemoryCalloc(pStb->numOfColumns, sizeof(SSchemaExt));
   if (pRsp->pSchemaExt == NULL) {
     taosRUnLockLatch(&pStb->lock);
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    TAOS_RETURN(code);
   }
 
   tstrncpy(pRsp->dbFName, pStb->db, sizeof(pRsp->dbFName));
@@ -2102,18 +2119,19 @@ static int32_t mndBuildStbSchemaImp(SDbObj *pDb, SStbObj *pStb, const char *tbNa
   }
 
   taosRUnLockLatch(&pStb->lock);
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndBuildStbCfgImp(SDbObj *pDb, SStbObj *pStb, const char *tbName, STableCfgRsp *pRsp) {
+  int32_t code = 0;
   taosRLockLatch(&pStb->lock);
 
   int32_t totalCols = pStb->numOfColumns + pStb->numOfTags;
   pRsp->pSchemas = taosMemoryCalloc(totalCols, sizeof(SSchema));
   if (pRsp->pSchemas == NULL) {
     taosRUnLockLatch(&pStb->lock);
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    TAOS_RETURN(code);
   }
 
   tstrncpy(pRsp->dbFName, pStb->db, sizeof(pRsp->dbFName));
@@ -2166,30 +2184,31 @@ static int32_t mndBuildStbCfgImp(SDbObj *pDb, SStbObj *pStb, const char *tbName,
   }
 
   taosRUnLockLatch(&pStb->lock);
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndValidateStbVersion(SMnode *pMnode, SSTableVersion *pStbVer, bool *schema, bool *sma) {
+  int32_t code = 0;
   char tbFName[TSDB_TABLE_FNAME_LEN] = {0};
   snprintf(tbFName, sizeof(tbFName), "%s.%s", pStbVer->dbFName, pStbVer->stbName);
 
   SDbObj *pDb = mndAcquireDb(pMnode, pStbVer->dbFName);
   if (pDb == NULL) {
-    terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
-    return -1;
+    code = TSDB_CODE_MND_DB_NOT_SELECTED;
+    TAOS_RETURN(code);
   }
 
   if (pDb->uid != pStbVer->dbId) {
     mndReleaseDb(pMnode, pDb);
-    terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
-    return -1;
+    code = TSDB_CODE_MND_DB_NOT_SELECTED;
+    TAOS_RETURN(code);
   }
 
   SStbObj *pStb = mndAcquireStb(pMnode, tbFName);
   if (pStb == NULL) {
     mndReleaseDb(pMnode, pDb);
-    terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST;
-    return -1;
+    code = TSDB_CODE_PAR_TABLE_NOT_EXIST;
+    TAOS_RETURN(code);
   }
 
   taosRLockLatch(&pStb->lock);
@@ -2214,54 +2233,56 @@ static int32_t mndValidateStbVersion(SMnode *pMnode, SSTableVersion *pStbVer, bo
 }
 
 static int32_t mndBuildStbSchema(SMnode *pMnode, const char *dbFName, const char *tbName, STableMetaRsp *pRsp) {
+  int32_t code = 0;
   char tbFName[TSDB_TABLE_FNAME_LEN] = {0};
   snprintf(tbFName, sizeof(tbFName), "%s.%s", dbFName, tbName);
 
   SDbObj *pDb = mndAcquireDb(pMnode, dbFName);
   if (pDb == NULL) {
-    terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
-    return -1;
+    code = TSDB_CODE_MND_DB_NOT_SELECTED;
+    TAOS_RETURN(code);
   }
 
   SStbObj *pStb = mndAcquireStb(pMnode, tbFName);
   if (pStb == NULL) {
     mndReleaseDb(pMnode, pDb);
-    terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST;
-    return -1;
+    code = TSDB_CODE_PAR_TABLE_NOT_EXIST;
+    TAOS_RETURN(code);
   }
 
-  int32_t code = mndBuildStbSchemaImp(pDb, pStb, tbName, pRsp);
+  code = mndBuildStbSchemaImp(pDb, pStb, tbName, pRsp);
   mndReleaseDb(pMnode, pDb);
   mndReleaseStb(pMnode, pStb);
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndBuildStbCfg(SMnode *pMnode, const char *dbFName, const char *tbName, STableCfgRsp *pRsp) {
+  int32_t code = 0;
   char tbFName[TSDB_TABLE_FNAME_LEN] = {0};
   snprintf(tbFName, sizeof(tbFName), "%s.%s", dbFName, tbName);
 
   SDbObj *pDb = mndAcquireDb(pMnode, dbFName);
   if (pDb == NULL) {
-    terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
-    return -1;
+    code = TSDB_CODE_MND_DB_NOT_SELECTED;
+    TAOS_RETURN(code);
   }
 
   SStbObj *pStb = mndAcquireStb(pMnode, tbFName);
   if (pStb == NULL) {
     mndReleaseDb(pMnode, pDb);
-    terrno = TSDB_CODE_PAR_TABLE_NOT_EXIST;
-    return -1;
+    code = TSDB_CODE_PAR_TABLE_NOT_EXIST;
+    TAOS_RETURN(code);
   }
 
-  int32_t code = mndBuildStbCfgImp(pDb, pStb, tbName, pRsp);
+  code = mndBuildStbCfgImp(pDb, pStb, tbName, pRsp);
 
   mndReleaseDb(pMnode, pDb);
   mndReleaseStb(pMnode, pStb);
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndBuildSMAlterStbRsp(SDbObj *pDb, SStbObj *pObj, void **pCont, int32_t *pLen) {
-  int32_t       ret;
+  int32_t       code = 0;
   SEncoder      ec = {0};
   uint32_t      contLen = 0;
   SMAlterStbRsp alterRsp = {0};
@@ -2270,20 +2291,20 @@ static int32_t mndBuildSMAlterStbRsp(SDbObj *pDb, SStbObj *pObj, void **pCont, i
 
   alterRsp.pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp));
   if (NULL == alterRsp.pMeta) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    TAOS_RETURN(code);
   }
 
-  ret = mndBuildStbSchemaImp(pDb, pObj, name.tname, alterRsp.pMeta);
-  if (ret) {
+  code = mndBuildStbSchemaImp(pDb, pObj, name.tname, alterRsp.pMeta);
+  if (code) {
     tFreeSMAlterStbRsp(&alterRsp);
-    return ret;
+    return code;
   }
 
-  tEncodeSize(tEncodeSMAlterStbRsp, &alterRsp, contLen, ret);
-  if (ret) {
+  tEncodeSize(tEncodeSMAlterStbRsp, &alterRsp, contLen, code);
+  if (code) {
     tFreeSMAlterStbRsp(&alterRsp);
-    return ret;
+    return code;
   }
 
   void *cont = taosMemoryMalloc(contLen);
@@ -2296,18 +2317,22 @@ static int32_t mndBuildSMAlterStbRsp(SDbObj *pDb, SStbObj *pObj, void **pCont, i
   *pCont = cont;
   *pLen = contLen;
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndBuildSMCreateStbRsp(SMnode *pMnode, char *dbFName, char *stbFName, void **pCont, int32_t *pLen) {
-  int32_t ret = -1;
+  int32_t code = -1;
   SDbObj *pDb = mndAcquireDb(pMnode, dbFName);
   if (NULL == pDb) {
-    return -1;
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
   }
 
   SStbObj *pObj = mndAcquireStb(pMnode, stbFName);
   if (NULL == pObj) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
     goto _OVER;
   }
 
@@ -2319,18 +2344,18 @@ int32_t mndBuildSMCreateStbRsp(SMnode *pMnode, char *dbFName, char *stbFName, vo
 
   stbRsp.pMeta = taosMemoryCalloc(1, sizeof(STableMetaRsp));
   if (NULL == stbRsp.pMeta) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    code = TSDB_CODE_OUT_OF_MEMORY;
     goto _OVER;
   }
 
-  ret = mndBuildStbSchemaImp(pDb, pObj, name.tname, stbRsp.pMeta);
-  if (ret) {
+  code = mndBuildStbSchemaImp(pDb, pObj, name.tname, stbRsp.pMeta);
+  if (code) {
     tFreeSMCreateStbRsp(&stbRsp);
     goto _OVER;
   }
 
-  tEncodeSize(tEncodeSMCreateStbRsp, &stbRsp, contLen, ret);
-  if (ret) {
+  tEncodeSize(tEncodeSMCreateStbRsp, &stbRsp, contLen, code);
+  if (code) {
     tFreeSMCreateStbRsp(&stbRsp);
     goto _OVER;
   }
@@ -2345,7 +2370,7 @@ int32_t mndBuildSMCreateStbRsp(SMnode *pMnode, char *dbFName, char *stbFName, vo
   *pCont = cont;
   *pLen = contLen;
 
-  ret = 0;
+  code = 0;
 
 _OVER:
   if (pObj) {
@@ -2356,53 +2381,61 @@ _OVER:
     mndReleaseDb(pMnode, pDb);
   }
 
-  return ret;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndAlterStbImp(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SStbObj *pStb, bool needRsp,
                               void *alterOriData, int32_t alterOriDataLen) {
   int32_t code = -1;
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB_INSIDE, pReq, "alter-stb");
-  if (pTrans == NULL) goto _OVER;
+  if (pTrans == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    goto _OVER;
+  }
 
   mInfo("trans:%d, used to alter stb:%s", pTrans->id, pStb->name);
   mndTransSetDbName(pTrans, pDb->name, pStb->name);
-  if (mndTransCheckConflict(pMnode, pTrans) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER);
 
   if (needRsp) {
     void   *pCont = NULL;
     int32_t contLen = 0;
-    if (mndBuildSMAlterStbRsp(pDb, pStb, &pCont, &contLen) != 0) goto _OVER;
+    TAOS_CHECK_GOTO(mndBuildSMAlterStbRsp(pDb, pStb, &pCont, &contLen), NULL, _OVER);
     mndTransSetRpcRsp(pTrans, pCont, contLen);
   }
 
-  if (mndSetAlterStbPrepareLogs(pMnode, pTrans, pDb, pStb) != 0) goto _OVER;
-  if (mndSetAlterStbCommitLogs(pMnode, pTrans, pDb, pStb) != 0) goto _OVER;
-  if (mndSetAlterStbRedoActions(pMnode, pTrans, pDb, pStb, alterOriData, alterOriDataLen) != 0) goto _OVER;
-  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndSetAlterStbPrepareLogs(pMnode, pTrans, pDb, pStb), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndSetAlterStbCommitLogs(pMnode, pTrans, pDb, pStb), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndSetAlterStbRedoActions(pMnode, pTrans, pDb, pStb, alterOriData, alterOriDataLen), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
 
   code = 0;
 
 _OVER:
   mndTransDrop(pTrans);
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndAlterStbAndUpdateTagIdxImp(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SStbObj *pStb, bool needRsp,
                                              void *alterOriData, int32_t alterOriDataLen, const SMAlterStbReq *pAlter) {
   int32_t code = -1;
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB_INSIDE, pReq, "alter-stb");
-  if (pTrans == NULL) goto _OVER;
+  if (pTrans == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    goto _OVER;
+  }
 
   mInfo("trans:%d, used to alter stb:%s", pTrans->id, pStb->name);
   mndTransSetDbName(pTrans, pDb->name, pStb->name);
 
-  if (mndTransCheckConflict(pMnode, pTrans) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER);
 
   if (needRsp) {
     void   *pCont = NULL;
     int32_t contLen = 0;
-    if (mndBuildSMAlterStbRsp(pDb, pStb, &pCont, &contLen) != 0) goto _OVER;
+    TAOS_CHECK_GOTO(mndBuildSMAlterStbRsp(pDb, pStb, &pCont, &contLen), NULL, _OVER);
     mndTransSetRpcRsp(pTrans, pCont, contLen);
   }
 
@@ -2413,16 +2446,16 @@ static int32_t mndAlterStbAndUpdateTagIdxImp(SMnode *pMnode, SRpcMsg *pReq, SDbO
     if (mndGetIdxsByTagName(pMnode, pStb, pField0->name, &idxObj) == 0) {
       exist = true;
     }
-    if (mndSetAlterStbPrepareLogs(pMnode, pTrans, pDb, pStb) != 0) goto _OVER;
-    if (mndSetAlterStbCommitLogs(pMnode, pTrans, pDb, pStb) != 0) goto _OVER;
+    TAOS_CHECK_GOTO(mndSetAlterStbPrepareLogs(pMnode, pTrans, pDb, pStb), NULL, _OVER);
+    TAOS_CHECK_GOTO(mndSetAlterStbCommitLogs(pMnode, pTrans, pDb, pStb), NULL, _OVER);
 
     if (exist == true) {
-      if (mndSetDropIdxPrepareLogs(pMnode, pTrans, &idxObj) != 0) goto _OVER;
-      if (mndSetDropIdxCommitLogs(pMnode, pTrans, &idxObj) != 0) goto _OVER;
+      TAOS_CHECK_GOTO(mndSetDropIdxPrepareLogs(pMnode, pTrans, &idxObj), NULL, _OVER);
+      TAOS_CHECK_GOTO(mndSetDropIdxCommitLogs(pMnode, pTrans, &idxObj), NULL, _OVER);
     }
 
-    if (mndSetAlterStbRedoActions(pMnode, pTrans, pDb, pStb, alterOriData, alterOriDataLen) != 0) goto _OVER;
-    if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+    TAOS_CHECK_GOTO(mndSetAlterStbRedoActions(pMnode, pTrans, pDb, pStb, alterOriData, alterOriDataLen), NULL, _OVER);
+    TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
 
   } else if (pAlter->alterType == TSDB_ALTER_TABLE_UPDATE_TAG_NAME) {
     SIdxObj     idxObj = {0};
@@ -2436,24 +2469,24 @@ static int32_t mndAlterStbAndUpdateTagIdxImp(SMnode *pMnode, SRpcMsg *pReq, SDbO
       exist = true;
     }
 
-    if (mndSetAlterStbPrepareLogs(pMnode, pTrans, pDb, pStb) != 0) goto _OVER;
-    if (mndSetAlterStbCommitLogs(pMnode, pTrans, pDb, pStb) != 0) goto _OVER;
+    TAOS_CHECK_GOTO(mndSetAlterStbPrepareLogs(pMnode, pTrans, pDb, pStb), NULL, _OVER);
+    TAOS_CHECK_GOTO(mndSetAlterStbCommitLogs(pMnode, pTrans, pDb, pStb), NULL, _OVER);
 
     if (exist == true) {
       memcpy(idxObj.colName, nTagName, strlen(nTagName));
       idxObj.colName[strlen(nTagName)] = 0;
-      if (mndSetAlterIdxPrepareLogs(pMnode, pTrans, &idxObj) != 0) goto _OVER;
-      if (mndSetAlterIdxCommitLogs(pMnode, pTrans, &idxObj) != 0) goto _OVER;
+      TAOS_CHECK_GOTO(mndSetAlterIdxPrepareLogs(pMnode, pTrans, &idxObj), NULL, _OVER);
+      TAOS_CHECK_GOTO(mndSetAlterIdxCommitLogs(pMnode, pTrans, &idxObj), NULL, _OVER);
     }
 
-    if (mndSetAlterStbRedoActions(pMnode, pTrans, pDb, pStb, alterOriData, alterOriDataLen) != 0) goto _OVER;
-    if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+    TAOS_CHECK_GOTO(mndSetAlterStbRedoActions(pMnode, pTrans, pDb, pStb, alterOriData, alterOriDataLen), NULL, _OVER);
+    TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
   }
   code = 0;
 
 _OVER:
   mndTransDrop(pTrans);
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndAlterStb(SMnode *pMnode, SRpcMsg *pReq, const SMAlterStbReq *pAlter, SDbObj *pDb, SStbObj *pOld) {
@@ -2530,7 +2563,7 @@ _OVER:
   if (pAlter->commentLen > 0) {
     taosMemoryFreeClear(stbObj.comment);
   }
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndProcessAlterStbReq(SRpcMsg *pReq) {
@@ -2541,7 +2574,7 @@ static int32_t mndProcessAlterStbReq(SRpcMsg *pReq) {
   SMAlterStbReq alterReq = {0};
 
   if (tDeserializeSMAlterStbReq(pReq->pCont, pReq->contLen, &alterReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
+    code = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
 
@@ -2550,17 +2583,17 @@ static int32_t mndProcessAlterStbReq(SRpcMsg *pReq) {
 
   pDb = mndAcquireDbByStb(pMnode, alterReq.name);
   if (pDb == NULL) {
-    terrno = TSDB_CODE_MND_DB_NOT_EXIST;
+    code = TSDB_CODE_MND_DB_NOT_EXIST;
     goto _OVER;
   }
 
   pStb = mndAcquireStb(pMnode, alterReq.name);
   if (pStb == NULL) {
-    terrno = TSDB_CODE_MND_STB_NOT_EXIST;
+    code = TSDB_CODE_MND_STB_NOT_EXIST;
     goto _OVER;
   }
 
-  if (mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_WRITE_DB, pDb) != 0) {
+  if ((code = mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_WRITE_DB, pDb)) != 0) {
     goto _OVER;
   }
 
@@ -2581,34 +2614,45 @@ _OVER:
   mndReleaseDb(pMnode, pDb);
   tFreeSMAltertbReq(&alterReq);
 
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSetDropStbPrepareLogs(SMnode *pMnode, STrans *pTrans, SStbObj *pStb) {
+  int32_t  code = 0;
   SSdbRaw *pRedoRaw = mndStbActionEncode(pStb);
-  if (pRedoRaw == NULL) return -1;
-  if (mndTransAppendPrepareLog(pTrans, pRedoRaw) != 0) {
-    sdbFreeRaw(pRedoRaw);
-    return -1;
+  if (pRedoRaw == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
   }
-  if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING) != 0) return -1;
+  if ((code = mndTransAppendPrepareLog(pTrans, pRedoRaw)) != 0) {
+    sdbFreeRaw(pRedoRaw);
+    TAOS_RETURN(code);
+  }
+  TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING));
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSetDropStbCommitLogs(SMnode *pMnode, STrans *pTrans, SStbObj *pStb) {
+  int32_t  code = 0;
   SSdbRaw *pCommitRaw = mndStbActionEncode(pStb);
-  if (pCommitRaw == NULL) return -1;
+  if (pCommitRaw == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
   if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
     sdbFreeRaw(pCommitRaw);
-    return -1;
+    TAOS_RETURN(code);
   }
-  if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED) != 0) return -1;
+  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSetDropStbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *pStb) {
+  int32_t code = 0;
   SSdb   *pSdb = pMnode->pSdb;
   SVgObj *pVgroup = NULL;
   void   *pIter = NULL;
@@ -2626,8 +2670,8 @@ static int32_t mndSetDropStbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *
     if (pReq == NULL) {
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pVgroup);
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
-      return -1;
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      TAOS_RETURN(code);
     }
 
     STransAction action = {0};
@@ -2636,42 +2680,47 @@ static int32_t mndSetDropStbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *
     action.contLen = contLen;
     action.msgType = TDMT_VND_DROP_STB;
     action.acceptableCode = TSDB_CODE_TDB_STB_NOT_EXIST;
-    if (mndTransAppendRedoAction(pTrans, &action) != 0) {
+    if ((code = mndTransAppendRedoAction(pTrans, &action)) != 0) {
       taosMemoryFree(pReq);
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pVgroup);
-      return -1;
+      TAOS_RETURN(code);
     }
     sdbRelease(pSdb, pVgroup);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndDropStb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SStbObj *pStb) {
   int32_t code = -1;
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB_INSIDE, pReq, "drop-stb");
-  if (pTrans == NULL) goto _OVER;
+  if (pTrans == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    goto _OVER;
+  }
 
   mInfo("trans:%d, used to drop stb:%s", pTrans->id, pStb->name);
   mndTransSetDbName(pTrans, pDb->name, pStb->name);
-  if (mndTransCheckConflict(pMnode, pTrans) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER);
 
-  if (mndSetDropStbPrepareLogs(pMnode, pTrans, pStb) != 0) goto _OVER;
-  if (mndSetDropStbCommitLogs(pMnode, pTrans, pStb) != 0) goto _OVER;
-  if (mndSetDropStbRedoActions(pMnode, pTrans, pDb, pStb) != 0) goto _OVER;
-  if (mndDropIdxsByStb(pMnode, pTrans, pDb, pStb) != 0) goto _OVER;
-  if (mndDropSmasByStb(pMnode, pTrans, pDb, pStb) != 0) goto _OVER;
-  if (mndUserRemoveStb(pMnode, pTrans, pStb->name) != 0) goto _OVER;
-  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndSetDropStbPrepareLogs(pMnode, pTrans, pStb), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndSetDropStbCommitLogs(pMnode, pTrans, pStb), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndSetDropStbRedoActions(pMnode, pTrans, pDb, pStb), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndDropIdxsByStb(pMnode, pTrans, pDb, pStb), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndDropSmasByStb(pMnode, pTrans, pDb, pStb), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndUserRemoveStb(pMnode, pTrans, pStb->name), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
   code = 0;
 
 _OVER:
   mndTransDrop(pTrans);
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndCheckDropStbForTopic(SMnode *pMnode, const char *stbFullName, int64_t suid) {
+  int32_t code = 0;
   SSdb *pSdb = pMnode->pSdb;
   void *pIter = NULL;
   while (1) {
@@ -2683,7 +2732,7 @@ static int32_t mndCheckDropStbForTopic(SMnode *pMnode, const char *stbFullName,
       if (pTopic->stbUid == suid) {
         sdbRelease(pSdb, pTopic);
         sdbCancelFetch(pSdb, pIter);
-        return -1;
+        TAOS_RETURN(-1);
       }
     }
 
@@ -2694,11 +2743,11 @@ static int32_t mndCheckDropStbForTopic(SMnode *pMnode, const char *stbFullName,
 
     SNode *pAst = NULL;
     if (nodesStringToNode(pTopic->ast, &pAst) != 0) {
-      terrno = TSDB_CODE_MND_INVALID_TOPIC_OPTION;
+      code = TSDB_CODE_MND_INVALID_TOPIC_OPTION;
       mError("topic:%s, create ast error", pTopic->name);
       sdbRelease(pSdb, pTopic);
       sdbCancelFetch(pSdb, pIter);
-      return -1;
+      TAOS_RETURN(code);
     }
 
     SNodeList *pNodeList = NULL;
@@ -2712,7 +2761,7 @@ static int32_t mndCheckDropStbForTopic(SMnode *pMnode, const char *stbFullName,
         nodesDestroyNode(pAst);
         nodesDestroyList(pNodeList);
         sdbCancelFetch(pSdb, pIter);
-        return -1;
+        TAOS_RETURN(-1);
       } else {
         goto NEXT;
       }
@@ -2722,10 +2771,11 @@ static int32_t mndCheckDropStbForTopic(SMnode *pMnode, const char *stbFullName,
     nodesDestroyNode(pAst);
     nodesDestroyList(pNodeList);
   }
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndCheckDropStbForStream(SMnode *pMnode, const char *stbFullName, int64_t suid) {
+  int32_t code = 0;
   SSdb *pSdb = pMnode->pSdb;
   void *pIter = NULL;
   while (1) {
@@ -2736,16 +2786,16 @@ static int32_t mndCheckDropStbForStream(SMnode *pMnode, const char *stbFullName,
     if (pStream->targetStbUid == suid) {
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pStream);
-      return -1;
+      TAOS_RETURN(-1);
     }
 
     SNode *pAst = NULL;
     if (nodesStringToNode(pStream->ast, &pAst) != 0) {
-      terrno = TSDB_CODE_MND_INVALID_STREAM_OPTION;
+      code = TSDB_CODE_MND_INVALID_STREAM_OPTION;
       mError("stream:%s, create ast error", pStream->name);
       sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pStream);
-      return -1;
+      TAOS_RETURN(code);
     }
 
     SNodeList *pNodeList = NULL;
@@ -2759,7 +2809,7 @@ static int32_t mndCheckDropStbForStream(SMnode *pMnode, const char *stbFullName,
         sdbRelease(pSdb, pStream);
         nodesDestroyNode(pAst);
         nodesDestroyList(pNodeList);
-        return -1;
+        TAOS_RETURN(-1);
       } else {
         goto NEXT;
       }
@@ -2769,7 +2819,7 @@ static int32_t mndCheckDropStbForStream(SMnode *pMnode, const char *stbFullName,
     nodesDestroyNode(pAst);
     nodesDestroyList(pNodeList);
   }
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndProcessDropTtltbRsp(SRpcMsg *pRsp) { return 0; }
@@ -2783,10 +2833,7 @@ static int32_t mndProcessDropStbReq(SRpcMsg *pReq) {
   SStbObj     *pStb = NULL;
   SMDropStbReq dropReq = {0};
 
-  if (tDeserializeSMDropStbReq(pReq->pCont, pReq->contLen, &dropReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
-    goto _OVER;
-  }
+  TAOS_CHECK_GOTO(tDeserializeSMDropStbReq(pReq->pCont, pReq->contLen, &dropReq), NULL, _OVER);
 
   mInfo("stb:%s, start to drop", dropReq.name);
 
@@ -2797,7 +2844,7 @@ static int32_t mndProcessDropStbReq(SRpcMsg *pReq) {
       code = 0;
       goto _OVER;
     } else {
-      terrno = TSDB_CODE_MND_STB_NOT_EXIST;
+      code = TSDB_CODE_MND_STB_NOT_EXIST;
       goto _OVER;
     }
   }
@@ -2809,21 +2856,21 @@ static int32_t mndProcessDropStbReq(SRpcMsg *pReq) {
 
   pDb = mndAcquireDbByStb(pMnode, dropReq.name);
   if (pDb == NULL) {
-    terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
+    code = TSDB_CODE_MND_DB_NOT_SELECTED;
     goto _OVER;
   }
 
-  if (mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_WRITE_DB, pDb) != 0) {
+  if ((code = mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_WRITE_DB, pDb)) != 0) {
     goto _OVER;
   }
 
   if (mndCheckDropStbForTopic(pMnode, dropReq.name, pStb->uid) < 0) {
-    terrno = TSDB_CODE_MND_TOPIC_MUST_BE_DELETED;
+    code = TSDB_CODE_MND_TOPIC_MUST_BE_DELETED;
     goto _OVER;
   }
 
   if (mndCheckDropStbForStream(pMnode, dropReq.name, pStb->uid) < 0) {
-    terrno = TSDB_CODE_MND_STREAM_MUST_BE_DELETED;
+    code = TSDB_CODE_MND_STREAM_MUST_BE_DELETED;
     goto _OVER;
   }
 
@@ -2843,7 +2890,7 @@ _OVER:
   mndReleaseDb(pMnode, pDb);
   mndReleaseStb(pMnode, pStb);
   tFreeSMDropStbReq(&dropReq);
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndProcessTableMetaReq(SRpcMsg *pReq) {
@@ -2853,40 +2900,35 @@ static int32_t mndProcessTableMetaReq(SRpcMsg *pReq) {
   STableMetaRsp metaRsp = {0};
 
   SUserObj *pUser = mndAcquireUser(pMnode, pReq->info.conn.user);
-  if (pUser == NULL) return 0;
+  if (pUser == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
   bool sysinfo = pUser->sysInfo;
 
-  if (tDeserializeSTableInfoReq(pReq->pCont, pReq->contLen, &infoReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
-    goto _OVER;
-  }
+  TAOS_CHECK_GOTO(tDeserializeSTableInfoReq(pReq->pCont, pReq->contLen, &infoReq), NULL, _OVER);
 
   if (0 == strcmp(infoReq.dbFName, TSDB_INFORMATION_SCHEMA_DB)) {
     mInfo("information_schema table:%s.%s, start to retrieve meta", infoReq.dbFName, infoReq.tbName);
-    if (mndBuildInsTableSchema(pMnode, infoReq.dbFName, infoReq.tbName, sysinfo, &metaRsp) != 0) {
-      goto _OVER;
-    }
+    TAOS_CHECK_GOTO(mndBuildInsTableSchema(pMnode, infoReq.dbFName, infoReq.tbName, sysinfo, &metaRsp), NULL, _OVER);
   } else if (0 == strcmp(infoReq.dbFName, TSDB_PERFORMANCE_SCHEMA_DB)) {
     mInfo("performance_schema table:%s.%s, start to retrieve meta", infoReq.dbFName, infoReq.tbName);
-    if (mndBuildPerfsTableSchema(pMnode, infoReq.dbFName, infoReq.tbName, &metaRsp) != 0) {
-      goto _OVER;
-    }
+    TAOS_CHECK_GOTO(mndBuildPerfsTableSchema(pMnode, infoReq.dbFName, infoReq.tbName, &metaRsp), NULL, _OVER);
   } else {
     mInfo("stb:%s.%s, start to retrieve meta", infoReq.dbFName, infoReq.tbName);
-    if (mndBuildStbSchema(pMnode, infoReq.dbFName, infoReq.tbName, &metaRsp) != 0) {
-      goto _OVER;
-    }
+    TAOS_CHECK_GOTO(mndBuildStbSchema(pMnode, infoReq.dbFName, infoReq.tbName, &metaRsp), NULL, _OVER);
   }
 
   int32_t rspLen = tSerializeSTableMetaRsp(NULL, 0, &metaRsp);
   if (rspLen < 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
+    code = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
 
   void *pRsp = rpcMallocCont(rspLen);
   if (pRsp == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    code = TSDB_CODE_OUT_OF_MEMORY;
     goto _OVER;
   }
 
@@ -2904,7 +2946,7 @@ _OVER:
 
   mndReleaseUser(pMnode, pUser);
   tFreeSTableMetaRsp(&metaRsp);
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndProcessTableCfgReq(SRpcMsg *pReq) {
@@ -2913,39 +2955,30 @@ static int32_t mndProcessTableCfgReq(SRpcMsg *pReq) {
   STableCfgReq cfgReq = {0};
   STableCfgRsp cfgRsp = {0};
 
-  if (tDeserializeSTableCfgReq(pReq->pCont, pReq->contLen, &cfgReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
-    goto _OVER;
-  }
+  TAOS_CHECK_GOTO(tDeserializeSTableCfgReq(pReq->pCont, pReq->contLen, &cfgReq), NULL, _OVER);
 
   char dbName[TSDB_DB_NAME_LEN] = {0};
   mndExtractShortDbNameFromDbFullName(cfgReq.dbFName, dbName);
   if (0 == strcmp(dbName, TSDB_INFORMATION_SCHEMA_DB)) {
     mInfo("information_schema table:%s.%s, start to retrieve cfg", cfgReq.dbFName, cfgReq.tbName);
-    if (mndBuildInsTableCfg(pMnode, cfgReq.dbFName, cfgReq.tbName, &cfgRsp) != 0) {
-      goto _OVER;
-    }
+    TAOS_CHECK_GOTO(mndBuildInsTableCfg(pMnode, cfgReq.dbFName, cfgReq.tbName, &cfgRsp), NULL, _OVER);
   } else if (0 == strcmp(dbName, TSDB_PERFORMANCE_SCHEMA_DB)) {
     mInfo("performance_schema table:%s.%s, start to retrieve cfg", cfgReq.dbFName, cfgReq.tbName);
-    if (mndBuildPerfsTableCfg(pMnode, cfgReq.dbFName, cfgReq.tbName, &cfgRsp) != 0) {
-      goto _OVER;
-    }
+    TAOS_CHECK_GOTO(mndBuildPerfsTableCfg(pMnode, cfgReq.dbFName, cfgReq.tbName, &cfgRsp), NULL, _OVER);
   } else {
     mInfo("stb:%s.%s, start to retrieve cfg", cfgReq.dbFName, cfgReq.tbName);
-    if (mndBuildStbCfg(pMnode, cfgReq.dbFName, cfgReq.tbName, &cfgRsp) != 0) {
-      goto _OVER;
-    }
+    TAOS_CHECK_GOTO(mndBuildStbCfg(pMnode, cfgReq.dbFName, cfgReq.tbName, &cfgRsp), NULL, _OVER);
   }
 
   int32_t rspLen = tSerializeSTableCfgRsp(NULL, 0, &cfgRsp);
   if (rspLen < 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
+    code = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
 
   void *pRsp = rpcMallocCont(rspLen);
   if (pRsp == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    code = TSDB_CODE_OUT_OF_MEMORY;
     goto _OVER;
   }
 
@@ -2962,23 +2995,24 @@ _OVER:
   }
 
   tFreeSTableCfgRsp(&cfgRsp);
-  return code;
+  TAOS_RETURN(code);
 }
 
 int32_t mndValidateStbInfo(SMnode *pMnode, SSTableVersion *pStbVersions, int32_t numOfStbs, void **ppRsp,
                            int32_t *pRspLen) {
+  int32_t   code = 0;
   SSTbHbRsp hbRsp = {0};
   hbRsp.pMetaRsp = taosArrayInit(numOfStbs, sizeof(STableMetaRsp));
   if (hbRsp.pMetaRsp == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    TAOS_RETURN(code);
   }
 
   hbRsp.pIndexRsp = taosArrayInit(numOfStbs, sizeof(STableIndexRsp));
   if (NULL == hbRsp.pIndexRsp) {
     taosArrayDestroy(hbRsp.pMetaRsp);
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    TAOS_RETURN(code);
   }
 
   for (int32_t i = 0; i < numOfStbs; ++i) {
@@ -3024,8 +3058,8 @@ int32_t mndValidateStbInfo(SMnode *pMnode, SSTableVersion *pStbVersions, int32_t
       STableIndexRsp indexRsp = {0};
       indexRsp.pIndex = taosArrayInit(10, sizeof(STableIndexInfo));
       if (NULL == indexRsp.pIndex) {
-        terrno = TSDB_CODE_OUT_OF_MEMORY;
-        return -1;
+        code = TSDB_CODE_OUT_OF_MEMORY;
+        TAOS_RETURN(code);
       }
 
       sprintf(tbFName, "%s.%s", pStbVersion->dbFName, pStbVersion->stbName);
@@ -3046,30 +3080,31 @@ int32_t mndValidateStbInfo(SMnode *pMnode, SSTableVersion *pStbVersions, int32_t
   int32_t rspLen = tSerializeSSTbHbRsp(NULL, 0, &hbRsp);
   if (rspLen < 0) {
     tFreeSSTbHbRsp(&hbRsp);
-    terrno = TSDB_CODE_INVALID_MSG;
-    return -1;
+    code = TSDB_CODE_INVALID_MSG;
+    TAOS_RETURN(code);
   }
 
   void *pRsp = taosMemoryMalloc(rspLen);
   if (pRsp == NULL) {
     tFreeSSTbHbRsp(&hbRsp);
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    TAOS_RETURN(code);
   }
 
   tSerializeSSTbHbRsp(pRsp, rspLen, &hbRsp);
   tFreeSSTbHbRsp(&hbRsp);
   *ppRsp = pRsp;
   *pRspLen = rspLen;
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndGetNumOfStbs(SMnode *pMnode, char *dbName, int32_t *pNumOfStbs) {
+  int32_t code = 0;
   SSdb   *pSdb = pMnode->pSdb;
   SDbObj *pDb = mndAcquireDb(pMnode, dbName);
   if (pDb == NULL) {
-    terrno = TSDB_CODE_MND_DB_NOT_SELECTED;
-    return -1;
+    code = TSDB_CODE_MND_DB_NOT_SELECTED;
+    TAOS_RETURN(code);
   }
 
   int32_t numOfStbs = 0;
@@ -3088,7 +3123,7 @@ int32_t mndGetNumOfStbs(SMnode *pMnode, char *dbName, int32_t *pNumOfStbs) {
 
   *pNumOfStbs = numOfStbs;
   mndReleaseDb(pMnode, pDb);
-  return 0;
+  TAOS_RETURN(code);
 }
 
 void mndExtractDbNameFromStbFullName(const char *stbFullName, char *dst) {
@@ -4046,29 +4081,40 @@ static int32_t mndSetDropTbsRedoActions(SMnode *pMnode, STrans *pTrans, const SV
 }
 
 static int32_t mndCreateDropTbsTxnPrepare(SRpcMsg *pRsp, SMndDropTbsWithTsmaCtx *pCtx) {
+  int32_t code = 0;
   SMnode *pMnode = pRsp->info.node;
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_GLOBAL, pRsp, "drop-tbs");
   mndTransSetChangeless(pTrans);
-  if (pTrans == NULL) goto _OVER;
+  if (pTrans == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    goto _OVER;
+  }
 
-  if (mndTransCheckConflict(pMnode, pTrans) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER);
 
   void *pIter = taosHashIterate(pCtx->pVgMap, NULL);
   while (pIter) {
     const SVDropTbVgReqs *pVgReqs = pIter;
     int32_t               len = 0;
     void                 *p = mndBuildVDropTbsReq(pMnode, &pVgReqs->info, &pVgReqs->req, &len);
-    if (!p || mndSetDropTbsRedoActions(pMnode, pTrans, pVgReqs, p, len) != 0) {
+    if (!p) {
+      taosHashCancelIterate(pCtx->pVgMap, pIter);
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
+      goto _OVER;
+    }
+    if ((code = mndSetDropTbsRedoActions(pMnode, pTrans, pVgReqs, p, len)) != 0) {
       taosHashCancelIterate(pCtx->pVgMap, pIter);
       goto _OVER;
     }
     pIter = taosHashIterate(pCtx->pVgMap, pIter);
   }
-  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+  if ((code = mndTransPrepare(pMnode, pTrans)) != 0) goto _OVER;
 
 _OVER:
   mndTransDrop(pTrans);
-  return terrno;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndProcessDropTbWithTsma(SRpcMsg *pReq) {
@@ -4079,23 +4125,23 @@ static int32_t mndProcessDropTbWithTsma(SRpcMsg *pReq) {
   SMDropTbsReq dropReq = {0};
   bool         locked = false;
   if (tDeserializeSMDropTbsReq(pReq->pCont, pReq->contLen, &dropReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
+    code = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
 
   SMndDropTbsWithTsmaCtx *pCtx = NULL;
-  terrno = mndInitDropTbsWithTsmaCtx(&pCtx);
-  if (terrno) goto _OVER;
+  code = mndInitDropTbsWithTsmaCtx(&pCtx);
+  if (code) goto _OVER;
   for (int32_t i = 0; i < dropReq.pVgReqs->size; ++i) {
     SMDropTbReqsOnSingleVg *pReq = taosArrayGet(dropReq.pVgReqs, i);
-    terrno = mndDropTbAddTsmaResTbsForSingleVg(pMnode, pCtx, pReq->pTbs, pReq->vgInfo.vgId);
-    if (terrno) goto _OVER;
+    code = mndDropTbAddTsmaResTbsForSingleVg(pMnode, pCtx, pReq->pTbs, pReq->vgInfo.vgId);
+    if (code) goto _OVER;
   }
   if (mndCreateDropTbsTxnPrepare(pReq, pCtx) == 0) code = 0;
 _OVER:
   tFreeSMDropTbsReq(&dropReq);
   if (pCtx) mndDestroyDropTbsWithTsmaCtx(pCtx);
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndDropTbAdd(SMnode *pMnode, SHashObj *pVgHashMap, const SVgroupInfo *pVgInfo, char *name, tb_uid_t suid,
@@ -4140,7 +4186,7 @@ _end:
     taosArrayDestroy(pInfo->dbInfo.dbVgInfos);
     pInfo->dbInfo.dbVgInfos = NULL;
   }
-  return code;
+  TAOS_RETURN(code);
 }
 
 int32_t vgHashValCmp(const void *lp, const void *rp) {
@@ -4249,7 +4295,7 @@ static int32_t mndProcessFetchTtlExpiredTbs(SRpcMsg *pRsp) {
   SVFetchTtlExpiredTbsRsp rsp = {0};
   SMndDropTbsWithTsmaCtx *pCtx = NULL;
   if (pRsp->code != TSDB_CODE_SUCCESS) {
-    terrno = pRsp->code;
+    code = pRsp->code;
     goto _end;
   }
   if (pRsp->contLen == 0) {
@@ -4258,18 +4304,18 @@ static int32_t mndProcessFetchTtlExpiredTbs(SRpcMsg *pRsp) {
   }
 
   tDecoderInit(&decoder, pRsp->pCont, pRsp->contLen);
-  terrno = tDecodeVFetchTtlExpiredTbsRsp(&decoder, &rsp);
-  if (terrno) goto _end;
+  code = tDecodeVFetchTtlExpiredTbsRsp(&decoder, &rsp);
+  if (code) goto _end;
 
-  terrno = mndInitDropTbsWithTsmaCtx(&pCtx);
-  if (terrno) goto _end;
+  code = mndInitDropTbsWithTsmaCtx(&pCtx);
+  if (code) goto _end;
 
-  terrno = mndDropTbAddTsmaResTbsForSingleVg(pMnode, pCtx, rsp.pExpiredTbs, rsp.vgId);
-  if (terrno) goto _end;
+  code = mndDropTbAddTsmaResTbsForSingleVg(pMnode, pCtx, rsp.pExpiredTbs, rsp.vgId);
+  if (code) goto _end;
   if (mndCreateDropTbsTxnPrepare(pRsp, pCtx) == 0) code = 0;
 _end:
   if (pCtx) mndDestroyDropTbsWithTsmaCtx(pCtx);
   tDecoderClear(&decoder);
   tFreeFetchTtlExpiredTbsRsp(&rsp);
-  return code;
+  TAOS_RETURN(code);
 }