From 929cb703e72eba118b222df874d18328403415fe Mon Sep 17 00:00:00 2001
From: dmchen <cademfly@hotmail.com>
Date: Thu, 25 Jul 2024 09:49:58 +0000
Subject: [PATCH] fix/TD-30989

---
 source/dnode/mnode/impl/src/mndDb.c    | 154 +++++----
 source/dnode/mnode/impl/src/mndDef.c   |  40 ++-
 source/dnode/mnode/impl/src/mndDnode.c | 206 ++++++-----
 source/dnode/mnode/impl/src/mndDump.c  | 460 ++++++++++++-------------
 source/dnode/mnode/impl/src/mndFunc.c  |  52 +--
 5 files changed, 488 insertions(+), 424 deletions(-)

diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c
index a6d37a5566..973215fdbd 100644
--- a/source/dnode/mnode/impl/src/mndDb.c
+++ b/source/dnode/mnode/impl/src/mndDb.c
@@ -738,15 +738,15 @@ static int32_t mndCreateDb(SMnode *pMnode, SRpcMsg *pReq, SCreateDbReq *pCreate,
   int32_t  code = 0;
   SUserObj newUserObj = {0};
   SDbObj   dbObj = {0};
-  memcpy(dbObj.name, pCreate->db, TSDB_DB_FNAME_LEN);
-  memcpy(dbObj.acct, pUser->acct, TSDB_USER_LEN);
+  (void)memcpy(dbObj.name, pCreate->db, TSDB_DB_FNAME_LEN);
+  (void)memcpy(dbObj.acct, pUser->acct, TSDB_USER_LEN);
   dbObj.createdTime = taosGetTimestampMs();
   dbObj.updateTime = dbObj.createdTime;
   dbObj.uid = mndGenerateUid(dbObj.name, TSDB_DB_FNAME_LEN);
   dbObj.cfgVersion = 1;
   dbObj.vgVersion = 1;
   dbObj.tsmaVersion = 1;
-  memcpy(dbObj.createUser, pUser->user, TSDB_USER_LEN);
+  (void)memcpy(dbObj.createUser, pUser->user, TSDB_USER_LEN);
   dbObj.cfg = (SDbCfg){
       .numOfVgroups = pCreate->numOfVgroups,
       .numOfStables = pCreate->numOfStables,
@@ -820,8 +820,10 @@ static int32_t mndCreateDb(SMnode *pMnode, SRpcMsg *pReq, SCreateDbReq *pCreate,
   SUserObj *pNewUserDuped = NULL;
   if (!pUser->superUser) {
     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);
+    TAOS_CHECK_GOTO(taosHashPut(newUserObj.readDbs, dbObj.name, strlen(dbObj.name) + 1, dbObj.name, TSDB_FILENAME_LEN),
+                    NULL, _OVER);
+    TAOS_CHECK_GOTO(taosHashPut(newUserObj.writeDbs, dbObj.name, strlen(dbObj.name) + 1, dbObj.name, TSDB_FILENAME_LEN),
+                    NULL, _OVER);
     pNewUserDuped = &newUserObj;
   }
 
@@ -855,17 +857,17 @@ _OVER:
 
 static void mndBuildAuditDetailInt32(char *detail, char *tmp, char *format, int32_t para) {
   if (para > 0) {
-    if (strlen(detail) > 0) strcat(detail, ", ");
-    sprintf(tmp, format, para);
-    strcat(detail, tmp);
+    if (strlen(detail) > 0) (void)strcat(detail, ", ");
+    (void)sprintf(tmp, format, para);
+    (void)strcat(detail, tmp);
   }
 }
 
 static void mndBuildAuditDetailInt64(char *detail, char *tmp, char *format, int64_t para) {
   if (para > 0) {
-    if (strlen(detail) > 0) strcat(detail, ", ");
-    sprintf(tmp, format, para);
-    strcat(detail, tmp);
+    if (strlen(detail) > 0) (void)strcat(detail, ", ");
+    (void)sprintf(tmp, format, para);
+    (void)strcat(detail, tmp);
   }
 }
 
@@ -967,7 +969,7 @@ static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) {
   if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;
 
   SName name = {0};
-  tNameFromString(&name, createReq.db, T_NAME_ACCT | T_NAME_DB);
+  (void)tNameFromString(&name, createReq.db, T_NAME_ACCT | T_NAME_DB);
 
   auditRecord(pReq, pMnode->clusterId, "createDB", name.dbname, "", createReq.sql, createReq.sqlLen);
 
@@ -1250,7 +1252,7 @@ static int32_t mndProcessAlterDbReq(SRpcMsg *pReq) {
     goto _OVER;
   }
 
-  memcpy(&dbObj, pDb, sizeof(SDbObj));
+  (void)memcpy(&dbObj, pDb, sizeof(SDbObj));
   if (dbObj.cfg.pRetensions != NULL) {
     dbObj.cfg.pRetensions = taosArrayDup(pDb->cfg.pRetensions, NULL);
     if (dbObj.cfg.pRetensions == NULL) goto _OVER;
@@ -1276,7 +1278,7 @@ static int32_t mndProcessAlterDbReq(SRpcMsg *pReq) {
   }
 
   SName name = {0};
-  tNameFromString(&name, alterReq.db, T_NAME_ACCT | T_NAME_DB);
+  (void)tNameFromString(&name, alterReq.db, T_NAME_ACCT | T_NAME_DB);
 
   auditRecord(pReq, pMnode->clusterId, "alterDB", name.dbname, "", alterReq.sql, alterReq.sqlLen);
 
@@ -1294,7 +1296,7 @@ _OVER:
 }
 
 static void mndDumpDbCfgInfo(SDbCfgRsp *cfgRsp, SDbObj *pDb) {
-  strcpy(cfgRsp->db, pDb->name);
+  (void)strcpy(cfgRsp->db, pDb->name);
   cfgRsp->dbId = pDb->uid;
   cfgRsp->cfgVersion = pDb->cfgVersion;
   cfgRsp->numOfVgroups = pDb->cfg.numOfVgroups;
@@ -1363,7 +1365,7 @@ static int32_t mndProcessGetDbCfgReq(SRpcMsg *pReq) {
     goto _OVER;
   }
 
-  tSerializeSDbCfgRsp(pRsp, contLen, &cfgRsp);
+  (void)tSerializeSDbCfgRsp(pRsp, contLen, &cfgRsp);
 
   pReq->info.rsp = pRsp;
   pReq->info.rspLen = contLen;
@@ -1537,7 +1539,7 @@ static int32_t mndBuildDropDbRsp(SDbObj *pDb, int32_t *pRspLen, void **ppRsp, bo
   int32_t    code = 0;
   SDropDbRsp dropRsp = {0};
   if (pDb != NULL) {
-    memcpy(dropRsp.db, pDb->name, TSDB_DB_FNAME_LEN);
+    (void)memcpy(dropRsp.db, pDb->name, TSDB_DB_FNAME_LEN);
     dropRsp.uid = pDb->uid;
   }
 
@@ -1554,7 +1556,7 @@ static int32_t mndBuildDropDbRsp(SDbObj *pDb, int32_t *pRspLen, void **ppRsp, bo
     TAOS_RETURN(code);
   }
 
-  tSerializeSDropDbRsp(pRsp, rspLen, &dropRsp);
+  (void)tSerializeSDropDbRsp(pRsp, rspLen, &dropRsp);
   *pRspLen = rspLen;
   *ppRsp = pRsp;
   TAOS_RETURN(code);
@@ -1635,7 +1637,7 @@ static int32_t mndProcessDropDbReq(SRpcMsg *pReq) {
   }
 
   SName name = {0};
-  tNameFromString(&name, dropReq.db, T_NAME_ACCT | T_NAME_DB);
+  (void)tNameFromString(&name, dropReq.db, T_NAME_ACCT | T_NAME_DB);
 
   auditRecord(pReq, pMnode->clusterId, "dropDB", name.dbname, "", dropReq.sql, dropReq.sqlLen);
 
@@ -1694,7 +1696,7 @@ void mndBuildDBVgroupInfo(SDbObj *pDb, SMnode *pMnode, SArray *pVgList) {
         SEp       *pEp = &vgInfo.epSet.eps[gid];
         SDnodeObj *pDnode = mndAcquireDnode(pMnode, pVgid->dnodeId);
         if (pDnode != NULL) {
-          memcpy(pEp->fqdn, pDnode->fqdn, TSDB_FQDN_LEN);
+          (void)memcpy(pEp->fqdn, pDnode->fqdn, TSDB_FQDN_LEN);
           pEp->port = pDnode->port;
         }
         mndReleaseDnode(pMnode, pDnode);
@@ -1703,7 +1705,7 @@ void mndBuildDBVgroupInfo(SDbObj *pDb, SMnode *pMnode, SArray *pVgList) {
         }
       }
       vindex++;
-      taosArrayPush(pVgList, &vgInfo);
+      (void)taosArrayPush(pVgList, &vgInfo);
     }
 
     sdbRelease(pSdb, pVgroup);
@@ -1730,7 +1732,7 @@ int32_t mndExtractDbInfo(SMnode *pMnode, SDbObj *pDb, SUseDbRsp *pRsp, const SUs
     mndBuildDBVgroupInfo(pDb, pMnode, pRsp->pVgroupInfos);
   }
 
-  memcpy(pRsp->db, pDb->name, TSDB_DB_FNAME_LEN);
+  (void)memcpy(pRsp->db, pDb->name, TSDB_DB_FNAME_LEN);
   pRsp->uid = pDb->uid;
   pRsp->vgVersion = pDb->vgVersion;
   pRsp->stateTs = pDb->stateTs;
@@ -1752,7 +1754,7 @@ static int32_t mndProcessUseDbReq(SRpcMsg *pReq) {
 
   char *p = strchr(usedbReq.db, '.');
   if (p && ((0 == strcmp(p + 1, TSDB_INFORMATION_SCHEMA_DB) || (0 == strcmp(p + 1, TSDB_PERFORMANCE_SCHEMA_DB))))) {
-    memcpy(usedbRsp.db, usedbReq.db, TSDB_DB_FNAME_LEN);
+    (void)memcpy(usedbRsp.db, usedbReq.db, TSDB_DB_FNAME_LEN);
     int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);
     if (usedbReq.vgVersion < vgVersion) {
       usedbRsp.pVgroupInfos = taosArrayInit(10, sizeof(SVgroupInfo));
@@ -1768,7 +1770,7 @@ static int32_t mndProcessUseDbReq(SRpcMsg *pReq) {
   } else {
     pDb = mndAcquireDb(pMnode, usedbReq.db);
     if (pDb == NULL) {
-      memcpy(usedbRsp.db, usedbReq.db, TSDB_DB_FNAME_LEN);
+      (void)memcpy(usedbRsp.db, usedbReq.db, TSDB_DB_FNAME_LEN);
       usedbRsp.uid = usedbReq.dbId;
       usedbRsp.vgVersion = usedbReq.vgVersion;
       usedbRsp.errCode = terrno;
@@ -1795,7 +1797,7 @@ static int32_t mndProcessUseDbReq(SRpcMsg *pReq) {
     goto _OVER;
   }
 
-  tSerializeSUseDbRsp(pRsp, contLen, &usedbRsp);
+  (void)tSerializeSUseDbRsp(pRsp, contLen, &usedbRsp);
 
   pReq->info.rsp = pRsp;
   pReq->info.rspLen = contLen;
@@ -1839,7 +1841,7 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
       }
 
       rsp.useDbRsp = taosMemoryCalloc(1, sizeof(SUseDbRsp));
-      memcpy(rsp.useDbRsp->db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);
+      (void)memcpy(rsp.useDbRsp->db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);
       rsp.useDbRsp->pVgroupInfos = taosArrayInit(10, sizeof(SVgroupInfo));
 
       mndBuildDBVgroupInfo(NULL, pMnode, rsp.useDbRsp->pVgroupInfos);
@@ -1847,7 +1849,7 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
 
       rsp.useDbRsp->vgNum = taosArrayGetSize(rsp.useDbRsp->pVgroupInfos);
 
-      taosArrayPush(batchRsp.pArray, &rsp);
+      (void)taosArrayPush(batchRsp.pArray, &rsp);
 
       continue;
     }
@@ -1856,10 +1858,10 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
     if (pDb == NULL) {
       mTrace("db:%s, no exist", pDbCacheInfo->dbFName);
       rsp.useDbRsp = taosMemoryCalloc(1, sizeof(SUseDbRsp));
-      memcpy(rsp.useDbRsp->db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);
+      (void)memcpy(rsp.useDbRsp->db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);
       rsp.useDbRsp->uid = pDbCacheInfo->dbId;
       rsp.useDbRsp->vgVersion = -1;
-      taosArrayPush(batchRsp.pArray, &rsp);
+      (void)taosArrayPush(batchRsp.pArray, &rsp);
       continue;
     }
 
@@ -1892,7 +1894,11 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
       if (rsp.pTsmaRsp && rsp.pTsmaRsp->pTsmas) {
         rsp.dbTsmaVersion = pDb->tsmaVersion;
         bool exist = false;
-        mndGetDbTsmas(pMnode, 0, pDb->uid, rsp.pTsmaRsp, &exist);
+        if (mndGetDbTsmas(pMnode, 0, pDb->uid, rsp.pTsmaRsp, &exist) != 0) {
+          mndReleaseDb(pMnode, pDb);
+          mError("db:%s, failed to get db tsmas", pDb->name);
+          continue;
+        }
       }
     }
 
@@ -1907,7 +1913,7 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
       }
 
       mndBuildDBVgroupInfo(pDb, pMnode, rsp.useDbRsp->pVgroupInfos);
-      memcpy(rsp.useDbRsp->db, pDb->name, TSDB_DB_FNAME_LEN);
+      (void)memcpy(rsp.useDbRsp->db, pDb->name, TSDB_DB_FNAME_LEN);
       rsp.useDbRsp->uid = pDb->uid;
       rsp.useDbRsp->vgVersion = pDb->vgVersion;
       rsp.useDbRsp->stateTs = pDb->stateTs;
@@ -1917,7 +1923,7 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
       rsp.useDbRsp->hashSuffix = pDb->cfg.hashSuffix;
     }
 
-    taosArrayPush(batchRsp.pArray, &rsp);
+    (void)taosArrayPush(batchRsp.pArray, &rsp);
     mndReleaseDb(pMnode, pDb);
   }
 
@@ -1928,7 +1934,7 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
     tFreeSDbHbBatchRsp(&batchRsp);
     return -1;
   }
-  tSerializeSDbHbBatchRsp(pRsp, rspLen, &batchRsp);
+  (void)tSerializeSDbHbBatchRsp(pRsp, rspLen, &batchRsp);
 
   *ppRsp = pRsp;
   *pRspLen = rspLen;
@@ -1957,7 +1963,7 @@ static int32_t mndTrimDb(SMnode *pMnode, SDbObj *pDb) {
     }
     pHead->contLen = htonl(contLen);
     pHead->vgId = htonl(pVgroup->vgId);
-    tSerializeSVTrimDbReq((char *)pHead + sizeof(SMsgHead), contLen, &trimReq);
+    (void)tSerializeSVTrimDbReq((char *)pHead + sizeof(SMsgHead), contLen, &trimReq);
 
     SRpcMsg rpcMsg = {.msgType = TDMT_VND_TRIM, .pCont = pHead, .contLen = contLen};
     SEpSet  epSet = mndGetVgroupEpset(pMnode, pVgroup);
@@ -2025,7 +2031,7 @@ static int32_t mndS3MigrateDb(SMnode *pMnode, SDbObj *pDb) {
     }
     pHead->contLen = htonl(contLen);
     pHead->vgId = htonl(pVgroup->vgId);
-    tSerializeSVS3MigrateDbReq((char *)pHead + sizeof(SMsgHead), contLen, &s3migrateReq);
+    (void)tSerializeSVS3MigrateDbReq((char *)pHead + sizeof(SMsgHead), contLen, &s3migrateReq);
 
     SRpcMsg rpcMsg = {.msgType = TDMT_VND_S3MIGRATE, .pCont = pHead, .contLen = contLen};
     SEpSet  epSet = mndGetVgroupEpset(pMnode, pVgroup);
@@ -2250,46 +2256,46 @@ static void mndDumpDbInfoData(SMnode *pMnode, SSDataBlock *pBlock, SDbObj *pDb,
     for (int32_t i = 0; i < pShow->numOfColumns; ++i) {
       SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, i);
       if (i == 0) {
-        colDataSetVal(pColInfo, rows, buf, false);
+        (void)colDataSetVal(pColInfo, rows, buf, false);
       } else if (i == 1) {
-        colDataSetVal(pColInfo, rows, (const char *)&pDb->createdTime, false);
+        (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->createdTime, false);
       } else if (i == 3) {
-        colDataSetVal(pColInfo, rows, (const char *)&numOfTables, false);
+        (void)colDataSetVal(pColInfo, rows, (const char *)&numOfTables, false);
       } else if (i == 14) {
-        colDataSetVal(pColInfo, rows, precVstr, false);
+        (void)colDataSetVal(pColInfo, rows, precVstr, false);
       } else if (i == 15) {
-        colDataSetVal(pColInfo, rows, statusVstr, false);
+        (void)colDataSetVal(pColInfo, rows, statusVstr, false);
       } else {
         colDataSetNULL(pColInfo, rows);
       }
     }
   } else {
     SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, buf, false);
+    (void)colDataSetVal(pColInfo, rows, buf, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->createdTime, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->createdTime, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.numOfVgroups, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.numOfVgroups, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&numOfTables, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&numOfTables, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.replications, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.replications, false);
 
     const char *strictStr = pDb->cfg.strict ? "on" : "off";
     char        strictVstr[24] = {0};
     STR_WITH_MAXSIZE_TO_VARSTR(strictVstr, strictStr, 24);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)strictVstr, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)strictVstr, false);
 
     char    durationVstr[128] = {0};
     int32_t len = sprintf(&durationVstr[VARSTR_HEADER_SIZE], "%dm", pDb->cfg.daysPerFile);
     varDataSetLen(durationVstr, len);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)durationVstr, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)durationVstr, false);
 
     char keepVstr[128] = {0};
     if (pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep1 || pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep2) {
@@ -2301,67 +2307,67 @@ static void mndDumpDbInfoData(SMnode *pMnode, SSDataBlock *pBlock, SDbObj *pDb,
     }
     varDataSetLen(keepVstr, len);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)keepVstr, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)keepVstr, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.buffer, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.buffer, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.pageSize, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.pageSize, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.pages, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.pages, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.minRows, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.minRows, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.maxRows, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.maxRows, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.compression, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.compression, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)precVstr, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)precVstr, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)statusVstr, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)statusVstr, false);
 
     char *rentensionVstr = buildRetension(pDb->cfg.pRetensions);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     if (rentensionVstr == NULL) {
       colDataSetNULL(pColInfo, rows);
     } else {
-      colDataSetVal(pColInfo, rows, (const char *)rentensionVstr, false);
+      (void)colDataSetVal(pColInfo, rows, (const char *)rentensionVstr, false);
       taosMemoryFree(rentensionVstr);
     }
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.numOfStables, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.numOfStables, false);
 
     const char *cacheModelStr = getCacheModelStr(pDb->cfg.cacheLast);
     char        cacheModelVstr[24] = {0};
     STR_WITH_MAXSIZE_TO_VARSTR(cacheModelVstr, cacheModelStr, 24);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)cacheModelVstr, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)cacheModelVstr, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.cacheLastSize, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.cacheLastSize, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walLevel, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walLevel, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walFsyncPeriod, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walFsyncPeriod, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walRetentionPeriod, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walRetentionPeriod, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walRetentionSize, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walRetentionSize, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.sstTrigger, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.sstTrigger, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     int16_t hashPrefix = pDb->cfg.hashPrefix;
@@ -2370,37 +2376,37 @@ static void mndDumpDbInfoData(SMnode *pMnode, SSDataBlock *pBlock, SDbObj *pDb,
     } else if (hashPrefix < 0) {
       hashPrefix = pDb->cfg.hashPrefix + strlen(pDb->name) + 1;
     }
-    colDataSetVal(pColInfo, rows, (const char *)&hashPrefix, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&hashPrefix, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.hashSuffix, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.hashSuffix, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.tsdbPageSize, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.tsdbPageSize, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.keepTimeOffset, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.keepTimeOffset, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.s3ChunkSize, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.s3ChunkSize, false);
 
     char keeplocalVstr[128] = {0};
     len = sprintf(&keeplocalVstr[VARSTR_HEADER_SIZE], "%dm", pDb->cfg.s3KeepLocal);
     varDataSetLen(keeplocalVstr, len);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)keeplocalVstr, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)keeplocalVstr, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.s3Compact, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.s3Compact, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.withArbitrator, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.withArbitrator, false);
 
     const char *encryptAlgorithmStr = getEncryptAlgorithmStr(pDb->cfg.encryptAlgorithm);
     char        encryptAlgorithmVStr[24] = {0};
     STR_WITH_MAXSIZE_TO_VARSTR(encryptAlgorithmVStr, encryptAlgorithmStr, 24);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)encryptAlgorithmVStr, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)encryptAlgorithmVStr, false);
   }
 
   taosMemoryFree(buf);
diff --git a/source/dnode/mnode/impl/src/mndDef.c b/source/dnode/mnode/impl/src/mndDef.c
index 32f8fb8548..6fdd77af98 100644
--- a/source/dnode/mnode/impl/src/mndDef.c
+++ b/source/dnode/mnode/impl/src/mndDef.c
@@ -158,10 +158,19 @@ int32_t tDecodeSStreamObj(SDecoder *pDecoder, SStreamObj *pObj, int32_t sver) {
             taosArrayDestroy(pArray);
             TAOS_RETURN(code);
           }
-          taosArrayPush(pArray, &pTask);
+          if (taosArrayPush(pArray, &pTask) == NULL) {
+            taosMemoryFree(pTask);
+            taosArrayDestroy(pArray);
+            code = TSDB_CODE_OUT_OF_MEMORY;
+            TAOS_RETURN(code);
+          }
         }
       }
-      taosArrayPush(pObj->tasks, &pArray);
+      if (taosArrayPush(pObj->tasks, &pArray) == NULL) {
+        taosArrayDestroy(pArray);
+        code = TSDB_CODE_OUT_OF_MEMORY;
+        TAOS_RETURN(code);
+      }
     }
   }
 
@@ -436,10 +445,15 @@ void *tDecodeSMqConsumerObj(const void *buf, SMqConsumerObj *pConsumer, int8_t s
   // current topics
   buf = taosDecodeFixedI32(buf, &sz);
   pConsumer->currentTopics = taosArrayInit(sz, sizeof(void *));
+  if (pConsumer->currentTopics == NULL) {
+    return NULL;
+  }
   for (int32_t i = 0; i < sz; i++) {
     char *topic;
     buf = taosDecodeString(buf, &topic);
-    taosArrayPush(pConsumer->currentTopics, &topic);
+    if (taosArrayPush(pConsumer->currentTopics, &topic) == NULL) {
+      return NULL;
+    }
   }
 
   // reb new topics
@@ -448,7 +462,9 @@ void *tDecodeSMqConsumerObj(const void *buf, SMqConsumerObj *pConsumer, int8_t s
   for (int32_t i = 0; i < sz; i++) {
     char *topic;
     buf = taosDecodeString(buf, &topic);
-    taosArrayPush(pConsumer->rebNewTopics, &topic);
+    if (taosArrayPush(pConsumer->rebNewTopics, &topic) == NULL) {
+      return NULL;
+    }
   }
 
   // reb removed topics
@@ -457,7 +473,9 @@ void *tDecodeSMqConsumerObj(const void *buf, SMqConsumerObj *pConsumer, int8_t s
   for (int32_t i = 0; i < sz; i++) {
     char *topic;
     buf = taosDecodeString(buf, &topic);
-    taosArrayPush(pConsumer->rebRemovedTopics, &topic);
+    if (taosArrayPush(pConsumer->rebRemovedTopics, &topic) == NULL) {
+      return NULL;
+    }
   }
 
   // reb removed topics
@@ -466,7 +484,9 @@ void *tDecodeSMqConsumerObj(const void *buf, SMqConsumerObj *pConsumer, int8_t s
   for (int32_t i = 0; i < sz; i++) {
     char *topic;
     buf = taosDecodeString(buf, &topic);
-    taosArrayPush(pConsumer->assignedTopics, &topic);
+    if (taosArrayPush(pConsumer->assignedTopics, &topic) == NULL) {
+      return NULL;
+    }
   }
 
   if (sver > 1) {
@@ -597,7 +617,9 @@ int32_t tCloneSubscribeObj(const SMqSubscribeObj *pSub, SMqSubscribeObj **ppSub)
         .consumerId = pConsumerEp->consumerId,
         .vgs = taosArrayDup(pConsumerEp->vgs, (__array_item_dup_fn_t)tCloneSMqVgEp),
     };
-    taosHashPut(pSubNew->consumerHash, &newEp.consumerId, sizeof(int64_t), &newEp, sizeof(SMqConsumerEp));
+    if ((code = taosHashPut(pSubNew->consumerHash, &newEp.consumerId, sizeof(int64_t), &newEp,
+                            sizeof(SMqConsumerEp))) != 0)
+      goto END;
   }
   pSubNew->unassignedVgs = taosArrayDup(pSub->unassignedVgs, (__array_item_dup_fn_t)tCloneSMqVgEp);
   pSubNew->offsetRows = taosArrayDup(pSub->offsetRows, NULL);
@@ -672,7 +694,9 @@ void *tDecodeSubscribeObj(const void *buf, SMqSubscribeObj *pSub, int8_t sver) {
   for (int32_t i = 0; i < sz; i++) {
     SMqConsumerEp consumerEp = {0};
     buf = tDecodeSMqConsumerEp(buf, &consumerEp, sver);
-    taosHashPut(pSub->consumerHash, &consumerEp.consumerId, sizeof(int64_t), &consumerEp, sizeof(SMqConsumerEp));
+    if (taosHashPut(pSub->consumerHash, &consumerEp.consumerId, sizeof(int64_t), &consumerEp, sizeof(SMqConsumerEp)) !=
+        0)
+      return NULL;
   }
 
   buf = taosDecodeArray(buf, &pSub->unassignedVgs, (FDecode)tDecodeSMqVgEp, sizeof(SMqVgEp), sver);
diff --git a/source/dnode/mnode/impl/src/mndDnode.c b/source/dnode/mnode/impl/src/mndDnode.c
index cd3b613ff6..b02f754943 100644
--- a/source/dnode/mnode/impl/src/mndDnode.c
+++ b/source/dnode/mnode/impl/src/mndDnode.c
@@ -152,11 +152,11 @@ static int32_t mndCreateDefaultDnode(SMnode *pMnode) {
   dnodeObj.port = tsServerPort;
   tstrncpy(dnodeObj.fqdn, tsLocalFqdn, TSDB_FQDN_LEN);
   dnodeObj.fqdn[TSDB_FQDN_LEN - 1] = 0;
-  snprintf(dnodeObj.ep, TSDB_EP_LEN - 1, "%s:%u", tsLocalFqdn, tsServerPort);
+  (void)snprintf(dnodeObj.ep, TSDB_EP_LEN - 1, "%s:%u", tsLocalFqdn, tsServerPort);
   char *machineId = NULL;
   code = tGetMachineId(&machineId);
   if (machineId) {
-    memcpy(dnodeObj.machineId, machineId, TSDB_MACHINE_ID_LEN);
+    (void)memcpy(dnodeObj.machineId, machineId, TSDB_MACHINE_ID_LEN);
     taosMemoryFreeClear(machineId);
   } else {
 #if defined(TD_ENTERPRISE) && !defined(GRANTS_CFG)
@@ -284,7 +284,7 @@ static int32_t mndDnodeActionInsert(SSdb *pSdb, SDnodeObj *pDnode) {
   pDnode->offlineReason = DND_REASON_STATUS_NOT_RECEIVED;
 
   char ep[TSDB_EP_LEN] = {0};
-  snprintf(ep, TSDB_EP_LEN - 1, "%s:%u", pDnode->fqdn, pDnode->port);
+  (void)snprintf(ep, TSDB_EP_LEN - 1, "%s:%u", pDnode->fqdn, pDnode->port);
   tstrncpy(pDnode->ep, ep, TSDB_EP_LEN);
   return 0;
 }
@@ -329,7 +329,7 @@ void mndReleaseDnode(SMnode *pMnode, SDnodeObj *pDnode) {
 
 SEpSet mndGetDnodeEpset(SDnodeObj *pDnode) {
   SEpSet epSet = {0};
-  addEpIntoEpSet(&epSet, pDnode->fqdn, pDnode->port);
+  terrno = addEpIntoEpSet(&epSet, pDnode->fqdn, pDnode->port);
   return epSet;
 }
 
@@ -428,7 +428,7 @@ static void mndGetDnodeEps(SMnode *pMnode, SArray *pDnodeEps) {
     if (mndIsMnode(pMnode, pDnode->id)) {
       dnodeEp.isMnode = 1;
     }
-    taosArrayPush(pDnodeEps, &dnodeEp);
+    (void)taosArrayPush(pDnodeEps, &dnodeEp);
   }
 }
 
@@ -748,7 +748,7 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
     if (statusReq.mload.roleTimeMs == 0) {
       statusReq.mload.roleTimeMs = statusReq.rebootTime;
     }
-    mndUpdateMnodeState(pObj, &statusReq.mload);
+    (void)mndUpdateMnodeState(pObj, &statusReq.mload);
     mndReleaseMnode(pMnode, pObj);
   }
 
@@ -808,7 +808,9 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
     pDnode->encryptionKeyChksum = statusReq.clusterCfg.encryptionKeyChksum;
     if (memcmp(pDnode->machineId, statusReq.machineId, TSDB_MACHINE_ID_LEN) != 0) {
       tstrncpy(pDnode->machineId, statusReq.machineId, TSDB_MACHINE_ID_LEN + 1);
-      mndUpdateDnodeObj(pMnode, pDnode);
+      if ((terrno = mndUpdateDnodeObj(pMnode, pDnode)) != 0) {
+        goto _OVER;
+      }
     }
 
     SStatusRsp statusRsp = {0};
@@ -827,7 +829,7 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
 
     int32_t contLen = tSerializeSStatusRsp(NULL, 0, &statusRsp);
     void   *pHead = rpcMallocCont(contLen);
-    tSerializeSStatusRsp(pHead, contLen, &statusRsp);
+    (void)tSerializeSStatusRsp(pHead, contLen, &statusRsp);
     taosArrayDestroy(statusRsp.pDnodeEps);
 
     pReq->info.rspLen = contLen;
@@ -841,7 +843,7 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
 _OVER:
   mndReleaseDnode(pMnode, pDnode);
   taosArrayDestroy(statusReq.pVloads);
-  mndUpdClusterInfo(pReq);
+  (void)mndUpdClusterInfo(pReq);
   return code;
 }
 
@@ -873,7 +875,7 @@ static int32_t mndProcessNotifyReq(SRpcMsg *pReq) {
       mndReleaseVgroup(pMnode, pVgroup);
     }
   }
-  mndUpdClusterInfo(pReq);
+  code = mndUpdClusterInfo(pReq);
 _OVER:
   tFreeSNotifyReq(&notifyReq);
   return code;
@@ -890,7 +892,7 @@ static int32_t mndCreateDnode(SMnode *pMnode, SRpcMsg *pReq, SCreateDnodeReq *pC
   dnodeObj.updateTime = dnodeObj.createdTime;
   dnodeObj.port = pCreate->port;
   tstrncpy(dnodeObj.fqdn, pCreate->fqdn, TSDB_FQDN_LEN);
-  snprintf(dnodeObj.ep, TSDB_EP_LEN - 1, "%s:%u", pCreate->fqdn, pCreate->port);
+  (void)snprintf(dnodeObj.ep, TSDB_EP_LEN - 1, "%s:%u", pCreate->fqdn, pCreate->port);
 
   pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_GLOBAL, pReq, "create-dnode");
   if (pTrans == NULL) {
@@ -957,7 +959,7 @@ static int32_t mndProcessDnodeListReq(SRpcMsg *pReq) {
     goto _OVER;
   }
 
-  tSerializeSDnodeListRsp(pRsp, rspLen, &rsp);
+  (void)tSerializeSDnodeListRsp(pRsp, rspLen, &rsp);
 
   pReq->info.rspLen = rspLen;
   pReq->info.rsp = pRsp;
@@ -976,26 +978,26 @@ _OVER:
 
 static void getSlowLogScopeString(int32_t scope, char* result){
   if(scope == SLOW_LOG_TYPE_NULL) {
-    strcat(result, "NONE");
+    (void)strcat(result, "NONE");
     return;
   }
   while(scope > 0){
     if(scope & SLOW_LOG_TYPE_QUERY) {
-      strcat(result, "QUERY");
+      (void)strcat(result, "QUERY");
       scope &= ~SLOW_LOG_TYPE_QUERY;
     } else if(scope & SLOW_LOG_TYPE_INSERT) {
-      strcat(result, "INSERT");
+      (void)strcat(result, "INSERT");
       scope &= ~SLOW_LOG_TYPE_INSERT;
     } else if(scope & SLOW_LOG_TYPE_OTHERS) {
-      strcat(result, "OTHERS");
+      (void)strcat(result, "OTHERS");
       scope &= ~SLOW_LOG_TYPE_OTHERS;
     } else{
-      printf("invalid slow log scope:%d", scope);
+      (void)printf("invalid slow log scope:%d", scope);
       return;
     }
 
     if(scope > 0) {
-      strcat(result, "|");
+      (void)strcat(result, "|");
     }
   }
 }
@@ -1017,52 +1019,79 @@ static int32_t mndProcessShowVariablesReq(SRpcMsg *pReq) {
 
   SVariablesInfo info = {0};
 
-  strcpy(info.name, "statusInterval");
-  snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsStatusInterval);
-  strcpy(info.scope, "server");
-  taosArrayPush(rsp.variables, &info);
+  (void)strcpy(info.name, "statusInterval");
+  (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsStatusInterval);
+  (void)strcpy(info.scope, "server");
+  if (taosArrayPush(rsp.variables, &info) == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
 
-  strcpy(info.name, "timezone");
-  snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%s", tsTimezoneStr);
-  strcpy(info.scope, "both");
-  taosArrayPush(rsp.variables, &info);
+  (void)strcpy(info.name, "timezone");
+  (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%s", tsTimezoneStr);
+  (void)strcpy(info.scope, "both");
+  if (taosArrayPush(rsp.variables, &info) == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
 
-  strcpy(info.name, "locale");
-  snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%s", tsLocale);
-  strcpy(info.scope, "both");
-  taosArrayPush(rsp.variables, &info);
+  (void)strcpy(info.name, "locale");
+  (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%s", tsLocale);
+  (void)strcpy(info.scope, "both");
+  if (taosArrayPush(rsp.variables, &info) == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
 
-  strcpy(info.name, "charset");
-  snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%s", tsCharset);
-  strcpy(info.scope, "both");
-  taosArrayPush(rsp.variables, &info);
+  (void)strcpy(info.name, "charset");
+  (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%s", tsCharset);
+  (void)strcpy(info.scope, "both");
+  if (taosArrayPush(rsp.variables, &info) == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
 
-  strcpy(info.name, "monitor");
-  snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsEnableMonitor);
-  strcpy(info.scope, "server");
-  taosArrayPush(rsp.variables, &info);
+  (void)strcpy(info.name, "monitor");
+  (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsEnableMonitor);
+  (void)strcpy(info.scope, "server");
+  if (taosArrayPush(rsp.variables, &info) == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
 
-  strcpy(info.name, "monitorInterval");
-  snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsMonitorInterval);
-  strcpy(info.scope, "server");
-  taosArrayPush(rsp.variables, &info);
+  (void)strcpy(info.name, "monitorInterval");
+  (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsMonitorInterval);
+  (void)strcpy(info.scope, "server");
+  if (taosArrayPush(rsp.variables, &info) == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
 
-  strcpy(info.name, "slowLogThreshold");
-  snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsSlowLogThreshold);
-  strcpy(info.scope, "server");
-  taosArrayPush(rsp.variables, &info);
+  (void)strcpy(info.name, "slowLogThreshold");
+  (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsSlowLogThreshold);
+  (void)strcpy(info.scope, "server");
+  if (taosArrayPush(rsp.variables, &info) == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
 
-  strcpy(info.name, "slowLogMaxLen");
-  snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsSlowLogMaxLen);
-  strcpy(info.scope, "server");
-  taosArrayPush(rsp.variables, &info);
+  (void)strcpy(info.name, "slowLogMaxLen");
+  (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsSlowLogMaxLen);
+  (void)strcpy(info.scope, "server");
+  if (taosArrayPush(rsp.variables, &info) == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
 
   char scopeStr[64] = {0};
   getSlowLogScopeString(tsSlowLogScope, scopeStr);
-  strcpy(info.name, "slowLogScope");
-  snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%s", scopeStr);
-  strcpy(info.scope, "server");
-  taosArrayPush(rsp.variables, &info);
+  (void)strcpy(info.name, "slowLogScope");
+  (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%s", scopeStr);
+  (void)strcpy(info.scope, "server");
+  if (taosArrayPush(rsp.variables, &info) == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
 
   int32_t rspLen = tSerializeSShowVariablesRsp(NULL, 0, &rsp);
   void   *pRsp = rpcMallocCont(rspLen);
@@ -1071,7 +1100,7 @@ static int32_t mndProcessShowVariablesReq(SRpcMsg *pReq) {
     goto _OVER;
   }
 
-  tSerializeSShowVariablesRsp(pRsp, rspLen, &rsp);
+  (void)tSerializeSShowVariablesRsp(pRsp, rspLen, &rsp);
 
   pReq->info.rspLen = rspLen;
   pReq->info.rsp = pRsp;
@@ -1108,7 +1137,7 @@ static int32_t mndProcessCreateDnodeReq(SRpcMsg *pReq) {
   }
 
   char ep[TSDB_EP_LEN];
-  snprintf(ep, TSDB_EP_LEN, "%s:%d", createReq.fqdn, createReq.port);
+  (void)snprintf(ep, TSDB_EP_LEN, "%s:%d", createReq.fqdn, createReq.port);
   pDnode = mndAcquireDnodeByEp(pMnode, ep);
   if (pDnode != NULL) {
     code = TSDB_CODE_MND_DNODE_ALREADY_EXIST;
@@ -1122,7 +1151,7 @@ static int32_t mndProcessCreateDnodeReq(SRpcMsg *pReq) {
   }
 
   char obj[200] = {0};
-  sprintf(obj, "%s:%d", createReq.fqdn, createReq.port);
+  (void)sprintf(obj, "%s:%d", createReq.fqdn, createReq.port);
 
   auditRecord(pReq, pMnode->clusterId, "createDnode", "", obj, createReq.sql, createReq.sqlLen);
 
@@ -1261,7 +1290,7 @@ static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq) {
   if (pDnode == NULL) {
     int32_t err = terrno;
     char    ep[TSDB_EP_LEN + 1] = {0};
-    snprintf(ep, sizeof(ep), dropReq.fqdn, dropReq.port);
+    (void)snprintf(ep, sizeof(ep), dropReq.fqdn, dropReq.port);
     pDnode = mndAcquireDnodeByEp(pMnode, ep);
     if (pDnode == NULL) {
       code = err;
@@ -1305,7 +1334,7 @@ static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq) {
   if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;
 
   char obj1[30] = {0};
-  sprintf(obj1, "%d", dropReq.dnodeId);
+  (void)sprintf(obj1, "%d", dropReq.dnodeId);
 
   auditRecord(pReq, pMnode->clusterId, "dropDnode", "", obj1, dropReq.sql, dropReq.sqlLen);
 
@@ -1333,17 +1362,17 @@ static int32_t mndMCfg2DCfg(SMCfgDnodeReq *pMCfgReq, SDCfgDnodeReq *pDCfgReq) {
   }
 
   size_t optLen = p - pMCfgReq->config;
-  strncpy(pDCfgReq->config, pMCfgReq->config, optLen);
+  (void)strncpy(pDCfgReq->config, pMCfgReq->config, optLen);
   pDCfgReq->config[optLen] = 0;
 
   if (' ' == pMCfgReq->config[optLen]) {
     // 'key value'
     if (strlen(pMCfgReq->value) != 0) goto _err;
-    strcpy(pDCfgReq->value, p + 1);
+    (void)strcpy(pDCfgReq->value, p + 1);
   } else {
     // 'key' 'value'
     if (strlen(pMCfgReq->value) == 0) goto _err;
-    strcpy(pDCfgReq->value, pMCfgReq->value);
+    (void)strcpy(pDCfgReq->value, pMCfgReq->value);
   }
 
   TAOS_RETURN(code);
@@ -1369,11 +1398,10 @@ static int32_t mndSendCfgDnodeReq(SMnode *pMnode, int32_t dnodeId, SDCfgDnodeReq
       void   *pBuf = rpcMallocCont(bufLen);
 
       if (pBuf != NULL) {
-        tSerializeSDCfgDnodeReq(pBuf, bufLen, pDcfgReq);
+        (void)tSerializeSDCfgDnodeReq(pBuf, bufLen, pDcfgReq);
         mInfo("dnode:%d, send config req to dnode, config:%s value:%s", dnodeId, pDcfgReq->config, pDcfgReq->value);
         SRpcMsg rpcMsg = {.msgType = TDMT_DND_CONFIG_DNODE, .pCont = pBuf, .contLen = bufLen};
-        tmsgSendReq(&epSet, &rpcMsg);
-        code = 0;
+        code = tmsgSendReq(&epSet, &rpcMsg);
       }
     }
 
@@ -1400,7 +1428,7 @@ static int32_t mndProcessConfigDnodeReq(SRpcMsg *pReq) {
 
   SDCfgDnodeReq dcfgReq = {0};
   if (strcasecmp(cfgReq.config, "resetlog") == 0) {
-    strcpy(dcfgReq.config, "resetlog");
+    (void)strcpy(dcfgReq.config, "resetlog");
 #ifdef TD_ENTERPRISE
   } else if (strncasecmp(cfgReq.config, "s3blocksize", 11) == 0) {
     int32_t optLen = strlen("s3blocksize");
@@ -1435,7 +1463,7 @@ static int32_t mndProcessConfigDnodeReq(SRpcMsg *pReq) {
 
   {  // audit
     char obj[50] = {0};
-    sprintf(obj, "%d", cfgReq.dnodeId);
+    (void)sprintf(obj, "%d", cfgReq.dnodeId);
 
     auditRecord(pReq, pMnode->clusterId, "alterDnode", obj, "", cfgReq.sql, cfgReq.sqlLen);
   }
@@ -1510,10 +1538,10 @@ static int32_t mndProcessCreateEncryptKeyReqImpl(SRpcMsg *pReq, int32_t dnodeId,
       void   *pBuf = rpcMallocCont(bufLen);
 
       if (pBuf != NULL) {
-        tSerializeSDCfgDnodeReq(pBuf, bufLen, pDcfgReq);
+        (void)tSerializeSDCfgDnodeReq(pBuf, bufLen, pDcfgReq);
         SRpcMsg rpcMsg = {.msgType = TDMT_DND_CREATE_ENCRYPT_KEY, .pCont = pBuf, .contLen = bufLen};
         if (0 == tmsgSendReq(&epSet, &rpcMsg)) {
-          atomic_add_fetch_16(&pMnode->encryptMgmt.nEncrypt, 1);
+          (void)atomic_add_fetch_16(&pMnode->encryptMgmt.nEncrypt, 1);
         }
       }
     }
@@ -1597,41 +1625,41 @@ static int32_t mndRetrieveConfigs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p
   int32_t cols = 0;
 
   cfgOpts[totalRows] = "statusInterval";
-  snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%d", tsStatusInterval);
+  (void)snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%d", tsStatusInterval);
   totalRows++;
 
   cfgOpts[totalRows] = "timezone";
-  snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%s", tsTimezoneStr);
+  (void)snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%s", tsTimezoneStr);
   totalRows++;
 
   cfgOpts[totalRows] = "locale";
-  snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%s", tsLocale);
+  (void)snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%s", tsLocale);
   totalRows++;
 
   cfgOpts[totalRows] = "charset";
-  snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%s", tsCharset);
+  (void)snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%s", tsCharset);
   totalRows++;
 
   cfgOpts[totalRows] = "monitor";
-  snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%d", tsEnableMonitor);
+  (void)snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%d", tsEnableMonitor);
   totalRows++;
 
   cfgOpts[totalRows] = "monitorInterval";
-  snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%d", tsMonitorInterval);
+  (void)snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%d", tsMonitorInterval);
   totalRows++;
 
   cfgOpts[totalRows] = "slowLogThreshold";
-  snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%d", tsSlowLogThreshold);
+  (void)snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%d", tsSlowLogThreshold);
   totalRows++;
 
   cfgOpts[totalRows] = "slowLogMaxLen";
-  snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%d", tsSlowLogMaxLen);
+  (void)snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%d", tsSlowLogMaxLen);
   totalRows++;
 
   char scopeStr[64] = {0};
   getSlowLogScopeString(tsSlowLogScope, scopeStr);
   cfgOpts[totalRows] = "slowLogScope";
-  snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%s", scopeStr);
+  (void)snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%s", scopeStr);
   totalRows++;
 
   char buf[TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE] = {0};
@@ -1642,11 +1670,11 @@ static int32_t mndRetrieveConfigs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p
 
     STR_WITH_MAXSIZE_TO_VARSTR(buf, cfgOpts[i], TSDB_CONFIG_OPTION_LEN);
     SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)buf, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)buf, false);
 
     STR_WITH_MAXSIZE_TO_VARSTR(bufVal, cfgVals[i], TSDB_CONFIG_VALUE_LEN);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)bufVal, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)bufVal, false);
 
     numOfRows++;
   }
@@ -1675,19 +1703,19 @@ static int32_t mndRetrieveDnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB
     cols = 0;
 
     SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pDnode->id, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pDnode->id, false);
 
     STR_WITH_MAXSIZE_TO_VARSTR(buf, pDnode->ep, pShow->pMeta->pSchemas[cols].bytes);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, buf, false);
+    (void)colDataSetVal(pColInfo, numOfRows, buf, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     int16_t id = mndGetVnodesNum(pMnode, pDnode->id);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&id, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&id, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pDnode->numOfSupportVnodes, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pDnode->numOfSupportVnodes, false);
 
     const char *status = "ready";
     if (objStatus == SDB_STATUS_CREATING) status = "creating";
@@ -1703,19 +1731,19 @@ static int32_t mndRetrieveDnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB
 
     STR_TO_VARSTR(buf, status);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, buf, false);
+    (void)colDataSetVal(pColInfo, numOfRows, buf, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pDnode->createdTime, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pDnode->createdTime, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pDnode->rebootTime, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pDnode->rebootTime, false);
 
     char *b = taosMemoryCalloc(VARSTR_HEADER_SIZE + strlen(offlineReason[pDnode->offlineReason]) + 1, 1);
     STR_TO_VARSTR(b, online ? "" : offlineReason[pDnode->offlineReason]);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, b, false);
+    (void)colDataSetVal(pColInfo, numOfRows, b, false);
     taosMemoryFreeClear(b);
 
 #ifdef TD_ENTERPRISE
@@ -1772,7 +1800,7 @@ SArray *mndGetAllDnodeFqdns(SMnode *pMnode) {
     if (pIter == NULL) break;
 
     char *fqdn = taosStrdup(pObj->fqdn);
-    taosArrayPush(fqdns, &fqdn);
+    (void)taosArrayPush(fqdns, &fqdn);
     sdbRelease(pSdb, pObj);
   }
   return fqdns;
diff --git a/source/dnode/mnode/impl/src/mndDump.c b/source/dnode/mnode/impl/src/mndDump.c
index 22dbc8eb57..ca7b5bbac6 100644
--- a/source/dnode/mnode/impl/src/mndDump.c
+++ b/source/dnode/mnode/impl/src/mndDump.c
@@ -41,7 +41,7 @@ int32_t sendSyncReq(const SEpSet *pEpSet, SRpcMsg *pMsg) {
 
 char *i642str(int64_t val) {
   static char str[24] = {0};
-  snprintf(str, sizeof(str), "%" PRId64, val);
+  (void)snprintf(str, sizeof(str), "%" PRId64, val);
   return str;
 }
 
@@ -55,18 +55,18 @@ void dumpFunc(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "name", pObj->name);
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "funcType", i642str(pObj->funcType));
-    tjsonAddStringToObject(item, "scriptType", i642str(pObj->scriptType));
-    tjsonAddStringToObject(item, "align", i642str(pObj->align));
-    tjsonAddStringToObject(item, "outputType", i642str(pObj->outputType));
-    tjsonAddStringToObject(item, "outputLen", i642str(pObj->outputLen));
-    tjsonAddStringToObject(item, "bufSize", i642str(pObj->bufSize));
-    tjsonAddStringToObject(item, "signature", i642str(pObj->signature));
-    tjsonAddStringToObject(item, "commentSize", i642str(pObj->commentSize));
-    tjsonAddStringToObject(item, "codeSize", i642str(pObj->codeSize));
+    (void)tjsonAddItemToArray(items, item);
+    (void)tjsonAddStringToObject(item, "name", pObj->name);
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "funcType", i642str(pObj->funcType));
+    (void)tjsonAddStringToObject(item, "scriptType", i642str(pObj->scriptType));
+    (void)tjsonAddStringToObject(item, "align", i642str(pObj->align));
+    (void)tjsonAddStringToObject(item, "outputType", i642str(pObj->outputType));
+    (void)tjsonAddStringToObject(item, "outputLen", i642str(pObj->outputLen));
+    (void)tjsonAddStringToObject(item, "bufSize", i642str(pObj->bufSize));
+    (void)tjsonAddStringToObject(item, "signature", i642str(pObj->signature));
+    (void)tjsonAddStringToObject(item, "commentSize", i642str(pObj->commentSize));
+    (void)tjsonAddStringToObject(item, "codeSize", i642str(pObj->codeSize));
     sdbRelease(pSdb, pObj);
   }
 }
@@ -84,56 +84,56 @@ void dumpDb(SSdb *pSdb, SJson *json) {
     SJson *item = tjsonCreateObject();
     tjsonAddItemToObject(items, "db", item);
 
-    tjsonAddStringToObject(item, "name", mndGetDbStr(pObj->name));
-    tjsonAddStringToObject(item, "acct", pObj->acct);
-    tjsonAddStringToObject(item, "createUser", pObj->createUser);
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
-    tjsonAddStringToObject(item, "uid", i642str(pObj->uid));
-    tjsonAddStringToObject(item, "cfgVersion", i642str(pObj->cfgVersion));
-    tjsonAddStringToObject(item, "vgVersion", i642str(pObj->vgVersion));
-    tjsonAddStringToObject(item, "numOfVgroups", i642str(pObj->cfg.numOfVgroups));
-    tjsonAddStringToObject(item, "numOfStables", i642str(pObj->cfg.numOfStables));
-    tjsonAddStringToObject(item, "buffer", i642str(pObj->cfg.buffer));
-    tjsonAddStringToObject(item, "pageSize", i642str(pObj->cfg.pageSize));
-    tjsonAddStringToObject(item, "pages", i642str(pObj->cfg.pages));
-    tjsonAddStringToObject(item, "cacheLastSize", i642str(pObj->cfg.cacheLastSize));
-    tjsonAddStringToObject(item, "daysPerFile", i642str(pObj->cfg.daysPerFile));
-    tjsonAddStringToObject(item, "daysToKeep0", i642str(pObj->cfg.daysToKeep0));
-    tjsonAddStringToObject(item, "daysToKeep1", i642str(pObj->cfg.daysToKeep1));
-    tjsonAddStringToObject(item, "daysToKeep2", i642str(pObj->cfg.daysToKeep2));
-    tjsonAddStringToObject(item, "minRows", i642str(pObj->cfg.minRows));
-    tjsonAddStringToObject(item, "maxRows", i642str(pObj->cfg.maxRows));
-    tjsonAddStringToObject(item, "precision", i642str(pObj->cfg.precision));
-    tjsonAddStringToObject(item, "compression", i642str(pObj->cfg.compression));
-    tjsonAddStringToObject(item, "encryptAlgorithm", i642str(pObj->cfg.encryptAlgorithm));
-    tjsonAddStringToObject(item, "replications", i642str(pObj->cfg.replications));
-    tjsonAddStringToObject(item, "strict", i642str(pObj->cfg.strict));
-    tjsonAddStringToObject(item, "cacheLast", i642str(pObj->cfg.cacheLast));
-    tjsonAddStringToObject(item, "hashMethod", i642str(pObj->cfg.hashMethod));
-    tjsonAddStringToObject(item, "hashPrefix", i642str(pObj->cfg.hashPrefix));
-    tjsonAddStringToObject(item, "hashSuffix", i642str(pObj->cfg.hashSuffix));
-    tjsonAddStringToObject(item, "sstTrigger", i642str(pObj->cfg.sstTrigger));
-    tjsonAddStringToObject(item, "tsdbPageSize", i642str(pObj->cfg.tsdbPageSize));
-    tjsonAddStringToObject(item, "schemaless", i642str(pObj->cfg.schemaless));
-    tjsonAddStringToObject(item, "walLevel", i642str(pObj->cfg.walLevel));
-    tjsonAddStringToObject(item, "walFsyncPeriod", i642str(pObj->cfg.walFsyncPeriod));
-    tjsonAddStringToObject(item, "walRetentionPeriod", i642str(pObj->cfg.walRetentionPeriod));
-    tjsonAddStringToObject(item, "walRetentionSize", i642str(pObj->cfg.walRetentionSize));
-    tjsonAddStringToObject(item, "walRollPeriod", i642str(pObj->cfg.walRollPeriod));
-    tjsonAddStringToObject(item, "walSegmentSize", i642str(pObj->cfg.walSegmentSize));
+    (void)tjsonAddStringToObject(item, "name", mndGetDbStr(pObj->name));
+    (void)tjsonAddStringToObject(item, "acct", pObj->acct);
+    (void)tjsonAddStringToObject(item, "createUser", pObj->createUser);
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "uid", i642str(pObj->uid));
+    (void)tjsonAddStringToObject(item, "cfgVersion", i642str(pObj->cfgVersion));
+    (void)tjsonAddStringToObject(item, "vgVersion", i642str(pObj->vgVersion));
+    (void)tjsonAddStringToObject(item, "numOfVgroups", i642str(pObj->cfg.numOfVgroups));
+    (void)tjsonAddStringToObject(item, "numOfStables", i642str(pObj->cfg.numOfStables));
+    (void)tjsonAddStringToObject(item, "buffer", i642str(pObj->cfg.buffer));
+    (void)tjsonAddStringToObject(item, "pageSize", i642str(pObj->cfg.pageSize));
+    (void)tjsonAddStringToObject(item, "pages", i642str(pObj->cfg.pages));
+    (void)tjsonAddStringToObject(item, "cacheLastSize", i642str(pObj->cfg.cacheLastSize));
+    (void)tjsonAddStringToObject(item, "daysPerFile", i642str(pObj->cfg.daysPerFile));
+    (void)tjsonAddStringToObject(item, "daysToKeep0", i642str(pObj->cfg.daysToKeep0));
+    (void)tjsonAddStringToObject(item, "daysToKeep1", i642str(pObj->cfg.daysToKeep1));
+    (void)tjsonAddStringToObject(item, "daysToKeep2", i642str(pObj->cfg.daysToKeep2));
+    (void)tjsonAddStringToObject(item, "minRows", i642str(pObj->cfg.minRows));
+    (void)tjsonAddStringToObject(item, "maxRows", i642str(pObj->cfg.maxRows));
+    (void)tjsonAddStringToObject(item, "precision", i642str(pObj->cfg.precision));
+    (void)tjsonAddStringToObject(item, "compression", i642str(pObj->cfg.compression));
+    (void)tjsonAddStringToObject(item, "encryptAlgorithm", i642str(pObj->cfg.encryptAlgorithm));
+    (void)tjsonAddStringToObject(item, "replications", i642str(pObj->cfg.replications));
+    (void)tjsonAddStringToObject(item, "strict", i642str(pObj->cfg.strict));
+    (void)tjsonAddStringToObject(item, "cacheLast", i642str(pObj->cfg.cacheLast));
+    (void)tjsonAddStringToObject(item, "hashMethod", i642str(pObj->cfg.hashMethod));
+    (void)tjsonAddStringToObject(item, "hashPrefix", i642str(pObj->cfg.hashPrefix));
+    (void)tjsonAddStringToObject(item, "hashSuffix", i642str(pObj->cfg.hashSuffix));
+    (void)tjsonAddStringToObject(item, "sstTrigger", i642str(pObj->cfg.sstTrigger));
+    (void)tjsonAddStringToObject(item, "tsdbPageSize", i642str(pObj->cfg.tsdbPageSize));
+    (void)tjsonAddStringToObject(item, "schemaless", i642str(pObj->cfg.schemaless));
+    (void)tjsonAddStringToObject(item, "walLevel", i642str(pObj->cfg.walLevel));
+    (void)tjsonAddStringToObject(item, "walFsyncPeriod", i642str(pObj->cfg.walFsyncPeriod));
+    (void)tjsonAddStringToObject(item, "walRetentionPeriod", i642str(pObj->cfg.walRetentionPeriod));
+    (void)tjsonAddStringToObject(item, "walRetentionSize", i642str(pObj->cfg.walRetentionSize));
+    (void)tjsonAddStringToObject(item, "walRollPeriod", i642str(pObj->cfg.walRollPeriod));
+    (void)tjsonAddStringToObject(item, "walSegmentSize", i642str(pObj->cfg.walSegmentSize));
 
-    tjsonAddStringToObject(item, "numOfRetensions", i642str(pObj->cfg.numOfRetensions));
+    (void)tjsonAddStringToObject(item, "numOfRetensions", i642str(pObj->cfg.numOfRetensions));
     for (int32_t i = 0; i < pObj->cfg.numOfRetensions; ++i) {
       SJson *rentensions = tjsonAddArrayToObject(item, "rentensions");
       SJson *rentension = tjsonCreateObject();
-      tjsonAddItemToArray(rentensions, rentension);
+      (void)tjsonAddItemToArray(rentensions, rentension);
 
       SRetention *pRetension = taosArrayGet(pObj->cfg.pRetensions, i);
-      tjsonAddStringToObject(item, "freq", i642str(pRetension->freq));
-      tjsonAddStringToObject(item, "freqUnit", i642str(pRetension->freqUnit));
-      tjsonAddStringToObject(item, "keep", i642str(pRetension->keep));
-      tjsonAddStringToObject(item, "keepUnit", i642str(pRetension->keepUnit));
+      (void)tjsonAddStringToObject(item, "freq", i642str(pRetension->freq));
+      (void)tjsonAddStringToObject(item, "freqUnit", i642str(pRetension->freqUnit));
+      (void)tjsonAddStringToObject(item, "keep", i642str(pRetension->keep));
+      (void)tjsonAddStringToObject(item, "keepUnit", i642str(pRetension->keepUnit));
     }
 
     sdbRelease(pSdb, pObj);
@@ -150,55 +150,55 @@ void dumpStb(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "name", mndGetStbStr(pObj->name));
-    tjsonAddStringToObject(item, "db", mndGetDbStr(pObj->db));
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
-    tjsonAddStringToObject(item, "uid", i642str(pObj->uid));
-    tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
-    tjsonAddStringToObject(item, "tagVer", i642str(pObj->tagVer));
-    tjsonAddStringToObject(item, "colVer", i642str(pObj->colVer));
-    tjsonAddStringToObject(item, "smaVer", i642str(pObj->smaVer));
-    tjsonAddStringToObject(item, "nextColId", i642str(pObj->nextColId));
-    tjsonAddStringToObject(item, "watermark1", i642str(pObj->watermark[0]));
-    tjsonAddStringToObject(item, "watermark2", i642str(pObj->watermark[1]));
-    tjsonAddStringToObject(item, "maxdelay0", i642str(pObj->maxdelay[0]));
-    tjsonAddStringToObject(item, "maxdelay1", i642str(pObj->maxdelay[1]));
-    tjsonAddStringToObject(item, "ttl", i642str(pObj->ttl));
-    tjsonAddStringToObject(item, "numOfFuncs", i642str(pObj->numOfFuncs));
-    tjsonAddStringToObject(item, "commentLen", i642str(pObj->commentLen));
-    tjsonAddStringToObject(item, "ast1Len", i642str(pObj->ast1Len));
-    tjsonAddStringToObject(item, "ast2Len", i642str(pObj->ast2Len));
+    (void)tjsonAddItemToArray(items, item);
+    (void)tjsonAddStringToObject(item, "name", mndGetStbStr(pObj->name));
+    (void)tjsonAddStringToObject(item, "db", mndGetDbStr(pObj->db));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "uid", i642str(pObj->uid));
+    (void)tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
+    (void)tjsonAddStringToObject(item, "tagVer", i642str(pObj->tagVer));
+    (void)tjsonAddStringToObject(item, "colVer", i642str(pObj->colVer));
+    (void)tjsonAddStringToObject(item, "smaVer", i642str(pObj->smaVer));
+    (void)tjsonAddStringToObject(item, "nextColId", i642str(pObj->nextColId));
+    (void)tjsonAddStringToObject(item, "watermark1", i642str(pObj->watermark[0]));
+    (void)tjsonAddStringToObject(item, "watermark2", i642str(pObj->watermark[1]));
+    (void)tjsonAddStringToObject(item, "maxdelay0", i642str(pObj->maxdelay[0]));
+    (void)tjsonAddStringToObject(item, "maxdelay1", i642str(pObj->maxdelay[1]));
+    (void)tjsonAddStringToObject(item, "ttl", i642str(pObj->ttl));
+    (void)tjsonAddStringToObject(item, "numOfFuncs", i642str(pObj->numOfFuncs));
+    (void)tjsonAddStringToObject(item, "commentLen", i642str(pObj->commentLen));
+    (void)tjsonAddStringToObject(item, "ast1Len", i642str(pObj->ast1Len));
+    (void)tjsonAddStringToObject(item, "ast2Len", i642str(pObj->ast2Len));
 
-    tjsonAddStringToObject(item, "numOfColumns", i642str(pObj->numOfColumns));
+    (void)tjsonAddStringToObject(item, "numOfColumns", i642str(pObj->numOfColumns));
     SJson *columns = tjsonAddArrayToObject(item, "columns");
     for (int32_t i = 0; i < pObj->numOfColumns; ++i) {
       SJson *column = tjsonCreateObject();
-      tjsonAddItemToArray(columns, column);
+      (void)tjsonAddItemToArray(columns, column);
 
       SSchema *pColumn = &pObj->pColumns[i];
-      tjsonAddStringToObject(column, "type", i642str(pColumn->type));
-      tjsonAddStringToObject(column, "typestr", tDataTypes[pColumn->type].name);
-      tjsonAddStringToObject(column, "flags", i642str(pColumn->flags));
-      tjsonAddStringToObject(column, "colId", i642str(pColumn->colId));
-      tjsonAddStringToObject(column, "bytes", i642str(pColumn->bytes));
-      tjsonAddStringToObject(column, "name", pColumn->name);
+      (void)tjsonAddStringToObject(column, "type", i642str(pColumn->type));
+      (void)tjsonAddStringToObject(column, "typestr", tDataTypes[pColumn->type].name);
+      (void)tjsonAddStringToObject(column, "flags", i642str(pColumn->flags));
+      (void)tjsonAddStringToObject(column, "colId", i642str(pColumn->colId));
+      (void)tjsonAddStringToObject(column, "bytes", i642str(pColumn->bytes));
+      (void)tjsonAddStringToObject(column, "name", pColumn->name);
     }
 
-    tjsonAddStringToObject(item, "numOfTags", i642str(pObj->numOfTags));
+    (void)tjsonAddStringToObject(item, "numOfTags", i642str(pObj->numOfTags));
     SJson *tags = tjsonAddArrayToObject(item, "tags");
     for (int32_t i = 0; i < pObj->numOfTags; ++i) {
       SJson *tag = tjsonCreateObject();
-      tjsonAddItemToArray(tags, tag);
+      (void)tjsonAddItemToArray(tags, tag);
 
       SSchema *pTag = &pObj->pTags[i];
-      tjsonAddStringToObject(tag, "type", i642str(pTag->type));
-      tjsonAddStringToObject(tag, "typestr", tDataTypes[pTag->type].name);
-      tjsonAddStringToObject(tag, "flags", i642str(pTag->flags));
-      tjsonAddStringToObject(tag, "colId", i642str(pTag->colId));
-      tjsonAddStringToObject(tag, "bytes", i642str(pTag->bytes));
-      tjsonAddStringToObject(tag, "name", pTag->name);
+      (void)tjsonAddStringToObject(tag, "type", i642str(pTag->type));
+      (void)tjsonAddStringToObject(tag, "typestr", tDataTypes[pTag->type].name);
+      (void)tjsonAddStringToObject(tag, "flags", i642str(pTag->flags));
+      (void)tjsonAddStringToObject(tag, "colId", i642str(pTag->colId));
+      (void)tjsonAddStringToObject(tag, "bytes", i642str(pTag->bytes));
+      (void)tjsonAddStringToObject(tag, "name", pTag->name);
     }
 
     sdbRelease(pSdb, pObj);
@@ -215,27 +215,27 @@ void dumpSma(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "name", mndGetStbStr(pObj->name));
-    tjsonAddStringToObject(item, "stb", mndGetStbStr(pObj->stb));
-    tjsonAddStringToObject(item, "db", mndGetDbStr(pObj->db));
-    tjsonAddStringToObject(item, "dstTbName", mndGetStbStr(pObj->dstTbName));
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "uid", i642str(pObj->uid));
-    tjsonAddStringToObject(item, "stbUid", i642str(pObj->stbUid));
-    tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
-    tjsonAddStringToObject(item, "dstTbUid", i642str(pObj->dstTbUid));
-    tjsonAddStringToObject(item, "intervalUnit", i642str(pObj->intervalUnit));
-    tjsonAddStringToObject(item, "slidingUnit", i642str(pObj->slidingUnit));
-    tjsonAddStringToObject(item, "timezone", i642str(pObj->timezone));
-    tjsonAddStringToObject(item, "dstVgId", i642str(pObj->dstVgId));
-    tjsonAddStringToObject(item, "interval", i642str(pObj->interval));
-    tjsonAddStringToObject(item, "offset", i642str(pObj->offset));
-    tjsonAddStringToObject(item, "sliding", i642str(pObj->sliding));
-    tjsonAddStringToObject(item, "exprLen", i642str(pObj->exprLen));
-    tjsonAddStringToObject(item, "tagsFilterLen", i642str(pObj->tagsFilterLen));
-    tjsonAddStringToObject(item, "sqlLen", i642str(pObj->sqlLen));
-    tjsonAddStringToObject(item, "astLen", i642str(pObj->astLen));
+    (void)tjsonAddItemToArray(items, item);
+    (void)tjsonAddStringToObject(item, "name", mndGetStbStr(pObj->name));
+    (void)tjsonAddStringToObject(item, "stb", mndGetStbStr(pObj->stb));
+    (void)tjsonAddStringToObject(item, "db", mndGetDbStr(pObj->db));
+    (void)tjsonAddStringToObject(item, "dstTbName", mndGetStbStr(pObj->dstTbName));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "uid", i642str(pObj->uid));
+    (void)tjsonAddStringToObject(item, "stbUid", i642str(pObj->stbUid));
+    (void)tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
+    (void)tjsonAddStringToObject(item, "dstTbUid", i642str(pObj->dstTbUid));
+    (void)tjsonAddStringToObject(item, "intervalUnit", i642str(pObj->intervalUnit));
+    (void)tjsonAddStringToObject(item, "slidingUnit", i642str(pObj->slidingUnit));
+    (void)tjsonAddStringToObject(item, "timezone", i642str(pObj->timezone));
+    (void)tjsonAddStringToObject(item, "dstVgId", i642str(pObj->dstVgId));
+    (void)tjsonAddStringToObject(item, "interval", i642str(pObj->interval));
+    (void)tjsonAddStringToObject(item, "offset", i642str(pObj->offset));
+    (void)tjsonAddStringToObject(item, "sliding", i642str(pObj->sliding));
+    (void)tjsonAddStringToObject(item, "exprLen", i642str(pObj->exprLen));
+    (void)tjsonAddStringToObject(item, "tagsFilterLen", i642str(pObj->tagsFilterLen));
+    (void)tjsonAddStringToObject(item, "sqlLen", i642str(pObj->sqlLen));
+    (void)tjsonAddStringToObject(item, "astLen", i642str(pObj->astLen));
     sdbRelease(pSdb, pObj);
   }
 }
@@ -250,22 +250,22 @@ void dumpVgroup(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "vgId", i642str(pObj->vgId));
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
-    tjsonAddStringToObject(item, "version", i642str(pObj->version));
-    tjsonAddStringToObject(item, "hashBegin", i642str(pObj->hashBegin));
-    tjsonAddStringToObject(item, "hashEnd", i642str(pObj->hashEnd));
-    tjsonAddStringToObject(item, "db", mndGetDbStr(pObj->dbName));
-    tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
-    tjsonAddStringToObject(item, "isTsma", i642str(pObj->isTsma));
-    tjsonAddStringToObject(item, "replica", i642str(pObj->replica));
+    (void)tjsonAddItemToArray(items, item);
+    (void)tjsonAddStringToObject(item, "vgId", i642str(pObj->vgId));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "version", i642str(pObj->version));
+    (void)tjsonAddStringToObject(item, "hashBegin", i642str(pObj->hashBegin));
+    (void)tjsonAddStringToObject(item, "hashEnd", i642str(pObj->hashEnd));
+    (void)tjsonAddStringToObject(item, "db", mndGetDbStr(pObj->dbName));
+    (void)tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
+    (void)tjsonAddStringToObject(item, "isTsma", i642str(pObj->isTsma));
+    (void)tjsonAddStringToObject(item, "replica", i642str(pObj->replica));
     for (int32_t i = 0; i < pObj->replica; ++i) {
       SJson *replicas = tjsonAddArrayToObject(item, "replicas");
       SJson *replica = tjsonCreateObject();
-      tjsonAddItemToArray(replicas, replica);
-      tjsonAddStringToObject(replica, "dnodeId", i642str(pObj->vnodeGid[i].dnodeId));
+      (void)tjsonAddItemToArray(replicas, replica);
+      (void)tjsonAddStringToObject(replica, "dnodeId", i642str(pObj->vnodeGid[i].dnodeId));
     }
     sdbRelease(pSdb, pObj);
   }
@@ -281,23 +281,23 @@ void dumpTopic(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "name", mndGetDbStr(pObj->name));
-    tjsonAddStringToObject(item, "name", mndGetDbStr(pObj->db));
-    tjsonAddStringToObject(item, "createTime", i642str(pObj->createTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
-    tjsonAddStringToObject(item, "uid", i642str(pObj->uid));
-    tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
-    tjsonAddStringToObject(item, "version", i642str(pObj->version));
-    tjsonAddStringToObject(item, "subType", i642str(pObj->subType));
-    tjsonAddStringToObject(item, "withMeta", i642str(pObj->withMeta));
-    tjsonAddStringToObject(item, "stbUid", i642str(pObj->stbUid));
-    tjsonAddStringToObject(item, "stbName", mndGetStableStr(pObj->stbName));
-    tjsonAddStringToObject(item, "sqlLen", i642str(pObj->sqlLen));
-    tjsonAddStringToObject(item, "astLen", i642str(pObj->astLen));
-    tjsonAddStringToObject(item, "sqlLen", i642str(pObj->sqlLen));
-    tjsonAddStringToObject(item, "ntbUid", i642str(pObj->ntbUid));
-    tjsonAddStringToObject(item, "ctbStbUid", i642str(pObj->ctbStbUid));
+    (void)tjsonAddItemToArray(items, item);
+    (void)tjsonAddStringToObject(item, "name", mndGetDbStr(pObj->name));
+    (void)tjsonAddStringToObject(item, "name", mndGetDbStr(pObj->db));
+    (void)tjsonAddStringToObject(item, "createTime", i642str(pObj->createTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "uid", i642str(pObj->uid));
+    (void)tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
+    (void)tjsonAddStringToObject(item, "version", i642str(pObj->version));
+    (void)tjsonAddStringToObject(item, "subType", i642str(pObj->subType));
+    (void)tjsonAddStringToObject(item, "withMeta", i642str(pObj->withMeta));
+    (void)tjsonAddStringToObject(item, "stbUid", i642str(pObj->stbUid));
+    (void)tjsonAddStringToObject(item, "stbName", mndGetStableStr(pObj->stbName));
+    (void)tjsonAddStringToObject(item, "sqlLen", i642str(pObj->sqlLen));
+    (void)tjsonAddStringToObject(item, "astLen", i642str(pObj->astLen));
+    (void)tjsonAddStringToObject(item, "sqlLen", i642str(pObj->sqlLen));
+    (void)tjsonAddStringToObject(item, "ntbUid", i642str(pObj->ntbUid));
+    (void)tjsonAddStringToObject(item, "ctbStbUid", i642str(pObj->ctbStbUid));
     sdbRelease(pSdb, pObj);
   }
 }
@@ -312,9 +312,9 @@ void dumpConsumer(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "consumerId", i642str(pObj->consumerId));
-    tjsonAddStringToObject(item, "cgroup", pObj->cgroup);
+    (void)tjsonAddItemToArray(items, item);
+    (void)tjsonAddStringToObject(item, "consumerId", i642str(pObj->consumerId));
+    (void)tjsonAddStringToObject(item, "cgroup", pObj->cgroup);
     sdbRelease(pSdb, pObj);
   }
 }
@@ -329,10 +329,10 @@ void dumpSubscribe(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "key", pObj->key);
-    tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
-    tjsonAddStringToObject(item, "stbUid", i642str(pObj->stbUid));
+    (void)tjsonAddItemToArray(items, item);
+    (void)tjsonAddStringToObject(item, "key", pObj->key);
+    (void)tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
+    (void)tjsonAddStringToObject(item, "stbUid", i642str(pObj->stbUid));
     sdbRelease(pSdb, pObj);
   }
 }
@@ -347,26 +347,26 @@ void dumpStream(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "name", mndGetDbStr(pObj->name));
-    tjsonAddStringToObject(item, "createTime", i642str(pObj->createTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
-    tjsonAddStringToObject(item, "version", i642str(pObj->version));
-    tjsonAddStringToObject(item, "totalLevel", i642str(pObj->totalLevel));
-    tjsonAddStringToObject(item, "smaId", i642str(pObj->smaId));
-    tjsonAddStringToObject(item, "uid", i642str(pObj->uid));
-    tjsonAddStringToObject(item, "status", i642str(pObj->status));
-    tjsonAddStringToObject(item, "igExpired", i642str(pObj->conf.igExpired));
-    tjsonAddStringToObject(item, "trigger", i642str(pObj->conf.trigger));
-    tjsonAddStringToObject(item, "triggerParam", i642str(pObj->conf.triggerParam));
-    tjsonAddStringToObject(item, "watermark", i642str(pObj->conf.watermark));
-    tjsonAddStringToObject(item, "sourceDbUid", i642str(pObj->sourceDbUid));
-    tjsonAddStringToObject(item, "targetDbUid", i642str(pObj->targetDbUid));
-    tjsonAddStringToObject(item, "sourceDb", mndGetDbStr(pObj->sourceDb));
-    tjsonAddStringToObject(item, "targetDb", mndGetDbStr(pObj->targetDb));
-    tjsonAddStringToObject(item, "targetSTbName", mndGetStbStr(pObj->targetSTbName));
-    tjsonAddStringToObject(item, "targetStbUid", i642str(pObj->targetStbUid));
-    tjsonAddStringToObject(item, "fixedSinkVgId", i642str(pObj->fixedSinkVgId));
+    (void)tjsonAddItemToArray(items, item);
+    (void)tjsonAddStringToObject(item, "name", mndGetDbStr(pObj->name));
+    (void)tjsonAddStringToObject(item, "createTime", i642str(pObj->createTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "version", i642str(pObj->version));
+    (void)tjsonAddStringToObject(item, "totalLevel", i642str(pObj->totalLevel));
+    (void)tjsonAddStringToObject(item, "smaId", i642str(pObj->smaId));
+    (void)tjsonAddStringToObject(item, "uid", i642str(pObj->uid));
+    (void)tjsonAddStringToObject(item, "status", i642str(pObj->status));
+    (void)tjsonAddStringToObject(item, "igExpired", i642str(pObj->conf.igExpired));
+    (void)tjsonAddStringToObject(item, "trigger", i642str(pObj->conf.trigger));
+    (void)tjsonAddStringToObject(item, "triggerParam", i642str(pObj->conf.triggerParam));
+    (void)tjsonAddStringToObject(item, "watermark", i642str(pObj->conf.watermark));
+    (void)tjsonAddStringToObject(item, "sourceDbUid", i642str(pObj->sourceDbUid));
+    (void)tjsonAddStringToObject(item, "targetDbUid", i642str(pObj->targetDbUid));
+    (void)tjsonAddStringToObject(item, "sourceDb", mndGetDbStr(pObj->sourceDb));
+    (void)tjsonAddStringToObject(item, "targetDb", mndGetDbStr(pObj->targetDb));
+    (void)tjsonAddStringToObject(item, "targetSTbName", mndGetStbStr(pObj->targetSTbName));
+    (void)tjsonAddStringToObject(item, "targetStbUid", i642str(pObj->targetStbUid));
+    (void)tjsonAddStringToObject(item, "fixedSinkVgId", i642str(pObj->fixedSinkVgId));
     sdbRelease(pSdb, pObj);
   }
 }
@@ -381,11 +381,11 @@ void dumpAcct(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "acct", pObj->acct);
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
-    tjsonAddStringToObject(item, "acctId", i642str(pObj->acctId));
+    (void)tjsonAddItemToArray(items, item);
+    (void)tjsonAddStringToObject(item, "acct", pObj->acct);
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "acctId", i642str(pObj->acctId));
     sdbRelease(pSdb, pObj);
   }
 }
@@ -404,16 +404,16 @@ void dumpUser(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "name", pObj->user);
-    tjsonAddStringToObject(item, "acct", pObj->acct);
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
-    tjsonAddStringToObject(item, "superUser", i642str(pObj->superUser));
-    tjsonAddStringToObject(item, "authVersion", i642str(pObj->authVersion));
-    tjsonAddStringToObject(item, "passVersion", i642str(pObj->passVersion));
-    tjsonAddStringToObject(item, "numOfReadDbs", i642str(taosHashGetSize(pObj->readDbs)));
-    tjsonAddStringToObject(item, "numOfWriteDbs", i642str(taosHashGetSize(pObj->writeDbs)));
+    (void)tjsonAddItemToArray(items, item);
+    (void)tjsonAddStringToObject(item, "name", pObj->user);
+    (void)tjsonAddStringToObject(item, "acct", pObj->acct);
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "superUser", i642str(pObj->superUser));
+    (void)tjsonAddStringToObject(item, "authVersion", i642str(pObj->authVersion));
+    (void)tjsonAddStringToObject(item, "passVersion", i642str(pObj->passVersion));
+    (void)tjsonAddStringToObject(item, "numOfReadDbs", i642str(taosHashGetSize(pObj->readDbs)));
+    (void)tjsonAddStringToObject(item, "numOfWriteDbs", i642str(taosHashGetSize(pObj->writeDbs)));
     sdbRelease(pSdb, pObj);
   }
 }
@@ -428,12 +428,12 @@ void dumpDnode(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "id", i642str(pObj->id));
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
-    tjsonAddStringToObject(item, "port", i642str(pObj->port));
-    tjsonAddStringToObject(item, "fqdn", pObj->fqdn);
+    (void)tjsonAddItemToArray(items, item);
+    (void)tjsonAddStringToObject(item, "id", i642str(pObj->id));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "port", i642str(pObj->port));
+    (void)tjsonAddStringToObject(item, "fqdn", pObj->fqdn);
     sdbRelease(pSdb, pObj);
   }
 }
@@ -448,10 +448,10 @@ void dumpSnode(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "id", i642str(pObj->id));
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddItemToArray(items, item);
+    (void)tjsonAddStringToObject(item, "id", i642str(pObj->id));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
     sdbRelease(pSdb, pObj);
   }
 }
@@ -466,10 +466,10 @@ void dumpQnode(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "id", i642str(pObj->id));
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddItemToArray(items, item);
+    (void)tjsonAddStringToObject(item, "id", i642str(pObj->id));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
     sdbRelease(pSdb, pObj);
   }
 }
@@ -484,10 +484,10 @@ void dumpMnode(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "id", i642str(pObj->id));
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddItemToArray(items, item);
+    (void)tjsonAddStringToObject(item, "id", i642str(pObj->id));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
     sdbRelease(pSdb, pObj);
   }
 }
@@ -502,11 +502,11 @@ void dumpCluster(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "id", i642str(pObj->id));
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
-    tjsonAddStringToObject(item, "name", pObj->name);
+    (void)tjsonAddItemToArray(items, item);
+    (void)tjsonAddStringToObject(item, "id", i642str(pObj->id));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "name", pObj->name);
     sdbRelease(pSdb, pObj);
   }
 }
@@ -521,29 +521,29 @@ void dumpTrans(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "id", i642str(pObj->id));
-    tjsonAddStringToObject(item, "stage", i642str(pObj->stage));
-    tjsonAddStringToObject(item, "policy", i642str(pObj->policy));
-    tjsonAddStringToObject(item, "conflict", i642str(pObj->conflict));
-    tjsonAddStringToObject(item, "exec", i642str(pObj->exec));
-    tjsonAddStringToObject(item, "oper", i642str(pObj->oper));
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "dbname", pObj->dbname);
-    tjsonAddStringToObject(item, "stbname", pObj->stbname);
-    tjsonAddStringToObject(item, "opername", pObj->opername);
-    tjsonAddStringToObject(item, "commitLogNum", i642str(taosArrayGetSize(pObj->commitActions)));
-    tjsonAddStringToObject(item, "redoActionNum", i642str(taosArrayGetSize(pObj->redoActions)));
-    tjsonAddStringToObject(item, "undoActionNum", i642str(taosArrayGetSize(pObj->undoActions)));
+    (void)tjsonAddItemToArray(items, item);
+    (void)tjsonAddStringToObject(item, "id", i642str(pObj->id));
+    (void)tjsonAddStringToObject(item, "stage", i642str(pObj->stage));
+    (void)tjsonAddStringToObject(item, "policy", i642str(pObj->policy));
+    (void)tjsonAddStringToObject(item, "conflict", i642str(pObj->conflict));
+    (void)tjsonAddStringToObject(item, "exec", i642str(pObj->exec));
+    (void)tjsonAddStringToObject(item, "oper", i642str(pObj->oper));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "dbname", pObj->dbname);
+    (void)tjsonAddStringToObject(item, "stbname", pObj->stbname);
+    (void)tjsonAddStringToObject(item, "opername", pObj->opername);
+    (void)tjsonAddStringToObject(item, "commitLogNum", i642str(taosArrayGetSize(pObj->commitActions)));
+    (void)tjsonAddStringToObject(item, "redoActionNum", i642str(taosArrayGetSize(pObj->redoActions)));
+    (void)tjsonAddStringToObject(item, "undoActionNum", i642str(taosArrayGetSize(pObj->undoActions)));
     sdbRelease(pSdb, pObj);
   }
 }
 
 void dumpHeader(SSdb *pSdb, SJson *json) {
-  tjsonAddStringToObject(json, "sver", i642str(1));
-  tjsonAddStringToObject(json, "applyIndex", i642str(pSdb->applyIndex));
-  tjsonAddStringToObject(json, "applyTerm", i642str(pSdb->applyTerm));
-  tjsonAddStringToObject(json, "applyConfig", i642str(pSdb->applyConfig));
+  (void)tjsonAddStringToObject(json, "sver", i642str(1));
+  (void)tjsonAddStringToObject(json, "applyIndex", i642str(pSdb->applyIndex));
+  (void)tjsonAddStringToObject(json, "applyTerm", i642str(pSdb->applyTerm));
+  (void)tjsonAddStringToObject(json, "applyConfig", i642str(pSdb->applyConfig));
 
   SJson *maxIdsJson = tjsonCreateObject();
   tjsonAddItemToObject(json, "maxIds", maxIdsJson);
@@ -553,7 +553,7 @@ void dumpHeader(SSdb *pSdb, SJson *json) {
     if (i < SDB_MAX) {
       maxId = pSdb->maxId[i];
     }
-    tjsonAddStringToObject(maxIdsJson, sdbTableName(i), i642str(maxId));
+    (void)tjsonAddStringToObject(maxIdsJson, sdbTableName(i), i642str(maxId));
   }
 
   SJson *tableVersJson = tjsonCreateObject();
@@ -563,7 +563,7 @@ void dumpHeader(SSdb *pSdb, SJson *json) {
     if (i < SDB_MAX) {
       tableVer = pSdb->tableVer[i];
     }
-    tjsonAddStringToObject(tableVersJson, sdbTableName(i), i642str(tableVer));
+    (void)tjsonAddStringToObject(tableVersJson, sdbTableName(i), i642str(tableVer));
   }
 }
 
@@ -571,7 +571,7 @@ void mndDumpSdb() {
   mInfo("start to dump sdb info to sdb.json");
 
   char path[PATH_MAX * 2] = {0};
-  snprintf(path, sizeof(path), "%s%smnode", tsDataDir, TD_DIRSEP);
+  (void)snprintf(path, sizeof(path), "%s%smnode", tsDataDir, TD_DIRSEP);
 
   SMsgCb msgCb = {0};
   msgCb.reportStartupFp = reportStartup;
diff --git a/source/dnode/mnode/impl/src/mndFunc.c b/source/dnode/mnode/impl/src/mndFunc.c
index 0642cb0153..442da63b31 100644
--- a/source/dnode/mnode/impl/src/mndFunc.c
+++ b/source/dnode/mnode/impl/src/mndFunc.c
@@ -205,7 +205,7 @@ static int32_t mndFuncActionUpdate(SSdb *pSdb, SFuncObj *pOld, SFuncObj *pNew) {
   if (pNew->commentSize > 0 && pNew->pComment != NULL) {
     pOld->commentSize = pNew->commentSize;
     pOld->pComment = taosMemoryMalloc(pOld->commentSize);
-    memcpy(pOld->pComment, pNew->pComment, pOld->commentSize);
+    (void)memcpy(pOld->pComment, pNew->pComment, pOld->commentSize);
   }
 
   if (pOld->pCode != NULL) {
@@ -215,7 +215,7 @@ static int32_t mndFuncActionUpdate(SSdb *pSdb, SFuncObj *pOld, SFuncObj *pNew) {
   if (pNew->codeSize > 0 && pNew->pCode != NULL) {
     pOld->codeSize = pNew->codeSize;
     pOld->pCode = taosMemoryMalloc(pOld->codeSize);
-    memcpy(pOld->pCode, pNew->pCode, pOld->codeSize);
+    (void)memcpy(pOld->pCode, pNew->pCode, pOld->codeSize);
   }
 
   pOld->scriptType = pNew->scriptType;
@@ -250,7 +250,7 @@ static int32_t mndCreateFunc(SMnode *pMnode, SRpcMsg *pReq, SCreateFuncReq *pCre
   }
 
   SFuncObj func = {0};
-  memcpy(func.name, pCreate->name, TSDB_FUNC_NAME_LEN);
+  (void)memcpy(func.name, pCreate->name, TSDB_FUNC_NAME_LEN);
   func.createdTime = taosGetTimestampMs();
   func.funcType = pCreate->funcType;
   func.scriptType = pCreate->scriptType;
@@ -270,9 +270,9 @@ static int32_t mndCreateFunc(SMnode *pMnode, SRpcMsg *pReq, SCreateFuncReq *pCre
   }
 
   if (func.commentSize > 0) {
-    memcpy(func.pComment, pCreate->pComment, func.commentSize);
+    (void)memcpy(func.pComment, pCreate->pComment, func.commentSize);
   }
-  memcpy(func.pCode, pCreate->pCode, func.codeSize);
+  (void)memcpy(func.pCode, pCreate->pCode, func.codeSize);
 
   pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_NOTHING, pReq, "create-func");
   if (pTrans == NULL) {
@@ -548,7 +548,7 @@ static int32_t mndProcessRetrieveFuncReq(SRpcMsg *pReq) {
     }
 
     SFuncInfo funcInfo = {0};
-    memcpy(funcInfo.name, pFunc->name, TSDB_FUNC_NAME_LEN);
+    (void)memcpy(funcInfo.name, pFunc->name, TSDB_FUNC_NAME_LEN);
     funcInfo.funcType = pFunc->funcType;
     funcInfo.scriptType = pFunc->scriptType;
     funcInfo.outputType = pFunc->outputType;
@@ -566,21 +566,27 @@ static int32_t mndProcessRetrieveFuncReq(SRpcMsg *pReq) {
         terrno = TSDB_CODE_OUT_OF_MEMORY;
         goto RETRIEVE_FUNC_OVER;
       }
-      memcpy(funcInfo.pCode, pFunc->pCode, pFunc->codeSize);
+      (void)memcpy(funcInfo.pCode, pFunc->pCode, pFunc->codeSize);
       if (funcInfo.commentSize > 0) {
         funcInfo.pComment = taosMemoryCalloc(1, funcInfo.commentSize);
         if (funcInfo.pComment == NULL) {
           terrno = TSDB_CODE_OUT_OF_MEMORY;
           goto RETRIEVE_FUNC_OVER;
         }
-        memcpy(funcInfo.pComment, pFunc->pComment, pFunc->commentSize);
+        (void)memcpy(funcInfo.pComment, pFunc->pComment, pFunc->commentSize);
       }
     }
-    taosArrayPush(retrieveRsp.pFuncInfos, &funcInfo);
+    if (taosArrayPush(retrieveRsp.pFuncInfos, &funcInfo) == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      goto RETRIEVE_FUNC_OVER;
+    }
     SFuncExtraInfo extraInfo = {0};
     extraInfo.funcVersion = pFunc->funcVersion;
     extraInfo.funcCreatedTime = pFunc->createdTime;
-    taosArrayPush(retrieveRsp.pFuncExtraInfos, &extraInfo);
+    if (taosArrayPush(retrieveRsp.pFuncExtraInfos, &extraInfo) == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      goto RETRIEVE_FUNC_OVER;
+    }
 
     mndReleaseFunc(pMnode, pFunc);
   }
@@ -616,7 +622,7 @@ static void *mnodeGenTypeStr(char *buf, int32_t buflen, uint8_t type, int32_t le
       type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_GEOMETRY) {
     int32_t bytes = len > 0 ? (int32_t)(len - VARSTR_HEADER_SIZE) : len;
 
-    snprintf(buf, buflen - 1, "%s(%d)", tDataTypes[type].name, type == TSDB_DATA_TYPE_NCHAR ? bytes / 4 : bytes);
+    (void)snprintf(buf, buflen - 1, "%s(%d)", tDataTypes[type].name, type == TSDB_DATA_TYPE_NCHAR ? bytes / 4 : bytes);
     buf[buflen - 1] = 0;
 
     return buf;
@@ -643,40 +649,40 @@ static int32_t mndRetrieveFuncs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
     STR_WITH_MAXSIZE_TO_VARSTR(b1, pFunc->name, pShow->pMeta->pSchemas[cols].bytes);
 
     SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)b1, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)b1, false);
 
     if (pFunc->pComment) {
       char *b2 = taosMemoryCalloc(1, pShow->pMeta->pSchemas[cols].bytes);
       STR_WITH_MAXSIZE_TO_VARSTR(b2, pFunc->pComment, pShow->pMeta->pSchemas[cols].bytes);
 
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)b2, false);
+      (void)colDataSetVal(pColInfo, numOfRows, (const char *)b2, false);
       taosMemoryFree(b2);
     } else {
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, NULL, true);
+      (void)colDataSetVal(pColInfo, numOfRows, NULL, true);
     }
 
     int32_t isAgg = (pFunc->funcType == TSDB_FUNC_TYPE_AGGREGATE) ? 1 : 0;
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&isAgg, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&isAgg, false);
 
     char b3[TSDB_TYPE_STR_MAX_LEN + 1] = {0};
     STR_WITH_MAXSIZE_TO_VARSTR(b3, mnodeGenTypeStr(buf, TSDB_TYPE_STR_MAX_LEN, pFunc->outputType, pFunc->outputLen),
                                pShow->pMeta->pSchemas[cols].bytes);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)b3, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)b3, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pFunc->createdTime, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pFunc->createdTime, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pFunc->codeSize, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pFunc->codeSize, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pFunc->bufSize, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pFunc->bufSize, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     char *language = "";
@@ -688,20 +694,20 @@ static int32_t mndRetrieveFuncs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
     char varLang[TSDB_TYPE_STR_MAX_LEN + 1] = {0};
     varDataSetLen(varLang, strlen(language));
     strcpy(varDataVal(varLang), language);
-    colDataSetVal(pColInfo, numOfRows, (const char *)varLang, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)varLang, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     int32_t varCodeLen = (pFunc->codeSize + VARSTR_HEADER_SIZE) > TSDB_MAX_BINARY_LEN
                              ? TSDB_MAX_BINARY_LEN
                              : pFunc->codeSize + VARSTR_HEADER_SIZE;
     char   *b4 = taosMemoryMalloc(varCodeLen);
-    memcpy(varDataVal(b4), pFunc->pCode, varCodeLen - VARSTR_HEADER_SIZE);
+    (void)memcpy(varDataVal(b4), pFunc->pCode, varCodeLen - VARSTR_HEADER_SIZE);
     varDataSetLen(b4, varCodeLen - VARSTR_HEADER_SIZE);
-    colDataSetVal(pColInfo, numOfRows, (const char *)b4, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)b4, false);
     taosMemoryFree(b4);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pFunc->funcVersion, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pFunc->funcVersion, false);
 
     numOfRows++;
     sdbRelease(pSdb, pFunc);