diff --git a/source/client/src/clientEnv.c b/source/client/src/clientEnv.c
index 18907ede5d..7d737fbb8e 100644
--- a/source/client/src/clientEnv.c
+++ b/source/client/src/clientEnv.c
@@ -885,7 +885,11 @@ void taos_init_imp(void) {
   taosSetCoreDump(true);
 #endif
 
-  initTaskQueue();
+  if (initTaskQueue() != 0){
+    tscInitRes = -1;
+    tscError("failed to init task queue");
+    return;
+  }
   fmFuncMgtInit();
   nodesInitAllocatorSet();
 
diff --git a/source/client/src/clientRawBlockWrite.c b/source/client/src/clientRawBlockWrite.c
index 2fabf01ef4..9e1ff6e5e5 100644
--- a/source/client/src/clientRawBlockWrite.c
+++ b/source/client/src/clientRawBlockWrite.c
@@ -460,8 +460,14 @@ static void buildChildElement(cJSON* json, SVCreateTbReq* pCreateReq) {
       } else {
         buf = taosMemoryCalloc(pTagVal->nData + 3, 1);
       }
+
       RAW_NULL_CHECK(buf);
-      RAW_RETURN_CHECK(dataConverToStr(buf, pTagVal->type, pTagVal->pData, pTagVal->nData, NULL));
+      if (!buf) goto end;
+      if(dataConverToStr(buf, pTagVal->type, pTagVal->pData, pTagVal->nData, NULL) != TSDB_CODE_SUCCESS) {
+        taosMemoryFree(buf);
+        goto end;
+      }
+
       tvalue = cJSON_CreateString(buf);
       RAW_NULL_CHECK(tvalue);
       taosMemoryFree(buf);
@@ -729,7 +735,10 @@ static void processAlterTable(SMqMetaRsp* metaRsp, cJSON** pJson) {
             buf = taosMemoryCalloc(vAlterTbReq.nTagVal + 3, 1);
           }
           RAW_NULL_CHECK(buf);
-          RAW_RETURN_CHECK(dataConverToStr(buf, vAlterTbReq.tagType, vAlterTbReq.pTagVal, vAlterTbReq.nTagVal, NULL));
+          if(dataConverToStr(buf, vAlterTbReq.tagType, vAlterTbReq.pTagVal, vAlterTbReq.nTagVal, NULL) != TSDB_CODE_SUCCESS) {
+            taosMemoryFree(buf);
+            goto end;
+          }
         }
 
         cJSON* colValue = cJSON_CreateString(buf);
diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c
index 8432855c6f..1e3fe909ae 100644
--- a/source/dnode/mnode/impl/src/mndDb.c
+++ b/source/dnode/mnode/impl/src/mndDb.c
@@ -290,14 +290,24 @@ static int32_t mndNewDbActionValidate(SMnode *pMnode, STrans *pTrans, SSdbRaw *p
   int      code = -1;
 
   pRow = mndDbActionDecode(pRaw);
-  if (pRow == NULL) goto _OVER;
+  if (pRow == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    goto _OVER;
+  }
   pNewDb = sdbGetRowObj(pRow);
-  if (pNewDb == NULL) goto _OVER;
+  if (pNewDb == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    goto _OVER;
+  }
 
   SDbObj *pOldDb = sdbAcquire(pMnode->pSdb, SDB_DB, pNewDb->name);
   if (pOldDb != NULL) {
     mError("trans:%d, db name already in use. name: %s", pTrans->id, pNewDb->name);
     sdbRelease(pMnode->pSdb, pOldDb);
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
     goto _OVER;
   }
 
@@ -387,143 +397,141 @@ void mndReleaseDb(SMnode *pMnode, SDbObj *pDb) {
 static int32_t mndCheckDbName(const char *dbName, SUserObj *pUser) {
   char *pos = strstr(dbName, TS_PATH_DELIMITER);
   if (pos == NULL) {
-    terrno = TSDB_CODE_MND_INVALID_DB;
-    return -1;
+    return TSDB_CODE_MND_INVALID_DB;
   }
 
   int32_t acctId = atoi(dbName);
   if (acctId != pUser->acctId) {
-    terrno = TSDB_CODE_MND_INVALID_DB_ACCT;
-    return -1;
+    return TSDB_CODE_MND_INVALID_DB_ACCT;
   }
 
   return 0;
 }
 
 static int32_t mndCheckDbCfg(SMnode *pMnode, SDbCfg *pCfg) {
-  terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
+  int32_t code = TSDB_CODE_MND_INVALID_DB_OPTION;
 
-  if (pCfg->numOfVgroups < TSDB_MIN_VNODES_PER_DB || pCfg->numOfVgroups > TSDB_MAX_VNODES_PER_DB) return -1;
-  if (pCfg->numOfStables < TSDB_DB_STREAM_MODE_OFF || pCfg->numOfStables > TSDB_DB_STREAM_MODE_ON) return -1;
-  if (pCfg->buffer < TSDB_MIN_BUFFER_PER_VNODE || pCfg->buffer > TSDB_MAX_BUFFER_PER_VNODE) return -1;
-  if (pCfg->pageSize < TSDB_MIN_PAGESIZE_PER_VNODE || pCfg->pageSize > TSDB_MAX_PAGESIZE_PER_VNODE) return -1;
-  if (pCfg->pages < TSDB_MIN_PAGES_PER_VNODE || pCfg->pages > TSDB_MAX_PAGES_PER_VNODE) return -1;
-  if (pCfg->cacheLastSize < TSDB_MIN_DB_CACHE_SIZE || pCfg->cacheLastSize > TSDB_MAX_DB_CACHE_SIZE) return -1;
-  if (pCfg->daysPerFile < TSDB_MIN_DAYS_PER_FILE || pCfg->daysPerFile > TSDB_MAX_DAYS_PER_FILE) return -1;
-  if (pCfg->daysToKeep0 < TSDB_MIN_KEEP || pCfg->daysToKeep0 > TSDB_MAX_KEEP) return -1;
-  if (pCfg->daysToKeep1 < TSDB_MIN_KEEP || pCfg->daysToKeep1 > TSDB_MAX_KEEP) return -1;
-  if (pCfg->daysToKeep2 < TSDB_MIN_KEEP || pCfg->daysToKeep2 > TSDB_MAX_KEEP) return -1;
-  if (pCfg->daysToKeep0 < pCfg->daysPerFile) return -1;
-  if (pCfg->daysToKeep0 > pCfg->daysToKeep1) return -1;
-  if (pCfg->daysToKeep1 > pCfg->daysToKeep2) return -1;
-  if (pCfg->keepTimeOffset < TSDB_MIN_KEEP_TIME_OFFSET || pCfg->keepTimeOffset > TSDB_MAX_KEEP_TIME_OFFSET) return -1;
-  if (pCfg->minRows < TSDB_MIN_MINROWS_FBLOCK || pCfg->minRows > TSDB_MAX_MINROWS_FBLOCK) return -1;
-  if (pCfg->maxRows < TSDB_MIN_MAXROWS_FBLOCK || pCfg->maxRows > TSDB_MAX_MAXROWS_FBLOCK) return -1;
-  if (pCfg->minRows > pCfg->maxRows) return -1;
-  if (pCfg->walFsyncPeriod < TSDB_MIN_FSYNC_PERIOD || pCfg->walFsyncPeriod > TSDB_MAX_FSYNC_PERIOD) return -1;
-  if (pCfg->walLevel < TSDB_MIN_WAL_LEVEL || pCfg->walLevel > TSDB_MAX_WAL_LEVEL) return -1;
-  if (pCfg->precision < TSDB_MIN_PRECISION && pCfg->precision > TSDB_MAX_PRECISION) return -1;
-  if (pCfg->compression < TSDB_MIN_COMP_LEVEL || pCfg->compression > TSDB_MAX_COMP_LEVEL) return -1;
-  if (pCfg->replications < TSDB_MIN_DB_REPLICA || pCfg->replications > TSDB_MAX_DB_REPLICA) return -1;
+  if (pCfg->numOfVgroups < TSDB_MIN_VNODES_PER_DB || pCfg->numOfVgroups > TSDB_MAX_VNODES_PER_DB) return code;
+  if (pCfg->numOfStables < TSDB_DB_STREAM_MODE_OFF || pCfg->numOfStables > TSDB_DB_STREAM_MODE_ON) return code;
+  if (pCfg->buffer < TSDB_MIN_BUFFER_PER_VNODE || pCfg->buffer > TSDB_MAX_BUFFER_PER_VNODE) return code;
+  if (pCfg->pageSize < TSDB_MIN_PAGESIZE_PER_VNODE || pCfg->pageSize > TSDB_MAX_PAGESIZE_PER_VNODE) return code;
+  if (pCfg->pages < TSDB_MIN_PAGES_PER_VNODE || pCfg->pages > TSDB_MAX_PAGES_PER_VNODE) return code;
+  if (pCfg->cacheLastSize < TSDB_MIN_DB_CACHE_SIZE || pCfg->cacheLastSize > TSDB_MAX_DB_CACHE_SIZE) return code;
+  if (pCfg->daysPerFile < TSDB_MIN_DAYS_PER_FILE || pCfg->daysPerFile > TSDB_MAX_DAYS_PER_FILE) return code;
+  if (pCfg->daysToKeep0 < TSDB_MIN_KEEP || pCfg->daysToKeep0 > TSDB_MAX_KEEP) return code;
+  if (pCfg->daysToKeep1 < TSDB_MIN_KEEP || pCfg->daysToKeep1 > TSDB_MAX_KEEP) return code;
+  if (pCfg->daysToKeep2 < TSDB_MIN_KEEP || pCfg->daysToKeep2 > TSDB_MAX_KEEP) return code;
+  if (pCfg->daysToKeep0 < pCfg->daysPerFile) return code;
+  if (pCfg->daysToKeep0 > pCfg->daysToKeep1) return code;
+  if (pCfg->daysToKeep1 > pCfg->daysToKeep2) return code;
+  if (pCfg->keepTimeOffset < TSDB_MIN_KEEP_TIME_OFFSET || pCfg->keepTimeOffset > TSDB_MAX_KEEP_TIME_OFFSET) return code;
+  if (pCfg->minRows < TSDB_MIN_MINROWS_FBLOCK || pCfg->minRows > TSDB_MAX_MINROWS_FBLOCK) return code;
+  if (pCfg->maxRows < TSDB_MIN_MAXROWS_FBLOCK || pCfg->maxRows > TSDB_MAX_MAXROWS_FBLOCK) return code;
+  if (pCfg->minRows > pCfg->maxRows) return code;
+  if (pCfg->walFsyncPeriod < TSDB_MIN_FSYNC_PERIOD || pCfg->walFsyncPeriod > TSDB_MAX_FSYNC_PERIOD) return code;
+  if (pCfg->walLevel < TSDB_MIN_WAL_LEVEL || pCfg->walLevel > TSDB_MAX_WAL_LEVEL) return code;
+  if (pCfg->precision < TSDB_MIN_PRECISION && pCfg->precision > TSDB_MAX_PRECISION) return code;
+  if (pCfg->compression < TSDB_MIN_COMP_LEVEL || pCfg->compression > TSDB_MAX_COMP_LEVEL) return code;
+  if (pCfg->replications < TSDB_MIN_DB_REPLICA || pCfg->replications > TSDB_MAX_DB_REPLICA) return code;
 #ifdef TD_ENTERPRISE
-  if ((pCfg->replications == 2) ^ (pCfg->withArbitrator == TSDB_MAX_DB_WITH_ARBITRATOR)) return -1;
-  if (pCfg->encryptAlgorithm < TSDB_MIN_ENCRYPT_ALGO || pCfg->encryptAlgorithm > TSDB_MAX_ENCRYPT_ALGO) return -1;
+  if ((pCfg->replications == 2) ^ (pCfg->withArbitrator == TSDB_MAX_DB_WITH_ARBITRATOR)) return code;
+  if (pCfg->encryptAlgorithm < TSDB_MIN_ENCRYPT_ALGO || pCfg->encryptAlgorithm > TSDB_MAX_ENCRYPT_ALGO) return code;
 #else
-  if (pCfg->replications != 1 && pCfg->replications != 3) return -1;
-  if (pCfg->encryptAlgorithm != TSDB_DEFAULT_ENCRYPT_ALGO) return -1;
+  if (pCfg->replications != 1 && pCfg->replications != 3) return code;
+  if (pCfg->encryptAlgorithm != TSDB_DEFAULT_ENCRYPT_ALGO) return code;
 #endif
 
-  if (pCfg->strict < TSDB_DB_STRICT_OFF || pCfg->strict > TSDB_DB_STRICT_ON) return -1;
-  if (pCfg->schemaless < TSDB_DB_SCHEMALESS_OFF || pCfg->schemaless > TSDB_DB_SCHEMALESS_ON) return -1;
-  if (pCfg->cacheLast < TSDB_CACHE_MODEL_NONE || pCfg->cacheLast > TSDB_CACHE_MODEL_BOTH) return -1;
-  if (pCfg->hashMethod != 1) return -1;
+  if (pCfg->strict < TSDB_DB_STRICT_OFF || pCfg->strict > TSDB_DB_STRICT_ON) return code;
+  if (pCfg->schemaless < TSDB_DB_SCHEMALESS_OFF || pCfg->schemaless > TSDB_DB_SCHEMALESS_ON) return code;
+  if (pCfg->cacheLast < TSDB_CACHE_MODEL_NONE || pCfg->cacheLast > TSDB_CACHE_MODEL_BOTH) return code;
+  if (pCfg->hashMethod != 1) return code;
   if (pCfg->replications > mndGetDnodeSize(pMnode)) {
     terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;
-    return -1;
+    return code;
   }
-  if (pCfg->walRetentionPeriod < TSDB_DB_MIN_WAL_RETENTION_PERIOD) return -1;
-  if (pCfg->walRetentionSize < TSDB_DB_MIN_WAL_RETENTION_SIZE) return -1;
-  if (pCfg->walRollPeriod < TSDB_DB_MIN_WAL_ROLL_PERIOD) return -1;
-  if (pCfg->walSegmentSize < TSDB_DB_MIN_WAL_SEGMENT_SIZE) return -1;
-  if (pCfg->sstTrigger < TSDB_MIN_STT_TRIGGER || pCfg->sstTrigger > TSDB_MAX_STT_TRIGGER) return -1;
-  if (pCfg->hashPrefix < TSDB_MIN_HASH_PREFIX || pCfg->hashPrefix > TSDB_MAX_HASH_PREFIX) return -1;
-  if (pCfg->hashSuffix < TSDB_MIN_HASH_SUFFIX || pCfg->hashSuffix > TSDB_MAX_HASH_SUFFIX) return -1;
-  if ((pCfg->hashSuffix * pCfg->hashPrefix) < 0) return -1;
-  if ((pCfg->hashPrefix + pCfg->hashSuffix) >= (TSDB_TABLE_NAME_LEN - 1)) return -1;
-  if (pCfg->tsdbPageSize < TSDB_MIN_TSDB_PAGESIZE || pCfg->tsdbPageSize > TSDB_MAX_TSDB_PAGESIZE) return -1;
-  if (taosArrayGetSize(pCfg->pRetensions) != pCfg->numOfRetensions) return -1;
+  if (pCfg->walRetentionPeriod < TSDB_DB_MIN_WAL_RETENTION_PERIOD) return code;
+  if (pCfg->walRetentionSize < TSDB_DB_MIN_WAL_RETENTION_SIZE) return code;
+  if (pCfg->walRollPeriod < TSDB_DB_MIN_WAL_ROLL_PERIOD) return code;
+  if (pCfg->walSegmentSize < TSDB_DB_MIN_WAL_SEGMENT_SIZE) return code;
+  if (pCfg->sstTrigger < TSDB_MIN_STT_TRIGGER || pCfg->sstTrigger > TSDB_MAX_STT_TRIGGER) return code;
+  if (pCfg->hashPrefix < TSDB_MIN_HASH_PREFIX || pCfg->hashPrefix > TSDB_MAX_HASH_PREFIX) return code;
+  if (pCfg->hashSuffix < TSDB_MIN_HASH_SUFFIX || pCfg->hashSuffix > TSDB_MAX_HASH_SUFFIX) return code;
+  if ((pCfg->hashSuffix * pCfg->hashPrefix) < 0) return code;
+  if ((pCfg->hashPrefix + pCfg->hashSuffix) >= (TSDB_TABLE_NAME_LEN - 1)) return code;
+  if (pCfg->tsdbPageSize < TSDB_MIN_TSDB_PAGESIZE || pCfg->tsdbPageSize > TSDB_MAX_TSDB_PAGESIZE) return code;
+  if (taosArrayGetSize(pCfg->pRetensions) != pCfg->numOfRetensions) return code;
 
-  if (pCfg->s3ChunkSize < TSDB_MIN_S3_CHUNK_SIZE || pCfg->s3ChunkSize > TSDB_MAX_S3_CHUNK_SIZE) return -1;
-  if (pCfg->s3KeepLocal < TSDB_MIN_S3_KEEP_LOCAL || pCfg->s3KeepLocal > TSDB_MAX_S3_KEEP_LOCAL) return -1;
-  if (pCfg->s3Compact < TSDB_MIN_S3_COMPACT || pCfg->s3Compact > TSDB_MAX_S3_COMPACT) return -1;
+  if (pCfg->s3ChunkSize < TSDB_MIN_S3_CHUNK_SIZE || pCfg->s3ChunkSize > TSDB_MAX_S3_CHUNK_SIZE) return code;
+  if (pCfg->s3KeepLocal < TSDB_MIN_S3_KEEP_LOCAL || pCfg->s3KeepLocal > TSDB_MAX_S3_KEEP_LOCAL) return code;
+  if (pCfg->s3Compact < TSDB_MIN_S3_COMPACT || pCfg->s3Compact > TSDB_MAX_S3_COMPACT) return code;
 
-  terrno = 0;
-  return terrno;
+  code = 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndCheckInChangeDbCfg(SMnode *pMnode, SDbCfg *pOldCfg, SDbCfg *pNewCfg) {
-  terrno = TSDB_CODE_MND_INVALID_DB_OPTION;
-  if (pNewCfg->buffer < TSDB_MIN_BUFFER_PER_VNODE || pNewCfg->buffer > TSDB_MAX_BUFFER_PER_VNODE) return -1;
-  if (pNewCfg->pages < TSDB_MIN_PAGES_PER_VNODE || pNewCfg->pages > TSDB_MAX_PAGES_PER_VNODE) return -1;
-  if (pNewCfg->pageSize < TSDB_MIN_PAGESIZE_PER_VNODE || pNewCfg->pageSize > TSDB_MAX_PAGESIZE_PER_VNODE) return -1;
-  if (pNewCfg->daysPerFile < TSDB_MIN_DAYS_PER_FILE || pNewCfg->daysPerFile > TSDB_MAX_DAYS_PER_FILE) return -1;
-  if (pNewCfg->daysToKeep0 < TSDB_MIN_KEEP || pNewCfg->daysToKeep0 > TSDB_MAX_KEEP) return -1;
-  if (pNewCfg->daysToKeep1 < TSDB_MIN_KEEP || pNewCfg->daysToKeep1 > TSDB_MAX_KEEP) return -1;
-  if (pNewCfg->daysToKeep2 < TSDB_MIN_KEEP || pNewCfg->daysToKeep2 > TSDB_MAX_KEEP) return -1;
-  if (pNewCfg->daysToKeep0 < pNewCfg->daysPerFile) return -1;
-  if (pNewCfg->daysToKeep0 > pNewCfg->daysToKeep1) return -1;
-  if (pNewCfg->daysToKeep1 > pNewCfg->daysToKeep2) return -1;
+  int32_t code = TSDB_CODE_MND_INVALID_DB_OPTION;
+  if (pNewCfg->buffer < TSDB_MIN_BUFFER_PER_VNODE || pNewCfg->buffer > TSDB_MAX_BUFFER_PER_VNODE) return code;
+  if (pNewCfg->pages < TSDB_MIN_PAGES_PER_VNODE || pNewCfg->pages > TSDB_MAX_PAGES_PER_VNODE) return code;
+  if (pNewCfg->pageSize < TSDB_MIN_PAGESIZE_PER_VNODE || pNewCfg->pageSize > TSDB_MAX_PAGESIZE_PER_VNODE) return code;
+  if (pNewCfg->daysPerFile < TSDB_MIN_DAYS_PER_FILE || pNewCfg->daysPerFile > TSDB_MAX_DAYS_PER_FILE) return code;
+  if (pNewCfg->daysToKeep0 < TSDB_MIN_KEEP || pNewCfg->daysToKeep0 > TSDB_MAX_KEEP) return code;
+  if (pNewCfg->daysToKeep1 < TSDB_MIN_KEEP || pNewCfg->daysToKeep1 > TSDB_MAX_KEEP) return code;
+  if (pNewCfg->daysToKeep2 < TSDB_MIN_KEEP || pNewCfg->daysToKeep2 > TSDB_MAX_KEEP) return code;
+  if (pNewCfg->daysToKeep0 < pNewCfg->daysPerFile) return code;
+  if (pNewCfg->daysToKeep0 > pNewCfg->daysToKeep1) return code;
+  if (pNewCfg->daysToKeep1 > pNewCfg->daysToKeep2) return code;
   if (pNewCfg->keepTimeOffset < TSDB_MIN_KEEP_TIME_OFFSET || pNewCfg->keepTimeOffset > TSDB_MAX_KEEP_TIME_OFFSET)
-    return -1;
-  if (pNewCfg->walFsyncPeriod < TSDB_MIN_FSYNC_PERIOD || pNewCfg->walFsyncPeriod > TSDB_MAX_FSYNC_PERIOD) return -1;
-  if (pNewCfg->walLevel < TSDB_MIN_WAL_LEVEL || pNewCfg->walLevel > TSDB_MAX_WAL_LEVEL) return -1;
-  if (pNewCfg->cacheLast < TSDB_CACHE_MODEL_NONE || pNewCfg->cacheLast > TSDB_CACHE_MODEL_BOTH) return -1;
-  if (pNewCfg->cacheLastSize < TSDB_MIN_DB_CACHE_SIZE || pNewCfg->cacheLastSize > TSDB_MAX_DB_CACHE_SIZE) return -1;
-  if (pNewCfg->replications < TSDB_MIN_DB_REPLICA || pNewCfg->replications > TSDB_MAX_DB_REPLICA) return -1;
+    return code;
+  if (pNewCfg->walFsyncPeriod < TSDB_MIN_FSYNC_PERIOD || pNewCfg->walFsyncPeriod > TSDB_MAX_FSYNC_PERIOD) return code;
+  if (pNewCfg->walLevel < TSDB_MIN_WAL_LEVEL || pNewCfg->walLevel > TSDB_MAX_WAL_LEVEL) return code;
+  if (pNewCfg->cacheLast < TSDB_CACHE_MODEL_NONE || pNewCfg->cacheLast > TSDB_CACHE_MODEL_BOTH) return code;
+  if (pNewCfg->cacheLastSize < TSDB_MIN_DB_CACHE_SIZE || pNewCfg->cacheLastSize > TSDB_MAX_DB_CACHE_SIZE) return code;
+  if (pNewCfg->replications < TSDB_MIN_DB_REPLICA || pNewCfg->replications > TSDB_MAX_DB_REPLICA) return code;
 #ifdef TD_ENTERPRISE
-  if ((pNewCfg->replications == 2) ^ (pNewCfg->withArbitrator == TSDB_MAX_DB_WITH_ARBITRATOR)) return -1;
+  if ((pNewCfg->replications == 2) ^ (pNewCfg->withArbitrator == TSDB_MAX_DB_WITH_ARBITRATOR)) return code;
   if (pNewCfg->replications == 2 && pNewCfg->withArbitrator == TSDB_MAX_DB_WITH_ARBITRATOR) {
     if (pOldCfg->replications != 1 && pOldCfg->replications != 2) {
       terrno = TSDB_CODE_OPS_NOT_SUPPORT;
-      return -1;
+      return code;
     }
   }
   if (pNewCfg->replications != 2 && pOldCfg->replications == 2) {
     terrno = TSDB_CODE_OPS_NOT_SUPPORT;
-    return -1;
+    return code;
   }
 #else
-  if (pNewCfg->replications != 1 && pNewCfg->replications != 3) return -1;
+  if (pNewCfg->replications != 1 && pNewCfg->replications != 3) return code;
 #endif
 
   if (pNewCfg->walLevel == 0 && pOldCfg->replications > 1) {
     terrno = TSDB_CODE_MND_INVALID_WAL_LEVEL;
-    return -1;
+    return code;
   }
   if (pNewCfg->replications > 1 && pOldCfg->walLevel == 0) {
     terrno = TSDB_CODE_MND_INVALID_WAL_LEVEL;
-    return -1;
+    return code;
   }
 
   if (pNewCfg->sstTrigger != pOldCfg->sstTrigger &&
       (pNewCfg->sstTrigger < TSDB_MIN_STT_TRIGGER || pNewCfg->sstTrigger > TSDB_MAX_STT_TRIGGER))
-    return -1;
-  if (pNewCfg->minRows < TSDB_MIN_MINROWS_FBLOCK || pNewCfg->minRows > TSDB_MAX_MINROWS_FBLOCK) return -1;
-  if (pNewCfg->maxRows < TSDB_MIN_MAXROWS_FBLOCK || pNewCfg->maxRows > TSDB_MAX_MAXROWS_FBLOCK) return -1;
-  if (pNewCfg->minRows > pNewCfg->maxRows) return -1;
-  if (pNewCfg->walRetentionPeriod < TSDB_DB_MIN_WAL_RETENTION_PERIOD) return -1;
-  if (pNewCfg->walRetentionSize < TSDB_DB_MIN_WAL_RETENTION_SIZE) return -1;
-  if (pNewCfg->strict < TSDB_DB_STRICT_OFF || pNewCfg->strict > TSDB_DB_STRICT_ON) return -1;
+    return code;
+  if (pNewCfg->minRows < TSDB_MIN_MINROWS_FBLOCK || pNewCfg->minRows > TSDB_MAX_MINROWS_FBLOCK) return code;
+  if (pNewCfg->maxRows < TSDB_MIN_MAXROWS_FBLOCK || pNewCfg->maxRows > TSDB_MAX_MAXROWS_FBLOCK) return code;
+  if (pNewCfg->minRows > pNewCfg->maxRows) return code;
+  if (pNewCfg->walRetentionPeriod < TSDB_DB_MIN_WAL_RETENTION_PERIOD) return code;
+  if (pNewCfg->walRetentionSize < TSDB_DB_MIN_WAL_RETENTION_SIZE) return code;
+  if (pNewCfg->strict < TSDB_DB_STRICT_OFF || pNewCfg->strict > TSDB_DB_STRICT_ON) return code;
   if (pNewCfg->replications > mndGetDnodeSize(pMnode)) {
     terrno = TSDB_CODE_MND_NO_ENOUGH_DNODES;
-    return -1;
+    return code;
   }
-  if (pNewCfg->s3ChunkSize < TSDB_MIN_S3_CHUNK_SIZE || pNewCfg->s3ChunkSize > TSDB_MAX_S3_CHUNK_SIZE) return -1;
-  if (pNewCfg->s3KeepLocal < TSDB_MIN_S3_KEEP_LOCAL || pNewCfg->s3KeepLocal > TSDB_MAX_S3_KEEP_LOCAL) return -1;
-  if (pNewCfg->s3Compact < TSDB_MIN_S3_COMPACT || pNewCfg->s3Compact > TSDB_MAX_S3_COMPACT) return -1;
+  if (pNewCfg->s3ChunkSize < TSDB_MIN_S3_CHUNK_SIZE || pNewCfg->s3ChunkSize > TSDB_MAX_S3_CHUNK_SIZE) return code;
+  if (pNewCfg->s3KeepLocal < TSDB_MIN_S3_KEEP_LOCAL || pNewCfg->s3KeepLocal > TSDB_MAX_S3_KEEP_LOCAL) return code;
+  if (pNewCfg->s3Compact < TSDB_MIN_S3_COMPACT || pNewCfg->s3Compact > TSDB_MAX_S3_COMPACT) return code;
 
-  terrno = 0;
-  return terrno;
+  code = 0;
+  TAOS_RETURN(code);
 }
 
 static void mndSetDefaultDbCfg(SDbCfg *pCfg) {
@@ -581,16 +589,25 @@ static int32_t mndSetNewVgPrepareActions(SMnode *pMnode, STrans *pTrans, SDbObj
 }
 
 static int32_t mndSetCreateDbRedoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups) {
+  int32_t  code = 0;
   SSdbRaw *pDbRaw = mndDbActionEncode(pDb);
-  if (pDbRaw == NULL) return -1;
-  if (mndTransAppendRedolog(pTrans, pDbRaw) != 0) return -1;
-  if (sdbSetRawStatus(pDbRaw, SDB_STATUS_UPDATE) != 0) return -1;
+  if (pDbRaw == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
+  TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pDbRaw));
+  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_UPDATE));
 
   for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {
     SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);
-    if (pVgRaw == NULL) return -1;
-    if (mndTransAppendRedolog(pTrans, pVgRaw) != 0) return -1;
-    if (sdbSetRawStatus(pVgRaw, SDB_STATUS_UPDATE) != 0) return -1;
+    if (pVgRaw == NULL) {
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
+      TAOS_RETURN(code);
+    }
+    TAOS_CHECK_RETURN(mndTransAppendRedolog(pTrans, pVgRaw));
+    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_UPDATE));
   }
 
   if (pDb->cfg.withArbitrator) {
@@ -598,24 +615,33 @@ static int32_t mndSetCreateDbRedoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pD
       SVgObj   *pVgObj = pVgroups + v;
       SArbGroup arbGroup = {0};
       mndArbGroupInitFromVgObj(pVgObj, &arbGroup);
-      if (mndSetCreateArbGroupRedoLogs(pTrans, &arbGroup) != 0) return -1;
+      TAOS_CHECK_RETURN(mndSetCreateArbGroupRedoLogs(pTrans, &arbGroup));
     }
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSetCreateDbUndoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups) {
+  int32_t  code = 0;
   SSdbRaw *pDbRaw = mndDbActionEncode(pDb);
-  if (pDbRaw == NULL) return -1;
-  if (mndTransAppendUndolog(pTrans, pDbRaw) != 0) return -1;
-  if (sdbSetRawStatus(pDbRaw, SDB_STATUS_DROPPED) != 0) return -1;
+  if (pDbRaw == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
+  TAOS_CHECK_RETURN(mndTransAppendUndolog(pTrans, pDbRaw));
+  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_DROPPED));
 
   for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {
     SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);
-    if (pVgRaw == NULL) return -1;
-    if (mndTransAppendUndolog(pTrans, pVgRaw) != 0) return -1;
-    if (sdbSetRawStatus(pVgRaw, SDB_STATUS_DROPPED) != 0) return -1;
+    if (pVgRaw == NULL) {
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
+      TAOS_RETURN(code);
+    }
+    TAOS_CHECK_RETURN(mndTransAppendUndolog(pTrans, pVgRaw));
+    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_DROPPED));
   }
 
   if (pDb->cfg.withArbitrator) {
@@ -623,25 +649,34 @@ static int32_t mndSetCreateDbUndoLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pD
       SVgObj   *pVgObj = pVgroups + v;
       SArbGroup arbGroup = {0};
       mndArbGroupInitFromVgObj(pVgObj, &arbGroup);
-      if (mndSetCreateArbGroupUndoLogs(pTrans, &arbGroup) != 0) return -1;
+      TAOS_CHECK_RETURN(mndSetCreateArbGroupUndoLogs(pTrans, &arbGroup));
     }
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSetCreateDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups,
                                         SUserObj *pUserDuped) {
+  int32_t  code = 0;
   SSdbRaw *pDbRaw = mndDbActionEncode(pDb);
-  if (pDbRaw == NULL) return -1;
-  if (mndTransAppendCommitlog(pTrans, pDbRaw) != 0) return -1;
-  if (sdbSetRawStatus(pDbRaw, SDB_STATUS_READY) != 0) return -1;
+  if (pDbRaw == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
+  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pDbRaw));
+  TAOS_CHECK_RETURN(sdbSetRawStatus(pDbRaw, SDB_STATUS_READY));
 
   for (int32_t v = 0; v < pDb->cfg.numOfVgroups; ++v) {
     SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroups + v);
-    if (pVgRaw == NULL) return -1;
-    if (mndTransAppendCommitlog(pTrans, pVgRaw) != 0) return -1;
-    if (sdbSetRawStatus(pVgRaw, SDB_STATUS_READY) != 0) return -1;
+    if (pVgRaw == NULL) {
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
+      TAOS_RETURN(code);
+    }
+    TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pVgRaw));
+    TAOS_CHECK_RETURN(sdbSetRawStatus(pVgRaw, SDB_STATUS_READY));
   }
 
   if (pDb->cfg.withArbitrator) {
@@ -649,51 +684,54 @@ static int32_t mndSetCreateDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *
       SVgObj   *pVgObj = pVgroups + v;
       SArbGroup arbGroup = {0};
       mndArbGroupInitFromVgObj(pVgObj, &arbGroup);
-      if (mndSetCreateArbGroupCommitLogs(pTrans, &arbGroup) != 0) return -1;
+      TAOS_CHECK_RETURN(mndSetCreateArbGroupCommitLogs(pTrans, &arbGroup));
     }
   }
 
   if (pUserDuped) {
     SSdbRaw *pUserRaw = mndUserActionEncode(pUserDuped);
-    if (pUserRaw == NULL) return -1;
-    if (mndTransAppendCommitlog(pTrans, pUserRaw) != 0) return -1;
-    if (sdbSetRawStatus(pUserRaw, SDB_STATUS_READY) != 0) return -1;
+    if (pUserRaw == NULL) {
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
+      TAOS_RETURN(code);
+    }
+    TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pUserRaw));
+    TAOS_CHECK_RETURN(sdbSetRawStatus(pUserRaw, SDB_STATUS_READY));
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSetCreateDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups) {
+  int32_t code = 0;
   for (int32_t vg = 0; vg < pDb->cfg.numOfVgroups; ++vg) {
     SVgObj *pVgroup = pVgroups + vg;
 
     for (int32_t vn = 0; vn < pVgroup->replica; ++vn) {
       SVnodeGid *pVgid = pVgroup->vnodeGid + vn;
-      if (mndAddCreateVnodeAction(pMnode, pTrans, pDb, pVgroup, pVgid) != 0) {
-        return -1;
-      }
+      TAOS_CHECK_RETURN(mndAddCreateVnodeAction(pMnode, pTrans, pDb, pVgroup, pVgid));
     }
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSetCreateDbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroups) {
+  int32_t code = 0;
   for (int32_t vg = 0; vg < pDb->cfg.numOfVgroups; ++vg) {
     SVgObj *pVgroup = pVgroups + vg;
 
     for (int32_t vn = 0; vn < pVgroup->replica; ++vn) {
       SVnodeGid *pVgid = pVgroup->vnodeGid + vn;
-      if (mndAddDropVnodeAction(pMnode, pTrans, pDb, pVgroup, pVgid, false) != 0) {
-        return -1;
-      }
+      TAOS_CHECK_RETURN(mndAddDropVnodeAction(pMnode, pTrans, pDb, pVgroup, pVgid, false));
     }
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndCreateDb(SMnode *pMnode, SRpcMsg *pReq, SCreateDbReq *pCreate, SUserObj *pUser) {
+  int32_t code = -1;
   SDbObj dbObj = {0};
   memcpy(dbObj.name, pCreate->db, TSDB_DB_FNAME_LEN);
   memcpy(dbObj.acct, pUser->acct, TSDB_USER_LEN);
@@ -747,14 +785,14 @@ static int32_t mndCreateDb(SMnode *pMnode, SRpcMsg *pReq, SCreateDbReq *pCreate,
 
   mndSetDefaultDbCfg(&dbObj.cfg);
 
-  if (mndCheckDbName(dbObj.name, pUser) != 0) {
+  if ((code = mndCheckDbName(dbObj.name, pUser)) != 0) {
     mError("db:%s, failed to create since %s", pCreate->db, terrstr());
-    return -1;
+    TAOS_RETURN(code);
   }
 
-  if (mndCheckDbCfg(pMnode, &dbObj.cfg) != 0) {
+  if ((code = mndCheckDbCfg(pMnode, &dbObj.cfg)) != 0) {
     mError("db:%s, failed to create since %s", pCreate->db, terrstr());
-    return -1;
+    TAOS_RETURN(code);
   }
 
   if (dbObj.cfg.hashPrefix > 0) {
@@ -768,37 +806,40 @@ static int32_t mndCreateDb(SMnode *pMnode, SRpcMsg *pReq, SCreateDbReq *pCreate,
   }
 
   SVgObj *pVgroups = NULL;
-  if (mndAllocVgroup(pMnode, &dbObj, &pVgroups) != 0) {
+  if ((code = mndAllocVgroup(pMnode, &dbObj, &pVgroups)) != 0) {
     mError("db:%s, failed to create since %s", pCreate->db, terrstr());
-    return -1;
+    TAOS_RETURN(code);
   }
 
   // add database privileges for user
   SUserObj newUserObj = {0}, *pNewUserDuped = NULL;
   if (!pUser->superUser) {
-    if (mndUserDupObj(pUser, &newUserObj) != 0) goto _OVER;
+    TAOS_CHECK_GOTO(mndUserDupObj(pUser, &newUserObj), NULL, _OVER);
     taosHashPut(newUserObj.readDbs, dbObj.name, strlen(dbObj.name) + 1, dbObj.name, TSDB_FILENAME_LEN);
     taosHashPut(newUserObj.writeDbs, dbObj.name, strlen(dbObj.name) + 1, dbObj.name, TSDB_FILENAME_LEN);
     pNewUserDuped = &newUserObj;
   }
 
-  int32_t code = -1;
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "create-db");
-  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 create db:%s", pTrans->id, pCreate->db);
 
   mndTransSetDbName(pTrans, dbObj.name, NULL);
-  if (mndTransCheckConflict(pMnode, pTrans) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER);
 
   mndTransSetOper(pTrans, MND_OPER_CREATE_DB);
-  if (mndSetCreateDbPrepareAction(pMnode, pTrans, &dbObj) != 0) goto _OVER;
-  if (mndSetCreateDbRedoActions(pMnode, pTrans, &dbObj, pVgroups) != 0) goto _OVER;
-  if (mndSetNewVgPrepareActions(pMnode, pTrans, &dbObj, pVgroups) != 0) goto _OVER;
-  if (mndSetCreateDbUndoLogs(pMnode, pTrans, &dbObj, pVgroups) != 0) goto _OVER;
-  if (mndSetCreateDbCommitLogs(pMnode, pTrans, &dbObj, pVgroups, pNewUserDuped) != 0) goto _OVER;
-  if (mndSetCreateDbUndoActions(pMnode, pTrans, &dbObj, pVgroups) != 0) goto _OVER;
-  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndSetCreateDbPrepareAction(pMnode, pTrans, &dbObj), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndSetCreateDbRedoActions(pMnode, pTrans, &dbObj, pVgroups), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndSetNewVgPrepareActions(pMnode, pTrans, &dbObj, pVgroups), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndSetCreateDbUndoLogs(pMnode, pTrans, &dbObj, pVgroups), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndSetCreateDbCommitLogs(pMnode, pTrans, &dbObj, pVgroups, pNewUserDuped), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndSetCreateDbUndoActions(pMnode, pTrans, &dbObj, pVgroups), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
 
   code = 0;
 
@@ -806,7 +847,7 @@ _OVER:
   taosMemoryFree(pVgroups);
   mndUserFreeObj(&newUserObj);
   mndTransDrop(pTrans);
-  return code;
+  TAOS_RETURN(code);
 }
 
 static void mndBuildAuditDetailInt32(char *detail, char *tmp, char *format, int32_t para) {
@@ -833,9 +874,7 @@ static int32_t mndCheckDbEncryptKey(SMnode *pMnode, SCreateDbReq *pReq) {
 
 #ifdef TD_ENTERPRISE
   if (pReq->encryptAlgorithm == TSDB_ENCRYPT_ALGO_NONE) goto _exit;
-  if ((code = grantCheck(TSDB_GRANT_DB_ENCRYPTION)) != 0) {
-    goto _exit;
-  }
+  TAOS_CHECK_GOTO(grantCheck(TSDB_GRANT_DB_ENCRYPTION), NULL, _exit);
   if (tsEncryptionKeyStat != ENCRYPT_KEY_STAT_LOADED) {
     code = TSDB_CODE_MND_INVALID_ENCRYPT_KEY;
     mError("db:%s, failed to check encryption key:%" PRIi8 " in mnode leader since it's not loaded", pReq->db,
@@ -853,6 +892,7 @@ static int32_t mndCheckDbEncryptKey(SMnode *pMnode, SCreateDbReq *pReq) {
              "-%u in dnode:%d since it's inconsitent with mnode leader:%" PRIi8 "-%u",
              pReq->db, pDnode->encryptionKeyStat, pDnode->encryptionKeyChksum, pDnode->id, tsEncryptionKeyStat,
              tsEncryptionKeyChksum);
+      sdbCancelFetch(pSdb, pIter);
       sdbRelease(pSdb, pDnode);
       break;
     }
@@ -865,20 +905,18 @@ static int32_t mndCheckDbEncryptKey(SMnode *pMnode, SCreateDbReq *pReq) {
   }
 #endif
 _exit:
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) {
   SMnode      *pMnode = pReq->info.node;
   int32_t      code = -1;
+  int32_t      lino = 0;
   SDbObj      *pDb = NULL;
   SUserObj    *pUser = NULL;
   SCreateDbReq createReq = {0};
 
-  if (tDeserializeSCreateDbReq(pReq->pCont, pReq->contLen, &createReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
-    goto _OVER;
-  }
+  TAOS_CHECK_GOTO(tDeserializeSCreateDbReq(pReq->pCont, pReq->contLen, &createReq), NULL, _OVER);
 #ifdef WINDOWS
   if (taosArrayGetSize(createReq.pRetensions) > 0) {
     terrno = TSDB_CODE_MND_INVALID_PLATFORM;
@@ -894,7 +932,7 @@ static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) {
       code = 0;
       goto _OVER;
     } else {
-      terrno = TSDB_CODE_MND_DB_ALREADY_EXIST;
+      code = TSDB_CODE_MND_DB_ALREADY_EXIST;
       goto _OVER;
     }
   } else {
@@ -910,29 +948,20 @@ static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) {
     }
   }
 
-  if (mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_DB, NULL) != 0) {
-    goto _OVER;
-  }
+  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_DB, NULL), &lino, _OVER);
 
-  if ((terrno = grantCheck(TSDB_GRANT_DB)) != 0) {
-    code = terrno;
-    goto _OVER;
-  }
+  TAOS_CHECK_GOTO(grantCheck(TSDB_GRANT_DB), &lino, _OVER);
 
   if (createReq.replications == 2) {
-    if ((terrno = grantCheck(TSDB_GRANT_DUAL_REPLICA_HA)) != 0) {
-      code = terrno;
-      goto _OVER;
-    }
+    TAOS_CHECK_GOTO(grantCheck(TSDB_GRANT_DUAL_REPLICA_HA), &lino, _OVER);
   }
 
-  if ((code = mndCheckDbEncryptKey(pMnode, &createReq)) != 0) {
-    terrno = code;
-    goto _OVER;
-  }
+  TAOS_CHECK_GOTO(mndCheckDbEncryptKey(pMnode, &createReq), &lino, _OVER);
 
   pUser = mndAcquireUser(pMnode, pReq->info.conn.user);
   if (pUser == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
     goto _OVER;
   }
 
@@ -946,147 +975,152 @@ static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) {
 
 _OVER:
   if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) {
-    mError("db:%s, failed to create since %s", createReq.db, terrstr());
+    mError("db:%s, failed to create at line:%d since %s", createReq.db, lino, tstrerror(code));
   }
 
   mndReleaseDb(pMnode, pDb);
   mndReleaseUser(pMnode, pUser);
   tFreeSCreateDbReq(&createReq);
 
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSetDbCfgFromAlterDbReq(SDbObj *pDb, SAlterDbReq *pAlter) {
-  terrno = TSDB_CODE_MND_DB_OPTION_UNCHANGED;
+  int32_t code = TSDB_CODE_MND_DB_OPTION_UNCHANGED;
 
   if (pAlter->buffer > 0 && pAlter->buffer != pDb->cfg.buffer) {
     pDb->cfg.buffer = pAlter->buffer;
-    terrno = 0;
+    code = 0;
   }
 
   if (pAlter->pages > 0 && pAlter->pages != pDb->cfg.pages) {
     pDb->cfg.pages = pAlter->pages;
-    terrno = 0;
+    code = 0;
   }
 
   if (pAlter->pageSize > 0 && pAlter->pageSize != pDb->cfg.pageSize) {
     pDb->cfg.pageSize = pAlter->pageSize;
-    terrno = 0;
+    code = 0;
   }
 
   if (pAlter->daysPerFile > 0 && pAlter->daysPerFile != pDb->cfg.daysPerFile) {
     pDb->cfg.daysPerFile = pAlter->daysPerFile;
-    terrno = 0;
+    code = 0;
   }
 
   if (pAlter->daysToKeep0 > 0 && pAlter->daysToKeep0 != pDb->cfg.daysToKeep0) {
     pDb->cfg.daysToKeep0 = pAlter->daysToKeep0;
-    terrno = 0;
+    code = 0;
   }
 
   if (pAlter->daysToKeep1 > 0 && pAlter->daysToKeep1 != pDb->cfg.daysToKeep1) {
     pDb->cfg.daysToKeep1 = pAlter->daysToKeep1;
-    terrno = 0;
+    code = 0;
   }
 
   if (pAlter->daysToKeep2 > 0 && pAlter->daysToKeep2 != pDb->cfg.daysToKeep2) {
     pDb->cfg.daysToKeep2 = pAlter->daysToKeep2;
-    terrno = 0;
+    code = 0;
   }
 
   if (pAlter->keepTimeOffset >= 0 && pAlter->keepTimeOffset != pDb->cfg.keepTimeOffset) {
     pDb->cfg.keepTimeOffset = pAlter->keepTimeOffset;
-    terrno = 0;
+    code = 0;
   }
 
   if (pAlter->walFsyncPeriod >= 0 && pAlter->walFsyncPeriod != pDb->cfg.walFsyncPeriod) {
     pDb->cfg.walFsyncPeriod = pAlter->walFsyncPeriod;
-    terrno = 0;
+    code = 0;
   }
 
   if (pAlter->walLevel >= 0 && pAlter->walLevel != pDb->cfg.walLevel) {
     pDb->cfg.walLevel = pAlter->walLevel;
-    terrno = 0;
+    code = 0;
   }
 
   if (pAlter->strict >= 0 && pAlter->strict != pDb->cfg.strict) {
 #if 1
-    terrno = TSDB_CODE_OPS_NOT_SUPPORT;
+    code = TSDB_CODE_OPS_NOT_SUPPORT;
 #else
     pDb->cfg.strict = pAlter->strict;
-    terrno = 0;
+    code = 0;
 #endif
   }
 
   if (pAlter->cacheLast >= 0 && pAlter->cacheLast != pDb->cfg.cacheLast) {
     pDb->cfg.cacheLast = pAlter->cacheLast;
-    terrno = 0;
+    code = 0;
   }
 
   if (pAlter->cacheLastSize > 0 && pAlter->cacheLastSize != pDb->cfg.cacheLastSize) {
     pDb->cfg.cacheLastSize = pAlter->cacheLastSize;
-    terrno = 0;
+    code = 0;
   }
 
   if (pAlter->replications > 0 && pAlter->replications != pDb->cfg.replications) {
     pDb->cfg.replications = pAlter->replications;
     pDb->vgVersion++;
-    terrno = 0;
+    code = 0;
   }
 
   if (pAlter->sstTrigger > 0 && pAlter->sstTrigger != pDb->cfg.sstTrigger) {
     pDb->cfg.sstTrigger = pAlter->sstTrigger;
     pDb->vgVersion++;
-    terrno = 0;
+    code = 0;
   }
 
   if (pAlter->minRows > 0 && pAlter->minRows != pDb->cfg.minRows) {
     pDb->cfg.minRows = pAlter->minRows;
     pDb->vgVersion++;
-    terrno = 0;
+    code = 0;
   }
 
   if (pAlter->walRetentionPeriod > TSDB_DB_MIN_WAL_RETENTION_PERIOD &&
       pAlter->walRetentionPeriod != pDb->cfg.walRetentionPeriod) {
     pDb->cfg.walRetentionPeriod = pAlter->walRetentionPeriod;
     pDb->vgVersion++;
-    terrno = 0;
+    code = 0;
   }
 
   if (pAlter->walRetentionSize > TSDB_DB_MIN_WAL_RETENTION_SIZE &&
       pAlter->walRetentionSize != pDb->cfg.walRetentionSize) {
     pDb->cfg.walRetentionSize = pAlter->walRetentionSize;
     pDb->vgVersion++;
-    terrno = 0;
+    code = 0;
   }
 
   if (pAlter->s3KeepLocal > TSDB_MIN_S3_KEEP_LOCAL && pAlter->s3KeepLocal != pDb->cfg.s3KeepLocal) {
     pDb->cfg.s3KeepLocal = pAlter->s3KeepLocal;
     pDb->vgVersion++;
-    terrno = 0;
+    code = 0;
   }
 
   if (pAlter->s3Compact > TSDB_MIN_S3_COMPACT && pAlter->s3Compact != pDb->cfg.s3Compact) {
     pDb->cfg.s3Compact = pAlter->s3Compact;
     pDb->vgVersion++;
-    terrno = 0;
+    code = 0;
   }
 
   if (pAlter->withArbitrator >= TSDB_MIN_DB_WITH_ARBITRATOR && pAlter->withArbitrator != pDb->cfg.withArbitrator) {
     pDb->cfg.withArbitrator = pAlter->withArbitrator;
     pDb->vgVersion++;
-    terrno = 0;
+    code = 0;
   }
 
-  return terrno;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSetAlterDbPrepareLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOld, SDbObj *pNew) {
+  int32_t  code = 0;
   SSdbRaw *pRedoRaw = mndDbActionEncode(pOld);
-  if (pRedoRaw == NULL) return -1;
-  if (mndTransAppendPrepareLog(pTrans, pRedoRaw) != 0) {
+  if (pRedoRaw == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
+  if ((code = mndTransAppendPrepareLog(pTrans, pRedoRaw)) != 0) {
     sdbFreeRaw(pRedoRaw);
-    return -1;
+    TAOS_RETURN(code);
   }
 
   (void)sdbSetRawStatus(pRedoRaw, SDB_STATUS_READY);
@@ -1094,18 +1128,24 @@ static int32_t mndSetAlterDbPrepareLogs(SMnode *pMnode, STrans *pTrans, SDbObj *
 }
 
 static int32_t mndSetAlterDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pOld, SDbObj *pNew) {
+  int32_t  code = 0;
   SSdbRaw *pCommitRaw = mndDbActionEncode(pNew);
-  if (pCommitRaw == NULL) return -1;
-  if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
+  if (pCommitRaw == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    TAOS_RETURN(code);
+  }
+  if ((code = mndTransAppendCommitlog(pTrans, pCommitRaw)) != 0) {
     sdbFreeRaw(pCommitRaw);
-    return -1;
+    TAOS_RETURN(code);
   }
 
   (void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY);
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSetAlterDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pOldDb, SDbObj *pNewDb) {
+  int32_t code = 0;
   SSdb   *pSdb = pMnode->pSdb;
   void   *pIter = NULL;
   SArray *pArray = mndBuildDnodesArray(pMnode, 0);
@@ -1117,31 +1157,31 @@ static int32_t mndSetAlterDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *
 
     if (mndVgroupInDb(pVgroup, pNewDb->uid)) {
       SVgObj newVgroup = {0};
-      if (mndBuildAlterVgroupAction(pMnode, pTrans, pOldDb, pNewDb, pVgroup, pArray, &newVgroup) != 0) {
+      if ((code = mndBuildAlterVgroupAction(pMnode, pTrans, pOldDb, pNewDb, pVgroup, pArray, &newVgroup)) != 0) {
         sdbCancelFetch(pSdb, pIter);
         sdbRelease(pSdb, pVgroup);
         taosArrayDestroy(pArray);
-        return -1;
+        TAOS_RETURN(code);
       }
       if (pNewDb->cfg.withArbitrator != pOldDb->cfg.withArbitrator) {
         if (pNewDb->cfg.withArbitrator) {
           SArbGroup arbGroup = {0};
           mndArbGroupInitFromVgObj(&newVgroup, &arbGroup);
-          if (mndSetCreateArbGroupCommitLogs(pTrans, &arbGroup) != 0) {
+          if ((code = mndSetCreateArbGroupCommitLogs(pTrans, &arbGroup)) != 0) {
             sdbCancelFetch(pSdb, pIter);
             sdbRelease(pSdb, pVgroup);
             taosArrayDestroy(pArray);
-            return -1;
+            TAOS_RETURN(code);
           }
 
         } else {
           SArbGroup arbGroup = {0};
           mndArbGroupInitFromVgObj(pVgroup, &arbGroup);
-          if (mndSetDropArbGroupCommitLogs(pTrans, &arbGroup) != 0) {
+          if ((code = mndSetDropArbGroupCommitLogs(pTrans, &arbGroup)) != 0) {
             sdbCancelFetch(pSdb, pIter);
             sdbRelease(pSdb, pVgroup);
             taosArrayDestroy(pArray);
-            return -1;
+            TAOS_RETURN(code);
           }
         }
       }
@@ -1151,22 +1191,26 @@ static int32_t mndSetAlterDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *
   }
 
   taosArrayDestroy(pArray);
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndAlterDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pOld, SDbObj *pNew) {
+  int32_t code = -1;
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "alter-db");
-  if (pTrans == NULL) return -1;
+  if (pTrans == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    return -1;
+  }
   mInfo("trans:%d, used to alter db:%s", pTrans->id, pOld->name);
 
-  int32_t code = -1;
   mndTransSetDbName(pTrans, pOld->name, NULL);
-  if (mndTransCheckConflict(pMnode, pTrans) != 0) goto _OVER;
+  TAOS_CHECK_RETURN(mndTransCheckConflict(pMnode, pTrans));
 
-  if (mndSetAlterDbPrepareLogs(pMnode, pTrans, pOld, pNew) != 0) goto _OVER;
-  if (mndSetAlterDbCommitLogs(pMnode, pTrans, pOld, pNew) != 0) goto _OVER;
-  if (mndSetAlterDbRedoActions(pMnode, pTrans, pOld, pNew) != 0) goto _OVER;
-  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+  TAOS_CHECK_RETURN(mndSetAlterDbPrepareLogs(pMnode, pTrans, pOld, pNew));
+  TAOS_CHECK_RETURN(mndSetAlterDbCommitLogs(pMnode, pTrans, pOld, pNew));
+  TAOS_CHECK_RETURN(mndSetAlterDbRedoActions(pMnode, pTrans, pOld, pNew));
+  TAOS_CHECK_RETURN(mndTransPrepare(pMnode, pTrans));
   code = 0;
 
 _OVER:
@@ -1181,35 +1225,28 @@ static int32_t mndProcessAlterDbReq(SRpcMsg *pReq) {
   SAlterDbReq alterReq = {0};
   SDbObj      dbObj = {0};
 
-  if (tDeserializeSAlterDbReq(pReq->pCont, pReq->contLen, &alterReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
-    goto _OVER;
-  }
+  TAOS_CHECK_GOTO(tDeserializeSAlterDbReq(pReq->pCont, pReq->contLen, &alterReq), NULL, _OVER);
 
   mInfo("db:%s, start to alter", alterReq.db);
 
   pDb = mndAcquireDb(pMnode, alterReq.db);
   if (pDb == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
     goto _OVER;
   }
 
-  if (mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_ALTER_DB, pDb) != 0) {
-    goto _OVER;
-  }
+  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_ALTER_DB, pDb), NULL, _OVER);
 
   if (alterReq.replications == 2) {
-    if ((code = grantCheck(TSDB_GRANT_DUAL_REPLICA_HA)) != 0) {
-      goto _OVER;
-    }
+    TAOS_CHECK_GOTO(grantCheck(TSDB_GRANT_DUAL_REPLICA_HA), NULL, _OVER);
   }
 
   int32_t numOfTopics = 0;
-  if (mndGetNumOfTopics(pMnode, pDb->name, &numOfTopics) != 0) {
-    goto _OVER;
-  }
+  TAOS_CHECK_GOTO(mndGetNumOfTopics(pMnode, pDb->name, &numOfTopics), NULL, _OVER);
 
   if (numOfTopics != 0 && alterReq.walRetentionPeriod == 0) {
-    terrno = TSDB_CODE_MND_DB_RETENTION_PERIOD_ZERO;
+    code = TSDB_CODE_MND_DB_RETENTION_PERIOD_ZERO;
     mError("db:%s, not allowed to set WAL_RETENTION_PERIOD 0 when there are topics defined. numOfTopics:%d", pDb->name,
            numOfTopics);
     goto _OVER;
@@ -1227,8 +1264,7 @@ static int32_t mndProcessAlterDbReq(SRpcMsg *pReq) {
     goto _OVER;
   }
 
-  code = mndCheckInChangeDbCfg(pMnode, &pDb->cfg, &dbObj.cfg);
-  if (code != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndCheckInChangeDbCfg(pMnode, &pDb->cfg, &dbObj.cfg), NULL, _OVER);
 
   dbObj.cfgVersion++;
   dbObj.updateTime = taosGetTimestampMs();
@@ -1256,8 +1292,7 @@ _OVER:
   taosArrayDestroy(dbObj.cfg.pRetensions);
   tFreeSAlterDbReq(&alterReq);
 
-  terrno = code;
-  return code;
+  TAOS_RETURN(code);
 }
 
 static void mndDumpDbCfgInfo(SDbCfgRsp *cfgRsp, SDbObj *pDb) {
@@ -1309,14 +1344,13 @@ static int32_t mndProcessGetDbCfgReq(SRpcMsg *pReq) {
   SDbCfgReq cfgReq = {0};
   SDbCfgRsp cfgRsp = {0};
 
-  if (tDeserializeSDbCfgReq(pReq->pCont, pReq->contLen, &cfgReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
-    goto _OVER;
-  }
+  TAOS_CHECK_GOTO(tDeserializeSDbCfgReq(pReq->pCont, pReq->contLen, &cfgReq), NULL, _OVER);
 
   if (strcasecmp(cfgReq.db, TSDB_INFORMATION_SCHEMA_DB) && strcasecmp(cfgReq.db, TSDB_PERFORMANCE_SCHEMA_DB)) {
     pDb = mndAcquireDb(pMnode, cfgReq.db);
     if (pDb == NULL) {
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
       goto _OVER;
     }
 
@@ -1326,8 +1360,8 @@ static int32_t mndProcessGetDbCfgReq(SRpcMsg *pReq) {
   int32_t contLen = tSerializeSDbCfgRsp(NULL, 0, &cfgRsp);
   void   *pRsp = rpcMallocCont(contLen);
   if (pRsp == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    code = -1;
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
     goto _OVER;
   }
 
@@ -1348,14 +1382,19 @@ _OVER:
 
   mndReleaseDb(pMnode, pDb);
 
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSetDropDbPrepareLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
+  int32_t  code = 0;
   SSdbRaw *pRedoRaw = mndDbActionEncode(pDb);
-  if (pRedoRaw == NULL) return -1;
-  if (mndTransAppendPrepareLog(pTrans, pRedoRaw) != 0) return -1;
-  if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING) != 0) return -1;
+  if (pRedoRaw == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    return -1;
+  }
+  TAOS_CHECK_RETURN(mndTransAppendPrepareLog(pTrans, pRedoRaw));
+  TAOS_CHECK_RETURN(sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPING));
 
   SSdb *pSdb = pMnode->pSdb;
   void *pIter = NULL;
@@ -1366,24 +1405,29 @@ static int32_t mndSetDropDbPrepareLogs(SMnode *pMnode, STrans *pTrans, SDbObj *p
     if (pIter == NULL) break;
 
     if (pArbGroup->dbUid == pDb->uid) {
-      if (mndSetDropArbGroupPrepareLogs(pTrans, pArbGroup) != 0) {
+      if ((code = mndSetDropArbGroupPrepareLogs(pTrans, pArbGroup)) != 0) {
         sdbCancelFetch(pSdb, pIter);
         sdbRelease(pSdb, pArbGroup);
-        return -1;
+        TAOS_RETURN(code);
       }
     }
 
     sdbRelease(pSdb, pArbGroup);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSetDropDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
+  int32_t  code = 0;
   SSdbRaw *pCommitRaw = mndDbActionEncode(pDb);
-  if (pCommitRaw == NULL) return -1;
-  if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1;
-  if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED) != 0) return -1;
+  if (pCommitRaw == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    return -1;
+  }
+  TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw));
+  TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED));
 
   SSdb *pSdb = pMnode->pSdb;
   void *pIter = NULL;
@@ -1394,10 +1438,10 @@ static int32_t mndSetDropDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pD
     if (pIter == NULL) break;
 
     if (pArbGroup->dbUid == pDb->uid) {
-      if (mndSetDropArbGroupCommitLogs(pTrans, pArbGroup) != 0) {
+      if ((code = mndSetDropArbGroupCommitLogs(pTrans, pArbGroup)) != 0) {
         sdbCancelFetch(pSdb, pIter);
         sdbRelease(pSdb, pArbGroup);
-        return -1;
+        TAOS_RETURN(code);
       }
     }
 
@@ -1411,10 +1455,17 @@ static int32_t mndSetDropDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pD
 
     if (pVgroup->dbUid == pDb->uid) {
       SSdbRaw *pVgRaw = mndVgroupActionEncode(pVgroup);
-      if (pVgRaw == NULL || mndTransAppendCommitlog(pTrans, pVgRaw) != 0) {
+      if (pVgRaw == NULL) {
         sdbCancelFetch(pSdb, pIter);
         sdbRelease(pSdb, pVgroup);
-        return -1;
+        code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+        if (terrno != 0) code = terrno;
+        TAOS_RETURN(code);
+      }
+      if ((code = mndTransAppendCommitlog(pTrans, pVgRaw)) != 0) {
+        sdbCancelFetch(pSdb, pIter);
+        sdbRelease(pSdb, pVgroup);
+        TAOS_RETURN(code);
       }
       (void)sdbSetRawStatus(pVgRaw, SDB_STATUS_DROPPED);
     }
@@ -1429,7 +1480,14 @@ static int32_t mndSetDropDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pD
 
     if (pStb->dbUid == pDb->uid) {
       SSdbRaw *pStbRaw = mndStbActionEncode(pStb);
-      if (pStbRaw == NULL || mndTransAppendCommitlog(pTrans, pStbRaw) != 0) {
+      if (pStbRaw == NULL) {
+        sdbCancelFetch(pSdb, pIter);
+        sdbRelease(pSdb, pStbRaw);
+        code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+        if (terrno != 0) code = terrno;
+        return -1;
+      }
+      if ((code = mndTransAppendCommitlog(pTrans, pStbRaw)) != 0) {
         sdbCancelFetch(pSdb, pIter);
         sdbRelease(pSdb, pStbRaw);
         return -1;
@@ -1440,21 +1498,21 @@ static int32_t mndSetDropDbCommitLogs(SMnode *pMnode, STrans *pTrans, SDbObj *pD
     sdbRelease(pSdb, pStb);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndBuildDropVgroupAction(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SVgObj *pVgroup) {
+  int32_t code = 0;
   for (int32_t vn = 0; vn < pVgroup->replica; ++vn) {
     SVnodeGid *pVgid = pVgroup->vnodeGid + vn;
-    if (mndAddDropVnodeAction(pMnode, pTrans, pDb, pVgroup, pVgid, true) != 0) {
-      return -1;
-    }
+    TAOS_CHECK_RETURN(mndAddDropVnodeAction(pMnode, pTrans, pDb, pVgroup, pVgid, true));
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSetDropDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) {
+  int32_t code = 0;
   SSdb *pSdb = pMnode->pSdb;
   void *pIter = NULL;
 
@@ -1464,20 +1522,21 @@ static int32_t mndSetDropDbRedoActions(SMnode *pMnode, STrans *pTrans, SDbObj *p
     if (pIter == NULL) break;
 
     if (pVgroup->dbUid == pDb->uid) {
-      if (mndBuildDropVgroupAction(pMnode, pTrans, pDb, pVgroup) != 0) {
+      if ((code = mndBuildDropVgroupAction(pMnode, pTrans, pDb, pVgroup)) != 0) {
         sdbCancelFetch(pSdb, pIter);
         sdbRelease(pSdb, pVgroup);
-        return -1;
+        TAOS_RETURN(code);
       }
     }
 
     sdbRelease(pSdb, pVgroup);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndBuildDropDbRsp(SDbObj *pDb, int32_t *pRspLen, void **ppRsp, bool useRpcMalloc) {
+  int32_t    code = 0;
   SDropDbRsp dropRsp = {0};
   if (pDb != NULL) {
     memcpy(dropRsp.db, pDb->name, TSDB_DB_FNAME_LEN);
@@ -1493,14 +1552,14 @@ static int32_t mndBuildDropDbRsp(SDbObj *pDb, int32_t *pRspLen, void **ppRsp, bo
   }
 
   if (pRsp == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    TAOS_RETURN(code);
   }
 
   tSerializeSDropDbRsp(pRsp, rspLen, &dropRsp);
   *pRspLen = rspLen;
   *ppRsp = pRsp;
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndDropDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb) {
@@ -1508,46 +1567,46 @@ static int32_t mndDropDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb) {
 
   STrans *pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "drop-db");
   if (pTrans == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
     goto _OVER;
   }
 
   mInfo("trans:%d start to drop db:%s", pTrans->id, pDb->name);
 
   mndTransSetDbName(pTrans, pDb->name, NULL);
-  if (mndTransCheckConflict(pMnode, pTrans) != 0) {
-    goto _OVER;
-  }
+  TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER);
 
   if (mndTopicExistsForDb(pMnode, pDb)) {
-    terrno = TSDB_CODE_MND_TOPIC_MUST_BE_DELETED;
+    code = TSDB_CODE_MND_TOPIC_MUST_BE_DELETED;
     goto _OVER;
   }
 
-  if (mndSetDropDbPrepareLogs(pMnode, pTrans, pDb) != 0) goto _OVER;
-  if (mndSetDropDbCommitLogs(pMnode, pTrans, pDb) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndSetDropDbPrepareLogs(pMnode, pTrans, pDb), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndSetDropDbCommitLogs(pMnode, pTrans, pDb), NULL, _OVER);
   /*if (mndDropOffsetByDB(pMnode, pTrans, pDb) != 0) goto _OVER;*/
   /*if (mndDropSubByDB(pMnode, pTrans, pDb) != 0) goto _OVER;*/
   /*if (mndDropTopicByDB(pMnode, pTrans, pDb) != 0) goto _OVER;*/
-  if (mndDropStreamByDb(pMnode, pTrans, pDb) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndDropStreamByDb(pMnode, pTrans, pDb), NULL, _OVER);
 #ifdef TD_ENTERPRISE
-  if (mndDropViewByDb(pMnode, pTrans, pDb) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndDropViewByDb(pMnode, pTrans, pDb), NULL, _OVER);
 #endif
-  if (mndDropSmasByDb(pMnode, pTrans, pDb) != 0) goto _OVER;
-  if (mndDropIdxsByDb(pMnode, pTrans, pDb) != 0) goto _OVER;
-  if (mndSetDropDbRedoActions(pMnode, pTrans, pDb) != 0) goto _OVER;
-  if (mndUserRemoveDb(pMnode, pTrans, pDb->name) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndDropSmasByDb(pMnode, pTrans, pDb), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndDropIdxsByDb(pMnode, pTrans, pDb), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndSetDropDbRedoActions(pMnode, pTrans, pDb), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndUserRemoveDb(pMnode, pTrans, pDb->name), NULL, _OVER);
 
   int32_t rspLen = 0;
   void   *pRsp = NULL;
-  if (mndBuildDropDbRsp(pDb, &rspLen, &pRsp, false) < 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndBuildDropDbRsp(pDb, &rspLen, &pRsp, false), NULL, _OVER);
   mndTransSetRpcRsp(pTrans, pRsp, rspLen);
 
-  if (mndTransPrepare(pMnode, pTrans) != 0) goto _OVER;
+  TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
   code = 0;
 
 _OVER:
   mndTransDrop(pTrans);
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndProcessDropDbReq(SRpcMsg *pReq) {
@@ -1556,24 +1615,21 @@ static int32_t mndProcessDropDbReq(SRpcMsg *pReq) {
   SDbObj    *pDb = NULL;
   SDropDbReq dropReq = {0};
 
-  if (tDeserializeSDropDbReq(pReq->pCont, pReq->contLen, &dropReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
-    goto _OVER;
-  }
+  TAOS_CHECK_GOTO(tDeserializeSDropDbReq(pReq->pCont, pReq->contLen, &dropReq), NULL, _OVER);
 
   mInfo("db:%s, start to drop", dropReq.db);
 
   pDb = mndAcquireDb(pMnode, dropReq.db);
   if (pDb == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
     if (dropReq.ignoreNotExists) {
       code = mndBuildDropDbRsp(pDb, &pReq->info.rspLen, &pReq->info.rsp, true);
     }
     goto _OVER;
   }
 
-  if (mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_DB, pDb) != 0) {
-    goto _OVER;
-  }
+  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_DB, pDb), NULL, _OVER);
 
   code = mndDropDb(pMnode, pReq, pDb);
   if (code == TSDB_CODE_SUCCESS) {
@@ -1592,7 +1648,7 @@ _OVER:
 
   mndReleaseDb(pMnode, pDb);
   tFreeSDropDbReq(&dropReq);
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndGetDBTableNum(SDbObj *pDb, SMnode *pMnode) {
@@ -1662,10 +1718,11 @@ void mndBuildDBVgroupInfo(SDbObj *pDb, SMnode *pMnode, SArray *pVgList) {
 }
 
 int32_t mndExtractDbInfo(SMnode *pMnode, SDbObj *pDb, SUseDbRsp *pRsp, const SUseDbReq *pReq) {
+  int32_t code = 0;
   pRsp->pVgroupInfos = taosArrayInit(pDb->cfg.numOfVgroups, sizeof(SVgroupInfo));
   if (pRsp->pVgroupInfos == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    TAOS_RETURN(code);
   }
 
   int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);
@@ -1683,7 +1740,7 @@ int32_t mndExtractDbInfo(SMnode *pMnode, SDbObj *pDb, SUseDbRsp *pRsp, const SUs
   pRsp->hashMethod = pDb->cfg.hashMethod;
   pRsp->hashPrefix = pDb->cfg.hashPrefix;
   pRsp->hashSuffix = pDb->cfg.hashSuffix;
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndProcessUseDbReq(SRpcMsg *pReq) {
@@ -1693,10 +1750,7 @@ static int32_t mndProcessUseDbReq(SRpcMsg *pReq) {
   SUseDbReq usedbReq = {0};
   SUseDbRsp usedbRsp = {0};
 
-  if (tDeserializeSUseDbReq(pReq->pCont, pReq->contLen, &usedbReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
-    goto _OVER;
-  }
+  TAOS_CHECK_GOTO(tDeserializeSUseDbReq(pReq->pCont, pReq->contLen, &usedbReq), NULL, _OVER);
 
   char *p = strchr(usedbReq.db, '.');
   if (p && ((0 == strcmp(p + 1, TSDB_INFORMATION_SCHEMA_DB) || (0 == strcmp(p + 1, TSDB_PERFORMANCE_SCHEMA_DB))))) {
@@ -1721,18 +1775,13 @@ static int32_t mndProcessUseDbReq(SRpcMsg *pReq) {
       usedbRsp.vgVersion = usedbReq.vgVersion;
       usedbRsp.errCode = terrno;
 
-      if (terrno == TSDB_CODE_MND_DB_IN_CREATING) {
-        code = terrno;
-        goto _OVER;
-      }
+      code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+      if (terrno != 0) code = terrno;
+      goto _OVER;
     } else {
-      if (mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_USE_DB, pDb) != 0) {
-        goto _OVER;
-      }
+      TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_USE_DB, pDb), NULL, _OVER);
 
-      if (mndExtractDbInfo(pMnode, pDb, &usedbRsp, &usedbReq) < 0) {
-        goto _OVER;
-      }
+      TAOS_CHECK_GOTO(mndExtractDbInfo(pMnode, pDb, &usedbRsp, &usedbReq), NULL, _OVER);
 
       mDebug("db:%s, process usedb req vgVersion:%d stateTs:%" PRId64 ", rsp vgVersion:%d stateTs:%" PRId64,
              usedbReq.db, usedbReq.vgVersion, usedbReq.stateTs, usedbRsp.vgVersion, usedbRsp.stateTs);
@@ -1761,15 +1810,16 @@ _OVER:
   mndReleaseDb(pMnode, pDb);
   tFreeSUsedbRsp(&usedbRsp);
 
-  return code;
+  TAOS_RETURN(code);
 }
 
 int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs, void **ppRsp, int32_t *pRspLen) {
+  int32_t       code = 0;
   SDbHbBatchRsp batchRsp = {0};
   batchRsp.pArray = taosArrayInit(numOfDbs, sizeof(SDbHbRsp));
   if (batchRsp.pArray == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return -1;
+    TAOS_RETURN(code);
   }
 
   for (int32_t i = 0; i < numOfDbs; ++i) {
@@ -1886,7 +1936,7 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
   *pRspLen = rspLen;
 
   tFreeSDbHbBatchRsp(&batchRsp);
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndTrimDb(SMnode *pMnode, SDbObj *pDb) {
@@ -1931,21 +1981,18 @@ static int32_t mndProcessTrimDbReq(SRpcMsg *pReq) {
   SDbObj    *pDb = NULL;
   STrimDbReq trimReq = {0};
 
-  if (tDeserializeSTrimDbReq(pReq->pCont, pReq->contLen, &trimReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
-    goto _OVER;
-  }
+  TAOS_CHECK_GOTO(tDeserializeSTrimDbReq(pReq->pCont, pReq->contLen, &trimReq), NULL, _OVER);
 
   mInfo("db:%s, start to trim", trimReq.db);
 
   pDb = mndAcquireDb(pMnode, trimReq.db);
   if (pDb == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
     goto _OVER;
   }
 
-  if (mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_TRIM_DB, pDb) != 0) {
-    goto _OVER;
-  }
+  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_TRIM_DB, pDb), NULL, _OVER);
 
   code = mndTrimDb(pMnode, pDb);
 
@@ -1955,7 +2002,7 @@ _OVER:
   }
 
   mndReleaseDb(pMnode, pDb);
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndS3MigrateDb(SMnode *pMnode, SDbObj *pDb) {
@@ -2002,21 +2049,18 @@ static int32_t mndProcessS3MigrateDbReq(SRpcMsg *pReq) {
   SDbObj         *pDb = NULL;
   SS3MigrateDbReq s3migrateReq = {0};
 
-  if (tDeserializeSS3MigrateDbReq(pReq->pCont, pReq->contLen, &s3migrateReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
-    goto _OVER;
-  }
+  TAOS_CHECK_GOTO(tDeserializeSS3MigrateDbReq(pReq->pCont, pReq->contLen, &s3migrateReq), NULL, _OVER);
 
   mInfo("db:%s, start to s3migrate", s3migrateReq.db);
 
   pDb = mndAcquireDb(pMnode, s3migrateReq.db);
   if (pDb == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
     goto _OVER;
   }
 
-  if (mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_TRIM_DB, pDb) != 0) {
-    goto _OVER;
-  }
+  TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_TRIM_DB, pDb), NULL, _OVER);
 
   code = mndS3MigrateDb(pMnode, pDb);
 
@@ -2026,7 +2070,7 @@ _OVER:
   }
 
   mndReleaseDb(pMnode, pDb);
-  return code;
+  TAOS_RETURN(code);
 }
 
 const char *mndGetDbStr(const char *src) {
diff --git a/source/libs/command/src/command.c b/source/libs/command/src/command.c
index 9506e801c5..07409b1411 100644
--- a/source/libs/command/src/command.c
+++ b/source/libs/command/src/command.c
@@ -23,6 +23,15 @@
 #include "tglobal.h"
 #include "tgrant.h"
 
+#define COL_DATA_SET_VAL_AND_CHECK(pCol, rows, buf, isNull) \
+    do {                                                    \
+        int  _code = colDataSetVal(pCol, rows, buf, isNull);\
+        if (TSDB_CODE_SUCCESS != _code) {                   \
+            terrno = _code;                                 \
+            return _code;                                   \
+        }                                                   \
+    } while(0)
+
 extern SConfig* tsCfg;
 
 static int32_t buildRetrieveTableRsp(SSDataBlock* pBlock, int32_t numOfCols, SRetrieveTableRsp** pRsp) {
@@ -100,7 +109,7 @@ static int32_t buildDescResultDataBlock(SSDataBlock** pOutput) {
   if (TSDB_CODE_SUCCESS == code) {
     *pOutput = pBlock;
   } else {
-    blockDataDestroy(pBlock);
+    (void)blockDataDestroy(pBlock);
   }
   return code;
 }
@@ -108,7 +117,7 @@ static int32_t buildDescResultDataBlock(SSDataBlock** pOutput) {
 static int32_t setDescResultIntoDataBlock(bool sysInfoUser, SSDataBlock* pBlock, int32_t numOfRows, STableMeta* pMeta,
                                           int8_t biMode) {
   int32_t blockCap = (biMode != 0) ? numOfRows + 1 : numOfRows;
-  blockDataEnsureCapacity(pBlock, blockCap);
+  QRY_ERR_RET(blockDataEnsureCapacity(pBlock, blockCap));
   pBlock->info.rows = 0;
 
   // field
@@ -138,11 +147,12 @@ static int32_t setDescResultIntoDataBlock(bool sysInfoUser, SSDataBlock* pBlock,
       continue;
     }
     STR_TO_VARSTR(buf, pMeta->schema[i].name);
-    colDataSetVal(pCol1, pBlock->info.rows, buf, false);
+    COL_DATA_SET_VAL_AND_CHECK(pCol1, pBlock->info.rows, buf, false);
+
     STR_TO_VARSTR(buf, tDataTypes[pMeta->schema[i].type].name);
-    colDataSetVal(pCol2, pBlock->info.rows, buf, false);
+    COL_DATA_SET_VAL_AND_CHECK(pCol2, pBlock->info.rows, buf, false);
     int32_t bytes = getSchemaBytes(pMeta->schema + i);
-    colDataSetVal(pCol3, pBlock->info.rows, (const char*)&bytes, false);
+    COL_DATA_SET_VAL_AND_CHECK(pCol3, pBlock->info.rows, (const char*)&bytes, false);
     if (TSDB_VIEW_TABLE != pMeta->tableType) {
       if (i >= pMeta->tableInfo.numOfColumns) {
         STR_TO_VARSTR(buf, "TAG");
@@ -155,22 +165,22 @@ static int32_t setDescResultIntoDataBlock(bool sysInfoUser, SSDataBlock* pBlock,
     } else {
       STR_TO_VARSTR(buf, "VIEW COL");
     }
-    colDataSetVal(pCol4, pBlock->info.rows, buf, false);
+    COL_DATA_SET_VAL_AND_CHECK(pCol4, pBlock->info.rows, buf, false);
     if (useCompress(pMeta->tableType) && pMeta->schemaExt) {
       if (i < pMeta->tableInfo.numOfColumns) {
         STR_TO_VARSTR(buf, columnEncodeStr(COMPRESS_L1_TYPE_U32(pMeta->schemaExt[i].compress)));
-        colDataSetVal(pCol5, pBlock->info.rows, buf, false);
+        COL_DATA_SET_VAL_AND_CHECK(pCol5, pBlock->info.rows, buf, false);
         STR_TO_VARSTR(buf, columnCompressStr(COMPRESS_L2_TYPE_U32(pMeta->schemaExt[i].compress)));
-        colDataSetVal(pCol6, pBlock->info.rows, buf, false);
+        COL_DATA_SET_VAL_AND_CHECK(pCol6, pBlock->info.rows, buf, false);
         STR_TO_VARSTR(buf, columnLevelStr(COMPRESS_L2_TYPE_LEVEL_U32(pMeta->schemaExt[i].compress)));
-        colDataSetVal(pCol7, pBlock->info.rows, buf, false);
+        COL_DATA_SET_VAL_AND_CHECK(pCol7, pBlock->info.rows, buf, false);
       } else {
         STR_TO_VARSTR(buf, fillTagCol == 0 ? "" : "disabled");
-        colDataSetVal(pCol5, pBlock->info.rows, buf, false);
+        COL_DATA_SET_VAL_AND_CHECK(pCol5, pBlock->info.rows, buf, false);
         STR_TO_VARSTR(buf, fillTagCol == 0 ? "" : "disabled");
-        colDataSetVal(pCol6, pBlock->info.rows, buf, false);
+        COL_DATA_SET_VAL_AND_CHECK(pCol6, pBlock->info.rows, buf, false);
         STR_TO_VARSTR(buf, fillTagCol == 0 ? "" : "disabled");
-        colDataSetVal(pCol7, pBlock->info.rows, buf, false);
+        COL_DATA_SET_VAL_AND_CHECK(pCol7, pBlock->info.rows, buf, false);
       }
     }
 
@@ -180,13 +190,13 @@ static int32_t setDescResultIntoDataBlock(bool sysInfoUser, SSDataBlock* pBlock,
   }
   if (pMeta->tableType == TSDB_SUPER_TABLE && biMode != 0) {
     STR_TO_VARSTR(buf, "tbname");
-    colDataSetVal(pCol1, pBlock->info.rows, buf, false);
+    COL_DATA_SET_VAL_AND_CHECK(pCol1, pBlock->info.rows, buf, false);
     STR_TO_VARSTR(buf, "VARCHAR");
-    colDataSetVal(pCol2, pBlock->info.rows, buf, false);
+    COL_DATA_SET_VAL_AND_CHECK(pCol2, pBlock->info.rows, buf, false);
     int32_t bytes = TSDB_TABLE_NAME_LEN - 1;
-    colDataSetVal(pCol3, pBlock->info.rows, (const char*)&bytes, false);
+    COL_DATA_SET_VAL_AND_CHECK(pCol3, pBlock->info.rows, (const char*)&bytes, false);
     STR_TO_VARSTR(buf, "TAG");
-    colDataSetVal(pCol4, pBlock->info.rows, buf, false);
+    COL_DATA_SET_VAL_AND_CHECK(pCol4, pBlock->info.rows, buf, false);
     ++(pBlock->info.rows);
   }
   if (pBlock->info.rows <= 0) {
@@ -212,7 +222,7 @@ static int32_t execDescribe(bool sysInfoUser, SNode* pStmt, SRetrieveTableRsp**
       code = buildRetrieveTableRsp(pBlock, DESCRIBE_RESULT_COLS, pRsp);
     }
   }
-  blockDataDestroy(pBlock);
+  (void)blockDataDestroy(pBlock);
   return code;
 }
 
@@ -234,7 +244,7 @@ static int32_t buildCreateDBResultDataBlock(SSDataBlock** pOutput) {
   if (TSDB_CODE_SUCCESS == code) {
     *pOutput = pBlock;
   } else {
-    blockDataDestroy(pBlock);
+    (void)blockDataDestroy(pBlock);
   }
   return code;
 }
@@ -264,13 +274,17 @@ int64_t getValOfDiffPrecision(int8_t unit, int64_t val) {
   return v;
 }
 
-static char* buildRetension(SArray* pRetension) {
+static int32_t buildRetension(SArray* pRetension, char **ppRetentions ) {
   size_t size = taosArrayGetSize(pRetension);
   if (size == 0) {
-    return NULL;
+    *ppRetentions = NULL;
+    return TSDB_CODE_SUCCESS;
   }
 
   char*   p1 = taosMemoryCalloc(1, 100);
+  if(NULL == p1) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
   int32_t len = 0;
 
   for (int32_t i = 0; i < size; ++i) {
@@ -288,7 +302,8 @@ static char* buildRetension(SArray* pRetension) {
     }
   }
 
-  return p1;
+  *ppRetentions = p1;
+  return TSDB_CODE_SUCCESS;
 }
 
 static const char* cacheModelStr(int8_t cacheModel) {
@@ -319,14 +334,14 @@ static const char* encryptAlgorithmStr(int8_t encryptAlgorithm) {
   return TSDB_CACHE_MODEL_NONE_STR;
 }
 
-static void setCreateDBResultIntoDataBlock(SSDataBlock* pBlock, char* dbName, char* dbFName, SDbCfgInfo* pCfg) {
-  blockDataEnsureCapacity(pBlock, 1);
+static int32_t setCreateDBResultIntoDataBlock(SSDataBlock* pBlock, char* dbName, char* dbFName, SDbCfgInfo* pCfg) {
+  QRY_ERR_RET(blockDataEnsureCapacity(pBlock, 1));
   pBlock->info.rows = 1;
 
   SColumnInfoData* pCol1 = taosArrayGet(pBlock->pDataBlock, 0);
   char             buf1[SHOW_CREATE_DB_RESULT_FIELD1_LEN] = {0};
   STR_TO_VARSTR(buf1, dbName);
-  colDataSetVal(pCol1, 0, buf1, false);
+  COL_DATA_SET_VAL_AND_CHECK(pCol1, 0, buf1, false);
 
   SColumnInfoData* pCol2 = taosArrayGet(pBlock->pDataBlock, 1);
   char             buf2[SHOW_CREATE_DB_RESULT_FIELD2_LEN] = {0};
@@ -347,7 +362,8 @@ static void setCreateDBResultIntoDataBlock(SSDataBlock* pBlock, char* dbName, ch
       break;
   }
 
-  char*   retentions = buildRetension(pCfg->pRetensions);
+  char*   pRetentions = NULL;
+  QRY_ERR_RET(buildRetension(pCfg->pRetensions, &pRetentions));
   int32_t dbFNameLen = strlen(dbFName);
   int32_t hashPrefix = 0;
   if (pCfg->hashPrefix > 0) {
@@ -374,28 +390,30 @@ static void setCreateDBResultIntoDataBlock(SSDataBlock* pBlock, char* dbName, ch
                    pCfg->keepTimeOffset, encryptAlgorithmStr(pCfg->encryptAlgorithm), pCfg->s3ChunkSize,
                    pCfg->s3KeepLocal, pCfg->s3Compact);
 
-    if (retentions) {
-      len += sprintf(buf2 + VARSTR_HEADER_SIZE + len, " RETENTIONS %s", retentions);
+    if (pRetentions) {
+      len += sprintf(buf2 + VARSTR_HEADER_SIZE + len, " RETENTIONS %s", pRetentions);
     }
   }
 
-  taosMemoryFree(retentions);
+  taosMemoryFree(pRetentions);
 
   (varDataLen(buf2)) = len;
 
-  colDataSetVal(pCol2, 0, buf2, false);
+  COL_DATA_SET_VAL_AND_CHECK(pCol2, 0, buf2, false);
+
+  return TSDB_CODE_SUCCESS;
 }
 
 static int32_t execShowCreateDatabase(SShowCreateDatabaseStmt* pStmt, SRetrieveTableRsp** pRsp) {
   SSDataBlock* pBlock = NULL;
   int32_t      code = buildCreateDBResultDataBlock(&pBlock);
   if (TSDB_CODE_SUCCESS == code) {
-    setCreateDBResultIntoDataBlock(pBlock, pStmt->dbName, pStmt->dbFName, pStmt->pCfg);
+    code = setCreateDBResultIntoDataBlock(pBlock, pStmt->dbName, pStmt->dbFName, pStmt->pCfg);
   }
   if (TSDB_CODE_SUCCESS == code) {
     code = buildRetrieveTableRsp(pBlock, SHOW_CREATE_DB_RESULT_COLS, pRsp);
   }
-  blockDataDestroy(pBlock);
+  (void)blockDataDestroy(pBlock);
   return code;
 }
 
@@ -415,7 +433,7 @@ static int32_t buildCreateTbResultDataBlock(SSDataBlock** pOutput) {
   if (TSDB_CODE_SUCCESS == code) {
     *pOutput = pBlock;
   } else {
-    blockDataDestroy(pBlock);
+    (void)blockDataDestroy(pBlock);
   }
   return code;
 }
@@ -436,7 +454,7 @@ static int32_t buildCreateViewResultDataBlock(SSDataBlock** pOutput) {
   if (TSDB_CODE_SUCCESS == code) {
     *pOutput = pBlock;
   } else {
-    blockDataDestroy(pBlock);
+    (void)blockDataDestroy(pBlock);
   }
   return code;
 }
@@ -494,6 +512,7 @@ void appendTagNameFields(char* buf, int32_t* len, STableCfg* pCfg) {
 }
 
 int32_t appendTagValues(char* buf, int32_t* len, STableCfg* pCfg) {
+  int32_t code = TSDB_CODE_SUCCESS;
   SArray* pTagVals = NULL;
   STag*   pTag = (STag*)pCfg->pTags;
 
@@ -511,11 +530,7 @@ int32_t appendTagValues(char* buf, int32_t* len, STableCfg* pCfg) {
     return TSDB_CODE_SUCCESS;
   }
 
-  int32_t code = tTagToValArray((const STag*)pCfg->pTags, &pTagVals);
-  if (code) {
-    return code;
-  }
-
+  QRY_ERR_RET(tTagToValArray((const STag*)pCfg->pTags, &pTagVals));
   int16_t valueNum = taosArrayGetSize(pTagVals);
   int32_t num = 0;
   int32_t j = 0;
@@ -533,16 +548,18 @@ int32_t appendTagValues(char* buf, int32_t* len, STableCfg* pCfg) {
     STagVal* pTagVal = (STagVal*)taosArrayGet(pTagVals, j);
     if (pSchema->colId > pTagVal->cid) {
       qError("tag value and column mismatch, schemaId:%d, valId:%d", pSchema->colId, pTagVal->cid);
-      taosArrayDestroy(pTagVals);
-      return TSDB_CODE_APP_ERROR;
+      code = TSDB_CODE_APP_ERROR;
+      TAOS_CHECK_ERRNO(code);
     } else if (pSchema->colId == pTagVal->cid) {
       char    type = pTagVal->type;
       int32_t tlen = 0;
 
       if (IS_VAR_DATA_TYPE(type)) {
-        dataConverToStr(buf + VARSTR_HEADER_SIZE + *len, type, pTagVal->pData, pTagVal->nData, &tlen);
+        code = dataConverToStr(buf + VARSTR_HEADER_SIZE + *len, type, pTagVal->pData, pTagVal->nData, &tlen);
+        TAOS_CHECK_ERRNO(code);
       } else {
-        dataConverToStr(buf + VARSTR_HEADER_SIZE + *len, type, &pTagVal->i64, tDataTypes[type].bytes, &tlen);
+        code = dataConverToStr(buf + VARSTR_HEADER_SIZE + *len, type, &pTagVal->i64, tDataTypes[type].bytes, &tlen);
+        TAOS_CHECK_ERRNO(code);
       }
       *len += tlen;
       j++;
@@ -579,9 +596,10 @@ int32_t appendTagValues(char* buf, int32_t* len, STableCfg* pCfg) {
     */
   }
 
+_exit:
   taosArrayDestroy(pTagVals);
 
-  return TSDB_CODE_SUCCESS;
+  return code;
 }
 
 void appendTableOptions(char* buf, int32_t* len, SDbCfgInfo* pDbCfg, STableCfg* pCfg) {
@@ -646,20 +664,19 @@ void appendTableOptions(char* buf, int32_t* len, SDbCfgInfo* pDbCfg, STableCfg*
 }
 
 static int32_t setCreateTBResultIntoDataBlock(SSDataBlock* pBlock, SDbCfgInfo* pDbCfg, char* tbName, STableCfg* pCfg) {
-  int32_t code = 0;
-  blockDataEnsureCapacity(pBlock, 1);
+  int32_t code = TSDB_CODE_SUCCESS;
+  QRY_ERR_RET(blockDataEnsureCapacity(pBlock, 1));
   pBlock->info.rows = 1;
 
   SColumnInfoData* pCol1 = taosArrayGet(pBlock->pDataBlock, 0);
   char             buf1[SHOW_CREATE_TB_RESULT_FIELD1_LEN] = {0};
   STR_TO_VARSTR(buf1, tbName);
-  colDataSetVal(pCol1, 0, buf1, false);
+  QRY_ERR_RET(colDataSetVal(pCol1, 0, buf1, false));
 
   SColumnInfoData* pCol2 = taosArrayGet(pBlock->pDataBlock, 1);
   char*            buf2 = taosMemoryMalloc(SHOW_CREATE_TB_RESULT_FIELD2_LEN);
   if (NULL == buf2) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return terrno;
+    QRY_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   int32_t len = 0;
@@ -676,10 +693,7 @@ static int32_t setCreateTBResultIntoDataBlock(SSDataBlock* pBlock, SDbCfgInfo* p
     appendTagNameFields(buf2, &len, pCfg);
     len += sprintf(buf2 + VARSTR_HEADER_SIZE + len, ") TAGS (");
     code = appendTagValues(buf2, &len, pCfg);
-    if (code) {
-      taosMemoryFree(buf2);
-      return code;
-    }
+    TAOS_CHECK_ERRNO(code);
     len += sprintf(buf2 + VARSTR_HEADER_SIZE + len, ")");
     appendTableOptions(buf2, &len, pDbCfg, pCfg);
   } else {
@@ -691,29 +705,30 @@ static int32_t setCreateTBResultIntoDataBlock(SSDataBlock* pBlock, SDbCfgInfo* p
 
   varDataLen(buf2) = (len > 65535) ? 65535 : len;
 
-  colDataSetVal(pCol2, 0, buf2, false);
+  code = colDataSetVal(pCol2, 0, buf2, false);
+  TAOS_CHECK_ERRNO(code);
 
+_exit:
   taosMemoryFree(buf2);
 
-  return TSDB_CODE_SUCCESS;
+  return code;
 }
 
 static int32_t setCreateViewResultIntoDataBlock(SSDataBlock* pBlock, SShowCreateViewStmt* pStmt) {
   int32_t code = 0;
-  blockDataEnsureCapacity(pBlock, 1);
+  QRY_ERR_RET(blockDataEnsureCapacity(pBlock, 1));
   pBlock->info.rows = 1;
 
   SColumnInfoData* pCol1 = taosArrayGet(pBlock->pDataBlock, 0);
   char             buf1[SHOW_CREATE_VIEW_RESULT_FIELD1_LEN + 1] = {0};
   snprintf(varDataVal(buf1), TSDB_VIEW_FNAME_LEN + 4, "`%s`.`%s`", pStmt->dbName, pStmt->viewName);
   varDataSetLen(buf1, strlen(varDataVal(buf1)));
-  colDataSetVal(pCol1, 0, buf1, false);
+  QRY_ERR_RET(colDataSetVal(pCol1, 0, buf1, false));
 
   SColumnInfoData* pCol2 = taosArrayGet(pBlock->pDataBlock, 1);
   char*            buf2 = taosMemoryMalloc(SHOW_CREATE_VIEW_RESULT_FIELD2_LEN);
   if (NULL == buf2) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
-    return terrno;
+    QRY_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   SViewMeta* pMeta = pStmt->pViewMeta;
@@ -722,11 +737,10 @@ static int32_t setCreateViewResultIntoDataBlock(SSDataBlock* pBlock, SShowCreate
            pStmt->dbName, pStmt->viewName, pMeta->querySql);
   int32_t len = strlen(varDataVal(buf2));
   varDataLen(buf2) = (len > 65535) ? 65535 : len;
-  colDataSetVal(pCol2, 0, buf2, false);
-
+  code = colDataSetVal(pCol2, 0, buf2, false);
   taosMemoryFree(buf2);
 
-  return TSDB_CODE_SUCCESS;
+  return code;
 }
 
 static int32_t execShowCreateTable(SShowCreateTableStmt* pStmt, SRetrieveTableRsp** pRsp) {
@@ -738,7 +752,7 @@ static int32_t execShowCreateTable(SShowCreateTableStmt* pStmt, SRetrieveTableRs
   if (TSDB_CODE_SUCCESS == code) {
     code = buildRetrieveTableRsp(pBlock, SHOW_CREATE_TB_RESULT_COLS, pRsp);
   }
-  blockDataDestroy(pBlock);
+  (void)blockDataDestroy(pBlock);
   return code;
 }
 
@@ -831,23 +845,39 @@ static int32_t buildLocalVariablesResultDataBlock(SSDataBlock** pOutput) {
   pBlock->info.hasVarCol = true;
 
   pBlock->pDataBlock = taosArrayInit(SHOW_LOCAL_VARIABLES_RESULT_COLS, sizeof(SColumnInfoData));
+  if (NULL == pBlock->pDataBlock) {
+    taosMemoryFree(pBlock);
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
 
   SColumnInfoData infoData = {0};
 
   infoData.info.type = TSDB_DATA_TYPE_VARCHAR;
   infoData.info.bytes = SHOW_LOCAL_VARIABLES_RESULT_FIELD1_LEN;
-  taosArrayPush(pBlock->pDataBlock, &infoData);
+  if(taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {
+    goto _exit;
+  }
 
   infoData.info.type = TSDB_DATA_TYPE_VARCHAR;
   infoData.info.bytes = SHOW_LOCAL_VARIABLES_RESULT_FIELD2_LEN;
-  taosArrayPush(pBlock->pDataBlock, &infoData);
+  if(taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {
+    goto _exit;
+  }
 
   infoData.info.type = TSDB_DATA_TYPE_VARCHAR;
   infoData.info.bytes = SHOW_LOCAL_VARIABLES_RESULT_FIELD3_LEN;
-  taosArrayPush(pBlock->pDataBlock, &infoData);
+  if(taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {
+    goto _exit;
+  }
 
   *pOutput = pBlock;
-  return TSDB_CODE_SUCCESS;
+
+_exit:
+  if(terrno != TSDB_CODE_SUCCESS) {
+    taosMemoryFree(pBlock);
+    taosArrayDestroy(pBlock->pDataBlock);
+  }
+  return terrno;
 }
 
 static int32_t execShowLocalVariables(SRetrieveTableRsp** pRsp) {
@@ -859,7 +889,7 @@ static int32_t execShowLocalVariables(SRetrieveTableRsp** pRsp) {
   if (TSDB_CODE_SUCCESS == code) {
     code = buildRetrieveTableRsp(pBlock, SHOW_LOCAL_VARIABLES_RESULT_COLS, pRsp);
   }
-  blockDataDestroy(pBlock);
+  (void)blockDataDestroy(pBlock);
   return code;
 }
 
@@ -880,14 +910,14 @@ static int32_t createSelectResultDataBlock(SNodeList* pProjects, SSDataBlock** p
       infoData.info.type = pExpr->resType.type;
       infoData.info.bytes = pExpr->resType.bytes;
     }
-    blockDataAppendColInfo(pBlock, &infoData);
+    QRY_ERR_RET(blockDataAppendColInfo(pBlock, &infoData));
   }
   *pOutput = pBlock;
   return TSDB_CODE_SUCCESS;
 }
 
 int32_t buildSelectResultDataBlock(SNodeList* pProjects, SSDataBlock* pBlock) {
-  blockDataEnsureCapacity(pBlock, 1);
+  QRY_ERR_RET(blockDataEnsureCapacity(pBlock, 1));
 
   int32_t index = 0;
   SNode*  pProj = NULL;
@@ -896,9 +926,9 @@ int32_t buildSelectResultDataBlock(SNodeList* pProjects, SSDataBlock* pBlock) {
       return TSDB_CODE_PAR_INVALID_SELECTED_EXPR;
     } else {
       if (((SValueNode*)pProj)->isNull) {
-        colDataSetVal(taosArrayGet(pBlock->pDataBlock, index++), 0, NULL, true);
+        QRY_ERR_RET(colDataSetVal(taosArrayGet(pBlock->pDataBlock, index++), 0, NULL, true));
       } else {
-        colDataSetVal(taosArrayGet(pBlock->pDataBlock, index++), 0, nodesGetValueFromNode((SValueNode*)pProj), false);
+        QRY_ERR_RET(colDataSetVal(taosArrayGet(pBlock->pDataBlock, index++), 0, nodesGetValueFromNode((SValueNode*)pProj), false));
       }
     }
   }
@@ -916,7 +946,7 @@ static int32_t execSelectWithoutFrom(SSelectStmt* pSelect, SRetrieveTableRsp** p
   if (TSDB_CODE_SUCCESS == code) {
     code = buildRetrieveTableRsp(pBlock, LIST_LENGTH(pSelect->pProjectionList), pRsp);
   }
-  blockDataDestroy(pBlock);
+  (void)blockDataDestroy(pBlock);
   return code;
 }
 
@@ -929,7 +959,7 @@ static int32_t execShowCreateView(SShowCreateViewStmt* pStmt, SRetrieveTableRsp*
   if (TSDB_CODE_SUCCESS == code) {
     code = buildRetrieveTableRsp(pBlock, SHOW_CREATE_VIEW_RESULT_COLS, pRsp);
   }
-  blockDataDestroy(pBlock);
+  (void)blockDataDestroy(pBlock);
   return code;
 }
 
diff --git a/source/libs/command/src/explain.c b/source/libs/command/src/explain.c
index 2ac7e6ae3b..843e3ee734 100644
--- a/source/libs/command/src/explain.c
+++ b/source/libs/command/src/explain.c
@@ -199,7 +199,7 @@ int32_t qExplainGenerateResNodeExecInfo(SPhysiNode *pNode, SArray **pExecInfo, S
       return TSDB_CODE_APP_ERROR;
     }
     
-    taosArrayPush(*pExecInfo, rsp->subplanInfo + group->physiPlanExecIdx);
+    if(taosArrayPush(*pExecInfo, rsp->subplanInfo + group->physiPlanExecIdx) == NULL) return terrno;
   } else {
     for (int32_t i = 0; i < group->nodeNum; ++i) {
       rsp = taosArrayGet(group->nodeExecInfo, i);
@@ -208,7 +208,7 @@ int32_t qExplainGenerateResNodeExecInfo(SPhysiNode *pNode, SArray **pExecInfo, S
         return TSDB_CODE_APP_ERROR;
       }
 
-      taosArrayPush(*pExecInfo, rsp->subplanInfo + group->physiPlanExecIdx);
+      if(taosArrayPush(*pExecInfo, rsp->subplanInfo + group->physiPlanExecIdx) == NULL) return terrno;
     }
   }
 
@@ -1920,6 +1920,7 @@ _return:
 }
 
 int32_t qExplainGetRspFromCtx(void *ctx, SRetrieveTableRsp **pRsp) {
+  int32_t          code = 0;
   SExplainCtx *pCtx = (SExplainCtx *)ctx;
   int32_t      rowNum = taosArrayGetSize(pCtx->rows);
   if (rowNum <= 0) {
@@ -1929,14 +1930,14 @@ int32_t qExplainGetRspFromCtx(void *ctx, SRetrieveTableRsp **pRsp) {
 
   SSDataBlock    *pBlock = createDataBlock();
   SColumnInfoData infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, TSDB_EXPLAIN_RESULT_ROW_SIZE, 1);
-  blockDataAppendColInfo(pBlock, &infoData);
-  blockDataEnsureCapacity(pBlock, rowNum);
+  QRY_ERR_JRET(blockDataAppendColInfo(pBlock, &infoData));
+  QRY_ERR_JRET(blockDataEnsureCapacity(pBlock, rowNum));
 
   SColumnInfoData *pInfoData = taosArrayGet(pBlock->pDataBlock, 0);
 
   for (int32_t i = 0; i < rowNum; ++i) {
     SQueryExplainRowInfo *row = taosArrayGet(pCtx->rows, i);
-    colDataSetVal(pInfoData, i, row->buf, false);
+    QRY_ERR_JRET(colDataSetVal(pInfoData, i, row->buf, false));
   }
 
   pBlock->info.rows = rowNum;
@@ -1946,8 +1947,7 @@ int32_t qExplainGetRspFromCtx(void *ctx, SRetrieveTableRsp **pRsp) {
   SRetrieveTableRsp *rsp = (SRetrieveTableRsp *)taosMemoryCalloc(1, rspSize);
   if (NULL == rsp) {
     qError("malloc SRetrieveTableRsp failed, size:%d", rspSize);
-    blockDataDestroy(pBlock);
-    QRY_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
+    QRY_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   rsp->completed = 1;
@@ -1961,10 +1961,11 @@ int32_t qExplainGetRspFromCtx(void *ctx, SRetrieveTableRsp **pRsp) {
 
   SET_PAYLOAD_LEN(rsp->data, len, len);
 
+_return:
   blockDataDestroy(pBlock);
 
   *pRsp = rsp;
-  return TSDB_CODE_SUCCESS;
+  QRY_RET(code);
 }
 
 int32_t qExplainPrepareCtx(SQueryPlan *pDag, SExplainCtx **pCtx) {
@@ -2099,32 +2100,30 @@ int32_t qExplainUpdateExecInfo(SExplainCtx *pCtx, SExplainRsp *pRspMsg, int32_t
     group->nodeExecInfo = taosArrayInit(group->nodeNum, sizeof(SExplainRsp));
     if (NULL == group->nodeExecInfo) {
       qError("taosArrayInit %d explainExecInfo failed", group->nodeNum);
-      tFreeSExplainRsp(pRspMsg);
-      taosWUnLockLatch(&group->lock);
-
-      QRY_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      TAOS_CHECK_ERRNO(code);
     }
 
     group->physiPlanExecNum = pRspMsg->numOfPlans;
   } else if (taosArrayGetSize(group->nodeExecInfo) >= group->nodeNum) {
     qError("group execInfo already full, size:%d, nodeNum:%d", (int32_t)taosArrayGetSize(group->nodeExecInfo),
            group->nodeNum);
-    tFreeSExplainRsp(pRspMsg);
-    taosWUnLockLatch(&group->lock);
-
-    QRY_ERR_RET(TSDB_CODE_APP_ERROR);
+    code = TSDB_CODE_APP_ERROR;
+    TAOS_CHECK_ERRNO(code);
   }
 
   if (group->physiPlanExecNum != pRspMsg->numOfPlans) {
     qError("physiPlanExecNum %d mismatch with others %d in group %d", pRspMsg->numOfPlans, group->physiPlanExecNum,
            groupId);
-    tFreeSExplainRsp(pRspMsg);
-    taosWUnLockLatch(&group->lock);
-
-    QRY_ERR_RET(TSDB_CODE_APP_ERROR);
+    code = TSDB_CODE_APP_ERROR;
+    TAOS_CHECK_ERRNO(code);
   }
 
-  taosArrayPush(group->nodeExecInfo, pRspMsg);
+  if(taosArrayPush(group->nodeExecInfo, pRspMsg) == NULL)
+  {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    TAOS_CHECK_ERRNO(code);
+  }
  
   groupDone = (taosArrayGetSize(group->nodeExecInfo) >= group->nodeNum);
 
@@ -2140,6 +2139,11 @@ int32_t qExplainUpdateExecInfo(SExplainCtx *pCtx, SExplainRsp *pRspMsg, int32_t
   }
 
   return TSDB_CODE_SUCCESS;
+
+_exit:
+  tFreeSExplainRsp(pRspMsg);
+  taosWUnLockLatch(&group->lock);
+  return code;
 }
 
 int32_t qExecStaticExplain(SQueryPlan *pDag, SRetrieveTableRsp **pRsp) {
diff --git a/source/libs/qcom/src/querymsg.c b/source/libs/qcom/src/querymsg.c
index b13919e5e1..e8deed1df9 100644
--- a/source/libs/qcom/src/querymsg.c
+++ b/source/libs/qcom/src/querymsg.c
@@ -85,7 +85,10 @@ int32_t queryBuildTableMetaReqMsg(void *input, char **msg, int32_t msgSize, int3
 
   int32_t bufLen = tSerializeSTableInfoReq(NULL, 0, &infoReq);
   void   *pBuf = (*mallcFp)(bufLen);
-  tSerializeSTableInfoReq(pBuf, bufLen, &infoReq);
+  if(tSerializeSTableInfoReq(pBuf, bufLen, &infoReq) < 0)
+  {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
 
   *msg = pBuf;
   *msgLen = bufLen;
@@ -109,7 +112,10 @@ int32_t queryBuildUseDbMsg(void *input, char **msg, int32_t msgSize, int32_t *ms
 
   int32_t bufLen = tSerializeSUseDbReq(NULL, 0, &usedbReq);
   void   *pBuf = (*mallcFp)(bufLen);
-  tSerializeSUseDbReq(pBuf, bufLen, &usedbReq);
+  if(tSerializeSUseDbReq(pBuf, bufLen, &usedbReq) < 0)
+  {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
 
   *msg = pBuf;
   *msgLen = bufLen;
@@ -127,7 +133,10 @@ int32_t queryBuildQnodeListMsg(void *input, char **msg, int32_t msgSize, int32_t
 
   int32_t bufLen = tSerializeSQnodeListReq(NULL, 0, &qnodeListReq);
   void   *pBuf = (*mallcFp)(bufLen);
-  tSerializeSQnodeListReq(pBuf, bufLen, &qnodeListReq);
+  if(tSerializeSQnodeListReq(pBuf, bufLen, &qnodeListReq) < 0)
+  {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
 
   *msg = pBuf;
   *msgLen = bufLen;
@@ -145,7 +154,10 @@ int32_t queryBuildDnodeListMsg(void *input, char **msg, int32_t msgSize, int32_t
 
   int32_t bufLen = tSerializeSDnodeListReq(NULL, 0, &dnodeListReq);
   void   *pBuf = (*mallcFp)(bufLen);
-  tSerializeSDnodeListReq(pBuf, bufLen, &dnodeListReq);
+  if(tSerializeSDnodeListReq(pBuf, bufLen, &dnodeListReq) < 0)
+  {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
 
   *msg = pBuf;
   *msgLen = bufLen;
@@ -162,7 +174,10 @@ int32_t queryBuildGetSerVerMsg(void *input, char **msg, int32_t msgSize, int32_t
 
   int32_t bufLen = tSerializeSServerVerReq(NULL, 0, &req);
   void   *pBuf = (*mallcFp)(bufLen);
-  tSerializeSServerVerReq(pBuf, bufLen, &req);
+  if(tSerializeSServerVerReq(pBuf, bufLen, &req) < 0)
+  {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
 
   *msg = pBuf;
   *msgLen = bufLen;
@@ -180,7 +195,10 @@ int32_t queryBuildGetDBCfgMsg(void *input, char **msg, int32_t msgSize, int32_t
 
   int32_t bufLen = tSerializeSDbCfgReq(NULL, 0, &dbCfgReq);
   void   *pBuf = (*mallcFp)(bufLen);
-  tSerializeSDbCfgReq(pBuf, bufLen, &dbCfgReq);
+  if(tSerializeSDbCfgReq(pBuf, bufLen, &dbCfgReq) < 0)
+  {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
 
   *msg = pBuf;
   *msgLen = bufLen;
@@ -198,7 +216,10 @@ int32_t queryBuildGetIndexMsg(void *input, char **msg, int32_t msgSize, int32_t
 
   int32_t bufLen = tSerializeSUserIndexReq(NULL, 0, &indexReq);
   void   *pBuf = (*mallcFp)(bufLen);
-  tSerializeSUserIndexReq(pBuf, bufLen, &indexReq);
+  if(tSerializeSUserIndexReq(pBuf, bufLen, &indexReq) < 0)
+  {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
 
   *msg = pBuf;
   *msgLen = bufLen;
@@ -216,11 +237,20 @@ int32_t queryBuildRetrieveFuncMsg(void *input, char **msg, int32_t msgSize, int3
   funcReq.numOfFuncs = 1;
   funcReq.ignoreCodeComment = true;
   funcReq.pFuncNames = taosArrayInit(1, strlen(input) + 1);
-  taosArrayPush(funcReq.pFuncNames, input);
+  if (NULL == funcReq.pFuncNames) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+  if (taosArrayPush(funcReq.pFuncNames, input) == NULL) {
+    taosArrayDestroy(funcReq.pFuncNames);
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
 
   int32_t bufLen = tSerializeSRetrieveFuncReq(NULL, 0, &funcReq);
   void   *pBuf = (*mallcFp)(bufLen);
-  tSerializeSRetrieveFuncReq(pBuf, bufLen, &funcReq);
+  if(tSerializeSRetrieveFuncReq(pBuf, bufLen, &funcReq) < 0)
+  {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
 
   taosArrayDestroy(funcReq.pFuncNames);
 
@@ -240,7 +270,9 @@ int32_t queryBuildGetUserAuthMsg(void *input, char **msg, int32_t msgSize, int32
 
   int32_t bufLen = tSerializeSGetUserAuthReq(NULL, 0, &req);
   void   *pBuf = (*mallcFp)(bufLen);
-  tSerializeSGetUserAuthReq(pBuf, bufLen, &req);
+  if (tSerializeSGetUserAuthReq(pBuf, bufLen, &req) < 0) {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
 
   *msg = pBuf;
   *msgLen = bufLen;
@@ -258,7 +290,10 @@ int32_t queryBuildGetTbIndexMsg(void *input, char **msg, int32_t msgSize, int32_
 
   int32_t bufLen = tSerializeSTableIndexReq(NULL, 0, &indexReq);
   void   *pBuf = (*mallcFp)(bufLen);
-  tSerializeSTableIndexReq(pBuf, bufLen, &indexReq);
+  if(tSerializeSTableIndexReq(pBuf, bufLen, &indexReq) < 0)
+  {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
 
   *msg = pBuf;
   *msgLen = bufLen;
@@ -279,7 +314,10 @@ int32_t queryBuildGetTbCfgMsg(void *input, char **msg, int32_t msgSize, int32_t
 
   int32_t bufLen = tSerializeSTableCfgReq(NULL, 0, &cfgReq);
   void   *pBuf = (*mallcFp)(bufLen);
-  tSerializeSTableCfgReq(pBuf, bufLen, &cfgReq);
+  if(tSerializeSTableCfgReq(pBuf, bufLen, &cfgReq) < 0)
+  {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
 
   *msg = pBuf;
   *msgLen = bufLen;
@@ -297,7 +335,10 @@ int32_t queryBuildGetViewMetaMsg(void *input, char **msg, int32_t msgSize, int32
 
   int32_t bufLen = tSerializeSViewMetaReq(NULL, 0, &req);
   void   *pBuf = (*mallcFp)(bufLen);
-  tSerializeSViewMetaReq(pBuf, bufLen, &req);
+  if(tSerializeSViewMetaReq(pBuf, bufLen, &req) < 0)
+  {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
 
   *msg = pBuf;
   *msgLen = bufLen;
@@ -316,7 +357,10 @@ int32_t queryBuildGetTableTSMAMsg(void *input, char **msg, int32_t msgSize, int3
 
   int32_t bufLen = tSerializeTableTSMAInfoReq(NULL, 0, &req);
   void *  pBuf = (*mallcFp)(bufLen);
-  tSerializeTableTSMAInfoReq(pBuf, bufLen, &req);
+  if(tSerializeTableTSMAInfoReq(pBuf, bufLen, &req) < 0)
+  {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
 
   *msg = pBuf;
   *msgLen = bufLen;
@@ -335,7 +379,10 @@ int32_t queryBuildGetTSMAMsg(void *input, char **msg, int32_t msgSize, int32_t *
 
   int32_t bufLen = tSerializeTableTSMAInfoReq(NULL, 0, &req);
   void *  pBuf = (*mallcFp)(bufLen);
-  tSerializeTableTSMAInfoReq(pBuf, bufLen, &req);
+  if(tSerializeTableTSMAInfoReq(pBuf, bufLen, &req) < 0)
+  {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
 
   *msg = pBuf;
   *msgLen = bufLen;
@@ -350,7 +397,10 @@ int32_t queryBuildGetStreamProgressMsg(void* input, char** msg, int32_t msgSize,
   int32_t len = tSerializeStreamProgressReq(NULL, 0, input);
   void* pBuf = (*mallcFp)(len);
 
-  tSerializeStreamProgressReq(pBuf, len, input);
+  if(tSerializeStreamProgressReq(pBuf, len, input) < 0)
+  {
+    return TSDB_CODE_TSC_INVALID_INPUT;
+  }
 
   *msg = pBuf;
   *msgLen = len;
@@ -713,6 +763,9 @@ int32_t queryProcessGetTbCfgRsp(void *output, char *msg, int32_t msgSize) {
   }
 
   STableCfgRsp *out = taosMemoryCalloc(1, sizeof(STableCfgRsp));
+  if(out == NULL) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
   if (tDeserializeSTableCfgRsp(msg, msgSize, out) != 0) {
     qError("tDeserializeSTableCfgRsp failed, msgSize:%d", msgSize);
     tFreeSTableCfgRsp(out);
@@ -731,6 +784,9 @@ int32_t queryProcessGetViewMetaRsp(void *output, char *msg, int32_t msgSize) {
   }
 
   SViewMetaRsp *out = taosMemoryCalloc(1, sizeof(SViewMetaRsp));
+  if (out == NULL) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
   if (tDeserializeSViewMetaRsp(msg, msgSize, out) != 0) {
     qError("tDeserializeSViewMetaRsp failed, msgSize:%d", msgSize);
     tFreeSViewMetaRsp(out);