diff --git a/include/os/os.h b/include/os/os.h
index 08b68f36d4..9e5e9221e4 100644
--- a/include/os/os.h
+++ b/include/os/os.h
@@ -126,6 +126,7 @@ extern "C" {
 
 extern int32_t          tsRandErrChance;
 extern int64_t          tsRandErrDivisor;
+extern int64_t          tsRandErrScope;
 extern threadlocal bool tsEnableRandErr;
 
 #ifdef __cplusplus
diff --git a/include/util/tdef.h b/include/util/tdef.h
index 890f1d8f95..35c4adab50 100644
--- a/include/util/tdef.h
+++ b/include/util/tdef.h
@@ -568,6 +568,13 @@ enum {
   SND_WORKER_TYPE__UNIQUE,
 };
 
+enum {
+  RAND_ERR_MEMORY = 1,
+  RAND_ERR_FILE = 2,
+  // RAND_ERR_SCOPE_XXX... = 4,
+  // ...
+};
+
 #define DEFAULT_HANDLE 0
 #define MNODE_HANDLE   1
 #define QNODE_HANDLE   -1
diff --git a/source/common/src/tglobal.c b/source/common/src/tglobal.c
index 6c59ffa279..40ace11d4f 100644
--- a/source/common/src/tglobal.c
+++ b/source/common/src/tglobal.c
@@ -596,6 +596,9 @@ static int32_t taosAddClientCfg(SConfig *pCfg) {
                                 CFG_SCOPE_CLIENT, CFG_DYN_NONE));
   TAOS_CHECK_RETURN(
       cfgAddInt32(pCfg, "metaCacheMaxSize", tsMetaCacheMaxSize, -1, INT32_MAX, CFG_SCOPE_CLIENT, CFG_DYN_CLIENT));
+  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "randErrorChance", tsRandErrChance, 0, 10000, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
+  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "randErrorDivisor", tsRandErrDivisor, 1, INT64_MAX, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
+  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "randErrorScope", tsRandErrScope, 0, INT64_MAX, CFG_SCOPE_BOTH, CFG_DYN_BOTH));
 
   tsNumOfRpcThreads = tsNumOfCores / 2;
   tsNumOfRpcThreads = TRANGE(tsNumOfRpcThreads, 2, TSDB_MAX_RPC_THREADS);
@@ -778,8 +781,6 @@ static int32_t taosAddServerCfg(SConfig *pCfg) {
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "transPullupInterval", tsTransPullupInterval, 1, 10000, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "compactPullupInterval", tsCompactPullupInterval, 1, 10000, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "mqRebalanceInterval", tsMqRebalanceInterval, 1, 10000, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER));
-  TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "randErrorChance", tsRandErrChance, 0, 10000, CFG_SCOPE_BOTH, CFG_DYN_NONE));
-  TAOS_CHECK_RETURN(cfgAddInt64(pCfg, "randErrorDivisor", tsRandErrDivisor, 1, INT64_MAX, CFG_SCOPE_BOTH, CFG_DYN_SERVER));
 
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "ttlUnit", tsTtlUnit, 1, 86400 * 365, CFG_SCOPE_SERVER, CFG_DYN_NONE));
   TAOS_CHECK_RETURN(cfgAddInt32(pCfg, "ttlPushInterval", tsTtlPushIntervalSec, 1, 100000, CFG_SCOPE_SERVER, CFG_DYN_ENT_SERVER));
@@ -1214,6 +1215,15 @@ static int32_t taosSetClientCfg(SConfig *pCfg) {
   TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "metaCacheMaxSize");
   tsMetaCacheMaxSize = pItem->i32;
 
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "randErrorChance");
+  tsRandErrChance = pItem->i32;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "randErrorDivisor");
+  tsRandErrDivisor = pItem->i64;
+
+  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "randErrorScope");
+  tsRandErrScope = pItem->i64;
+
   TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "countAlwaysReturnValue");
   tsCountAlwaysReturnValue = pItem->i32;
 
@@ -1470,12 +1480,6 @@ static int32_t taosSetServerCfg(SConfig *pCfg) {
   TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "mqRebalanceInterval");
   tsMqRebalanceInterval = pItem->i32;
 
-  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "randErrorChance");
-  tsRandErrChance = pItem->i32;
-
-  TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "randErrorDivisor");
-  tsRandErrDivisor = pItem->i64;
-
   TAOS_CHECK_GET_CFG_ITEM(pCfg, pItem, "ttlUnit");
   tsTtlUnit = pItem->i32;
 
@@ -1930,7 +1934,9 @@ static int32_t taosCfgDynamicOptionsForServer(SConfig *pCfg, const char *name) {
 
                                          {"mndSdbWriteDelta", &tsMndSdbWriteDelta},
                                          {"minDiskFreeSize", &tsMinDiskFreeSize},
+                                         {"randErrorChance", &tsRandErrChance},
                                          {"randErrorDivisor", &tsRandErrDivisor},
+                                         {"randErrorScope", &tsRandErrScope},
 
                                          {"cacheLazyLoadThreshold", &tsCacheLazyLoadThreshold},
                                          {"checkpointInterval", &tsStreamCheckpointInterval},
@@ -2209,6 +2215,9 @@ static int32_t taosCfgDynamicOptionsForClient(SConfig *pCfg, const char *name) {
                                          {"queryPlannerTrace", &tsQueryPlannerTrace},
                                          {"queryNodeChunkSize", &tsQueryNodeChunkSize},
                                          {"queryUseNodeAllocator", &tsQueryUseNodeAllocator},
+                                         {"randErrorChance", &tsRandErrChance},
+                                         {"randErrorDivisor", &tsRandErrDivisor},
+                                         {"randErrorScope", &tsRandErrScope},
                                          {"smlDot2Underline", &tsSmlDot2Underline},
                                          {"shellActivityTimer", &tsShellActivityTimer},
                                          {"useAdapter", &tsUseAdapter},
diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c
index fe5c12419c..d0eed37f99 100644
--- a/source/dnode/mnode/impl/src/mndDb.c
+++ b/source/dnode/mnode/impl/src/mndDb.c
@@ -1211,22 +1211,22 @@ static int32_t mndAlterDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pOld, SDbObj *p
   if (pTrans == NULL) {
     code = TSDB_CODE_MND_RETURN_VALUE_NULL;
     if (terrno != 0) code = terrno;
-    return -1;
+    TAOS_RETURN(code);
   }
   mInfo("trans:%d, used to alter db:%s", pTrans->id, pOld->name);
 
   mndTransSetDbName(pTrans, pOld->name, NULL);
-  TAOS_CHECK_RETURN(mndTransCheckConflict(pMnode, pTrans));
+  TAOS_CHECK_GOTO(mndTransCheckConflict(pMnode, pTrans), NULL, _OVER);
 
-  TAOS_CHECK_RETURN(mndSetAlterDbPrepareLogs(pMnode, pTrans, pOld, pNew));
-  TAOS_CHECK_RETURN(mndSetAlterDbCommitLogs(pMnode, pTrans, pOld, pNew));
-  TAOS_CHECK_RETURN(mndSetAlterDbRedoActions(pMnode, pTrans, pOld, pNew));
-  TAOS_CHECK_RETURN(mndTransPrepare(pMnode, pTrans));
+  TAOS_CHECK_GOTO(mndSetAlterDbPrepareLogs(pMnode, pTrans, pOld, pNew), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndSetAlterDbCommitLogs(pMnode, pTrans, pOld, pNew), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndSetAlterDbRedoActions(pMnode, pTrans, pOld, pNew), NULL, _OVER);
+  TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
   code = 0;
 
 _OVER:
   mndTransDrop(pTrans);
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndProcessAlterDbReq(SRpcMsg *pReq) {
diff --git a/source/dnode/vnode/src/tsdb/tsdbCache.c b/source/dnode/vnode/src/tsdb/tsdbCache.c
index cf1728f1fe..aa92597211 100644
--- a/source/dnode/vnode/src/tsdb/tsdbCache.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCache.c
@@ -1406,7 +1406,7 @@ static int32_t mergeLastRowCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray,
 
 static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArray, SArray *remainCols,
                                     SCacheRowsReader *pr, int8_t ltype) {
-  int32_t               code = 0;
+  int32_t               code = 0, lino = 0;
   rocksdb_writebatch_t *wb = NULL;
   SArray               *pTmpColArray = NULL;
 
@@ -1440,11 +1440,7 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr
   int lastrowIndex = 0;
 
   if (!slotIds || !lastColIds || !lastSlotIds || !lastrowColIds || !lastrowSlotIds) {
-    taosMemoryFree(slotIds);
-    taosMemoryFree(lastColIds);
-    taosMemoryFree(lastSlotIds);
-    taosMemoryFree(lastrowColIds);
-    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   for (int i = 0; i < num_keys; ++i) {
@@ -1454,9 +1450,7 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr
       if (NULL == lastTmpIndexArray) {
         lastTmpIndexArray = taosArrayInit(num_keys, sizeof(int32_t));
         if (!lastTmpIndexArray) {
-          taosArrayDestroy(lastrowTmpIndexArray);
-
-          TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+          TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY);
         }
       }
       (void)taosArrayPush(lastTmpIndexArray, &(i));
@@ -1467,9 +1461,7 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr
       if (NULL == lastrowTmpIndexArray) {
         lastrowTmpIndexArray = taosArrayInit(num_keys, sizeof(int32_t));
         if (!lastrowTmpIndexArray) {
-          taosArrayDestroy(lastTmpIndexArray);
-
-          TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+          TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY);
         }
       }
       (void)taosArrayPush(lastrowTmpIndexArray, &(i));
@@ -1481,13 +1473,11 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr
 
   pTmpColArray = taosArrayInit(lastIndex + lastrowIndex, sizeof(SLastCol));
   if (!pTmpColArray) {
-    taosArrayDestroy(lastrowTmpIndexArray);
-    taosArrayDestroy(lastTmpIndexArray);
-    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY);
   }
 
   if (lastTmpIndexArray != NULL) {
-    (void)mergeLastCid(uid, pTsdb, &lastTmpColArray, pr, lastColIds, lastIndex, lastSlotIds);
+    TAOS_CHECK_EXIT(mergeLastCid(uid, pTsdb, &lastTmpColArray, pr, lastColIds, lastIndex, lastSlotIds));
     for (int i = 0; i < taosArrayGetSize(lastTmpColArray); i++) {
       (void)taosArrayInsert(pTmpColArray, *(int32_t *)taosArrayGet(lastTmpIndexArray, i),
                             taosArrayGet(lastTmpColArray, i));
@@ -1495,7 +1485,7 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr
   }
 
   if (lastrowTmpIndexArray != NULL) {
-    (void)mergeLastRowCid(uid, pTsdb, &lastrowTmpColArray, pr, lastrowColIds, lastrowIndex, lastrowSlotIds);
+    TAOS_CHECK_EXIT(mergeLastRowCid(uid, pTsdb, &lastrowTmpColArray, pr, lastrowColIds, lastrowIndex, lastrowSlotIds));
     for (int i = 0; i < taosArrayGetSize(lastrowTmpColArray); i++) {
       (void)taosArrayInsert(pTmpColArray, *(int32_t *)taosArrayGet(lastrowTmpIndexArray, i),
                             taosArrayGet(lastrowTmpColArray, i));
@@ -1517,7 +1507,7 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr
                         .cacheStatus = TSDB_LAST_CACHE_VALID};
     if (!pLastCol) {
       pLastCol = &noneCol;
-      TAOS_CHECK_RETURN(reallocVarData(&pLastCol->colVal));
+      TAOS_CHECK_EXIT(reallocVarData(&pLastCol->colVal));
     }
 
     taosArraySet(pLastArray, idxKey->idx, pLastCol);
@@ -1532,12 +1522,7 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr
 
     SLastCol *pTmpLastCol = taosMemoryCalloc(1, sizeof(SLastCol));
     if (!pTmpLastCol) {
-      taosMemoryFree(slotIds);
-      taosMemoryFree(lastColIds);
-      taosMemoryFree(lastSlotIds);
-      taosMemoryFree(lastrowColIds);
-      taosMemoryFree(lastrowSlotIds);
-      TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+      TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY);
     }
     *pTmpLastCol = *pLastCol;
     pLastCol = pTmpLastCol;
@@ -1546,12 +1531,12 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr
     for (int8_t i = 0; i < pLastCol->rowKey.numOfPKs; i++) {
       SValue *pValue = &pLastCol->rowKey.pks[i];
       if (IS_VAR_DATA_TYPE(pValue->type)) {
-        TAOS_CHECK_RETURN(reallocVarDataVal(pValue));
+        TAOS_CHECK_EXIT(reallocVarDataVal(pValue));
         charge += pValue->nData;
       }
     }
     if (IS_VAR_DATA_TYPE(pLastCol->colVal.value.type)) {
-      TAOS_CHECK_RETURN(reallocVarData(&pLastCol->colVal));
+      TAOS_CHECK_EXIT(reallocVarData(&pLastCol->colVal));
       charge += pLastCol->colVal.value.nData;
     }
 
@@ -1580,6 +1565,7 @@ static int32_t tsdbCacheLoadFromRaw(STsdb *pTsdb, tb_uid_t uid, SArray *pLastArr
     rocksMayWrite(pTsdb, false, true);
   }
 
+_exit:
   taosArrayDestroy(lastrowTmpIndexArray);
   taosArrayDestroy(lastrowTmpColArray);
   taosArrayDestroy(lastTmpIndexArray);
@@ -2951,11 +2937,13 @@ static int32_t nextRowIterGet(CacheNextRowIter *pIter, TSDBROW **ppRow, bool *pI
 
       if (!pIter->pSkyline) {
         pIter->pSkyline = taosArrayInit(32, sizeof(TSDBKEY));
+        TSDB_CHECK_NULL(pIter->pSkyline, code, lino, _err, TSDB_CODE_OUT_OF_MEMORY);
 
         uint64_t        uid = pIter->idx.uid;
         STableLoadInfo *pInfo = getTableLoadInfo(pIter->pr, uid);
         if (pInfo->pTombData == NULL) {
           pInfo->pTombData = taosArrayInit(4, sizeof(SDelData));
+          TSDB_CHECK_NULL(pInfo->pTombData, code, lino, _err, TSDB_CODE_OUT_OF_MEMORY);
         }
 
         (void)taosArrayAddAll(pInfo->pTombData, pIter->pMemDelData);
@@ -2963,6 +2951,7 @@ static int32_t nextRowIterGet(CacheNextRowIter *pIter, TSDBROW **ppRow, bool *pI
         size_t delSize = TARRAY_SIZE(pInfo->pTombData);
         if (delSize > 0) {
           code = tsdbBuildDeleteSkyline(pInfo->pTombData, 0, (int32_t)(delSize - 1), pIter->pSkyline);
+          TAOS_CHECK_GOTO(code, &lino, _err);
         }
         pIter->iSkyline = taosArrayGetSize(pIter->pSkyline) - 1;
       }
@@ -3065,11 +3054,13 @@ static int32_t mergeLastCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray, SC
 
   // inverse iterator
   CacheNextRowIter iter = {0};
-  (void)nextRowIterOpen(&iter, uid, pTsdb, pTSchema, pr->info.suid, pr->pLDataIterArray, pr->pReadSnap, pr->lastTs, pr);
+  code =
+      nextRowIterOpen(&iter, uid, pTsdb, pTSchema, pr->info.suid, pr->pLDataIterArray, pr->pReadSnap, pr->lastTs, pr);
+  TAOS_CHECK_GOTO(code, &lino, _err);
 
   do {
     TSDBROW *pRow = NULL;
-    (void)nextRowIterGet(&iter, &pRow, &ignoreEarlierTs, true, TARRAY_DATA(aColArray), TARRAY_SIZE(aColArray));
+    code = nextRowIterGet(&iter, &pRow, &ignoreEarlierTs, true, TARRAY_DATA(aColArray), TARRAY_SIZE(aColArray));
 
     if (!pRow) {
       break;
@@ -3250,11 +3241,13 @@ static int32_t mergeLastRowCid(tb_uid_t uid, STsdb *pTsdb, SArray **ppLastArray,
 
   // inverse iterator
   CacheNextRowIter iter = {0};
-  (void)nextRowIterOpen(&iter, uid, pTsdb, pTSchema, pr->info.suid, pr->pLDataIterArray, pr->pReadSnap, pr->lastTs, pr);
+  code =
+      nextRowIterOpen(&iter, uid, pTsdb, pTSchema, pr->info.suid, pr->pLDataIterArray, pr->pReadSnap, pr->lastTs, pr);
+  TAOS_CHECK_GOTO(code, &lino, _err);
 
   do {
     TSDBROW *pRow = NULL;
-    (void)nextRowIterGet(&iter, &pRow, &ignoreEarlierTs, false, TARRAY_DATA(aColArray), TARRAY_SIZE(aColArray));
+    code = nextRowIterGet(&iter, &pRow, &ignoreEarlierTs, false, TARRAY_DATA(aColArray), TARRAY_SIZE(aColArray));
 
     if (!pRow) {
       break;
diff --git a/source/dnode/vnode/src/tsdb/tsdbDataFileRW.c b/source/dnode/vnode/src/tsdb/tsdbDataFileRW.c
index 2665cc1aaf..7e7ea59a5b 100644
--- a/source/dnode/vnode/src/tsdb/tsdbDataFileRW.c
+++ b/source/dnode/vnode/src/tsdb/tsdbDataFileRW.c
@@ -463,7 +463,7 @@ int32_t tsdbDataFileReadBlockDataByColumn(SDataFileReader *reader, const SBrinRe
 
     if (cid < blockCol.cid) {
       const STColumn *tcol = tTSchemaSearchColumn(pTSchema, cid);
-      ASSERT(tcol);
+      TSDB_CHECK_NULL(tcol, code, lino, _exit, TSDB_CODE_TDB_INVALID_TABLE_SCHEMA_VER);
       SBlockCol none = {
           .cid = cid,
           .type = tcol->type,
diff --git a/source/dnode/vnode/src/tsdb/tsdbMergeTree.c b/source/dnode/vnode/src/tsdb/tsdbMergeTree.c
index e55ede560e..9d99c51587 100644
--- a/source/dnode/vnode/src/tsdb/tsdbMergeTree.c
+++ b/source/dnode/vnode/src/tsdb/tsdbMergeTree.c
@@ -1004,6 +1004,7 @@ int32_t tMergeTreeOpen2(SMergeTree *pMTree, SMergeTreeConf *pConf, SSttDataInfoF
           pSttDataInfo->numOfRows += numOfRows;
         }
       } else {
+        TAOS_CHECK_GOTO(terrno, NULL, _end);
         if (!pMTree->ignoreEarlierTs) {
           pMTree->ignoreEarlierTs = pIter->ignoreEarlierTs;
         }
diff --git a/source/dnode/vnode/src/tsdb/tsdbRead2.c b/source/dnode/vnode/src/tsdb/tsdbRead2.c
index 7d633e2520..0572df2922 100644
--- a/source/dnode/vnode/src/tsdb/tsdbRead2.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRead2.c
@@ -2440,20 +2440,23 @@ static bool initSttBlockReader(SSttBlockReader* pSttBlockReader, STableBlockScan
 
   int32_t code = tMergeTreeOpen2(&pSttBlockReader->mergeTree, &conf, &info);
   if (code != TSDB_CODE_SUCCESS) {
+    taosArrayDestroy(info.pKeyRangeList);
     pReader->code = code;
     return false;
   }
 
   code = initMemDataIterator(pScanInfo, pReader);
   if (code != TSDB_CODE_SUCCESS) {
+    taosArrayDestroy(info.pKeyRangeList);
     pReader->code = code;
     return false;
   }
 
   code = initDelSkylineIterator(pScanInfo, pReader->info.order, &pReader->cost);
   if (code != TSDB_CODE_SUCCESS) {
+    taosArrayDestroy(info.pKeyRangeList);
     pReader->code = code;
-    return code;
+    return false;
   }
 
   if (conf.rspRows) {
diff --git a/source/dnode/vnode/src/tsdb/tsdbSttFileRW.c b/source/dnode/vnode/src/tsdb/tsdbSttFileRW.c
index 6e24311017..e3d7f9d45f 100644
--- a/source/dnode/vnode/src/tsdb/tsdbSttFileRW.c
+++ b/source/dnode/vnode/src/tsdb/tsdbSttFileRW.c
@@ -309,7 +309,7 @@ int32_t tsdbSttFileReadBlockDataByColumn(SSttFileReader *reader, const SSttBlk *
 
     if (cid < blockCol.cid) {
       const STColumn *tcol = tTSchemaSearchColumn(pTSchema, cid);
-      ASSERT(tcol);
+      TSDB_CHECK_NULL(tcol, code, lino, _exit, TSDB_CODE_TDB_INVALID_TABLE_SCHEMA_VER);
       SBlockCol none = {
           .cid = cid,
           .type = tcol->type,
diff --git a/source/os/src/osFile.c b/source/os/src/osFile.c
index b8160a14b7..a5df4f63f3 100644
--- a/source/os/src/osFile.c
+++ b/source/os/src/osFile.c
@@ -15,6 +15,7 @@
 #define ALLOW_FORBID_FUNC
 #include "os.h"
 #include "osSemaphore.h"
+#include "tdef.h"
 #include "zlib.h"
 
 #ifdef WINDOWS
@@ -65,14 +66,14 @@ typedef struct TdFile {
 #define FILE_WITH_LOCK 1
 
 #ifdef BUILD_WITH_RAND_ERR
-#define STUB_RAND_IO_ERR(ret)                   \
-  if (tsEnableRandErr) {                        \
-    uint32_t r = taosRand() % tsRandErrDivisor; \
-    if ((r + 1) <= tsRandErrChance) {           \
-      errno = EIO;                              \
-      terrno = TAOS_SYSTEM_ERROR(errno);        \
-      return (ret);                             \
-    }                                           \
+#define STUB_RAND_IO_ERR(ret)                                \
+  if (tsEnableRandErr && (tsRandErrScope & RAND_ERR_FILE)) { \
+    uint32_t r = taosRand() % tsRandErrDivisor;              \
+    if ((r + 1) <= tsRandErrChance) {                        \
+      errno = EIO;                                           \
+      terrno = TAOS_SYSTEM_ERROR(errno);                     \
+      return (ret);                                          \
+    }                                                        \
   }
 #else
 #define STUB_RAND_IO_ERR(ret)
diff --git a/source/os/src/osMemory.c b/source/os/src/osMemory.c
index 297b17b957..7a5a547354 100644
--- a/source/os/src/osMemory.c
+++ b/source/os/src/osMemory.c
@@ -20,9 +20,11 @@
 #include <malloc.h>
 #endif
 #include "os.h"
+#include "tdef.h"
 
 int32_t          tsRandErrChance = 1;
 int64_t          tsRandErrDivisor = 10001;
+int64_t          tsRandErrScope = (RAND_ERR_MEMORY | RAND_ERR_FILE);
 threadlocal bool tsEnableRandErr = 0;
 
 #if defined(USE_TD_MEMORY) || defined(USE_ADDR2LINE)
@@ -272,7 +274,7 @@ void *taosMemoryMalloc(int64_t size) {
 #else
 
 #ifdef BUILD_WITH_RAND_ERR
-  if (tsEnableRandErr) {
+  if (tsEnableRandErr && (tsRandErrScope & RAND_ERR_MEMORY)) {
     uint32_t r = taosRand() % tsRandErrDivisor;
     if ((r + 1) <= tsRandErrChance) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -302,7 +304,7 @@ void *taosMemoryCalloc(int64_t num, int64_t size) {
   return (char *)tmp + sizeof(TdMemoryInfo);
 #else
 #ifdef BUILD_WITH_RAND_ERR
-  if (tsEnableRandErr) {
+  if (tsEnableRandErr && (tsRandErrScope & RAND_ERR_MEMORY)) {
     uint32_t r = taosRand() % tsRandErrDivisor;
     if ((r + 1) <= tsRandErrChance) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -342,7 +344,7 @@ void *taosMemoryRealloc(void *ptr, int64_t size) {
   return (char *)tmp + sizeof(TdMemoryInfo);
 #else
 #ifdef BUILD_WITH_RAND_ERR
-  if (tsEnableRandErr) {
+  if (tsEnableRandErr && (tsRandErrScope & RAND_ERR_MEMORY)) {
     uint32_t r = taosRand() % tsRandErrDivisor;
     if ((r + 1) <= tsRandErrChance) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -377,7 +379,7 @@ char *taosStrdup(const char *ptr) {
   return (char *)tmp + sizeof(TdMemoryInfo);
 #else
 #ifdef BUILD_WITH_RAND_ERR
-  if (tsEnableRandErr) {
+  if (tsEnableRandErr && (tsRandErrScope & RAND_ERR_MEMORY)) {
     uint32_t r = taosRand() % tsRandErrDivisor;
     if ((r + 1) <= tsRandErrChance) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
@@ -443,7 +445,7 @@ void *taosMemoryMallocAlign(uint32_t alignment, int64_t size) {
 #else
 #if defined(LINUX)
 #ifdef BUILD_WITH_RAND_ERR
-  if (tsEnableRandErr) {
+  if (tsEnableRandErr && (tsRandErrScope & RAND_ERR_MEMORY)) {
     uint32_t r = taosRand() % tsRandErrDivisor;
     if ((r + 1) <= tsRandErrChance) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;