diff --git a/source/dnode/vnode/src/meta/metaTable.c b/source/dnode/vnode/src/meta/metaTable.c
index 21602627e9..cbd4f298d2 100644
--- a/source/dnode/vnode/src/meta/metaTable.c
+++ b/source/dnode/vnode/src/meta/metaTable.c
@@ -129,7 +129,11 @@ static int metaSaveJsonVarToIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const
   }
 
   SIndexMultiTerm *terms = indexMultiTermCreate();
-  int16_t          nCols = taosArrayGetSize(pTagVals);
+  if (terms == NULL) {
+    return terrno;
+  }
+
+  int16_t nCols = taosArrayGetSize(pTagVals);
   for (int i = 0; i < nCols; i++) {
     STagVal *pTagVal = (STagVal *)taosArrayGet(pTagVals, i);
     char     type = pTagVal->type;
@@ -142,8 +146,14 @@ static int metaSaveJsonVarToIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const
       term = indexTermCreate(suid, ADD_VALUE, TSDB_DATA_TYPE_VARCHAR, key, nKey, NULL, 0);
     } else if (type == TSDB_DATA_TYPE_NCHAR) {
       if (pTagVal->nData > 0) {
-        char   *val = taosMemoryCalloc(1, pTagVal->nData + VARSTR_HEADER_SIZE);
+        char *val = taosMemoryCalloc(1, pTagVal->nData + VARSTR_HEADER_SIZE);
+        if (val == NULL) {
+          TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _except);
+        }
         int32_t len = taosUcs4ToMbs((TdUcs4 *)pTagVal->pData, pTagVal->nData, val + VARSTR_HEADER_SIZE);
+        if (len < 0) {
+          TAOS_CHECK_GOTO(len, NULL, _except);
+        }
         memcpy(val, (uint16_t *)&len, VARSTR_HEADER_SIZE);
         type = TSDB_DATA_TYPE_VARCHAR;
         term = indexTermCreate(suid, ADD_VALUE, type, key, nKey, val, len);
@@ -160,8 +170,11 @@ static int metaSaveJsonVarToIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const
       int len = sizeof(val);
       term = indexTermCreate(suid, ADD_VALUE, TSDB_DATA_TYPE_BOOL, key, nKey, (const char *)&val, len);
     }
+
     if (term != NULL) {
       (void)indexMultiTermAdd(terms, term);
+    } else {
+      code = terrno;
     }
   }
   (void)indexJsonPut(pMeta->pTagIvtIdx, terms, tuid);
@@ -170,6 +183,10 @@ static int metaSaveJsonVarToIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const
   taosArrayDestroy(pTagVals);
 #endif
   return 0;
+_except:
+  indexMultiTermDestroy(terms);
+  taosArrayDestroy(pTagVals);
+  return code;
 }
 int metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSchema *pSchema) {
 #ifdef USE_INVERTED_INDEX
@@ -191,7 +208,11 @@ int metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSche
   }
 
   SIndexMultiTerm *terms = indexMultiTermCreate();
-  int16_t          nCols = taosArrayGetSize(pTagVals);
+  if (terms == NULL) {
+    return TSDB_CODE_OUT_OF_MEMORY;
+  }
+
+  int16_t nCols = taosArrayGetSize(pTagVals);
   for (int i = 0; i < nCols; i++) {
     STagVal *pTagVal = (STagVal *)taosArrayGet(pTagVals, i);
     char     type = pTagVal->type;
@@ -204,8 +225,14 @@ int metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSche
       term = indexTermCreate(suid, DEL_VALUE, TSDB_DATA_TYPE_VARCHAR, key, nKey, NULL, 0);
     } else if (type == TSDB_DATA_TYPE_NCHAR) {
       if (pTagVal->nData > 0) {
-        char   *val = taosMemoryCalloc(1, pTagVal->nData + VARSTR_HEADER_SIZE);
+        char *val = taosMemoryCalloc(1, pTagVal->nData + VARSTR_HEADER_SIZE);
+        if (val == NULL) {
+          TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _except);
+        }
         int32_t len = taosUcs4ToMbs((TdUcs4 *)pTagVal->pData, pTagVal->nData, val + VARSTR_HEADER_SIZE);
+        if (len < 0) {
+          TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _except);
+        }
         memcpy(val, (uint16_t *)&len, VARSTR_HEADER_SIZE);
         type = TSDB_DATA_TYPE_VARCHAR;
         term = indexTermCreate(suid, DEL_VALUE, type, key, nKey, val, len);
@@ -224,6 +251,8 @@ int metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSche
     }
     if (term != NULL) {
       (void)indexMultiTermAdd(terms, term);
+    } else {
+      code = terrno;
     }
   }
   (void)indexJsonPut(pMeta->pTagIvtIdx, terms, tuid);
@@ -231,6 +260,10 @@ int metaDelJsonVarFromIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry, const SSche
   taosArrayDestroy(pTagVals);
 #endif
   return 0;
+_except:
+  indexMultiTermDestroy(terms);
+  taosArrayDestroy(pTagVals);
+  return code;
 }
 
 static inline void metaTimeSeriesNotifyCheck(SMeta *pMeta) {
@@ -867,7 +900,6 @@ int metaDropIndexFromSTable(SMeta *pMeta, int64_t version, SDropIndexReq *pReq)
     goto _err;
   }
 
-
   nStbEntry.stbEntry.schemaRow = *row;
   nStbEntry.stbEntry.schemaTag = *tag;
   nStbEntry.stbEntry.rsmaParam = oStbEntry.stbEntry.rsmaParam;
@@ -1580,7 +1612,12 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl
                                                                              : pAlterTbReq->compress;
       (void)updataTableColCmpr(&entry.colCmpr, pCol, 1, compress);
       freeColCmpr = true;
-      ASSERT(entry.colCmpr.nCols == pSchema->nCols);
+      if (entry.colCmpr.nCols != pSchema->nCols) {
+        if (pNewSchema) taosMemoryFree(pNewSchema);
+        if (freeColCmpr) taosMemoryFree(entry.colCmpr.pColCmpr);
+        terrno = TSDB_CODE_VND_INVALID_TABLE_ACTION;
+        goto _err;
+      }
       break;
     case TSDB_ALTER_TABLE_DROP_COLUMN:
       if (pColumn == NULL) {
@@ -1617,7 +1654,10 @@ static int metaAlterTableColumn(SMeta *pMeta, int64_t version, SVAlterTbReq *pAl
       }
 
       (void)updataTableColCmpr(&entry.colCmpr, &tScheam, 0, 0);
-      ASSERT(entry.colCmpr.nCols == pSchema->nCols);
+      if (entry.colCmpr.nCols != pSchema->nCols) {
+        terrno = TSDB_CODE_VND_INVALID_TABLE_ACTION;
+        goto _err;
+      }
       break;
     case TSDB_ALTER_TABLE_UPDATE_COLUMN_BYTES:
       if (pColumn == NULL) {
@@ -1698,7 +1738,7 @@ _err:
   (void)tdbTbcClose(pUidIdxc);
   tDecoderClear(&dc);
 
-  return TSDB_CODE_FAILED;
+  return terrno != 0 ? terrno : TSDB_CODE_FAILED;
 }
 
 static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTbReq) {
@@ -2514,8 +2554,7 @@ static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry) {
   if (tdbTbGet(pMeta->pUidIdx, &pCtbEntry->ctbEntry.suid, sizeof(tb_uid_t), &pData, &nData) != 0) {
     metaError("vgId:%d, failed to get stable suid for update. version:%" PRId64, TD_VID(pMeta->pVnode),
               pCtbEntry->version);
-    terrno = TSDB_CODE_TDB_INVALID_TABLE_ID;
-    ret = -1;
+    ret = TSDB_CODE_TDB_INVALID_TABLE_ID;
     goto end;
   }
   tbDbKey.uid = pCtbEntry->ctbEntry.suid;
@@ -2529,6 +2568,7 @@ static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry) {
   }
 
   if (stbEntry.stbEntry.schemaTag.pSchema == NULL) {
+    ret = TSDB_CODE_INVALID_PARA;
     goto end;
   }
 
@@ -2573,7 +2613,9 @@ static int metaUpdateTagIdx(SMeta *pMeta, const SMetaEntry *pCtbEntry) {
     }
   }
 end:
-  // metaDestroyTagIdxKey(pTagIdxKey);
+  if (terrno != 0) {
+    ret = terrno;
+  }
   tDecoderClear(&dc);
   tdbFree(pData);
   return ret;
diff --git a/source/libs/command/src/command.c b/source/libs/command/src/command.c
index 11ddc89d4c..26f8b00040 100644
--- a/source/libs/command/src/command.c
+++ b/source/libs/command/src/command.c
@@ -24,13 +24,13 @@
 #include "tgrant.h"
 
 #define COL_DATA_SET_VAL_AND_CHECK(pCol, rows, buf, isNull) \
-    do {                                                    \
-        int  _code = colDataSetVal(pCol, rows, buf, isNull);\
-        if (TSDB_CODE_SUCCESS != _code) {                   \
-            terrno = _code;                                 \
-            return _code;                                   \
-        }                                                   \
-    } while(0)
+  do {                                                      \
+    int _code = colDataSetVal(pCol, rows, buf, isNull);     \
+    if (TSDB_CODE_SUCCESS != _code) {                       \
+      terrno = _code;                                       \
+      return _code;                                         \
+    }                                                       \
+  } while (0)
 
 extern SConfig* tsCfg;
 
@@ -77,7 +77,7 @@ static int32_t buildDescResultDataBlock(SSDataBlock** pOutput) {
   QRY_OPTR_CHECK(pOutput);
 
   SSDataBlock* pBlock = NULL;
-  int32_t code = createDataBlock(&pBlock);
+  int32_t      code = createDataBlock(&pBlock);
   if (code) {
     return code;
   }
@@ -235,7 +235,7 @@ static int32_t buildCreateDBResultDataBlock(SSDataBlock** pOutput) {
   QRY_OPTR_CHECK(pOutput);
 
   SSDataBlock* pBlock = NULL;
-  int32_t code = createDataBlock(&pBlock);
+  int32_t      code = createDataBlock(&pBlock);
   if (code) {
     return code;
   }
@@ -280,15 +280,15 @@ int64_t getValOfDiffPrecision(int8_t unit, int64_t val) {
   return v;
 }
 
-static int32_t buildRetension(SArray* pRetension, char **ppRetentions ) {
+static int32_t buildRetension(SArray* pRetension, char** ppRetentions) {
   size_t size = taosArrayGetSize(pRetension);
   if (size == 0) {
     *ppRetentions = NULL;
     return TSDB_CODE_SUCCESS;
   }
 
-  char*   p1 = taosMemoryCalloc(1, 100);
-  if(NULL == p1) {
+  char* p1 = taosMemoryCalloc(1, 100);
+  if (NULL == p1) {
     return terrno;
   }
   int32_t len = 0;
@@ -368,7 +368,7 @@ static int32_t setCreateDBResultIntoDataBlock(SSDataBlock* pBlock, char* dbName,
       break;
   }
 
-  char*   pRetentions = NULL;
+  char* pRetentions = NULL;
   QRY_ERR_RET(buildRetension(pCfg->pRetensions, &pRetentions));
   int32_t dbFNameLen = strlen(dbFName);
   int32_t hashPrefix = 0;
@@ -427,7 +427,7 @@ static int32_t buildCreateTbResultDataBlock(SSDataBlock** pOutput) {
   QRY_OPTR_CHECK(pOutput);
 
   SSDataBlock* pBlock = NULL;
-  int32_t code = createDataBlock(&pBlock);
+  int32_t      code = createDataBlock(&pBlock);
   if (code) {
     return code;
   }
@@ -451,7 +451,7 @@ static int32_t buildCreateViewResultDataBlock(SSDataBlock** pOutput) {
   QRY_OPTR_CHECK(pOutput);
 
   SSDataBlock* pBlock = NULL;
-  int32_t code = createDataBlock(&pBlock);
+  int32_t      code = createDataBlock(&pBlock);
   if (code) {
     return code;
   }
@@ -578,36 +578,7 @@ int32_t appendTagValues(char* buf, int32_t* len, STableCfg* pCfg) {
     } else {
       *len += sprintf(buf + VARSTR_HEADER_SIZE + *len, "NULL");
     }
-
-    /*
-    if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_GEOMETRY) {
-      if (pTagVal->nData > 0) {
-        if (num) {
-          *len += sprintf(buf + VARSTR_HEADER_SIZE + *len, ", ");
-        }
-
-        memcpy(buf + VARSTR_HEADER_SIZE + *len, pTagVal->pData, pTagVal->nData);
-        *len += pTagVal->nData;
-      }
-    } else if (type == TSDB_DATA_TYPE_NCHAR) {
-      if (pTagVal->nData > 0) {
-        if (num) {
-          *len += sprintf(buf + VARSTR_HEADER_SIZE + *len, ", ");
-        }
-        int32_t tlen = taosUcs4ToMbs((TdUcs4 *)pTagVal->pData, pTagVal->nData, buf + VARSTR_HEADER_SIZE + *len);
-      }
-    } else if (type == TSDB_DATA_TYPE_DOUBLE) {
-      double val = *(double *)(&pTagVal->i64);
-      int    len = 0;
-      term = indexTermCreate(suid, ADD_VALUE, type, key, nKey, (const char *)&val, len);
-    } else if (type == TSDB_DATA_TYPE_BOOL) {
-      int val = *(int *)(&pTagVal->i64);
-      int len = 0;
-      term = indexTermCreate(suid, ADD_VALUE, TSDB_DATA_TYPE_INT, key, nKey, (const char *)&val, len);
-    }
-    */
   }
-
 _exit:
   taosArrayDestroy(pTagVals);
 
@@ -864,26 +835,26 @@ static int32_t buildLocalVariablesResultDataBlock(SSDataBlock** pOutput) {
 
   infoData.info.type = TSDB_DATA_TYPE_VARCHAR;
   infoData.info.bytes = SHOW_LOCAL_VARIABLES_RESULT_FIELD1_LEN;
-  if(taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {
+  if (taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {
     goto _exit;
   }
 
   infoData.info.type = TSDB_DATA_TYPE_VARCHAR;
   infoData.info.bytes = SHOW_LOCAL_VARIABLES_RESULT_FIELD2_LEN;
-  if(taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {
+  if (taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {
     goto _exit;
   }
 
   infoData.info.type = TSDB_DATA_TYPE_VARCHAR;
   infoData.info.bytes = SHOW_LOCAL_VARIABLES_RESULT_FIELD3_LEN;
-  if(taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {
+  if (taosArrayPush(pBlock->pDataBlock, &infoData) == NULL) {
     goto _exit;
   }
 
   *pOutput = pBlock;
 
 _exit:
-  if(terrno != TSDB_CODE_SUCCESS) {
+  if (terrno != TSDB_CODE_SUCCESS) {
     taosMemoryFree(pBlock);
     taosArrayDestroy(pBlock->pDataBlock);
   }
@@ -907,7 +878,7 @@ static int32_t createSelectResultDataBlock(SNodeList* pProjects, SSDataBlock** p
   QRY_OPTR_CHECK(pOutput);
 
   SSDataBlock* pBlock = NULL;
-  int32_t code = createDataBlock(&pBlock);
+  int32_t      code = createDataBlock(&pBlock);
   if (code) {
     return code;
   }
@@ -942,7 +913,8 @@ int32_t buildSelectResultDataBlock(SNodeList* pProjects, SSDataBlock* pBlock) {
       if (((SValueNode*)pProj)->isNull) {
         QRY_ERR_RET(colDataSetVal(taosArrayGet(pBlock->pDataBlock, index++), 0, NULL, true));
       } else {
-        QRY_ERR_RET(colDataSetVal(taosArrayGet(pBlock->pDataBlock, index++), 0, nodesGetValueFromNode((SValueNode*)pProj), false));
+        QRY_ERR_RET(colDataSetVal(taosArrayGet(pBlock->pDataBlock, index++), 0,
+                                  nodesGetValueFromNode((SValueNode*)pProj), false));
       }
     }
   }
diff --git a/source/libs/index/src/index.c b/source/libs/index/src/index.c
index b881d2cac8..993b74ba94 100644
--- a/source/libs/index/src/index.c
+++ b/source/libs/index/src/index.c
@@ -237,8 +237,7 @@ int32_t indexPut(SIndex* index, SIndexMultiTerm* fVals, uint64_t uid) {
     indexDebug("w suid:%" PRIu64 ", colName:%s, colType:%d", key.suid, key.colName, key.colType);
 
     IndexCache** cache = taosHashGet(index->colObj, buf, sz);
-    ASSERTS(*cache != NULL, "index-cache already release");
-    if (*cache == NULL) return -1;
+    if (*cache == NULL) return TSDB_CODE_INVALID_PTR;
 
     int ret = idxCachePut(*cache, p, uid);
     if (ret != 0) {
@@ -295,7 +294,9 @@ void indexMultiTermQueryDestroy(SIndexMultiTermQuery* pQuery) {
 };
 int32_t indexMultiTermQueryAdd(SIndexMultiTermQuery* pQuery, SIndexTerm* term, EIndexQueryType qType) {
   SIndexTermQuery q = {.qType = qType, .term = term};
-  (void)taosArrayPush(pQuery->query, &q);
+  if (taosArrayPush(pQuery->query, &q) == NULL) {
+    return terrno;
+  }
   return 0;
 }
 
@@ -303,6 +304,7 @@ SIndexTerm* indexTermCreate(int64_t suid, SIndexOperOnColumn oper, uint8_t colTy
                             int32_t nColName, const char* colVal, int32_t nColVal) {
   SIndexTerm* tm = (SIndexTerm*)taosMemoryCalloc(1, (sizeof(SIndexTerm)));
   if (tm == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
   }
 
@@ -311,6 +313,10 @@ SIndexTerm* indexTermCreate(int64_t suid, SIndexOperOnColumn oper, uint8_t colTy
   tm->colType = colType;
 
   tm->colName = (char*)taosMemoryCalloc(1, nColName + 1);
+  if (tm->colName == NULL) {
+    taosMemoryFree(tm);
+    return NULL;
+  }
   memcpy(tm->colName, colName, nColName);
   tm->nColName = nColName;
 
@@ -326,8 +332,23 @@ SIndexTerm* indexTermCreate(int64_t suid, SIndexOperOnColumn oper, uint8_t colTy
     buf = strndup(emptyStr, (int32_t)strlen(emptyStr));
     len = (int32_t)strlen(emptyStr);
   }
+
   tm->colVal = buf;
+  if (tm->colVal == NULL) {
+    taosMemoryFree(tm->colName);
+    taosMemoryFree(tm);
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return NULL;
+  }
+
   tm->nColVal = len;
+  if (tm->nColVal < 0) {
+    taosMemoryFree(tm->colName);
+    taosMemoryFree(tm->colVal);
+    taosMemoryFree(tm);
+    terrno = len;
+    return NULL;
+  }
 
   return tm;
 }
diff --git a/source/libs/index/src/indexComm.c b/source/libs/index/src/indexComm.c
index 6337b2c556..ec572700ae 100644
--- a/source/libs/index/src/indexComm.c
+++ b/source/libs/index/src/indexComm.c
@@ -290,90 +290,6 @@ int idxUidCompare(const void* a, const void* b) {
   uint64_t r = *(uint64_t*)b;
   return l - r;
 }
-#ifdef BUILD_NO_CALL
-int32_t idxConvertData(void* src, int8_t type, void** dst) {
-  int tlen = -1;
-  switch (type) {
-    case TSDB_DATA_TYPE_TIMESTAMP:
-      tlen = taosEncodeFixedI64(NULL, *(int64_t*)src);
-      *dst = taosMemoryCalloc(1, tlen + 1);
-      tlen = taosEncodeFixedI64(dst, *(int64_t*)src);
-      break;
-    case TSDB_DATA_TYPE_BOOL:
-    case TSDB_DATA_TYPE_UTINYINT:
-      tlen = taosEncodeFixedU8(NULL, *(uint8_t*)src);
-      *dst = taosMemoryCalloc(1, tlen + 1);
-      tlen = taosEncodeFixedU8(dst, *(uint8_t*)src);
-      break;
-    case TSDB_DATA_TYPE_TINYINT:
-      tlen = taosEncodeFixedI8(NULL, *(uint8_t*)src);
-      *dst = taosMemoryCalloc(1, tlen + 1);
-      tlen = taosEncodeFixedI8(dst, *(uint8_t*)src);
-      break;
-    case TSDB_DATA_TYPE_SMALLINT:
-      tlen = taosEncodeFixedI16(NULL, *(int16_t*)src);
-      *dst = taosMemoryCalloc(1, tlen + 1);
-      tlen = taosEncodeFixedI16(dst, *(int16_t*)src);
-      break;
-    case TSDB_DATA_TYPE_USMALLINT:
-      tlen = taosEncodeFixedU16(NULL, *(uint16_t*)src);
-      *dst = taosMemoryCalloc(1, tlen + 1);
-      tlen = taosEncodeFixedU16(dst, *(uint16_t*)src);
-      break;
-    case TSDB_DATA_TYPE_INT:
-      tlen = taosEncodeFixedI32(NULL, *(int32_t*)src);
-      *dst = taosMemoryCalloc(1, tlen + 1);
-      tlen = taosEncodeFixedI32(dst, *(int32_t*)src);
-      break;
-    case TSDB_DATA_TYPE_FLOAT:
-      tlen = taosEncodeBinary(NULL, src, sizeof(float));
-      *dst = taosMemoryCalloc(1, tlen + 1);
-      tlen = taosEncodeBinary(dst, src, sizeof(float));
-      break;
-    case TSDB_DATA_TYPE_UINT:
-      tlen = taosEncodeFixedU32(NULL, *(uint32_t*)src);
-      *dst = taosMemoryCalloc(1, tlen + 1);
-      tlen = taosEncodeFixedU32(dst, *(uint32_t*)src);
-      break;
-    case TSDB_DATA_TYPE_BIGINT:
-      tlen = taosEncodeFixedI64(NULL, *(int64_t*)src);
-      *dst = taosMemoryCalloc(1, tlen + 1);
-      tlen = taosEncodeFixedI64(dst, *(int64_t*)src);
-      break;
-    case TSDB_DATA_TYPE_DOUBLE:
-      tlen = taosEncodeBinary(NULL, src, sizeof(double));
-      *dst = taosMemoryCalloc(1, tlen + 1);
-      tlen = taosEncodeBinary(dst, src, sizeof(double));
-      break;
-    case TSDB_DATA_TYPE_UBIGINT:
-      tlen = taosEncodeFixedU64(NULL, *(uint64_t*)src);
-      *dst = taosMemoryCalloc(1, tlen + 1);
-      tlen = taosEncodeFixedU64(dst, *(uint64_t*)src);
-      break;
-    case TSDB_DATA_TYPE_NCHAR: {
-      tlen = taosEncodeBinary(NULL, varDataVal(src), varDataLen(src));
-      *dst = taosMemoryCalloc(1, tlen + 1);
-      tlen = taosEncodeBinary(dst, varDataVal(src), varDataLen(src));
-
-      break;
-    }
-    case TSDB_DATA_TYPE_VARCHAR:  // TSDB_DATA_TYPE_BINARY
-    case TSDB_DATA_TYPE_VARBINARY:
-    case TSDB_DATA_TYPE_GEOMETRY: {
-      tlen = taosEncodeBinary(NULL, src, strlen(src));
-      *dst = taosMemoryCalloc(1, tlen + 1);
-      tlen = taosEncodeBinary(dst, src, strlen(src));
-      break;
-    }
-    default:
-      ASSERTS(0, "index invalid input type");
-      break;
-  }
-  *dst = (char*)*dst - tlen;
-  // indexMayFillNumbericData(*dst, tlen);
-  return tlen;
-}
-#endif
 
 int32_t idxConvertDataToStr(void* src, int8_t type, void** dst) {
   if (src == NULL) {
@@ -495,7 +411,7 @@ int32_t idxConvertDataToStr(void* src, int8_t type, void** dst) {
       break;
     }
     default:
-      ASSERTS(0, "index invalid input type");
+      tlen = TSDB_CODE_INVALID_DATA_FMT;
       break;
   }
   return tlen;
diff --git a/source/libs/index/src/indexFilter.c b/source/libs/index/src/indexFilter.c
index c362932da3..483920ba4f 100644
--- a/source/libs/index/src/indexFilter.c
+++ b/source/libs/index/src/indexFilter.c
@@ -646,7 +646,16 @@ static int32_t sifDoIndex(SIFParam *left, SIFParam *right, int8_t operType, SIFP
     }
 
     SIndexMultiTermQuery *mtm = indexMultiTermQueryCreate(MUST);
-    (void)indexMultiTermQueryAdd(mtm, tm, qtype);
+    if (mtm == NULL) {
+      indexTermDestroy(tm);
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+
+    if ((ret = indexMultiTermQueryAdd(mtm, tm, qtype)) != 0) {
+      indexMultiTermQueryDestroy(mtm);
+      return ret;
+    }
+
     ret = indexJsonSearch(arg->ivtIdx, mtm, output->result);
     indexMultiTermQueryDestroy(mtm);
   } else {
@@ -1104,7 +1113,6 @@ int32_t doFilterTag(SNode *pFilterNode, SIndexMetaArg *metaArg, SArray *result,
     *status = st;
   }
 
-
   if (taosArrayAddAll(result, param.result) == NULL) {
     sifFreeParam(&param);
     return TSDB_CODE_OUT_OF_MEMORY;
diff --git a/source/libs/index/src/indexFst.c b/source/libs/index/src/indexFst.c
index 54d28f4784..e57ba6267d 100644
--- a/source/libs/index/src/indexFst.c
+++ b/source/libs/index/src/indexFst.c
@@ -98,7 +98,7 @@ void fstUnFinishedNodesAddSuffix(FstUnFinishedNodes* nodes, FstSlice bs, Output
   }
   int32_t                   sz = taosArrayGetSize(nodes->stack) - 1;
   FstBuilderNodeUnfinished* un = taosArrayGet(nodes->stack, sz);
-  ASSERTS(un->last == NULL, "index-fst meet unexpected node");
+
   if (un->last != NULL) return;
 
   // FstLastTransition *trn = taosMemoryMalloc(sizeof(FstLastTransition));
@@ -318,7 +318,7 @@ void fstStateCompileForAnyTrans(IdxFstFile* w, CompiledAddr addr, FstBuilderNode
 
 // set_comm_input
 void fstStateSetCommInput(FstState* s, uint8_t inp) {
-  ASSERT(s->state == OneTransNext || s->state == OneTrans);
+  // ASSERT(s->state == OneTransNext || s->state == OneTrans);
 
   uint8_t val;
   COMMON_INDEX(inp, 0b111111, val);
@@ -327,7 +327,7 @@ void fstStateSetCommInput(FstState* s, uint8_t inp) {
 
 // comm_input
 uint8_t fstStateCommInput(FstState* s, bool* null) {
-  ASSERT(s->state == OneTransNext || s->state == OneTrans);
+  // ASSERT(s->state == OneTransNext || s->state == OneTrans);
   uint8_t v = s->val & 0b00111111;
   if (v == 0) {
     *null = true;
@@ -340,7 +340,7 @@ uint8_t fstStateCommInput(FstState* s, bool* null) {
 // input_len
 
 uint64_t fstStateInputLen(FstState* s) {
-  ASSERT(s->state == OneTransNext || s->state == OneTrans);
+  // ASSERT(s->state == OneTransNext || s->state == OneTrans);
   bool null = false;
   (void)fstStateCommInput(s, &null);
   return null ? 1 : 0;
@@ -348,11 +348,11 @@ uint64_t fstStateInputLen(FstState* s) {
 
 // end_addr
 uint64_t fstStateEndAddrForOneTransNext(FstState* s, FstSlice* data) {
-  ASSERT(s->state == OneTransNext);
+  // ASSERT(s->state == OneTransNext);
   return FST_SLICE_LEN(data) - 1 - fstStateInputLen(s);
 }
 uint64_t fstStateEndAddrForOneTrans(FstState* s, FstSlice* data, PackSizes sizes) {
-  ASSERT(s->state == OneTrans);
+  // ASSERT(s->state == OneTrans);
   return FST_SLICE_LEN(data) - 1 - fstStateInputLen(s) - 1  // pack size
          - FST_GET_TRANSITION_PACK_SIZE(sizes) - FST_GET_OUTPUT_PACK_SIZE(sizes);
 }
@@ -366,7 +366,7 @@ uint64_t fstStateEndAddrForAnyTrans(FstState* state, uint64_t version, FstSlice*
 }
 // input
 uint8_t fstStateInput(FstState* s, FstNode* node) {
-  ASSERT(s->state == OneTransNext || s->state == OneTrans);
+  // ASSERT(s->state == OneTransNext || s->state == OneTrans);
   FstSlice* slice = &node->data;
   bool      null = false;
   uint8_t   inp = fstStateCommInput(s, &null);
@@ -374,7 +374,7 @@ uint8_t fstStateInput(FstState* s, FstNode* node) {
   return null == false ? inp : data[node->start - 1];
 }
 uint8_t fstStateInputForAnyTrans(FstState* s, FstNode* node, uint64_t i) {
-  ASSERT(s->state == AnyTrans);
+  // ASSERT(s->state == AnyTrans);
   FstSlice* slice = &node->data;
 
   uint64_t at = node->start - fstStateNtransLen(s) - 1                             // pack size
@@ -386,7 +386,7 @@ uint8_t fstStateInputForAnyTrans(FstState* s, FstNode* node, uint64_t i) {
 
 // trans_addr
 CompiledAddr fstStateTransAddr(FstState* s, FstNode* node) {
-  ASSERT(s->state == OneTransNext || s->state == OneTrans);
+  // ASSERT(s->state == OneTransNext || s->state == OneTrans);
   FstSlice* slice = &node->data;
   if (s->state == OneTransNext) {
     return (CompiledAddr)(node->end) - 1;
@@ -402,7 +402,7 @@ CompiledAddr fstStateTransAddr(FstState* s, FstNode* node) {
   }
 }
 CompiledAddr fstStateTransAddrForAnyTrans(FstState* s, FstNode* node, uint64_t i) {
-  ASSERT(s->state == AnyTrans);
+  // ASSERT(s->state == AnyTrans);
 
   FstSlice* slice = &node->data;
   uint8_t   tSizes = FST_GET_TRANSITION_PACK_SIZE(node->sizes);
@@ -414,7 +414,7 @@ CompiledAddr fstStateTransAddrForAnyTrans(FstState* s, FstNode* node, uint64_t i
 
 // sizes
 PackSizes fstStateSizes(FstState* s, FstSlice* slice) {
-  ASSERT(s->state == OneTrans || s->state == AnyTrans);
+  /// ASSERT(s->state == OneTrans || s->state == AnyTrans);
   uint64_t i;
   if (s->state == OneTrans) {
     i = FST_SLICE_LEN(slice) - 1 - fstStateInputLen(s) - 1;
@@ -427,7 +427,7 @@ PackSizes fstStateSizes(FstState* s, FstSlice* slice) {
 }
 // Output
 Output fstStateOutput(FstState* s, FstNode* node) {
-  ASSERT(s->state == OneTrans);
+  // ASSERT(s->state == OneTrans);
 
   uint8_t oSizes = FST_GET_OUTPUT_PACK_SIZE(node->sizes);
   if (oSizes == 0) {
@@ -441,7 +441,7 @@ Output fstStateOutput(FstState* s, FstNode* node) {
   return unpackUint64(data + i, oSizes);
 }
 Output fstStateOutputForAnyTrans(FstState* s, FstNode* node, uint64_t i) {
-  ASSERT(s->state == AnyTrans);
+  // ASSERT(s->state == AnyTrans);
 
   uint8_t oSizes = FST_GET_OUTPUT_PACK_SIZE(node->sizes);
   if (oSizes == 0) {
@@ -458,19 +458,19 @@ Output fstStateOutputForAnyTrans(FstState* s, FstNode* node, uint64_t i) {
 // anyTrans specify function
 
 void fstStateSetFinalState(FstState* s, bool yes) {
-  ASSERT(s->state == AnyTrans);
+  // ASSERT(s->state == AnyTrans);
   if (yes) {
     s->val |= 0b01000000;
   }
   return;
 }
 bool fstStateIsFinalState(FstState* s) {
-  ASSERT(s->state == AnyTrans);
+  // ASSERT(s->state == AnyTrans);
   return (s->val & 0b01000000) == 0b01000000;
 }
 
 void fstStateSetStateNtrans(FstState* s, uint8_t n) {
-  ASSERT(s->state == AnyTrans);
+  // ASSERT(s->state == AnyTrans);
   if (n <= 0b00111111) {
     s->val = (s->val & 0b11000000) | n;
   }
@@ -478,7 +478,7 @@ void fstStateSetStateNtrans(FstState* s, uint8_t n) {
 }
 // state_ntrans
 uint8_t fstStateStateNtrans(FstState* s, bool* null) {
-  ASSERT(s->state == AnyTrans);
+  // ASSERT(s->state == AnyTrans);
   *null = false;
   uint8_t n = s->val & 0b00111111;
 
@@ -488,16 +488,16 @@ uint8_t fstStateStateNtrans(FstState* s, bool* null) {
   return n;
 }
 uint64_t fstStateTotalTransSize(FstState* s, uint64_t version, PackSizes sizes, uint64_t nTrans) {
-  ASSERT(s->state == AnyTrans);
+  // ASSERT(s->state == AnyTrans);
   uint64_t idxSize = fstStateTransIndexSize(s, version, nTrans);
   return nTrans + (nTrans * FST_GET_TRANSITION_PACK_SIZE(sizes)) + idxSize;
 }
 uint64_t fstStateTransIndexSize(FstState* s, uint64_t version, uint64_t nTrans) {
-  ASSERT(s->state == AnyTrans);
+  // ASSERT(s->state == AnyTrans);
   return (version >= 2 && nTrans > TRANS_INDEX_THRESHOLD) ? 256 : 0;
 }
 uint64_t fstStateNtransLen(FstState* s) {
-  ASSERT(s->state == AnyTrans);
+  // ASSERT(s->state == AnyTrans);
   bool null = false;
   (void)fstStateStateNtrans(s, &null);
   return null == true ? 1 : 0;
@@ -526,7 +526,7 @@ Output fstStateFinalOutput(FstState* s, uint64_t version, FstSlice* slice, PackS
   return unpackUint64(data + at, (uint8_t)oSizes);
 }
 uint64_t fstStateFindInput(FstState* s, FstNode* node, uint8_t b, bool* null) {
-  ASSERT(s->state == AnyTrans);
+  // ASSERT(s->state == AnyTrans);
   FstSlice* slice = &node->data;
   if (node->version >= 2 && node->nTrans > TRANS_INDEX_THRESHOLD) {
     uint64_t at = node->start - fstStateNtransLen(s) - 1  // pack size
@@ -672,17 +672,17 @@ bool fstNodeGetTransitionAddrAt(FstNode* node, uint64_t i, CompiledAddr* res) {
   bool      s = true;
   FstState* st = &node->state;
   if (st->state == OneTransNext) {
-    ASSERT(i == 0);
+    /// ASSERT(i == 0);
     (void)fstStateTransAddr(st, node);
   } else if (st->state == OneTrans) {
-    ASSERT(i == 0);
+    // ASSERT(i == 0);
     (void)fstStateTransAddr(st, node);
   } else if (st->state == AnyTrans) {
     (void)fstStateTransAddrForAnyTrans(st, node, i);
   } else if (FST_STATE_EMPTY_FINAL(node)) {
     s = false;
   } else {
-    ASSERT(0);
+    // ASSERT(0);
   }
   return s;
 }
@@ -718,7 +718,7 @@ bool fstNodeFindInput(FstNode* node, uint8_t b, uint64_t* res) {
 
 bool fstNodeCompile(FstNode* node, void* w, CompiledAddr lastAddr, CompiledAddr addr, FstBuilderNode* builderNode) {
   int32_t sz = taosArrayGetSize(builderNode->trans);
-  ASSERT(sz < 256);
+  // ASSERT(sz < 256);
   if (sz == 0 && builderNode->isFinal && builderNode->finalOutput == 0) {
     return true;
   } else if (sz != 1 || builderNode->isFinal) {
@@ -800,7 +800,7 @@ void fstBuilderInsertOutput(FstBuilder* b, FstSlice bs, Output in) {
   uint64_t prefixLen = fstUnFinishedNodesFindCommPrefixAndSetOutput(b->unfinished, bs, in, &out);
 
   if (prefixLen == FST_SLICE_LEN(s)) {
-    ASSERT(out == 0);
+    // ASSERT(out == 0);
     return;
   }
 
@@ -844,7 +844,7 @@ void fstBuilderCompileFrom(FstBuilder* b, uint64_t istate) {
     addr = fstBuilderCompile(b, bn);
 
     fstBuilderNodeDestroy(bn);
-    ASSERT(addr != NONE_ADDRESS);
+    // ASSERT(addr != NONE_ADDRESS);
   }
   fstUnFinishedNodesTopLastFreeze(b->unfinished, addr);
   return;
diff --git a/source/libs/index/src/indexFstFile.c b/source/libs/index/src/indexFstFile.c
index 69fee8d29d..5c6a39d13c 100644
--- a/source/libs/index/src/indexFstFile.c
+++ b/source/libs/index/src/indexFstFile.c
@@ -104,7 +104,10 @@ static int idxFileCtxDoReadFrom(IFileCtx* ctx, uint8_t* buf, int len, int32_t of
 
   do {
     char key[1024] = {0};
-    ASSERT(strlen(ctx->file.buf) + 1 + 64 < sizeof(key));
+    if (strlen(ctx->file.buf) + 1 + 64 >= sizeof(key)) {
+      return TSDB_CODE_INDEX_INVALID_FILE;
+    }
+
     idxGenLRUKey(key, ctx->file.buf, blkId);
     LRUHandle* h = taosLRUCacheLookup(ctx->lru, key, strlen(key));
 
@@ -118,8 +121,10 @@ static int idxFileCtxDoReadFrom(IFileCtx* ctx, uint8_t* buf, int len, int32_t of
       if (left < kBlockSize) {
         nread = TMIN(left, len);
         int32_t bytes = taosPReadFile(ctx->file.pFile, buf + total, nread, offset);
-        ASSERTS(bytes == nread, "index read incomplete data");
-        if (bytes != nread) break;
+        if (bytes != nread) {
+          total = TSDB_CODE_INDEX_INVALID_FILE;
+          break;
+        }
 
         total += bytes;
         return total;
@@ -129,7 +134,6 @@ static int idxFileCtxDoReadFrom(IFileCtx* ctx, uint8_t* buf, int len, int32_t of
         SDataBlock* blk = taosMemoryCalloc(1, cacheMemSize);
         blk->blockId = blkId;
         blk->nread = taosPReadFile(ctx->file.pFile, blk->buf, kBlockSize, blkId * kBlockSize);
-        ASSERTS(blk->nread <= kBlockSize, "index read incomplete data");
         if (blk->nread < kBlockSize && blk->nread < len) {
           taosMemoryFree(blk);
           break;
@@ -288,7 +292,6 @@ int32_t idxFileWrite(IdxFstFile* write, uint8_t* buf, uint32_t len) {
   // update checksum
   IFileCtx* ctx = write->wrt;
   int       nWrite = ctx->write(ctx, buf, len);
-  ASSERTS(nWrite == len, "index write incomplete data");
   if (nWrite != len) {
     code = TAOS_SYSTEM_ERROR(errno);
     return code;
diff --git a/source/libs/index/src/indexFstNode.c b/source/libs/index/src/indexFstNode.c
index b934cb0536..041444f1c9 100644
--- a/source/libs/index/src/indexFstNode.c
+++ b/source/libs/index/src/indexFstNode.c
@@ -97,9 +97,8 @@ void fstBuilderNodeCloneFrom(FstBuilderNode* dst, FstBuilderNode* src) {
 
 // bool fstBuilderNodeCompileTo(FstBuilderNode *b, IdxFile *wrt, CompiledAddr lastAddr, CompiledAddr
 // startAddr) {
-
 // size_t sz = taosArrayGetSize(b->trans);
-// assert(sz < 256);
+// ASSERT(sz < 256);
 // if (FST_BUILDER_NODE_IS_FINAL(b)
 //    && FST_BUILDER_NODE_TRANS_ISEMPTY(b)
 //    && FST_BUILDER_NODE_FINALOUTPUT_ISZERO(b)) {
diff --git a/source/libs/index/src/indexFstRegister.c b/source/libs/index/src/indexFstRegister.c
index e27ab939b3..a8c4365a44 100644
--- a/source/libs/index/src/indexFstRegister.c
+++ b/source/libs/index/src/indexFstRegister.c
@@ -57,8 +57,9 @@ static void fstRegistryCellPromote(SArray* arr, uint32_t start, uint32_t end) {
   if (start >= sz && end >= sz) {
     return;
   }
-  ASSERTS(start >= end, "index-fst start lower than end");
-  if (start < end) return;
+  if (start < end) {
+    return;
+  }
 
   int32_t s = (int32_t)start;
   int32_t e = (int32_t)end;
diff --git a/source/libs/index/src/indexTfile.c b/source/libs/index/src/indexTfile.c
index 99c7b6bc76..5b0734d3d0 100644
--- a/source/libs/index/src/indexTfile.c
+++ b/source/libs/index/src/indexTfile.c
@@ -898,17 +898,20 @@ static int tfileWriteFooter(TFileWriter* write) {
   char  buf[sizeof(FILE_MAGIC_NUMBER) + 1] = {0};
   void* pBuf = (void*)buf;
   (void)taosEncodeFixedU64((void**)(void*)&pBuf, FILE_MAGIC_NUMBER);
-  int nwrite = write->ctx->write(write->ctx, buf, (int32_t)strlen(buf));
+  int nwrite = write->ctx->write(write->ctx, (uint8_t*)buf, (int32_t)strlen(buf));
 
   indexInfo("tfile write footer size: %d", write->ctx->size(write->ctx));
-  ASSERTS(nwrite == sizeof(FILE_MAGIC_NUMBER), "index write incomplete data");
-  return nwrite;
+  if (nwrite != sizeof(FILE_MAGIC_NUMBER)) {
+    return TAOS_SYSTEM_ERROR(errno);
+  } else {
+    return nwrite;
+  }
 }
 static int tfileReaderLoadHeader(TFileReader* reader) {
   // TODO simple tfile header later
   char buf[TFILE_HEADER_SIZE] = {0};
 
-  int64_t nread = reader->ctx->readFrom(reader->ctx, buf, sizeof(buf), 0);
+  int64_t nread = reader->ctx->readFrom(reader->ctx, (uint8_t*)buf, sizeof(buf), 0);
 
   if (nread == -1) {
     indexError("actual Read: %d, to read: %d, code:0x%x, filename: %s", (int)(nread), (int)sizeof(buf), errno,
@@ -932,14 +935,13 @@ static int tfileReaderLoadFst(TFileReader* reader) {
   }
 
   int64_t ts = taosGetTimestampUs();
-  int32_t nread = ctx->readFrom(ctx, buf, fstSize, reader->header.fstOffset);
+  int32_t nread = ctx->readFrom(ctx, (uint8_t*)buf, fstSize, reader->header.fstOffset);
   int64_t cost = taosGetTimestampUs() - ts;
   indexInfo("nread = %d, and fst offset=%d, fst size: %d, filename: %s, file size: %d, time cost: %" PRId64 "us", nread,
             reader->header.fstOffset, fstSize, ctx->file.buf, size, cost);
   // we assuse fst size less than FST_MAX_SIZE
-  ASSERTS(nread > 0 && nread <= fstSize, "index read incomplete fst");
   if (nread <= 0 || nread > fstSize) {
-    return -1;
+    return TSDB_CODE_INDEX_INVALID_FILE;
   }
 
   FstSlice st = fstSliceCreate((uint8_t*)buf, nread);
@@ -954,8 +956,10 @@ static int tfileReaderLoadTableIds(TFileReader* reader, int32_t offset, SArray*
   IFileCtx* ctx = reader->ctx;
   // add block cache
   char    block[4096] = {0};
-  int32_t nread = ctx->readFrom(ctx, block, sizeof(block), offset);
-  ASSERT(nread >= sizeof(uint32_t));
+  int32_t nread = ctx->readFrom(ctx, (uint8_t*)block, sizeof(block), offset);
+  if (nread < sizeof(uint32_t)) {
+    return TSDB_CODE_INDEX_INVALID_FILE;
+  }
 
   char*   p = block;
   int32_t nid = *(int32_t*)p;
@@ -972,7 +976,7 @@ static int tfileReaderLoadTableIds(TFileReader* reader, int32_t offset, SArray*
 
       memset(block, 0, sizeof(block));
       offset += sizeof(block);
-      nread = ctx->readFrom(ctx, block, sizeof(block), offset);
+      nread = ctx->readFrom(ctx, (uint8_t*)block, sizeof(block), offset);
       memcpy(buf + left, block, sizeof(uint64_t) - left);
 
       (void)taosArrayPush(result, (uint64_t*)buf);
@@ -991,13 +995,14 @@ static int tfileReaderVerify(TFileReader* reader) {
   int      size = ctx->size(ctx);
 
   if (size < sizeof(tMagicNumber) || size <= sizeof(reader->header)) {
-    return -1;
-  } else if (ctx->readFrom(ctx, buf, sizeof(tMagicNumber), size - sizeof(tMagicNumber)) != sizeof(tMagicNumber)) {
-    return -1;
+    return TSDB_CODE_INDEX_INVALID_FILE;
+  } else if (ctx->readFrom(ctx, (uint8_t*)buf, sizeof(tMagicNumber), size - sizeof(tMagicNumber)) !=
+             sizeof(tMagicNumber)) {
+    return TSDB_CODE_INDEX_INVALID_FILE;
   }
 
   (void)taosDecodeFixedU64(buf, &tMagicNumber);
-  return tMagicNumber == FILE_MAGIC_NUMBER ? 0 : -1;
+  return tMagicNumber == FILE_MAGIC_NUMBER ? 0 : TSDB_CODE_INDEX_INVALID_FILE;
 }
 
 void tfileReaderRef(TFileReader* rd) {
diff --git a/source/libs/stream/src/streamBackendRocksdb.c b/source/libs/stream/src/streamBackendRocksdb.c
index 83e55791d2..29fb18ef07 100644
--- a/source/libs/stream/src/streamBackendRocksdb.c
+++ b/source/libs/stream/src/streamBackendRocksdb.c
@@ -420,7 +420,10 @@ int32_t remoteChkpGetDelFile(char* path, SArray* toDel) {
 }
 
 void cleanDir(const char* pPath, const char* id) {
-  ASSERT(pPath != NULL);
+  if (pPath == NULL) {
+    stError("%s try to clean dir, but path is NULL", id);
+    return;
+  }
 
   if (taosIsDir(pPath)) {
     taosRemoveDir(pPath);
@@ -2603,7 +2606,7 @@ void taskDbDestroy(void* pDb, bool flush) {
   stDebug("succ to destroy stream backend:%p", wrapper);
 
   int8_t nCf = tListLen(ginitDict);
-  if (flush &&  wrapper->removeAllFiles == 0) {
+  if (flush && wrapper->removeAllFiles == 0) {
     if (wrapper->db && wrapper->pCf) {
       rocksdb_flushoptions_t* flushOpt = rocksdb_flushoptions_create();
       rocksdb_flushoptions_set_wait(flushOpt, 1);
diff --git a/source/libs/transport/src/transCli.c b/source/libs/transport/src/transCli.c
index 862a74c72b..51780c484f 100644
--- a/source/libs/transport/src/transCli.c
+++ b/source/libs/transport/src/transCli.c
@@ -2193,7 +2193,6 @@ bool cliRecvReleaseReq(SCliConn* conn, STransMsgHead* pHead) {
     for (int i = 0; ahandle == 0 && i < transQueueSize(&conn->cliMsgs); i++) {
       SCliMsg* cliMsg = transQueueGet(&conn->cliMsgs, i);
       if (cliMsg->type == Release) {
-        ASSERTS(pMsg == NULL, "trans-cli recv invaid release-req");
         tDebug("%s conn %p receive release request, refId:%" PRId64 ", ignore msg", CONN_GET_INST_LABEL(conn), conn,
                conn->refId);
         cliDestroyConn(conn, true);
@@ -3015,7 +3014,6 @@ _exception:
 }
 int32_t transSendRequestWithId(void* shandle, const SEpSet* pEpSet, STransMsg* pReq, int64_t* transpointId) {
   if (transpointId == NULL) {
-    ASSERT(0);
     return TSDB_CODE_INVALID_PARA;
   }
   int32_t code = 0;
diff --git a/source/libs/transport/src/transComm.c b/source/libs/transport/src/transComm.c
index 5d82e157b3..f5820b80aa 100644
--- a/source/libs/transport/src/transComm.c
+++ b/source/libs/transport/src/transComm.c
@@ -183,7 +183,6 @@ int32_t transResetBuffer(SConnBuffer* connBuf, int8_t resetBuf) {
       }
     }
   } else {
-    ASSERTS(0, "invalid read from sock buf");
     return TSDB_CODE_INVALID_MSG;
   }
   return 0;
diff --git a/source/libs/transport/src/transSvr.c b/source/libs/transport/src/transSvr.c
index c1b934c812..c3883830ad 100644
--- a/source/libs/transport/src/transSvr.c
+++ b/source/libs/transport/src/transSvr.c
@@ -468,8 +468,8 @@ static bool uvHandleReq(SSvrConn* pConn) {
 
   tGTrace("%s handle %p conn:%p translated to app, refId:%" PRIu64, transLabel(pTransInst), transMsg.info.handle, pConn,
           pConn->refId);
-  ASSERTS(transMsg.info.handle != NULL, "trans-svr failed to alloc handle to msg");
   if (transMsg.info.handle == NULL) {
+    tError("%s handle %p conn:%p handle failed to init" PRIu64, transLabel(pTransInst), transMsg.info.handle, pConn);
     return false;
   }
 
@@ -960,15 +960,19 @@ void uvOnConnectionCb(uv_stream_t* q, ssize_t nread, const uv_buf_t* buf) {
     return;
   }
   // free memory allocated by
-  ASSERTS(nread == strlen(notify), "trans-svr mem corrupted");
-  ASSERTS(buf->base[0] == notify[0], "trans-svr mem corrupted");
+  if (nread != strlen(notify) || strncmp(buf->base, notify, strlen(notify)) != 0) {
+    tError("failed to read pip ");
+    taosMemoryFree(buf->base);
+    uv_close((uv_handle_t*)q, NULL);
+  }
+
   taosMemoryFree(buf->base);
 
   SWorkThrd* pThrd = q->data;
 
   uv_pipe_t* pipe = (uv_pipe_t*)q;
   if (!uv_pipe_pending_count(pipe)) {
-    tError("No pending count");
+    tError("no pending count, unexpected error");
     uv_close((uv_handle_t*)q, NULL);
     return;
   }
@@ -1344,25 +1348,32 @@ static void uvPipeListenCb(uv_stream_t* handle, int status) {
   uv_pipe_t*  pipe = &(srv->pipe[srv->numOfWorkerReady][0]);
 
   int ret = uv_pipe_init(srv->loop, pipe, 1);
-  ASSERTS(ret == 0, "trans-svr failed to init pipe");
-  if (ret != 0) return;
+  if (ret != 0) {
+    tError("trans-svr failed to init pipe, errmsg: %s", uv_err_name(ret));
+  }
 
   ret = uv_accept((uv_stream_t*)&srv->pipeListen, (uv_stream_t*)pipe);
-  ASSERTS(ret == 0, "trans-svr failed to accept pipe msg");
-  if (ret != 0) return;
+  if (ret != 0) {
+    tError("trans-svr failed to accept pipe, errmsg: %s", uv_err_name(ret));
+    return;
+  }
 
   ret = uv_is_readable((uv_stream_t*)pipe);
-  ASSERTS(ret == 1, "trans-svr pipe status corrupted");
-  if (ret != 1) return;
-
+  if (ret != 1) {
+    tError("trans-svr failed to check pipe, pip not readable");
+    return;
+  }
   ret = uv_is_writable((uv_stream_t*)pipe);
-  ASSERTS(ret == 1, "trans-svr pipe status corrupted");
-  if (ret != 1) return;
+  if (ret != 1) {
+    tError("trans-svr failed to check pipe, pip not writable");
+    return;
+  }
 
   ret = uv_is_closing((uv_handle_t*)pipe);
-  ASSERTS(ret == 0, "trans-svr pipe status corrupted");
-  if (ret != 0) return;
-
+  if (ret != 0) {
+    tError("trans-svr failed to check pipe, pip is closing");
+    return;
+  }
   srv->numOfWorkerReady++;
 }