Merge remote-tracking branch 'origin/3.0' into fix/refactorTqBackend

include/common/tdatablock.h

@@ -32,8 +32,8 @@ typedef struct SBlockOrderInfo {
   SColumnInfoData* pColData;
 } SBlockOrderInfo;
 
-#define BLOCK_VERSION_1          1
+#define BLOCK_VERSION_1 1
-#define BLOCK_VERSION_2          2
+#define BLOCK_VERSION_2 2
 
 #define NBIT                     (3u)
 #define BitPos(_n)               ((_n) & ((1 << NBIT) - 1))
@@ -46,9 +46,9 @@ typedef struct SBlockOrderInfo {
     BMCharPos(bm_, r_) |= (1u << (7u - BitPos(r_))); \
   } while (0)
 
-#define colDataSetNull_f_s(c_, r_)                                        \
+#define colDataSetNull_f_s(c_, r_)                                                     \
-  do {                                                                    \
+  do {                                                                                 \
-    colDataSetNull_f((c_)->nullbitmap, r_);                               \
+    colDataSetNull_f((c_)->nullbitmap, r_);                                            \
     (void)memset(((char*)(c_)->pData) + (c_)->info.bytes * (r_), 0, (c_)->info.bytes); \
   } while (0)
 
@@ -143,7 +143,7 @@ static FORCE_INLINE void colDataSetNNULL(SColumnInfoData* pColumnInfoData, uint3
     for (int32_t i = start; i < start + nRows; ++i) {
       colDataSetNull_f(pColumnInfoData->nullbitmap, i);
     }
-    memset(pColumnInfoData->pData + start * pColumnInfoData->info.bytes, 0, pColumnInfoData->info.bytes * nRows);
+    (void)memset(pColumnInfoData->pData + start * pColumnInfoData->info.bytes, 0, pColumnInfoData->info.bytes * nRows);
   }
 
   pColumnInfoData->hasNull = true;
@@ -192,15 +192,17 @@ int32_t getJsonValueLen(const char* data);
 
 int32_t colDataSetVal(SColumnInfoData* pColumnInfoData, uint32_t rowIndex, const char* pData, bool isNull);
 int32_t colDataReassignVal(SColumnInfoData* pColumnInfoData, uint32_t dstRowIdx, uint32_t srcRowIdx, const char* pData);
-int32_t colDataSetNItems(SColumnInfoData* pColumnInfoData, uint32_t rowIndex, const char* pData, uint32_t numOfRows, bool trimValue);
+int32_t colDataSetNItems(SColumnInfoData* pColumnInfoData, uint32_t rowIndex, const char* pData, uint32_t numOfRows,
-void colDataSetNItemsNull(SColumnInfoData* pColumnInfoData, uint32_t currentRow, uint32_t numOfRows);
+                         bool trimValue);
-int32_t colDataCopyNItems(SColumnInfoData* pColumnInfoData, uint32_t currentRow, const char* pData,
+void    colDataSetNItemsNull(SColumnInfoData* pColumnInfoData, uint32_t currentRow, uint32_t numOfRows);
-                            uint32_t numOfRows, bool isNull);
+int32_t colDataCopyNItems(SColumnInfoData* pColumnInfoData, uint32_t currentRow, const char* pData, uint32_t numOfRows,
+                          bool isNull);
 int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, int32_t numOfRow1, int32_t* capacity,
                         const SColumnInfoData* pSource, int32_t numOfRow2);
 int32_t colDataAssign(SColumnInfoData* pColumnInfoData, const SColumnInfoData* pSource, int32_t numOfRows,
                       const SDataBlockInfo* pBlockInfo);
-int32_t colDataAssignNRows(SColumnInfoData* pDst, int32_t dstIdx, const SColumnInfoData* pSrc, int32_t srcIdx, int32_t numOfRows);                      
+int32_t colDataAssignNRows(SColumnInfoData* pDst, int32_t dstIdx, const SColumnInfoData* pSrc, int32_t srcIdx,
+                           int32_t numOfRows);
 int32_t blockDataUpdateTsWindow(SSDataBlock* pDataBlock, int32_t tsColumnIndex);
 int32_t blockDataUpdatePkRange(SSDataBlock* pDataBlock, int32_t pkColumnIndex, bool asc);
 
@@ -214,7 +216,7 @@ size_t blockDataGetNumOfRows(const SSDataBlock* pBlock);
 
 int32_t blockDataMerge(SSDataBlock* pDest, const SSDataBlock* pSrc);
 int32_t blockDataMergeNRows(SSDataBlock* pDest, const SSDataBlock* pSrc, int32_t srcIdx, int32_t numOfRows);
-void blockDataShrinkNRows(SSDataBlock* pBlock, int32_t numOfRows);
+void    blockDataShrinkNRows(SSDataBlock* pBlock, int32_t numOfRows);
 int32_t blockDataSplitRows(SSDataBlock* pBlock, bool hasVarCol, int32_t startIndex, int32_t* stopIndex,
                            int32_t pageSize);
 int32_t blockDataToBuf(char* buf, const SSDataBlock* pBlock);
@@ -237,12 +239,12 @@ int32_t blockDataGetSortedRows(SSDataBlock* pDataBlock, SArray* pOrderInfo);
 int32_t colInfoDataEnsureCapacity(SColumnInfoData* pColumn, uint32_t numOfRows, bool clearPayload);
 int32_t blockDataEnsureCapacity(SSDataBlock* pDataBlock, uint32_t numOfRows);
 
-void colInfoDataCleanup(SColumnInfoData* pColumn, uint32_t numOfRows);
+void    colInfoDataCleanup(SColumnInfoData* pColumn, uint32_t numOfRows);
-void blockDataCleanup(SSDataBlock* pDataBlock);
+void    blockDataCleanup(SSDataBlock* pDataBlock);
-void blockDataReset(SSDataBlock* pDataBlock);
+void    blockDataReset(SSDataBlock* pDataBlock);
-void blockDataEmpty(SSDataBlock* pDataBlock);
+void    blockDataEmpty(SSDataBlock* pDataBlock);
 int32_t doEnsureCapacity(SColumnInfoData* pColumn, const SDataBlockInfo* pBlockInfo, uint32_t numOfRows,
-                                bool clearPayload);
+                         bool clearPayload);
 
 size_t blockDataGetCapacityInRow(const SSDataBlock* pBlock, size_t pageSize, int32_t extraSize);
 
@@ -264,20 +266,20 @@ int32_t      blockDataAppendColInfo(SSDataBlock* pBlock, SColumnInfoData* pColIn
 SColumnInfoData  createColumnInfoData(int16_t type, int32_t bytes, int16_t colId);
 SColumnInfoData* bdGetColumnInfoData(const SSDataBlock* pBlock, int32_t index);
 
-int32_t blockGetEncodeSize(const SSDataBlock* pBlock);
+int32_t     blockGetEncodeSize(const SSDataBlock* pBlock);
-int32_t blockEncode(const SSDataBlock* pBlock, char* data, int32_t numOfCols);
+int32_t     blockEncode(const SSDataBlock* pBlock, char* data, int32_t numOfCols);
 const char* blockDecode(SSDataBlock* pBlock, const char* pData);
 
 // for debug
 char* dumpBlockData(SSDataBlock* pDataBlock, const char* flag, char** dumpBuf, const char* taskIdStr);
 
-int32_t buildSubmitReqFromDataBlock(SSubmitReq2** pReq, const SSDataBlock* pDataBlocks, const STSchema* pTSchema, int64_t uid, int32_t vgId,
+int32_t buildSubmitReqFromDataBlock(SSubmitReq2** pReq, const SSDataBlock* pDataBlocks, const STSchema* pTSchema,
-                                    tb_uid_t suid);
+                                    int64_t uid, int32_t vgId, tb_uid_t suid);
 
-bool  alreadyAddGroupId(char* ctbName, int64_t groupId);
+bool    alreadyAddGroupId(char* ctbName, int64_t groupId);
-bool  isAutoTableName(char* ctbName);
+bool    isAutoTableName(char* ctbName);
-void  buildCtbNameAddGroupId(const char* stbName, char* ctbName, uint64_t groupId);
+void    buildCtbNameAddGroupId(const char* stbName, char* ctbName, uint64_t groupId);
-char* buildCtbNameByGroupId(const char* stbName, uint64_t groupId);
+char*   buildCtbNameByGroupId(const char* stbName, uint64_t groupId);
 int32_t buildCtbNameByGroupIdImpl(const char* stbName, uint64_t groupId, char* pBuf);
 
 void trimDataBlock(SSDataBlock* pBlock, int32_t totalRows, const bool* pBoolList);

include/common/tdataformat.h

@@ -315,7 +315,7 @@ struct STag {
   do {                                            \
     VarDataLenT __len = (VarDataLenT)strlen(str); \
     *(VarDataLenT *)(x) = __len;                  \
-    memcpy(varDataVal(x), (str), __len);          \
+    (void)memcpy(varDataVal(x), (str), __len);    \
   } while (0);
 
 #define STR_WITH_MAXSIZE_TO_VARSTR(x, str, _maxs)                         \
@@ -324,10 +324,10 @@ struct STag {
     varDataSetLen(x, (_e - (x)-VARSTR_HEADER_SIZE));                      \
   } while (0)
 
-#define STR_WITH_SIZE_TO_VARSTR(x, str, _size)  \
+#define STR_WITH_SIZE_TO_VARSTR(x, str, _size)   \
-  do {                                          \
+  do {                                           \
-    *(VarDataLenT *)(x) = (VarDataLenT)(_size); \
+    *(VarDataLenT *)(x) = (VarDataLenT)(_size);  \
-    memcpy(varDataVal(x), (str), (_size));      \
+    (void)memcpy(varDataVal(x), (str), (_size)); \
   } while (0);
 
 // STSchema ================================

include/common/tglobal.h

@@ -272,11 +272,11 @@ int32_t taosCfgDynamicOptions(SConfig *pCfg, const char *name, bool forServer);
 
 struct SConfig *taosGetCfg();
 
-void   taosSetGlobalDebugFlag(int32_t flag);
+int32_t taosSetGlobalDebugFlag(int32_t flag);
-void   taosSetDebugFlag(int32_t *pFlagPtr, const char *flagName, int32_t flagVal);
+int32_t taosSetDebugFlag(int32_t *pFlagPtr, const char *flagName, int32_t flagVal);
-void   taosLocalCfgForbiddenToChange(char *name, bool *forbidden);
+void    taosLocalCfgForbiddenToChange(char *name, bool *forbidden);
-int8_t taosGranted(int8_t type);
+int8_t  taosGranted(int8_t type);
-int32_t taosSetSlowLogScope(char *pScope);
+int32_t taosSetSlowLogScope(char *pScopeStr, int32_t *pScope);
 
 #ifdef __cplusplus
 }

include/common/tgrant.h

@@ -68,7 +68,7 @@ int32_t generateEncryptCode(const char *key, const char *machineId, char **encry
 int64_t grantRemain(EGrantType grant);
 int32_t grantCheck(EGrantType grant);
 int32_t grantCheckExpire(EGrantType grant);
-char   *tGetMachineId();
+int32_t tGetMachineId(char **result);
 
 // #ifndef GRANTS_CFG
 #ifdef TD_ENTERPRISE

include/common/tmsg.h

@@ -683,36 +683,55 @@ typedef struct {
 } SColCmprWrapper;
 
 static FORCE_INLINE SColCmprWrapper* tCloneSColCmprWrapper(const SColCmprWrapper* pSrcWrapper) {
-  if (pSrcWrapper->pColCmpr == NULL || pSrcWrapper->nCols == 0) return NULL;
+  if (pSrcWrapper->pColCmpr == NULL || pSrcWrapper->nCols == 0) {
+    terrno = TSDB_CODE_INVALID_PARA;
+    return NULL;
+  }
 
   SColCmprWrapper* pDstWrapper = (SColCmprWrapper*)taosMemoryMalloc(sizeof(SColCmprWrapper));
+  if (pDstWrapper == NULL) {
+    return NULL;
+  }
   pDstWrapper->nCols = pSrcWrapper->nCols;
   pDstWrapper->version = pSrcWrapper->version;
 
   int32_t size = sizeof(SColCmpr) * pDstWrapper->nCols;
   pDstWrapper->pColCmpr = (SColCmpr*)taosMemoryCalloc(1, size);
-  memcpy(pDstWrapper->pColCmpr, pSrcWrapper->pColCmpr, size);
+  if (pDstWrapper->pColCmpr == NULL) {
+    taosMemoryFree(pDstWrapper);
+    return NULL;
+  }
+  (void)memcpy(pDstWrapper->pColCmpr, pSrcWrapper->pColCmpr, size);
 
   return pDstWrapper;
 }
 
-static FORCE_INLINE void tInitDefaultSColCmprWrapperByCols(SColCmprWrapper* pCmpr, int32_t nCols) {
+static FORCE_INLINE int32_t tInitDefaultSColCmprWrapperByCols(SColCmprWrapper* pCmpr, int32_t nCols) {
   assert(!pCmpr->pColCmpr);
   pCmpr->pColCmpr = (SColCmpr*)taosMemoryCalloc(nCols, sizeof(SColCmpr));
+  if (pCmpr->pColCmpr == NULL) {
+    return terrno;
+  }
   pCmpr->nCols = nCols;
+  return 0;
 }
 
-static FORCE_INLINE void tInitDefaultSColCmprWrapper(SColCmprWrapper* pCmpr, SSchemaWrapper* pSchema) {
+static FORCE_INLINE int32_t tInitDefaultSColCmprWrapper(SColCmprWrapper* pCmpr, SSchemaWrapper* pSchema) {
   pCmpr->nCols = pSchema->nCols;
   assert(!pCmpr->pColCmpr);
   pCmpr->pColCmpr = (SColCmpr*)taosMemoryCalloc(pCmpr->nCols, sizeof(SColCmpr));
+  if (pCmpr->pColCmpr == NULL) {
+    return terrno;
+  }
   for (int32_t i = 0; i < pCmpr->nCols; i++) {
     SColCmpr* pColCmpr = &pCmpr->pColCmpr[i];
     SSchema*  pColSchema = &pSchema->pSchema[i];
     pColCmpr->id = pColSchema->colId;
     pColCmpr->alg = 0;
   }
+  return 0;
 }
+
 static FORCE_INLINE void tDeleteSColCmprWrapper(SColCmprWrapper* pWrapper) {
   if (pWrapper == NULL) return;
 
@@ -723,7 +742,9 @@ static FORCE_INLINE SSchemaWrapper* tCloneSSchemaWrapper(const SSchemaWrapper* p
   if (pSchemaWrapper->pSchema == NULL) return NULL;
 
   SSchemaWrapper* pSW = (SSchemaWrapper*)taosMemoryMalloc(sizeof(SSchemaWrapper));
-  if (pSW == NULL) return pSW;
+  if (pSW == NULL) {
+    return NULL;
+  }
   pSW->nCols = pSchemaWrapper->nCols;
   pSW->version = pSchemaWrapper->version;
   pSW->pSchema = (SSchema*)taosMemoryCalloc(pSW->nCols, sizeof(SSchema));
@@ -732,7 +753,7 @@ static FORCE_INLINE SSchemaWrapper* tCloneSSchemaWrapper(const SSchemaWrapper* p
     return NULL;
   }
 
-  memcpy(pSW->pSchema, pSchemaWrapper->pSchema, pSW->nCols * sizeof(SSchema));
+  (void)memcpy(pSW->pSchema, pSchemaWrapper->pSchema, pSW->nCols * sizeof(SSchema));
   return pSW;
 }
 
@@ -770,32 +791,32 @@ static FORCE_INLINE void* taosDecodeSSchema(const void* buf, SSchema* pSchema) {
 }
 
 static FORCE_INLINE int32_t tEncodeSSchema(SEncoder* pEncoder, const SSchema* pSchema) {
-  if (tEncodeI8(pEncoder, pSchema->type) < 0) return -1;
+  TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pSchema->type));
-  if (tEncodeI8(pEncoder, pSchema->flags) < 0) return -1;
+  TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pSchema->flags));
-  if (tEncodeI32v(pEncoder, pSchema->bytes) < 0) return -1;
+  TAOS_CHECK_RETURN(tEncodeI32v(pEncoder, pSchema->bytes));
-  if (tEncodeI16v(pEncoder, pSchema->colId) < 0) return -1;
+  TAOS_CHECK_RETURN(tEncodeI16v(pEncoder, pSchema->colId));
-  if (tEncodeCStr(pEncoder, pSchema->name) < 0) return -1;
+  TAOS_CHECK_RETURN(tEncodeCStr(pEncoder, pSchema->name));
   return 0;
 }
 
 static FORCE_INLINE int32_t tDecodeSSchema(SDecoder* pDecoder, SSchema* pSchema) {
-  if (tDecodeI8(pDecoder, &pSchema->type) < 0) return -1;
+  TAOS_CHECK_RETURN(tDecodeI8(pDecoder, &pSchema->type));
-  if (tDecodeI8(pDecoder, &pSchema->flags) < 0) return -1;
+  TAOS_CHECK_RETURN(tDecodeI8(pDecoder, &pSchema->flags));
-  if (tDecodeI32v(pDecoder, &pSchema->bytes) < 0) return -1;
+  TAOS_CHECK_RETURN(tDecodeI32v(pDecoder, &pSchema->bytes));
-  if (tDecodeI16v(pDecoder, &pSchema->colId) < 0) return -1;
+  TAOS_CHECK_RETURN(tDecodeI16v(pDecoder, &pSchema->colId));
-  if (tDecodeCStrTo(pDecoder, pSchema->name) < 0) return -1;
+  TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, pSchema->name));
   return 0;
 }
 
 static FORCE_INLINE int32_t tEncodeSSchemaExt(SEncoder* pEncoder, const SSchemaExt* pSchemaExt) {
-  if (tEncodeI16v(pEncoder, pSchemaExt->colId) < 0) return -1;
+  TAOS_CHECK_RETURN(tEncodeI16v(pEncoder, pSchemaExt->colId));
-  if (tEncodeU32(pEncoder, pSchemaExt->compress) < 0) return -1;
+  TAOS_CHECK_RETURN(tEncodeU32(pEncoder, pSchemaExt->compress));
   return 0;
 }
 
 static FORCE_INLINE int32_t tDecodeSSchemaExt(SDecoder* pDecoder, SSchemaExt* pSchemaExt) {
-  if (tDecodeI16v(pDecoder, &pSchemaExt->colId) < 0) return -1;
+  TAOS_CHECK_RETURN(tDecodeI16v(pDecoder, &pSchemaExt->colId));
-  if (tDecodeU32(pDecoder, &pSchemaExt->compress) < 0) return -1;
+  TAOS_CHECK_RETURN(tDecodeU32(pDecoder, &pSchemaExt->compress));
   return 0;
 }
 
@@ -828,36 +849,39 @@ static FORCE_INLINE void* taosDecodeSSchemaWrapper(const void* buf, SSchemaWrapp
 }
 
 static FORCE_INLINE int32_t tEncodeSSchemaWrapper(SEncoder* pEncoder, const SSchemaWrapper* pSW) {
-  if (tEncodeI32v(pEncoder, pSW->nCols) < 0) return -1;
+  TAOS_CHECK_RETURN(tEncodeI32v(pEncoder, pSW->nCols));
-  if (tEncodeI32v(pEncoder, pSW->version) < 0) return -1;
+  TAOS_CHECK_RETURN(tEncodeI32v(pEncoder, pSW->version));
   for (int32_t i = 0; i < pSW->nCols; i++) {
-    if (tEncodeSSchema(pEncoder, &pSW->pSchema[i]) < 0) return -1;
+    TAOS_CHECK_RETURN(tEncodeSSchema(pEncoder, &pSW->pSchema[i]));
   }
-
   return 0;
 }
 
 static FORCE_INLINE int32_t tDecodeSSchemaWrapper(SDecoder* pDecoder, SSchemaWrapper* pSW) {
-  if (tDecodeI32v(pDecoder, &pSW->nCols) < 0) return -1;
+  TAOS_CHECK_RETURN(tDecodeI32v(pDecoder, &pSW->nCols));
-  if (tDecodeI32v(pDecoder, &pSW->version) < 0) return -1;
+  TAOS_CHECK_RETURN(tDecodeI32v(pDecoder, &pSW->version));
 
   pSW->pSchema = (SSchema*)taosMemoryCalloc(pSW->nCols, sizeof(SSchema));
-  if (pSW->pSchema == NULL) return -1;
+  if (pSW->pSchema == NULL) {
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+  }
   for (int32_t i = 0; i < pSW->nCols; i++) {
-    if (tDecodeSSchema(pDecoder, &pSW->pSchema[i]) < 0) return -1;
+    TAOS_CHECK_RETURN(tDecodeSSchema(pDecoder, &pSW->pSchema[i]));
   }
 
   return 0;
 }
 
 static FORCE_INLINE int32_t tDecodeSSchemaWrapperEx(SDecoder* pDecoder, SSchemaWrapper* pSW) {
-  if (tDecodeI32v(pDecoder, &pSW->nCols) < 0) return -1;
+  TAOS_CHECK_RETURN(tDecodeI32v(pDecoder, &pSW->nCols));
-  if (tDecodeI32v(pDecoder, &pSW->version) < 0) return -1;
+  TAOS_CHECK_RETURN(tDecodeI32v(pDecoder, &pSW->version));
 
   pSW->pSchema = (SSchema*)tDecoderMalloc(pDecoder, pSW->nCols * sizeof(SSchema));
-  if (pSW->pSchema == NULL) return -1;
+  if (pSW->pSchema == NULL) {
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+  }
   for (int32_t i = 0; i < pSW->nCols; i++) {
-    if (tDecodeSSchema(pDecoder, &pSW->pSchema[i]) < 0) return -1;
+    TAOS_CHECK_RETURN(tDecodeSSchema(pDecoder, &pSW->pSchema[i]));
   }
 
   return 0;
@@ -2837,14 +2861,14 @@ static FORCE_INLINE int32_t tDeserializeSCMSubscribeReq(void* buf, SCMSubscribeR
   buf = taosDecodeFixedI32(buf, &topicNum);
 
   pReq->topicNames = taosArrayInit(topicNum, sizeof(void*));
-  if (pReq->topicNames == NULL){
+  if (pReq->topicNames == NULL) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
   for (int32_t i = 0; i < topicNum; i++) {
     char* name = NULL;
     buf = taosDecodeString(buf, &name);
-    if (taosArrayPush(pReq->topicNames, &name) == NULL){
+    if (taosArrayPush(pReq->topicNames, &name) == NULL) {
-      return TSDB_CODE_OUT_OF_MEMORY;
+      return terrno;
     }
   }
 
@@ -2875,6 +2899,7 @@ static FORCE_INLINE SMqRebInfo* tNewSMqRebSubscribe(const char* key) {
   }
   pRebInfo->newConsumers = taosArrayInit(0, sizeof(int64_t));
   if (pRebInfo->newConsumers == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
     goto _err;
   }
   return pRebInfo;
@@ -3358,30 +3383,32 @@ int32_t tDeserializeSClientHbBatchRsp(void* buf, int32_t bufLen, SClientHbBatchR
 void    tFreeSClientHbBatchRsp(SClientHbBatchRsp* pBatchRsp);
 
 static FORCE_INLINE int32_t tEncodeSKv(SEncoder* pEncoder, const SKv* pKv) {
-  if (tEncodeI32(pEncoder, pKv->key) < 0) return -1;
+  TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pKv->key));
-  if (tEncodeI32(pEncoder, pKv->valueLen) < 0) return -1;
+  TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pKv->valueLen));
-  if (tEncodeBinary(pEncoder, (uint8_t*)pKv->value, pKv->valueLen) < 0) return -1;
+  TAOS_CHECK_RETURN(tEncodeBinary(pEncoder, (uint8_t*)pKv->value, pKv->valueLen));
   return 0;
 }
 
 static FORCE_INLINE int32_t tDecodeSKv(SDecoder* pDecoder, SKv* pKv) {
-  if (tDecodeI32(pDecoder, &pKv->key) < 0) return -1;
+  TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &pKv->key));
-  if (tDecodeI32(pDecoder, &pKv->valueLen) < 0) return -1;
+  TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &pKv->valueLen));
   pKv->value = taosMemoryMalloc(pKv->valueLen + 1);
-  if (pKv->value == NULL) return -1;
+  if (pKv->value == NULL) {
-  if (tDecodeCStrTo(pDecoder, (char*)pKv->value) < 0) return -1;
+    TAOS_CHECK_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+  }
+  TAOS_CHECK_RETURN(tDecodeCStrTo(pDecoder, (char*)pKv->value));
   return 0;
 }
 
 static FORCE_INLINE int32_t tEncodeSClientHbKey(SEncoder* pEncoder, const SClientHbKey* pKey) {
-  if (tEncodeI64(pEncoder, pKey->tscRid) < 0) return -1;
+  TAOS_CHECK_RETURN(tEncodeI64(pEncoder, pKey->tscRid));
-  if (tEncodeI8(pEncoder, pKey->connType) < 0) return -1;
+  TAOS_CHECK_RETURN(tEncodeI8(pEncoder, pKey->connType));
   return 0;
 }
 
 static FORCE_INLINE int32_t tDecodeSClientHbKey(SDecoder* pDecoder, SClientHbKey* pKey) {
-  if (tDecodeI64(pDecoder, &pKey->tscRid) < 0) return -1;
+  TAOS_CHECK_RETURN(tDecodeI64(pDecoder, &pKey->tscRid));
-  if (tDecodeI8(pDecoder, &pKey->connType) < 0) return -1;
+  TAOS_CHECK_RETURN(tDecodeI8(pDecoder, &pKey->connType));
   return 0;
 }
 
@@ -3432,7 +3459,9 @@ static FORCE_INLINE void* taosDecodeSMqTopicInfoMsg(void* buf, SMqTopicInfo* pTo
   for (int32_t i = 0; i < sz; i++) {
     SMqReportVgInfo vgInfo;
     buf = taosDecodeSMqVgInfo(buf, &vgInfo);
-    taosArrayPush(pTopicInfo->pVgInfo, &vgInfo);
+    if (taosArrayPush(pTopicInfo->pVgInfo, &vgInfo) == NULL) {
+      return NULL;
+    }
   }
   return buf;
 }
@@ -3468,7 +3497,9 @@ static FORCE_INLINE void* taosDecodeSMqReportMsg(void* buf, SMqReportReq* pMsg)
   for (int32_t i = 0; i < sz; i++) {
     SMqTopicInfo topicInfo;
     buf = taosDecodeSMqTopicInfoMsg(buf, &topicInfo);
-    taosArrayPush(pMsg->pTopics, &topicInfo);
+    if (taosArrayPush(pMsg->pTopics, &topicInfo) == NULL) {
+      return NULL;
+    }
   }
   return buf;
 }
@@ -3607,7 +3638,7 @@ int32_t tEncodeSTqOffsetVal(SEncoder* pEncoder, const STqOffsetVal* pOffsetVal);
 int32_t tDecodeSTqOffsetVal(SDecoder* pDecoder, STqOffsetVal* pOffsetVal);
 int32_t tFormatOffset(char* buf, int32_t maxLen, const STqOffsetVal* pVal);
 bool    tOffsetEqual(const STqOffsetVal* pLeft, const STqOffsetVal* pRight);
-void    tOffsetCopy(STqOffsetVal* pLeft, const STqOffsetVal* pOffsetVal);
+int32_t tOffsetCopy(STqOffsetVal* pLeft, const STqOffsetVal* pRight);
 void    tOffsetDestroy(void* pVal);
 
 typedef struct {
@@ -3808,17 +3839,17 @@ int32_t tEncodeTSma(SEncoder* pCoder, const STSma* pSma);
 int32_t tDecodeTSma(SDecoder* pCoder, STSma* pSma, bool deepCopy);
 
 static int32_t tEncodeTSmaWrapper(SEncoder* pEncoder, const STSmaWrapper* pReq) {
-  if (tEncodeI32(pEncoder, pReq->number) < 0) return -1;
+  TAOS_CHECK_RETURN(tEncodeI32(pEncoder, pReq->number));
   for (int32_t i = 0; i < pReq->number; ++i) {
-    tEncodeTSma(pEncoder, pReq->tSma + i);
+    TAOS_CHECK_RETURN(tEncodeTSma(pEncoder, pReq->tSma + i));
   }
   return 0;
 }
 
 static int32_t tDecodeTSmaWrapper(SDecoder* pDecoder, STSmaWrapper* pReq, bool deepCopy) {
-  if (tDecodeI32(pDecoder, &pReq->number) < 0) return -1;
+  TAOS_CHECK_RETURN(tDecodeI32(pDecoder, &pReq->number));
   for (int32_t i = 0; i < pReq->number; ++i) {
-    tDecodeTSma(pDecoder, pReq->tSma + i, deepCopy);
+    TAOS_CHECK_RETURN(tDecodeTSma(pDecoder, pReq->tSma + i, deepCopy));
   }
   return 0;
 }
@@ -4041,7 +4072,12 @@ static FORCE_INLINE void* tDecodeSMqAskEpRsp(void* buf, SMqAskEpRsp* pRsp) {
   for (int32_t i = 0; i < sz; i++) {
     SMqSubTopicEp topicEp;
     buf = tDecodeMqSubTopicEp(buf, &topicEp);
-    taosArrayPush(pRsp->topics, &topicEp);
+    if (buf == NULL) {
+      return NULL;
+    }
+    if ((taosArrayPush(pRsp->topics, &topicEp) == NULL)) {
+      return NULL;
+    }
   }
   return buf;
 }

include/common/ttime.h

@@ -117,7 +117,7 @@ int32_t taosTs2Char(const char* format, SArray** formats, int64_t ts, int32_t pr
 int32_t taosChar2Ts(const char* format, SArray** formats, const char* tsStr, int64_t* ts, int32_t precision, char* errMsg,
                     int32_t errMsgLen);
 
-void    TEST_ts2char(const char* format, int64_t ts, int32_t precision, char* out, int32_t outLen);
+int32_t TEST_ts2char(const char* format, int64_t ts, int32_t precision, char* out, int32_t outLen);
 int32_t TEST_char2ts(const char* format, int64_t* ts, int32_t precision, const char* tsStr);
 
 /// @brief get offset seconds from zero timezone to input timezone

include/common/ttszip.h

@@ -1,147 +0,0 @@
-/*
- * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
- *
- * This program is free software: you can use, redistribute, and/or modify
- * it under the terms of the GNU Affero General Public License, version 3
- * or later ("AGPL"), as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.
- *
- * You should have received a copy of the GNU Affero General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _TD_COMMON_TTSZIP_H_
-#define _TD_COMMON_TTSZIP_H_
-
-#include "os.h"
-#include "tdef.h"
-#include "tvariant.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define MEM_BUF_SIZE           (1 << 20)
-#define TS_COMP_FILE_MAGIC     0x87F5EC4C
-#define TS_COMP_FILE_GROUP_MAX 512
-
-typedef struct STSList {
-  char*   rawBuf;
-  int32_t allocSize;
-  int32_t threshold;
-  int32_t len;
-} STSList;
-
-typedef struct STSElem {
-  TSKEY     ts;
-  SVariant* tag;
-  int32_t   id;
-} STSElem;
-
-typedef struct STSCursor {
-  int32_t  vgroupIndex;
-  int32_t  blockIndex;
-  int32_t  tsIndex;
-  uint32_t order;
-} STSCursor;
-
-typedef struct STSBlock {
-  SVariant tag;        // tag value
-  int32_t  numOfElem;  // number of elements
-  int32_t  compLen;    // size after compressed
-  int32_t  padding;    // 0xFFFFFFFF by default, after the payload
-  char*    payload;    // actual data that is compressed
-} STSBlock;
-
-/*
- * The size of buffer file should not be greater than 2G,
- * and the offset of int32_t type is enough
- */
-typedef struct STSGroupBlockInfo {
-  int32_t id;           // group id
-  int32_t offset;       // offset set value in file
-  int32_t numOfBlocks;  // number of total blocks
-  int32_t compLen;      // compressed size
-} STSGroupBlockInfo;
-
-typedef struct STSGroupBlockInfoEx {
-  STSGroupBlockInfo info;
-  int32_t           len;  // length before compress
-} STSGroupBlockInfoEx;
-
-typedef struct STSBuf {
-  TdFilePtr pFile;
-  char      path[PATH_MAX];
-  uint32_t  fileSize;
-
-  // todo use array
-  STSGroupBlockInfoEx* pData;
-  uint32_t             numOfAlloc;
-  uint32_t             numOfGroups;
-
-  char*     assistBuf;
-  int32_t   bufSize;
-  STSBlock  block;
-  STSList   tsData;  // uncompressed raw ts data
-  uint64_t  numOfTotal;
-  bool      autoDelete;
-  bool      remainOpen;
-  int32_t   tsOrder;  // order of timestamp in ts comp buffer
-  STSCursor cur;
-} STSBuf;
-
-typedef struct STSBufFileHeader {
-  uint32_t magic;       // file magic number
-  uint32_t numOfGroup;  // number of group stored in current file
-  int32_t  tsOrder;     // timestamp order in current file
-} STSBufFileHeader;
-
-STSBuf* tsBufCreate(bool autoDelete, int32_t order);
-STSBuf* tsBufCreateFromFile(const char* path, bool autoDelete);
-STSBuf* tsBufCreateFromCompBlocks(const char* pData, int32_t numOfBlocks, int32_t len, int32_t tsOrder, int32_t id);
-
-void* tsBufDestroy(STSBuf* pTSBuf);
-
-void    tsBufAppend(STSBuf* pTSBuf, int32_t id, SVariant* tag, const char* pData, int32_t len);
-int32_t tsBufMerge(STSBuf* pDestBuf, const STSBuf* pSrcBuf);
-
-STSBuf* tsBufClone(STSBuf* pTSBuf);
-
-STSGroupBlockInfo* tsBufGetGroupBlockInfo(STSBuf* pTSBuf, int32_t id);
-
-void tsBufFlush(STSBuf* pTSBuf);
-void tsBufResetPos(STSBuf* pTSBuf);
-bool tsBufNextPos(STSBuf* pTSBuf);
-
-STSElem tsBufGetElem(STSBuf* pTSBuf);
-STSElem tsBufGetElemStartPos(STSBuf* pTSBuf, int32_t id, SVariant* tag);
-
-STSCursor tsBufGetCursor(STSBuf* pTSBuf);
-void      tsBufSetTraverseOrder(STSBuf* pTSBuf, int32_t order);
-
-void tsBufSetCursor(STSBuf* pTSBuf, STSCursor* pCur);
-
-/**
- * display all data in comp block file, for debug purpose only
- * @param pTSBuf
- */
-void tsBufDisplay(STSBuf* pTSBuf);
-
-int32_t tsBufGetNumOfGroup(STSBuf* pTSBuf);
-
-void tsBufGetGroupIdList(STSBuf* pTSBuf, int32_t* num, int32_t** id);
-
-int32_t dumpFileBlockByGroupId(STSBuf* pTSBuf, int32_t id, void* buf, int32_t* len, int32_t* numOfBlocks);
-
-STSElem tsBufFindElemStartPosByTag(STSBuf* pTSBuf, SVariant* pTag);
-
-bool tsBufIsValidElem(STSElem* pElem);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*_TD_COMMON_TTSZIP_H_*/

include/common/ttypes.h

@@ -46,7 +46,7 @@ typedef struct {
 #pragma pack(pop)
 
 #define varDataTLen(v)         (sizeof(VarDataLenT) + varDataLen(v))
-#define varDataCopy(dst, v)    memcpy((dst), (void *)(v), varDataTLen(v))
+#define varDataCopy(dst, v)    (void)memcpy((dst), (void *)(v), varDataTLen(v))
 #define varDataLenByData(v)    (*(VarDataLenT *)(((char *)(v)) - VARSTR_HEADER_SIZE))
 #define varDataSetLen(v, _len) (((VarDataLenT *)(v))[0] = (VarDataLenT)(_len))
 

include/libs/executor/executor.h

@@ -211,7 +211,7 @@ const char* qExtractTbnameFromTask(qTaskInfo_t tinfo);
 
 void* qExtractReaderFromStreamScanner(void* scanner);
 
-int32_t qExtractStreamScanner(qTaskInfo_t tinfo, void** scanner);
+void qExtractStreamScanner(qTaskInfo_t tinfo, void** scanner);
 
 int32_t qSetStreamOperatorOptionForScanHistory(qTaskInfo_t tinfo);
 int32_t qStreamSourceScanParamForHistoryScanStep1(qTaskInfo_t tinfo, SVersionRange *pVerRange, STimeWindow* pWindow);

include/libs/executor/storageapi.h

@@ -195,7 +195,7 @@ typedef struct SStoreCacheReader {
   int32_t  (*openReader)(void *pVnode, int32_t type, void *pTableIdList, int32_t numOfTables, int32_t numOfCols,
                          SArray *pCidList, int32_t *pSlotIds, uint64_t suid, void **pReader, const char *idstr,
                          SArray *pFuncTypeList, SColumnInfo* pPkCol, int32_t numOfPks);
-  void    *(*closeReader)(void *pReader);
+  void     (*closeReader)(void *pReader);
   int32_t  (*retrieveRows)(void *pReader, SSDataBlock *pResBlock, const int32_t *slotIds, const int32_t *dstSlotIds,
                            SArray *pTableUidList);
   int32_t  (*reuseReader)(void *pReader, void *pTableIdList, int32_t numOfTables);
@@ -218,10 +218,10 @@ typedef struct SStoreTqReader {
   int32_t (*tqGetStreamExecProgress)();
 
   void (*tqReaderSetColIdList)();
-  int32_t (*tqReaderSetQueryTableList)();
+  void (*tqReaderSetQueryTableList)();
 
-  int32_t (*tqReaderAddTables)();
+  void (*tqReaderAddTables)();
-  int32_t (*tqReaderRemoveTables)();
+  void (*tqReaderRemoveTables)();
 
   void (*tqSetTablePrimaryKey)();
   bool (*tqGetTablePrimaryKey)();
@@ -239,8 +239,8 @@ typedef struct SStoreSnapshotFn {
   bool (*taosXGetTablePrimaryKey)(SSnapContext* ctx);
   void (*taosXSetTablePrimaryKey)(SSnapContext* ctx, int64_t uid);
   int32_t (*setForSnapShot)(SSnapContext* ctx, int64_t uid);
-  int32_t (*destroySnapshot)(SSnapContext* ctx);
+  void (*destroySnapshot)(SSnapContext* ctx);
-  SMetaTableInfo (*getMetaTableInfoFromSnapshot)(SSnapContext* ctx);
+  int32_t (*getMetaTableInfoFromSnapshot)(SSnapContext* ctx, SMetaTableInfo* info);
   int32_t (*getTableInfoFromSnapshot)(SSnapContext* ctx, void** pBuf, int32_t* contLen, int16_t* type, int64_t* uid);
 } SStoreSnapshotFn;
 

include/libs/function/taosudf.h

@@ -105,12 +105,14 @@ typedef uint16_t VarDataLenT;  // maxVarDataLen: 65535
 #define varDataLen(v)          ((VarDataLenT *)(v))[0]
 #define varDataVal(v)          ((char *)(v) + VARSTR_HEADER_SIZE)
 #define varDataTLen(v)         (sizeof(VarDataLenT) + varDataLen(v))
-#define varDataCopy(dst, v)    memcpy((dst), (void *)(v), varDataTLen(v))
+#define varDataCopy(dst, v)    (void)memcpy((dst), (void *)(v), varDataTLen(v))
 #define varDataLenByData(v)    (*(VarDataLenT *)(((char *)(v)) - VARSTR_HEADER_SIZE))
 #define varDataSetLen(v, _len) (((VarDataLenT *)(v))[0] = (VarDataLenT)(_len))
-#define IS_VAR_DATA_TYPE(t) \
+#define IS_VAR_DATA_TYPE(t)                                                                                 \
-  (((t) == TSDB_DATA_TYPE_VARCHAR) || ((t) == TSDB_DATA_TYPE_VARBINARY) || ((t) == TSDB_DATA_TYPE_NCHAR) || ((t) == TSDB_DATA_TYPE_JSON) || ((t) == TSDB_DATA_TYPE_GEOMETRY))
+  (((t) == TSDB_DATA_TYPE_VARCHAR) || ((t) == TSDB_DATA_TYPE_VARBINARY) || ((t) == TSDB_DATA_TYPE_NCHAR) || \
-#define IS_STR_DATA_TYPE(t) (((t) == TSDB_DATA_TYPE_VARCHAR) || ((t) == TSDB_DATA_TYPE_VARBINARY) || ((t) == TSDB_DATA_TYPE_NCHAR))
+   ((t) == TSDB_DATA_TYPE_JSON) || ((t) == TSDB_DATA_TYPE_GEOMETRY))
+#define IS_STR_DATA_TYPE(t) \
+  (((t) == TSDB_DATA_TYPE_VARCHAR) || ((t) == TSDB_DATA_TYPE_VARBINARY) || ((t) == TSDB_DATA_TYPE_NCHAR))
 
 static FORCE_INLINE char *udfColDataGetData(const SUdfColumn *pColumn, int32_t row) {
   if (IS_VAR_DATA_TYPE(pColumn->colMeta.type)) {
@@ -158,7 +160,7 @@ static FORCE_INLINE int32_t udfColEnsureCapacity(SUdfColumn *pColumn, int32_t ne
     }
     data->varLenCol.varOffsets = (int32_t *)tmp;
     data->varLenCol.varOffsetsLen = sizeof(int32_t) * allocCapacity;
-    memset(&data->varLenCol.varOffsets[existedRows], 0, sizeof(int32_t) * (allocCapacity - existedRows));
+    (void)memset(&data->varLenCol.varOffsets[existedRows], 0, sizeof(int32_t) * (allocCapacity - existedRows));
     // for payload, add data in udfColDataAppend
   } else {
     char *tmp = (char *)realloc(data->fixLenCol.nullBitmap, BitmapLen(allocCapacity));
@@ -166,11 +168,11 @@ static FORCE_INLINE int32_t udfColEnsureCapacity(SUdfColumn *pColumn, int32_t ne
       return TSDB_CODE_OUT_OF_MEMORY;
     }
     uint32_t extend = BitmapLen(allocCapacity) - BitmapLen(data->rowsAlloc);
-    memset(tmp + BitmapLen(data->rowsAlloc), 0, extend);
+    (void)memset(tmp + BitmapLen(data->rowsAlloc), 0, extend);
     data->fixLenCol.nullBitmap = tmp;
     data->fixLenCol.nullBitmapLen = BitmapLen(allocCapacity);
     int32_t oldLen = BitmapLen(existedRows);
-    memset(&data->fixLenCol.nullBitmap[oldLen], 0, BitmapLen(allocCapacity) - oldLen);
+    (void)memset(&data->fixLenCol.nullBitmap[oldLen], 0, BitmapLen(allocCapacity) - oldLen);
 
     if (meta->type == TSDB_DATA_TYPE_NULL) {
       return TSDB_CODE_SUCCESS;
@@ -198,7 +200,8 @@ static FORCE_INLINE void udfColDataSetNull(SUdfColumn *pColumn, int32_t row) {
     udfColDataSetNull_f(pColumn, row);
   }
   pColumn->hasNull = true;
-  pColumn->colData.numOfRows = ((int32_t)(row + 1) > pColumn->colData.numOfRows) ? (int32_t)(row + 1) : pColumn->colData.numOfRows;
+  pColumn->colData.numOfRows =
+      ((int32_t)(row + 1) > pColumn->colData.numOfRows) ? (int32_t)(row + 1) : pColumn->colData.numOfRows;
 }
 
 static FORCE_INLINE int32_t udfColDataSet(SUdfColumn *pColumn, uint32_t currentRow, const char *pData, bool isNull) {
@@ -211,7 +214,7 @@ static FORCE_INLINE int32_t udfColDataSet(SUdfColumn *pColumn, uint32_t currentR
   } else {
     if (!isVarCol) {
       udfColDataSetNotNull_f(pColumn, currentRow);
-      memcpy(data->fixLenCol.data + meta->bytes * currentRow, pData, meta->bytes);
+      (void)memcpy(data->fixLenCol.data + meta->bytes * currentRow, pData, meta->bytes);
     } else {
       int32_t dataLen = varDataTLen(pData);
       if (meta->type == TSDB_DATA_TYPE_JSON) {
@@ -249,7 +252,7 @@ static FORCE_INLINE int32_t udfColDataSet(SUdfColumn *pColumn, uint32_t currentR
       uint32_t len = data->varLenCol.payloadLen;
       data->varLenCol.varOffsets[currentRow] = len;
 
-      memcpy(data->varLenCol.payload + len, pData, dataLen);
+      (void)memcpy(data->varLenCol.payload + len, pData, dataLen);
       data->varLenCol.payloadLen += dataLen;
     }
   }
@@ -278,8 +281,8 @@ typedef enum EUdfFuncType { UDF_FUNC_TYPE_SCALAR = 1, UDF_FUNC_TYPE_AGG = 2 } EU
 
 typedef struct SScriptUdfInfo {
   const char *name;
-  int32_t version;
+  int32_t     version;
-  int64_t createdTime;
+  int64_t     createdTime;
 
   EUdfFuncType funcType;
   int8_t       scriptType;

include/libs/index/index.h

@@ -83,7 +83,7 @@ void indexMultiTermQueryDestroy(SIndexMultiTermQuery* pQuery);
  * @param type (input, single query type)
  * @return error code
  */
-int indexMultiTermQueryAdd(SIndexMultiTermQuery* pQuery, SIndexTerm* term, EIndexQueryType type);
+int32_t indexMultiTermQueryAdd(SIndexMultiTermQuery* pQuery, SIndexTerm* term, EIndexQueryType type);
 /*
  * open index
  * @param opt (input, index opt)
@@ -91,7 +91,7 @@ int indexMultiTermQueryAdd(SIndexMultiTermQuery* pQuery, SIndexTerm* term, EInde
  * @param index (output, index object)
  * @return error code
  */
-int indexOpen(SIndexOpts* opt, const char* path, SIndex** index);
+int32_t indexOpen(SIndexOpts* opt, const char* path, SIndex** index);
 /*
  * close index
  * @param index (input, index to be closed)
@@ -106,7 +106,7 @@ void indexClose(SIndex* index);
  * @param uid  (input, uid of terms)
  * @return error code
  */
-int indexPut(SIndex* index, SIndexMultiTerm* terms, uint64_t uid);
+int32_t indexPut(SIndex* index, SIndexMultiTerm* terms, uint64_t uid);
 /*
  * delete terms that meet query condition
  * @param index (input, index object)
@@ -114,7 +114,7 @@ int indexPut(SIndex* index, SIndexMultiTerm* terms, uint64_t uid);
  * @return error code
  */
 
-int indexDelete(SIndex* index, SIndexMultiTermQuery* query);
+int32_t indexDelete(SIndex* index, SIndexMultiTermQuery* query);
 /*
  * search index
  * @param index (input, index object)
@@ -122,7 +122,7 @@ int indexDelete(SIndex* index, SIndexMultiTermQuery* query);
  * @param result(output, query result)
  * @return error code
  */
-int indexSearch(SIndex* index, SIndexMultiTermQuery* query, SArray* result);
+int32_t indexSearch(SIndex* index, SIndexMultiTermQuery* query, SArray* result);
 /*
  * rebuild index
  * @param index (input, index object)
@@ -138,7 +138,7 @@ int indexSearch(SIndex* index, SIndexMultiTermQuery* query, SArray* result);
  * @param index (output, index json object)
  * @return error code
  */
-int indexJsonOpen(SIndexJsonOpts* opts, const char* path, SIndexJson** index);
+int32_t indexJsonOpen(SIndexJsonOpts* opts, const char* path, SIndexJson** index);
 /*
  * close index
  * @param index (input, index to be closed)
@@ -154,7 +154,7 @@ void indexJsonClose(SIndexJson* index);
  * @param uid  (input, uid of terms)
  * @return error code
  */
-int indexJsonPut(SIndexJson* index, SIndexJsonMultiTerm* terms, uint64_t uid);
+int32_t indexJsonPut(SIndexJson* index, SIndexJsonMultiTerm* terms, uint64_t uid);
 /*
  * search index
  * @param index (input, index object)
@@ -163,7 +163,7 @@ int indexJsonPut(SIndexJson* index, SIndexJsonMultiTerm* terms, uint64_t uid);
  * @return error code
  */
 
-int indexJsonSearch(SIndexJson* index, SIndexJsonMultiTermQuery* query, SArray* result);
+int32_t indexJsonSearch(SIndexJson* index, SIndexJsonMultiTermQuery* query, SArray* result);
 /*
  * @param
  * @param

include/libs/nodes/nodes.h

@@ -112,11 +112,11 @@ int64_t nodesMakeAllocatorWeakRef(int64_t allocatorId);
 int64_t nodesReleaseAllocatorWeakRef(int64_t allocatorId);
 void    nodesDestroyAllocator(int64_t allocatorId);
 
-SNode* nodesMakeNode(ENodeType type);
+int32_t nodesMakeNode(ENodeType type, SNode** ppNodeOut);
 void   nodesDestroyNode(SNode* pNode);
 void   nodesFree(void* p);
 
-SNodeList* nodesMakeList();
+int32_t    nodesMakeList(SNodeList** ppListOut);
 int32_t    nodesListAppend(SNodeList* pList, SNode* pNode);
 int32_t    nodesListStrictAppend(SNodeList* pList, SNode* pNode);
 int32_t    nodesListMakeAppend(SNodeList** pList, SNode* pNode);
@@ -156,8 +156,8 @@ bool nodeListNodeEqual(const SNodeList* a, const SNode* b);
 
 bool nodesMatchNode(const SNode* pSub, const SNode* pNode);
 
-SNode*     nodesCloneNode(const SNode* pNode);
+int32_t nodesCloneNode(const SNode* pNode, SNode** ppNodeOut);
-SNodeList* nodesCloneList(const SNodeList* pList);
+int32_t nodesCloneList(const SNodeList* pList, SNodeList** ppList);
 
 const char* nodesNodeName(ENodeType type);
 int32_t     nodesNodeToString(const SNode* pNode, bool format, char** pStr, int32_t* pLen);

include/libs/nodes/querynodes.h

@@ -636,9 +636,9 @@ void*   nodesGetValueFromNode(SValueNode* pNode);
 int32_t nodesSetValueNodeValue(SValueNode* pNode, void* value);
 char*   nodesGetStrValueFromNode(SValueNode* pNode);
 void    nodesValueNodeToVariant(const SValueNode* pNode, SVariant* pVal);
-SValueNode* nodesMakeValueNodeFromString(char* literal);
+int32_t nodesMakeValueNodeFromString(char* literal, SValueNode** ppValNode);
-SValueNode* nodesMakeValueNodeFromBool(bool b);
+int32_t nodesMakeValueNodeFromBool(bool b, SValueNode** ppValNode);
-SNode* nodesMakeValueNodeFromInt32(int32_t value);
+int32_t nodesMakeValueNodeFromInt32(int32_t value, SNode** ppNode);
 
 char*   nodesGetFillModeString(EFillMode mode);
 int32_t nodesMergeConds(SNode** pDst, SNodeList** pSrc);

include/libs/parser/parser.h

@@ -118,6 +118,7 @@ void qDestroyQuery(SQuery* pQueryNode);
 
 int32_t qExtractResultSchema(const SNode* pRoot, int32_t* numOfCols, SSchema** pSchema);
 int32_t qSetSTableIdForRsma(SNode* pStmt, int64_t uid);
+int32_t qInitKeywordsTable();
 void    qCleanupKeywordsTable();
 
 int32_t     qAppendStmtTableOutput(SQuery* pQuery, SHashObj* pAllVgHash, STableColsData* pTbData, STableDataCxt* pTbCtx, SStbInterlaceInfo* pBuildInfo);

include/libs/tfs/tfs.h

@@ -44,9 +44,9 @@ typedef struct {
  *
  * @param pCfg Config of the fs.
  * @param ndisk Length of the config.
- * @return STfs* The fs object.
+ * @param ppTfs The fs object.
  */
-STfs *tfsOpen(SDiskCfg *pCfg, int32_t ndisk);
+int32_t tfsOpen(SDiskCfg *pCfg, int32_t ndisk, STfs **ppTfs);
 
 /**
  * @brief Close a fs.
@@ -275,7 +275,7 @@ int32_t tfsCopyFile(const STfsFile *pFile1, const STfsFile *pFile2);
  * @param rname The rel name of file.
  * @return STfsDir* The dir object.
  */
-STfsDir *tfsOpendir(STfs *pTfs, const char *rname);
+int32_t tfsOpendir(STfs *pTfs, const char *rname, STfsDir **ppDir);
 
 /**
  * @brief Get a file from dir and move to next pos.

include/libs/wal/wal.h

@@ -12,6 +12,7 @@
  * You should have received a copy of the GNU Affero General Public License
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
+
 #ifndef _TD_WAL_H_
 #define _TD_WAL_H_
 
@@ -20,19 +21,11 @@
 #include "tdef.h"
 #include "tlog.h"
 #include "tmsg.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-// clang-format off
-#define wFatal(...) { if (wDebugFlag & DEBUG_FATAL) { taosPrintLog("WAL FATAL ", DEBUG_FATAL, 255,        __VA_ARGS__); }}
-#define wError(...) { if (wDebugFlag & DEBUG_ERROR) { taosPrintLog("WAL ERROR ", DEBUG_ERROR, 255,        __VA_ARGS__); }}
-#define wWarn(...)  { if (wDebugFlag & DEBUG_WARN)  { taosPrintLog("WAL WARN ",  DEBUG_WARN, 255,         __VA_ARGS__); }}
-#define wInfo(...)  { if (wDebugFlag & DEBUG_INFO)  { taosPrintLog("WAL ",       DEBUG_INFO, 255,         __VA_ARGS__); }}
-#define wDebug(...) { if (wDebugFlag & DEBUG_DEBUG) { taosPrintLog("WAL ",       DEBUG_DEBUG, wDebugFlag, __VA_ARGS__); }}
-#define wTrace(...) { if (wDebugFlag & DEBUG_TRACE) { taosPrintLog("WAL ",       DEBUG_TRACE, wDebugFlag, __VA_ARGS__); }}
-// clang-format on
-
 #define WAL_PROTO_VER     0
 #define WAL_NOSUFFIX_LEN  20
 #define WAL_SUFFIX_AT     (WAL_NOSUFFIX_LEN + 1)
@@ -131,8 +124,7 @@ typedef struct SWal {
 typedef struct {
   int64_t refId;
   int64_t refVer;
-  //  int64_t refFile;
+  SWal   *pWal;
-  SWal *pWal;
 } SWalRef;
 
 typedef struct {
@@ -143,10 +135,8 @@ typedef struct {
   int8_t enableRef;
 } SWalFilterCond;
 
-typedef struct SWalReader SWalReader;
-
 // todo hide this struct
-struct SWalReader {
+typedef struct SWalReader {
   SWal     *pWal;
   int64_t   readerId;
   TdFilePtr pLogFile;
@@ -159,7 +149,7 @@ struct SWalReader {
   TdThreadMutex  mutex;
   SWalFilterCond cond;
   SWalCkHead    *pHead;
-};
+} SWalReader;
 
 // module initialization
 int32_t walInit();
@@ -172,17 +162,9 @@ int32_t walPersist(SWal *);
 void    walClose(SWal *);
 
 // write interfaces
-
 // By assigning index by the caller, wal gurantees linearizability
-int32_t walWrite(SWal *, int64_t index, tmsg_t msgType, const void *body, int32_t bodyLen);
+int32_t walAppendLog(SWal *, int64_t index, tmsg_t msgType, SWalSyncInfo syncMeta, const void *body, int32_t bodyLen);
-int32_t walWriteWithSyncInfo(SWal *, int64_t index, tmsg_t msgType, SWalSyncInfo syncMeta, const void *body,
+int32_t walFsync(SWal *, bool force);
-                             int32_t bodyLen);
-
-// Assign version automatically and return to caller,
-// -1 will be returned for failed writes
-int64_t walAppendLog(SWal *, int64_t index, tmsg_t msgType, SWalSyncInfo syncMeta, const void *body, int32_t bodyLen);
-
-void walFsync(SWal *, bool force);
 
 // apis for lifecycle management
 int32_t walCommit(SWal *, int64_t ver);
@@ -191,17 +173,13 @@ int32_t walRollback(SWal *, int64_t ver);
 int32_t walBeginSnapshot(SWal *, int64_t ver, int64_t logRetention);
 int32_t walEndSnapshot(SWal *);
 int32_t walRestoreFromSnapshot(SWal *, int64_t ver);
-// for tq
 int32_t walApplyVer(SWal *, int64_t ver);
 
-// int32_t  walDataCorrupted(SWal*);
-
 // wal reader
 SWalReader *walOpenReader(SWal *, SWalFilterCond *pCond, int64_t id);
 void        walCloseReader(SWalReader *pRead);
 void        walReadReset(SWalReader *pReader);
 int32_t     walReadVer(SWalReader *pRead, int64_t ver);
-void        decryptBody(SWalCfg *cfg, SWalCkHead *pHead, int32_t plainBodyLen, const char *func);
 int32_t     walReaderSeekVer(SWalReader *pRead, int64_t ver);
 int32_t     walNextValidMsg(SWalReader *pRead);
 int64_t     walReaderGetCurrentVer(const SWalReader *pReader);
@@ -216,12 +194,11 @@ int32_t walFetchHead(SWalReader *pRead, int64_t ver);
 int32_t walFetchBody(SWalReader *pRead);
 int32_t walSkipFetchBody(SWalReader *pRead);
 
-void walRefFirstVer(SWal *, SWalRef *);
-void walRefLastVer(SWal *, SWalRef *);
-
 SWalRef *walOpenRef(SWal *);
 void     walCloseRef(SWal *pWal, int64_t refId);
 int32_t  walSetRefVer(SWalRef *, int64_t ver);
+void     walRefFirstVer(SWal *, SWalRef *);
+void     walRefLastVer(SWal *, SWalRef *);
 
 // helper function for raft
 bool walLogExist(SWal *, int64_t ver);

include/os/osDef.h

@@ -65,7 +65,7 @@ typedef int (*__compar_fn_t)(const void *, const void *);
 #endif
 #define ssize_t int
 #define _SSIZE_T_
-#define bzero(ptr, size) memset((ptr), 0, (size))
+#define bzero(ptr, size) (void)memset((ptr), 0, (size))
 #define strcasecmp       _stricmp
 #define strncasecmp      _strnicmp
 #define wcsncasecmp      _wcsnicmp

include/os/osFile.h

@@ -114,8 +114,6 @@ int64_t taosFSendFile(TdFilePtr pFileOut, TdFilePtr pFileIn, int64_t *offset, in
 
 bool taosValidFile(TdFilePtr pFile);
 
-int32_t taosGetErrorFile(TdFilePtr pFile);
-
 int32_t taosCompressFile(char *srcFileName, char *destFileName);
 
 int32_t taosSetFileHandlesLimit();

include/os/osLocale.h

@@ -30,7 +30,7 @@ extern "C" {
 
 char *taosCharsetReplace(char *charsetstr);
 void  taosGetSystemLocale(char *outLocale, char *outCharset);
-void  taosSetSystemLocale(const char *inLocale, const char *inCharSet);
+int32_t  taosSetSystemLocale(const char *inLocale, const char *inCharSet);
 
 #ifdef __cplusplus
 }

include/os/osMemory.h

@@ -65,6 +65,16 @@ void   *taosMemoryMallocAlign(uint32_t alignment, int64_t size);
     }                              \
   } while (0)
 
+#define TAOS_MEMORY_REALLOC(ptr, len)          \
+  do {                                         \
+    void *tmp = taosMemoryRealloc(ptr, (len)); \
+    if (tmp) {                                 \
+      (ptr) = tmp;                             \
+    } else {                                   \
+      taosMemoryFreeClear(ptr);                \
+    }                                          \
+  } while (0)
+
 #ifdef __cplusplus
 }
 #endif

include/os/osSignal.h

@@ -49,11 +49,14 @@ typedef BOOL (*FSignalHandler)(DWORD fdwCtrlType);
 #else
 typedef void (*FSignalHandler)(int32_t signum, void *sigInfo, void *context);
 #endif
-void taosSetSignal(int32_t signum, FSignalHandler sigfp);
-void taosIgnSignal(int32_t signum);
-void taosDflSignal(int32_t signum);
 
-void taosKillChildOnParentStopped();
+typedef void (*sighandler_t)(int);
+
+int32_t taosSetSignal(int32_t signum, FSignalHandler sigfp);
+int32_t taosIgnSignal(int32_t signum);
+int32_t taosDflSignal(int32_t signum);
+
+int32_t taosKillChildOnParentStopped();
 
 #ifdef __cplusplus
 }

include/os/osSocket.h

@@ -159,13 +159,12 @@ TdSocketPtr       taosAcceptTcpConnectSocket(TdSocketServerPtr pServerSocket, st
 
 int32_t taosGetSocketName(TdSocketPtr pSocket, struct sockaddr *destAddr, int *addrLen);
 
-void        taosBlockSIGPIPE();
+int32_t     taosBlockSIGPIPE();
-uint32_t    taosGetIpv4FromFqdn(const char *);
+int32_t     taosGetIpv4FromFqdn(const char *fqdn, uint32_t* ip);
 int32_t     taosGetFqdn(char *);
 void        tinet_ntoa(char *ipstr, uint32_t ip);
 uint32_t    ip2uint(const char *const ip_addr);
-void        taosIgnSIGPIPE();
+int32_t     taosIgnSIGPIPE();
-void        taosSetMaskSIGPIPE();
 uint32_t    taosInetAddr(const char *ipAddr);
 const char *taosInetNtoa(struct in_addr ipInt, char *dstStr, int32_t len);
 

include/os/osString.h

@@ -75,7 +75,7 @@ int32_t taosUcs4ToMbs(TdUcs4 *ucs4, int32_t ucs4_max_len, char *mbs);
 int32_t taosUcs4ToMbsEx(TdUcs4 *ucs4, int32_t ucs4_max_len, char *mbs, iconv_t conv);
 bool    taosMbsToUcs4(const char *mbs, size_t mbs_len, TdUcs4 *ucs4, int32_t ucs4_max_len, int32_t *len);
 int32_t tasoUcs4Compare(TdUcs4 *f1_ucs4, TdUcs4 *f2_ucs4, int32_t bytes);
-TdUcs4 *tasoUcs4Copy(TdUcs4 *target_ucs4, TdUcs4 *source_ucs4, int32_t len_ucs4);
+int32_t tasoUcs4Copy(TdUcs4 *target_ucs4, TdUcs4 *source_ucs4, int32_t len_ucs4);
 bool    taosValidateEncodec(const char *encodec);
 int32_t taosHexEncode(const unsigned char *src, char *dst, int32_t len);
 int32_t taosHexDecode(const char *src, char *dst, int32_t len);

include/os/osSystem.h

@@ -44,7 +44,7 @@ int64_t taosGetLineCmd(TdCmdPtr pCmd, char **__restrict ptrBuf);
 
 int32_t taosEOFCmd(TdCmdPtr pCmd);
 
-int64_t taosCloseCmd(TdCmdPtr *ppCmd);
+void    taosCloseCmd(TdCmdPtr *ppCmd);
 
 void *taosLoadDll(const char *filename);
 
@@ -54,11 +54,11 @@ void taosCloseDll(void *handle);
 
 int32_t taosSetConsoleEcho(bool on);
 
-void taosSetTerminalMode();
+int32_t taosSetTerminalMode();
 
 int32_t taosGetOldTerminalMode();
 
-void taosResetTerminalMode();
+int32_t taosResetTerminalMode();
 
 #define STACKSIZE 100
 

include/util/tRealloc.h

@@ -41,7 +41,7 @@ static FORCE_INLINE int32_t tRealloc(uint8_t **ppBuf, int64_t size) {
 
   pBuf = (uint8_t *)taosMemoryRealloc(pBuf, bsize + sizeof(int64_t));
   if (pBuf == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     goto _exit;
   }
 

include/util/taoserror.h

@@ -198,7 +198,8 @@ int32_t  taosGetErrSize();
 #define TSDB_CODE_TSC_ENCODE_PARAM_ERROR        TAOS_DEF_ERROR_CODE(0, 0X0231)
 #define TSDB_CODE_TSC_ENCODE_PARAM_NULL         TAOS_DEF_ERROR_CODE(0, 0X0232)
 #define TSDB_CODE_TSC_COMPRESS_PARAM_ERROR      TAOS_DEF_ERROR_CODE(0, 0X0233)
-#define TSDB_CODE_TSC_COMPRESS_LEVEL_ERROR TAOS_DEF_ERROR_CODE(0, 0X0234)
+#define TSDB_CODE_TSC_COMPRESS_LEVEL_ERROR      TAOS_DEF_ERROR_CODE(0, 0X0234)
+#define TSDB_CODE_TSC_FAIL_GENERATE_JSON        TAOS_DEF_ERROR_CODE(0, 0X0235)
 #define TSDB_CODE_TSC_INTERNAL_ERROR            TAOS_DEF_ERROR_CODE(0, 0X02FF)
 
 // mnode-common
@@ -668,8 +669,16 @@ int32_t  taosGetErrSize();
 #define TSDB_CODE_SYN_BUFFER_FULL               TAOS_DEF_ERROR_CODE(0, 0x0916)
 #define TSDB_CODE_SYN_WRITE_STALL               TAOS_DEF_ERROR_CODE(0, 0x0917)
 #define TSDB_CODE_SYN_NEGOTIATION_WIN_FULL      TAOS_DEF_ERROR_CODE(0, 0x0918)
+#define TSDB_CODE_SYN_WRONG_TERM                TAOS_DEF_ERROR_CODE(0, 0x0919)
+#define TSDB_CODE_SYN_WRONG_FSM_STATE           TAOS_DEF_ERROR_CODE(0, 0x091A)
+#define TSDB_CODE_SYN_WRONG_SYNC_STATE          TAOS_DEF_ERROR_CODE(0, 0x091B)
+#define TSDB_CODE_SYN_WRONG_REF                 TAOS_DEF_ERROR_CODE(0, 0x091C)
+#define TSDB_CODE_SYN_INVALID_ID                TAOS_DEF_ERROR_CODE(0, 0x091D)
+#define TSDB_CODE_SYN_RETURN_VALUE_NULL         TAOS_DEF_ERROR_CODE(0, 0x091E)
+#define TSDB_CODE_SYN_WRONG_ROLE                TAOS_DEF_ERROR_CODE(0, 0x091F)
 #define TSDB_CODE_SYN_INTERNAL_ERROR            TAOS_DEF_ERROR_CODE(0, 0x09FF)
 
+
 // tq
 #define TSDB_CODE_TQ_INVALID_CONFIG             TAOS_DEF_ERROR_CODE(0, 0x0A00)
 #define TSDB_CODE_TQ_INIT_FAILED                TAOS_DEF_ERROR_CODE(0, 0x0A01)

include/util/tarray2.h

@@ -55,7 +55,7 @@ static FORCE_INLINE int32_t tarray2_make_room(void *arr, int32_t expSize, int32_
     capacity <<= 1;
   }
   void *p = taosMemoryRealloc(a->data, capacity * eleSize);
-  if (p == NULL) return TSDB_CODE_OUT_OF_MEMORY;
+  if (p == NULL) return terrno;
   a->capacity = capacity;
   a->data = p;
   return 0;
@@ -71,9 +71,9 @@ static FORCE_INLINE int32_t tarray2InsertBatch(void *arr, int32_t idx, const voi
   }
   if (ret == 0) {
     if (idx < a->size) {
-      memmove(a->data + (idx + numEle) * eleSize, a->data + idx * eleSize, (a->size - idx) * eleSize);
+      (void)memmove(a->data + (idx + numEle) * eleSize, a->data + idx * eleSize, (a->size - idx) * eleSize);
     }
-    memcpy(a->data + idx * eleSize, elePtr, numEle * eleSize);
+    (void)memcpy(a->data + idx * eleSize, elePtr, numEle * eleSize);
     a->size += numEle;
   }
   return ret;
@@ -145,18 +145,18 @@ static FORCE_INLINE int32_t tarray2SortInsert(void *arr, const void *elePtr, int
 #define TARRAY2_SORT_INSERT(a, e, cmp)    tarray2SortInsert(a, &(e), sizeof(((a)->data[0])), (__compar_fn_t)cmp)
 #define TARRAY2_SORT_INSERT_P(a, ep, cmp) tarray2SortInsert(a, ep, sizeof(((a)->data[0])), (__compar_fn_t)cmp)
 
-#define TARRAY2_REMOVE(a, idx, cb)                                                                       \
+#define TARRAY2_REMOVE(a, idx, cb)                                                                             \
-  do {                                                                                                   \
+  do {                                                                                                         \
-    if ((idx) < (a)->size) {                                                                             \
+    if ((idx) < (a)->size) {                                                                                   \
-      if (cb) {                                                                                          \
+      if (cb) {                                                                                                \
-        TArray2Cb cb_ = (TArray2Cb)(cb);                                                                 \
+        TArray2Cb cb_ = (TArray2Cb)(cb);                                                                       \
-        cb_((a)->data + (idx));                                                                          \
+        cb_((a)->data + (idx));                                                                                \
-      }                                                                                                  \
+      }                                                                                                        \
-      if ((idx) < (a)->size - 1) {                                                                       \
+      if ((idx) < (a)->size - 1) {                                                                             \
-        memmove((a)->data + (idx), (a)->data + (idx) + 1, sizeof((*(a)->data)) * ((a)->size - (idx)-1)); \
+        (void)memmove((a)->data + (idx), (a)->data + (idx) + 1, sizeof((*(a)->data)) * ((a)->size - (idx)-1)); \
-      }                                                                                                  \
+      }                                                                                                        \
-      (a)->size--;                                                                                       \
+      (a)->size--;                                                                                             \
-    }                                                                                                    \
+    }                                                                                                          \
   } while (0)
 
 #define TARRAY2_FOREACH(a, e)         for (int32_t __i = 0; __i < (a)->size && ((e) = (a)->data[__i], 1); __i++)

include/util/tbase58.h

@@ -25,8 +25,8 @@ extern "C" {
 #define TBASE_MAX_ILEN 4096
 #define TBASE_MAX_OLEN 5653
 
-uint8_t *base58_decode(const char *value, size_t inlen, int32_t *outlen);
+int32_t base58_decode(const char *value, size_t inlen, int32_t *outlen, uint8_t **result);
-char    *base58_encode(const uint8_t *value, int32_t vlen);
+int32_t base58_encode(const uint8_t *value, int32_t vlen, char **result);
 
 #ifdef __cplusplus
 }

include/util/tbase64.h

@@ -22,8 +22,8 @@
 extern "C" {
 #endif
 
-uint8_t *base64_decode(const char *value, int32_t inlen, int32_t *outlen);
+int32_t base64_decode(const char *value, int32_t inlen, int32_t *outlen, uint8_t **result);
-char    *base64_encode(const uint8_t *value, int32_t vlen);
+int32_t base64_encode(const uint8_t *value, int32_t vlen, char **result);
 
 #ifdef __cplusplus
 }

include/util/tcoding.h

@@ -79,7 +79,7 @@ static FORCE_INLINE void *taosDecodeFixedBool(const void *buf, bool *value) {
 static FORCE_INLINE int32_t taosEncodeFixedU16(void **buf, uint16_t value) {
   if (buf != NULL) {
     if (IS_LITTLE_ENDIAN()) {
-      memcpy(*buf, &value, sizeof(value));
+      TAOS_MEMCPY(*buf, &value, sizeof(value));
     } else {
       ((uint8_t *)(*buf))[0] = value & 0xff;
       ((uint8_t *)(*buf))[1] = (value >> 8) & 0xff;
@@ -92,7 +92,7 @@ static FORCE_INLINE int32_t taosEncodeFixedU16(void **buf, uint16_t value) {
 
 static FORCE_INLINE void *taosDecodeFixedU16(const void *buf, uint16_t *value) {
   if (IS_LITTLE_ENDIAN()) {
-    memcpy(value, buf, sizeof(*value));
+    TAOS_MEMCPY(value, buf, sizeof(*value));
   } else {
     ((uint8_t *)value)[1] = ((uint8_t *)buf)[0];
     ((uint8_t *)value)[0] = ((uint8_t *)buf)[1];
@@ -117,7 +117,7 @@ static FORCE_INLINE void *taosDecodeFixedI16(const void *buf, int16_t *value) {
 static FORCE_INLINE int32_t taosEncodeFixedU32(void **buf, uint32_t value) {
   if (buf != NULL) {
     if (IS_LITTLE_ENDIAN()) {
-      memcpy(*buf, &value, sizeof(value));
+      TAOS_MEMCPY(*buf, &value, sizeof(value));
     } else {
       ((uint8_t *)(*buf))[0] = value & 0xff;
       ((uint8_t *)(*buf))[1] = (value >> 8) & 0xff;
@@ -132,7 +132,7 @@ static FORCE_INLINE int32_t taosEncodeFixedU32(void **buf, uint32_t value) {
 
 static FORCE_INLINE void *taosDecodeFixedU32(const void *buf, uint32_t *value) {
   if (IS_LITTLE_ENDIAN()) {
-    memcpy(value, buf, sizeof(*value));
+    TAOS_MEMCPY(value, buf, sizeof(*value));
   } else {
     ((uint8_t *)value)[3] = ((uint8_t *)buf)[0];
     ((uint8_t *)value)[2] = ((uint8_t *)buf)[1];
@@ -159,7 +159,7 @@ static FORCE_INLINE void *taosDecodeFixedI32(const void *buf, int32_t *value) {
 static FORCE_INLINE int32_t taosEncodeFixedU64(void **buf, uint64_t value) {
   if (buf != NULL) {
     if (IS_LITTLE_ENDIAN()) {
-      memcpy(*buf, &value, sizeof(value));
+      TAOS_MEMCPY(*buf, &value, sizeof(value));
     } else {
       ((uint8_t *)(*buf))[0] = value & 0xff;
       ((uint8_t *)(*buf))[1] = (value >> 8) & 0xff;
@@ -179,7 +179,7 @@ static FORCE_INLINE int32_t taosEncodeFixedU64(void **buf, uint64_t value) {
 
 static FORCE_INLINE void *taosDecodeFixedU64(const void *buf, uint64_t *value) {
   if (IS_LITTLE_ENDIAN()) {
-    memcpy(value, buf, sizeof(*value));
+    TAOS_MEMCPY(value, buf, sizeof(*value));
   } else {
     ((uint8_t *)value)[7] = ((uint8_t *)buf)[0];
     ((uint8_t *)value)[6] = ((uint8_t *)buf)[1];
@@ -357,7 +357,7 @@ static FORCE_INLINE int32_t taosEncodeString(void **buf, const char *value) {
 
   tlen += taosEncodeVariantU64(buf, size);
   if (buf != NULL) {
-    memcpy(*buf, value, size);
+    TAOS_MEMCPY(*buf, value, size);
     *buf = POINTER_SHIFT(*buf, size);
   }
   tlen += (int32_t)size;
@@ -372,7 +372,7 @@ static FORCE_INLINE void *taosDecodeString(const void *buf, char **value) {
   *value = (char *)taosMemoryMalloc((size_t)size + 1);
 
   if (*value == NULL) return NULL;
-  memcpy(*value, buf, (size_t)size);
+  TAOS_MEMCPY(*value, buf, (size_t)size);
 
   (*value)[size] = '\0';
 
@@ -383,7 +383,7 @@ static FORCE_INLINE void *taosDecodeStringTo(const void *buf, char *value) {
   uint64_t size = 0;
 
   buf = taosDecodeVariantU64(buf, &size);
-  memcpy(value, buf, (size_t)size);
+  TAOS_MEMCPY(value, buf, (size_t)size);
 
   value[size] = '\0';
 
@@ -395,7 +395,7 @@ static FORCE_INLINE int32_t taosEncodeBinary(void **buf, const void *value, int3
   int32_t tlen = 0;
 
   if (buf != NULL) {
-    memcpy(*buf, value, valueLen);
+    TAOS_MEMCPY(*buf, value, valueLen);
     *buf = POINTER_SHIFT(*buf, valueLen);
   }
   tlen += (int32_t)valueLen;
@@ -406,13 +406,13 @@ static FORCE_INLINE int32_t taosEncodeBinary(void **buf, const void *value, int3
 static FORCE_INLINE void *taosDecodeBinary(const void *buf, void **value, int32_t valueLen) {
   *value = taosMemoryMalloc((size_t)valueLen);
   if (*value == NULL) return NULL;
-  memcpy(*value, buf, (size_t)valueLen);
+  TAOS_MEMCPY(*value, buf, (size_t)valueLen);
 
   return POINTER_SHIFT(buf, valueLen);
 }
 
 static FORCE_INLINE void *taosDecodeBinaryTo(const void *buf, void *value, int32_t valueLen) {
-  memcpy(value, buf, (size_t)valueLen);
+  TAOS_MEMCPY(value, buf, (size_t)valueLen);
   return POINTER_SHIFT(buf, valueLen);
 }
 

include/util/tconfig.h

@@ -101,7 +101,7 @@ typedef struct {
 typedef struct SConfig SConfig;
 typedef struct SConfigIter SConfigIter;
 
-SConfig     *cfgInit();
+int32_t      cfgInit(SConfig **ppCfg);
 int32_t      cfgLoad(SConfig *pCfg, ECfgSrcType cfgType, const void *sourceStr);
 int32_t      cfgLoadFromArray(SConfig *pCfg, SArray *pArgs);  // SConfigPair
 void         cfgCleanup(SConfig *pCfg);
@@ -110,7 +110,7 @@ SConfigItem *cfgGetItem(SConfig *pCfg, const char *pName);
 int32_t      cfgSetItem(SConfig *pCfg, const char *name, const char *value, ECfgSrcType stype, bool lock);
 int32_t      cfgCheckRangeForDynUpdate(SConfig *pCfg, const char *name, const char *pVal, bool isServer);
 
-SConfigIter *cfgCreateIter(SConfig *pConf);
+int32_t      cfgCreateIter(SConfig *pConf, SConfigIter **ppIter);
 SConfigItem *cfgNextIter(SConfigIter *pIter);
 void         cfgDestroyIter(SConfigIter *pIter);
 void         cfgLock(SConfig *pCfg);
@@ -131,8 +131,8 @@ int32_t cfgAddTimezone(SConfig *pCfg, const char *name, const char *defaultVal,
 const char *cfgStypeStr(ECfgSrcType type);
 const char *cfgDtypeStr(ECfgDataType type);
 
-void cfgDumpItemValue(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen);
+int32_t cfgDumpItemValue(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen);
-void cfgDumpItemScope(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen);
+int32_t cfgDumpItemScope(SConfigItem *pItem, char *buf, int32_t bufSize, int32_t *pLen);
 
 void cfgDumpCfg(SConfig *pCfg, bool tsc, bool dump);
 void cfgDumpCfgS3(SConfig *pCfg, bool tsc, bool dump);

include/util/tdef.h

@@ -131,10 +131,10 @@ static const int64_t TICK_PER_SECOND[] = {
                  : ((precision) == TSDB_TIME_PRECISION_MICRO ? 1000000LL : 1000000000LL)))
 
 #define T_MEMBER_SIZE(type, member) sizeof(((type *)0)->member)
-#define T_APPEND_MEMBER(dst, ptr, type, member)                                     \
+#define T_APPEND_MEMBER(dst, ptr, type, member)                                           \
-  do {                                                                              \
+  do {                                                                                    \
-    memcpy((void *)(dst), (void *)(&((ptr)->member)), T_MEMBER_SIZE(type, member)); \
+    (void)memcpy((void *)(dst), (void *)(&((ptr)->member)), T_MEMBER_SIZE(type, member)); \
-    dst = (void *)((char *)(dst) + T_MEMBER_SIZE(type, member));                    \
+    dst = (void *)((char *)(dst) + T_MEMBER_SIZE(type, member));                          \
   } while (0)
 #define T_READ_MEMBER(src, type, target)          \
   do {                                            \
@@ -556,7 +556,7 @@ typedef struct {
   char name[TSDB_LOG_VAR_LEN];
 } SLogVar;
 
-#define TMQ_SEPARATOR ":"
+#define TMQ_SEPARATOR      ":"
 #define TMQ_SEPARATOR_CHAR ':'
 
 enum {

include/util/tdigest.h

@@ -64,10 +64,10 @@ typedef struct TDigest {
 } TDigest;
 
 TDigest *tdigestNewFrom(void *pBuf, int32_t compression);
-void     tdigestAdd(TDigest *t, double x, int64_t w);
+int32_t  tdigestAdd(TDigest *t, double x, int64_t w);
-void     tdigestMerge(TDigest *t1, TDigest *t2);
+int32_t  tdigestMerge(TDigest *t1, TDigest *t2);
 double   tdigestQuantile(TDigest *t, double q);
-void     tdigestCompress(TDigest *t);
+int32_t  tdigestCompress(TDigest *t);
 void     tdigestFreeFrom(TDigest *t);
 void     tdigestAutoFill(TDigest *t, int32_t compression);
 

include/util/tencode.h

@@ -127,7 +127,7 @@ static FORCE_INLINE int32_t tEncodeFixed(SEncoder* pCoder, const void* val, uint
     if (pCoder->pos + size > pCoder->size) {
       TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
     }
-    memcpy(pCoder->data + pCoder->pos, val, size);
+    TAOS_MEMCPY(pCoder->data + pCoder->pos, val, size);
   }
 
   pCoder->pos += size;
@@ -212,7 +212,7 @@ static FORCE_INLINE int32_t tEncodeBinary(SEncoder* pCoder, const uint8_t* val,
       if (pCoder->pos + len > pCoder->size) {
         TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
       }
-      memcpy(pCoder->data + pCoder->pos, val, len);
+      TAOS_MEMCPY(pCoder->data + pCoder->pos, val, len);
     }
 
     pCoder->pos += len;
@@ -233,7 +233,7 @@ static int32_t tDecodeFixed(SDecoder* pCoder, void* val, uint32_t size) {
   if (pCoder->pos + size > pCoder->size) {
     TAOS_RETURN(TSDB_CODE_OUT_OF_RANGE);
   } else if (val) {
-    memcpy(val, pCoder->data + pCoder->pos, size);
+    TAOS_MEMCPY(val, pCoder->data + pCoder->pos, size);
   }
   pCoder->pos += size;
   return 0;
@@ -427,7 +427,7 @@ static int32_t tDecodeCStrTo(SDecoder* pCoder, char* val) {
   uint32_t len;
   TAOS_CHECK_RETURN(tDecodeCStrAndLen(pCoder, &pStr, &len));
 
-  memcpy(val, pStr, len + 1);
+  TAOS_MEMCPY(val, pStr, len + 1);
   return 0;
 }
 
@@ -446,7 +446,7 @@ static FORCE_INLINE int32_t tDecodeBinaryAlloc(SDecoder* pCoder, void** val, uin
       TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
     }
 
-    memcpy(*val, pCoder->data + pCoder->pos, length);
+    TAOS_MEMCPY(*val, pCoder->data + pCoder->pos, length);
 
     pCoder->pos += length;
   } else {
@@ -468,7 +468,7 @@ static FORCE_INLINE int32_t tDecodeBinaryAlloc32(SDecoder* pCoder, void** val, u
     if (*val == NULL) {
       TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
     }
-    memcpy(*val, pCoder->data + pCoder->pos, length);
+    TAOS_MEMCPY(*val, pCoder->data + pCoder->pos, length);
 
     pCoder->pos += length;
   } else {
@@ -757,7 +757,7 @@ static FORCE_INLINE int32_t tPutBinary(uint8_t* p, uint8_t* pData, uint32_t nDat
   int n = 0;
 
   n += tPutU32v(p ? p + n : p, nData);
-  if (p) memcpy(p + n, pData, nData);
+  if (p) TAOS_MEMCPY(p + n, pData, nData);
   n += nData;
 
   return n;

include/util/tpagedbuf.h

@@ -156,7 +156,7 @@ void setBufPageCompressOnDisk(SDiskbasedBuf* pBuf, bool comp);
  * @param pBuf
  * @param pageId
  */
-void dBufSetBufPageRecycled(SDiskbasedBuf* pBuf, void* pPage);
+int32_t dBufSetBufPageRecycled(SDiskbasedBuf* pBuf, void* pPage);
 
 /**
  * Print the statistics when closing this buffer

include/util/tutil.h

@@ -64,7 +64,7 @@ static FORCE_INLINE void taosEncryptPass(uint8_t *inBuf, size_t inLen, char *tar
   tMD5Init(&context);
   tMD5Update(&context, inBuf, (uint32_t)inLen);
   tMD5Final(&context);
-  memcpy(target, context.digest, tListLen(context.digest));
+  (void)memcpy(target, context.digest, tListLen(context.digest));
 }
 
 static FORCE_INLINE void taosEncryptPass_c(uint8_t *inBuf, size_t len, char *target) {
@@ -75,11 +75,11 @@ static FORCE_INLINE void taosEncryptPass_c(uint8_t *inBuf, size_t len, char *tar
   char buf[TSDB_PASSWORD_LEN + 1];
 
   buf[TSDB_PASSWORD_LEN] = 0;
-  sprintf(buf, "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", context.digest[0], context.digest[1],
+  (void)sprintf(buf, "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", context.digest[0], context.digest[1],
           context.digest[2], context.digest[3], context.digest[4], context.digest[5], context.digest[6],
           context.digest[7], context.digest[8], context.digest[9], context.digest[10], context.digest[11],
           context.digest[12], context.digest[13], context.digest[14], context.digest[15]);
-  memcpy(target, buf, TSDB_PASSWORD_LEN);
+  (void)memcpy(target, buf, TSDB_PASSWORD_LEN);
 }
 
 static FORCE_INLINE int32_t taosCreateMD5Hash(char *pBuf, int32_t len) {
@@ -108,10 +108,10 @@ static FORCE_INLINE int32_t taosGetTbHashVal(const char *tbname, int32_t tblen,
     int32_t offset = 0;
     if (prefix < 0) {
       offset = -1 * prefix;
-      strncpy(tbName, tbname, offset);
+      (void)strncpy(tbName, tbname, offset);
     }
     if (suffix < 0) {
-      strncpy(tbName + offset, tbname + tblen + suffix, -1 * suffix);
+      (void)strncpy(tbName + offset, tbname + tblen + suffix, -1 * suffix);
       offset += -1 * suffix;
     }
     return MurmurHash3_32(tbName, offset);
@@ -152,9 +152,12 @@ static FORCE_INLINE int32_t taosGetTbHashVal(const char *tbname, int32_t tblen,
 
 #define TCONTAINER_OF(ptr, type, member) ((type *)((char *)(ptr)-offsetof(type, member)))
 
-#define TAOS_RETURN(code)     \
+#define TAOS_GET_TERRNO(code) \
+ (terrno == 0 ? code : terrno)
+
+#define TAOS_RETURN(CODE)     \
   do {                        \
-    return (terrno = (code)); \
+    return (terrno = (CODE)); \
   } while (0)
 
 #define TAOS_CHECK_RETURN(CMD)       \
@@ -176,6 +179,15 @@ static FORCE_INLINE int32_t taosGetTbHashVal(const char *tbname, int32_t tblen,
     }                                     \
   } while (0)
 
+#define TAOS_CHECK_EXIT(CMD)        \
+  do {                              \
+    code = (CMD);                   \
+    if (code < TSDB_CODE_SUCCESS) { \
+      lino = __LINE__;              \
+      goto _exit;                   \
+    }                               \
+  } while (0)
+
 #define TAOS_UNUSED(expr) (void)(expr)
 
 #ifdef __cplusplus

include/util/types.h

@@ -38,7 +38,7 @@ static FORCE_INLINE float taos_align_get_float(const char *pBuf) {
   assert(sizeof(float) == sizeof(uint32_t));
 #endif
   float fv = 0;
-  memcpy(&fv, pBuf, sizeof(fv));  // in ARM, return *((const float*)(pBuf)) may cause problem
+  (void)memcpy(&fv, pBuf, sizeof(fv));  // in ARM, return *((const float*)(pBuf)) may cause problem
   return fv;
 }
 
@@ -49,7 +49,7 @@ static FORCE_INLINE double taos_align_get_double(const char *pBuf) {
   assert(sizeof(double) == sizeof(uint64_t));
 #endif
   double dv = 0;
-  memcpy(&dv, pBuf, sizeof(dv));  // in ARM, return *((const double*)(pBuf)) may cause problem
+  (void)memcpy(&dv, pBuf, sizeof(dv));  // in ARM, return *((const double*)(pBuf)) may cause problem
   return dv;
 }
 

source/client/inc/clientInt.h

@@ -310,7 +310,7 @@ void    setResPrecision(SReqResultInfo* pResInfo, int32_t precision);
 int32_t setQueryResultFromRsp(SReqResultInfo* pResultInfo, const SRetrieveTableRsp* pRsp, bool convertUcs4);
 int32_t setResultDataPtr(SReqResultInfo* pResultInfo, TAOS_FIELD* pFields, int32_t numOfCols, int32_t numOfRows,
                          bool convertUcs4);
-void    setResSchemaInfo(SReqResultInfo* pResInfo, const SSchema* pSchema, int32_t numOfCols);
+int32_t setResSchemaInfo(SReqResultInfo* pResInfo, const SSchema* pSchema, int32_t numOfCols);
 void    doFreeReqResultInfo(SReqResultInfo* pResInfo);
 int32_t transferTableNameList(const char* tbList, int32_t acctId, char* dbName, SArray** pReq);
 void    syncCatalogFn(SMetaData* pResult, void* param, int32_t code);
@@ -332,8 +332,7 @@ static FORCE_INLINE SReqResultInfo* tmqGetCurResInfo(TAOS_RES* res) {
   return (SReqResultInfo*)&msg->common.resInfo;
 }
 
-SReqResultInfo* tmqGetNextResInfo(TAOS_RES* res, bool convertUcs4);
+int32_t tmqGetNextResInfo(TAOS_RES* res, bool convertUcs4, SReqResultInfo** pResInfo);
-
 static FORCE_INLINE SReqResultInfo* tscGetCurResInfo(TAOS_RES* res) {
   if (TD_RES_QUERY(res)) return &(((SRequestObj*)res)->body.resInfo);
   return tmqGetCurResInfo(res);
@@ -349,15 +348,16 @@ __async_send_cb_fn_t getMsgRspHandle(int32_t msgType);
 
 SMsgSendInfo* buildMsgInfoImpl(SRequestObj* pReqObj);
 
-void*    createTscObj(const char* user, const char* auth, const char* db, int32_t connType, SAppInstInfo* pAppInfo);
+int32_t   createTscObj(const char *user, const char *auth, const char *db, int32_t connType, SAppInstInfo *pAppInfo,
+                      STscObj **p);
 void     destroyTscObj(void* pObj);
 STscObj* acquireTscObj(int64_t rid);
-int32_t  releaseTscObj(int64_t rid);
+void     releaseTscObj(int64_t rid);
 void     destroyAppInst(void* pAppInfo);
 
 uint64_t generateRequestId();
 
-void*        createRequest(uint64_t connId, int32_t type, int64_t reqid);
+int32_t      createRequest(uint64_t connId, int32_t type, int64_t reqid, SRequestObj **pRequest);
 void         destroyRequest(SRequestObj* pRequest);
 SRequestObj* acquireRequest(int64_t rid);
 int32_t      releaseRequest(int64_t rid);
@@ -371,7 +371,7 @@ void  resetConnectDB(STscObj* pTscObj);
 
 int taos_options_imp(TSDB_OPTION option, const char* str);
 
-void* openTransporter(const char* user, const char* auth, int32_t numOfThreads);
+int32_t openTransporter(const char* user, const char* auth, int32_t numOfThreads, void **pDnodeConn);
 void tscStopCrashReport();
 
 typedef struct AsyncArg {
@@ -382,8 +382,8 @@ typedef struct AsyncArg {
 bool persistConnForSpecificMsg(void* parenct, tmsg_t msgType);
 void processMsgFromServer(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet);
 
-STscObj* taos_connect_internal(const char* ip, const char* user, const char* pass, const char* auth, const char* db,
+int32_t taos_connect_internal(const char* ip, const char* user, const char* pass, const char* auth, const char* db,
-                               uint16_t port, int connType);
+                              uint16_t port, int connType, STscObj** pObj);
 
 int32_t parseSql(SRequestObj* pRequest, bool topicQuery, SQuery** pQuery, SStmtCallback* pStmtCb);
 
@@ -396,11 +396,11 @@ void taos_close_internal(void* taos);
 
 // --- heartbeat
 // global, called by mgmt
-int  hbMgrInit();
+int32_t hbMgrInit();
-void hbMgrCleanUp();
+void    hbMgrCleanUp();
 
 // cluster level
-SAppHbMgr* appHbMgrInit(SAppInstInfo* pAppInstInfo, char* key);
+int32_t    appHbMgrInit(SAppInstInfo *pAppInstInfo, char *key, SAppHbMgr **pAppHbMgr);
 void       appHbMgrCleanup(void);
 void       hbRemoveAppHbMrg(SAppHbMgr** pAppHbMgr);
 void       destroyAllRequests(SHashObj* pRequests);
@@ -409,7 +409,7 @@ void       stopAllRequests(SHashObj* pRequests);
 //SAppInstInfo* getAppInstInfo(const char* clusterKey);
 
 // conn level
-int  hbRegisterConn(SAppHbMgr* pAppHbMgr, int64_t tscRefId, int64_t clusterId, int8_t connType);
+int32_t hbRegisterConn(SAppHbMgr* pAppHbMgr, int64_t tscRefId, int64_t clusterId, int8_t connType);
 void hbDeregisterConn(STscObj* pTscObj, SClientHbKey connKey);
 
 typedef struct SSqlCallbackWrapper {
@@ -428,7 +428,7 @@ void    doAsyncQuery(SRequestObj* pRequest, bool forceUpdateMeta);
 int32_t removeMeta(STscObj* pTscObj, SArray* tbList, bool isView);
 int32_t handleAlterTbExecRes(void* res, struct SCatalog* pCatalog);
 int32_t handleCreateTbExecRes(void* res, SCatalog* pCatalog);
-bool    qnodeRequired(SRequestObj* pRequest);
+int32_t qnodeRequired(SRequestObj* pRequest, bool *required);
 void    continueInsertFromCsv(SSqlCallbackWrapper* pWrapper, SRequestObj* pRequest);
 void    destorySqlCallbackWrapper(SSqlCallbackWrapper* pWrapper);
 void    handleQueryAnslyseRes(SSqlCallbackWrapper *pWrapper, SMetaData *pResultMeta, int32_t code);
@@ -444,6 +444,30 @@ void    freeQueryParam(SSyncQueryParam* param);
 int32_t clientParseSqlImpl(void* param, const char* dbName, const char* sql, bool parseOnly, const char* effeciveUser, SParseSqlRes* pRes);
 #endif
 
+#define TSC_ERR_RET(c)                \
+  do {                                \
+    int32_t _code = c;                \
+    if (_code != TSDB_CODE_SUCCESS) { \
+      terrno = _code;                 \
+      return _code;                   \
+    }                                 \
+  } while (0)
+#define TSC_RET(c)                    \
+  do {                                \
+    int32_t _code = c;                \
+    if (_code != TSDB_CODE_SUCCESS) { \
+      terrno = _code;                 \
+    }                                 \
+    return _code;                     \
+  } while (0)
+#define TSC_ERR_JRET(c)              \
+  do {                               \
+    code = c;                        \
+    if (code != TSDB_CODE_SUCCESS) { \
+      terrno = code;                 \
+      goto _return;                  \
+    }                                \
+  } while (0)
 
 void slowQueryLog(int64_t rid, bool killed, int32_t code, int32_t cost);
 

source/client/src/clientEnv.c

@@ -44,6 +44,26 @@
 #define TSC_VAR_NOT_RELEASE 1
 #define TSC_VAR_RELEASED    0
 
+#define ENV_JSON_FALSE_CHECK(c)                    \
+  do {                                             \
+    if (!c) {                                      \
+      tscError("faild to add item to JSON object");\
+      code = TSDB_CODE_TSC_FAIL_GENERATE_JSON;     \
+      goto _end;                                   \
+    }                                              \
+  } while (0)
+
+#define ENV_ERR_RET(c,info)           \
+  do {                                \
+    int32_t _code = c;                \
+    if (_code != TSDB_CODE_SUCCESS) { \
+      errno = _code;                  \
+      tscInitRes = _code;             \
+      tscError(info);                 \
+      return;                         \
+    }                                 \
+  } while (0)
+
 STscDbg  tscDbg = {0};
 SAppInfo appInfo;
 int64_t  lastClusterId = 0;
@@ -57,8 +77,14 @@ static TdThreadOnce tscinit = PTHREAD_ONCE_INIT;
 volatile int32_t    tscInitRes = 0;
 
 static int32_t registerRequest(SRequestObj *pRequest, STscObj *pTscObj) {
+  int32_t code = TSDB_CODE_SUCCESS;
   // connection has been released already, abort creating request.
   pRequest->self = taosAddRef(clientReqRefPool, pRequest);
+  if (pRequest->self < 0) {
+    tscError("failed to add ref to request");
+    code = terrno;
+    return code;
+  }
 
   int32_t num = atomic_add_fetch_32(&pTscObj->numOfReqs, 1);
 
@@ -72,19 +98,23 @@ static int32_t registerRequest(SRequestObj *pRequest, STscObj *pTscObj) {
              pRequest->self, pRequest->pTscObj->id, num, currentInst, total, pRequest->requestId);
   }
 
-  return TSDB_CODE_SUCCESS;
+  return code;
 }
 
 static void concatStrings(SArray *list, char* buf, int size){
   int  len = 0;
   for(int i = 0; i < taosArrayGetSize(list); i++){
     char* db = taosArrayGet(list, i);
+    if (NULL == db) {
+      tscError("get dbname failed, buf:%s", buf);
+      break;
+    }
     char* dot = strchr(db, '.');
     if (dot != NULL) {
       db = dot + 1;
     }
     if (i != 0){
-      strcat(buf, ",");
+      (void)strcat(buf, ",");
       len += 1;
     }
     int ret = snprintf(buf + len, size - len, "%s", db);
@@ -100,61 +130,70 @@ static void concatStrings(SArray *list, char* buf, int size){
   }
 }
 
-static void generateWriteSlowLog(STscObj *pTscObj, SRequestObj *pRequest, int32_t reqType, int64_t duration){
+static int32_t generateWriteSlowLog(STscObj *pTscObj, SRequestObj *pRequest, int32_t reqType, int64_t duration){
   cJSON* json = cJSON_CreateObject();
+  int32_t code = TSDB_CODE_SUCCESS;
   if (json == NULL) {
     tscError("[monitor] cJSON_CreateObject failed");
-    return;
+    return TSDB_CODE_OUT_OF_MEMORY;
   }
   char clusterId[32] = {0};
   if (snprintf(clusterId, sizeof(clusterId), "%" PRId64, pTscObj->pAppInfo->clusterId) < 0){
     tscError("failed to generate clusterId:%" PRId64, pTscObj->pAppInfo->clusterId);
+    code = TSDB_CODE_FAILED;
+    goto _end;
   }
 
   char startTs[32] = {0};
   if (snprintf(startTs, sizeof(startTs), "%" PRId64, pRequest->metric.start/1000) < 0){
     tscError("failed to generate startTs:%" PRId64, pRequest->metric.start/1000);
+    code = TSDB_CODE_FAILED;
+    goto _end;
   }
 
   char requestId[32] = {0};
   if (snprintf(requestId, sizeof(requestId), "%" PRIu64, pRequest->requestId) < 0){
     tscError("failed to generate requestId:%" PRIu64, pRequest->requestId);
+    code = TSDB_CODE_FAILED;
+    goto _end;
   }
-  cJSON_AddItemToObject(json, "cluster_id",  cJSON_CreateString(clusterId));
+  ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(json, "cluster_id",   cJSON_CreateString(clusterId)));
-  cJSON_AddItemToObject(json, "start_ts",    cJSON_CreateString(startTs));
+  ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(json, "start_ts",     cJSON_CreateString(startTs)));
-  cJSON_AddItemToObject(json, "request_id",  cJSON_CreateString(requestId));
+  ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(json, "request_id",   cJSON_CreateString(requestId)));
-  cJSON_AddItemToObject(json, "query_time",         cJSON_CreateNumber(duration/1000));
+  ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(json, "query_time",   cJSON_CreateNumber(duration/1000)));
-  cJSON_AddItemToObject(json, "code",         cJSON_CreateNumber(pRequest->code));
+  ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(json, "code",         cJSON_CreateNumber(pRequest->code)));
-  cJSON_AddItemToObject(json, "error_info",   cJSON_CreateString(tstrerror(pRequest->code)));
+  ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(json, "error_info",   cJSON_CreateString(tstrerror(pRequest->code))));
-  cJSON_AddItemToObject(json, "type",         cJSON_CreateNumber(reqType));
+  ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(json, "type",         cJSON_CreateNumber(reqType)));
-  cJSON_AddItemToObject(json, "rows_num",     cJSON_CreateNumber(pRequest->body.resInfo.numOfRows + pRequest->body.resInfo.totalRows));
+  ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(json, "rows_num",     cJSON_CreateNumber(pRequest->body.resInfo.numOfRows + pRequest->body.resInfo.totalRows)));
   if(pRequest->sqlstr != NULL && strlen(pRequest->sqlstr) > pTscObj->pAppInfo->monitorParas.tsSlowLogMaxLen){
     char tmp = pRequest->sqlstr[pTscObj->pAppInfo->monitorParas.tsSlowLogMaxLen];
     pRequest->sqlstr[pTscObj->pAppInfo->monitorParas.tsSlowLogMaxLen] = '\0';
-    cJSON_AddItemToObject(json, "sql",          cJSON_CreateString(pRequest->sqlstr));
+    ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(json, "sql",        cJSON_CreateString(pRequest->sqlstr)));
     pRequest->sqlstr[pTscObj->pAppInfo->monitorParas.tsSlowLogMaxLen] = tmp;
   }else{
-    cJSON_AddItemToObject(json, "sql",          cJSON_CreateString(pRequest->sqlstr));
+    ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(json, "sql",        cJSON_CreateString(pRequest->sqlstr)));
   }
 
-  cJSON_AddItemToObject(json, "user",         cJSON_CreateString(pTscObj->user));
+  ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(json, "user",         cJSON_CreateString(pTscObj->user)));
-  cJSON_AddItemToObject(json, "process_name", cJSON_CreateString(appInfo.appName));
+  ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(json, "process_name", cJSON_CreateString(appInfo.appName)));
-  cJSON_AddItemToObject(json, "ip",           cJSON_CreateString(tsLocalFqdn));
+  ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(json, "ip",           cJSON_CreateString(tsLocalFqdn)));
 
   char pid[32] = {0};
   if (snprintf(pid, sizeof(pid), "%d", appInfo.pid) < 0){
     tscError("failed to generate pid:%d", appInfo.pid);
+    code = TSDB_CODE_FAILED;
+    goto _end;
   }
 
-  cJSON_AddItemToObject(json, "process_id",   cJSON_CreateString(pid));
+  ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(json, "process_id",   cJSON_CreateString(pid)));
   if(pRequest->dbList != NULL){
     char dbList[1024] = {0};
     concatStrings(pRequest->dbList, dbList, sizeof(dbList) - 1);
-    cJSON_AddItemToObject(json, "db", cJSON_CreateString(dbList));
+    ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(json, "db", cJSON_CreateString(dbList)));
   }else if(pRequest->pDb != NULL){
-    cJSON_AddItemToObject(json, "db", cJSON_CreateString(pRequest->pDb));
+    ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(json, "db", cJSON_CreateString(pRequest->pDb)));
   }else{
-    cJSON_AddItemToObject(json, "db", cJSON_CreateString(""));
+    ENV_JSON_FALSE_CHECK(cJSON_AddItemToObject(json, "db", cJSON_CreateString("")));
   }
 
   char* value = cJSON_PrintUnformatted(json);
@@ -162,11 +201,15 @@ static void generateWriteSlowLog(STscObj *pTscObj, SRequestObj *pRequest, int32_
   data.clusterId = pTscObj->pAppInfo->clusterId;
   data.type = SLOW_LOG_WRITE;
   data.data = value;
-  if(monitorPutData2MonitorQueue(data) < 0){
+  code = monitorPutData2MonitorQueue(data);
+  if (TSDB_CODE_SUCCESS != code) {
     taosMemoryFree(value);
+    goto _end;
   }
 
+_end:
   cJSON_Delete(json);
+  return code;
 }
 
 static bool checkSlowLogExceptDb(SRequestObj *pRequest, char* exceptDb) {
@@ -176,6 +219,10 @@ static bool checkSlowLogExceptDb(SRequestObj *pRequest, char* exceptDb) {
 
   for (int i = 0; i < taosArrayGetSize(pRequest->dbList); i++) {
     char *db = taosArrayGet(pRequest->dbList, i);
+    if (NULL == db) {
+      tscError("get dbname failed, exceptDb:%s", exceptDb);
+      return false;
+    }
     char *dot = strchr(db, '.');
     if (dot != NULL) {
       db = dot + 1;
@@ -215,7 +262,7 @@ static void deregisterRequest(SRequestObj *pRequest) {
                "us, planCost:%" PRId64 "us, exec:%" PRId64 "us",
                duration, pRequest->metric.parseCostUs, pRequest->metric.ctgCostUs, pRequest->metric.analyseCostUs,
                pRequest->metric.planCostUs, pRequest->metric.execCostUs);
-      atomic_add_fetch_64((int64_t *)&pActivity->insertElapsedTime, duration);
+      (void)atomic_add_fetch_64((int64_t *)&pActivity->insertElapsedTime, duration);
       reqType = SLOW_LOG_TYPE_INSERT;
     } else if (QUERY_NODE_SELECT_STMT == pRequest->stmtType) {
       tscDebug("query duration %" PRId64 "us: parseCost:%" PRId64 "us, ctgCost:%" PRId64 "us, analyseCost:%" PRId64
@@ -223,11 +270,13 @@ static void deregisterRequest(SRequestObj *pRequest) {
                duration, pRequest->metric.parseCostUs, pRequest->metric.ctgCostUs, pRequest->metric.analyseCostUs,
                pRequest->metric.planCostUs, pRequest->metric.execCostUs);
 
-      atomic_add_fetch_64((int64_t *)&pActivity->queryElapsedTime, duration);
+      (void)atomic_add_fetch_64((int64_t *)&pActivity->queryElapsedTime, duration);
       reqType = SLOW_LOG_TYPE_QUERY;
     }
 
-    nodesSimReleaseAllocator(pRequest->allocatorRefId);
+    if (TSDB_CODE_SUCCESS != nodesSimReleaseAllocator(pRequest->allocatorRefId)) {
+      tscError("failed to release allocator");
+    }
   }
 
   if(pTscObj->pAppInfo->monitorParas.tsEnableMonitor){
@@ -242,14 +291,16 @@ static void deregisterRequest(SRequestObj *pRequest) {
 
   if ((duration >= pTscObj->pAppInfo->monitorParas.tsSlowLogThreshold * 1000000UL || duration >= pTscObj->pAppInfo->monitorParas.tsSlowLogThresholdTest * 1000000UL) &&
       checkSlowLogExceptDb(pRequest, pTscObj->pAppInfo->monitorParas.tsSlowLogExceptDb)) {
-    atomic_add_fetch_64((int64_t *)&pActivity->numOfSlowQueries, 1);
+    (void)atomic_add_fetch_64((int64_t *)&pActivity->numOfSlowQueries, 1);
     if (pTscObj->pAppInfo->monitorParas.tsSlowLogScope & reqType) {
       taosPrintSlowLog("PID:%d, Conn:%u, QID:0x%" PRIx64 ", Start:%" PRId64 " us, Duration:%" PRId64 "us, SQL:%s",
                        taosGetPId(), pTscObj->connId, pRequest->requestId, pRequest->metric.start, duration,
                        pRequest->sqlstr);
       if(pTscObj->pAppInfo->monitorParas.tsEnableMonitor){
         slowQueryLog(pTscObj->id, pRequest->killed, pRequest->code, duration);
-        generateWriteSlowLog(pTscObj, pRequest, reqType, duration);
+        if (TSDB_CODE_SUCCESS != generateWriteSlowLog(pTscObj, pRequest, reqType, duration)) {
+          tscError("failed to generate write slow log");
+        }
       }
     }
   }
@@ -289,9 +340,9 @@ static bool clientRpcTfp(int32_t code, tmsg_t msgType) {
 }
 
 // TODO refactor
-void *openTransporter(const char *user, const char *auth, int32_t numOfThread) {
+int32_t openTransporter(const char *user, const char *auth, int32_t numOfThread, void **pDnodeConn) {
   SRpcInit rpcInit;
-  memset(&rpcInit, 0, sizeof(rpcInit));
+  (void)memset(&rpcInit, 0, sizeof(rpcInit));
   rpcInit.localPort = 0;
   rpcInit.label = "TSC";
   rpcInit.numOfThreads = tsNumOfRpcThreads;
@@ -315,15 +366,19 @@ void *openTransporter(const char *user, const char *auth, int32_t numOfThread) {
   rpcInit.connLimitNum = connLimitNum;
   rpcInit.timeToGetConn = tsTimeToGetAvailableConn;
 
-  taosVersionStrToInt(version, &(rpcInit.compatibilityVer));
+  int32_t code = taosVersionStrToInt(version, &(rpcInit.compatibilityVer));
-
+  if (TSDB_CODE_SUCCESS != code) {
-  void *pDnodeConn = rpcOpen(&rpcInit);
+    tscError("invalid version string.");
-  if (pDnodeConn == NULL) {
+    return code;
-    tscError("failed to init connection to server");
-    return NULL;
   }
 
-  return pDnodeConn;
+  *pDnodeConn = rpcOpen(&rpcInit);
+  if (*pDnodeConn == NULL) {
+    tscError("failed to init connection to server.");
+    code = TSDB_CODE_FAILED;
+  }
+
+  return code;
 }
 
 void destroyAllRequests(SHashObj *pRequests) {
@@ -334,7 +389,7 @@ void destroyAllRequests(SHashObj *pRequests) {
     SRequestObj *pRequest = acquireRequest(*rid);
     if (pRequest) {
       destroyRequest(pRequest);
-      releaseRequest(*rid);
+      (void)releaseRequest(*rid); // ignore error
     }
 
     pIter = taosHashIterate(pRequests, pIter);
@@ -349,7 +404,7 @@ void stopAllRequests(SHashObj *pRequests) {
     SRequestObj *pRequest = acquireRequest(*rid);
     if (pRequest) {
       taos_stop_query(pRequest);
-      releaseRequest(*rid);
+      (void)releaseRequest(*rid); // ignore error
     }
 
     pIter = taosHashIterate(pRequests, pIter);
@@ -360,18 +415,31 @@ void destroyAppInst(void *info) {
   SAppInstInfo* pAppInfo = *(SAppInstInfo**)info;
   tscDebug("destroy app inst mgr %p", pAppInfo);
 
-  taosThreadMutexLock(&appInfo.mutex);
+  int32_t code = taosThreadMutexLock(&appInfo.mutex);
+  if (TSDB_CODE_SUCCESS != code) {
+    tscError("failed to lock app info, code:%s", tstrerror(TAOS_SYSTEM_ERROR(code)));
+  }
 
   hbRemoveAppHbMrg(&pAppInfo->pAppHbMgr);
 
-  taosThreadMutexUnlock(&appInfo.mutex);
+  code = taosThreadMutexUnlock(&appInfo.mutex);
+  if (TSDB_CODE_SUCCESS != code) {
+    tscError("failed to unlock app info, code:%s", tstrerror(TAOS_SYSTEM_ERROR(code)));
+  }
 
   taosMemoryFreeClear(pAppInfo->instKey);
   closeTransporter(pAppInfo);
 
-  taosThreadMutexLock(&pAppInfo->qnodeMutex);
+  code = taosThreadMutexLock(&pAppInfo->qnodeMutex);
+  if (TSDB_CODE_SUCCESS != code) {
+    tscError("failed to lock qnode mutex, code:%s", tstrerror(TAOS_SYSTEM_ERROR(code)));
+  }
+
   taosArrayDestroy(pAppInfo->pQnodeList);
-  taosThreadMutexUnlock(&pAppInfo->qnodeMutex);
+  code = taosThreadMutexUnlock(&pAppInfo->qnodeMutex);
+  if (TSDB_CODE_SUCCESS != code) {
+    tscError("failed to unlock qnode mutex, code:%s", tstrerror(TAOS_SYSTEM_ERROR(code)));
+  }
 
   taosMemoryFree(pAppInfo);
 }
@@ -396,97 +464,111 @@ void destroyTscObj(void *pObj) {
            pTscObj->pAppInfo->numOfConns);
 
   // In any cases, we should not free app inst here. Or an race condition rises.
-  /*int64_t connNum = */ atomic_sub_fetch_64(&pTscObj->pAppInfo->numOfConns, 1);
+  /*int64_t connNum = */ (void)atomic_sub_fetch_64(&pTscObj->pAppInfo->numOfConns, 1);
 
-  taosThreadMutexDestroy(&pTscObj->mutex);
+  (void)taosThreadMutexDestroy(&pTscObj->mutex);
   taosMemoryFree(pTscObj);
 
   tscTrace("end to destroy tscObj %" PRIx64 " p:%p", tscId, pTscObj);
 }
 
-void *createTscObj(const char *user, const char *auth, const char *db, int32_t connType, SAppInstInfo *pAppInfo) {
+int32_t createTscObj(const char *user, const char *auth, const char *db, int32_t connType, SAppInstInfo *pAppInfo,
-  STscObj *pObj = (STscObj *)taosMemoryCalloc(1, sizeof(STscObj));
+                     STscObj **pObj) {
-  if (NULL == pObj) {
+  *pObj = (STscObj *)taosMemoryCalloc(1, sizeof(STscObj));
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
+  if (NULL == *pObj) {
-    return NULL;
+    return TSDB_CODE_OUT_OF_MEMORY;
   }
 
-  pObj->pRequests = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK);
+  (*pObj)->pRequests = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK);
-  if (NULL == pObj->pRequests) {
+  if (NULL == (*pObj)->pRequests) {
-    taosMemoryFree(pObj);
+    taosMemoryFree(*pObj);
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    return terrno ? terrno : TSDB_CODE_OUT_OF_MEMORY;
-    return NULL;
   }
 
-  pObj->connType = connType;
+  (*pObj)->connType = connType;
-  pObj->pAppInfo = pAppInfo;
+  (*pObj)->pAppInfo = pAppInfo;
-  pObj->appHbMgrIdx = pAppInfo->pAppHbMgr->idx;
+  (*pObj)->appHbMgrIdx = pAppInfo->pAppHbMgr->idx;
-  tstrncpy(pObj->user, user, sizeof(pObj->user));
+  tstrncpy((*pObj)->user, user, sizeof((*pObj)->user));
-  memcpy(pObj->pass, auth, TSDB_PASSWORD_LEN);
+  (void)memcpy((*pObj)->pass, auth, TSDB_PASSWORD_LEN);
 
   if (db != NULL) {
-    tstrncpy(pObj->db, db, tListLen(pObj->db));
+    tstrncpy((*pObj)->db, db, tListLen((*pObj)->db));
   }
 
-  taosThreadMutexInit(&pObj->mutex, NULL);
+  TSC_ERR_RET(taosThreadMutexInit(&(*pObj)->mutex, NULL));
-  pObj->id = taosAddRef(clientConnRefPool, pObj);
 
-  atomic_add_fetch_64(&pObj->pAppInfo->numOfConns, 1);
+  int32_t code = TSDB_CODE_SUCCESS;
 
-  tscDebug("connObj created, 0x%" PRIx64 ",p:%p", pObj->id, pObj);
+  (*pObj)->id = taosAddRef(clientConnRefPool, *pObj);
-  return pObj;
+  if ((*pObj)->id < 0) {
+    tscError("failed to add object to clientConnRefPool");
+    code = terrno;
+    taosMemoryFree(*pObj);
+    return code;
+  }
+
+  (void)atomic_add_fetch_64(&(*pObj)->pAppInfo->numOfConns, 1);
+
+  tscDebug("connObj created, 0x%" PRIx64 ",p:%p", (*pObj)->id, *pObj);
+  return code;
 }
 
 STscObj *acquireTscObj(int64_t rid) { return (STscObj *)taosAcquireRef(clientConnRefPool, rid); }
 
-int32_t releaseTscObj(int64_t rid) { return taosReleaseRef(clientConnRefPool, rid); }
+void releaseTscObj(int64_t rid) {
+  int32_t code = taosReleaseRef(clientConnRefPool, rid);
+  if (TSDB_CODE_SUCCESS != code) {
+    tscWarn("failed to release TscObj, code:%s", tstrerror(code));
+  }
+}
 
-void *createRequest(uint64_t connId, int32_t type, int64_t reqid) {
+int32_t createRequest(uint64_t connId, int32_t type, int64_t reqid, SRequestObj **pRequest) {
-  SRequestObj *pRequest = (SRequestObj *)taosMemoryCalloc(1, sizeof(SRequestObj));
+  int32_t code = TSDB_CODE_SUCCESS;
-  if (NULL == pRequest) {
+  *pRequest = (SRequestObj *)taosMemoryCalloc(1, sizeof(SRequestObj));
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
+  if (NULL == *pRequest) {
-    return NULL;
+    return TSDB_CODE_OUT_OF_MEMORY;
   }
 
   STscObj *pTscObj = acquireTscObj(connId);
   if (pTscObj == NULL) {
-    taosMemoryFree(pRequest);
+    code = TSDB_CODE_TSC_DISCONNECTED;
-    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    goto _return;
-    return NULL;
   }
   SSyncQueryParam *interParam = taosMemoryCalloc(1, sizeof(SSyncQueryParam));
   if (interParam == NULL) {
     releaseTscObj(connId);
-    doDestroyRequest(pRequest);
+    code = TSDB_CODE_OUT_OF_MEMORY;
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    goto _return;
-    return NULL;
   }
-  tsem_init(&interParam->sem, 0, 0);
+  TSC_ERR_JRET(tsem_init(&interParam->sem, 0, 0));
-  interParam->pRequest = pRequest;
+  interParam->pRequest = *pRequest;
-  pRequest->body.interParam = interParam;
+  (*pRequest)->body.interParam = interParam;
 
-  pRequest->resType = RES_TYPE__QUERY;
+  (*pRequest)->resType = RES_TYPE__QUERY;
-  pRequest->requestId = reqid == 0 ? generateRequestId() : reqid;
+  (*pRequest)->requestId = reqid == 0 ? generateRequestId() : reqid;
-  pRequest->metric.start = taosGetTimestampUs();
+  (*pRequest)->metric.start = taosGetTimestampUs();
 
-  pRequest->body.resInfo.convertUcs4 = true;  // convert ucs4 by default
+  (*pRequest)->body.resInfo.convertUcs4 = true;  // convert ucs4 by default
-  pRequest->type = type;
+  (*pRequest)->type = type;
-  pRequest->allocatorRefId = -1;
+  (*pRequest)->allocatorRefId = -1;
 
-  pRequest->pDb = getDbOfConnection(pTscObj);
+  (*pRequest)->pDb = getDbOfConnection(pTscObj);
-  pRequest->pTscObj = pTscObj;
+  (*pRequest)->pTscObj = pTscObj;
-  pRequest->inCallback = false;
+  (*pRequest)->inCallback = false;
 
-  pRequest->msgBuf = taosMemoryCalloc(1, ERROR_MSG_BUF_DEFAULT_SIZE);
+  (*pRequest)->msgBuf = taosMemoryCalloc(1, ERROR_MSG_BUF_DEFAULT_SIZE);
-  pRequest->msgBufLen = ERROR_MSG_BUF_DEFAULT_SIZE;
+  if (NULL == (*pRequest)->msgBuf) {
-  tsem_init(&pRequest->body.rspSem, 0, 0);
+    code = TSDB_CODE_OUT_OF_MEMORY;
-
+    goto _return;
-  if (registerRequest(pRequest, pTscObj)) {
-    doDestroyRequest(pRequest);
-    return NULL;
   }
+  (*pRequest)->msgBufLen = ERROR_MSG_BUF_DEFAULT_SIZE;
+  TSC_ERR_JRET(tsem_init(&(*pRequest)->body.rspSem, 0, 0));
+  TSC_ERR_JRET(registerRequest(*pRequest, pTscObj));
 
-  return pRequest;
+  return TSDB_CODE_SUCCESS;
+_return:
+  doDestroyRequest(*pRequest);
+  return code;
 }
 
 void doFreeReqResultInfo(SReqResultInfo *pResInfo) {
@@ -521,12 +603,12 @@ int64_t removeFromMostPrevReq(SRequestObj* pRequest) {
     pTmp = acquireRequest(pTmp->relation.prevRefId);
     if (pTmp) {
       mostPrevReqRefId = pTmp->self;
-      releaseRequest(mostPrevReqRefId);
+      (void)releaseRequest(mostPrevReqRefId); // ignore error
     } else {
       break;
     }
   }
-  removeRequest(mostPrevReqRefId);
+  (void)removeRequest(mostPrevReqRefId); // ignore error
   return mostPrevReqRefId;
 }
 
@@ -534,8 +616,8 @@ void destroyNextReq(int64_t nextRefId) {
   if (nextRefId) {
     SRequestObj* pObj = acquireRequest(nextRefId);
     if (pObj) {
-      releaseRequest(nextRefId);
+      (void)releaseRequest(nextRefId); // ignore error
-      releaseRequest(nextRefId);
+      (void)releaseRequest(nextRefId); // ignore error
     }
   }
 }
@@ -555,7 +637,7 @@ void destroySubRequests(SRequestObj *pRequest) {
     pTmp = acquireRequest(tmpRefId);
     if (pTmp) {
       pReqList[++reqIdx] = pTmp;
-      releaseRequest(tmpRefId);
+      (void)releaseRequest(tmpRefId); // ignore error
     } else {
       tscError("prev req ref 0x%" PRIx64 " is not there", tmpRefId);
       break;
@@ -563,7 +645,7 @@ void destroySubRequests(SRequestObj *pRequest) {
   }
 
   for (int32_t i = reqIdx; i >= 0; i--) {
-    removeRequest(pReqList[i]->self);
+    (void)removeRequest(pReqList[i]->self); // ignore error
   }
 
   tmpRefId = pRequest->relation.nextRefId;
@@ -571,8 +653,8 @@ void destroySubRequests(SRequestObj *pRequest) {
     pTmp = acquireRequest(tmpRefId);
     if (pTmp) {
       tmpRefId = pTmp->relation.nextRefId;
-      removeRequest(pTmp->self);
+      (void)removeRequest(pTmp->self); // ignore error
-      releaseRequest(pTmp->self);
+      (void)releaseRequest(pTmp->self); // ignore error
     } else {
       tscError("next req ref 0x%" PRIx64 " is not there", tmpRefId);
       break;
@@ -592,8 +674,10 @@ void doDestroyRequest(void *p) {
 
   int64_t nextReqRefId = pRequest->relation.nextRefId;
 
-  taosHashRemove(pRequest->pTscObj->pRequests, &pRequest->self, sizeof(pRequest->self));
+  int32_t code = taosHashRemove(pRequest->pTscObj->pRequests, &pRequest->self, sizeof(pRequest->self));
-
+  if (TSDB_CODE_SUCCESS != code) {
+    tscError("failed to remove request from hash, code:%s", tstrerror(code));
+  }
   schedulerFreeJob(&pRequest->body.queryJob, 0);
 
   destorySqlCallbackWrapper(pRequest->pWrapper);
@@ -601,7 +685,7 @@ void doDestroyRequest(void *p) {
   taosMemoryFreeClear(pRequest->msgBuf);
 
   doFreeReqResultInfo(&pRequest->body.resInfo);
-  tsem_destroy(&pRequest->body.rspSem);
+  (void)tsem_destroy(&pRequest->body.rspSem);
 
   taosArrayDestroy(pRequest->tableList);
   taosArrayDestroy(pRequest->targetTableList);
@@ -615,13 +699,15 @@ void doDestroyRequest(void *p) {
   taosMemoryFreeClear(pRequest->pDb);
   taosArrayDestroy(pRequest->dbList);
   if (pRequest->body.interParam) {
-    tsem_destroy(&((SSyncQueryParam *)pRequest->body.interParam)->sem);
+    (void)tsem_destroy(&((SSyncQueryParam *)pRequest->body.interParam)->sem);
   }
   taosMemoryFree(pRequest->body.interParam);
 
   if (TSDB_CODE_SUCCESS == nodesSimAcquireAllocator(pRequest->allocatorRefId)) {
     qDestroyQuery(pRequest->pQuery);
-    nodesSimReleaseAllocator(pRequest->allocatorRefId);
+    if (TSDB_CODE_SUCCESS != nodesSimReleaseAllocator(pRequest->allocatorRefId)) {
+      tscError("failed to release allocator");
+    }
   }
   nodesDestroyAllocator(pRequest->allocatorRefId);
 
@@ -638,7 +724,7 @@ void destroyRequest(SRequestObj *pRequest) {
   }
 
   taos_stop_query(pRequest);
-  removeFromMostPrevReq(pRequest);
+  (void)removeFromMostPrevReq(pRequest);
 }
 
 void taosStopQueryImpl(SRequestObj *pRequest) {
@@ -677,7 +763,7 @@ void stopAllQueries(SRequestObj *pRequest) {
 
   for (int32_t i = reqIdx; i >= 0; i--) {
     taosStopQueryImpl(pReqList[i]);
-    releaseRequest(pReqList[i]->self);
+    (void)releaseRequest(pReqList[i]->self); // ignore error
   }
 
   taosStopQueryImpl(pRequest);
@@ -688,7 +774,7 @@ void stopAllQueries(SRequestObj *pRequest) {
     if (pTmp) {
       tmpRefId = pTmp->relation.nextRefId;
       taosStopQueryImpl(pTmp);
-      releaseRequest(pTmp->self);
+      (void)releaseRequest(pTmp->self); // ignore error
     } else {
       tscError("next req ref 0x%" PRIx64 " is not there", tmpRefId);
       break;
@@ -701,7 +787,7 @@ void crashReportThreadFuncUnexpectedStopped(void) { atomic_store_32(&clientStop,
 static void *tscCrashReportThreadFp(void *param) {
   setThreadName("client-crashReport");
   char filepath[PATH_MAX] = {0};
-  snprintf(filepath, sizeof(filepath), "%s%s.taosCrashLog", tsLogDir, TD_DIRSEP);
+  (void)snprintf(filepath, sizeof(filepath), "%s%s.taosCrashLog", tsLogDir, TD_DIRSEP);
   char     *pMsg = NULL;
   int64_t   msgLen = 0;
   TdFilePtr pFile = NULL;
@@ -770,20 +856,27 @@ static void *tscCrashReportThreadFp(void *param) {
 
 int32_t tscCrashReportInit() {
   if (!tsEnableCrashReport) {
-    return 0;
+    return TSDB_CODE_SUCCESS;
   }
-
+  int32_t      code = TSDB_CODE_SUCCESS;
   TdThreadAttr thAttr;
-  taosThreadAttrInit(&thAttr);
+  TSC_ERR_JRET(taosThreadAttrInit(&thAttr));
-  taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
+  TSC_ERR_JRET(taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE));
   TdThread crashReportThread;
   if (taosThreadCreate(&crashReportThread, &thAttr, tscCrashReportThreadFp, NULL) != 0) {
     tscError("failed to create crashReport thread since %s", strerror(errno));
-    return -1;
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    TSC_ERR_RET(errno);
   }
 
-  taosThreadAttrDestroy(&thAttr);
+  (void)taosThreadAttrDestroy(&thAttr);
-  return 0;
+_return:
+  if (code) {
+    terrno = TAOS_SYSTEM_ERROR(errno);
+    TSC_ERR_RET(terrno);
+  }
+
+  return TSDB_CODE_SUCCESS;
 }
 
 void tscStopCrashReport() {
@@ -842,6 +935,11 @@ void taos_init_imp(void) {
   appInfo.startTime = taosGetTimestampMs();
   appInfo.pInstMap = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
   appInfo.pInstMapByClusterId = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_ENTRY_LOCK);
+  if (NULL == appInfo.pInstMap || NULL == appInfo.pInstMapByClusterId) {
+    tscError("failed to allocate memory when init appInfo");
+    tscInitRes = TSDB_CODE_OUT_OF_MEMORY;
+    return;
+  }
   taosHashSetFreeFp(appInfo.pInstMap, destroyAppInst);
   deltaToUtcInitOnce();
 
@@ -849,7 +947,7 @@ void taos_init_imp(void) {
 #ifdef CUS_PROMPT
   snprintf(logDirName, 64, "%slog", CUS_PROMPT);
 #else
-  snprintf(logDirName, 64, "taoslog");
+  (void)snprintf(logDirName, 64, "taoslog");
 #endif
   if (taosCreateLog(logDirName, 10, configDir, NULL, NULL, NULL, NULL, 1) != 0) {
     printf(" WARING: Create %s failed:%s. configDir=%s\n", logDirName, strerror(errno), configDir);
@@ -857,24 +955,12 @@ void taos_init_imp(void) {
     return;
   }
 
-  if (taosInitCfg(configDir, NULL, NULL, NULL, NULL, 1) != 0) {
+  ENV_ERR_RET(taosInitCfg(configDir, NULL, NULL, NULL, NULL, 1), "failed to init cfg");
-    tscInitRes = -1;
-    return;
-  }
 
   initQueryModuleMsgHandle();
-
+  ENV_ERR_RET(taosConvInit(), "failed to init conv");
-  if (taosConvInit() != 0) {
+  ENV_ERR_RET(monitorInit(), "failed to init monitor");
-    tscInitRes = -1;
+  ENV_ERR_RET(rpcInit(), "failed to init rpc");
-    tscError("failed to init conv");
-    return;
-  }
-  if (monitorInit() != 0){
-    tscInitRes = -1;
-    tscError("failed to init monitor");
-    return;
-  }
-  rpcInit();
 
   if (InitRegexCache() != 0) {
     tscInitRes = -1;
@@ -883,34 +969,26 @@ void taos_init_imp(void) {
   }
 
   SCatalogCfg cfg = {.maxDBCacheNum = 100, .maxTblCacheNum = 100};
-  catalogInit(&cfg);
+  ENV_ERR_RET(catalogInit(&cfg), "failed to init catalog");
+  ENV_ERR_RET(schedulerInit(), "failed to init scheduler");
 
-  schedulerInit();
   tscDebug("starting to initialize TAOS driver");
 
 #ifndef WINDOWS
   taosSetCoreDump(true);
 #endif
 
-  if (initTaskQueue() != 0){
+  ENV_ERR_RET(initTaskQueue(), "failed to init task queue");
-    tscInitRes = -1;
+  ENV_ERR_RET(fmFuncMgtInit(), "failed to init funcMgt");
-    tscError("failed to init task queue");
+  ENV_ERR_RET(nodesInitAllocatorSet(), "failed to init allocator set");
-    return;
-  }
-  if (fmFuncMgtInit() != TSDB_CODE_SUCCESS) {
-    tscInitRes = -1;
-    tscError("failed to init function manager");
-    return;
-  }
-  nodesInitAllocatorSet();
 
   clientConnRefPool = taosOpenRef(200, destroyTscObj);
   clientReqRefPool = taosOpenRef(40960, doDestroyRequest);
 
-  taosGetAppName(appInfo.appName, NULL);
+  ENV_ERR_RET(taosGetAppName(appInfo.appName, NULL), "failed to get app name");
-  taosThreadMutexInit(&appInfo.mutex, NULL);
+  ENV_ERR_RET(taosThreadMutexInit(&appInfo.mutex, NULL), "failed to init thread mutex");
-
+  ENV_ERR_RET(tscCrashReportInit(), "failed to init crash report");
-  tscCrashReportInit();
+  ENV_ERR_RET(qInitKeywordsTable(), "failed to init parser keywords table");
 
   tscDebug("client is initialized successfully");
 }
@@ -957,7 +1035,7 @@ int taos_options_imp(TSDB_OPTION option, const char *str) {
         return -1;
       }
       newstr[0] = '"';
-      memcpy(newstr+1, str, len);
+      (void)memcpy(newstr+1, str, len);
       newstr[len + 1] = '"';
       newstr[len + 2] = '\0';
       str = newstr;

source/client/src/clientJniConnector.c

@@ -73,7 +73,7 @@ void jniGetGlobalMethod(JNIEnv *env) {
   }
 
   if (g_vm == NULL) {
-    (*env)->GetJavaVM(env, &g_vm);
+    (void)(*env)->GetJavaVM(env, &g_vm);
   }
 
   jclass arrayListClass = (*env)->FindClass(env, "java/util/ArrayList");
@@ -582,20 +582,20 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_fetchRowImp(JNIEn
       case TSDB_DATA_TYPE_BINARY:
       case TSDB_DATA_TYPE_VARBINARY:
       case TSDB_DATA_TYPE_GEOMETRY: {
-        memcpy(tmp, row[i], length[i]);  // handle the case that terminated does not exist
+        (void)memcpy(tmp, row[i], length[i]);  // handle the case that terminated does not exist
         (*env)->CallVoidMethod(env, rowobj, g_rowdataSetStringFp, i, (*env)->NewStringUTF(env, tmp));
 
-        memset(tmp, 0, length[i]);
+        (void)memset(tmp, 0, length[i]);
         break;
       }
       case TSDB_DATA_TYPE_NCHAR: {
         (*env)->CallVoidMethod(env, rowobj, g_rowdataSetByteArrayFp, i,
-                               jniFromNCharToByteArray(env, (char *)row[i], length[i]));
+                                     jniFromNCharToByteArray(env, (char *)row[i], length[i]));
         break;
       }
       case TSDB_DATA_TYPE_JSON: {
         (*env)->CallVoidMethod(env, rowobj, g_rowdataSetByteArrayFp, i,
-                               jniFromNCharToByteArray(env, (char *)row[i], length[i]));
+                                     jniFromNCharToByteArray(env, (char *)row[i], length[i]));
         break;
       }
       case TSDB_DATA_TYPE_TIMESTAMP: {
@@ -680,6 +680,10 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_validateCreateTab
   jsize len = (*env)->GetArrayLength(env, jsql);
 
   char *str = (char *)taosMemoryCalloc(1, sizeof(char) * (len + 1));
+  if (str == NULL) {
+    jniError("jobj:%p, conn:%p, alloc memory failed", jobj, tscon);
+    return JNI_OUT_OF_MEMORY;
+  }
   (*env)->GetByteArrayRegion(env, jsql, 0, len, (jbyte *)str);
   if ((*env)->ExceptionCheck(env)) {
     // todo handle error
@@ -843,6 +847,10 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setTableNameTagsI
 
   jsize len = (*env)->GetArrayLength(env, tags);
   char *tagsData = (char *)taosMemoryCalloc(1, len);
+  if (tagsData == NULL) {
+    jniError("jobj:%p, conn:%p, alloc memory failed", jobj, tsconn);
+    return JNI_OUT_OF_MEMORY;
+  }
   (*env)->GetByteArrayRegion(env, tags, 0, len, (jbyte *)tagsData);
   if ((*env)->ExceptionCheck(env)) {
     // todo handle error
@@ -850,18 +858,30 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setTableNameTagsI
 
   len = (*env)->GetArrayLength(env, lengthList);
   int32_t *lengthArray = (int32_t *)taosMemoryCalloc(1, len);
+  if (lengthArray == NULL) {
+    jniError("jobj:%p, conn:%p, alloc memory failed", jobj, tsconn);
+    return JNI_OUT_OF_MEMORY;
+  }
   (*env)->GetByteArrayRegion(env, lengthList, 0, len, (jbyte *)lengthArray);
   if ((*env)->ExceptionCheck(env)) {
   }
 
   len = (*env)->GetArrayLength(env, typeList);
   char *typeArray = (char *)taosMemoryCalloc(1, len);
+  if (typeArray == NULL) {
+    jniError("jobj:%p, conn:%p, alloc memory failed", jobj, tsconn);
+    return JNI_OUT_OF_MEMORY;
+  }
   (*env)->GetByteArrayRegion(env, typeList, 0, len, (jbyte *)typeArray);
   if ((*env)->ExceptionCheck(env)) {
   }
 
   len = (*env)->GetArrayLength(env, nullList);
   char *nullArray = (char *)taosMemoryCalloc(1, len);
+  if (nullArray == NULL) {
+    jniError("jobj:%p, conn:%p, alloc memory failed", jobj, tsconn);
+    return JNI_OUT_OF_MEMORY;
+  }
   (*env)->GetByteArrayRegion(env, nullList, 0, len, (jbyte *)nullArray);
   if ((*env)->ExceptionCheck(env)) {
   }
@@ -870,6 +890,10 @@ JNIEXPORT jint JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_setTableNameTagsI
   char       *curTags = tagsData;
 
   TAOS_MULTI_BIND *tagsBind = taosMemoryCalloc(numOfTags, sizeof(TAOS_MULTI_BIND));
+  if (tagsBind == NULL) {
+    jniError("jobj:%p, conn:%p, alloc memory failed", jobj, tsconn);
+    return JNI_OUT_OF_MEMORY;
+  }
   for (int32_t i = 0; i < numOfTags; ++i) {
     tagsBind[i].buffer_type = typeArray[i];
     tagsBind[i].buffer = curTags;
@@ -916,6 +940,10 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_bindColDataImp(
   // todo refactor
   jsize len = (*env)->GetArrayLength(env, colDataList);
   char *colBuf = (char *)taosMemoryCalloc(1, len);
+  if (colBuf == NULL) {
+    jniError("jobj:%p, conn:%p, alloc memory failed", jobj, tscon);
+    return JNI_OUT_OF_MEMORY;
+  }
   (*env)->GetByteArrayRegion(env, colDataList, 0, len, (jbyte *)colBuf);
   if ((*env)->ExceptionCheck(env)) {
     // todo handle error
@@ -923,18 +951,30 @@ JNIEXPORT jlong JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_bindColDataImp(
 
   len = (*env)->GetArrayLength(env, lengthList);
   char *lengthArray = (char *)taosMemoryCalloc(1, len);
+  if (lengthArray == NULL) {
+    jniError("jobj:%p, conn:%p, alloc memory failed", jobj, tscon);
+    return JNI_OUT_OF_MEMORY;
+  }
   (*env)->GetByteArrayRegion(env, lengthList, 0, len, (jbyte *)lengthArray);
   if ((*env)->ExceptionCheck(env)) {
   }
 
   len = (*env)->GetArrayLength(env, nullList);
   char *nullArray = (char *)taosMemoryCalloc(1, len);
+  if (nullArray == NULL) {
+    jniError("jobj:%p, conn:%p, alloc memory failed", jobj, tscon);
+    return JNI_OUT_OF_MEMORY;
+  }
   (*env)->GetByteArrayRegion(env, nullList, 0, len, (jbyte *)nullArray);
   if ((*env)->ExceptionCheck(env)) {
   }
 
   // bind multi-rows with only one invoke.
   TAOS_MULTI_BIND *b = taosMemoryCalloc(1, sizeof(TAOS_MULTI_BIND));
+  if (b == NULL) {
+    jniError("jobj:%p, conn:%p, alloc memory failed", jobj, tscon);
+    return JNI_OUT_OF_MEMORY;
+  }
 
   b->num = numOfRows;
   b->buffer_type = dataType;  // todo check data type
@@ -1043,14 +1083,14 @@ JNIEXPORT jstring JNICALL Java_com_taosdata_jdbc_TSDBJNIConnector_stmtErrorMsgIm
   TAOS *tscon = (TAOS *)con;
   if (tscon == NULL) {
     jniError("jobj:%p, connection already closed", jobj);
-    sprintf(errMsg, "jobj:%p, connection already closed", jobj);
+    (void)sprintf(errMsg, "jobj:%p, connection already closed", jobj);
     return (*env)->NewStringUTF(env, errMsg);
   }
 
   TAOS_STMT *pStmt = (TAOS_STMT *)stmt;
   if (pStmt == NULL) {
     jniError("jobj:%p, conn:%p, invalid stmt", jobj, tscon);
-    sprintf(errMsg, "jobj:%p, conn:%p, invalid stmt", jobj, tscon);
+    (void)sprintf(errMsg, "jobj:%p, conn:%p, invalid stmt", jobj, tscon);
     return (*env)->NewStringUTF(env, errMsg);
   }
 

source/client/src/clientMain.c

@@ -69,15 +69,21 @@ void taos_cleanup(void) {
   qCleanupKeywordsTable();
   nodesDestroyAllocatorSet();
 
-  cleanupTaskQueue();
+  if (TSDB_CODE_SUCCESS != cleanupTaskQueue()) {
+    tscWarn("failed to cleanup task queue");
+  }
 
   int32_t id = clientReqRefPool;
   clientReqRefPool = -1;
-  taosCloseRef(id);
+  if (TSDB_CODE_SUCCESS != taosCloseRef(id)) {
+    tscWarn("failed to close clientReqRefPool");
+  }
 
   id = clientConnRefPool;
   clientConnRefPool = -1;
-  taosCloseRef(id);
+  if (TSDB_CODE_SUCCESS != taosCloseRef(id)) {
+    tscWarn("failed to close clientReqRefPool");
+  }
 
   DestroyRegexCache();
   rpcCleanup();
@@ -115,11 +121,19 @@ TAOS *taos_connect(const char *ip, const char *user, const char *pass, const cha
     pass = TSDB_DEFAULT_PASS;
   }
 
-  STscObj *pObj = taos_connect_internal(ip, user, pass, NULL, db, port, CONN_TYPE__QUERY);
+  STscObj *pObj = NULL;
-  if (pObj) {
+  int32_t code = taos_connect_internal(ip, user, pass, NULL, db, port, CONN_TYPE__QUERY, &pObj);
+  if (TSDB_CODE_SUCCESS == code) {
     int64_t *rid = taosMemoryCalloc(1, sizeof(int64_t));
+    if (NULL == rid) {
+      tscError("out of memory when taos connect to %s:%u, user:%s db:%s", ip, port, user, db);
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      return NULL;
+    }
     *rid = pObj->id;
     return (TAOS *)rid;
+  } else {
+    terrno = code;
   }
 
   return NULL;
@@ -140,24 +154,24 @@ int taos_set_notify_cb(TAOS *taos, __taos_notify_fn_t fp, void *param, int type)
 
   switch (type) {
     case TAOS_NOTIFY_PASSVER: {
-      taosThreadMutexLock(&pObj->mutex);
+      TSC_ERR_RET(taosThreadMutexLock(&pObj->mutex));
       pObj->passInfo.fp = fp;
       pObj->passInfo.param = param;
-      taosThreadMutexUnlock(&pObj->mutex);
+      TSC_ERR_RET(taosThreadMutexUnlock(&pObj->mutex));
       break;
     }
     case TAOS_NOTIFY_WHITELIST_VER: {
-      taosThreadMutexLock(&pObj->mutex);
+      TSC_ERR_RET(taosThreadMutexLock(&pObj->mutex));
       pObj->whiteListInfo.fp = fp;
       pObj->whiteListInfo.param = param;
-      taosThreadMutexUnlock(&pObj->mutex);
+      TSC_ERR_RET(taosThreadMutexUnlock(&pObj->mutex));
       break;
     }
     case TAOS_NOTIFY_USER_DROPPED: {
-      taosThreadMutexLock(&pObj->mutex);
+      TSC_ERR_RET(taosThreadMutexLock(&pObj->mutex));
       pObj->userDroppedInfo.fp = fp;
       pObj->userDroppedInfo.param = param;
-      taosThreadMutexUnlock(&pObj->mutex);
+      TSC_ERR_RET(taosThreadMutexUnlock(&pObj->mutex));
       break;
     }
     default: {
@@ -189,7 +203,13 @@ int32_t fetchWhiteListCallbackFn(void* param, SDataBuf* pMsg, int32_t code) {
   }
 
   SGetUserWhiteListRsp wlRsp;
-  tDeserializeSGetUserWhiteListRsp(pMsg->pData, pMsg->len, &wlRsp);
+  if (TSDB_CODE_SUCCESS != tDeserializeSGetUserWhiteListRsp(pMsg->pData, pMsg->len, &wlRsp)) {
+    taosMemoryFree(pMsg->pData);
+    taosMemoryFree(pMsg->pEpSet);
+    taosMemoryFree(pInfo);
+    tFreeSGetUserWhiteListRsp(&wlRsp);
+    return terrno;
+  }
 
   uint64_t* pWhiteLists = taosMemoryMalloc(wlRsp.numWhiteLists * sizeof(uint64_t));
   if (pWhiteLists == NULL) {
@@ -229,8 +249,14 @@ void taos_fetch_whitelist_a(TAOS *taos, __taos_async_whitelist_fn_t fp, void *pa
   }
 
   SGetUserWhiteListReq req;
-  memcpy(req.user, pTsc->user, TSDB_USER_LEN);
+  (void)memcpy(req.user, pTsc->user, TSDB_USER_LEN);
   int32_t msgLen = tSerializeSGetUserWhiteListReq(NULL, 0, &req);
+  if (msgLen < 0) {
+    fp(param, TSDB_CODE_INVALID_PARA, taos, 0, NULL);
+    releaseTscObj(connId);
+    return;
+  }
+
   void* pReq = taosMemoryMalloc(msgLen);
   if (pReq == NULL) {
     fp(param, TSDB_CODE_OUT_OF_MEMORY, taos, 0, NULL);
@@ -274,7 +300,9 @@ void taos_fetch_whitelist_a(TAOS *taos, __taos_async_whitelist_fn_t fp, void *pa
 
   int64_t transportId = 0;
   SEpSet epSet = getEpSet_s(&pTsc->pAppInfo->mgmtEp);
-  asyncSendMsgToServer(pTsc->pAppInfo->pTransporter, &epSet, &transportId, pSendInfo);
+  if (TSDB_CODE_SUCCESS != asyncSendMsgToServer(pTsc->pAppInfo->pTransporter, &epSet, &transportId, pSendInfo)) {
+    tscWarn("failed to async send msg to server");
+  }
   releaseTscObj(connId);
   return;
 }
@@ -287,7 +315,7 @@ void taos_close_internal(void *taos) {
   STscObj *pTscObj = (STscObj *)taos;
   tscDebug("0x%" PRIx64 " try to close connection, numOfReq:%d", pTscObj->id, pTscObj->numOfReqs);
 
-  taosRemoveRef(clientConnRefPool, pTscObj->id);
+  (void)taosRemoveRef(clientConnRefPool, pTscObj->id);
 }
 
 void taos_close(TAOS *taos) {
@@ -426,9 +454,11 @@ TAOS_ROW taos_fetch_row(TAOS_RES *res) {
     return doAsyncFetchRows(pRequest, true, true);
   } else if (TD_RES_TMQ(res) || TD_RES_TMQ_METADATA(res)) {
     SMqRspObj      *msg = ((SMqRspObj *)res);
-    SReqResultInfo *pResultInfo;
+    SReqResultInfo *pResultInfo = NULL;
     if (msg->common.resIter == -1) {
-      pResultInfo = tmqGetNextResInfo(res, true);
+      if(tmqGetNextResInfo(res, true, &pResultInfo) != 0){
+        return NULL;
+      }
     } else {
       pResultInfo = tmqGetCurResInfo(res);
     }
@@ -438,8 +468,7 @@ TAOS_ROW taos_fetch_row(TAOS_RES *res) {
       pResultInfo->current += 1;
       return pResultInfo->row;
     } else {
-      pResultInfo = tmqGetNextResInfo(res, true);
+      if (tmqGetNextResInfo(res, true, &pResultInfo) != 0){
-      if (pResultInfo == NULL) {
         return NULL;
       }
 
@@ -452,6 +481,7 @@ TAOS_ROW taos_fetch_row(TAOS_RES *res) {
   } else {
     // assert to avoid un-initialization error
     tscError("invalid result passed to taos_fetch_row");
+    terrno = TSDB_CODE_TSC_INTERNAL_ERROR;
     return NULL;
   }
 }
@@ -520,7 +550,7 @@ int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields)
         if(taosAscii2Hex(row[i], charLen, &data, &size) < 0){
           break;
         }
-        memcpy(str + len, data, size);
+        (void)memcpy(str + len, data, size);
         len += size;
         taosMemoryFree(data);
       }break;
@@ -538,7 +568,7 @@ int taos_print_row(char *str, TAOS_ROW row, TAOS_FIELD *fields, int num_fields)
           }
         }
 
-        memcpy(str + len, row[i], charLen);
+        (void)memcpy(str + len, row[i], charLen);
         len += charLen;
       } break;
 
@@ -685,7 +715,7 @@ int taos_select_db(TAOS *taos, const char *db) {
   }
 
   char sql[256] = {0};
-  snprintf(sql, tListLen(sql), "use %s", db);
+  (void)snprintf(sql, tListLen(sql), "use %s", db);
 
   TAOS_RES *pRequest = taos_query(taos, sql);
   int32_t   code = taos_errno(pRequest);
@@ -741,10 +771,10 @@ int taos_fetch_block_s(TAOS_RES *res, int *numOfRows, TAOS_ROW *rows) {
 
     if (pRequest->type == TSDB_SQL_RETRIEVE_EMPTY_RESULT || pRequest->type == TSDB_SQL_INSERT ||
         pRequest->code != TSDB_CODE_SUCCESS || taos_num_fields(res) == 0) {
-      return 0;
+      return pRequest->code;
     }
 
-    doAsyncFetchRows(pRequest, false, true);
+    (void)doAsyncFetchRows(pRequest, false, true);
 
     // TODO refactor
     SReqResultInfo *pResultInfo = &pRequest->body.resInfo;
@@ -754,8 +784,9 @@ int taos_fetch_block_s(TAOS_RES *res, int *numOfRows, TAOS_ROW *rows) {
     (*numOfRows) = pResultInfo->numOfRows;
     return pRequest->code;
   } else if (TD_RES_TMQ(res) || TD_RES_TMQ_METADATA(res)) {
-    SReqResultInfo *pResultInfo = tmqGetNextResInfo(res, true);
+    SReqResultInfo *pResultInfo = NULL;
-    if (pResultInfo == NULL) return -1;
+    int32_t code = tmqGetNextResInfo(res, true, &pResultInfo);
+    if (code != 0) return code;
 
     pResultInfo->current = pResultInfo->numOfRows;
     (*rows) = pResultInfo->row;
@@ -776,8 +807,9 @@ int taos_fetch_raw_block(TAOS_RES *res, int *numOfRows, void **pData) {
   }
 
   if (TD_RES_TMQ(res) || TD_RES_TMQ_METADATA(res)) {
-    SReqResultInfo *pResultInfo = tmqGetNextResInfo(res, false);
+    SReqResultInfo *pResultInfo = NULL;
-    if (pResultInfo == NULL) {
+    int32_t code = tmqGetNextResInfo(res, false, &pResultInfo);
+    if (code != 0) {
       (*numOfRows) = 0;
       return 0;
     }
@@ -792,10 +824,10 @@ int taos_fetch_raw_block(TAOS_RES *res, int *numOfRows, void **pData) {
 
   if (pRequest->type == TSDB_SQL_RETRIEVE_EMPTY_RESULT || pRequest->type == TSDB_SQL_INSERT ||
       pRequest->code != TSDB_CODE_SUCCESS || taos_num_fields(res) == 0) {
-    return 0;
+    return pRequest->code;
   }
 
-  doAsyncFetchRows(pRequest, false, false);
+  (void)doAsyncFetchRows(pRequest, false, false);
 
   SReqResultInfo *pResultInfo = &pRequest->body.resInfo;
 
@@ -803,7 +835,7 @@ int taos_fetch_raw_block(TAOS_RES *res, int *numOfRows, void **pData) {
   (*numOfRows) = pResultInfo->numOfRows;
   (*pData) = (void *)pResultInfo->pData;
 
-  return 0;
+  return pRequest->code;
 }
 
 int *taos_get_column_data_offset(TAOS_RES *res, int columnIndex) {
@@ -861,26 +893,24 @@ const char *taos_get_server_info(TAOS *taos) {
 int taos_get_current_db(TAOS *taos, char *database, int len, int *required) {
   STscObj *pTscObj = acquireTscObj(*(int64_t *)taos);
   if (pTscObj == NULL) {
-    terrno = TSDB_CODE_TSC_DISCONNECTED;
+    return TSDB_CODE_TSC_DISCONNECTED;
-    return -1;
   }
 
   int code = TSDB_CODE_SUCCESS;
-  taosThreadMutexLock(&pTscObj->mutex);
+  (void)taosThreadMutexLock(&pTscObj->mutex);
   if (database == NULL || len <= 0) {
     if (required != NULL) *required = strlen(pTscObj->db) + 1;
-    terrno = TSDB_CODE_INVALID_PARA;
+    TSC_ERR_JRET(TSDB_CODE_INVALID_PARA);
-    code = -1;
   } else if (len < strlen(pTscObj->db) + 1) {
     tstrncpy(database, pTscObj->db, len);
     if (required) *required = strlen(pTscObj->db) + 1;
-    terrno = TSDB_CODE_INVALID_PARA;
+    TSC_ERR_JRET(TSDB_CODE_INVALID_PARA);
-    code = -1;
   } else {
-    strcpy(database, pTscObj->db);
+    (void)strcpy(database, pTscObj->db);
     code = 0;
   }
-  taosThreadMutexUnlock(&pTscObj->mutex);
+_return:
+  (void)taosThreadMutexUnlock(&pTscObj->mutex);
   releaseTscObj(*(int64_t *)taos);
   return code;
 }
@@ -921,8 +951,8 @@ static void doAsyncQueryFromAnalyse(SMetaData *pResultMeta, void *param, int32_t
   pRequest->metric.analyseCostUs += taosGetTimestampUs() - analyseStart;
 
   if (pRequest->parseOnly) {
-    memcpy(&pRequest->parseMeta, pResultMeta, sizeof(*pResultMeta));
+    (void)memcpy(&pRequest->parseMeta, pResultMeta, sizeof(*pResultMeta));
-    memset(pResultMeta, 0, sizeof(*pResultMeta));
+    (void)memset(pResultMeta, 0, sizeof(*pResultMeta));
   }
   
   handleQueryAnslyseRes(pWrapper, pResultMeta, code);
@@ -969,10 +999,9 @@ void handleSubQueryFromAnalyse(SSqlCallbackWrapper *pWrapper, SMetaData *pResult
     return;
   }
 
-  pNewRequest->pQuery = (SQuery *)nodesMakeNode(QUERY_NODE_QUERY);
+  pNewRequest->pQuery = NULL;
-  if (NULL == pNewRequest->pQuery) {
+  code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pNewRequest->pQuery);
-    code = TSDB_CODE_OUT_OF_MEMORY;
+  if (pNewRequest->pQuery) {
-  } else {
     pNewRequest->pQuery->pRoot = pRoot;
     pRoot = NULL;
     pNewRequest->pQuery->execStage = QUERY_EXEC_STAGE_ANALYSE;
@@ -1010,10 +1039,12 @@ void handleQueryAnslyseRes(SSqlCallbackWrapper *pWrapper, SMetaData *pResultMeta
     }
 
     if (pQuery->haveResultSet) {
-      setResSchemaInfo(&pRequest->body.resInfo, pQuery->pResSchema, pQuery->numOfResCols);
+      code = setResSchemaInfo(&pRequest->body.resInfo, pQuery->pResSchema, pQuery->numOfResCols);
       setResPrecision(&pRequest->body.resInfo, pQuery->precision);
     }
+  }
 
+  if (code == TSDB_CODE_SUCCESS) {
     TSWAP(pRequest->dbList, (pQuery)->pDbList);
     TSWAP(pRequest->tableList, (pQuery)->pTableList);
     TSWAP(pRequest->targetTableList, (pQuery)->pTargetTableList);
@@ -1198,7 +1229,7 @@ int32_t prepareAndParseSqlSyntax(SSqlCallbackWrapper **ppWrapper, SRequestObj *p
       code = TSDB_CODE_OUT_OF_MEMORY;
     } else {
       pWrapper->pCatalogReq->forceUpdate = updateMetaForce;
-      pWrapper->pCatalogReq->qNodeRequired = qnodeRequired(pRequest);
+      TSC_ERR_RET(qnodeRequired(pRequest, &pWrapper->pCatalogReq->qNodeRequired));
       code = qParseSqlSyntax(pWrapper->pParseCtx, &pRequest->pQuery, pWrapper->pCatalogReq);
     }
 
@@ -1241,7 +1272,7 @@ void doAsyncQuery(SRequestObj *pRequest, bool updateMetaForce) {
     if (NEED_CLIENT_HANDLE_ERROR(code)) {
       tscDebug("0x%" PRIx64 " client retry to handle the error, code:%d - %s, tryCount:%d, reqId:0x%" PRIx64,
                pRequest->self, code, tstrerror(code), pRequest->retry, pRequest->requestId);
-      refreshMeta(pRequest->pTscObj, pRequest);
+      (void)refreshMeta(pRequest->pTscObj, pRequest); //ignore return code,try again
       pRequest->prevCode = code;
       doAsyncQuery(pRequest, true);
       return;
@@ -1256,13 +1287,13 @@ void doAsyncQuery(SRequestObj *pRequest, bool updateMetaForce) {
 void restartAsyncQuery(SRequestObj *pRequest, int32_t code) {
   tscInfo("restart request: %s p: %p", pRequest->sqlstr, pRequest);
   SRequestObj* pUserReq = pRequest;
-  acquireRequest(pRequest->self);
+  (void)acquireRequest(pRequest->self);
   while (pUserReq) {
     if (pUserReq->self == pUserReq->relation.userRefId || pUserReq->relation.userRefId == 0) {
       break;
     } else {
       int64_t nextRefId = pUserReq->relation.nextRefId;
-      releaseRequest(pUserReq->self);
+      (void)releaseRequest(pUserReq->self);
       if (nextRefId) {
         pUserReq = acquireRequest(nextRefId);
       }
@@ -1272,16 +1303,16 @@ void restartAsyncQuery(SRequestObj *pRequest, int32_t code) {
   if (pUserReq) {
     destroyCtxInRequest(pUserReq);
     pUserReq->prevCode = code;
-    memset(&pUserReq->relation, 0, sizeof(pUserReq->relation));
+    (void)memset(&pUserReq->relation, 0, sizeof(pUserReq->relation));
   } else {
     tscError("User req is missing");
-    removeFromMostPrevReq(pRequest);
+    (void)removeFromMostPrevReq(pRequest);
     return;
   }
   if (hasSubRequest)
-    removeFromMostPrevReq(pRequest);
+    (void)removeFromMostPrevReq(pRequest);
   else
-    releaseRequest(pUserReq->self);
+    (void)releaseRequest(pUserReq->self);
   doAsyncQuery(pUserReq, true);
 }
 
@@ -1371,7 +1402,7 @@ int taos_get_db_route_info(TAOS *taos, const char *db, TAOS_DB_ROUTE_INFO *dbInf
   conn.mgmtEps = getEpSet_s(&pTscObj->pAppInfo->mgmtEp);
 
   char dbFName[TSDB_DB_FNAME_LEN] = {0};
-  snprintf(dbFName, sizeof(dbFName), "%d.%s", pTscObj->acctId, db);
+  (void)snprintf(dbFName, sizeof(dbFName), "%d.%s", pTscObj->acctId, db);
 
   code = catalogGetDBVgInfo(pCtg, &conn, dbFName, dbInfo);
   if (code) {
@@ -1421,7 +1452,7 @@ int taos_get_table_vgId(TAOS *taos, const char *db, const char *table, int *vgId
   conn.mgmtEps = getEpSet_s(&pTscObj->pAppInfo->mgmtEp);
 
   SName tableName;
-  toName(pTscObj->acctId, db, table, &tableName);
+  (void)toName(pTscObj->acctId, db, table, &tableName);
 
   SVgroupInfo vgInfo;
   code = catalogGetTableHashVgroup(pCtg, &conn, &tableName, &vgInfo);
@@ -1542,7 +1573,7 @@ int taos_load_table_info(TAOS *taos, const char *tableNameList) {
   }
 
   SSyncQueryParam *pParam = pRequest->body.interParam;
-  tsem_wait(&pParam->sem);
+  (void)tsem_wait(&pParam->sem);
 
 _return:
   destoryCatalogReq(&catalogReq);
@@ -1559,7 +1590,9 @@ TAOS_STMT *taos_stmt_init(TAOS *taos) {
   }
 
   TAOS_STMT *pStmt = stmtInit(pObj, 0, NULL);
-
+  if (NULL == pStmt) {
+    tscError("stmt init failed, errcode:%s", terrstr());
+  }
   releaseTscObj(*(int64_t *)taos);
 
   return pStmt;
@@ -1574,7 +1607,9 @@ TAOS_STMT *taos_stmt_init_with_reqid(TAOS *taos, int64_t reqid) {
   }
 
   TAOS_STMT *pStmt = stmtInit(pObj, reqid, NULL);
-
+  if (NULL == pStmt) {
+    tscError("stmt init failed, errcode:%s", terrstr());
+  }
   releaseTscObj(*(int64_t *)taos);
 
   return pStmt;
@@ -1589,7 +1624,9 @@ TAOS_STMT *taos_stmt_init_with_options(TAOS *taos, TAOS_STMT_OPTIONS *options) {
   }
 
   TAOS_STMT *pStmt = stmtInit(pObj, options->reqId, options);
-
+  if (NULL == pStmt) {
+    tscError("stmt init failed, errcode:%s", terrstr());
+  }
   releaseTscObj(*(int64_t *)taos);
 
   return pStmt;
@@ -1704,7 +1741,11 @@ int taos_stmt_bind_param_batch(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind) {
   }
 
   int32_t insert = 0;
-  stmtIsInsert(stmt, &insert);
+  int32_t code = stmtIsInsert(stmt, &insert);
+  if (TSDB_CODE_SUCCESS != code) {
+    tscError("stmt insert failed, errcode:%s", tstrerror(code));
+    return code;
+  }
   if (0 == insert && bind->num > 1) {
     tscError("only one row data allowed for query");
     terrno = TSDB_CODE_INVALID_PARA;
@@ -1728,7 +1769,11 @@ int taos_stmt_bind_single_param_batch(TAOS_STMT *stmt, TAOS_MULTI_BIND *bind, in
   }
 
   int32_t insert = 0;
-  stmtIsInsert(stmt, &insert);
+  int32_t code = stmtIsInsert(stmt, &insert);
+  if (TSDB_CODE_SUCCESS != code) {
+    tscError("stmt insert failed, errcode:%s", tstrerror(code));
+    return code;
+  }
   if (0 == insert && bind->num > 1) {
     tscError("only one row data allowed for query");
     terrno = TSDB_CODE_INVALID_PARA;
@@ -1855,4 +1900,4 @@ int taos_set_conn_mode(TAOS* taos, int mode, int value) {
 
 char* getBuildInfo(){
     return buildinfo;
-}
+}

source/client/src/clientRawBlockWrite.c

@@ -484,7 +484,7 @@ static void buildChildElement(cJSON* json, SVCreateTbReq* pCreateReq) {
 
 end:
   RAW_FALSE_CHECK(cJSON_AddItemToObject(json, "tags", tags));
-  (void)taosArrayDestroy(pTagVals);
+  taosArrayDestroy(pTagVals);
 }
 
 static void buildCreateCTableJson(SVCreateTbReq* pCreateReq, int32_t nReqs, cJSON** pJson) {
@@ -588,7 +588,7 @@ end:
     tDecoderClear(&decoder[i]);
     taosMemoryFreeClear(pCreateReq[i].comment);
     if (pCreateReq[i].type == TSDB_CHILD_TABLE) {
-      (void)taosArrayDestroy(pCreateReq[i].ctb.tagName);
+      taosArrayDestroy(pCreateReq[i].ctb.tagName);
     }
   }
   taosMemoryFree(decoder);
@@ -1097,7 +1097,7 @@ typedef struct SVgroupCreateTableBatch {
 
 static void destroyCreateTbReqBatch(void* data) {
   SVgroupCreateTableBatch* pTbBatch = (SVgroupCreateTableBatch*)data;
-  (void)taosArrayDestroy(pTbBatch->req.pArray);
+  taosArrayDestroy(pTbBatch->req.pArray);
 }
 
 static int32_t taosCreateTable(TAOS* taos, void* meta, int32_t metaLen) {
@@ -1214,12 +1214,14 @@ static int32_t taosCreateTable(TAOS* taos, void* meta, int32_t metaLen) {
   }
   SArray* pBufArray = NULL;
   RAW_RETURN_CHECK(serializeVgroupsCreateTableBatch(pVgroupHashmap, &pBufArray));
-  pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY);
+  pQuery = NULL;
-  RAW_NULL_CHECK(pQuery);
+  code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pQuery);
+  if (TSDB_CODE_SUCCESS != code) goto end;
   pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
   pQuery->msgType = TDMT_VND_CREATE_TABLE;
   pQuery->stableQuery = false;
-  pQuery->pRoot = nodesMakeNode(QUERY_NODE_CREATE_TABLE_STMT);
+  code = nodesMakeNode(QUERY_NODE_CREATE_TABLE_STMT, &pQuery->pRoot);
+  if (TSDB_CODE_SUCCESS != code) goto end;
   RAW_NULL_CHECK(pQuery->pRoot);
 
   RAW_RETURN_CHECK(rewriteToVnodeModifyOpStmt(pQuery, pBufArray));
@@ -1250,7 +1252,7 @@ typedef struct SVgroupDropTableBatch {
 
 static void destroyDropTbReqBatch(void* data) {
   SVgroupDropTableBatch* pTbBatch = (SVgroupDropTableBatch*)data;
-  (void)taosArrayDestroy(pTbBatch->req.pArray);
+  taosArrayDestroy(pTbBatch->req.pArray);
 }
 
 static int32_t taosDropTable(TAOS* taos, void* meta, int32_t metaLen) {
@@ -1343,13 +1345,14 @@ static int32_t taosDropTable(TAOS* taos, void* meta, int32_t metaLen) {
   }
   SArray* pBufArray = NULL;
   RAW_RETURN_CHECK(serializeVgroupsDropTableBatch(pVgroupHashmap, &pBufArray));
-  pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY);
+  code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pQuery);
-  RAW_NULL_CHECK(pQuery);
+  if (TSDB_CODE_SUCCESS != code) goto end;
   pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
   pQuery->msgType = TDMT_VND_DROP_TABLE;
   pQuery->stableQuery = false;
-  pQuery->pRoot = nodesMakeNode(QUERY_NODE_DROP_TABLE_STMT);
+  pQuery->pRoot = NULL;
-  RAW_NULL_CHECK(pQuery->pRoot);
+  code = nodesMakeNode(QUERY_NODE_DROP_TABLE_STMT, &pQuery->pRoot);
+  if (TSDB_CODE_SUCCESS != code) goto end;
   RAW_RETURN_CHECK(rewriteToVnodeModifyOpStmt(pQuery, pBufArray));
 
   (void)launchQueryImpl(pRequest, pQuery, true, NULL);
@@ -1486,13 +1489,15 @@ static int32_t taosAlterTable(TAOS* taos, void* meta, int32_t metaLen) {
   pVgData->numOfTables = 1;
   RAW_NULL_CHECK(taosArrayPush(pArray, &pVgData));
 
-  pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY);
+  pQuery = NULL;
-  RAW_NULL_CHECK(pQuery);
+  code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pQuery);
+  if (NULL == pQuery) goto end;
   pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE;
   pQuery->msgType = TDMT_VND_ALTER_TABLE;
   pQuery->stableQuery = false;
-  pQuery->pRoot = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT);
+  pQuery->pRoot = NULL;
-  RAW_NULL_CHECK(pQuery->pRoot);
+  code = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT, &pQuery->pRoot);
+  if (TSDB_CODE_SUCCESS != code) goto end;
   RAW_RETURN_CHECK(rewriteToVnodeModifyOpStmt(pQuery, pArray));
 
 
@@ -1513,7 +1518,7 @@ static int32_t taosAlterTable(TAOS* taos, void* meta, int32_t metaLen) {
   }
 end:
   uDebug(LOG_ID_TAG " alter table return, meta:%p, len:%d, msg:%s", LOG_ID_VALUE, meta, metaLen, tstrerror(code));
-  (void)taosArrayDestroy(pArray);
+  taosArrayDestroy(pArray);
   if (pVgData) taosMemoryFreeClear(pVgData->pData);
   taosMemoryFreeClear(pVgData);
   destroyRequest(pRequest);
@@ -1537,8 +1542,8 @@ int taos_write_raw_block_with_fields_with_reqid(TAOS* taos, int rows, char* pDat
   SQuery*     pQuery = NULL;
   SHashObj*   pVgHash = NULL;
 
-  SRequestObj* pRequest = (SRequestObj*)createRequest(*(int64_t*)taos, TSDB_SQL_INSERT, reqid);
+  SRequestObj* pRequest = NULL;
-  RAW_NULL_CHECK(pRequest);
+  RAW_RETURN_CHECK(createRequest(*(int64_t*)taos, TSDB_SQL_INSERT, reqid, &pRequest));
 
   uDebug(LOG_ID_TAG " write raw block with field, rows:%d, pData:%p, tbname:%s, fields:%p, numFields:%d", LOG_ID_VALUE,
          rows, pData, tbname, fields, numFields);
@@ -1597,8 +1602,8 @@ int taos_write_raw_block_with_reqid(TAOS* taos, int rows, char* pData, const cha
   SQuery*     pQuery = NULL;
   SHashObj*   pVgHash = NULL;
 
-  SRequestObj* pRequest = (SRequestObj*)createRequest(*(int64_t*)taos, TSDB_SQL_INSERT, reqid);
+  SRequestObj* pRequest = NULL;
-  RAW_NULL_CHECK(pRequest);
+  RAW_RETURN_CHECK(createRequest(*(int64_t*)taos, TSDB_SQL_INSERT, reqid, &pRequest));
 
   uDebug(LOG_ID_TAG " write raw block, rows:%d, pData:%p, tbname:%s", LOG_ID_VALUE, rows, pData, tbname);
 
@@ -1667,8 +1672,8 @@ static int32_t tmqWriteRawDataImpl(TAOS* taos, void* data, int32_t dataLen) {
   SDecoder    decoder = {0};
   STableMeta* pTableMeta = NULL;
 
-  SRequestObj* pRequest = (SRequestObj*)createRequest(*(int64_t*)taos, TSDB_SQL_INSERT, 0);
+  SRequestObj* pRequest = NULL;
-  RAW_NULL_CHECK(pRequest);
+  RAW_RETURN_CHECK(createRequest(*(int64_t*)taos, TSDB_SQL_INSERT, 0, &pRequest));
 
   uDebug(LOG_ID_TAG " write raw data, data:%p, dataLen:%d", LOG_ID_VALUE, data, dataLen);
   pRequest->syncQuery = true;
@@ -1778,8 +1783,8 @@ static int32_t tmqWriteRawMetaDataImpl(TAOS* taos, void* data, int32_t dataLen)
   STableMeta*    pTableMeta = NULL;
   SVCreateTbReq* pCreateReqDst = NULL;
 
-  SRequestObj* pRequest = (SRequestObj*)createRequest(*(int64_t*)taos, TSDB_SQL_INSERT, 0);
+  SRequestObj* pRequest = NULL;
-  RAW_NULL_CHECK(pRequest);
+  RAW_RETURN_CHECK(createRequest(*(int64_t*)taos, TSDB_SQL_INSERT, 0, &pRequest));
 
   uDebug(LOG_ID_TAG " write raw metadata, data:%p, dataLen:%d", LOG_ID_VALUE, data, dataLen);
   pRequest->syncQuery = true;

source/client/src/clientSml.c

@@ -197,8 +197,8 @@ static void smlDestroySTableMeta(void *para) {
   SSmlSTableMeta *meta = *(SSmlSTableMeta **)para;
   taosHashCleanup(meta->tagHash);
   taosHashCleanup(meta->colHash);
-  (void)taosArrayDestroy(meta->tags);
+  taosArrayDestroy(meta->tags);
-  (void)taosArrayDestroy(meta->cols);
+  taosArrayDestroy(meta->cols);
   taosMemoryFreeClear(meta->tableMeta);
   taosMemoryFree(meta);
 }
@@ -568,7 +568,7 @@ int32_t smlSetCTableName(SSmlTableInfo *oneTable) {
     if (code != TSDB_CODE_SUCCESS){
       return code;
     }
-    (void)taosArrayDestroy(dst);
+    taosArrayDestroy(dst);
   }
   return TSDB_CODE_SUCCESS;
 }
@@ -1198,25 +1198,25 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
       SArray *pTags = taosArrayInit(taosArrayGetSize(sTableData->tags), sizeof(SField));
       if (pTags == NULL) {
         code = TSDB_CODE_OUT_OF_MEMORY;
-        (void)taosArrayDestroy(pColumns);
+        taosArrayDestroy(pColumns);
         goto end;
       }
       code = smlBuildFieldsList(info, NULL, NULL, sTableData->tags, pTags, 0, true);
       if (code != TSDB_CODE_SUCCESS) {
         uError("SML:0x%" PRIx64 " smlBuildFieldsList tag1 failed. %s", info->id, pName.tname);
-        (void)taosArrayDestroy(pColumns);
+        taosArrayDestroy(pColumns);
-        (void)taosArrayDestroy(pTags);
+        taosArrayDestroy(pTags);
         goto end;
       }
       code = smlBuildFieldsList(info, NULL, NULL, sTableData->cols, pColumns, 0, false);
       if (code != TSDB_CODE_SUCCESS) {
         uError("SML:0x%" PRIx64 " smlBuildFieldsList col1 failed. %s", info->id, pName.tname);
-        (void)taosArrayDestroy(pColumns);
+        taosArrayDestroy(pColumns);
-        (void)taosArrayDestroy(pTags);
+        taosArrayDestroy(pTags);
         goto end;
       }
       code = smlSendMetaMsg(info, &pName, pColumns, pTags, NULL, SCHEMA_ACTION_CREATE_STABLE);
-      (void)taosArrayDestroy(pColumns);
+      taosArrayDestroy(pColumns);
       if (code != TSDB_CODE_SUCCESS) {
         uError("SML:0x%" PRIx64 " smlSendMetaMsg failed. can not create %s", info->id, pName.tname);
         goto end;
@@ -1271,7 +1271,7 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
         SArray *pTags =
             taosArrayInit(taosArrayGetSize(sTableData->tags) + pTableMeta->tableInfo.numOfTags, sizeof(SField));
         if (pTags == NULL){
-          (void)taosArrayDestroy(pColumns);
+          taosArrayDestroy(pColumns);
           code = TSDB_CODE_OUT_OF_MEMORY;
           goto end;
         }
@@ -1282,15 +1282,15 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
           tstrncpy(field.name, pTableMeta->schema[i].name, sizeof(field.name));
           if (i < pTableMeta->tableInfo.numOfColumns) {
             if (taosArrayPush(pColumns, &field) == NULL){
-              (void)taosArrayDestroy(pColumns);
+              taosArrayDestroy(pColumns);
-              (void)taosArrayDestroy(pTags);
+              taosArrayDestroy(pTags);
               code = TSDB_CODE_OUT_OF_MEMORY;
               goto end;
             }
           } else {
             if (taosArrayPush(pTags, &field) == NULL){
-              (void)taosArrayDestroy(pColumns);
+              taosArrayDestroy(pColumns);
-              (void)taosArrayDestroy(pTags);
+              taosArrayDestroy(pTags);
               code = TSDB_CODE_OUT_OF_MEMORY;
               goto end;
             }
@@ -1300,28 +1300,28 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
                                   pTableMeta->tableInfo.numOfColumns, true);
         if (code != TSDB_CODE_SUCCESS) {
           uError("SML:0x%" PRIx64 " smlBuildFieldsList tag2 failed. %s", info->id, pName.tname);
-          (void)taosArrayDestroy(pColumns);
+          taosArrayDestroy(pColumns);
-          (void)taosArrayDestroy(pTags);
+          taosArrayDestroy(pTags);
           goto end;
         }
 
         if (taosArrayGetSize(pTags) + pTableMeta->tableInfo.numOfColumns > TSDB_MAX_COLUMNS) {
           uError("SML:0x%" PRIx64 " too many columns than 4096", info->id);
           code = TSDB_CODE_PAR_TOO_MANY_COLUMNS;
-          (void)taosArrayDestroy(pColumns);
+          taosArrayDestroy(pColumns);
-          (void)taosArrayDestroy(pTags);
+          taosArrayDestroy(pTags);
           goto end;
         }
         if (taosArrayGetSize(pTags) > TSDB_MAX_TAGS) {
           uError("SML:0x%" PRIx64 " too many tags than 128", info->id);
           code = TSDB_CODE_PAR_INVALID_TAGS_NUM;
-          (void)taosArrayDestroy(pColumns);
+          taosArrayDestroy(pColumns);
-          (void)taosArrayDestroy(pTags);
+          taosArrayDestroy(pTags);
           goto end;
         }
 
         code = smlSendMetaMsg(info, &pName, pColumns, pTags, pTableMeta, action);
-        (void)taosArrayDestroy(pColumns);
+        taosArrayDestroy(pColumns);
         if (code != TSDB_CODE_SUCCESS) {
           uError("SML:0x%" PRIx64 " smlSendMetaMsg failed. can not create %s", info->id, pName.tname);
           goto end;
@@ -1367,7 +1367,7 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
         SArray *pTags =
             taosArrayInit(taosArrayGetSize(sTableData->tags) + pTableMeta->tableInfo.numOfTags, sizeof(SField));
         if (pTags == NULL){
-          (void)taosArrayDestroy(pColumns);
+          taosArrayDestroy(pColumns);
           code = TSDB_CODE_OUT_OF_MEMORY;
           goto end;
         }
@@ -1378,15 +1378,15 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
           tstrncpy(field.name, pTableMeta->schema[i].name, sizeof(field.name));
           if (i < pTableMeta->tableInfo.numOfColumns) {
             if (taosArrayPush(pColumns, &field) == NULL){
-              (void)taosArrayDestroy(pColumns);
+              taosArrayDestroy(pColumns);
-              (void)taosArrayDestroy(pTags);
+              taosArrayDestroy(pTags);
               code = TSDB_CODE_OUT_OF_MEMORY;
               goto end;
             }
           } else {
             if (taosArrayPush(pTags, &field) == NULL){
-              (void)taosArrayDestroy(pColumns);
+              taosArrayDestroy(pColumns);
-              (void)taosArrayDestroy(pTags);
+              taosArrayDestroy(pTags);
               code = TSDB_CODE_OUT_OF_MEMORY;
               goto end;
             }
@@ -1397,21 +1397,21 @@ static int32_t smlModifyDBSchemas(SSmlHandle *info) {
                                   pTableMeta->tableInfo.numOfColumns, false);
         if (code != TSDB_CODE_SUCCESS) {
           uError("SML:0x%" PRIx64 " smlBuildFieldsList col2 failed. %s", info->id, pName.tname);
-          (void)taosArrayDestroy(pColumns);
+          taosArrayDestroy(pColumns);
-          (void)taosArrayDestroy(pTags);
+          taosArrayDestroy(pTags);
           goto end;
         }
 
         if (taosArrayGetSize(pColumns) + pTableMeta->tableInfo.numOfTags > TSDB_MAX_COLUMNS) {
           uError("SML:0x%" PRIx64 " too many columns than 4096", info->id);
           code = TSDB_CODE_PAR_TOO_MANY_COLUMNS;
-          (void)taosArrayDestroy(pColumns);
+          taosArrayDestroy(pColumns);
-          (void)taosArrayDestroy(pTags);
+          taosArrayDestroy(pTags);
           goto end;
         }
 
         code = smlSendMetaMsg(info, &pName, pColumns, pTags, pTableMeta, action);
-        (void)taosArrayDestroy(pColumns);
+        taosArrayDestroy(pColumns);
         if (code != TSDB_CODE_SUCCESS) {
           uError("SML:0x%" PRIx64 " smlSendMetaMsg failed. can not create %s", info->id, pName.tname);
           goto end;
@@ -1555,7 +1555,7 @@ void smlDestroyTableInfo(void *para) {
     taosHashCleanup(kvHash);
   }
 
-  (void)taosArrayDestroy(tag->cols);
+  taosArrayDestroy(tag->cols);
   taosArrayDestroyEx(tag->tags, freeSSmlKv);
   taosMemoryFree(tag);
 }
@@ -1581,13 +1581,13 @@ void smlDestroyInfo(SSmlHandle *info) {
     cJSON *tags = (cJSON *)taosArrayGetP(info->tagJsonArray, i);
     cJSON_Delete(tags);
   }
-  (void)taosArrayDestroy(info->tagJsonArray);
+  taosArrayDestroy(info->tagJsonArray);
 
   for (int i = 0; i < taosArrayGetSize(info->valueJsonArray); i++) {
     cJSON *value = (cJSON *)taosArrayGetP(info->valueJsonArray, i);
     cJSON_Delete(value);
   }
-  (void)taosArrayDestroy(info->valueJsonArray);
+  taosArrayDestroy(info->valueJsonArray);
 
   taosArrayDestroyEx(info->preLineTagKV, freeSSmlKv);
 
@@ -2137,8 +2137,8 @@ TAOS_RES *taos_schemaless_insert_inner(TAOS *taos, char *lines[], char *rawLine,
   SSmlHandle  *info = NULL;
   int          cnt = 0;
   while (1) {
-    request = (SRequestObj *)createRequest(*(int64_t *)taos, TSDB_SQL_INSERT, reqid);
+    code = createRequest(*(int64_t *)taos, TSDB_SQL_INSERT, reqid, &request);
-    if (request == NULL) {
+    if (TSDB_CODE_SUCCESS != code) {
       uError("SML:taos_schemaless_insert error request is null");
       return NULL;
     }

source/client/test/smlTest.cpp

@@ -65,7 +65,7 @@ TEST(testCase, smlParseInfluxString_Test) {
 
   ASSERT_EQ(elements.timestamp, sql + elements.measureTagsLen + 1 + elements.colsLen + 1);
   ASSERT_EQ(elements.timestampLen, strlen("1626006833639000000"));
-  (void)taosArrayDestroy(elements.colArray);
+  taosArrayDestroy(elements.colArray);
   elements.colArray = nullptr;
 
   // case 2  false
@@ -74,7 +74,7 @@ TEST(testCase, smlParseInfluxString_Test) {
   (void)memset(&elements, 0, sizeof(SSmlLineInfo));
   ret = smlParseInfluxString(info, sql, sql + strlen(sql), &elements);
   ASSERT_NE(ret, 0);
-  (void)taosArrayDestroy(elements.colArray);
+  taosArrayDestroy(elements.colArray);
   elements.colArray = nullptr;
 
   // case 4  tag is null
@@ -95,7 +95,7 @@ TEST(testCase, smlParseInfluxString_Test) {
 
   ASSERT_EQ(elements.timestamp, sql + elements.measureTagsLen + 1 + elements.colsLen + 1);
   ASSERT_EQ(elements.timestampLen, strlen("1626006833639000000"));
-  (void)taosArrayDestroy(elements.colArray);
+  taosArrayDestroy(elements.colArray);
   elements.colArray = nullptr;
 
   // case 5 tag is null
@@ -115,7 +115,7 @@ TEST(testCase, smlParseInfluxString_Test) {
 
   ASSERT_EQ(elements.timestamp, sql + 1 + elements.measureTagsLen + 3 + elements.colsLen + 2);
   ASSERT_EQ(elements.timestampLen, strlen("1626006833639000000"));
-  (void)taosArrayDestroy(elements.colArray);
+  taosArrayDestroy(elements.colArray);
   elements.colArray = nullptr;
 
   // case 6
@@ -124,7 +124,7 @@ TEST(testCase, smlParseInfluxString_Test) {
   (void)memset(&elements, 0, sizeof(SSmlLineInfo));
   ret = smlParseInfluxString(info, sql, sql + strlen(sql), &elements);
   ASSERT_EQ(ret, 0);
-  (void)taosArrayDestroy(elements.colArray);
+  taosArrayDestroy(elements.colArray);
   elements.colArray = nullptr;
   ASSERT_EQ(smlClearForRerun(info), 0);
 
@@ -134,7 +134,7 @@ TEST(testCase, smlParseInfluxString_Test) {
   (void)memset(&elements, 0, sizeof(SSmlLineInfo));
   ret = smlParseInfluxString(info, sql, sql + strlen(sql), &elements);
   ASSERT_NE(ret, 0);
-  (void)taosArrayDestroy(elements.colArray);
+  taosArrayDestroy(elements.colArray);
   elements.colArray = nullptr;
 
   // case 8 false
@@ -143,7 +143,7 @@ TEST(testCase, smlParseInfluxString_Test) {
   (void)memset(&elements, 0, sizeof(SSmlLineInfo));
   ret = smlParseInfluxString(info, sql, sql + strlen(sql), &elements);
   ASSERT_NE(ret, 0);
-  (void)taosArrayDestroy(elements.colArray);
+  taosArrayDestroy(elements.colArray);
   elements.colArray = nullptr;
 
   taosMemoryFree(sql);
@@ -250,7 +250,7 @@ TEST(testCase, smlParseCols_Error_Test) {
 //    printf("i:%d\n", i);
     ASSERT_NE(ret, TSDB_CODE_SUCCESS);
     taosMemoryFree(sql);
-    (void)taosArrayDestroy(elements.colArray);
+    taosArrayDestroy(elements.colArray);
   }
   smlDestroyInfo(info);
 }
@@ -458,7 +458,7 @@ TEST(testCase, smlParseCols_Test) {
   ASSERT_EQ(kv->length, 4);
   ASSERT_EQ(strncasecmp(kv->value, "iuwq", 4), 0);
 
-  (void)taosArrayDestroy(elements.colArray);
+  taosArrayDestroy(elements.colArray);
   taosMemoryFree(sql);
   smlDestroyInfo(info);
 }

source/common/src/cos.c

@@ -65,13 +65,13 @@ int32_t s3CheckCfg() {
   int32_t code = 0, lino = 0;
 
   if (!tsS3Enabled) {
-    fprintf(stderr, "s3 not configured.\n");
+    (void)fprintf(stderr, "s3 not configured.\n");
     goto _exit;
   }
 
   code = s3Begin();
   if (code != 0) {
-    fprintf(stderr, "failed to initialize s3.\n");
+    (void)fprintf(stderr, "failed to initialize s3.\n");
     TAOS_CHECK_GOTO(code, &lino, _exit);
   }
 
@@ -82,72 +82,72 @@ int32_t s3CheckCfg() {
   int         ds_len = strlen(TD_DIRSEP);
   int         tmp_len = strlen(tsTempDir);
 
-  snprintf(path, PATH_MAX, "%s", tsTempDir);
+  (void)snprintf(path, PATH_MAX, "%s", tsTempDir);
   if (strncmp(tsTempDir + tmp_len - ds_len, TD_DIRSEP, ds_len) != 0) {
-    snprintf(path + tmp_len, PATH_MAX - tmp_len, "%s", TD_DIRSEP);
+    (void)snprintf(path + tmp_len, PATH_MAX - tmp_len, "%s", TD_DIRSEP);
-    snprintf(path + tmp_len + ds_len, PATH_MAX - tmp_len - ds_len, "%s", objectname[0]);
+    (void)snprintf(path + tmp_len + ds_len, PATH_MAX - tmp_len - ds_len, "%s", objectname[0]);
   } else {
-    snprintf(path + tmp_len, PATH_MAX - tmp_len, "%s", objectname[0]);
+    (void)snprintf(path + tmp_len, PATH_MAX - tmp_len, "%s", objectname[0]);
   }
 
   TdFilePtr fp = taosOpenFile(path, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_READ | TD_FILE_TRUNC);
   if (!fp) {
-    fprintf(stderr, "failed to open test file: %s.\n", path);
+    (void)fprintf(stderr, "failed to open test file: %s.\n", path);
     // uError("ERROR: %s Failed to open %s", __func__, path);
     TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _exit);
   }
   if (taosWriteFile(fp, testdata, strlen(testdata)) < 0) {
-    fprintf(stderr, "failed to write test file: %s.\n", path);
+    (void)fprintf(stderr, "failed to write test file: %s.\n", path);
     TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _exit);
   }
   if (taosFsyncFile(fp) < 0) {
-    fprintf(stderr, "failed to fsync test file: %s.\n", path);
+    (void)fprintf(stderr, "failed to fsync test file: %s.\n", path);
     TAOS_CHECK_GOTO(TAOS_SYSTEM_ERROR(errno), &lino, _exit);
   }
-  taosCloseFile(&fp);
+  (void)taosCloseFile(&fp);
 
-  fprintf(stderr, "\nstart to put object: %s, file: %s content: %s\n", objectname[0], path, testdata);
+  (void)fprintf(stderr, "\nstart to put object: %s, file: %s content: %s\n", objectname[0], path, testdata);
   code = s3PutObjectFromFileOffset(path, objectname[0], 0, 16);
   if (code != 0) {
-    fprintf(stderr, "put object %s : failed.\n", objectname[0]);
+    (void)fprintf(stderr, "put object %s : failed.\n", objectname[0]);
     TAOS_CHECK_GOTO(code, &lino, _exit);
   }
-  fprintf(stderr, "put object %s: success.\n\n", objectname[0]);
+  (void)fprintf(stderr, "put object %s: success.\n\n", objectname[0]);
 
   // list buckets
-  fprintf(stderr, "start to list bucket %s by prefix s3.\n", tsS3BucketName);
+  (void)fprintf(stderr, "start to list bucket %s by prefix s3.\n", tsS3BucketName);
   code = s3ListBucket(tsS3BucketName);
   if (code != 0) {
-    fprintf(stderr, "listing bucket %s : failed.\n", tsS3BucketName);
+    (void)fprintf(stderr, "listing bucket %s : failed.\n", tsS3BucketName);
     TAOS_CHECK_GOTO(code, &lino, _exit);
   }
-  fprintf(stderr, "listing bucket %s: success.\n\n", tsS3BucketName);
+  (void)fprintf(stderr, "listing bucket %s: success.\n\n", tsS3BucketName);
 
   // test range get
   uint8_t *pBlock = NULL;
   int      c_offset = 10;
   int      c_len = 6;
 
-  fprintf(stderr, "start to range get object %s offset: %d len: %d.\n", objectname[0], c_offset, c_len);
+  (void)fprintf(stderr, "start to range get object %s offset: %d len: %d.\n", objectname[0], c_offset, c_len);
   code = s3GetObjectBlock(objectname[0], c_offset, c_len, true, &pBlock);
   if (code != 0) {
-    fprintf(stderr, "get object %s : failed.\n", objectname[0]);
+    (void)fprintf(stderr, "get object %s : failed.\n", objectname[0]);
     TAOS_CHECK_GOTO(code, &lino, _exit);
   }
   char buf[7] = {0};
-  memcpy(buf, pBlock, c_len);
+  (void)memcpy(buf, pBlock, c_len);
   taosMemoryFree(pBlock);
-  fprintf(stderr, "object content: %s\n", buf);
+  (void)fprintf(stderr, "object content: %s\n", buf);
-  fprintf(stderr, "get object %s: success.\n\n", objectname[0]);
+  (void)fprintf(stderr, "get object %s: success.\n\n", objectname[0]);
 
   // delete test object
-  fprintf(stderr, "start to delete object: %s.\n", objectname[0]);
+  (void)fprintf(stderr, "start to delete object: %s.\n", objectname[0]);
   code = s3DeleteObjects(objectname, 1);
   if (code != 0) {
-    fprintf(stderr, "delete object %s : failed.\n", objectname[0]);
+    (void)fprintf(stderr, "delete object %s : failed.\n", objectname[0]);
     TAOS_CHECK_GOTO(code, &lino, _exit);
   }
-  fprintf(stderr, "delete object %s: success.\n\n", objectname[0]);
+  (void)fprintf(stderr, "delete object %s: success.\n\n", objectname[0]);
 
   s3End();
 
@@ -252,9 +252,9 @@ static int32_t s3ListBucket(char const *bucketname) {
   const char **object_name = TARRAY_DATA(objectArray);
   int          size = TARRAY_SIZE(objectArray);
 
-  fprintf(stderr, "objects:\n");
+  (void)fprintf(stderr, "objects:\n");
   for (int i = 0; i < size; ++i) {
-    fprintf(stderr, "%s\n", object_name[i]);
+    (void)fprintf(stderr, "%s\n", object_name[i]);
   }
 
   taosArrayDestroyEx(objectArray, s3FreeObjectKey);
@@ -300,7 +300,7 @@ static int growbuffer_append(growbuffer **gb, const char *data, int dataLen) {
       toCopy = dataLen;
     }
 
-    memcpy(&(buf->data[buf->size]), data, toCopy);
+    (void)memcpy(&(buf->data[buf->size]), data, toCopy);
 
     buf->size += toCopy, data += toCopy, dataLen -= toCopy;
   }
@@ -319,7 +319,7 @@ static void growbuffer_read(growbuffer **gb, int amt, int *amtReturn, char *buff
 
   *amtReturn = (buf->size > amt) ? amt : buf->size;
 
-  memcpy(buffer, &(buf->data[buf->start]), *amtReturn);
+  (void)memcpy(buffer, &(buf->data[buf->start]), *amtReturn);
 
   buf->start += *amtReturn, buf->size -= *amtReturn;
 
@@ -440,7 +440,7 @@ S3Status initial_multipart_callback(const char *upload_id, void *callbackData) {
 }
 
 S3Status MultipartResponseProperiesCallback(const S3ResponseProperties *properties, void *callbackData) {
-  responsePropertiesCallbackNull(properties, callbackData);
+  (void)responsePropertiesCallbackNull(properties, callbackData);
 
   MultipartPartData *data = (MultipartPartData *)callbackData;
   int                seq = data->seq;
@@ -451,7 +451,7 @@ S3Status MultipartResponseProperiesCallback(const S3ResponseProperties *properti
 }
 
 S3Status MultipartResponseProperiesCallbackWithCp(const S3ResponseProperties *properties, void *callbackData) {
-  responsePropertiesCallbackNull(properties, callbackData);
+  (void)responsePropertiesCallbackNull(properties, callbackData);
 
   MultipartPartData *data = (MultipartPartData *)callbackData;
   int                seq = data->seq;
@@ -624,7 +624,7 @@ static int32_t s3PutObjectFromFileWithoutCp(S3BucketContext *bucket_context, cha
   }
 
   MultipartPartData partData;
-  memset(&partData, 0, sizeof(MultipartPartData));
+  (void)memset(&partData, 0, sizeof(MultipartPartData));
   int partContentLength = 0;
 
   S3MultipartInitialHandler handler = {{&responsePropertiesCallbackNull, &responseCompleteCallback},
@@ -739,7 +739,7 @@ static int32_t s3PutObjectFromFileWithCp(S3BucketContext *bucket_context, const
 
   bool need_init_upload = true;
   char file_cp_path[TSDB_FILENAME_LEN];
-  snprintf(file_cp_path, TSDB_FILENAME_LEN, "%s.cp", file);
+  (void)snprintf(file_cp_path, TSDB_FILENAME_LEN, "%s.cp", file);
 
   SCheckpoint cp = {0};
   cp.parts = taosMemoryCalloc(max_part_num, sizeof(SCheckpointPart));
@@ -781,7 +781,7 @@ static int32_t s3PutObjectFromFileWithCp(S3BucketContext *bucket_context, const
   // cos_cp_get_undo_parts(&cp, &part_num, parts, &consume_bytes);
 
   MultipartPartData partData;
-  memset(&partData, 0, sizeof(MultipartPartData));
+  (void)memset(&partData, 0, sizeof(MultipartPartData));
   int partContentLength = 0;
 
   S3PutObjectHandler putObjectHandler = {{&MultipartResponseProperiesCallbackWithCp, &responseCompleteCallback},
@@ -920,7 +920,7 @@ int32_t s3PutObjectFromFile2(const char *file, const char *object_name, int8_t w
   char                     useServerSideEncryption = 0;
   put_object_callback_data data = {0};
 
-  if (taosStatFile(file, &contentLength, &lmtime, NULL) < 0) {
+  if (taosStatFile(file, (int64_t *)&contentLength, &lmtime, NULL) < 0) {
     uError("ERROR: %s Failed to stat file %s: ", __func__, file);
     TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
   }
@@ -953,7 +953,7 @@ int32_t s3PutObjectFromFile2(const char *file, const char *object_name, int8_t w
   }
 
   if (data.infileFD) {
-    taosCloseFile(&data.infileFD);
+    (void)taosCloseFile(&data.infileFD);
   } else if (data.gb) {
     growbuffer_destroy(data.gb);
   }
@@ -975,7 +975,7 @@ int32_t s3PutObjectFromFileOffset(const char *file, const char *object_name, int
   char                     useServerSideEncryption = 0;
   put_object_callback_data data = {0};
 
-  if (taosStatFile(file, &contentLength, &lmtime, NULL) < 0) {
+  if (taosStatFile(file, (int64_t *)&contentLength, &lmtime, NULL) < 0) {
     uError("ERROR: %s Failed to stat file %s: ", __func__, file);
     TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
   }
@@ -987,7 +987,7 @@ int32_t s3PutObjectFromFileOffset(const char *file, const char *object_name, int
     TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
   }
   if (taosLSeekFile(data.infileFD, offset, SEEK_SET) < 0) {
-    taosCloseFile(&data.infileFD);
+    (void)taosCloseFile(&data.infileFD);
     TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
   }
 
@@ -1010,7 +1010,7 @@ int32_t s3PutObjectFromFileOffset(const char *file, const char *object_name, int
   }
 
   if (data.infileFD) {
-    taosCloseFile(&data.infileFD);
+    (void)taosCloseFile(&data.infileFD);
   } else if (data.gb) {
     growbuffer_destroy(data.gb);
   }
@@ -1038,7 +1038,7 @@ static S3Status listBucketCallback(int isTruncated, const char *nextMarker, int
     nextMarker = contents[contentsCount - 1].key;
   }
   if (nextMarker) {
-    snprintf(data->nextMarker, sizeof(data->nextMarker), "%s", nextMarker);
+    (void)snprintf(data->nextMarker, sizeof(data->nextMarker), "%s", nextMarker);
   } else {
     data->nextMarker[0] = 0;
   }
@@ -1052,7 +1052,7 @@ static S3Status listBucketCallback(int isTruncated, const char *nextMarker, int
     const S3ListBucketContent *content = &(contents[i]);
     // printf("%-50s", content->key);
     char *object_key = strdup(content->key);
-    taosArrayPush(data->objectArray, &object_key);
+    (void)taosArrayPush(data->objectArray, &object_key);
   }
   data->keyCount += contentsCount;
 
@@ -1139,7 +1139,7 @@ int32_t s3DeleteObjects(const char *object_name[], int nobject) {
 void s3DeleteObjectsByPrefix(const char *prefix) {
   SArray *objectArray = getListByPrefix(prefix);
   if (objectArray == NULL) return;
-  s3DeleteObjects(TARRAY_DATA(objectArray), TARRAY_SIZE(objectArray));
+  (void)s3DeleteObjects(TARRAY_DATA(objectArray), TARRAY_SIZE(objectArray));
   taosArrayDestroyEx(objectArray, s3FreeObjectKey);
 }
 
@@ -1156,7 +1156,7 @@ static S3Status getObjectDataCallback(int bufferSize, const char *buffer, void *
   }
 
   if (cbd->buf) {
-    memcpy(cbd->buf + cbd->buf_pos, buffer, bufferSize);
+    (void)memcpy(cbd->buf + cbd->buf_pos, buffer, bufferSize);
     cbd->buf_pos += bufferSize;
     cbd->status = S3StatusOK;
     return S3StatusOK;
@@ -1196,7 +1196,7 @@ int32_t s3GetObjectBlock(const char *object_name, int64_t offset, int64_t size,
     TAOS_RETURN(TAOS_SYSTEM_ERROR(EIO));
   }
 
-  *ppBlock = cbd.buf;
+  *ppBlock = (uint8_t *)cbd.buf;
 
   TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
@@ -1231,11 +1231,11 @@ int32_t s3GetObjectToFile(const char *object_name, const char *fileName) {
 
   if (cbd.status != S3StatusOK) {
     uError("%s: %d(%s)", __func__, cbd.status, cbd.err_msg);
-    taosCloseFile(&pFile);
+    (void)taosCloseFile(&pFile);
     TAOS_RETURN(TAOS_SYSTEM_ERROR(EIO));
   }
 
-  taosCloseFile(&pFile);
+  (void)taosCloseFile(&pFile);
 
   TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
@@ -1250,9 +1250,9 @@ int32_t s3GetObjectsByPrefix(const char *prefix, const char *path) {
     tmp = (tmp == NULL) ? object : tmp + 1;
     char fileName[PATH_MAX] = {0};
     if (path[strlen(path) - 1] != TD_DIRSEP_CHAR) {
-      snprintf(fileName, PATH_MAX, "%s%s%s", path, TD_DIRSEP, tmp);
+      (void)snprintf(fileName, PATH_MAX, "%s%s%s", path, TD_DIRSEP, tmp);
     } else {
-      snprintf(fileName, PATH_MAX, "%s%s", path, tmp);
+      (void)snprintf(fileName, PATH_MAX, "%s%s", path, tmp);
     }
     if (s3GetObjectToFile(object, fileName) != 0) {
       taosArrayDestroyEx(objectArray, s3FreeObjectKey);

source/common/src/cos_cp.c

@@ -43,12 +43,12 @@ static int32_t cos_cp_parse_body(char* cp_body, SCheckpoint* cp) {
 
   item = cJSON_GetObjectItem(json, "md5");
   if (cJSON_IsString(item)) {
-    memcpy(cp->md5, item->valuestring, strlen(item->valuestring));
+    (void)memcpy(cp->md5, item->valuestring, strlen(item->valuestring));
   }
 
   item = cJSON_GetObjectItem(json, "upload_id");
   if (cJSON_IsString(item)) {
-    strncpy(cp->upload_id, item->valuestring, 128);
+    (void)strncpy(cp->upload_id, item->valuestring, 128);
   }
 
   item2 = cJSON_GetObjectItem(json, "file");
@@ -65,12 +65,12 @@ static int32_t cos_cp_parse_body(char* cp_body, SCheckpoint* cp) {
 
     item = cJSON_GetObjectItem(item2, "path");
     if (cJSON_IsString(item)) {
-      strncpy(cp->file_path, item->valuestring, TSDB_FILENAME_LEN);
+      (void)strncpy(cp->file_path, item->valuestring, TSDB_FILENAME_LEN);
     }
 
     item = cJSON_GetObjectItem(item2, "file_md5");
     if (cJSON_IsString(item)) {
-      strncpy(cp->file_md5, item->valuestring, 64);
+      (void)strncpy(cp->file_md5, item->valuestring, 64);
     }
   }
 
@@ -83,17 +83,17 @@ static int32_t cos_cp_parse_body(char* cp_body, SCheckpoint* cp) {
 
     item = cJSON_GetObjectItem(item2, "object_name");
     if (cJSON_IsString(item)) {
-      strncpy(cp->object_name, item->valuestring, 128);
+      (void)strncpy(cp->object_name, item->valuestring, 128);
     }
 
     item = cJSON_GetObjectItem(item2, "object_last_modified");
     if (cJSON_IsString(item)) {
-      strncpy(cp->object_last_modified, item->valuestring, 64);
+      (void)strncpy(cp->object_last_modified, item->valuestring, 64);
     }
 
     item = cJSON_GetObjectItem(item2, "object_etag");
     if (cJSON_IsString(item)) {
-      strncpy(cp->object_etag, item->valuestring, 128);
+      (void)strncpy(cp->object_etag, item->valuestring, 128);
     }
   }
 
@@ -141,7 +141,7 @@ static int32_t cos_cp_parse_body(char* cp_body, SCheckpoint* cp) {
 
         item3 = cJSON_GetObjectItem(item, "etag");
         if (cJSON_IsString(item3)) {
-          strncpy(cp->parts[index].etag, item3->valuestring, 128);
+          (void)strncpy(cp->parts[index].etag, item3->valuestring, 128);
         }
       }
     }
@@ -179,7 +179,7 @@ int32_t cos_cp_load(char const* filepath, SCheckpoint* checkpoint) {
   } else if (n != size) {
     TAOS_CHECK_GOTO(TSDB_CODE_FILE_CORRUPTED, &lino, _exit);
   }
-  taosCloseFile(&fd);
+  (void)taosCloseFile(&fd);
   cp_body[size] = '\0';
 
   return cos_cp_parse_body(cp_body, checkpoint);
@@ -189,7 +189,7 @@ _exit:
     uError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
   }
   if (fd) {
-    taosCloseFile(&fd);
+    (void)taosCloseFile(&fd);
   }
   if (cp_body) {
     taosMemoryFree(cp_body);
@@ -309,7 +309,7 @@ int32_t cos_cp_dump(SCheckpoint* cp) {
     if (!item) {
       TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit);
     }
-    cJSON_AddItemToArray(ajson, item);
+    (void)cJSON_AddItemToArray(ajson, item);
 
     if (NULL == cJSON_AddNumberToObject(item, "index", cp->parts[i].index)) {
       TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, &lino, _exit);
@@ -346,7 +346,7 @@ void cos_cp_get_undo_parts(SCheckpoint* checkpoint, int* part_num, SCheckpointPa
 
 void cos_cp_update(SCheckpoint* checkpoint, int32_t part_index, char const* etag, uint64_t crc64) {
   checkpoint->parts[part_index].completed = 1;
-  strncpy(checkpoint->parts[part_index].etag, etag, 127);
+  (void)strncpy(checkpoint->parts[part_index].etag, etag, 127);
   checkpoint->parts[part_index].crc64 = crc64;
 }
 
@@ -355,12 +355,12 @@ void cos_cp_build_upload(SCheckpoint* checkpoint, char const* filepath, int64_t
   int i = 0;
 
   checkpoint->cp_type = COS_CP_TYPE_UPLOAD;
-  memset(checkpoint->file_path, 0, TSDB_FILENAME_LEN);
+  (void)memset(checkpoint->file_path, 0, TSDB_FILENAME_LEN);
-  strncpy(checkpoint->file_path, filepath, TSDB_FILENAME_LEN - 1);
+  (void)strncpy(checkpoint->file_path, filepath, TSDB_FILENAME_LEN - 1);
 
   checkpoint->file_size = size;
   checkpoint->file_last_modified = mtime;
-  strncpy(checkpoint->upload_id, upload_id, 127);
+  (void)strncpy(checkpoint->upload_id, upload_id, 127);
 
   checkpoint->part_size = part_size;
   for (; i * part_size < size; i++) {

source/common/src/tdatablock.c

@@ -456,7 +456,7 @@ int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, int32_t numOfRow1, int
 int32_t colDataAssign(SColumnInfoData* pColumnInfoData, const SColumnInfoData* pSource, int32_t numOfRows,
                       const SDataBlockInfo* pBlockInfo) {
   if (pColumnInfoData->info.type != pSource->info.type || (pBlockInfo != NULL && pBlockInfo->capacity < numOfRows)) {
-    return TSDB_CODE_FAILED;
+    return TSDB_CODE_INVALID_PARA;
   }
 
   if (numOfRows <= 0) {
@@ -1510,6 +1510,9 @@ int32_t blockDataEnsureCapacity(SSDataBlock* pDataBlock, uint32_t numOfRows) {
 }
 
 void blockDataFreeRes(SSDataBlock* pBlock) {
+  if (pBlock == NULL){
+    return;
+  }
   int32_t numOfOutput = taosArrayGetSize(pBlock->pDataBlock);
   for (int32_t i = 0; i < numOfOutput; ++i) {
     SColumnInfoData* pColInfoData = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, i);

source/common/src/tdataformat.c

@@ -310,7 +310,7 @@ static int32_t tRowBuildTupleRow(SArray *aColVal, const SRowBuildScanInfo *sinfo
             }
           } else {
             (void)memcpy(fixed + schema->columns[i].offset, &colValArray[colValIndex].value.val,
-                   tDataTypes[schema->columns[i].type].bytes);
+                         tDataTypes[schema->columns[i].type].bytes);
           }
         } else if (COL_VAL_IS_NULL(&colValArray[colValIndex])) {  // NULL
           ROW_SET_BITMAP(bitmap, sinfo->tupleFlag, i - 1, BIT_FLG_NULL);
@@ -384,13 +384,14 @@ static int32_t tRowBuildKVRow(SArray *aColVal, const SRowBuildScanInfo *sinfo, c
             payloadSize += tPutI16v(payload + payloadSize, colValArray[colValIndex].cid);
             payloadSize += tPutU32v(payload + payloadSize, colValArray[colValIndex].value.nData);
             if (colValArray[colValIndex].value.nData > 0) {
-              (void)memcpy(payload + payloadSize, colValArray[colValIndex].value.pData, colValArray[colValIndex].value.nData);
+              (void)memcpy(payload + payloadSize, colValArray[colValIndex].value.pData,
+                           colValArray[colValIndex].value.nData);
             }
             payloadSize += colValArray[colValIndex].value.nData;
           } else {
             payloadSize += tPutI16v(payload + payloadSize, colValArray[colValIndex].cid);
             (void)memcpy(payload + payloadSize, &colValArray[colValIndex].value.val,
-                   tDataTypes[schema->columns[i].type].bytes);
+                         tDataTypes[schema->columns[i].type].bytes);
             payloadSize += tDataTypes[schema->columns[i].type].bytes;
           }
         } else if (COL_VAL_IS_NULL(&colValArray[colValIndex])) {  // NULL
@@ -476,11 +477,14 @@ int32_t tRowBuildFromBind(SBindInfo *infos, int32_t numOfInfos, bool infoSorted,
           value.pData = (uint8_t *)infos[iInfo].bind->buffer + infos[iInfo].bind->buffer_length * iRow;
         } else {
           (void)memcpy(&value.val, (uint8_t *)infos[iInfo].bind->buffer + infos[iInfo].bind->buffer_length * iRow,
-                 infos[iInfo].bind->buffer_length);
+                       infos[iInfo].bind->buffer_length);
         }
         colVal = COL_VAL_VALUE(infos[iInfo].columnId, value);
       }
-      taosArrayPush(colValArray, &colVal);
+      if (taosArrayPush(colValArray, &colVal) == NULL) {
+        code = TSDB_CODE_OUT_OF_MEMORY;
+        goto _exit;
+      }
     }
 
     SRow *row;
@@ -689,7 +693,12 @@ static int32_t tRowMergeImpl(SArray *aRowP, STSchema *pTSchema, int32_t iStart,
       }
     }
 
-    if (pColVal) taosArrayPush(aColVal, pColVal);
+    if (pColVal) {
+      if (taosArrayPush(aColVal, pColVal) == NULL) {
+        code = TSDB_CODE_OUT_OF_MEMORY;
+        goto _exit;
+      }
+    }
   }
 
   // build
@@ -1750,7 +1759,10 @@ int32_t tTagToValArray(const STag *pTag, SArray **ppArray) {
       offset = pTag->idx[iTag];
     }
     tGetTagVal(p + offset, &tv, pTag->flags & TD_TAG_JSON);
-    taosArrayPush(*ppArray, &tv);
+    if (taosArrayPush(*ppArray, &tv) == NULL) {
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      goto _err;
+    }
   }
 
   return code;
@@ -1783,6 +1795,7 @@ void tTagSetCid(const STag *pTag, int16_t iTag, int16_t cid) {
 STSchema *tBuildTSchema(SSchema *aSchema, int32_t numOfCols, int32_t version) {
   STSchema *pTSchema = taosMemoryCalloc(1, sizeof(STSchema) + sizeof(STColumn) * numOfCols);
   if (pTSchema == NULL) {
+    terrno = TSDB_CODE_OUT_OF_MEMORY;
     return NULL;
   }
 
@@ -2592,7 +2605,8 @@ static FORCE_INLINE void tColDataGetValue4(SColData *pColData, int32_t iVal, SCo
     }
     value.pData = pColData->pData + pColData->aOffset[iVal];
   } else {
-    (void)memcpy(&value.val, pColData->pData + tDataTypes[pColData->type].bytes * iVal, tDataTypes[pColData->type].bytes);
+    (void)memcpy(&value.val, pColData->pData + tDataTypes[pColData->type].bytes * iVal,
+                 tDataTypes[pColData->type].bytes);
   }
   *pColVal = COL_VAL_VALUE(pColData->cid, value);
 }
@@ -3118,10 +3132,10 @@ static int32_t tColDataCopyRowCell(SColData *pFromColData, int32_t iFromRow, SCo
     }
 
     (void)memcpy(pToColData->pData + pToColData->aOffset[iToRow], pFromColData->pData + pFromColData->aOffset[iFromRow],
-           nData);
+                 nData);
   } else {
     (void)memcpy(&pToColData->pData[TYPE_BYTES[pToColData->type] * iToRow],
-           &pFromColData->pData[TYPE_BYTES[pToColData->type] * iFromRow], TYPE_BYTES[pToColData->type]);
+                 &pFromColData->pData[TYPE_BYTES[pToColData->type] * iFromRow], TYPE_BYTES[pToColData->type]);
   }
   return code;
 }
@@ -3209,12 +3223,12 @@ static int32_t tColDataMergeSortMerge(SColData *aColData, int32_t start, int32_t
 
   if (end > start) {
     aDstColData = taosMemoryCalloc(1, sizeof(SColData) * nColData);
-    for (int c = 0; c < nColData; ++c) {
-      tColDataInit(&aDstColData[c], aColData[c].cid, aColData[c].type, aColData[c].cflag);
-    }
     if (aDstColData == NULL) {
       return TSDB_CODE_OUT_OF_MEMORY;
     }
+    for (int c = 0; c < nColData; ++c) {
+      tColDataInit(&aDstColData[c], aColData[c].cid, aColData[c].type, aColData[c].cflag);
+    }
   }
 
   tColDataArrGetRowKey(aColData, nColData, i, &keyi);
@@ -3360,7 +3374,7 @@ static void tColDataMergeImpl(SColData *pColData, int32_t iStart, int32_t iEnd /
         } else {
           if (iv != iStart) {
             (void)memcpy(&pColData->pData[TYPE_BYTES[pColData->type] * iStart],
-                   &pColData->pData[TYPE_BYTES[pColData->type] * iv], TYPE_BYTES[pColData->type]);
+                         &pColData->pData[TYPE_BYTES[pColData->type] * iv], TYPE_BYTES[pColData->type]);
           }
           memmove(&pColData->pData[TYPE_BYTES[pColData->type] * (iStart + 1)],
                   &pColData->pData[TYPE_BYTES[pColData->type] * iEnd],
@@ -4476,6 +4490,9 @@ int32_t tDecompressData(void                *input,       // input
       buffer = &local;
     }
     code = tBufferEnsureCapacity(buffer, info->originalSize + COMP_OVERFLOW_BYTES);
+    if (code) {
+      return code;
+    }
 
     int32_t decompressedSize = tDataCompress[info->dataType].decompFunc(
         input,                                                  // input

source/common/src/tmisce.c

@@ -270,11 +270,7 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
 
   TAOS_CHECK_GOTO(blockDataEnsureCapacity(pBlock, cfgGetSize(pConf)), NULL, _exit);
 
-  pIter = cfgCreateIter(pConf);
+  TAOS_CHECK_GOTO(cfgCreateIter(pConf, &pIter), NULL, _exit);
-  if (pIter == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
-    TAOS_CHECK_GOTO(code, NULL, _exit);
-  }
 
   cfgLock(pConf);
   locked = 1;
@@ -296,7 +292,7 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
 
     char    value[TSDB_CONFIG_VALUE_LEN + VARSTR_HEADER_SIZE] = {0};
     int32_t valueLen = 0;
-    cfgDumpItemValue(pItem, &value[VARSTR_HEADER_SIZE], TSDB_CONFIG_VALUE_LEN, &valueLen);
+    TAOS_CHECK_GOTO(cfgDumpItemValue(pItem, &value[VARSTR_HEADER_SIZE], TSDB_CONFIG_VALUE_LEN, &valueLen), NULL, _exit);
     varDataSetLen(value, valueLen);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, col++);
@@ -308,7 +304,7 @@ int32_t dumpConfToDataBlock(SSDataBlock* pBlock, int32_t startCol) {
     TAOS_CHECK_GOTO(colDataSetVal(pColInfo, numOfRows, value, false), NULL, _exit);
 
     char scope[TSDB_CONFIG_SCOPE_LEN + VARSTR_HEADER_SIZE] = {0};
-    cfgDumpItemScope(pItem, &scope[VARSTR_HEADER_SIZE], TSDB_CONFIG_SCOPE_LEN, &valueLen);
+    TAOS_CHECK_GOTO(cfgDumpItemScope(pItem, &scope[VARSTR_HEADER_SIZE], TSDB_CONFIG_SCOPE_LEN, &valueLen), NULL, _exit);
     varDataSetLen(scope, valueLen);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, col++);

source/common/src/tname.c

@@ -181,7 +181,7 @@ int32_t tNameSetDbName(SName* dst, int32_t acct, const char* dbName, size_t name
 int32_t tNameAddTbName(SName* dst, const char* tbName, size_t nameLen) {
   // too long account id or too long db name
   if (nameLen >= tListLen(dst->tname) || nameLen <= 0) {
-    return -1;
+    return TSDB_CODE_INVALID_PARA;
   }
 
   dst->type = TSDB_TABLE_NAME_T;
@@ -225,14 +225,14 @@ bool tNameTbNameEqual(SName* left, SName* right) {
 
 int32_t tNameFromString(SName* dst, const char* str, uint32_t type) {
   if (strlen(str) == 0) {
-    return -1;
+    return TSDB_CODE_INVALID_PARA;
   }
 
   char* p = NULL;
   if ((type & T_NAME_ACCT) == T_NAME_ACCT) {
     p = strstr(str, TS_PATH_DELIMITER);
     if (p == NULL) {
-      return -1;
+      return TSDB_CODE_INVALID_PARA;
     }
 
     dst->acctId = taosStr2Int32(str, NULL, 10);
@@ -252,7 +252,7 @@ int32_t tNameFromString(SName* dst, const char* str, uint32_t type) {
 
     // too long account id or too long db name
     if ((len >= tListLen(dst->dbname)) || (len <= 0)) {
-      return -1;
+      return TSDB_CODE_INVALID_PARA;
     }
 
     memcpy(dst->dbname, start, len);
@@ -266,7 +266,7 @@ int32_t tNameFromString(SName* dst, const char* str, uint32_t type) {
     // too long account id or too long db name
     int32_t len = (int32_t)strlen(start);
     if ((len >= tListLen(dst->tname)) || (len <= 0)) {
-      return -1;
+      return TSDB_CODE_INVALID_PARA;
     }
 
     memcpy(dst->tname, start, len);
@@ -302,7 +302,7 @@ int32_t buildChildTableName(RandTableName* rName) {
   for (int j = 0; j < taosArrayGetSize(rName->tags); ++j) {
     taosStringBuilderAppendChar(&sb, ',');
     SSmlKv* tagKv = taosArrayGet(rName->tags, j);
-    if(tagKv == NULL) {
+    if (tagKv == NULL) {
       return TSDB_CODE_SML_INVALID_DATA;
     }
     taosStringBuilderAppendStringLen(&sb, tagKv->key, tagKv->keyLen);

source/common/src/trow.c

@@ -17,8 +17,8 @@
 #include "trow.h"
 #include "tlog.h"
 
-static bool  tdSTSRowIterGetTpVal(STSRowIter *pIter, col_type_t colType, int32_t offset, SCellVal *pVal);
+static bool tdSTSRowIterGetTpVal(STSRowIter *pIter, col_type_t colType, int32_t offset, SCellVal *pVal);
-static bool  tdSTSRowIterGetKvVal(STSRowIter *pIter, col_id_t colId, col_id_t *nIdx, SCellVal *pVal);
+static bool tdSTSRowIterGetKvVal(STSRowIter *pIter, col_id_t colId, col_id_t *nIdx, SCellVal *pVal);
 
 void tdSTSRowIterInit(STSRowIter *pIter, STSchema *pSchema) {
   pIter->pSchema = pSchema;
@@ -110,8 +110,7 @@ bool tdSTSRowIterGetTpVal(STSRowIter *pIter, col_type_t colType, int32_t offset,
 
 int32_t tdGetBitmapValTypeII(const void *pBitmap, int16_t colIdx, TDRowValT *pValType) {
   if (!pBitmap || colIdx < 0) {
-    terrno = TSDB_CODE_INVALID_PARA;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
-    return terrno;
   }
   int16_t nBytes = colIdx / TD_VTYPE_PARTS;
   int16_t nOffset = colIdx & TD_VTYPE_OPTR;
@@ -131,59 +130,15 @@ int32_t tdGetBitmapValTypeII(const void *pBitmap, int16_t colIdx, TDRowValT *pVa
       *pValType = ((*pDestByte) & 0x03);
       break;
     default:
-      terrno = TSDB_CODE_INVALID_PARA;
+      TAOS_RETURN(TSDB_CODE_INVALID_PARA);
-      return terrno;
   }
-  return TSDB_CODE_SUCCESS;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
-#if 0
-int32_t tdGetBitmapValTypeI(const void *pBitmap, int16_t colIdx, TDRowValT *pValType) {
-  if (!pBitmap || colIdx < 0) {
-    terrno = TSDB_CODE_INVALID_PARA;
-    return terrno;
-  }
-  int16_t nBytes = colIdx / TD_VTYPE_PARTS_I;
-  int16_t nOffset = colIdx & TD_VTYPE_OPTR_I;
-  char   *pDestByte = (char *)POINTER_SHIFT(pBitmap, nBytes);
-  // use literal value directly and not use formula to simplify the codes
-  switch (nOffset) {
-    case 0:
-      *pValType = (((*pDestByte) & 0x80) >> 7);
-      break;
-    case 1:
-      *pValType = (((*pDestByte) & 0x40) >> 6);
-      break;
-    case 2:
-      *pValType = (((*pDestByte) & 0x20) >> 5);
-      break;
-    case 3:
-      *pValType = (((*pDestByte) & 0x10) >> 4);
-      break;
-    case 4:
-      *pValType = (((*pDestByte) & 0x08) >> 3);
-      break;
-    case 5:
-      *pValType = (((*pDestByte) & 0x04) >> 2);
-      break;
-    case 6:
-      *pValType = (((*pDestByte) & 0x02) >> 1);
-      break;
-    case 7:
-      *pValType = ((*pDestByte) & 0x01);
-      break;
-    default:
-      terrno = TSDB_CODE_INVALID_PARA;
-      return terrno;
-  }
-  return TSDB_CODE_SUCCESS;
-}
-#endif
-
 int32_t tdGetBitmapValType(const void *pBitmap, int16_t colIdx, TDRowValT *pValType, int8_t bitmapMode) {
   switch (bitmapMode) {
     case 0:
-      tdGetBitmapValTypeII(pBitmap, colIdx, pValType);
+      (void)tdGetBitmapValTypeII(pBitmap, colIdx, pValType);
       break;
 #if 0
     case -1:
@@ -192,10 +147,9 @@ int32_t tdGetBitmapValType(const void *pBitmap, int16_t colIdx, TDRowValT *pValT
       break;
 #endif
     default:
-      terrno = TSDB_CODE_INVALID_PARA;
+      TAOS_RETURN(TSDB_CODE_INVALID_PARA);
-      return TSDB_CODE_FAILED;
   }
-  return TSDB_CODE_SUCCESS;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 bool tdSTSRowIterGetKvVal(STSRowIter *pIter, col_id_t colId, col_id_t *nIdx, SCellVal *pVal) {
@@ -400,8 +354,8 @@ bool tdSKvRowGetVal(STSRow *pRow, col_id_t colId, col_id_t colIdx, SCellVal *pVa
   }
 
   void *pBitmap = tdGetBitmapAddrKv(pRow, tdRowGetNCols(pRow));
-  tdGetKvRowValOfCol(pVal, pRow, pBitmap, pColIdx->offset,
+  (void)tdGetKvRowValOfCol(pVal, pRow, pBitmap, pColIdx->offset,
-                     POINTER_DISTANCE(pColIdx, TD_ROW_COL_IDX(pRow)) / sizeof(SKvRowIdx));
+                           POINTER_DISTANCE(pColIdx, TD_ROW_COL_IDX(pRow)) / sizeof(SKvRowIdx));
   return true;
 }
 
@@ -412,11 +366,10 @@ bool tdSTpRowGetVal(STSRow *pRow, col_id_t colId, col_type_t colType, int32_t fl
     return true;
   }
   void *pBitmap = tdGetBitmapAddrTp(pRow, flen);
-  tdGetTpRowValOfCol(pVal, pRow, pBitmap, colType, offset, colIdx);
+  (void)tdGetTpRowValOfCol(pVal, pRow, pBitmap, colType, offset, colIdx);
   return true;
 }
 
-
 bool tdSTSRowIterNext(STSRowIter *pIter, SCellVal *pVal) {
   if (pIter->colIdx >= pIter->pSchema->numOfCols) {
     return false;
@@ -432,9 +385,9 @@ bool tdSTSRowIterNext(STSRowIter *pIter, SCellVal *pVal) {
   }
 
   if (TD_IS_TP_ROW(pIter->pRow)) {
-    tdSTSRowIterGetTpVal(pIter, pCol->type, pCol->offset, pVal);
+    (void)tdSTSRowIterGetTpVal(pIter, pCol->type, pCol->offset, pVal);
   } else if (TD_IS_KV_ROW(pIter->pRow)) {
-    tdSTSRowIterGetKvVal(pIter, pCol->colId, &pIter->kvIdx, pVal);
+    (void)tdSTSRowIterGetKvVal(pIter, pCol->colId, &pIter->kvIdx, pVal);
   } else {
     ASSERT(0);
   }
@@ -452,6 +405,7 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow, int8_t r
   int32_t   maxVarDataLen = 0;
   int32_t   iColVal = 0;
   int32_t   nBound = 0;
+  int32_t   code = 0;
   void     *varBuf = NULL;
   bool      isAlloc = false;
 
@@ -481,7 +435,8 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow, int8_t r
           }
         } else {
           varDataLen += sizeof(VarDataLenT);
-          if (pTColumn->type == TSDB_DATA_TYPE_VARCHAR || pTColumn->type == TSDB_DATA_TYPE_VARBINARY || pTColumn->type == TSDB_DATA_TYPE_GEOMETRY) {
+          if (pTColumn->type == TSDB_DATA_TYPE_VARCHAR || pTColumn->type == TSDB_DATA_TYPE_VARBINARY ||
+              pTColumn->type == TSDB_DATA_TYPE_GEOMETRY) {
             varDataLen += CHAR_BYTES;
             if (maxVarDataLen < CHAR_BYTES + sizeof(VarDataLenT)) {
               maxVarDataLen = CHAR_BYTES + sizeof(VarDataLenT);
@@ -494,7 +449,7 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow, int8_t r
           }
         }
       } else {
-        if(pColVal && COL_VAL_IS_VALUE(pColVal)) {
+        if (pColVal && COL_VAL_IS_VALUE(pColVal)) {
           nonVarDataLen += TYPE_BYTES[pTColumn->type];
         }
       }
@@ -516,8 +471,7 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow, int8_t r
   }
 
   if (!(*ppRow)) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
-    return -1;
   }
 
   if (maxVarDataLen > 0) {
@@ -526,15 +480,14 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow, int8_t r
       if (isAlloc) {
         taosMemoryFreeClear(*ppRow);
       }
-      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
-      return -1;
     }
   }
 
   SRowBuilder rb = {.rowType = rowType};
   tdSRowInit(&rb, pTSchema->version);
-  tdSRowSetInfo(&rb, pTSchema->numOfCols, nBound, pTSchema->flen);
+  (void)tdSRowSetInfo(&rb, pTSchema->numOfCols, nBound, pTSchema->flen);
-  tdSRowResetBuf(&rb, *ppRow);
+  (void)tdSRowResetBuf(&rb, *ppRow);
   int32_t iBound = 0;
 
   iColVal = 0;
@@ -553,7 +506,7 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow, int8_t r
       } else if (IS_VAR_DATA_TYPE(pTColumn->type)) {
         varDataSetLen(varBuf, pColVal->value.nData);
         if (pColVal->value.nData != 0) {
-          memcpy(varDataVal(varBuf), pColVal->value.pData, pColVal->value.nData);
+          (void)memcpy(varDataVal(varBuf), pColVal->value.pData, pColVal->value.nData);
         }
         val = varBuf;
         ++iBound;
@@ -567,18 +520,28 @@ int32_t tdSTSRowNew(SArray *pArray, STSchema *pTSchema, STSRow **ppRow, int8_t r
     }
 
     if (TD_IS_TP_ROW(rb.pBuf)) {
-      tdAppendColValToRow(&rb, pTColumn->colId, pTColumn->type, valType, val, true, pTColumn->offset, iColVal);
+      TAOS_CHECK_GOTO(
+          tdAppendColValToRow(&rb, pTColumn->colId, pTColumn->type, valType, val, true, pTColumn->offset, iColVal),
+          NULL, _exit);
     } else {
-      tdAppendColValToRow(&rb, pTColumn->colId, pTColumn->type, valType, val, true, rb.offset, iBound - 1);
+      TAOS_CHECK_GOTO(
+          tdAppendColValToRow(&rb, pTColumn->colId, pTColumn->type, valType, val, true, rb.offset, iBound - 1), NULL,
+          _exit);
     }
 
     ++iColVal;
   }
   tdSRowEnd(&rb);
 
+_exit:
   taosMemoryFreeClear(varBuf);
+  if (code < 0) {
+    if (isAlloc) {
+      taosMemoryFreeClear(*ppRow);
+    }
+  }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static FORCE_INLINE int32_t tdCompareColId(const void *arg1, const void *arg2) {
@@ -615,7 +578,7 @@ bool tdSTSRowGetVal(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCell
 #ifdef TD_SUPPORT_BITMAP
     colIdx = POINTER_DISTANCE(pCol, pSchema->columns) / sizeof(STColumn);
 #endif
-    tdGetTpRowValOfCol(pVal, pRow, pIter->pBitmap, pCol->type, pCol->offset, colIdx - 1);
+    (void)tdGetTpRowValOfCol(pVal, pRow, pIter->pBitmap, pCol->type, pCol->offset, colIdx - 1);
   } else if (TD_IS_KV_ROW(pRow)) {
     SKvRowIdx *pIdx = (SKvRowIdx *)taosbsearch(&colId, TD_ROW_COL_IDX(pRow), tdRowGetNCols(pRow), sizeof(SKvRowIdx),
                                                compareKvRowColId, TD_EQ);
@@ -624,7 +587,7 @@ bool tdSTSRowGetVal(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCell
       colIdx = POINTER_DISTANCE(pIdx, TD_ROW_COL_IDX(pRow)) / sizeof(SKvRowIdx);
     }
 #endif
-    tdGetKvRowValOfCol(pVal, pRow, pIter->pBitmap, pIdx ? pIdx->offset : -1, colIdx);
+    (void)tdGetKvRowValOfCol(pVal, pRow, pIter->pBitmap, pIdx ? pIdx->offset : -1, colIdx);
   } else {
     if (COL_REACH_END(colId, pIter->maxColId)) return false;
     pVal->valType = TD_VTYPE_NONE;
@@ -632,83 +595,31 @@ bool tdSTSRowGetVal(STSRowIter *pIter, col_id_t colId, col_type_t colType, SCell
 
   return true;
 }
-#if 0
-int32_t tdSetBitmapValTypeI(void *pBitmap, int16_t colIdx, TDRowValT valType) {
-  if (!pBitmap || colIdx < 0) {
-    terrno = TSDB_CODE_INVALID_PARA;
-    return terrno;
-  }
-  int16_t nBytes = colIdx / TD_VTYPE_PARTS_I;
-  int16_t nOffset = colIdx & TD_VTYPE_OPTR_I;
-  char   *pDestByte = (char *)POINTER_SHIFT(pBitmap, nBytes);
-  // use literal value directly and not use formula to simplify the codes
-  switch (nOffset) {
-    case 0:
-      *pDestByte = ((*pDestByte) & 0x7F) | (valType << 7);
-      // set the value and clear other partitions for offset 0
-      // *pDestByte |= (valType << 7);
-      break;
-    case 1:
-      *pDestByte = ((*pDestByte) & 0xBF) | (valType << 6);
-      // *pDestByte |= (valType << 6);
-      break;
-    case 2:
-      *pDestByte = ((*pDestByte) & 0xDF) | (valType << 5);
-      // *pDestByte |= (valType << 5);
-      break;
-    case 3:
-      *pDestByte = ((*pDestByte) & 0xEF) | (valType << 4);
-      // *pDestByte |= (valType << 4);
-      break;
-    case 4:
-      *pDestByte = ((*pDestByte) & 0xF7) | (valType << 3);
-      // *pDestByte |= (valType << 3);
-      break;
-    case 5:
-      *pDestByte = ((*pDestByte) & 0xFB) | (valType << 2);
-      // *pDestByte |= (valType << 2);
-      break;
-    case 6:
-      *pDestByte = ((*pDestByte) & 0xFD) | (valType << 1);
-      // *pDestByte |= (valType << 1);
-      break;
-    case 7:
-      *pDestByte = ((*pDestByte) & 0xFE) | valType;
-      // *pDestByte |= (valType);
-      break;
-    default:
-      terrno = TSDB_CODE_INVALID_PARA;
-      return terrno;
-  }
-  return TSDB_CODE_SUCCESS;
-}
-#endif
 
 int32_t tdGetKvRowValOfCol(SCellVal *output, STSRow *pRow, void *pBitmap, int32_t offset, int16_t colIdx) {
 #ifdef TD_SUPPORT_BITMAP
   ASSERT(colIdx < tdRowGetNCols(pRow) - 1);
-  if (tdGetBitmapValType(pBitmap, colIdx, &output->valType, 0) != TSDB_CODE_SUCCESS) {
+  int32_t code = 0;
+  if ((code = tdGetBitmapValType(pBitmap, colIdx, &output->valType, 0)) != TSDB_CODE_SUCCESS) {
     output->valType = TD_VTYPE_NONE;
-    return terrno;
+    TAOS_RETURN(code);
   }
   if (tdValTypeIsNorm(output->valType)) {
     if (offset < 0) {
-      terrno = TSDB_CODE_INVALID_PARA;
       output->valType = TD_VTYPE_NONE;
-      return terrno;
+      TAOS_RETURN(TSDB_CODE_INVALID_PARA);
     }
     output->val = POINTER_SHIFT(pRow, offset);
   }
 #else
   if (offset < 0) {
-    terrno = TSDB_CODE_INVALID_PARA;
     output->valType = TD_VTYPE_NONE;
-    return terrno;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
   }
   output->val = POINTER_SHIFT(pRow, offset);
   output->valType = isNull(output->val, colType) ? TD_VTYPE_NULL : TD_VTYPE_NORM;
 #endif
-  return TSDB_CODE_SUCCESS;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t tdGetTpRowValOfCol(SCellVal *output, STSRow *pRow, void *pBitmap, int8_t colType, int32_t offset,
@@ -720,12 +631,13 @@ int32_t tdGetTpRowValOfCol(SCellVal *output, STSRow *pRow, void *pBitmap, int8_t
     } else {
       output->val = POINTER_SHIFT(TD_ROW_DATA(pRow), offset);
     }
-    return TSDB_CODE_SUCCESS;
+    TAOS_RETURN(TSDB_CODE_SUCCESS);
   }
 
-  if (tdGetBitmapValType(pBitmap, colIdx, &output->valType, 0) != TSDB_CODE_SUCCESS) {
+  int32_t code = 0;
+  if ((code = tdGetBitmapValType(pBitmap, colIdx, &output->valType, 0)) != TSDB_CODE_SUCCESS) {
     output->valType = TD_VTYPE_NONE;
-    return terrno;
+    TAOS_RETURN(code);
   }
 
   if (output->valType == TD_VTYPE_NORM) {
@@ -736,7 +648,7 @@ int32_t tdGetTpRowValOfCol(SCellVal *output, STSRow *pRow, void *pBitmap, int8_t
     }
   }
 
-  return TSDB_CODE_SUCCESS;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t tdAppendColValToRow(SRowBuilder *pBuilder, col_id_t colId, int8_t colType, TDRowValT valType, const void *val,
@@ -745,23 +657,21 @@ int32_t tdAppendColValToRow(SRowBuilder *pBuilder, col_id_t colId, int8_t colTyp
   if (!val) {
 #ifdef TD_SUPPORT_BITMAP
     if (valType == TD_VTYPE_NORM) {
-      terrno = TSDB_CODE_INVALID_PTR;
+      TAOS_RETURN(TSDB_CODE_INVALID_PARA);
-      return terrno;
     }
 #else
-    terrno = TSDB_CODE_INVALID_PARA;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
-    return terrno;
+    d
 #endif
   }
   // TS KEY is stored in STSRow.ts and not included in STSRow.data field.
   if (colId == PRIMARYKEY_TIMESTAMP_COL_ID) {
     if (!val) {
-      terrno = TSDB_CODE_INVALID_PARA;
+      TAOS_RETURN(TSDB_CODE_INVALID_PARA);
-      return terrno;
     }
     TD_ROW_KEY(pRow) = *(TSKEY *)val;
     // The primary TS key is Norm all the time, thus its valType is not stored in bitmap.
-    return TSDB_CODE_SUCCESS;
+    TAOS_RETURN(TSDB_CODE_SUCCESS);
   }
   // TODO:  We can avoid the type judegement by FP, but would prevent the inline scheme.
 
@@ -773,33 +683,29 @@ int32_t tdAppendColValToRow(SRowBuilder *pBuilder, col_id_t colId, int8_t colTyp
       break;
     case TD_VTYPE_NONE:
       if (!pBuilder->hasNone) pBuilder->hasNone = true;
-      return TSDB_CODE_SUCCESS;
+      TAOS_RETURN(TSDB_CODE_SUCCESS);
     default:
-      terrno = TSDB_CODE_INVALID_PARA;
+      TAOS_RETURN(TSDB_CODE_INVALID_PARA);
-      return terrno;
   }
 
   if (TD_IS_TP_ROW(pRow)) {
-    tdAppendColValToTpRow(pBuilder, valType, val, isCopyVarData, colType, colIdx, offset);
+    (void)tdAppendColValToTpRow(pBuilder, valType, val, isCopyVarData, colType, colIdx, offset);
   } else {
-    tdAppendColValToKvRow(pBuilder, valType, val, isCopyVarData, colType, colIdx, offset, colId);
+    (void)tdAppendColValToKvRow(pBuilder, valType, val, isCopyVarData, colType, colIdx, offset, colId);
   }
-  return TSDB_CODE_SUCCESS;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t tdAppendColValToKvRow(SRowBuilder *pBuilder, TDRowValT valType, const void *val, bool isCopyVarData,
                               int8_t colType, int16_t colIdx, int32_t offset, col_id_t colId) {
   if (colIdx < 1) {
-    terrno = TSDB_CODE_INVALID_PARA;
     ASSERTS(0, "colIdx is %" PRIi64, colIdx);
-    return terrno;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
   }
   --colIdx;
 
 #ifdef TD_SUPPORT_BITMAP
-  if (tdSetBitmapValType(pBuilder->pBitmap, colIdx, valType, 0) != TSDB_CODE_SUCCESS) {
+  TAOS_CHECK_RETURN(tdSetBitmapValType(pBuilder->pBitmap, colIdx, valType, 0));
-    return terrno;
-  }
 #endif
 
   STSRow *row = pBuilder->pBuf;
@@ -812,30 +718,27 @@ int32_t tdAppendColValToKvRow(SRowBuilder *pBuilder, TDRowValT valType, const vo
     char *ptr = (char *)POINTER_SHIFT(row, TD_ROW_LEN(row));
     if (IS_VAR_DATA_TYPE(colType)) {
       if (isCopyVarData) {
-        memcpy(ptr, val, varDataTLen(val));
+        (void)memcpy(ptr, val, varDataTLen(val));
       }
       TD_ROW_LEN(row) += varDataTLen(val);
     } else {
-      memcpy(ptr, val, TYPE_BYTES[colType]);
+      (void)memcpy(ptr, val, TYPE_BYTES[colType]);
       TD_ROW_LEN(row) += TYPE_BYTES[colType];
     }
   }
 
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t tdAppendColValToTpRow(SRowBuilder *pBuilder, TDRowValT valType, const void *val, bool isCopyVarData,
                               int8_t colType, int16_t colIdx, int32_t offset) {
   if (colIdx < 1) {
-    terrno = TSDB_CODE_INVALID_PARA;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
-    return terrno;
   }
   --colIdx;
 
 #ifdef TD_SUPPORT_BITMAP
-  if (tdSetBitmapValType(pBuilder->pBitmap, colIdx, valType, 0) != TSDB_CODE_SUCCESS) {
+  TAOS_CHECK_RETURN(tdSetBitmapValType(pBuilder->pBitmap, colIdx, valType, 0));
-    return terrno;
-  }
 #endif
 
   STSRow *row = pBuilder->pBuf;
@@ -849,59 +752,21 @@ int32_t tdAppendColValToTpRow(SRowBuilder *pBuilder, TDRowValT valType, const vo
       // ts key stored in STSRow.ts
       *(VarDataOffsetT *)POINTER_SHIFT(TD_ROW_DATA(row), offset) = TD_ROW_LEN(row);
       if (isCopyVarData) {
-        memcpy(POINTER_SHIFT(row, TD_ROW_LEN(row)), val, varDataTLen(val));
+        (void)memcpy(POINTER_SHIFT(row, TD_ROW_LEN(row)), val, varDataTLen(val));
       }
       TD_ROW_LEN(row) += varDataTLen(val);
     } else {
-      memcpy(POINTER_SHIFT(TD_ROW_DATA(row), offset), val, TYPE_BYTES[colType]);
+      (void)memcpy(POINTER_SHIFT(TD_ROW_DATA(row), offset), val, TYPE_BYTES[colType]);
     }
   }
 
-  return 0;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
-#if 0
-int32_t tdSRowSetExtendedInfo(SRowBuilder *pBuilder, int32_t nCols, int32_t nBoundCols, int32_t flen,
-                              int32_t allNullLen, int32_t boundNullLen) {
-  if ((boundNullLen > 0) && (allNullLen > 0) && (nBoundCols > 0)) {
-    uint32_t tpLen = allNullLen;
-    uint32_t kvLen = sizeof(col_id_t) + sizeof(SKvRowIdx) * nBoundCols + boundNullLen;
-    if (isSelectKVRow(kvLen, tpLen)) {
-      pBuilder->rowType = TD_ROW_KV;
-    } else {
-      pBuilder->rowType = TD_ROW_TP;
-    }
-
-  } else {
-    pBuilder->rowType = TD_ROW_TP;
-  }
-  pBuilder->flen = flen;
-  pBuilder->nCols = nCols;
-  pBuilder->nBoundCols = nBoundCols;
-  if (pBuilder->flen <= 0 || pBuilder->nCols <= 0) {
-    terrno = TSDB_CODE_INVALID_PARA;
-    return terrno;
-  }
-#ifdef TD_SUPPORT_BITMAP
-  // the primary TS key is stored separatedly
-  pBuilder->nBitmaps = (col_id_t)TD_BITMAP_BYTES(pBuilder->nCols - 1);
-  if (nBoundCols > 0) {
-    pBuilder->nBoundBitmaps = (col_id_t)TD_BITMAP_BYTES(pBuilder->nBoundCols - 1);
-  } else {
-    pBuilder->nBoundBitmaps = 0;
-  }
-#else
-  pBuilder->nBitmaps = 0;
-  pBuilder->nBoundBitmaps = 0;
-#endif
-  return TSDB_CODE_SUCCESS;
-}
-#endif
 
 int32_t tdSRowResetBuf(SRowBuilder *pBuilder, void *pBuf) {
   pBuilder->pBuf = (STSRow *)pBuf;
   if (!pBuilder->pBuf) {
-    terrno = TSDB_CODE_INVALID_PARA;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
-    return terrno;
   }
 
   if (pBuilder->hasNone) pBuilder->hasNone = false;
@@ -917,7 +782,7 @@ int32_t tdSRowResetBuf(SRowBuilder *pBuilder, void *pBuf) {
     case TD_ROW_TP:
 #ifdef TD_SUPPORT_BITMAP
       pBuilder->pBitmap = tdGetBitmapAddrTp(pBuilder->pBuf, pBuilder->flen);
-      memset(pBuilder->pBitmap, TD_VTYPE_NONE_BYTE_II, pBuilder->nBitmaps);
+      (void)memset(pBuilder->pBitmap, TD_VTYPE_NONE_BYTE_II, pBuilder->nBitmaps);
 #endif
       // the primary TS key is stored separatedly
       len = TD_ROW_HEAD_LEN + pBuilder->flen + pBuilder->nBitmaps;
@@ -927,7 +792,7 @@ int32_t tdSRowResetBuf(SRowBuilder *pBuilder, void *pBuf) {
     case TD_ROW_KV:
 #ifdef TD_SUPPORT_BITMAP
       pBuilder->pBitmap = tdGetBitmapAddrKv(pBuilder->pBuf, pBuilder->nBoundCols);
-      memset(pBuilder->pBitmap, TD_VTYPE_NONE_BYTE_II, pBuilder->nBoundBitmaps);
+      (void)memset(pBuilder->pBitmap, TD_VTYPE_NONE_BYTE_II, pBuilder->nBoundBitmaps);
 #endif
       len = TD_ROW_HEAD_LEN + TD_ROW_NCOLS_LEN + (pBuilder->nBoundCols - 1) * sizeof(SKvRowIdx) +
             pBuilder->nBoundBitmaps;  // add
@@ -937,18 +802,16 @@ int32_t tdSRowResetBuf(SRowBuilder *pBuilder, void *pBuf) {
       pBuilder->offset = 0;
       break;
     default:
-      terrno = TSDB_CODE_INVALID_PARA;
+      TAOS_RETURN(TSDB_CODE_INVALID_PARA);
-      return terrno;
   }
 
-  return TSDB_CODE_SUCCESS;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t tdSRowGetBuf(SRowBuilder *pBuilder, void *pBuf) {
   pBuilder->pBuf = (STSRow *)pBuf;
   if (!pBuilder->pBuf) {
-    terrno = TSDB_CODE_INVALID_PARA;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
-    return terrno;
   }
 
   ASSERT(pBuilder->nBitmaps > 0 && pBuilder->flen > 0);
@@ -966,10 +829,9 @@ int32_t tdSRowGetBuf(SRowBuilder *pBuilder, void *pBuf) {
 #endif
       break;
     default:
-      terrno = TSDB_CODE_INVALID_PARA;
+      TAOS_RETURN(TSDB_CODE_INVALID_PARA);
-      return terrno;
   }
-  return TSDB_CODE_SUCCESS;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 void tdSRowReset(SRowBuilder *pBuilder) {
@@ -985,8 +847,7 @@ int32_t tdSRowSetTpInfo(SRowBuilder *pBuilder, int32_t nCols, int32_t flen) {
   pBuilder->flen = flen;
   pBuilder->nCols = nCols;
   if (pBuilder->flen <= 0 || pBuilder->nCols <= 0) {
-    terrno = TSDB_CODE_INVALID_PARA;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
-    return terrno;
   }
 #ifdef TD_SUPPORT_BITMAP
   // the primary TS key is stored separatedly
@@ -995,7 +856,7 @@ int32_t tdSRowSetTpInfo(SRowBuilder *pBuilder, int32_t nCols, int32_t flen) {
   pBuilder->nBitmaps = 0;
   pBuilder->nBoundBitmaps = 0;
 #endif
-  return TSDB_CODE_SUCCESS;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t tdSRowSetInfo(SRowBuilder *pBuilder, int32_t nCols, int32_t nBoundCols, int32_t flen) {
@@ -1003,8 +864,7 @@ int32_t tdSRowSetInfo(SRowBuilder *pBuilder, int32_t nCols, int32_t nBoundCols,
   pBuilder->nCols = nCols;
   pBuilder->nBoundCols = nBoundCols;
   if (pBuilder->flen <= 0 || pBuilder->nCols <= 0) {
-    terrno = TSDB_CODE_INVALID_PARA;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
-    return terrno;
   }
 #ifdef TD_SUPPORT_BITMAP
   // the primary TS key is stored separatedly
@@ -1018,24 +878,12 @@ int32_t tdSRowSetInfo(SRowBuilder *pBuilder, int32_t nCols, int32_t nBoundCols,
   pBuilder->nBitmaps = 0;
   pBuilder->nBoundBitmaps = 0;
 #endif
-  return TSDB_CODE_SUCCESS;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
-#if 0
-bool tdIsBitmapValTypeNorm(const void *pBitmap, int16_t idx, int8_t bitmapMode) {
-  TDRowValT valType = 0;
-  tdGetBitmapValType(pBitmap, idx, &valType, bitmapMode);
-  if (tdValTypeIsNorm(valType)) {
-    return true;
-  }
-  return false;
-}
-#endif
-
 int32_t tdSetBitmapValTypeII(void *pBitmap, int16_t colIdx, TDRowValT valType) {
   if (!pBitmap || colIdx < 0) {
-    terrno = TSDB_CODE_INVALID_PARA;
+    TAOS_RETURN(TSDB_CODE_INVALID_PARA);
-    return terrno;
   }
   int16_t nBytes = colIdx / TD_VTYPE_PARTS;
   int16_t nOffset = colIdx & TD_VTYPE_OPTR;
@@ -1060,10 +908,9 @@ int32_t tdSetBitmapValTypeII(void *pBitmap, int16_t colIdx, TDRowValT valType) {
       // *pDestByte |= (valType);
       break;
     default:
-      terrno = TSDB_CODE_INVALID_PARA;
+      TAOS_RETURN(TSDB_CODE_INVALID_PARA);
-      return terrno;
   }
-  return TSDB_CODE_SUCCESS;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t tdSetBitmapValType(void *pBitmap, int16_t colIdx, TDRowValT valType, int8_t bitmapMode) {
@@ -1078,14 +925,11 @@ int32_t tdSetBitmapValType(void *pBitmap, int16_t colIdx, TDRowValT valType, int
       break;
 #endif
     default:
-      terrno = TSDB_CODE_INVALID_PARA;
+      TAOS_RETURN(TSDB_CODE_INVALID_PARA);
-      return TSDB_CODE_FAILED;
   }
-  return TSDB_CODE_SUCCESS;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
-
-
 void tTSRowGetVal(STSRow *pRow, STSchema *pTSchema, int16_t iCol, SColVal *pColVal) {
   STColumn *pTColumn = &pTSchema->columns[iCol];
   SCellVal  cv = {0};
@@ -1093,9 +937,9 @@ void tTSRowGetVal(STSRow *pRow, STSchema *pTSchema, int16_t iCol, SColVal *pColV
   ASSERT((pTColumn->colId == PRIMARYKEY_TIMESTAMP_COL_ID) || (iCol > 0));
 
   if (TD_IS_TP_ROW(pRow)) {
-    tdSTpRowGetVal(pRow, pTColumn->colId, pTColumn->type, pTSchema->flen, pTColumn->offset, iCol - 1, &cv);
+    (void)tdSTpRowGetVal(pRow, pTColumn->colId, pTColumn->type, pTSchema->flen, pTColumn->offset, iCol - 1, &cv);
   } else if (TD_IS_KV_ROW(pRow)) {
-    tdSKvRowGetVal(pRow, pTColumn->colId, iCol - 1, &cv);
+    (void)tdSKvRowGetVal(pRow, pTColumn->colId, iCol - 1, &cv);
   } else {
     ASSERT(0);
   }
@@ -1113,7 +957,7 @@ void tTSRowGetVal(STSRow *pRow, STSchema *pTSchema, int16_t iCol, SColVal *pColV
       pColVal->value.nData = varDataLen(cv.val);
       pColVal->value.pData = varDataVal(cv.val);
     } else {
-      memcpy(&pColVal->value.val, cv.val, tDataTypes[pTColumn->type].bytes);
+      (void)memcpy(&pColVal->value.val, cv.val, tDataTypes[pTColumn->type].bytes);
     }
   }
 }

source/common/src/ttime.c

@@ -96,8 +96,6 @@ char* forwardToTimeStringEnd(char* str) {
 }
 
 int32_t parseFraction(char* str, char** end, int32_t timePrec, int64_t* pFraction) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   int32_t i = 0;
   int64_t fraction = 0;
 
@@ -147,8 +145,6 @@ int32_t parseFraction(char* str, char** end, int32_t timePrec, int64_t* pFractio
 }
 
 int32_t parseTimezone(char* str, int64_t* tzOffset) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   int64_t hour = 0;
 
   int32_t i = 0;
@@ -224,8 +220,6 @@ int32_t offsetOfTimezone(char* tzStr, int64_t* offset) {
  * 2013-04-12T15:52:01.123+0800
  */
 int32_t parseTimeWithTz(const char* timestr, int64_t* time, int32_t timePrec, char delim) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   int64_t factor = TSDB_TICK_PER_SECOND(timePrec);
   int64_t tzOffset = 0;
 
@@ -315,8 +309,6 @@ static FORCE_INLINE bool validateTm(struct tm* pTm) {
 }
 
 int32_t parseLocaltime(char* timestr, int32_t len, int64_t* utime, int32_t timePrec, char delim) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   *utime = 0;
   struct tm tm = {0};
 
@@ -358,8 +350,6 @@ int32_t parseLocaltime(char* timestr, int32_t len, int64_t* utime, int32_t timeP
 }
 
 int32_t parseLocaltimeDst(char* timestr, int32_t len, int64_t* utime, int32_t timePrec, char delim) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   *utime = 0;
   struct tm tm = {0};
   tm.tm_isdst = -1;
@@ -484,8 +474,6 @@ int64_t convertTimePrecision(int64_t utime, int32_t fromPrecision, int32_t toPre
 // !!!!notice: double lose precison if time is too large, for example: 1626006833631000000*1.0 = double =
 // 1626006833631000064
 int32_t convertTimeFromPrecisionToUnit(int64_t time, int32_t fromPrecision, char toUnit, int64_t* pRes) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   if (fromPrecision != TSDB_TIME_PRECISION_MILLI && fromPrecision != TSDB_TIME_PRECISION_MICRO &&
       fromPrecision != TSDB_TIME_PRECISION_NANO) {
     TAOS_RETURN(TSDB_CODE_INVALID_PARA);
@@ -559,13 +547,14 @@ int32_t convertTimeFromPrecisionToUnit(int64_t time, int32_t fromPrecision, char
 }
 
 int32_t convertStringToTimestamp(int16_t type, char* inputData, int64_t timePrec, int64_t* timeVal) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   int32_t charLen = varDataLen(inputData);
   char*   newColData;
   if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_VARBINARY) {
     newColData = taosMemoryCalloc(1, charLen + 1);
-    memcpy(newColData, varDataVal(inputData), charLen);
+    if (NULL == newColData) {
+      TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    }
+    (void)memcpy(newColData, varDataVal(inputData), charLen);
     int32_t ret = taosParseTime(newColData, timeVal, charLen, (int32_t)timePrec, tsDaylight);
     if (ret != TSDB_CODE_SUCCESS) {
       taosMemoryFree(newColData);
@@ -574,6 +563,9 @@ int32_t convertStringToTimestamp(int16_t type, char* inputData, int64_t timePrec
     taosMemoryFree(newColData);
   } else if (type == TSDB_DATA_TYPE_NCHAR) {
     newColData = taosMemoryCalloc(1, charLen + TSDB_NCHAR_SIZE);
+    if (NULL == newColData) {
+      TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    }
     int len = taosUcs4ToMbs((TdUcs4*)varDataVal(inputData), charLen, newColData);
     if (len < 0) {
       taosMemoryFree(newColData);
@@ -593,8 +585,6 @@ int32_t convertStringToTimestamp(int16_t type, char* inputData, int64_t timePrec
 }
 
 int32_t getDuration(int64_t val, char unit, int64_t* result, int32_t timePrecision) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   switch (unit) {
     case 's':
       if (val > INT64_MAX / MILLISECOND_PER_SECOND) {
@@ -658,8 +648,6 @@ int32_t getDuration(int64_t val, char unit, int64_t* result, int32_t timePrecisi
  */
 int32_t parseAbsoluteDuration(const char* token, int32_t tokenlen, int64_t* duration, char* unit,
                               int32_t timePrecision) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   errno = 0;
   char* endPtr = NULL;
 
@@ -680,8 +668,6 @@ int32_t parseAbsoluteDuration(const char* token, int32_t tokenlen, int64_t* dura
 
 int32_t parseNatualDuration(const char* token, int32_t tokenLen, int64_t* duration, char* unit, int32_t timePrecision,
                             bool negativeAllow) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   errno = 0;
 
   /* get the basic numeric value */
@@ -718,7 +704,7 @@ int64_t taosTimeAdd(int64_t t, int64_t duration, char unit, int32_t precision) {
 
   struct tm tm;
   time_t    tt = (time_t)(t / TSDB_TICK_PER_SECOND(precision));
-  taosLocalTime(&tt, &tm, NULL);
+  (void)taosLocalTime(&tt, &tm, NULL);
   int32_t mon = tm.tm_year * 12 + tm.tm_mon + (int32_t)numOfMonth;
   tm.tm_year = mon / 12;
   tm.tm_mon = mon % 12;
@@ -779,11 +765,11 @@ int32_t taosTimeCountIntervalForFill(int64_t skey, int64_t ekey, int64_t interva
 
     struct tm tm;
     time_t    t = (time_t)skey;
-    taosLocalTime(&t, &tm, NULL);
+    (void)taosLocalTime(&t, &tm, NULL);
     int32_t smon = tm.tm_year * 12 + tm.tm_mon;
 
     t = (time_t)ekey;
-    taosLocalTime(&t, &tm, NULL);
+    (void)taosLocalTime(&t, &tm, NULL);
     int32_t emon = tm.tm_year * 12 + tm.tm_mon;
 
     if (unit == 'y') {
@@ -808,7 +794,7 @@ int64_t taosTimeTruncate(int64_t ts, const SInterval* pInterval) {
     start /= (int64_t)(TSDB_TICK_PER_SECOND(precision));
     struct tm tm;
     time_t    tt = (time_t)start;
-    taosLocalTime(&tt, &tm, NULL);
+    (void)taosLocalTime(&tt, &tm, NULL);
     tm.tm_sec = 0;
     tm.tm_min = 0;
     tm.tm_hour = 0;
@@ -978,8 +964,6 @@ const char* fmtts(int64_t ts) {
 }
 
 int32_t taosFormatUtcTime(char* buf, int32_t bufLen, int64_t t, int32_t precision) {
-  int32_t code = TSDB_CODE_SUCCESS;
-
   char      ts[40] = {0};
   struct tm ptm;
 
@@ -1018,7 +1002,7 @@ int32_t taosFormatUtcTime(char* buf, int32_t bufLen, int64_t t, int32_t precisio
       TAOS_RETURN(TSDB_CODE_INVALID_PARA);
   }
 
-  if (taosLocalTime(&quot, &ptm, buf) == NULL) {
+  if (NULL == taosLocalTime(&quot, &ptm, buf)) {
     TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
   }
   int32_t length = (int32_t)strftime(ts, 40, "%Y-%m-%dT%H:%M:%S", &ptm);
@@ -1032,7 +1016,9 @@ int32_t taosFormatUtcTime(char* buf, int32_t bufLen, int64_t t, int32_t precisio
 int32_t taosTs2Tm(int64_t ts, int32_t precision, struct STm* tm) {
   tm->fsec = ts % TICK_PER_SECOND[precision] * (TICK_PER_SECOND[TSDB_TIME_PRECISION_NANO] / TICK_PER_SECOND[precision]);
   time_t t = ts / TICK_PER_SECOND[precision];
-  taosLocalTime(&t, &tm->tm, NULL);
+  if (NULL == taosLocalTime(&t, &tm->tm, NULL)) {
+    TAOS_RETURN(TAOS_SYSTEM_ERROR(errno));
+  }
   return TSDB_CODE_SUCCESS;
 }
 
@@ -1266,13 +1252,13 @@ static bool isSeperatorChar(char c) {
   return (c > 0x20 && c < 0x7F && !(c >= 'A' && c <= 'Z') && !(c >= 'a' && c <= 'z') && !(c >= '0' && c <= '9'));
 }
 
-static void parseTsFormat(const char* formatStr, SArray* formats) {
+static int32_t parseTsFormat(const char* formatStr, SArray* formats) {
   TSFormatNode* lastOtherFormat = NULL;
   while (*formatStr) {
     const TSFormatKeyWord* key = keywordSearch(formatStr);
     if (key) {
       TSFormatNode format = {.key = key, .type = TS_FORMAT_NODE_TYPE_KEYWORD};
-      taosArrayPush(formats, &format);
+      if (NULL == taosArrayPush(formats, &format)) TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
       formatStr += key->len;
       lastOtherFormat = NULL;
     } else {
@@ -1300,7 +1286,7 @@ static void parseTsFormat(const char* formatStr, SArray* formats) {
             TSFormatNode format = {.type = TS_FORMAT_NODE_TYPE_CHAR, .key = NULL};
             format.c = formatStr;
             format.len = 1;
-            taosArrayPush(formats, &format);
+            if (NULL == taosArrayPush(formats, &format)) TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
             formatStr++;
             last = taosArrayGetLast(formats);
           }
@@ -1328,13 +1314,14 @@ static void parseTsFormat(const char* formatStr, SArray* formats) {
               .key = NULL};
           format.c = formatStr;
           format.len = 1;
-          taosArrayPush(formats, &format);
+          if (NULL == taosArrayPush(formats, &format)) TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
           formatStr++;
           if (format.type == TS_FORMAT_NODE_TYPE_CHAR) lastOtherFormat = taosArrayGetLast(formats);
         }
       }
     }
   }
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 static int32_t tm2char(const SArray* formats, const struct STm* tm, char* s, int32_t outLen) {
@@ -1344,7 +1331,7 @@ static int32_t tm2char(const SArray* formats, const struct STm* tm, char* s, int
     TSFormatNode* format = taosArrayGet(formats, i);
     if (format->type != TS_FORMAT_NODE_TYPE_KEYWORD) {
       if (s - start + format->len + 1 > outLen) break;
-      strncpy(s, format->c, format->len);
+      (void)strncpy(s, format->c, format->len);
       s += format->len;
       continue;
     }
@@ -1353,37 +1340,37 @@ static int32_t tm2char(const SArray* formats, const struct STm* tm, char* s, int
     switch (format->key->id) {
       case TSFKW_AM:
       case TSFKW_PM:
-        sprintf(s, tm->tm.tm_hour % 24 >= 12 ? "PM" : "AM");
+        (void)sprintf(s, tm->tm.tm_hour % 24 >= 12 ? "PM" : "AM");
         s += 2;
         break;
       case TSFKW_A_M:
       case TSFKW_P_M:
-        sprintf(s, tm->tm.tm_hour % 24 >= 12 ? "P.M." : "A.M.");
+        (void)sprintf(s, tm->tm.tm_hour % 24 >= 12 ? "P.M." : "A.M.");
         s += 4;
         break;
       case TSFKW_am:
       case TSFKW_pm:
-        sprintf(s, tm->tm.tm_hour % 24 >= 12 ? "pm" : "am");
+        (void)sprintf(s, tm->tm.tm_hour % 24 >= 12 ? "pm" : "am");
         s += 2;
         break;
       case TSFKW_a_m:
       case TSFKW_p_m:
-        sprintf(s, tm->tm.tm_hour % 24 >= 12 ? "p.m." : "a.m.");
+        (void)sprintf(s, tm->tm.tm_hour % 24 >= 12 ? "p.m." : "a.m.");
         s += 4;
         break;
       case TSFKW_DDD:
 #ifdef WINDOWS
         return TSDB_CODE_FUNC_TO_CHAR_NOT_SUPPORTED;
 #endif
-        sprintf(s, "%03d", tm->tm.tm_yday + 1);
+        (void)sprintf(s, "%03d", tm->tm.tm_yday + 1);
         s += strlen(s);
         break;
       case TSFKW_DD:
-        sprintf(s, "%02d", tm->tm.tm_mday);
+        (void)sprintf(s, "%02d", tm->tm.tm_mday);
         s += 2;
         break;
       case TSFKW_D:
-        sprintf(s, "%d", tm->tm.tm_wday + 1);
+        (void)sprintf(s, "%d", tm->tm.tm_wday + 1);
         s += 1;
         break;
       case TSFKW_DAY: {
@@ -1391,20 +1378,20 @@ static int32_t tm2char(const SArray* formats, const struct STm* tm, char* s, int
         const char* wd = weekDays[tm->tm.tm_wday];
         char        buf[10] = {0};
         for (int32_t i = 0; i < strlen(wd); ++i) buf[i] = toupper(wd[i]);
-        sprintf(s, "%-9s", buf);
+        (void)sprintf(s, "%-9s", buf);
         s += strlen(s);
         break;
       }
       case TSFKW_Day:
         // Monday, TuesDay...
-        sprintf(s, "%-9s", weekDays[tm->tm.tm_wday]);
+        (void)sprintf(s, "%-9s", weekDays[tm->tm.tm_wday]);
         s += strlen(s);
         break;
       case TSFKW_day: {
         const char* wd = weekDays[tm->tm.tm_wday];
         char        buf[10] = {0};
         for (int32_t i = 0; i < strlen(wd); ++i) buf[i] = tolower(wd[i]);
-        sprintf(s, "%-9s", buf);
+        (void)sprintf(s, "%-9s", buf);
         s += strlen(s);
         break;
       }
@@ -1413,13 +1400,13 @@ static int32_t tm2char(const SArray* formats, const struct STm* tm, char* s, int
         const char* wd = shortWeekDays[tm->tm.tm_wday];
         char        buf[8] = {0};
         for (int32_t i = 0; i < strlen(wd); ++i) buf[i] = toupper(wd[i]);
-        sprintf(s, "%3s", buf);
+        (void)sprintf(s, "%3s", buf);
         s += 3;
         break;
       }
       case TSFKW_Dy:
         // Mon, Tue
-        sprintf(s, "%3s", shortWeekDays[tm->tm.tm_wday]);
+        (void)sprintf(s, "%3s", shortWeekDays[tm->tm.tm_wday]);
         s += 3;
         break;
       case TSFKW_dy: {
@@ -1427,33 +1414,33 @@ static int32_t tm2char(const SArray* formats, const struct STm* tm, char* s, int
         const char* wd = shortWeekDays[tm->tm.tm_wday];
         char        buf[8] = {0};
         for (int32_t i = 0; i < strlen(wd); ++i) buf[i] = tolower(wd[i]);
-        sprintf(s, "%3s", buf);
+        (void)sprintf(s, "%3s", buf);
         s += 3;
         break;
       }
       case TSFKW_HH24:
-        sprintf(s, "%02d", tm->tm.tm_hour);
+        (void)sprintf(s, "%02d", tm->tm.tm_hour);
         s += 2;
         break;
       case TSFKW_HH:
       case TSFKW_HH12:
         // 0 or 12 o'clock in 24H coresponds to 12 o'clock (AM/PM) in 12H
-        sprintf(s, "%02d", tm->tm.tm_hour % 12 == 0 ? 12 : tm->tm.tm_hour % 12);
+        (void)sprintf(s, "%02d", tm->tm.tm_hour % 12 == 0 ? 12 : tm->tm.tm_hour % 12);
         s += 2;
         break;
       case TSFKW_MI:
-        sprintf(s, "%02d", tm->tm.tm_min);
+        (void)sprintf(s, "%02d", tm->tm.tm_min);
         s += 2;
         break;
       case TSFKW_MM:
-        sprintf(s, "%02d", tm->tm.tm_mon + 1);
+        (void)sprintf(s, "%02d", tm->tm.tm_mon + 1);
         s += 2;
         break;
       case TSFKW_MONTH: {
         const char* mon = fullMonths[tm->tm.tm_mon];
         char        buf[10] = {0};
         for (int32_t i = 0; i < strlen(mon); ++i) buf[i] = toupper(mon[i]);
-        sprintf(s, "%-9s", buf);
+        (void)sprintf(s, "%-9s", buf);
         s += strlen(s);
         break;
       }
@@ -1461,68 +1448,68 @@ static int32_t tm2char(const SArray* formats, const struct STm* tm, char* s, int
         const char* mon = months[tm->tm.tm_mon];
         char        buf[10] = {0};
         for (int32_t i = 0; i < strlen(mon); ++i) buf[i] = toupper(mon[i]);
-        sprintf(s, "%s", buf);
+        (void)sprintf(s, "%s", buf);
         s += strlen(s);
         break;
       }
       case TSFKW_Month:
-        sprintf(s, "%-9s", fullMonths[tm->tm.tm_mon]);
+        (void)sprintf(s, "%-9s", fullMonths[tm->tm.tm_mon]);
         s += strlen(s);
         break;
       case TSFKW_month: {
         const char* mon = fullMonths[tm->tm.tm_mon];
         char        buf[10] = {0};
         for (int32_t i = 0; i < strlen(mon); ++i) buf[i] = tolower(mon[i]);
-        sprintf(s, "%-9s", buf);
+        (void)sprintf(s, "%-9s", buf);
         s += strlen(s);
         break;
       }
       case TSFKW_Mon:
-        sprintf(s, "%s", months[tm->tm.tm_mon]);
+        (void)sprintf(s, "%s", months[tm->tm.tm_mon]);
         s += strlen(s);
         break;
       case TSFKW_mon: {
         const char* mon = months[tm->tm.tm_mon];
         char        buf[10] = {0};
         for (int32_t i = 0; i < strlen(mon); ++i) buf[i] = tolower(mon[i]);
-        sprintf(s, "%s", buf);
+        (void)sprintf(s, "%s", buf);
         s += strlen(s);
         break;
       }
       case TSFKW_SS:
-        sprintf(s, "%02d", tm->tm.tm_sec);
+        (void)sprintf(s, "%02d", tm->tm.tm_sec);
         s += 2;
         break;
       case TSFKW_MS:
-        sprintf(s, "%03" PRId64, tm->fsec / 1000000L);
+        (void)sprintf(s, "%03" PRId64, tm->fsec / 1000000L);
         s += 3;
         break;
       case TSFKW_US:
-        sprintf(s, "%06" PRId64, tm->fsec / 1000L);
+        (void)sprintf(s, "%06" PRId64, tm->fsec / 1000L);
         s += 6;
         break;
       case TSFKW_NS:
-        sprintf(s, "%09" PRId64, tm->fsec);
+        (void)sprintf(s, "%09" PRId64, tm->fsec);
         s += 9;
         break;
       case TSFKW_TZH:
-        sprintf(s, "%s%02d", tsTimezone < 0 ? "-" : "+", tsTimezone);
+        (void)sprintf(s, "%s%02d", tsTimezone < 0 ? "-" : "+", tsTimezone);
         s += strlen(s);
         break;
       case TSFKW_YYYY:
-        sprintf(s, "%04d", tm->tm.tm_year + 1900);
+        (void)sprintf(s, "%04d", tm->tm.tm_year + 1900);
         s += strlen(s);
         break;
       case TSFKW_YYY:
-        sprintf(s, "%03d", (tm->tm.tm_year + 1900) % 1000);
+        (void)sprintf(s, "%03d", (tm->tm.tm_year + 1900) % 1000);
         s += strlen(s);
         break;
       case TSFKW_YY:
-        sprintf(s, "%02d", (tm->tm.tm_year + 1900) % 100);
+        (void)sprintf(s, "%02d", (tm->tm.tm_year + 1900) % 100);
         s += strlen(s);
         break;
       case TSFKW_Y:
-        sprintf(s, "%01d", (tm->tm.tm_year + 1900) % 10);
+        (void)sprintf(s, "%01d", (tm->tm.tm_year + 1900) % 10);
         s += strlen(s);
         break;
       default:
@@ -1557,7 +1544,7 @@ static const char* tsFormatStr2Int32(int32_t* dest, const char* str, int32_t len
     s = last;
   } else {
     char buf[16] = {0};
-    strncpy(buf, s, len);
+    (void)strncpy(buf, s, len);
     int32_t copiedLen = strlen(buf);
     if (copiedLen < len) {
       if (!needMoreDigit) {
@@ -1936,10 +1923,13 @@ static int32_t char2ts(const char* s, SArray* formats, int64_t* ts, int32_t prec
 int32_t taosTs2Char(const char* format, SArray** formats, int64_t ts, int32_t precision, char* out, int32_t outLen) {
   if (!*formats) {
     *formats = taosArrayInit(8, sizeof(TSFormatNode));
-    parseTsFormat(format, *formats);
+    if (!*formats){
+      TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    }
+    TAOS_CHECK_RETURN(parseTsFormat(format, *formats));
   }
   struct STm tm;
-  taosTs2Tm(ts, precision, &tm);
+  TAOS_CHECK_RETURN(taosTs2Tm(ts, precision, &tm));
   return tm2char(*formats, &tm, out, outLen);
 }
 
@@ -1949,7 +1939,10 @@ int32_t taosChar2Ts(const char* format, SArray** formats, const char* tsStr, int
   int32_t     fErrIdx;
   if (!*formats) {
     *formats = taosArrayInit(4, sizeof(TSFormatNode));
-    parseTsFormat(format, *formats);
+    if (!*formats) {
+      TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+    }
+    TAOS_CHECK_RETURN(parseTsFormat(format, *formats));
   }
   int32_t code = char2ts(tsStr, *formats, ts, precision, &sErrPos, &fErrIdx);
   if (code == -1) {
@@ -1964,27 +1957,35 @@ int32_t taosChar2Ts(const char* format, SArray** formats, const char* tsStr, int
     snprintf(errMsg, errMsgLen, "timestamp format not supported");
     code = TSDB_CODE_FUNC_TO_TIMESTAMP_FAILED_NOT_SUPPORTED;
   }
-  return code;
+  TAOS_RETURN(code);
 }
 
-void TEST_ts2char(const char* format, int64_t ts, int32_t precision, char* out, int32_t outLen) {
+int32_t TEST_ts2char(const char* format, int64_t ts, int32_t precision, char* out, int32_t outLen) {
+  int32_t code = TSDB_CODE_SUCCESS;
+
   SArray* formats = taosArrayInit(4, sizeof(TSFormatNode));
-  parseTsFormat(format, formats);
+  if (!formats) {
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
+  }
+  TAOS_CHECK_RETURN(parseTsFormat(format, formats));
   struct STm tm;
-  taosTs2Tm(ts, precision, &tm);
+  TAOS_CHECK_GOTO(taosTs2Tm(ts, precision, &tm), NULL, _exit);
-  tm2char(formats, &tm, out, outLen);
+  TAOS_CHECK_GOTO(tm2char(formats, &tm, out, outLen), NULL, _exit);
+
+_exit:
   taosArrayDestroy(formats);
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 int32_t TEST_char2ts(const char* format, int64_t* ts, int32_t precision, const char* tsStr) {
   const char* sErrPos;
   int32_t     fErrIdx;
   SArray*     formats = taosArrayInit(4, sizeof(TSFormatNode));
-  parseTsFormat(format, formats);
+  TAOS_CHECK_RETURN(parseTsFormat(format, formats));
   int32_t code = char2ts(tsStr, formats, ts, precision, &sErrPos, &fErrIdx);
   if (code == -1) {
-    printf("failed position: %s\n", sErrPos);
+    (void)printf("failed position: %s\n", sErrPos);
-    printf("failed format: %s\n", ((TSFormatNode*)taosArrayGet(formats, fErrIdx))->key->name);
+    (void)printf("failed format: %s\n", ((TSFormatNode*)taosArrayGet(formats, fErrIdx))->key->name);
   }
   taosArrayDestroy(formats);
   return code;
@@ -1997,17 +1998,19 @@ static int8_t UNIT_INDEX[26] = {/*a*/ 2,  0,  -1, 6,  -1, -1, -1,
 
 #define GET_UNIT_INDEX(idx) UNIT_INDEX[(idx) - 97]
 
-static int64_t UNIT_MATRIX[10][11] = {/*  ns,   us,   ms,    s,   min,   h,   d,   w, month, y*/
+// clang-format off
-                                      /*ns*/ {1, 1000, 0},
+static int64_t UNIT_MATRIX[10][11] = {     /*  ns,   us,   ms,    s,   min,   h,   d,   w, month, y*/
-                                      /*us*/ {1000, 1, 1000, 0},
+                                /*ns*/ {   1, 1000,    0},
-                                      /*ms*/ {0, 1000, 1, 1000, 0},
+                                /*us*/ {1000,    1, 1000,    0},
-                                      /*s*/ {0, 0, 1000, 1, 60, 0},
+                                /*ms*/ {   0, 1000,    1, 1000,    0},
-                                      /*min*/ {0, 0, 0, 60, 1, 60, 0},
+                                 /*s*/ {   0,    0, 1000,    1,   60,    0},
-                                      /*h*/ {0, 0, 0, 0, 60, 1, 1, 0},
+                               /*min*/ {   0,    0,    0,   60,    1,   60,   0},
-                                      /*d*/ {0, 0, 0, 0, 0, 24, 1, 7, 1, 0},
+                                 /*h*/ {   0,    0,    0,    0,   60,    1,   1,   0},
-                                      /*w*/ {0, 0, 0, 0, 0, 0, 7, 1, -1, 0},
+                                 /*d*/ {   0,    0,    0,    0,    0,   24,   1,   7,   1,   0},
-                                      /*mon*/ {0, 0, 0, 0, 0, 0, 0, 0, 1, 12, 0},
+                                 /*w*/ {   0,    0,    0,    0,    0,    0,   7,   1,  -1,   0},
-                                      /*y*/ {0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 0}};
+                               /*mon*/ {   0,    0,    0,    0,    0,    0,   0,   0,   1,  12,  0},
+                                 /*y*/ {   0,    0,    0,    0,    0,    0,   0,   0,   12,   1,  0}};
+// clang-format on
 
 static bool recursiveTsmaCheckRecursive(int64_t baseInterval, int8_t baseIdx, int64_t interval, int8_t idx,
                                         bool checkEq) {

source/common/src/ttypes.c

@@ -175,7 +175,7 @@ void assignVal(char *val, const char *src, int32_t len, int32_t type) {
       break;
     default: {
       if (len > 0) {
-        memcpy(val, src, len);
+        (void)memcpy(val, src, len);
       }
 
       break;

source/common/src/tvariant.c

@@ -426,7 +426,7 @@ void taosVariantCreateFromBinary(SVariant *pVar, const char *pz, size_t len, uin
       size_t lenInwchar = len / TSDB_NCHAR_SIZE;
 
       pVar->ucs4 = taosMemoryCalloc(1, (lenInwchar + 1) * TSDB_NCHAR_SIZE);
-      memcpy(pVar->ucs4, pz, lenInwchar * TSDB_NCHAR_SIZE);
+      (void)memcpy(pVar->ucs4, pz, lenInwchar * TSDB_NCHAR_SIZE);
       pVar->nLen = (int32_t)len;
 
       break;
@@ -435,7 +435,7 @@ void taosVariantCreateFromBinary(SVariant *pVar, const char *pz, size_t len, uin
     case TSDB_DATA_TYPE_VARBINARY:
     case TSDB_DATA_TYPE_GEOMETRY: {  // todo refactor, extract a method
       pVar->pz = taosMemoryCalloc(len + 1, sizeof(char));
-      memcpy(pVar->pz, pz, len);
+      (void)memcpy(pVar->pz, pz, len);
       pVar->nLen = (int32_t)len;
       break;
     }
@@ -470,10 +470,10 @@ void taosVariantAssign(SVariant *pDst, const SVariant *pSrc) {
     char   *p = taosMemoryRealloc(pDst->pz, len);
     ASSERT(p);
 
-    memset(p, 0, len);
+    (void)memset(p, 0, len);
     pDst->pz = p;
 
-    memcpy(pDst->pz, pSrc->pz, pSrc->nLen);
+    (void)memcpy(pDst->pz, pSrc->pz, pSrc->nLen);
     pDst->nLen = pSrc->nLen;
     return;
   }

source/common/test/commonTests.cpp

@@ -465,7 +465,8 @@ TEST(timeTest, timestamp2tm) {
 
 void test_ts2char(int64_t ts, const char* format, int32_t precison, const char* expected) {
   char buf[256] = {0};
-  TEST_ts2char(format, ts, precison, buf, 256);
+  int32_t code = TEST_ts2char(format, ts, precison, buf, 256);
+  ASSERT_EQ(code, 0);
   printf("ts: %ld format: %s res: [%s], expected: [%s]\n", ts, format, buf, expected);
   ASSERT_STREQ(expected, buf);
 }
@@ -732,16 +733,17 @@ TEST(AlreadyAddGroupIdTest, GroupIdAddedWithDifferentLength) {
 #define SLOW_LOG_TYPE_OTHERS 0x4
 #define SLOW_LOG_TYPE_ALL    0x7
 
-static int32_t taosSetSlowLogScope(char *pScope) {
+static int32_t taosSetSlowLogScope(char* pScopeStr, int32_t* pScope) {
-  if (NULL == pScope || 0 == strlen(pScope)) {
+  if (NULL == pScopeStr || 0 == strlen(pScopeStr)) {
-    return SLOW_LOG_TYPE_QUERY;
+    *pScope = SLOW_LOG_TYPE_QUERY;
+    TAOS_RETURN(TSDB_CODE_SUCCESS);
   }
 
   int32_t slowScope = 0;
 
   char* scope = NULL;
   char *tmp   = NULL;
-  while((scope = strsep(&pScope, "|")) != NULL){
+  while((scope = strsep(&pScopeStr, "|")) != NULL){
     taosMemoryFreeClear(tmp);
     tmp = taosStrdup(scope);
     strtrim(tmp);
@@ -771,73 +773,94 @@ static int32_t taosSetSlowLogScope(char *pScope) {
     }
 
     taosMemoryFreeClear(tmp);
-    uError("Invalid slowLog scope value:%s", pScope);
+    uError("Invalid slowLog scope value:%s", pScopeStr);
-    terrno = TSDB_CODE_INVALID_CFG_VALUE;
+    TAOS_RETURN(TSDB_CODE_INVALID_CFG_VALUE);
-    return -1;
   }
 
+  *pScope = slowScope;
   taosMemoryFreeClear(tmp);
-  return slowScope;
+  TAOS_RETURN(TSDB_CODE_SUCCESS);
 }
 
 TEST(TaosSetSlowLogScopeTest, NullPointerInput) {
-  char *pScope = NULL;
+  char*   pScopeStr = NULL;
-  int32_t result = taosSetSlowLogScope(pScope);
+  int32_t scope = 0;
-  EXPECT_EQ(result, SLOW_LOG_TYPE_QUERY);
+  int32_t result = taosSetSlowLogScope(pScopeStr, &scope);
+  EXPECT_EQ(result, TSDB_CODE_SUCCESS);
+  EXPECT_EQ(scope, SLOW_LOG_TYPE_QUERY);
 }
 
 TEST(TaosSetSlowLogScopeTest, EmptyStringInput) {
-  char pScope[1] = "";
+  char    pScopeStr[1] = "";
-  int32_t result = taosSetSlowLogScope(pScope);
+  int32_t scope = 0;
-  EXPECT_EQ(result, SLOW_LOG_TYPE_QUERY);
+  int32_t result = taosSetSlowLogScope(pScopeStr, &scope);
+  EXPECT_EQ(result, TSDB_CODE_SUCCESS);
+  EXPECT_EQ(scope, SLOW_LOG_TYPE_QUERY);
 }
 
 TEST(TaosSetSlowLogScopeTest, AllScopeInput) {
-  char pScope[] = "all";
+  char    pScopeStr[] = "all";
-  int32_t result = taosSetSlowLogScope(pScope);
+  int32_t scope = 0;
-  EXPECT_EQ(result, SLOW_LOG_TYPE_ALL);
+  int32_t result = taosSetSlowLogScope(pScopeStr, &scope);
+  EXPECT_EQ(result, TSDB_CODE_SUCCESS);
+
+  EXPECT_EQ(scope, SLOW_LOG_TYPE_ALL);
 }
 
 TEST(TaosSetSlowLogScopeTest, QueryScopeInput) {
-  char pScope[] = " query";
+  char    pScopeStr[] = " query";
-  int32_t result = taosSetSlowLogScope(pScope);
+  int32_t scope = 0;
-  EXPECT_EQ(result, SLOW_LOG_TYPE_QUERY);
+  int32_t result = taosSetSlowLogScope(pScopeStr, &scope);
+  EXPECT_EQ(result, TSDB_CODE_SUCCESS);
+  EXPECT_EQ(scope, SLOW_LOG_TYPE_QUERY);
 }
 
 TEST(TaosSetSlowLogScopeTest, InsertScopeInput) {
-  char pScope[] = "insert";
+  char    pScopeStr[] = "insert";
-  int32_t result = taosSetSlowLogScope(pScope);
+  int32_t scope = 0;
-  EXPECT_EQ(result, SLOW_LOG_TYPE_INSERT);
+  int32_t result = taosSetSlowLogScope(pScopeStr, &scope);
+  EXPECT_EQ(result, TSDB_CODE_SUCCESS);
+  EXPECT_EQ(scope, SLOW_LOG_TYPE_INSERT);
 }
 
 TEST(TaosSetSlowLogScopeTest, OthersScopeInput) {
-  char pScope[] = "others";
+  char    pScopeStr[] = "others";
-  int32_t result = taosSetSlowLogScope(pScope);
+  int32_t scope = 0;
-  EXPECT_EQ(result, SLOW_LOG_TYPE_OTHERS);
+  int32_t result = taosSetSlowLogScope(pScopeStr, &scope);
+  EXPECT_EQ(result, TSDB_CODE_SUCCESS);
+  EXPECT_EQ(scope, SLOW_LOG_TYPE_OTHERS);
 }
 
 TEST(TaosSetSlowLogScopeTest, NoneScopeInput) {
-  char pScope[] = "none";
+  char    pScopeStr[] = "none";
-  int32_t result = taosSetSlowLogScope(pScope);
+  int32_t scope = 0;
-  EXPECT_EQ(result, SLOW_LOG_TYPE_NULL);
+  int32_t result = taosSetSlowLogScope(pScopeStr, &scope);
+  EXPECT_EQ(result, TSDB_CODE_SUCCESS);
+  EXPECT_EQ(scope, SLOW_LOG_TYPE_NULL);
 }
 
 TEST(TaosSetSlowLogScopeTest, InvalidScopeInput) {
-  char pScope[] = "invalid";
+  char    pScopeStr[] = "invalid";
-  int32_t result = taosSetSlowLogScope(pScope);
+  int32_t scope = 0;
-  EXPECT_EQ(result, -1);
+  int32_t result = taosSetSlowLogScope(pScopeStr, &scope);
+  EXPECT_EQ(result, TSDB_CODE_SUCCESS);
+  EXPECT_EQ(scope, -1);
 }
 
 TEST(TaosSetSlowLogScopeTest, MixedScopesInput) {
-  char pScope[] = "query|insert|others|none";
+  char    pScopeStr[] = "query|insert|others|none";
-  int32_t result = taosSetSlowLogScope(pScope);
+  int32_t scope = 0;
-  EXPECT_EQ(result, (SLOW_LOG_TYPE_QUERY | SLOW_LOG_TYPE_INSERT | SLOW_LOG_TYPE_OTHERS));
+  int32_t result = taosSetSlowLogScope(pScopeStr, &scope);
+  EXPECT_EQ(result, TSDB_CODE_SUCCESS);
+  EXPECT_EQ(scope, (SLOW_LOG_TYPE_QUERY | SLOW_LOG_TYPE_INSERT | SLOW_LOG_TYPE_OTHERS));
 }
 
 TEST(TaosSetSlowLogScopeTest, MixedScopesInputWithSpaces) {
-  char pScope[] = "query | insert | others ";
+  char    pScopeStr[] = "query | insert | others ";
-  int32_t result = taosSetSlowLogScope(pScope);
+  int32_t scope = 0;
-  EXPECT_EQ(result, (SLOW_LOG_TYPE_QUERY | SLOW_LOG_TYPE_INSERT | SLOW_LOG_TYPE_OTHERS));
+  int32_t result = taosSetSlowLogScope(pScopeStr, &scope);
+  EXPECT_EQ(result, TSDB_CODE_SUCCESS);
+  EXPECT_EQ(scope, (SLOW_LOG_TYPE_QUERY | SLOW_LOG_TYPE_INSERT | SLOW_LOG_TYPE_OTHERS));
 }
 
 #pragma GCC diagnostic pop

source/dnode/mgmt/exe/dmMain.c

@@ -74,7 +74,7 @@ static struct {
   char         encryptKey[ENCRYPT_KEY_LEN + 1];
 } global = {0};
 
-static void dmSetDebugFlag(int32_t signum, void *sigInfo, void *context) { taosSetGlobalDebugFlag(143); }
+static void dmSetDebugFlag(int32_t signum, void *sigInfo, void *context) { (void)taosSetGlobalDebugFlag(143); }
 static void dmSetAssert(int32_t signum, void *sigInfo, void *context) { tsAssert = 1; }
 
 static void dmStopDnode(int signum, void *sigInfo, void *context) {

source/dnode/mgmt/node_mgmt/src/dmEnv.c

@@ -109,13 +109,6 @@ static int32_t dmCheckDiskSpace() {
   return code;
 }
 
-int32_t tfsOpenWrapper(SDiskCfg *pCfg, int32_t ndisk, STfs **tfs) {
-  *tfs = tfsOpen(pCfg, ndisk);
-  if (*tfs == NULL) {
-    return terrno;
-  }
-  return 0;
-}
 int32_t dmDiskInit() {
   SDnode  *pDnode = dmInstance();
   SDiskCfg dCfg = {.level = 0, .primary = 1, .disable = 0};
@@ -127,10 +120,10 @@ int32_t dmDiskInit() {
     numOfDisks = 1;
   }
 
-  int32_t code = tfsOpenWrapper(pDisks, numOfDisks, &pDnode->pTfs);
+  int32_t code = tfsOpen(pDisks, numOfDisks, &pDnode->pTfs);
   if (code != 0) {
     dError("failed to init tfs since %s", tstrerror(code));
-    return code;
+    TAOS_RETURN(code);
   }
   return 0;
 }

source/dnode/mgmt/node_mgmt/src/dmMgmt.c

@@ -145,7 +145,8 @@ int32_t dmInitVars(SDnode *pDnode) {
   pData->rebootTime = taosGetTimestampMs();
   pData->dropped = 0;
   pData->stopped = 0;
-  char *machineId = tGetMachineId();
+  char *machineId = NULL;
+  code = tGetMachineId(&machineId);
   if (machineId) {
     tstrncpy(pData->machineId, machineId, TSDB_MACHINE_ID_LEN + 1);
     taosMemoryFreeClear(machineId);
@@ -181,7 +182,7 @@ int32_t dmInitVars(SDnode *pDnode) {
       code = 0;
       strncpy(tsEncryptKey, tsAuthCode, 16);
 
-      if(code != 0) {
+      if (code != 0) {
         if(code == -1){
           terrno = TSDB_CODE_DNODE_NO_ENCRYPT_KEY;
           dError("machine code changed, can't get crypt key");

source/dnode/mgmt/node_util/src/dmFile.c

@@ -380,6 +380,7 @@ _OVER:
 int32_t dmUpdateEncryptKey(char *key, bool toLogFile) {
 #ifdef TD_ENTERPRISE
   int32_t code = -1;
+  int32_t lino = 0;
   char   *machineId = NULL;
   char   *encryptCode = NULL;
 
@@ -428,14 +429,9 @@ int32_t dmUpdateEncryptKey(char *key, bool toLogFile) {
     }
   }
 
-  if (!(machineId = tGetMachineId())) {
+  TAOS_CHECK_GOTO(tGetMachineId(&machineId), &lino, _OVER);
-    code = TSDB_CODE_OUT_OF_MEMORY;
-    goto _OVER;
-  }
 
-  if ((code = generateEncryptCode(key, machineId, &encryptCode)) != 0) {
+  TAOS_CHECK_GOTO(generateEncryptCode(key, machineId, &encryptCode), &lino, _OVER);
-    goto _OVER;
-  }
 
   if ((code = dmWriteEncryptCodeFile(encryptFile, realEncryptFile, encryptCode, toLogFile)) != 0) {
     goto _OVER;
@@ -452,9 +448,9 @@ _OVER:
   taosMemoryFree(encryptCode);
   taosMemoryFree(machineId);
   if (code != 0) {
-    encryptError("failed to update encrypt key since %s", tstrerror(code));
+    encryptError("failed to update encrypt key at line %d since %s", lino, tstrerror(code));
   }
-  return code;
+  TAOS_RETURN(code);
 #else
   return 0;
 #endif
@@ -539,8 +535,7 @@ int32_t dmGetEncryptKey() {
     goto _OVER;
   }
 
-  if (!(machineId = tGetMachineId())) {
+  if ((code = tGetMachineId(&machineId)) != 0) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
     goto _OVER;
   }
 
@@ -574,7 +569,7 @@ _OVER:
   if (code != 0) {
     dError("failed to get encrypt key since %s", tstrerror(code));
   }
-  return code;
+  TAOS_RETURN(code);
 #else
   return 0;
 #endif

source/dnode/mnode/impl/inc/mndDnode.h

@@ -30,7 +30,7 @@ SEpSet     mndGetDnodeEpset(SDnodeObj *pDnode);
 SEpSet     mndGetDnodeEpsetById(SMnode *pMnode, int32_t dnodeId);
 int32_t    mndGetDnodeSize(SMnode *pMnode);
 bool       mndIsDnodeOnline(SDnodeObj *pDnode, int64_t curMs);
-void       mndGetDnodeData(SMnode *pMnode, SArray *pDnodeInfo);
+int32_t    mndGetDnodeData(SMnode *pMnode, SArray *pDnodeInfo);
 
 #ifdef __cplusplus
 }

source/dnode/mnode/impl/inc/mndShow.h

@@ -23,11 +23,12 @@
 extern "C" {
 #endif
 
-#define COL_DATA_SET_VAL_RET(pData, isNull, pObj)                              \
+#define COL_DATA_SET_VAL_GOTO(pData, isNull, pObj, LABEL)                      \
   do {                                                                         \
     if ((code = colDataSetVal(pColInfo, numOfRows, (pData), (isNull))) != 0) { \
       if (pObj) sdbRelease(pSdb, (pObj));                                      \
-      return code;                                                             \
+      lino = __LINE__;                                                         \
+      goto LABEL;                                                              \
     }                                                                          \
   } while (0)
 

source/dnode/mnode/impl/inc/mndUser.h

@@ -27,29 +27,29 @@ enum {
   IP_WHITE_ADD,
   IP_WHITE_DROP,
 };
-int32_t   mndInitUser(SMnode *pMnode);
+int32_t mndInitUser(SMnode *pMnode);
-void      mndCleanupUser(SMnode *pMnode);
+void    mndCleanupUser(SMnode *pMnode);
-SUserObj *mndAcquireUser(SMnode *pMnode, const char *userName);
+int32_t mndAcquireUser(SMnode *pMnode, const char *userName, SUserObj **ppUser);
-void      mndReleaseUser(SMnode *pMnode, SUserObj *pUser);
+void    mndReleaseUser(SMnode *pMnode, SUserObj *pUser);
 
 // for trans test
-SSdbRaw  *mndUserActionEncode(SUserObj *pUser);
+SSdbRaw *mndUserActionEncode(SUserObj *pUser);
-SHashObj *mndDupDbHash(SHashObj *pOld);
+int32_t  mndDupDbHash(SHashObj *pOld, SHashObj **ppNew);
-SHashObj *mndDupTableHash(SHashObj *pOld);
+int32_t  mndDupTableHash(SHashObj *pOld, SHashObj **ppNew);
-SHashObj *mndDupTopicHash(SHashObj *pOld);
+int32_t  mndDupTopicHash(SHashObj *pOld, SHashObj **ppNew);
-int32_t   mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_t numOfUses, void **ppRsp,
+int32_t  mndValidateUserAuthInfo(SMnode *pMnode, SUserAuthVersion *pUsers, int32_t numOfUses, void **ppRsp,
-                                  int32_t *pRspLen, int64_t ipWhiteListVer);
+                                 int32_t *pRspLen, int64_t ipWhiteListVer);
-int32_t   mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db);
+int32_t  mndUserRemoveDb(SMnode *pMnode, STrans *pTrans, char *db);
-int32_t   mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb);
+int32_t  mndUserRemoveStb(SMnode *pMnode, STrans *pTrans, char *stb);
-int32_t   mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view);
+int32_t  mndUserRemoveView(SMnode *pMnode, STrans *pTrans, char *view);
-int32_t   mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic);
+int32_t  mndUserRemoveTopic(SMnode *pMnode, STrans *pTrans, char *topic);
 
 int32_t mndUserDupObj(SUserObj *pUser, SUserObj *pNew);
 void    mndUserFreeObj(SUserObj *pUser);
 
 int64_t mndGetIpWhiteVer(SMnode *pMnode);
 
-void mndUpdateIpWhiteForAllUser(SMnode *pMnode, char *user, char *fqdn, int8_t type, int8_t lock);
+int32_t mndUpdateIpWhiteForAllUser(SMnode *pMnode, char *user, char *fqdn, int8_t type, int8_t lock);
 
 int32_t mndRefreshUserIpWhiteList(SMnode *pMnode);
 

source/dnode/mnode/impl/src/mndAcct.c

@@ -113,6 +113,8 @@ static int32_t mndCreateDefaultAcct(SMnode *pMnode) {
 }
 
 static SSdbRaw *mndAcctActionEncode(SAcctObj *pAcct) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   SSdbRaw *pRaw = sdbAllocRaw(SDB_ACCT, ACCT_VER_NUMBER, sizeof(SAcctObj) + ACCT_RESERVE_SIZE);
@@ -153,6 +155,8 @@ _OVER:
 }
 
 static SSdbRow *mndAcctActionDecode(SSdbRaw *pRaw) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
   SAcctObj *pAcct = NULL;
   SSdbRow  *pRow = NULL;

source/dnode/mnode/impl/src/mndArbGroup.c

@@ -104,7 +104,7 @@ void mndReleaseArbGroup(SMnode *pMnode, SArbGroup *pGroup) {
 
 void mndArbGroupInitFromVgObj(SVgObj *pVgObj, SArbGroup *outGroup) {
   ASSERT(pVgObj->replica == 2);
-  memset(outGroup, 0, sizeof(SArbGroup));
+  (void)memset(outGroup, 0, sizeof(SArbGroup));
   outGroup->dbUid = pVgObj->dbUid;
   outGroup->vgId = pVgObj->vgId;
   for (int i = 0; i < TSDB_ARB_GROUP_MEMBER_NUM; i++) {
@@ -114,6 +114,8 @@ void mndArbGroupInitFromVgObj(SVgObj *pVgObj, SArbGroup *outGroup) {
 }
 
 SSdbRaw *mndArbGroupActionEncode(SArbGroup *pGroup) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   int32_t  size = sizeof(SArbGroup) + ARBGROUP_RESERVE_SIZE;
@@ -152,6 +154,8 @@ _OVER:
 }
 
 SSdbRow *mndArbGroupActionDecode(SSdbRaw *pRaw) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
   SSdbRow   *pRow = NULL;
   SArbGroup *pGroup = NULL;
@@ -219,7 +223,7 @@ static int32_t mndArbGroupActionInsert(SSdb *pSdb, SArbGroup *pGroup) {
 static int32_t mndArbGroupActionDelete(SSdb *pSdb, SArbGroup *pGroup) {
   mTrace("arbgroup:%d, perform delete action, row:%p", pGroup->vgId, pGroup);
   if (pGroup->mutexInited) {
-    taosThreadMutexDestroy(&pGroup->mutex);
+    (void)taosThreadMutexDestroy(&pGroup->mutex);
     pGroup->mutexInited = false;
   }
   return 0;
@@ -227,7 +231,7 @@ static int32_t mndArbGroupActionDelete(SSdb *pSdb, SArbGroup *pGroup) {
 
 static int32_t mndArbGroupActionUpdate(SSdb *pSdb, SArbGroup *pOld, SArbGroup *pNew) {
   mTrace("arbgroup:%d, perform update action, old row:%p new row:%p", pOld->vgId, pOld, pNew);
-  taosThreadMutexLock(&pOld->mutex);
+  (void)taosThreadMutexLock(&pOld->mutex);
 
   if (pOld->version != pNew->version) {
     mInfo("arbgroup:%d, skip to perform update action, old row:%p new row:%p, old version:%" PRId64
@@ -237,18 +241,18 @@ static int32_t mndArbGroupActionUpdate(SSdb *pSdb, SArbGroup *pOld, SArbGroup *p
   }
 
   for (int i = 0; i < TSDB_ARB_GROUP_MEMBER_NUM; i++) {
-    memcpy(pOld->members[i].state.token, pNew->members[i].state.token, TSDB_ARB_TOKEN_SIZE);
+    (void)memcpy(pOld->members[i].state.token, pNew->members[i].state.token, TSDB_ARB_TOKEN_SIZE);
   }
   pOld->isSync = pNew->isSync;
   pOld->assignedLeader.dnodeId = pNew->assignedLeader.dnodeId;
-  memcpy(pOld->assignedLeader.token, pNew->assignedLeader.token, TSDB_ARB_TOKEN_SIZE);
+  (void)memcpy(pOld->assignedLeader.token, pNew->assignedLeader.token, TSDB_ARB_TOKEN_SIZE);
   pOld->assignedLeader.acked = pNew->assignedLeader.acked;
   pOld->version++;
 
 _OVER:
-  taosThreadMutexUnlock(&pOld->mutex);
+  (void)taosThreadMutexUnlock(&pOld->mutex);
 
-  taosHashRemove(arbUpdateHash, &pOld->vgId, sizeof(int32_t));
+  (void)taosHashRemove(arbUpdateHash, &pOld->vgId, sizeof(int32_t));
   return 0;
 }
 
@@ -385,7 +389,7 @@ static int32_t mndProcessArbHbTimer(SRpcMsg *pReq) {
     pIter = sdbFetch(pSdb, SDB_ARBGROUP, pIter, (void **)&pArbGroup);
     if (pIter == NULL) break;
 
-    taosThreadMutexLock(&pArbGroup->mutex);
+    (void)taosThreadMutexLock(&pArbGroup->mutex);
 
     for (int i = 0; i < TSDB_ARB_GROUP_MEMBER_NUM; i++) {
       SArbGroupMember *pMember = &pArbGroup->members[i];
@@ -396,13 +400,13 @@ static int32_t mndProcessArbHbTimer(SRpcMsg *pReq) {
         hbMembers = *(SArray **)pObj;
       } else {
         hbMembers = taosArrayInit(16, sizeof(SVArbHbReqMember));
-        taosHashPut(pDnodeHash, &dnodeId, sizeof(int32_t), &hbMembers, POINTER_BYTES);
+        (void)taosHashPut(pDnodeHash, &dnodeId, sizeof(int32_t), &hbMembers, POINTER_BYTES);
       }
       SVArbHbReqMember reqMember = {.vgId = pArbGroup->vgId, .hbSeq = pMember->state.nextHbSeq++};
-      taosArrayPush(hbMembers, &reqMember);
+      (void)taosArrayPush(hbMembers, &reqMember);
     }
 
-    taosThreadMutexUnlock(&pArbGroup->mutex);
+    (void)taosThreadMutexUnlock(&pArbGroup->mutex);
     sdbRelease(pSdb, pArbGroup);
   }
 
@@ -598,9 +602,9 @@ static int32_t mndProcessArbCheckSyncTimer(SRpcMsg *pReq) {
     pIter = sdbFetch(pSdb, SDB_ARBGROUP, pIter, (void **)&pArbGroup);
     if (pIter == NULL) break;
 
-    taosThreadMutexLock(&pArbGroup->mutex);
+    (void)taosThreadMutexLock(&pArbGroup->mutex);
     mndArbGroupDupObj(pArbGroup, &arbGroupDup);
-    taosThreadMutexUnlock(&pArbGroup->mutex);
+    (void)taosThreadMutexUnlock(&pArbGroup->mutex);
 
     int32_t vgId = arbGroupDup.vgId;
 
@@ -664,7 +668,10 @@ static int32_t mndProcessArbCheckSyncTimer(SRpcMsg *pReq) {
     SArbGroup newGroup = {0};
     mndArbGroupDupObj(&arbGroupDup, &newGroup);
     mndArbGroupSetAssignedLeader(&newGroup, candidateIndex);
-    taosArrayPush(pUpdateArray, &newGroup);
+    if (taosArrayPush(pUpdateArray, &newGroup) == NULL) {
+      taosArrayDestroy(pUpdateArray);
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
 
     sdbRelease(pSdb, pArbGroup);
   }
@@ -718,7 +725,7 @@ static int32_t mndPullupArbUpdateGroup(SMnode *pMnode, SArbGroup *pNewGroup) {
   mndInitArbUpdateGroup(pNewGroup, &newGroup);
 
   SArray *pArray = taosArrayInit(1, sizeof(SMArbUpdateGroup));
-  taosArrayPush(pArray, &newGroup);
+  if (taosArrayPush(pArray, &newGroup) == NULL) goto _OVER;
 
   int32_t contLen = 0;
   void   *pHead = mndBuildArbUpdateGroupBatchReq(&contLen, pArray);
@@ -732,7 +739,7 @@ static int32_t mndPullupArbUpdateGroup(SMnode *pMnode, SArbGroup *pNewGroup) {
   ret = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg);
   if (ret != 0) goto _OVER;
 
-  taosHashPut(arbUpdateHash, &pNewGroup->vgId, sizeof(pNewGroup->vgId), NULL, 0);
+  if ((ret = taosHashPut(arbUpdateHash, &pNewGroup->vgId, sizeof(pNewGroup->vgId), NULL, 0)) != 0) goto _OVER;
 
 _OVER:
   taosArrayDestroy(pArray);
@@ -754,8 +761,8 @@ static int32_t mndPullupArbUpdateGroupBatch(SMnode *pMnode, SArray *newGroupArra
     SMArbUpdateGroup newGroup = {0};
     mndInitArbUpdateGroup(pNewGroup, &newGroup);
 
-    taosArrayPush(pArray, &newGroup);
+    if (taosArrayPush(pArray, &newGroup) == NULL) goto _OVER;
-    taosHashPut(arbUpdateHash, &pNewGroup->vgId, sizeof(pNewGroup->vgId), NULL, 0);
+    if (taosHashPut(arbUpdateHash, &pNewGroup->vgId, sizeof(pNewGroup->vgId), NULL, 0) != 0) goto _OVER;
   }
 
   if (taosArrayGetSize(pArray) == 0) {
@@ -780,7 +787,7 @@ _OVER:
   if (ret != 0) {
     for (size_t i = 0; i < sz; i++) {
       SArbGroup *pNewGroup = taosArrayGet(newGroupArray, i);
-      taosHashRemove(arbUpdateHash, &pNewGroup->vgId, sizeof(pNewGroup->vgId));
+      (void)taosHashRemove(arbUpdateHash, &pNewGroup->vgId, sizeof(pNewGroup->vgId));
     }
   }
 
@@ -812,19 +819,19 @@ static int32_t mndProcessArbUpdateGroupBatchReq(SRpcMsg *pReq) {
     newGroup.dbUid = pUpdateGroup->dbUid;
     for (int i = 0; i < TSDB_ARB_GROUP_MEMBER_NUM; i++) {
       newGroup.members[i].info.dnodeId = pUpdateGroup->members[i].dnodeId;
-      memcpy(newGroup.members[i].state.token, pUpdateGroup->members[i].token, TSDB_ARB_TOKEN_SIZE);
+      (void)memcpy(newGroup.members[i].state.token, pUpdateGroup->members[i].token, TSDB_ARB_TOKEN_SIZE);
     }
 
     newGroup.isSync = pUpdateGroup->isSync;
     newGroup.assignedLeader.dnodeId = pUpdateGroup->assignedLeader.dnodeId;
-    memcpy(newGroup.assignedLeader.token, pUpdateGroup->assignedLeader.token, TSDB_ARB_TOKEN_SIZE);
+    (void)memcpy(newGroup.assignedLeader.token, pUpdateGroup->assignedLeader.token, TSDB_ARB_TOKEN_SIZE);
     newGroup.assignedLeader.acked = pUpdateGroup->assignedLeader.acked;
     newGroup.version = pUpdateGroup->version;
 
     SArbGroup *pOldGroup = sdbAcquire(pMnode->pSdb, SDB_ARBGROUP, &newGroup.vgId);
     if (!pOldGroup) {
       mInfo("vgId:%d, arb skip to update arbgroup, since no obj found", newGroup.vgId);
-      taosHashRemove(arbUpdateHash, &newGroup.vgId, sizeof(int32_t));
+      (void)taosHashRemove(arbUpdateHash, &newGroup.vgId, sizeof(int32_t));
       continue;
     }
 
@@ -854,7 +861,7 @@ _OVER:
     // failed to update arbgroup
     for (size_t i = 0; i < sz; i++) {
       SMArbUpdateGroup *pUpdateGroup = taosArrayGet(req.updateArray, i);
-      taosHashRemove(arbUpdateHash, &pUpdateGroup->vgId, sizeof(int32_t));
+      (void)taosHashRemove(arbUpdateHash, &pUpdateGroup->vgId, sizeof(int32_t));
     }
   }
 
@@ -864,20 +871,20 @@ _OVER:
 }
 
 static void mndArbGroupDupObj(SArbGroup *pGroup, SArbGroup *pNew) {
-  memcpy(pNew, pGroup, offsetof(SArbGroup, mutexInited));
+  (void)memcpy(pNew, pGroup, offsetof(SArbGroup, mutexInited));
 }
 
 static void mndArbGroupSetAssignedLeader(SArbGroup *pGroup, int32_t index) {
   SArbGroupMember *pMember = &pGroup->members[index];
 
   pGroup->assignedLeader.dnodeId = pMember->info.dnodeId;
-  strncpy(pGroup->assignedLeader.token, pMember->state.token, TSDB_ARB_TOKEN_SIZE);
+  (void)strncpy(pGroup->assignedLeader.token, pMember->state.token, TSDB_ARB_TOKEN_SIZE);
   pGroup->assignedLeader.acked = false;
 }
 
 static void mndArbGroupResetAssignedLeader(SArbGroup *pGroup) {
   pGroup->assignedLeader.dnodeId = 0;
-  memset(pGroup->assignedLeader.token, 0, TSDB_ARB_TOKEN_SIZE);
+  (void)memset(pGroup->assignedLeader.token, 0, TSDB_ARB_TOKEN_SIZE);
   pGroup->assignedLeader.acked = false;
 }
 
@@ -919,7 +926,7 @@ bool mndUpdateArbGroupByHeartBeat(SArbGroup *pGroup, SVArbHbRspMember *pRspMembe
   bool             updateToken = false;
   SArbGroupMember *pMember = NULL;
 
-  taosThreadMutexLock(&pGroup->mutex);
+  (void)taosThreadMutexLock(&pGroup->mutex);
 
   int index = 0;
   for (; index < TSDB_ARB_GROUP_MEMBER_NUM; index++) {
@@ -953,7 +960,7 @@ bool mndUpdateArbGroupByHeartBeat(SArbGroup *pGroup, SVArbHbRspMember *pRspMembe
 
   // update token
   mndArbGroupDupObj(pGroup, pNewGroup);
-  memcpy(pNewGroup->members[index].state.token, pRspMember->memberToken, TSDB_ARB_TOKEN_SIZE);
+  (void)memcpy(pNewGroup->members[index].state.token, pRspMember->memberToken, TSDB_ARB_TOKEN_SIZE);
   pNewGroup->isSync = false;
 
   bool resetAssigned = false;
@@ -966,7 +973,7 @@ bool mndUpdateArbGroupByHeartBeat(SArbGroup *pGroup, SVArbHbRspMember *pRspMembe
   mInfo("dnodeId:%d vgId:%d, arb token updating, resetAssigned:%d", dnodeId, pRspMember->vgId, resetAssigned);
 
 _OVER:
-  taosThreadMutexUnlock(&pGroup->mutex);
+  (void)taosThreadMutexUnlock(&pGroup->mutex);
   return updateToken;
 }
 
@@ -987,7 +994,7 @@ static int32_t mndUpdateArbHeartBeat(SMnode *pMnode, int32_t dnodeId, SArray *me
 
     bool updateToken = mndUpdateArbGroupByHeartBeat(pGroup, pRspMember, nowMs, dnodeId, &newGroup);
     if (updateToken) {
-      taosArrayPush(pUpdateArray, &newGroup);
+      (void)taosArrayPush(pUpdateArray, &newGroup);
     }
 
     sdbRelease(pMnode->pSdb, pGroup);
@@ -1003,7 +1010,7 @@ bool mndUpdateArbGroupByCheckSync(SArbGroup *pGroup, int32_t vgId, char *member0
                                   bool newIsSync, SArbGroup *pNewGroup) {
   bool updateIsSync = false;
 
-  taosThreadMutexLock(&pGroup->mutex);
+  (void)taosThreadMutexLock(&pGroup->mutex);
 
   if (pGroup->assignedLeader.dnodeId != 0) {
     terrno = TSDB_CODE_SUCCESS;
@@ -1029,7 +1036,7 @@ bool mndUpdateArbGroupByCheckSync(SArbGroup *pGroup, int32_t vgId, char *member0
   }
 
 _OVER:
-  taosThreadMutexUnlock(&pGroup->mutex);
+  (void)taosThreadMutexUnlock(&pGroup->mutex);
   return updateIsSync;
 }
 
@@ -1144,7 +1151,7 @@ bool mndUpdateArbGroupBySetAssignedLeader(SArbGroup *pGroup, int32_t vgId, char
                                           SArbGroup *pNewGroup) {
   bool updateAssigned = false;
 
-  taosThreadMutexLock(&pGroup->mutex);
+  (void)taosThreadMutexLock(&pGroup->mutex);
   if (mndArbCheckToken(pGroup->assignedLeader.token, memberToken) != 0) {
     mInfo("skip update arb assigned for vgId:%d, member token mismatch, local:[%s] msg:[%s]", vgId,
           pGroup->assignedLeader.token, memberToken);
@@ -1167,7 +1174,7 @@ bool mndUpdateArbGroupBySetAssignedLeader(SArbGroup *pGroup, int32_t vgId, char
   }
 
 _OVER:
-  taosThreadMutexUnlock(&pGroup->mutex);
+  (void)taosThreadMutexUnlock(&pGroup->mutex);
   return updateAssigned;
 }
 
@@ -1237,43 +1244,43 @@ static int32_t mndRetrieveArbGroups(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock
     pShow->pIter = sdbFetch(pSdb, SDB_ARBGROUP, pShow->pIter, (void **)&pGroup);
     if (pShow->pIter == NULL) break;
 
-    taosThreadMutexLock(&pGroup->mutex);
+    (void)taosThreadMutexLock(&pGroup->mutex);
 
     cols = 0;
     SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     SVgObj          *pVgObj = sdbAcquire(pSdb, SDB_VGROUP, &pGroup->vgId);
     if (!pVgObj) {
-      taosThreadMutexUnlock(&pGroup->mutex);
+      (void)taosThreadMutexUnlock(&pGroup->mutex);
       sdbRelease(pSdb, pGroup);
       continue;
     }
     char dbname[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0};
     STR_WITH_MAXSIZE_TO_VARSTR(dbname, mndGetDbStr(pVgObj->dbName), TSDB_ARB_TOKEN_SIZE + VARSTR_HEADER_SIZE);
-    colDataSetVal(pColInfo, numOfRows, (const char *)dbname, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)dbname, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pGroup->vgId, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pGroup->vgId, false);
 
     for (int i = 0; i < TSDB_ARB_GROUP_MEMBER_NUM; i++) {
       SArbGroupMember *pMember = &pGroup->members[i];
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)&pMember->info.dnodeId, false);
+      (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pMember->info.dnodeId, false);
     }
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pGroup->isSync, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pGroup->isSync, false);
 
     if (pGroup->assignedLeader.dnodeId != 0) {
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)&pGroup->assignedLeader.dnodeId, false);
+      (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pGroup->assignedLeader.dnodeId, false);
 
       char token[TSDB_ARB_TOKEN_SIZE + VARSTR_HEADER_SIZE] = {0};
       STR_WITH_MAXSIZE_TO_VARSTR(token, pGroup->assignedLeader.token, TSDB_ARB_TOKEN_SIZE + VARSTR_HEADER_SIZE);
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)token, false);
+      (void)colDataSetVal(pColInfo, numOfRows, (const char *)token, false);
 
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)&pGroup->assignedLeader.acked, false);
+      (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pGroup->assignedLeader.acked, false);
     } else {
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
       colDataSetNULL(pColInfo, numOfRows);
@@ -1285,7 +1292,7 @@ static int32_t mndRetrieveArbGroups(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock
       colDataSetNULL(pColInfo, numOfRows);
     }
 
-    taosThreadMutexUnlock(&pGroup->mutex);
+    (void)taosThreadMutexUnlock(&pGroup->mutex);
 
     numOfRows++;
     sdbRelease(pSdb, pVgObj);

source/dnode/mnode/impl/src/mndCluster.c

@@ -144,6 +144,8 @@ int64_t mndGetClusterUpTime(SMnode *pMnode) {
 }
 
 static SSdbRaw *mndClusterActionEncode(SClusterObj *pCluster) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   SSdbRaw *pRaw = sdbAllocRaw(SDB_CLUSTER, CLUSTER_VER_NUMBE, sizeof(SClusterObj) + CLUSTER_RESERVE_SIZE);
@@ -172,6 +174,8 @@ _OVER:
 }
 
 static SSdbRow *mndClusterActionDecode(SSdbRaw *pRaw) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
   SClusterObj *pCluster = NULL;
   SSdbRow     *pRow = NULL;
@@ -239,7 +243,7 @@ static int32_t mndCreateDefaultCluster(SMnode *pMnode) {
 
   int32_t code = taosGetSystemUUID(clusterObj.name, TSDB_CLUSTER_ID_LEN);
   if (code != 0) {
-    strcpy(clusterObj.name, "tdengine3.0");
+    (void)strcpy(clusterObj.name, "tdengine3.0");
     mError("failed to get name from system, set to default val %s", clusterObj.name);
   }
 
@@ -287,6 +291,7 @@ static int32_t mndRetrieveClusters(SRpcMsg *pMsg, SShowObj *pShow, SSDataBlock *
   SMnode      *pMnode = pMsg->info.node;
   SSdb        *pSdb = pMnode->pSdb;
   int32_t      code = 0;
+  int32_t      lino = 0;
   int32_t      numOfRows = 0;
   int32_t      cols = 0;
   SClusterObj *pCluster = NULL;
@@ -297,31 +302,32 @@ static int32_t mndRetrieveClusters(SRpcMsg *pMsg, SShowObj *pShow, SSDataBlock *
 
     cols = 0;
     SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    COL_DATA_SET_VAL_RET((const char *)&pCluster->id, false, pCluster);
+    COL_DATA_SET_VAL_GOTO((const char *)&pCluster->id, false, pCluster, _OVER);
 
     char buf[tListLen(pCluster->name) + VARSTR_HEADER_SIZE] = {0};
     STR_WITH_MAXSIZE_TO_VARSTR(buf, pCluster->name, pShow->pMeta->pSchemas[cols].bytes);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    COL_DATA_SET_VAL_RET(buf, false, pCluster);
+    COL_DATA_SET_VAL_GOTO(buf, false, pCluster, _OVER);
 
     int32_t upTime = mndGetClusterUpTimeImp(pCluster);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    COL_DATA_SET_VAL_RET((const char *)&upTime, false, pCluster);
+    COL_DATA_SET_VAL_GOTO((const char *)&upTime, false, pCluster, _OVER);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    COL_DATA_SET_VAL_RET((const char *)&pCluster->createdTime, false, pCluster);
+    COL_DATA_SET_VAL_GOTO((const char *)&pCluster->createdTime, false, pCluster, _OVER);
+
 
     char ver[12] = {0};
     STR_WITH_MAXSIZE_TO_VARSTR(ver, tsVersionName, pShow->pMeta->pSchemas[cols].bytes);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    COL_DATA_SET_VAL_RET((const char *)ver, false, pCluster);
+    COL_DATA_SET_VAL_GOTO((const char *)ver, false, pCluster, _OVER);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     if (tsExpireTime <= 0) {
       colDataSetNULL(pColInfo, numOfRows);
     } else {
-      COL_DATA_SET_VAL_RET((const char *)&tsExpireTime, false, pCluster);
+      COL_DATA_SET_VAL_GOTO((const char *)&tsExpireTime, false, pCluster, _OVER);
     }
 
     sdbRelease(pSdb, pCluster);
@@ -329,6 +335,12 @@ static int32_t mndRetrieveClusters(SRpcMsg *pMsg, SShowObj *pShow, SSDataBlock *
   }
 
   pShow->numOfRows += numOfRows;
+
+_OVER:
+  if (code != 0) {
+    mError("failed to retrieve cluster info at line %d since %s", lino, tstrerror(code));
+    TAOS_RETURN(code);
+  }
   return numOfRows;
 }
 
@@ -343,7 +355,7 @@ static int32_t mndProcessUptimeTimer(SRpcMsg *pReq) {
   void        *pIter = NULL;
   SClusterObj *pCluster = mndAcquireCluster(pMnode, &pIter);
   if (pCluster != NULL) {
-    memcpy(&clusterObj, pCluster, sizeof(SClusterObj));
+    (void)memcpy(&clusterObj, pCluster, sizeof(SClusterObj));
     clusterObj.upTime += tsUptimeInterval;
     mndReleaseCluster(pMnode, pCluster, pIter);
   }
@@ -408,7 +420,7 @@ int32_t mndProcessConfigClusterReq(SRpcMsg *pReq) {
     if (pCluster) mndReleaseCluster(pMnode, pCluster, pIter);
     goto _exit;
   }
-  memcpy(&clusterObj, pCluster, sizeof(SClusterObj));
+  (void)memcpy(&clusterObj, pCluster, sizeof(SClusterObj));
   mndReleaseCluster(pMnode, pCluster, pIter);
 
   if (strncmp(cfgReq.config, GRANT_ACTIVE_CODE, TSDB_DNODE_CONFIG_LEN) == 0) {

source/dnode/mnode/impl/src/mndCompact.c

@@ -88,6 +88,8 @@ int32_t tDeserializeSCompactObj(void *buf, int32_t bufLen, SCompactObj *pObj) {
 }
 
 SSdbRaw *mndCompactActionEncode(SCompactObj *pCompact) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_SUCCESS;
 
   void    *buf = NULL;
@@ -136,6 +138,8 @@ OVER:
 }
 
 SSdbRow *mndCompactActionDecode(SSdbRaw *pRaw) {
+  int32_t      code = 0;
+  int32_t      lino = 0;
   SSdbRow     *pRow = NULL;
   SCompactObj *pCompact = NULL;
   void        *buf = NULL;
@@ -227,7 +231,7 @@ int32_t mndAddCompactToTran(SMnode *pMnode, STrans *pTrans, SCompactObj *pCompac
   int32_t code = 0;
   pCompact->compactId = tGenIdPI32();
 
-  strcpy(pCompact->dbname, pDb->name);
+  (void)strcpy(pCompact->dbname, pDb->name);
 
   pCompact->startTime = taosGetTimestampMs();
 
@@ -279,21 +283,21 @@ int32_t mndRetrieveCompact(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock,
     char tmpBuf[TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE] = {0};
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pCompact->compactId, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pCompact->compactId, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     if (pDb != NULL || !IS_SYS_DBNAME(pCompact->dbname)) {
       SName name = {0};
-      tNameFromString(&name, pCompact->dbname, T_NAME_ACCT | T_NAME_DB);
+      (void)tNameFromString(&name, pCompact->dbname, T_NAME_ACCT | T_NAME_DB);
-      tNameGetDbName(&name, varDataVal(tmpBuf));
+      (void)tNameGetDbName(&name, varDataVal(tmpBuf));
     } else {
-      strncpy(varDataVal(tmpBuf), pCompact->dbname, TSDB_SHOW_SQL_LEN);
+      (void)strncpy(varDataVal(tmpBuf), pCompact->dbname, TSDB_SHOW_SQL_LEN);
     }
     varDataSetLen(tmpBuf, strlen(varDataVal(tmpBuf)));
-    colDataSetVal(pColInfo, numOfRows, (const char *)tmpBuf, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)tmpBuf, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pCompact->startTime, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pCompact->startTime, false);
 
     numOfRows++;
     sdbRelease(pSdb, pCompact);
@@ -330,7 +334,7 @@ static void *mndBuildKillCompactReq(SMnode *pMnode, SVgObj *pVgroup, int32_t *pC
   pHead->contLen = htonl(contLen);
   pHead->vgId = htonl(pVgroup->vgId);
 
-  tSerializeSVKillCompactReq((char *)pReq + sizeof(SMsgHead), contLen, &req);
+  (void)tSerializeSVKillCompactReq((char *)pReq + sizeof(SMsgHead), contLen, &req);
   *pContLen = contLen;
   return pReq;
 }
@@ -474,7 +478,7 @@ int32_t mndProcessKillCompactReq(SRpcMsg *pReq) {
   code = TSDB_CODE_ACTION_IN_PROGRESS;
 
   char obj[TSDB_INT32_ID_LEN] = {0};
-  sprintf(obj, "%d", pCompact->compactId);
+  (void)sprintf(obj, "%d", pCompact->compactId);
 
   auditRecord(pReq, pMnode->clusterId, "killCompact", pCompact->dbname, obj, killCompactReq.sql, killCompactReq.sqlLen);
 
@@ -583,7 +587,7 @@ void mndCompactSendProgressReq(SMnode *pMnode, SCompactObj *pCompact) {
       pHead->contLen = htonl(contLen);
       pHead->vgId = htonl(pDetail->vgId);
 
-      tSerializeSQueryCompactProgressReq((char *)pHead + sizeof(SMsgHead), contLen - sizeof(SMsgHead), &req);
+      (void)tSerializeSQueryCompactProgressReq((char *)pHead + sizeof(SMsgHead), contLen - sizeof(SMsgHead), &req);
 
       SRpcMsg rpcMsg = {.msgType = TDMT_VND_QUERY_COMPACT_PROGRESS, .contLen = contLen};
 
@@ -598,7 +602,10 @@ void mndCompactSendProgressReq(SMnode *pMnode, SCompactObj *pCompact) {
 
       mDebug("compact:%d, send update progress msg to %s", pDetail->compactId, detail);
 
-      tmsgSendReq(&epSet, &rpcMsg);
+      if (tmsgSendReq(&epSet, &rpcMsg) < 0) {
+        sdbRelease(pMnode->pSdb, pDetail);
+        continue;
+      }
     }
 
     sdbRelease(pMnode->pSdb, pDetail);
@@ -802,7 +809,7 @@ void mndCompactPullup(SMnode *pMnode) {
     SCompactObj *pCompact = NULL;
     pIter = sdbFetch(pMnode->pSdb, SDB_COMPACT, pIter, (void **)&pCompact);
     if (pIter == NULL) break;
-    taosArrayPush(pArray, &pCompact->compactId);
+    (void)taosArrayPush(pArray, &pCompact->compactId);
     sdbRelease(pSdb, pCompact);
   }
 

source/dnode/mnode/impl/src/mndCompactDetail.c

@@ -68,22 +68,22 @@ int32_t mndRetrieveCompactDetail(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB
     char tmpBuf[TSDB_SHOW_SQL_LEN + VARSTR_HEADER_SIZE] = {0};
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->compactId, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->compactId, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->vgId, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->vgId, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->dnodeId, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->dnodeId, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->numberFileset, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->numberFileset, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->finished, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->finished, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->startTime, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pCompactDetail->startTime, false);
 
     numOfRows++;
     sdbRelease(pSdb, pCompactDetail);
@@ -144,6 +144,8 @@ int32_t tDeserializeSCompactDetailObj(void *buf, int32_t bufLen, SCompactDetailO
 }
 
 SSdbRaw *mndCompactDetailActionEncode(SCompactDetailObj *pCompact) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_SUCCESS;
 
   void *buf = NULL;
@@ -193,9 +195,11 @@ OVER:
 }
 
 SSdbRow *mndCompactDetailActionDecode(SSdbRaw *pRaw) {
-  SSdbRow       *pRow = NULL;
+  int32_t            code = 0;
-  SCompactDetailObj   *pCompact = NULL;
+  int32_t            lino = 0;
-  void          *buf = NULL;
+  SSdbRow           *pRow = NULL;
+  SCompactDetailObj *pCompact = NULL;
+  void              *buf = NULL;
   terrno = TSDB_CODE_SUCCESS;
 
   int8_t sver = 0;

source/dnode/mnode/impl/src/mndConsumer.c

@@ -590,6 +590,8 @@ END:
 }
 
 SSdbRaw *mndConsumerActionEncode(SMqConsumerObj *pConsumer) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   void   *buf = NULL;
@@ -628,6 +630,8 @@ CM_ENCODE_OVER:
 }
 
 SSdbRow *mndConsumerActionDecode(SSdbRaw *pRaw) {
+  int32_t         code = 0;
+  int32_t         lino = 0;
   SSdbRow        *pRow = NULL;
   SMqConsumerObj *pConsumer = NULL;
   void           *buf = NULL;
@@ -942,7 +946,7 @@ static int32_t mndRetrieveConsumer(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *
 
       char         buf[TSDB_OFFSET_LEN] = {0};
       STqOffsetVal pVal = {.type = pConsumer->resetOffsetCfg};
-      MND_TMQ_RETURN_CHECK(tFormatOffset(buf, TSDB_OFFSET_LEN, &pVal));
+      tFormatOffset(buf, TSDB_OFFSET_LEN, &pVal);
 
       char parasStr[64 + TSDB_OFFSET_LEN + VARSTR_HEADER_SIZE] = {0};
       (void)sprintf(varDataVal(parasStr), "tbname:%d,commit:%d,interval:%dms,reset:%s", pConsumer->withTbName,

source/dnode/mnode/impl/src/mndDb.c

@@ -88,6 +88,8 @@ int32_t mndInitDb(SMnode *pMnode) {
 void mndCleanupDb(SMnode *pMnode) {}
 
 SSdbRaw *mndDbActionEncode(SDbObj *pDb) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   int32_t  size = sizeof(SDbObj) + pDb->cfg.numOfRetensions * sizeof(SRetention) + DB_RESERVE_SIZE;
@@ -166,6 +168,8 @@ _OVER:
 }
 
 static SSdbRow *mndDbActionDecode(SSdbRaw *pRaw) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
   SSdbRow *pRow = NULL;
   SDbObj  *pDb = NULL;
@@ -731,17 +735,18 @@ static int32_t mndSetCreateDbUndoActions(SMnode *pMnode, STrans *pTrans, SDbObj
 }
 
 static int32_t mndCreateDb(SMnode *pMnode, SRpcMsg *pReq, SCreateDbReq *pCreate, SUserObj *pUser) {
-  int32_t code = -1;
+  int32_t  code = 0;
-  SDbObj dbObj = {0};
+  SUserObj newUserObj = {0};
-  memcpy(dbObj.name, pCreate->db, TSDB_DB_FNAME_LEN);
+  SDbObj   dbObj = {0};
-  memcpy(dbObj.acct, pUser->acct, TSDB_USER_LEN);
+  (void)memcpy(dbObj.name, pCreate->db, TSDB_DB_FNAME_LEN);
+  (void)memcpy(dbObj.acct, pUser->acct, TSDB_USER_LEN);
   dbObj.createdTime = taosGetTimestampMs();
   dbObj.updateTime = dbObj.createdTime;
   dbObj.uid = mndGenerateUid(dbObj.name, TSDB_DB_FNAME_LEN);
   dbObj.cfgVersion = 1;
   dbObj.vgVersion = 1;
   dbObj.tsmaVersion = 1;
-  memcpy(dbObj.createUser, pUser->user, TSDB_USER_LEN);
+  (void)memcpy(dbObj.createUser, pUser->user, TSDB_USER_LEN);
   dbObj.cfg = (SDbCfg){
       .numOfVgroups = pCreate->numOfVgroups,
       .numOfStables = pCreate->numOfStables,
@@ -812,11 +817,13 @@ static int32_t mndCreateDb(SMnode *pMnode, SRpcMsg *pReq, SCreateDbReq *pCreate,
   }
 
   // add database privileges for user
-  SUserObj newUserObj = {0}, *pNewUserDuped = NULL;
+  SUserObj *pNewUserDuped = NULL;
   if (!pUser->superUser) {
     TAOS_CHECK_GOTO(mndUserDupObj(pUser, &newUserObj), NULL, _OVER);
-    taosHashPut(newUserObj.readDbs, dbObj.name, strlen(dbObj.name) + 1, dbObj.name, TSDB_FILENAME_LEN);
+    TAOS_CHECK_GOTO(taosHashPut(newUserObj.readDbs, dbObj.name, strlen(dbObj.name) + 1, dbObj.name, TSDB_FILENAME_LEN),
-    taosHashPut(newUserObj.writeDbs, dbObj.name, strlen(dbObj.name) + 1, dbObj.name, TSDB_FILENAME_LEN);
+                    NULL, _OVER);
+    TAOS_CHECK_GOTO(taosHashPut(newUserObj.writeDbs, dbObj.name, strlen(dbObj.name) + 1, dbObj.name, TSDB_FILENAME_LEN),
+                    NULL, _OVER);
     pNewUserDuped = &newUserObj;
   }
 
@@ -841,8 +848,6 @@ static int32_t mndCreateDb(SMnode *pMnode, SRpcMsg *pReq, SCreateDbReq *pCreate,
   TAOS_CHECK_GOTO(mndSetCreateDbUndoActions(pMnode, pTrans, &dbObj, pVgroups), NULL, _OVER);
   TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
 
-  code = 0;
-
 _OVER:
   taosMemoryFree(pVgroups);
   mndUserFreeObj(&newUserObj);
@@ -852,17 +857,17 @@ _OVER:
 
 static void mndBuildAuditDetailInt32(char *detail, char *tmp, char *format, int32_t para) {
   if (para > 0) {
-    if (strlen(detail) > 0) strcat(detail, ", ");
+    if (strlen(detail) > 0) (void)strcat(detail, ", ");
-    sprintf(tmp, format, para);
+    (void)sprintf(tmp, format, para);
-    strcat(detail, tmp);
+    (void)strcat(detail, tmp);
   }
 }
 
 static void mndBuildAuditDetailInt64(char *detail, char *tmp, char *format, int64_t para) {
   if (para > 0) {
-    if (strlen(detail) > 0) strcat(detail, ", ");
+    if (strlen(detail) > 0) (void)strcat(detail, ", ");
-    sprintf(tmp, format, para);
+    (void)sprintf(tmp, format, para);
-    strcat(detail, tmp);
+    (void)strcat(detail, tmp);
   }
 }
 
@@ -958,18 +963,13 @@ static int32_t mndProcessCreateDbReq(SRpcMsg *pReq) {
 
   TAOS_CHECK_GOTO(mndCheckDbEncryptKey(pMnode, &createReq), &lino, _OVER);
 
-  pUser = mndAcquireUser(pMnode, pReq->info.conn.user);
+  TAOS_CHECK_GOTO(mndAcquireUser(pMnode, pReq->info.conn.user, &pUser), &lino, _OVER);
-  if (pUser == NULL) {
-    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
-    if (terrno != 0) code = terrno;
-    goto _OVER;
-  }
 
   code = mndCreateDb(pMnode, pReq, &createReq, pUser);
   if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;
 
   SName name = {0};
-  tNameFromString(&name, createReq.db, T_NAME_ACCT | T_NAME_DB);
+  (void)tNameFromString(&name, createReq.db, T_NAME_ACCT | T_NAME_DB);
 
   auditRecord(pReq, pMnode->clusterId, "createDB", name.dbname, "", createReq.sql, createReq.sqlLen);
 
@@ -1252,7 +1252,7 @@ static int32_t mndProcessAlterDbReq(SRpcMsg *pReq) {
     goto _OVER;
   }
 
-  memcpy(&dbObj, pDb, sizeof(SDbObj));
+  (void)memcpy(&dbObj, pDb, sizeof(SDbObj));
   if (dbObj.cfg.pRetensions != NULL) {
     dbObj.cfg.pRetensions = taosArrayDup(pDb->cfg.pRetensions, NULL);
     if (dbObj.cfg.pRetensions == NULL) goto _OVER;
@@ -1278,7 +1278,7 @@ static int32_t mndProcessAlterDbReq(SRpcMsg *pReq) {
   }
 
   SName name = {0};
-  tNameFromString(&name, alterReq.db, T_NAME_ACCT | T_NAME_DB);
+  (void)tNameFromString(&name, alterReq.db, T_NAME_ACCT | T_NAME_DB);
 
   auditRecord(pReq, pMnode->clusterId, "alterDB", name.dbname, "", alterReq.sql, alterReq.sqlLen);
 
@@ -1296,7 +1296,7 @@ _OVER:
 }
 
 static void mndDumpDbCfgInfo(SDbCfgRsp *cfgRsp, SDbObj *pDb) {
-  strcpy(cfgRsp->db, pDb->name);
+  (void)strcpy(cfgRsp->db, pDb->name);
   cfgRsp->dbId = pDb->uid;
   cfgRsp->cfgVersion = pDb->cfgVersion;
   cfgRsp->numOfVgroups = pDb->cfg.numOfVgroups;
@@ -1365,7 +1365,7 @@ static int32_t mndProcessGetDbCfgReq(SRpcMsg *pReq) {
     goto _OVER;
   }
 
-  tSerializeSDbCfgRsp(pRsp, contLen, &cfgRsp);
+  (void)tSerializeSDbCfgRsp(pRsp, contLen, &cfgRsp);
 
   pReq->info.rsp = pRsp;
   pReq->info.rspLen = contLen;
@@ -1539,7 +1539,7 @@ static int32_t mndBuildDropDbRsp(SDbObj *pDb, int32_t *pRspLen, void **ppRsp, bo
   int32_t    code = 0;
   SDropDbRsp dropRsp = {0};
   if (pDb != NULL) {
-    memcpy(dropRsp.db, pDb->name, TSDB_DB_FNAME_LEN);
+    (void)memcpy(dropRsp.db, pDb->name, TSDB_DB_FNAME_LEN);
     dropRsp.uid = pDb->uid;
   }
 
@@ -1556,7 +1556,7 @@ static int32_t mndBuildDropDbRsp(SDbObj *pDb, int32_t *pRspLen, void **ppRsp, bo
     TAOS_RETURN(code);
   }
 
-  tSerializeSDropDbRsp(pRsp, rspLen, &dropRsp);
+  (void)tSerializeSDropDbRsp(pRsp, rspLen, &dropRsp);
   *pRspLen = rspLen;
   *ppRsp = pRsp;
   TAOS_RETURN(code);
@@ -1637,7 +1637,7 @@ static int32_t mndProcessDropDbReq(SRpcMsg *pReq) {
   }
 
   SName name = {0};
-  tNameFromString(&name, dropReq.db, T_NAME_ACCT | T_NAME_DB);
+  (void)tNameFromString(&name, dropReq.db, T_NAME_ACCT | T_NAME_DB);
 
   auditRecord(pReq, pMnode->clusterId, "dropDB", name.dbname, "", dropReq.sql, dropReq.sqlLen);
 
@@ -1696,7 +1696,7 @@ void mndBuildDBVgroupInfo(SDbObj *pDb, SMnode *pMnode, SArray *pVgList) {
         SEp       *pEp = &vgInfo.epSet.eps[gid];
         SDnodeObj *pDnode = mndAcquireDnode(pMnode, pVgid->dnodeId);
         if (pDnode != NULL) {
-          memcpy(pEp->fqdn, pDnode->fqdn, TSDB_FQDN_LEN);
+          (void)memcpy(pEp->fqdn, pDnode->fqdn, TSDB_FQDN_LEN);
           pEp->port = pDnode->port;
         }
         mndReleaseDnode(pMnode, pDnode);
@@ -1705,7 +1705,7 @@ void mndBuildDBVgroupInfo(SDbObj *pDb, SMnode *pMnode, SArray *pVgList) {
         }
       }
       vindex++;
-      taosArrayPush(pVgList, &vgInfo);
+      (void)taosArrayPush(pVgList, &vgInfo);
     }
 
     sdbRelease(pSdb, pVgroup);
@@ -1732,7 +1732,7 @@ int32_t mndExtractDbInfo(SMnode *pMnode, SDbObj *pDb, SUseDbRsp *pRsp, const SUs
     mndBuildDBVgroupInfo(pDb, pMnode, pRsp->pVgroupInfos);
   }
 
-  memcpy(pRsp->db, pDb->name, TSDB_DB_FNAME_LEN);
+  (void)memcpy(pRsp->db, pDb->name, TSDB_DB_FNAME_LEN);
   pRsp->uid = pDb->uid;
   pRsp->vgVersion = pDb->vgVersion;
   pRsp->stateTs = pDb->stateTs;
@@ -1754,7 +1754,7 @@ static int32_t mndProcessUseDbReq(SRpcMsg *pReq) {
 
   char *p = strchr(usedbReq.db, '.');
   if (p && ((0 == strcmp(p + 1, TSDB_INFORMATION_SCHEMA_DB) || (0 == strcmp(p + 1, TSDB_PERFORMANCE_SCHEMA_DB))))) {
-    memcpy(usedbRsp.db, usedbReq.db, TSDB_DB_FNAME_LEN);
+    (void)memcpy(usedbRsp.db, usedbReq.db, TSDB_DB_FNAME_LEN);
     int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);
     if (usedbReq.vgVersion < vgVersion) {
       usedbRsp.pVgroupInfos = taosArrayInit(10, sizeof(SVgroupInfo));
@@ -1770,7 +1770,7 @@ static int32_t mndProcessUseDbReq(SRpcMsg *pReq) {
   } else {
     pDb = mndAcquireDb(pMnode, usedbReq.db);
     if (pDb == NULL) {
-      memcpy(usedbRsp.db, usedbReq.db, TSDB_DB_FNAME_LEN);
+      (void)memcpy(usedbRsp.db, usedbReq.db, TSDB_DB_FNAME_LEN);
       usedbRsp.uid = usedbReq.dbId;
       usedbRsp.vgVersion = usedbReq.vgVersion;
       usedbRsp.errCode = terrno;
@@ -1797,7 +1797,7 @@ static int32_t mndProcessUseDbReq(SRpcMsg *pReq) {
     goto _OVER;
   }
 
-  tSerializeSUseDbRsp(pRsp, contLen, &usedbRsp);
+  (void)tSerializeSUseDbRsp(pRsp, contLen, &usedbRsp);
 
   pReq->info.rsp = pRsp;
   pReq->info.rspLen = contLen;
@@ -1841,7 +1841,7 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
       }
 
       rsp.useDbRsp = taosMemoryCalloc(1, sizeof(SUseDbRsp));
-      memcpy(rsp.useDbRsp->db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);
+      (void)memcpy(rsp.useDbRsp->db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);
       rsp.useDbRsp->pVgroupInfos = taosArrayInit(10, sizeof(SVgroupInfo));
 
       mndBuildDBVgroupInfo(NULL, pMnode, rsp.useDbRsp->pVgroupInfos);
@@ -1849,7 +1849,7 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
 
       rsp.useDbRsp->vgNum = taosArrayGetSize(rsp.useDbRsp->pVgroupInfos);
 
-      taosArrayPush(batchRsp.pArray, &rsp);
+      (void)taosArrayPush(batchRsp.pArray, &rsp);
 
       continue;
     }
@@ -1858,10 +1858,10 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
     if (pDb == NULL) {
       mTrace("db:%s, no exist", pDbCacheInfo->dbFName);
       rsp.useDbRsp = taosMemoryCalloc(1, sizeof(SUseDbRsp));
-      memcpy(rsp.useDbRsp->db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);
+      (void)memcpy(rsp.useDbRsp->db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);
       rsp.useDbRsp->uid = pDbCacheInfo->dbId;
       rsp.useDbRsp->vgVersion = -1;
-      taosArrayPush(batchRsp.pArray, &rsp);
+      (void)taosArrayPush(batchRsp.pArray, &rsp);
       continue;
     }
 
@@ -1894,7 +1894,11 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
       if (rsp.pTsmaRsp && rsp.pTsmaRsp->pTsmas) {
         rsp.dbTsmaVersion = pDb->tsmaVersion;
         bool exist = false;
-        mndGetDbTsmas(pMnode, 0, pDb->uid, rsp.pTsmaRsp, &exist);
+        if (mndGetDbTsmas(pMnode, 0, pDb->uid, rsp.pTsmaRsp, &exist) != 0) {
+          mndReleaseDb(pMnode, pDb);
+          mError("db:%s, failed to get db tsmas", pDb->name);
+          continue;
+        }
       }
     }
 
@@ -1909,7 +1913,7 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
       }
 
       mndBuildDBVgroupInfo(pDb, pMnode, rsp.useDbRsp->pVgroupInfos);
-      memcpy(rsp.useDbRsp->db, pDb->name, TSDB_DB_FNAME_LEN);
+      (void)memcpy(rsp.useDbRsp->db, pDb->name, TSDB_DB_FNAME_LEN);
       rsp.useDbRsp->uid = pDb->uid;
       rsp.useDbRsp->vgVersion = pDb->vgVersion;
       rsp.useDbRsp->stateTs = pDb->stateTs;
@@ -1919,7 +1923,7 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
       rsp.useDbRsp->hashSuffix = pDb->cfg.hashSuffix;
     }
 
-    taosArrayPush(batchRsp.pArray, &rsp);
+    (void)taosArrayPush(batchRsp.pArray, &rsp);
     mndReleaseDb(pMnode, pDb);
   }
 
@@ -1930,7 +1934,7 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs,
     tFreeSDbHbBatchRsp(&batchRsp);
     return -1;
   }
-  tSerializeSDbHbBatchRsp(pRsp, rspLen, &batchRsp);
+  (void)tSerializeSDbHbBatchRsp(pRsp, rspLen, &batchRsp);
 
   *ppRsp = pRsp;
   *pRspLen = rspLen;
@@ -1959,7 +1963,7 @@ static int32_t mndTrimDb(SMnode *pMnode, SDbObj *pDb) {
     }
     pHead->contLen = htonl(contLen);
     pHead->vgId = htonl(pVgroup->vgId);
-    tSerializeSVTrimDbReq((char *)pHead + sizeof(SMsgHead), contLen, &trimReq);
+    (void)tSerializeSVTrimDbReq((char *)pHead + sizeof(SMsgHead), contLen, &trimReq);
 
     SRpcMsg rpcMsg = {.msgType = TDMT_VND_TRIM, .pCont = pHead, .contLen = contLen};
     SEpSet  epSet = mndGetVgroupEpset(pMnode, pVgroup);
@@ -2027,7 +2031,7 @@ static int32_t mndS3MigrateDb(SMnode *pMnode, SDbObj *pDb) {
     }
     pHead->contLen = htonl(contLen);
     pHead->vgId = htonl(pVgroup->vgId);
-    tSerializeSVS3MigrateDbReq((char *)pHead + sizeof(SMsgHead), contLen, &s3migrateReq);
+    (void)tSerializeSVS3MigrateDbReq((char *)pHead + sizeof(SMsgHead), contLen, &s3migrateReq);
 
     SRpcMsg rpcMsg = {.msgType = TDMT_VND_S3MIGRATE, .pCont = pHead, .contLen = contLen};
     SEpSet  epSet = mndGetVgroupEpset(pMnode, pVgroup);
@@ -2252,46 +2256,46 @@ static void mndDumpDbInfoData(SMnode *pMnode, SSDataBlock *pBlock, SDbObj *pDb,
     for (int32_t i = 0; i < pShow->numOfColumns; ++i) {
       SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, i);
       if (i == 0) {
-        colDataSetVal(pColInfo, rows, buf, false);
+        (void)colDataSetVal(pColInfo, rows, buf, false);
       } else if (i == 1) {
-        colDataSetVal(pColInfo, rows, (const char *)&pDb->createdTime, false);
+        (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->createdTime, false);
       } else if (i == 3) {
-        colDataSetVal(pColInfo, rows, (const char *)&numOfTables, false);
+        (void)colDataSetVal(pColInfo, rows, (const char *)&numOfTables, false);
       } else if (i == 14) {
-        colDataSetVal(pColInfo, rows, precVstr, false);
+        (void)colDataSetVal(pColInfo, rows, precVstr, false);
       } else if (i == 15) {
-        colDataSetVal(pColInfo, rows, statusVstr, false);
+        (void)colDataSetVal(pColInfo, rows, statusVstr, false);
       } else {
         colDataSetNULL(pColInfo, rows);
       }
     }
   } else {
     SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, buf, false);
+    (void)colDataSetVal(pColInfo, rows, buf, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->createdTime, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->createdTime, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.numOfVgroups, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.numOfVgroups, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&numOfTables, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&numOfTables, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.replications, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.replications, false);
 
     const char *strictStr = pDb->cfg.strict ? "on" : "off";
     char        strictVstr[24] = {0};
     STR_WITH_MAXSIZE_TO_VARSTR(strictVstr, strictStr, 24);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)strictVstr, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)strictVstr, false);
 
     char    durationVstr[128] = {0};
     int32_t len = sprintf(&durationVstr[VARSTR_HEADER_SIZE], "%dm", pDb->cfg.daysPerFile);
     varDataSetLen(durationVstr, len);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)durationVstr, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)durationVstr, false);
 
     char keepVstr[128] = {0};
     if (pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep1 || pDb->cfg.daysToKeep0 > pDb->cfg.daysToKeep2) {
@@ -2303,67 +2307,67 @@ static void mndDumpDbInfoData(SMnode *pMnode, SSDataBlock *pBlock, SDbObj *pDb,
     }
     varDataSetLen(keepVstr, len);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)keepVstr, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)keepVstr, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.buffer, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.buffer, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.pageSize, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.pageSize, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.pages, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.pages, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.minRows, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.minRows, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.maxRows, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.maxRows, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.compression, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.compression, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)precVstr, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)precVstr, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)statusVstr, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)statusVstr, false);
 
     char *rentensionVstr = buildRetension(pDb->cfg.pRetensions);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     if (rentensionVstr == NULL) {
       colDataSetNULL(pColInfo, rows);
     } else {
-      colDataSetVal(pColInfo, rows, (const char *)rentensionVstr, false);
+      (void)colDataSetVal(pColInfo, rows, (const char *)rentensionVstr, false);
       taosMemoryFree(rentensionVstr);
     }
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.numOfStables, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.numOfStables, false);
 
     const char *cacheModelStr = getCacheModelStr(pDb->cfg.cacheLast);
     char        cacheModelVstr[24] = {0};
     STR_WITH_MAXSIZE_TO_VARSTR(cacheModelVstr, cacheModelStr, 24);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)cacheModelVstr, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)cacheModelVstr, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.cacheLastSize, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.cacheLastSize, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walLevel, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walLevel, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walFsyncPeriod, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walFsyncPeriod, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walRetentionPeriod, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walRetentionPeriod, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walRetentionSize, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.walRetentionSize, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.sstTrigger, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.sstTrigger, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     int16_t hashPrefix = pDb->cfg.hashPrefix;
@@ -2372,37 +2376,37 @@ static void mndDumpDbInfoData(SMnode *pMnode, SSDataBlock *pBlock, SDbObj *pDb,
     } else if (hashPrefix < 0) {
       hashPrefix = pDb->cfg.hashPrefix + strlen(pDb->name) + 1;
     }
-    colDataSetVal(pColInfo, rows, (const char *)&hashPrefix, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&hashPrefix, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.hashSuffix, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.hashSuffix, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.tsdbPageSize, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.tsdbPageSize, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.keepTimeOffset, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.keepTimeOffset, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.s3ChunkSize, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.s3ChunkSize, false);
 
     char keeplocalVstr[128] = {0};
     len = sprintf(&keeplocalVstr[VARSTR_HEADER_SIZE], "%dm", pDb->cfg.s3KeepLocal);
     varDataSetLen(keeplocalVstr, len);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)keeplocalVstr, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)keeplocalVstr, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.s3Compact, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.s3Compact, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.withArbitrator, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)&pDb->cfg.withArbitrator, false);
 
     const char *encryptAlgorithmStr = getEncryptAlgorithmStr(pDb->cfg.encryptAlgorithm);
     char        encryptAlgorithmVStr[24] = {0};
     STR_WITH_MAXSIZE_TO_VARSTR(encryptAlgorithmVStr, encryptAlgorithmStr, 24);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, rows, (const char *)encryptAlgorithmVStr, false);
+    (void)colDataSetVal(pColInfo, rows, (const char *)encryptAlgorithmVStr, false);
   }
 
   taosMemoryFree(buf);
@@ -2441,9 +2445,10 @@ static int32_t mndRetrieveDbs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBloc
   SSdb      *pSdb = pMnode->pSdb;
   int32_t    numOfRows = 0;
   SDbObj    *pDb = NULL;
+  SUserObj  *pUser = NULL;
   ESdbStatus objStatus = 0;
 
-  SUserObj *pUser = mndAcquireUser(pMnode, pReq->info.conn.user);
+  (void)mndAcquireUser(pMnode, pReq->info.conn.user, &pUser);
   if (pUser == NULL) return 0;
   bool sysinfo = pUser->sysInfo;
 

source/dnode/mnode/impl/src/mndDef.c

@@ -158,10 +158,19 @@ int32_t tDecodeSStreamObj(SDecoder *pDecoder, SStreamObj *pObj, int32_t sver) {
             taosArrayDestroy(pArray);
             TAOS_RETURN(code);
           }
-          taosArrayPush(pArray, &pTask);
+          if (taosArrayPush(pArray, &pTask) == NULL) {
+            taosMemoryFree(pTask);
+            taosArrayDestroy(pArray);
+            code = TSDB_CODE_OUT_OF_MEMORY;
+            TAOS_RETURN(code);
+          }
         }
       }
-      taosArrayPush(pObj->tasks, &pArray);
+      if (taosArrayPush(pObj->tasks, &pArray) == NULL) {
+        taosArrayDestroy(pArray);
+        code = TSDB_CODE_OUT_OF_MEMORY;
+        TAOS_RETURN(code);
+      }
     }
   }
 
@@ -436,10 +445,15 @@ void *tDecodeSMqConsumerObj(const void *buf, SMqConsumerObj *pConsumer, int8_t s
   // current topics
   buf = taosDecodeFixedI32(buf, &sz);
   pConsumer->currentTopics = taosArrayInit(sz, sizeof(void *));
+  if (pConsumer->currentTopics == NULL) {
+    return NULL;
+  }
   for (int32_t i = 0; i < sz; i++) {
     char *topic;
     buf = taosDecodeString(buf, &topic);
-    taosArrayPush(pConsumer->currentTopics, &topic);
+    if (taosArrayPush(pConsumer->currentTopics, &topic) == NULL) {
+      return NULL;
+    }
   }
 
   // reb new topics
@@ -448,7 +462,9 @@ void *tDecodeSMqConsumerObj(const void *buf, SMqConsumerObj *pConsumer, int8_t s
   for (int32_t i = 0; i < sz; i++) {
     char *topic;
     buf = taosDecodeString(buf, &topic);
-    taosArrayPush(pConsumer->rebNewTopics, &topic);
+    if (taosArrayPush(pConsumer->rebNewTopics, &topic) == NULL) {
+      return NULL;
+    }
   }
 
   // reb removed topics
@@ -457,7 +473,9 @@ void *tDecodeSMqConsumerObj(const void *buf, SMqConsumerObj *pConsumer, int8_t s
   for (int32_t i = 0; i < sz; i++) {
     char *topic;
     buf = taosDecodeString(buf, &topic);
-    taosArrayPush(pConsumer->rebRemovedTopics, &topic);
+    if (taosArrayPush(pConsumer->rebRemovedTopics, &topic) == NULL) {
+      return NULL;
+    }
   }
 
   // reb removed topics
@@ -466,7 +484,9 @@ void *tDecodeSMqConsumerObj(const void *buf, SMqConsumerObj *pConsumer, int8_t s
   for (int32_t i = 0; i < sz; i++) {
     char *topic;
     buf = taosDecodeString(buf, &topic);
-    taosArrayPush(pConsumer->assignedTopics, &topic);
+    if (taosArrayPush(pConsumer->assignedTopics, &topic) == NULL) {
+      return NULL;
+    }
   }
 
   if (sver > 1) {
@@ -597,7 +617,9 @@ int32_t tCloneSubscribeObj(const SMqSubscribeObj *pSub, SMqSubscribeObj **ppSub)
         .consumerId = pConsumerEp->consumerId,
         .vgs = taosArrayDup(pConsumerEp->vgs, (__array_item_dup_fn_t)tCloneSMqVgEp),
     };
-    taosHashPut(pSubNew->consumerHash, &newEp.consumerId, sizeof(int64_t), &newEp, sizeof(SMqConsumerEp));
+    if ((code = taosHashPut(pSubNew->consumerHash, &newEp.consumerId, sizeof(int64_t), &newEp,
+                            sizeof(SMqConsumerEp))) != 0)
+      goto END;
   }
   pSubNew->unassignedVgs = taosArrayDup(pSub->unassignedVgs, (__array_item_dup_fn_t)tCloneSMqVgEp);
   pSubNew->offsetRows = taosArrayDup(pSub->offsetRows, NULL);
@@ -672,7 +694,9 @@ void *tDecodeSubscribeObj(const void *buf, SMqSubscribeObj *pSub, int8_t sver) {
   for (int32_t i = 0; i < sz; i++) {
     SMqConsumerEp consumerEp = {0};
     buf = tDecodeSMqConsumerEp(buf, &consumerEp, sver);
-    taosHashPut(pSub->consumerHash, &consumerEp.consumerId, sizeof(int64_t), &consumerEp, sizeof(SMqConsumerEp));
+    if (taosHashPut(pSub->consumerHash, &consumerEp.consumerId, sizeof(int64_t), &consumerEp, sizeof(SMqConsumerEp)) !=
+        0)
+      return NULL;
   }
 
   buf = taosDecodeArray(buf, &pSub->unassignedVgs, (FDecode)tDecodeSMqVgEp, sizeof(SMqVgEp), sver);

source/dnode/mnode/impl/src/mndDnode.c

@@ -152,10 +152,11 @@ static int32_t mndCreateDefaultDnode(SMnode *pMnode) {
   dnodeObj.port = tsServerPort;
   tstrncpy(dnodeObj.fqdn, tsLocalFqdn, TSDB_FQDN_LEN);
   dnodeObj.fqdn[TSDB_FQDN_LEN - 1] = 0;
-  snprintf(dnodeObj.ep, TSDB_EP_LEN - 1, "%s:%u", tsLocalFqdn, tsServerPort);
+  (void)snprintf(dnodeObj.ep, TSDB_EP_LEN - 1, "%s:%u", tsLocalFqdn, tsServerPort);
-  char *machineId = tGetMachineId();
+  char *machineId = NULL;
+  code = tGetMachineId(&machineId);
   if (machineId) {
-    memcpy(dnodeObj.machineId, machineId, TSDB_MACHINE_ID_LEN);
+    (void)memcpy(dnodeObj.machineId, machineId, TSDB_MACHINE_ID_LEN);
     taosMemoryFreeClear(machineId);
   } else {
 #if defined(TD_ENTERPRISE) && !defined(GRANTS_CFG)
@@ -184,7 +185,8 @@ static int32_t mndCreateDefaultDnode(SMnode *pMnode) {
 
   TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
   code = 0;
-  mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, 1);
+  mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD,
+                             1);  // TODO: check the return value
 
 _OVER:
   mndTransDrop(pTrans);
@@ -193,6 +195,8 @@ _OVER:
 }
 
 static SSdbRaw *mndDnodeActionEncode(SDnodeObj *pDnode) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   SSdbRaw *pRaw = sdbAllocRaw(SDB_DNODE, TSDB_DNODE_VER_NUMBER, sizeof(SDnodeObj) + TSDB_DNODE_RESERVE_SIZE);
@@ -224,6 +228,8 @@ _OVER:
 }
 
 static SSdbRow *mndDnodeActionDecode(SSdbRaw *pRaw) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
   SSdbRow   *pRow = NULL;
   SDnodeObj *pDnode = NULL;
@@ -278,7 +284,7 @@ static int32_t mndDnodeActionInsert(SSdb *pSdb, SDnodeObj *pDnode) {
   pDnode->offlineReason = DND_REASON_STATUS_NOT_RECEIVED;
 
   char ep[TSDB_EP_LEN] = {0};
-  snprintf(ep, TSDB_EP_LEN - 1, "%s:%u", pDnode->fqdn, pDnode->port);
+  (void)snprintf(ep, TSDB_EP_LEN - 1, "%s:%u", pDnode->fqdn, pDnode->port);
   tstrncpy(pDnode->ep, ep, TSDB_EP_LEN);
   return 0;
 }
@@ -323,7 +329,7 @@ void mndReleaseDnode(SMnode *pMnode, SDnodeObj *pDnode) {
 
 SEpSet mndGetDnodeEpset(SDnodeObj *pDnode) {
   SEpSet epSet = {0};
-  addEpIntoEpSet(&epSet, pDnode->fqdn, pDnode->port);
+  terrno = addEpIntoEpSet(&epSet, pDnode->fqdn, pDnode->port);
   return epSet;
 }
 
@@ -422,12 +428,13 @@ static void mndGetDnodeEps(SMnode *pMnode, SArray *pDnodeEps) {
     if (mndIsMnode(pMnode, pDnode->id)) {
       dnodeEp.isMnode = 1;
     }
-    taosArrayPush(pDnodeEps, &dnodeEp);
+    (void)taosArrayPush(pDnodeEps, &dnodeEp);
   }
 }
 
-void mndGetDnodeData(SMnode *pMnode, SArray *pDnodeInfo) {
+int32_t mndGetDnodeData(SMnode *pMnode, SArray *pDnodeInfo) {
-  SSdb *pSdb = pMnode->pSdb;
+  SSdb   *pSdb = pMnode->pSdb;
+  int32_t code = 0;
 
   int32_t numOfEps = 0;
   void   *pIter = NULL;
@@ -449,8 +456,13 @@ void mndGetDnodeData(SMnode *pMnode, SArray *pDnodeInfo) {
       dInfo.isMnode = 0;
     }
 
-    taosArrayPush(pDnodeInfo, &dInfo);
+    if(taosArrayPush(pDnodeInfo, &dInfo) == NULL){
+      code = TSDB_CODE_OUT_OF_MEMORY;
+      sdbCancelFetch(pSdb, pIter);
+      break;
+    }
   }
+  TAOS_RETURN(code);
 }
 
 #define CHECK_MONITOR_PARA(para,err) \
@@ -736,7 +748,7 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
     if (statusReq.mload.roleTimeMs == 0) {
       statusReq.mload.roleTimeMs = statusReq.rebootTime;
     }
-    mndUpdateMnodeState(pObj, &statusReq.mload);
+    (void)mndUpdateMnodeState(pObj, &statusReq.mload);
     mndReleaseMnode(pMnode, pObj);
   }
 
@@ -796,7 +808,9 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
     pDnode->encryptionKeyChksum = statusReq.clusterCfg.encryptionKeyChksum;
     if (memcmp(pDnode->machineId, statusReq.machineId, TSDB_MACHINE_ID_LEN) != 0) {
       tstrncpy(pDnode->machineId, statusReq.machineId, TSDB_MACHINE_ID_LEN + 1);
-      mndUpdateDnodeObj(pMnode, pDnode);
+      if ((terrno = mndUpdateDnodeObj(pMnode, pDnode)) != 0) {
+        goto _OVER;
+      }
     }
 
     SStatusRsp statusRsp = {0};
@@ -815,7 +829,7 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
 
     int32_t contLen = tSerializeSStatusRsp(NULL, 0, &statusRsp);
     void   *pHead = rpcMallocCont(contLen);
-    tSerializeSStatusRsp(pHead, contLen, &statusRsp);
+    (void)tSerializeSStatusRsp(pHead, contLen, &statusRsp);
     taosArrayDestroy(statusRsp.pDnodeEps);
 
     pReq->info.rspLen = contLen;
@@ -829,7 +843,7 @@ static int32_t mndProcessStatusReq(SRpcMsg *pReq) {
 _OVER:
   mndReleaseDnode(pMnode, pDnode);
   taosArrayDestroy(statusReq.pVloads);
-  mndUpdClusterInfo(pReq);
+  (void)mndUpdClusterInfo(pReq);
   return code;
 }
 
@@ -861,7 +875,7 @@ static int32_t mndProcessNotifyReq(SRpcMsg *pReq) {
       mndReleaseVgroup(pMnode, pVgroup);
     }
   }
-  mndUpdClusterInfo(pReq);
+  code = mndUpdClusterInfo(pReq);
 _OVER:
   tFreeSNotifyReq(&notifyReq);
   return code;
@@ -878,7 +892,7 @@ static int32_t mndCreateDnode(SMnode *pMnode, SRpcMsg *pReq, SCreateDnodeReq *pC
   dnodeObj.updateTime = dnodeObj.createdTime;
   dnodeObj.port = pCreate->port;
   tstrncpy(dnodeObj.fqdn, pCreate->fqdn, TSDB_FQDN_LEN);
-  snprintf(dnodeObj.ep, TSDB_EP_LEN - 1, "%s:%u", pCreate->fqdn, pCreate->port);
+  (void)snprintf(dnodeObj.ep, TSDB_EP_LEN - 1, "%s:%u", pCreate->fqdn, pCreate->port);
 
   pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_GLOBAL, pReq, "create-dnode");
   if (pTrans == NULL) {
@@ -902,7 +916,7 @@ static int32_t mndCreateDnode(SMnode *pMnode, SRpcMsg *pReq, SCreateDnodeReq *pC
   TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
   code = 0;
 
-  mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, 1);
+  mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, dnodeObj.fqdn, IP_WHITE_ADD, 1); // TODO: check the return value
 _OVER:
   mndTransDrop(pTrans);
   sdbFreeRaw(pRaw);
@@ -945,7 +959,7 @@ static int32_t mndProcessDnodeListReq(SRpcMsg *pReq) {
     goto _OVER;
   }
 
-  tSerializeSDnodeListRsp(pRsp, rspLen, &rsp);
+  (void)tSerializeSDnodeListRsp(pRsp, rspLen, &rsp);
 
   pReq->info.rspLen = rspLen;
   pReq->info.rsp = pRsp;
@@ -964,26 +978,26 @@ _OVER:
 
 static void getSlowLogScopeString(int32_t scope, char* result){
   if(scope == SLOW_LOG_TYPE_NULL) {
-    strcat(result, "NONE");
+    (void)strcat(result, "NONE");
     return;
   }
   while(scope > 0){
     if(scope & SLOW_LOG_TYPE_QUERY) {
-      strcat(result, "QUERY");
+      (void)strcat(result, "QUERY");
       scope &= ~SLOW_LOG_TYPE_QUERY;
     } else if(scope & SLOW_LOG_TYPE_INSERT) {
-      strcat(result, "INSERT");
+      (void)strcat(result, "INSERT");
       scope &= ~SLOW_LOG_TYPE_INSERT;
     } else if(scope & SLOW_LOG_TYPE_OTHERS) {
-      strcat(result, "OTHERS");
+      (void)strcat(result, "OTHERS");
       scope &= ~SLOW_LOG_TYPE_OTHERS;
     } else{
-      printf("invalid slow log scope:%d", scope);
+      (void)printf("invalid slow log scope:%d", scope);
       return;
     }
 
     if(scope > 0) {
-      strcat(result, "|");
+      (void)strcat(result, "|");
     }
   }
 }
@@ -1005,52 +1019,79 @@ static int32_t mndProcessShowVariablesReq(SRpcMsg *pReq) {
 
   SVariablesInfo info = {0};
 
-  strcpy(info.name, "statusInterval");
+  (void)strcpy(info.name, "statusInterval");
-  snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsStatusInterval);
+  (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsStatusInterval);
-  strcpy(info.scope, "server");
+  (void)strcpy(info.scope, "server");
-  taosArrayPush(rsp.variables, &info);
+  if (taosArrayPush(rsp.variables, &info) == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
 
-  strcpy(info.name, "timezone");
+  (void)strcpy(info.name, "timezone");
-  snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%s", tsTimezoneStr);
+  (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%s", tsTimezoneStr);
-  strcpy(info.scope, "both");
+  (void)strcpy(info.scope, "both");
-  taosArrayPush(rsp.variables, &info);
+  if (taosArrayPush(rsp.variables, &info) == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
 
-  strcpy(info.name, "locale");
+  (void)strcpy(info.name, "locale");
-  snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%s", tsLocale);
+  (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%s", tsLocale);
-  strcpy(info.scope, "both");
+  (void)strcpy(info.scope, "both");
-  taosArrayPush(rsp.variables, &info);
+  if (taosArrayPush(rsp.variables, &info) == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
 
-  strcpy(info.name, "charset");
+  (void)strcpy(info.name, "charset");
-  snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%s", tsCharset);
+  (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%s", tsCharset);
-  strcpy(info.scope, "both");
+  (void)strcpy(info.scope, "both");
-  taosArrayPush(rsp.variables, &info);
+  if (taosArrayPush(rsp.variables, &info) == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
 
-  strcpy(info.name, "monitor");
+  (void)strcpy(info.name, "monitor");
-  snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsEnableMonitor);
+  (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsEnableMonitor);
-  strcpy(info.scope, "server");
+  (void)strcpy(info.scope, "server");
-  taosArrayPush(rsp.variables, &info);
+  if (taosArrayPush(rsp.variables, &info) == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
 
-  strcpy(info.name, "monitorInterval");
+  (void)strcpy(info.name, "monitorInterval");
-  snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsMonitorInterval);
+  (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsMonitorInterval);
-  strcpy(info.scope, "server");
+  (void)strcpy(info.scope, "server");
-  taosArrayPush(rsp.variables, &info);
+  if (taosArrayPush(rsp.variables, &info) == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
 
-  strcpy(info.name, "slowLogThreshold");
+  (void)strcpy(info.name, "slowLogThreshold");
-  snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsSlowLogThreshold);
+  (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsSlowLogThreshold);
-  strcpy(info.scope, "server");
+  (void)strcpy(info.scope, "server");
-  taosArrayPush(rsp.variables, &info);
+  if (taosArrayPush(rsp.variables, &info) == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
 
-  strcpy(info.name, "slowLogMaxLen");
+  (void)strcpy(info.name, "slowLogMaxLen");
-  snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsSlowLogMaxLen);
+  (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%d", tsSlowLogMaxLen);
-  strcpy(info.scope, "server");
+  (void)strcpy(info.scope, "server");
-  taosArrayPush(rsp.variables, &info);
+  if (taosArrayPush(rsp.variables, &info) == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
 
   char scopeStr[64] = {0};
   getSlowLogScopeString(tsSlowLogScope, scopeStr);
-  strcpy(info.name, "slowLogScope");
+  (void)strcpy(info.name, "slowLogScope");
-  snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%s", scopeStr);
+  (void)snprintf(info.value, TSDB_CONFIG_VALUE_LEN, "%s", scopeStr);
-  strcpy(info.scope, "server");
+  (void)strcpy(info.scope, "server");
-  taosArrayPush(rsp.variables, &info);
+  if (taosArrayPush(rsp.variables, &info) == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _OVER;
+  }
 
   int32_t rspLen = tSerializeSShowVariablesRsp(NULL, 0, &rsp);
   void   *pRsp = rpcMallocCont(rspLen);
@@ -1059,7 +1100,7 @@ static int32_t mndProcessShowVariablesReq(SRpcMsg *pReq) {
     goto _OVER;
   }
 
-  tSerializeSShowVariablesRsp(pRsp, rspLen, &rsp);
+  (void)tSerializeSShowVariablesRsp(pRsp, rspLen, &rsp);
 
   pReq->info.rspLen = rspLen;
   pReq->info.rsp = pRsp;
@@ -1096,7 +1137,7 @@ static int32_t mndProcessCreateDnodeReq(SRpcMsg *pReq) {
   }
 
   char ep[TSDB_EP_LEN];
-  snprintf(ep, TSDB_EP_LEN, "%s:%d", createReq.fqdn, createReq.port);
+  (void)snprintf(ep, TSDB_EP_LEN, "%s:%d", createReq.fqdn, createReq.port);
   pDnode = mndAcquireDnodeByEp(pMnode, ep);
   if (pDnode != NULL) {
     code = TSDB_CODE_MND_DNODE_ALREADY_EXIST;
@@ -1110,7 +1151,7 @@ static int32_t mndProcessCreateDnodeReq(SRpcMsg *pReq) {
   }
 
   char obj[200] = {0};
-  sprintf(obj, "%s:%d", createReq.fqdn, createReq.port);
+  (void)sprintf(obj, "%s:%d", createReq.fqdn, createReq.port);
 
   auditRecord(pReq, pMnode->clusterId, "createDnode", "", obj, createReq.sql, createReq.sqlLen);
 
@@ -1190,7 +1231,7 @@ static int32_t mndDropDnode(SMnode *pMnode, SRpcMsg *pReq, SDnodeObj *pDnode, SM
 
   TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _OVER);
 
-  mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, pDnode->fqdn, IP_WHITE_DROP, 1);
+  mndUpdateIpWhiteForAllUser(pMnode, TSDB_DEFAULT_USER, pDnode->fqdn, IP_WHITE_DROP, 1); // TODO: check the return value
   code = 0;
 
 _OVER:
@@ -1249,7 +1290,7 @@ static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq) {
   if (pDnode == NULL) {
     int32_t err = terrno;
     char    ep[TSDB_EP_LEN + 1] = {0};
-    snprintf(ep, sizeof(ep), dropReq.fqdn, dropReq.port);
+    (void)snprintf(ep, sizeof(ep), dropReq.fqdn, dropReq.port);
     pDnode = mndAcquireDnodeByEp(pMnode, ep);
     if (pDnode == NULL) {
       code = err;
@@ -1293,7 +1334,7 @@ static int32_t mndProcessDropDnodeReq(SRpcMsg *pReq) {
   if (code == 0) code = TSDB_CODE_ACTION_IN_PROGRESS;
 
   char obj1[30] = {0};
-  sprintf(obj1, "%d", dropReq.dnodeId);
+  (void)sprintf(obj1, "%d", dropReq.dnodeId);
 
   auditRecord(pReq, pMnode->clusterId, "dropDnode", "", obj1, dropReq.sql, dropReq.sqlLen);
 
@@ -1321,17 +1362,17 @@ static int32_t mndMCfg2DCfg(SMCfgDnodeReq *pMCfgReq, SDCfgDnodeReq *pDCfgReq) {
   }
 
   size_t optLen = p - pMCfgReq->config;
-  strncpy(pDCfgReq->config, pMCfgReq->config, optLen);
+  (void)strncpy(pDCfgReq->config, pMCfgReq->config, optLen);
   pDCfgReq->config[optLen] = 0;
 
   if (' ' == pMCfgReq->config[optLen]) {
     // 'key value'
     if (strlen(pMCfgReq->value) != 0) goto _err;
-    strcpy(pDCfgReq->value, p + 1);
+    (void)strcpy(pDCfgReq->value, p + 1);
   } else {
     // 'key' 'value'
     if (strlen(pMCfgReq->value) == 0) goto _err;
-    strcpy(pDCfgReq->value, pMCfgReq->value);
+    (void)strcpy(pDCfgReq->value, pMCfgReq->value);
   }
 
   TAOS_RETURN(code);
@@ -1357,11 +1398,10 @@ static int32_t mndSendCfgDnodeReq(SMnode *pMnode, int32_t dnodeId, SDCfgDnodeReq
       void   *pBuf = rpcMallocCont(bufLen);
 
       if (pBuf != NULL) {
-        tSerializeSDCfgDnodeReq(pBuf, bufLen, pDcfgReq);
+        (void)tSerializeSDCfgDnodeReq(pBuf, bufLen, pDcfgReq);
         mInfo("dnode:%d, send config req to dnode, config:%s value:%s", dnodeId, pDcfgReq->config, pDcfgReq->value);
         SRpcMsg rpcMsg = {.msgType = TDMT_DND_CONFIG_DNODE, .pCont = pBuf, .contLen = bufLen};
-        tmsgSendReq(&epSet, &rpcMsg);
+        code = tmsgSendReq(&epSet, &rpcMsg);
-        code = 0;
       }
     }
 
@@ -1388,7 +1428,7 @@ static int32_t mndProcessConfigDnodeReq(SRpcMsg *pReq) {
 
   SDCfgDnodeReq dcfgReq = {0};
   if (strcasecmp(cfgReq.config, "resetlog") == 0) {
-    strcpy(dcfgReq.config, "resetlog");
+    (void)strcpy(dcfgReq.config, "resetlog");
 #ifdef TD_ENTERPRISE
   } else if (strncasecmp(cfgReq.config, "s3blocksize", 11) == 0) {
     int32_t optLen = strlen("s3blocksize");
@@ -1423,7 +1463,7 @@ static int32_t mndProcessConfigDnodeReq(SRpcMsg *pReq) {
 
   {  // audit
     char obj[50] = {0};
-    sprintf(obj, "%d", cfgReq.dnodeId);
+    (void)sprintf(obj, "%d", cfgReq.dnodeId);
 
     auditRecord(pReq, pMnode->clusterId, "alterDnode", obj, "", cfgReq.sql, cfgReq.sqlLen);
   }
@@ -1498,10 +1538,10 @@ static int32_t mndProcessCreateEncryptKeyReqImpl(SRpcMsg *pReq, int32_t dnodeId,
       void   *pBuf = rpcMallocCont(bufLen);
 
       if (pBuf != NULL) {
-        tSerializeSDCfgDnodeReq(pBuf, bufLen, pDcfgReq);
+        (void)tSerializeSDCfgDnodeReq(pBuf, bufLen, pDcfgReq);
         SRpcMsg rpcMsg = {.msgType = TDMT_DND_CREATE_ENCRYPT_KEY, .pCont = pBuf, .contLen = bufLen};
         if (0 == tmsgSendReq(&epSet, &rpcMsg)) {
-          atomic_add_fetch_16(&pMnode->encryptMgmt.nEncrypt, 1);
+          (void)atomic_add_fetch_16(&pMnode->encryptMgmt.nEncrypt, 1);
         }
       }
     }
@@ -1585,41 +1625,41 @@ static int32_t mndRetrieveConfigs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p
   int32_t cols = 0;
 
   cfgOpts[totalRows] = "statusInterval";
-  snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%d", tsStatusInterval);
+  (void)snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%d", tsStatusInterval);
   totalRows++;
 
   cfgOpts[totalRows] = "timezone";
-  snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%s", tsTimezoneStr);
+  (void)snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%s", tsTimezoneStr);
   totalRows++;
 
   cfgOpts[totalRows] = "locale";
-  snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%s", tsLocale);
+  (void)snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%s", tsLocale);
   totalRows++;
 
   cfgOpts[totalRows] = "charset";
-  snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%s", tsCharset);
+  (void)snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%s", tsCharset);
   totalRows++;
 
   cfgOpts[totalRows] = "monitor";
-  snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%d", tsEnableMonitor);
+  (void)snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%d", tsEnableMonitor);
   totalRows++;
 
   cfgOpts[totalRows] = "monitorInterval";
-  snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%d", tsMonitorInterval);
+  (void)snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%d", tsMonitorInterval);
   totalRows++;
 
   cfgOpts[totalRows] = "slowLogThreshold";
-  snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%d", tsSlowLogThreshold);
+  (void)snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%d", tsSlowLogThreshold);
   totalRows++;
 
   cfgOpts[totalRows] = "slowLogMaxLen";
-  snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%d", tsSlowLogMaxLen);
+  (void)snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%d", tsSlowLogMaxLen);
   totalRows++;
 
   char scopeStr[64] = {0};
   getSlowLogScopeString(tsSlowLogScope, scopeStr);
   cfgOpts[totalRows] = "slowLogScope";
-  snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%s", scopeStr);
+  (void)snprintf(cfgVals[totalRows], TSDB_CONFIG_VALUE_LEN, "%s", scopeStr);
   totalRows++;
 
   char buf[TSDB_CONFIG_OPTION_LEN + VARSTR_HEADER_SIZE] = {0};
@@ -1630,11 +1670,11 @@ static int32_t mndRetrieveConfigs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *p
 
     STR_WITH_MAXSIZE_TO_VARSTR(buf, cfgOpts[i], TSDB_CONFIG_OPTION_LEN);
     SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)buf, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)buf, false);
 
     STR_WITH_MAXSIZE_TO_VARSTR(bufVal, cfgVals[i], TSDB_CONFIG_VALUE_LEN);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)bufVal, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)bufVal, false);
 
     numOfRows++;
   }
@@ -1663,19 +1703,19 @@ static int32_t mndRetrieveDnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB
     cols = 0;
 
     SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pDnode->id, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pDnode->id, false);
 
     STR_WITH_MAXSIZE_TO_VARSTR(buf, pDnode->ep, pShow->pMeta->pSchemas[cols].bytes);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, buf, false);
+    (void)colDataSetVal(pColInfo, numOfRows, buf, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     int16_t id = mndGetVnodesNum(pMnode, pDnode->id);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&id, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&id, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pDnode->numOfSupportVnodes, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pDnode->numOfSupportVnodes, false);
 
     const char *status = "ready";
     if (objStatus == SDB_STATUS_CREATING) status = "creating";
@@ -1691,19 +1731,19 @@ static int32_t mndRetrieveDnodes(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pB
 
     STR_TO_VARSTR(buf, status);
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, buf, false);
+    (void)colDataSetVal(pColInfo, numOfRows, buf, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pDnode->createdTime, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pDnode->createdTime, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pDnode->rebootTime, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pDnode->rebootTime, false);
 
     char *b = taosMemoryCalloc(VARSTR_HEADER_SIZE + strlen(offlineReason[pDnode->offlineReason]) + 1, 1);
     STR_TO_VARSTR(b, online ? "" : offlineReason[pDnode->offlineReason]);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, b, false);
+    (void)colDataSetVal(pColInfo, numOfRows, b, false);
     taosMemoryFreeClear(b);
 
 #ifdef TD_ENTERPRISE
@@ -1760,7 +1800,7 @@ SArray *mndGetAllDnodeFqdns(SMnode *pMnode) {
     if (pIter == NULL) break;
 
     char *fqdn = taosStrdup(pObj->fqdn);
-    taosArrayPush(fqdns, &fqdn);
+    (void)taosArrayPush(fqdns, &fqdn);
     sdbRelease(pSdb, pObj);
   }
   return fqdns;

source/dnode/mnode/impl/src/mndDump.c

@@ -41,7 +41,7 @@ int32_t sendSyncReq(const SEpSet *pEpSet, SRpcMsg *pMsg) {
 
 char *i642str(int64_t val) {
   static char str[24] = {0};
-  snprintf(str, sizeof(str), "%" PRId64, val);
+  (void)snprintf(str, sizeof(str), "%" PRId64, val);
   return str;
 }
 
@@ -55,18 +55,18 @@ void dumpFunc(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
+    (void)tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "name", pObj->name);
+    (void)tjsonAddStringToObject(item, "name", pObj->name);
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "funcType", i642str(pObj->funcType));
+    (void)tjsonAddStringToObject(item, "funcType", i642str(pObj->funcType));
-    tjsonAddStringToObject(item, "scriptType", i642str(pObj->scriptType));
+    (void)tjsonAddStringToObject(item, "scriptType", i642str(pObj->scriptType));
-    tjsonAddStringToObject(item, "align", i642str(pObj->align));
+    (void)tjsonAddStringToObject(item, "align", i642str(pObj->align));
-    tjsonAddStringToObject(item, "outputType", i642str(pObj->outputType));
+    (void)tjsonAddStringToObject(item, "outputType", i642str(pObj->outputType));
-    tjsonAddStringToObject(item, "outputLen", i642str(pObj->outputLen));
+    (void)tjsonAddStringToObject(item, "outputLen", i642str(pObj->outputLen));
-    tjsonAddStringToObject(item, "bufSize", i642str(pObj->bufSize));
+    (void)tjsonAddStringToObject(item, "bufSize", i642str(pObj->bufSize));
-    tjsonAddStringToObject(item, "signature", i642str(pObj->signature));
+    (void)tjsonAddStringToObject(item, "signature", i642str(pObj->signature));
-    tjsonAddStringToObject(item, "commentSize", i642str(pObj->commentSize));
+    (void)tjsonAddStringToObject(item, "commentSize", i642str(pObj->commentSize));
-    tjsonAddStringToObject(item, "codeSize", i642str(pObj->codeSize));
+    (void)tjsonAddStringToObject(item, "codeSize", i642str(pObj->codeSize));
     sdbRelease(pSdb, pObj);
   }
 }
@@ -84,56 +84,56 @@ void dumpDb(SSdb *pSdb, SJson *json) {
     SJson *item = tjsonCreateObject();
     tjsonAddItemToObject(items, "db", item);
 
-    tjsonAddStringToObject(item, "name", mndGetDbStr(pObj->name));
+    (void)tjsonAddStringToObject(item, "name", mndGetDbStr(pObj->name));
-    tjsonAddStringToObject(item, "acct", pObj->acct);
+    (void)tjsonAddStringToObject(item, "acct", pObj->acct);
-    tjsonAddStringToObject(item, "createUser", pObj->createUser);
+    (void)tjsonAddStringToObject(item, "createUser", pObj->createUser);
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
-    tjsonAddStringToObject(item, "uid", i642str(pObj->uid));
+    (void)tjsonAddStringToObject(item, "uid", i642str(pObj->uid));
-    tjsonAddStringToObject(item, "cfgVersion", i642str(pObj->cfgVersion));
+    (void)tjsonAddStringToObject(item, "cfgVersion", i642str(pObj->cfgVersion));
-    tjsonAddStringToObject(item, "vgVersion", i642str(pObj->vgVersion));
+    (void)tjsonAddStringToObject(item, "vgVersion", i642str(pObj->vgVersion));
-    tjsonAddStringToObject(item, "numOfVgroups", i642str(pObj->cfg.numOfVgroups));
+    (void)tjsonAddStringToObject(item, "numOfVgroups", i642str(pObj->cfg.numOfVgroups));
-    tjsonAddStringToObject(item, "numOfStables", i642str(pObj->cfg.numOfStables));
+    (void)tjsonAddStringToObject(item, "numOfStables", i642str(pObj->cfg.numOfStables));
-    tjsonAddStringToObject(item, "buffer", i642str(pObj->cfg.buffer));
+    (void)tjsonAddStringToObject(item, "buffer", i642str(pObj->cfg.buffer));
-    tjsonAddStringToObject(item, "pageSize", i642str(pObj->cfg.pageSize));
+    (void)tjsonAddStringToObject(item, "pageSize", i642str(pObj->cfg.pageSize));
-    tjsonAddStringToObject(item, "pages", i642str(pObj->cfg.pages));
+    (void)tjsonAddStringToObject(item, "pages", i642str(pObj->cfg.pages));
-    tjsonAddStringToObject(item, "cacheLastSize", i642str(pObj->cfg.cacheLastSize));
+    (void)tjsonAddStringToObject(item, "cacheLastSize", i642str(pObj->cfg.cacheLastSize));
-    tjsonAddStringToObject(item, "daysPerFile", i642str(pObj->cfg.daysPerFile));
+    (void)tjsonAddStringToObject(item, "daysPerFile", i642str(pObj->cfg.daysPerFile));
-    tjsonAddStringToObject(item, "daysToKeep0", i642str(pObj->cfg.daysToKeep0));
+    (void)tjsonAddStringToObject(item, "daysToKeep0", i642str(pObj->cfg.daysToKeep0));
-    tjsonAddStringToObject(item, "daysToKeep1", i642str(pObj->cfg.daysToKeep1));
+    (void)tjsonAddStringToObject(item, "daysToKeep1", i642str(pObj->cfg.daysToKeep1));
-    tjsonAddStringToObject(item, "daysToKeep2", i642str(pObj->cfg.daysToKeep2));
+    (void)tjsonAddStringToObject(item, "daysToKeep2", i642str(pObj->cfg.daysToKeep2));
-    tjsonAddStringToObject(item, "minRows", i642str(pObj->cfg.minRows));
+    (void)tjsonAddStringToObject(item, "minRows", i642str(pObj->cfg.minRows));
-    tjsonAddStringToObject(item, "maxRows", i642str(pObj->cfg.maxRows));
+    (void)tjsonAddStringToObject(item, "maxRows", i642str(pObj->cfg.maxRows));
-    tjsonAddStringToObject(item, "precision", i642str(pObj->cfg.precision));
+    (void)tjsonAddStringToObject(item, "precision", i642str(pObj->cfg.precision));
-    tjsonAddStringToObject(item, "compression", i642str(pObj->cfg.compression));
+    (void)tjsonAddStringToObject(item, "compression", i642str(pObj->cfg.compression));
-    tjsonAddStringToObject(item, "encryptAlgorithm", i642str(pObj->cfg.encryptAlgorithm));
+    (void)tjsonAddStringToObject(item, "encryptAlgorithm", i642str(pObj->cfg.encryptAlgorithm));
-    tjsonAddStringToObject(item, "replications", i642str(pObj->cfg.replications));
+    (void)tjsonAddStringToObject(item, "replications", i642str(pObj->cfg.replications));
-    tjsonAddStringToObject(item, "strict", i642str(pObj->cfg.strict));
+    (void)tjsonAddStringToObject(item, "strict", i642str(pObj->cfg.strict));
-    tjsonAddStringToObject(item, "cacheLast", i642str(pObj->cfg.cacheLast));
+    (void)tjsonAddStringToObject(item, "cacheLast", i642str(pObj->cfg.cacheLast));
-    tjsonAddStringToObject(item, "hashMethod", i642str(pObj->cfg.hashMethod));
+    (void)tjsonAddStringToObject(item, "hashMethod", i642str(pObj->cfg.hashMethod));
-    tjsonAddStringToObject(item, "hashPrefix", i642str(pObj->cfg.hashPrefix));
+    (void)tjsonAddStringToObject(item, "hashPrefix", i642str(pObj->cfg.hashPrefix));
-    tjsonAddStringToObject(item, "hashSuffix", i642str(pObj->cfg.hashSuffix));
+    (void)tjsonAddStringToObject(item, "hashSuffix", i642str(pObj->cfg.hashSuffix));
-    tjsonAddStringToObject(item, "sstTrigger", i642str(pObj->cfg.sstTrigger));
+    (void)tjsonAddStringToObject(item, "sstTrigger", i642str(pObj->cfg.sstTrigger));
-    tjsonAddStringToObject(item, "tsdbPageSize", i642str(pObj->cfg.tsdbPageSize));
+    (void)tjsonAddStringToObject(item, "tsdbPageSize", i642str(pObj->cfg.tsdbPageSize));
-    tjsonAddStringToObject(item, "schemaless", i642str(pObj->cfg.schemaless));
+    (void)tjsonAddStringToObject(item, "schemaless", i642str(pObj->cfg.schemaless));
-    tjsonAddStringToObject(item, "walLevel", i642str(pObj->cfg.walLevel));
+    (void)tjsonAddStringToObject(item, "walLevel", i642str(pObj->cfg.walLevel));
-    tjsonAddStringToObject(item, "walFsyncPeriod", i642str(pObj->cfg.walFsyncPeriod));
+    (void)tjsonAddStringToObject(item, "walFsyncPeriod", i642str(pObj->cfg.walFsyncPeriod));
-    tjsonAddStringToObject(item, "walRetentionPeriod", i642str(pObj->cfg.walRetentionPeriod));
+    (void)tjsonAddStringToObject(item, "walRetentionPeriod", i642str(pObj->cfg.walRetentionPeriod));
-    tjsonAddStringToObject(item, "walRetentionSize", i642str(pObj->cfg.walRetentionSize));
+    (void)tjsonAddStringToObject(item, "walRetentionSize", i642str(pObj->cfg.walRetentionSize));
-    tjsonAddStringToObject(item, "walRollPeriod", i642str(pObj->cfg.walRollPeriod));
+    (void)tjsonAddStringToObject(item, "walRollPeriod", i642str(pObj->cfg.walRollPeriod));
-    tjsonAddStringToObject(item, "walSegmentSize", i642str(pObj->cfg.walSegmentSize));
+    (void)tjsonAddStringToObject(item, "walSegmentSize", i642str(pObj->cfg.walSegmentSize));
 
-    tjsonAddStringToObject(item, "numOfRetensions", i642str(pObj->cfg.numOfRetensions));
+    (void)tjsonAddStringToObject(item, "numOfRetensions", i642str(pObj->cfg.numOfRetensions));
     for (int32_t i = 0; i < pObj->cfg.numOfRetensions; ++i) {
       SJson *rentensions = tjsonAddArrayToObject(item, "rentensions");
       SJson *rentension = tjsonCreateObject();
-      tjsonAddItemToArray(rentensions, rentension);
+      (void)tjsonAddItemToArray(rentensions, rentension);
 
       SRetention *pRetension = taosArrayGet(pObj->cfg.pRetensions, i);
-      tjsonAddStringToObject(item, "freq", i642str(pRetension->freq));
+      (void)tjsonAddStringToObject(item, "freq", i642str(pRetension->freq));
-      tjsonAddStringToObject(item, "freqUnit", i642str(pRetension->freqUnit));
+      (void)tjsonAddStringToObject(item, "freqUnit", i642str(pRetension->freqUnit));
-      tjsonAddStringToObject(item, "keep", i642str(pRetension->keep));
+      (void)tjsonAddStringToObject(item, "keep", i642str(pRetension->keep));
-      tjsonAddStringToObject(item, "keepUnit", i642str(pRetension->keepUnit));
+      (void)tjsonAddStringToObject(item, "keepUnit", i642str(pRetension->keepUnit));
     }
 
     sdbRelease(pSdb, pObj);
@@ -150,55 +150,55 @@ void dumpStb(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
+    (void)tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "name", mndGetStbStr(pObj->name));
+    (void)tjsonAddStringToObject(item, "name", mndGetStbStr(pObj->name));
-    tjsonAddStringToObject(item, "db", mndGetDbStr(pObj->db));
+    (void)tjsonAddStringToObject(item, "db", mndGetDbStr(pObj->db));
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
-    tjsonAddStringToObject(item, "uid", i642str(pObj->uid));
+    (void)tjsonAddStringToObject(item, "uid", i642str(pObj->uid));
-    tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
+    (void)tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
-    tjsonAddStringToObject(item, "tagVer", i642str(pObj->tagVer));
+    (void)tjsonAddStringToObject(item, "tagVer", i642str(pObj->tagVer));
-    tjsonAddStringToObject(item, "colVer", i642str(pObj->colVer));
+    (void)tjsonAddStringToObject(item, "colVer", i642str(pObj->colVer));
-    tjsonAddStringToObject(item, "smaVer", i642str(pObj->smaVer));
+    (void)tjsonAddStringToObject(item, "smaVer", i642str(pObj->smaVer));
-    tjsonAddStringToObject(item, "nextColId", i642str(pObj->nextColId));
+    (void)tjsonAddStringToObject(item, "nextColId", i642str(pObj->nextColId));
-    tjsonAddStringToObject(item, "watermark1", i642str(pObj->watermark[0]));
+    (void)tjsonAddStringToObject(item, "watermark1", i642str(pObj->watermark[0]));
-    tjsonAddStringToObject(item, "watermark2", i642str(pObj->watermark[1]));
+    (void)tjsonAddStringToObject(item, "watermark2", i642str(pObj->watermark[1]));
-    tjsonAddStringToObject(item, "maxdelay0", i642str(pObj->maxdelay[0]));
+    (void)tjsonAddStringToObject(item, "maxdelay0", i642str(pObj->maxdelay[0]));
-    tjsonAddStringToObject(item, "maxdelay1", i642str(pObj->maxdelay[1]));
+    (void)tjsonAddStringToObject(item, "maxdelay1", i642str(pObj->maxdelay[1]));
-    tjsonAddStringToObject(item, "ttl", i642str(pObj->ttl));
+    (void)tjsonAddStringToObject(item, "ttl", i642str(pObj->ttl));
-    tjsonAddStringToObject(item, "numOfFuncs", i642str(pObj->numOfFuncs));
+    (void)tjsonAddStringToObject(item, "numOfFuncs", i642str(pObj->numOfFuncs));
-    tjsonAddStringToObject(item, "commentLen", i642str(pObj->commentLen));
+    (void)tjsonAddStringToObject(item, "commentLen", i642str(pObj->commentLen));
-    tjsonAddStringToObject(item, "ast1Len", i642str(pObj->ast1Len));
+    (void)tjsonAddStringToObject(item, "ast1Len", i642str(pObj->ast1Len));
-    tjsonAddStringToObject(item, "ast2Len", i642str(pObj->ast2Len));
+    (void)tjsonAddStringToObject(item, "ast2Len", i642str(pObj->ast2Len));
 
-    tjsonAddStringToObject(item, "numOfColumns", i642str(pObj->numOfColumns));
+    (void)tjsonAddStringToObject(item, "numOfColumns", i642str(pObj->numOfColumns));
     SJson *columns = tjsonAddArrayToObject(item, "columns");
     for (int32_t i = 0; i < pObj->numOfColumns; ++i) {
       SJson *column = tjsonCreateObject();
-      tjsonAddItemToArray(columns, column);
+      (void)tjsonAddItemToArray(columns, column);
 
       SSchema *pColumn = &pObj->pColumns[i];
-      tjsonAddStringToObject(column, "type", i642str(pColumn->type));
+      (void)tjsonAddStringToObject(column, "type", i642str(pColumn->type));
-      tjsonAddStringToObject(column, "typestr", tDataTypes[pColumn->type].name);
+      (void)tjsonAddStringToObject(column, "typestr", tDataTypes[pColumn->type].name);
-      tjsonAddStringToObject(column, "flags", i642str(pColumn->flags));
+      (void)tjsonAddStringToObject(column, "flags", i642str(pColumn->flags));
-      tjsonAddStringToObject(column, "colId", i642str(pColumn->colId));
+      (void)tjsonAddStringToObject(column, "colId", i642str(pColumn->colId));
-      tjsonAddStringToObject(column, "bytes", i642str(pColumn->bytes));
+      (void)tjsonAddStringToObject(column, "bytes", i642str(pColumn->bytes));
-      tjsonAddStringToObject(column, "name", pColumn->name);
+      (void)tjsonAddStringToObject(column, "name", pColumn->name);
     }
 
-    tjsonAddStringToObject(item, "numOfTags", i642str(pObj->numOfTags));
+    (void)tjsonAddStringToObject(item, "numOfTags", i642str(pObj->numOfTags));
     SJson *tags = tjsonAddArrayToObject(item, "tags");
     for (int32_t i = 0; i < pObj->numOfTags; ++i) {
       SJson *tag = tjsonCreateObject();
-      tjsonAddItemToArray(tags, tag);
+      (void)tjsonAddItemToArray(tags, tag);
 
       SSchema *pTag = &pObj->pTags[i];
-      tjsonAddStringToObject(tag, "type", i642str(pTag->type));
+      (void)tjsonAddStringToObject(tag, "type", i642str(pTag->type));
-      tjsonAddStringToObject(tag, "typestr", tDataTypes[pTag->type].name);
+      (void)tjsonAddStringToObject(tag, "typestr", tDataTypes[pTag->type].name);
-      tjsonAddStringToObject(tag, "flags", i642str(pTag->flags));
+      (void)tjsonAddStringToObject(tag, "flags", i642str(pTag->flags));
-      tjsonAddStringToObject(tag, "colId", i642str(pTag->colId));
+      (void)tjsonAddStringToObject(tag, "colId", i642str(pTag->colId));
-      tjsonAddStringToObject(tag, "bytes", i642str(pTag->bytes));
+      (void)tjsonAddStringToObject(tag, "bytes", i642str(pTag->bytes));
-      tjsonAddStringToObject(tag, "name", pTag->name);
+      (void)tjsonAddStringToObject(tag, "name", pTag->name);
     }
 
     sdbRelease(pSdb, pObj);
@@ -215,27 +215,27 @@ void dumpSma(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
+    (void)tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "name", mndGetStbStr(pObj->name));
+    (void)tjsonAddStringToObject(item, "name", mndGetStbStr(pObj->name));
-    tjsonAddStringToObject(item, "stb", mndGetStbStr(pObj->stb));
+    (void)tjsonAddStringToObject(item, "stb", mndGetStbStr(pObj->stb));
-    tjsonAddStringToObject(item, "db", mndGetDbStr(pObj->db));
+    (void)tjsonAddStringToObject(item, "db", mndGetDbStr(pObj->db));
-    tjsonAddStringToObject(item, "dstTbName", mndGetStbStr(pObj->dstTbName));
+    (void)tjsonAddStringToObject(item, "dstTbName", mndGetStbStr(pObj->dstTbName));
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "uid", i642str(pObj->uid));
+    (void)tjsonAddStringToObject(item, "uid", i642str(pObj->uid));
-    tjsonAddStringToObject(item, "stbUid", i642str(pObj->stbUid));
+    (void)tjsonAddStringToObject(item, "stbUid", i642str(pObj->stbUid));
-    tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
+    (void)tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
-    tjsonAddStringToObject(item, "dstTbUid", i642str(pObj->dstTbUid));
+    (void)tjsonAddStringToObject(item, "dstTbUid", i642str(pObj->dstTbUid));
-    tjsonAddStringToObject(item, "intervalUnit", i642str(pObj->intervalUnit));
+    (void)tjsonAddStringToObject(item, "intervalUnit", i642str(pObj->intervalUnit));
-    tjsonAddStringToObject(item, "slidingUnit", i642str(pObj->slidingUnit));
+    (void)tjsonAddStringToObject(item, "slidingUnit", i642str(pObj->slidingUnit));
-    tjsonAddStringToObject(item, "timezone", i642str(pObj->timezone));
+    (void)tjsonAddStringToObject(item, "timezone", i642str(pObj->timezone));
-    tjsonAddStringToObject(item, "dstVgId", i642str(pObj->dstVgId));
+    (void)tjsonAddStringToObject(item, "dstVgId", i642str(pObj->dstVgId));
-    tjsonAddStringToObject(item, "interval", i642str(pObj->interval));
+    (void)tjsonAddStringToObject(item, "interval", i642str(pObj->interval));
-    tjsonAddStringToObject(item, "offset", i642str(pObj->offset));
+    (void)tjsonAddStringToObject(item, "offset", i642str(pObj->offset));
-    tjsonAddStringToObject(item, "sliding", i642str(pObj->sliding));
+    (void)tjsonAddStringToObject(item, "sliding", i642str(pObj->sliding));
-    tjsonAddStringToObject(item, "exprLen", i642str(pObj->exprLen));
+    (void)tjsonAddStringToObject(item, "exprLen", i642str(pObj->exprLen));
-    tjsonAddStringToObject(item, "tagsFilterLen", i642str(pObj->tagsFilterLen));
+    (void)tjsonAddStringToObject(item, "tagsFilterLen", i642str(pObj->tagsFilterLen));
-    tjsonAddStringToObject(item, "sqlLen", i642str(pObj->sqlLen));
+    (void)tjsonAddStringToObject(item, "sqlLen", i642str(pObj->sqlLen));
-    tjsonAddStringToObject(item, "astLen", i642str(pObj->astLen));
+    (void)tjsonAddStringToObject(item, "astLen", i642str(pObj->astLen));
     sdbRelease(pSdb, pObj);
   }
 }
@@ -250,22 +250,22 @@ void dumpVgroup(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
+    (void)tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "vgId", i642str(pObj->vgId));
+    (void)tjsonAddStringToObject(item, "vgId", i642str(pObj->vgId));
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
-    tjsonAddStringToObject(item, "version", i642str(pObj->version));
+    (void)tjsonAddStringToObject(item, "version", i642str(pObj->version));
-    tjsonAddStringToObject(item, "hashBegin", i642str(pObj->hashBegin));
+    (void)tjsonAddStringToObject(item, "hashBegin", i642str(pObj->hashBegin));
-    tjsonAddStringToObject(item, "hashEnd", i642str(pObj->hashEnd));
+    (void)tjsonAddStringToObject(item, "hashEnd", i642str(pObj->hashEnd));
-    tjsonAddStringToObject(item, "db", mndGetDbStr(pObj->dbName));
+    (void)tjsonAddStringToObject(item, "db", mndGetDbStr(pObj->dbName));
-    tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
+    (void)tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
-    tjsonAddStringToObject(item, "isTsma", i642str(pObj->isTsma));
+    (void)tjsonAddStringToObject(item, "isTsma", i642str(pObj->isTsma));
-    tjsonAddStringToObject(item, "replica", i642str(pObj->replica));
+    (void)tjsonAddStringToObject(item, "replica", i642str(pObj->replica));
     for (int32_t i = 0; i < pObj->replica; ++i) {
       SJson *replicas = tjsonAddArrayToObject(item, "replicas");
       SJson *replica = tjsonCreateObject();
-      tjsonAddItemToArray(replicas, replica);
+      (void)tjsonAddItemToArray(replicas, replica);
-      tjsonAddStringToObject(replica, "dnodeId", i642str(pObj->vnodeGid[i].dnodeId));
+      (void)tjsonAddStringToObject(replica, "dnodeId", i642str(pObj->vnodeGid[i].dnodeId));
     }
     sdbRelease(pSdb, pObj);
   }
@@ -281,23 +281,23 @@ void dumpTopic(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
+    (void)tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "name", mndGetDbStr(pObj->name));
+    (void)tjsonAddStringToObject(item, "name", mndGetDbStr(pObj->name));
-    tjsonAddStringToObject(item, "name", mndGetDbStr(pObj->db));
+    (void)tjsonAddStringToObject(item, "name", mndGetDbStr(pObj->db));
-    tjsonAddStringToObject(item, "createTime", i642str(pObj->createTime));
+    (void)tjsonAddStringToObject(item, "createTime", i642str(pObj->createTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
-    tjsonAddStringToObject(item, "uid", i642str(pObj->uid));
+    (void)tjsonAddStringToObject(item, "uid", i642str(pObj->uid));
-    tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
+    (void)tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
-    tjsonAddStringToObject(item, "version", i642str(pObj->version));
+    (void)tjsonAddStringToObject(item, "version", i642str(pObj->version));
-    tjsonAddStringToObject(item, "subType", i642str(pObj->subType));
+    (void)tjsonAddStringToObject(item, "subType", i642str(pObj->subType));
-    tjsonAddStringToObject(item, "withMeta", i642str(pObj->withMeta));
+    (void)tjsonAddStringToObject(item, "withMeta", i642str(pObj->withMeta));
-    tjsonAddStringToObject(item, "stbUid", i642str(pObj->stbUid));
+    (void)tjsonAddStringToObject(item, "stbUid", i642str(pObj->stbUid));
-    tjsonAddStringToObject(item, "stbName", mndGetStableStr(pObj->stbName));
+    (void)tjsonAddStringToObject(item, "stbName", mndGetStableStr(pObj->stbName));
-    tjsonAddStringToObject(item, "sqlLen", i642str(pObj->sqlLen));
+    (void)tjsonAddStringToObject(item, "sqlLen", i642str(pObj->sqlLen));
-    tjsonAddStringToObject(item, "astLen", i642str(pObj->astLen));
+    (void)tjsonAddStringToObject(item, "astLen", i642str(pObj->astLen));
-    tjsonAddStringToObject(item, "sqlLen", i642str(pObj->sqlLen));
+    (void)tjsonAddStringToObject(item, "sqlLen", i642str(pObj->sqlLen));
-    tjsonAddStringToObject(item, "ntbUid", i642str(pObj->ntbUid));
+    (void)tjsonAddStringToObject(item, "ntbUid", i642str(pObj->ntbUid));
-    tjsonAddStringToObject(item, "ctbStbUid", i642str(pObj->ctbStbUid));
+    (void)tjsonAddStringToObject(item, "ctbStbUid", i642str(pObj->ctbStbUid));
     sdbRelease(pSdb, pObj);
   }
 }
@@ -312,9 +312,9 @@ void dumpConsumer(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
+    (void)tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "consumerId", i642str(pObj->consumerId));
+    (void)tjsonAddStringToObject(item, "consumerId", i642str(pObj->consumerId));
-    tjsonAddStringToObject(item, "cgroup", pObj->cgroup);
+    (void)tjsonAddStringToObject(item, "cgroup", pObj->cgroup);
     sdbRelease(pSdb, pObj);
   }
 }
@@ -329,10 +329,10 @@ void dumpSubscribe(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
+    (void)tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "key", pObj->key);
+    (void)tjsonAddStringToObject(item, "key", pObj->key);
-    tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
+    (void)tjsonAddStringToObject(item, "dbUid", i642str(pObj->dbUid));
-    tjsonAddStringToObject(item, "stbUid", i642str(pObj->stbUid));
+    (void)tjsonAddStringToObject(item, "stbUid", i642str(pObj->stbUid));
     sdbRelease(pSdb, pObj);
   }
 }
@@ -347,26 +347,26 @@ void dumpStream(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
+    (void)tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "name", mndGetDbStr(pObj->name));
+    (void)tjsonAddStringToObject(item, "name", mndGetDbStr(pObj->name));
-    tjsonAddStringToObject(item, "createTime", i642str(pObj->createTime));
+    (void)tjsonAddStringToObject(item, "createTime", i642str(pObj->createTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
-    tjsonAddStringToObject(item, "version", i642str(pObj->version));
+    (void)tjsonAddStringToObject(item, "version", i642str(pObj->version));
-    tjsonAddStringToObject(item, "totalLevel", i642str(pObj->totalLevel));
+    (void)tjsonAddStringToObject(item, "totalLevel", i642str(pObj->totalLevel));
-    tjsonAddStringToObject(item, "smaId", i642str(pObj->smaId));
+    (void)tjsonAddStringToObject(item, "smaId", i642str(pObj->smaId));
-    tjsonAddStringToObject(item, "uid", i642str(pObj->uid));
+    (void)tjsonAddStringToObject(item, "uid", i642str(pObj->uid));
-    tjsonAddStringToObject(item, "status", i642str(pObj->status));
+    (void)tjsonAddStringToObject(item, "status", i642str(pObj->status));
-    tjsonAddStringToObject(item, "igExpired", i642str(pObj->conf.igExpired));
+    (void)tjsonAddStringToObject(item, "igExpired", i642str(pObj->conf.igExpired));
-    tjsonAddStringToObject(item, "trigger", i642str(pObj->conf.trigger));
+    (void)tjsonAddStringToObject(item, "trigger", i642str(pObj->conf.trigger));
-    tjsonAddStringToObject(item, "triggerParam", i642str(pObj->conf.triggerParam));
+    (void)tjsonAddStringToObject(item, "triggerParam", i642str(pObj->conf.triggerParam));
-    tjsonAddStringToObject(item, "watermark", i642str(pObj->conf.watermark));
+    (void)tjsonAddStringToObject(item, "watermark", i642str(pObj->conf.watermark));
-    tjsonAddStringToObject(item, "sourceDbUid", i642str(pObj->sourceDbUid));
+    (void)tjsonAddStringToObject(item, "sourceDbUid", i642str(pObj->sourceDbUid));
-    tjsonAddStringToObject(item, "targetDbUid", i642str(pObj->targetDbUid));
+    (void)tjsonAddStringToObject(item, "targetDbUid", i642str(pObj->targetDbUid));
-    tjsonAddStringToObject(item, "sourceDb", mndGetDbStr(pObj->sourceDb));
+    (void)tjsonAddStringToObject(item, "sourceDb", mndGetDbStr(pObj->sourceDb));
-    tjsonAddStringToObject(item, "targetDb", mndGetDbStr(pObj->targetDb));
+    (void)tjsonAddStringToObject(item, "targetDb", mndGetDbStr(pObj->targetDb));
-    tjsonAddStringToObject(item, "targetSTbName", mndGetStbStr(pObj->targetSTbName));
+    (void)tjsonAddStringToObject(item, "targetSTbName", mndGetStbStr(pObj->targetSTbName));
-    tjsonAddStringToObject(item, "targetStbUid", i642str(pObj->targetStbUid));
+    (void)tjsonAddStringToObject(item, "targetStbUid", i642str(pObj->targetStbUid));
-    tjsonAddStringToObject(item, "fixedSinkVgId", i642str(pObj->fixedSinkVgId));
+    (void)tjsonAddStringToObject(item, "fixedSinkVgId", i642str(pObj->fixedSinkVgId));
     sdbRelease(pSdb, pObj);
   }
 }
@@ -381,11 +381,11 @@ void dumpAcct(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
+    (void)tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "acct", pObj->acct);
+    (void)tjsonAddStringToObject(item, "acct", pObj->acct);
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
-    tjsonAddStringToObject(item, "acctId", i642str(pObj->acctId));
+    (void)tjsonAddStringToObject(item, "acctId", i642str(pObj->acctId));
     sdbRelease(pSdb, pObj);
   }
 }
@@ -404,16 +404,16 @@ void dumpUser(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
+    (void)tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "name", pObj->user);
+    (void)tjsonAddStringToObject(item, "name", pObj->user);
-    tjsonAddStringToObject(item, "acct", pObj->acct);
+    (void)tjsonAddStringToObject(item, "acct", pObj->acct);
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
-    tjsonAddStringToObject(item, "superUser", i642str(pObj->superUser));
+    (void)tjsonAddStringToObject(item, "superUser", i642str(pObj->superUser));
-    tjsonAddStringToObject(item, "authVersion", i642str(pObj->authVersion));
+    (void)tjsonAddStringToObject(item, "authVersion", i642str(pObj->authVersion));
-    tjsonAddStringToObject(item, "passVersion", i642str(pObj->passVersion));
+    (void)tjsonAddStringToObject(item, "passVersion", i642str(pObj->passVersion));
-    tjsonAddStringToObject(item, "numOfReadDbs", i642str(taosHashGetSize(pObj->readDbs)));
+    (void)tjsonAddStringToObject(item, "numOfReadDbs", i642str(taosHashGetSize(pObj->readDbs)));
-    tjsonAddStringToObject(item, "numOfWriteDbs", i642str(taosHashGetSize(pObj->writeDbs)));
+    (void)tjsonAddStringToObject(item, "numOfWriteDbs", i642str(taosHashGetSize(pObj->writeDbs)));
     sdbRelease(pSdb, pObj);
   }
 }
@@ -428,12 +428,12 @@ void dumpDnode(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
+    (void)tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "id", i642str(pObj->id));
+    (void)tjsonAddStringToObject(item, "id", i642str(pObj->id));
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
-    tjsonAddStringToObject(item, "port", i642str(pObj->port));
+    (void)tjsonAddStringToObject(item, "port", i642str(pObj->port));
-    tjsonAddStringToObject(item, "fqdn", pObj->fqdn);
+    (void)tjsonAddStringToObject(item, "fqdn", pObj->fqdn);
     sdbRelease(pSdb, pObj);
   }
 }
@@ -448,10 +448,10 @@ void dumpSnode(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
+    (void)tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "id", i642str(pObj->id));
+    (void)tjsonAddStringToObject(item, "id", i642str(pObj->id));
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
     sdbRelease(pSdb, pObj);
   }
 }
@@ -466,10 +466,10 @@ void dumpQnode(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
+    (void)tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "id", i642str(pObj->id));
+    (void)tjsonAddStringToObject(item, "id", i642str(pObj->id));
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
     sdbRelease(pSdb, pObj);
   }
 }
@@ -484,10 +484,10 @@ void dumpMnode(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
+    (void)tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "id", i642str(pObj->id));
+    (void)tjsonAddStringToObject(item, "id", i642str(pObj->id));
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
     sdbRelease(pSdb, pObj);
   }
 }
@@ -502,11 +502,11 @@ void dumpCluster(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
+    (void)tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "id", i642str(pObj->id));
+    (void)tjsonAddStringToObject(item, "id", i642str(pObj->id));
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
+    (void)tjsonAddStringToObject(item, "updateTime", i642str(pObj->updateTime));
-    tjsonAddStringToObject(item, "name", pObj->name);
+    (void)tjsonAddStringToObject(item, "name", pObj->name);
     sdbRelease(pSdb, pObj);
   }
 }
@@ -521,29 +521,29 @@ void dumpTrans(SSdb *pSdb, SJson *json) {
     if (pIter == NULL) break;
 
     SJson *item = tjsonCreateObject();
-    tjsonAddItemToArray(items, item);
+    (void)tjsonAddItemToArray(items, item);
-    tjsonAddStringToObject(item, "id", i642str(pObj->id));
+    (void)tjsonAddStringToObject(item, "id", i642str(pObj->id));
-    tjsonAddStringToObject(item, "stage", i642str(pObj->stage));
+    (void)tjsonAddStringToObject(item, "stage", i642str(pObj->stage));
-    tjsonAddStringToObject(item, "policy", i642str(pObj->policy));
+    (void)tjsonAddStringToObject(item, "policy", i642str(pObj->policy));
-    tjsonAddStringToObject(item, "conflict", i642str(pObj->conflict));
+    (void)tjsonAddStringToObject(item, "conflict", i642str(pObj->conflict));
-    tjsonAddStringToObject(item, "exec", i642str(pObj->exec));
+    (void)tjsonAddStringToObject(item, "exec", i642str(pObj->exec));
-    tjsonAddStringToObject(item, "oper", i642str(pObj->oper));
+    (void)tjsonAddStringToObject(item, "oper", i642str(pObj->oper));
-    tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
+    (void)tjsonAddStringToObject(item, "createdTime", i642str(pObj->createdTime));
-    tjsonAddStringToObject(item, "dbname", pObj->dbname);
+    (void)tjsonAddStringToObject(item, "dbname", pObj->dbname);
-    tjsonAddStringToObject(item, "stbname", pObj->stbname);
+    (void)tjsonAddStringToObject(item, "stbname", pObj->stbname);
-    tjsonAddStringToObject(item, "opername", pObj->opername);
+    (void)tjsonAddStringToObject(item, "opername", pObj->opername);
-    tjsonAddStringToObject(item, "commitLogNum", i642str(taosArrayGetSize(pObj->commitActions)));
+    (void)tjsonAddStringToObject(item, "commitLogNum", i642str(taosArrayGetSize(pObj->commitActions)));
-    tjsonAddStringToObject(item, "redoActionNum", i642str(taosArrayGetSize(pObj->redoActions)));
+    (void)tjsonAddStringToObject(item, "redoActionNum", i642str(taosArrayGetSize(pObj->redoActions)));
-    tjsonAddStringToObject(item, "undoActionNum", i642str(taosArrayGetSize(pObj->undoActions)));
+    (void)tjsonAddStringToObject(item, "undoActionNum", i642str(taosArrayGetSize(pObj->undoActions)));
     sdbRelease(pSdb, pObj);
   }
 }
 
 void dumpHeader(SSdb *pSdb, SJson *json) {
-  tjsonAddStringToObject(json, "sver", i642str(1));
+  (void)tjsonAddStringToObject(json, "sver", i642str(1));
-  tjsonAddStringToObject(json, "applyIndex", i642str(pSdb->applyIndex));
+  (void)tjsonAddStringToObject(json, "applyIndex", i642str(pSdb->applyIndex));
-  tjsonAddStringToObject(json, "applyTerm", i642str(pSdb->applyTerm));
+  (void)tjsonAddStringToObject(json, "applyTerm", i642str(pSdb->applyTerm));
-  tjsonAddStringToObject(json, "applyConfig", i642str(pSdb->applyConfig));
+  (void)tjsonAddStringToObject(json, "applyConfig", i642str(pSdb->applyConfig));
 
   SJson *maxIdsJson = tjsonCreateObject();
   tjsonAddItemToObject(json, "maxIds", maxIdsJson);
@@ -553,7 +553,7 @@ void dumpHeader(SSdb *pSdb, SJson *json) {
     if (i < SDB_MAX) {
       maxId = pSdb->maxId[i];
     }
-    tjsonAddStringToObject(maxIdsJson, sdbTableName(i), i642str(maxId));
+    (void)tjsonAddStringToObject(maxIdsJson, sdbTableName(i), i642str(maxId));
   }
 
   SJson *tableVersJson = tjsonCreateObject();
@@ -563,7 +563,7 @@ void dumpHeader(SSdb *pSdb, SJson *json) {
     if (i < SDB_MAX) {
       tableVer = pSdb->tableVer[i];
     }
-    tjsonAddStringToObject(tableVersJson, sdbTableName(i), i642str(tableVer));
+    (void)tjsonAddStringToObject(tableVersJson, sdbTableName(i), i642str(tableVer));
   }
 }
 
@@ -571,7 +571,7 @@ void mndDumpSdb() {
   mInfo("start to dump sdb info to sdb.json");
 
   char path[PATH_MAX * 2] = {0};
-  snprintf(path, sizeof(path), "%s%smnode", tsDataDir, TD_DIRSEP);
+  (void)snprintf(path, sizeof(path), "%s%smnode", tsDataDir, TD_DIRSEP);
 
   SMsgCb msgCb = {0};
   msgCb.reportStartupFp = reportStartup;

source/dnode/mnode/impl/src/mndFunc.c

@@ -61,6 +61,8 @@ int32_t mndInitFunc(SMnode *pMnode) {
 void mndCleanupFunc(SMnode *pMnode) {}
 
 static SSdbRaw *mndFuncActionEncode(SFuncObj *pFunc) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   int32_t  size = pFunc->commentSize + pFunc->codeSize + sizeof(SFuncObj) + SDB_FUNC_RESERVE_SIZE;
@@ -101,6 +103,8 @@ _OVER:
 }
 
 static SSdbRow *mndFuncActionDecode(SSdbRaw *pRaw) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
   SSdbRow  *pRow = NULL;
   SFuncObj *pFunc = NULL;
@@ -201,7 +205,7 @@ static int32_t mndFuncActionUpdate(SSdb *pSdb, SFuncObj *pOld, SFuncObj *pNew) {
   if (pNew->commentSize > 0 && pNew->pComment != NULL) {
     pOld->commentSize = pNew->commentSize;
     pOld->pComment = taosMemoryMalloc(pOld->commentSize);
-    memcpy(pOld->pComment, pNew->pComment, pOld->commentSize);
+    (void)memcpy(pOld->pComment, pNew->pComment, pOld->commentSize);
   }
 
   if (pOld->pCode != NULL) {
@@ -211,7 +215,7 @@ static int32_t mndFuncActionUpdate(SSdb *pSdb, SFuncObj *pOld, SFuncObj *pNew) {
   if (pNew->codeSize > 0 && pNew->pCode != NULL) {
     pOld->codeSize = pNew->codeSize;
     pOld->pCode = taosMemoryMalloc(pOld->codeSize);
-    memcpy(pOld->pCode, pNew->pCode, pOld->codeSize);
+    (void)memcpy(pOld->pCode, pNew->pCode, pOld->codeSize);
   }
 
   pOld->scriptType = pNew->scriptType;
@@ -246,7 +250,7 @@ static int32_t mndCreateFunc(SMnode *pMnode, SRpcMsg *pReq, SCreateFuncReq *pCre
   }
 
   SFuncObj func = {0};
-  memcpy(func.name, pCreate->name, TSDB_FUNC_NAME_LEN);
+  (void)memcpy(func.name, pCreate->name, TSDB_FUNC_NAME_LEN);
   func.createdTime = taosGetTimestampMs();
   func.funcType = pCreate->funcType;
   func.scriptType = pCreate->scriptType;
@@ -266,9 +270,9 @@ static int32_t mndCreateFunc(SMnode *pMnode, SRpcMsg *pReq, SCreateFuncReq *pCre
   }
 
   if (func.commentSize > 0) {
-    memcpy(func.pComment, pCreate->pComment, func.commentSize);
+    (void)memcpy(func.pComment, pCreate->pComment, func.commentSize);
   }
-  memcpy(func.pCode, pCreate->pCode, func.codeSize);
+  (void)memcpy(func.pCode, pCreate->pCode, func.codeSize);
 
   pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_NOTHING, pReq, "create-func");
   if (pTrans == NULL) {
@@ -544,7 +548,7 @@ static int32_t mndProcessRetrieveFuncReq(SRpcMsg *pReq) {
     }
 
     SFuncInfo funcInfo = {0};
-    memcpy(funcInfo.name, pFunc->name, TSDB_FUNC_NAME_LEN);
+    (void)memcpy(funcInfo.name, pFunc->name, TSDB_FUNC_NAME_LEN);
     funcInfo.funcType = pFunc->funcType;
     funcInfo.scriptType = pFunc->scriptType;
     funcInfo.outputType = pFunc->outputType;
@@ -562,21 +566,27 @@ static int32_t mndProcessRetrieveFuncReq(SRpcMsg *pReq) {
         terrno = TSDB_CODE_OUT_OF_MEMORY;
         goto RETRIEVE_FUNC_OVER;
       }
-      memcpy(funcInfo.pCode, pFunc->pCode, pFunc->codeSize);
+      (void)memcpy(funcInfo.pCode, pFunc->pCode, pFunc->codeSize);
       if (funcInfo.commentSize > 0) {
         funcInfo.pComment = taosMemoryCalloc(1, funcInfo.commentSize);
         if (funcInfo.pComment == NULL) {
           terrno = TSDB_CODE_OUT_OF_MEMORY;
           goto RETRIEVE_FUNC_OVER;
         }
-        memcpy(funcInfo.pComment, pFunc->pComment, pFunc->commentSize);
+        (void)memcpy(funcInfo.pComment, pFunc->pComment, pFunc->commentSize);
       }
     }
-    taosArrayPush(retrieveRsp.pFuncInfos, &funcInfo);
+    if (taosArrayPush(retrieveRsp.pFuncInfos, &funcInfo) == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      goto RETRIEVE_FUNC_OVER;
+    }
     SFuncExtraInfo extraInfo = {0};
     extraInfo.funcVersion = pFunc->funcVersion;
     extraInfo.funcCreatedTime = pFunc->createdTime;
-    taosArrayPush(retrieveRsp.pFuncExtraInfos, &extraInfo);
+    if (taosArrayPush(retrieveRsp.pFuncExtraInfos, &extraInfo) == NULL) {
+      terrno = TSDB_CODE_OUT_OF_MEMORY;
+      goto RETRIEVE_FUNC_OVER;
+    }
 
     mndReleaseFunc(pMnode, pFunc);
   }
@@ -612,7 +622,7 @@ static void *mnodeGenTypeStr(char *buf, int32_t buflen, uint8_t type, int32_t le
       type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_GEOMETRY) {
     int32_t bytes = len > 0 ? (int32_t)(len - VARSTR_HEADER_SIZE) : len;
 
-    snprintf(buf, buflen - 1, "%s(%d)", tDataTypes[type].name, type == TSDB_DATA_TYPE_NCHAR ? bytes / 4 : bytes);
+    (void)snprintf(buf, buflen - 1, "%s(%d)", tDataTypes[type].name, type == TSDB_DATA_TYPE_NCHAR ? bytes / 4 : bytes);
     buf[buflen - 1] = 0;
 
     return buf;
@@ -639,40 +649,40 @@ static int32_t mndRetrieveFuncs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
     STR_WITH_MAXSIZE_TO_VARSTR(b1, pFunc->name, pShow->pMeta->pSchemas[cols].bytes);
 
     SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)b1, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)b1, false);
 
     if (pFunc->pComment) {
       char *b2 = taosMemoryCalloc(1, pShow->pMeta->pSchemas[cols].bytes);
       STR_WITH_MAXSIZE_TO_VARSTR(b2, pFunc->pComment, pShow->pMeta->pSchemas[cols].bytes);
 
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, (const char *)b2, false);
+      (void)colDataSetVal(pColInfo, numOfRows, (const char *)b2, false);
       taosMemoryFree(b2);
     } else {
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-      colDataSetVal(pColInfo, numOfRows, NULL, true);
+      (void)colDataSetVal(pColInfo, numOfRows, NULL, true);
     }
 
     int32_t isAgg = (pFunc->funcType == TSDB_FUNC_TYPE_AGGREGATE) ? 1 : 0;
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&isAgg, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&isAgg, false);
 
     char b3[TSDB_TYPE_STR_MAX_LEN + 1] = {0};
     STR_WITH_MAXSIZE_TO_VARSTR(b3, mnodeGenTypeStr(buf, TSDB_TYPE_STR_MAX_LEN, pFunc->outputType, pFunc->outputLen),
                                pShow->pMeta->pSchemas[cols].bytes);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)b3, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)b3, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pFunc->createdTime, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pFunc->createdTime, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pFunc->codeSize, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pFunc->codeSize, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pFunc->bufSize, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pFunc->bufSize, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     char *language = "";
@@ -684,20 +694,20 @@ static int32_t mndRetrieveFuncs(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
     char varLang[TSDB_TYPE_STR_MAX_LEN + 1] = {0};
     varDataSetLen(varLang, strlen(language));
     strcpy(varDataVal(varLang), language);
-    colDataSetVal(pColInfo, numOfRows, (const char *)varLang, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)varLang, false);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     int32_t varCodeLen = (pFunc->codeSize + VARSTR_HEADER_SIZE) > TSDB_MAX_BINARY_LEN
                              ? TSDB_MAX_BINARY_LEN
                              : pFunc->codeSize + VARSTR_HEADER_SIZE;
     char   *b4 = taosMemoryMalloc(varCodeLen);
-    memcpy(varDataVal(b4), pFunc->pCode, varCodeLen - VARSTR_HEADER_SIZE);
+    (void)memcpy(varDataVal(b4), pFunc->pCode, varCodeLen - VARSTR_HEADER_SIZE);
     varDataSetLen(b4, varCodeLen - VARSTR_HEADER_SIZE);
-    colDataSetVal(pColInfo, numOfRows, (const char *)b4, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)b4, false);
     taosMemoryFree(b4);
 
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pFunc->funcVersion, false);
+    (void)colDataSetVal(pColInfo, numOfRows, (const char *)&pFunc->funcVersion, false);
 
     numOfRows++;
     sdbRelease(pSdb, pFunc);

source/dnode/mnode/impl/src/mndGrant.c

@@ -25,12 +25,16 @@
     pColInfo = taosArrayGet(pBlock->pDataBlock, cols); \
     src = (display);                                   \
     STR_WITH_MAXSIZE_TO_VARSTR(tmp, src, 32);          \
-    colDataSetVal(pColInfo, numOfRows, tmp, false);    \
+    COL_DATA_SET_VAL_GOTO(tmp, false, NULL, _exit);    \
   } while (0)
 
 static int32_t mndRetrieveGrant(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
+  SMnode *pMnode = pReq->info.node;
+  SSdb   *pSdb = pMnode->pSdb;
   int32_t numOfRows = 0;
   int32_t cols = 0;
+  int32_t code = 0;
+  int32_t lino = 0;
   char    tmp[32];
 
   if (pShow->numOfRows < 1) {
@@ -38,7 +42,7 @@ static int32_t mndRetrieveGrant(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
     SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols);
     const char      *src = TD_PRODUCT_NAME;
     STR_WITH_MAXSIZE_TO_VARSTR(tmp, src, 32);
-    colDataSetVal(pColInfo, numOfRows, tmp, false);
+    COL_DATA_SET_VAL_GOTO(tmp, false, NULL, _exit);
 
     GRANT_ITEM_SHOW("unlimited");
     GRANT_ITEM_SHOW("limited");
@@ -52,6 +56,11 @@ static int32_t mndRetrieveGrant(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl
   }
 
   pShow->numOfRows += numOfRows;
+_exit:
+  if (code != 0) {
+    mError("failed to retrieve grant at line %d since %s", lino, tstrerror(code));
+    TAOS_RETURN(code);
+  }
   return numOfRows;
 }
 
@@ -78,7 +87,10 @@ void    grantReset(SMnode *pMnode, EGrantType grant, uint64_t value) {}
 void    grantAdd(EGrantType grant, uint64_t value) {}
 void    grantRestore(EGrantType grant, uint64_t value) {}
 int64_t grantRemain(EGrantType grant) { return 0; }
-char   *tGetMachineId() { return NULL; };
+int32_t tGetMachineId(char **result) {
+  *result = NULL;
+  return TSDB_CODE_APP_ERROR;
+}
 int32_t dmProcessGrantReq(void *pInfo, SRpcMsg *pMsg) { return TSDB_CODE_SUCCESS; }
 int32_t dmProcessGrantNotify(void *pInfo, SRpcMsg *pMsg) { return TSDB_CODE_SUCCESS; }
 int32_t mndProcessConfigGrantReq(SMnode *pMnode, SRpcMsg *pReq, SMCfgClusterReq *pCfg) { return 0; }

source/dnode/mnode/impl/src/mndIndex.c

@@ -213,6 +213,8 @@ void mndCleanupIdx(SMnode *pMnode) {
 }
 
 static SSdbRaw *mndIdxActionEncode(SIdxObj *pIdx) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   // int32_t size =
@@ -250,6 +252,8 @@ _OVER:
 }
 
 static SSdbRow *mndIdxActionDecode(SSdbRaw *pRaw) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
   SSdbRow *pRow = NULL;
   SIdxObj *pIdx = NULL;

source/dnode/mnode/impl/src/mndMnode.c

@@ -127,6 +127,8 @@ static int32_t mndCreateDefaultMnode(SMnode *pMnode) {
 }
 
 static SSdbRaw *mndMnodeActionEncode(SMnodeObj *pObj) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   SSdbRaw *pRaw = sdbAllocRaw(SDB_MNODE, MNODE_VER_NUMBER, sizeof(SMnodeObj) + MNODE_RESERVE_SIZE);
@@ -154,6 +156,8 @@ _OVER:
 }
 
 static SSdbRow *mndMnodeActionDecode(SSdbRaw *pRaw) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
   SSdbRow   *pRow = NULL;
   SMnodeObj *pObj = NULL;

source/dnode/mnode/impl/src/mndProfile.c

@@ -229,32 +229,29 @@ static int32_t mndProcessConnectReq(SRpcMsg *pReq) {
   SUserObj       *pUser = NULL;
   SDbObj         *pDb = NULL;
   SConnObj       *pConn = NULL;
-  int32_t         code = -1;
+  int32_t         code = 0;
   SConnectReq     connReq = {0};
   char            ip[24] = {0};
   const STraceId *trace = &pReq->info.traceId;
 
   if ((code = tDeserializeSConnectReq(pReq->pCont, pReq->contLen, &connReq)) != 0) {
-    terrno = (-1 == code ? TSDB_CODE_INVALID_MSG : code);
     goto _OVER;
   }
 
   if ((code = taosCheckVersionCompatibleFromStr(connReq.sVer, version, 3)) != 0) {
     mGError("version not compatible. client version: %s, server version: %s", connReq.sVer, version);
-    terrno = code;
     goto _OVER;
   }
 
-  code = -1;
   taosIp2String(pReq->info.conn.clientIp, ip);
-  if (mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CONNECT) != 0) {
+  if ((code = mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CONNECT)) != 0) {
-    mGError("user:%s, failed to login from %s since %s", pReq->info.conn.user, ip, terrstr());
+    mGError("user:%s, failed to login from %s since %s", pReq->info.conn.user, ip, tstrerror(code));
     goto _OVER;
   }
 
-  pUser = mndAcquireUser(pMnode, pReq->info.conn.user);
+  code = mndAcquireUser(pMnode, pReq->info.conn.user, &pUser);
   if (pUser == NULL) {
-    mGError("user:%s, failed to login from %s while acquire user since %s", pReq->info.conn.user, ip, terrstr());
+    mGError("user:%s, failed to login from %s while acquire user since %s", pReq->info.conn.user, ip, tstrerror(code));
     goto _OVER;
   }
 
@@ -271,22 +268,22 @@ static int32_t mndProcessConnectReq(SRpcMsg *pReq) {
     if (pDb == NULL) {
       if (0 != strcmp(connReq.db, TSDB_INFORMATION_SCHEMA_DB) &&
           (0 != strcmp(connReq.db, TSDB_PERFORMANCE_SCHEMA_DB))) {
-        terrno = TSDB_CODE_MND_DB_NOT_EXIST;
+        code = TSDB_CODE_MND_DB_NOT_EXIST;
         mGError("user:%s, failed to login from %s while use db:%s since %s", pReq->info.conn.user, ip, connReq.db,
-                terrstr());
+                tstrerror(code));
         goto _OVER;
       }
     }
 
-    if (mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_READ_OR_WRITE_DB, pDb) != 0) {
+    TAOS_CHECK_GOTO(mndCheckDbPrivilege(pMnode, pReq->info.conn.user, MND_OPER_READ_OR_WRITE_DB, pDb), NULL, _OVER);
-      goto _OVER;
-    }
   }
 
   pConn = mndCreateConn(pMnode, pReq->info.conn.user, connReq.connType, pReq->info.conn.clientIp,
                         pReq->info.conn.clientPort, connReq.pid, connReq.app, connReq.startTime);
   if (pConn == NULL) {
-    mGError("user:%s, failed to login from %s while create connection since %s", pReq->info.conn.user, ip, terrstr());
+    code = terrno;
+    mGError("user:%s, failed to login from %s while create connection since %s", pReq->info.conn.user, ip,
+            tstrerror(code));
     goto _OVER;
   }
 
@@ -316,10 +313,19 @@ static int32_t mndProcessConnectReq(SRpcMsg *pReq) {
   mndGetMnodeEpSet(pMnode, &connectRsp.epSet);
 
   int32_t contLen = tSerializeSConnectRsp(NULL, 0, &connectRsp);
-  if (contLen < 0) goto _OVER;
+  if (contLen < 0) {
+    TAOS_CHECK_GOTO(contLen, NULL, _OVER);
+  }
   void *pRsp = rpcMallocCont(contLen);
-  if (pRsp == NULL) goto _OVER;
+  if (pRsp == NULL) {
-  tSerializeSConnectRsp(pRsp, contLen, &connectRsp);
+    TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _OVER);
+  }
+
+  contLen = tSerializeSConnectRsp(pRsp, contLen, &connectRsp);
+  if (contLen < 0) {
+    rpcFreeCont(pRsp);
+    TAOS_CHECK_GOTO(contLen, NULL, _OVER);
+  }
 
   pReq->info.rspLen = contLen;
   pReq->info.rsp = pRsp;
@@ -339,7 +345,7 @@ _OVER:
   mndReleaseDb(pMnode, pDb);
   mndReleaseConn(pMnode, pConn, true);
 
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndSaveQueryList(SConnObj *pConn, SQueryHbReqBasic *pBasic) {
@@ -656,6 +662,7 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
 
 static int32_t mndProcessHeartBeatReq(SRpcMsg *pReq) {
   int32_t code = 0;
+  int32_t lino = 0;
   SMnode *pMnode = pReq->info.node;
 
   SClientHbBatchReq batchReq = {0};
@@ -675,6 +682,9 @@ static int32_t mndProcessHeartBeatReq(SRpcMsg *pReq) {
   SClientHbBatchRsp batchRsp = {0};
   batchRsp.svrTimestamp = taosGetTimestampSec();
   batchRsp.rsps = taosArrayInit(0, sizeof(SClientHbRsp));
+  if (batchRsp.rsps == NULL) {
+    TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY);
+  }
   batchRsp.monitorParas.tsEnableMonitor = tsEnableMonitor;
   batchRsp.monitorParas.tsMonitorInterval = tsMonitorInterval;
   batchRsp.monitorParas.tsSlowLogThreshold = tsSlowLogThreshold;
@@ -687,7 +697,7 @@ static int32_t mndProcessHeartBeatReq(SRpcMsg *pReq) {
   for (int i = 0; i < sz; i++) {
     SClientHbReq *pHbReq = taosArrayGet(batchReq.reqs, i);
     if (pHbReq->connKey.connType == CONN_TYPE__QUERY) {
-      mndProcessQueryHeartBeat(pMnode, pReq, pHbReq, &batchRsp, &obj);
+      TAOS_CHECK_EXIT(mndProcessQueryHeartBeat(pMnode, pReq, pHbReq, &batchRsp, &obj));
     } else if (pHbReq->connKey.connType == CONN_TYPE__TMQ) {
       SClientHbRsp *pRsp = mndMqHbBuildRsp(pMnode, pHbReq);
       if (pRsp != NULL) {
@@ -699,12 +709,22 @@ static int32_t mndProcessHeartBeatReq(SRpcMsg *pReq) {
   taosArrayDestroyEx(batchReq.reqs, tFreeClientHbReq);
 
   int32_t tlen = tSerializeSClientHbBatchRsp(NULL, 0, &batchRsp);
-  void   *buf = rpcMallocCont(tlen);
+  if (tlen < 0) {
-  tSerializeSClientHbBatchRsp(buf, tlen, &batchRsp);
+    TAOS_CHECK_EXIT(tlen);
-
+  }
-  tFreeClientHbBatchRsp(&batchRsp);
+  void *buf = rpcMallocCont(tlen);
+  if (!buf) {
+    TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY);
+  }
+  tlen = tSerializeSClientHbBatchRsp(buf, tlen, &batchRsp);
+  if (tlen < 0) {
+    rpcFreeCont(buf);
+    TAOS_CHECK_EXIT(tlen);
+  }
   pReq->info.rspLen = tlen;
   pReq->info.rsp = buf;
+_exit:
+  tFreeClientHbBatchRsp(&batchRsp);
 
   taosArrayDestroy(obj.pQnodeList);
 
@@ -771,24 +791,31 @@ static int32_t mndProcessKillConnReq(SRpcMsg *pReq) {
 }
 
 static int32_t mndProcessSvrVerReq(SRpcMsg *pReq) {
-  int32_t       code = -1;
+  int32_t       code = 0;
+  int32_t       lino = 0;
   SServerVerRsp rsp = {0};
   tstrncpy(rsp.ver, version, sizeof(rsp.ver));
 
   int32_t contLen = tSerializeSServerVerRsp(NULL, 0, &rsp);
-  if (contLen < 0) goto _over;
+  if (contLen < 0) {
+    TAOS_CHECK_EXIT(contLen);
+  }
   void *pRsp = rpcMallocCont(contLen);
-  if (pRsp == NULL) goto _over;
+  if (pRsp == NULL) {
-  tSerializeSServerVerRsp(pRsp, contLen, &rsp);
+    TAOS_CHECK_EXIT(TSDB_CODE_OUT_OF_MEMORY);
+  }
+  contLen = tSerializeSServerVerRsp(pRsp, contLen, &rsp);
+  if (contLen < 0) {
+    rpcFreeCont(pRsp);
+    TAOS_CHECK_EXIT(contLen);
+  }
 
   pReq->info.rspLen = contLen;
   pReq->info.rsp = pRsp;
 
-  code = 0;
+_exit:
 
-_over:
+  TAOS_RETURN(code);
-
-  return code;
 }
 
 static int32_t mndRetrieveConns(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {

source/dnode/mnode/impl/src/mndQnode.c

@@ -75,6 +75,8 @@ void mndReleaseQnode(SMnode *pMnode, SQnodeObj *pObj) {
 }
 
 static SSdbRaw *mndQnodeActionEncode(SQnodeObj *pObj) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   SSdbRaw *pRaw = sdbAllocRaw(SDB_QNODE, QNODE_VER_NUMBER, sizeof(SQnodeObj) + QNODE_RESERVE_SIZE);
@@ -100,6 +102,8 @@ _OVER:
 }
 
 static SSdbRow *mndQnodeActionDecode(SSdbRaw *pRaw) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
   SSdbRow   *pRow = NULL;
   SQnodeObj *pObj = NULL;

source/dnode/mnode/impl/src/mndSma.c

@@ -112,6 +112,8 @@ int32_t mndInitSma(SMnode *pMnode) {
 void mndCleanupSma(SMnode *pMnode) {}
 
 static SSdbRaw *mndSmaActionEncode(SSmaObj *pSma) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   int32_t size =
@@ -173,6 +175,8 @@ _OVER:
 }
 
 static SSdbRow *mndSmaActionDecode(SSdbRaw *pRaw) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
   SSdbRow *pRow = NULL;
   SSmaObj *pSma = NULL;
@@ -294,12 +298,7 @@ void mndReleaseSma(SMnode *pMnode, SSmaObj *pSma) {
   sdbRelease(pSdb, pSma);
 }
 
-SDbObj *mndAcquireDbBySma(SMnode *pMnode, const char *smaName) {
+SDbObj *mndAcquireDbBySma(SMnode *pMnode, const char *db) {
-  SName name = {0};
-  tNameFromString(&name, smaName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
-
-  char db[TSDB_TABLE_FNAME_LEN] = {0};
-  tNameGetFullDbName(&name, db);
 
   return mndAcquireDb(pMnode, db);
 }
@@ -308,7 +307,10 @@ static void *mndBuildVCreateSmaReq(SMnode *pMnode, SVgObj *pVgroup, SSmaObj *pSm
   SEncoder encoder = {0};
   int32_t  contLen = 0;
   SName    name = {0};
-  tNameFromString(&name, pSma->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  int32_t code = tNameFromString(&name, pSma->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  if (TSDB_CODE_SUCCESS != code) {
+    return NULL;
+  }
 
   SVCreateTSmaReq req = {0};
   req.version = 0;
@@ -366,7 +368,7 @@ static void *mndBuildVDropSmaReq(SMnode *pMnode, SVgObj *pVgroup, SSmaObj *pSma,
   SEncoder encoder = {0};
   int32_t  contLen;
   SName    name = {0};
-  tNameFromString(&name, pSma->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  (void)tNameFromString(&name, pSma->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
 
   SVDropTSmaReq req = {0};
   req.indexUid = pSma->uid;
@@ -778,10 +780,14 @@ static int32_t mndCheckCreateSmaReq(SMCreateSmaReq *pCreate) {
   TAOS_RETURN(code);
 }
 
-static void mndGetStreamNameFromSmaName(char *streamName, char *smaName) {
+static int32_t mndGetStreamNameFromSmaName(char *streamName, char *smaName) {
   SName n;
-  tNameFromString(&n, smaName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  int32_t code = tNameFromString(&n, smaName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  if (TSDB_CODE_SUCCESS != code) {
+    return code;
+  }
   sprintf(streamName, "%d.%s", n.acctId, n.tname);
+  return TSDB_CODE_SUCCESS;
 }
 
 static int32_t mndProcessCreateSmaReq(SRpcMsg *pReq) {
@@ -813,7 +819,10 @@ static int32_t mndProcessCreateSmaReq(SRpcMsg *pReq) {
   }
 
   char streamName[TSDB_TABLE_FNAME_LEN] = {0};
-  mndGetStreamNameFromSmaName(streamName, createReq.name);
+  code = mndGetStreamNameFromSmaName(streamName, createReq.name);
+  if (TSDB_CODE_SUCCESS != code) {
+    goto _OVER;
+  }
 
   code = mndAcquireStream(pMnode, streamName, &pStream);
   if (pStream != NULL || code == 0) {
@@ -839,7 +848,15 @@ static int32_t mndProcessCreateSmaReq(SRpcMsg *pReq) {
     }
   }
 
-  pDb = mndAcquireDbBySma(pMnode, createReq.name);
+  SName name = {0};
+  code = tNameFromString(&name, createReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  if (TSDB_CODE_SUCCESS != code) {
+    goto _OVER;
+  }
+  char db[TSDB_TABLE_FNAME_LEN] = {0};
+  (void)tNameGetFullDbName(&name, db);
+
+  pDb = mndAcquireDb(pMnode, db);
   if (pDb == NULL) {
     code = TSDB_CODE_MND_DB_NOT_SELECTED;
     goto _OVER;
@@ -960,6 +977,7 @@ static int32_t mndDropSma(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SSmaObj *p
   SVgObj  *pVgroup = NULL;
   SStbObj *pStb = NULL;
   STrans  *pTrans = NULL;
+  SStreamObj *pStream = NULL;
 
   pVgroup = mndAcquireVgroup(pMnode, pSma->dstVgId);
   if (pVgroup == NULL) {
@@ -989,9 +1007,11 @@ static int32_t mndDropSma(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SSmaObj *p
   mndTransSetSerial(pTrans);
 
   char streamName[TSDB_TABLE_FNAME_LEN] = {0};
-  mndGetStreamNameFromSmaName(streamName, pSma->name);
+  code = mndGetStreamNameFromSmaName(streamName, pSma->name);
+  if (TSDB_CODE_SUCCESS != code) {
+    goto _OVER;
+  }
 
-  SStreamObj *pStream = NULL;
 
   code = mndAcquireStream(pMnode, streamName, &pStream);
   if (pStream == NULL || pStream->smaId != pSma->uid || code != 0) {
@@ -1050,7 +1070,10 @@ int32_t mndDropSmasByStb(SMnode *pMnode, STrans *pTrans, SDbObj *pDb, SStbObj *p
       }
 
       char streamName[TSDB_TABLE_FNAME_LEN] = {0};
-      mndGetStreamNameFromSmaName(streamName, pSma->name);
+      code = mndGetStreamNameFromSmaName(streamName, pSma->name);
+      if (TSDB_CODE_SUCCESS != code) {
+        goto _OVER;
+      }
 
       SStreamObj *pStream = NULL;
       code = mndAcquireStream(pMnode, streamName, &pStream);
@@ -1140,7 +1163,15 @@ static int32_t mndProcessDropSmaReq(SRpcMsg *pReq) {
     }
   }
 
-  pDb = mndAcquireDbBySma(pMnode, dropReq.name);
+  SName name = {0};
+  code = tNameFromString(&name, dropReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  if (TSDB_CODE_SUCCESS != code) {
+    goto _OVER;
+  }
+  char db[TSDB_TABLE_FNAME_LEN] = {0};
+  (void)tNameGetFullDbName(&name, db);
+
+  pDb = mndAcquireDb(pMnode, db);
   if (pDb == NULL) {
     code = TSDB_CODE_MND_DB_NOT_SELECTED;
     goto _OVER;
@@ -1299,7 +1330,11 @@ static int32_t mndProcessGetSmaReq(SRpcMsg *pReq) {
       goto _OVER;
     }
 
-    tSerializeSUserIndexRsp(pRsp, contLen, &rsp);
+    contLen = tSerializeSUserIndexRsp(pRsp, contLen, &rsp);
+    if (contLen < 0) {
+      code = terrno;
+      goto _OVER;
+    }
 
     pReq->info.rsp = pRsp;
     pReq->info.rspLen = contLen;
@@ -1345,7 +1380,11 @@ static int32_t mndProcessGetTbSmaReq(SRpcMsg *pReq) {
       goto _OVER;
     }
 
-    tSerializeSTableIndexRsp(pRsp, contLen, &rsp);
+    contLen = tSerializeSTableIndexRsp(pRsp, contLen, &rsp);
+    if (contLen < 0) {
+      code = terrno;
+      goto _OVER;
+    }
 
     pReq->info.rsp = pRsp;
     pReq->info.rspLen = contLen;
@@ -1368,6 +1407,7 @@ static int32_t mndRetrieveSma(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBloc
   int32_t  numOfRows = 0;
   SSmaObj *pSma = NULL;
   int32_t  cols = 0;
+  int32_t  code = 0;
 
   SDbObj *pDb = NULL;
   if (strlen(pShow->db) > 0) {
@@ -1387,47 +1427,63 @@ static int32_t mndRetrieveSma(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBloc
     cols = 0;
 
     SName smaName = {0};
-    tNameFromString(&smaName, pSma->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
-    char n1[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
-    STR_TO_VARSTR(n1, (char *)tNameGetTableName(&smaName));
-
-    char n2[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
-    STR_TO_VARSTR(n2, (char *)mndGetDbStr(pSma->db));
-
     SName stbName = {0};
-    tNameFromString(&stbName, pSma->stb, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+    char n2[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
     char n3[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
-    STR_TO_VARSTR(n3, (char *)tNameGetTableName(&stbName));
+    code = tNameFromString(&smaName, pSma->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+    char n1[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
+    if (TSDB_CODE_SUCCESS == code) {
+      STR_TO_VARSTR(n1, (char *)tNameGetTableName(&smaName));
+      STR_TO_VARSTR(n2, (char *)mndGetDbStr(pSma->db));
+      code = tNameFromString(&stbName, pSma->stb, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+    }
+    SColumnInfoData* pColInfo = NULL;
+    if (TSDB_CODE_SUCCESS == code) {
+      STR_TO_VARSTR(n3, (char *)tNameGetTableName(&stbName));
 
-    SColumnInfoData *pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)n1, false);
+      code = colDataSetVal(pColInfo, numOfRows, (const char *)n1, false);
-
+    }
-    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    if (TSDB_CODE_SUCCESS == code) {
-    colDataSetVal(pColInfo, numOfRows, (const char *)n2, false);
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-
+      code = colDataSetVal(pColInfo, numOfRows, (const char *)n2, false);
-    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    }
-    colDataSetVal(pColInfo, numOfRows, (const char *)n3, false);
+    if (TSDB_CODE_SUCCESS == code) {
-
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      code = colDataSetVal(pColInfo, numOfRows, (const char *)n3, false);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pSma->dstVgId, false);
+    }
-
+    if (TSDB_CODE_SUCCESS == code) {
-    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char *)&pSma->createdTime, false);
+      code = colDataSetVal(pColInfo, numOfRows, (const char *)&pSma->dstVgId, false);
+    }
+    if (TSDB_CODE_SUCCESS == code) {
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      code = colDataSetVal(pColInfo, numOfRows, (const char *)&pSma->createdTime, false);
+    }
 
     char col[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
     STR_TO_VARSTR(col, (char *)"");
 
-    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    if (TSDB_CODE_SUCCESS == code) {
-    colDataSetVal(pColInfo, numOfRows, (const char *)col, false);
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      code = colDataSetVal(pColInfo, numOfRows, (const char *)col, false);
+    }
 
-    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    if (TSDB_CODE_SUCCESS == code) {
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
 
-    char tag[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
+      char tag[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
-    STR_TO_VARSTR(tag, (char *)"sma_index");
+      STR_TO_VARSTR(tag, (char *)"sma_index");
-    colDataSetVal(pColInfo, numOfRows, (const char *)tag, false);
+      code = colDataSetVal(pColInfo, numOfRows, (const char *)tag, false);
+    }
 
     numOfRows++;
     sdbRelease(pSdb, pSma);
+    if (TSDB_CODE_SUCCESS != code) {
+      sdbCancelFetch(pMnode->pSdb, pIter->pSmaIter);
+      numOfRows = -1;
+      break;
+    }
   }
 
   mndReleaseDb(pMnode, pDb);
@@ -1516,7 +1572,7 @@ static void initStreamObj(SStreamObj *pStream, const char *streamName, const SMC
   pStream->ast = taosStrdup(pSma->ast);
 }
 
-static void mndCreateTSMABuildCreateStreamReq(SCreateTSMACxt *pCxt) {
+static int32_t mndCreateTSMABuildCreateStreamReq(SCreateTSMACxt *pCxt) {
   tstrncpy(pCxt->pCreateStreamReq->name, pCxt->streamName, TSDB_STREAM_FNAME_LEN);
   tstrncpy(pCxt->pCreateStreamReq->sourceDB, pCxt->pDb->name, TSDB_DB_FNAME_LEN);
   tstrncpy(pCxt->pCreateStreamReq->targetStbFullName, pCxt->targetStbFullName, TSDB_TABLE_FNAME_LEN);
@@ -1536,11 +1592,21 @@ static void mndCreateTSMABuildCreateStreamReq(SCreateTSMACxt *pCxt) {
   pCxt->pCreateStreamReq->lastTs = pCxt->pCreateSmaReq->lastTs;
   pCxt->pCreateStreamReq->smaId = pCxt->pSma->uid;
   pCxt->pCreateStreamReq->ast = taosStrdup(pCxt->pCreateSmaReq->ast);
+  if (!pCxt->pCreateStreamReq->ast) {
+    return terrno;
+  }
   pCxt->pCreateStreamReq->sql = taosStrdup(pCxt->pCreateSmaReq->sql);
+  if (!pCxt->pCreateStreamReq->sql) {
+    return terrno;
+  }
 
   // construct tags
   pCxt->pCreateStreamReq->pTags = taosArrayInit(pCxt->pCreateStreamReq->numOfTags, sizeof(SField));
+  if (!pCxt->pCreateStreamReq->pTags) {
+    return terrno;
+  }
   SField f = {0};
+  int32_t code = 0;
   if (pCxt->pSrcStb) {
     for (int32_t idx = 0; idx < pCxt->pCreateStreamReq->numOfTags - 1; ++idx) {
       SSchema *pSchema = &pCxt->pSrcStb->pTags[idx];
@@ -1548,25 +1614,39 @@ static void mndCreateTSMABuildCreateStreamReq(SCreateTSMACxt *pCxt) {
       f.type = pSchema->type;
       f.flags = pSchema->flags;
       tstrncpy(f.name, pSchema->name, TSDB_COL_NAME_LEN);
-      taosArrayPush(pCxt->pCreateStreamReq->pTags, &f);
+      if (NULL == taosArrayPush(pCxt->pCreateStreamReq->pTags, &f)) {
+        code = terrno;
+        break;
+      }
     }
   }
-  f.bytes = TSDB_TABLE_FNAME_LEN - 1 + VARSTR_HEADER_SIZE;
-  f.flags = COL_SMA_ON;
-  f.type = TSDB_DATA_TYPE_BINARY;
-  tstrncpy(f.name, "tbname", strlen("tbname") + 1);
-  taosArrayPush(pCxt->pCreateStreamReq->pTags, &f);
 
-  // construct output cols
+  if (TSDB_CODE_SUCCESS == code) {
-  SNode* pNode;
+    f.bytes = TSDB_TABLE_FNAME_LEN - 1 + VARSTR_HEADER_SIZE;
-  FOREACH(pNode, pCxt->pProjects) {
-    SExprNode* pExprNode = (SExprNode*)pNode;
-    f.bytes = pExprNode->resType.bytes;
-    f.type = pExprNode->resType.type;
     f.flags = COL_SMA_ON;
-    strcpy(f.name, pExprNode->userAlias);
+    f.type = TSDB_DATA_TYPE_BINARY;
-    taosArrayPush(pCxt->pCreateStreamReq->pCols, &f);
+    tstrncpy(f.name, "tbname", strlen("tbname") + 1);
+    if (NULL == taosArrayPush(pCxt->pCreateStreamReq->pTags, &f)) {
+      code = terrno;
+    }
   }
+
+  if (TSDB_CODE_SUCCESS == code) {
+    // construct output cols
+    SNode* pNode;
+    FOREACH(pNode, pCxt->pProjects) {
+      SExprNode* pExprNode = (SExprNode*)pNode;
+      f.bytes = pExprNode->resType.bytes;
+      f.type = pExprNode->resType.type;
+      f.flags = COL_SMA_ON;
+      strcpy(f.name, pExprNode->userAlias);
+      if (NULL == taosArrayPush(pCxt->pCreateStreamReq->pCols, &f)) {
+        code = terrno;
+        break;
+      }
+    }
+  }
+  return code;
 }
 
 static void mndCreateTSMABuildDropStreamReq(SCreateTSMACxt* pCxt) {
@@ -1729,7 +1809,10 @@ static int32_t mndCreateTSMA(SCreateTSMACxt *pCxt) {
     }
   }
   pCxt->pDropStreamReq = &dropStreamReq;
-  mndCreateTSMABuildCreateStreamReq(pCxt);
+  code = mndCreateTSMABuildCreateStreamReq(pCxt);
+  if (TSDB_CODE_SUCCESS != code) {
+    goto _OVER;
+  }
   mndCreateTSMABuildDropStreamReq(pCxt);
 
   if (TSDB_CODE_SUCCESS != (code = mndCreateTSMATxnPrepare(pCxt))) {
@@ -1749,11 +1832,15 @@ _OVER:
   TAOS_RETURN(code);
 }
 
-static void mndTSMAGenerateOutputName(const char* tsmaName, char* streamName, char* targetStbName) {
+static int32_t mndTSMAGenerateOutputName(const char* tsmaName, char* streamName, char* targetStbName) {
   SName smaName;
-  tNameFromString(&smaName, tsmaName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  int32_t code = tNameFromString(&smaName, tsmaName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  if (TSDB_CODE_SUCCESS != code) {
+    return code;
+  }
   sprintf(streamName, "%d.%s", smaName.acctId, smaName.tname);
   snprintf(targetStbName, TSDB_TABLE_FNAME_LEN, "%s"TSMA_RES_STB_POSTFIX, tsmaName);
+  return TSDB_CODE_SUCCESS;
 }
 
 static int32_t mndProcessCreateTSMAReq(SRpcMsg* pReq) {
@@ -1795,7 +1882,11 @@ static int32_t mndProcessCreateTSMAReq(SRpcMsg* pReq) {
 
   char streamName[TSDB_TABLE_FNAME_LEN] = {0};
   char streamTargetStbFullName[TSDB_TABLE_FNAME_LEN] = {0};
-  mndTSMAGenerateOutputName(createReq.name, streamName, streamTargetStbFullName);
+  code = mndTSMAGenerateOutputName(createReq.name, streamName, streamTargetStbFullName);
+  if (TSDB_CODE_SUCCESS != code) {
+    mInfo("tsma:%s, faield to generate name", createReq.name);
+    goto _OVER;
+  }
 
   pSma = sdbAcquire(pMnode->pSdb, SDB_SMA, createReq.name);
   if (pSma && createReq.igExists) {
@@ -1824,7 +1915,15 @@ static int32_t mndProcessCreateTSMAReq(SRpcMsg* pReq) {
     goto _OVER;
   }
 
-  pDb = mndAcquireDbBySma(pMnode, createReq.name);
+  SName name = {0};
+  code = tNameFromString(&name, createReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  if (TSDB_CODE_SUCCESS != code) {
+    goto _OVER;
+  }
+  char db[TSDB_TABLE_FNAME_LEN] = {0};
+  (void)tNameGetFullDbName(&name, db);
+
+  pDb = mndAcquireDb(pMnode, db);
   if (pDb == NULL) {
     code = TSDB_CODE_MND_DB_NOT_SELECTED;
     goto _OVER;
@@ -1974,7 +2073,10 @@ static int32_t mndProcessDropTSMAReq(SRpcMsg* pReq) {
 
   char  streamName[TSDB_TABLE_FNAME_LEN] = {0};
   char  streamTargetStbFullName[TSDB_TABLE_FNAME_LEN] = {0};
-  mndTSMAGenerateOutputName(dropReq.name, streamName, streamTargetStbFullName);
+  code = mndTSMAGenerateOutputName(dropReq.name, streamName, streamTargetStbFullName);
+  if (TSDB_CODE_SUCCESS != code) {
+    goto _OVER;
+  }
 
   SStbObj* pStb = mndAcquireStb(pMnode, streamTargetStbFullName);
 
@@ -1987,7 +2089,15 @@ static int32_t mndProcessDropTSMAReq(SRpcMsg* pReq) {
     code = TSDB_CODE_MND_SMA_NOT_EXIST;
     goto _OVER;
   }
-  pDb = mndAcquireDbBySma(pMnode, dropReq.name);
+  SName name = {0};
+  code = tNameFromString(&name, dropReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  if (TSDB_CODE_SUCCESS != code) {
+    goto _OVER;
+  }
+  char db[TSDB_TABLE_FNAME_LEN] = {0};
+  (void)tNameGetFullDbName(&name, db);
+
+  pDb = mndAcquireDb(pMnode, db);
   if (!pDb) {
     code = TSDB_CODE_MND_DB_NOT_EXIST;
     goto _OVER;
@@ -2028,6 +2138,7 @@ static int32_t mndRetrieveTSMA(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlo
   int32_t          numOfRows = 0;
   SSmaObj *        pSma = NULL;
   SMnode *         pMnode = pReq->info.node;
+  int32_t          code = 0;
   SColumnInfoData *pColInfo;
   if (pShow->db[0]) {
     pDb = mndAcquireDb(pMnode, pShow->db);
@@ -2050,65 +2161,90 @@ static int32_t mndRetrieveTSMA(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlo
     int32_t cols = 0;
     SName   n = {0};
 
-    tNameFromString(&n, pSma->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+    code = tNameFromString(&n, pSma->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
     char smaName[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
-    STR_TO_VARSTR(smaName, (char *)tNameGetTableName(&n));
+    if (TSDB_CODE_SUCCESS == code) {
-    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      STR_TO_VARSTR(smaName, (char *)tNameGetTableName(&n));
-    colDataSetVal(pColInfo, numOfRows, (const char *)smaName, false);
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      code = colDataSetVal(pColInfo, numOfRows, (const char *)smaName, false);
+    }
 
     char db[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
-    STR_TO_VARSTR(db, (char *)mndGetDbStr(pSma->db));
+    if (TSDB_CODE_SUCCESS == code) {
-    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      STR_TO_VARSTR(db, (char *)mndGetDbStr(pSma->db));
-    colDataSetVal(pColInfo, numOfRows, (const char*)db, false);
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      code = colDataSetVal(pColInfo, numOfRows, (const char*)db, false);
+    }
 
-    tNameFromString(&n, pSma->stb, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+    if (TSDB_CODE_SUCCESS == code) {
+      code = tNameFromString(&n, pSma->stb, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+    }
     char srcTb[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
-    STR_TO_VARSTR(srcTb, (char *)tNameGetTableName(&n));
+    if (TSDB_CODE_SUCCESS == code) {
-    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      STR_TO_VARSTR(srcTb, (char *)tNameGetTableName(&n));
-    colDataSetVal(pColInfo, numOfRows, (const char*)srcTb, false);
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      code = colDataSetVal(pColInfo, numOfRows, (const char*)srcTb, false);
+    }
 
-    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    if (TSDB_CODE_SUCCESS == code) {
-    colDataSetVal(pColInfo, numOfRows, (const char*)db, false);
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      code = colDataSetVal(pColInfo, numOfRows, (const char*)db, false);
+    }
 
-    tNameFromString(&n, pSma->dstTbName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+    if (TSDB_CODE_SUCCESS == code) {
-    char targetTb[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
+      code = tNameFromString(&n, pSma->dstTbName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
-    STR_TO_VARSTR(targetTb, (char*)tNameGetTableName(&n));
+    }
-    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, (const char*)targetTb, false);
 
-    // stream name
+    if (TSDB_CODE_SUCCESS == code) {
-    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      char targetTb[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0};
-    colDataSetVal(pColInfo, numOfRows, (const char*)smaName, false);
+      STR_TO_VARSTR(targetTb, (char*)tNameGetTableName(&n));
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      code = colDataSetVal(pColInfo, numOfRows, (const char*)targetTb, false);
+    }
 
-    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    if (TSDB_CODE_SUCCESS == code) {
-    colDataSetVal(pColInfo, numOfRows, (const char*)(&pSma->createdTime), false);
+      // stream name
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      code = colDataSetVal(pColInfo, numOfRows, (const char*)smaName, false);
+    }
+
+    if (TSDB_CODE_SUCCESS == code) {
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      code = colDataSetVal(pColInfo, numOfRows, (const char*)(&pSma->createdTime), false);
+    }
 
     // interval
     char interval[64 + VARSTR_HEADER_SIZE] = {0};
     int32_t len = 0;
-    if (!IS_CALENDAR_TIME_DURATION(pSma->intervalUnit)) {
+    if (TSDB_CODE_SUCCESS == code) {
-      len = snprintf(interval + VARSTR_HEADER_SIZE, 64, "%" PRId64 "%c", pSma->interval,
+      if (!IS_CALENDAR_TIME_DURATION(pSma->intervalUnit)) {
-          getPrecisionUnit(pSrcDb->cfg.precision));
+        len = snprintf(interval + VARSTR_HEADER_SIZE, 64, "%" PRId64 "%c", pSma->interval,
-    } else {
+            getPrecisionUnit(pSrcDb->cfg.precision));
-      len = snprintf(interval + VARSTR_HEADER_SIZE, 64, "%" PRId64 "%c", pSma->interval, pSma->intervalUnit);
+      } else {
+        len = snprintf(interval + VARSTR_HEADER_SIZE, 64, "%" PRId64 "%c", pSma->interval, pSma->intervalUnit);
+      }
+      varDataSetLen(interval, len);
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      code = colDataSetVal(pColInfo, numOfRows, interval, false);
     }
-    varDataSetLen(interval, len);
-    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
-    colDataSetVal(pColInfo, numOfRows, interval, false);
 
-    // create sql
-    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
     char buf[TSDB_MAX_SAVED_SQL_LEN + VARSTR_HEADER_SIZE] = {0};
-    len = snprintf(buf + VARSTR_HEADER_SIZE, TSDB_MAX_SAVED_SQL_LEN, "%s", pSma->sql);
+    if (TSDB_CODE_SUCCESS == code) {
-    varDataSetLen(buf, TMIN(len, TSDB_MAX_SAVED_SQL_LEN));
+      // create sql
-    colDataSetVal(pColInfo, numOfRows, buf, false);
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      len = snprintf(buf + VARSTR_HEADER_SIZE, TSDB_MAX_SAVED_SQL_LEN, "%s", pSma->sql);
+      varDataSetLen(buf, TMIN(len, TSDB_MAX_SAVED_SQL_LEN));
+      code = colDataSetVal(pColInfo, numOfRows, buf, false);
+    }
 
     // func list
     len = 0;
-    char * start = buf + VARSTR_HEADER_SIZE;
     SNode *pNode = NULL, *pFunc = NULL;
-    nodesStringToNode(pSma->ast, &pNode);
+    if (TSDB_CODE_SUCCESS  == code) {
-    if (pNode) {
+      code = nodesStringToNode(pSma->ast, &pNode);
+    }
+    if (TSDB_CODE_SUCCESS == code) {
+      char * start = buf + VARSTR_HEADER_SIZE;
       FOREACH(pFunc, ((SSelectStmt *)pNode)->pProjectionList) {
         if (nodeType(pFunc) == QUERY_NODE_FUNCTION) {
           SFunctionNode *pFuncNode = (SFunctionNode *)pFunc;
@@ -2124,13 +2260,21 @@ static int32_t mndRetrieveTSMA(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlo
       }
       nodesDestroyNode(pNode);
     }
-    varDataSetLen(buf, len);
+
-    pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+    if (TSDB_CODE_SUCCESS == code) {
-    colDataSetVal(pColInfo, numOfRows, buf, false);
+      varDataSetLen(buf, len);
+      pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);
+      code = colDataSetVal(pColInfo, numOfRows, buf, false);
+    }
 
     numOfRows++;
     mndReleaseSma(pMnode, pSma);
     mndReleaseDb(pMnode, pSrcDb);
+    if (TSDB_CODE_SUCCESS != code) {
+      sdbCancelFetch(pMnode->pSdb, pIter->pSmaIter);
+      numOfRows = -1;
+      break;
+    }
   }
   mndReleaseDb(pMnode, pDb);
   pShow->numOfRows += numOfRows;
@@ -2159,13 +2303,22 @@ int32_t dumpTSMAInfoFromSmaObj(const SSmaObj* pSma, const SStbObj* pDestStb, STa
   pInfo->tsmaId = pSma->uid;
   pInfo->destTbUid = pDestStb->uid;
   SName sName = {0};
-  tNameFromString(&sName, pSma->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  code = tNameFromString(&sName, pSma->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  if (TSDB_CODE_SUCCESS != code) {
+    return code;
+  }
   tstrncpy(pInfo->name, sName.tname, TSDB_TABLE_NAME_LEN);
   tstrncpy(pInfo->targetDbFName, pSma->db, TSDB_DB_FNAME_LEN);
-  tNameFromString(&sName, pSma->dstTbName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  code = tNameFromString(&sName, pSma->dstTbName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  if (TSDB_CODE_SUCCESS != code) {
+    return code;
+  }
   tstrncpy(pInfo->targetTb, sName.tname, TSDB_TABLE_NAME_LEN);
   tstrncpy(pInfo->dbFName, pSma->db, TSDB_DB_FNAME_LEN);
-  tNameFromString(&sName, pSma->stb, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  code = tNameFromString(&sName, pSma->stb, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+  if (TSDB_CODE_SUCCESS != code) {
+    return code;
+  }
   tstrncpy(pInfo->tb, sName.tname, TSDB_TABLE_NAME_LEN);
   pInfo->pFuncs = taosArrayInit(8, sizeof(STableTSMAFuncInfo));
   if (!pInfo->pFuncs) return TSDB_CODE_OUT_OF_MEMORY;
@@ -2202,7 +2355,10 @@ int32_t dumpTSMAInfoFromSmaObj(const SSmaObj* pSma, const SStbObj* pDestStb, STa
       code = TSDB_CODE_OUT_OF_MEMORY;
     } else {
       for (int32_t i = 0; i < pDestStb->numOfTags; ++i) {
-        taosArrayPush(pInfo->pTags, &pDestStb->pTags[i]);
+        if (NULL == taosArrayPush(pInfo->pTags, &pDestStb->pTags[i])) {
+          code = terrno;
+          break;
+        }
       }
     }
   }
@@ -2213,7 +2369,10 @@ int32_t dumpTSMAInfoFromSmaObj(const SSmaObj* pSma, const SStbObj* pDestStb, STa
     else {
       // skip _wstart, _wend, _duration
       for (int32_t i = 1; i < pDestStb->numOfColumns - 2; ++i) {
-        taosArrayPush(pInfo->pUsedCols, &pDestStb->pColumns[i]);
+        if (NULL == taosArrayPush(pInfo->pUsedCols, &pDestStb->pColumns[i])) {
+          code = terrno;
+          break;
+        }
       }
     }
   }
@@ -2276,12 +2435,12 @@ static int32_t mndGetTSMA(SMnode *pMnode, char *tsmaFName, STableTSMAInfoRsp *rs
     sdbRelease(pMnode->pSdb, pSma);
     if (pBaseTsma) mndReleaseSma(pMnode, pBaseTsma);
     if (terrno) {
-      tFreeTableTSMAInfo(pTsma);
+      tFreeAndClearTableTSMAInfo(pTsma);
       TAOS_RETURN(code);
     }
     if (NULL == taosArrayPush(rsp->pTsmas, &pTsma)) {
       code = TSDB_CODE_OUT_OF_MEMORY;
-      tFreeTableTSMAInfo(pTsma);
+      tFreeAndClearTableTSMAInfo(pTsma);
     }
     *exist = true;
   }
@@ -2316,7 +2475,11 @@ static int32_t mndGetSomeTsmas(SMnode* pMnode, STableTSMAInfoRsp* pRsp, tsmaFilt
 
     SName smaName;
     char streamName[TSDB_TABLE_FNAME_LEN] = {0};
-    tNameFromString(&smaName, pSma->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+    code = tNameFromString(&smaName, pSma->name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE);
+    if (TSDB_CODE_SUCCESS != code) {
+      sdbRelease(pSdb, pSma);
+      TAOS_RETURN(code);
+    }
     sprintf(streamName, "%d.%s", smaName.acctId, smaName.tname);
     pStream = NULL;
 
@@ -2347,13 +2510,13 @@ static int32_t mndGetSomeTsmas(SMnode* pMnode, STableTSMAInfoRsp* pRsp, tsmaFilt
     sdbRelease(pSdb, pSma);
     if (pBaseTsma) mndReleaseSma(pMnode, pBaseTsma);
     if (terrno) {
-      tFreeTableTSMAInfo(pTsma);
+      tFreeAndClearTableTSMAInfo(pTsma);
       sdbCancelFetch(pSdb, pIter);
       TAOS_RETURN(code);
     }
     if (NULL == taosArrayPush(pRsp->pTsmas, &pTsma)) {
       code = TSDB_CODE_OUT_OF_MEMORY;
-      tFreeTableTSMAInfo(pTsma);
+      tFreeAndClearTableTSMAInfo(pTsma);
       sdbCancelFetch(pSdb, pIter);
       TAOS_RETURN(code);
     }
@@ -2414,7 +2577,11 @@ static int32_t mndProcessGetTbTSMAReq(SRpcMsg *pReq) {
       goto _OVER;
     }
 
-    tSerializeTableTSMAInfoRsp(pRsp, contLen, &rsp);
+    int32_t len = tSerializeTableTSMAInfoRsp(pRsp, contLen, &rsp);
+    if (len < 0) {
+      code = terrno;
+      goto _OVER;
+    }
 
     pReq->info.rsp = pRsp;
     pReq->info.rspLen = contLen;
@@ -2430,7 +2597,7 @@ _OVER:
 static int32_t mkNonExistTSMAInfo(const STSMAVersion *pTsmaVer, STableTSMAInfo **ppTsma) {
   STableTSMAInfo *pInfo = taosMemoryCalloc(1, sizeof(STableTSMAInfo));
   if (!pInfo) {
-    return TSDB_CODE_OUT_OF_MEMORY;
+    return terrno;
   }
   pInfo->pFuncs = NULL;
   pInfo->tsmaId = pTsmaVer->tsmaId;
@@ -2439,6 +2606,10 @@ static int32_t mkNonExistTSMAInfo(const STSMAVersion *pTsmaVer, STableTSMAInfo *
   tstrncpy(pInfo->name, pTsmaVer->name, TSDB_TABLE_NAME_LEN);
   pInfo->dbId = pTsmaVer->dbId;
   pInfo->ast = taosMemoryCalloc(1, 1);
+  if (!pInfo->ast) {
+    taosMemoryFree(pInfo);
+    return terrno;
+  }
   *ppTsma = pInfo;
   return TSDB_CODE_SUCCESS;
 }
@@ -2454,7 +2625,7 @@ int32_t mndValidateTSMAInfo(SMnode *pMnode, STSMAVersion *pTsmaVersions, int32_t
 
   hbRsp.pTsmas = taosArrayInit(numOfTsmas, POINTER_BYTES);
   if (!hbRsp.pTsmas) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     TAOS_RETURN(code);
   }
 
@@ -2469,7 +2640,11 @@ int32_t mndValidateTSMAInfo(SMnode *pMnode, STSMAVersion *pTsmaVersions, int32_t
     if (!pSma) {
       code = mkNonExistTSMAInfo(pTsmaVer, &pTsmaInfo);
       if (code) goto _OVER;
-      taosArrayPush(hbRsp.pTsmas, &pTsmaInfo);
+      if (NULL == taosArrayPush(hbRsp.pTsmas, &pTsmaInfo)) {
+        code = terrno;
+        tFreeAndClearTableTSMAInfo(pTsmaInfo);
+        goto _OVER;
+      }
       continue;
     }
 
@@ -2478,7 +2653,11 @@ int32_t mndValidateTSMAInfo(SMnode *pMnode, STSMAVersion *pTsmaVersions, int32_t
       code = mkNonExistTSMAInfo(pTsmaVer, &pTsmaInfo);
       mndReleaseSma(pMnode, pSma);
       if (code) goto _OVER;
-      taosArrayPush(hbRsp.pTsmas, &pTsmaInfo);
+      if (NULL == taosArrayPush(hbRsp.pTsmas, &pTsmaInfo)) {
+        code = terrno;
+        tFreeAndClearTableTSMAInfo(pTsmaInfo);
+        goto _OVER;
+      }
       continue;
     } else if (pSma->version == pTsmaVer->version) {
       mndReleaseSma(pMnode, pSma);
@@ -2491,7 +2670,11 @@ int32_t mndValidateTSMAInfo(SMnode *pMnode, STSMAVersion *pTsmaVersions, int32_t
       code = mkNonExistTSMAInfo(pTsmaVer, &pTsmaInfo);
       mndReleaseSma(pMnode, pSma);
       if (code) goto _OVER;
-      taosArrayPush(hbRsp.pTsmas, &pTsmaInfo);
+      if (NULL == taosArrayPush(hbRsp.pTsmas, &pTsmaInfo)) {
+        code = terrno;
+        tFreeAndClearTableTSMAInfo(pTsmaInfo);
+        goto _OVER;
+      }
       continue;
     }
 
@@ -2499,7 +2682,7 @@ int32_t mndValidateTSMAInfo(SMnode *pMnode, STSMAVersion *pTsmaVersions, int32_t
     STableTSMAInfo *   pInfo = NULL;
     pInfo = taosMemoryCalloc(1, sizeof(STableTSMAInfo));
     if (!pInfo) {
-      code = TSDB_CODE_OUT_OF_MEMORY;
+      code = terrno;
       mndReleaseSma(pMnode, pSma);
       mndReleaseStb(pMnode, pDestStb);
       goto _OVER;
@@ -2513,27 +2696,35 @@ int32_t mndValidateTSMAInfo(SMnode *pMnode, STSMAVersion *pTsmaVersions, int32_t
     mndReleaseSma(pMnode, pSma);
     if (pBaseSma) mndReleaseSma(pMnode, pBaseSma);
     if (terrno) {
-      tFreeTableTSMAInfo(pInfo);
+      tFreeAndClearTableTSMAInfo(pInfo);
       goto _OVER;
     }
 
-    taosArrayPush(hbRsp.pTsmas, pInfo);
+    if (NULL == taosArrayPush(hbRsp.pTsmas, pInfo)) {
+      code = terrno;
+      tFreeAndClearTableTSMAInfo(pInfo);
+      goto _OVER;
+    }
   }
 
   rspLen = tSerializeTSMAHbRsp(NULL, 0, &hbRsp);
   if (rspLen < 0) {
-    code = TSDB_CODE_INVALID_MSG;
+    code = terrno;
     goto _OVER;
   }
 
   pRsp = taosMemoryMalloc(rspLen);
   if (!pRsp) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    code = terrno;
     rspLen = 0;
     goto _OVER;
   }
 
-  tSerializeTSMAHbRsp(pRsp, rspLen, &hbRsp);
+  rspLen = tSerializeTSMAHbRsp(pRsp, rspLen, &hbRsp);
+  if (rspLen < 0) {
+    code = terrno;
+    goto _OVER;
+  }
   code = 0;
 _OVER:
   tFreeTSMAHbRsp(&hbRsp);

source/dnode/mnode/impl/src/mndSnode.c

@@ -79,6 +79,8 @@ void mndReleaseSnode(SMnode *pMnode, SSnodeObj *pObj) {
 }
 
 static SSdbRaw *mndSnodeActionEncode(SSnodeObj *pObj) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   SSdbRaw *pRaw = sdbAllocRaw(SDB_SNODE, SNODE_VER_NUMBER, sizeof(SSnodeObj) + SNODE_RESERVE_SIZE);
@@ -104,6 +106,8 @@ _OVER:
 }
 
 static SSdbRow *mndSnodeActionDecode(SSdbRaw *pRaw) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
   SSdbRow   *pRow = NULL;
   SSnodeObj *pObj = NULL;

source/dnode/mnode/impl/src/mndStb.c

@@ -115,6 +115,8 @@ int32_t mndInitStb(SMnode *pMnode) {
 void mndCleanupStb(SMnode *pMnode) {}
 
 SSdbRaw *mndStbActionEncode(SStbObj *pStb) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   int32_t size = sizeof(SStbObj) + (pStb->numOfColumns + pStb->numOfTags) * sizeof(SSchema) + pStb->commentLen +
@@ -205,6 +207,8 @@ _OVER:
 }
 
 static SSdbRow *mndStbActionDecode(SSdbRaw *pRaw) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
   SSdbRow *pRow = NULL;
   SStbObj *pStb = NULL;
@@ -2898,9 +2902,9 @@ static int32_t mndProcessTableMetaReq(SRpcMsg *pReq) {
   int32_t       code = -1;
   STableInfoReq infoReq = {0};
   STableMetaRsp metaRsp = {0};
+  SUserObj     *pUser = NULL;
 
-  SUserObj *pUser = mndAcquireUser(pMnode, pReq->info.conn.user);
+  code = mndAcquireUser(pMnode, pReq->info.conn.user, &pUser);
-  //TODO why return 0 here
   if (pUser == NULL) return 0;
   bool sysinfo = pUser->sysInfo;
 

source/dnode/mnode/impl/src/mndStreamHb.c

@@ -57,7 +57,10 @@ void addIntoCheckpointList(SArray *pList, const SFailedCheckpointInfo *pInfo) {
     }
   }
 
-  taosArrayPush(pList, pInfo);
+  void* p = taosArrayPush(pList, pInfo);
+  if (p == NULL) {
+    mError("failed to push failed checkpoint info checkpointId:%" PRId64 " in list", pInfo->checkpointId);
+  }
 }
 
 int32_t mndCreateStreamResetStatusTrans(SMnode *pMnode, SStreamObj *pStream) {
@@ -208,6 +211,8 @@ int32_t suspendAllStreams(SMnode *pMnode, SRpcHandleInfo *info) {
   SSdb       *pSdb = pMnode->pSdb;
   SStreamObj *pStream = NULL;
   void       *pIter = NULL;
+  int32_t     code = 0;
+
   while (1) {
     pIter = sdbFetch(pSdb, SDB_STREAM, pIter, (void **)&pStream);
     if (pIter == NULL) break;
@@ -219,7 +224,17 @@ int32_t suspendAllStreams(SMnode *pMnode, SRpcHandleInfo *info) {
 
       int32_t contLen = tSerializeSMPauseStreamReq(NULL, 0, &reqPause);
       void   *pHead = rpcMallocCont(contLen);
-      tSerializeSMPauseStreamReq(pHead, contLen, &reqPause);
+      if (pHead == NULL) {
+        code = TSDB_CODE_OUT_OF_MEMORY;
+        sdbRelease(pSdb, pStream);
+        continue;
+      }
+
+      code = tSerializeSMPauseStreamReq(pHead, contLen, &reqPause);
+      if (code) {
+        sdbRelease(pSdb, pStream);
+        continue;
+      }
 
       SRpcMsg rpcMsg = {
           .msgType = TDMT_MND_PAUSE_STREAM,
@@ -228,14 +243,14 @@ int32_t suspendAllStreams(SMnode *pMnode, SRpcHandleInfo *info) {
           .info = *info,
       };
 
-      tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg);
+      code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg);
-      mInfo("receive pause stream:%s, %s, %" PRId64 ", because grant expired", pStream->name, reqPause.name,
+      mInfo("receive pause stream:%s, %s, %" PRId64 ", because grant expired, code:%s", pStream->name, reqPause.name,
-            pStream->uid);
+            pStream->uid, tstrerror(code));
     }
 
     sdbRelease(pSdb, pStream);
   }
-  return 0;
+  return code;
 }
 
 int32_t mndProcessStreamHb(SRpcMsg *pReq) {
@@ -267,7 +282,7 @@ int32_t mndProcessStreamHb(SRpcMsg *pReq) {
   pFailedChkpt = taosArrayInit(4, sizeof(SFailedCheckpointInfo));
   pOrphanTasks = taosArrayInit(4, sizeof(SOrphanTask));
 
-  taosThreadMutexLock(&execInfo.lock);
+  streamMutexLock(&execInfo.lock);
 
   mndInitStreamExecInfo(pMnode, &execInfo);
   if (!validateHbMsg(execInfo.pNodeList, req.vgId)) {
@@ -276,7 +291,7 @@ int32_t mndProcessStreamHb(SRpcMsg *pReq) {
     code = terrno = TSDB_CODE_INVALID_MSG;
     doSendHbMsgRsp(terrno, &pReq->info, req.vgId, req.msgId);
 
-    taosThreadMutexUnlock(&execInfo.lock);
+    streamMutexUnlock(&execInfo.lock);
     cleanupAfterProcessHbMsg(&req, pFailedChkpt, pOrphanTasks);
     return code;
   }
@@ -284,7 +299,7 @@ int32_t mndProcessStreamHb(SRpcMsg *pReq) {
   int32_t numOfUpdated = taosArrayGetSize(req.pUpdateNodes);
   if (numOfUpdated > 0) {
     mDebug("%d stream node(s) need updated from hbMsg(vgId:%d)", numOfUpdated, req.vgId);
-    setNodeEpsetExpiredFlag(req.pUpdateNodes);
+    (void) setNodeEpsetExpiredFlag(req.pUpdateNodes);
   }
 
   bool snodeChanged = false;
@@ -296,7 +311,10 @@ int32_t mndProcessStreamHb(SRpcMsg *pReq) {
       mError("s-task:0x%" PRIx64 " not found in mnode task list", p->id.taskId);
 
       SOrphanTask oTask = {.streamId = p->id.streamId, .taskId = p->id.taskId, .nodeId = p->nodeId};
-      taosArrayPush(pOrphanTasks, &oTask);
+      void* px = taosArrayPush(pOrphanTasks, &oTask);
+      if (px == NULL) {
+        mError("Failed to put task into list, taskId:0x%" PRIx64, p->id.taskId);
+      }
       continue;
     }
 
@@ -346,7 +364,10 @@ int32_t mndProcessStreamHb(SRpcMsg *pReq) {
         addIntoCheckpointList(pFailedChkpt, &info);
 
         // remove failed trans from pChkptStreams
-        taosHashRemove(execInfo.pChkptStreams, &p->id.streamId, sizeof(p->id.streamId));
+        code = taosHashRemove(execInfo.pChkptStreams, &p->id.streamId, sizeof(p->id.streamId));
+        if (code) {
+          mError("failed to remove stream:0x%"PRIx64" in checkpoint stream list", p->id.streamId);
+        }
       }
     }
 
@@ -386,7 +407,10 @@ int32_t mndProcessStreamHb(SRpcMsg *pReq) {
         mInfo("checkpointId:%" PRId64 " transId:%d failed, issue task-reset trans to reset all tasks status",
               pInfo->checkpointId, pInfo->transId);
 
-        mndResetStatusFromCheckpoint(pMnode, pInfo->streamUid, pInfo->transId);
+        code = mndResetStatusFromCheckpoint(pMnode, pInfo->streamUid, pInfo->transId);
+        if (code) {
+          mError("failed to create reset task trans, code:%s", tstrerror(code));
+        }
       }
     } else {
       mInfo("not all vgroups are ready, wait for next HB from stream tasks to reset the task status");
@@ -395,20 +419,19 @@ int32_t mndProcessStreamHb(SRpcMsg *pReq) {
 
   // handle the orphan tasks that are invalid but not removed in some vnodes or snode due to some unknown errors.
   if (taosArrayGetSize(pOrphanTasks) > 0) {
-    mndDropOrphanTasks(pMnode, pOrphanTasks);
+    code = mndDropOrphanTasks(pMnode, pOrphanTasks);
   }
 
   if (pMnode != NULL) {  // make sure that the unit test case can work
     mndStreamStartUpdateCheckpointInfo(pMnode);
   }
 
-  taosThreadMutexUnlock(&execInfo.lock);
+  streamMutexUnlock(&execInfo.lock);
 
-  terrno = TSDB_CODE_SUCCESS;
+  doSendHbMsgRsp(TSDB_CODE_SUCCESS, &pReq->info, req.vgId, req.msgId);
-  doSendHbMsgRsp(terrno, &pReq->info, req.vgId, req.msgId);
 
   cleanupAfterProcessHbMsg(&req, pFailedChkpt, pOrphanTasks);
-  return terrno;
+  return code;
 }
 
 void mndStreamStartUpdateCheckpointInfo(SMnode *pMnode) {  // here reuse the doCheckpointmsg
@@ -416,7 +439,10 @@ void mndStreamStartUpdateCheckpointInfo(SMnode *pMnode) {  // here reuse the doC
   if (pMsg != NULL) {
     int32_t size = sizeof(SMStreamDoCheckpointMsg);
     SRpcMsg rpcMsg = {.msgType = TDMT_MND_STREAM_UPDATE_CHKPT_EVT, .pCont = pMsg, .contLen = size};
-    tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg);
+    int32_t code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg);
+    if (code) {
+      mError("failed to put into write Queue, code:%s", tstrerror(code));
+    }
   }
 }
 

source/dnode/mnode/impl/src/mndStreamTrans.c

@@ -24,8 +24,7 @@ typedef struct SKeyInfo {
 int32_t mndStreamRegisterTrans(STrans *pTrans, const char *pTransName, int64_t streamId) {
   SStreamTransInfo info = {
       .transId = pTrans->id, .startTime = taosGetTimestampMs(), .name = pTransName, .streamId = streamId};
-  taosHashPut(execInfo.transMgmt.pDBTrans, &streamId, sizeof(streamId), &info, sizeof(SStreamTransInfo));
+  return taosHashPut(execInfo.transMgmt.pDBTrans, &streamId, sizeof(streamId), &info, sizeof(SStreamTransInfo));
-  return 0;
 }
 
 int32_t mndStreamClearFinishedTrans(SMnode *pMnode, int32_t *pNumOfActiveChkpt) {
@@ -45,7 +44,10 @@ int32_t mndStreamClearFinishedTrans(SMnode *pMnode, int32_t *pNumOfActiveChkpt)
       SKeyInfo info = {.pKey = pKey, .keyLen = keyLen};
       mDebug("transId:%d %s startTs:%" PRId64 " cleared since finished", pEntry->transId, pEntry->name,
              pEntry->startTime);
-      taosArrayPush(pList, &info);
+      void* p = taosArrayPush(pList, &info);
+      if (p == NULL) {
+        return TSDB_CODE_OUT_OF_MEMORY;
+      }
     } else {
       if (strcmp(pEntry->name, MND_STREAM_CHECKPOINT_NAME) == 0) {
         num++;
@@ -57,7 +59,11 @@ int32_t mndStreamClearFinishedTrans(SMnode *pMnode, int32_t *pNumOfActiveChkpt)
   int32_t size = taosArrayGetSize(pList);
   for (int32_t i = 0; i < size; ++i) {
     SKeyInfo *pKey = taosArrayGet(pList, i);
-    taosHashRemove(execInfo.transMgmt.pDBTrans, pKey->pKey, pKey->keyLen);
+    int32_t code = taosHashRemove(execInfo.transMgmt.pDBTrans, pKey->pKey, pKey->keyLen);
+    if (code != 0) {
+      taosArrayDestroy(pList);
+      return code;
+    }
   }
 
   mDebug("clear %d finished stream-trans, remained:%d, active checkpoint trans:%d", size,
@@ -79,25 +85,28 @@ int32_t mndStreamClearFinishedTrans(SMnode *pMnode, int32_t *pNumOfActiveChkpt)
 // 2. create/drop/reset/update trans are conflict with any other trans.
 bool mndStreamTransConflictCheck(SMnode *pMnode, int64_t streamId, const char *pTransName, bool lock) {
   if (lock) {
-    taosThreadMutexLock(&execInfo.lock);
+    streamMutexLock(&execInfo.lock);
   }
 
   int32_t num = taosHashGetSize(execInfo.transMgmt.pDBTrans);
   if (num <= 0) {
     if (lock) {
-      taosThreadMutexUnlock(&execInfo.lock);
+      streamMutexUnlock(&execInfo.lock);
     }
     return false;
   }
 
-  mndStreamClearFinishedTrans(pMnode, NULL);
+  int32_t code = mndStreamClearFinishedTrans(pMnode, NULL);
+  if (code) {
+    mError("failed to clear finish trans, code:%s", tstrerror(code));
+  }
 
   SStreamTransInfo *pEntry = taosHashGet(execInfo.transMgmt.pDBTrans, &streamId, sizeof(streamId));
   if (pEntry != NULL) {
     SStreamTransInfo tInfo = *pEntry;
 
     if (lock) {
-      taosThreadMutexUnlock(&execInfo.lock);
+      streamMutexUnlock(&execInfo.lock);
     }
 
     if (strcmp(tInfo.name, MND_STREAM_CHECKPOINT_NAME) == 0) {
@@ -122,32 +131,36 @@ bool mndStreamTransConflictCheck(SMnode *pMnode, int64_t streamId, const char *p
   }
 
   if (lock) {
-    taosThreadMutexUnlock(&execInfo.lock);
+    streamMutexUnlock(&execInfo.lock);
   }
 
   return false;
 }
 
 int32_t mndStreamGetRelTrans(SMnode *pMnode, int64_t streamId) {
-  taosThreadMutexLock(&execInfo.lock);
+  streamMutexLock(&execInfo.lock);
   int32_t num = taosHashGetSize(execInfo.transMgmt.pDBTrans);
   if (num <= 0) {
-    taosThreadMutexUnlock(&execInfo.lock);
+    streamMutexUnlock(&execInfo.lock);
     return 0;
   }
 
-  mndStreamClearFinishedTrans(pMnode, NULL);
+  int32_t code = mndStreamClearFinishedTrans(pMnode, NULL);
+  if (code) {
+    mError("failed to clear finish trans, code:%s", tstrerror(code));
+  }
+
   SStreamTransInfo *pEntry = taosHashGet(execInfo.transMgmt.pDBTrans, &streamId, sizeof(streamId));
   if (pEntry != NULL) {
     SStreamTransInfo tInfo = *pEntry;
-    taosThreadMutexUnlock(&execInfo.lock);
+    streamMutexUnlock(&execInfo.lock);
 
     if (strcmp(tInfo.name, MND_STREAM_CHECKPOINT_NAME) == 0 || strcmp(tInfo.name, MND_STREAM_TASK_UPDATE_NAME) == 0 ||
         strcmp(tInfo.name, MND_STREAM_CHKPT_UPDATE_NAME) == 0) {
       return tInfo.transId;
     }
   } else {
-    taosThreadMutexUnlock(&execInfo.lock);
+    streamMutexUnlock(&execInfo.lock);
   }
 
   return 0;
@@ -180,6 +193,8 @@ int32_t doCreateTrans(SMnode *pMnode, SStreamObj *pStream, SRpcMsg *pReq, ETrnCo
 }
 
 SSdbRaw *mndStreamActionEncode(SStreamObj *pStream) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
   void *buf = NULL;
 
@@ -231,21 +246,21 @@ int32_t mndPersistTransLog(SStreamObj *pStream, STrans *pTrans, int32_t status)
   if (pCommitRaw == NULL) {
     mError("failed to encode stream since %s", terrstr());
     mndTransDrop(pTrans);
-    return -1;
+    return terrno;
   }
 
   if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) {
     mError("stream trans:%d, failed to append commit log since %s", pTrans->id, terrstr());
     sdbFreeRaw(pCommitRaw);
     mndTransDrop(pTrans);
-    return -1;
+    return terrno;
   }
 
   if (sdbSetRawStatus(pCommitRaw, status) != 0) {
     mError("stream trans:%d failed to set raw status:%d since %s", pTrans->id, status, terrstr());
     sdbFreeRaw(pCommitRaw);
     mndTransDrop(pTrans);
-    return -1;
+    return terrno;
   }
 
   return 0;
@@ -303,8 +318,12 @@ void killAllCheckpointTrans(SMnode *pMnode, SVgroupChangeInfo *pChangeInfo) {
     void  *pKey = taosHashGetKey(pDb, &len);
     char  *p = strndup(pKey, len);
 
-    mDebug("clear checkpoint trans in Db:%s", p);
+    int32_t code = doKillCheckpointTrans(pMnode, pKey, len);
-    doKillCheckpointTrans(pMnode, pKey, len);
+    if (code) {
+      mError("failed to kill trans, transId:%p", pKey)
+    } else {
+      mDebug("clear checkpoint trans in Db:%s", p);
+    }
     taosMemoryFree(p);
   }
 

source/dnode/mnode/impl/src/mndStreamUtil.c

@@ -744,8 +744,9 @@ int32_t mndInitExecInfo() {
 void removeExpiredNodeInfo(const SArray *pNodeSnapshot) {
   SArray *pValidList = taosArrayInit(4, sizeof(SNodeEntry));
   int32_t size = taosArrayGetSize(pNodeSnapshot);
+  int32_t oldSize = taosArrayGetSize(execInfo.pNodeList);
 
-  for (int32_t i = 0; i < taosArrayGetSize(execInfo.pNodeList); ++i) {
+  for (int32_t i = 0; i < oldSize; ++i) {
     SNodeEntry *p = taosArrayGet(execInfo.pNodeList, i);
 
     for (int32_t j = 0; j < size; ++j) {
@@ -763,7 +764,8 @@ void removeExpiredNodeInfo(const SArray *pNodeSnapshot) {
   taosArrayDestroy(execInfo.pNodeList);
   execInfo.pNodeList = pValidList;
 
-  mDebug("remain %d valid node entries after clean expired nodes info", (int32_t)taosArrayGetSize(pValidList));
+  mDebug("remain %d valid node entries after clean expired nodes info, prev size:%d",
+         (int32_t)taosArrayGetSize(pValidList), oldSize);
 }
 
 int32_t doRemoveTasks(SStreamExecInfo *pExecNode, STaskId *pRemovedId) {
@@ -1203,13 +1205,17 @@ void mndClearConsensusRspEntry(SCheckpointConsensusInfo* pInfo) {
 }
 
 int64_t mndClearConsensusCheckpointId(SHashObj* pHash, int64_t streamId) {
-  int32_t code = taosHashRemove(pHash, &streamId, sizeof(streamId));
+  int32_t code = 0;
+  int32_t numOfStreams = taosHashGetSize(pHash);
+  if (numOfStreams == 0) {
+    return TSDB_CODE_SUCCESS;
+  }
+
+  code = taosHashRemove(pHash, &streamId, sizeof(streamId));
   if (code == 0) {
-    int32_t numOfStreams = taosHashGetSize(pHash);
+    mDebug("drop stream:0x%" PRIx64 " in consensus-checkpointId list, remain:%d", streamId, numOfStreams);
-    mDebug("drop stream:0x%" PRIx64 " in consensus-checkpointId list after new checkpoint generated, remain:%d",
-           streamId, numOfStreams);
   } else {
-    mError("failed to remove stream:0x%"PRIx64" in consensus-checkpointId list", streamId);
+    mError("failed to remove stream:0x%"PRIx64" in consensus-checkpointId list, remain:%d", streamId, numOfStreams);
   }
 
   return code;

source/dnode/mnode/impl/src/mndSubscribe.c

@@ -1099,6 +1099,8 @@ END:
 void mndCleanupSubscribe(SMnode *pMnode) {}
 
 static SSdbRaw *mndSubActionEncode(SMqSubscribeObj *pSub) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
   void   *buf = NULL;
   int32_t tlen = tEncodeSubscribeObj(NULL, pSub);
@@ -1137,6 +1139,8 @@ SUB_ENCODE_OVER:
 }
 
 static SSdbRow *mndSubActionDecode(SSdbRaw *pRaw) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
   SSdbRow         *pRow = NULL;
   SMqSubscribeObj *pSub = NULL;
@@ -1371,7 +1375,7 @@ static int32_t buildResult(SSDataBlock *pBlock, int32_t *numOfRows, int64_t cons
     if (data) {
       // vg id
       char buf[TSDB_OFFSET_LEN * 2 + VARSTR_HEADER_SIZE] = {0};
-      MND_TMQ_RETURN_CHECK(tFormatOffset(varDataVal(buf), TSDB_OFFSET_LEN, &data->offset));
+      tFormatOffset(varDataVal(buf), TSDB_OFFSET_LEN, &data->offset);
       (void)sprintf(varDataVal(buf) + strlen(varDataVal(buf)), "/%" PRId64, data->ever);
       varDataSetLen(buf, strlen(varDataVal(buf)));
       pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);

source/dnode/mnode/impl/src/mndTopic.c

@@ -81,6 +81,8 @@ void mndTopicGetShowName(const char* fullTopic, char* topic) {
 }
 
 SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
 
   void   *swBuf = NULL;
@@ -170,6 +172,8 @@ TOPIC_ENCODE_OVER:
 }
 
 SSdbRow *mndTopicActionDecode(SSdbRaw *pRaw) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_OUT_OF_MEMORY;
   SSdbRow     *pRow = NULL;
   SMqTopicObj *pTopic = NULL;

source/dnode/mnode/impl/src/mndTrans.c

@@ -105,6 +105,8 @@ static int32_t mndTransGetActionsSize(SArray *pArray) {
 }
 
 static int32_t mndTransEncodeAction(SSdbRaw *pRaw, int32_t *offset, SArray *pActions, int32_t actionsNum) {
+  int32_t code = 0;
+  int32_t lino = 0;
   int32_t dataPos = *offset;
   int8_t  unused = 0;
   int32_t ret = -1;
@@ -142,6 +144,8 @@ _OVER:
 }
 
 SSdbRaw *mndTransEncode(STrans *pTrans) {
+  int32_t code = 0;
+  int32_t lino = 0;
   terrno = TSDB_CODE_INVALID_MSG;
   int8_t sver = taosArrayGetSize(pTrans->prepareActions) ? TRANS_VER2_NUMBER : TRANS_VER1_NUMBER;
 
@@ -225,6 +229,8 @@ _OVER:
 }
 
 static int32_t mndTransDecodeAction(SSdbRaw *pRaw, int32_t *offset, SArray *pActions, int32_t actionNum) {
+  int32_t      code = 0;
+  int32_t      lino = 0;
   STransAction action = {0};
   int32_t      dataPos = *offset;
   int8_t       unused = 0;
@@ -279,7 +285,8 @@ _OVER:
 
 SSdbRow *mndTransDecode(SSdbRaw *pRaw) {
   terrno = TSDB_CODE_INVALID_MSG;
-
+  int32_t code = 0;
+  int32_t lino = 0;
   SSdbRow *pRow = NULL;
   STrans  *pTrans = NULL;
   char    *pData = NULL;
@@ -541,8 +548,7 @@ static int32_t mndTransActionUpdate(SSdb *pSdb, STrans *pOld, STrans *pNew) {
            pOld->id, pOld, mndTransStr(pOld->stage), pOld->createdTime, pNew, mndTransStr(pNew->stage),
            pNew->createdTime);
     // only occured while sync timeout
-    terrno = TSDB_CODE_MND_TRANS_SYNC_TIMEOUT;
+    TAOS_RETURN(TSDB_CODE_MND_TRANS_SYNC_TIMEOUT);
-    return -1;
   }
 
   mndTransUpdateActions(pOld->prepareActions, pNew->prepareActions);
@@ -660,8 +666,7 @@ static int32_t mndTransAppendAction(SArray *pArray, STransAction *pAction) {
 
   void *ptr = taosArrayPush(pArray, pAction);
   if (ptr == NULL) {
-    terrno = TSDB_CODE_OUT_OF_MEMORY;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
-    return -1;
   }
 
   return 0;
@@ -772,26 +777,29 @@ void mndTransSetChangeless(STrans *pTrans) { pTrans->changeless = true; }
 void mndTransSetOper(STrans *pTrans, EOperType oper) { pTrans->oper = oper; }
 
 static int32_t mndTransSync(SMnode *pMnode, STrans *pTrans) {
+  int32_t  code = 0;
   SSdbRaw *pRaw = mndTransEncode(pTrans);
   if (pRaw == NULL) {
-    mError("trans:%d, failed to encode while sync trans since %s", pTrans->id, terrstr());
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
-    return -1;
+    if (terrno != 0) code = terrno;
+    mError("trans:%d, failed to encode while sync trans since %s", pTrans->id, tstrerror(code));
+    TAOS_RETURN(code);
   }
   (void)sdbSetRawStatus(pRaw, SDB_STATUS_READY);
 
   mInfo("trans:%d, sync to other mnodes, stage:%s createTime:%" PRId64, pTrans->id, mndTransStr(pTrans->stage),
         pTrans->createdTime);
-  int32_t code = mndSyncPropose(pMnode, pRaw, pTrans->id);
+  code = mndSyncPropose(pMnode, pRaw, pTrans->id);
   if (code != 0) {
-    mError("trans:%d, failed to sync, errno:%s code:0x%x createTime:%" PRId64 " saved trans:%d", pTrans->id, terrstr(),
+    mError("trans:%d, failed to sync, errno:%s code:0x%x createTime:%" PRId64 " saved trans:%d", pTrans->id,
-           code, pTrans->createdTime, pMnode->syncMgmt.transId);
+           tstrerror(code), code, pTrans->createdTime, pMnode->syncMgmt.transId);
     sdbFreeRaw(pRaw);
-    return -1;
+    TAOS_RETURN(code);
   }
 
   sdbFreeRaw(pRaw);
   mInfo("trans:%d, sync finished, createTime:%" PRId64, pTrans->id, pTrans->createdTime);
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static bool mndCheckDbConflict(const char *conflict, STrans *pTrans) {
@@ -883,24 +891,26 @@ static bool mndCheckTransConflict(SMnode *pMnode, STrans *pNew) {
 }
 
 int32_t mndTransCheckConflict(SMnode *pMnode, STrans *pTrans) {
+  int32_t code = 0;
   if (pTrans->conflict == TRN_CONFLICT_DB || pTrans->conflict == TRN_CONFLICT_DB_INSIDE) {
     if (strlen(pTrans->dbname) == 0 && strlen(pTrans->stbname) == 0) {
-      terrno = TSDB_CODE_MND_TRANS_CONFLICT;
+      code = TSDB_CODE_MND_TRANS_CONFLICT;
       mError("trans:%d, failed to prepare conflict db not set", pTrans->id);
-      return -1;
+      TAOS_RETURN(code);
     }
   }
 
   if (mndCheckTransConflict(pMnode, pTrans)) {
-    terrno = TSDB_CODE_MND_TRANS_CONFLICT;
+    code = TSDB_CODE_MND_TRANS_CONFLICT;
-    mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
+    mError("trans:%d, failed to prepare since %s", pTrans->id, tstrerror(code));
-    return terrno;
+    TAOS_RETURN(code);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndTransCheckConflictWithCompact(SMnode *pMnode, STrans *pTrans) {
+  int32_t      code = 0;
   void        *pIter = NULL;
   bool         conflict = false;
   SCompactObj *pCompact = NULL;
@@ -927,12 +937,12 @@ int32_t mndTransCheckConflictWithCompact(SMnode *pMnode, STrans *pTrans) {
   }
 
   if (conflict) {
-    terrno = TSDB_CODE_MND_TRANS_CONFLICT_COMPACT;
+    code = TSDB_CODE_MND_TRANS_CONFLICT_COMPACT;
-    mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
+    mError("trans:%d, failed to prepare since %s", pTrans->id, tstrerror(code));
-    return terrno;
+    TAOS_RETURN(code);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static bool mndTransActionsOfSameType(SArray *pActions) {
@@ -953,66 +963,65 @@ static bool mndTransActionsOfSameType(SArray *pActions) {
 }
 
 static int32_t mndTransCheckParallelActions(SMnode *pMnode, STrans *pTrans) {
+  int32_t code = 0;
   if (pTrans->exec == TRN_EXEC_PARALLEL) {
     if (mndTransActionsOfSameType(pTrans->redoActions) == false) {
-      terrno = TSDB_CODE_MND_TRANS_INVALID_STAGE;
+      code = TSDB_CODE_MND_TRANS_INVALID_STAGE;
       mError("trans:%d, types of parallel redo actions are not the same", pTrans->id);
-      return -1;
+      TAOS_RETURN(code);
     }
 
     if (pTrans->policy == TRN_POLICY_ROLLBACK) {
       if (mndTransActionsOfSameType(pTrans->undoActions) == false) {
-        terrno = TSDB_CODE_MND_TRANS_INVALID_STAGE;
+        code = TSDB_CODE_MND_TRANS_INVALID_STAGE;
         mError("trans:%d, types of parallel undo actions are not the same", pTrans->id);
-        return -1;
+        TAOS_RETURN(code);
       }
     }
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndTransCheckCommitActions(SMnode *pMnode, STrans *pTrans) {
+  int32_t code = 0;
   if (!pTrans->changeless && taosArrayGetSize(pTrans->commitActions) <= 0) {
-    terrno = TSDB_CODE_MND_TRANS_CLOG_IS_NULL;
+    code = TSDB_CODE_MND_TRANS_CLOG_IS_NULL;
     mError("trans:%d, commit actions of non-changeless trans are empty", pTrans->id);
-    return -1;
+    TAOS_RETURN(code);
   }
   if (mndTransActionsOfSameType(pTrans->commitActions) == false) {
-    terrno = TSDB_CODE_MND_TRANS_INVALID_STAGE;
+    code = TSDB_CODE_MND_TRANS_INVALID_STAGE;
     mError("trans:%d, types of commit actions are not the same", pTrans->id);
-    return -1;
+    TAOS_RETURN(code);
   }
 
-  return 0;
+  TAOS_RETURN(code);
 }
 
 int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans) {
+  int32_t code = 0;
   if (pTrans == NULL) return -1;
 
-  if (mndTransCheckConflict(pMnode, pTrans) != 0) {
+  TAOS_CHECK_RETURN(mndTransCheckConflict(pMnode, pTrans));
-    return -1;
-  }
 
-  if (mndTransCheckParallelActions(pMnode, pTrans) != 0) {
+  TAOS_CHECK_RETURN(mndTransCheckParallelActions(pMnode, pTrans));
-    return -1;
-  }
 
-  if (mndTransCheckCommitActions(pMnode, pTrans) != 0) {
+  TAOS_CHECK_RETURN(mndTransCheckCommitActions(pMnode, pTrans));
-    return -1;
-  }
 
   mInfo("trans:%d, prepare transaction", pTrans->id);
-  if (mndTransSync(pMnode, pTrans) != 0) {
+  if ((code = mndTransSync(pMnode, pTrans)) != 0) {
-    mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr());
+    mError("trans:%d, failed to prepare since %s", pTrans->id, tstrerror(code));
-    return -1;
+    TAOS_RETURN(code);
   }
   mInfo("trans:%d, prepare finished", pTrans->id);
 
   STrans *pNew = mndAcquireTrans(pMnode, pTrans->id);
   if (pNew == NULL) {
-    mError("trans:%d, failed to read from sdb since %s", pTrans->id, terrstr());
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
-    return -1;
+    if (terrno != 0) code = terrno;
+    mError("trans:%d, failed to read from sdb since %s", pTrans->id, tstrerror(code));
+    TAOS_RETURN(code);
   }
 
   pNew->pRpcArray = pTrans->pRpcArray;
@@ -1025,37 +1034,41 @@ int32_t mndTransPrepare(SMnode *pMnode, STrans *pTrans) {
 
   mndTransExecute(pMnode, pNew);
   mndReleaseTrans(pMnode, pNew);
+  // TDOD change to TAOS_RETURN(code);
   return 0;
 }
 
 static int32_t mndTransCommit(SMnode *pMnode, STrans *pTrans) {
+  int32_t code = 0;
   mInfo("trans:%d, commit transaction", pTrans->id);
-  if (mndTransSync(pMnode, pTrans) != 0) {
+  if ((code = mndTransSync(pMnode, pTrans)) != 0) {
-    mError("trans:%d, failed to commit since %s", pTrans->id, terrstr());
+    mError("trans:%d, failed to commit since %s", pTrans->id, tstrerror(code));
-    return -1;
+    TAOS_RETURN(code);
   }
   mInfo("trans:%d, commit finished", pTrans->id);
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndTransRollback(SMnode *pMnode, STrans *pTrans) {
+  int32_t code = 0;
   mInfo("trans:%d, rollback transaction", pTrans->id);
-  if (mndTransSync(pMnode, pTrans) != 0) {
+  if ((code = mndTransSync(pMnode, pTrans)) != 0) {
-    mError("trans:%d, failed to rollback since %s", pTrans->id, terrstr());
+    mError("trans:%d, failed to rollback since %s", pTrans->id, tstrerror(code));
-    return -1;
+    TAOS_RETURN(code);
   }
   mInfo("trans:%d, rollback finished", pTrans->id);
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndTransPreFinish(SMnode *pMnode, STrans *pTrans) {
+  int32_t code = 0;
   mInfo("trans:%d, pre-finish transaction", pTrans->id);
-  if (mndTransSync(pMnode, pTrans) != 0) {
+  if ((code = mndTransSync(pMnode, pTrans)) != 0) {
-    mError("trans:%d, failed to pre-finish since %s", pTrans->id, terrstr());
+    mError("trans:%d, failed to pre-finish since %s", pTrans->id, tstrerror(code));
-    return -1;
+    TAOS_RETURN(code);
   }
   mInfo("trans:%d, pre-finish finished", pTrans->id);
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static void mndTransSendRpcRsp(SMnode *pMnode, STrans *pTrans) {
@@ -1161,6 +1174,7 @@ static void mndTransSendRpcRsp(SMnode *pMnode, STrans *pTrans) {
 }
 
 int32_t mndTransProcessRsp(SRpcMsg *pRsp) {
+  int32_t code = 0;
   SMnode *pMnode = pRsp->info.node;
   int64_t signature = (int64_t)(pRsp->info.ahandle);
   int32_t transId = (int32_t)(signature >> 32);
@@ -1168,7 +1182,9 @@ int32_t mndTransProcessRsp(SRpcMsg *pRsp) {
 
   STrans *pTrans = mndAcquireTrans(pMnode, transId);
   if (pTrans == NULL) {
-    mError("trans:%d, failed to get transId from vnode rsp since %s", transId, terrstr());
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
+    mError("trans:%d, failed to get transId from vnode rsp since %s", transId, tstrerror(code));
     goto _OVER;
   }
 
@@ -1209,7 +1225,7 @@ int32_t mndTransProcessRsp(SRpcMsg *pRsp) {
 
 _OVER:
   mndReleaseTrans(pMnode, pTrans);
-  return 0;
+  TAOS_RETURN(code);
 }
 
 static void mndTransResetAction(SMnode *pMnode, STrans *pTrans, STransAction *pAction) {
@@ -1245,8 +1261,7 @@ static void mndTransResetActions(SMnode *pMnode, STrans *pTrans, SArray *pArray)
 static int32_t mndTransWriteSingleLog(SMnode *pMnode, STrans *pTrans, STransAction *pAction, bool topHalf) {
   if (pAction->rawWritten) return 0;
   if (topHalf) {
-    terrno = TSDB_CODE_MND_TRANS_CTX_SWITCH;
+    TAOS_RETURN(TSDB_CODE_MND_TRANS_CTX_SWITCH);
-    return TSDB_CODE_MND_TRANS_CTX_SWITCH;
   }
 
   int32_t code = sdbWriteWithoutFree(pMnode->pSdb, pAction->pRaw);
@@ -1265,15 +1280,14 @@ static int32_t mndTransWriteSingleLog(SMnode *pMnode, STrans *pTrans, STransActi
     mndSetTransLastAction(pTrans, pAction);
   }
 
-  return code;
+  TAOS_RETURN(code);
 }
 
 // execute at top half
 static int32_t mndTransSendSingleMsg(SMnode *pMnode, STrans *pTrans, STransAction *pAction, bool topHalf) {
   if (pAction->msgSent) return 0;
   if (mndCannotExecuteTransAction(pMnode, topHalf)) {
-    terrno = TSDB_CODE_MND_TRANS_CTX_SWITCH;
+    TAOS_RETURN(TSDB_CODE_MND_TRANS_CTX_SWITCH);
-    return TSDB_CODE_MND_TRANS_CTX_SWITCH;
   }
 
   int64_t signature = pTrans->id;
@@ -1317,7 +1331,7 @@ static int32_t mndTransSendSingleMsg(SMnode *pMnode, STrans *pTrans, STransActio
     mndSetTransLastAction(pTrans, pAction);
   }
 
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndTransExecNullMsg(SMnode *pMnode, STrans *pTrans, STransAction *pAction, bool topHalf) {
@@ -1815,8 +1829,7 @@ int32_t mndKillTrans(SMnode *pMnode, STrans *pTrans) {
   } else if (pTrans->stage == TRN_STAGE_UNDO_ACTION) {
     pArray = pTrans->undoActions;
   } else {
-    terrno = TSDB_CODE_MND_TRANS_INVALID_STAGE;
+    TAOS_RETURN(TSDB_CODE_MND_TRANS_INVALID_STAGE);
-    return -1;
   }
 
   for (int32_t i = 0; i < taosArrayGetSize(pArray); ++i) {
@@ -1839,17 +1852,19 @@ static int32_t mndProcessKillTransReq(SRpcMsg *pReq) {
   STrans       *pTrans = NULL;
 
   if (tDeserializeSKillTransReq(pReq->pCont, pReq->contLen, &killReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
+    code = TSDB_CODE_INVALID_MSG;
     goto _OVER;
   }
 
   mInfo("trans:%d, start to kill", killReq.transId);
-  if (mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_KILL_TRANS) != 0) {
+  if ((code = mndCheckOperPrivilege(pMnode, pReq->info.conn.user, MND_OPER_KILL_TRANS)) != 0) {
     goto _OVER;
   }
 
   pTrans = mndAcquireTrans(pMnode, killReq.transId);
   if (pTrans == NULL) {
+    code = TSDB_CODE_MND_RETURN_VALUE_NULL;
+    if (terrno != 0) code = terrno;
     goto _OVER;
   }
 
@@ -1861,7 +1876,7 @@ _OVER:
   }
 
   mndReleaseTrans(pMnode, pTrans);
-  return code;
+  TAOS_RETURN(code);
 }
 
 static int32_t mndCompareTransId(int32_t *pTransId1, int32_t *pTransId2) { return *pTransId1 >= *pTransId2 ? 1 : 0; }

source/dnode/mnode/impl/src/mndView.c

@@ -43,18 +43,15 @@ int32_t mndInitView(SMnode *pMnode) {
 #endif
 }
 
-void mndCleanupView(SMnode *pMnode) {
+void mndCleanupView(SMnode *pMnode) { mDebug("mnd view cleanup"); }
-  mDebug("mnd view cleanup");
-}
 
 int32_t mndProcessCreateViewReq(SRpcMsg *pReq) {
 #ifndef TD_ENTERPRISE
   return TSDB_CODE_OPS_NOT_SUPPORT;
 #else
-  SCMCreateViewReq   createViewReq = {0};
+  SCMCreateViewReq createViewReq = {0};
   if (tDeserializeSCMCreateViewReq(pReq->pCont, pReq->contLen, &createViewReq) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
+    TAOS_RETURN(TSDB_CODE_INVALID_MSG);
-    return -1;
   }
 
   mInfo("start to create view:%s, sql:%s", createViewReq.fullname, createViewReq.sql);
@@ -65,17 +62,16 @@ int32_t mndProcessCreateViewReq(SRpcMsg *pReq) {
 
 int32_t mndProcessDropViewReq(SRpcMsg *pReq) {
 #ifndef TD_ENTERPRISE
-    return TSDB_CODE_OPS_NOT_SUPPORT;
+  return TSDB_CODE_OPS_NOT_SUPPORT;
 #else
-    SCMDropViewReq dropViewReq = {0};
+  SCMDropViewReq dropViewReq = {0};
-    if (tDeserializeSCMDropViewReq(pReq->pCont, pReq->contLen, &dropViewReq) != 0) {
+  if (tDeserializeSCMDropViewReq(pReq->pCont, pReq->contLen, &dropViewReq) != 0) {
-      terrno = TSDB_CODE_INVALID_MSG;
+    TAOS_RETURN(TSDB_CODE_INVALID_MSG);
-      return -1;
+  }
-    }
+
-  
+  mInfo("start to drop view:%s, sql:%s", dropViewReq.name, dropViewReq.sql);
-    mInfo("start to drop view:%s, sql:%s", dropViewReq.name, dropViewReq.sql);
+
-  
+  return mndProcessDropViewReqImpl(&dropViewReq, pReq);
-    return mndProcessDropViewReqImpl(&dropViewReq, pReq);
 #endif
 }
 
@@ -83,18 +79,16 @@ int32_t mndProcessGetViewMetaReq(SRpcMsg *pReq) {
 #ifndef TD_ENTERPRISE
   return TSDB_CODE_OPS_NOT_SUPPORT;
 #else
-  SViewMetaReq  req = {0};
+  SViewMetaReq req = {0};
 
   if (tDeserializeSViewMetaReq(pReq->pCont, pReq->contLen, &req) != 0) {
-    terrno = TSDB_CODE_INVALID_MSG;
+    TAOS_RETURN(TSDB_CODE_INVALID_MSG);
-    return -1;
   }
 
   return mndProcessViewMetaReqImpl(&req, pReq);
-#endif  
+#endif
 }
 
-
 int32_t mndRetrieveView(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows) {
 #ifndef TD_ENTERPRISE
   return 0;
@@ -107,6 +101,3 @@ void mndCancelGetNextView(SMnode *pMnode, void *pIter) {
   SSdb *pSdb = pMnode->pSdb;
   sdbCancelFetch(pSdb, pIter);
 }
-
-
-

source/dnode/mnode/sdb/inc/sdb.h

@@ -39,18 +39,20 @@ extern "C" {
 
 #define SDB_GET_VAL(pData, dataPos, val, pos, func, type) \
   {                                                       \
-    if (func(pRaw, dataPos, val) != 0) {                  \
+    if ((code = func(pRaw, dataPos, val)) != 0) {         \
+      lino = __LINE__;                                    \
       goto pos;                                           \
     }                                                     \
     dataPos += sizeof(type);                              \
   }
 
-#define SDB_GET_BINARY(pRaw, dataPos, val, valLen, pos)     \
+#define SDB_GET_BINARY(pRaw, dataPos, val, valLen, pos)              \
-  {                                                         \
+  {                                                                  \
-    if (sdbGetRawBinary(pRaw, dataPos, val, valLen) != 0) { \
+    if ((code = sdbGetRawBinary(pRaw, dataPos, val, valLen)) != 0) { \
-      goto pos;                                             \
+      lino = __LINE__;                                               \
-    }                                                       \
+      goto pos;                                                      \
-    dataPos += valLen;                                      \
+    }                                                                \
+    dataPos += valLen;                                               \
   }
 
 #define SDB_GET_INT64(pData, dataPos, val, pos) SDB_GET_VAL(pData, dataPos, val, pos, sdbGetRawInt64, int64_t)
@@ -67,7 +69,8 @@ extern "C" {
 
 #define SDB_SET_VAL(pRaw, dataPos, val, pos, func, type) \
   {                                                      \
-    if (func(pRaw, dataPos, val) != 0) {                 \
+    if ((code = func(pRaw, dataPos, val)) != 0) {        \
+      lino = __LINE__;                                   \
       goto pos;                                          \
     }                                                    \
     dataPos += sizeof(type);                             \
@@ -79,12 +82,13 @@ extern "C" {
 #define SDB_SET_INT8(pRaw, dataPos, val, pos)  SDB_SET_VAL(pRaw, dataPos, val, pos, sdbSetRawInt8, int8_t)
 #define SDB_SET_UINT8(pRaw, dataPos, val, pos) SDB_SET_VAL(pRaw, dataPos, val, pos, sdbSetRawUInt8, uint8_t)
 
-#define SDB_SET_BINARY(pRaw, dataPos, val, valLen, pos)     \
+#define SDB_SET_BINARY(pRaw, dataPos, val, valLen, pos)              \
-  {                                                         \
+  {                                                                  \
-    if (sdbSetRawBinary(pRaw, dataPos, val, valLen) != 0) { \
+    if ((code = sdbSetRawBinary(pRaw, dataPos, val, valLen)) != 0) { \
-      goto pos;                                             \
+      lino = __LINE__;                                               \
-    }                                                       \
+      goto pos;                                                      \
-    dataPos += valLen;                                      \
+    }                                                                \
+    dataPos += valLen;                                               \
   }
 
 #define SDB_SET_RESERVE(pRaw, dataPos, valLen, pos) \
@@ -93,11 +97,12 @@ extern "C" {
     SDB_SET_BINARY(pRaw, dataPos, val, valLen, pos) \
   }
 
-#define SDB_SET_DATALEN(pRaw, dataLen, pos)     \
+#define SDB_SET_DATALEN(pRaw, dataLen, pos)              \
-  {                                             \
+  {                                                      \
-    if (sdbSetRawDataLen(pRaw, dataLen) != 0) { \
+    if ((code = sdbSetRawDataLen(pRaw, dataLen)) != 0) { \
-      goto pos;                                 \
+      lino = __LINE__;                                   \
-    }                                           \
+      goto pos;                                          \
+    }                                                    \
   }
 
 typedef struct SMnode  SMnode;

source/dnode/mnode/sdb/src/sdb.c

@@ -136,15 +136,14 @@ int32_t sdbSetTable(SSdb *pSdb, SSdbTable table) {
 
   SHashObj *hash = taosHashInit(64, taosGetDefaultHashFunction(hashType), true, HASH_ENTRY_LOCK);
   if (hash == NULL) {
-    code = TSDB_CODE_OUT_OF_MEMORY;
+    TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
-    TAOS_RETURN(code);
   }
 
   pSdb->maxId[sdbType] = 0;
   pSdb->hashObjs[sdbType] = hash;
   mInfo("sdb table:%s is initialized", sdbTableName(sdbType));
 
-  return 0;
+  TAOS_RETURN(0);
 }
 
 static int32_t sdbCreateDir(SSdb *pSdb) {