Merge branch 'test/ci-sh-3.0' of github.com:taosdata/TDengine into test/ci-sh-3.0

docs/examples/rust/restexample/examples/tmq.rs

@@ -83,7 +83,6 @@ async fn main() -> anyhow::Result<()> {
                     eprintln!("Failed to execute insert: {:?}", e);
                 }
                 tokio::time::sleep(Duration::from_millis(10)).await;
-                println!("Succed to execute insert 1 row");
             }
         });
     });

docs/zh/05-basic/03-query.md

@@ -181,7 +181,7 @@ INTERVAL(interval_val [, interval_offset])
 - FILL：用于指定窗口区间数据缺失的情况下，数据的填充模式。
 
 对于时间窗口，interval_val 和 sliding_val 都表示时间段， 语法上支持三种方式。例如：
-1. INTERVAL(1s, 500a) SLIDING(1s)，带时间单位的形式，其中的时间单位是单字符表示， 分别为： a （毫秒）， b （纳秒）， d （天）， h （小时）， m （分钟）， n （月）， s （秒）， u （微妙）， w （周）， y （年）；
+1. INTERVAL(1s, 500a) SLIDING(1s)，带时间单位的形式，其中的时间单位是单字符表示， 分别为： a （毫秒）， b （纳秒）， d （天）， h （小时）， m （分钟）， n （月）， s （秒）， u （微秒）， w （周）， y （年）；
 2. INTERVAL(1000, 500) SLIDING(1000)，不带时间单位的形式，将使用查询库的时间精度作为默认时间单位，当存在多个库时默认采用精度更高的库；
 3. INTERVAL('1s', '500a') SLIDING('1s')，带时间单位的字符串形式，字符串内部不能有任何空格等其它字符。
 

docs/zh/07-develop/index.md

@@ -14,7 +14,8 @@ description: 让开发者能够快速上手的指南
 7. 在很多场景下（如车辆管理），应用需要获取每个数据采集点的最新状态，那么建议你采用 TDengine 的 Cache 功能，而不用单独部署 Redis 等缓存软件。
 8. 如果你发现 TDengine 的函数无法满足你的要求，那么你可以使用用户自定义函数（UDF）来解决问题。
 
-本部分内容就是按照上述顺序组织的。为便于理解，TDengine 为每个功能和每个支持的编程语言都提供了示例代码。如果你希望深入了解 SQL 的使用，需要查看[SQL 手册](../reference/taos-sql/)。如果想更深入地了解各连接器的使用，请阅读[连接器参考指南](../reference/connector/)。如果还希望想将 TDengine 与第三方系统集成起来，比如 Grafana, 请参考[第三方工具](../third-party/)。
+本部分内容就是按照上述顺序组织的。为便于理解，TDengine 为每个功能和每个支持的编程语言都提供了示例代码，位于 [示例代码](https://github.com/taosdata/TDengine/tree/main/docs/examples)。所有示例代码都会有 CI 保证正确性，脚本位于 [示例代码 CI](https://github.com/taosdata/TDengine/tree/main/tests/docs-examples-test)。
+如果你希望深入了解 SQL 的使用，需要查看[SQL 手册](../reference/taos-sql/)。如果想更深入地了解各连接器的使用，请阅读[连接器参考指南](../reference/connector/)。如果还希望想将 TDengine 与第三方系统集成起来，比如 Grafana, 请参考[第三方工具](../third-party/)。
 
 如果在开发过程中遇到任何问题，请点击每个页面下方的["反馈问题"](https://github.com/taosdata/TDengine/issues/new/choose), 在 GitHub 上直接递交 Issue。
 

docs/zh/14-reference/03-taos-sql/02-database.md

@@ -80,7 +80,6 @@ database_option: {
 
 ```sql
 create database if not exists db vgroups 10 buffer 10
-
 ```
 
 以上示例创建了一个有 10 个 vgroup 名为 db 的数据库， 其中每个 vnode 分配 10MB 的写入缓存

docs/zh/14-reference/03-taos-sql/10-function.md

@@ -1214,7 +1214,7 @@ TO_TIMESTAMP(ts_str_literal, format_str_literal)
 - 如果没有指定完整的时间，那么默认时间值为指定或默认时区的 `1970-01-01 00:00:00`, 未指定部分使用该默认值中的对应部分. 暂不支持只指定年日而不指定月日的格式, 如'yyyy-mm-DDD', 支持'yyyy-mm-DD'.
 - 如果格式串中有`AM`, `PM`等, 那么小时必须是12小时制, 范围必须是01-12.
 - `to_timestamp`转换具有一定的容错机制, 在格式串和时间戳串不完全对应时, 有时也可转换, 如: `to_timestamp('200101/2', 'yyyyMM1/dd')`, 格式串中多出来的1会被丢弃. 格式串与时间戳串中多余的空格字符(空格, tab等)也会被 自动忽略. 如`to_timestamp('  23 年 - 1 月 - 01 日  ', 'yy 年-MM月-dd日')` 可以被成功转换. 虽然`MM`等字段需要两个数字对应(只有一位时前面补0), 在`to_timestamp`时, 一个数字也可以成功转换.
-- 输出时间戳的精度与查询表的精度相同, 若查询未指定表, 则输出精度为毫秒. 如`select to_timestamp('2023-08-1 10:10:10.123456789', 'yyyy-mm-dd hh:mi:ss.ns')`的输出将会把微妙和纳秒进行截断. 如果指定一张纳秒表, 那么就不会发生截断, 如`select to_timestamp('2023-08-1 10:10:10.123456789', 'yyyy-mm-dd hh:mi:ss.ns') from db_ns.table_ns limit 1`.
+- 输出时间戳的精度与查询表的精度相同, 若查询未指定表, 则输出精度为毫秒. 如`select to_timestamp('2023-08-1 10:10:10.123456789', 'yyyy-mm-dd hh:mi:ss.ns')`的输出将会把微秒和纳秒进行截断. 如果指定一张纳秒表, 那么就不会发生截断, 如`select to_timestamp('2023-08-1 10:10:10.123456789', 'yyyy-mm-dd hh:mi:ss.ns') from db_ns.table_ns limit 1`.
 
 
 ### 时间和日期函数

docs/zh/14-reference/03-taos-sql/16-operators.md

@@ -41,9 +41,11 @@ TDengine 支持 `UNION ALL` 和 `UNION` 操作符。UNION ALL 将查询返回的
 | 5   |   IS [NOT] NULL   | 所有类型                                                             | 是否为空值           |
 | 6   | [NOT] BETWEEN AND | 除 BOOL、BLOB、MEDIUMBLOB、JSON 和 GEOMETRY 外的所有类型                | 闭区间比较           |
 | 7   |        IN         | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型，且不可以为表的时间戳主键列 | 与列表内的任意值相等 |
-| 8   |       LIKE        | BINARY、NCHAR 和 VARCHAR                                             | 通配符匹配           |
+| 8  |      NOT  IN         | 除 BLOB、MEDIUMBLOB 和 JSON 外的所有类型，且不可以为表的时间戳主键列 | 与列表内的任意值都不相等 |
-| 9   |   MATCH, NMATCH   | BINARY、NCHAR 和 VARCHAR                                             | 正则表达式匹配       |
+| 9   |       LIKE        | BINARY、NCHAR 和 VARCHAR                                             | 通配符匹配所指定的模式串          |
-| 10  |     CONTAINS      | JSON                                                                 | JSON 中是否存在某键  |
+| 10   |      NOT LIKE        | BINARY、NCHAR 和 VARCHAR                                             | 通配符不匹配所指定的模式串           |
+| 11   |   MATCH, NMATCH   | BINARY、NCHAR 和 VARCHAR                                             | 正则表达式匹配       |
+| 12  |     CONTAINS      | JSON                                                                 | JSON 中是否存在某键  |
 
 LIKE 条件使用通配符字符串进行匹配检查，规则如下：
 

docs/zh/14-reference/03-taos-sql/28-index.md

@@ -28,7 +28,7 @@ TSMA只能基于超级表和普通表创建, 不能基于子表创建.
 
 由于TSMA输出为一张超级表, 因此输出表的行长度受最大行长度限制, 不同函数的`中间结果`大小各异, 一般都大于原始数据大小, 若输出表的行长度大于最大行长度限制, 将会报`Row length exceeds max length`错误. 此时需要减少函数个数或者将常用的函数进行分组拆分到多个TSMA中.
 
-窗口大小的限制为[1m ~ 1y/12n]. INTERVAL 的单位与查询中INTERVAL子句相同, 如 a (毫秒), b (纳秒), h (小时), m (分钟), s (秒), u (微妙), d (天), w(周), n(月), y(年).
+窗口大小的限制为[1m ~ 1y/12n]. INTERVAL 的单位与查询中INTERVAL子句相同, 如 a (毫秒), b (纳秒), h (小时), m (分钟), s (秒), u (微秒), d (天), w(周), n(月), y(年).
 
 TSMA为库内对象, 但名字全局唯一. 集群内一共可创建TSMA个数受参数`maxTsmaNum`限制, 参数默认值为3, 范围: [0-3]. 注意, 由于TSMA后台计算使用流计算, 因此每创建一条TSMA, 将会创建一条流, 因此能够创建的TSMA条数也受当前已经存在的流条数和最大可创建流条数限制.
 

include/common/tdataformat.h

@@ -115,7 +115,7 @@ typedef struct {
 } SValueColumnCompressInfo;
 
 int32_t tValueColumnInit(SValueColumn *valCol);
-int32_t tValueColumnDestroy(SValueColumn *valCol);
+void    tValueColumnDestroy(SValueColumn *valCol);
 void    tValueColumnClear(SValueColumn *valCol);
 int32_t tValueColumnAppend(SValueColumn *valCol, const SValue *value);
 int32_t tValueColumnUpdate(SValueColumn *valCol, int32_t idx, const SValue *value);

source/client/src/clientImpl.c

@@ -679,9 +679,15 @@ _return:
   return TSDB_CODE_SUCCESS;
 }
 
+void freeVgList(void* list) {
+  SArray* pList = *(SArray**)list;
+  taosArrayDestroy(pList);
+}
+
 int32_t buildAsyncExecNodeList(SRequestObj* pRequest, SArray** pNodeList, SArray* pMnodeList, SMetaData* pResultMeta) {
   SArray* pDbVgList = NULL;
   SArray* pQnodeList = NULL;
+  FDelete fp = NULL;
   int32_t code = 0;
 
   switch (tsQueryPolicy) {
@@ -705,6 +711,43 @@ int32_t buildAsyncExecNodeList(SRequestObj* pRequest, SArray** pNodeList, SArray
             goto _return;
           }
         }
+      } else {
+        fp = freeVgList;
+
+        int32_t dbNum = taosArrayGetSize(pRequest->dbList);
+        if (dbNum > 0) {
+          SCatalog*     pCtg = NULL;
+          SAppInstInfo* pInst = pRequest->pTscObj->pAppInfo;
+          code = catalogGetHandle(pInst->clusterId, &pCtg);
+          if (code != TSDB_CODE_SUCCESS) {
+            goto _return;
+          }
+
+          pDbVgList = taosArrayInit(dbNum, POINTER_BYTES);
+          if (NULL == pDbVgList) {
+            code = terrno;
+            goto _return;
+          }
+          SArray* pVgList = NULL;
+          for (int32_t i = 0; i < dbNum; ++i) {
+            char*            dbFName = taosArrayGet(pRequest->dbList, i);
+            SRequestConnInfo conn = {.pTrans = pInst->pTransporter,
+                                     .requestId = pRequest->requestId,
+                                     .requestObjRefId = pRequest->self,
+                                     .mgmtEps = getEpSet_s(&pInst->mgmtEp)};
+
+            // catalogGetDBVgList will handle dbFName == null.
+            code = catalogGetDBVgList(pCtg, &conn, dbFName, &pVgList);
+            if (code) {
+              goto _return;
+            }
+
+            if (NULL == taosArrayPush(pDbVgList, &pVgList)) {
+              code = terrno;
+              goto _return;
+            }
+          }
+        }
       }
 
       code = buildVnodePolicyNodeList(pRequest, pNodeList, pMnodeList, pDbVgList);
@@ -745,17 +788,12 @@ int32_t buildAsyncExecNodeList(SRequestObj* pRequest, SArray** pNodeList, SArray
   }
 
 _return:
-  taosArrayDestroy(pDbVgList);
+  taosArrayDestroyEx(pDbVgList, fp);
   taosArrayDestroy(pQnodeList);
 
   return code;
 }
 
-void freeVgList(void* list) {
-  SArray* pList = *(SArray**)list;
-  taosArrayDestroy(pList);
-}
-
 int32_t buildSyncExecNodeList(SRequestObj* pRequest, SArray** pNodeList, SArray* pMnodeList) {
   SArray* pDbVgList = NULL;
   SArray* pQnodeList = NULL;

source/client/src/clientStmt2.c

@@ -1873,6 +1873,8 @@ int stmtGetParamNum2(TAOS_STMT2* stmt, int* nums) {
 
 int stmtGetParamTbName(TAOS_STMT2* stmt, int* nums) {
   STscStmt2* pStmt = (STscStmt2*)stmt;
+  int32_t    code = 0;
+  int32_t    preCode = pStmt->errCode;
 
   STMT_DLOG_E("start to get param num");
 
@@ -1895,17 +1897,19 @@ int stmtGetParamTbName(TAOS_STMT2* stmt, int* nums) {
   STMT_ERR_RET(stmtCreateRequest(pStmt));
 
   if (pStmt->bInfo.needParse) {
-    STMT_ERR_RET(stmtParseSql(pStmt));
+    STMT_ERRI_JRET(stmtParseSql(pStmt));
   }
 
-  if (TSDB_CODE_TSC_STMT_TBNAME_ERROR == pStmt->errCode) {
+  *nums = STMT_TYPE_MULTI_INSERT == pStmt->sql.type ? 1 : 0;
+
+_return:
+  if (TSDB_CODE_TSC_STMT_TBNAME_ERROR == code) {
     *nums = 1;
-    pStmt->errCode = TSDB_CODE_SUCCESS;
+    code = TSDB_CODE_SUCCESS;
-  } else {
-    *nums = STMT_TYPE_MULTI_INSERT == pStmt->sql.type ? 1 : 0;
   }
 
-  return TSDB_CODE_SUCCESS;
+  pStmt->errCode = preCode;
+  return code;
 }
 /*
 int stmtGetParam(TAOS_STMT* stmt, int idx, int* type, int* bytes) {

source/common/src/tdataformat.c

@@ -4171,12 +4171,12 @@ int32_t tValueColumnInit(SValueColumn *valCol) {
   return 0;
 }
 
-int32_t tValueColumnDestroy(SValueColumn *valCol) {
+void tValueColumnDestroy(SValueColumn *valCol) {
   valCol->type = TSDB_DATA_TYPE_NULL;
   valCol->numOfValues = 0;
   tBufferDestroy(&valCol->data);
   tBufferDestroy(&valCol->offsets);
-  return 0;
+  return;
 }
 
 void tValueColumnClear(SValueColumn *valCol) {

source/dnode/vnode/src/inc/tsdb.h

@@ -292,7 +292,7 @@ int32_t tsdbReadDelData(SDelFReader *pReader, SDelIdx *pDelIdx, SArray *aDelData
 int32_t tsdbReadDelIdx(SDelFReader *pReader, SArray *aDelIdx);
 
 // tsdbRead.c ==============================================================================================
-int32_t tsdbTakeReadSnap2(STsdbReader *pReader, _query_reseek_func_t reseek, STsdbReadSnap **ppSnap, const char* id);
+int32_t tsdbTakeReadSnap2(STsdbReader *pReader, _query_reseek_func_t reseek, STsdbReadSnap **ppSnap, const char *id);
 void    tsdbUntakeReadSnap2(STsdbReader *pReader, STsdbReadSnap *pSnap, bool proactive);
 int32_t tsdbGetTableSchema(SMeta *pMeta, int64_t uid, STSchema **pSchema, int64_t *suid);
 
@@ -1069,6 +1069,13 @@ int32_t      tsdbSnapPrepDescription(SVnode *pVnode, SSnapshot *pSnap);
 
 void tsdbRemoveFile(const char *path);
 
+#define taosCloseFileWithLog(fd)         \
+  do {                                   \
+    if (taosCloseFile(fd) < 0) {         \
+      tsdbTrace("failed to close file"); \
+    }                                    \
+  } while (0)
+
 #ifdef __cplusplus
 }
 #endif

source/dnode/vnode/src/meta/metaCache.c

@@ -216,7 +216,7 @@ void metaCacheClose(SMeta* pMeta) {
   }
 }
 
-static int32_t metaRehashCache(SMetaCache* pCache, int8_t expand) {
+static void metaRehashCache(SMetaCache* pCache, int8_t expand) {
   int32_t code = 0;
   int32_t nBucket;
 
@@ -228,8 +228,7 @@ static int32_t metaRehashCache(SMetaCache* pCache, int8_t expand) {
 
   SMetaCacheEntry** aBucket = (SMetaCacheEntry**)taosMemoryCalloc(nBucket, sizeof(SMetaCacheEntry*));
   if (aBucket == NULL) {
-    code = terrno;
+    return;
-    goto _exit;
   }
 
   // rehash
@@ -250,9 +249,7 @@ static int32_t metaRehashCache(SMetaCache* pCache, int8_t expand) {
   taosMemoryFree(pCache->sEntryCache.aBucket);
   pCache->sEntryCache.nBucket = nBucket;
   pCache->sEntryCache.aBucket = aBucket;
-
+  return;
-_exit:
-  return code;
 }
 
 int32_t metaCacheUpsert(SMeta* pMeta, SMetaInfo* pInfo) {
@@ -279,7 +276,7 @@ int32_t metaCacheUpsert(SMeta* pMeta, SMetaInfo* pInfo) {
     }
   } else {  // insert
     if (pCache->sEntryCache.nEntry >= pCache->sEntryCache.nBucket) {
-      TAOS_UNUSED(metaRehashCache(pCache, 1));
+      metaRehashCache(pCache, 1);
 
       iBucket = TABS(pInfo->uid) % pCache->sEntryCache.nBucket;
     }
@@ -317,7 +314,7 @@ int32_t metaCacheDrop(SMeta* pMeta, int64_t uid) {
     pCache->sEntryCache.nEntry--;
     if (pCache->sEntryCache.nEntry < pCache->sEntryCache.nBucket / 4 &&
         pCache->sEntryCache.nBucket > META_CACHE_BASE_BUCKET) {
-      TAOS_UNUSED(metaRehashCache(pCache, 0));
+      metaRehashCache(pCache, 0);
     }
   } else {
     code = TSDB_CODE_NOT_FOUND;

source/dnode/vnode/src/meta/metaOpen.c

@@ -60,7 +60,7 @@ int32_t metaOpen(SVnode *pVnode, SMeta **ppMeta, int8_t rollback) {
 
   pMeta->path = (char *)&pMeta[1];
   strcpy(pMeta->path, path);
-  (void)taosRealPath(pMeta->path, NULL, strlen(path) + 1);
+  int32_t ret = taosRealPath(pMeta->path, NULL, strlen(path) + 1);
 
   pMeta->pVnode = pVnode;
 
@@ -98,7 +98,7 @@ int32_t metaOpen(SVnode *pVnode, SMeta **ppMeta, int8_t rollback) {
   TSDB_CHECK_CODE(code, lino, _exit);
 
   sprintf(indexFullPath, "%s/%s", pMeta->path, "invert");
-  TAOS_UNUSED(taosMkDir(indexFullPath));
+  ret = taosMkDir(indexFullPath);
 
   SIndexOpts opts = {.cacheSize = 8 * 1024 * 1024};
   code = indexOpen(&opts, indexFullPath, (SIndex **)&pMeta->pTagIvtIdx);

source/dnode/vnode/src/meta/metaQuery.c

@@ -62,7 +62,10 @@ int metaGetTableEntryByVersion(SMetaReader *pReader, int64_t version, tb_uid_t u
   tDecoderInit(&pReader->coder, pReader->pBuf, pReader->szBuf);
 
   code = metaDecodeEntry(&pReader->coder, &pReader->me);
-  if (code) return code;
+  if (code) {
+    tDecoderClear(&pReader->coder);
+    return code;
+  }
   // taosMemoryFreeClear(pReader->me.colCmpr.pColCmpr);
 
   return 0;
@@ -393,6 +396,7 @@ _query:
   tDecoderInit(&dc, pData, nData);
   int32_t code = metaDecodeEntry(&dc, &me);
   if (code) {
+    tDecoderClear(&dc);
     goto _err;
   }
   if (me.type == TSDB_SUPER_TABLE) {
@@ -1277,7 +1281,11 @@ int32_t metaFilterTableIds(void *pVnode, SMetaFltParam *arg, SArray *pUids) {
 
   tDecoderInit(&dc, pData, nData);
 
-  TAOS_CHECK_GOTO(metaDecodeEntry(&dc, &oStbEntry), NULL, END);
+  code = metaDecodeEntry(&dc, &oStbEntry);
+  if (code) {
+    tDecoderClear(&dc);
+    goto END;
+  }
 
   if (oStbEntry.stbEntry.schemaTag.pSchema == NULL || oStbEntry.stbEntry.schemaTag.pSchema == NULL) {
     TAOS_CHECK_GOTO(TSDB_CODE_INVALID_PARA, NULL, END);

source/dnode/vnode/src/meta/metaSnapshot.c

@@ -605,6 +605,7 @@ int32_t getTableInfoFromSnapshot(SSnapContext* ctx, void** pBuf, int32_t* contLe
   tDecoderInit(&dc, pVal, vLen);
   ret = metaDecodeEntry(&dc, &me);
   if (ret < 0) {
+    tDecoderClear(&dc);
     ret = TAOS_GET_TERRNO(ret);
     goto END;
   }

source/dnode/vnode/src/meta/metaTable.c

@@ -285,7 +285,9 @@ static inline void metaTimeSeriesNotifyCheck(SMeta *pMeta) {
   int64_t deltaTS = nTimeSeries - pMeta->pVnode->config.vndStats.numOfReportedTimeSeries;
   if (deltaTS > tsTimeSeriesThreshold) {
     if (0 == atomic_val_compare_exchange_8(&dmNotifyHdl.state, 1, 2)) {
-      (void)tsem_post(&dmNotifyHdl.sem);
+      if (tsem_post(&dmNotifyHdl.sem) != 0) {
+        metaError("vgId:%d, failed to post semaphore, errno:%d", TD_VID(pMeta->pVnode), errno);
+      }
     }
   }
 #endif
@@ -563,6 +565,7 @@ int metaAlterSTable(SMeta *pMeta, int64_t version, SVCreateStbReq *pReq) {
   if (ret < 0) {
     metaError("vgId:%d, failed to decode stb:%s uid:%" PRId64 " since %s", TD_VID(pMeta->pVnode), pReq->name,
               pReq->suid, tstrerror(ret));
+    tDecoderClear(&dc);
     tdbTbcClose(pTbDbc);
     tdbTbcClose(pUidIdxc);
     return terrno;
@@ -1502,6 +1505,7 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type, tb_uid_t *p
         tDecoderInit(&tdc, tData, tLen);
         int32_t ret = metaDecodeEntry(&tdc, &stbEntry);
         if (ret < 0) {
+          tDecoderClear(&tdc);
           metaError("vgId:%d, failed to decode child table:%s uid:%" PRId64 " since %s", TD_VID(pMeta->pVnode), e.name,
                     e.ctbEntry.suid, tstrerror(ret));
           return ret;
@@ -2397,6 +2401,7 @@ static int metaAddTagIndex(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterTb
   tDecoderInit(&dc, pVal, nVal);
   ret = metaDecodeEntry(&dc, &stbEntry);
   if (ret < 0) {
+    tDecoderClear(&dc);
     goto _err;
   }
 
@@ -2538,6 +2543,7 @@ static int metaDropTagIndex(SMeta *pMeta, int64_t version, SVAlterTbReq *pAlterT
   tDecoderInit(&dc, pVal, nVal);
   ret = metaDecodeEntry(&dc, &stbEntry);
   if (ret < 0) {
+    tDecoderClear(&dc);
     goto _err;
   }
 

source/dnode/vnode/src/sma/smaRollup.c

@@ -89,7 +89,7 @@ void *tdFreeRSmaInfo(SSma *pSma, SRSmaInfo *pInfo) {
       if (pItem->tmrId) {
         smaDebug("vgId:%d, stop fetch timer %p for table %" PRIi64 " level %d", SMA_VID(pSma), pItem->tmrId,
                  pInfo->suid, i + 1);
-        if(!taosTmrStopA(&pItem->tmrId)){
+        if (!taosTmrStopA(&pItem->tmrId)) {
           smaError("vgId:%d, failed to stop fetch timer for table %" PRIi64 " level %d", SMA_VID(pSma), pInfo->suid,
                    i + 1);
         }
@@ -404,7 +404,7 @@ int32_t tdRSmaProcessCreateImpl(SSma *pSma, SRSmaParam *param, int64_t suid, con
   }
 
   STSchema *pTSchema;
-  code = metaGetTbTSchemaNotNull(SMA_META(pSma), suid, -1, 1,  &pTSchema);
+  code = metaGetTbTSchemaNotNull(SMA_META(pSma), suid, -1, 1, &pTSchema);
   TAOS_CHECK_EXIT(code);
   pRSmaInfo->pSma = pSma;
   pRSmaInfo->pTSchema = pTSchema;
@@ -820,7 +820,10 @@ static int32_t tdExecuteRSmaImplAsync(SSma *pSma, int64_t version, const void *p
   int64_t nItems = atomic_fetch_add_64(&pRSmaStat->nBufItems, 1);
 
   if (atomic_load_8(&pInfo->assigned) == 0) {
-    (void)tsem_post(&(pRSmaStat->notEmpty));
+    if (tsem_post(&(pRSmaStat->notEmpty)) != 0) {
+      smaError("vgId:%d, failed to post notEmpty semaphore for rsma %" PRIi64 " since %s", SMA_VID(pSma), suid,
+               tstrerror(terrno));
+    }
   }
 
   // smoothing consume
@@ -1385,7 +1388,8 @@ static void tdRSmaFetchTrigger(void *param, void *tmrId) {
       if (rsmaTriggerStat == TASK_TRIGGER_STAT_PAUSED) {
         bool ret = taosTmrReset(tdRSmaFetchTrigger, RSMA_FETCH_INTERVAL, pItem, smaMgmt.tmrHandle, &pItem->tmrId);
         if (!ret) {
-          smaWarn("vgId:%d, rsma fetch task not reset for level %" PRIi8 " since tmr reset failed, rsetId:%d refId:%" PRIi64,
+          smaWarn("vgId:%d, rsma fetch task not reset for level %" PRIi8
+                  " since tmr reset failed, rsetId:%d refId:%" PRIi64,
                   SMA_VID(pSma), pItem->level, smaMgmt.rsetId, pRSmaRef->refId);
         }
       }
@@ -1407,7 +1411,10 @@ static void tdRSmaFetchTrigger(void *param, void *tmrId) {
       atomic_store_8(&pItem->fetchLevel, 1);
 
       if (atomic_load_8(&pRSmaInfo->assigned) == 0) {
-        (void)tsem_post(&(pStat->notEmpty));
+        if (tsem_post(&(pStat->notEmpty)) != 0) {
+          smaError("vgId:%d, rsma fetch task not start for level:%" PRIi8 " suid:%" PRIi64 " since sem post failed",
+                   SMA_VID(pSma), pItem->level, pRSmaInfo->suid);
+        }
       }
     } break;
     case TASK_TRIGGER_STAT_INACTIVE: {
@@ -1641,7 +1648,7 @@ int32_t tdRSmaProcessExecImpl(SSma *pSma, ERsmaExecType type) {
               batchMax = 100 / batchMax;
               batchMax = TMAX(batchMax, 4);
             }
-            while (occupied || (++batchCnt < batchMax)) {    // greedy mode
+            while (occupied || (++batchCnt < batchMax)) {                 // greedy mode
               TAOS_UNUSED(taosReadAllQitems(pInfo->queue, pInfo->qall));  // queue has mutex lock
               int32_t qallItemSize = taosQallItemSize(pInfo->qall);
               if (qallItemSize > 0) {

source/dnode/vnode/src/tsdb/tsdbCommit2.c

@@ -199,9 +199,9 @@ _exit:
   return code;
 }
 
-static int32_t tsdbCommitCloseReader(SCommitter2 *committer) {
+static void tsdbCommitCloseReader(SCommitter2 *committer) {
   TARRAY2_CLEAR(committer->sttReaderArray, tsdbSttFileReaderClose);
-  return 0;
+  return;
 }
 
 static int32_t tsdbCommitOpenReader(SCommitter2 *committer) {
@@ -243,19 +243,19 @@ static int32_t tsdbCommitOpenReader(SCommitter2 *committer) {
 
 _exit:
   if (code) {
-    TAOS_UNUSED(tsdbCommitCloseReader(committer));
+    tsdbCommitCloseReader(committer);
     tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(committer->tsdb->pVnode), __func__, __FILE__, lino,
               tstrerror(code));
   }
   return code;
 }
 
-static int32_t tsdbCommitCloseIter(SCommitter2 *committer) {
+static void tsdbCommitCloseIter(SCommitter2 *committer) {
   tsdbIterMergerClose(&committer->tombIterMerger);
   tsdbIterMergerClose(&committer->dataIterMerger);
   TARRAY2_CLEAR(committer->tombIterArray, tsdbIterClose);
   TARRAY2_CLEAR(committer->dataIterArray, tsdbIterClose);
-  return 0;
+  return;
 }
 
 static int32_t tsdbCommitOpenIter(SCommitter2 *committer) {
@@ -309,7 +309,7 @@ static int32_t tsdbCommitOpenIter(SCommitter2 *committer) {
 
 _exit:
   if (code) {
-    TAOS_UNUSED(tsdbCommitCloseIter(committer));
+    tsdbCommitCloseIter(committer);
     tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(committer->tsdb->pVnode), __func__, __FILE__, lino,
               tstrerror(code));
   }
@@ -322,7 +322,7 @@ static int32_t tsdbCommitFileSetBegin(SCommitter2 *committer) {
   STsdb  *tsdb = committer->tsdb;
 
   // check if can commit
-  TAOS_UNUSED(tsdbFSCheckCommit(tsdb, committer->ctx->info->fid));
+  tsdbFSCheckCommit(tsdb, committer->ctx->info->fid);
 
   committer->ctx->expLevel = tsdbFidLevel(committer->ctx->info->fid, &tsdb->keepCfg, committer->now);
   tsdbFidKeyRange(committer->ctx->info->fid, committer->minutes, committer->precision, &committer->ctx->minKey,
@@ -355,8 +355,8 @@ static int32_t tsdbCommitFileSetEnd(SCommitter2 *committer) {
   int32_t lino = 0;
 
   TAOS_CHECK_GOTO(tsdbCommitCloseWriter(committer), &lino, _exit);
-  TAOS_CHECK_GOTO(tsdbCommitCloseIter(committer), &lino, _exit);
+  tsdbCommitCloseIter(committer);
-  TAOS_CHECK_GOTO(tsdbCommitCloseReader(committer), &lino, _exit);
+  tsdbCommitCloseReader(committer);
 
 _exit:
   if (code) {
@@ -409,11 +409,11 @@ static uint32_t tFileSetCommitInfoHash(const void *arg) {
   return MurmurHash3_32((const char *)&info->fid, sizeof(info->fid));
 }
 
-static int32_t tsdbCommitInfoDestroy(STsdb *pTsdb) {
+static void tsdbCommitInfoDestroy(STsdb *pTsdb) {
   if (pTsdb->commitInfo) {
     for (int32_t i = 0; i < taosArrayGetSize(pTsdb->commitInfo->arr); i++) {
       SFileSetCommitInfo *info = *(SFileSetCommitInfo **)taosArrayGet(pTsdb->commitInfo->arr, i);
-      TAOS_UNUSED(vHashDrop(pTsdb->commitInfo->ht, info));
+      int32_t             ret = vHashDrop(pTsdb->commitInfo->ht, info);
       tsdbTFileSetClear(&info->fset);
       taosMemoryFree(info);
     }
@@ -423,7 +423,7 @@ static int32_t tsdbCommitInfoDestroy(STsdb *pTsdb) {
     pTsdb->commitInfo->arr = NULL;
     taosMemoryFreeClear(pTsdb->commitInfo);
   }
-  return 0;
+  return;
 }
 
 static int32_t tsdbCommitInfoInit(STsdb *pTsdb) {
@@ -444,7 +444,7 @@ static int32_t tsdbCommitInfoInit(STsdb *pTsdb) {
 
 _exit:
   if (code) {
-    TAOS_UNUSED(tsdbCommitInfoDestroy(pTsdb));
+    tsdbCommitInfoDestroy(pTsdb);
     tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(pTsdb->pVnode), __func__, __FILE__, lino, tstrerror(code));
   }
   return code;
@@ -514,7 +514,7 @@ static int32_t tsdbCommitInfoBuild(STsdb *tsdb) {
       SFileSetCommitInfo  tinfo = {
            .fid = fid,
       };
-      TAOS_UNUSED(vHashGet(tsdb->commitInfo->ht, &tinfo, (void **)&info));
+      int32_t ret = vHashGet(tsdb->commitInfo->ht, &tinfo, (void **)&info);
       if (info == NULL) {
         TAOS_CHECK_GOTO(tsdbCommitInfoAdd(tsdb, fid), &lino, _exit);
       }
@@ -538,7 +538,7 @@ static int32_t tsdbCommitInfoBuild(STsdb *tsdb) {
       };
 
       // check if the file set already on the commit list
-      TAOS_UNUSED(vHashGet(tsdb->commitInfo->ht, &tinfo, (void **)&info));
+      int32_t ret = vHashGet(tsdb->commitInfo->ht, &tinfo, (void **)&info);
       if (info != NULL) {
         continue;
       }
@@ -586,7 +586,7 @@ static int32_t tsdbCommitInfoBuild(STsdb *tsdb) {
 
 _exit:
   if (code) {
-    TAOS_UNUSED(tsdbCommitInfoDestroy(tsdb));
+    tsdbCommitInfoDestroy(tsdb);
     tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(tsdb->pVnode), __func__, __FILE__, lino, tstrerror(code));
   }
   return code;
@@ -716,7 +716,7 @@ int32_t tsdbCommitCommit(STsdb *tsdb) {
 
     (void)taosThreadMutexUnlock(&tsdb->mutex);
 
-    TAOS_UNUSED(tsdbCommitInfoDestroy(tsdb));
+    tsdbCommitInfoDestroy(tsdb);
     tsdbUnrefMemTable(pMemTable, NULL, true);
   }
 
@@ -745,7 +745,7 @@ int32_t tsdbCommitAbort(STsdb *pTsdb) {
     }
   }
   (void)taosThreadMutexUnlock(&pTsdb->mutex);
-  TAOS_UNUSED(tsdbCommitInfoDestroy(pTsdb));
+  tsdbCommitInfoDestroy(pTsdb);
 
 _exit:
   if (code) {

source/dnode/vnode/src/tsdb/tsdbFS.c

@@ -130,7 +130,7 @@ _exit:
     tsdbError("%s failed at line %d since %s, fname:%s", __func__, lino, tstrerror(code), fname);
   }
   taosMemoryFree(pData);
-  (void)taosCloseFile(&pFD);
+  taosCloseFileWithLog(&pFD);
   return code;
 }
 
@@ -300,26 +300,26 @@ static int32_t load_fs(const char *fname, STsdbFS *pFS) {
   int64_t size;
   code = taosFStatFile(pFD, &size, NULL);
   if (code != 0) {
-    (void)taosCloseFile(&pFD);
+    taosCloseFileWithLog(&pFD);
     TSDB_CHECK_CODE(code, lino, _exit);
   }
 
   pData = taosMemoryMalloc(size);
   if (pData == NULL) {
     code = terrno;
-    (void)taosCloseFile(&pFD);
+    taosCloseFileWithLog(&pFD);
     TSDB_CHECK_CODE(code, lino, _exit);
   }
 
   if (taosReadFile(pFD, pData, size) < 0) {
     code = terrno;
-    (void)taosCloseFile(&pFD);
+    taosCloseFileWithLog(&pFD);
     TSDB_CHECK_CODE(code, lino, _exit);
   }
 
   if (!taosCheckChecksumWhole(pData, size)) {
     code = TSDB_CODE_FILE_CORRUPTED;
-    (void)taosCloseFile(&pFD);
+    taosCloseFileWithLog(&pFD);
     TSDB_CHECK_CODE(code, lino, _exit);
   }
 
@@ -331,7 +331,7 @@ _exit:
     tsdbError("%s failed at line %d since %s, fname:%s", __func__, lino, tstrerror(code), fname);
   }
   taosMemoryFree(pData);
-  (void)taosCloseFile(&pFD);
+  taosCloseFileWithLog(&pFD);
   return code;
 }
 

source/dnode/vnode/src/tsdb/tsdbFS2.c

@@ -44,7 +44,12 @@ static int32_t create_fs(STsdb *pTsdb, STFileSystem **fs) {
   }
 
   fs[0]->tsdb = pTsdb;
-  (void)tsem_init(&fs[0]->canEdit, 0, 1);
+  int32_t code = tsem_init(&fs[0]->canEdit, 0, 1);
+  if (code) {
+    taosMemoryFree(fs[0]);
+    return code;
+  }
+
   fs[0]->fsstate = TSDB_FS_STATE_NORMAL;
   fs[0]->neid = 0;
   TARRAY2_INIT(fs[0]->fSetArr);
@@ -58,7 +63,9 @@ static void destroy_fs(STFileSystem **fs) {
 
   TARRAY2_DESTROY(fs[0]->fSetArr, NULL);
   TARRAY2_DESTROY(fs[0]->fSetArrTmp, NULL);
-  (void)tsem_destroy(&fs[0]->canEdit);
+  if (tsem_destroy(&fs[0]->canEdit) != 0) {
+    tsdbError("failed to destroy semaphore");
+  }
   taosMemoryFree(fs[0]);
   fs[0] = NULL;
 }
@@ -100,7 +107,7 @@ _exit:
     tsdbError("%s failed at %s:%d since %s", __func__, fname, __LINE__, tstrerror(code));
   }
   taosMemoryFree(data);
-  (void)taosCloseFile(&fp);
+  taosCloseFileWithLog(&fp);
   return code;
 }
 
@@ -140,7 +147,7 @@ _exit:
     tsdbError("%s failed at %s:%d since %s", __func__, fname, __LINE__, tstrerror(code));
     json[0] = NULL;
   }
-  (void)taosCloseFile(&fp);
+  taosCloseFileWithLog(&fp);
   taosMemoryFree(data);
   return code;
 }
@@ -803,7 +810,11 @@ void tsdbEnableBgTask(STsdb *pTsdb) {
 void tsdbCloseFS(STFileSystem **fs) {
   if (fs[0] == NULL) return;
 
-  TAOS_UNUSED(tsdbDisableAndCancelAllBgTask((*fs)->tsdb));
+  int32_t code = tsdbDisableAndCancelAllBgTask((*fs)->tsdb);
+  if (code) {
+    tsdbError("vgId:%d %s failed at line %d since %s", TD_VID((*fs)->tsdb->pVnode), __func__, __LINE__,
+              tstrerror(code));
+  }
   close_file_system(fs[0]);
   destroy_fs(fs);
   return;
@@ -833,7 +844,9 @@ int32_t tsdbFSEditBegin(STFileSystem *fs, const TFileOpArray *opArray, EFEditT e
     current_fname(fs->tsdb, current_t, TSDB_FCURRENT_M);
   }
 
-  (void)tsem_wait(&fs->canEdit);
+  if (tsem_wait(&fs->canEdit) != 0) {
+    tsdbError("vgId:%d failed to wait semaphore", TD_VID(fs->tsdb->pVnode));
+  }
   fs->etype = etype;
 
   // edit
@@ -865,7 +878,7 @@ static void tsdbFSSetBlockCommit(STFileSet *fset, bool block) {
   }
 }
 
-int32_t tsdbFSCheckCommit(STsdb *tsdb, int32_t fid) {
+void tsdbFSCheckCommit(STsdb *tsdb, int32_t fid) {
   (void)taosThreadMutexLock(&tsdb->mutex);
   STFileSet *fset;
   tsdbFSGetFSet(tsdb->pFS, fid, &fset);
@@ -877,7 +890,7 @@ int32_t tsdbFSCheckCommit(STsdb *tsdb, int32_t fid) {
     }
   }
   (void)taosThreadMutexUnlock(&tsdb->mutex);
-  return 0;
+  return;
 }
 
 // IMPORTANT: the caller must hold fs->tsdb->mutex
@@ -939,13 +952,17 @@ _exit:
   } else {
     tsdbInfo("vgId:%d %s done, etype:%d", TD_VID(fs->tsdb->pVnode), __func__, fs->etype);
   }
-  (void)tsem_post(&fs->canEdit);
+  if (tsem_post(&fs->canEdit) != 0) {
+    tsdbError("vgId:%d failed to post semaphore", TD_VID(fs->tsdb->pVnode));
+  }
   return code;
 }
 
 int32_t tsdbFSEditAbort(STFileSystem *fs) {
   int32_t code = abort_edit(fs);
-  (void)tsem_post(&fs->canEdit);
+  if (tsem_post(&fs->canEdit) != 0) {
+    tsdbError("vgId:%d failed to post semaphore", TD_VID(fs->tsdb->pVnode));
+  }
   return code;
 }
 

source/dnode/vnode/src/tsdb/tsdbFS2.h

@@ -59,10 +59,10 @@ int32_t tsdbFSEditBegin(STFileSystem *fs, const TFileOpArray *opArray, EFEditT e
 int32_t tsdbFSEditCommit(STFileSystem *fs);
 int32_t tsdbFSEditAbort(STFileSystem *fs);
 // other
-void    tsdbFSGetFSet(STFileSystem *fs, int32_t fid, STFileSet **fset);
+void tsdbFSGetFSet(STFileSystem *fs, int32_t fid, STFileSet **fset);
-int32_t tsdbFSCheckCommit(STsdb *tsdb, int32_t fid);
+void tsdbFSCheckCommit(STsdb *tsdb, int32_t fid);
-void    tsdbBeginTaskOnFileSet(STsdb *tsdb, int32_t fid, STFileSet **fset);
+void tsdbBeginTaskOnFileSet(STsdb *tsdb, int32_t fid, STFileSet **fset);
-void    tsdbFinishTaskOnFileSet(STsdb *tsdb, int32_t fid);
+void tsdbFinishTaskOnFileSet(STsdb *tsdb, int32_t fid);
 // utils
 int32_t save_fs(const TFileSetArray *arr, const char *fname);
 void    current_fname(STsdb *pTsdb, char *fname, EFCurrentT ftype);

source/dnode/vnode/src/tsdb/tsdbReaderWriter.c

@@ -436,7 +436,7 @@ static int32_t tsdbReadFileS3(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int64
       code = tsdbCacheGetPageS3(pFD->pTsdb->pgCache, pFD, pgno, &handle);
       if (code != TSDB_CODE_SUCCESS) {
         if (handle) {
-          (void)tsdbCacheRelease(pFD->pTsdb->pgCache, handle);
+          tsdbCacheRelease(pFD->pTsdb->pgCache, handle);
         }
         TSDB_CHECK_CODE(code, lino, _exit);
       }
@@ -447,7 +447,7 @@ static int32_t tsdbReadFileS3(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int64
 
       uint8_t *pPage = (uint8_t *)taosLRUCacheValue(pFD->pTsdb->pgCache, handle);
       memcpy(pFD->pBuf, pPage, pFD->szPage);
-      (void)tsdbCacheRelease(pFD->pTsdb->pgCache, handle);
+      tsdbCacheRelease(pFD->pTsdb->pgCache, handle);
 
       // check
       if (pgno > 1 && !taosCheckChecksumWhole(pFD->pBuf, pFD->szPage)) {

source/dnode/vnode/src/tsdb/tsdbRetention.c

@@ -99,8 +99,12 @@ _exit:
     tsdbError("vgId:%d, %s failed at %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino,
               tstrerror(code));
   }
-  (void)taosCloseFile(&fdFrom);
+  if (taosCloseFile(&fdFrom) != 0) {
-  (void)taosCloseFile(&fdTo);
+    tsdbError("vgId:%d, failed to close file %s", TD_VID(rtner->tsdb->pVnode), fname_from);
+  }
+  if (taosCloseFile(&fdTo) != 0) {
+    tsdbError("vgId:%d, failed to close file %s", TD_VID(rtner->tsdb->pVnode), fname_to);
+  }
   return code;
 }
 
@@ -136,8 +140,12 @@ _exit:
     tsdbError("vgId:%d, %s failed at %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino,
               tstrerror(code));
   }
-  (void)taosCloseFile(&fdFrom);
+  if (taosCloseFile(&fdFrom) != 0) {
-  (void)taosCloseFile(&fdTo);
+    tsdbTrace("vgId:%d, failed to close file", TD_VID(rtner->tsdb->pVnode));
+  }
+  if (taosCloseFile(&fdTo) != 0) {
+    tsdbTrace("vgId:%d, failed to close file", TD_VID(rtner->tsdb->pVnode));
+  }
   return code;
 }
 
@@ -441,7 +449,9 @@ _exit:
     tsdbError("vgId:%d %s failed at line %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino,
               tstrerror(code));
   }
-  (void)taosCloseFile(&fdFrom);
+  if (taosCloseFile(&fdFrom) != 0) {
+    tsdbTrace("vgId:%d, failed to close file", TD_VID(rtner->tsdb->pVnode));
+  }
   return code;
 }
 
@@ -541,8 +551,13 @@ _exit:
     tsdbError("vgId:%d %s failed at line %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino,
               tstrerror(code));
   }
-  (void)taosCloseFile(&fdFrom);
+  if (taosCloseFile(&fdFrom) != 0) {
-  (void)taosCloseFile(&fdTo);
+    tsdbTrace("vgId:%d, failed to close file", TD_VID(rtner->tsdb->pVnode));
+  }
+
+  if (taosCloseFile(&fdTo) != 0) {
+    tsdbTrace("vgId:%d, failed to close file", TD_VID(rtner->tsdb->pVnode));
+  }
   return code;
 }
 
@@ -639,8 +654,12 @@ _exit:
     tsdbError("vgId:%d %s failed at line %s:%d since %s", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, lino,
               tstrerror(code));
   }
-  (void)taosCloseFile(&fdFrom);
+  if (taosCloseFile(&fdFrom) != 0) {
-  (void)taosCloseFile(&fdTo);
+    tsdbTrace("vgId:%d, failed to close file", TD_VID(rtner->tsdb->pVnode));
+  }
+  if (taosCloseFile(&fdTo) != 0) {
+    tsdbTrace("vgId:%d, failed to close file", TD_VID(rtner->tsdb->pVnode));
+  }
   return code;
 }
 
@@ -699,7 +718,9 @@ static int32_t tsdbDoS3Migrate(SRTNer *rtner) {
     if (taosCheckExistFile(fname1)) {
       int32_t mtime = 0;
       int64_t size = 0;
-      (void)taosStatFile(fname1, &size, &mtime, NULL);
+      if (taosStatFile(fname1, &size, &mtime, NULL) != 0) {
+        tsdbError("vgId:%d, %s failed at %s:%d ", TD_VID(rtner->tsdb->pVnode), __func__, __FILE__, __LINE__);
+      }
       if (size > chunksize && mtime < rtner->now - tsS3UploadDelaySec) {
         TAOS_CHECK_GOTO(tsdbMigrateDataFileLCS3(rtner, fobj, size, chunksize), &lino, _exit);
       }

source/dnode/vnode/src/tsdb/tsdbSnapshot.c

@@ -57,10 +57,10 @@ struct STsdbSnapReader {
   STombBlock tombBlock[1];
 };
 
-static int32_t tsdbSnapReadFileSetCloseReader(STsdbSnapReader* reader) {
+static void tsdbSnapReadFileSetCloseReader(STsdbSnapReader* reader) {
   TARRAY2_CLEAR(reader->sttReaderArr, tsdbSttFileReaderClose);
   tsdbDataFileReaderClose(&reader->dataReader);
-  return 0;
+  return;
 }
 
 static int32_t tsdbSnapReadFileSetOpenReader(STsdbSnapReader* reader) {
@@ -112,7 +112,7 @@ static int32_t tsdbSnapReadFileSetOpenReader(STsdbSnapReader* reader) {
 
 _exit:
   if (code) {
-    TAOS_UNUSED(tsdbSnapReadFileSetCloseReader(reader));
+    tsdbSnapReadFileSetCloseReader(reader);
     TSDB_ERROR_LOG(TD_VID(reader->tsdb->pVnode), code, lino);
   }
   return code;
@@ -190,12 +190,12 @@ _exit:
   return code;
 }
 
-static int32_t tsdbSnapReadFileSetCloseIter(STsdbSnapReader* reader) {
+static void tsdbSnapReadFileSetCloseIter(STsdbSnapReader* reader) {
   tsdbIterMergerClose(&reader->dataIterMerger);
   tsdbIterMergerClose(&reader->tombIterMerger);
   TARRAY2_CLEAR(reader->dataIterArr, tsdbIterClose);
   TARRAY2_CLEAR(reader->tombIterArr, tsdbIterClose);
-  return 0;
+  return;
 }
 
 static int32_t tsdbSnapReadRangeBegin(STsdbSnapReader* reader) {
@@ -222,8 +222,8 @@ _exit:
 }
 
 static int32_t tsdbSnapReadRangeEnd(STsdbSnapReader* reader) {
-  TAOS_UNUSED(tsdbSnapReadFileSetCloseIter(reader));
+  tsdbSnapReadFileSetCloseIter(reader);
-  TAOS_UNUSED(tsdbSnapReadFileSetCloseReader(reader));
+  tsdbSnapReadFileSetCloseReader(reader);
   reader->ctx->fsr = NULL;
   return 0;
 }
@@ -373,7 +373,7 @@ static int32_t tsdbSnapReadTombData(STsdbSnapReader* reader, uint8_t** data) {
   int32_t   lino = 0;
   SMetaInfo info;
 
-  TAOS_UNUSED(tTombBlockClear(reader->tombBlock));
+  tTombBlockClear(reader->tombBlock);
 
   TABLEID tbid[1] = {0};
   for (STombRecord* record; (record = tsdbIterMergerGetTombRecord(reader->tombIterMerger)) != NULL;) {
@@ -463,7 +463,7 @@ void tsdbSnapReaderClose(STsdbSnapReader** reader) {
   tDestroyTSchema(reader[0]->skmTb->pTSchema);
 
   for (int32_t i = 0; i < ARRAY_SIZE(reader[0]->buffers); ++i) {
-    TAOS_UNUSED(tBufferDestroy(reader[0]->buffers + i));
+    tBufferDestroy(reader[0]->buffers + i);
   }
 
   taosMemoryFree(reader[0]);
@@ -1000,7 +1000,7 @@ static int32_t tsdbSnapWriteDecmprTombBlock(SSnapDataHdr* hdr, STombBlock* tombB
   int32_t code = 0;
   int32_t lino = 0;
 
-  TAOS_UNUSED(tTombBlockClear(tombBlock));
+  tTombBlockClear(tombBlock);
 
   int64_t size = hdr->size;
   size = size / TOMB_RECORD_ELEM_NUM;

source/dnode/vnode/src/tsdb/tsdbSttFileRW.c

@@ -415,7 +415,7 @@ int32_t tsdbSttFileReadStatisBlock(SSttFileReader *reader, const SStatisBlk *sta
                   &lino, _exit);
 
   // decode data
-  TAOS_UNUSED(tStatisBlockClear(statisBlock));
+  tStatisBlockClear(statisBlock);
   statisBlock->numOfPKs = statisBlk->numOfPKs;
   statisBlock->numOfRecords = statisBlk->numRec;
   SBufferReader br = BUFFER_READER_INITIALIZER(0, buffer0);
@@ -654,7 +654,7 @@ static int32_t tsdbSttFileDoWriteStatisBlock(SSttFileWriter *writer) {
 
   TAOS_CHECK_GOTO(TARRAY2_APPEND_PTR(writer->statisBlkArray, &statisBlk), &lino, _exit);
 
-  TAOS_UNUSED(tStatisBlockClear(writer->staticBlock));
+  tStatisBlockClear(writer->staticBlock);
 
 _exit:
   if (code) {

source/dnode/vnode/src/tsdb/tsdbUtil.c

@@ -609,7 +609,10 @@ void tsdbRowGetColVal(TSDBROW *pRow, STSchema *pTSchema, int32_t iCol, SColVal *
   SValue    value;
 
   if (pRow->type == TSDBROW_ROW_FMT) {
-    (void)tRowGet(pRow->pTSRow, pTSchema, iCol, pColVal);
+    int32_t ret = tRowGet(pRow->pTSRow, pTSchema, iCol, pColVal);
+    if (ret != 0) {
+      tsdbError("failed to get column value, code:%d", ret);
+    }
   } else if (pRow->type == TSDBROW_COL_FMT) {
     if (iCol == 0) {
       *pColVal =

source/dnode/vnode/src/tsdb/tsdbUtil2.c

@@ -93,25 +93,25 @@ void tStatisBlockDestroy(STbStatisBlock *statisBlock) {
   statisBlock->numOfPKs = 0;
   statisBlock->numOfRecords = 0;
   for (int32_t i = 0; i < ARRAY_SIZE(statisBlock->buffers); ++i) {
-    TAOS_UNUSED(tBufferDestroy(&statisBlock->buffers[i]));
+    tBufferDestroy(&statisBlock->buffers[i]);
   }
   for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) {
-    TAOS_UNUSED(tValueColumnDestroy(&statisBlock->firstKeyPKs[i]));
+    tValueColumnDestroy(&statisBlock->firstKeyPKs[i]);
-    TAOS_UNUSED(tValueColumnDestroy(&statisBlock->lastKeyPKs[i]));
+    tValueColumnDestroy(&statisBlock->lastKeyPKs[i]);
   }
 }
 
-int32_t tStatisBlockClear(STbStatisBlock *statisBlock) {
+void tStatisBlockClear(STbStatisBlock *statisBlock) {
   statisBlock->numOfPKs = 0;
   statisBlock->numOfRecords = 0;
   for (int32_t i = 0; i < ARRAY_SIZE(statisBlock->buffers); ++i) {
-    TAOS_UNUSED(tBufferClear(&statisBlock->buffers[i]));
+    tBufferClear(&statisBlock->buffers[i]);
   }
   for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) {
     tValueColumnClear(&statisBlock->firstKeyPKs[i]);
     tValueColumnClear(&statisBlock->lastKeyPKs[i]);
   }
-  return 0;
+  return;
 }
 
 static int32_t tStatisBlockAppend(STbStatisBlock *block, SRowInfo *row) {
@@ -252,11 +252,11 @@ void tBrinBlockDestroy(SBrinBlock *brinBlock) {
   brinBlock->numOfPKs = 0;
   brinBlock->numOfRecords = 0;
   for (int32_t i = 0; i < ARRAY_SIZE(brinBlock->buffers); ++i) {
-    TAOS_UNUSED(tBufferDestroy(&brinBlock->buffers[i]));
+    tBufferDestroy(&brinBlock->buffers[i]);
   }
   for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) {
-    TAOS_UNUSED(tValueColumnDestroy(&brinBlock->firstKeyPKs[i]));
+    tValueColumnDestroy(&brinBlock->firstKeyPKs[i]);
-    TAOS_UNUSED(tValueColumnDestroy(&brinBlock->lastKeyPKs[i]));
+    tValueColumnDestroy(&brinBlock->lastKeyPKs[i]);
   }
 }
 
@@ -264,7 +264,7 @@ void tBrinBlockClear(SBrinBlock *brinBlock) {
   brinBlock->numOfPKs = 0;
   brinBlock->numOfRecords = 0;
   for (int32_t i = 0; i < ARRAY_SIZE(brinBlock->buffers); ++i) {
-    TAOS_UNUSED(tBufferClear(&brinBlock->buffers[i]));
+    tBufferClear(&brinBlock->buffers[i]);
   }
   for (int32_t i = 0; i < TD_MAX_PK_COLS; ++i) {
     tValueColumnClear(&brinBlock->firstKeyPKs[i]);

source/dnode/vnode/src/tsdb/tsdbUtil2.h

@@ -113,7 +113,7 @@ typedef struct {
 
 int32_t tStatisBlockInit(STbStatisBlock *statisBlock);
 void    tStatisBlockDestroy(STbStatisBlock *statisBlock);
-int32_t tStatisBlockClear(STbStatisBlock *statisBlock);
+void    tStatisBlockClear(STbStatisBlock *statisBlock);
 int32_t tStatisBlockPut(STbStatisBlock *statisBlock, SRowInfo *row, int32_t maxRecords);
 int32_t tStatisBlockGet(STbStatisBlock *statisBlock, int32_t idx, STbStatisRecord *record);
 

source/dnode/vnode/src/vnd/vnodeAsync.c

@@ -187,10 +187,12 @@ static void vnodeAsyncCancelAllTasks(SVAsync *async, SArray *cancelArray) {
         task->prev->next = task->next;
         task->next->prev = task->prev;
         if (task->cancel) {
-          TAOS_UNUSED(taosArrayPush(cancelArray, &(SVATaskCancelInfo){
+          if (taosArrayPush(cancelArray, &(SVATaskCancelInfo){
-                                                     .cancel = task->cancel,
+                                             .cancel = task->cancel,
-                                                     .arg = task->arg,
+                                             .arg = task->arg,
-                                                 }));
+                                         }) == NULL) {
+            vError("failed to push cancel task into array");
+          };
         }
         vnodeAsyncTaskDone(async, task);
       }
@@ -430,7 +432,7 @@ static void vnodeAsyncLaunchWorker(SVAsync *async) {
     if (async->workers[i].state == EVA_WORKER_STATE_ACTIVE) {
       continue;
     } else if (async->workers[i].state == EVA_WORKER_STATE_STOP) {
-      TAOS_UNUSED(taosThreadJoin(async->workers[i].thread, NULL));
+      int32_t ret = taosThreadJoin(async->workers[i].thread, NULL);
       async->workers[i].state = EVA_WORKER_STATE_UINIT;
     }
 
@@ -748,10 +750,12 @@ int32_t vnodeAChannelDestroy(SVAChannelID *channelID, bool waitRunning) {
         task->prev->next = task->next;
         task->next->prev = task->prev;
         if (task->cancel) {
-          TAOS_UNUSED(taosArrayPush(cancelArray, &(SVATaskCancelInfo){
+          if (taosArrayPush(cancelArray, &(SVATaskCancelInfo){
-                                                     .cancel = task->cancel,
+                                             .cancel = task->cancel,
-                                                     .arg = task->arg,
+                                             .arg = task->arg,
-                                                 }));
+                                         }) == NULL) {
+            vError("failed to push cancel info");
+          };
         }
         vnodeAsyncTaskDone(async, task);
       }
@@ -763,10 +767,12 @@ int32_t vnodeAChannelDestroy(SVAChannelID *channelID, bool waitRunning) {
         channel->scheduled->prev->next = channel->scheduled->next;
         channel->scheduled->next->prev = channel->scheduled->prev;
         if (channel->scheduled->cancel) {
-          TAOS_UNUSED(taosArrayPush(cancelArray, &(SVATaskCancelInfo){
+          if (taosArrayPush(cancelArray, &(SVATaskCancelInfo){
-                                                     .cancel = channel->scheduled->cancel,
+                                             .cancel = channel->scheduled->cancel,
-                                                     .arg = channel->scheduled->arg,
+                                             .arg = channel->scheduled->arg,
-                                                 }));
+                                         }) == NULL) {
+            vError("failed to push cancel info");
+          }
         }
         vnodeAsyncTaskDone(async, channel->scheduled);
       }

source/dnode/vnode/src/vnd/vnodeCommit.c

@@ -201,7 +201,9 @@ _exit:
     vInfo("vgId:%d, vnode info is saved, fname:%s replica:%d selfIndex:%d changeVersion:%d", pInfo->config.vgId, fname,
           pInfo->config.syncCfg.replicaNum, pInfo->config.syncCfg.myIndex, pInfo->config.syncCfg.changeVersion);
   }
-  (void)taosCloseFile(&pFile);
+  if (taosCloseFile(&pFile) != 0) {
+    vError("vgId:%d, failed to close file", pInfo->config.vgId);
+  }
   taosMemoryFree(data);
   return code;
 }
@@ -263,7 +265,9 @@ _exit:
     }
   }
   taosMemoryFree(pData);
-  (void)taosCloseFile(&pFile);
+  if (taosCloseFile(&pFile) != 0) {
+    vError("vgId:%d, failed to close file", pInfo->config.vgId);
+  }
   return code;
 }
 
@@ -496,7 +500,9 @@ void vnodeRollback(SVnode *pVnode) {
   offset = strlen(tFName);
   snprintf(tFName + offset, TSDB_FILENAME_LEN - offset - 1, "%s%s", TD_DIRSEP, VND_INFO_FNAME_TMP);
 
-  TAOS_UNUSED(taosRemoveFile(tFName));
+  if (taosRemoveFile(tFName) != 0) {
+    vError("vgId:%d, failed to remove file %s since %s", TD_VID(pVnode), tFName, tstrerror(terrno));
+  }
 }
 
 static int vnodeEncodeState(const void *pObj, SJson *pJson) {

source/dnode/vnode/src/vnd/vnodeOpen.c

@@ -414,7 +414,10 @@ SVnode *vnodeOpen(const char *path, int32_t diskPrimary, STfs *pTfs, SMsgCb msgC
   pVnode->blocked = false;
   pVnode->disableWrite = false;
 
-  (void)tsem_init(&pVnode->syncSem, 0, 0);
+  if (tsem_init(&pVnode->syncSem, 0, 0) != 0) {
+    vError("vgId:%d, failed to init semaphore", TD_VID(pVnode));
+    goto _err;
+  }
   (void)taosThreadMutexInit(&pVnode->mutex, NULL);
   (void)taosThreadCondInit(&pVnode->poolNotEmpty, NULL);
 

source/dnode/vnode/src/vnd/vnodeSnapshot.c

@@ -274,13 +274,17 @@ int32_t vnodeSnapRead(SVSnapReader *pReader, uint8_t **ppData, uint32_t *nData)
     int64_t size;
     code = taosFStatFile(pFile, &size, NULL);
     if (code != 0) {
-      (void)taosCloseFile(&pFile);
+      if (taosCloseFile(&pFile) != 0) {
+        vError("vgId:%d, failed to close file", vgId);
+      }
       TSDB_CHECK_CODE(code, lino, _exit);
     }
 
     *ppData = taosMemoryMalloc(sizeof(SSnapDataHdr) + size + 1);
     if (*ppData == NULL) {
-      (void)taosCloseFile(&pFile);
+      if (taosCloseFile(&pFile) != 0) {
+        vError("vgId:%d, failed to close file", vgId);
+      }
       TSDB_CHECK_CODE(code = terrno, lino, _exit);
     }
     ((SSnapDataHdr *)(*ppData))->type = SNAP_DATA_CFG;
@@ -289,11 +293,15 @@ int32_t vnodeSnapRead(SVSnapReader *pReader, uint8_t **ppData, uint32_t *nData)
 
     if (taosReadFile(pFile, ((SSnapDataHdr *)(*ppData))->data, size) < 0) {
       taosMemoryFree(*ppData);
-      (void)taosCloseFile(&pFile);
+      if (taosCloseFile(&pFile) != 0) {
+        vError("vgId:%d, failed to close file", vgId);
+      }
       TSDB_CHECK_CODE(code = terrno, lino, _exit);
     }
 
-    (void)taosCloseFile(&pFile);
+    if (taosCloseFile(&pFile) != 0) {
+      vError("vgId:%d, failed to close file", vgId);
+    }
 
     pReader->cfgDone = 1;
     goto _exit;

source/dnode/vnode/src/vnd/vnodeSvr.c

@@ -1833,7 +1833,9 @@ static int32_t vnodeProcessSubmitReq(SVnode *pVnode, int64_t ver, void *pReq, in
       }
 
       if (info.suid) {
-        (void)metaGetInfo(pVnode->pMeta, info.suid, &info, NULL);
+        if (metaGetInfo(pVnode->pMeta, info.suid, &info, NULL) != 0) {
+          vWarn("vgId:%d, table uid:%" PRId64 " not exists", TD_VID(pVnode), info.suid);
+        }
       }
 
       if (pSubmitTbData->sver != info.skmVer) {

source/dnode/vnode/src/vnd/vnodeSync.c

@@ -28,7 +28,9 @@ static inline void vnodeWaitBlockMsg(SVnode *pVnode, const SRpcMsg *pMsg) {
   const STraceId *trace = &pMsg->info.traceId;
   vGTrace("vgId:%d, msg:%p wait block, type:%s sec:%d seq:%" PRId64, pVnode->config.vgId, pMsg,
           TMSG_INFO(pMsg->msgType), pVnode->blockSec, pVnode->blockSeq);
-  (void)tsem_wait(&pVnode->syncSem);
+  if (tsem_wait(&pVnode->syncSem) != 0) {
+    vError("vgId:%d, failed to wait sem", pVnode->config.vgId);
+  }
 }
 
 static inline void vnodePostBlockMsg(SVnode *pVnode, const SRpcMsg *pMsg) {
@@ -41,7 +43,9 @@ static inline void vnodePostBlockMsg(SVnode *pVnode, const SRpcMsg *pMsg) {
       pVnode->blocked = false;
       pVnode->blockSec = 0;
       pVnode->blockSeq = 0;
-      (void)tsem_post(&pVnode->syncSem);
+      if (tsem_post(&pVnode->syncSem) != 0) {
+        vError("vgId:%d, failed to post sem", pVnode->config.vgId);
+      }
     }
     (void)taosThreadMutexUnlock(&pVnode->lock);
   }
@@ -613,7 +617,9 @@ static void vnodeBecomeFollower(const SSyncFSM *pFsm) {
   if (pVnode->blocked) {
     pVnode->blocked = false;
     vDebug("vgId:%d, become follower and post block", pVnode->config.vgId);
-    (void)tsem_post(&pVnode->syncSem);
+    if (tsem_post(&pVnode->syncSem) != 0) {
+      vError("vgId:%d, failed to post sync semaphore", pVnode->config.vgId);
+    }
   }
   (void)taosThreadMutexUnlock(&pVnode->lock);
 
@@ -633,7 +639,9 @@ static void vnodeBecomeLearner(const SSyncFSM *pFsm) {
   if (pVnode->blocked) {
     pVnode->blocked = false;
     vDebug("vgId:%d, become learner and post block", pVnode->config.vgId);
-    (void)tsem_post(&pVnode->syncSem);
+    if (tsem_post(&pVnode->syncSem) != 0) {
+      vError("vgId:%d, failed to post sync semaphore", pVnode->config.vgId);
+    }
   }
   (void)taosThreadMutexUnlock(&pVnode->lock);
 }
@@ -766,7 +774,9 @@ void vnodeSyncPreClose(SVnode *pVnode) {
   if (pVnode->blocked) {
     vInfo("vgId:%d, post block after close sync", pVnode->config.vgId);
     pVnode->blocked = false;
-    (void)tsem_post(&pVnode->syncSem);
+    if (tsem_post(&pVnode->syncSem) != 0) {
+      vError("vgId:%d, failed to post block", pVnode->config.vgId);
+    }
   }
   (void)taosThreadMutexUnlock(&pVnode->lock);
 }
@@ -801,7 +811,9 @@ void vnodeSyncCheckTimeout(SVnode *pVnode) {
       pVnode->blocked = false;
       pVnode->blockSec = 0;
       pVnode->blockSeq = 0;
-      (void)tsem_post(&pVnode->syncSem);
+      if (tsem_post(&pVnode->syncSem) != 0) {
+        vError("vgId:%d, failed to post block", pVnode->config.vgId);
+      }
     }
   }
   (void)taosThreadMutexUnlock(&pVnode->lock);

source/libs/executor/src/cachescanoperator.c

@@ -347,11 +347,7 @@ static int32_t doScanCacheNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
       SExprSupp* pSup = &pInfo->pseudoExprSup;
       code = addTagPseudoColumnData(&pInfo->readHandle, pSup->pExprInfo, pSup->numOfExprs, pRes, pRes->info.rows,
                                     pTaskInfo, NULL);
-      if (code != TSDB_CODE_SUCCESS) {
+      QUERY_CHECK_CODE(code, lino, _end);
-        pTaskInfo->code = code;
-        (*ppRes) = NULL;
-        return code;
-      }
 
       pRes->info.id.groupId = tableListGetTableGroupId(pTableList, pRes->info.id.uid);
       pInfo->indexOfBufferedRes += 1;
@@ -414,11 +410,7 @@ static int32_t doScanCacheNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
             pInfo->pRes->info.id.uid = *(tb_uid_t*)pUid;
             code = addTagPseudoColumnData(&pInfo->readHandle, pSup->pExprInfo, pSup->numOfExprs, pInfo->pRes,
                                           pInfo->pRes->info.rows, pTaskInfo, NULL);
-            if (code != TSDB_CODE_SUCCESS) {
+            QUERY_CHECK_CODE(code, lino, _end);
-              pTaskInfo->code = code;
-              (*ppRes) = NULL;
-              return code;
-            }
           }
         }
 

source/libs/executor/src/dynqueryctrloperator.c

@@ -938,7 +938,9 @@ _return:
   }
 
   if (code) {
+    qError("%s failed since %s", __func__, tstrerror(code));
     pOperator->pTaskInfo->code = code;
+    T_LONG_JMP(pOperator->pTaskInfo->env, code);
   } else {
     seqStableJoinComposeRes(pStbJoin, *pRes);
   }

source/libs/executor/src/exchangeoperator.c

@@ -1094,6 +1094,7 @@ int32_t addDynamicExchangeSource(SOperatorInfo* pOperator) {
 int32_t prepareLoadRemoteData(SOperatorInfo* pOperator) {
   SExchangeInfo* pExchangeInfo = pOperator->info;
   int32_t        code = TSDB_CODE_SUCCESS;
+  int32_t        lino = 0;
   if ((OPTR_IS_OPENED(pOperator) && !pExchangeInfo->dynamicOp) ||
       (pExchangeInfo->dynamicOp && NULL == pOperator->pOperatorGetParam)) {
     return TSDB_CODE_SUCCESS;
@@ -1101,23 +1102,26 @@ int32_t prepareLoadRemoteData(SOperatorInfo* pOperator) {
 
   if (pExchangeInfo->dynamicOp) {
     code = addDynamicExchangeSource(pOperator);
-    if (code) {
+    QUERY_CHECK_CODE(code, lino, _end);
-      return code;
-    }
   }
 
   int64_t st = taosGetTimestampUs();
 
   if (!pExchangeInfo->seqLoadData) {
-    int32_t code = prepareConcurrentlyLoad(pOperator);
+    code = prepareConcurrentlyLoad(pOperator);
-    if (code != TSDB_CODE_SUCCESS) {
+    QUERY_CHECK_CODE(code, lino, _end);
-      return code;
-    }
     pExchangeInfo->openedTs = taosGetTimestampUs();
   }
 
   OPTR_SET_OPENED(pOperator);
   pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0;
+
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    pOperator->pTaskInfo->code = code;
+    T_LONG_JMP(pOperator->pTaskInfo->env, code);
+  }
   return TSDB_CODE_SUCCESS;
 }
 

source/libs/executor/src/groupoperator.c

@@ -450,7 +450,7 @@ static int32_t hashGroupbyAggregateNext(SOperatorInfo* pOperator, SSDataBlock**
 
   QRY_PARAM_CHECK(ppRes);
   if (pOperator->status == OP_EXEC_DONE) {
-    return TSDB_CODE_SUCCESS;
+    return code;
   }
 
   if (pOperator->status == OP_RES_TO_RETURN) {
@@ -502,6 +502,7 @@ _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
     pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   } else {
     (*ppRes) = buildGroupResultDataBlockByHash(pOperator);
   }
@@ -1533,8 +1534,9 @@ static int32_t doStreamHashPartitionNext(SOperatorInfo* pOperator, SSDataBlock**
 
 _end:
   if (code != TSDB_CODE_SUCCESS) {
-    pTaskInfo->code = code;
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   (*ppRes) = NULL;
   return code;

source/libs/executor/src/hashjoinoperator.c

@@ -993,6 +993,7 @@ static int32_t hJoinMainProcess(struct SOperatorInfo* pOperator, SSDataBlock** p
   SHJoinOperatorInfo* pJoin = pOperator->info;
   SExecTaskInfo*      pTaskInfo = pOperator->pTaskInfo;
   int32_t             code = TSDB_CODE_SUCCESS;
+  int32_t             lino = 0;
   SSDataBlock*        pRes = pJoin->finBlk;
   int64_t             st = 0;
 
@@ -1003,7 +1004,7 @@ static int32_t hJoinMainProcess(struct SOperatorInfo* pOperator, SSDataBlock** p
 
   if (pOperator->status == OP_EXEC_DONE) {
     pRes->info.rows = 0;
-    goto _return;
+    goto _end;
   }
 
   if (!pJoin->keyHashBuilt) {
@@ -1011,13 +1012,10 @@ static int32_t hJoinMainProcess(struct SOperatorInfo* pOperator, SSDataBlock** p
 
     bool queryDone = false;
     code = hJoinBuildHash(pOperator, &queryDone);
-    if (code) {
+    QUERY_CHECK_CODE(code, lino, _end);
-      pTaskInfo->code = code;
-      return code;
-    }
 
     if (queryDone) {
-      goto _return;
+      goto _end;
     }
   }
 
@@ -1025,17 +1023,11 @@ static int32_t hJoinMainProcess(struct SOperatorInfo* pOperator, SSDataBlock** p
 
   if (pJoin->ctx.rowRemains) {
     code = (*pJoin->joinFp)(pOperator);
-    if (code) {
+    QUERY_CHECK_CODE(code, lino, _end);
-      pTaskInfo->code = code;
-      return pTaskInfo->code;
-    }
 
     if (pRes->info.rows > 0 && pJoin->pFinFilter != NULL) {
       code = doFilter(pRes, pJoin->pFinFilter, NULL);
-      if (code) {
+      QUERY_CHECK_CODE(code, lino, _end);
-        pTaskInfo->code = code;
-        return pTaskInfo->code;
-      }
     }
 
     if (pRes->info.rows > 0) {
@@ -1055,10 +1047,7 @@ static int32_t hJoinMainProcess(struct SOperatorInfo* pOperator, SSDataBlock** p
     pJoin->execInfo.probeBlkRows += pBlock->info.rows;
 
     code = hJoinPrepareStart(pOperator, pBlock);
-    if (code) {
+    QUERY_CHECK_CODE(code, lino, _end);
-      pTaskInfo->code = code;
-      return pTaskInfo->code;
-    }
 
     if (!hJoinBlkReachThreshold(pJoin, pRes->info.rows)) {
       continue;
@@ -1066,10 +1055,7 @@ static int32_t hJoinMainProcess(struct SOperatorInfo* pOperator, SSDataBlock** p
 
     if (pRes->info.rows > 0 && pJoin->pFinFilter != NULL) {
       code = doFilter(pRes, pJoin->pFinFilter, NULL);
-      if (code) {
+      QUERY_CHECK_CODE(code, lino, _end);
-        pTaskInfo->code = code;
-        return pTaskInfo->code;
-      }
     }
 
     if (pRes->info.rows > 0) {
@@ -1077,11 +1063,15 @@ static int32_t hJoinMainProcess(struct SOperatorInfo* pOperator, SSDataBlock** p
     }
   }
 
-_return:
+_end:
   if (pOperator->cost.openCost == 0) {
     pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0;
   }
-
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
+  }
   if (pRes->info.rows > 0) {
     *pResBlock = pRes;
   }

source/libs/executor/src/mergejoinoperator.c

@@ -1731,6 +1731,7 @@ int32_t mJoinMainProcess(struct SOperatorInfo* pOperator, SSDataBlock** pResBloc
     if (pJoin->pFinFilter != NULL) {
       code = doFilter(pBlock, pJoin->pFinFilter, NULL);
       if (code) {
+        qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
         pJoin->errCode = code;
         T_LONG_JMP(pOperator->pTaskInfo->env, pJoin->errCode);
       }

source/libs/executor/src/mergeoperator.c

@@ -492,6 +492,8 @@ int32_t openMultiwayMergeOperator(SOperatorInfo* pOperator) {
   pOperator->status = OP_RES_TO_RETURN;
 
   if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+    pOperator->pTaskInfo->code = code;
     T_LONG_JMP(pTaskInfo->env, terrno);
   }
 
@@ -501,6 +503,8 @@ int32_t openMultiwayMergeOperator(SOperatorInfo* pOperator) {
 
 int32_t doMultiwayMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
   QRY_PARAM_CHECK(pResBlock);
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
 
   if (pOperator->status == OP_EXEC_DONE) {
     return 0;
@@ -509,18 +513,12 @@ int32_t doMultiwayMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
   SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
   SMultiwayMergeOperatorInfo* pInfo = pOperator->info;
 
-  int32_t code = pOperator->fpSet._openFn(pOperator);
+  code = pOperator->fpSet._openFn(pOperator);
-  if (code != TSDB_CODE_SUCCESS) {
+  QUERY_CHECK_CODE(code, lino, _end);
-    pTaskInfo->code = code;
-    return code;
-  }
 
   if (NULL != gMultiwayMergeFps[pInfo->type].getNextFn) {
     code = (*gMultiwayMergeFps[pInfo->type].getNextFn)(pOperator, pResBlock);
-    if (code) {
+    QUERY_CHECK_CODE(code, lino, _end);
-      pTaskInfo->code = code;
-      return code;
-    }
   }
 
   if ((*pResBlock) != NULL) {
@@ -530,6 +528,12 @@ int32_t doMultiwayMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
     setOperatorCompleted(pOperator);
   }
 
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
+  }
   return code;
 }
 

source/libs/executor/src/operator.c

@@ -881,14 +881,17 @@ SSDataBlock* getNextBlockFromDownstreamRemain(struct SOperatorInfo* pOperator, i
 int32_t optrDefaultGetNextExtFn(struct SOperatorInfo* pOperator, SOperatorParam* pParam, SSDataBlock** pRes) {
   QRY_PARAM_CHECK(pRes);
 
+  int32_t lino = 0;
   int32_t code = setOperatorParams(pOperator, pParam, OP_GET_PARAM);
-  if (TSDB_CODE_SUCCESS != code) {
+  QUERY_CHECK_CODE(code, lino, _end);
+  code = pOperator->fpSet.getNextFn(pOperator, pRes);
+  QUERY_CHECK_CODE(code, lino, _end);
+
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
     pOperator->pTaskInfo->code = code;
-  } else {
+    T_LONG_JMP(pOperator->pTaskInfo->env, code);
-    code = pOperator->fpSet.getNextFn(pOperator, pRes);
-    if (code) {
-      pOperator->pTaskInfo->code = code;
-    }
   }
 
   return code;

source/libs/executor/src/projectoperator.c

@@ -270,6 +270,7 @@ int32_t doProjectOperation(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
   SSDataBlock*          pRes = pInfo->pRes;
   SSDataBlock*          pFinalRes = pProjectInfo->pFinalRes;
   int32_t               code = 0;
+  int32_t               lino = 0;
   int64_t               st = 0;
   int32_t               order = pInfo->inputTsOrder;
   int32_t               scanFlag = 0;
@@ -290,9 +291,7 @@ int32_t doProjectOperation(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
 
   if (downstream == NULL) {
     code = doGenerateSourceData(pOperator);
-    if (code != TSDB_CODE_SUCCESS) {
+    QUERY_CHECK_CODE(code, lino, _end);
-      T_LONG_JMP(pTaskInfo->env, code);
-    }
 
     if (pProjectInfo->outputIgnoreGroup) {
       pRes->info.id.groupId = 0;
@@ -348,20 +347,14 @@ int32_t doProjectOperation(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
       }
 
       code = setInputDataBlock(pSup, pBlock, order, scanFlag, false);
-      if (code) {
+      QUERY_CHECK_CODE(code, lino, _end);
-        T_LONG_JMP(pTaskInfo->env, code);
-      }
 
       code = blockDataEnsureCapacity(pInfo->pRes, pInfo->pRes->info.rows + pBlock->info.rows);
-      if (code != TSDB_CODE_SUCCESS) {
+      QUERY_CHECK_CODE(code, lino, _end);
-        T_LONG_JMP(pTaskInfo->env, code);
-      }
 
       code = projectApplyFunctions(pSup->pExprInfo, pInfo->pRes, pBlock, pSup->pCtx, pSup->numOfExprs,
                                    pProjectInfo->pPseudoColInfo);
-      if (code != TSDB_CODE_SUCCESS) {
+      QUERY_CHECK_CODE(code, lino, _end);
-        T_LONG_JMP(pTaskInfo->env, code);
-      }
 
       status = doIngroupLimitOffset(pLimitInfo, pBlock->info.id.groupId, pInfo->pRes, pOperator);
       if (status == PROJECT_RETRIEVE_CONTINUE) {
@@ -377,11 +370,8 @@ int32_t doProjectOperation(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
         pFinalRes->info.version = pRes->info.version;
 
         // continue merge data, ignore the group id
-        int32_t ret = blockDataMerge(pFinalRes, pRes);
+        code = blockDataMerge(pFinalRes, pRes);
-        if (ret < 0) {
+        QUERY_CHECK_CODE(code, lino, _end);
-          pTaskInfo->code = code;
-          return code;
-        }
 
         if (pFinalRes->info.rows + pRes->info.rows <= pOperator->resultInfo.threshold && (pOperator->status != OP_EXEC_DONE)) {
           continue;
@@ -390,10 +380,7 @@ int32_t doProjectOperation(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
 
       // do apply filter
       code = doFilter(pFinalRes, pOperator->exprSupp.pFilterInfo, NULL);
-      if (code) {
+      QUERY_CHECK_CODE(code, lino, _end);
-        pTaskInfo->code = code;
-        return code;
-      }
 
       // when apply the limit/offset for each group, pRes->info.rows may be 0, due to limit constraint.
       if (pFinalRes->info.rows > 0 || (pOperator->status == OP_EXEC_DONE)) {
@@ -404,10 +391,7 @@ int32_t doProjectOperation(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
       // do apply filter
       if (pRes->info.rows > 0) {
         code = doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL);
-        if (code) {
+        QUERY_CHECK_CODE(code, lino, _end);
-          pTaskInfo->code = code;
-          return code;
-        }
 
         if (pRes->info.rows == 0) {
           continue;
@@ -436,6 +420,13 @@ int32_t doProjectOperation(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
   }
 
   *pResBlock = (p->info.rows > 0)? p:NULL;
+
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
+  }
   return code;
 }
 
@@ -578,14 +569,15 @@ int32_t doApplyIndefinitFunction(SOperatorInfo* pOperator, SSDataBlock** pResBlo
   SOptrBasicInfo*     pInfo = &pIndefInfo->binfo;
   SExprSupp*          pSup = &pOperator->exprSupp;
   int64_t             st = 0;
-  int32_t             code = 0;
+  int32_t             code = TSDB_CODE_SUCCESS;
+  int32_t             lino = 0;
   SSDataBlock*        pRes = pInfo->pRes;
 
   blockDataCleanup(pRes);
 
   SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo;
   if (pOperator->status == OP_EXEC_DONE) {
-    return 0;
+    return code;
   }
 
   if (pOperator->cost.openCost == 0) {
@@ -637,10 +629,7 @@ int32_t doApplyIndefinitFunction(SOperatorInfo* pOperator, SSDataBlock** pResBlo
     }
 
     code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL);
-    if (code) {
+    QUERY_CHECK_CODE(code, lino, _end);
-      pTaskInfo->code = code;
-      return code;
-    }
 
     size_t rows = pInfo->pRes->info.rows;
     if (rows > 0 || pOperator->status == OP_EXEC_DONE) {
@@ -658,6 +647,13 @@ int32_t doApplyIndefinitFunction(SOperatorInfo* pOperator, SSDataBlock** pResBlo
   }
 
   *pResBlock = (rows > 0) ? pInfo->pRes : NULL;
+
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
+  }
   return code;
 }
 

source/libs/executor/src/scanoperator.c

@@ -951,7 +951,8 @@ static int32_t doTableScanImplNext(SOperatorInfo* pOperator, SSDataBlock** ppRes
 
     if (isTaskKilled(pTaskInfo)) {
       pAPI->tsdReader.tsdReaderReleaseDataBlock(pTableScanInfo->base.dataReader);
-      return pTaskInfo->code;
+      code = pTaskInfo->code;
+      goto _end;
     }
 
     if (pOperator->status == OP_EXEC_DONE) {
@@ -996,6 +997,7 @@ _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
     pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   return code;
 }
@@ -1416,6 +1418,7 @@ _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
     pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
 
   return code;
@@ -2944,8 +2947,9 @@ static int32_t doQueueScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
       if (pResult && pResult->info.rows > 0) {
         bool hasPrimaryKey = pAPI->tqReaderFn.tqGetTablePrimaryKey(pInfo->tqReader);
         code = processPrimaryKey(pResult, hasPrimaryKey, &pTaskInfo->streamInfo.currentOffset);
+        QUERY_CHECK_CODE(code, lino, _end);
         qDebug("tmqsnap doQueueScan get data utid:%" PRId64 "", pResult->info.id.uid);
-        if (pResult->info.rows > 0 || code != TSDB_CODE_SUCCESS) {
+        if (pResult->info.rows > 0) {
           (*ppRes) = pResult;
           return code;
         }
@@ -3009,8 +3013,9 @@ static int32_t doQueueScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
 
 _end:
   if (code != TSDB_CODE_SUCCESS) {
-    pTaskInfo->code = code;
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   (*ppRes) = NULL;
   return code;
@@ -3340,9 +3345,7 @@ FETCH_NEXT_BLOCK:
     if (pBlock->info.parTbName[0]) {
       code =
           pAPI->stateStore.streamStatePutParName(pStreamInfo->pState, pBlock->info.id.groupId, pBlock->info.parTbName);
-      if (code != TSDB_CODE_SUCCESS) {
+      QUERY_CHECK_CODE(code, lino, _end);
-        qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
-      }
     }
 
     // TODO move into scan
@@ -3482,7 +3485,7 @@ FETCH_NEXT_BLOCK:
           return code;
         }
         qError("%s===stream=== %s failed at line %d since pInfo->pUpdateRes is empty", GET_TASKID(pTaskInfo), __func__,
-               lino);
+               __LINE__);
         blockDataCleanup(pInfo->pUpdateDataRes);
         pInfo->scanMode = STREAM_SCAN_FROM_READERHANDLE;
       } break;
@@ -3496,7 +3499,7 @@ FETCH_NEXT_BLOCK:
           return code;
         }
         qError("%s===stream=== %s failed at line %d since pInfo->pUpdateRes is empty", GET_TASKID(pTaskInfo), __func__,
-               lino);
+               __LINE__);
         blockDataCleanup(pInfo->pUpdateDataRes);
         pInfo->scanMode = STREAM_SCAN_FROM_READERHANDLE;
       } break;
@@ -3658,8 +3661,9 @@ FETCH_NEXT_BLOCK:
 
 _end:
   if (code != TSDB_CODE_SUCCESS) {
-    pTaskInfo->code = code;
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   (*ppRes) = NULL;
   return code;
@@ -3730,6 +3734,7 @@ static int32_t doRawScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
       if (pBlock && pBlock->info.rows > 0) {
         bool hasPrimaryKey = pAPI->snapshotFn.taosXGetTablePrimaryKey(pInfo->sContext);
         code = processPrimaryKey(pBlock, hasPrimaryKey, &pTaskInfo->streamInfo.currentOffset);
+        QUERY_CHECK_CODE(code, lino, _end);
         qDebug("tmqsnap doRawScan get data uid:%" PRId64 "", pBlock->info.id.uid);
         (*ppRes) = pBlock;
         return code;
@@ -3741,7 +3746,7 @@ static int32_t doRawScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
     QUERY_CHECK_CODE(code, lino, _end);
     if (code != 0) {
       tDeleteSchemaWrapper(mtInfo.schema);
-      goto _end;
+      QUERY_CHECK_CODE(code, lino, _end);
     }
     STqOffsetVal offset = {0};
     if (mtInfo.uid == 0 || pInfo->sContext->withMeta == ONLY_META) {  // read snapshot done, change to get data from wal
@@ -3831,6 +3836,7 @@ _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
     pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
 
   (*ppRes) = NULL;
@@ -4677,6 +4683,7 @@ _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
     pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
 
   return code;
@@ -4684,6 +4691,7 @@ _end:
 
 static int32_t doTagScanFromMetaEntryNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
   int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
   if (pOperator->status == OP_EXEC_DONE) {
     (*ppRes) = NULL;
     return code;
@@ -4699,10 +4707,7 @@ static int32_t doTagScanFromMetaEntryNext(SOperatorInfo* pOperator, SSDataBlock*
 
   int32_t size = 0;
   code = tableListGetSize(pInfo->pTableListInfo, &size);
-  if (code != TSDB_CODE_SUCCESS) {
+  QUERY_CHECK_CODE(code, lino, _end);
-    qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
-    return code;
-  }
 
   if (size == 0) {
     setTaskStatus(pTaskInfo, TASK_COMPLETED);
@@ -4716,11 +4721,11 @@ static int32_t doTagScanFromMetaEntryNext(SOperatorInfo* pOperator, SSDataBlock*
 
   while (pInfo->curPos < size && count < pOperator->resultInfo.capacity) {
     code = doTagScanOneTable(pOperator, pRes, count, &mr, &pTaskInfo->storageAPI);
-    if (code == TSDB_CODE_OUT_OF_MEMORY) {
+    if (code != TSDB_CODE_OUT_OF_MEMORY) {
-      break;
-    } else {
       // ignore other error
+      code = TSDB_CODE_SUCCESS;
     }
+    QUERY_CHECK_CODE(code, lino, _end);
 
     ++count;
     if (++pInfo->curPos >= size) {
@@ -4744,6 +4749,13 @@ static int32_t doTagScanFromMetaEntryNext(SOperatorInfo* pOperator, SSDataBlock*
   pOperator->resultInfo.totalRows += pRes->info.rows;
 
   (*ppRes) = (pRes->info.rows == 0) ? NULL : pInfo->pRes;
+
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
+  }
   return code;
 }
 
@@ -5429,6 +5441,7 @@ _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
     pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   } else {
     (*ppRes) = pBlock;
   }
@@ -5945,6 +5958,7 @@ _end:
   if (code != TSDB_CODE_SUCCESS) {
     qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
     pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   } else {
     (*ppRes) = pBlock;
   }
@@ -6460,7 +6474,12 @@ static int32_t doTableCountScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRe
   }
 
   code = buildVnodeDbTableCount(pOperator, pInfo, pSupp, pRes);
-  if ((pRes->info.rows > 0) && (code == 0)) {
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed since %s", __func__, tstrerror(code));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
+  }
+  if (pRes->info.rows > 0) {
     *ppRes = pRes;
   }
 

source/libs/executor/src/sortoperator.c

@@ -349,82 +349,84 @@ void applyScalarFunction(SSDataBlock* pBlock, void* param) {
 int32_t doOpenSortOperator(SOperatorInfo* pOperator) {
   SSortOperatorInfo* pInfo = pOperator->info;
   SExecTaskInfo*     pTaskInfo = pOperator->pTaskInfo;
+  int32_t            code = TSDB_CODE_SUCCESS;
+  int32_t            lino = 0;
+  SSortSource* pSource =NULL;
 
   if (OPTR_IS_OPENED(pOperator)) {
-    return TSDB_CODE_SUCCESS;
+    return code;
   }
 
   pInfo->startTs = taosGetTimestampUs();
   //  pInfo->binfo.pRes is not equalled to the input datablock.
   pInfo->pSortHandle = NULL;
-  int32_t code =
+  code =
       tsortCreateSortHandle(pInfo->pSortInfo, SORT_SINGLESOURCE_SORT, -1, -1, NULL, pTaskInfo->id.str, pInfo->maxRows,
                             pInfo->maxTupleLength, tsPQSortMemThreshold * 1024 * 1024, &pInfo->pSortHandle);
-  if (code) {
+  QUERY_CHECK_CODE(code, lino, _end);
-    return code;
-  }
 
   tsortSetFetchRawDataFp(pInfo->pSortHandle, loadNextDataBlock, applyScalarFunction, pOperator);
 
-  SSortSource* pSource = taosMemoryCalloc(1, sizeof(SSortSource));
+  pSource = taosMemoryCalloc(1, sizeof(SSortSource));
-  if (pSource == NULL) {
+  QUERY_CHECK_NULL(pSource, code, lino, _end, terrno);
-    return terrno;
-  }
 
   pSource->param = pOperator->pDownstream[0];
   pSource->onlyRef = true;
 
   code = tsortAddSource(pInfo->pSortHandle, pSource);
-  if (code) {
+  QUERY_CHECK_CODE(code, lino, _end);
-    taosMemoryFree(pSource);
+  pSource = NULL;
-    return code;
-  }
 
   code = tsortOpen(pInfo->pSortHandle);
-  if (code != TSDB_CODE_SUCCESS) {
+  QUERY_CHECK_CODE(code, lino, _end);
-    pTaskInfo->code = code;
+  pOperator->cost.openCost = (taosGetTimestampUs() - pInfo->startTs) / 1000.0;
-  } else {
+  pOperator->status = OP_RES_TO_RETURN;
-    pOperator->cost.openCost = (taosGetTimestampUs() - pInfo->startTs) / 1000.0;
+  OPTR_SET_OPENED(pOperator);
-    pOperator->status = OP_RES_TO_RETURN;
-    OPTR_SET_OPENED(pOperator);
-  }
 
+_end:
+  if (pSource) {
+    taosMemoryFree(pSource);
+  }
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
+  }
   return code;
 }
 
 int32_t doSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
   QRY_PARAM_CHECK(pResBlock);
+  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t lino = 0;
   if (pOperator->status == OP_EXEC_DONE) {
-    return 0;
+    return code;
   }
 
   SExecTaskInfo*     pTaskInfo = pOperator->pTaskInfo;
   SSortOperatorInfo* pInfo = pOperator->info;
 
-  int32_t code = pOperator->fpSet._openFn(pOperator);
+  code = pOperator->fpSet._openFn(pOperator);
-  if (code != TSDB_CODE_SUCCESS) {
+  QUERY_CHECK_CODE(code, lino, _end);
-    return code;
-  }
 
   // multi-group case not handle here
   SSDataBlock* pBlock = NULL;
   while (1) {
     if (tsortIsClosed(pInfo->pSortHandle)) {
       code = TSDB_CODE_TSC_QUERY_CANCELLED;
-      T_LONG_JMP(pTaskInfo->env, code);
+      QUERY_CHECK_CODE(code, lino, _end);
     }
 
     code = getSortedBlockData(pInfo->pSortHandle, pInfo->binfo.pRes, pOperator->resultInfo.capacity,
                                 pInfo->matchInfo.pList, pInfo, &pBlock);
-    if (pBlock == NULL || code != 0) {
+    QUERY_CHECK_CODE(code, lino, _end);
+    if (pBlock == NULL) {
       setOperatorCompleted(pOperator);
       return code;
     }
 
     code = doFilter(pBlock, pOperator->exprSupp.pFilterInfo, &pInfo->matchInfo);
-    if (code) {
+    QUERY_CHECK_CODE(code, lino, _end);
-      break;
-    }
 
     if (blockDataGetNumOfRows(pBlock) == 0) {
       continue;
@@ -443,6 +445,12 @@ int32_t doSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
   }
 
   *pResBlock = blockDataGetNumOfRows(pBlock) > 0 ? pBlock : NULL;
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
+  }
   return code;
 }
 
@@ -692,16 +700,16 @@ int32_t doGroupSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
   QRY_PARAM_CHECK(pResBlock);
   SExecTaskInfo*          pTaskInfo = pOperator->pTaskInfo;
   SGroupSortOperatorInfo* pInfo = pOperator->info;
+  int32_t                 code = TSDB_CODE_SUCCESS;
+  int32_t                 lino = 0;
 
   if (pOperator->status == OP_EXEC_DONE) {
-    return 0;
-  }
-
-  int32_t code = pOperator->fpSet._openFn(pOperator);
-  if (code != TSDB_CODE_SUCCESS) {
     return code;
   }
 
+  code = pOperator->fpSet._openFn(pOperator);
+  QUERY_CHECK_CODE(code, lino, _end);
+
   if (!pInfo->hasGroupId) {
     pInfo->hasGroupId = true;
 
@@ -714,30 +722,25 @@ int32_t doGroupSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
     pInfo->currGroupId = pInfo->prefetchedSortInput->info.id.groupId;
     pInfo->childOpStatus = CHILD_OP_NEW_GROUP;
     code = beginSortGroup(pOperator);
-    if (code) {
+    QUERY_CHECK_CODE(code, lino, _end);
-      return code;
-    }
   }
 
   SSDataBlock* pBlock = NULL;
   while (pInfo->pCurrSortHandle != NULL) {
     if (tsortIsClosed(pInfo->pCurrSortHandle)) {
       code = TSDB_CODE_TSC_QUERY_CANCELLED;
-      T_LONG_JMP(pTaskInfo->env, code);
+      QUERY_CHECK_CODE(code, lino, _end);
     }
 
     // beginSortGroup would fetch all child blocks of pInfo->currGroupId;
     if (pInfo->childOpStatus == CHILD_OP_SAME_GROUP) {
-      pTaskInfo->code = code = TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;
+      code = TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;
-      qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code));
+      QUERY_CHECK_CODE(code, lino, _end);
-      return code;
     }
 
     code = getGroupSortedBlockData(pInfo->pCurrSortHandle, pInfo->binfo.pRes, pOperator->resultInfo.capacity,
                                      pInfo->matchInfo.pList, pInfo, &pBlock);
-    if (code != TSDB_CODE_SUCCESS) {
+    QUERY_CHECK_CODE(code, lino, _end);
-      return code;
-    }
     if (pBlock != NULL) {
       pBlock->info.id.groupId = pInfo->currGroupId;
       pOperator->resultInfo.totalRows += pBlock->info.rows;
@@ -748,9 +751,7 @@ int32_t doGroupSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
         (void) finishSortGroup(pOperator);
         pInfo->currGroupId = pInfo->prefetchedSortInput->info.id.groupId;
         code = beginSortGroup(pOperator);
-        if (code) {
+        QUERY_CHECK_CODE(code, lino, _end);
-          return code;
-        }
       } else if (pInfo->childOpStatus == CHILD_OP_FINISHED) {
         (void) finishSortGroup(pOperator);
         setOperatorCompleted(pOperator);
@@ -759,6 +760,12 @@ int32_t doGroupSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock) {
     }
   }
 
+_end:
+  if (code != TSDB_CODE_SUCCESS) {
+    qError("%s failed at line %d since %s", __func__, lino, tstrerror(code));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
+  }
   return code;
 }
 

source/libs/executor/src/streamcountwindowoperator.c

@@ -744,8 +744,9 @@ static int32_t doStreamCountAggNext(SOperatorInfo* pOperator, SSDataBlock** ppRe
 
 _end:
   if (code != TSDB_CODE_SUCCESS) {
-    pTaskInfo->code = code;
     qError("%s failed at line %d since %s. task:%s", __func__, lino, tstrerror(code), GET_TASKID(pTaskInfo));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   setStreamOperatorCompleted(pOperator);
   (*ppRes) = NULL;

source/libs/executor/src/streameventwindowoperator.c

@@ -179,7 +179,7 @@ _end:
     pAggSup->stateStore.streamStateSessionDel(pAggSup->pState, &pCurWin->winInfo.sessionWin);
   }
   pAggSup->stateStore.streamStateFreeCur(pCur);
-  qDebug("===stream===set event next win buff. skey:%" PRId64 ", endkey:%" PRId64, pCurWin->winInfo.sessionWin.win.skey,
+  qDebug("===stream===set event cur win buff. skey:%" PRId64 ", endkey:%" PRId64, pCurWin->winInfo.sessionWin.win.skey,
          pCurWin->winInfo.sessionWin.win.ekey);
 
 _error:
@@ -233,7 +233,7 @@ int32_t updateEventWindowInfo(SStreamAggSupporter* pAggSup, SEventWindowInfo* pW
       pWinInfo->pWinFlag->endFlag = ends[i];
     } else if (pWin->ekey == pTsData[i]) {
       pWinInfo->pWinFlag->endFlag |= ends[i];
-    } else {
+    } else if (ends[i] && !pWinInfo->pWinFlag->endFlag) {
       *pRebuild = true;
       pWinInfo->pWinFlag->endFlag |= ends[i];
       (*pWinRow) = i + 1 - start;
@@ -734,8 +734,9 @@ static int32_t doStreamEventAggNext(SOperatorInfo* pOperator, SSDataBlock** ppRe
 
 _end:
   if (code != TSDB_CODE_SUCCESS) {
-    pTaskInfo->code = code;
     qError("%s failed at line %d since %s. task:%s", __func__, lino, tstrerror(code), GET_TASKID(pTaskInfo));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   setStreamOperatorCompleted(pOperator);
   (*ppRes) = NULL;

source/libs/executor/src/streamfilloperator.c

@@ -1155,8 +1155,9 @@ static int32_t doStreamFillNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) {
 
 _end:
   if (code != TSDB_CODE_SUCCESS) {
-    pTaskInfo->code = code;
     qError("%s failed at line %d since %s. task:%s", __func__, lino, tstrerror(code), GET_TASKID(pTaskInfo));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   setOperatorCompleted(pOperator);
   resetStreamFillInfo(pInfo);

source/libs/executor/src/streamtimewindowoperator.c

@@ -1802,8 +1802,9 @@ static int32_t doStreamFinalIntervalAggNext(SOperatorInfo* pOperator, SSDataBloc
 
 _end:
   if (code != TSDB_CODE_SUCCESS) {
-    pTaskInfo->code = code;
     qError("%s failed at line %d since %s. task:%s", __func__, lino, tstrerror(code), GET_TASKID(pTaskInfo));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   setStreamOperatorCompleted(pOperator);
   (*ppRes) = NULL;
@@ -3571,8 +3572,9 @@ static int32_t doStreamSessionAggNext(SOperatorInfo* pOperator, SSDataBlock** pp
 
 _end:
   if (code != TSDB_CODE_SUCCESS) {
-    pTaskInfo->code = code;
     qError("%s failed at line %d since %s. task:%s", __func__, lino, tstrerror(code), GET_TASKID(pTaskInfo));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   setStreamOperatorCompleted(pOperator);
   (*ppRes) = NULL;
@@ -4076,8 +4078,9 @@ static int32_t doStreamSessionSemiAggNext(SOperatorInfo* pOperator, SSDataBlock*
 
 _end:
   if (code != TSDB_CODE_SUCCESS) {
-    pTaskInfo->code = code;
     qError("%s failed at line %d since %s. task:%s", __func__, lino, tstrerror(code), GET_TASKID(pTaskInfo));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
 
   clearFunctionContext(&pOperator->exprSupp);
@@ -4816,8 +4819,9 @@ static int32_t doStreamStateAggNext(SOperatorInfo* pOperator, SSDataBlock** ppRe
 
 _end:
   if (code != TSDB_CODE_SUCCESS) {
-    pTaskInfo->code = code;
     qError("%s failed at line %d since %s. task:%s", __func__, lino, tstrerror(code), GET_TASKID(pTaskInfo));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   setStreamOperatorCompleted(pOperator);
   (*ppRes) = NULL;
@@ -5216,6 +5220,7 @@ static int32_t doStreamIntervalAggNext(SOperatorInfo* pOperator, SSDataBlock** p
       code = TSDB_CODE_SUCCESS;
       break;
     }
+    QUERY_CHECK_CODE(code, lino, _end);
     pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey);
     pInfo->twAggSup.minTs = TMIN(pInfo->twAggSup.minTs, pBlock->info.window.skey);
   }
@@ -5258,8 +5263,9 @@ static int32_t doStreamIntervalAggNext(SOperatorInfo* pOperator, SSDataBlock** p
 
 _end:
   if (code != TSDB_CODE_SUCCESS) {
-    pTaskInfo->code = code;
     qError("%s failed at line %d since %s. task:%s", __func__, lino, tstrerror(code), GET_TASKID(pTaskInfo));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   setStreamOperatorCompleted(pOperator);
   (*ppRes) = NULL;
@@ -5795,8 +5801,9 @@ static int32_t doStreamMidIntervalAggNext(SOperatorInfo* pOperator, SSDataBlock*
 
 _end:
   if (code != TSDB_CODE_SUCCESS) {
-    pTaskInfo->code = code;
     qError("%s failed at line %d since %s. task:%s", __func__, lino, tstrerror(code), GET_TASKID(pTaskInfo));
+    pTaskInfo->code = code;
+    T_LONG_JMP(pTaskInfo->env, code);
   }
   (*ppRes) = NULL;
   return code;

source/libs/executor/src/sysscanoperator.c

@@ -2049,7 +2049,7 @@ static int32_t doSysTableScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes)
     if (isTaskKilled(pOperator->pTaskInfo)) {
       setOperatorCompleted(pOperator);
       (*ppRes) = NULL;
-      return pTaskInfo->code;
+      break;
     }
 
     blockDataCleanup(pInfo->pRes);
@@ -2092,12 +2092,18 @@ static int32_t doSysTableScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes)
         continue;
       }
       (*ppRes) = pBlock;
-      return pTaskInfo->code;
     } else {
       (*ppRes) = NULL;
-      return pTaskInfo->code;
     }
+    break;
   }
+
+_end:
+  if (pTaskInfo->code) {
+    qError("%s failed since %s", __func__, tstrerror(pTaskInfo->code));
+    T_LONG_JMP(pTaskInfo->env, pTaskInfo->code);
+  }
+  return pTaskInfo->code;
 }
 
 static void sysTableScanFillTbName(SOperatorInfo* pOperator, const SSysTableScanInfo* pInfo, const char* name,

source/libs/executor/src/tsort.c

@@ -437,41 +437,36 @@ int32_t tsortAddSource(SSortHandle* pSortHandle, void* pSource) {
 
 static int32_t doAddNewExternalMemSource(SDiskbasedBuf* pBuf, SArray* pAllSources, SSDataBlock* pBlock,
                                          int32_t* sourceId, SArray* pPageIdList) {
+  int32_t      code = 0;
+  int32_t      lino = 0;
   SSortSource* pSource = taosMemoryCalloc(1, sizeof(SSortSource));
-  if (pSource == NULL) {
+  QUERY_CHECK_NULL(pSource, code, lino, _err, terrno);
-    taosArrayDestroy(pPageIdList);
-    return terrno;
-  }
 
   pSource->src.pBlock = pBlock;
   pSource->pageIdList = pPageIdList;
 
-  void* p = taosArrayPush(pAllSources, &pSource);
+  SSortSource** p = taosArrayPush(pAllSources, &pSource);
-  if (p == NULL) {
+  QUERY_CHECK_NULL(p, code, lino, _err, terrno);
-    taosArrayDestroy(pPageIdList);
+  pSource = NULL;
-    return terrno;
-  }
 
   (*sourceId) += 1;
 
-  int32_t rowSize = blockDataGetSerialRowSize(pSource->src.pBlock);
+  int32_t rowSize = blockDataGetSerialRowSize((*p)->src.pBlock);
 
   // The value of numOfRows must be greater than 0, which is guaranteed by the previous memory allocation
   int32_t numOfRows =
       (getBufPageSize(pBuf) - blockDataGetSerialMetaSize(taosArrayGetSize(pBlock->pDataBlock))) / rowSize;
-  if (numOfRows <= 0) {
+  QUERY_CHECK_CONDITION((numOfRows > 0), code, lino, _err, TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR);
-    qError("sort failed at: %s:%d", __func__, __LINE__);
-    taosArrayDestroy(pPageIdList);
-    return TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR;
-  }
 
-  int32_t code = blockDataEnsureCapacity(pSource->src.pBlock, numOfRows);
+  code = blockDataEnsureCapacity((*p)->src.pBlock, numOfRows);
-  if (code != 0) {
+  QUERY_CHECK_CODE(code, lino, _err);
-    qError("sort failed at: %s:%d", __func__, __LINE__);
-    taosArrayDestroy(pPageIdList);
-  }
 
   return code;
+
+_err:
+  if (pSource) taosMemoryFree(pSource);
+  qError("sort failed at %s:%d since %s", __func__, lino, tstrerror(code));
+  return code;
 }
 
 static int32_t doAddToBuf(SSDataBlock* pDataBlock, SSortHandle* pHandle) {
@@ -554,7 +549,12 @@ static int32_t doAddToBuf(SSDataBlock* pDataBlock, SSortHandle* pHandle) {
     return code;
   }
 
-  return doAddNewExternalMemSource(pHandle->pBuf, pHandle->pOrderedSource, pBlock, &pHandle->sourceId, pPageIdList);
+  code = doAddNewExternalMemSource(pHandle->pBuf, pHandle->pOrderedSource, pBlock, &pHandle->sourceId, pPageIdList);
+  if (code) {
+    blockDataDestroy(pBlock);
+    taosArrayDestroy(pPageIdList);
+  }
+  return code;
 }
 
 static void setCurrentSourceDone(SSortSource* pSource, SSortHandle* pHandle) {
@@ -1023,6 +1023,9 @@ static int32_t doSortForEachGroup(SSortHandle* pHandle, int32_t sortTimes, int32
     QUERY_CHECK_CODE(code, lino, _err);
 
     code = doAddNewExternalMemSource(pHandle->pBuf, pResList, pBlock, &pHandle->sourceId, pPageIdList);
+    if (code != TSDB_CODE_SUCCESS) {
+      blockDataDestroy(pBlock);
+    }
     QUERY_CHECK_CODE(code, lino, _err);
   }
 
@@ -2144,6 +2147,10 @@ static int32_t sortBlocksToExtSource(SSortHandle* pHandle, SArray* aBlk, SArray*
   if (code) goto _error;
 
   code = doAddNewExternalMemSource(pHandle->pBuf, aExtSrc, pMemSrcBlk, &pHandle->sourceId, aPgId);
+  if (code != TSDB_CODE_SUCCESS) {
+    blockDataDestroy(pMemSrcBlk);
+    goto _error;
+  }
 
   cleanupMergeSup(&sup);
   tMergeTreeDestroy(&pTree);
@@ -2306,9 +2313,15 @@ static int32_t createBlocksMergeSortInitialSources(SSortHandle* pHandle) {
         }
 
         code = tSimpleHashPut(mUidBlk, &pBlk->info.id.uid, sizeof(pBlk->info.id.uid), &tBlk, POINTER_BYTES);
+        if (code != TSDB_CODE_SUCCESS) {
+          blockDataDestroy(tBlk);
+        }
         QUERY_CHECK_CODE(code, lino, _err);
 
         void* px = taosArrayPush(aBlkSort, &tBlk);
+        if (px == NULL) {
+          blockDataDestroy(tBlk);
+        }
         QUERY_CHECK_NULL(px, code, lino, _err, terrno);
       }
     }

source/libs/monitor/src/monFramework.c

@@ -100,7 +100,9 @@ extern char* tsMonFwUri;
 #define VNODE_ROLE "taosd_vnodes_info:role"
 
 void monInitMonitorFW(){
-  (void)taos_collector_registry_default_init();
+  if (taos_collector_registry_default_init() != 0) {
+    uError("failed to init default collector registry");
+  }
 
   tsMonitor.metrics = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
   taos_gauge_t *gauge = NULL;
@@ -115,7 +117,9 @@ void monInitMonitorFW(){
   for(int32_t i = 0; i < 25; i++){
     gauge= taos_gauge_new(dnodes_gauges[i], "",  dnodes_label_count, dnodes_sample_labels);
     if(taos_collector_registry_register_metric(gauge) == 1){
-      (void)taos_counter_destroy(gauge);
+      if (taos_counter_destroy(gauge) != 0) {
+        uError("failed to delete metric %s", dnodes_gauges[i]);
+      }
     }
     if (taosHashPut(tsMonitor.metrics, dnodes_gauges[i], strlen(dnodes_gauges[i]), &gauge, sizeof(taos_gauge_t *)) !=
         0) {
@@ -129,7 +133,9 @@ void monInitMonitorFW(){
   for(int32_t i = 0; i < 3; i++){
     gauge= taos_gauge_new(dnodes_data_gauges[i], "",  dnodes_data_label_count, dnodes_data_sample_labels);
     if(taos_collector_registry_register_metric(gauge) == 1){
-      (void)taos_counter_destroy(gauge);
+      if (taos_counter_destroy(gauge) != 0) {
+        uError("failed to delete metric %s", dnodes_data_gauges[i]);
+      }
     }
     if (taosHashPut(tsMonitor.metrics, dnodes_data_gauges[i], strlen(dnodes_data_gauges[i]), &gauge,
                     sizeof(taos_gauge_t *)) != 0) {
@@ -143,7 +149,9 @@ void monInitMonitorFW(){
   for(int32_t i = 0; i < 3; i++){
     gauge= taos_gauge_new(dnodes_log_gauges[i], "",  dnodes_log_label_count, dnodes_log_sample_labels);
     if(taos_collector_registry_register_metric(gauge) == 1){
-      (void)taos_counter_destroy(gauge);
+      if (taos_counter_destroy(gauge) != 0) {
+        uError("failed to delete metric %s", dnodes_log_gauges[i]);
+      }
     }
     if (taosHashPut(tsMonitor.metrics, dnodes_log_gauges[i], strlen(dnodes_log_gauges[i]), &gauge,
                     sizeof(taos_gauge_t *)) != 0) {
@@ -154,7 +162,9 @@ void monInitMonitorFW(){
 
 void monCleanupMonitorFW(){
   taosHashCleanup(tsMonitor.metrics);
-  (void)taos_collector_registry_destroy(TAOS_COLLECTOR_REGISTRY_DEFAULT);
+  if (taos_collector_registry_destroy(TAOS_COLLECTOR_REGISTRY_DEFAULT) != 0) {
+    uError("failed to destroy default collector registry");
+  }
   TAOS_COLLECTOR_REGISTRY_DEFAULT = NULL;
 }
 
@@ -174,7 +184,9 @@ void monGenClusterInfoTable(SMonInfo *pMonitor){
       uError("failed to delete metric %s", metric_names[i]);
     }
 
-    (void)taosHashRemove(tsMonitor.metrics, metric_names[i], strlen(metric_names[i]));
+    if (taosHashRemove(tsMonitor.metrics, metric_names[i], strlen(metric_names[i])) != 0) {
+      uError("failed to remove metric %s", metric_names[i]);
+    }
   } 
 
   if(pBasicInfo->cluster_id == 0) {
@@ -191,7 +203,9 @@ void monGenClusterInfoTable(SMonInfo *pMonitor){
   for(int32_t i = 0; i < 18; i++){
     gauge= taos_gauge_new(metric_names[i], "",  label_count, sample_labels1);
     if(taos_collector_registry_register_metric(gauge) == 1){
-      (void)taos_counter_destroy(gauge);
+      if (taos_counter_destroy(gauge) != 0) {
+        uError("failed to delete metric %s", metric_names[i]);
+      }
     }
     if (taosHashPut(tsMonitor.metrics, metric_names[i], strlen(metric_names[i]), &gauge, sizeof(taos_gauge_t *)) != 0) {
       uError("failed to add cluster gauge at%d:%s", i, metric_names[i]);
@@ -317,11 +331,15 @@ void monGenVgroupInfoTable(SMonInfo *pMonitor){
   const char *vgroup_sample_labels[] = {"cluster_id", "vgroup_id", "database_name"};
   taos_gauge_t *tableNumGauge = taos_gauge_new(TABLES_NUM, "",  vgroup_label_count, vgroup_sample_labels);
   if(taos_collector_registry_register_metric(tableNumGauge) == 1){
-    (void)taos_counter_destroy(tableNumGauge);
+    if (taos_counter_destroy(tableNumGauge) != 0) {
+      uError("failed to delete metric " TABLES_NUM);
+    }
   }
   taos_gauge_t *statusGauge = taos_gauge_new(STATUS, "",  vgroup_label_count, vgroup_sample_labels);
   if(taos_collector_registry_register_metric(statusGauge) == 1){
-    (void)taos_counter_destroy(statusGauge);
+    if (taos_counter_destroy(statusGauge) != 0) {
+      uError("failed to delete metric " STATUS);
+    }
   }
 
   char cluster_id[TSDB_CLUSTER_ID_LEN] = {0};
@@ -530,7 +548,9 @@ void monGenDnodeStatusInfoTable(SMonInfo *pMonitor){
 
   gauge= taos_gauge_new(DNODE_STATUS, "",  dnodes_label_count, dnodes_sample_labels);
   if(taos_collector_registry_register_metric(gauge) == 1){
-    (void)taos_counter_destroy(gauge);
+    if (taos_counter_destroy(gauge) != 0) {
+      uError("failed to delete metric " DNODE_STATUS);
+    }
   }
 
   char cluster_id[TSDB_CLUSTER_ID_LEN];
@@ -633,7 +653,9 @@ void monGenMnodeRoleTable(SMonInfo *pMonitor){
       uError("failed to delete metric %s", mnodes_role_gauges[i]);
     }
 
-    (void)taosHashRemove(tsMonitor.metrics, mnodes_role_gauges[i], strlen(mnodes_role_gauges[i]));
+    if (taosHashRemove(tsMonitor.metrics, mnodes_role_gauges[i], strlen(mnodes_role_gauges[i])) != 0) {
+      uError("failed to remove metric %s", mnodes_role_gauges[i]);
+    }
   }
 
   SMonClusterInfo *pInfo = &pMonitor->mmInfo.cluster;
@@ -647,7 +669,9 @@ void monGenMnodeRoleTable(SMonInfo *pMonitor){
   for(int32_t i = 0; i < 1; i++){
     gauge= taos_gauge_new(mnodes_role_gauges[i], "",  mnodes_role_label_count, mnodes_role_sample_labels);
     if(taos_collector_registry_register_metric(gauge) == 1){
-      (void)taos_counter_destroy(gauge);
+      if (taos_counter_destroy(gauge) != 0) {
+        uError("failed to destroy gauge");
+      }
     }
     if (taosHashPut(tsMonitor.metrics, mnodes_role_gauges[i], strlen(mnodes_role_gauges[i]), &gauge,
                     sizeof(taos_gauge_t *)) != 0) {
@@ -702,7 +726,9 @@ void monGenVnodeRoleTable(SMonInfo *pMonitor){
       uError("failed to delete metric %s", vnodes_role_gauges[i]);
     }
 
-    (void)taosHashRemove(tsMonitor.metrics, vnodes_role_gauges[i], strlen(vnodes_role_gauges[i]));
+    if (taosHashRemove(tsMonitor.metrics, vnodes_role_gauges[i], strlen(vnodes_role_gauges[i])) != 0) {
+      uError("failed to remove metric %s", vnodes_role_gauges[i]);
+    }
   }
 
   SMonVgroupInfo *pInfo = &pMonitor->mmInfo.vgroup;
@@ -716,7 +742,9 @@ void monGenVnodeRoleTable(SMonInfo *pMonitor){
   for(int32_t i = 0; i < 1; i++){
     gauge= taos_gauge_new(vnodes_role_gauges[i], "",  vnodes_role_label_count, vnodes_role_sample_labels);
     if(taos_collector_registry_register_metric(gauge) == 1){
-      (void)taos_counter_destroy(gauge);
+      if (taos_counter_destroy(gauge) != 0) {
+        uError("failed to destroy gauge");
+      }
     }
     if (taosHashPut(tsMonitor.metrics, vnodes_role_gauges[i], strlen(vnodes_role_gauges[i]), &gauge,
                     sizeof(taos_gauge_t *)) != 0) {
@@ -774,7 +802,9 @@ void monSendPromReport() {
                                   tmp) != 0) {
       uError("failed to send monitor msg");
     } else {
-      (void)taos_collector_registry_clear_batch(TAOS_COLLECTOR_REGISTRY_DEFAULT);
+      if (taos_collector_registry_clear_batch(TAOS_COLLECTOR_REGISTRY_DEFAULT) != 0) {
+        uError("failed to clear batch");
+      }
     }
     taosMemoryFreeClear(pCont);
   }

source/libs/monitor/src/monMain.c

@@ -145,7 +145,9 @@ void monInitVnode() {
     counter = taos_counter_new(VNODE_METRIC_SQL_COUNT, "counter for insert sql", label_count, sample_labels);
     uDebug("new metric:%p", counter);
     if (taos_collector_registry_register_metric(counter) == 1) {
-      (void)taos_counter_destroy(counter);
+      if (taos_counter_destroy(counter) != 0) {
+        uError("failed to destroy metric:%p", counter);
+      }
       uError("failed to register metric:%p", counter);
     } else {
       tsInsertCounter = counter;
@@ -226,14 +228,17 @@ static void monGenBasicJson(SMonInfo *pMonitor) {
 
   SJson *pJson = pMonitor->pJson;
   char   buf[40] = {0};
-  (void)taosFormatUtcTime(buf, sizeof(buf), pMonitor->curTime, TSDB_TIME_PRECISION_MILLI);
+  if (taosFormatUtcTime(buf, sizeof(buf), pMonitor->curTime, TSDB_TIME_PRECISION_MILLI) != 0) {
+    uError("failed to format time");
+    return;
+  }
 
-  (void)tjsonAddStringToObject(pJson, "ts", buf);
+  if (tjsonAddStringToObject(pJson, "ts", buf) != 0) uError("failed to add ts");
-  (void)tjsonAddDoubleToObject(pJson, "dnode_id", pInfo->dnode_id);
+  if (tjsonAddDoubleToObject(pJson, "dnode_id", pInfo->dnode_id) != 0) uError("failed to add dnode_id");
-  (void)tjsonAddStringToObject(pJson, "dnode_ep", pInfo->dnode_ep);
+  if (tjsonAddStringToObject(pJson, "dnode_ep", pInfo->dnode_ep) != 0) uError("failed to add dnode_ep");
   snprintf(buf, sizeof(buf), "%" PRId64, pInfo->cluster_id);
-  (void)tjsonAddStringToObject(pJson, "cluster_id", buf);
+  if (tjsonAddStringToObject(pJson, "cluster_id", buf) != 0) uError("failed to add cluster_id");
-  (void)tjsonAddDoubleToObject(pJson, "protocol", pInfo->protocol);
+  if (tjsonAddDoubleToObject(pJson, "protocol", pInfo->protocol) != 0) uError("failed to add protocol");
 }
 
 static void monGenBasicJsonBasic(SMonInfo *pMonitor) {
@@ -244,12 +249,12 @@ static void monGenBasicJsonBasic(SMonInfo *pMonitor) {
   char   buf[40] = {0};
 
   sprintf(buf, "%" PRId64, taosGetTimestamp(TSDB_TIME_PRECISION_MILLI));
-  (void)tjsonAddStringToObject(pJson, "ts", buf);
+  if (tjsonAddStringToObject(pJson, "ts", buf) != 0) uError("failed to add ts");
-  (void)tjsonAddDoubleToObject(pJson, "dnode_id", pInfo->dnode_id);
+  if (tjsonAddDoubleToObject(pJson, "dnode_id", pInfo->dnode_id) != 0) uError("failed to add dnode_id");
-  (void)tjsonAddStringToObject(pJson, "dnode_ep", pInfo->dnode_ep);
+  if (tjsonAddStringToObject(pJson, "dnode_ep", pInfo->dnode_ep) != 0) uError("failed to add dnode_ep");
   snprintf(buf, sizeof(buf), "%" PRId64, pInfo->cluster_id);
-  (void)tjsonAddStringToObject(pJson, "cluster_id", buf);
+  if (tjsonAddStringToObject(pJson, "cluster_id", buf) != 0) uError("failed to add cluster_id");
-  (void)tjsonAddDoubleToObject(pJson, "protocol", pInfo->protocol);
+  if (tjsonAddDoubleToObject(pJson, "protocol", pInfo->protocol) != 0) uError("failed to add protocol");
 }
 
 static void monGenClusterJson(SMonInfo *pMonitor) {
@@ -263,21 +268,24 @@ static void monGenClusterJson(SMonInfo *pMonitor) {
     return;
   }
 
-  (void)tjsonAddStringToObject(pJson, "first_ep", pInfo->first_ep);
+  if (tjsonAddStringToObject(pJson, "first_ep", pInfo->first_ep) != 0) uError("failed to add first_ep");
-  (void)tjsonAddDoubleToObject(pJson, "first_ep_dnode_id", pInfo->first_ep_dnode_id);
+  if (tjsonAddDoubleToObject(pJson, "first_ep_dnode_id", pInfo->first_ep_dnode_id) != 0)
-  (void)tjsonAddStringToObject(pJson, "version", pInfo->version);
+    uError("failed to add first_ep_dnode_id");
-  (void)tjsonAddDoubleToObject(pJson, "master_uptime", pInfo->master_uptime);
+  if (tjsonAddStringToObject(pJson, "version", pInfo->version) != 0) uError("failed to add version");
-  (void)tjsonAddDoubleToObject(pJson, "monitor_interval", pInfo->monitor_interval);
+  if (tjsonAddDoubleToObject(pJson, "master_uptime", pInfo->master_uptime) != 0) uError("failed to add master_uptime");
-  (void)tjsonAddDoubleToObject(pJson, "dbs_total", pInfo->dbs_total);
+  if (tjsonAddDoubleToObject(pJson, "monitor_interval", pInfo->monitor_interval) != 0)
-  (void)tjsonAddDoubleToObject(pJson, "tbs_total", pInfo->tbs_total);
+    uError("failed to add monitor_interval");
-  (void)tjsonAddDoubleToObject(pJson, "stbs_total", pInfo->stbs_total);
+  if (tjsonAddDoubleToObject(pJson, "dbs_total", pInfo->dbs_total) != 0) uError("failed to add dbs_total");
-  (void)tjsonAddDoubleToObject(pJson, "vgroups_total", pInfo->vgroups_total);
+  if (tjsonAddDoubleToObject(pJson, "tbs_total", pInfo->tbs_total) != 0) uError("failed to add tbs_total");
-  (void)tjsonAddDoubleToObject(pJson, "vgroups_alive", pInfo->vgroups_alive);
+  if (tjsonAddDoubleToObject(pJson, "stbs_total", pInfo->stbs_total) != 0) uError("failed to add stbs_total");
-  (void)tjsonAddDoubleToObject(pJson, "vnodes_total", pInfo->vnodes_total);
+  if (tjsonAddDoubleToObject(pJson, "vgroups_total", pInfo->vgroups_total) != 0) uError("failed to add vgroups_total");
-  (void)tjsonAddDoubleToObject(pJson, "vnodes_alive", pInfo->vnodes_alive);
+  if (tjsonAddDoubleToObject(pJson, "vgroups_alive", pInfo->vgroups_alive) != 0) uError("failed to add vgroups_alive");
-  (void)tjsonAddDoubleToObject(pJson, "connections_total", pInfo->connections_total);
+  if (tjsonAddDoubleToObject(pJson, "vnodes_total", pInfo->vnodes_total) != 0) uError("failed to add vnodes_total");
-  (void)tjsonAddDoubleToObject(pJson, "topics_total", pInfo->topics_toal);
+  if (tjsonAddDoubleToObject(pJson, "vnodes_alive", pInfo->vnodes_alive) != 0) uError("failed to add vnodes_alive");
-  (void)tjsonAddDoubleToObject(pJson, "streams_total", pInfo->streams_total);
+  if (tjsonAddDoubleToObject(pJson, "connections_total", pInfo->connections_total) != 0)
+    uError("failed to add connections_total");
+  if (tjsonAddDoubleToObject(pJson, "topics_total", pInfo->topics_toal) != 0) uError("failed to add topics_total");
+  if (tjsonAddDoubleToObject(pJson, "streams_total", pInfo->streams_total) != 0) uError("failed to add streams_total");
 
   SJson *pDnodesJson = tjsonAddArrayToObject(pJson, "dnodes");
   if (pDnodesJson == NULL) return;
@@ -287,9 +295,9 @@ static void monGenClusterJson(SMonInfo *pMonitor) {
     if (pDnodeJson == NULL) continue;
 
     SMonDnodeDesc *pDnodeDesc = taosArrayGet(pInfo->dnodes, i);
-    (void)tjsonAddDoubleToObject(pDnodeJson, "dnode_id", pDnodeDesc->dnode_id);
+    if (tjsonAddDoubleToObject(pDnodeJson, "dnode_id", pDnodeDesc->dnode_id) != 0) uError("failed to add dnode_id");
-    (void)tjsonAddStringToObject(pDnodeJson, "dnode_ep", pDnodeDesc->dnode_ep);
+    if (tjsonAddStringToObject(pDnodeJson, "dnode_ep", pDnodeDesc->dnode_ep) != 0) uError("failed to add dnode_ep");
-    (void)tjsonAddStringToObject(pDnodeJson, "status", pDnodeDesc->status);
+    if (tjsonAddStringToObject(pDnodeJson, "status", pDnodeDesc->status) != 0) uError("failed to add status");
 
     if (tjsonAddItemToArray(pDnodesJson, pDnodeJson) != 0) tjsonDelete(pDnodeJson);
   }
@@ -302,9 +310,9 @@ static void monGenClusterJson(SMonInfo *pMonitor) {
     if (pMnodeJson == NULL) continue;
 
     SMonMnodeDesc *pMnodeDesc = taosArrayGet(pInfo->mnodes, i);
-    (void)tjsonAddDoubleToObject(pMnodeJson, "mnode_id", pMnodeDesc->mnode_id);
+    if (tjsonAddDoubleToObject(pMnodeJson, "mnode_id", pMnodeDesc->mnode_id) != 0) uError("failed to add mnode_id");
-    (void)tjsonAddStringToObject(pMnodeJson, "mnode_ep", pMnodeDesc->mnode_ep);
+    if (tjsonAddStringToObject(pMnodeJson, "mnode_ep", pMnodeDesc->mnode_ep) != 0) uError("failed to add mnode_ep");
-    (void)tjsonAddStringToObject(pMnodeJson, "role", pMnodeDesc->role);
+    if (tjsonAddStringToObject(pMnodeJson, "role", pMnodeDesc->role) != 0) uError("failed to add role");
 
     if (tjsonAddItemToArray(pMnodesJson, pMnodeJson) != 0) tjsonDelete(pMnodeJson);
   }
@@ -314,11 +322,11 @@ static void monGenClusterJsonBasic(SMonInfo *pMonitor) {
   SMonClusterInfo *pInfo = &pMonitor->mmInfo.cluster;
   if (pMonitor->mmInfo.cluster.first_ep_dnode_id == 0) return;
 
-  // (void)tjsonAddStringToObject(pMonitor->pJson, "first_ep", pInfo->first_ep);
+  if (tjsonAddStringToObject(pMonitor->pJson, "first_ep", tsFirst) != 0) uError("failed to add first_ep");
-  (void)tjsonAddStringToObject(pMonitor->pJson, "first_ep", tsFirst);
+  if (tjsonAddDoubleToObject(pMonitor->pJson, "first_ep_dnode_id", pInfo->first_ep_dnode_id) != 0)
-  (void)tjsonAddDoubleToObject(pMonitor->pJson, "first_ep_dnode_id", pInfo->first_ep_dnode_id);
+    uError("failed to add first_ep_dnode_id");
-  (void)tjsonAddStringToObject(pMonitor->pJson, "cluster_version", pInfo->version);
+  if (tjsonAddStringToObject(pMonitor->pJson, "cluster_version", pInfo->version) != 0)
-  // (void)tjsonAddDoubleToObject(pMonitor->pJson, "monitor_interval", pInfo->monitor_interval);
+    uError("failed to add cluster_version");
 }
 
 static void monGenVgroupJson(SMonInfo *pMonitor) {
@@ -337,10 +345,13 @@ static void monGenVgroupJson(SMonInfo *pMonitor) {
     }
 
     SMonVgroupDesc *pVgroupDesc = taosArrayGet(pInfo->vgroups, i);
-    (void)tjsonAddDoubleToObject(pVgroupJson, "vgroup_id", pVgroupDesc->vgroup_id);
+    if (tjsonAddDoubleToObject(pVgroupJson, "vgroup_id", pVgroupDesc->vgroup_id) != 0)
-    (void)tjsonAddStringToObject(pVgroupJson, "database_name", pVgroupDesc->database_name);
+      uError("failed to add vgroup_id");
-    (void)tjsonAddDoubleToObject(pVgroupJson, "tables_num", pVgroupDesc->tables_num);
+    if (tjsonAddStringToObject(pVgroupJson, "database_name", pVgroupDesc->database_name) != 0)
-    (void)tjsonAddStringToObject(pVgroupJson, "status", pVgroupDesc->status);
+      uError("failed to add database_name");
+    if (tjsonAddDoubleToObject(pVgroupJson, "tables_num", pVgroupDesc->tables_num) != 0)
+      uError("failed to add tables_num");
+    if (tjsonAddStringToObject(pVgroupJson, "status", pVgroupDesc->status) != 0) uError("failed to add status");
 
     SJson *pVnodesJson = tjsonAddArrayToObject(pVgroupJson, "vnodes");
     if (pVnodesJson == NULL) continue;
@@ -352,8 +363,9 @@ static void monGenVgroupJson(SMonInfo *pMonitor) {
       SJson *pVnodeJson = tjsonCreateObject();
       if (pVnodeJson == NULL) continue;
 
-      (void)tjsonAddDoubleToObject(pVnodeJson, "dnode_id", pVnodeDesc->dnode_id);
+      if (tjsonAddDoubleToObject(pVnodeJson, "dnode_id", pVnodeDesc->dnode_id) != 0) uError("failed to add dnode_id");
-      (void)tjsonAddStringToObject(pVnodeJson, "vnode_role", pVnodeDesc->vnode_role);
+      if (tjsonAddStringToObject(pVnodeJson, "vnode_role", pVnodeDesc->vnode_role) != 0)
+        uError("failed to add vnode_role");
 
       if (tjsonAddItemToArray(pVnodesJson, pVnodeJson) != 0) tjsonDelete(pVnodeJson);
     }
@@ -376,8 +388,9 @@ static void monGenStbJson(SMonInfo *pMonitor) {
     }
 
     SMonStbDesc *pStbDesc = taosArrayGet(pInfo->stbs, i);
-    (void)tjsonAddStringToObject(pStbJson, "stb_name", pStbDesc->stb_name);
+    if (tjsonAddStringToObject(pStbJson, "stb_name", pStbDesc->stb_name) != 0) uError("failed to add stb_name");
-    (void)tjsonAddStringToObject(pStbJson, "database_name", pStbDesc->database_name);
+    if (tjsonAddStringToObject(pStbJson, "database_name", pStbDesc->database_name) != 0)
+      uError("failed to add database_name");
   }
 }
 
@@ -392,9 +405,11 @@ static void monGenGrantJson(SMonInfo *pMonitor) {
     return;
   }
 
-  (void)tjsonAddDoubleToObject(pJson, "expire_time", pInfo->expire_time);
+  if (tjsonAddDoubleToObject(pJson, "expire_time", pInfo->expire_time) != 0) uError("failed to add expire_time");
-  (void)tjsonAddDoubleToObject(pJson, "timeseries_used", pInfo->timeseries_used);
+  if (tjsonAddDoubleToObject(pJson, "timeseries_used", pInfo->timeseries_used) != 0)
-  (void)tjsonAddDoubleToObject(pJson, "timeseries_total", pInfo->timeseries_total);
+    uError("failed to add timeseries_used");
+  if (tjsonAddDoubleToObject(pJson, "timeseries_total", pInfo->timeseries_total) != 0)
+    uError("failed to add timeseries_total");
 }
 
 static void monGenDnodeJson(SMonInfo *pMonitor) {
@@ -451,36 +466,40 @@ static void monGenDnodeJson(SMonInfo *pMonitor) {
   double io_read_disk_rate = io_read_disk / interval;
   double io_write_disk_rate = io_write_disk / interval;
 
-  (void)tjsonAddDoubleToObject(pJson, "uptime", pInfo->uptime);
+  if (tjsonAddDoubleToObject(pJson, "uptime", pInfo->uptime) != 0) uError("failed to add uptime");
-  (void)tjsonAddDoubleToObject(pJson, "cpu_engine", cpu_engine);
+  if (tjsonAddDoubleToObject(pJson, "cpu_engine", cpu_engine) != 0) uError("failed to add cpu_engine");
-  (void)tjsonAddDoubleToObject(pJson, "cpu_system", pSys->cpu_system);
+  if (tjsonAddDoubleToObject(pJson, "cpu_system", pSys->cpu_system) != 0) uError("failed to add cpu_system");
-  (void)tjsonAddDoubleToObject(pJson, "cpu_cores", pSys->cpu_cores);
+  if (tjsonAddDoubleToObject(pJson, "cpu_cores", pSys->cpu_cores) != 0) uError("failed to add cpu_cores");
-  (void)tjsonAddDoubleToObject(pJson, "mem_engine", mem_engine);
+  if (tjsonAddDoubleToObject(pJson, "mem_engine", mem_engine) != 0) uError("failed to add mem_engine");
-  (void)tjsonAddDoubleToObject(pJson, "mem_system", pSys->mem_system);
+  if (tjsonAddDoubleToObject(pJson, "mem_system", pSys->mem_system) != 0) uError("failed to add mem_system");
-  (void)tjsonAddDoubleToObject(pJson, "mem_total", pSys->mem_total);
+  if (tjsonAddDoubleToObject(pJson, "mem_total", pSys->mem_total) != 0) uError("failed to add mem_total");
-  (void)tjsonAddDoubleToObject(pJson, "disk_engine", pSys->disk_engine);
+  if (tjsonAddDoubleToObject(pJson, "disk_engine", pSys->disk_engine) != 0) uError("failed to add disk_engine");
-  (void)tjsonAddDoubleToObject(pJson, "disk_used", pSys->disk_used);
+  if (tjsonAddDoubleToObject(pJson, "disk_used", pSys->disk_used) != 0) uError("failed to add disk_used");
-  (void)tjsonAddDoubleToObject(pJson, "disk_total", pSys->disk_total);
+  if (tjsonAddDoubleToObject(pJson, "disk_total", pSys->disk_total) != 0) uError("failed to add disk_total");
-  (void)tjsonAddDoubleToObject(pJson, "net_in", net_in_rate);
+  if (tjsonAddDoubleToObject(pJson, "net_in", net_in_rate) != 0) uError("failed to add net_in");
-  (void)tjsonAddDoubleToObject(pJson, "net_out", net_out_rate);
+  if (tjsonAddDoubleToObject(pJson, "net_out", net_out_rate) != 0) uError("failed to add net_out");
-  (void)tjsonAddDoubleToObject(pJson, "io_read", io_read_rate);
+  if (tjsonAddDoubleToObject(pJson, "io_read", io_read_rate) != 0) uError("failed to add io_read");
-  (void)tjsonAddDoubleToObject(pJson, "io_write", io_write_rate);
+  if (tjsonAddDoubleToObject(pJson, "io_write", io_write_rate) != 0) uError("failed to add io_write");
-  (void)tjsonAddDoubleToObject(pJson, "io_read_disk", io_read_disk_rate);
+  if (tjsonAddDoubleToObject(pJson, "io_read_disk", io_read_disk_rate) != 0) uError("failed to add io_read_disk");
-  (void)tjsonAddDoubleToObject(pJson, "io_write_disk", io_write_disk_rate);
+  if (tjsonAddDoubleToObject(pJson, "io_write_disk", io_write_disk_rate) != 0) uError("failed to add io_write_disk");
-  (void)tjsonAddDoubleToObject(pJson, "req_select", pStat->numOfSelectReqs);
+  if (tjsonAddDoubleToObject(pJson, "req_select", pStat->numOfSelectReqs) != 0) uError("failed to add req_select");
-  (void)tjsonAddDoubleToObject(pJson, "req_select_rate", req_select_rate);
+  if (tjsonAddDoubleToObject(pJson, "req_select_rate", req_select_rate) != 0) uError("failed to add req_select_rate");
-  (void)tjsonAddDoubleToObject(pJson, "req_insert", pStat->numOfInsertReqs);
+  if (tjsonAddDoubleToObject(pJson, "req_insert", pStat->numOfInsertReqs) != 0) uError("failed to add req_insert");
-  (void)tjsonAddDoubleToObject(pJson, "req_insert_success", pStat->numOfInsertSuccessReqs);
+  if (tjsonAddDoubleToObject(pJson, "req_insert_success", pStat->numOfInsertSuccessReqs) != 0)
-  (void)tjsonAddDoubleToObject(pJson, "req_insert_rate", req_insert_rate);
+    uError("failed to add req_insert_success");
-  (void)tjsonAddDoubleToObject(pJson, "req_insert_batch", pStat->numOfBatchInsertReqs);
+  if (tjsonAddDoubleToObject(pJson, "req_insert_rate", req_insert_rate) != 0) uError("failed to add req_insert_rate");
-  (void)tjsonAddDoubleToObject(pJson, "req_insert_batch_success", pStat->numOfBatchInsertSuccessReqs);
+  if (tjsonAddDoubleToObject(pJson, "req_insert_batch", pStat->numOfBatchInsertReqs) != 0)
-  (void)tjsonAddDoubleToObject(pJson, "req_insert_batch_rate", req_insert_batch_rate);
+    uError("failed to add req_insert_batch");
-  (void)tjsonAddDoubleToObject(pJson, "errors", pStat->errors);
+  if (tjsonAddDoubleToObject(pJson, "req_insert_batch_success", pStat->numOfBatchInsertSuccessReqs) != 0)
-  (void)tjsonAddDoubleToObject(pJson, "vnodes_num", pStat->totalVnodes);
+    uError("failed to add req_insert_batch_success");
-  (void)tjsonAddDoubleToObject(pJson, "masters", pStat->masterNum);
+  if (tjsonAddDoubleToObject(pJson, "req_insert_batch_rate", req_insert_batch_rate) != 0)
-  (void)tjsonAddDoubleToObject(pJson, "has_mnode", pInfo->has_mnode);
+    uError("failed to add req_insert_batch_rate");
-  (void)tjsonAddDoubleToObject(pJson, "has_qnode", pInfo->has_qnode);
+  if (tjsonAddDoubleToObject(pJson, "errors", pStat->errors) != 0) uError("failed to add errors");
-  (void)tjsonAddDoubleToObject(pJson, "has_snode", pInfo->has_snode);
+  if (tjsonAddDoubleToObject(pJson, "vnodes_num", pStat->totalVnodes) != 0) uError("failed to add vnodes_num");
+  if (tjsonAddDoubleToObject(pJson, "masters", pStat->masterNum) != 0) uError("failed to add masters");
+  if (tjsonAddDoubleToObject(pJson, "has_mnode", pInfo->has_mnode) != 0) uError("failed to add has_mnode");
+  if (tjsonAddDoubleToObject(pJson, "has_qnode", pInfo->has_qnode) != 0) uError("failed to add has_qnode");
+  if (tjsonAddDoubleToObject(pJson, "has_snode", pInfo->has_snode) != 0) uError("failed to add has_snode");
 }
 
 static void monGenDiskJson(SMonInfo *pMonitor) {
@@ -515,18 +534,18 @@ static void monGenDiskJson(SMonInfo *pMonitor) {
   SJson *pLogdirJson = tjsonCreateObject();
   if (pLogdirJson == NULL) return;
   if (tjsonAddItemToObject(pJson, "logdir", pLogdirJson) != 0) return;
-  (void)tjsonAddStringToObject(pLogdirJson, "name", pLogDesc->name);
+  if (tjsonAddStringToObject(pLogdirJson, "name", pLogDesc->name) != 0) uError("failed to add string to json");
-  (void)tjsonAddDoubleToObject(pLogdirJson, "avail", pLogDesc->size.avail);
+  if (tjsonAddDoubleToObject(pLogdirJson, "avail", pLogDesc->size.avail) != 0) uError("failed to add double to json");
-  (void)tjsonAddDoubleToObject(pLogdirJson, "used", pLogDesc->size.used);
+  if (tjsonAddDoubleToObject(pLogdirJson, "used", pLogDesc->size.used) != 0) uError("failed to add double to json");
-  (void)tjsonAddDoubleToObject(pLogdirJson, "total", pLogDesc->size.total);
+  if (tjsonAddDoubleToObject(pLogdirJson, "total", pLogDesc->size.total) != 0) uError("failed to add double to json");
 
   SJson *pTempdirJson = tjsonCreateObject();
   if (pTempdirJson == NULL) return;
   if (tjsonAddItemToObject(pJson, "tempdir", pTempdirJson) != 0) return;
-  (void)tjsonAddStringToObject(pTempdirJson, "name", pTempDesc->name);
+  if (tjsonAddStringToObject(pTempdirJson, "name", pTempDesc->name) != 0) uError("failed to add string to json");
-  (void)tjsonAddDoubleToObject(pTempdirJson, "avail", pTempDesc->size.avail);
+  if (tjsonAddDoubleToObject(pTempdirJson, "avail", pTempDesc->size.avail) != 0) uError("failed to add double to json");
-  (void)tjsonAddDoubleToObject(pTempdirJson, "used", pTempDesc->size.used);
+  if (tjsonAddDoubleToObject(pTempdirJson, "used", pTempDesc->size.used) != 0) uError("failed to add double to json");
-  (void)tjsonAddDoubleToObject(pTempdirJson, "total", pTempDesc->size.total);
+  if (tjsonAddDoubleToObject(pTempdirJson, "total", pTempDesc->size.total) != 0) uError("failed to add double to json");
 }
 
 static const char *monLogLevelStr(ELogLevel level) {
@@ -571,26 +590,26 @@ static void monGenLogJson(SMonInfo *pMonitor) {
 
   SJson *pLogError = tjsonCreateObject();
   if (pLogError == NULL) return;
-  (void)tjsonAddStringToObject(pLogError, "level", "error");
+  if (tjsonAddStringToObject(pLogError, "level", "error") != 0) uError("failed to add string to json");
-  (void)tjsonAddDoubleToObject(pLogError, "total", numOfErrorLogs);
+  if (tjsonAddDoubleToObject(pLogError, "total", numOfErrorLogs) != 0) uError("failed to add double to json");
   if (tjsonAddItemToArray(pSummaryJson, pLogError) != 0) tjsonDelete(pLogError);
 
   SJson *pLogInfo = tjsonCreateObject();
   if (pLogInfo == NULL) return;
-  (void)tjsonAddStringToObject(pLogInfo, "level", "info");
+  if (tjsonAddStringToObject(pLogInfo, "level", "info") != 0) uError("failed to add string to json");
-  (void)tjsonAddDoubleToObject(pLogInfo, "total", numOfInfoLogs);
+  if (tjsonAddDoubleToObject(pLogInfo, "total", numOfInfoLogs) != 0) uError("failed to add double to json");
   if (tjsonAddItemToArray(pSummaryJson, pLogInfo) != 0) tjsonDelete(pLogInfo);
 
   SJson *pLogDebug = tjsonCreateObject();
   if (pLogDebug == NULL) return;
-  (void)tjsonAddStringToObject(pLogDebug, "level", "debug");
+  if (tjsonAddStringToObject(pLogDebug, "level", "debug") != 0) uError("failed to add string to json");
-  (void)tjsonAddDoubleToObject(pLogDebug, "total", numOfDebugLogs);
+  if (tjsonAddDoubleToObject(pLogDebug, "total", numOfDebugLogs) != 0) uError("failed to add double to json");
   if (tjsonAddItemToArray(pSummaryJson, pLogDebug) != 0) tjsonDelete(pLogDebug);
 
   SJson *pLogTrace = tjsonCreateObject();
   if (pLogTrace == NULL) return;
-  (void)tjsonAddStringToObject(pLogTrace, "level", "trace");
+  if (tjsonAddStringToObject(pLogTrace, "level", "trace") != 0) uError("failed to add string to json");
-  (void)tjsonAddDoubleToObject(pLogTrace, "total", numOfTraceLogs);
+  if (tjsonAddDoubleToObject(pLogTrace, "total", numOfTraceLogs) != 0) uError("failed to add double to json");
   if (tjsonAddItemToArray(pSummaryJson, pLogTrace) != 0) tjsonDelete(pLogTrace);
 }
 

source/libs/parser/src/parTranslater.c

@@ -14705,7 +14705,7 @@ static int32_t rewriteDropSuperTablewithOpt(STranslateContext* pCxt, SQuery* pQu
       break;
     }
     if (!isdigit(pStmt->tableName[i])) {
-      return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_TABLE_NOT_EXIST, "Table does not exist: `%s`.`%s`",
+      return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_TABLE_NOT_EXIST, "STable not exist: `%s`.`%s`",
                                      pStmt->dbName, pStmt->tableName);
     }
   }
@@ -14715,8 +14715,11 @@ static int32_t rewriteDropSuperTablewithOpt(STranslateContext* pCxt, SQuery* pQu
   toName(pCxt->pParseCxt->acctId, pStmt->dbName, pStmt->tableName, &name);
   code = getTargetName(pCxt, &name, pTableName);
   if (TSDB_CODE_SUCCESS != code) {
-    return generateSyntaxErrMsgExt(&pCxt->msgBuf, code, "%s: db:`%s`, tbuid:`%s`", tstrerror(code), pStmt->dbName,
+    return generateSyntaxErrMsgExt(&pCxt->msgBuf, code, "%s: db:`%s`, tbuid:`%s`",
-                                   pStmt->tableName);
+                                   (code == TSDB_CODE_PAR_TABLE_NOT_EXIST || code == TSDB_CODE_TDB_TABLE_NOT_EXIST)
+                                       ? "STable not exist"
+                                       : tstrerror(code),
+                                   pStmt->dbName, pStmt->tableName);
   }
   tstrncpy(pStmt->tableName, pTableName, TSDB_TABLE_NAME_LEN);  // rewrite table uid to table name
 

source/libs/transport/src/transCli.c

@@ -1634,7 +1634,7 @@ static void cliHandleFreeById(SCliMsg* pMsg, SCliThrd* pThrd) {
   int64_t    refId = (int64_t)(pMsg->msg.info.handle);
   SExHandle* exh = transAcquireExHandle(transGetRefMgt(), refId);
   if (exh == NULL) {
-    tDebug("id %" PRId64 " already released", refId);
+    tDebug("refId %" PRId64 " already released", refId);
     destroyCmsg(pMsg);
     return;
   }
@@ -1646,7 +1646,7 @@ static void cliHandleFreeById(SCliMsg* pMsg, SCliThrd* pThrd) {
   if (conn == NULL || conn->refId != refId) {
     TAOS_CHECK_GOTO(TSDB_CODE_REF_INVALID_ID, NULL, _exception);
   }
-  tDebug("do free conn %p by id %" PRId64 "", conn, refId);
+  tDebug("do free conn %p by refId %" PRId64 "", conn, refId);
 
   int32_t size = transQueueSize(&conn->cliMsgs);
   if (size == 0) {
@@ -3316,13 +3316,14 @@ int32_t transAllocHandle(int64_t* refId) {
 
   QUEUE_INIT(&exh->q);
   taosInitRWLatch(&exh->latch);
-  tDebug("pre alloc refId %" PRId64 "", exh->refId);
+  tDebug("pre alloc refId %" PRId64 ", alloc exhandle %p", exh->refId, exh);
   *refId = exh->refId;
   return 0;
 }
 int32_t transFreeConnById(void* shandle, int64_t transpointId) {
-  int32_t code = 0;
+  int32_t  code = 0;
-  STrans* pTransInst = (STrans*)transAcquireExHandle(transGetInstMgt(), (int64_t)shandle);
+  SCliMsg* pCli = NULL;
+  STrans*  pTransInst = (STrans*)transAcquireExHandle(transGetInstMgt(), (int64_t)shandle);
   if (pTransInst == NULL) {
     return TSDB_CODE_RPC_MODULE_QUIT;
   }
@@ -3336,7 +3337,7 @@ int32_t transFreeConnById(void* shandle, int64_t transpointId) {
     TAOS_CHECK_GOTO(TSDB_CODE_REF_INVALID_ID, NULL, _exception);
   }
 
-  SCliMsg* pCli = taosMemoryCalloc(1, sizeof(SCliMsg));
+  pCli = taosMemoryCalloc(1, sizeof(SCliMsg));
   if (pCli == NULL) {
     TAOS_CHECK_GOTO(terrno, NULL, _exception);
   }
@@ -3349,11 +3350,19 @@ int32_t transFreeConnById(void* shandle, int64_t transpointId) {
 
   code = transAsyncSend(pThrd->asyncPool, &pCli->q);
   if (code != 0) {
-    taosMemoryFree(pCli);
+    taosMemoryFreeClear(pCli);
     TAOS_CHECK_GOTO(code, NULL, _exception);
   }
 
 _exception:
   transReleaseExHandle(transGetInstMgt(), (int64_t)shandle);
+  if (code != 0) {
+    if (transpointId != 0) {
+      (void)transReleaseExHandle(transGetRefMgt(), transpointId);
+      (void)transRemoveExHandle(transGetRefMgt(), transpointId);
+    }
+    taosMemoryFree(pCli);
+  }
+
   return code;
 }

source/libs/transport/src/transComm.c

@@ -768,6 +768,7 @@ void transDestroyExHandle(void* handle) {
   if (!QUEUE_IS_EMPTY(&eh->q)) {
     tDebug("handle %p mem leak", handle);
   }
+  tDebug("free exhandle %p", handle);
   taosMemoryFree(handle);
 }
 

source/libs/wal/src/walMgmt.c

@@ -189,6 +189,7 @@ SWal *walOpen(const char *path, SWalCfg *pCfg) {
 
 _err:
   taosArrayDestroy(pWal->fileInfoSet);
+  taosArrayDestroy(pWal->toDeleteFiles);
   taosHashCleanup(pWal->pRefHash);
   TAOS_UNUSED(taosThreadRwlockDestroy(&pWal->mutex));
   taosMemoryFreeClear(pWal);

source/os/src/osSemaphore.c

@@ -232,7 +232,7 @@ int32_t tsem_init(tsem_t *psem, int flags, unsigned int count) {
   if(sem_init(psem, flags, count) == 0) {
     return 0;
   } else {
-    return TAOS_SYSTEM_ERROR(errno);
+    return terrno = TAOS_SYSTEM_ERROR(errno);
   }
 }
 

source/util/src/tqueue.c

@@ -224,7 +224,9 @@ int32_t taosWriteQitem(STaosQueue *queue, void *pItem) {
   (void)taosThreadMutexUnlock(&queue->mutex);
 
   if (queue->qset) {
-    (void)tsem_post(&queue->qset->sem);
+    if (tsem_post(&queue->qset->sem) != 0) {
+      uError("failed to post semaphore for queue set:%p", queue->qset);
+    }
   }
   return code;
 }
@@ -333,7 +335,10 @@ int32_t taosOpenQset(STaosQset **qset) {
   }
 
   (void)taosThreadMutexInit(&(*qset)->mutex, NULL);
-  (void)tsem_init(&(*qset)->sem, 0, 0);
+  if (tsem_init(&(*qset)->sem, 0, 0) != 0) {
+    taosMemoryFree(*qset);
+    return terrno;
+  }
 
   uDebug("qset:%p is opened", qset);
   return 0;
@@ -354,7 +359,9 @@ void taosCloseQset(STaosQset *qset) {
   (void)taosThreadMutexUnlock(&qset->mutex);
 
   (void)taosThreadMutexDestroy(&qset->mutex);
-  (void)tsem_destroy(&qset->sem);
+  if (tsem_destroy(&qset->sem) != 0) {
+    uError("failed to destroy semaphore for qset:%p", qset);
+  }
   taosMemoryFree(qset);
   uDebug("qset:%p is closed", qset);
 }
@@ -364,7 +371,9 @@ void taosCloseQset(STaosQset *qset) {
 // thread to exit.
 void taosQsetThreadResume(STaosQset *qset) {
   uDebug("qset:%p, it will exit", qset);
-  (void)tsem_post(&qset->sem);
+  if (tsem_post(&qset->sem) != 0) {
+    uError("failed to post semaphore for qset:%p", qset);
+  }
 }
 
 int32_t taosAddIntoQset(STaosQset *qset, STaosQueue *queue, void *ahandle) {
@@ -432,7 +441,9 @@ int32_t taosReadQitemFromQset(STaosQset *qset, void **ppItem, SQueueInfo *qinfo)
   STaosQnode *pNode = NULL;
   int32_t     code = 0;
 
-  (void)tsem_wait(&qset->sem);
+  if (tsem_wait(&qset->sem) != 0) {
+    uError("failed to wait semaphore for qset:%p", qset);
+  }
 
   (void)taosThreadMutexLock(&qset->mutex);
 
@@ -476,7 +487,9 @@ int32_t taosReadAllQitemsFromQset(STaosQset *qset, STaosQall *qall, SQueueInfo *
   STaosQueue *queue;
   int32_t     code = 0;
 
-  (void)tsem_wait(&qset->sem);
+  if (tsem_wait(&qset->sem) != 0) {
+    uError("failed to wait semaphore for qset:%p", qset);
+  }
   (void)taosThreadMutexLock(&qset->mutex);
 
   for (int32_t i = 0; i < qset->numOfQueues; ++i) {
@@ -510,7 +523,9 @@ int32_t taosReadAllQitemsFromQset(STaosQset *qset, STaosQall *qall, SQueueInfo *
 
       (void)atomic_sub_fetch_32(&qset->numOfItems, qall->numOfItems);
       for (int32_t j = 1; j < qall->numOfItems; ++j) {
-        (void)tsem_wait(&qset->sem);
+        if (tsem_wait(&qset->sem) != 0) {
+          uError("failed to wait semaphore for qset:%p", qset);
+        }
       }
     }
 

source/util/src/tworker.c

@@ -440,7 +440,8 @@ STaosQueue *tWWorkerAllocQueue(SWWorkerPool *pool, void *ahandle, FItems fp) {
     TdThreadAttr thAttr;
     (void)taosThreadAttrInit(&thAttr);
     (void)taosThreadAttrSetDetachState(&thAttr, PTHREAD_CREATE_JOINABLE);
-    if (taosThreadCreate(&worker->thread, &thAttr, (ThreadFp)tWWorkerThreadFp, worker) != 0) goto _OVER;
+    code = taosThreadCreate(&worker->thread, &thAttr, (ThreadFp)tWWorkerThreadFp, worker);
+    if ((code)) goto _OVER;
 
     uInfo("worker:%s:%d is launched, max:%d", pool->name, worker->id, pool->max);
     pool->nextId = (pool->nextId + 1) % pool->max;

tests/docs-examples-test/rust.sh

@@ -0,0 +1,87 @@
+#!/bin/bash
+
+set -e
+
+
+check_transactions() {
+    for i in {1..30}
+    do
+        output=$(taos -s "show transactions;")
+        if [[ $output == *"Query OK, 0 row(s)"* ]]; then
+            echo "Success: No transactions are in progress."
+            return 0
+        fi
+        sleep 1
+    done
+
+    echo "Error: Transactions are still in progress after 30 attempts."
+    return 1
+}
+
+reset_cache() {
+  response=$(curl --location -uroot:taosdata 'http://127.0.0.1:6041/rest/sql' --data 'reset query cache')
+
+  if [[ $response == \{\"code\":0* ]]; then
+    echo "Success: Query cache reset successfully."
+  else
+    echo "Error: Failed to reset query cache. Response: $response"
+    return 1
+  fi
+}
+
+taosd >>/dev/null 2>&1 &
+taosadapter >>/dev/null 2>&1 &
+
+sleep 5
+
+cd ../../docs/examples/rust/nativeexample
+
+cargo run --example connect
+
+cargo run --example createdb
+
+cargo run --example insert
+
+cargo run --example query
+
+taos -s "drop database if exists power"
+check_transactions || exit 1
+reset_cache || exit 1
+
+cargo run --example schemaless
+
+taos -s "drop database if exists power"
+check_transactions || exit 1
+reset_cache || exit 1
+
+
+cargo run --example stmt
+
+cargo run --example tmq
+
+
+
+cd ../restexample
+
+cargo run --example connect
+
+cargo run --example createdb
+
+cargo run --example insert
+
+cargo run --example query
+
+taos -s "drop database if exists power"
+check_transactions || exit 1
+reset_cache || exit 1
+taos -s "create database if not exists power"
+cargo run --example schemaless
+
+taos -s "drop database if exists power"
+check_transactions || exit 1
+reset_cache || exit 1
+
+
+cargo run --example stmt
+
+cargo run --example tmq

tests/parallel_test/cases.task

@@ -1559,3 +1559,4 @@
 #,,n,docs-examples-test,bash jdbc.sh
 #,,n,docs-examples-test,bash go.sh
 #,,n,docs-examples-test,bash test_R.sh
+

tests/pytest/util/csv.py

@@ -1,5 +1,6 @@
 import csv
 import os
+import platform
 
 class TDCsv:
     def __init__(self):
@@ -25,7 +26,11 @@ class TDCsv:
     @property
     def file(self):
         if self.file_name and self.file_path:
-            return os.path.join(self.file_path, self.file_name)
+            print(f"self.file_path {self.file_path}, self.file_name {self.file_name}")
+            csv_file = os.path.join(self.file_path, self.file_name)
+            if platform.system().lower() == 'windows':
+                csv_file = csv_file.replace("\\", "/")                         
+            return csv_file
         return None
     
     

tests/pytest/util/sql.py

@@ -24,26 +24,48 @@ from util.log import *
 from util.constant import *
 import ctypes
 import random
-# from datetime import timezone
+import datetime
 import time
+from tzlocal import get_localzone
 
 def _parse_ns_timestamp(timestr):
     dt_obj = datetime.datetime.strptime(timestr[:len(timestr)-3], "%Y-%m-%d %H:%M:%S.%f")
     tz = int(int((dt_obj-datetime.datetime.fromtimestamp(0,dt_obj.tzinfo)).total_seconds())*1e9) + int(dt_obj.microsecond * 1000) + int(timestr[-3:])
     return tz
 
-
 def _parse_datetime(timestr):
-    try:
+    # defined timestr formats
-        return datetime.datetime.strptime(timestr, '%Y-%m-%d %H:%M:%S.%f')
+    formats = [
-    except ValueError:
+        '%Y-%m-%d %H:%M:%S.%f%z',  # 包含微秒和时区偏移
-        pass
+        '%Y-%m-%d %H:%M:%S%z',      # 不包含微秒但包含时区偏移
-    try:
+        '%Y-%m-%d %H:%M:%S.%f',     # 包含微秒
-        return datetime.datetime.strptime(timestr, '%Y-%m-%d %H:%M:%S')
+        '%Y-%m-%d %H:%M:%S'         # 不包含微秒
-    except ValueError:
+    ]
-        pass
+    
+    for fmt in formats:
+        try:
+            # try to parse the string with the current format
+            dt = datetime.datetime.strptime(timestr, fmt)
+            # 如果字符串包含时区信息，则返回 aware 对象
+            # if sting contains timezone info, return aware object
+            if dt.tzinfo is not None:
+                return dt
+
+            else:
+            # if sting does not contain timezone info, assume it is in local timezone
+                # get local timezone
+                local_timezone = get_localzone()
+                # print("Timezone:", local_timezone)
+                return dt.replace(tzinfo=local_timezone)
+        except ValueError:
+            continue  # if the current format does not match, try the next format
+    
+    # 如果所有格式都不匹配，返回 None
+    # if none of the formats match, return 
+    raise ValueError(f"input format does not match. correct formats include: '{', '.join(formats)}'")
 
 class TDSql:
+
     def __init__(self):
         self.queryRows = 0
         self.queryCols = 0
@@ -408,6 +430,7 @@ class TDSql:
 
         if self.queryResult[row][col] != data:
             if self.cursor.istype(col, "TIMESTAMP"):
+                # tdLog.debug(f"self.queryResult[row][col]:{self.queryResult[row][col]}, data:{data},len(data):{len(data)}, isinstance(data,str) :{isinstance(data,str)}")
                 # suppose user want to check nanosecond timestamp if a longer data passed``
                 if isinstance(data,str) :
                     if (len(data) >= 28):
@@ -419,8 +442,9 @@ class TDSql:
                             args = (caller.filename, caller.lineno, self.sql, row, col, self.queryResult[row][col], data)
                             tdLog.exit("%s(%d) failed: sql:%s row:%d col:%d data:%s != expect:%s" % args)
                     else:
+                        # tdLog.info(f"datetime.timezone.utc:{datetime.timezone.utc},data:{data},_parse_datetime(data).astimezone(datetime.timezone.utc):{_parse_datetime(data).astimezone(datetime.timezone.utc)}")
                         if self.queryResult[row][col].astimezone(datetime.timezone.utc) == _parse_datetime(data).astimezone(datetime.timezone.utc):
-                            # tdLog.info(f"sql:{self.sql}, row:{row} col:{col} data:{self.queryResult[row][col]} == expect:{data}")
+                            # tdLog.info(f"sql:{self.sql}, row:{row} col:{col} data:{self.queryResult[row][col].astimezone(datetime.timezone.utc)} == expect:{_parse_datetime(data).astimezone(datetime.timezone.utc)}")
                             if(show):
                                tdLog.info("check successfully")
                         else:

tests/system-test/0-others/backquote_check.py

@@ -133,7 +133,7 @@ class TDTestCase:
     def run(self):
         self.topic_name_check()
         self.db_name_check()
-        if platform.system().lower() == 'windows':
+        if platform.system().lower() != 'windows':
             self.stream_name_check()
         self.table_name_check()
         self.view_name_check()

tests/system-test/0-others/test_hot_refresh_configurations.py

@@ -203,7 +203,7 @@ class TDTestCase:
                     assert str(v) == str(value)
         else:
             for v in values:
-                tdLog.debug("Set {} to {}".format(name, v))
+                tdLog.debug("Set client {} to {}".format(name, v))
                 tdSql.error(f'alter local "{name} {v}";')
 
     def svr_check(self, item, except_values=False):

tests/system-test/1-insert/composite_primary_key_insert.py

@@ -4,6 +4,7 @@ from util.log import *
 from util.sql import *
 from util.cases import *
 from util.csv import *
+import platform
 import os
 import taos
 import json
@@ -56,7 +57,6 @@ class TDTestCase:
         tdSql.init(conn.cursor(), True)
 
         self.testcasePath = os.path.split(__file__)[0]
-        self.testcasePath = self.testcasePath.replace('\\', '//')
         self.testcaseFilename = os.path.split(__file__)[-1]
         os.system("rm -rf %s/%s.sql" % (self.testcasePath,self.testcaseFilename))
         # tdSql.execute(f"insert into db4096.ctb00 file '{self.testcasePath}//tableColumn4096csvLength64k.csv'")

tests/system-test/1-insert/drop.py

@@ -54,6 +54,7 @@ class TDTestCase:
         self.ctb_names = [ f'ctb0', 'ctb1', f'aa\u00bf\u200bctb0', f'aa\u00bf\u200bctb1']
         self.ntb_names = [ f'ntb0', f'aa\u00bf\u200bntb0', f'ntb1', f'aa\u00bf\u200bntb1']
         self.vgroups_opt = f'vgroups 4'
+        self.err_dup_cnt = 5
     def insert_data(self,column_dict,tbname,row_num):
         insert_sql = self.setsql.set_insertsql(column_dict,tbname,self.binary_str,self.nchar_str)
         for i in range(row_num):
@@ -147,13 +148,31 @@ class TDTestCase:
             if i == 0:
                 dropTable = f'drop table with `{stb_result[1]}`.`{stb_result[10]}`,'
                 dropStable = f'drop stable with `{stb_result[1]}`.`{stb_result[10]}`,'
+                dropTableWithSpace = f'drop table with `{stb_result[1]}`.`{stb_result[10]} `,'
+                dropStableWithSpace = f'drop stable with `{stb_result[1]}`.` {stb_result[10]}`,'
+                dropStableNotExist = f'drop stable with `{stb_result[1]}`.`{stb_result[10]}_notexist`,'
+                for _ in range(self.err_dup_cnt):
+                    tdLog.info(dropTableWithSpace[:-1])
+                    tdSql.error(dropTableWithSpace[:-1], expectErrInfo="Table does not exist", fullMatched=False)
+                    tdLog.info(dropStableWithSpace[:-1])
+                    tdSql.error(dropStableWithSpace[:-1], expectErrInfo="STable not exist", fullMatched=False)
+                    tdLog.info(dropStableNotExist[:-1])
+                    tdSql.error(dropStableWithSpace[:-1], expectErrInfo="STable not exist", fullMatched=False)
             else:
                 dropTable += f'`{stb_result[1]}`.`{stb_result[10]}`,'
                 dropStable += f'`{stb_result[1]}`.`{stb_result[10]}`,'
-                tdLog.info(dropTable[:-1])
+                for _ in range(self.err_dup_cnt):
-                tdLog.info(dropStable[:-1])
+                    tdLog.info(dropTable[:-1])
-                tdSql.error(dropTable[:-1])
+                    tdLog.info(dropStable[:-1])
-                tdSql.error(dropStable[:-1])
+                    tdSql.error(dropTable[:-1], expectErrInfo="Cannot drop super table in batch")
+                    tdSql.error(dropStable[:-1], expectErrInfo="syntax error", fullMatched=False)
+                dropTableWithSpace += f'`{stb_result[1]}`.` {stb_result[10]}`,'
+                dropStableWithSpace += f'`{stb_result[1]}`.`{stb_result[10]} `,'
+                for _ in range(self.err_dup_cnt):
+                    tdLog.info(dropTableWithSpace[:-1])
+                    tdLog.info(dropStableWithSpace[:-1])
+                    tdSql.error(dropTableWithSpace[:-1], expectErrInfo="Table does not exist", fullMatched=False)
+                    tdSql.error(dropStableWithSpace[:-1], expectErrInfo="syntax error", fullMatched=False)
             i += 1
         i = 0
         for stb_result in result:
@@ -172,9 +191,10 @@ class TDTestCase:
         tdSql.checkRows(0)
         tdSql.query(f'select * from information_schema.ins_tables where db_name like "dbtest_%"')
         tdSql.checkRows(8)
-        tdSql.error(f'drop stable with information_schema.`ins_tables`;')
+        for _ in range(self.err_dup_cnt):
-        tdSql.error(f'drop stable with performance_schema.`perf_connections`;')
+            tdSql.error(f'drop stable with information_schema.`ins_tables`;', expectErrInfo="Cannot drop table of system database", fullMatched=False)
-        self.drop_table_check_end()    
+            tdSql.error(f'drop stable with performance_schema.`perf_connections`;', expectErrInfo="Cannot drop table of system database", fullMatched=False)
+        self.drop_table_check_end()
     def drop_table_with_check(self):
         self.drop_table_check_init()
         tdSql.query(f'select * from information_schema.ins_tables where db_name like "dbtest_%"')
@@ -196,8 +216,9 @@ class TDTestCase:
         tdSql.checkRows(0)
         tdSql.query(f'select * from information_schema.ins_stables where db_name like "dbtest_%"')
         tdSql.checkRows(2)
-        tdSql.error(f'drop table with information_schema.`ins_tables`;')
+        for _ in range(self.err_dup_cnt):
-        tdSql.error(f'drop table with performance_schema.`perf_connections`;')
+            tdSql.error(f'drop table with information_schema.`ins_tables`;', expectErrInfo="Cannot drop table of system database", fullMatched=False)
+            tdSql.error(f'drop table with performance_schema.`perf_connections`;', expectErrInfo="Cannot drop table of system database", fullMatched=False)
         self.drop_table_check_end()
     def drop_table_with_check_tsma(self):
         tdSql.execute(f'create database if not exists {self.dbname} {self.vgroups_opt}')
@@ -285,7 +306,7 @@ class TDTestCase:
         self.drop_table_with_check()
         self.drop_table_with_check_tsma()
         self.drop_topic_check()
-        if platform.system().lower() == 'windows':        
+        if platform.system().lower() != 'windows':        
             self.drop_stream_check()
         pass
     def stop(self):

tests/system-test/2-query/fill.py

@@ -1,6 +1,5 @@
 import queue
 import random
-from fabric2.runners import threading
 from pandas._libs import interval
 import taos
 import sys
@@ -9,6 +8,7 @@ from util.common import TDCom
 from util.log import *
 from util.sql import *
 from util.cases import *
+import threading
 
 
 

tests/system-test/2-query/normal.py

@@ -140,14 +140,14 @@ class TDTestCase:
         tdsql2 = tdCom.newTdSqlWithTimezone(timezone="UTC")
         tdsql2.query(f"select * from {dbname}.tzt")
         tdsql2.checkRows(1)
-        tdsql2.checkData(0, 0, "2018-09-17 01:00:00")
+        # checkData:The expected date and time is the local time zone of the machine where the test case is executed.
-        
+        tdsql2.checkData(0, 0, "2018-09-17 09:00:00")
-        
+
         tdsql2.execute(f'insert into {dbname}.tzt values({self.ts + 1000}, 2)')
         tdsql2.query(f"select * from {dbname}.tzt order by ts")
         tdsql2.checkRows(2)
-        tdsql2.checkData(0, 0, "2018-09-17 01:00:00")
+        tdsql2.checkData(0, 0, "2018-09-17 09:00:00")
-        tdsql2.checkData(1, 0, "2018-09-17 01:00:01")
+        tdsql2.checkData(1, 0, "2018-09-17 09:00:01")
         
         tdsql2 = tdCom.newTdSqlWithTimezone(timezone="Asia/Shanghai")
         tdsql2.query(f"select * from {dbname}.tzt order by ts")
@@ -160,7 +160,7 @@ class TDTestCase:
         tdSql.prepare()
         
         self.timeZoneTest()
-        self.inAndNotinTest()
+        # self.inAndNotinTest()
 
 
     def stop(self):
@@ -168,4 +168,5 @@ class TDTestCase:
         tdLog.success("%s successfully executed" % __file__)
 
 tdCases.addWindows(__file__, TDTestCase())
+
 tdCases.addLinux(__file__, TDTestCase())