diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index 4eb64785df..782b9a072d 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -3641,7 +3641,7 @@ int32_t tEncodeSTqOffsetVal(SEncoder* pEncoder, const STqOffsetVal* pOffsetVal);
 int32_t tDecodeSTqOffsetVal(SDecoder* pDecoder, STqOffsetVal* pOffsetVal);
 void    tFormatOffset(char* buf, int32_t maxLen, const STqOffsetVal* pVal);
 bool    tOffsetEqual(const STqOffsetVal* pLeft, const STqOffsetVal* pRight);
-void    tOffsetCopy(STqOffsetVal* pLeft, const STqOffsetVal* pRight);
+int32_t tOffsetCopy(STqOffsetVal* pLeft, const STqOffsetVal* pRight);
 void    tOffsetDestroy(void* pVal);
 
 typedef struct {
diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c
index c5c0553abe..2fe6deaf14 100644
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -9238,17 +9238,18 @@ bool tOffsetEqual(const STqOffsetVal *pLeft, const STqOffsetVal *pRight) {
   return false;
 }
 
-void tOffsetCopy(STqOffsetVal *pLeft, const STqOffsetVal *pRight) {
+int32_t tOffsetCopy(STqOffsetVal *pLeft, const STqOffsetVal *pRight) {
   tOffsetDestroy(pLeft);
   *pLeft = *pRight;
   if (IS_VAR_DATA_TYPE(pRight->primaryKey.type)) {
     pLeft->primaryKey.pData = taosMemoryMalloc(pRight->primaryKey.nData);
     if (pLeft->primaryKey.pData == NULL) {
       uError("failed to allocate memory for offset");
-      return;
+      return terrno;
     }
     (void)memcpy(pLeft->primaryKey.pData, pRight->primaryKey.pData, pRight->primaryKey.nData);
   }
+  return 0;
 }
 
 void tOffsetDestroy(void *param) {
diff --git a/source/dnode/vnode/src/tsdb/tsdbCommit2.c b/source/dnode/vnode/src/tsdb/tsdbCommit2.c
index 0c3fc95d6c..4467102d6f 100644
--- a/source/dnode/vnode/src/tsdb/tsdbCommit2.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCommit2.c
@@ -251,7 +251,7 @@ static int32_t tsdbCommitOpenReader(SCommitter2 *committer) {
 
 _exit:
   if (code) {
-    tsdbCommitCloseReader(committer);
+    TAOS_UNUSED(tsdbCommitCloseReader(committer));
     tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(committer->tsdb->pVnode), __func__, __FILE__, lino,
               tstrerror(code));
   }
@@ -259,8 +259,8 @@ _exit:
 }
 
 static int32_t tsdbCommitCloseIter(SCommitter2 *committer) {
-  tsdbIterMergerClose(&committer->tombIterMerger);
-  tsdbIterMergerClose(&committer->dataIterMerger);
+  TAOS_UNUSED(tsdbIterMergerClose(&committer->tombIterMerger));
+  TAOS_UNUSED(tsdbIterMergerClose(&committer->dataIterMerger));
   TARRAY2_CLEAR(committer->tombIterArray, tsdbIterClose);
   TARRAY2_CLEAR(committer->dataIterArray, tsdbIterClose);
   return 0;
@@ -322,7 +322,7 @@ static int32_t tsdbCommitOpenIter(SCommitter2 *committer) {
 
 _exit:
   if (code) {
-    tsdbCommitCloseIter(committer);
+    TAOS_UNUSED(tsdbCommitCloseIter(committer));
     tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(committer->tsdb->pVnode), __func__, __FILE__, lino,
               tstrerror(code));
   }
@@ -335,7 +335,7 @@ static int32_t tsdbCommitFileSetBegin(SCommitter2 *committer) {
   STsdb  *tsdb = committer->tsdb;
 
   // check if can commit
-  tsdbFSCheckCommit(tsdb, committer->ctx->info->fid);
+  TAOS_UNUSED(tsdbFSCheckCommit(tsdb, committer->ctx->info->fid));
 
   committer->ctx->expLevel = tsdbFidLevel(committer->ctx->info->fid, &tsdb->keepCfg, committer->now);
   tsdbFidKeyRange(committer->ctx->info->fid, committer->minutes, committer->precision, &committer->ctx->minKey,
@@ -344,7 +344,7 @@ static int32_t tsdbCommitFileSetBegin(SCommitter2 *committer) {
   TAOS_CHECK_GOTO(tfsAllocDisk(committer->tsdb->pVnode->pTfs, committer->ctx->expLevel, &committer->ctx->did), &lino,
                   _exit);
 
-  tfsMkdirRecurAt(committer->tsdb->pVnode->pTfs, committer->tsdb->path, committer->ctx->did);
+  TAOS_UNUSED(tfsMkdirRecurAt(committer->tsdb->pVnode->pTfs, committer->tsdb->path, committer->ctx->did));
   committer->ctx->tbid->suid = 0;
   committer->ctx->tbid->uid = 0;
 
@@ -430,12 +430,12 @@ static int32_t tsdbCommitInfoDestroy(STsdb *pTsdb) {
   if (pTsdb->commitInfo) {
     for (int32_t i = 0; i < taosArrayGetSize(pTsdb->commitInfo->arr); i++) {
       SFileSetCommitInfo *info = *(SFileSetCommitInfo **)taosArrayGet(pTsdb->commitInfo->arr, i);
-      vHashDrop(pTsdb->commitInfo->ht, info);
+      TAOS_UNUSED(vHashDrop(pTsdb->commitInfo->ht, info));
       tsdbTFileSetClear(&info->fset);
       taosMemoryFree(info);
     }
 
-    vHashDestroy(&pTsdb->commitInfo->ht);
+    TAOS_UNUSED(vHashDestroy(&pTsdb->commitInfo->ht));
     taosArrayDestroy(pTsdb->commitInfo->arr);
     pTsdb->commitInfo->arr = NULL;
     taosMemoryFreeClear(pTsdb->commitInfo);
@@ -461,7 +461,7 @@ static int32_t tsdbCommitInfoInit(STsdb *pTsdb) {
 
 _exit:
   if (code) {
-    tsdbCommitInfoDestroy(pTsdb);
+    TAOS_UNUSED(tsdbCommitInfoDestroy(pTsdb));
     tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(pTsdb->pVnode), __func__, __FILE__, lino, tstrerror(code));
   }
   return code;
@@ -531,7 +531,7 @@ static int32_t tsdbCommitInfoBuild(STsdb *tsdb) {
       SFileSetCommitInfo  tinfo = {
            .fid = fid,
       };
-      vHashGet(tsdb->commitInfo->ht, &tinfo, (void **)&info);
+      TAOS_UNUSED(vHashGet(tsdb->commitInfo->ht, &tinfo, (void **)&info));
       if (info == NULL) {
         TAOS_CHECK_GOTO(tsdbCommitInfoAdd(tsdb, fid), &lino, _exit);
       }
@@ -555,7 +555,7 @@ static int32_t tsdbCommitInfoBuild(STsdb *tsdb) {
       };
 
       // check if the file set already on the commit list
-      vHashGet(tsdb->commitInfo->ht, &tinfo, (void **)&info);
+      TAOS_UNUSED(vHashGet(tsdb->commitInfo->ht, &tinfo, (void **)&info));
       if (info != NULL) {
         continue;
       }
@@ -589,7 +589,7 @@ static int32_t tsdbCommitInfoBuild(STsdb *tsdb) {
   // begin tasks on file set
   for (int i = 0; i < taosArrayGetSize(tsdb->commitInfo->arr); i++) {
     SFileSetCommitInfo *info = *(SFileSetCommitInfo **)taosArrayGet(tsdb->commitInfo->arr, i);
-    tsdbBeginTaskOnFileSet(tsdb, info->fid, &fset);
+    TAOS_UNUSED(tsdbBeginTaskOnFileSet(tsdb, info->fid, &fset));
     if (fset) {
       code = tsdbTFileSetInitCopy(tsdb, fset, &info->fset);
       if (code) {
@@ -603,7 +603,7 @@ static int32_t tsdbCommitInfoBuild(STsdb *tsdb) {
 
 _exit:
   if (code) {
-    tsdbCommitInfoDestroy(tsdb);
+    TAOS_UNUSED(tsdbCommitInfoDestroy(tsdb));
     tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(tsdb->pVnode), __func__, __FILE__, lino, tstrerror(code));
   }
   return code;
@@ -689,7 +689,7 @@ int32_t tsdbCommitBegin(STsdb *tsdb, SCommitInfo *info) {
     (void)taosThreadMutexLock(&tsdb->mutex);
     tsdb->imem = NULL;
     (void)taosThreadMutexUnlock(&tsdb->mutex);
-    tsdbUnrefMemTable(imem, NULL, true);
+    TAOS_UNUSED(tsdbUnrefMemTable(imem, NULL, true));
   } else {
     SCommitter2 committer = {0};
 
@@ -730,14 +730,14 @@ int32_t tsdbCommitCommit(STsdb *tsdb) {
     for (int32_t i = 0; i < taosArrayGetSize(tsdb->commitInfo->arr); i++) {
       SFileSetCommitInfo *info = *(SFileSetCommitInfo **)taosArrayGet(tsdb->commitInfo->arr, i);
       if (info->fset) {
-        tsdbFinishTaskOnFileSet(tsdb, info->fid);
+        TAOS_UNUSED(tsdbFinishTaskOnFileSet(tsdb, info->fid));
       }
     }
 
     (void)taosThreadMutexUnlock(&tsdb->mutex);
 
-    tsdbCommitInfoDestroy(tsdb);
-    tsdbUnrefMemTable(pMemTable, NULL, true);
+    TAOS_UNUSED(tsdbCommitInfoDestroy(tsdb));
+    TAOS_UNUSED(tsdbUnrefMemTable(pMemTable, NULL, true));
   }
 
 _exit:
@@ -761,11 +761,11 @@ int32_t tsdbCommitAbort(STsdb *pTsdb) {
   for (int32_t i = 0; i < taosArrayGetSize(pTsdb->commitInfo->arr); i++) {
     SFileSetCommitInfo *info = *(SFileSetCommitInfo **)taosArrayGet(pTsdb->commitInfo->arr, i);
     if (info->fset) {
-      tsdbFinishTaskOnFileSet(pTsdb, info->fid);
+      TAOS_UNUSED(tsdbFinishTaskOnFileSet(pTsdb, info->fid));
     }
   }
   (void)taosThreadMutexUnlock(&pTsdb->mutex);
-  tsdbCommitInfoDestroy(pTsdb);
+  TAOS_UNUSED(tsdbCommitInfoDestroy(pTsdb));
 
 _exit:
   if (code) {
diff --git a/source/dnode/vnode/src/tsdb/tsdbDataFileRAW.c b/source/dnode/vnode/src/tsdb/tsdbDataFileRAW.c
index e358b8f87e..6469160536 100644
--- a/source/dnode/vnode/src/tsdb/tsdbDataFileRAW.c
+++ b/source/dnode/vnode/src/tsdb/tsdbDataFileRAW.c
@@ -35,7 +35,7 @@ int32_t tsdbDataFileRAWReaderOpen(const char *fname, const SDataFileRAWReaderCon
     }
   } else {
     char fname1[TSDB_FILENAME_LEN];
-    tsdbTFileName(config->tsdb, &config->file, fname1);
+    (void)tsdbTFileName(config->tsdb, &config->file, fname1);
     TAOS_CHECK_GOTO(tsdbOpenFile(fname1, config->tsdb, TD_FILE_READ, &reader[0]->fd, lcn), &lino, _exit);
   }
 
@@ -159,7 +159,7 @@ static int32_t tsdbDataFileRAWWriterOpenDataFD(SDataFileRAWWriter *writer) {
     flag |= (TD_FILE_CREATE | TD_FILE_TRUNC);
   }
 
-  tsdbTFileName(writer->config->tsdb, &writer->file, fname);
+  (void)tsdbTFileName(writer->config->tsdb, &writer->file, fname);
   TAOS_CHECK_GOTO(tsdbOpenFile(fname, writer->config->tsdb, flag, &writer->fd, writer->file.lcn), &lino, _exit);
 
 _exit:
@@ -202,7 +202,7 @@ int32_t tsdbDataFileRAWWriterClose(SDataFileRAWWriter **writer, bool abort, TFil
     } else {
       TAOS_CHECK_GOTO(tsdbDataFileRAWWriterCloseCommit(writer[0], opArr), &lino, _exit);
     }
-    tsdbDataFileRAWWriterDoClose(writer[0]);
+    (void)tsdbDataFileRAWWriterDoClose(writer[0]);
   }
   taosMemoryFree(writer[0]);
   writer[0] = NULL;
diff --git a/source/dnode/vnode/src/tsdb/tsdbFS2.c b/source/dnode/vnode/src/tsdb/tsdbFS2.c
index ff97274097..8985e07b0c 100644
--- a/source/dnode/vnode/src/tsdb/tsdbFS2.c
+++ b/source/dnode/vnode/src/tsdb/tsdbFS2.c
@@ -46,7 +46,7 @@ static int32_t create_fs(STsdb *pTsdb, STFileSystem **fs) {
   }
 
   fs[0]->tsdb = pTsdb;
-  tsem_init(&fs[0]->canEdit, 0, 1);
+  (void)tsem_init(&fs[0]->canEdit, 0, 1);
   fs[0]->fsstate = TSDB_FS_STATE_NORMAL;
   fs[0]->neid = 0;
   TARRAY2_INIT(fs[0]->fSetArr);
@@ -60,7 +60,7 @@ static int32_t destroy_fs(STFileSystem **fs) {
 
   TARRAY2_DESTROY(fs[0]->fSetArr, NULL);
   TARRAY2_DESTROY(fs[0]->fSetArrTmp, NULL);
-  tsem_destroy(&fs[0]->canEdit);
+  (void)tsem_destroy(&fs[0]->canEdit);
   taosMemoryFree(fs[0]);
   fs[0] = NULL;
   return 0;
@@ -69,7 +69,7 @@ static int32_t destroy_fs(STFileSystem **fs) {
 int32_t current_fname(STsdb *pTsdb, char *fname, EFCurrentT ftype) {
   int32_t offset = 0;
 
-  vnodeGetPrimaryDir(pTsdb->path, pTsdb->pVnode->diskPrimary, pTsdb->pVnode->pTfs, fname, TSDB_FILENAME_LEN);
+  (void)vnodeGetPrimaryDir(pTsdb->path, pTsdb->pVnode->diskPrimary, pTsdb->pVnode->pTfs, fname, TSDB_FILENAME_LEN);
   offset = strlen(fname);
   snprintf(fname + offset, TSDB_FILENAME_LEN - offset - 1, "%s%s", TD_DIRSEP, gCurrentFname[ftype]);
 
@@ -105,7 +105,7 @@ _exit:
     tsdbError("%s failed at %s:%d since %s", __func__, fname, __LINE__, tstrerror(code));
   }
   taosMemoryFree(data);
-  taosCloseFile(&fp);
+  (void)taosCloseFile(&fp);
   return code;
 }
 
@@ -144,7 +144,7 @@ _exit:
     tsdbError("%s failed at %s:%d since %s", __func__, fname, __LINE__, tstrerror(code));
     json[0] = NULL;
   }
-  taosCloseFile(&fp);
+  (void)taosCloseFile(&fp);
   taosMemoryFree(data);
   return code;
 }
@@ -174,7 +174,7 @@ int32_t save_fs(const TFileSetArray *arr, const char *fname) {
     if (!item) {
       TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit);
     }
-    cJSON_AddItemToArray(ajson, item);
+    (void)cJSON_AddItemToArray(ajson, item);
 
     code = tsdbTFileSetToJson(fset, item);
     TSDB_CHECK_CODE(code, lino, _exit);
@@ -255,7 +255,7 @@ static int32_t apply_commit(STFileSystem *fs) {
     if (fset1 && fset2) {
       if (fset1->fid < fset2->fid) {
         // delete fset1
-        tsdbTFileSetRemove(fset1);
+        (void)tsdbTFileSetRemove(fset1);
         i1++;
       } else if (fset1->fid > fset2->fid) {
         // create new file set with fid of fset2->fid
@@ -274,7 +274,7 @@ static int32_t apply_commit(STFileSystem *fs) {
       }
     } else if (fset1) {
       // delete fset1
-      tsdbTFileSetRemove(fset1);
+      (void)tsdbTFileSetRemove(fset1);
       i1++;
     } else {
       // create new file set with fid of fset2->fid
@@ -298,11 +298,11 @@ static int32_t commit_edit(STFileSystem *fs) {
   char current[TSDB_FILENAME_LEN];
   char current_t[TSDB_FILENAME_LEN];
 
-  current_fname(fs->tsdb, current, TSDB_FCURRENT);
+  (void)current_fname(fs->tsdb, current, TSDB_FCURRENT);
   if (fs->etype == TSDB_FEDIT_COMMIT) {
-    current_fname(fs->tsdb, current_t, TSDB_FCURRENT_C);
+    (void)current_fname(fs->tsdb, current_t, TSDB_FCURRENT_C);
   } else {
-    current_fname(fs->tsdb, current_t, TSDB_FCURRENT_M);
+    (void)current_fname(fs->tsdb, current_t, TSDB_FCURRENT_M);
   }
 
   int32_t code;
@@ -333,9 +333,9 @@ static int32_t abort_edit(STFileSystem *fs) {
   char fname[TSDB_FILENAME_LEN];
 
   if (fs->etype == TSDB_FEDIT_COMMIT) {
-    current_fname(fs->tsdb, fname, TSDB_FCURRENT_C);
+    (void)current_fname(fs->tsdb, fname, TSDB_FCURRENT_C);
   } else {
-    current_fname(fs->tsdb, fname, TSDB_FCURRENT_M);
+    (void)current_fname(fs->tsdb, fname, TSDB_FCURRENT_M);
   }
 
   int32_t code;
@@ -368,7 +368,7 @@ static int32_t tsdbFSDoScanAndFixFile(STFileSystem *fs, const STFileObj *fobj) {
 
     if (tsS3Enabled && fobj->f->lcn > 1) {
       char fname1[TSDB_FILENAME_LEN];
-      tsdbTFileLastChunkName(fs->tsdb, fobj->f, fname1);
+      (void)tsdbTFileLastChunkName(fs->tsdb, fobj->f, fname1);
       if (!taosCheckExistFile(fname1)) {
         code = TSDB_CODE_FILE_CORRUPTED;
         tsdbError("vgId:%d %s failed since file:%s does not exist", TD_VID(fs->tsdb->pVnode), __func__, fname1);
@@ -419,7 +419,7 @@ static int32_t tsdbFSCreateFileObjHash(STFileSystem *fs, STFileHash *hash) {
   }
 
   // vnode.json
-  current_fname(fs->tsdb, fname, TSDB_FCURRENT);
+  (void)current_fname(fs->tsdb, fname, TSDB_FCURRENT);
   code = tsdbFSAddEntryToFileObjHash(hash, fname);
   TSDB_CHECK_CODE(code, lino, _exit);
 
@@ -603,9 +603,9 @@ static int32_t open_fs(STFileSystem *fs, int8_t rollback) {
   char cCurrent[TSDB_FILENAME_LEN];
   char mCurrent[TSDB_FILENAME_LEN];
 
-  current_fname(pTsdb, fCurrent, TSDB_FCURRENT);
-  current_fname(pTsdb, cCurrent, TSDB_FCURRENT_C);
-  current_fname(pTsdb, mCurrent, TSDB_FCURRENT_M);
+  (void)current_fname(pTsdb, fCurrent, TSDB_FCURRENT);
+  (void)current_fname(pTsdb, cCurrent, TSDB_FCURRENT_C);
+  (void)current_fname(pTsdb, mCurrent, TSDB_FCURRENT_M);
 
   if (taosCheckExistFile(fCurrent)) {  // current.json exists
     code = load_fs(pTsdb, fCurrent, fs->fSetArr);
@@ -744,7 +744,7 @@ int32_t tsdbOpenFS(STsdb *pTsdb, STFileSystem **fs, int8_t rollback) {
 _exit:
   if (code) {
     tsdbError("vgId:%d %s failed at line %d since %s", TD_VID(pTsdb->pVnode), __func__, lino, tstrerror(code));
-    destroy_fs(fs);
+    (void)destroy_fs(fs);
   } else {
     tsdbInfo("vgId:%d %s success", TD_VID(pTsdb->pVnode), __func__);
   }
@@ -787,12 +787,12 @@ int32_t tsdbDisableAndCancelAllBgTask(STsdb *pTsdb) {
   // destroy all channels
   for (int32_t i = 0; i < taosArrayGetSize(channelArray); i++) {
     SVAChannelID *channel = taosArrayGet(channelArray, i);
-    vnodeAChannelDestroy(channel, true);
+    (void)vnodeAChannelDestroy(channel, true);
   }
   taosArrayDestroy(channelArray);
 
 #ifdef TD_ENTERPRISE
-  tsdbStopAllCompTask(pTsdb);
+  (void)tsdbStopAllCompTask(pTsdb);
 #endif
   return 0;
 }
@@ -807,9 +807,9 @@ int32_t tsdbEnableBgTask(STsdb *pTsdb) {
 int32_t tsdbCloseFS(STFileSystem **fs) {
   if (fs[0] == NULL) return 0;
 
-  tsdbDisableAndCancelAllBgTask((*fs)->tsdb);
-  close_file_system(fs[0]);
-  destroy_fs(fs);
+  (void)tsdbDisableAndCancelAllBgTask((*fs)->tsdb);
+  (void)close_file_system(fs[0]);
+  (void)destroy_fs(fs);
   return 0;
 }
 
@@ -832,12 +832,12 @@ int32_t tsdbFSEditBegin(STFileSystem *fs, const TFileOpArray *opArray, EFEditT e
   char    current_t[TSDB_FILENAME_LEN];
 
   if (etype == TSDB_FEDIT_COMMIT) {
-    current_fname(fs->tsdb, current_t, TSDB_FCURRENT_C);
+    (void)current_fname(fs->tsdb, current_t, TSDB_FCURRENT_C);
   } else {
-    current_fname(fs->tsdb, current_t, TSDB_FCURRENT_M);
+    (void)current_fname(fs->tsdb, current_t, TSDB_FCURRENT_M);
   }
 
-  tsem_wait(&fs->canEdit);
+  (void)tsem_wait(&fs->canEdit);
   fs->etype = etype;
 
   // edit
@@ -864,7 +864,7 @@ static int32_t tsdbFSSetBlockCommit(STFileSet *fset, bool block) {
   } else {
     fset->blockCommit = false;
     if (fset->numWaitCommit > 0) {
-      taosThreadCondSignal(&fset->canCommit);
+      (void)taosThreadCondSignal(&fset->canCommit);
     }
   }
   return 0;
@@ -873,7 +873,7 @@ static int32_t tsdbFSSetBlockCommit(STFileSet *fset, bool block) {
 int32_t tsdbFSCheckCommit(STsdb *tsdb, int32_t fid) {
   (void)taosThreadMutexLock(&tsdb->mutex);
   STFileSet *fset;
-  tsdbFSGetFSet(tsdb->pFS, fid, &fset);
+  (void)tsdbFSGetFSet(tsdb->pFS, fid, &fset);
   if (fset) {
     while (fset->blockCommit) {
       fset->numWaitCommit++;
@@ -901,13 +901,13 @@ int32_t tsdbFSEditCommit(STFileSystem *fs) {
     STFileSet *fset;
     TARRAY2_FOREACH_REVERSE(fs->fSetArr, fset) {
       if (TARRAY2_SIZE(fset->lvlArr) == 0) {
-        tsdbFSSetBlockCommit(fset, false);
+        (void)tsdbFSSetBlockCommit(fset, false);
         continue;
       }
 
       SSttLvl *lvl = TARRAY2_FIRST(fset->lvlArr);
       if (lvl->level != 0) {
-        tsdbFSSetBlockCommit(fset, false);
+        (void)tsdbFSSetBlockCommit(fset, false);
         continue;
       }
 
@@ -932,9 +932,9 @@ int32_t tsdbFSEditCommit(STFileSystem *fs) {
       }
 
       if (numFile >= sttTrigger * BLOCK_COMMIT_FACTOR) {
-        tsdbFSSetBlockCommit(fset, true);
+        (void)tsdbFSSetBlockCommit(fset, true);
       } else {
-        tsdbFSSetBlockCommit(fset, false);
+        (void)tsdbFSSetBlockCommit(fset, false);
       }
     }
   }
@@ -945,13 +945,13 @@ _exit:
   } else {
     tsdbInfo("vgId:%d %s done, etype:%d", TD_VID(fs->tsdb->pVnode), __func__, fs->etype);
   }
-  tsem_post(&fs->canEdit);
+  (void)tsem_post(&fs->canEdit);
   return code;
 }
 
 int32_t tsdbFSEditAbort(STFileSystem *fs) {
   int32_t code = abort_edit(fs);
-  tsem_post(&fs->canEdit);
+  (void)tsem_post(&fs->canEdit);
   return code;
 }
 
@@ -1181,7 +1181,7 @@ int32_t tsdbFSDestroyRefRangedSnapshot(TFileSetRangeArray **fsrArr) { return tsd
 int32_t tsdbBeginTaskOnFileSet(STsdb *tsdb, int32_t fid, STFileSet **fset) {
   int16_t sttTrigger = tsdb->pVnode->config.sttTrigger;
 
-  tsdbFSGetFSet(tsdb->pFS, fid, fset);
+  (void)tsdbFSGetFSet(tsdb->pFS, fid, fset);
   if (sttTrigger == 1 && (*fset)) {
     for (;;) {
       if ((*fset)->taskRunning) {
@@ -1189,7 +1189,7 @@ int32_t tsdbBeginTaskOnFileSet(STsdb *tsdb, int32_t fid, STFileSet **fset) {
 
         taosThreadCondWait(&(*fset)->beginTask, &tsdb->mutex);
 
-        tsdbFSGetFSet(tsdb->pFS, fid, fset);
+        (void)tsdbFSGetFSet(tsdb->pFS, fid, fset);
         ASSERT(fset != NULL);
 
         (*fset)->numWaitTask--;
@@ -1209,11 +1209,11 @@ int32_t tsdbFinishTaskOnFileSet(STsdb *tsdb, int32_t fid) {
   int16_t sttTrigger = tsdb->pVnode->config.sttTrigger;
   if (sttTrigger == 1) {
     STFileSet *fset = NULL;
-    tsdbFSGetFSet(tsdb->pFS, fid, &fset);
+    (void)tsdbFSGetFSet(tsdb->pFS, fid, &fset);
     if (fset != NULL && fset->taskRunning) {
       fset->taskRunning = false;
       if (fset->numWaitTask > 0) {
-        taosThreadCondSignal(&fset->beginTask);
+        (void)taosThreadCondSignal(&fset->beginTask);
       }
       tsdbInfo("vgId:%d finish task on file set:%d", TD_VID(tsdb->pVnode), fid);
     }
diff --git a/source/dnode/vnode/src/tsdb/tsdbFSetRW.c b/source/dnode/vnode/src/tsdb/tsdbFSetRW.c
index 77d8998aa7..3ccf833ddd 100644
--- a/source/dnode/vnode/src/tsdb/tsdbFSetRW.c
+++ b/source/dnode/vnode/src/tsdb/tsdbFSetRW.c
@@ -44,7 +44,7 @@ static int32_t tsdbFSetWriteTableDataBegin(SFSetWriter *writer, const TABLEID *t
   writer->ctx->tbid->uid = tbid->uid;
 
   code = tsdbUpdateSkmTb(writer->config->tsdb, writer->ctx->tbid, writer->skmTb);
-  TSDB_CHECK_CODE(code , lino, _exit);
+  TSDB_CHECK_CODE(code, lino, _exit);
 
   code = metaGetColCmpr(writer->config->tsdb->pVnode->pMeta, tbid->suid ? tbid->suid : tbid->uid, &writer->pColCmprObj);
   // TODO: TSDB_CHECK_CODE(code, lino, _exit);
diff --git a/source/dnode/vnode/src/tsdb/tsdbFile.c b/source/dnode/vnode/src/tsdb/tsdbFile.c
index 243ff662f7..cf88f9a066 100644
--- a/source/dnode/vnode/src/tsdb/tsdbFile.c
+++ b/source/dnode/vnode/src/tsdb/tsdbFile.c
@@ -221,7 +221,7 @@ void tsdbDelFileName(STsdb *pTsdb, SDelFile *pFile, char fname[]) {
   int32_t offset = 0;
   SVnode *pVnode = pTsdb->pVnode;
 
-  vnodeGetPrimaryDir(pTsdb->path, pVnode->diskPrimary, pVnode->pTfs, fname, TSDB_FILENAME_LEN);
+  (void)vnodeGetPrimaryDir(pTsdb->path, pVnode->diskPrimary, pVnode->pTfs, fname, TSDB_FILENAME_LEN);
   offset = strlen(fname);
   snprintf((char *)fname + offset, TSDB_FILENAME_LEN - offset - 1, "%sv%dver%" PRId64 ".del", TD_DIRSEP,
            TD_VID(pTsdb->pVnode), pFile->commitID);
diff --git a/source/dnode/vnode/src/tsdb/tsdbIter.c b/source/dnode/vnode/src/tsdb/tsdbIter.c
index 3b5bd6d02f..0de9ba9822 100644
--- a/source/dnode/vnode/src/tsdb/tsdbIter.c
+++ b/source/dnode/vnode/src/tsdb/tsdbIter.c
@@ -224,7 +224,7 @@ static int32_t tsdbMemTableIterNext(STsdbIter *iter, const TABLEID *tbid) {
 
       iter->row->row = row[0];
 
-      tsdbTbDataIterNext(iter->memtData->tbIter);
+      (void)tsdbTbDataIterNext(iter->memtData->tbIter);
       goto _exit;
     }
 
diff --git a/source/dnode/vnode/src/tsdb/tsdbMerge.c b/source/dnode/vnode/src/tsdb/tsdbMerge.c
index 7b40290c05..1bbda8a249 100644
--- a/source/dnode/vnode/src/tsdb/tsdbMerge.c
+++ b/source/dnode/vnode/src/tsdb/tsdbMerge.c
@@ -215,7 +215,7 @@ static int32_t tsdbMergeFileSetBeginOpenReader(SMerger *merger) {
         TAOS_CHECK_GOTO(tsdbSttFileReaderOpen(fobj->fname, &config, &reader), &lino, _exit);
 
         if ((code = TARRAY2_APPEND(merger->sttReaderArr, reader))) {
-          tsdbSttFileReaderClose(&reader);
+          (void)tsdbSttFileReaderClose(&reader);
           TSDB_CHECK_CODE(code, lino, _exit);
         }
       }
@@ -230,7 +230,7 @@ _exit:
   if (code) {
     tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(merger->tsdb->pVnode), __func__, __FILE__, lino,
               tstrerror(code));
-    tsdbMergeFileSetEndCloseReader(merger);
+    (void)tsdbMergeFileSetEndCloseReader(merger);
   }
   return code;
 }
@@ -282,7 +282,7 @@ static int32_t tsdbMergeFileSetBeginOpenWriter(SMerger *merger) {
 
   TAOS_CHECK_GOTO(tfsAllocDisk(merger->tsdb->pVnode->pTfs, level, &did), &lino, _exit);
 
-  tfsMkdirRecurAt(merger->tsdb->pVnode->pTfs, merger->tsdb->path, did);
+  (void)tfsMkdirRecurAt(merger->tsdb->pVnode->pTfs, merger->tsdb->path, did);
   SFSetWriterConfig config = {
       .tsdb = merger->tsdb,
       .toSttOnly = true,
@@ -355,9 +355,9 @@ static int32_t tsdbMergeFileSetEndCloseWriter(SMerger *merger) {
 }
 
 static int32_t tsdbMergeFileSetEndCloseIter(SMerger *merger) {
-  tsdbIterMergerClose(&merger->tombIterMerger);
+  (void)tsdbIterMergerClose(&merger->tombIterMerger);
   TARRAY2_CLEAR(merger->tombIterArr, tsdbIterClose);
-  tsdbIterMergerClose(&merger->dataIterMerger);
+  (void)tsdbIterMergerClose(&merger->dataIterMerger);
   TARRAY2_CLEAR(merger->dataIterArr, tsdbIterClose);
   return 0;
 }
@@ -479,7 +479,7 @@ static int32_t tsdbMergeGetFSet(SMerger *merger) {
   STFileSet *fset;
 
   (void)taosThreadMutexLock(&merger->tsdb->mutex);
-  tsdbFSGetFSet(merger->tsdb->pFS, merger->fid, &fset);
+  (void)tsdbFSGetFSet(merger->tsdb->pFS, merger->fid, &fset);
   if (fset == NULL) {
     (void)taosThreadMutexUnlock(&merger->tsdb->mutex);
     return 0;
diff --git a/source/dnode/vnode/src/tsdb/tsdbOpen.c b/source/dnode/vnode/src/tsdb/tsdbOpen.c
index 370d847a33..7f83bcdb0c 100644
--- a/source/dnode/vnode/src/tsdb/tsdbOpen.c
+++ b/source/dnode/vnode/src/tsdb/tsdbOpen.c
@@ -59,16 +59,16 @@ int32_t tsdbOpen(SVnode *pVnode, STsdb **ppTsdb, const char *dir, STsdbKeepCfg *
   pTsdb->pVnode = pVnode;
   taosThreadMutexInit(&pTsdb->mutex, NULL);
   if (!pKeepCfg) {
-    tsdbSetKeepCfg(pTsdb, &pVnode->config.tsdbCfg);
+    (void)tsdbSetKeepCfg(pTsdb, &pVnode->config.tsdbCfg);
   } else {
     memcpy(&pTsdb->keepCfg, pKeepCfg, sizeof(STsdbKeepCfg));
   }
 
   // create dir
   if (pVnode->pTfs) {
-    tfsMkdir(pVnode->pTfs, pTsdb->path);
+    (void)tfsMkdir(pVnode->pTfs, pTsdb->path);
   } else {
-    taosMkDir(pTsdb->path);
+    (void)taosMkDir(pTsdb->path);
   }
 
   // open tsdb
@@ -87,8 +87,8 @@ int32_t tsdbOpen(SVnode *pVnode, STsdb **ppTsdb, const char *dir, STsdbKeepCfg *
 _exit:
   if (code) {
     tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(pVnode), __func__, __FILE__, lino, tstrerror(code));
-    tsdbCloseFS(&pTsdb->pFS);
-    taosThreadMutexDestroy(&pTsdb->mutex);
+    (void)tsdbCloseFS(&pTsdb->pFS);
+    (void)taosThreadMutexDestroy(&pTsdb->mutex);
     taosMemoryFree(pTsdb);
   } else {
     tsdbDebug("vgId:%d, tsdb is opened at %s, days:%d, keep:%d,%d,%d, keepTimeoffset:%d", TD_VID(pVnode), pTsdb->path,
@@ -110,12 +110,12 @@ int32_t tsdbClose(STsdb **pTsdb) {
     (*pTsdb)->mem = NULL;
     (void)taosThreadMutexUnlock(&(*pTsdb)->mutex);
 
-    tsdbCloseFS(&(*pTsdb)->pFS);
+    (void)tsdbCloseFS(&(*pTsdb)->pFS);
     tsdbCloseCache(*pTsdb);
 #ifdef TD_ENTERPRISE
-    tsdbCloseCompMonitor(*pTsdb);
+    (void)tsdbCloseCompMonitor(*pTsdb);
 #endif
-    taosThreadMutexDestroy(&(*pTsdb)->mutex);
+    (void)taosThreadMutexDestroy(&(*pTsdb)->mutex);
     taosMemoryFreeClear(*pTsdb);
   }
   return 0;
diff --git a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
index 28abed1ce7..8e52074807 100644
--- a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
+++ b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c
@@ -35,7 +35,7 @@ static int32_t tsdbOpenFileImpl(STsdbFD *pFD) {
 
       int32_t     vid = 0;
       const char *object_name = taosDirEntryBaseName((char *)path);
-      sscanf(object_name, "v%df%dver%" PRId64 ".data", &vid, &pFD->fid, &pFD->cid);
+      (void)sscanf(object_name, "v%df%dver%" PRId64 ".data", &vid, &pFD->fid, &pFD->cid);
 
       char *dot = strrchr(lc_path, '.');
       if (!dot) {
@@ -124,7 +124,7 @@ void tsdbCloseFile(STsdbFD **ppFD) {
   if (pFD) {
     taosMemoryFree(pFD->pBuf);
     // if (!pFD->s3File) {
-    taosCloseFile(&pFD->pFD);
+    (void)taosCloseFile(&pFD->pFD);
     //}
     taosMemoryFree(pFD);
     *ppFD = NULL;
@@ -156,7 +156,7 @@ static int32_t tsdbWriteFilePage(STsdbFD *pFD, int32_t encryptAlgorithm, char *e
       TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(errno), lino, _exit);
     }
 
-    taosCalcChecksumAppend(0, pFD->pBuf, pFD->szPage);
+    (void)taosCalcChecksumAppend(0, pFD->pBuf, pFD->szPage);
 
     if (encryptAlgorithm == DND_CA_SM4) {
       // if(tsiEncryptAlgorithm == DND_CA_SM4 && (tsiEncryptScope & DND_CS_TSDB) == DND_CS_TSDB){
@@ -430,7 +430,7 @@ static int32_t tsdbReadFileS3(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int64
       code = tsdbCacheGetPageS3(pFD->pTsdb->pgCache, pFD, pgno, &handle);
       if (code != TSDB_CODE_SUCCESS) {
         if (handle) {
-          tsdbCacheRelease(pFD->pTsdb->pgCache, handle);
+          (void)tsdbCacheRelease(pFD->pTsdb->pgCache, handle);
         }
         TSDB_CHECK_CODE(code, lino, _exit);
       }
@@ -441,7 +441,7 @@ static int32_t tsdbReadFileS3(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int64
 
       uint8_t *pPage = (uint8_t *)taosLRUCacheValue(pFD->pTsdb->pgCache, handle);
       memcpy(pFD->pBuf, pPage, pFD->szPage);
-      tsdbCacheRelease(pFD->pTsdb->pgCache, handle);
+      (void)tsdbCacheRelease(pFD->pTsdb->pgCache, handle);
 
       // check
       if (pgno > 1 && !taosCheckChecksumWhole(pFD->pBuf, pFD->szPage)) {
@@ -477,7 +477,7 @@ static int32_t tsdbReadFileS3(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int64
     int nPage = pgnoEnd - pgno + 1;
     for (int i = 0; i < nPage; ++i) {
       if (pFD->szFile != pgno) {  // DONOT cache last volatile page
-        tsdbCacheSetPageS3(pFD->pTsdb->pgCache, pFD, pgno, pBlock + i * pFD->szPage);
+        (void)tsdbCacheSetPageS3(pFD->pTsdb->pgCache, pFD, pgno, pBlock + i * pFD->szPage);
       }
 
       if (szHint > 0 && n >= size) {
diff --git a/source/dnode/vnode/src/tsdb/tsdbRetention.c b/source/dnode/vnode/src/tsdb/tsdbRetention.c
index a454f09e22..bdd174a8f8 100644
--- a/source/dnode/vnode/src/tsdb/tsdbRetention.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRetention.c
@@ -71,8 +71,8 @@ static int32_t tsdbDoCopyFileLC(SRTNer *rtner, const STFileObj *from, const STFi
   char      fname_from[TSDB_FILENAME_LEN];
   char      fname_to[TSDB_FILENAME_LEN];
 
-  tsdbTFileLastChunkName(rtner->tsdb, from->f, fname_from);
-  tsdbTFileLastChunkName(rtner->tsdb, to, fname_to);
+  (void)tsdbTFileLastChunkName(rtner->tsdb, from->f, fname_from);
+  (void)tsdbTFileLastChunkName(rtner->tsdb, to, fname_to);
 
   fdFrom = taosOpenFile(fname_from, TD_FILE_READ);
   if (fdFrom == NULL) {
@@ -99,8 +99,8 @@ _exit:
     tsdbError("vgId:%d, %s failed at %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino,
               tstrerror(code));
   }
-  taosCloseFile(&fdFrom);
-  taosCloseFile(&fdTo);
+  (void)taosCloseFile(&fdFrom);
+  (void)taosCloseFile(&fdTo);
   return code;
 }
 
@@ -112,7 +112,7 @@ static int32_t tsdbDoCopyFile(SRTNer *rtner, const STFileObj *from, const STFile
   TdFilePtr fdFrom = NULL;
   TdFilePtr fdTo = NULL;
 
-  tsdbTFileName(rtner->tsdb, to, fname);
+  (void)tsdbTFileName(rtner->tsdb, to, fname);
 
   fdFrom = taosOpenFile(from->fname, TD_FILE_READ);
   if (fdFrom == NULL) {
@@ -136,8 +136,8 @@ _exit:
     tsdbError("vgId:%d, %s failed at %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino,
               tstrerror(code));
   }
-  taosCloseFile(&fdFrom);
-  taosCloseFile(&fdTo);
+  (void)taosCloseFile(&fdFrom);
+  (void)taosCloseFile(&fdTo);
   return code;
 }
 
@@ -255,7 +255,7 @@ static int32_t tsdbDoRetention(SRTNer *rtner) {
     SDiskID did;
 
     TAOS_CHECK_GOTO(tfsAllocDisk(rtner->tsdb->pVnode->pTfs, expLevel, &did), &lino, _exit);
-    tfsMkdirRecurAt(rtner->tsdb->pVnode->pTfs, rtner->tsdb->path, did);
+    (void)tfsMkdirRecurAt(rtner->tsdb->pVnode->pTfs, rtner->tsdb->path, did);
 
     // data
     for (int32_t ftype = 0; ftype < TSDB_FTYPE_MAX && (fobj = fset->farr[ftype], 1); ++ftype) {
@@ -316,7 +316,7 @@ static int32_t tsdbRetention(void *arg) {
 
   // begin task
   (void)taosThreadMutexLock(&pTsdb->mutex);
-  tsdbBeginTaskOnFileSet(pTsdb, rtnArg->fid, &fset);
+  (void)tsdbBeginTaskOnFileSet(pTsdb, rtnArg->fid, &fset);
   if (fset && (code = tsdbTFileSetInitCopy(pTsdb, fset, &rtner.fset))) {
     (void)taosThreadMutexUnlock(&pTsdb->mutex);
     TSDB_CHECK_CODE(code, lino, _exit);
@@ -337,7 +337,7 @@ static int32_t tsdbRetention(void *arg) {
 _exit:
   if (rtner.fset) {
     (void)taosThreadMutexLock(&pTsdb->mutex);
-    tsdbFinishTaskOnFileSet(pTsdb, rtnArg->fid);
+    (void)tsdbFinishTaskOnFileSet(pTsdb, rtnArg->fid);
     (void)taosThreadMutexUnlock(&pTsdb->mutex);
   }
 
@@ -427,7 +427,7 @@ static int32_t tsdbCopyFileS3(SRTNer *rtner, const STFileObj *from, const STFile
   TdFilePtr fdFrom = NULL;
   // TdFilePtr fdTo = NULL;
 
-  tsdbTFileName(rtner->tsdb, to, fname);
+  (void)tsdbTFileName(rtner->tsdb, to, fname);
 
   fdFrom = taosOpenFile(from->fname, TD_FILE_READ);
   if (fdFrom == NULL) {
@@ -442,7 +442,7 @@ _exit:
     tsdbError("vgId:%d %s failed at line %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino,
               tstrerror(code));
   }
-  taosCloseFile(&fdFrom);
+  (void)taosCloseFile(&fdFrom);
   return code;
 }
 
@@ -486,7 +486,7 @@ static int32_t tsdbMigrateDataFileLCS3(SRTNer *rtner, const STFileObj *fobj, int
   TAOS_CHECK_GOTO(TARRAY2_APPEND(&rtner->fopArr, op), &lino, _exit);
 
   char fname[TSDB_FILENAME_LEN];
-  tsdbTFileName(rtner->tsdb, &op.nf, fname);
+  (void)tsdbTFileName(rtner->tsdb, &op.nf, fname);
   char   *object_name = taosDirEntryBaseName(fname);
   char    object_name_prefix[TSDB_FILENAME_LEN];
   int32_t node_id = vnodeNodeId(rtner->tsdb->pVnode);
@@ -542,8 +542,8 @@ _exit:
     tsdbError("vgId:%d %s failed at line %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino,
               tstrerror(code));
   }
-  taosCloseFile(&fdFrom);
-  taosCloseFile(&fdTo);
+  (void)taosCloseFile(&fdFrom);
+  (void)taosCloseFile(&fdTo);
   return code;
 }
 
@@ -587,7 +587,7 @@ static int32_t tsdbMigrateDataFileS3(SRTNer *rtner, const STFileObj *fobj, int64
   TAOS_CHECK_GOTO(TARRAY2_APPEND(&rtner->fopArr, op), &lino, _exit);
 
   char fname[TSDB_FILENAME_LEN];
-  tsdbTFileName(rtner->tsdb, &op.nf, fname);
+  (void)tsdbTFileName(rtner->tsdb, &op.nf, fname);
   char   *object_name = taosDirEntryBaseName(fname);
   char    object_name_prefix[TSDB_FILENAME_LEN];
   int32_t node_id = vnodeNodeId(rtner->tsdb->pVnode);
@@ -640,8 +640,8 @@ _exit:
     tsdbError("vgId:%d %s failed at line %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino,
               tstrerror(code));
   }
-  taosCloseFile(&fdFrom);
-  taosCloseFile(&fdTo);
+  (void)taosCloseFile(&fdFrom);
+  (void)taosCloseFile(&fdTo);
   return code;
 }
 
@@ -673,7 +673,7 @@ static int32_t tsdbDoS3Migrate(SRTNer *rtner) {
   if (/*lcn < 1 && */ taosCheckExistFile(fobj->fname)) {
     int32_t mtime = 0;
     int64_t size = 0;
-    taosStatFile(fobj->fname, &size, &mtime, NULL);
+    (void)taosStatFile(fobj->fname, &size, &mtime, NULL);
     if (size > chunksize && mtime < rtner->now - tsS3UploadDelaySec) {
       if (pCfg->s3Compact && lcn < 0) {
         extern int32_t tsdbAsyncCompact(STsdb * tsdb, const STimeWindow *tw, bool sync);
@@ -695,12 +695,12 @@ static int32_t tsdbDoS3Migrate(SRTNer *rtner) {
       TAOS_CHECK_GOTO(TSDB_CODE_INVALID_PARA, &lino, _exit);
     }
     char fname1[TSDB_FILENAME_LEN];
-    tsdbTFileLastChunkName(rtner->tsdb, fobj->f, fname1);
+    (void)tsdbTFileLastChunkName(rtner->tsdb, fobj->f, fname1);
 
     if (taosCheckExistFile(fname1)) {
       int32_t mtime = 0;
       int64_t size = 0;
-      taosStatFile(fname1, &size, &mtime, NULL);
+      (void)taosStatFile(fname1, &size, &mtime, NULL);
       if (size > chunksize && mtime < rtner->now - tsS3UploadDelaySec) {
         TAOS_CHECK_GOTO(tsdbMigrateDataFileLCS3(rtner, fobj, size, chunksize), &lino, _exit);
       }
diff --git a/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c b/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c
index c9e02c5130..decf276bc6 100644
--- a/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c
@@ -196,7 +196,7 @@ int32_t tsdbFSetPartListToRangeDiff(STsdbFSetPartList* pList, TFileSetRangeArray
 
 _err:
   if (pDiff) {
-    tsdbTFileSetRangeArrayDestroy(&pDiff);
+    (void)tsdbTFileSetRangeArrayDestroy(&pDiff);
   }
   return code;
 }
diff --git a/source/dnode/vnode/src/tsdb/tsdbSnapshot.c b/source/dnode/vnode/src/tsdb/tsdbSnapshot.c
index 3edff5ebcb..2b63d5b6e6 100644
--- a/source/dnode/vnode/src/tsdb/tsdbSnapshot.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSnapshot.c
@@ -59,7 +59,7 @@ struct STsdbSnapReader {
 
 static int32_t tsdbSnapReadFileSetCloseReader(STsdbSnapReader* reader) {
   TARRAY2_CLEAR(reader->sttReaderArr, tsdbSttFileReaderClose);
-  tsdbDataFileReaderClose(&reader->dataReader);
+  TAOS_UNUSED(tsdbDataFileReaderClose(&reader->dataReader));
   return 0;
 }
 
@@ -107,7 +107,7 @@ static int32_t tsdbSnapReadFileSetOpenReader(STsdbSnapReader* reader) {
       TSDB_CHECK_CODE(code, lino, _exit);
 
       if ((code = TARRAY2_APPEND(reader->sttReaderArr, sttReader))) {
-        tsdbSttFileReaderClose(&sttReader);
+        TAOS_UNUSED(tsdbSttFileReaderClose(&sttReader));
         TSDB_CHECK_CODE(code, lino, _exit);
       }
     }
@@ -115,7 +115,7 @@ static int32_t tsdbSnapReadFileSetOpenReader(STsdbSnapReader* reader) {
 
 _exit:
   if (code) {
-    tsdbSnapReadFileSetCloseReader(reader);
+    TAOS_UNUSED(tsdbSnapReadFileSetCloseReader(reader));
     TSDB_ERROR_LOG(TD_VID(reader->tsdb->pVnode), code, lino);
   }
   return code;
@@ -199,8 +199,8 @@ _exit:
 }
 
 static int32_t tsdbSnapReadFileSetCloseIter(STsdbSnapReader* reader) {
-  tsdbIterMergerClose(&reader->dataIterMerger);
-  tsdbIterMergerClose(&reader->tombIterMerger);
+  TAOS_UNUSED(tsdbIterMergerClose(&reader->dataIterMerger));
+  TAOS_UNUSED(tsdbIterMergerClose(&reader->tombIterMerger));
   TARRAY2_CLEAR(reader->dataIterArr, tsdbIterClose);
   TARRAY2_CLEAR(reader->tombIterArr, tsdbIterClose);
   return 0;
@@ -232,8 +232,8 @@ _exit:
 }
 
 static int32_t tsdbSnapReadRangeEnd(STsdbSnapReader* reader) {
-  tsdbSnapReadFileSetCloseIter(reader);
-  tsdbSnapReadFileSetCloseReader(reader);
+  TAOS_UNUSED(tsdbSnapReadFileSetCloseIter(reader));
+  TAOS_UNUSED(tsdbSnapReadFileSetCloseReader(reader));
   reader->ctx->fsr = NULL;
   return 0;
 }
@@ -384,7 +384,7 @@ static int32_t tsdbSnapReadTombData(STsdbSnapReader* reader, uint8_t** data) {
   int32_t   lino = 0;
   SMetaInfo info;
 
-  tTombBlockClear(reader->tombBlock);
+  TAOS_UNUSED(tTombBlockClear(reader->tombBlock));
 
   TABLEID tbid[1] = {0};
   for (STombRecord* record; (record = tsdbIterMergerGetTombRecord(reader->tombIterMerger)) != NULL;) {
@@ -441,7 +441,7 @@ _exit:
   if (code) {
     tsdbError("vgId:%d %s failed at %s:%d since %s, sver:%" PRId64 " ever:%" PRId64 " type:%d", TD_VID(tsdb->pVnode),
               __func__, __FILE__, lino, tstrerror(code), sver, ever, type);
-    tsdbTFileSetRangeArrayDestroy(&reader[0]->fsrArr);
+    TAOS_UNUSED(tsdbTFileSetRangeArrayDestroy(&reader[0]->fsrArr));
     taosMemoryFree(reader[0]);
     reader[0] = NULL;
   } else {
@@ -460,21 +460,21 @@ int32_t tsdbSnapReaderClose(STsdbSnapReader** reader) {
 
   STsdb* tsdb = reader[0]->tsdb;
 
-  tTombBlockDestroy(reader[0]->tombBlock);
+  TAOS_UNUSED(tTombBlockDestroy(reader[0]->tombBlock));
   tBlockDataDestroy(reader[0]->blockData);
 
-  tsdbIterMergerClose(&reader[0]->dataIterMerger);
-  tsdbIterMergerClose(&reader[0]->tombIterMerger);
+  TAOS_UNUSED(tsdbIterMergerClose(&reader[0]->dataIterMerger));
+  TAOS_UNUSED(tsdbIterMergerClose(&reader[0]->tombIterMerger));
   TARRAY2_DESTROY(reader[0]->dataIterArr, tsdbIterClose);
   TARRAY2_DESTROY(reader[0]->tombIterArr, tsdbIterClose);
   TARRAY2_DESTROY(reader[0]->sttReaderArr, tsdbSttFileReaderClose);
-  tsdbDataFileReaderClose(&reader[0]->dataReader);
+  TAOS_UNUSED(tsdbDataFileReaderClose(&reader[0]->dataReader));
 
-  tsdbFSDestroyRefRangedSnapshot(&reader[0]->fsrArr);
+  TAOS_UNUSED(tsdbFSDestroyRefRangedSnapshot(&reader[0]->fsrArr));
   tDestroyTSchema(reader[0]->skmTb->pTSchema);
 
   for (int32_t i = 0; i < ARRAY_SIZE(reader[0]->buffers); ++i) {
-    tBufferDestroy(reader[0]->buffers + i);
+    TAOS_UNUSED(tBufferDestroy(reader[0]->buffers + i));
   }
 
   taosMemoryFree(reader[0]);
@@ -706,7 +706,7 @@ _exit:
 
 static int32_t tsdbSnapWriteFileSetCloseReader(STsdbSnapWriter* writer) {
   TARRAY2_CLEAR(writer->ctx->sttReaderArr, tsdbSttFileReaderClose);
-  tsdbDataFileReaderClose(&writer->ctx->dataReader);
+  TAOS_UNUSED(tsdbDataFileReaderClose(&writer->ctx->dataReader));
   return 0;
 }
 
@@ -782,8 +782,8 @@ _exit:
 }
 
 static int32_t tsdbSnapWriteFileSetCloseIter(STsdbSnapWriter* writer) {
-  tsdbIterMergerClose(&writer->ctx->dataIterMerger);
-  tsdbIterMergerClose(&writer->ctx->tombIterMerger);
+  TAOS_UNUSED(tsdbIterMergerClose(&writer->ctx->dataIterMerger));
+  TAOS_UNUSED(tsdbIterMergerClose(&writer->ctx->tombIterMerger));
   TARRAY2_CLEAR(writer->ctx->dataIterArr, tsdbIterClose);
   TARRAY2_CLEAR(writer->ctx->tombIterArr, tsdbIterClose);
   return 0;
@@ -838,7 +838,7 @@ static int32_t tsdbSnapWriteFileSetBegin(STsdbSnapWriter* writer, int32_t fid) {
     code = TSDB_CODE_NO_AVAIL_DISK;
     TSDB_CHECK_CODE(code, lino, _exit);
   }
-  tfsMkdirRecurAt(writer->tsdb->pVnode->pTfs, writer->tsdb->path, writer->ctx->did);
+  TAOS_UNUSED(tfsMkdirRecurAt(writer->tsdb->pVnode->pTfs, writer->tsdb->path, writer->ctx->did));
 
   writer->ctx->hasData = true;
   writer->ctx->hasTomb = true;
@@ -993,7 +993,7 @@ static int32_t tsdbSnapWriteDecmprTombBlock(SSnapDataHdr* hdr, STombBlock* tombB
   int32_t code = 0;
   int32_t lino = 0;
 
-  tTombBlockClear(tombBlock);
+  TAOS_UNUSED(tTombBlockClear(tombBlock));
 
   int64_t size = hdr->size;
   ASSERT(size % TOMB_RECORD_ELEM_NUM == 0);
@@ -1140,15 +1140,15 @@ int32_t tsdbSnapWriterClose(STsdbSnapWriter** writer, int8_t rollback) {
     (void)taosThreadMutexUnlock(&writer[0]->tsdb->mutex);
   }
 
-  tsdbIterMergerClose(&writer[0]->ctx->tombIterMerger);
-  tsdbIterMergerClose(&writer[0]->ctx->dataIterMerger);
+  TAOS_UNUSED(tsdbIterMergerClose(&writer[0]->ctx->tombIterMerger));
+  TAOS_UNUSED(tsdbIterMergerClose(&writer[0]->ctx->dataIterMerger));
   TARRAY2_DESTROY(writer[0]->ctx->tombIterArr, tsdbIterClose);
   TARRAY2_DESTROY(writer[0]->ctx->dataIterArr, tsdbIterClose);
   TARRAY2_DESTROY(writer[0]->ctx->sttReaderArr, tsdbSttFileReaderClose);
-  tsdbDataFileReaderClose(&writer[0]->ctx->dataReader);
+  TAOS_UNUSED(tsdbDataFileReaderClose(&writer[0]->ctx->dataReader));
 
   TARRAY2_DESTROY(writer[0]->fopArr, NULL);
-  tsdbFSDestroyCopyRangedSnapshot(&writer[0]->fsetArr);
+  TAOS_UNUSED(tsdbFSDestroyCopyRangedSnapshot(&writer[0]->fsetArr));
 
   for (int32_t i = 0; i < ARRAY_SIZE(writer[0]->buffers); ++i) {
     tBufferDestroy(writer[0]->buffers + i);
diff --git a/source/dnode/vnode/src/tsdb/tsdbUpgrade.c b/source/dnode/vnode/src/tsdb/tsdbUpgrade.c
index 6d2006eaa1..8b55b2bab2 100644
--- a/source/dnode/vnode/src/tsdb/tsdbUpgrade.c
+++ b/source/dnode/vnode/src/tsdb/tsdbUpgrade.c
@@ -79,7 +79,7 @@ static int32_t tsdbUpgradeHead(STsdb *tsdb, SDFileSet *pDFileSet, SDataFReader *
 
     // open fd
     char fname[TSDB_FILENAME_LEN];
-    tsdbTFileName(tsdb, &file, fname);
+    (void)tsdbTFileName(tsdb, &file, fname);
 
     TAOS_CHECK_GOTO(tsdbOpenFile(fname, tsdb, TD_FILE_READ | TD_FILE_WRITE, &ctx->fd, 0), &lino, _exit);
 
@@ -321,7 +321,7 @@ static int32_t tsdbUpgradeStt(STsdb *tsdb, SDFileSet *pDFileSet, SDataFReader *r
   if (TARRAY2_SIZE(lvl->fobjArr) > 0) {
     TAOS_CHECK_GOTO(TARRAY2_APPEND(fset->lvlArr, lvl), &lino, _exit);
   } else {
-    tsdbSttLvlClear(&lvl);
+    (void)tsdbSttLvlClear(&lvl);
   }
 
 _exit: