From 23920e10c160628c6391000905fdad7d1032a0e7 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Wed, 12 Apr 2023 13:58:29 +0800
Subject: [PATCH 01/44] enh: optimize log perf

---
 source/libs/executor/src/executil.c |  4 ++--
 source/libs/executor/src/executor.c |  4 ++--
 source/libs/qworker/src/qwMsg.c     |  8 ++++----
 source/libs/qworker/src/qworker.c   |  2 +-
 source/util/src/tlog.c              | 14 +++++++++-----
 5 files changed, 18 insertions(+), 14 deletions(-)

diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index 7d318786ba..afd742fb6d 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -2040,7 +2040,7 @@ int32_t createScanTableListInfo(SScanPhysiNode* pScanNode, SNodeList* pGroupTags
 
   int64_t st1 = taosGetTimestampUs();
   pTaskInfo->cost.extractListTime = (st1 - st) / 1000.0;
-  qDebug("extract queried table list completed, %d tables, elapsed time:%.2f ms %s", numOfTables,
+  qError("extract queried table list completed, %d tables, elapsed time:%.2f ms %s", numOfTables,
          pTaskInfo->cost.extractListTime, idStr);
 
   if (numOfTables == 0) {
@@ -2054,7 +2054,7 @@ int32_t createScanTableListInfo(SScanPhysiNode* pScanNode, SNodeList* pGroupTags
   }
 
   pTaskInfo->cost.groupIdMapTime = (taosGetTimestampUs() - st1) / 1000.0;
-  qDebug("generate group id map completed, elapsed time:%.2f ms %s", pTaskInfo->cost.groupIdMapTime, idStr);
+  qError("generate group id map completed, elapsed time:%.2f ms %s", pTaskInfo->cost.groupIdMapTime, idStr);
 
   return TSDB_CODE_SUCCESS;
 }
diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c
index cd7a76f7ad..63828b0ca6 100644
--- a/source/libs/executor/src/executor.c
+++ b/source/libs/executor/src/executor.c
@@ -486,7 +486,7 @@ int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId,
   SExecTaskInfo** pTask = (SExecTaskInfo**)pTaskInfo;
   taosThreadOnce(&initPoolOnce, initRefPool);
 
-  qDebug("start to create task, TID:0x%" PRIx64 " QID:0x%" PRIx64 ", vgId:%d", taskId, pSubplan->id.queryId, vgId);
+  qError("start to create task, TID:0x%" PRIx64 " QID:0x%" PRIx64 ", vgId:%d", taskId, pSubplan->id.queryId, vgId);
 
   int32_t code = createExecTaskInfo(pSubplan, pTask, readHandle, taskId, vgId, sql, model);
   if (code != TSDB_CODE_SUCCESS) {
@@ -515,7 +515,7 @@ int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId,
     }
   }
 
-  qDebug("subplan task create completed, TID:0x%" PRIx64 " QID:0x%" PRIx64, taskId, pSubplan->id.queryId);
+  qError("subplan task create completed, TID:0x%" PRIx64 " QID:0x%" PRIx64, taskId, pSubplan->id.queryId);
 
 _error:
   // if failed to add ref for all tables in this query, abort current query
diff --git a/source/libs/qworker/src/qwMsg.c b/source/libs/qworker/src/qwMsg.c
index 1a3a740b34..3c6ba2da06 100644
--- a/source/libs/qworker/src/qwMsg.c
+++ b/source/libs/qworker/src/qwMsg.c
@@ -381,9 +381,9 @@ int32_t qWorkerPreprocessQueryMsg(void *qWorkerMgmt, SRpcMsg *pMsg, bool chkGran
   SQWMsg qwMsg = {
       .msgType = pMsg->msgType, .msg = msg.msg, .msgLen = msg.msgLen, .connInfo = pMsg->info};
 
-  QW_SCH_TASK_DLOG("prerocessQuery start, handle:%p, SQL:%s", pMsg->info.handle, msg.sql);
+  QW_SCH_TASK_ELOG("prerocessQuery start, handle:%p, SQL:%s", pMsg->info.handle, msg.sql);
   code = qwPreprocessQuery(QW_FPARAMS(), &qwMsg);
-  QW_SCH_TASK_DLOG("prerocessQuery end, handle:%p, code:%x", pMsg->info.handle, code);
+  QW_SCH_TASK_ELOG("prerocessQuery end, handle:%p, code:%x", pMsg->info.handle, code);
 
   tFreeSSubQueryMsg(&msg);
 
@@ -449,11 +449,11 @@ int32_t qWorkerProcessQueryMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int
   qwMsg.msgInfo.taskType = msg.taskType;
   qwMsg.msgInfo.needFetch = msg.needFetch;
 
-  QW_SCH_TASK_DLOG("processQuery start, node:%p, type:%s, handle:%p, SQL:%s", node, TMSG_INFO(pMsg->msgType),
+  QW_SCH_TASK_ELOG("processQuery start, node:%p, type:%s, handle:%p, SQL:%s", node, TMSG_INFO(pMsg->msgType),
                    pMsg->info.handle, msg.sql);
   code = qwProcessQuery(QW_FPARAMS(), &qwMsg, msg.sql);
   msg.sql = NULL;
-  QW_SCH_TASK_DLOG("processQuery end, node:%p, code:%x", node, code);
+  QW_SCH_TASK_ELOG("processQuery end, node:%p, code:%x", node, code);
 
   tFreeSSubQueryMsg(&msg);
 
diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c
index 92c7852dbc..a68cf981e3 100644
--- a/source/libs/qworker/src/qworker.c
+++ b/source/libs/qworker/src/qworker.c
@@ -138,7 +138,7 @@ int32_t qwSendQueryRsp(QW_FPARAMS_DEF, int32_t msgType, SQWTaskCtx *ctx, int32_t
   if ((!quickRsp) || QUERY_RSP_POLICY_QUICK == tsQueryRspPolicy) {
     if (!ctx->localExec) {
       qwBuildAndSendQueryRsp(msgType, &ctx->ctrlConnInfo, rspCode, ctx);
-      QW_TASK_DLOG("query msg rsped, handle:%p, code:%x - %s", ctx->ctrlConnInfo.handle, rspCode, tstrerror(rspCode));
+      QW_TASK_ELOG("query msg rsped, handle:%p, code:%x - %s", ctx->ctrlConnInfo.handle, rspCode, tstrerror(rspCode));
     }
 
     ctx->queryRsped = true;
diff --git a/source/util/src/tlog.c b/source/util/src/tlog.c
index bd9ea058b4..48e35f7af0 100644
--- a/source/util/src/tlog.c
+++ b/source/util/src/tlog.c
@@ -51,6 +51,7 @@ typedef struct {
   int32_t       stop;
   TdThread      asyncThread;
   TdThreadMutex buffMutex;
+  SRWLatch      buffLock;
 } SLogBuff;
 
 typedef struct {
@@ -569,7 +570,7 @@ static SLogBuff *taosLogBuffNew(int32_t bufSize) {
   pLogBuf->minBuffSize = bufSize / 10;
   pLogBuf->stop = 0;
 
-  if (taosThreadMutexInit(&LOG_BUF_MUTEX(pLogBuf), NULL) < 0) goto _err;
+  //if (taosThreadMutexInit(&LOG_BUF_MUTEX(pLogBuf), NULL) < 0) goto _err;
   // tsem_init(&(pLogBuf->buffNotEmpty), 0, 0);
 
   return pLogBuf;
@@ -599,12 +600,13 @@ static int32_t taosPushLogBuffer(SLogBuff *pLogBuf, const char *msg, int32_t msg
   int32_t        end = 0;
   int32_t        remainSize = 0;
   static int64_t lostLine = 0;
-  char           tmpBuf[128] = {0};
+  char           tmpBuf[128];
   int32_t        tmpBufLen = 0;
 
   if (pLogBuf == NULL || pLogBuf->stop) return -1;
 
-  taosThreadMutexLock(&LOG_BUF_MUTEX(pLogBuf));
+  //taosThreadMutexLock(&LOG_BUF_MUTEX(pLogBuf));
+  taosWLockLatch(&pLogBuf->buffLock);
   start = LOG_BUF_START(pLogBuf);
   end = LOG_BUF_END(pLogBuf);
 
@@ -618,7 +620,8 @@ static int32_t taosPushLogBuffer(SLogBuff *pLogBuf, const char *msg, int32_t msg
   if (remainSize <= msgLen || ((lostLine > 0) && (remainSize <= (msgLen + tmpBufLen)))) {
     lostLine++;
     tsAsyncLogLostLines++;
-    taosThreadMutexUnlock(&LOG_BUF_MUTEX(pLogBuf));
+    //taosThreadMutexUnlock(&LOG_BUF_MUTEX(pLogBuf));
+    taosWUnLockLatch(&pLogBuf->buffLock);
     return -1;
   }
 
@@ -639,7 +642,8 @@ static int32_t taosPushLogBuffer(SLogBuff *pLogBuf, const char *msg, int32_t msg
   }
   */
 
-  taosThreadMutexUnlock(&LOG_BUF_MUTEX(pLogBuf));
+  //taosThreadMutexUnlock(&LOG_BUF_MUTEX(pLogBuf));
+  taosWUnLockLatch(&pLogBuf->buffLock);
 
   return 0;
 }

From 772238428f06b5f7e61c0ff941d91298a1ebeac4 Mon Sep 17 00:00:00 2001
From: chenhaoran <haoran920c@163.com>
Date: Wed, 12 Apr 2023 13:59:45 +0800
Subject: [PATCH 02/44] fix: release version

---
 cmake/cmake.define | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/cmake/cmake.define b/cmake/cmake.define
index 10f2172541..8abd60252f 100644
--- a/cmake/cmake.define
+++ b/cmake/cmake.define
@@ -120,8 +120,10 @@ ELSE ()
         SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fsanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=shift-base -fno-sanitize=alignment -g3 -Wformat=0")
 	      MESSAGE(STATUS "Compile with Address Sanitizer!")
     ELSE ()
-        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -gdwarf-2 -g3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -g3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
+        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -O3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
+        #SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -gdwarf-2 -g3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-literal-suffix -Werror=return-type -fPIC -O3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
+        #SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -g3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
     ENDIF ()
 
     # disable all assert

From ba1219303bfdb1cc0bf34a39ba5128390370cf73 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Wed, 12 Apr 2023 15:48:18 +0800
Subject: [PATCH 03/44] fix: add debug info

---
 source/client/inc/clientLog.h               |  1 +
 source/client/src/clientImpl.c              |  2 +-
 source/client/src/clientMain.c              |  2 +-
 source/libs/catalog/src/catalog.c           |  2 ++
 source/libs/catalog/src/ctgAsync.c          |  2 +-
 source/libs/catalog/src/ctgRemote.c         |  2 +-
 source/libs/executor/src/exchangeoperator.c |  2 +-
 source/libs/scheduler/src/schJob.c          |  4 ++--
 source/libs/scheduler/src/schRemote.c       |  4 ++--
 source/libs/scheduler/src/schTask.c         |  2 +-
 source/libs/scheduler/src/scheduler.c       |  4 ++--
 source/libs/transport/src/transCli.c        |  4 ++--
 source/libs/transport/src/transSvr.c        | 10 +++++-----
 13 files changed, 22 insertions(+), 19 deletions(-)

diff --git a/source/client/inc/clientLog.h b/source/client/inc/clientLog.h
index 908e470830..d213abd6f7 100644
--- a/source/client/inc/clientLog.h
+++ b/source/client/inc/clientLog.h
@@ -25,6 +25,7 @@ extern "C" {
 // clang-format off
 #define tscFatal(...)  do { if (cDebugFlag & DEBUG_FATAL) { taosPrintLog("TSC FATAL ", DEBUG_FATAL, cDebugFlag, __VA_ARGS__); }} while(0)
 #define tscError(...)  do { if (cDebugFlag & DEBUG_ERROR) { taosPrintLog("TSC ERROR ", DEBUG_ERROR, cDebugFlag, __VA_ARGS__); }} while(0)
+#define tscErrorL(...) do { if (cDebugFlag & DEBUG_ERROR) { taosPrintLongString("TSC ERROR ", DEBUG_ERROR, cDebugFlag, __VA_ARGS__); }} while(0)
 #define tscWarn(...)   do { if (cDebugFlag & DEBUG_WARN)  { taosPrintLog("TSC WARN ", DEBUG_WARN, cDebugFlag, __VA_ARGS__); }}  while(0)
 #define tscWarnL(...)  do { if (cDebugFlag & DEBUG_WARN)  { taosPrintLongString("TSC WARN ", DEBUG_WARN, cDebugFlag, __VA_ARGS__); }}  while(0)
 #define tscInfo(...)   do { if (cDebugFlag & DEBUG_INFO)  { taosPrintLog("TSC ", DEBUG_INFO, cDebugFlag, __VA_ARGS__); }} while(0)
diff --git a/source/client/src/clientImpl.c b/source/client/src/clientImpl.c
index 9e5d9080b4..949fe56862 100644
--- a/source/client/src/clientImpl.c
+++ b/source/client/src/clientImpl.c
@@ -233,7 +233,7 @@ int32_t buildRequest(uint64_t connId, const char* sql, int sqlLen, void* param,
     }
   }
 
-  tscDebugL("0x%" PRIx64 " SQL: %s, reqId:0x%" PRIx64, (*pRequest)->self, (*pRequest)->sqlstr, (*pRequest)->requestId);
+  tscErrorL("0x%" PRIx64 " SQL: %s, reqId:0x%" PRIx64, (*pRequest)->self, (*pRequest)->sqlstr, (*pRequest)->requestId);
   return TSDB_CODE_SUCCESS;
 }
 
diff --git a/source/client/src/clientMain.c b/source/client/src/clientMain.c
index 4fdc6081e5..023d2584ec 100644
--- a/source/client/src/clientMain.c
+++ b/source/client/src/clientMain.c
@@ -760,7 +760,7 @@ static void doAsyncQueryFromAnalyse(SMetaData *pResultMeta, void *param, int32_t
 
   int64_t analyseStart = taosGetTimestampUs();
   pRequest->metric.ctgCostUs = analyseStart - pRequest->metric.ctgStart;
-  qDebug("0x%" PRIx64 " start to semantic analysis, reqId:0x%" PRIx64, pRequest->self, pRequest->requestId);
+  qError("0x%" PRIx64 " start to semantic analysis, reqId:0x%" PRIx64, pRequest->self, pRequest->requestId);
 
   if (code == TSDB_CODE_SUCCESS) {
     code = qAnalyseSqlSemantic(pWrapper->pParseCtx, pWrapper->pCatalogReq, pResultMeta, pQuery);
diff --git a/source/libs/catalog/src/catalog.c b/source/libs/catalog/src/catalog.c
index f4549417f0..6ef659b059 100644
--- a/source/libs/catalog/src/catalog.c
+++ b/source/libs/catalog/src/catalog.c
@@ -1262,6 +1262,8 @@ int32_t catalogAsyncGetAllMeta(SCatalog* pCtg, SRequestConnInfo* pConn, const SC
     CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
   }
 
+  ctgError("%s", "catalog start async get all metas");
+
   int32_t  code = 0;
   SCtgJob* pJob = NULL;
   CTG_ERR_JRET(ctgInitJob(pCtg, pConn, &pJob, pReq, fp, param));
diff --git a/source/libs/catalog/src/ctgAsync.c b/source/libs/catalog/src/ctgAsync.c
index 92ac33a566..5e83de70b4 100644
--- a/source/libs/catalog/src/ctgAsync.c
+++ b/source/libs/catalog/src/ctgAsync.c
@@ -894,7 +894,7 @@ _return:
 int32_t ctgCallUserCb(void* param) {
   SCtgJob* pJob = (SCtgJob*)param;
 
-  qDebug("QID:0x%" PRIx64 " ctg start to call user cb with rsp %s", pJob->queryId, tstrerror(pJob->jobResCode));
+  qError("QID:0x%" PRIx64 " ctg start to call user cb with rsp %s", pJob->queryId, tstrerror(pJob->jobResCode));
 
   (*pJob->userFp)(&pJob->jobRes, pJob->userParam, pJob->jobResCode);
 
diff --git a/source/libs/catalog/src/ctgRemote.c b/source/libs/catalog/src/ctgRemote.c
index 3b037e2062..d22fae6a40 100644
--- a/source/libs/catalog/src/ctgRemote.c
+++ b/source/libs/catalog/src/ctgRemote.c
@@ -627,7 +627,7 @@ int32_t ctgLaunchBatchs(SCatalog* pCtg, SCtgJob* pJob, SHashObj* pBatchs) {
     SCtgBatch* pBatch = (SCtgBatch*)p;
     int32_t msgSize = 0;
 
-    ctgDebug("QID:0x%" PRIx64 " ctg start to launch batch %d", pJob->queryId, pBatch->batchId);
+    ctgError("QID:0x%" PRIx64 " ctg start to launch batch %d", pJob->queryId, pBatch->batchId);
 
     CTG_ERR_JRET(ctgBuildBatchReqMsg(pBatch, *vgId, &msg, &msgSize));
     code = ctgAsyncSendMsg(pCtg, &pBatch->conn, pJob, pBatch->pTaskIds, pBatch->batchId, pBatch->pMsgIdxs,
diff --git a/source/libs/executor/src/exchangeoperator.c b/source/libs/executor/src/exchangeoperator.c
index c855a104b2..326d2c43c5 100644
--- a/source/libs/executor/src/exchangeoperator.c
+++ b/source/libs/executor/src/exchangeoperator.c
@@ -449,7 +449,7 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas
       return pTaskInfo->code;
     }
 
-    qDebug("%s build fetch msg and send to vgId:%d, ep:%s, taskId:0x%" PRIx64 ", execId:%d, %p, %d/%" PRIzu,
+    qError("%s build fetch msg and send to vgId:%d, ep:%s, taskId:0x%" PRIx64 ", execId:%d, %p, %d/%" PRIzu,
            GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->addr.epSet.eps[0].fqdn, pSource->taskId,
            pSource->execId, pExchangeInfo, sourceIndex, totalSources);
 
diff --git a/source/libs/scheduler/src/schJob.c b/source/libs/scheduler/src/schJob.c
index e7bfe95795..b8269eb3cb 100644
--- a/source/libs/scheduler/src/schJob.c
+++ b/source/libs/scheduler/src/schJob.c
@@ -452,7 +452,7 @@ int32_t schNotifyUserFetchRes(SSchJob *pJob) {
 
   schDumpJobFetchRes(pJob, &pRes);
 
-  SCH_JOB_DLOG("sch start to invoke fetch cb, code: %s", tstrerror(pJob->errCode));
+  SCH_JOB_ELOG("sch start to invoke fetch cb, code: %s", tstrerror(pJob->errCode));
   (*pJob->userRes.fetchFp)(pRes, pJob->userRes.cbParam, atomic_load_32(&pJob->errCode));
   SCH_JOB_DLOG("sch end from fetch cb, code: %s", tstrerror(pJob->errCode));
 
@@ -811,7 +811,7 @@ int32_t schExecJob(SSchJob *pJob, SSchedulerReq *pReq) {
     tsem_wait(&pJob->rspSem);
   }
 
-  SCH_JOB_DLOG("job exec done, job status:%s, jobId:0x%" PRIx64, SCH_GET_JOB_STATUS_STR(pJob), pJob->refId);
+  SCH_JOB_ELOG("job exec done, job status:%s, jobId:0x%" PRIx64, SCH_GET_JOB_STATUS_STR(pJob), pJob->refId);
 
   return TSDB_CODE_SUCCESS;
 }
diff --git a/source/libs/scheduler/src/schRemote.c b/source/libs/scheduler/src/schRemote.c
index 80fdc7594c..f2bb583075 100644
--- a/source/libs/scheduler/src/schRemote.c
+++ b/source/libs/scheduler/src/schRemote.c
@@ -923,10 +923,10 @@ int32_t schAsyncSendMsg(SSchJob *pJob, SSchTask *pTask, SSchTrans *trans, SQuery
   SCH_ERR_JRET(schUpdateSendTargetInfo(pMsgSendInfo, addr, pTask));
 
   if (pJob && pTask) {
-    SCH_TASK_DLOG("start to send %s msg to node[%d,%s,%d], pTrans:%p, pHandle:%p", TMSG_INFO(msgType), addr->nodeId,
+    SCH_TASK_ELOG("start to send %s msg to node[%d,%s,%d], pTrans:%p, pHandle:%p", TMSG_INFO(msgType), addr->nodeId,
            epSet->eps[epSet->inUse].fqdn, epSet->eps[epSet->inUse].port, trans->pTrans, trans->pHandle);
   } else {
-    qDebug("start to send %s msg to node[%d,%s,%d], pTrans:%p, pHandle:%p", TMSG_INFO(msgType), addr->nodeId,
+    qError("start to send %s msg to node[%d,%s,%d], pTrans:%p, pHandle:%p", TMSG_INFO(msgType), addr->nodeId,
            epSet->eps[epSet->inUse].fqdn, epSet->eps[epSet->inUse].port, trans->pTrans, trans->pHandle);
   }
   
diff --git a/source/libs/scheduler/src/schTask.c b/source/libs/scheduler/src/schTask.c
index 207753ae25..7e9d672139 100644
--- a/source/libs/scheduler/src/schTask.c
+++ b/source/libs/scheduler/src/schTask.c
@@ -1064,7 +1064,7 @@ int32_t schLaunchTaskImpl(void *param) {
   pTask->retryTimes++;
   pTask->waitRetry = false;
 
-  SCH_TASK_DLOG("start to launch %s task, execId %d, retry %d",
+  SCH_TASK_ELOG("start to launch %s task, execId %d, retry %d",
                 SCH_IS_LOCAL_EXEC_TASK(pJob, pTask) ? "LOCAL" : "REMOTE", pTask->execId, pTask->retryTimes);
 
   SCH_LOG_TASK_START_TS(pTask);
diff --git a/source/libs/scheduler/src/scheduler.c b/source/libs/scheduler/src/scheduler.c
index e7561ccb7e..c4fefb4862 100644
--- a/source/libs/scheduler/src/scheduler.c
+++ b/source/libs/scheduler/src/scheduler.c
@@ -67,7 +67,7 @@ int32_t schedulerInit() {
 }
 
 int32_t schedulerExecJob(SSchedulerReq *pReq, int64_t *pJobId) {
-  qDebug("scheduler %s exec job start", pReq->syncReq ? "SYNC" : "ASYNC");
+  qError("scheduler %s exec job start", pReq->syncReq ? "SYNC" : "ASYNC");
 
   int32_t  code = 0;
   SSchJob *pJob = NULL;
@@ -86,7 +86,7 @@ _return:
 }
 
 int32_t schedulerFetchRows(int64_t jobId, SSchedulerReq *pReq) {
-  qDebug("scheduler %s fetch rows start", pReq->syncReq ? "SYNC" : "ASYNC");
+  qError("scheduler %s fetch rows start", pReq->syncReq ? "SYNC" : "ASYNC");
 
   int32_t  code = 0;
   SSchJob *pJob = NULL;
diff --git a/source/libs/transport/src/transCli.c b/source/libs/transport/src/transCli.c
index c23d6d0a1f..add700c024 100644
--- a/source/libs/transport/src/transCli.c
+++ b/source/libs/transport/src/transCli.c
@@ -426,7 +426,7 @@ void cliHandleResp(SCliConn* conn) {
   }
 
   STraceId* trace = &transMsg.info.traceId;
-  tGDebug("%s conn %p %s received from %s, local info:%s, len:%d, code str:%s", CONN_GET_INST_LABEL(conn), conn,
+  tGError("%s conn %p %s received from %s, local info:%s, len:%d, code str:%s", CONN_GET_INST_LABEL(conn), conn,
           TMSG_INFO(pHead->msgType), conn->dst, conn->src, pHead->msgLen, tstrerror(transMsg.code));
 
   if (pCtx == NULL && CONN_NO_PERSIST_BY_APP(conn)) {
@@ -1105,7 +1105,7 @@ void cliSend(SCliConn* pConn) {
     msgLen = (int32_t)ntohl((uint32_t)(pHead->msgLen));
   }
 
-  tGDebug("%s conn %p %s is sent to %s, local info %s, len:%d", CONN_GET_INST_LABEL(pConn), pConn,
+  tGError("%s conn %p %s is sent to %s, local info %s, len:%d", CONN_GET_INST_LABEL(pConn), pConn,
           TMSG_INFO(pHead->msgType), pConn->dst, pConn->src, msgLen);
 
   uv_buf_t    wb = uv_buf_init((char*)pHead, msgLen);
diff --git a/source/libs/transport/src/transSvr.c b/source/libs/transport/src/transSvr.c
index 28fb474972..34787fa96d 100644
--- a/source/libs/transport/src/transSvr.c
+++ b/source/libs/transport/src/transSvr.c
@@ -236,19 +236,19 @@ static bool uvHandleReq(SSvrConn* pConn) {
   if (pConn->status == ConnNormal && pHead->noResp == 0) {
     transRefSrvHandle(pConn);
     if (cost >= EXCEPTION_LIMIT_US) {
-      tGWarn("%s conn %p %s received from %s, local info:%s, len:%d, cost:%dus, recv exception", transLabel(pTransInst),
+      tGError("%s conn %p %s received from %s, local info:%s, len:%d, cost:%dus, recv exception", transLabel(pTransInst),
              pConn, TMSG_INFO(transMsg.msgType), pConn->dst, pConn->src, msgLen, (int)cost);
     } else {
-      tGDebug("%s conn %p %s received from %s, local info:%s, len:%d, cost:%dus", transLabel(pTransInst), pConn,
+      tGError("%s conn %p %s received from %s, local info:%s, len:%d, cost:%dus", transLabel(pTransInst), pConn,
               TMSG_INFO(transMsg.msgType), pConn->dst, pConn->src, msgLen, (int)cost);
     }
   } else {
     if (cost >= EXCEPTION_LIMIT_US) {
-      tGWarn("%s conn %p %s received from %s, local info:%s, len:%d, noResp:%d, code:%d, cost:%dus, recv exception",
+      tGError("%s conn %p %s received from %s, local info:%s, len:%d, noResp:%d, code:%d, cost:%dus, recv exception",
              transLabel(pTransInst), pConn, TMSG_INFO(transMsg.msgType), pConn->dst, pConn->src, msgLen, pHead->noResp,
              transMsg.code, (int)(cost));
     } else {
-      tGDebug("%s conn %p %s received from %s, local info:%s, len:%d, noResp:%d, code:%d, cost:%dus",
+      tGError("%s conn %p %s received from %s, local info:%s, len:%d, noResp:%d, code:%d, cost:%dus",
               transLabel(pTransInst), pConn, TMSG_INFO(transMsg.msgType), pConn->dst, pConn->src, msgLen, pHead->noResp,
               transMsg.code, (int)(cost));
     }
@@ -447,7 +447,7 @@ static int uvPrepareSendData(SSvrMsg* smsg, uv_buf_t* wb) {
   }
 
   STraceId* trace = &pMsg->info.traceId;
-  tGDebug("%s conn %p %s is sent to %s, local info:%s, len:%d", transLabel(pTransInst), pConn,
+  tGError("%s conn %p %s is sent to %s, local info:%s, len:%d", transLabel(pTransInst), pConn,
           TMSG_INFO(pHead->msgType), pConn->dst, pConn->src, len);
 
   wb->base = (char*)pHead;

From 7f518ca4eada06490f49d8a9fed68b8a28c3c94e Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Thu, 13 Apr 2023 10:54:57 +0800
Subject: [PATCH 04/44] feat: support cache db cfg

---
 include/common/tmsg.h                     |   4 +
 include/libs/catalog/catalog.h            |   8 +-
 include/libs/qcom/query.h                 |   1 +
 source/client/src/clientHb.c              |   6 +-
 source/common/src/tmsg.c                  |   4 +
 source/dnode/mnode/impl/inc/mndDb.h       |   2 +-
 source/dnode/mnode/impl/src/mndDb.c       |   6 +-
 source/dnode/mnode/impl/src/mndProfile.c  |   2 +-
 source/libs/catalog/inc/catalogInt.h      |  38 ++++--
 source/libs/catalog/src/catalog.c         |  23 +++-
 source/libs/catalog/src/ctgAsync.c        |  22 ++-
 source/libs/catalog/src/ctgCache.c        | 156 +++++++++++++++++++++-
 source/libs/catalog/src/ctgUtil.c         |  20 +--
 source/libs/catalog/test/catalogTests.cpp |   8 +-
 source/libs/qcom/src/queryUtil.c          |   8 ++
 source/util/src/tarray.c                  |   2 +-
 16 files changed, 265 insertions(+), 45 deletions(-)

diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index 66925471fb..40d38e9348 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -939,6 +939,8 @@ int32_t tSerializeSVDropTtlTableReq(void* buf, int32_t bufLen, SVDropTtlTableReq
 int32_t tDeserializeSVDropTtlTableReq(void* buf, int32_t bufLen, SVDropTtlTableReq* pReq);
 
 typedef struct {
+  int64_t dbId;
+  int32_t cfgVersion;
   int32_t numOfVgroups;
   int32_t numOfStables;
   int32_t buffer;
@@ -971,6 +973,8 @@ typedef struct {
   int16_t sstTrigger;
 } SDbCfgRsp;
 
+typedef SDbCfgRsp     SDbCfgInfo;
+
 int32_t tSerializeSDbCfgRsp(void* buf, int32_t bufLen, const SDbCfgRsp* pRsp);
 int32_t tDeserializeSDbCfgRsp(void* buf, int32_t bufLen, SDbCfgRsp* pRsp);
 
diff --git a/include/libs/catalog/catalog.h b/include/libs/catalog/catalog.h
index 2c684f8f76..cbc3f94daf 100644
--- a/include/libs/catalog/catalog.h
+++ b/include/libs/catalog/catalog.h
@@ -127,13 +127,14 @@ typedef struct SSTableVersion {
   int32_t  smaVer;
 } SSTableVersion;
 
-typedef struct SDbVgVersion {
+typedef struct SDbCacheInfo {
   char    dbFName[TSDB_DB_FNAME_LEN];
   int64_t dbId;
   int32_t vgVersion;
+  int32_t cfgVersion;
   int32_t numOfTable;  // unit is TSDB_TABLE_NUM_UNIT
   int64_t stateTs;
-} SDbVgVersion;
+} SDbCacheInfo;
 
 typedef struct STbSVersion {
   char*   tbFName;
@@ -146,7 +147,6 @@ typedef struct SUserAuthVersion {
   int32_t version;
 } SUserAuthVersion;
 
-typedef SDbCfgRsp     SDbCfgInfo;
 typedef SUserIndexRsp SIndexInfo;
 
 typedef void (*catalogCallback)(SMetaData* pResult, void* param, int32_t code);
@@ -302,7 +302,7 @@ int32_t catalogGetDnodeList(SCatalog* pCatalog, SRequestConnInfo* pConn, SArray*
 
 int32_t catalogGetExpiredSTables(SCatalog* pCatalog, SSTableVersion** stables, uint32_t* num);
 
-int32_t catalogGetExpiredDBs(SCatalog* pCatalog, SDbVgVersion** dbs, uint32_t* num);
+int32_t catalogGetExpiredDBs(SCatalog* pCatalog, SDbCacheInfo** dbs, uint32_t* num);
 
 int32_t catalogGetExpiredUsers(SCatalog* pCtg, SUserAuthVersion** users, uint32_t* num);
 
diff --git a/include/libs/qcom/query.h b/include/libs/qcom/query.h
index b6ada5a0c7..87619ab2a5 100644
--- a/include/libs/qcom/query.h
+++ b/include/libs/qcom/query.h
@@ -259,6 +259,7 @@ int32_t cloneTableMeta(STableMeta* pSrc, STableMeta** pDst);
 int32_t cloneDbVgInfo(SDBVgInfo* pSrc, SDBVgInfo** pDst);
 int32_t cloneSVreateTbReq(SVCreateTbReq* pSrc, SVCreateTbReq** pDst);
 void    freeVgInfo(SDBVgInfo* vgInfo);
+void    freeDbCfgInfo(SDbCfgInfo *pInfo);
 
 extern int32_t (*queryBuildMsg[TDMT_MAX])(void* input, char** msg, int32_t msgSize, int32_t* msgLen,
                                           void* (*mallocFp)(int64_t));
diff --git a/source/client/src/clientHb.c b/source/client/src/clientHb.c
index c9c2e7a5f8..622ddd21ec 100644
--- a/source/client/src/clientHb.c
+++ b/source/client/src/clientHb.c
@@ -510,7 +510,7 @@ int32_t hbGetExpiredUserInfo(SClientHbKey *connKey, struct SCatalog *pCatalog, S
 }
 
 int32_t hbGetExpiredDBInfo(SClientHbKey *connKey, struct SCatalog *pCatalog, SClientHbReq *req) {
-  SDbVgVersion *dbs = NULL;
+  SDbCacheInfo *dbs = NULL;
   uint32_t      dbNum = 0;
   int32_t       code = 0;
 
@@ -525,7 +525,7 @@ int32_t hbGetExpiredDBInfo(SClientHbKey *connKey, struct SCatalog *pCatalog, SCl
   }
 
   for (int32_t i = 0; i < dbNum; ++i) {
-    SDbVgVersion *db = &dbs[i];
+    SDbCacheInfo *db = &dbs[i];
     tscDebug("the %dth expired dbFName:%s, dbId:%" PRId64 ", vgVersion:%d, numOfTable:%d, startTs:%" PRId64, 
       i, db->dbFName, db->dbId, db->vgVersion, db->numOfTable, db->stateTs);
 
@@ -537,7 +537,7 @@ int32_t hbGetExpiredDBInfo(SClientHbKey *connKey, struct SCatalog *pCatalog, SCl
 
   SKv kv = {
       .key = HEARTBEAT_KEY_DBINFO,
-      .valueLen = sizeof(SDbVgVersion) * dbNum,
+      .valueLen = sizeof(SDbCacheInfo) * dbNum,
       .value = dbs,
   };
 
diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c
index 5f605c80f7..75fad6ede5 100644
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -2998,6 +2998,8 @@ int32_t tSerializeSDbCfgRsp(void *buf, int32_t bufLen, const SDbCfgRsp *pRsp) {
   tEncoderInit(&encoder, buf, bufLen);
 
   if (tStartEncode(&encoder) < 0) return -1;
+  if (tEncodeI64(&encoder, pRsp->dbId) < 0) return -1;
+  if (tEncodeI32(&encoder, pRsp->cfgVersion) < 0) return -1;
   if (tEncodeI32(&encoder, pRsp->numOfVgroups) < 0) return -1;
   if (tEncodeI32(&encoder, pRsp->numOfStables) < 0) return -1;
   if (tEncodeI32(&encoder, pRsp->buffer) < 0) return -1;
@@ -3045,6 +3047,8 @@ int32_t tDeserializeSDbCfgRsp(void *buf, int32_t bufLen, SDbCfgRsp *pRsp) {
   tDecoderInit(&decoder, buf, bufLen);
 
   if (tStartDecode(&decoder) < 0) return -1;
+  if (tDecodeI64(&decoder, &pRsp->dbId) < 0) return -1;
+  if (tDecodeI32(&decoder, &pRsp->cfgVersion) < 0) return -1;
   if (tDecodeI32(&decoder, &pRsp->numOfVgroups) < 0) return -1;
   if (tDecodeI32(&decoder, &pRsp->numOfStables) < 0) return -1;
   if (tDecodeI32(&decoder, &pRsp->buffer) < 0) return -1;
diff --git a/source/dnode/mnode/impl/inc/mndDb.h b/source/dnode/mnode/impl/inc/mndDb.h
index 97d047d7a3..60d35ebe1d 100644
--- a/source/dnode/mnode/impl/inc/mndDb.h
+++ b/source/dnode/mnode/impl/inc/mndDb.h
@@ -26,7 +26,7 @@ int32_t mndInitDb(SMnode *pMnode);
 void    mndCleanupDb(SMnode *pMnode);
 SDbObj *mndAcquireDb(SMnode *pMnode, const char *db);
 void    mndReleaseDb(SMnode *pMnode, SDbObj *pDb);
-int32_t mndValidateDbInfo(SMnode *pMnode, SDbVgVersion *pDbs, int32_t numOfDbs, void **ppRsp, int32_t *pRspLen);
+int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs, void **ppRsp, int32_t *pRspLen);
 int32_t mndExtractDbInfo(SMnode *pMnode, SDbObj *pDb, SUseDbRsp *pRsp, const SUseDbReq *pReq);
 bool    mndIsDbReady(SMnode *pMnode, SDbObj *pDb);
 
diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c
index 126a653a69..5aa4afd467 100644
--- a/source/dnode/mnode/impl/src/mndDb.c
+++ b/source/dnode/mnode/impl/src/mndDb.c
@@ -883,6 +883,8 @@ static int32_t mndProcessGetDbCfgReq(SRpcMsg *pReq) {
     goto _OVER;
   }
 
+  cfgRsp.dbId = pDb->uid;
+  cfgRsp.cfgVersion = pDb->cfgVersion;
   cfgRsp.numOfVgroups = pDb->cfg.numOfVgroups;
   cfgRsp.numOfStables = pDb->cfg.numOfStables;
   cfgRsp.buffer = pDb->cfg.buffer;
@@ -1309,7 +1311,7 @@ _OVER:
   return code;
 }
 
-int32_t mndValidateDbInfo(SMnode *pMnode, SDbVgVersion *pDbs, int32_t numOfDbs, void **ppRsp, int32_t *pRspLen) {
+int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs, void **ppRsp, int32_t *pRspLen) {
   SUseDbBatchRsp batchUseRsp = {0};
   batchUseRsp.pArray = taosArrayInit(numOfDbs, sizeof(SUseDbRsp));
   if (batchUseRsp.pArray == NULL) {
@@ -1318,7 +1320,7 @@ int32_t mndValidateDbInfo(SMnode *pMnode, SDbVgVersion *pDbs, int32_t numOfDbs,
   }
 
   for (int32_t i = 0; i < numOfDbs; ++i) {
-    SDbVgVersion *pDbVgVersion = &pDbs[i];
+    SDbCacheInfo *pDbVgVersion = &pDbs[i];
     pDbVgVersion->dbId = be64toh(pDbVgVersion->dbId);
     pDbVgVersion->vgVersion = htonl(pDbVgVersion->vgVersion);
     pDbVgVersion->numOfTable = htonl(pDbVgVersion->numOfTable);
diff --git a/source/dnode/mnode/impl/src/mndProfile.c b/source/dnode/mnode/impl/src/mndProfile.c
index 50e502f4ab..ec013681bb 100644
--- a/source/dnode/mnode/impl/src/mndProfile.c
+++ b/source/dnode/mnode/impl/src/mndProfile.c
@@ -530,7 +530,7 @@ static int32_t mndProcessQueryHeartBeat(SMnode *pMnode, SRpcMsg *pMsg, SClientHb
       case HEARTBEAT_KEY_DBINFO: {
         void   *rspMsg = NULL;
         int32_t rspLen = 0;
-        mndValidateDbInfo(pMnode, kv->value, kv->valueLen / sizeof(SDbVgVersion), &rspMsg, &rspLen);
+        mndValidateDbInfo(pMnode, kv->value, kv->valueLen / sizeof(SDbCacheInfo), &rspMsg, &rspLen);
         if (rspMsg && rspLen > 0) {
           SKv kv1 = {.key = HEARTBEAT_KEY_DBINFO, .valueLen = rspLen, .value = rspMsg};
           taosArrayPush(hbRsp.info, &kv1);
diff --git a/source/libs/catalog/inc/catalogInt.h b/source/libs/catalog/inc/catalogInt.h
index 711274ce1d..a654458e8e 100644
--- a/source/libs/catalog/inc/catalogInt.h
+++ b/source/libs/catalog/inc/catalogInt.h
@@ -55,6 +55,7 @@ enum {
 
 enum {
   CTG_OP_UPDATE_VGROUP = 0,
+  CTG_OP_UPDATE_DB_CFG,
   CTG_OP_UPDATE_TB_META,
   CTG_OP_DROP_DB_CACHE,
   CTG_OP_DROP_DB_VGROUP,
@@ -204,19 +205,25 @@ typedef struct SCtgVgCache {
   SDBVgInfo* vgInfo;
 } SCtgVgCache;
 
+typedef struct SCtgCfgCache {
+  SRWLatch    cfgLock;
+  SDbCfgInfo* cfgInfo;
+} SCtgCfgCache;
+
 typedef struct SCtgDBCache {
-  SRWLatch    dbLock;  // RC between destroy tbCache/stbCache and all reads
-  uint64_t    dbId;
-  int8_t      deleted;
-  SCtgVgCache vgCache;
-  SHashObj*   tbCache;   // key:tbname, value:SCtgTbCache
-  SHashObj*   stbCache;  // key:suid, value:char*
+  SRWLatch     dbLock;  // RC between destroy tbCache/stbCache and all reads
+  uint64_t     dbId;
+  int8_t       deleted;
+  SCtgVgCache  vgCache;
+  SCtgCfgCache cfgCache;
+  SHashObj*    tbCache;   // key:tbname, value:SCtgTbCache
+  SHashObj*    stbCache;  // key:suid, value:char*
 } SCtgDBCache;
 
 typedef struct SCtgRentSlot {
   SRWLatch lock;
   bool     needSort;
-  SArray*  meta;  // element is SDbVgVersion or SSTableVersion
+  SArray*  meta;  // element is SDbCacheInfo or SSTableVersion
 } SCtgRentSlot;
 
 typedef struct SCtgRentMgmt {
@@ -367,6 +374,8 @@ typedef struct SCtgCacheStat {
   uint64_t numOfUser;
   uint64_t numOfVgHit;
   uint64_t numOfVgMiss;
+  uint64_t numOfCfgHit;
+  uint64_t numOfCfgMiss;  
   uint64_t numOfMetaHit;
   uint64_t numOfMetaMiss;
   uint64_t numOfIndexHit;
@@ -393,6 +402,13 @@ typedef struct SCtgUpdateVgMsg {
   SDBVgInfo* dbInfo;
 } SCtgUpdateVgMsg;
 
+typedef struct SCtgUpdateDbCfgMsg {
+  SCatalog*   pCtg;
+  char        dbFName[TSDB_DB_FNAME_LEN];
+  uint64_t    dbId;
+  SDbCfgInfo* cfgInfo;
+} SCtgUpdateDbCfgMsg;
+
 typedef struct SCtgUpdateTbMetaMsg {
   SCatalog*         pCtg;
   STableMetaOutput* pMeta;
@@ -697,8 +713,10 @@ int32_t ctgRemoveTbMetaFromCache(SCatalog* pCtg, SName* pTableName, bool syncReq
 int32_t ctgGetTbMetaFromCache(SCatalog* pCtg, SCtgTbMetaCtx* ctx, STableMeta** pTableMeta);
 int32_t ctgGetTbMetasFromCache(SCatalog* pCtg, SRequestConnInfo* pConn, SCtgTbMetasCtx* ctx, int32_t dbIdx,
                                int32_t* fetchIdx, int32_t baseResIdx, SArray* pList);
+void*   ctgCloneDbCfgInfo(void* pSrc);
 
 int32_t ctgOpUpdateVgroup(SCtgCacheOperation* action);
+int32_t ctgOpUpdateDbCfg(SCtgCacheOperation *operation);
 int32_t ctgOpUpdateTbMeta(SCtgCacheOperation* action);
 int32_t ctgOpDropDbCache(SCtgCacheOperation* action);
 int32_t ctgOpDropDbVgroup(SCtgCacheOperation* action);
@@ -720,6 +738,7 @@ int32_t ctgDropStbMetaEnqueue(SCatalog* pCtg, const char* dbFName, int64_t dbId,
                               bool syncReq);
 int32_t ctgDropTbMetaEnqueue(SCatalog* pCtg, const char* dbFName, int64_t dbId, const char* tbName, bool syncReq);
 int32_t ctgUpdateVgroupEnqueue(SCatalog* pCtg, const char* dbFName, int64_t dbId, SDBVgInfo* dbInfo, bool syncReq);
+int32_t ctgUpdateDbCfgEnqueue(SCatalog *pCtg, const char *dbFName, int64_t dbId, SDbCfgInfo *cfgInfo, bool syncOp);
 int32_t ctgUpdateTbMetaEnqueue(SCatalog* pCtg, STableMetaOutput* output, bool syncReq);
 int32_t ctgUpdateUserEnqueue(SCatalog* pCtg, SGetUserAuthRsp* pAuth, bool syncReq);
 int32_t ctgUpdateVgEpsetEnqueue(SCatalog* pCtg, char* dbFName, int32_t vgId, SEpSet* pEpSet);
@@ -790,9 +809,9 @@ int32_t ctgGetVgIdsFromHashValue(SCatalog* pCtg, SDBVgInfo* dbInfo, char* dbFNam
 void    ctgResetTbMetaTask(SCtgTask* pTask);
 void    ctgFreeDbCache(SCtgDBCache* dbCache);
 int32_t ctgStbVersionSortCompare(const void* key1, const void* key2);
-int32_t ctgDbVgVersionSortCompare(const void* key1, const void* key2);
+int32_t ctgDbCacheInfoSortCompare(const void* key1, const void* key2);
 int32_t ctgStbVersionSearchCompare(const void* key1, const void* key2);
-int32_t ctgDbVgVersionSearchCompare(const void* key1, const void* key2);
+int32_t ctgDbCacheInfoSearchCompare(const void* key1, const void* key2);
 void    ctgFreeSTableMetaOutput(STableMetaOutput* pOutput);
 int32_t ctgUpdateMsgCtx(SCtgMsgCtx* pCtx, int32_t reqType, void* out, char* target);
 int32_t ctgAddMsgCtx(SArray* pCtxs, int32_t reqType, void* out, char* target);
@@ -817,6 +836,7 @@ int32_t ctgCopyTbMeta(SCatalog *pCtg, SCtgTbMetaCtx *ctx, SCtgDBCache **pDb, SCt
 void    ctgReleaseVgMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, SCtgTbCache *pCache);
 void    ctgReleaseTbMetaToCache(SCatalog *pCtg, SCtgDBCache *dbCache, SCtgTbCache *pCache);
 int32_t ctgChkSetAuthRes(SCatalog *pCtg, SCtgAuthReq *req, SCtgAuthRsp* res);
+int32_t ctgReadDBCfgFromCache(SCatalog *pCtg, const char* dbFName, SDbCfgInfo* pDbCfg);
 
 extern SCatalogMgmt gCtgMgmt;
 extern SCtgDebug    gCTGDebug;
diff --git a/source/libs/catalog/src/catalog.c b/source/libs/catalog/src/catalog.c
index 6ef659b059..3a646d139a 100644
--- a/source/libs/catalog/src/catalog.c
+++ b/source/libs/catalog/src/catalog.c
@@ -626,6 +626,23 @@ _return:
   CTG_RET(code);
 }
 
+int32_t ctgGetDBCfg(SCatalog* pCtg, SRequestConnInfo* pConn, const char* dbFName, SDbCfgInfo* pDbCfg) {
+  CTG_ERR_RET(ctgReadDBCfgFromCache(pCtg, dbFName, pDbCfg));
+
+  if (pDbCfg->cfgVersion < 0) {
+    CTG_ERR_RET(ctgGetDBCfgFromMnode(pCtg, pConn, dbFName, pDbCfg, NULL));
+    SDbCfgInfo *pCfg = ctgCloneDbCfgInfo(pDbCfg);    
+    if (NULL == pCfg) {
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+    
+    CTG_ERR_RET(ctgUpdateDbCfgEnqueue(pCtg, dbFName, pDbCfg->dbId, pCfg, false));
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
+
 int32_t catalogInit(SCatalogCfg* cfg) {
   if (gCtgMgmt.pCluster) {
     qError("catalog already initialized");
@@ -1326,14 +1343,14 @@ int32_t catalogGetExpiredSTables(SCatalog* pCtg, SSTableVersion** stables, uint3
   CTG_API_LEAVE(ctgMetaRentGet(&pCtg->stbRent, (void**)stables, num, sizeof(SSTableVersion)));
 }
 
-int32_t catalogGetExpiredDBs(SCatalog* pCtg, SDbVgVersion** dbs, uint32_t* num) {
+int32_t catalogGetExpiredDBs(SCatalog* pCtg, SDbCacheInfo** dbs, uint32_t* num) {
   CTG_API_ENTER();
 
   if (NULL == pCtg || NULL == dbs || NULL == num) {
     CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
   }
 
-  CTG_API_LEAVE(ctgMetaRentGet(&pCtg->dbRent, (void**)dbs, num, sizeof(SDbVgVersion)));
+  CTG_API_LEAVE(ctgMetaRentGet(&pCtg->dbRent, (void**)dbs, num, sizeof(SDbCacheInfo)));
 }
 
 int32_t catalogGetExpiredUsers(SCatalog* pCtg, SUserAuthVersion** users, uint32_t* num) {
@@ -1381,7 +1398,7 @@ int32_t catalogGetDBCfg(SCatalog* pCtg, SRequestConnInfo* pConn, const char* dbF
     CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
   }
 
-  CTG_API_LEAVE(ctgGetDBCfgFromMnode(pCtg, pConn, dbFName, pDbCfg, NULL));
+  CTG_API_LEAVE(ctgGetDBCfg(pCtg, pConn, dbFName, pDbCfg));
 }
 
 int32_t catalogGetIndexMeta(SCatalog* pCtg, SRequestConnInfo* pConn, const char* indexName, SIndexInfo* pInfo) {
diff --git a/source/libs/catalog/src/ctgAsync.c b/source/libs/catalog/src/ctgAsync.c
index 5e83de70b4..a3ca002330 100644
--- a/source/libs/catalog/src/ctgAsync.c
+++ b/source/libs/catalog/src/ctgAsync.c
@@ -1446,7 +1446,6 @@ int32_t ctgHandleGetTbIndexRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBu
   CTG_ERR_JRET(ctgCloneTableIndex(pOut->pIndex, &pInfo));
   pTask->res = pInfo;
 
-  SCtgTbIndexCtx* ctx = pTask->taskCtx;
   CTG_ERR_JRET(ctgUpdateTbIndexEnqueue(pTask->pJob->pCtg, (STableIndex**)&pTask->msgCtx.out, false));
 
 _return:
@@ -1476,8 +1475,14 @@ _return:
 int32_t ctgHandleGetDbCfgRsp(SCtgTaskReq* tReq, int32_t reqType, const SDataBuf* pMsg, int32_t rspCode) {
   int32_t   code = 0;
   SCtgTask* pTask = tReq->pTask;
+  SCtgDbCfgCtx* ctx = pTask->taskCtx;
+  
   CTG_ERR_JRET(ctgProcessRspMsg(pTask->msgCtx.out, reqType, pMsg->pData, pMsg->len, rspCode, pTask->msgCtx.target));
 
+  SDbCfgInfo* pCfg = ctgCloneDbCfgInfo(pTask->msgCtx.out);
+
+  CTG_ERR_RET(ctgUpdateDbCfgEnqueue(pTask->pJob->pCtg, ctx->dbFName, pCfg->dbId, pCfg, false));
+
   TSWAP(pTask->res, pTask->msgCtx.out);
 
 _return:
@@ -1965,11 +1970,24 @@ int32_t ctgLaunchGetDbCfgTask(SCtgTask* pTask) {
   SCtgDbCfgCtx*     pCtx = (SCtgDbCfgCtx*)pTask->taskCtx;
   SCtgJob*          pJob = pTask->pJob;
   SCtgMsgCtx*       pMsgCtx = CTG_GET_TASK_MSGCTX(pTask, -1);
+  SDbCfgInfo        cfgInfo;
   if (NULL == pMsgCtx->pBatchs) {
     pMsgCtx->pBatchs = pJob->pBatchs;
   }
 
-  CTG_ERR_RET(ctgGetDBCfgFromMnode(pCtg, pConn, pCtx->dbFName, NULL, pTask));
+  CTG_ERR_RET(ctgReadDBCfgFromCache(pCtg, pCtx->dbFName, &cfgInfo));
+
+  if (cfgInfo.cfgVersion < 0) {
+    CTG_ERR_RET(ctgGetDBCfgFromMnode(pCtg, pConn, pCtx->dbFName, NULL, pTask));
+  } else {
+    pTask->res = taosMemoryCalloc(1, sizeof(SDbCfgInfo));
+    if (NULL == pTask->res) {
+      CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
+    }
+
+    memcpy(pTask->res, &cfgInfo, sizeof(cfgInfo));
+    CTG_ERR_RET(ctgHandleTaskEnd(pTask, 0));
+  }
 
   return TSDB_CODE_SUCCESS;
 }
diff --git a/source/libs/catalog/src/ctgCache.c b/source/libs/catalog/src/ctgCache.c
index dec92a4483..6f554e1e3c 100644
--- a/source/libs/catalog/src/ctgCache.c
+++ b/source/libs/catalog/src/ctgCache.c
@@ -20,6 +20,7 @@
 #include "trpc.h"
 
 SCtgOperation gCtgCacheOperation[CTG_OP_MAX] = {{CTG_OP_UPDATE_VGROUP, "update vgInfo", ctgOpUpdateVgroup},
+                                                {CTG_OP_UPDATE_DB_CFG, "update dbCfg", ctgOpUpdateDbCfg},
                                                 {CTG_OP_UPDATE_TB_META, "update tbMeta", ctgOpUpdateTbMeta},
                                                 {CTG_OP_DROP_DB_CACHE, "drop DB", ctgOpDropDbCache},
                                                 {CTG_OP_DROP_DB_VGROUP, "drop DBVgroup", ctgOpDropDbVgroup},
@@ -68,10 +69,15 @@ int32_t ctgWLockVgInfo(SCatalog *pCtg, SCtgDBCache *dbCache) {
   return TSDB_CODE_SUCCESS;
 }
 
-void ctgRUnlockVgInfo(SCtgDBCache *dbCache) { CTG_UNLOCK(CTG_READ, &dbCache->vgCache.vgLock); }
+void ctgRLockDbCfgInfo(SCtgDBCache *dbCache) {  CTG_LOCK(CTG_READ, &dbCache->cfgCache.cfgLock); }
+void ctgWLockDbCfgInfo(SCtgDBCache *dbCache) {  CTG_LOCK(CTG_WRITE, &dbCache->cfgCache.cfgLock); }
 
+void ctgRUnlockVgInfo(SCtgDBCache *dbCache) { CTG_UNLOCK(CTG_READ, &dbCache->vgCache.vgLock); }
 void ctgWUnlockVgInfo(SCtgDBCache *dbCache) { CTG_UNLOCK(CTG_WRITE, &dbCache->vgCache.vgLock); }
 
+void ctgRUnlockDbCfgInfo(SCtgDBCache *dbCache) { CTG_UNLOCK(CTG_READ, &dbCache->cfgCache.cfgLock); }
+void ctgWUnlockDbCfgInfo(SCtgDBCache *dbCache) { CTG_UNLOCK(CTG_WRITE, &dbCache->cfgCache.cfgLock); }
+
 void ctgReleaseDBCache(SCatalog *pCtg, SCtgDBCache *dbCache) {
   CTG_UNLOCK(CTG_READ, &dbCache->dbLock);
   taosHashRelease(pCtg->dbCache, dbCache);
@@ -679,6 +685,43 @@ _return:
   CTG_RET(code);
 }
 
+int32_t ctgReadDBCfgFromCache(SCatalog *pCtg, const char* dbFName, SDbCfgInfo* pDbCfg) {
+  int32_t code = 0;
+  SCtgDBCache *dbCache = NULL;
+  ctgAcquireDBCache(pCtg, dbFName, &dbCache);
+  if (NULL == dbCache) {
+    ctgDebug("db %s not in cache", dbFName);
+    pDbCfg->cfgVersion = -1;
+    CTG_CACHE_STAT_INC(numOfCfgMiss, 1);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  CTG_LOCK(CTG_READ, &dbCache->cfgCache.cfgLock);
+
+  if (dbCache->cfgCache.cfgInfo) {
+    SDbCfgInfo *pInfo = ctgCloneDbCfgInfo(dbCache->cfgCache.cfgInfo);
+    if (NULL == pInfo) {
+      CTG_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY);
+    }
+    
+    memcpy(pDbCfg, pInfo, sizeof(*pInfo));
+    taosMemoryFree(pInfo);
+    CTG_CACHE_STAT_INC(numOfCfgHit, 1);
+  } else {
+    pDbCfg->cfgVersion = -1;
+    CTG_CACHE_STAT_INC(numOfCfgMiss, 1);
+  }
+
+_return:
+
+  if (dbCache) {
+    CTG_UNLOCK(CTG_READ, &dbCache->cfgCache.cfgLock);
+    ctgReleaseDBCache(pCtg, dbCache);
+  }
+  
+  return code;
+}
+
 int32_t ctgChkAuthFromCache(SCatalog *pCtg, SUserAuthInfo *pReq, bool *inCache, SCtgAuthRsp *pRes) {
   if (IS_SYS_DBNAME(pReq->tbName.dbname)) {
     *inCache = true;
@@ -957,6 +1000,44 @@ _return:
   CTG_RET(code);
 }
 
+
+int32_t ctgUpdateDbCfgEnqueue(SCatalog *pCtg, const char *dbFName, int64_t dbId, SDbCfgInfo *cfgInfo, bool syncOp) {
+  int32_t             code = 0;
+  SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
+  op->opId = CTG_OP_UPDATE_DB_CFG;
+  op->syncOp = syncOp;
+
+  SCtgUpdateDbCfgMsg *msg = taosMemoryMalloc(sizeof(SCtgUpdateDbCfgMsg));
+  if (NULL == msg) {
+    ctgError("malloc %d failed", (int32_t)sizeof(SCtgUpdateDbCfgMsg));
+    taosMemoryFree(op);
+    freeDbCfgInfo(cfgInfo);
+    CTG_ERR_RET(TSDB_CODE_OUT_OF_MEMORY);
+  }
+
+  char *p = strchr(dbFName, '.');
+  if (p && IS_SYS_DBNAME(p + 1)) {
+    dbFName = p + 1;
+  }
+
+  tstrncpy(msg->dbFName, dbFName, sizeof(msg->dbFName));
+  msg->pCtg = pCtg;
+  msg->dbId = dbId;
+  msg->cfgInfo = cfgInfo;
+
+  op->data = msg;
+
+  CTG_ERR_JRET(ctgEnqueue(pCtg, op));
+
+  return TSDB_CODE_SUCCESS;
+
+_return:
+
+  freeDbCfgInfo(cfgInfo);
+  CTG_RET(code);
+}
+
+
 int32_t ctgUpdateTbMetaEnqueue(SCatalog *pCtg, STableMetaOutput *output, bool syncOp) {
   int32_t             code = 0;
   SCtgCacheOperation *op = taosMemoryCalloc(1, sizeof(SCtgCacheOperation));
@@ -1370,13 +1451,13 @@ int32_t ctgAddNewDBCache(SCatalog *pCtg, const char *dbFName, uint64_t dbId) {
 
   CTG_CACHE_STAT_INC(numOfDb, 1);
 
-  SDbVgVersion vgVersion = {.dbId = newDBCache.dbId, .vgVersion = -1, .stateTs = 0};
+  SDbCacheInfo vgVersion = {.dbId = newDBCache.dbId, .vgVersion = -1, .stateTs = 0};
   tstrncpy(vgVersion.dbFName, dbFName, sizeof(vgVersion.dbFName));
 
   ctgDebug("db added to cache, dbFName:%s, dbId:0x%" PRIx64, dbFName, dbId);
 
   if (!IS_SYS_DBNAME(dbFName)) {
-    CTG_ERR_RET(ctgMetaRentAdd(&pCtg->dbRent, &vgVersion, dbId, sizeof(SDbVgVersion)));
+    CTG_ERR_RET(ctgMetaRentAdd(&pCtg->dbRent, &vgVersion, dbId, sizeof(SDbCacheInfo)));
 
     ctgDebug("db added to rent, dbFName:%s, vgVersion:%d, dbId:0x%" PRIx64, dbFName, vgVersion.vgVersion, dbId);
   }
@@ -1422,7 +1503,7 @@ int32_t ctgRemoveDBFromCache(SCatalog *pCtg, SCtgDBCache *dbCache, const char *d
 
   CTG_UNLOCK(CTG_WRITE, &dbCache->dbLock);
 
-  CTG_ERR_RET(ctgMetaRentRemove(&pCtg->dbRent, dbId, ctgDbVgVersionSortCompare, ctgDbVgVersionSearchCompare));
+  CTG_ERR_RET(ctgMetaRentRemove(&pCtg->dbRent, dbId, ctgDbCacheInfoSortCompare, ctgDbCacheInfoSearchCompare));
   ctgDebug("db removed from rent, dbFName:%s, dbId:0x%" PRIx64, dbFName, dbId);
 
   if (taosHashRemove(pCtg->dbCache, dbFName, strlen(dbFName))) {
@@ -1717,7 +1798,7 @@ int32_t ctgOpUpdateVgroup(SCtgCacheOperation *operation) {
   }
 
   bool         newAdded = false;
-  SDbVgVersion vgVersion = {
+  SDbCacheInfo vgVersion = {
       .dbId = msg->dbId, .vgVersion = dbInfo->vgVersion, .numOfTable = dbInfo->numOfTable, .stateTs = dbInfo->stateTs};
 
   SCtgDBCache *dbCache = NULL;
@@ -1765,8 +1846,8 @@ int32_t ctgOpUpdateVgroup(SCtgCacheOperation *operation) {
 
   // if (!IS_SYS_DBNAME(dbFName)) {
   tstrncpy(vgVersion.dbFName, dbFName, sizeof(vgVersion.dbFName));
-  CTG_ERR_JRET(ctgMetaRentUpdate(&msg->pCtg->dbRent, &vgVersion, vgVersion.dbId, sizeof(SDbVgVersion),
-                                 ctgDbVgVersionSortCompare, ctgDbVgVersionSearchCompare));
+  CTG_ERR_JRET(ctgMetaRentUpdate(&msg->pCtg->dbRent, &vgVersion, vgVersion.dbId, sizeof(SDbCacheInfo),
+                                 ctgDbCacheInfoSortCompare, ctgDbCacheInfoSearchCompare));
   //}
 
 _return:
@@ -1777,6 +1858,67 @@ _return:
   CTG_RET(code);
 }
 
+int32_t ctgOpUpdateDbCfg(SCtgCacheOperation *operation) {
+  int32_t          code = 0;
+  SCtgUpdateDbCfgMsg *msg = operation->data;
+  SDbCfgInfo       *cfgInfo = msg->cfgInfo;
+  char            *dbFName = msg->dbFName;
+  SCatalog        *pCtg = msg->pCtg;
+
+  if (pCtg->stopUpdate || NULL == cfgInfo) {
+    goto _return;
+  }
+
+  if (cfgInfo->cfgVersion < 0) {
+    ctgDebug("invalid db cfgInfo, dbFName:%s, cfgVersion:%d", dbFName, cfgInfo->cfgVersion);
+    CTG_ERR_JRET(TSDB_CODE_APP_ERROR);
+  }
+
+  SCtgDBCache *dbCache = NULL;
+  CTG_ERR_JRET(ctgGetAddDBCache(msg->pCtg, dbFName, msg->dbId, &dbCache));
+  if (NULL == dbCache) {
+    ctgInfo("conflict db update, ignore this update, dbFName:%s, dbId:0x%" PRIx64, dbFName, msg->dbId);
+    CTG_ERR_JRET(TSDB_CODE_CTG_INTERNAL_ERROR);
+  }
+
+  SDbCacheInfo cacheInfo = {0};
+  cacheInfo.dbId = dbCache->dbId;
+  tstrncpy(cacheInfo.dbFName, dbFName, sizeof(cacheInfo.dbFName));
+  cacheInfo.cfgVersion = cfgInfo->cfgVersion;
+
+  SCtgVgCache *vgCache = &dbCache->vgCache;
+  if (vgCache->vgInfo) {
+    cacheInfo.vgVersion = vgCache->vgInfo->vgVersion;
+    cacheInfo.numOfTable = vgCache->vgInfo->numOfTable;
+    cacheInfo.stateTs = vgCache->vgInfo->stateTs;
+  } else {
+    cacheInfo.vgVersion = -1;
+  }
+
+  ctgWLockDbCfgInfo(dbCache);
+
+  freeDbCfgInfo(dbCache->cfgCache.cfgInfo);
+  dbCache->cfgCache.cfgInfo = cfgInfo;
+  cfgInfo = NULL;
+  
+  ctgWUnlockDbCfgInfo(dbCache);
+
+  ctgDebug("db cfgInfo updated, dbFName:%s, cfgVer:%d", dbFName, dbCache->cfgCache.cfgInfo->cfgVersion);
+
+  // if (!IS_SYS_DBNAME(dbFName)) {
+  CTG_ERR_JRET(ctgMetaRentUpdate(&msg->pCtg->dbRent, &cacheInfo, cacheInfo.dbId, sizeof(SDbCacheInfo),
+                                 ctgDbCacheInfoSortCompare, ctgDbCacheInfoSearchCompare));
+  //}
+
+_return:
+
+  freeDbCfgInfo(cfgInfo);
+  taosMemoryFreeClear(msg);
+
+  CTG_RET(code);
+}
+
+
 int32_t ctgOpDropDbCache(SCtgCacheOperation *operation) {
   int32_t        code = 0;
   SCtgDropDBMsg *msg = operation->data;
diff --git a/source/libs/catalog/src/ctgUtil.c b/source/libs/catalog/src/ctgUtil.c
index f7c7522a88..e062fd73e2 100644
--- a/source/libs/catalog/src/ctgUtil.c
+++ b/source/libs/catalog/src/ctgUtil.c
@@ -1039,10 +1039,10 @@ int32_t ctgStbVersionSearchCompare(const void* key1, const void* key2) {
   }
 }
 
-int32_t ctgDbVgVersionSearchCompare(const void* key1, const void* key2) {
-  if (*(int64_t*)key1 < ((SDbVgVersion*)key2)->dbId) {
+int32_t ctgDbCacheInfoSearchCompare(const void* key1, const void* key2) {
+  if (*(int64_t*)key1 < ((SDbCacheInfo*)key2)->dbId) {
     return -1;
-  } else if (*(int64_t*)key1 > ((SDbVgVersion*)key2)->dbId) {
+  } else if (*(int64_t*)key1 > ((SDbCacheInfo*)key2)->dbId) {
     return 1;
   } else {
     return 0;
@@ -1059,10 +1059,10 @@ int32_t ctgStbVersionSortCompare(const void* key1, const void* key2) {
   }
 }
 
-int32_t ctgDbVgVersionSortCompare(const void* key1, const void* key2) {
-  if (((SDbVgVersion*)key1)->dbId < ((SDbVgVersion*)key2)->dbId) {
+int32_t ctgDbCacheInfoSortCompare(const void* key1, const void* key2) {
+  if (((SDbCacheInfo*)key1)->dbId < ((SDbCacheInfo*)key2)->dbId) {
     return -1;
-  } else if (((SDbVgVersion*)key1)->dbId > ((SDbVgVersion*)key2)->dbId) {
+  } else if (((SDbCacheInfo*)key1)->dbId > ((SDbCacheInfo*)key2)->dbId) {
     return 1;
   } else {
     return 0;
@@ -1233,16 +1233,20 @@ static void* ctgCloneDbVgroup(void* pSrc) { return taosArrayDup((const SArray*)p
 
 static void ctgFreeDbVgroup(void* p) { taosArrayDestroy((SArray*)((SMetaRes*)p)->pRes); }
 
-static void* ctgCloneDbCfgInfo(void* pSrc) {
+void* ctgCloneDbCfgInfo(void* pSrc) {
   SDbCfgInfo* pDst = taosMemoryMalloc(sizeof(SDbCfgInfo));
   if (NULL == pDst) {
     return NULL;
   }
   memcpy(pDst, pSrc, sizeof(SDbCfgInfo));
+  pDst->pRetensions = taosArrayDup((const SArray*)pSrc, NULL);
   return pDst;
 }
 
-static void ctgFreeDbCfgInfo(void* p) { taosMemoryFree(((SMetaRes*)p)->pRes); }
+static void ctgFreeDbCfgInfo(void* p) { 
+  SDbCfgInfo* pDst = (SDbCfgInfo *)((SMetaRes*)p)->pRes;
+  freeDbCfgInfo(pDst);
+}
 
 static void* ctgCloneDbInfo(void* pSrc) {
   SDbInfo* pDst = taosMemoryMalloc(sizeof(SDbInfo));
diff --git a/source/libs/catalog/test/catalogTests.cpp b/source/libs/catalog/test/catalogTests.cpp
index 3d3a8161ad..2bd31a9a7f 100644
--- a/source/libs/catalog/test/catalogTests.cpp
+++ b/source/libs/catalog/test/catalogTests.cpp
@@ -1326,7 +1326,7 @@ TEST(tableMeta, normalTable) {
   ASSERT_EQ(tableMeta->tableInfo.precision, 1);
   ASSERT_EQ(tableMeta->tableInfo.rowSize, 12);
 
-  SDbVgVersion   *dbs = NULL;
+  SDbCacheInfo   *dbs = NULL;
   SSTableVersion *stb = NULL;
   uint32_t        dbNum = 0, stbNum = 0, allDbNum = 0, allStbNum = 0;
   int32_t         i = 0;
@@ -1438,7 +1438,7 @@ TEST(tableMeta, childTableCase) {
 
   taosMemoryFree(tableMeta);
 
-  SDbVgVersion   *dbs = NULL;
+  SDbCacheInfo   *dbs = NULL;
   SSTableVersion *stb = NULL;
   uint32_t        dbNum = 0, stbNum = 0, allDbNum = 0, allStbNum = 0;
   int32_t         i = 0;
@@ -1579,7 +1579,7 @@ TEST(tableMeta, superTableCase) {
 
   taosMemoryFree(tableMeta);
 
-  SDbVgVersion   *dbs = NULL;
+  SDbCacheInfo   *dbs = NULL;
   SSTableVersion *stb = NULL;
   uint32_t        dbNum = 0, stbNum = 0, allDbNum = 0, allStbNum = 0;
   int32_t         i = 0;
@@ -2675,7 +2675,7 @@ TEST(rentTest, allRent) {
   SDBVgInfo         dbVgroup = {0};
   SArray           *vgList = NULL;
   ctgTestStop = false;
-  SDbVgVersion   *dbs = NULL;
+  SDbCacheInfo   *dbs = NULL;
   SSTableVersion *stable = NULL;
   uint32_t        num = 0;
 
diff --git a/source/libs/qcom/src/queryUtil.c b/source/libs/qcom/src/queryUtil.c
index 9d8c170003..c70ea57401 100644
--- a/source/libs/qcom/src/queryUtil.c
+++ b/source/libs/qcom/src/queryUtil.c
@@ -548,3 +548,11 @@ int32_t cloneSVreateTbReq(SVCreateTbReq* pSrc, SVCreateTbReq** pDst) {
 
   return TSDB_CODE_SUCCESS;
 }
+
+void freeDbCfgInfo(SDbCfgInfo *pInfo) {
+  if (pInfo) {
+    taosArrayDestroy(pInfo->pRetensions);
+  }
+  taosMemoryFree(pInfo);
+}
+
diff --git a/source/util/src/tarray.c b/source/util/src/tarray.c
index b15bb519e7..498c4d437b 100644
--- a/source/util/src/tarray.c
+++ b/source/util/src/tarray.c
@@ -312,7 +312,7 @@ SArray* taosArrayFromList(const void* src, size_t size, size_t elemSize) {
 }
 
 SArray* taosArrayDup(const SArray* pSrc, __array_item_dup_fn_t fn) {
-  if (pSrc->size == 0) {  // empty array list
+  if (NULL == pSrc || pSrc->size == 0) {  // empty array list
     return taosArrayInit(8, pSrc->elemSize);
   }
 

From 5ae95f36600c8c3d810f6b57faeadf85ecb36204 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Thu, 13 Apr 2023 13:14:01 +0800
Subject: [PATCH 05/44] fix: clone db cfg issue

---
 source/client/inc/clientLog.h      |  2 ++
 source/client/src/clientEnv.c      |  2 +-
 source/libs/catalog/src/ctgCache.c | 24 ++++++++----------------
 source/libs/catalog/src/ctgUtil.c  |  2 +-
 4 files changed, 12 insertions(+), 18 deletions(-)

diff --git a/source/client/inc/clientLog.h b/source/client/inc/clientLog.h
index d213abd6f7..1a6d47d4f9 100644
--- a/source/client/inc/clientLog.h
+++ b/source/client/inc/clientLog.h
@@ -33,6 +33,8 @@ extern "C" {
 #define tscTrace(...)  do { if (cDebugFlag & DEBUG_TRACE) { taosPrintLog("TSC ", DEBUG_TRACE, cDebugFlag, __VA_ARGS__); }} while(0)
 #define tscDebugL(...) do { if (cDebugFlag & DEBUG_DEBUG) { taosPrintLongString("TSC ", DEBUG_DEBUG, cDebugFlag, __VA_ARGS__); }} while(0)
 #define tscPerf(...)   do { if (cDebugFlag & DEBUG_INFO)  { taosPrintLog("TSC ", 0, cDebugFlag, __VA_ARGS__); }} while(0)
+#define tscLog(...)    do { taosPrintLog("TSC ", 0, DEBUG_FILE, __VA_ARGS__); } while(0)
+#define tscLogL(...)   do { taosPrintLongString("TSC ", 0, DEBUG_FILE, __VA_ARGS__); } while(0)
 // clang-format on
 
 #ifdef __cplusplus
diff --git a/source/client/src/clientEnv.c b/source/client/src/clientEnv.c
index 418103f2a6..1d63955060 100644
--- a/source/client/src/clientEnv.c
+++ b/source/client/src/clientEnv.c
@@ -107,7 +107,7 @@ static void deregisterRequest(SRequestObj *pRequest) {
 
   if (duration >= SLOW_QUERY_INTERVAL) {
     atomic_add_fetch_64((int64_t *)&pActivity->numOfSlowQueries, 1);
-    tscWarnL("slow query: %s, duration:%" PRId64, pRequest->sqlstr, duration);
+    tscLogL("slow query: %s, duration:%" PRId64, pRequest->sqlstr, duration);
   }
 
   releaseTscObj(pTscObj->id);
diff --git a/source/libs/catalog/src/ctgCache.c b/source/libs/catalog/src/ctgCache.c
index 6f554e1e3c..6a95762cab 100644
--- a/source/libs/catalog/src/ctgCache.c
+++ b/source/libs/catalog/src/ctgCache.c
@@ -2166,27 +2166,19 @@ int32_t ctgOpUpdateUser(SCtgCacheOperation *operation) {
   CTG_LOCK(CTG_WRITE, &pUser->lock);
 
   taosHashCleanup(pUser->userAuth.createdDbs);
-  pUser->userAuth.createdDbs = msg->userAuth.createdDbs;
-  msg->userAuth.createdDbs = NULL;
-
   taosHashCleanup(pUser->userAuth.readDbs);
-  pUser->userAuth.readDbs = msg->userAuth.readDbs;
-  msg->userAuth.readDbs = NULL;
-
   taosHashCleanup(pUser->userAuth.writeDbs);
-  pUser->userAuth.writeDbs = msg->userAuth.writeDbs;
-  msg->userAuth.writeDbs = NULL;
-
   taosHashCleanup(pUser->userAuth.readTbs);
-  pUser->userAuth.readTbs = msg->userAuth.readTbs;
-  msg->userAuth.readTbs = NULL;
-
   taosHashCleanup(pUser->userAuth.writeTbs);
-  pUser->userAuth.writeTbs = msg->userAuth.writeTbs;
-  msg->userAuth.writeTbs = NULL;
-
   taosHashCleanup(pUser->userAuth.useDbs);
-  pUser->userAuth.useDbs = msg->userAuth.useDbs;
+
+  memcpy(&pUser->userAuth, &msg->userAuth, sizeof(msg->userAuth));
+
+  msg->userAuth.createdDbs = NULL;
+  msg->userAuth.readDbs = NULL;
+  msg->userAuth.writeDbs = NULL;
+  msg->userAuth.readTbs = NULL;
+  msg->userAuth.writeTbs = NULL;
   msg->userAuth.useDbs = NULL;
 
   CTG_UNLOCK(CTG_WRITE, &pUser->lock);
diff --git a/source/libs/catalog/src/ctgUtil.c b/source/libs/catalog/src/ctgUtil.c
index e062fd73e2..97578bd1d8 100644
--- a/source/libs/catalog/src/ctgUtil.c
+++ b/source/libs/catalog/src/ctgUtil.c
@@ -1239,7 +1239,7 @@ void* ctgCloneDbCfgInfo(void* pSrc) {
     return NULL;
   }
   memcpy(pDst, pSrc, sizeof(SDbCfgInfo));
-  pDst->pRetensions = taosArrayDup((const SArray*)pSrc, NULL);
+  pDst->pRetensions = taosArrayDup(((SDbCfgInfo *)pSrc)->pRetensions, NULL);
   return pDst;
 }
 

From e1d7b76adf0d3890f331ef0d219ad62be011d130 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Thu, 13 Apr 2023 13:26:28 +0800
Subject: [PATCH 06/44] fix: array dup issue

---
 source/util/src/tarray.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/source/util/src/tarray.c b/source/util/src/tarray.c
index 498c4d437b..a786721213 100644
--- a/source/util/src/tarray.c
+++ b/source/util/src/tarray.c
@@ -312,7 +312,11 @@ SArray* taosArrayFromList(const void* src, size_t size, size_t elemSize) {
 }
 
 SArray* taosArrayDup(const SArray* pSrc, __array_item_dup_fn_t fn) {
-  if (NULL == pSrc || pSrc->size == 0) {  // empty array list
+  if (NULL == pSrc) {
+    return NULL;
+  }
+  
+  if (pSrc->size == 0) {  // empty array list
     return taosArrayInit(8, pSrc->elemSize);
   }
 

From e86ffad8eff9cc41eaad7526dc1deccf88869c60 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Thu, 13 Apr 2023 14:23:12 +0800
Subject: [PATCH 07/44] fix: add debug info

---
 include/libs/executor/dataSinkMgt.h       | 1 +
 source/libs/executor/src/dataDispatcher.c | 1 +
 source/libs/qworker/src/qworker.c         | 2 ++
 3 files changed, 4 insertions(+)

diff --git a/include/libs/executor/dataSinkMgt.h b/include/libs/executor/dataSinkMgt.h
index ed7cbc8125..5e0b37eb46 100644
--- a/include/libs/executor/dataSinkMgt.h
+++ b/include/libs/executor/dataSinkMgt.h
@@ -70,6 +70,7 @@ typedef struct SOutputData {
   int32_t numOfBlocks;
   int64_t numOfRows; // int32_t changed to int64_t
   int32_t numOfCols;
+  int32_t dataSize;
   int8_t  compressed;
   char*   pData;
   bool    queryEnd;
diff --git a/source/libs/executor/src/dataDispatcher.c b/source/libs/executor/src/dataDispatcher.c
index d8efcf50ca..b6433cc012 100644
--- a/source/libs/executor/src/dataDispatcher.c
+++ b/source/libs/executor/src/dataDispatcher.c
@@ -189,6 +189,7 @@ static int32_t getDataBlock(SDataSinkHandle* pHandle, SOutputData* pOutput) {
     return TSDB_CODE_SUCCESS;
   }
   SDataCacheEntry* pEntry = (SDataCacheEntry*)(pDispatcher->nextOutput.pData);
+  assert(pOutput->dataSize == pEntry->dataLen);
   memcpy(pOutput->pData, pEntry->data, pEntry->dataLen);
   pOutput->numOfRows = pEntry->numOfRows;
   pOutput->numOfCols = pEntry->numOfCols;
diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c
index a68cf981e3..38294c5443 100644
--- a/source/libs/qworker/src/qworker.c
+++ b/source/libs/qworker/src/qworker.c
@@ -322,6 +322,7 @@ int32_t qwGetQueryResFromSink(QW_FPARAMS_DEF, SQWTaskCtx *ctx, int32_t *dataLen,
 
     if (len == 0) {
       if (queryEnd) {
+        output.dataSize = 0;
         code = dsGetDataBlock(ctx->sinkHandle, &output);
         if (code) {
           QW_TASK_ELOG("dsGetDataBlock failed, code:%x - %s", code, tstrerror(code));
@@ -357,6 +358,7 @@ int32_t qwGetQueryResFromSink(QW_FPARAMS_DEF, SQWTaskCtx *ctx, int32_t *dataLen,
     QW_ERR_RET(qwMallocFetchRsp(!ctx->localExec, *dataLen, &rsp));
 
     output.pData = rsp->data + *dataLen - len;
+    output.dataSize = len;
     code = dsGetDataBlock(ctx->sinkHandle, &output);
     if (code) {
       QW_TASK_ELOG("dsGetDataBlock failed, code:%x - %s", code, tstrerror(code));

From 945997f22a947af1c39a7de62de9a786bd5fbf57 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Thu, 13 Apr 2023 15:18:53 +0800
Subject: [PATCH 08/44] fix: add memory protect

---
 source/libs/executor/src/dataDispatcher.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/source/libs/executor/src/dataDispatcher.c b/source/libs/executor/src/dataDispatcher.c
index b6433cc012..c1b4bed523 100644
--- a/source/libs/executor/src/dataDispatcher.c
+++ b/source/libs/executor/src/dataDispatcher.c
@@ -82,6 +82,8 @@ static void toDataCacheEntry(SDataDispatchHandle* pHandle, const SInputData* pIn
 
   pBuf->useSize += pEntry->dataLen;
 
+  mprotect(pBuf->pData, pBuf->allocSize, PROT_READ);
+
   atomic_add_fetch_64(&pHandle->cachedSize, pEntry->dataLen);
   atomic_add_fetch_64(&gDataSinkStat.cachedSize, pEntry->dataLen);
 }
@@ -98,7 +100,9 @@ static bool allocBuf(SDataDispatchHandle* pDispatcher, const SInputData* pInput,
 
   pBuf->allocSize = sizeof(SDataCacheEntry) + blockGetEncodeSize(pInput->pData);
 
-  pBuf->pData = taosMemoryMalloc(pBuf->allocSize);
+//  pBuf->pData = taosMemoryMalloc(pBuf->allocSize);
+  pBuf->allocSize = (pBuf->allocSize > 4096) ? (pBuf->allocSize/4096 + 1)*4096 : 4096;
+  pBuf->pData = taosMemoryMallocAlign(4096, pBuf->allocSize);
   if (pBuf->pData == NULL) {
     qError("SinkNode failed to malloc memory, size:%d, code:%d", pBuf->allocSize, TAOS_SYSTEM_ERROR(errno));
   }
@@ -201,6 +205,7 @@ static int32_t getDataBlock(SDataSinkHandle* pHandle, SOutputData* pOutput) {
   atomic_sub_fetch_64(&pDispatcher->cachedSize, pEntry->dataLen);
   atomic_sub_fetch_64(&gDataSinkStat.cachedSize, pEntry->dataLen);
 
+  mprotect(pDispatcher->nextOutput.pData, pDispatcher->nextOutput.allocSize, PROT_READ|PROT_WRITE|PROT_EXEC);
   taosMemoryFreeClear(pDispatcher->nextOutput.pData);  // todo persistent
   pOutput->bufStatus = updateStatus(pDispatcher);
   taosThreadMutexLock(&pDispatcher->mutex);

From 1b47b35c3d6ac8188fd168803c5f731db73709c7 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Thu, 13 Apr 2023 15:23:35 +0800
Subject: [PATCH 09/44] fix: memory protect issue

---
 source/libs/executor/src/dataDispatcher.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/source/libs/executor/src/dataDispatcher.c b/source/libs/executor/src/dataDispatcher.c
index c1b4bed523..4b5a5f3aa9 100644
--- a/source/libs/executor/src/dataDispatcher.c
+++ b/source/libs/executor/src/dataDispatcher.c
@@ -225,6 +225,7 @@ static int32_t destroyDataSinker(SDataSinkHandle* pHandle) {
     SDataDispatchBuf* pBuf = NULL;
     taosReadQitem(pDispatcher->pDataBlocks, (void**)&pBuf);
     if (pBuf != NULL) {
+      mprotect(pBuf->pData, pBuf->allocSize, PROT_READ|PROT_WRITE|PROT_EXEC);
       taosMemoryFreeClear(pBuf->pData);
       taosFreeQitem(pBuf);
     }

From 48f2e26c7915a8e2acb269761633a032eb9725ad Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Thu, 13 Apr 2023 15:59:52 +0800
Subject: [PATCH 10/44] fix: remove protect

---
 source/libs/executor/src/dataDispatcher.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/source/libs/executor/src/dataDispatcher.c b/source/libs/executor/src/dataDispatcher.c
index 4b5a5f3aa9..f8dcd771c0 100644
--- a/source/libs/executor/src/dataDispatcher.c
+++ b/source/libs/executor/src/dataDispatcher.c
@@ -82,7 +82,7 @@ static void toDataCacheEntry(SDataDispatchHandle* pHandle, const SInputData* pIn
 
   pBuf->useSize += pEntry->dataLen;
 
-  mprotect(pBuf->pData, pBuf->allocSize, PROT_READ);
+  //mprotect(pBuf->pData, pBuf->allocSize, PROT_READ);
 
   atomic_add_fetch_64(&pHandle->cachedSize, pEntry->dataLen);
   atomic_add_fetch_64(&gDataSinkStat.cachedSize, pEntry->dataLen);
@@ -100,9 +100,9 @@ static bool allocBuf(SDataDispatchHandle* pDispatcher, const SInputData* pInput,
 
   pBuf->allocSize = sizeof(SDataCacheEntry) + blockGetEncodeSize(pInput->pData);
 
-//  pBuf->pData = taosMemoryMalloc(pBuf->allocSize);
-  pBuf->allocSize = (pBuf->allocSize > 4096) ? (pBuf->allocSize/4096 + 1)*4096 : 4096;
-  pBuf->pData = taosMemoryMallocAlign(4096, pBuf->allocSize);
+  pBuf->pData = taosMemoryMalloc(pBuf->allocSize);
+  //pBuf->allocSize = (pBuf->allocSize > 4096) ? (pBuf->allocSize/4096 + 1)*4096 : 4096;
+  //pBuf->pData = taosMemoryMallocAlign(4096, pBuf->allocSize);
   if (pBuf->pData == NULL) {
     qError("SinkNode failed to malloc memory, size:%d, code:%d", pBuf->allocSize, TAOS_SYSTEM_ERROR(errno));
   }
@@ -205,7 +205,7 @@ static int32_t getDataBlock(SDataSinkHandle* pHandle, SOutputData* pOutput) {
   atomic_sub_fetch_64(&pDispatcher->cachedSize, pEntry->dataLen);
   atomic_sub_fetch_64(&gDataSinkStat.cachedSize, pEntry->dataLen);
 
-  mprotect(pDispatcher->nextOutput.pData, pDispatcher->nextOutput.allocSize, PROT_READ|PROT_WRITE|PROT_EXEC);
+  //mprotect(pDispatcher->nextOutput.pData, pDispatcher->nextOutput.allocSize, PROT_READ|PROT_WRITE|PROT_EXEC);
   taosMemoryFreeClear(pDispatcher->nextOutput.pData);  // todo persistent
   pOutput->bufStatus = updateStatus(pDispatcher);
   taosThreadMutexLock(&pDispatcher->mutex);
@@ -225,7 +225,7 @@ static int32_t destroyDataSinker(SDataSinkHandle* pHandle) {
     SDataDispatchBuf* pBuf = NULL;
     taosReadQitem(pDispatcher->pDataBlocks, (void**)&pBuf);
     if (pBuf != NULL) {
-      mprotect(pBuf->pData, pBuf->allocSize, PROT_READ|PROT_WRITE|PROT_EXEC);
+      //mprotect(pBuf->pData, pBuf->allocSize, PROT_READ|PROT_WRITE|PROT_EXEC);
       taosMemoryFreeClear(pBuf->pData);
       taosFreeQitem(pBuf);
     }

From 8ecf5bdb33c670c1fd3ad750fddc0bf96215634e Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Thu, 13 Apr 2023 17:42:20 +0800
Subject: [PATCH 11/44] fix: quick rsp

---
 source/libs/qworker/src/qworker.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c
index 38294c5443..a60b7b79fa 100644
--- a/source/libs/qworker/src/qworker.c
+++ b/source/libs/qworker/src/qworker.c
@@ -636,6 +636,8 @@ int32_t qwPreprocessQuery(QW_FPARAMS_DEF, SQWMsg *qwMsg) {
 
   QW_ERR_JRET(qwAddTaskStatus(QW_FPARAMS(), JOB_TASK_STATUS_INIT));
 
+  qwSendQueryRsp(QW_FPARAMS(), qwMsg->msgType + 1, ctx, code, true);
+
 _return:
 
   if (ctx) {
@@ -686,7 +688,7 @@ int32_t qwProcessQuery(QW_FPARAMS_DEF, SQWMsg *qwMsg, char *sql) {
     QW_ERR_JRET(TSDB_CODE_APP_ERROR);
   }
 
-  qwSendQueryRsp(QW_FPARAMS(), qwMsg->msgType + 1, ctx, code, true);
+  //qwSendQueryRsp(QW_FPARAMS(), qwMsg->msgType + 1, ctx, code, true);
 
   ctx->level = plan->level;
   atomic_store_ptr(&ctx->taskHandle, pTaskInfo);

From 8ad82f07b0f4131a2c536374f116c758281c4be6 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Thu, 13 Apr 2023 18:25:50 +0800
Subject: [PATCH 12/44] fix: quick rsp issue

---
 source/libs/qworker/src/qworker.c | 68 +++++++++++++++++++------------
 1 file changed, 42 insertions(+), 26 deletions(-)

diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c
index a60b7b79fa..0052917eb1 100644
--- a/source/libs/qworker/src/qworker.c
+++ b/source/libs/qworker/src/qworker.c
@@ -254,6 +254,7 @@ bool qwTaskNotInExec(SQWTaskCtx *ctx) {
   return false;
 }
 
+
 int32_t qwGenerateSchHbRsp(SQWorker *mgmt, SQWSchStatus *sch, SQWHbInfo *hbInfo) {
   int32_t taskNum = 0;
 
@@ -438,6 +439,44 @@ int32_t qwGetDeleteResFromSink(QW_FPARAMS_DEF, SQWTaskCtx *ctx, SDeleteRes *pRes
   return TSDB_CODE_SUCCESS;
 }
 
+
+int32_t qwQuickRspFetchReq(QW_FPARAMS_DEF, SQWTaskCtx    * ctx, SQWMsg *qwMsg, int32_t code) {
+  QW_LOCK(QW_WRITE, &ctx->lock);
+  if (QUERY_RSP_POLICY_QUICK == tsQueryRspPolicy && ctx != NULL && QW_EVENT_RECEIVED(ctx, QW_EVENT_FETCH)) {
+    QW_SET_EVENT_PROCESSED(ctx, QW_EVENT_FETCH);
+    QW_UNLOCK(QW_WRITE, &ctx->lock);
+    
+    void       *rsp = NULL;
+    int32_t     dataLen = 0;
+    SOutputData sOutput = {0};
+    if (qwGetQueryResFromSink(QW_FPARAMS(), ctx, &dataLen, &rsp, &sOutput)) {
+      return TSDB_CODE_SUCCESS;
+    }
+
+    if (rsp) {
+      bool qComplete = (DS_BUF_EMPTY == sOutput.bufStatus && sOutput.queryEnd);
+
+      qwBuildFetchRsp(rsp, &sOutput, dataLen, qComplete);
+      if (qComplete) {
+        atomic_store_8((int8_t *)&ctx->queryEnd, true);
+      }
+
+      qwMsg->connInfo = ctx->dataConnInfo;
+      QW_SET_EVENT_PROCESSED(ctx, QW_EVENT_FETCH);
+
+      qwBuildAndSendFetchRsp(ctx->msgType + 1, &qwMsg->connInfo, rsp, dataLen, code);
+      rsp = NULL;
+
+      QW_TASK_DLOG("fetch rsp send, handle:%p, code:%x - %s, dataLen:%d", qwMsg->connInfo.handle, code, tstrerror(code),
+                   dataLen);
+    } else {
+      QW_SET_EVENT_RECEIVED(ctx, QW_EVENT_FETCH);
+    }
+  }
+
+  return TSDB_CODE_SUCCESS;
+}
+
 int32_t qwHandlePrePhaseEvents(QW_FPARAMS_DEF, int8_t phase, SQWPhaseInput *input, SQWPhaseOutput *output) {
   int32_t     code = 0;
   SQWTaskCtx *ctx = NULL;
@@ -705,32 +744,7 @@ _return:
   input.msgType = qwMsg->msgType;
   code = qwHandlePostPhaseEvents(QW_FPARAMS(), QW_PHASE_POST_QUERY, &input, NULL);
 
-  if (QUERY_RSP_POLICY_QUICK == tsQueryRspPolicy && ctx != NULL && QW_EVENT_RECEIVED(ctx, QW_EVENT_FETCH)) {
-    void       *rsp = NULL;
-    int32_t     dataLen = 0;
-    SOutputData sOutput = {0};
-    if (qwGetQueryResFromSink(QW_FPARAMS(), ctx, &dataLen, &rsp, &sOutput)) {
-      return TSDB_CODE_SUCCESS;
-    }
-
-    if (rsp) {
-      bool qComplete = (DS_BUF_EMPTY == sOutput.bufStatus && sOutput.queryEnd);
-
-      qwBuildFetchRsp(rsp, &sOutput, dataLen, qComplete);
-      if (qComplete) {
-        atomic_store_8((int8_t *)&ctx->queryEnd, true);
-      }
-
-      qwMsg->connInfo = ctx->dataConnInfo;
-      QW_SET_EVENT_PROCESSED(ctx, QW_EVENT_FETCH);
-
-      qwBuildAndSendFetchRsp(ctx->msgType + 1, &qwMsg->connInfo, rsp, dataLen, code);
-      rsp = NULL;
-
-      QW_TASK_DLOG("fetch rsp send, handle:%p, code:%x - %s, dataLen:%d", qwMsg->connInfo.handle, code, tstrerror(code),
-                   dataLen);
-    }
-  }
+  qwQuickRspFetchReq(QW_FPARAMS(), ctx, qwMsg, code);
 
   QW_RET(TSDB_CODE_SUCCESS);
 }
@@ -900,6 +914,8 @@ _return:
       qwFreeFetchRsp(rsp);
       rsp = NULL;
     }
+  } else {    
+    qwQuickRspFetchReq(QW_FPARAMS(), ctx, qwMsg, code);
   }
 
   QW_RET(TSDB_CODE_SUCCESS);

From 7800da65ae6174df1b24ec2064b1744a2fc6fd47 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Thu, 13 Apr 2023 18:30:13 +0800
Subject: [PATCH 13/44] fix: quick rsp lock issue

---
 source/libs/qworker/src/qworker.c | 52 +++++++++++++++++--------------
 1 file changed, 28 insertions(+), 24 deletions(-)

diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c
index 0052917eb1..310617670f 100644
--- a/source/libs/qworker/src/qworker.c
+++ b/source/libs/qworker/src/qworker.c
@@ -441,34 +441,38 @@ int32_t qwGetDeleteResFromSink(QW_FPARAMS_DEF, SQWTaskCtx *ctx, SDeleteRes *pRes
 
 
 int32_t qwQuickRspFetchReq(QW_FPARAMS_DEF, SQWTaskCtx    * ctx, SQWMsg *qwMsg, int32_t code) {
-  QW_LOCK(QW_WRITE, &ctx->lock);
-  if (QUERY_RSP_POLICY_QUICK == tsQueryRspPolicy && ctx != NULL && QW_EVENT_RECEIVED(ctx, QW_EVENT_FETCH)) {
-    QW_SET_EVENT_PROCESSED(ctx, QW_EVENT_FETCH);
-    QW_UNLOCK(QW_WRITE, &ctx->lock);
-    
-    void       *rsp = NULL;
-    int32_t     dataLen = 0;
-    SOutputData sOutput = {0};
-    if (qwGetQueryResFromSink(QW_FPARAMS(), ctx, &dataLen, &rsp, &sOutput)) {
-      return TSDB_CODE_SUCCESS;
-    }
-
-    if (rsp) {
-      bool qComplete = (DS_BUF_EMPTY == sOutput.bufStatus && sOutput.queryEnd);
-
-      qwBuildFetchRsp(rsp, &sOutput, dataLen, qComplete);
-      if (qComplete) {
-        atomic_store_8((int8_t *)&ctx->queryEnd, true);
+  if (QUERY_RSP_POLICY_QUICK == tsQueryRspPolicy && ctx != NULL) {
+    QW_LOCK(QW_WRITE, &ctx->lock);
+    if (QW_EVENT_RECEIVED(ctx, QW_EVENT_FETCH)) {
+      QW_SET_EVENT_PROCESSED(ctx, QW_EVENT_FETCH);
+      QW_UNLOCK(QW_WRITE, &ctx->lock);
+      
+      void       *rsp = NULL;
+      int32_t     dataLen = 0;
+      SOutputData sOutput = {0};
+      if (qwGetQueryResFromSink(QW_FPARAMS(), ctx, &dataLen, &rsp, &sOutput)) {
+        return TSDB_CODE_SUCCESS;
       }
 
-      qwMsg->connInfo = ctx->dataConnInfo;
-      QW_SET_EVENT_PROCESSED(ctx, QW_EVENT_FETCH);
+      if (rsp) {
+        bool qComplete = (DS_BUF_EMPTY == sOutput.bufStatus && sOutput.queryEnd);
 
-      qwBuildAndSendFetchRsp(ctx->msgType + 1, &qwMsg->connInfo, rsp, dataLen, code);
-      rsp = NULL;
+        qwBuildFetchRsp(rsp, &sOutput, dataLen, qComplete);
+        if (qComplete) {
+          atomic_store_8((int8_t *)&ctx->queryEnd, true);
+        }
 
-      QW_TASK_DLOG("fetch rsp send, handle:%p, code:%x - %s, dataLen:%d", qwMsg->connInfo.handle, code, tstrerror(code),
-                   dataLen);
+        qwMsg->connInfo = ctx->dataConnInfo;
+        QW_SET_EVENT_PROCESSED(ctx, QW_EVENT_FETCH);
+
+        qwBuildAndSendFetchRsp(ctx->msgType + 1, &qwMsg->connInfo, rsp, dataLen, code);
+        rsp = NULL;
+
+        QW_TASK_DLOG("fetch rsp send, handle:%p, code:%x - %s, dataLen:%d", qwMsg->connInfo.handle, code, tstrerror(code),
+                     dataLen);
+      } else {
+        QW_UNLOCK(QW_WRITE, &ctx->lock);
+      }
     } else {
       QW_SET_EVENT_RECEIVED(ctx, QW_EVENT_FETCH);
     }

From 1508c3afc2607564e7ddb94a72eb74ef022807d5 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Thu, 13 Apr 2023 18:34:23 +0800
Subject: [PATCH 14/44] fix: quick rsp issue

---
 source/libs/qworker/src/qworker.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c
index 310617670f..4ca9940cac 100644
--- a/source/libs/qworker/src/qworker.c
+++ b/source/libs/qworker/src/qworker.c
@@ -471,10 +471,10 @@ int32_t qwQuickRspFetchReq(QW_FPARAMS_DEF, SQWTaskCtx    * ctx, SQWMsg *qwMsg, i
         QW_TASK_DLOG("fetch rsp send, handle:%p, code:%x - %s, dataLen:%d", qwMsg->connInfo.handle, code, tstrerror(code),
                      dataLen);
       } else {
-        QW_UNLOCK(QW_WRITE, &ctx->lock);
+        QW_SET_EVENT_RECEIVED(ctx, QW_EVENT_FETCH);
       }
     } else {
-      QW_SET_EVENT_RECEIVED(ctx, QW_EVENT_FETCH);
+      QW_UNLOCK(QW_WRITE, &ctx->lock);
     }
   }
 

From 9caac472e830fa1ef02c53d9bf402c964df61868 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Thu, 13 Apr 2023 19:40:56 +0800
Subject: [PATCH 15/44] fix: quick rsp issue

---
 source/libs/qworker/src/qworker.c | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c
index 4ca9940cac..f92f31fb1c 100644
--- a/source/libs/qworker/src/qworker.c
+++ b/source/libs/qworker/src/qworker.c
@@ -443,14 +443,13 @@ int32_t qwGetDeleteResFromSink(QW_FPARAMS_DEF, SQWTaskCtx *ctx, SDeleteRes *pRes
 int32_t qwQuickRspFetchReq(QW_FPARAMS_DEF, SQWTaskCtx    * ctx, SQWMsg *qwMsg, int32_t code) {
   if (QUERY_RSP_POLICY_QUICK == tsQueryRspPolicy && ctx != NULL) {
     QW_LOCK(QW_WRITE, &ctx->lock);
+    
     if (QW_EVENT_RECEIVED(ctx, QW_EVENT_FETCH)) {
-      QW_SET_EVENT_PROCESSED(ctx, QW_EVENT_FETCH);
-      QW_UNLOCK(QW_WRITE, &ctx->lock);
-      
       void       *rsp = NULL;
       int32_t     dataLen = 0;
       SOutputData sOutput = {0};
       if (qwGetQueryResFromSink(QW_FPARAMS(), ctx, &dataLen, &rsp, &sOutput)) {
+        QW_UNLOCK(QW_WRITE, &ctx->lock);
         return TSDB_CODE_SUCCESS;
       }
 
@@ -470,12 +469,10 @@ int32_t qwQuickRspFetchReq(QW_FPARAMS_DEF, SQWTaskCtx    * ctx, SQWMsg *qwMsg, i
 
         QW_TASK_DLOG("fetch rsp send, handle:%p, code:%x - %s, dataLen:%d", qwMsg->connInfo.handle, code, tstrerror(code),
                      dataLen);
-      } else {
-        QW_SET_EVENT_RECEIVED(ctx, QW_EVENT_FETCH);
       }
-    } else {
-      QW_UNLOCK(QW_WRITE, &ctx->lock);
-    }
+    } 
+    
+    QW_UNLOCK(QW_WRITE, &ctx->lock);
   }
 
   return TSDB_CODE_SUCCESS;

From fe9df727f35ead1e7b6b97af06a6cc1d906a477d Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Fri, 14 Apr 2023 09:15:14 +0800
Subject: [PATCH 16/44] fix: fetch rsp message type issue

---
 source/libs/qworker/inc/qwInt.h   |  3 ++-
 source/libs/qworker/src/qwDbg.c   |  8 ++++----
 source/libs/qworker/src/qworker.c | 16 ++++++++--------
 3 files changed, 14 insertions(+), 13 deletions(-)

diff --git a/source/libs/qworker/inc/qwInt.h b/source/libs/qworker/inc/qwInt.h
index f198b73c7d..4bc357d7dd 100644
--- a/source/libs/qworker/inc/qwInt.h
+++ b/source/libs/qworker/inc/qwInt.h
@@ -120,7 +120,8 @@ typedef struct SQWTaskCtx {
   int8_t   explain;
   int8_t   needFetch;
   int8_t   localExec;
-  int32_t  msgType;
+  int32_t  queryMsgType;
+  int32_t  fetchMsgType;
   int32_t  level;
   uint64_t sId;
 
diff --git a/source/libs/qworker/src/qwDbg.c b/source/libs/qworker/src/qwDbg.c
index 59e63e9eae..f2e48918ab 100644
--- a/source/libs/qworker/src/qwDbg.c
+++ b/source/libs/qworker/src/qwDbg.c
@@ -126,10 +126,10 @@ void qwDbgDumpTasksInfo(SQWorker *mgmt) {
     void       *key = taosHashGetKey(pIter, NULL);
     QW_GET_QTID(key, qId, tId, eId);
     
-    QW_TASK_DLOG("%p lock:%x, phase:%d, type:%d, explain:%d, needFetch:%d, localExec:%d, msgType:%d, "
+    QW_TASK_DLOG("%p lock:%x, phase:%d, type:%d, explain:%d, needFetch:%d, localExec:%d, queryMsgType:%d, "
       "sId:%" PRId64 ", level:%d, queryGotData:%d, queryRsped:%d, queryEnd:%d, queryContinue:%d, queryInQueue:%d, "
       "rspCode:%x, affectedRows:%" PRId64 ", taskHandle:%p, sinkHandle:%p, tbFName:%s, sver:%d, tver:%d, events:%d,%d,%d,%d,%d",
-      ctx, ctx->lock, ctx->phase, ctx->taskType, ctx->explain, ctx->needFetch, ctx->localExec, ctx->msgType,
+      ctx, ctx->lock, ctx->phase, ctx->taskType, ctx->explain, ctx->needFetch, ctx->localExec, ctx->queryMsgType,
       ctx->sId, ctx->level, ctx->queryGotData, ctx->queryRsped, ctx->queryEnd, ctx->queryContinue, 
       ctx->queryInQueue, ctx->rspCode, ctx->affectedRows, ctx->taskHandle, ctx->sinkHandle, ctx->tbInfo.tbFName,
       ctx->tbInfo.sversion, ctx->tbInfo.tversion, ctx->events[QW_EVENT_CANCEL], ctx->events[QW_EVENT_READY], 
@@ -259,9 +259,9 @@ void qwDbgSimulateDead(QW_FPARAMS_DEF, SQWTaskCtx *ctx, bool *rsped) {
   static int32_t ignoreTime = 0;
 
   if (++ignoreTime > 10 && 0 == taosRand() % 9) {
-    if (ctx->msgType == TDMT_SCH_FETCH) {
+    if (ctx->fetchMsgType == TDMT_SCH_FETCH) {
       qwBuildAndSendErrorRsp(TDMT_SCH_LINK_BROKEN, &ctx->ctrlConnInfo, TSDB_CODE_RPC_BROKEN_LINK);
-      qwBuildAndSendErrorRsp(ctx->msgType + 1, &ctx->dataConnInfo, TSDB_CODE_QRY_TASK_CTX_NOT_EXIST);
+      qwBuildAndSendErrorRsp(ctx->fetchMsgType + 1, &ctx->dataConnInfo, TSDB_CODE_QRY_TASK_CTX_NOT_EXIST);
       *rsped = true;
       
       taosSsleep(3);
diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c
index f92f31fb1c..533575a62f 100644
--- a/source/libs/qworker/src/qworker.c
+++ b/source/libs/qworker/src/qworker.c
@@ -464,7 +464,7 @@ int32_t qwQuickRspFetchReq(QW_FPARAMS_DEF, SQWTaskCtx    * ctx, SQWMsg *qwMsg, i
         qwMsg->connInfo = ctx->dataConnInfo;
         QW_SET_EVENT_PROCESSED(ctx, QW_EVENT_FETCH);
 
-        qwBuildAndSendFetchRsp(ctx->msgType + 1, &qwMsg->connInfo, rsp, dataLen, code);
+        qwBuildAndSendFetchRsp(ctx->fetchMsgType + 1, &qwMsg->connInfo, rsp, dataLen, code);
         rsp = NULL;
 
         QW_TASK_DLOG("fetch rsp send, handle:%p, code:%x - %s, dataLen:%d", qwMsg->connInfo.handle, code, tstrerror(code),
@@ -626,7 +626,7 @@ _return:
 
   if (QW_PHASE_POST_QUERY == phase && ctx && !ctx->queryRsped) {
     bool   rsped = false;
-    SQWMsg qwMsg = {.msgType = ctx->msgType, .connInfo = ctx->ctrlConnInfo};
+    SQWMsg qwMsg = {.msgType = ctx->queryMsgType, .connInfo = ctx->ctrlConnInfo};
     qwDbgSimulateRedirect(&qwMsg, ctx, &rsped);
     qwDbgSimulateDead(QW_FPARAMS(), ctx, &rsped);
     if (!rsped) {
@@ -704,7 +704,7 @@ int32_t qwProcessQuery(QW_FPARAMS_DEF, SQWMsg *qwMsg, char *sql) {
   ctx->taskType = qwMsg->msgInfo.taskType;
   ctx->explain = qwMsg->msgInfo.explain;
   ctx->needFetch = qwMsg->msgInfo.needFetch;
-  ctx->msgType = qwMsg->msgType;
+  ctx->queryMsgType = qwMsg->msgType;
   ctx->localExec = false;
 
   // QW_TASK_DLOGL("subplan json string, len:%d, %s", qwMsg->msgLen, qwMsg->msg);
@@ -793,7 +793,7 @@ int32_t qwProcessCQuery(QW_FPARAMS_DEF, SQWMsg *qwMsg) {
         qwMsg->connInfo = ctx->dataConnInfo;
         QW_SET_EVENT_PROCESSED(ctx, QW_EVENT_FETCH);
 
-        qwBuildAndSendFetchRsp(ctx->msgType + 1, &qwMsg->connInfo, rsp, dataLen, code);
+        qwBuildAndSendFetchRsp(ctx->fetchMsgType + 1, &qwMsg->connInfo, rsp, dataLen, code);
         rsp = NULL;
 
         QW_TASK_DLOG("fetch rsp send, handle:%p, code:%x - %s, dataLen:%d", qwMsg->connInfo.handle, code,
@@ -815,7 +815,7 @@ int32_t qwProcessCQuery(QW_FPARAMS_DEF, SQWMsg *qwMsg) {
       rsp = NULL;
 
       qwMsg->connInfo = ctx->dataConnInfo;
-      qwBuildAndSendFetchRsp(ctx->msgType + 1, &qwMsg->connInfo, NULL, 0, code);
+      qwBuildAndSendFetchRsp(ctx->fetchMsgType + 1, &qwMsg->connInfo, NULL, 0, code);
       QW_TASK_DLOG("fetch rsp send, handle:%p, code:%x - %s, dataLen:%d", qwMsg->connInfo.handle, code, tstrerror(code),
                    0);
     }
@@ -849,7 +849,7 @@ int32_t qwProcessFetch(QW_FPARAMS_DEF, SQWMsg *qwMsg) {
 
   QW_ERR_JRET(qwGetTaskCtx(QW_FPARAMS(), &ctx));
 
-  ctx->msgType = qwMsg->msgType;
+  ctx->fetchMsgType = qwMsg->msgType;
   ctx->dataConnInfo = qwMsg->connInfo;
 
   SOutputData sOutput = {0};
@@ -1328,7 +1328,7 @@ int32_t qWorkerProcessLocalQuery(void *pMgmt, uint64_t sId, uint64_t qId, uint64
   ctx->taskType = qwMsg->msgInfo.taskType;
   ctx->explain = qwMsg->msgInfo.explain;
   ctx->needFetch = qwMsg->msgInfo.needFetch;
-  ctx->msgType = qwMsg->msgType;
+  ctx->queryMsgType = qwMsg->msgType;
   ctx->localExec = true;
   ctx->explainRes = explainRes;
 
@@ -1383,7 +1383,7 @@ int32_t qWorkerProcessLocalFetch(void *pMgmt, uint64_t sId, uint64_t qId, uint64
 
   QW_ERR_JRET(qwGetTaskCtx(QW_FPARAMS(), &ctx));
 
-  ctx->msgType = TDMT_SCH_MERGE_FETCH;
+  ctx->fetchMsgType = TDMT_SCH_MERGE_FETCH;
   ctx->explainRes = explainRes;
 
   SOutputData sOutput = {0};

From 9f78c22fb5a338c7b1f93bb4d502e861912fb041 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Fri, 14 Apr 2023 10:08:40 +0800
Subject: [PATCH 17/44] fix: quick rsp issue

---
 source/libs/qworker/src/qworker.c | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c
index 533575a62f..7b5d85a6f5 100644
--- a/source/libs/qworker/src/qworker.c
+++ b/source/libs/qworker/src/qworker.c
@@ -442,14 +442,11 @@ int32_t qwGetDeleteResFromSink(QW_FPARAMS_DEF, SQWTaskCtx *ctx, SDeleteRes *pRes
 
 int32_t qwQuickRspFetchReq(QW_FPARAMS_DEF, SQWTaskCtx    * ctx, SQWMsg *qwMsg, int32_t code) {
   if (QUERY_RSP_POLICY_QUICK == tsQueryRspPolicy && ctx != NULL) {
-    QW_LOCK(QW_WRITE, &ctx->lock);
-    
     if (QW_EVENT_RECEIVED(ctx, QW_EVENT_FETCH)) {
       void       *rsp = NULL;
       int32_t     dataLen = 0;
       SOutputData sOutput = {0};
       if (qwGetQueryResFromSink(QW_FPARAMS(), ctx, &dataLen, &rsp, &sOutput)) {
-        QW_UNLOCK(QW_WRITE, &ctx->lock);
         return TSDB_CODE_SUCCESS;
       }
 
@@ -471,8 +468,6 @@ int32_t qwQuickRspFetchReq(QW_FPARAMS_DEF, SQWTaskCtx    * ctx, SQWMsg *qwMsg, i
                      dataLen);
       }
     } 
-    
-    QW_UNLOCK(QW_WRITE, &ctx->lock);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -916,7 +911,7 @@ _return:
       rsp = NULL;
     }
   } else {    
-    qwQuickRspFetchReq(QW_FPARAMS(), ctx, qwMsg, code);
+    //qwQuickRspFetchReq(QW_FPARAMS(), ctx, qwMsg, code);
   }
 
   QW_RET(TSDB_CODE_SUCCESS);

From 423ec923ca175b8a2b541f89d5be9d4fccabe866 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Fri, 14 Apr 2023 14:30:20 +0800
Subject: [PATCH 18/44] enh: reuse tsdb cache reader

---
 source/dnode/vnode/inc/vnode.h               |  1 +
 source/dnode/vnode/src/tsdb/tsdbCacheRead.c  | 12 ++++++++++
 source/libs/executor/src/cachescanoperator.c | 23 ++++++++++++--------
 3 files changed, 27 insertions(+), 9 deletions(-)

diff --git a/source/dnode/vnode/inc/vnode.h b/source/dnode/vnode/inc/vnode.h
index a9e5fe628b..151a501386 100644
--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@@ -193,6 +193,7 @@ void        *tsdbGetIdx(SMeta *pMeta);
 void        *tsdbGetIvtIdx(SMeta *pMeta);
 uint64_t     getReaderMaxVersion(STsdbReader *pReader);
 
+int32_t tsdbReuseCacherowsReader(void* pReader, void* pTableIdList, int32_t numOfTables);
 int32_t tsdbCacherowsReaderOpen(void *pVnode, int32_t type, void *pTableIdList, int32_t numOfTables, int32_t numOfCols,
                                 uint64_t suid, void **pReader, const char *idstr);
 int32_t tsdbRetrieveCacheRows(void *pReader, SSDataBlock *pResBlock, const int32_t *slotIds, SArray *pTableUids);
diff --git a/source/dnode/vnode/src/tsdb/tsdbCacheRead.c b/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
index 95981c2f08..f1c257e6a5 100644
--- a/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbCacheRead.c
@@ -142,6 +142,18 @@ static int32_t setTableSchema(SCacheRowsReader* p, uint64_t suid, const char* id
   return TSDB_CODE_SUCCESS;
 }
 
+int32_t tsdbReuseCacherowsReader(void* reader, void* pTableIdList, int32_t numOfTables) {
+  SCacheRowsReader* pReader = (SCacheRowsReader*)reader;
+
+  pReader->pTableList = pTableIdList;
+  pReader->numOfTables = numOfTables;
+  pReader->lastTs = INT64_MIN;
+
+  resetLastBlockLoadInfo(pReader->pLoadInfo);
+
+  return TSDB_CODE_SUCCESS;
+}
+
 int32_t tsdbCacherowsReaderOpen(void* pVnode, int32_t type, void* pTableIdList, int32_t numOfTables, int32_t numOfCols,
                                 uint64_t suid, void** pReader, const char* idstr) {
   *pReader = NULL;
diff --git a/source/libs/executor/src/cachescanoperator.c b/source/libs/executor/src/cachescanoperator.c
index f6fc332b37..d0f7cb08f7 100644
--- a/source/libs/executor/src/cachescanoperator.c
+++ b/source/libs/executor/src/cachescanoperator.c
@@ -224,13 +224,17 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) {
         T_LONG_JMP(pTaskInfo->env, code);
       }
 
-      code = tsdbCacherowsReaderOpen(pInfo->readHandle.vnode, pInfo->retrieveType, pList, num,
-                                     taosArrayGetSize(pInfo->matchInfo.pList), suid, &pInfo->pLastrowReader,
-                                     pTaskInfo->id.str);
-      if (code != TSDB_CODE_SUCCESS) {
-        pInfo->currentGroupIndex += 1;
-        taosArrayClear(pInfo->pUidList);
-        continue;
+      if (NULL == pInfo->pLastrowReader) {
+        code = tsdbCacherowsReaderOpen(pInfo->readHandle.vnode, pInfo->retrieveType, pList, num,
+                                       taosArrayGetSize(pInfo->matchInfo.pList), suid, &pInfo->pLastrowReader,
+                                       pTaskInfo->id.str);
+        if (code != TSDB_CODE_SUCCESS) {
+          pInfo->currentGroupIndex += 1;
+          taosArrayClear(pInfo->pUidList);
+          continue;
+        }
+      } else {
+        tsdbReuseCacherowsReader(pInfo->pLastrowReader, pList, num);
       }
 
       taosArrayClear(pInfo->pUidList);
@@ -263,13 +267,14 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) {
           }
         }
 
-        pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader);
+        //pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader);
         return pInfo->pRes;
       } else {
-        pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader);
+        //pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader);
       }
     }
 
+    pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader);
     setOperatorCompleted(pOperator);
     return NULL;
   }

From dab59ec8ae9813f528c6e95a44b86578fa0fa71a Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Fri, 14 Apr 2023 16:18:02 +0800
Subject: [PATCH 19/44] fix: add debug info

---
 source/client/src/clientEnv.c      | 2 +-
 source/libs/scheduler/src/schJob.c | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/client/src/clientEnv.c b/source/client/src/clientEnv.c
index 1d63955060..33c50d9aca 100644
--- a/source/client/src/clientEnv.c
+++ b/source/client/src/clientEnv.c
@@ -96,7 +96,7 @@ static void deregisterRequest(SRequestObj *pRequest) {
                pRequest->metric.planCostUs, pRequest->metric.execCostUs);
       atomic_add_fetch_64((int64_t *)&pActivity->insertElapsedTime, duration);
     } else if (QUERY_NODE_SELECT_STMT == pRequest->stmtType) {
-      tscDebug("query duration %" PRId64 "us: parseCost:%" PRId64 "us, ctgCost:%" PRId64 "us, analyseCost:%" PRId64
+      tscError("query duration %" PRId64 "us: parseCost:%" PRId64 "us, ctgCost:%" PRId64 "us, analyseCost:%" PRId64
                "us, planCost:%" PRId64 "us, exec:%" PRId64 "us",
                duration, pRequest->metric.parseCostUs, pRequest->metric.ctgCostUs, pRequest->metric.analyseCostUs,
                pRequest->metric.planCostUs, pRequest->metric.execCostUs);
diff --git a/source/libs/scheduler/src/schJob.c b/source/libs/scheduler/src/schJob.c
index b8269eb3cb..ce030ecdf7 100644
--- a/source/libs/scheduler/src/schJob.c
+++ b/source/libs/scheduler/src/schJob.c
@@ -440,7 +440,7 @@ int32_t schNotifyUserExecRes(SSchJob *pJob) {
     schDumpJobExecRes(pJob, pRes);
   }
 
-  SCH_JOB_DLOG("sch start to invoke exec cb, code: %s", tstrerror(pJob->errCode));
+  SCH_JOB_ELOG("sch start to invoke exec cb, code: %s", tstrerror(pJob->errCode));
   (*pJob->userRes.execFp)(pRes, pJob->userRes.cbParam, atomic_load_32(&pJob->errCode));
   SCH_JOB_DLOG("sch end from exec cb, code: %s", tstrerror(pJob->errCode));
 

From 4506813ddb24f3cb68f285e00d8df06a754fd11f Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Mon, 17 Apr 2023 15:14:06 +0800
Subject: [PATCH 20/44] enh: add group cache

---
 source/libs/executor/src/executil.c  | 52 ++++++++++++++++++++--------
 source/libs/transport/src/transCli.c |  2 +-
 2 files changed, 38 insertions(+), 16 deletions(-)

diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index afd742fb6d..f782add971 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -430,12 +430,32 @@ void freeItem(void* p) {
   }
 }
 
+
+static void genTagFilterDigest(const SNode* pTagCond, T_MD5_CTX* pContext) {
+  if (pTagCond == NULL) {
+    return;
+  }
+
+  char*   payload = NULL;
+  int32_t len = 0;
+  nodesNodeToMsg(pTagCond, &payload, &len);
+
+  tMD5Init(pContext);
+  tMD5Update(pContext, (uint8_t*)payload, (uint32_t)len);
+  tMD5Final(pContext);
+
+  taosMemoryFree(payload);
+}
+
+
 int32_t getColInfoResultForGroupby(void* metaHandle, SNodeList* group, STableListInfo* pTableListInfo) {
   int32_t      code = TSDB_CODE_SUCCESS;
   SArray*      pBlockList = NULL;
   SSDataBlock* pResBlock = NULL;
   void*        keyBuf = NULL;
   SArray*      groupData = NULL;
+  static T_MD5_CTX lastMd5 = {0};
+  static SArray*   lastTableList = NULL;
 
   int32_t rows = taosArrayGetSize(pTableListInfo->pTableList);
   if (rows == 0) {
@@ -462,6 +482,17 @@ int32_t getColInfoResultForGroupby(void* metaHandle, SNodeList* group, STableLis
     REPLACE_NODE(pNode);
   }
 
+  T_MD5_CTX context = {0};
+  if (lastTableList) {
+    SNodeListNode* listNode = (SNodeListNode*)nodesMakeNode(QUERY_NODE_NODE_LIST);
+    listNode->pNodeList = group;
+    genTagFilterDigest((SNode *)listNode, &context);
+    if (0 == memcmp(context.digest, lastMd5.digest, sizeof(lastMd5.digest)) && (taosArrayGetSize(pTableListInfo->pTableList) == taosArrayGetSize(lastTableList))) {
+      pTableListInfo->pTableList = taosArrayDup(lastTableList, NULL);
+      goto end;
+    }
+  }
+  
   SArray* pUidTagList = taosArrayInit(8, sizeof(STUidTagInfo));
   for (int32_t i = 0; i < rows; ++i) {
     STableKeyInfo* pkeyInfo = taosArrayGet(pTableListInfo->pTableList, i);
@@ -588,6 +619,12 @@ int32_t getColInfoResultForGroupby(void* metaHandle, SNodeList* group, STableLis
     info->groupId = calcGroupId(keyBuf, len);
   }
 
+  if (memcmp(context.digest, lastMd5.digest, sizeof(lastMd5.digest))) {
+    memcpy(&lastMd5.digest, &context.digest, sizeof(context.digest));
+    taosArrayDestroy(lastTableList);
+    lastTableList = taosArrayDup(pTableListInfo->pTableList, NULL);
+  }
+
   //  int64_t st2 = taosGetTimestampUs();
   //  qDebug("calculate tag block rows:%d, cost:%ld us", rows, st2-st1);
 
@@ -792,21 +829,6 @@ static int32_t optimizeTbnameInCondImpl(void* metaHandle, SArray* pExistedUidLis
   return -1;
 }
 
-static void genTagFilterDigest(const SNode* pTagCond, T_MD5_CTX* pContext) {
-  if (pTagCond == NULL) {
-    return;
-  }
-
-  char*   payload = NULL;
-  int32_t len = 0;
-  nodesNodeToMsg(pTagCond, &payload, &len);
-
-  tMD5Init(pContext);
-  tMD5Update(pContext, (uint8_t*)payload, (uint32_t)len);
-  tMD5Final(pContext);
-
-  taosMemoryFree(payload);
-}
 
 static SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, SArray* pUidTagList,
                                                void* metaHandle) {
diff --git a/source/libs/transport/src/transCli.c b/source/libs/transport/src/transCli.c
index add700c024..73d611a8a7 100644
--- a/source/libs/transport/src/transCli.c
+++ b/source/libs/transport/src/transCli.c
@@ -965,7 +965,7 @@ static void cliSendCb(uv_write_t* req, int status) {
   }
 
   if (status == 0) {
-    tTrace("%s conn %p data already was written out", CONN_GET_INST_LABEL(pConn), pConn);
+    tError("%s conn %p data already was written out", CONN_GET_INST_LABEL(pConn), pConn);
   } else {
     if (!uv_is_closing((uv_handle_t*)&pConn->stream)) {
       tError("%s conn %p failed to write:%s", CONN_GET_INST_LABEL(pConn), pConn, uv_err_name(status));

From 31d187444e7b009d3ef17c05f188e77e5493d7f0 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Mon, 17 Apr 2023 15:33:54 +0800
Subject: [PATCH 21/44] fix: grou cache issue

---
 source/libs/executor/src/executil.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index f782add971..dc244acb40 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -454,7 +454,7 @@ int32_t getColInfoResultForGroupby(void* metaHandle, SNodeList* group, STableLis
   SSDataBlock* pResBlock = NULL;
   void*        keyBuf = NULL;
   SArray*      groupData = NULL;
-  static T_MD5_CTX lastMd5 = {0};
+  static T_MD5_CTX lastMd5 = {-1};
   static SArray*   lastTableList = NULL;
 
   int32_t rows = taosArrayGetSize(pTableListInfo->pTableList);
@@ -483,14 +483,14 @@ int32_t getColInfoResultForGroupby(void* metaHandle, SNodeList* group, STableLis
   }
 
   T_MD5_CTX context = {0};
-  if (lastTableList) {
-    SNodeListNode* listNode = (SNodeListNode*)nodesMakeNode(QUERY_NODE_NODE_LIST);
-    listNode->pNodeList = group;
-    genTagFilterDigest((SNode *)listNode, &context);
-    if (0 == memcmp(context.digest, lastMd5.digest, sizeof(lastMd5.digest)) && (taosArrayGetSize(pTableListInfo->pTableList) == taosArrayGetSize(lastTableList))) {
-      pTableListInfo->pTableList = taosArrayDup(lastTableList, NULL);
-      goto end;
-    }
+  SNodeListNode* listNode = (SNodeListNode*)nodesMakeNode(QUERY_NODE_NODE_LIST);
+  listNode->pNodeList = group;
+  genTagFilterDigest((SNode *)listNode, &context);
+  taosMemoryFree(listNode);
+
+  if (lastTableList && (0 == memcmp(context.digest, lastMd5.digest, sizeof(lastMd5.digest)) && (taosArrayGetSize(pTableListInfo->pTableList) == taosArrayGetSize(lastTableList)))) {
+    pTableListInfo->pTableList = taosArrayDup(lastTableList, NULL);
+    goto end;
   }
   
   SArray* pUidTagList = taosArrayInit(8, sizeof(STUidTagInfo));

From ed3778dc9f11cd4dc6613303e06309bb05442eba Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Mon, 17 Apr 2023 15:44:15 +0800
Subject: [PATCH 22/44] fix: nodes free issue

---
 include/libs/nodes/nodes.h             | 1 +
 source/libs/executor/src/executil.c    | 2 +-
 source/libs/nodes/src/nodesUtilFuncs.c | 2 +-
 3 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/include/libs/nodes/nodes.h b/include/libs/nodes/nodes.h
index a2e4c76adc..f8d6f1dcf9 100644
--- a/include/libs/nodes/nodes.h
+++ b/include/libs/nodes/nodes.h
@@ -306,6 +306,7 @@ void    nodesDestroyAllocator(int64_t allocatorId);
 
 SNode* nodesMakeNode(ENodeType type);
 void   nodesDestroyNode(SNode* pNode);
+void   nodesFree(void* p);
 
 SNodeList* nodesMakeList();
 int32_t    nodesListAppend(SNodeList* pList, SNode* pNode);
diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index dc244acb40..2716f7fd7d 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -486,7 +486,7 @@ int32_t getColInfoResultForGroupby(void* metaHandle, SNodeList* group, STableLis
   SNodeListNode* listNode = (SNodeListNode*)nodesMakeNode(QUERY_NODE_NODE_LIST);
   listNode->pNodeList = group;
   genTagFilterDigest((SNode *)listNode, &context);
-  taosMemoryFree(listNode);
+  nodesFree(listNode);
 
   if (lastTableList && (0 == memcmp(context.digest, lastMd5.digest, sizeof(lastMd5.digest)) && (taosArrayGetSize(pTableListInfo->pTableList) == taosArrayGetSize(lastTableList)))) {
     pTableListInfo->pTableList = taosArrayDup(lastTableList, NULL);
diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c
index eff69e9764..35860196e4 100644
--- a/source/libs/nodes/src/nodesUtilFuncs.c
+++ b/source/libs/nodes/src/nodesUtilFuncs.c
@@ -87,7 +87,7 @@ static void* nodesCalloc(int32_t num, int32_t size) {
   return (char*)p + 1;
 }
 
-static void nodesFree(void* p) {
+void nodesFree(void* p) {
   char* ptr = (char*)p - 1;
   if (0 == *ptr) {
     taosMemoryFree(ptr);

From 20c9cea5f0b20a2b88d45f122c3c05c475601394 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Mon, 17 Apr 2023 15:50:25 +0800
Subject: [PATCH 23/44] fix: free uid list issue

---
 source/libs/executor/src/executil.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index 2716f7fd7d..27ac8e4076 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -454,6 +454,7 @@ int32_t getColInfoResultForGroupby(void* metaHandle, SNodeList* group, STableLis
   SSDataBlock* pResBlock = NULL;
   void*        keyBuf = NULL;
   SArray*      groupData = NULL;
+  SArray*      pUidTagList = NULL;
   static T_MD5_CTX lastMd5 = {-1};
   static SArray*   lastTableList = NULL;
 
@@ -493,7 +494,7 @@ int32_t getColInfoResultForGroupby(void* metaHandle, SNodeList* group, STableLis
     goto end;
   }
   
-  SArray* pUidTagList = taosArrayInit(8, sizeof(STUidTagInfo));
+  pUidTagList = taosArrayInit(8, sizeof(STUidTagInfo));
   for (int32_t i = 0; i < rows; ++i) {
     STableKeyInfo* pkeyInfo = taosArrayGet(pTableListInfo->pTableList, i);
     STUidTagInfo   info = {.uid = pkeyInfo->uid};

From bd71cb887086b43e345336e7db885963c93ae078 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Mon, 17 Apr 2023 16:09:54 +0800
Subject: [PATCH 24/44] fix: group cache save issue

---
 source/libs/executor/src/executil.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index 27ac8e4076..bbda0d2513 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -492,6 +492,8 @@ int32_t getColInfoResultForGroupby(void* metaHandle, SNodeList* group, STableLis
   if (lastTableList && (0 == memcmp(context.digest, lastMd5.digest, sizeof(lastMd5.digest)) && (taosArrayGetSize(pTableListInfo->pTableList) == taosArrayGetSize(lastTableList)))) {
     pTableListInfo->pTableList = taosArrayDup(lastTableList, NULL);
     goto end;
+  } else {
+    qError("group not hit, last:%p, lastSize:%d, newSize:%d", lastTableList, (int32_t)taosArrayGetSize(lastTableList), (int32_t)taosArrayGetSize(pTableListInfo->pTableList));
   }
   
   pUidTagList = taosArrayInit(8, sizeof(STUidTagInfo));
@@ -620,11 +622,9 @@ int32_t getColInfoResultForGroupby(void* metaHandle, SNodeList* group, STableLis
     info->groupId = calcGroupId(keyBuf, len);
   }
 
-  if (memcmp(context.digest, lastMd5.digest, sizeof(lastMd5.digest))) {
-    memcpy(&lastMd5.digest, &context.digest, sizeof(context.digest));
-    taosArrayDestroy(lastTableList);
-    lastTableList = taosArrayDup(pTableListInfo->pTableList, NULL);
-  }
+  memcpy(&lastMd5.digest, &context.digest, sizeof(context.digest));
+  taosArrayDestroy(lastTableList);
+  lastTableList = taosArrayDup(pTableListInfo->pTableList, NULL);
 
   //  int64_t st2 = taosGetTimestampUs();
   //  qDebug("calculate tag block rows:%d, cost:%ld us", rows, st2-st1);

From 8ef7fa9bf8703d449da103979f37a3b576c0b6c7 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Mon, 17 Apr 2023 16:33:55 +0800
Subject: [PATCH 25/44] fix: add group cache hash

---
 source/libs/executor/src/executil.c | 22 +++++++++++++++-------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index bbda0d2513..f279a19c83 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -448,7 +448,7 @@ static void genTagFilterDigest(const SNode* pTagCond, T_MD5_CTX* pContext) {
 }
 
 
-int32_t getColInfoResultForGroupby(void* metaHandle, SNodeList* group, STableListInfo* pTableListInfo) {
+int32_t getColInfoResultForGroupby(void* metaHandle, uint64_t suid, SNodeList* group, STableListInfo* pTableListInfo) {
   int32_t      code = TSDB_CODE_SUCCESS;
   SArray*      pBlockList = NULL;
   SSDataBlock* pResBlock = NULL;
@@ -457,6 +457,7 @@ int32_t getColInfoResultForGroupby(void* metaHandle, SNodeList* group, STableLis
   SArray*      pUidTagList = NULL;
   static T_MD5_CTX lastMd5 = {-1};
   static SArray*   lastTableList = NULL;
+  static SHashObj *pTableListHash = NULL;
 
   int32_t rows = taosArrayGetSize(pTableListInfo->pTableList);
   if (rows == 0) {
@@ -489,7 +490,8 @@ int32_t getColInfoResultForGroupby(void* metaHandle, SNodeList* group, STableLis
   genTagFilterDigest((SNode *)listNode, &context);
   nodesFree(listNode);
 
-  if (lastTableList && (0 == memcmp(context.digest, lastMd5.digest, sizeof(lastMd5.digest)) && (taosArrayGetSize(pTableListInfo->pTableList) == taosArrayGetSize(lastTableList)))) {
+  SArray **pLastTableList = (SArray **)taosHashGet(pTableListHash, context.digest, sizeof(context.digest));
+  if (pLastTableList && *pLastTableList) {
     pTableListInfo->pTableList = taosArrayDup(lastTableList, NULL);
     goto end;
   } else {
@@ -622,9 +624,15 @@ int32_t getColInfoResultForGroupby(void* metaHandle, SNodeList* group, STableLis
     info->groupId = calcGroupId(keyBuf, len);
   }
 
-  memcpy(&lastMd5.digest, &context.digest, sizeof(context.digest));
-  taosArrayDestroy(lastTableList);
+  if (NULL == pTableListHash) {
+    SHashObj *pHash = taosHashInit(10, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
+    if (atomic_val_compare_exchange_ptr(&pTableListHash, NULL, pHash)) {
+      taosHashCleanup(pHash);
+    }
+  }
+  
   lastTableList = taosArrayDup(pTableListInfo->pTableList, NULL);
+  taosHashPut(pTableListHash, context.digest, sizeof(context.digest), &lastTableList, POINTER_BYTES);
 
   //  int64_t st2 = taosGetTimestampUs();
   //  qDebug("calculate tag block rows:%d, cost:%ld us", rows, st2-st1);
@@ -2001,7 +2009,7 @@ static int32_t sortTableGroup(STableListInfo* pTableListInfo) {
   return TDB_CODE_SUCCESS;
 }
 
-int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle* pHandle, SNodeList* group,
+int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle* pHandle, SScanPhysiNode* pScanNode, SNodeList* group,
                                     bool groupSort) {
   int32_t code = TSDB_CODE_SUCCESS;
 
@@ -2022,7 +2030,7 @@ int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle*
       pTableListInfo->numOfOuputGroups = 1;
     }
   } else {
-    code = getColInfoResultForGroupby(pHandle->meta, group, pTableListInfo);
+    code = getColInfoResultForGroupby(pHandle->meta, pScanNode->suid, group, pTableListInfo);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
     }
@@ -2071,7 +2079,7 @@ int32_t createScanTableListInfo(SScanPhysiNode* pScanNode, SNodeList* pGroupTags
     return TSDB_CODE_SUCCESS;
   }
 
-  code = buildGroupIdMapForAllTables(pTableListInfo, pHandle, pGroupTags, groupSort);
+  code = buildGroupIdMapForAllTables(pTableListInfo, pHandle, pScanNode, pGroupTags, groupSort);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }

From 5becc19c3cc1e4fefa9d0c466f231d1d7f0b40ac Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Tue, 18 Apr 2023 11:40:20 +0800
Subject: [PATCH 26/44] fix: add debug info

---
 source/libs/executor/src/projectoperator.c    | 10 ++++++++++
 source/libs/executor/src/timewindowoperator.c |  6 ++++++
 2 files changed, 16 insertions(+)

diff --git a/source/libs/executor/src/projectoperator.c b/source/libs/executor/src/projectoperator.c
index 86c49e0fc8..811bcbe0b5 100644
--- a/source/libs/executor/src/projectoperator.c
+++ b/source/libs/executor/src/projectoperator.c
@@ -247,6 +247,9 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) {
     return doGenerateSourceData(pOperator);
   }
 
+  int64_t st0 = taosGetTimestampUs();
+  int64_t st1 = 0, st2 = 0;
+
   while (1) {
     while (1) {
       blockDataCleanup(pRes);
@@ -258,6 +261,7 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) {
         setOperatorCompleted(pOperator);
         break;
       }
+      st1 = taosGetTimestampUs();
 //      if (pTaskInfo->execModel == OPTR_EXEC_MODEL_QUEUE) {
 //        qDebug("set status recv");
 //        pOperator->status = OP_EXEC_RECV;
@@ -299,6 +303,8 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) {
         continue;
       }
 
+      st2 = taosGetTimestampUs();
+
       break;
     }
 
@@ -344,6 +350,10 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) {
     pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0;
   }
 
+  if (p->info.rows > 0) {
+    qError("doProjection, open:%" PRId64 "us, project:%" PRId64 "us, rows:%" PRId64,st1-st0,st2-st1,p->info.rows);
+  }
+
   return (p->info.rows > 0) ? p : NULL;
 }
 
diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c
index 1a1fb6208d..e115090be7 100644
--- a/source/libs/executor/src/timewindowoperator.c
+++ b/source/libs/executor/src/timewindowoperator.c
@@ -1275,15 +1275,20 @@ static SSDataBlock* doBuildIntervalResult(SOperatorInfo* pOperator) {
     return NULL;
   }
 
+  int64_t st0 = taosGetTimestampUs();
   SSDataBlock* pBlock = pInfo->binfo.pRes;
   pTaskInfo->code = pOperator->fpSet._openFn(pOperator);
   if (pTaskInfo->code != TSDB_CODE_SUCCESS) {
     return NULL;
   }
+  int64_t st1 = taosGetTimestampUs();
+  int64_t st2 = 0, st3 = 0;
 
   while (1) {
     doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf);
+    st2 = taosGetTimestampUs();
     doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL);
+    st3 = taosGetTimestampUs();
 
     bool hasRemain = hasRemainResults(&pInfo->groupResInfo);
     if (!hasRemain) {
@@ -1292,6 +1297,7 @@ static SSDataBlock* doBuildIntervalResult(SOperatorInfo* pOperator) {
     }
 
     if (pBlock->info.rows > 0) {
+      qError("interval open:%" PRId64 "us, build:%" PRId64 "us, filter:%" PRId64 "us, rows:%" PRId64, st1-st0,st2-st1,st3-st2,pBlock->info.rows);
       break;
     }
   }

From ed34b401ee46c9183df818850c99bbfb8b961235 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Tue, 18 Apr 2023 13:44:41 +0800
Subject: [PATCH 27/44] fix: optimize decompress double

---
 source/util/src/tcompression.c | 27 ++++++++++++---------------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/source/util/src/tcompression.c b/source/util/src/tcompression.c
index 7631da1b56..58528a91ba 100644
--- a/source/util/src/tcompression.c
+++ b/source/util/src/tcompression.c
@@ -912,11 +912,11 @@ int32_t tsCompressDoubleImp(const char *const input, const int32_t nelements, ch
   return opos;
 }
 
-uint64_t decodeDoubleValue(const char *const input, int32_t *const ipos, uint8_t flag) {
+FORCE_INLINE uint64_t decodeDoubleValue(const char *const input, int32_t *const ipos, uint8_t flag) {
   uint64_t diff = 0ul;
-  int32_t  nbytes = (flag & INT8MASK(3)) + 1;
+  int32_t  nbytes = (flag & 0x7) + 1;
   for (int32_t i = 0; i < nbytes; i++) {
-    diff = diff | ((INT64MASK(8) & input[(*ipos)++]) << BITS_PER_BYTE * i);
+    diff |= ((0xffff & input[(*ipos)++]) << BITS_PER_BYTE * i);
   }
   int32_t shift_width = (LONG_BYTES * BITS_PER_BYTE - nbytes * BITS_PER_BYTE) * (flag >> 3);
   diff <<= shift_width;
@@ -936,25 +936,22 @@ int32_t tsDecompressDoubleImp(const char *const input, const int32_t nelements,
   uint8_t  flags = 0;
   int32_t  ipos = 1;
   int32_t  opos = 0;
-  uint64_t prev_value = 0;
+  uint64_t diff = 0;
+  union {
+    uint64_t bits;
+    double   real;
+  } curr;
+
+  curr.bits = 0;
 
   for (int32_t i = 0; i < nelements; i++) {
     if ((i & 0x01) == 0) {
       flags = input[ipos++];
     }
 
-    uint8_t flag = flags & INT8MASK(4);
+    diff = decodeDoubleValue(input, &ipos, flags & 0x0f);
     flags >>= 4;
-
-    uint64_t diff = decodeDoubleValue(input, &ipos, flag);
-    union {
-      uint64_t bits;
-      double   real;
-    } curr;
-
-    uint64_t predicted = prev_value;
-    curr.bits = predicted ^ diff;
-    prev_value = curr.bits;
+    curr.bits ^= diff;
 
     ostream[opos++] = curr.real;
   }

From 36f3e440961e8f2b8aa0fd6f2ed043917e87b84e Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Thu, 20 Apr 2023 17:51:41 +0800
Subject: [PATCH 28/44] enh: change tdb lock to rwlock

---
 source/libs/tdb/src/db/tdbPCache.c | 25 +++++++++++++++----------
 1 file changed, 15 insertions(+), 10 deletions(-)

diff --git a/source/libs/tdb/src/db/tdbPCache.c b/source/libs/tdb/src/db/tdbPCache.c
index 262f3d27e6..443e0b4575 100644
--- a/source/libs/tdb/src/db/tdbPCache.c
+++ b/source/libs/tdb/src/db/tdbPCache.c
@@ -21,7 +21,7 @@ struct SPCache {
   int         szPage;
   int         nPages;
   SPage     **aPage;
-  tdb_mutex_t mutex;
+  TdThreadRwlock rwLock;
   int         nFree;
   SPage      *pFree;
   int         nPage;
@@ -44,10 +44,11 @@ static void   tdbPCacheAddPageToHash(SPCache *pCache, SPage *pPage);
 static void   tdbPCacheUnpinPage(SPCache *pCache, SPage *pPage);
 static int    tdbPCacheCloseImpl(SPCache *pCache);
 
-static void tdbPCacheInitLock(SPCache *pCache) { tdbMutexInit(&(pCache->mutex), NULL); }
-static void tdbPCacheDestroyLock(SPCache *pCache) { tdbMutexDestroy(&(pCache->mutex)); }
-static void tdbPCacheLock(SPCache *pCache) { tdbMutexLock(&(pCache->mutex)); }
-static void tdbPCacheUnlock(SPCache *pCache) { tdbMutexUnlock(&(pCache->mutex)); }
+static void tdbPCacheInitLock(SPCache *pCache) { taosThreadRwlockInit(&(pCache->rwLock), NULL); }
+static void tdbPCacheDestroyLock(SPCache *pCache) { taosThreadRwlockDestroy(&(pCache->rwLock)); }
+static void tdbPCacheRLock(SPCache *pCache) { taosThreadRwlockRdlock(&(pCache->rwLock)); }
+static void tdbPCacheWLock(SPCache *pCache) { taosThreadRwlockWrlock(&(pCache->rwLock)); }
+static void tdbPCacheUnlock(SPCache *pCache) { taosThreadRwlockUnlock(&(pCache->rwLock)); }
 
 int tdbPCacheOpen(int pageSize, int cacheSize, SPCache **ppCache) {
   SPCache *pCache;
@@ -158,7 +159,7 @@ static int tdbPCacheAlterImpl(SPCache *pCache, int32_t nPage) {
 int tdbPCacheAlter(SPCache *pCache, int32_t nPage) {
   int ret = 0;
 
-  tdbPCacheLock(pCache);
+  tdbPCacheWLock(pCache);
 
   ret = tdbPCacheAlterImpl(pCache, nPage);
 
@@ -171,8 +172,6 @@ SPage *tdbPCacheFetch(SPCache *pCache, const SPgid *pPgid, TXN *pTxn) {
   SPage *pPage;
   i32    nRef = 0;
 
-  tdbPCacheLock(pCache);
-
   pPage = tdbPCacheFetchImpl(pCache, pPgid, pTxn);
   if (pPage) {
     nRef = tdbRefPage(pPage);
@@ -193,7 +192,7 @@ SPage *tdbPCacheFetch(SPCache *pCache, const SPgid *pPgid, TXN *pTxn) {
 }
 
 void tdbPCacheMarkFree(SPCache *pCache, SPage *pPage) {
-  tdbPCacheLock(pCache);
+  tdbPCacheWLock(pCache);
   tdbPCacheRemovePageFromHash(pCache, pPage);
   pPage->isFree = 1;
   tdbPCacheUnlock(pCache);
@@ -241,7 +240,7 @@ void tdbPCacheRelease(SPCache *pCache, SPage *pPage, TXN *pTxn) {
     return;
   }
 
-  tdbPCacheLock(pCache);
+  tdbPCacheWLock(pCache);
   nRef = tdbUnrefPage(pPage);
   tdbTrace("pcache/release page %p/%d/%d/%d", pPage, TDB_PAGE_PGNO(pPage), pPage->id, nRef);
   if (nRef == 0) {
@@ -275,6 +274,8 @@ static SPage *tdbPCacheFetchImpl(SPCache *pCache, const SPgid *pPgid, TXN *pTxn)
   SPage *pPage = NULL;
   SPage *pPageH = NULL;
 
+  tdbPCacheRLock(pCache);
+
   if (!pTxn) {
     tdbError("tdb/pcache: null ptr pTxn, fetch impl failed.");
     return NULL;
@@ -294,6 +295,10 @@ static SPage *tdbPCacheFetchImpl(SPCache *pCache, const SPgid *pPgid, TXN *pTxn)
     }
   }
 
+  tdbPCacheUnlock(pCache);
+
+  tdbPCacheWLock(pCache);
+
   // 1. pPage == NULL
   // 2. pPage && pPage->isLocal == 0 && !TDB_TXN_IS_WRITE(pTxn)
   pPageH = pPage;

From fa77356cc4982dd781353908b662fdbcb5b4ed44 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Thu, 20 Apr 2023 18:56:18 +0800
Subject: [PATCH 29/44] fix: restore tdb page cache lock

---
 source/libs/tdb/src/db/tdbPCache.c | 25 ++++++++++---------------
 1 file changed, 10 insertions(+), 15 deletions(-)

diff --git a/source/libs/tdb/src/db/tdbPCache.c b/source/libs/tdb/src/db/tdbPCache.c
index 443e0b4575..262f3d27e6 100644
--- a/source/libs/tdb/src/db/tdbPCache.c
+++ b/source/libs/tdb/src/db/tdbPCache.c
@@ -21,7 +21,7 @@ struct SPCache {
   int         szPage;
   int         nPages;
   SPage     **aPage;
-  TdThreadRwlock rwLock;
+  tdb_mutex_t mutex;
   int         nFree;
   SPage      *pFree;
   int         nPage;
@@ -44,11 +44,10 @@ static void   tdbPCacheAddPageToHash(SPCache *pCache, SPage *pPage);
 static void   tdbPCacheUnpinPage(SPCache *pCache, SPage *pPage);
 static int    tdbPCacheCloseImpl(SPCache *pCache);
 
-static void tdbPCacheInitLock(SPCache *pCache) { taosThreadRwlockInit(&(pCache->rwLock), NULL); }
-static void tdbPCacheDestroyLock(SPCache *pCache) { taosThreadRwlockDestroy(&(pCache->rwLock)); }
-static void tdbPCacheRLock(SPCache *pCache) { taosThreadRwlockRdlock(&(pCache->rwLock)); }
-static void tdbPCacheWLock(SPCache *pCache) { taosThreadRwlockWrlock(&(pCache->rwLock)); }
-static void tdbPCacheUnlock(SPCache *pCache) { taosThreadRwlockUnlock(&(pCache->rwLock)); }
+static void tdbPCacheInitLock(SPCache *pCache) { tdbMutexInit(&(pCache->mutex), NULL); }
+static void tdbPCacheDestroyLock(SPCache *pCache) { tdbMutexDestroy(&(pCache->mutex)); }
+static void tdbPCacheLock(SPCache *pCache) { tdbMutexLock(&(pCache->mutex)); }
+static void tdbPCacheUnlock(SPCache *pCache) { tdbMutexUnlock(&(pCache->mutex)); }
 
 int tdbPCacheOpen(int pageSize, int cacheSize, SPCache **ppCache) {
   SPCache *pCache;
@@ -159,7 +158,7 @@ static int tdbPCacheAlterImpl(SPCache *pCache, int32_t nPage) {
 int tdbPCacheAlter(SPCache *pCache, int32_t nPage) {
   int ret = 0;
 
-  tdbPCacheWLock(pCache);
+  tdbPCacheLock(pCache);
 
   ret = tdbPCacheAlterImpl(pCache, nPage);
 
@@ -172,6 +171,8 @@ SPage *tdbPCacheFetch(SPCache *pCache, const SPgid *pPgid, TXN *pTxn) {
   SPage *pPage;
   i32    nRef = 0;
 
+  tdbPCacheLock(pCache);
+
   pPage = tdbPCacheFetchImpl(pCache, pPgid, pTxn);
   if (pPage) {
     nRef = tdbRefPage(pPage);
@@ -192,7 +193,7 @@ SPage *tdbPCacheFetch(SPCache *pCache, const SPgid *pPgid, TXN *pTxn) {
 }
 
 void tdbPCacheMarkFree(SPCache *pCache, SPage *pPage) {
-  tdbPCacheWLock(pCache);
+  tdbPCacheLock(pCache);
   tdbPCacheRemovePageFromHash(pCache, pPage);
   pPage->isFree = 1;
   tdbPCacheUnlock(pCache);
@@ -240,7 +241,7 @@ void tdbPCacheRelease(SPCache *pCache, SPage *pPage, TXN *pTxn) {
     return;
   }
 
-  tdbPCacheWLock(pCache);
+  tdbPCacheLock(pCache);
   nRef = tdbUnrefPage(pPage);
   tdbTrace("pcache/release page %p/%d/%d/%d", pPage, TDB_PAGE_PGNO(pPage), pPage->id, nRef);
   if (nRef == 0) {
@@ -274,8 +275,6 @@ static SPage *tdbPCacheFetchImpl(SPCache *pCache, const SPgid *pPgid, TXN *pTxn)
   SPage *pPage = NULL;
   SPage *pPageH = NULL;
 
-  tdbPCacheRLock(pCache);
-
   if (!pTxn) {
     tdbError("tdb/pcache: null ptr pTxn, fetch impl failed.");
     return NULL;
@@ -295,10 +294,6 @@ static SPage *tdbPCacheFetchImpl(SPCache *pCache, const SPgid *pPgid, TXN *pTxn)
     }
   }
 
-  tdbPCacheUnlock(pCache);
-
-  tdbPCacheWLock(pCache);
-
   // 1. pPage == NULL
   // 2. pPage && pPage->isLocal == 0 && !TDB_TXN_IS_WRITE(pTxn)
   pPageH = pPage;

From 13852f5699380b33b91e04d49d31bdbebe4689c4 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Fri, 21 Apr 2023 17:07:20 +0800
Subject: [PATCH 30/44] fix: compile issue

---
 source/libs/catalog/src/ctgCache.c |  6 +++---
 source/util/src/tlog.c             | 12 ++++--------
 2 files changed, 7 insertions(+), 11 deletions(-)

diff --git a/source/libs/catalog/src/ctgCache.c b/source/libs/catalog/src/ctgCache.c
index 2fe9fef51a..85d2a5c1be 100644
--- a/source/libs/catalog/src/ctgCache.c
+++ b/source/libs/catalog/src/ctgCache.c
@@ -716,7 +716,7 @@ int32_t ctgReadDBCfgFromCache(SCatalog *pCtg, const char* dbFName, SDbCfgInfo* p
   if (NULL == dbCache) {
     ctgDebug("db %s not in cache", dbFName);
     pDbCfg->cfgVersion = -1;
-    CTG_CACHE_STAT_INC(numOfCfgMiss, 1);
+    CTG_CACHE_NHIT_INC(CTG_CI_DB_CFG, 1);
     return TSDB_CODE_SUCCESS;
   }
 
@@ -730,10 +730,10 @@ int32_t ctgReadDBCfgFromCache(SCatalog *pCtg, const char* dbFName, SDbCfgInfo* p
     
     memcpy(pDbCfg, pInfo, sizeof(*pInfo));
     taosMemoryFree(pInfo);
-    CTG_CACHE_STAT_INC(numOfCfgHit, 1);
+    CTG_CACHE_HIT_INC(CTG_CI_DB_CFG, 1);
   } else {
     pDbCfg->cfgVersion = -1;
-    CTG_CACHE_STAT_INC(numOfCfgMiss, 1);
+    CTG_CACHE_NHIT_INC(CTG_CI_DB_CFG, 1);
   }
 
 _return:
diff --git a/source/util/src/tlog.c b/source/util/src/tlog.c
index ff13bf160e..0e75e2022b 100644
--- a/source/util/src/tlog.c
+++ b/source/util/src/tlog.c
@@ -50,7 +50,6 @@ typedef struct {
   int32_t       stop;
   TdThread      asyncThread;
   TdThreadMutex buffMutex;
-  SRWLatch      buffLock;
 } SLogBuff;
 
 typedef struct {
@@ -569,7 +568,7 @@ static SLogBuff *taosLogBuffNew(int32_t bufSize) {
   pLogBuf->minBuffSize = bufSize / 10;
   pLogBuf->stop = 0;
 
-  //if (taosThreadMutexInit(&LOG_BUF_MUTEX(pLogBuf), NULL) < 0) goto _err;
+  if (taosThreadMutexInit(&LOG_BUF_MUTEX(pLogBuf), NULL) < 0) goto _err;
   // tsem_init(&(pLogBuf->buffNotEmpty), 0, 0);
 
   return pLogBuf;
@@ -604,8 +603,7 @@ static int32_t taosPushLogBuffer(SLogBuff *pLogBuf, const char *msg, int32_t msg
 
   if (pLogBuf == NULL || pLogBuf->stop) return -1;
 
-  //taosThreadMutexLock(&LOG_BUF_MUTEX(pLogBuf));
-  taosWLockLatch(&pLogBuf->buffLock);
+  taosThreadMutexLock(&LOG_BUF_MUTEX(pLogBuf));
   start = LOG_BUF_START(pLogBuf);
   end = LOG_BUF_END(pLogBuf);
 
@@ -619,8 +617,7 @@ static int32_t taosPushLogBuffer(SLogBuff *pLogBuf, const char *msg, int32_t msg
   if (remainSize <= msgLen || ((lostLine > 0) && (remainSize <= (msgLen + tmpBufLen)))) {
     lostLine++;
     tsAsyncLogLostLines++;
-    //taosThreadMutexUnlock(&LOG_BUF_MUTEX(pLogBuf));
-    taosWUnLockLatch(&pLogBuf->buffLock);
+    taosThreadMutexUnlock(&LOG_BUF_MUTEX(pLogBuf));
     return -1;
   }
 
@@ -641,8 +638,7 @@ static int32_t taosPushLogBuffer(SLogBuff *pLogBuf, const char *msg, int32_t msg
   }
   */
 
-  //taosThreadMutexUnlock(&LOG_BUF_MUTEX(pLogBuf));
-  taosWUnLockLatch(&pLogBuf->buffLock);
+  taosThreadMutexUnlock(&LOG_BUF_MUTEX(pLogBuf));
 
   return 0;
 }

From c83367e455d6e82fc4c2ca4f25f2849e5c4fb103 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Sat, 6 May 2023 19:24:47 +0800
Subject: [PATCH 31/44] enh: add table group cache

---
 source/dnode/vnode/src/meta/metaCache.c | 211 +++++++++++++++++++++++-
 source/dnode/vnode/src/meta/metaTable.c |   4 +
 source/libs/executor/src/executil.c     |  15 +-
 3 files changed, 220 insertions(+), 10 deletions(-)

diff --git a/source/dnode/vnode/src/meta/metaCache.c b/source/dnode/vnode/src/meta/metaCache.c
index 795f281ab2..b37e9272c5 100644
--- a/source/dnode/vnode/src/meta/metaCache.c
+++ b/source/dnode/vnode/src/meta/metaCache.c
@@ -59,6 +59,13 @@ struct SMetaCache {
     SHashObj*     pTableEntry;
     SLRUCache*    pUidResCache;
   } sTagFilterResCache;
+
+  struct STbGroupResCache {
+    TdThreadMutex lock;
+    uint32_t      accTimes;
+    SHashObj*     pTableEntry;
+    SLRUCache*    pResCache;
+  } STbGroupResCache;
 };
 
 static void entryCacheClose(SMeta* pMeta) {
@@ -144,6 +151,25 @@ int32_t metaCacheOpen(SMeta* pMeta) {
   taosHashSetFreeFp(pCache->sTagFilterResCache.pTableEntry, freeCacheEntryFp);
   taosThreadMutexInit(&pCache->sTagFilterResCache.lock, NULL);
 
+
+  pCache->STbGroupResCache.pResCache = taosLRUCacheInit(5 * 1024 * 1024, -1, 0.5);
+  if (pCache->STbGroupResCache.pResCache == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _err2;
+  }
+
+  pCache->STbGroupResCache.accTimes = 0;
+  pCache->STbGroupResCache.pTableEntry =
+      taosHashInit(1024, taosGetDefaultHashFunction(TSDB_DATA_TYPE_VARCHAR), false, HASH_NO_LOCK);
+  if (pCache->STbGroupResCache.pTableEntry == NULL) {
+    code = TSDB_CODE_OUT_OF_MEMORY;
+    goto _err2;
+  }
+
+  taosHashSetFreeFp(pCache->STbGroupResCache.pTableEntry, freeCacheEntryFp);
+  taosThreadMutexInit(&pCache->STbGroupResCache.lock, NULL);
+
+
   pMeta->pCache = pCache;
   return code;
 
@@ -165,6 +191,10 @@ void metaCacheClose(SMeta* pMeta) {
     taosThreadMutexDestroy(&pMeta->pCache->sTagFilterResCache.lock);
     taosHashCleanup(pMeta->pCache->sTagFilterResCache.pTableEntry);
 
+    taosLRUCacheCleanup(pMeta->pCache->STbGroupResCache.pResCache);
+    taosThreadMutexDestroy(&pMeta->pCache->STbGroupResCache.lock);
+    taosHashCleanup(pMeta->pCache->STbGroupResCache.pTableEntry);
+
     taosMemoryFree(pMeta->pCache);
     pMeta->pCache = NULL;
   }
@@ -520,7 +550,7 @@ int32_t metaGetCachedTableUidList(SMeta* pMeta, tb_uid_t suid, const uint8_t* pK
   return TSDB_CODE_SUCCESS;
 }
 
-static void freePayload(const void* key, size_t keyLen, void* value) {
+static void freeUidCachePayload(const void* key, size_t keyLen, void* value) {
   if (value == NULL) {
     return;
   }
@@ -626,7 +656,7 @@ int32_t metaUidFilterCachePut(SMeta* pMeta, uint64_t suid, const void* pKey, int
   }
 
   // add to cache.
-  taosLRUCacheInsert(pCache, key, TAG_FILTER_RES_KEY_LEN, pPayload, payloadLen, freePayload, NULL,
+  taosLRUCacheInsert(pCache, key, TAG_FILTER_RES_KEY_LEN, pPayload, payloadLen, freeUidCachePayload, NULL,
                      TAOS_LRU_PRIORITY_LOW);
 _end:
   taosThreadMutexUnlock(pLock);
@@ -671,3 +701,180 @@ int32_t metaUidCacheClear(SMeta* pMeta, uint64_t suid) {
   metaDebug("vgId:%d suid:%"PRId64" cached related tag filter uid list cleared", vgId, suid);
   return TSDB_CODE_SUCCESS;
 }
+
+int32_t metaGetCachedTbGroup(SMeta* pMeta, tb_uid_t suid, const uint8_t* pKey, int32_t keyLen, SArray** pList) {
+  int32_t vgId = TD_VID(pMeta->pVnode);
+
+  // generate the composed key for LRU cache
+  SLRUCache*     pCache = pMeta->pCache->STbGroupResCache.pResCache;
+  SHashObj*      pTableMap = pMeta->pCache->STbGroupResCache.pTableEntry;
+  TdThreadMutex* pLock = &pMeta->pCache->STbGroupResCache.lock;
+
+  *pList = NULL;
+  uint64_t key[4];
+  initCacheKey(key, pTableMap, suid, (const char*)pKey, keyLen);
+
+  taosThreadMutexLock(pLock);
+  pMeta->pCache->STbGroupResCache.accTimes += 1;
+
+  LRUHandle* pHandle = taosLRUCacheLookup(pCache, key, TAG_FILTER_RES_KEY_LEN);
+  if (pHandle == NULL) {
+    taosThreadMutexUnlock(pLock);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  STagFilterResEntry** pEntry = taosHashGet(pTableMap, &suid, sizeof(uint64_t));
+  if (NULL == pEntry) {
+    metaDebug("suid %" PRIu64 " not in tb group cache", suid);
+    return TSDB_CODE_FAILED;
+  }
+
+  *pList = taosLRUCacheValue(pCache, pHandle);
+
+  (*pEntry)->hitTimes += 1;
+
+  uint32_t acc = pMeta->pCache->STbGroupResCache.accTimes;
+  if ((*pEntry)->hitTimes % 5000 == 0 && (*pEntry)->hitTimes > 0) {
+    metaInfo("vgId:%d tb group cache hit:%d, total acc:%d, rate:%.2f", vgId, (*pEntry)->hitTimes, acc, ((double)(*pEntry)->hitTimes) / acc);
+  }
+
+  taosLRUCacheRelease(pCache, pHandle, false);
+
+  // unlock meta
+  taosThreadMutexUnlock(pLock);
+  return TSDB_CODE_SUCCESS;
+}
+
+
+static void freeTbGroupCachePayload(const void* key, size_t keyLen, void* value) {
+  if (value == NULL) {
+    return;
+  }
+
+  const uint64_t* p = key;
+  if (keyLen != sizeof(int64_t) * 4) {
+    metaError("tb group key length is invalid, length:%d, expect:%d", (int32_t)keyLen, (int32_t)sizeof(uint64_t) * 2);
+    return;
+  }
+
+  SHashObj* pHashObj = (SHashObj*)p[0];
+
+  STagFilterResEntry** pEntry = taosHashGet(pHashObj, &p[1], sizeof(uint64_t));
+
+  if (pEntry != NULL && (*pEntry) != NULL) {
+    int64_t st = taosGetTimestampUs();
+
+    SListIter iter = {0};
+    tdListInitIter((SList*)&((*pEntry)->list), &iter, TD_LIST_FORWARD);
+
+    SListNode* pNode = NULL;
+    while ((pNode = tdListNext(&iter)) != NULL) {
+      uint64_t* digest = (uint64_t*)pNode->data;
+      if (digest[0] == p[2] && digest[1] == p[3]) {
+        void* tmp = tdListPopNode(&((*pEntry)->list), pNode);
+        taosMemoryFree(tmp);
+
+        double el = (taosGetTimestampUs() - st) / 1000.0;
+        metaDebug("clear one item in tb group cache, remain cached item:%d, elapsed time:%.2fms", listNEles(&((*pEntry)->list)),
+                 el);
+        break;
+      }
+    }
+  }
+
+  taosArrayDestroy((SArray*)value);
+}
+
+
+int32_t metaPutTbGroupToCache(SMeta* pMeta, uint64_t suid, const void* pKey, int32_t keyLen, void* pPayload,
+                              int32_t payloadLen) {
+  int32_t code = 0;
+  int32_t vgId = TD_VID(pMeta->pVnode);
+
+  if (payloadLen > tsTagFilterResCacheSize) {
+    metaDebug("vgId:%d, suid:%" PRIu64
+              " ignore to add to tb group cache, due to payload length %d greater than threshold %d",
+              vgId, suid, payloadLen, tsTagFilterResCacheSize);
+    taosArrayDestroy((SArray*)pPayload);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  SLRUCache*     pCache = pMeta->pCache->STbGroupResCache.pResCache;
+  SHashObj*      pTableEntry = pMeta->pCache->STbGroupResCache.pTableEntry;
+  TdThreadMutex* pLock = &pMeta->pCache->STbGroupResCache.lock;
+
+  uint64_t key[4] = {0};
+  initCacheKey(key, pTableEntry, suid, pKey, keyLen);
+
+  taosThreadMutexLock(pLock);
+  STagFilterResEntry** pEntry = taosHashGet(pTableEntry, &suid, sizeof(uint64_t));
+  if (pEntry == NULL) {
+    code = addNewEntry(pTableEntry, pKey, keyLen, suid);
+    if (code != TSDB_CODE_SUCCESS) {
+      goto _end;
+    }
+  } else { // check if it exists or not
+    size_t size = listNEles(&(*pEntry)->list);
+    if (size == 0) {
+      tdListAppend(&(*pEntry)->list, pKey);
+    } else {
+      SListNode* pNode = listHead(&(*pEntry)->list);
+      uint64_t*  p = (uint64_t*)pNode->data;
+      if (p[1] == ((uint64_t*)pKey)[1] && p[0] == ((uint64_t*)pKey)[0]) {
+        // we have already found the existed items, no need to added to cache anymore.
+        taosThreadMutexUnlock(pLock);
+        return TSDB_CODE_SUCCESS;
+      } else {  // not equal, append it
+        tdListAppend(&(*pEntry)->list, pKey);
+      }
+    }
+  }
+
+  // add to cache.
+  taosLRUCacheInsert(pCache, key, TAG_FILTER_RES_KEY_LEN, pPayload, payloadLen, freeTbGroupCachePayload, NULL,
+                     TAOS_LRU_PRIORITY_LOW);
+_end:
+  taosThreadMutexUnlock(pLock);
+  metaDebug("vgId:%d, suid:%" PRIu64 " tb group added into cache, total:%d, tables:%d", vgId, suid,
+            (int32_t)taosLRUCacheGetUsage(pCache), taosHashGetSize(pTableEntry));
+
+  return code;
+}
+
+// remove the lru cache that are expired due to the tags value update, or creating, or dropping, of child tables
+int32_t metaTbGroupCacheClear(SMeta* pMeta, uint64_t suid) {
+  uint64_t  p[4] = {0};
+  int32_t   vgId = TD_VID(pMeta->pVnode);
+  SHashObj* pEntryHashMap = pMeta->pCache->STbGroupResCache.pTableEntry;
+
+  uint64_t dummy[2] = {0};
+  initCacheKey(p, pEntryHashMap, suid, (char*) &dummy[0], 16);
+
+  TdThreadMutex* pLock = &pMeta->pCache->STbGroupResCache.lock;
+  taosThreadMutexLock(pLock);
+
+  STagFilterResEntry** pEntry = taosHashGet(pEntryHashMap, &suid, sizeof(uint64_t));
+  if (pEntry == NULL || listNEles(&(*pEntry)->list) == 0) {
+    taosThreadMutexUnlock(pLock);
+    return TSDB_CODE_SUCCESS;
+  }
+
+  (*pEntry)->hitTimes = 0;
+
+  SListIter iter = {0};
+  tdListInitIter(&(*pEntry)->list, &iter, TD_LIST_FORWARD);
+
+  SListNode* pNode = NULL;
+  while ((pNode = tdListNext(&iter)) != NULL) {
+    setMD5DigestInKey(p, pNode->data, 2 * sizeof(uint64_t));
+    taosLRUCacheErase(pMeta->pCache->STbGroupResCache.pResCache, p, TAG_FILTER_RES_KEY_LEN);
+  }
+
+  tdListEmpty(&(*pEntry)->list);
+  taosThreadMutexUnlock(pLock);
+
+  metaDebug("vgId:%d suid:%"PRId64" cached related tb group cleared", vgId, suid);
+  return TSDB_CODE_SUCCESS;
+}
+
+
diff --git a/source/dnode/vnode/src/meta/metaTable.c b/source/dnode/vnode/src/meta/metaTable.c
index 3325f4055c..b2d553055d 100644
--- a/source/dnode/vnode/src/meta/metaTable.c
+++ b/source/dnode/vnode/src/meta/metaTable.c
@@ -767,6 +767,7 @@ int metaCreateTable(SMeta *pMeta, int64_t version, SVCreateTbReq *pReq, STableMe
     metaWLock(pMeta);
     metaUpdateStbStats(pMeta, me.ctbEntry.suid, 1);
     metaUidCacheClear(pMeta, me.ctbEntry.suid);
+    metaTbGroupCacheClear(pMeta, me.ctbEntry.suid);
     metaULock(pMeta);
   } else {
     me.ntbEntry.ctime = pReq->ctime;
@@ -999,6 +1000,7 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type) {
 
     metaUpdateStbStats(pMeta, e.ctbEntry.suid, -1);
     metaUidCacheClear(pMeta, e.ctbEntry.suid);
+    metaTbGroupCacheClear(pMeta, e.ctbEntry.suid);    
   } else if (e.type == TSDB_NORMAL_TABLE) {
     // drop schema.db (todo)
 
@@ -1010,6 +1012,7 @@ static int metaDropTableByUid(SMeta *pMeta, tb_uid_t uid, int *type) {
 
     metaStatsCacheDrop(pMeta, uid);
     metaUidCacheClear(pMeta, uid);
+    metaTbGroupCacheClear(pMeta, uid);        
     --pMeta->pVnode->config.vndStats.numOfSTables;
   }
 
@@ -1430,6 +1433,7 @@ static int metaUpdateTableTagVal(SMeta *pMeta, int64_t version, SVAlterTbReq *pA
               ((STag *)(ctbEntry.ctbEntry.pTags))->len, pMeta->txn);
 
   metaUidCacheClear(pMeta, ctbEntry.ctbEntry.suid);
+  metaTbGroupCacheClear(pMeta, ctbEntry.ctbEntry.suid);        
 
   metaULock(pMeta);
 
diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index c7baef8d08..080ed37ee9 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -454,15 +454,14 @@ static void genTagFilterDigest(const SNode* pTagCond, T_MD5_CTX* pContext) {
 }
 
 
-int32_t getColInfoResultForGroupby(void* metaHandle, uint64_t suid, SNodeList* group, STableListInfo* pTableListInfo) {
+int32_t getColInfoResultForGroupby(void* metaHandle, SNodeList* group, STableListInfo* pTableListInfo) {
   int32_t      code = TSDB_CODE_SUCCESS;
   SArray*      pBlockList = NULL;
   SSDataBlock* pResBlock = NULL;
   void*        keyBuf = NULL;
   SArray*      groupData = NULL;
   SArray*      pUidTagList = NULL;
-  static T_MD5_CTX lastMd5 = {-1};
-  static SArray*   lastTableList = NULL;
+  SArray*      tableList = NULL;
   static SHashObj *pTableListHash = NULL;
 
   int32_t rows = taosArrayGetSize(pTableListInfo->pTableList);
@@ -498,10 +497,10 @@ int32_t getColInfoResultForGroupby(void* metaHandle, uint64_t suid, SNodeList* g
 
   SArray **pLastTableList = (SArray **)taosHashGet(pTableListHash, context.digest, sizeof(context.digest));
   if (pLastTableList && *pLastTableList) {
-    pTableListInfo->pTableList = taosArrayDup(lastTableList, NULL);
+    pTableListInfo->pTableList = taosArrayDup(*pLastTableList, NULL);
     goto end;
   } else {
-    qError("group not hit, last:%p, lastSize:%d, newSize:%d", lastTableList, (int32_t)taosArrayGetSize(lastTableList), (int32_t)taosArrayGetSize(pTableListInfo->pTableList));
+    qError("group not hit");
   }
   
   pUidTagList = taosArrayInit(8, sizeof(STUidTagInfo));
@@ -637,8 +636,8 @@ int32_t getColInfoResultForGroupby(void* metaHandle, uint64_t suid, SNodeList* g
     }
   }
   
-  lastTableList = taosArrayDup(pTableListInfo->pTableList, NULL);
-  taosHashPut(pTableListHash, context.digest, sizeof(context.digest), &lastTableList, POINTER_BYTES);
+  tableList = taosArrayDup(pTableListInfo->pTableList, NULL);
+  taosHashPut(pTableListHash, context.digest, sizeof(context.digest), &tableList, POINTER_BYTES);
 
   //  int64_t st2 = taosGetTimestampUs();
   //  qDebug("calculate tag block rows:%d, cost:%ld us", rows, st2-st1);
@@ -2046,7 +2045,7 @@ int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle*
       pTableListInfo->numOfOuputGroups = 1;
     }
   } else {
-    code = getColInfoResultForGroupby(pHandle->meta, pScanNode->suid, group, pTableListInfo);
+    code = getColInfoResultForGroupby(pHandle->meta, group, pTableListInfo);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
     }

From 52fd6a84ace60c37593364e66bb2e681ea1b5a5e Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Tue, 9 May 2023 17:04:20 +0800
Subject: [PATCH 32/44] enh: support db cfg cache update

---
 include/common/tmsg.h                   |  19 +-
 include/libs/catalog/catalog.h          |   2 +
 source/client/src/clientHb.c            |  59 +++---
 source/common/src/tmsg.c                | 253 +++++++++++++++---------
 source/dnode/mnode/impl/src/mndDb.c     | 208 ++++++++++---------
 source/dnode/vnode/inc/vnode.h          |   5 +
 source/dnode/vnode/src/meta/metaCache.c |   2 +-
 source/libs/catalog/src/catalog.c       |  17 ++
 source/libs/catalog/src/ctgCache.c      |  22 ++-
 source/libs/catalog/src/ctgDbg.c        |  19 ++
 source/libs/executor/src/executil.c     |  74 ++++---
 11 files changed, 429 insertions(+), 251 deletions(-)

diff --git a/include/common/tmsg.h b/include/common/tmsg.h
index 8f5fd15078..da482c9ebc 100644
--- a/include/common/tmsg.h
+++ b/include/common/tmsg.h
@@ -941,6 +941,7 @@ int32_t tSerializeSVDropTtlTableReq(void* buf, int32_t bufLen, SVDropTtlTableReq
 int32_t tDeserializeSVDropTtlTableReq(void* buf, int32_t bufLen, SVDropTtlTableReq* pReq);
 
 typedef struct {
+  char    db[TSDB_DB_FNAME_LEN];
   int64_t dbId;
   int32_t cfgVersion;
   int32_t numOfVgroups;
@@ -977,8 +978,11 @@ typedef struct {
 
 typedef SDbCfgRsp     SDbCfgInfo;
 
+int32_t tSerializeSDbCfgRspImpl(SEncoder *encoder, const SDbCfgRsp *pRsp);
 int32_t tSerializeSDbCfgRsp(void* buf, int32_t bufLen, const SDbCfgRsp* pRsp);
 int32_t tDeserializeSDbCfgRsp(void* buf, int32_t bufLen, SDbCfgRsp* pRsp);
+int32_t tDeserializeSDbCfgRspImpl(SDecoder* decoder, SDbCfgRsp *pRsp);
+void tFreeSDbCfgRsp(SDbCfgRsp *pRsp);
 
 typedef struct {
   int32_t rowNum;
@@ -1035,12 +1039,17 @@ int32_t tDeserializeSDnodeListRsp(void* buf, int32_t bufLen, SDnodeListRsp* pRsp
 void    tFreeSDnodeListRsp(SDnodeListRsp* pRsp);
 
 typedef struct {
-  SArray* pArray;  // Array of SUseDbRsp
-} SUseDbBatchRsp;
+  SUseDbRsp *useDbRsp;
+  SDbCfgRsp *cfgRsp;
+} SDbHbRsp;
 
-int32_t tSerializeSUseDbBatchRsp(void* buf, int32_t bufLen, SUseDbBatchRsp* pRsp);
-int32_t tDeserializeSUseDbBatchRsp(void* buf, int32_t bufLen, SUseDbBatchRsp* pRsp);
-void    tFreeSUseDbBatchRsp(SUseDbBatchRsp* pRsp);
+typedef struct {
+  SArray* pArray;  // Array of SDbHbRsp
+} SDbHbBatchRsp;
+
+int32_t tSerializeSDbHbBatchRsp(void* buf, int32_t bufLen, SDbHbBatchRsp* pRsp);
+int32_t tDeserializeSDbHbBatchRsp(void* buf, int32_t bufLen, SDbHbBatchRsp* pRsp);
+void    tFreeSDbHbBatchRsp(SDbHbBatchRsp* pRsp);
 
 typedef struct {
   SArray* pArray;  // Array of SGetUserAuthRsp
diff --git a/include/libs/catalog/catalog.h b/include/libs/catalog/catalog.h
index cbc3f94daf..48b312967a 100644
--- a/include/libs/catalog/catalog.h
+++ b/include/libs/catalog/catalog.h
@@ -178,6 +178,8 @@ int32_t catalogGetDBVgInfo(SCatalog* pCtg, SRequestConnInfo* pConn, const char*
 
 int32_t catalogUpdateDBVgInfo(SCatalog* pCatalog, const char* dbName, uint64_t dbId, SDBVgInfo* dbInfo);
 
+int32_t catalogUpdateDbCfg(SCatalog* pCtg, const char* dbFName, uint64_t dbId, SDbCfgInfo* cfgInfo);
+
 int32_t catalogRemoveDB(SCatalog* pCatalog, const char* dbName, uint64_t dbId);
 
 int32_t catalogRemoveTableMeta(SCatalog* pCtg, SName* pTableName);
diff --git a/source/client/src/clientHb.c b/source/client/src/clientHb.c
index c2fea57b11..65e4030cbe 100644
--- a/source/client/src/clientHb.c
+++ b/source/client/src/clientHb.c
@@ -94,47 +94,51 @@ _return:
 static int32_t hbProcessDBInfoRsp(void *value, int32_t valueLen, struct SCatalog *pCatalog) {
   int32_t code = 0;
 
-  SUseDbBatchRsp batchUseRsp = {0};
-  if (tDeserializeSUseDbBatchRsp(value, valueLen, &batchUseRsp) != 0) {
+  SDbHbBatchRsp batchRsp = {0};
+  if (tDeserializeSDbHbBatchRsp(value, valueLen, &batchRsp) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
     return -1;
   }
 
-  int32_t numOfBatchs = taosArrayGetSize(batchUseRsp.pArray);
+  int32_t numOfBatchs = taosArrayGetSize(batchRsp.pArray);
   for (int32_t i = 0; i < numOfBatchs; ++i) {
-    SUseDbRsp *rsp = taosArrayGet(batchUseRsp.pArray, i);
-    tscDebug("hb db rsp, db:%s, vgVersion:%d, stateTs:%" PRId64 ", uid:%" PRIx64, rsp->db, rsp->vgVersion, rsp->stateTs,
-             rsp->uid);
-
-    if (rsp->vgVersion < 0) {
-      code = catalogRemoveDB(pCatalog, rsp->db, rsp->uid);
-    } else {
-      SDBVgInfo *vgInfo = NULL;
-      code = hbGenerateVgInfoFromRsp(&vgInfo, rsp);
-      if (TSDB_CODE_SUCCESS != code) {
-        goto _return;
-      }
-
-      catalogUpdateDBVgInfo(pCatalog, rsp->db, rsp->uid, vgInfo);
-
-      if (IS_SYS_DBNAME(rsp->db)) {
-        code = hbGenerateVgInfoFromRsp(&vgInfo, rsp);
+    SDbHbRsp *rsp = taosArrayGet(batchRsp.pArray, i);
+    if (rsp->useDbRsp) {
+      tscDebug("hb use db rsp, db:%s, vgVersion:%d, stateTs:%" PRId64 ", uid:%" PRIx64, 
+        rsp->useDbRsp->db, rsp->useDbRsp->vgVersion, rsp->useDbRsp->stateTs, rsp->useDbRsp->uid);
+        
+      if (rsp->useDbRsp->vgVersion < 0) {
+        code = catalogRemoveDB(pCatalog, rsp->useDbRsp->db, rsp->useDbRsp->uid);
+      } else {
+        SDBVgInfo *vgInfo = NULL;
+        code = hbGenerateVgInfoFromRsp(&vgInfo, rsp->useDbRsp);
         if (TSDB_CODE_SUCCESS != code) {
           goto _return;
         }
-
-        catalogUpdateDBVgInfo(pCatalog, (rsp->db[0] == 'i') ? TSDB_PERFORMANCE_SCHEMA_DB : TSDB_INFORMATION_SCHEMA_DB, rsp->uid, vgInfo);
+      
+        catalogUpdateDBVgInfo(pCatalog, rsp->useDbRsp->db, rsp->useDbRsp->uid, vgInfo);
+      
+        if (IS_SYS_DBNAME(rsp->useDbRsp->db)) {
+          code = hbGenerateVgInfoFromRsp(&vgInfo, rsp->useDbRsp);
+          if (TSDB_CODE_SUCCESS != code) {
+            goto _return;
+          }
+      
+          catalogUpdateDBVgInfo(pCatalog, (rsp->useDbRsp->db[0] == 'i') ? TSDB_PERFORMANCE_SCHEMA_DB : TSDB_INFORMATION_SCHEMA_DB, rsp->useDbRsp->uid, vgInfo);
+        }
       }
     }
 
-    if (code) {
-      goto _return;
+    if (rsp->cfgRsp) {
+      tscDebug("hb db cfg rsp, db:%s, cfgVersion:%d", rsp->cfgRsp->db, rsp->cfgRsp->cfgVersion);
+      catalogUpdateDbCfg(pCatalog, rsp->cfgRsp->db, rsp->cfgRsp->dbId, rsp->cfgRsp);
+      rsp->cfgRsp = NULL;
     }
   }
 
 _return:
 
-  tFreeSUseDbBatchRsp(&batchUseRsp);
+  tFreeSDbHbBatchRsp(&batchRsp);
   return code;
 }
 
@@ -526,11 +530,12 @@ int32_t hbGetExpiredDBInfo(SClientHbKey *connKey, struct SCatalog *pCatalog, SCl
 
   for (int32_t i = 0; i < dbNum; ++i) {
     SDbCacheInfo *db = &dbs[i];
-    tscDebug("the %dth expired dbFName:%s, dbId:%" PRId64 ", vgVersion:%d, numOfTable:%d, startTs:%" PRId64, 
-      i, db->dbFName, db->dbId, db->vgVersion, db->numOfTable, db->stateTs);
+    tscDebug("the %dth expired dbFName:%s, dbId:%" PRId64 ", vgVersion:%d, cfgVersion:%d, numOfTable:%d, startTs:%" PRId64, 
+      i, db->dbFName, db->dbId, db->vgVersion, db->cfgVersion, db->numOfTable, db->stateTs);
 
     db->dbId = htobe64(db->dbId);
     db->vgVersion = htonl(db->vgVersion);
+    db->cfgVersion = htonl(db->cfgVersion);
     db->numOfTable = htonl(db->numOfTable);
     db->stateTs = htobe64(db->stateTs);
   }
diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c
index b04a4eaf3f..f594831bad 100644
--- a/source/common/src/tmsg.c
+++ b/source/common/src/tmsg.c
@@ -2777,7 +2777,26 @@ int32_t tSerializeSUseDbRsp(void *buf, int32_t bufLen, const SUseDbRsp *pRsp) {
   return tlen;
 }
 
-int32_t tSerializeSUseDbBatchRsp(void *buf, int32_t bufLen, SUseDbBatchRsp *pRsp) {
+int32_t tSerializeSDbHbRspImp(SEncoder *pEncoder, const SDbHbRsp *pRsp) {
+  if (pRsp->useDbRsp) {
+    if (tEncodeI8(pEncoder, 1) < 0) return -1;
+    if (tSerializeSUseDbRspImp(pEncoder, pRsp->useDbRsp) < 0) return -1;
+  } else {
+    if (tEncodeI8(pEncoder, 0) < 0) return -1;
+  }
+
+  if (pRsp->cfgRsp) {
+    if (tEncodeI8(pEncoder, 1) < 0) return -1;
+    if (tSerializeSDbCfgRspImpl(pEncoder, pRsp->cfgRsp) < 0) return -1;
+  } else {
+    if (tEncodeI8(pEncoder, 0) < 0) return -1;
+  }
+
+  return 0;
+}
+
+
+int32_t tSerializeSDbHbBatchRsp(void *buf, int32_t bufLen, SDbHbBatchRsp *pRsp) {
   SEncoder encoder = {0};
   tEncoderInit(&encoder, buf, bufLen);
 
@@ -2786,8 +2805,8 @@ int32_t tSerializeSUseDbBatchRsp(void *buf, int32_t bufLen, SUseDbBatchRsp *pRsp
   int32_t numOfBatch = taosArrayGetSize(pRsp->pArray);
   if (tEncodeI32(&encoder, numOfBatch) < 0) return -1;
   for (int32_t i = 0; i < numOfBatch; ++i) {
-    SUseDbRsp *pUsedbRsp = taosArrayGet(pRsp->pArray, i);
-    if (tSerializeSUseDbRspImp(&encoder, pUsedbRsp) < 0) return -1;
+    SDbHbRsp *pDbRsp = taosArrayGet(pRsp->pArray, i);
+    if (tSerializeSDbHbRspImp(&encoder, pDbRsp) < 0) return -1;
   }
   tEndEncode(&encoder);
 
@@ -2840,7 +2859,25 @@ int32_t tDeserializeSUseDbRsp(void *buf, int32_t bufLen, SUseDbRsp *pRsp) {
   return 0;
 }
 
-int32_t tDeserializeSUseDbBatchRsp(void *buf, int32_t bufLen, SUseDbBatchRsp *pRsp) {
+int32_t tDeserializeSDbHbRspImp(SDecoder* decoder, SDbHbRsp* pRsp) {
+  int8_t flag = 0;
+  if (tDecodeI8(decoder, &flag) < 0) return -1;
+  if (flag) {
+    pRsp->useDbRsp = taosMemoryCalloc(1, sizeof(SUseDbRsp));
+    if (NULL == pRsp->useDbRsp) return -1;
+    if (tDeserializeSUseDbRspImp(decoder, pRsp->useDbRsp) < 0) return -1;
+  }
+  if (tDecodeI8(decoder, &flag) < 0) return -1;
+  if (flag) {
+    pRsp->cfgRsp = taosMemoryCalloc(1, sizeof(SDbCfgRsp));
+    if (NULL == pRsp->cfgRsp) return -1;
+    if (tDeserializeSDbCfgRspImpl(decoder, pRsp->cfgRsp) < 0) return -1;
+  }
+
+  return 0;
+}
+
+int32_t tDeserializeSDbHbBatchRsp(void *buf, int32_t bufLen, SDbHbBatchRsp *pRsp) {
   SDecoder decoder = {0};
   tDecoderInit(&decoder, buf, bufLen);
 
@@ -2849,19 +2886,19 @@ int32_t tDeserializeSUseDbBatchRsp(void *buf, int32_t bufLen, SUseDbBatchRsp *pR
   int32_t numOfBatch = taosArrayGetSize(pRsp->pArray);
   if (tDecodeI32(&decoder, &numOfBatch) < 0) return -1;
 
-  pRsp->pArray = taosArrayInit(numOfBatch, sizeof(SUseDbRsp));
+  pRsp->pArray = taosArrayInit(numOfBatch, sizeof(SDbHbRsp));
   if (pRsp->pArray == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
 
   for (int32_t i = 0; i < numOfBatch; ++i) {
-    SUseDbRsp usedbRsp = {0};
-    if (tDeserializeSUseDbRspImp(&decoder, &usedbRsp) < 0) {
+    SDbHbRsp rsp = {0};
+    if (tDeserializeSDbHbRspImp(&decoder, &rsp) < 0) {
       tDecoderClear(&decoder);
       return -1;
     }
-    taosArrayPush(pRsp->pArray, &usedbRsp);
+    taosArrayPush(pRsp->pArray, &rsp);
   }
   tEndDecode(&decoder);
 
@@ -2871,11 +2908,27 @@ int32_t tDeserializeSUseDbBatchRsp(void *buf, int32_t bufLen, SUseDbBatchRsp *pR
 
 void tFreeSUsedbRsp(SUseDbRsp *pRsp) { taosArrayDestroy(pRsp->pVgroupInfos); }
 
-void tFreeSUseDbBatchRsp(SUseDbBatchRsp *pRsp) {
+void tFreeSDbHbRsp(SDbHbRsp *pDbRsp) {
+  if (NULL == pDbRsp) {
+    return;
+  }
+
+  if (pDbRsp->useDbRsp) {
+    tFreeSUsedbRsp(pDbRsp->useDbRsp);
+    taosMemoryFree(pDbRsp->useDbRsp);
+  }
+
+  if (pDbRsp->cfgRsp) {
+    tFreeSDbCfgRsp(pDbRsp->cfgRsp);
+    taosMemoryFree(pDbRsp->cfgRsp);
+  }
+}
+
+void tFreeSDbHbBatchRsp(SDbHbBatchRsp *pRsp) {
   int32_t numOfBatch = taosArrayGetSize(pRsp->pArray);
   for (int32_t i = 0; i < numOfBatch; ++i) {
-    SUseDbRsp *pUsedbRsp = taosArrayGet(pRsp->pArray, i);
-    tFreeSUsedbRsp(pUsedbRsp);
+    SDbHbRsp *pDbRsp = taosArrayGet(pRsp->pArray, i);
+    tFreeSDbHbRsp(pDbRsp);
   }
 
   taosArrayDestroy(pRsp->pArray);
@@ -3038,89 +3091,93 @@ int32_t tDeserializeSVDropTtlTableReq(void *buf, int32_t bufLen, SVDropTtlTableR
   return 0;
 }
 
+int32_t tSerializeSDbCfgRspImpl(SEncoder *encoder, const SDbCfgRsp *pRsp) {
+  if (tEncodeCStr(encoder, pRsp->db) < 0) return -1;
+  if (tEncodeI64(encoder, pRsp->dbId) < 0) return -1;
+  if (tEncodeI32(encoder, pRsp->cfgVersion) < 0) return -1;
+  if (tEncodeI32(encoder, pRsp->numOfVgroups) < 0) return -1;
+  if (tEncodeI32(encoder, pRsp->numOfStables) < 0) return -1;
+  if (tEncodeI32(encoder, pRsp->buffer) < 0) return -1;
+  if (tEncodeI32(encoder, pRsp->cacheSize) < 0) return -1;
+  if (tEncodeI32(encoder, pRsp->pageSize) < 0) return -1;
+  if (tEncodeI32(encoder, pRsp->pages) < 0) return -1;
+  if (tEncodeI32(encoder, pRsp->daysPerFile) < 0) return -1;
+  if (tEncodeI32(encoder, pRsp->daysToKeep0) < 0) return -1;
+  if (tEncodeI32(encoder, pRsp->daysToKeep1) < 0) return -1;
+  if (tEncodeI32(encoder, pRsp->daysToKeep2) < 0) return -1;
+  if (tEncodeI32(encoder, pRsp->minRows) < 0) return -1;
+  if (tEncodeI32(encoder, pRsp->maxRows) < 0) return -1;
+  if (tEncodeI32(encoder, pRsp->walFsyncPeriod) < 0) return -1;
+  if (tEncodeI16(encoder, pRsp->hashPrefix) < 0) return -1;
+  if (tEncodeI16(encoder, pRsp->hashSuffix) < 0) return -1;
+  if (tEncodeI8(encoder, pRsp->walLevel) < 0) return -1;
+  if (tEncodeI8(encoder, pRsp->precision) < 0) return -1;
+  if (tEncodeI8(encoder, pRsp->compression) < 0) return -1;
+  if (tEncodeI8(encoder, pRsp->replications) < 0) return -1;
+  if (tEncodeI8(encoder, pRsp->strict) < 0) return -1;
+  if (tEncodeI8(encoder, pRsp->cacheLast) < 0) return -1;
+  if (tEncodeI32(encoder, pRsp->tsdbPageSize) < 0) return -1;
+  if (tEncodeI32(encoder, pRsp->walRetentionPeriod) < 0) return -1;
+  if (tEncodeI32(encoder, pRsp->walRollPeriod) < 0) return -1;
+  if (tEncodeI64(encoder, pRsp->walRetentionSize) < 0) return -1;
+  if (tEncodeI64(encoder, pRsp->walSegmentSize) < 0) return -1;
+  if (tEncodeI32(encoder, pRsp->numOfRetensions) < 0) return -1;
+  for (int32_t i = 0; i < pRsp->numOfRetensions; ++i) {
+    SRetention *pRetension = taosArrayGet(pRsp->pRetensions, i);
+    if (tEncodeI64(encoder, pRetension->freq) < 0) return -1;
+    if (tEncodeI64(encoder, pRetension->keep) < 0) return -1;
+    if (tEncodeI8(encoder, pRetension->freqUnit) < 0) return -1;
+    if (tEncodeI8(encoder, pRetension->keepUnit) < 0) return -1;
+  }
+  if (tEncodeI8(encoder, pRsp->schemaless) < 0) return -1;
+  if (tEncodeI16(encoder, pRsp->sstTrigger) < 0) return -1;
+
+  return 0;
+}
+
 int32_t tSerializeSDbCfgRsp(void *buf, int32_t bufLen, const SDbCfgRsp *pRsp) {
   SEncoder encoder = {0};
   tEncoderInit(&encoder, buf, bufLen);
 
   if (tStartEncode(&encoder) < 0) return -1;
-  if (tEncodeI64(&encoder, pRsp->dbId) < 0) return -1;
-  if (tEncodeI32(&encoder, pRsp->cfgVersion) < 0) return -1;
-  if (tEncodeI32(&encoder, pRsp->numOfVgroups) < 0) return -1;
-  if (tEncodeI32(&encoder, pRsp->numOfStables) < 0) return -1;
-  if (tEncodeI32(&encoder, pRsp->buffer) < 0) return -1;
-  if (tEncodeI32(&encoder, pRsp->cacheSize) < 0) return -1;
-  if (tEncodeI32(&encoder, pRsp->pageSize) < 0) return -1;
-  if (tEncodeI32(&encoder, pRsp->pages) < 0) return -1;
-  if (tEncodeI32(&encoder, pRsp->daysPerFile) < 0) return -1;
-  if (tEncodeI32(&encoder, pRsp->daysToKeep0) < 0) return -1;
-  if (tEncodeI32(&encoder, pRsp->daysToKeep1) < 0) return -1;
-  if (tEncodeI32(&encoder, pRsp->daysToKeep2) < 0) return -1;
-  if (tEncodeI32(&encoder, pRsp->minRows) < 0) return -1;
-  if (tEncodeI32(&encoder, pRsp->maxRows) < 0) return -1;
-  if (tEncodeI32(&encoder, pRsp->walFsyncPeriod) < 0) return -1;
-  if (tEncodeI16(&encoder, pRsp->hashPrefix) < 0) return -1;
-  if (tEncodeI16(&encoder, pRsp->hashSuffix) < 0) return -1;
-  if (tEncodeI8(&encoder, pRsp->walLevel) < 0) return -1;
-  if (tEncodeI8(&encoder, pRsp->precision) < 0) return -1;
-  if (tEncodeI8(&encoder, pRsp->compression) < 0) return -1;
-  if (tEncodeI8(&encoder, pRsp->replications) < 0) return -1;
-  if (tEncodeI8(&encoder, pRsp->strict) < 0) return -1;
-  if (tEncodeI8(&encoder, pRsp->cacheLast) < 0) return -1;
-  if (tEncodeI32(&encoder, pRsp->tsdbPageSize) < 0) return -1;
-  if (tEncodeI32(&encoder, pRsp->walRetentionPeriod) < 0) return -1;
-  if (tEncodeI32(&encoder, pRsp->walRollPeriod) < 0) return -1;
-  if (tEncodeI64(&encoder, pRsp->walRetentionSize) < 0) return -1;
-  if (tEncodeI64(&encoder, pRsp->walSegmentSize) < 0) return -1;
-  if (tEncodeI32(&encoder, pRsp->numOfRetensions) < 0) return -1;
-  for (int32_t i = 0; i < pRsp->numOfRetensions; ++i) {
-    SRetention *pRetension = taosArrayGet(pRsp->pRetensions, i);
-    if (tEncodeI64(&encoder, pRetension->freq) < 0) return -1;
-    if (tEncodeI64(&encoder, pRetension->keep) < 0) return -1;
-    if (tEncodeI8(&encoder, pRetension->freqUnit) < 0) return -1;
-    if (tEncodeI8(&encoder, pRetension->keepUnit) < 0) return -1;
-  }
-  if (tEncodeI8(&encoder, pRsp->schemaless) < 0) return -1;
-  if (tEncodeI16(&encoder, pRsp->sstTrigger) < 0) return -1;
+  tSerializeSDbCfgRspImpl(&encoder, pRsp);
   tEndEncode(&encoder);
   int32_t tlen = encoder.pos;
   tEncoderClear(&encoder);
   return tlen;
 }
 
-int32_t tDeserializeSDbCfgRsp(void *buf, int32_t bufLen, SDbCfgRsp *pRsp) {
-  SDecoder decoder = {0};
-  tDecoderInit(&decoder, buf, bufLen);
-
-  if (tStartDecode(&decoder) < 0) return -1;
-  if (tDecodeI64(&decoder, &pRsp->dbId) < 0) return -1;
-  if (tDecodeI32(&decoder, &pRsp->cfgVersion) < 0) return -1;
-  if (tDecodeI32(&decoder, &pRsp->numOfVgroups) < 0) return -1;
-  if (tDecodeI32(&decoder, &pRsp->numOfStables) < 0) return -1;
-  if (tDecodeI32(&decoder, &pRsp->buffer) < 0) return -1;
-  if (tDecodeI32(&decoder, &pRsp->cacheSize) < 0) return -1;
-  if (tDecodeI32(&decoder, &pRsp->pageSize) < 0) return -1;
-  if (tDecodeI32(&decoder, &pRsp->pages) < 0) return -1;
-  if (tDecodeI32(&decoder, &pRsp->daysPerFile) < 0) return -1;
-  if (tDecodeI32(&decoder, &pRsp->daysToKeep0) < 0) return -1;
-  if (tDecodeI32(&decoder, &pRsp->daysToKeep1) < 0) return -1;
-  if (tDecodeI32(&decoder, &pRsp->daysToKeep2) < 0) return -1;
-  if (tDecodeI32(&decoder, &pRsp->minRows) < 0) return -1;
-  if (tDecodeI32(&decoder, &pRsp->maxRows) < 0) return -1;
-  if (tDecodeI32(&decoder, &pRsp->walFsyncPeriod) < 0) return -1;
-  if (tDecodeI16(&decoder, &pRsp->hashPrefix) < 0) return -1;
-  if (tDecodeI16(&decoder, &pRsp->hashSuffix) < 0) return -1;
-  if (tDecodeI8(&decoder, &pRsp->walLevel) < 0) return -1;
-  if (tDecodeI8(&decoder, &pRsp->precision) < 0) return -1;
-  if (tDecodeI8(&decoder, &pRsp->compression) < 0) return -1;
-  if (tDecodeI8(&decoder, &pRsp->replications) < 0) return -1;
-  if (tDecodeI8(&decoder, &pRsp->strict) < 0) return -1;
-  if (tDecodeI8(&decoder, &pRsp->cacheLast) < 0) return -1;
-  if (tDecodeI32(&decoder, &pRsp->tsdbPageSize) < 0) return -1;
-  if (tDecodeI32(&decoder, &pRsp->walRetentionPeriod) < 0) return -1;
-  if (tDecodeI32(&decoder, &pRsp->walRollPeriod) < 0) return -1;
-  if (tDecodeI64(&decoder, &pRsp->walRetentionSize) < 0) return -1;
-  if (tDecodeI64(&decoder, &pRsp->walSegmentSize) < 0) return -1;
-  if (tDecodeI32(&decoder, &pRsp->numOfRetensions) < 0) return -1;
+int32_t tDeserializeSDbCfgRspImpl(SDecoder* decoder, SDbCfgRsp *pRsp) {
+  if (tDecodeCStrTo(decoder, pRsp->db) < 0) return -1;
+  if (tDecodeI64(decoder, &pRsp->dbId) < 0) return -1;
+  if (tDecodeI32(decoder, &pRsp->cfgVersion) < 0) return -1;
+  if (tDecodeI32(decoder, &pRsp->numOfVgroups) < 0) return -1;
+  if (tDecodeI32(decoder, &pRsp->numOfStables) < 0) return -1;
+  if (tDecodeI32(decoder, &pRsp->buffer) < 0) return -1;
+  if (tDecodeI32(decoder, &pRsp->cacheSize) < 0) return -1;
+  if (tDecodeI32(decoder, &pRsp->pageSize) < 0) return -1;
+  if (tDecodeI32(decoder, &pRsp->pages) < 0) return -1;
+  if (tDecodeI32(decoder, &pRsp->daysPerFile) < 0) return -1;
+  if (tDecodeI32(decoder, &pRsp->daysToKeep0) < 0) return -1;
+  if (tDecodeI32(decoder, &pRsp->daysToKeep1) < 0) return -1;
+  if (tDecodeI32(decoder, &pRsp->daysToKeep2) < 0) return -1;
+  if (tDecodeI32(decoder, &pRsp->minRows) < 0) return -1;
+  if (tDecodeI32(decoder, &pRsp->maxRows) < 0) return -1;
+  if (tDecodeI32(decoder, &pRsp->walFsyncPeriod) < 0) return -1;
+  if (tDecodeI16(decoder, &pRsp->hashPrefix) < 0) return -1;
+  if (tDecodeI16(decoder, &pRsp->hashSuffix) < 0) return -1;
+  if (tDecodeI8(decoder, &pRsp->walLevel) < 0) return -1;
+  if (tDecodeI8(decoder, &pRsp->precision) < 0) return -1;
+  if (tDecodeI8(decoder, &pRsp->compression) < 0) return -1;
+  if (tDecodeI8(decoder, &pRsp->replications) < 0) return -1;
+  if (tDecodeI8(decoder, &pRsp->strict) < 0) return -1;
+  if (tDecodeI8(decoder, &pRsp->cacheLast) < 0) return -1;
+  if (tDecodeI32(decoder, &pRsp->tsdbPageSize) < 0) return -1;
+  if (tDecodeI32(decoder, &pRsp->walRetentionPeriod) < 0) return -1;
+  if (tDecodeI32(decoder, &pRsp->walRollPeriod) < 0) return -1;
+  if (tDecodeI64(decoder, &pRsp->walRetentionSize) < 0) return -1;
+  if (tDecodeI64(decoder, &pRsp->walSegmentSize) < 0) return -1;
+  if (tDecodeI32(decoder, &pRsp->numOfRetensions) < 0) return -1;
   if (pRsp->numOfRetensions > 0) {
     pRsp->pRetensions = taosArrayInit(pRsp->numOfRetensions, sizeof(SRetention));
     if (pRsp->pRetensions == NULL) {
@@ -3131,23 +3188,41 @@ int32_t tDeserializeSDbCfgRsp(void *buf, int32_t bufLen, SDbCfgRsp *pRsp) {
 
   for (int32_t i = 0; i < pRsp->numOfRetensions; ++i) {
     SRetention rentension = {0};
-    if (tDecodeI64(&decoder, &rentension.freq) < 0) return -1;
-    if (tDecodeI64(&decoder, &rentension.keep) < 0) return -1;
-    if (tDecodeI8(&decoder, &rentension.freqUnit) < 0) return -1;
-    if (tDecodeI8(&decoder, &rentension.keepUnit) < 0) return -1;
+    if (tDecodeI64(decoder, &rentension.freq) < 0) return -1;
+    if (tDecodeI64(decoder, &rentension.keep) < 0) return -1;
+    if (tDecodeI8(decoder, &rentension.freqUnit) < 0) return -1;
+    if (tDecodeI8(decoder, &rentension.keepUnit) < 0) return -1;
     if (taosArrayPush(pRsp->pRetensions, &rentension) == NULL) {
       terrno = TSDB_CODE_OUT_OF_MEMORY;
       return -1;
     }
   }
-  if (tDecodeI8(&decoder, &pRsp->schemaless) < 0) return -1;
-  if (tDecodeI16(&decoder, &pRsp->sstTrigger) < 0) return -1;
+  if (tDecodeI8(decoder, &pRsp->schemaless) < 0) return -1;
+  if (tDecodeI16(decoder, &pRsp->sstTrigger) < 0) return -1;
+
+  return 0;
+}
+
+int32_t tDeserializeSDbCfgRsp(void *buf, int32_t bufLen, SDbCfgRsp *pRsp) {
+  SDecoder decoder = {0};
+  tDecoderInit(&decoder, buf, bufLen);
+
+  if (tStartDecode(&decoder) < 0) return -1;
+  if (tDeserializeSDbCfgRspImpl(&decoder, pRsp) < 0) return -1;
   tEndDecode(&decoder);
 
   tDecoderClear(&decoder);
   return 0;
 }
 
+void tFreeSDbCfgRsp(SDbCfgRsp *pRsp) {
+  if (NULL == pRsp) {
+    return;
+  }
+
+  taosArrayDestroy(pRsp->pRetensions);
+}
+
 int32_t tSerializeSUserIndexReq(void *buf, int32_t bufLen, SUserIndexReq *pReq) {
   SEncoder encoder = {0};
   tEncoderInit(&encoder, buf, bufLen);
diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c
index 71292ba649..da617bb0ab 100644
--- a/source/dnode/mnode/impl/src/mndDb.c
+++ b/source/dnode/mnode/impl/src/mndDb.c
@@ -894,6 +894,42 @@ _OVER:
   return code;
 }
 
+static void mndDumpDbCfgInfo(SDbCfgRsp *cfgRsp, SDbObj *pDb) {
+  strcpy(cfgRsp->db, pDb->name);
+  cfgRsp->dbId = pDb->uid;
+  cfgRsp->cfgVersion = pDb->cfgVersion;
+  cfgRsp->numOfVgroups = pDb->cfg.numOfVgroups;
+  cfgRsp->numOfStables = pDb->cfg.numOfStables;
+  cfgRsp->buffer = pDb->cfg.buffer;
+  cfgRsp->cacheSize = pDb->cfg.cacheLastSize;
+  cfgRsp->pageSize = pDb->cfg.pageSize;
+  cfgRsp->pages = pDb->cfg.pages;
+  cfgRsp->daysPerFile = pDb->cfg.daysPerFile;
+  cfgRsp->daysToKeep0 = pDb->cfg.daysToKeep0;
+  cfgRsp->daysToKeep1 = pDb->cfg.daysToKeep1;
+  cfgRsp->daysToKeep2 = pDb->cfg.daysToKeep2;
+  cfgRsp->minRows = pDb->cfg.minRows;
+  cfgRsp->maxRows = pDb->cfg.maxRows;
+  cfgRsp->walFsyncPeriod = pDb->cfg.walFsyncPeriod;
+  cfgRsp->hashPrefix = pDb->cfg.hashPrefix;
+  cfgRsp->hashSuffix = pDb->cfg.hashSuffix;
+  cfgRsp->walLevel = pDb->cfg.walLevel;
+  cfgRsp->precision = pDb->cfg.precision;
+  cfgRsp->compression = pDb->cfg.compression;
+  cfgRsp->replications = pDb->cfg.replications;
+  cfgRsp->strict = pDb->cfg.strict;
+  cfgRsp->cacheLast = pDb->cfg.cacheLast;
+  cfgRsp->tsdbPageSize = pDb->cfg.tsdbPageSize;
+  cfgRsp->walRetentionPeriod = pDb->cfg.walRetentionPeriod;
+  cfgRsp->walRollPeriod = pDb->cfg.walRollPeriod;
+  cfgRsp->walRetentionSize = pDb->cfg.walRetentionSize;
+  cfgRsp->walSegmentSize = pDb->cfg.walSegmentSize;
+  cfgRsp->numOfRetensions = pDb->cfg.numOfRetensions;
+  cfgRsp->pRetensions = pDb->cfg.pRetensions;
+  cfgRsp->schemaless = pDb->cfg.schemaless;
+  cfgRsp->sstTrigger = pDb->cfg.sstTrigger;
+}
+
 static int32_t mndProcessGetDbCfgReq(SRpcMsg *pReq) {
   SMnode   *pMnode = pReq->info.node;
   int32_t   code = -1;
@@ -906,43 +942,15 @@ static int32_t mndProcessGetDbCfgReq(SRpcMsg *pReq) {
     goto _OVER;
   }
 
-  pDb = mndAcquireDb(pMnode, cfgReq.db);
-  if (pDb == NULL) {
-    goto _OVER;
-  }
+  if (strcasecmp(cfgReq.db, TSDB_INFORMATION_SCHEMA_DB) && strcasecmp(cfgReq.db, TSDB_PERFORMANCE_SCHEMA_DB)) {
+    pDb = mndAcquireDb(pMnode, cfgReq.db);
+    if (pDb == NULL) {
+      goto _OVER;
+    }
 
-  cfgRsp.dbId = pDb->uid;
-  cfgRsp.cfgVersion = pDb->cfgVersion;
-  cfgRsp.numOfVgroups = pDb->cfg.numOfVgroups;
-  cfgRsp.numOfStables = pDb->cfg.numOfStables;
-  cfgRsp.buffer = pDb->cfg.buffer;
-  cfgRsp.cacheSize = pDb->cfg.cacheLastSize;
-  cfgRsp.pageSize = pDb->cfg.pageSize;
-  cfgRsp.pages = pDb->cfg.pages;
-  cfgRsp.daysPerFile = pDb->cfg.daysPerFile;
-  cfgRsp.daysToKeep0 = pDb->cfg.daysToKeep0;
-  cfgRsp.daysToKeep1 = pDb->cfg.daysToKeep1;
-  cfgRsp.daysToKeep2 = pDb->cfg.daysToKeep2;
-  cfgRsp.minRows = pDb->cfg.minRows;
-  cfgRsp.maxRows = pDb->cfg.maxRows;
-  cfgRsp.walFsyncPeriod = pDb->cfg.walFsyncPeriod;
-  cfgRsp.hashPrefix = pDb->cfg.hashPrefix;
-  cfgRsp.hashSuffix = pDb->cfg.hashSuffix;
-  cfgRsp.walLevel = pDb->cfg.walLevel;
-  cfgRsp.precision = pDb->cfg.precision;
-  cfgRsp.compression = pDb->cfg.compression;
-  cfgRsp.replications = pDb->cfg.replications;
-  cfgRsp.strict = pDb->cfg.strict;
-  cfgRsp.cacheLast = pDb->cfg.cacheLast;
-  cfgRsp.tsdbPageSize = pDb->cfg.tsdbPageSize;
-  cfgRsp.walRetentionPeriod = pDb->cfg.walRetentionPeriod;
-  cfgRsp.walRollPeriod = pDb->cfg.walRollPeriod;
-  cfgRsp.walRetentionSize = pDb->cfg.walRetentionSize;
-  cfgRsp.walSegmentSize = pDb->cfg.walSegmentSize;
-  cfgRsp.numOfRetensions = pDb->cfg.numOfRetensions;
-  cfgRsp.pRetensions = pDb->cfg.pRetensions;
-  cfgRsp.schemaless = pDb->cfg.schemaless;
-  cfgRsp.sstTrigger = pDb->cfg.sstTrigger;
+    mndDumpDbCfgInfo(&cfgRsp, pDb);
+  }
+  
   int32_t contLen = tSerializeSDbCfgRsp(NULL, 0, &cfgRsp);
   void   *pRsp = rpcMallocCont(contLen);
   if (pRsp == NULL) {
@@ -1340,102 +1348,118 @@ _OVER:
 }
 
 int32_t mndValidateDbInfo(SMnode *pMnode, SDbCacheInfo *pDbs, int32_t numOfDbs, void **ppRsp, int32_t *pRspLen) {
-  SUseDbBatchRsp batchUseRsp = {0};
-  batchUseRsp.pArray = taosArrayInit(numOfDbs, sizeof(SUseDbRsp));
-  if (batchUseRsp.pArray == NULL) {
+  SDbHbBatchRsp batchRsp = {0};
+  batchRsp.pArray = taosArrayInit(numOfDbs, sizeof(SDbHbRsp));
+  if (batchRsp.pArray == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
     return -1;
   }
 
   for (int32_t i = 0; i < numOfDbs; ++i) {
-    SDbCacheInfo *pDbVgVersion = &pDbs[i];
-    pDbVgVersion->dbId = be64toh(pDbVgVersion->dbId);
-    pDbVgVersion->vgVersion = htonl(pDbVgVersion->vgVersion);
-    pDbVgVersion->numOfTable = htonl(pDbVgVersion->numOfTable);
-    pDbVgVersion->stateTs = be64toh(pDbVgVersion->stateTs);
+    SDbCacheInfo *pDbCacheInfo = &pDbs[i];
+    pDbCacheInfo->dbId = be64toh(pDbCacheInfo->dbId);
+    pDbCacheInfo->vgVersion = htonl(pDbCacheInfo->vgVersion);
+    pDbCacheInfo->cfgVersion = htonl(pDbCacheInfo->cfgVersion);
+    pDbCacheInfo->numOfTable = htonl(pDbCacheInfo->numOfTable);
+    pDbCacheInfo->stateTs = be64toh(pDbCacheInfo->stateTs);
 
-    SUseDbRsp usedbRsp = {0};
+    SDbHbRsp rsp = {0};
 
-    if ((0 == strcasecmp(pDbVgVersion->dbFName, TSDB_INFORMATION_SCHEMA_DB) ||
-         (0 == strcasecmp(pDbVgVersion->dbFName, TSDB_PERFORMANCE_SCHEMA_DB)))) {
-      memcpy(usedbRsp.db, pDbVgVersion->dbFName, TSDB_DB_FNAME_LEN);
+    if ((0 == strcasecmp(pDbCacheInfo->dbFName, TSDB_INFORMATION_SCHEMA_DB) ||
+         (0 == strcasecmp(pDbCacheInfo->dbFName, TSDB_PERFORMANCE_SCHEMA_DB)))) {
       int32_t vgVersion = mndGetGlobalVgroupVersion(pMnode);
-      if (pDbVgVersion->vgVersion < vgVersion) {
-        usedbRsp.pVgroupInfos = taosArrayInit(10, sizeof(SVgroupInfo));
-
-        mndBuildDBVgroupInfo(NULL, pMnode, usedbRsp.pVgroupInfos);
-        usedbRsp.vgVersion = vgVersion++;
-      } else {
-        usedbRsp.vgVersion = pDbVgVersion->vgVersion;
+      if (pDbCacheInfo->vgVersion >= vgVersion) {
+        continue;
       }
-      usedbRsp.vgNum = taosArrayGetSize(usedbRsp.pVgroupInfos);
+      
+      rsp.useDbRsp = taosMemoryCalloc(1, sizeof(SUseDbRsp));
+      memcpy(rsp.useDbRsp->db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);
+      rsp.useDbRsp->pVgroupInfos = taosArrayInit(10, sizeof(SVgroupInfo));
 
-      taosArrayPush(batchUseRsp.pArray, &usedbRsp);
+      mndBuildDBVgroupInfo(NULL, pMnode, rsp.useDbRsp->pVgroupInfos);
+      rsp.useDbRsp->vgVersion = vgVersion++;
+      
+      rsp.useDbRsp->vgNum = taosArrayGetSize(rsp.useDbRsp->pVgroupInfos);
+
+      taosArrayPush(batchRsp.pArray, &rsp);
 
       continue;
     }
 
-    SDbObj *pDb = mndAcquireDb(pMnode, pDbVgVersion->dbFName);
+    SDbObj *pDb = mndAcquireDb(pMnode, pDbCacheInfo->dbFName);
     if (pDb == NULL) {
-      mTrace("db:%s, no exist", pDbVgVersion->dbFName);
-      memcpy(usedbRsp.db, pDbVgVersion->dbFName, TSDB_DB_FNAME_LEN);
-      usedbRsp.uid = pDbVgVersion->dbId;
-      usedbRsp.vgVersion = -1;
-      taosArrayPush(batchUseRsp.pArray, &usedbRsp);
+      mTrace("db:%s, no exist", pDbCacheInfo->dbFName);
+      rsp.useDbRsp = taosMemoryCalloc(1, sizeof(SUseDbRsp));
+      memcpy(rsp.useDbRsp->db, pDbCacheInfo->dbFName, TSDB_DB_FNAME_LEN);
+      rsp.useDbRsp->uid = pDbCacheInfo->dbId;
+      rsp.useDbRsp->vgVersion = -1;
+      taosArrayPush(batchRsp.pArray, &rsp);
       continue;
     }
 
     int32_t numOfTable = mndGetDBTableNum(pDb, pMnode);
 
-    if (pDbVgVersion->vgVersion >= pDb->vgVersion && numOfTable == pDbVgVersion->numOfTable &&
-        pDbVgVersion->stateTs == pDb->stateTs) {
-      mTrace("db:%s, valid dbinfo, vgVersion:%d stateTs:%" PRId64
-             " numOfTables:%d, not changed vgVersion:%d stateTs:%" PRId64 " numOfTables:%d",
-             pDbVgVersion->dbFName, pDbVgVersion->vgVersion, pDbVgVersion->stateTs, pDbVgVersion->numOfTable,
-             pDb->vgVersion, pDb->stateTs, numOfTable);
+    if (pDbCacheInfo->vgVersion >= pDb->vgVersion && 
+        pDbCacheInfo->cfgVersion >= pDb->cfgVersion &&
+        numOfTable == pDbCacheInfo->numOfTable &&
+        pDbCacheInfo->stateTs == pDb->stateTs) {
+      mTrace("db:%s, valid dbinfo, vgVersion:%d cfgVersion:%d stateTs:%" PRId64
+             " numOfTables:%d, not changed vgVersion:%d cfgVersion:%d stateTs:%" PRId64 " numOfTables:%d",
+             pDbCacheInfo->dbFName, pDbCacheInfo->vgVersion, pDbCacheInfo->cfgVersion, pDbCacheInfo->stateTs, pDbCacheInfo->numOfTable,
+             pDb->vgVersion, pDb->cfgVersion, pDb->stateTs, numOfTable);
       mndReleaseDb(pMnode, pDb);
       continue;
     } else {
-      mInfo("db:%s, valid dbinfo, vgVersion:%d stateTs:%" PRId64
-            " numOfTables:%d, changed to vgVersion:%d stateTs:%" PRId64 " numOfTables:%d",
-            pDbVgVersion->dbFName, pDbVgVersion->vgVersion, pDbVgVersion->stateTs, pDbVgVersion->numOfTable,
-            pDb->vgVersion, pDb->stateTs, numOfTable);
+      mInfo("db:%s, valid dbinfo, vgVersion:%d cfgVersion:%d stateTs:%" PRId64
+            " numOfTables:%d, changed to vgVersion:%d cfgVersion:%d stateTs:%" PRId64 " numOfTables:%d",
+            pDbCacheInfo->dbFName, pDbCacheInfo->vgVersion, pDbCacheInfo->cfgVersion, pDbCacheInfo->stateTs, pDbCacheInfo->numOfTable,
+            pDb->vgVersion, pDb->cfgVersion, pDb->stateTs, numOfTable);
     }
 
-    usedbRsp.pVgroupInfos = taosArrayInit(pDb->cfg.numOfVgroups, sizeof(SVgroupInfo));
-    if (usedbRsp.pVgroupInfos == NULL) {
-      mndReleaseDb(pMnode, pDb);
-      mError("db:%s, failed to malloc usedb response", pDb->name);
-      continue;
+    if (pDbCacheInfo->cfgVersion < pDb->cfgVersion) {
+      rsp.cfgRsp = taosMemoryCalloc(1, sizeof(SDbCfgRsp));
+      mndDumpDbCfgInfo(rsp.cfgRsp, pDb);
     }
 
-    mndBuildDBVgroupInfo(pDb, pMnode, usedbRsp.pVgroupInfos);
-    memcpy(usedbRsp.db, pDb->name, TSDB_DB_FNAME_LEN);
-    usedbRsp.uid = pDb->uid;
-    usedbRsp.vgVersion = pDb->vgVersion;
-    usedbRsp.stateTs = pDb->stateTs;
-    usedbRsp.vgNum = (int32_t)taosArrayGetSize(usedbRsp.pVgroupInfos);
-    usedbRsp.hashMethod = pDb->cfg.hashMethod;
-    usedbRsp.hashPrefix = pDb->cfg.hashPrefix;
-    usedbRsp.hashSuffix = pDb->cfg.hashSuffix;
+    if (pDbCacheInfo->vgVersion < pDb->vgVersion || 
+        numOfTable != pDbCacheInfo->numOfTable ||
+        pDbCacheInfo->stateTs != pDb->stateTs) {
+      rsp.useDbRsp = taosMemoryCalloc(1, sizeof(SUseDbRsp));
+      rsp.useDbRsp->pVgroupInfos = taosArrayInit(pDb->cfg.numOfVgroups, sizeof(SVgroupInfo));
+      if (rsp.useDbRsp->pVgroupInfos == NULL) {
+        mndReleaseDb(pMnode, pDb);
+        mError("db:%s, failed to malloc usedb response", pDb->name);
+        continue;
+      }
 
-    taosArrayPush(batchUseRsp.pArray, &usedbRsp);
+      mndBuildDBVgroupInfo(pDb, pMnode, rsp.useDbRsp->pVgroupInfos);
+      memcpy(rsp.useDbRsp->db, pDb->name, TSDB_DB_FNAME_LEN);
+      rsp.useDbRsp->uid = pDb->uid;
+      rsp.useDbRsp->vgVersion = pDb->vgVersion;
+      rsp.useDbRsp->stateTs = pDb->stateTs;
+      rsp.useDbRsp->vgNum = (int32_t)taosArrayGetSize(rsp.useDbRsp->pVgroupInfos);
+      rsp.useDbRsp->hashMethod = pDb->cfg.hashMethod;
+      rsp.useDbRsp->hashPrefix = pDb->cfg.hashPrefix;
+      rsp.useDbRsp->hashSuffix = pDb->cfg.hashSuffix;
+    }
+
+    taosArrayPush(batchRsp.pArray, &rsp);
     mndReleaseDb(pMnode, pDb);
   }
 
-  int32_t rspLen = tSerializeSUseDbBatchRsp(NULL, 0, &batchUseRsp);
+  int32_t rspLen = tSerializeSDbHbBatchRsp(NULL, 0, &batchRsp);
   void   *pRsp = taosMemoryMalloc(rspLen);
   if (pRsp == NULL) {
     terrno = TSDB_CODE_OUT_OF_MEMORY;
-    tFreeSUseDbBatchRsp(&batchUseRsp);
+    tFreeSDbHbBatchRsp(&batchRsp);
     return -1;
   }
-  tSerializeSUseDbBatchRsp(pRsp, rspLen, &batchUseRsp);
+  tSerializeSDbHbBatchRsp(pRsp, rspLen, &batchRsp);
 
   *ppRsp = pRsp;
   *pRspLen = rspLen;
 
-  tFreeSUseDbBatchRsp(&batchUseRsp);
+  tFreeSDbHbBatchRsp(&batchRsp);
   return 0;
 }
 
diff --git a/source/dnode/vnode/inc/vnode.h b/source/dnode/vnode/inc/vnode.h
index 90f8041a1b..6a1709c6f7 100644
--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@@ -123,6 +123,11 @@ int32_t  metaUidFilterCachePut(SMeta *pMeta, uint64_t suid, const void *pKey, in
                                int32_t payloadLen, double selectivityRatio);
 int32_t  metaUidCacheClear(SMeta *pMeta, uint64_t suid);
 tb_uid_t metaGetTableEntryUidByName(SMeta *pMeta, const char *name);
+int32_t  metaTbGroupCacheClear(SMeta* pMeta, uint64_t suid);
+int32_t  metaGetCachedTbGroup(SMeta* pMeta, tb_uid_t suid, const uint8_t* pKey, int32_t keyLen, SArray** pList);
+int32_t  metaPutTbGroupToCache(SMeta* pMeta, uint64_t suid, const void* pKey, int32_t keyLen, void* pPayload,
+                              int32_t payloadLen);
+
 int64_t  metaGetTbNum(SMeta *pMeta);
 int64_t  metaGetNtbNum(SMeta *pMeta);
 typedef struct {
diff --git a/source/dnode/vnode/src/meta/metaCache.c b/source/dnode/vnode/src/meta/metaCache.c
index b37e9272c5..436ca1abd3 100644
--- a/source/dnode/vnode/src/meta/metaCache.c
+++ b/source/dnode/vnode/src/meta/metaCache.c
@@ -729,7 +729,7 @@ int32_t metaGetCachedTbGroup(SMeta* pMeta, tb_uid_t suid, const uint8_t* pKey, i
     return TSDB_CODE_FAILED;
   }
 
-  *pList = taosLRUCacheValue(pCache, pHandle);
+  *pList = taosArrayDup(taosLRUCacheValue(pCache, pHandle), NULL);
 
   (*pEntry)->hitTimes += 1;
 
diff --git a/source/libs/catalog/src/catalog.c b/source/libs/catalog/src/catalog.c
index c2f3f52c08..6ffef6b181 100644
--- a/source/libs/catalog/src/catalog.c
+++ b/source/libs/catalog/src/catalog.c
@@ -933,6 +933,23 @@ _return:
   CTG_API_LEAVE(code);
 }
 
+int32_t catalogUpdateDbCfg(SCatalog* pCtg, const char* dbFName, uint64_t dbId, SDbCfgInfo* cfgInfo) {
+  CTG_API_ENTER();
+
+  int32_t code = 0;
+
+  if (NULL == pCtg || NULL == dbFName || NULL == cfgInfo) {
+    freeDbCfgInfo(cfgInfo);
+    CTG_ERR_JRET(TSDB_CODE_CTG_INVALID_INPUT);
+  }
+
+  code = ctgUpdateDbCfgEnqueue(pCtg, dbFName, dbId, cfgInfo, false);
+
+_return:
+
+  CTG_API_LEAVE(code);
+}
+
 int32_t catalogRemoveDB(SCatalog* pCtg, const char* dbFName, uint64_t dbId) {
   CTG_API_ENTER();
 
diff --git a/source/libs/catalog/src/ctgCache.c b/source/libs/catalog/src/ctgCache.c
index 85d2a5c1be..3000f152eb 100644
--- a/source/libs/catalog/src/ctgCache.c
+++ b/source/libs/catalog/src/ctgCache.c
@@ -1475,15 +1475,15 @@ int32_t ctgAddNewDBCache(SCatalog *pCtg, const char *dbFName, uint64_t dbId) {
 
   CTG_CACHE_NUM_INC(CTG_CI_DB, 1);
 
-  SDbCacheInfo vgVersion = {.dbId = newDBCache.dbId, .vgVersion = -1, .stateTs = 0};
-  tstrncpy(vgVersion.dbFName, dbFName, sizeof(vgVersion.dbFName));
+  SDbCacheInfo dbCacheInfo = {.dbId = newDBCache.dbId, .vgVersion = -1, .stateTs = 0, .cfgVersion = -1};
+  tstrncpy(dbCacheInfo.dbFName, dbFName, sizeof(dbCacheInfo.dbFName));
 
   ctgDebug("db added to cache, dbFName:%s, dbId:0x%" PRIx64, dbFName, dbId);
 
   if (!IS_SYS_DBNAME(dbFName)) {
-    CTG_ERR_RET(ctgMetaRentAdd(&pCtg->dbRent, &vgVersion, dbId, sizeof(SDbCacheInfo)));
+    CTG_ERR_RET(ctgMetaRentAdd(&pCtg->dbRent, &dbCacheInfo, dbId, sizeof(SDbCacheInfo)));
 
-    ctgDebug("db added to rent, dbFName:%s, vgVersion:%d, dbId:0x%" PRIx64, dbFName, vgVersion.vgVersion, dbId);
+    ctgDebug("db added to rent, dbFName:%s, vgVersion:%d, dbId:0x%" PRIx64, dbFName, dbCacheInfo.vgVersion, dbId);
   }
 
   return TSDB_CODE_SUCCESS;
@@ -1822,8 +1822,8 @@ int32_t ctgOpUpdateVgroup(SCtgCacheOperation *operation) {
   }
 
   bool         newAdded = false;
-  SDbCacheInfo vgVersion = {
-      .dbId = msg->dbId, .vgVersion = dbInfo->vgVersion, .numOfTable = dbInfo->numOfTable, .stateTs = dbInfo->stateTs};
+  SDbCacheInfo dbCacheInfo = {
+      .dbId = msg->dbId, .vgVersion = dbInfo->vgVersion, .cfgVersion = -1, .numOfTable = dbInfo->numOfTable, .stateTs = dbInfo->stateTs};
 
   SCtgDBCache *dbCache = NULL;
   CTG_ERR_JRET(ctgGetAddDBCache(msg->pCtg, dbFName, msg->dbId, &dbCache));
@@ -1859,20 +1859,24 @@ int32_t ctgOpUpdateVgroup(SCtgCacheOperation *operation) {
     CTG_DB_NUM_RESET(CTG_CI_DB_VGROUP);
   }
 
+  if (dbCache->cfgCache.cfgInfo) {
+    dbCacheInfo.cfgVersion = dbCache->cfgCache.cfgInfo->cfgVersion;
+  }
+
   vgCache->vgInfo = dbInfo;
   msg->dbInfo = NULL;
   CTG_DB_NUM_SET(CTG_CI_DB_VGROUP);
 
   ctgDebug("db vgInfo updated, dbFName:%s, vgVer:%d, stateTs:%" PRId64 ", dbId:0x%" PRIx64, dbFName,
-           vgVersion.vgVersion, vgVersion.stateTs, vgVersion.dbId);
+           dbCacheInfo.vgVersion, dbCacheInfo.stateTs, dbCacheInfo.dbId);
 
   ctgWUnlockVgInfo(dbCache);
 
   dbCache = NULL;
 
   // if (!IS_SYS_DBNAME(dbFName)) {
-  tstrncpy(vgVersion.dbFName, dbFName, sizeof(vgVersion.dbFName));
-  CTG_ERR_JRET(ctgMetaRentUpdate(&msg->pCtg->dbRent, &vgVersion, vgVersion.dbId, sizeof(SDbCacheInfo),
+  tstrncpy(dbCacheInfo.dbFName, dbFName, sizeof(dbCacheInfo.dbFName));
+  CTG_ERR_JRET(ctgMetaRentUpdate(&msg->pCtg->dbRent, &dbCacheInfo, dbCacheInfo.dbId, sizeof(SDbCacheInfo),
                                  ctgDbCacheInfoSortCompare, ctgDbCacheInfoSearchCompare));
   //}
 
diff --git a/source/libs/catalog/src/ctgDbg.c b/source/libs/catalog/src/ctgDbg.c
index 12ff8a7b38..8924e8c27c 100644
--- a/source/libs/catalog/src/ctgDbg.c
+++ b/source/libs/catalog/src/ctgDbg.c
@@ -501,6 +501,25 @@ void ctgdShowDBCache(SCatalog *pCtg, SHashObj *dbHash) {
       }
     }
 
+    if (dbCache->cfgCache.cfgInfo) {
+      SDbCfgInfo *pCfg = dbCache->cfgCache.cfgInfo;
+      ctgDebug("[%d] db [%.*s][0x%" PRIx64
+               "] %s: cfgVersion:%d, numOfVgroups:%d, numOfStables:%d, buffer:%d, cacheSize:%d, pageSize:%d, pages:%d"
+               ", daysPerFile:%d, daysToKeep0:%d, daysToKeep1:%d, daysToKeep2:%d, minRows:%d, maxRows:%d, walFsyncPeriod:%d"
+               ", hashPrefix:%d, hashSuffix:%d, walLevel:%d, precision:%d, compression:%d, replications:%d, strict:%d"
+               ", cacheLast:%d, tsdbPageSize:%d, walRetentionPeriod:%d, walRollPeriod:%d, walRetentionSize:%" PRId64 ""
+               ", walSegmentSize:%" PRId64 ", numOfRetensions:%d, schemaless:%d, sstTrigger:%d",
+               i, (int32_t)len, dbFName, dbCache->dbId, dbCache->deleted ? "deleted" : "", 
+               pCfg->cfgVersion, pCfg->numOfVgroups, pCfg->numOfStables, pCfg->buffer,
+               pCfg->cacheSize, pCfg->pageSize, pCfg->pages, pCfg->daysPerFile, pCfg->daysToKeep0,
+               pCfg->daysToKeep1, pCfg->daysToKeep2, pCfg->minRows, pCfg->maxRows, pCfg->walFsyncPeriod,
+               pCfg->hashPrefix, pCfg->hashSuffix, pCfg->walLevel, pCfg->precision, pCfg->compression,
+               pCfg->replications, pCfg->strict, pCfg->cacheLast, pCfg->tsdbPageSize, pCfg->walRetentionPeriod,
+               pCfg->walRollPeriod, pCfg->walRetentionSize, pCfg->walSegmentSize, pCfg->numOfRetensions,
+               pCfg->schemaless, pCfg->sstTrigger);
+    }
+
+    ++i;
     pIter = taosHashIterate(dbHash, pIter);
   }
 }
diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index 080ed37ee9..3a8875e997 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -61,7 +61,7 @@ static int32_t        optimizeTbnameInCond(void* metaHandle, int64_t suid, SArra
 static int32_t        optimizeTbnameInCondImpl(void* metaHandle, SArray* list, SNode* pTagCond);
 
 static int32_t      getTableList(void* metaHandle, void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond,
-                                 SNode* pTagIndexCond, STableListInfo* pListInfo, const char* idstr);
+                                 SNode* pTagIndexCond, STableListInfo* pListInfo, uint8_t* digest, const char* idstr);
 static SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, SArray* pUidTagList,
                                                void* metaHandle);
 
@@ -436,7 +436,6 @@ void freeItem(void* p) {
   }
 }
 
-
 static void genTagFilterDigest(const SNode* pTagCond, T_MD5_CTX* pContext) {
   if (pTagCond == NULL) {
     return;
@@ -454,7 +453,25 @@ static void genTagFilterDigest(const SNode* pTagCond, T_MD5_CTX* pContext) {
 }
 
 
-int32_t getColInfoResultForGroupby(void* metaHandle, SNodeList* group, STableListInfo* pTableListInfo) {
+static void genTbGroupDigest(const SNode* pGroup, uint8_t* filterDigest, T_MD5_CTX* pContext) {
+  char*   payload = NULL;
+  int32_t len = 0;
+  nodesNodeToMsg(pGroup, &payload, &len);
+  if (filterDigest[0]) {
+    payload = taosMemoryRealloc(payload, len + tListLen(pContext->digest));
+    memcpy(payload + len, filterDigest + 1, tListLen(pContext->digest));
+    len += tListLen(pContext->digest);
+  }
+
+  tMD5Init(pContext);
+  tMD5Update(pContext, (uint8_t*)payload, (uint32_t)len);
+  tMD5Final(pContext);
+
+  taosMemoryFree(payload);
+}
+
+
+int32_t getColInfoResultForGroupby(void* metaHandle, SNodeList* group, STableListInfo* pTableListInfo, uint8_t *digest) {
   int32_t      code = TSDB_CODE_SUCCESS;
   SArray*      pBlockList = NULL;
   SSDataBlock* pResBlock = NULL;
@@ -462,7 +479,6 @@ int32_t getColInfoResultForGroupby(void* metaHandle, SNodeList* group, STableLis
   SArray*      groupData = NULL;
   SArray*      pUidTagList = NULL;
   SArray*      tableList = NULL;
-  static SHashObj *pTableListHash = NULL;
 
   int32_t rows = taosArrayGetSize(pTableListInfo->pTableList);
   if (rows == 0) {
@@ -490,17 +506,19 @@ int32_t getColInfoResultForGroupby(void* metaHandle, SNodeList* group, STableLis
   }
 
   T_MD5_CTX context = {0};
-  SNodeListNode* listNode = (SNodeListNode*)nodesMakeNode(QUERY_NODE_NODE_LIST);
-  listNode->pNodeList = group;
-  genTagFilterDigest((SNode *)listNode, &context);
-  nodesFree(listNode);
-
-  SArray **pLastTableList = (SArray **)taosHashGet(pTableListHash, context.digest, sizeof(context.digest));
-  if (pLastTableList && *pLastTableList) {
-    pTableListInfo->pTableList = taosArrayDup(*pLastTableList, NULL);
-    goto end;
-  } else {
-    qError("group not hit");
+  if (tsTagFilterCache) {
+    SNodeListNode* listNode = (SNodeListNode*)nodesMakeNode(QUERY_NODE_NODE_LIST);
+    listNode->pNodeList = group;
+    genTbGroupDigest((SNode *)listNode, digest, &context);
+    nodesFree(listNode);
+    
+    metaGetCachedTbGroup(metaHandle, pTableListInfo->idInfo.suid, context.digest, tListLen(context.digest), &tableList);
+    if (tableList) {
+      taosArrayDestroy(pTableListInfo->pTableList);
+      pTableListInfo->pTableList = tableList;
+      qDebug("retrieve tb group list from cache, numOfTables:%d", (int32_t)taosArrayGetSize(pTableListInfo->pTableList));
+      goto end;
+    }
   }
   
   pUidTagList = taosArrayInit(8, sizeof(STUidTagInfo));
@@ -629,16 +647,11 @@ int32_t getColInfoResultForGroupby(void* metaHandle, SNodeList* group, STableLis
     info->groupId = calcGroupId(keyBuf, len);
   }
 
-  if (NULL == pTableListHash) {
-    SHashObj *pHash = taosHashInit(10, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
-    if (atomic_val_compare_exchange_ptr(&pTableListHash, NULL, pHash)) {
-      taosHashCleanup(pHash);
-    }
+  if (tsTagFilterCache) {
+    tableList = taosArrayDup(pTableListInfo->pTableList, NULL);
+    metaPutTbGroupToCache(metaHandle, pTableListInfo->idInfo.suid, context.digest, tListLen(context.digest), tableList, taosArrayGetSize(tableList) * sizeof(STableKeyInfo));
   }
   
-  tableList = taosArrayDup(pTableListInfo->pTableList, NULL);
-  taosHashPut(pTableListHash, context.digest, sizeof(context.digest), &tableList, POINTER_BYTES);
-
   //  int64_t st2 = taosGetTimestampUs();
   //  qDebug("calculate tag block rows:%d, cost:%ld us", rows, st2-st1);
 
@@ -1057,7 +1070,7 @@ end:
 }
 
 int32_t getTableList(void* metaHandle, void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, SNode* pTagIndexCond,
-                     STableListInfo* pListInfo, const char* idstr) {
+                     STableListInfo* pListInfo, uint8_t* digest, const char* idstr) {
   int32_t code = TSDB_CODE_SUCCESS;
   size_t  numOfTables = 0;
 
@@ -1087,6 +1100,8 @@ int32_t getTableList(void* metaHandle, void* pVnode, SScanPhysiNode* pScanNode,
       metaGetCachedTableUidList(metaHandle, pScanNode->suid, context.digest, tListLen(context.digest), pUidList,
                                 &acquired);
       if (acquired) {
+        digest[0] = 1;
+        memcpy(digest + 1, context.digest, tListLen(context.digest));
         qDebug("retrieve table uid list from cache, numOfTables:%d", (int32_t)taosArrayGetSize(pUidList));
         goto _end;
       }
@@ -1130,6 +1145,8 @@ int32_t getTableList(void* metaHandle, void* pVnode, SScanPhysiNode* pScanNode,
       }
 
       metaUidFilterCachePut(metaHandle, pScanNode->suid, context.digest, tListLen(context.digest), pPayload, size, 1);
+      digest[0] = 1;
+      memcpy(digest + 1, context.digest, tListLen(context.digest));
     }
   }
 
@@ -2025,7 +2042,7 @@ static int32_t sortTableGroup(STableListInfo* pTableListInfo) {
 }
 
 int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle* pHandle, SScanPhysiNode* pScanNode, SNodeList* group,
-                                    bool groupSort) {
+                                    bool groupSort, uint8_t *digest) {
   int32_t code = TSDB_CODE_SUCCESS;
 
   bool   groupByTbname = groupbyTbname(group);
@@ -2045,7 +2062,7 @@ int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle*
       pTableListInfo->numOfOuputGroups = 1;
     }
   } else {
-    code = getColInfoResultForGroupby(pHandle->meta, group, pTableListInfo);
+    code = getColInfoResultForGroupby(pHandle->meta, group, pTableListInfo, digest);
     if (code != TSDB_CODE_SUCCESS) {
       return code;
     }
@@ -2076,7 +2093,8 @@ int32_t createScanTableListInfo(SScanPhysiNode* pScanNode, SNodeList* pGroupTags
     return TSDB_CODE_INVALID_PARA;
   }
 
-  int32_t code = getTableList(pHandle->meta, pHandle->vnode, pScanNode, pTagCond, pTagIndexCond, pTableListInfo, idStr);
+  uint8_t digest[17] = {0};
+  int32_t code = getTableList(pHandle->meta, pHandle->vnode, pScanNode, pTagCond, pTagIndexCond, pTableListInfo, digest, idStr);
   if (code != TSDB_CODE_SUCCESS) {
     qError("failed to getTableList, code: %s", tstrerror(code));
     return code;
@@ -2094,7 +2112,7 @@ int32_t createScanTableListInfo(SScanPhysiNode* pScanNode, SNodeList* pGroupTags
     return TSDB_CODE_SUCCESS;
   }
 
-  code = buildGroupIdMapForAllTables(pTableListInfo, pHandle, pScanNode, pGroupTags, groupSort);
+  code = buildGroupIdMapForAllTables(pTableListInfo, pHandle, pScanNode, pGroupTags, groupSort, digest);
   if (code != TSDB_CODE_SUCCESS) {
     return code;
   }

From cacbc7d3d3a20f15f5e65eccf21e7a116dcff5c4 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Wed, 10 May 2023 16:20:44 +0800
Subject: [PATCH 33/44] fix: query stop issue

---
 source/libs/qworker/src/qworker.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c
index 7b5d85a6f5..3daec242e7 100644
--- a/source/libs/qworker/src/qworker.c
+++ b/source/libs/qworker/src/qworker.c
@@ -764,8 +764,10 @@ int32_t qwProcessCQuery(QW_FPARAMS_DEF, SQWMsg *qwMsg) {
     atomic_store_8((int8_t *)&ctx->queryInQueue, 0);
     atomic_store_8((int8_t *)&ctx->queryContinue, 0);
 
-    QW_ERR_JRET(qwExecTask(QW_FPARAMS(), ctx, &queryStop));
-
+    if (!queryStop) {
+      QW_ERR_JRET(qwExecTask(QW_FPARAMS(), ctx, &queryStop));
+    }
+    
     if (QW_EVENT_RECEIVED(ctx, QW_EVENT_FETCH)) {
       SOutputData sOutput = {0};
       QW_ERR_JRET(qwGetQueryResFromSink(QW_FPARAMS(), ctx, &dataLen, &rsp, &sOutput));

From 0dd0b16842be80da91c90909d24df680ee4f623c Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Fri, 12 May 2023 13:30:17 +0800
Subject: [PATCH 34/44] enh: optimize table scan for last query

---
 include/libs/function/functionMgt.h        |  1 +
 source/dnode/vnode/inc/vnode.h             |  2 +-
 source/dnode/vnode/src/tsdb/tsdbRead.c     | 41 +++++++++++++++++---
 source/libs/executor/inc/executil.h        | 20 +++++++++-
 source/libs/executor/inc/executorimpl.h    |  1 +
 source/libs/executor/src/executil.c        | 17 --------
 source/libs/executor/src/executor.c        |  4 +-
 source/libs/executor/src/scanoperator.c    | 45 +++++++++++++++++++---
 source/libs/executor/src/sysscanoperator.c |  2 +-
 9 files changed, 100 insertions(+), 33 deletions(-)

diff --git a/include/libs/function/functionMgt.h b/include/libs/function/functionMgt.h
index 42bc89f0b7..f097a2b2df 100644
--- a/include/libs/function/functionMgt.h
+++ b/include/libs/function/functionMgt.h
@@ -230,6 +230,7 @@ typedef enum EFuncDataRequired {
   FUNC_DATA_REQUIRED_SMA_LOAD,
   FUNC_DATA_REQUIRED_NOT_LOAD,
   FUNC_DATA_REQUIRED_FILTEROUT,
+  FUNC_DATA_REQUIRED_ALL_FILTEROUT,
 } EFuncDataRequired;
 
 EFuncDataRequired fmFuncDataRequired(SFunctionNode* pFunc, STimeWindow* pTimeWindow);
diff --git a/source/dnode/vnode/inc/vnode.h b/source/dnode/vnode/inc/vnode.h
index 6a1709c6f7..a8b2a74019 100644
--- a/source/dnode/vnode/inc/vnode.h
+++ b/source/dnode/vnode/inc/vnode.h
@@ -183,7 +183,7 @@ typedef struct STsdbReader STsdbReader;
 
 int32_t tsdbSetTableList(STsdbReader *pReader, const void *pTableList, int32_t num);
 int32_t tsdbReaderOpen(SVnode *pVnode, SQueryTableDataCond *pCond, void *pTableList, int32_t numOfTables,
-                       SSDataBlock *pResBlock, STsdbReader **ppReader, const char *idstr, bool countOnly);
+                       SSDataBlock *pResBlock, STsdbReader **ppReader, const char *idstr, bool countOnly, SHashObj** pIgnoreTables);
 
 void         tsdbReaderSetId(STsdbReader* pReader, const char* idstr);
 void         tsdbReaderClose(STsdbReader *pReader);
diff --git a/source/dnode/vnode/src/tsdb/tsdbRead.c b/source/dnode/vnode/src/tsdb/tsdbRead.c
index 5bd41dd86f..2b6f175158 100644
--- a/source/dnode/vnode/src/tsdb/tsdbRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRead.c
@@ -193,6 +193,7 @@ struct STsdbReader {
   SBlockInfoBuf blockInfoBuf;
   int32_t       step;
   STsdbReader*  innerReader[2];
+  SHashObj**    pIgnoreTables;
 };
 
 static SFileDataBlockInfo* getCurrentBlockInfo(SDataBlockIter* pBlockIter);
@@ -2704,15 +2705,21 @@ static int32_t buildComposedDataBlock(STsdbReader* pReader) {
   int64_t st = taosGetTimestampUs();
   int32_t step = asc ? 1 : -1;
   double  el = 0;
+  SDataBlk* pBlock = getCurrentBlock(&pReader->status.blockIter);
+  SFileBlockDumpInfo* pDumpInfo = &pReader->status.fBlockDumpInfo;
 
   STableBlockScanInfo* pBlockScanInfo = NULL;
   if (pBlockInfo != NULL) {
+    if (*pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pBlockScanInfo->uid, sizeof(pBlockScanInfo->uid))) {
+      setBlockAllDumped(pDumpInfo, pBlock->maxKey.ts, pReader->order);
+      return code;
+    }
+    
     pBlockScanInfo = getTableBlockScanInfo(pReader->status.pTableMap, pBlockInfo->uid, pReader->idStr);
     if (pBlockScanInfo == NULL) {
       goto _end;
     }
 
-    SDataBlk* pBlock = getCurrentBlock(&pReader->status.blockIter);
     TSDBKEY   keyInBuf = getCurrentKeyInBuf(pBlockScanInfo, pReader);
 
     // it is a clean block, load it directly
@@ -2731,9 +2738,12 @@ static int32_t buildComposedDataBlock(STsdbReader* pReader) {
     }
   } else {  // file blocks not exist
     pBlockScanInfo = *pReader->status.pTableIter;
+    if (*pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pBlockScanInfo->uid, sizeof(pBlockScanInfo->uid))) {
+      setBlockAllDumped(pDumpInfo, pBlock->maxKey.ts, pReader->order);
+      return code;
+    }
   }
 
-  SFileBlockDumpInfo* pDumpInfo = &pReader->status.fBlockDumpInfo;
   SBlockData*         pBlockData = &pReader->status.fileBlockData;
 
   while (1) {
@@ -3009,6 +3019,14 @@ static int32_t doLoadLastBlockSequentially(STsdbReader* pReader) {
   while (1) {
     // load the last data block of current table
     STableBlockScanInfo* pScanInfo = *(STableBlockScanInfo**)pStatus->pTableIter;
+    if (*pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pScanInfo->uid, sizeof(pScanInfo->uid))) {
+      bool hasNexTable = moveToNextTable(pUidList, pStatus);
+      if (!hasNexTable) {
+        return TSDB_CODE_SUCCESS;
+      }
+
+      continue;
+    }
 
     bool hasVal = initLastBlockReader(pLastBlockReader, pScanInfo, pReader);
     if (!hasVal) {
@@ -3060,20 +3078,24 @@ static int32_t doLoadLastBlockSequentially(STsdbReader* pReader) {
 
 static int32_t doBuildDataBlock(STsdbReader* pReader) {
   int32_t   code = TSDB_CODE_SUCCESS;
-  SDataBlk* pBlock = NULL;
 
   SReaderStatus*       pStatus = &pReader->status;
   SDataBlockIter*      pBlockIter = &pStatus->blockIter;
   STableBlockScanInfo* pScanInfo = NULL;
   SFileDataBlockInfo*  pBlockInfo = getCurrentBlockInfo(pBlockIter);
   SLastBlockReader*    pLastBlockReader = pReader->status.fileIter.pLastBlockReader;
+  SDataBlk*            pBlock = getCurrentBlock(pBlockIter);
+
+  if (*pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pBlockInfo->uid, sizeof(pBlockInfo->uid))) {
+    setBlockAllDumped(&pStatus->fBlockDumpInfo, pBlock->maxKey.ts, pReader->order);
+    return code;
+  }
 
   pScanInfo = getTableBlockScanInfo(pReader->status.pTableMap, pBlockInfo->uid, pReader->idStr);
   if (pScanInfo == NULL) {
     return terrno;
   }
 
-  pBlock = getCurrentBlock(pBlockIter);
 
   initLastBlockReader(pLastBlockReader, pScanInfo, pReader);
   TSDBKEY keyInBuf = getCurrentKeyInBuf(pScanInfo, pReader);
@@ -3309,6 +3331,13 @@ static int32_t buildBlockFromBufferSequentially(STsdbReader* pReader) {
     //    }
 
     STableBlockScanInfo** pBlockScanInfo = pStatus->pTableIter;
+    if (*pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &(*pBlockScanInfo)->uid, sizeof((*pBlockScanInfo)->uid))) {
+      bool hasNexTable = moveToNextTable(pUidList, pStatus);
+      if (!hasNexTable) {
+        return TSDB_CODE_SUCCESS;
+      }
+    }
+    
     initMemDataIterator(*pBlockScanInfo, pReader);
 
     int64_t endKey = (ASCENDING_TRAVERSE(pReader->order)) ? INT64_MAX : INT64_MIN;
@@ -4257,7 +4286,7 @@ static void freeSchemaFunc(void* param) {
 
 // ====================================== EXPOSED APIs ======================================
 int32_t tsdbReaderOpen(SVnode* pVnode, SQueryTableDataCond* pCond, void* pTableList, int32_t numOfTables,
-                       SSDataBlock* pResBlock, STsdbReader** ppReader, const char* idstr, bool countOnly) {
+                       SSDataBlock* pResBlock, STsdbReader** ppReader, const char* idstr, bool countOnly, SHashObj** pIgnoreTables) {
   STimeWindow window = pCond->twindows;
 
   int32_t capacity = pVnode->config.tsdbCfg.maxRows;
@@ -4357,6 +4386,8 @@ int32_t tsdbReaderOpen(SVnode* pVnode, SQueryTableDataCond* pCond, void* pTableL
     pReader->readMode = READ_MODE_COUNT_ONLY;
   }
 
+  pReader->pIgnoreTables = pIgnoreTables;
+
   tsdbDebug("%p total numOfTable:%d in this query %s", pReader, numOfTables, pReader->idStr);
   return code;
 
diff --git a/source/libs/executor/inc/executil.h b/source/libs/executor/inc/executil.h
index 2e92f9e396..a4a55e91fb 100644
--- a/source/libs/executor/inc/executil.h
+++ b/source/libs/executor/inc/executil.h
@@ -89,7 +89,25 @@ typedef struct SColMatchInfo {
 } SColMatchInfo;
 
 typedef struct SExecTaskInfo SExecTaskInfo;
-typedef struct STableListInfo STableListInfo;
+
+
+typedef struct STableListIdInfo {
+  uint64_t suid;
+  uint64_t uid;
+  int32_t  tableType;
+} STableListIdInfo;
+
+// If the numOfOutputGroups is 1, the data blocks that belongs to different groups will be provided randomly
+// The numOfOutputGroups is specified by physical plan. and will not be affect by numOfGroups
+typedef struct STableListInfo {
+  bool             oneTableForEachGroup;
+  int32_t          numOfOuputGroups;  // the data block will be generated one by one
+  int32_t*         groupOffset;       // keep the offset value for each group in the tableList
+  SArray*          pTableList;
+  SHashObj*        map;     // speedup acquire the tableQueryInfo by table uid
+  STableListIdInfo idInfo;  // this maybe the super table or ordinary table
+} STableListInfo;
+
 struct SqlFunctionCtx;
 
 int32_t createScanTableListInfo(SScanPhysiNode* pScanNode, SNodeList* pGroupTags, bool groupSort, SReadHandle* pHandle,
diff --git a/source/libs/executor/inc/executorimpl.h b/source/libs/executor/inc/executorimpl.h
index 85424fd7de..f4e0108b92 100644
--- a/source/libs/executor/inc/executorimpl.h
+++ b/source/libs/executor/inc/executorimpl.h
@@ -327,6 +327,7 @@ typedef struct STableScanInfo {
   SScanInfo       scanInfo;
   int32_t         scanTimes;
   SSDataBlock*    pResBlock;
+  SHashObj*       pIgnoreTables;
   SSampleExecInfo sample;  // sample execution info
   int32_t         currentGroupId;
   int32_t         currentTable;
diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index 3a8875e997..c265c0b003 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -27,23 +27,6 @@
 #include "executorimpl.h"
 #include "tcompression.h"
 
-typedef struct STableListIdInfo {
-  uint64_t suid;
-  uint64_t uid;
-  int32_t  tableType;
-} STableListIdInfo;
-
-// If the numOfOutputGroups is 1, the data blocks that belongs to different groups will be provided randomly
-// The numOfOutputGroups is specified by physical plan. and will not be affect by numOfGroups
-struct STableListInfo {
-  bool             oneTableForEachGroup;
-  int32_t          numOfOuputGroups;  // the data block will be generated one by one
-  int32_t*         groupOffset;       // keep the offset value for each group in the tableList
-  SArray*          pTableList;
-  SHashObj*        map;     // speedup acquire the tableQueryInfo by table uid
-  STableListIdInfo idInfo;  // this maybe the super table or ordinary table
-};
-
 typedef struct tagFilterAssist {
   SHashObj* colHash;
   int32_t   index;
diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c
index f979987ad0..c6f5d3912d 100644
--- a/source/libs/executor/src/executor.c
+++ b/source/libs/executor/src/executor.c
@@ -1170,7 +1170,7 @@ int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subT
 
       if (pScanBaseInfo->dataReader == NULL) {
         int32_t code = tsdbReaderOpen(pScanBaseInfo->readHandle.vnode, &pScanBaseInfo->cond, &keyInfo, 1,
-                                      pScanInfo->pResBlock, &pScanBaseInfo->dataReader, id, false);
+                                      pScanInfo->pResBlock, &pScanBaseInfo->dataReader, id, false, NULL);
         if (code != TSDB_CODE_SUCCESS) {
           qError("prepare read tsdb snapshot failed, uid:%" PRId64 ", code:%s %s", pOffset->uid, tstrerror(code), id);
           terrno = code;
@@ -1229,7 +1229,7 @@ int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subT
       int32_t        size = tableListGetSize(pTableListInfo);
 
       tsdbReaderOpen(pInfo->vnode, &pTaskInfo->streamInfo.tableCond, pList, size, NULL, &pInfo->dataReader, NULL,
-                     false);
+                     false, NULL);
 
       cleanupQueryTableDataCond(&pTaskInfo->streamInfo.tableCond);
       strcpy(pTaskInfo->streamInfo.tbName, mtInfo.tbName);
diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c
index 2389c7252e..1c57db6d71 100644
--- a/source/libs/executor/src/scanoperator.c
+++ b/source/libs/executor/src/scanoperator.c
@@ -192,9 +192,24 @@ static SResultRow* getTableGroupOutputBuf(SOperatorInfo* pOperator, uint64_t gro
   return (SResultRow*)((char*)(*pPage) + p1->offset);
 }
 
+static int32_t insertTableToScanIgnoreList(STableScanInfo* pTableScanInfo, uint64_t uid) {
+  if (NULL == pTableScanInfo->pIgnoreTables) {
+    int32_t tableNum = taosArrayGetSize(pTableScanInfo->base.pTableListInfo->pTableList);
+    pTableScanInfo->pIgnoreTables = taosHashInit(tableNum,  taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK);
+    if (NULL == pTableScanInfo->pIgnoreTables) {
+      return TSDB_CODE_OUT_OF_MEMORY;
+    }
+  }
+  
+  taosHashPut(pTableScanInfo->pIgnoreTables, &uid, sizeof(uid), &pTableScanInfo->scanTimes, sizeof(pTableScanInfo->scanTimes));
+
+  return TSDB_CODE_SUCCESS;
+}
+
 static int32_t doDynamicPruneDataBlock(SOperatorInfo* pOperator, SDataBlockInfo* pBlockInfo, uint32_t* status) {
   STableScanInfo* pTableScanInfo = pOperator->info;
-
+  int32_t code = TSDB_CODE_SUCCESS;
+  
   if (pTableScanInfo->base.pdInfo.pExprSup == NULL) {
     return TSDB_CODE_SUCCESS;
   }
@@ -226,9 +241,10 @@ static int32_t doDynamicPruneDataBlock(SOperatorInfo* pOperator, SDataBlockInfo*
 
   if (notLoadBlock) {
     *status = FUNC_DATA_REQUIRED_NOT_LOAD;
+    code = insertTableToScanIgnoreList(pTableScanInfo, pBlockInfo->id.uid);
   }
 
-  return TSDB_CODE_SUCCESS;
+  return code;
 }
 
 static bool doFilterByBlockSMA(SFilterInfo* pFilterInfo, SColumnDataAgg** pColsAgg, int32_t numOfCols,
@@ -380,7 +396,13 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanBase* pTableSca
            GET_TASKID(pTaskInfo), pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows);
     pCost->skipBlocks += 1;
     tsdbReleaseDataBlock(pTableScanInfo->dataReader);
-    *status = FUNC_DATA_REQUIRED_FILTEROUT;
+
+    STableScanInfo* pTableScanInfo = pOperator->info;
+    if (taosHashGetSize(pTableScanInfo->pIgnoreTables) == taosArrayGetSize(pTableScanInfo->base.pTableListInfo->pTableList)) {
+      *status = FUNC_DATA_REQUIRED_ALL_FILTEROUT;
+    } else {
+      *status = FUNC_DATA_REQUIRED_FILTEROUT;
+    }
     return TSDB_CODE_SUCCESS;
   }
 
@@ -695,6 +717,10 @@ static SSDataBlock* doTableScanImpl(SOperatorInfo* pOperator) {
       T_LONG_JMP(pTaskInfo->env, code);
     }
 
+    if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {
+      break;
+    }
+
     // current block is filter out according to filter condition, continue load the next block
     if (status == FUNC_DATA_REQUIRED_FILTEROUT || pBlock->info.rows == 0) {
       continue;
@@ -734,6 +760,7 @@ static SSDataBlock* doGroupedTableScan(SOperatorInfo* pOperator) {
     }
 
     pTableScanInfo->scanTimes += 1;
+    taosHashClear(pTableScanInfo->pIgnoreTables);
 
     if (pTableScanInfo->scanTimes < pTableScanInfo->scanInfo.numOfAsc) {
       setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED);
@@ -761,6 +788,7 @@ static SSDataBlock* doGroupedTableScan(SOperatorInfo* pOperator) {
       }
 
       pTableScanInfo->scanTimes += 1;
+      taosHashClear(pTableScanInfo->pIgnoreTables);
 
       if (pTableScanInfo->scanTimes < total) {
         setTaskStatus(pTaskInfo, TASK_NOT_COMPLETED);
@@ -825,7 +853,7 @@ static SSDataBlock* doTableScan(SOperatorInfo* pOperator) {
       ASSERT(pInfo->base.dataReader == NULL);
 
       int32_t code = tsdbReaderOpen(pInfo->base.readHandle.vnode, &pInfo->base.cond, pList, num, pInfo->pResBlock,
-                                    (STsdbReader**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), pInfo->countOnly);
+                                    (STsdbReader**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), pInfo->countOnly, &pInfo->pIgnoreTables);
       if (code != TSDB_CODE_SUCCESS) {
         T_LONG_JMP(pTaskInfo->env, code);
       }
@@ -894,6 +922,7 @@ static void destroyTableScanBase(STableScanBase* pBase) {
 static void destroyTableScanOperatorInfo(void* param) {
   STableScanInfo* pTableScanInfo = (STableScanInfo*)param;
   blockDataDestroy(pTableScanInfo->pResBlock);
+  taosHashCleanup(pTableScanInfo->pIgnoreTables);
   destroyTableScanBase(&pTableScanInfo->base);
   taosMemoryFreeClear(param);
 }
@@ -1059,7 +1088,7 @@ static SSDataBlock* readPreVersionData(SOperatorInfo* pTableScanOp, uint64_t tbU
   SSDataBlock* pBlock = pTableScanInfo->pResBlock;
   STsdbReader* pReader = NULL;
   int32_t      code = tsdbReaderOpen(pTableScanInfo->base.readHandle.vnode, &cond, &tblInfo, 1, pBlock,
-                                     (STsdbReader**)&pReader, GET_TASKID(pTaskInfo), false);
+                                     (STsdbReader**)&pReader, GET_TASKID(pTaskInfo), false, NULL);
   if (code != TSDB_CODE_SUCCESS) {
     terrno = code;
     T_LONG_JMP(pTaskInfo->env, code);
@@ -2662,7 +2691,7 @@ static SSDataBlock* getTableDataBlockImpl(void* param) {
   SReadHandle* pHandle = &pInfo->base.readHandle;
 
   if (NULL == source->dataReader || !source->multiReader) {
-    code = tsdbReaderOpen(pHandle->vnode, pQueryCond, p, 1, pBlock, &source->dataReader, GET_TASKID(pTaskInfo), false);
+    code = tsdbReaderOpen(pHandle->vnode, pQueryCond, p, 1, pBlock, &source->dataReader, GET_TASKID(pTaskInfo), false, NULL);
     if (code != 0) {
       T_LONG_JMP(pTaskInfo->env, code);
     }
@@ -2710,6 +2739,10 @@ static SSDataBlock* getTableDataBlockImpl(void* param) {
       T_LONG_JMP(pTaskInfo->env, code);
     }
 
+    if (status == FUNC_DATA_REQUIRED_ALL_FILTEROUT) {
+      break;
+    }
+
     // current block is filter out according to filter condition, continue load the next block
     if (status == FUNC_DATA_REQUIRED_FILTEROUT || pBlock->info.rows == 0) {
       continue;
diff --git a/source/libs/executor/src/sysscanoperator.c b/source/libs/executor/src/sysscanoperator.c
index 1abe678ac6..7dbf182d9a 100644
--- a/source/libs/executor/src/sysscanoperator.c
+++ b/source/libs/executor/src/sysscanoperator.c
@@ -2269,7 +2269,7 @@ SOperatorInfo* createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDi
     size_t num = tableListGetSize(pTableListInfo);
     void*  pList = tableListGetInfo(pTableListInfo, 0);
 
-    code = tsdbReaderOpen(readHandle->vnode, &cond, pList, num, pInfo->pResBlock, &pInfo->pHandle, pTaskInfo->id.str, false);
+    code = tsdbReaderOpen(readHandle->vnode, &cond, pList, num, pInfo->pResBlock, &pInfo->pHandle, pTaskInfo->id.str, false, NULL);
     cleanupQueryTableDataCond(&cond);
     if (code != 0) {
       goto _error;

From 026a4b55407a363c53ef08666ba626adea1ff6f8 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Fri, 12 May 2023 15:07:05 +0800
Subject: [PATCH 35/44] fix: fix compile issue

---
 source/libs/function/src/udfd.c | 24 ++++++++++--------------
 1 file changed, 10 insertions(+), 14 deletions(-)

diff --git a/source/libs/function/src/udfd.c b/source/libs/function/src/udfd.c
index aa72309c62..b198865696 100644
--- a/source/libs/function/src/udfd.c
+++ b/source/libs/function/src/udfd.c
@@ -54,16 +54,15 @@ int32_t udfdCPluginOpen(SScriptUdfEnvItem *items, int numItems) { return 0; }
 int32_t udfdCPluginClose() { return 0; }
 
 const char *udfdCPluginUdfInitLoadInitDestoryFuncs(SUdfCPluginCtx *udfCtx, const char *udfName) {
-  char  initFuncName[TSDB_FUNC_NAME_LEN + 5] = {0};
+  char  initFuncName[TSDB_FUNC_NAME_LEN + 6] = {0};
   char *initSuffix = "_init";
-  strcpy(initFuncName, udfName);
-  strncat(initFuncName, initSuffix, strlen(initSuffix));
+  snprintf(initFuncName, sizeof(initFuncName), "%s%s", udfName, initSuffix);
   uv_dlsym(&udfCtx->lib, initFuncName, (void **)(&udfCtx->initFunc));
 
-  char  destroyFuncName[TSDB_FUNC_NAME_LEN + 5] = {0};
+  char  destroyFuncName[TSDB_FUNC_NAME_LEN + 9] = {0};
   char *destroySuffix = "_destroy";
   strcpy(destroyFuncName, udfName);
-  strncat(destroyFuncName, destroySuffix, strlen(destroySuffix));
+  snprintf(destroyFuncName, sizeof(destroyFuncName), "%s%s", udfName, destroySuffix);
   uv_dlsym(&udfCtx->lib, destroyFuncName, (void **)(&udfCtx->destroyFunc));
   return udfName;
 }
@@ -73,22 +72,19 @@ void udfdCPluginUdfInitLoadAggFuncs(SUdfCPluginCtx *udfCtx, const char *udfName)
   strcpy(processFuncName, udfName);
   uv_dlsym(&udfCtx->lib, processFuncName, (void **)(&udfCtx->aggProcFunc));
 
-  char  startFuncName[TSDB_FUNC_NAME_LEN + 6] = {0};
+  char  startFuncName[TSDB_FUNC_NAME_LEN + 7] = {0};
   char *startSuffix = "_start";
-  strncpy(startFuncName, processFuncName, sizeof(startFuncName));
-  strncat(startFuncName, startSuffix, strlen(startSuffix));
+  snprintf(startFuncName, sizeof(startFuncName), "%s%s", processFuncName, startSuffix);
   uv_dlsym(&udfCtx->lib, startFuncName, (void **)(&udfCtx->aggStartFunc));
 
-  char  finishFuncName[TSDB_FUNC_NAME_LEN + 7] = {0};
+  char  finishFuncName[TSDB_FUNC_NAME_LEN + 8] = {0};
   char *finishSuffix = "_finish";
-  strncpy(finishFuncName, processFuncName, sizeof(finishFuncName));
-  strncat(finishFuncName, finishSuffix, strlen(finishSuffix));
+  snprintf(finishFuncName, sizeof(finishFuncName), "%s%s", processFuncName, finishSuffix);
   uv_dlsym(&udfCtx->lib, finishFuncName, (void **)(&udfCtx->aggFinishFunc));
 
-  char  mergeFuncName[TSDB_FUNC_NAME_LEN + 6] = {0};
+  char  mergeFuncName[TSDB_FUNC_NAME_LEN + 7] = {0};
   char *mergeSuffix = "_merge";
-  strncpy(mergeFuncName, processFuncName, sizeof(mergeFuncName));
-  strncat(mergeFuncName, mergeSuffix, strlen(mergeSuffix));
+  snprintf(mergeFuncName, sizeof(mergeFuncName), "%s%s", processFuncName, mergeSuffix);
   uv_dlsym(&udfCtx->lib, mergeFuncName, (void **)(&udfCtx->aggMergeFunc));
 }
 

From 1a52b3d519cc712f3b25135effb9860b0ff22bbd Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Fri, 12 May 2023 18:13:16 +0800
Subject: [PATCH 36/44] fix: taosd crash issue

---
 source/dnode/vnode/src/tsdb/tsdbRead.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/source/dnode/vnode/src/tsdb/tsdbRead.c b/source/dnode/vnode/src/tsdb/tsdbRead.c
index 89cfe19de9..88d0981c6b 100644
--- a/source/dnode/vnode/src/tsdb/tsdbRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRead.c
@@ -2791,7 +2791,7 @@ static int32_t buildComposedDataBlock(STsdbReader* pReader) {
 
   STableBlockScanInfo* pBlockScanInfo = NULL;
   if (pBlockInfo != NULL) {
-    if (*pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pBlockScanInfo->uid, sizeof(pBlockScanInfo->uid))) {
+    if (pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pBlockScanInfo->uid, sizeof(pBlockScanInfo->uid))) {
       setBlockAllDumped(pDumpInfo, pBlock->maxKey.ts, pReader->order);
       return code;
     }
@@ -2819,7 +2819,7 @@ static int32_t buildComposedDataBlock(STsdbReader* pReader) {
     }
   } else {  // file blocks not exist
     pBlockScanInfo = *pReader->status.pTableIter;
-    if (*pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pBlockScanInfo->uid, sizeof(pBlockScanInfo->uid))) {
+    if (pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pBlockScanInfo->uid, sizeof(pBlockScanInfo->uid))) {
       setBlockAllDumped(pDumpInfo, pBlock->maxKey.ts, pReader->order);
       return code;
     }
@@ -3111,7 +3111,7 @@ static int32_t doLoadLastBlockSequentially(STsdbReader* pReader) {
 
     // load the last data block of current table
     STableBlockScanInfo* pScanInfo = *(STableBlockScanInfo**)pStatus->pTableIter;
-    if (*pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pScanInfo->uid, sizeof(pScanInfo->uid))) {
+    if (pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pScanInfo->uid, sizeof(pScanInfo->uid))) {
       bool hasNexTable = moveToNextTable(pUidList, pStatus);
       if (!hasNexTable) {
         return TSDB_CODE_SUCCESS;
@@ -3182,7 +3182,7 @@ static int32_t doBuildDataBlock(STsdbReader* pReader) {
   SLastBlockReader*    pLastBlockReader = pReader->status.fileIter.pLastBlockReader;
   SDataBlk*            pBlock = getCurrentBlock(pBlockIter);
 
-  if (*pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pBlockInfo->uid, sizeof(pBlockInfo->uid))) {
+  if (pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pBlockInfo->uid, sizeof(pBlockInfo->uid))) {
     setBlockAllDumped(&pStatus->fBlockDumpInfo, pBlock->maxKey.ts, pReader->order);
     return code;
   }
@@ -3424,7 +3424,7 @@ static int32_t buildBlockFromBufferSequentially(STsdbReader* pReader) {
     }
 
     STableBlockScanInfo** pBlockScanInfo = pStatus->pTableIter;
-    if (*pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &(*pBlockScanInfo)->uid, sizeof((*pBlockScanInfo)->uid))) {
+    if (pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &(*pBlockScanInfo)->uid, sizeof((*pBlockScanInfo)->uid))) {
       bool hasNexTable = moveToNextTable(pUidList, pStatus);
       if (!hasNexTable) {
         return TSDB_CODE_SUCCESS;

From 3ca5559b379930ceb07ca113076a287c8261b9e2 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Fri, 12 May 2023 19:27:11 +0800
Subject: [PATCH 37/44] fix: invalid read issue

---
 source/dnode/vnode/src/tsdb/tsdbRead.c | 2 +-
 source/util/src/tcompression.c         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/source/dnode/vnode/src/tsdb/tsdbRead.c b/source/dnode/vnode/src/tsdb/tsdbRead.c
index 88d0981c6b..21b59e376c 100644
--- a/source/dnode/vnode/src/tsdb/tsdbRead.c
+++ b/source/dnode/vnode/src/tsdb/tsdbRead.c
@@ -2791,7 +2791,7 @@ static int32_t buildComposedDataBlock(STsdbReader* pReader) {
 
   STableBlockScanInfo* pBlockScanInfo = NULL;
   if (pBlockInfo != NULL) {
-    if (pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pBlockScanInfo->uid, sizeof(pBlockScanInfo->uid))) {
+    if (pReader->pIgnoreTables && taosHashGet(*pReader->pIgnoreTables, &pBlockInfo->uid, sizeof(pBlockInfo->uid))) {
       setBlockAllDumped(pDumpInfo, pBlock->maxKey.ts, pReader->order);
       return code;
     }
diff --git a/source/util/src/tcompression.c b/source/util/src/tcompression.c
index 58528a91ba..38d5a9edeb 100644
--- a/source/util/src/tcompression.c
+++ b/source/util/src/tcompression.c
@@ -916,7 +916,7 @@ FORCE_INLINE uint64_t decodeDoubleValue(const char *const input, int32_t *const
   uint64_t diff = 0ul;
   int32_t  nbytes = (flag & 0x7) + 1;
   for (int32_t i = 0; i < nbytes; i++) {
-    diff |= ((0xffff & input[(*ipos)++]) << BITS_PER_BYTE * i);
+    diff |= (((uint64_t)0xffff & input[(*ipos)++]) << BITS_PER_BYTE * i);
   }
   int32_t shift_width = (LONG_BYTES * BITS_PER_BYTE - nbytes * BITS_PER_BYTE) * (flag >> 3);
   diff <<= shift_width;

From 198be9a7a6da370396bb4044ed5640e1e13080dd Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Mon, 15 May 2023 10:13:20 +0800
Subject: [PATCH 38/44] fix: double decompress issue and memory leak issue

---
 source/client/src/clientHb.c      | 3 ++-
 source/libs/catalog/src/ctgUtil.c | 2 ++
 source/util/src/tcompression.c    | 2 +-
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/source/client/src/clientHb.c b/source/client/src/clientHb.c
index 65e4030cbe..0cf9930911 100644
--- a/source/client/src/clientHb.c
+++ b/source/client/src/clientHb.c
@@ -97,7 +97,8 @@ static int32_t hbProcessDBInfoRsp(void *value, int32_t valueLen, struct SCatalog
   SDbHbBatchRsp batchRsp = {0};
   if (tDeserializeSDbHbBatchRsp(value, valueLen, &batchRsp) != 0) {
     terrno = TSDB_CODE_INVALID_MSG;
-    return -1;
+    code = terrno;
+    goto _return;
   }
 
   int32_t numOfBatchs = taosArrayGetSize(batchRsp.pArray);
diff --git a/source/libs/catalog/src/ctgUtil.c b/source/libs/catalog/src/ctgUtil.c
index bf858c7b44..ae8fe0cca4 100644
--- a/source/libs/catalog/src/ctgUtil.c
+++ b/source/libs/catalog/src/ctgUtil.c
@@ -236,6 +236,7 @@ void ctgFreeTbCache(SCtgDBCache* dbCache) {
 }
 
 void ctgFreeVgInfoCache(SCtgDBCache* dbCache) { freeVgInfo(dbCache->vgCache.vgInfo); }
+void ctgFreeCfgInfoCache(SCtgDBCache* dbCache) { freeDbCfgInfo(dbCache->cfgCache.cfgInfo); }
 
 void ctgFreeDbCache(SCtgDBCache* dbCache) {
   if (NULL == dbCache) {
@@ -243,6 +244,7 @@ void ctgFreeDbCache(SCtgDBCache* dbCache) {
   }
 
   ctgFreeVgInfoCache(dbCache);
+  ctgFreeCfgInfoCache(dbCache);
   ctgFreeStbMetaCache(dbCache);
   ctgFreeTbCache(dbCache);
 }
diff --git a/source/util/src/tcompression.c b/source/util/src/tcompression.c
index 38d5a9edeb..b05f1808e8 100644
--- a/source/util/src/tcompression.c
+++ b/source/util/src/tcompression.c
@@ -916,7 +916,7 @@ FORCE_INLINE uint64_t decodeDoubleValue(const char *const input, int32_t *const
   uint64_t diff = 0ul;
   int32_t  nbytes = (flag & 0x7) + 1;
   for (int32_t i = 0; i < nbytes; i++) {
-    diff |= (((uint64_t)0xffff & input[(*ipos)++]) << BITS_PER_BYTE * i);
+    diff |= (((uint64_t)0xff & input[(*ipos)++]) << BITS_PER_BYTE * i);
   }
   int32_t shift_width = (LONG_BYTES * BITS_PER_BYTE - nbytes * BITS_PER_BYTE) * (flag >> 3);
   diff <<= shift_width;

From e7df9b8fa0e029c7c3ed1ef8fdc7ba0d997cb697 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Tue, 16 May 2023 14:12:48 +0800
Subject: [PATCH 39/44] enh: optimize copy group result

---
 source/dnode/mgmt/mgmt_mnode/src/mmWorker.c |  5 ++++
 source/libs/executor/src/executorInt.c      | 31 +++++++++++----------
 2 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/source/dnode/mgmt/mgmt_mnode/src/mmWorker.c b/source/dnode/mgmt/mgmt_mnode/src/mmWorker.c
index 0152e5d0b1..bbd77c0828 100644
--- a/source/dnode/mgmt/mgmt_mnode/src/mmWorker.c
+++ b/source/dnode/mgmt/mgmt_mnode/src/mmWorker.c
@@ -120,6 +120,11 @@ int32_t mmPutMsgToReadQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg) {
 }
 
 int32_t mmPutMsgToQueryQueue(SMnodeMgmt *pMgmt, SRpcMsg *pMsg) {
+  if (NULL == pMgmt->pMnode) {
+    const STraceId *trace = &pMsg->info.traceId;
+    dGError("msg:%p, stop to pre-process in mnode since mnode is NULL, type:%s", pMsg, TMSG_INFO(pMsg->msgType));
+    return -1;
+  }
   pMsg->info.node = pMgmt->pMnode;
   if (mndPreProcessQueryMsg(pMsg) != 0) {
     const STraceId *trace = &pMsg->info.traceId;
diff --git a/source/libs/executor/src/executorInt.c b/source/libs/executor/src/executorInt.c
index 62ab2d9df2..fc69ad1add 100644
--- a/source/libs/executor/src/executorInt.c
+++ b/source/libs/executor/src/executorInt.c
@@ -82,7 +82,7 @@ static void    extractQualifiedTupleByFilterResult(SSDataBlock* pBlock, const SC
 static int32_t doSetInputDataBlock(SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t order, int32_t scanFlag,
                                    bool createDummyCol);
 static int32_t doCopyToSDataBlock(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf,
-                                  SGroupResInfo* pGroupResInfo, int32_t threshold);
+                                  SGroupResInfo* pGroupResInfo, int32_t threshold, bool ignoreGroup);
 
 SResultRow* getNewResultRow(SDiskbasedBuf* pResultBuf, int32_t* currentPageId, int32_t interBufSize) {
   SFilePage* pData = NULL;
@@ -776,7 +776,7 @@ int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPos
 }
 
 int32_t doCopyToSDataBlock(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf,
-                           SGroupResInfo* pGroupResInfo, int32_t threshold) {
+                           SGroupResInfo* pGroupResInfo, int32_t threshold, bool ignoreGroup) {
   SExprInfo*      pExprInfo = pSup->pExprInfo;
   int32_t         numOfExprs = pSup->numOfExprs;
   int32_t*        rowEntryOffset = pSup->rowEntryInfoOffset;
@@ -803,20 +803,23 @@ int32_t doCopyToSDataBlock(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprS
       continue;
     }
 
-    if (pBlock->info.id.groupId == 0) {
-      pBlock->info.id.groupId = pPos->groupId;
-    } else {
-      // current value belongs to different group, it can't be packed into one datablock
-      if (pBlock->info.id.groupId != pPos->groupId) {
-        releaseBufPage(pBuf, page);
-        break;
+    if (!ignoreGroup) {
+      if (pBlock->info.id.groupId == 0) {
+        pBlock->info.id.groupId = pPos->groupId;
+      } else {
+        // current value belongs to different group, it can't be packed into one datablock
+        if (pBlock->info.id.groupId != pPos->groupId) {
+          releaseBufPage(pBuf, page);
+          break;
+        }
       }
     }
 
     if (pBlock->info.rows + pRow->numOfRows > pBlock->info.capacity) {
-      blockDataEnsureCapacity(pBlock, pBlock->info.rows + pRow->numOfRows);
+      uint32_t newSize = pBlock->info.rows + pRow->numOfRows + (numOfRows - i) > 1 ? 1 : 0;
+      blockDataEnsureCapacity(pBlock, newSize);
       qDebug("datablock capacity not sufficient, expand to required:%" PRId64 ", current capacity:%d, %s",
-             (pRow->numOfRows + pBlock->info.rows), pBlock->info.capacity, GET_TASKID(pTaskInfo));
+             newSize, pBlock->info.capacity, GET_TASKID(pTaskInfo));
       // todo set the pOperator->resultInfo size
     }
 
@@ -853,7 +856,7 @@ void doBuildStreamResBlock(SOperatorInfo* pOperator, SOptrBasicInfo* pbInfo, SGr
   // clear the existed group id
   pBlock->info.id.groupId = 0;
   ASSERT(!pbInfo->mergeResultBlock);
-  doCopyToSDataBlock(pTaskInfo, pBlock, &pOperator->exprSupp, pBuf, pGroupResInfo, pOperator->resultInfo.threshold);
+  doCopyToSDataBlock(pTaskInfo, pBlock, &pOperator->exprSupp, pBuf, pGroupResInfo, pOperator->resultInfo.threshold, false);
 
   void* tbname = NULL;
   if (streamStateGetParName(pTaskInfo->streamInfo.pState, pBlock->info.id.groupId, &tbname) < 0) {
@@ -880,10 +883,10 @@ void doBuildResultDatablock(SOperatorInfo* pOperator, SOptrBasicInfo* pbInfo, SG
   // clear the existed group id
   pBlock->info.id.groupId = 0;
   if (!pbInfo->mergeResultBlock) {
-    doCopyToSDataBlock(pTaskInfo, pBlock, &pOperator->exprSupp, pBuf, pGroupResInfo, pOperator->resultInfo.threshold);
+    doCopyToSDataBlock(pTaskInfo, pBlock, &pOperator->exprSupp, pBuf, pGroupResInfo, pOperator->resultInfo.threshold, false);
   } else {
     while (hasRemainResults(pGroupResInfo)) {
-      doCopyToSDataBlock(pTaskInfo, pBlock, &pOperator->exprSupp, pBuf, pGroupResInfo, pOperator->resultInfo.threshold);
+      doCopyToSDataBlock(pTaskInfo, pBlock, &pOperator->exprSupp, pBuf, pGroupResInfo, pOperator->resultInfo.threshold, true);
       if (pBlock->info.rows >= pOperator->resultInfo.threshold) {
         break;
       }

From de45d163cae3653fc15aeec6437cb38ad4ead818 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Tue, 16 May 2023 14:18:23 +0800
Subject: [PATCH 40/44] fix: compile issue

---
 source/libs/executor/src/executorInt.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/libs/executor/src/executorInt.c b/source/libs/executor/src/executorInt.c
index fc69ad1add..1a14d0e78a 100644
--- a/source/libs/executor/src/executorInt.c
+++ b/source/libs/executor/src/executorInt.c
@@ -818,7 +818,7 @@ int32_t doCopyToSDataBlock(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprS
     if (pBlock->info.rows + pRow->numOfRows > pBlock->info.capacity) {
       uint32_t newSize = pBlock->info.rows + pRow->numOfRows + (numOfRows - i) > 1 ? 1 : 0;
       blockDataEnsureCapacity(pBlock, newSize);
-      qDebug("datablock capacity not sufficient, expand to required:%" PRId64 ", current capacity:%d, %s",
+      qDebug("datablock capacity not sufficient, expand to required:%d, current capacity:%d, %s",
              newSize, pBlock->info.capacity, GET_TASKID(pTaskInfo));
       // todo set the pOperator->resultInfo size
     }

From e4380d63ded74d8146f85ff3ae35fffe2eaa1cd6 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Tue, 16 May 2023 18:00:10 +0800
Subject: [PATCH 41/44] enh: add release build option

---
 cmake/cmake.define  | 7 ++++---
 cmake/cmake.options | 5 +++++
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/cmake/cmake.define b/cmake/cmake.define
index 06e2456ccf..8484355a91 100644
--- a/cmake/cmake.define
+++ b/cmake/cmake.define
@@ -119,11 +119,12 @@ ELSE ()
         SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}     -Werror -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fsanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=shift-base -fno-sanitize=alignment -g3 -Wformat=0")
         SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -fsanitize=address -fsanitize=undefined -fsanitize-recover=all -fsanitize=float-divide-by-zero -fsanitize=float-cast-overflow -fno-sanitize=shift-base -fno-sanitize=alignment -g3 -Wformat=0")
 	      MESSAGE(STATUS "Compile with Address Sanitizer!")
-    ELSE ()
+    ELSEIF (${BUILD_RELEASE})
         SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -O3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
-        #SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -gdwarf-2 -g3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
         SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-reserved-user-defined-literal -Wno-literal-suffix -Werror=return-type -fPIC -O3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
-        #SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-reserved-user-defined-literal -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -g3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
+    ELSE ()
+        SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Werror=return-type -fPIC -gdwarf-2 -g3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
+        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wno-reserved-user-defined-literal -Wno-literal-suffix -Werror=return-type -fPIC -gdwarf-2 -g3 -Wformat=2 -Wno-format-nonliteral -Wno-format-truncation -Wno-format-y2k")
     ENDIF ()
 
     # disable all assert
diff --git a/cmake/cmake.options b/cmake/cmake.options
index 60ff00affc..14939c1d30 100644
--- a/cmake/cmake.options
+++ b/cmake/cmake.options
@@ -171,3 +171,8 @@ option(
    ON 
 )
 
+option(
+   BUILD_RELEASE
+   "If build release version"
+   OFF
+)

From 61bc3ab72e0e11ca1e0bebd6db0ad4d78c197b67 Mon Sep 17 00:00:00 2001
From: dapan1121 <72057773+dapan1121@users.noreply.github.com>
Date: Tue, 16 May 2023 18:04:00 +0800
Subject: [PATCH 42/44] Update clientEnv.c

---
 source/client/src/clientEnv.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/client/src/clientEnv.c b/source/client/src/clientEnv.c
index 33c50d9aca..1d63955060 100644
--- a/source/client/src/clientEnv.c
+++ b/source/client/src/clientEnv.c
@@ -96,7 +96,7 @@ static void deregisterRequest(SRequestObj *pRequest) {
                pRequest->metric.planCostUs, pRequest->metric.execCostUs);
       atomic_add_fetch_64((int64_t *)&pActivity->insertElapsedTime, duration);
     } else if (QUERY_NODE_SELECT_STMT == pRequest->stmtType) {
-      tscError("query duration %" PRId64 "us: parseCost:%" PRId64 "us, ctgCost:%" PRId64 "us, analyseCost:%" PRId64
+      tscDebug("query duration %" PRId64 "us: parseCost:%" PRId64 "us, ctgCost:%" PRId64 "us, analyseCost:%" PRId64
                "us, planCost:%" PRId64 "us, exec:%" PRId64 "us",
                duration, pRequest->metric.parseCostUs, pRequest->metric.ctgCostUs, pRequest->metric.analyseCostUs,
                pRequest->metric.planCostUs, pRequest->metric.execCostUs);

From a1e776bcf8ece1cd0b5a1679be99c54b0e772417 Mon Sep 17 00:00:00 2001
From: dapan1121 <72057773+dapan1121@users.noreply.github.com>
Date: Tue, 16 May 2023 18:04:54 +0800
Subject: [PATCH 43/44] Update clientImpl.c

---
 source/client/src/clientImpl.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/source/client/src/clientImpl.c b/source/client/src/clientImpl.c
index f131e128b0..ce174744ef 100644
--- a/source/client/src/clientImpl.c
+++ b/source/client/src/clientImpl.c
@@ -233,7 +233,7 @@ int32_t buildRequest(uint64_t connId, const char* sql, int sqlLen, void* param,
     }
   }
 
-  tscErrorL("0x%" PRIx64 " SQL: %s, reqId:0x%" PRIx64, (*pRequest)->self, (*pRequest)->sqlstr, (*pRequest)->requestId);
+  tscDebugL("0x%" PRIx64 " SQL: %s, reqId:0x%" PRIx64, (*pRequest)->self, (*pRequest)->sqlstr, (*pRequest)->requestId);
   return TSDB_CODE_SUCCESS;
 }
 

From df973ce28ee995c9f98d86c9726af6d08a81e982 Mon Sep 17 00:00:00 2001
From: dapan1121 <wpan@taosdata.com>
Date: Tue, 16 May 2023 18:37:00 +0800
Subject: [PATCH 44/44] fix: remove debug info

---
 include/libs/executor/dataSinkMgt.h           |  1 -
 source/client/src/clientMain.c                |  2 +-
 source/libs/catalog/src/catalog.c             |  2 --
 source/libs/catalog/src/ctgAsync.c            |  2 +-
 source/libs/catalog/src/ctgRemote.c           |  2 +-
 source/libs/executor/src/dataDispatcher.c     | 10 ----------
 source/libs/executor/src/exchangeoperator.c   |  2 +-
 source/libs/executor/src/executil.c           |  4 ++--
 source/libs/executor/src/executor.c           |  4 ++--
 source/libs/executor/src/projectoperator.c    | 10 ----------
 source/libs/executor/src/timewindowoperator.c |  6 ------
 source/libs/qworker/src/qwMsg.c               |  8 ++++----
 source/libs/qworker/src/qworker.c             |  4 +---
 source/libs/scheduler/src/schJob.c            |  6 +++---
 source/libs/scheduler/src/schRemote.c         |  4 ++--
 source/libs/scheduler/src/schTask.c           |  2 +-
 source/libs/scheduler/src/scheduler.c         |  4 ++--
 source/libs/transport/src/transCli.c          |  6 +++---
 source/libs/transport/src/transSvr.c          | 10 +++++-----
 19 files changed, 29 insertions(+), 60 deletions(-)

diff --git a/include/libs/executor/dataSinkMgt.h b/include/libs/executor/dataSinkMgt.h
index 51ca35dda0..ce7d038d42 100644
--- a/include/libs/executor/dataSinkMgt.h
+++ b/include/libs/executor/dataSinkMgt.h
@@ -69,7 +69,6 @@ typedef struct SOutputData {
   int32_t numOfBlocks;
   int64_t numOfRows; // int32_t changed to int64_t
   int32_t numOfCols;
-  int32_t dataSize;
   int8_t  compressed;
   char*   pData;
   bool    queryEnd;
diff --git a/source/client/src/clientMain.c b/source/client/src/clientMain.c
index b43f1e79e0..fd70598efb 100644
--- a/source/client/src/clientMain.c
+++ b/source/client/src/clientMain.c
@@ -761,7 +761,7 @@ static void doAsyncQueryFromAnalyse(SMetaData *pResultMeta, void *param, int32_t
 
   int64_t analyseStart = taosGetTimestampUs();
   pRequest->metric.ctgCostUs = analyseStart - pRequest->metric.ctgStart;
-  qError("0x%" PRIx64 " start to semantic analysis, reqId:0x%" PRIx64, pRequest->self, pRequest->requestId);
+  qDebug("0x%" PRIx64 " start to semantic analysis, reqId:0x%" PRIx64, pRequest->self, pRequest->requestId);
 
   if (code == TSDB_CODE_SUCCESS) {
     code = qAnalyseSqlSemantic(pWrapper->pParseCtx, pWrapper->pCatalogReq, pResultMeta, pQuery);
diff --git a/source/libs/catalog/src/catalog.c b/source/libs/catalog/src/catalog.c
index f8ead25852..0deeafda9f 100644
--- a/source/libs/catalog/src/catalog.c
+++ b/source/libs/catalog/src/catalog.c
@@ -1341,8 +1341,6 @@ int32_t catalogAsyncGetAllMeta(SCatalog* pCtg, SRequestConnInfo* pConn, const SC
     CTG_API_LEAVE(TSDB_CODE_CTG_INVALID_INPUT);
   }
 
-  ctgError("%s", "catalog start async get all metas");
-
   int32_t  code = 0;
   SCtgJob* pJob = NULL;
   CTG_ERR_JRET(ctgInitJob(pCtg, pConn, &pJob, pReq, fp, param));
diff --git a/source/libs/catalog/src/ctgAsync.c b/source/libs/catalog/src/ctgAsync.c
index 1d904213ba..f69fa8a502 100644
--- a/source/libs/catalog/src/ctgAsync.c
+++ b/source/libs/catalog/src/ctgAsync.c
@@ -1035,7 +1035,7 @@ _return:
 int32_t ctgCallUserCb(void* param) {
   SCtgJob* pJob = (SCtgJob*)param;
 
-  qError("QID:0x%" PRIx64 " ctg start to call user cb with rsp %s", pJob->queryId, tstrerror(pJob->jobResCode));
+  qDebug("QID:0x%" PRIx64 " ctg start to call user cb with rsp %s", pJob->queryId, tstrerror(pJob->jobResCode));
 
   (*pJob->userFp)(&pJob->jobRes, pJob->userParam, pJob->jobResCode);
 
diff --git a/source/libs/catalog/src/ctgRemote.c b/source/libs/catalog/src/ctgRemote.c
index d22fae6a40..3b037e2062 100644
--- a/source/libs/catalog/src/ctgRemote.c
+++ b/source/libs/catalog/src/ctgRemote.c
@@ -627,7 +627,7 @@ int32_t ctgLaunchBatchs(SCatalog* pCtg, SCtgJob* pJob, SHashObj* pBatchs) {
     SCtgBatch* pBatch = (SCtgBatch*)p;
     int32_t msgSize = 0;
 
-    ctgError("QID:0x%" PRIx64 " ctg start to launch batch %d", pJob->queryId, pBatch->batchId);
+    ctgDebug("QID:0x%" PRIx64 " ctg start to launch batch %d", pJob->queryId, pBatch->batchId);
 
     CTG_ERR_JRET(ctgBuildBatchReqMsg(pBatch, *vgId, &msg, &msgSize));
     code = ctgAsyncSendMsg(pCtg, &pBatch->conn, pJob, pBatch->pTaskIds, pBatch->batchId, pBatch->pMsgIdxs,
diff --git a/source/libs/executor/src/dataDispatcher.c b/source/libs/executor/src/dataDispatcher.c
index 3d5645128b..49e5bfdd19 100644
--- a/source/libs/executor/src/dataDispatcher.c
+++ b/source/libs/executor/src/dataDispatcher.c
@@ -82,8 +82,6 @@ static void toDataCacheEntry(SDataDispatchHandle* pHandle, const SInputData* pIn
 
   pBuf->useSize += pEntry->dataLen;
 
-  //mprotect(pBuf->pData, pBuf->allocSize, PROT_READ);
-
   atomic_add_fetch_64(&pHandle->cachedSize, pEntry->dataLen);
   atomic_add_fetch_64(&gDataSinkStat.cachedSize, pEntry->dataLen);
 }
@@ -101,8 +99,6 @@ static bool allocBuf(SDataDispatchHandle* pDispatcher, const SInputData* pInput,
   pBuf->allocSize = sizeof(SDataCacheEntry) + blockGetEncodeSize(pInput->pData);
 
   pBuf->pData = taosMemoryMalloc(pBuf->allocSize);
-  //pBuf->allocSize = (pBuf->allocSize > 4096) ? (pBuf->allocSize/4096 + 1)*4096 : 4096;
-  //pBuf->pData = taosMemoryMallocAlign(4096, pBuf->allocSize);
   if (pBuf->pData == NULL) {
     qError("SinkNode failed to malloc memory, size:%d, code:%d", pBuf->allocSize, TAOS_SYSTEM_ERROR(errno));
   }
@@ -193,19 +189,14 @@ static int32_t getDataBlock(SDataSinkHandle* pHandle, SOutputData* pOutput) {
     return TSDB_CODE_SUCCESS;
   }
   SDataCacheEntry* pEntry = (SDataCacheEntry*)(pDispatcher->nextOutput.pData);
-  assert(pOutput->dataSize == pEntry->dataLen);
   memcpy(pOutput->pData, pEntry->data, pEntry->dataLen);
   pOutput->numOfRows = pEntry->numOfRows;
   pOutput->numOfCols = pEntry->numOfCols;
   pOutput->compressed = pEntry->compressed;
 
-  //  ASSERT(pEntry->numOfRows == *(int32_t*)(pEntry->data + 8));
-  //  ASSERT(pEntry->numOfCols == *(int32_t*)(pEntry->data + 8 + 4));
-
   atomic_sub_fetch_64(&pDispatcher->cachedSize, pEntry->dataLen);
   atomic_sub_fetch_64(&gDataSinkStat.cachedSize, pEntry->dataLen);
 
-  //mprotect(pDispatcher->nextOutput.pData, pDispatcher->nextOutput.allocSize, PROT_READ|PROT_WRITE|PROT_EXEC);
   taosMemoryFreeClear(pDispatcher->nextOutput.pData);  // todo persistent
   pOutput->bufStatus = updateStatus(pDispatcher);
   taosThreadMutexLock(&pDispatcher->mutex);
@@ -225,7 +216,6 @@ static int32_t destroyDataSinker(SDataSinkHandle* pHandle) {
     SDataDispatchBuf* pBuf = NULL;
     taosReadQitem(pDispatcher->pDataBlocks, (void**)&pBuf);
     if (pBuf != NULL) {
-      //mprotect(pBuf->pData, pBuf->allocSize, PROT_READ|PROT_WRITE|PROT_EXEC);
       taosMemoryFreeClear(pBuf->pData);
       taosFreeQitem(pBuf);
     }
diff --git a/source/libs/executor/src/exchangeoperator.c b/source/libs/executor/src/exchangeoperator.c
index b4a53be317..94041140d4 100644
--- a/source/libs/executor/src/exchangeoperator.c
+++ b/source/libs/executor/src/exchangeoperator.c
@@ -451,7 +451,7 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas
       return pTaskInfo->code;
     }
 
-    qError("%s build fetch msg and send to vgId:%d, ep:%s, taskId:0x%" PRIx64 ", execId:%d, %p, %d/%" PRIzu,
+    qDebug("%s build fetch msg and send to vgId:%d, ep:%s, taskId:0x%" PRIx64 ", execId:%d, %p, %d/%" PRIzu,
            GET_TASKID(pTaskInfo), pSource->addr.nodeId, pSource->addr.epSet.eps[0].fqdn, pSource->taskId,
            pSource->execId, pExchangeInfo, sourceIndex, totalSources);
 
diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c
index 45e8c22aac..fa46715c22 100644
--- a/source/libs/executor/src/executil.c
+++ b/source/libs/executor/src/executil.c
@@ -2096,7 +2096,7 @@ int32_t createScanTableListInfo(SScanPhysiNode* pScanNode, SNodeList* pGroupTags
 
   int64_t st1 = taosGetTimestampUs();
   pTaskInfo->cost.extractListTime = (st1 - st) / 1000.0;
-  qError("extract queried table list completed, %d tables, elapsed time:%.2f ms %s", numOfTables,
+  qDebug("extract queried table list completed, %d tables, elapsed time:%.2f ms %s", numOfTables,
          pTaskInfo->cost.extractListTime, idStr);
 
   if (numOfTables == 0) {
@@ -2110,7 +2110,7 @@ int32_t createScanTableListInfo(SScanPhysiNode* pScanNode, SNodeList* pGroupTags
   }
 
   pTaskInfo->cost.groupIdMapTime = (taosGetTimestampUs() - st1) / 1000.0;
-  qError("generate group id map completed, elapsed time:%.2f ms %s", pTaskInfo->cost.groupIdMapTime, idStr);
+  qDebug("generate group id map completed, elapsed time:%.2f ms %s", pTaskInfo->cost.groupIdMapTime, idStr);
 
   return TSDB_CODE_SUCCESS;
 }
diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c
index 489c4ff650..16d6898361 100644
--- a/source/libs/executor/src/executor.c
+++ b/source/libs/executor/src/executor.c
@@ -493,7 +493,7 @@ int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId,
   SExecTaskInfo** pTask = (SExecTaskInfo**)pTaskInfo;
   taosThreadOnce(&initPoolOnce, initRefPool);
 
-  qError("start to create task, TID:0x%" PRIx64 " QID:0x%" PRIx64 ", vgId:%d", taskId, pSubplan->id.queryId, vgId);
+  qDebug("start to create task, TID:0x%" PRIx64 " QID:0x%" PRIx64 ", vgId:%d", taskId, pSubplan->id.queryId, vgId);
 
   int32_t code = createExecTaskInfo(pSubplan, pTask, readHandle, taskId, vgId, sql, model);
   if (code != TSDB_CODE_SUCCESS) {
@@ -520,7 +520,7 @@ int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId,
     code = dsCreateDataSinker(pSubplan->pDataSink, handle, pSinkParam, (*pTask)->id.str);
   }
 
-  qError("subplan task create completed, TID:0x%" PRIx64 " QID:0x%" PRIx64, taskId, pSubplan->id.queryId);
+  qDebug("subplan task create completed, TID:0x%" PRIx64 " QID:0x%" PRIx64, taskId, pSubplan->id.queryId);
 
 _error:
   // if failed to add ref for all tables in this query, abort current query
diff --git a/source/libs/executor/src/projectoperator.c b/source/libs/executor/src/projectoperator.c
index 2c98f37388..02f504bef0 100644
--- a/source/libs/executor/src/projectoperator.c
+++ b/source/libs/executor/src/projectoperator.c
@@ -249,9 +249,6 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) {
     return doGenerateSourceData(pOperator);
   }
 
-  int64_t st0 = taosGetTimestampUs();
-  int64_t st1 = 0, st2 = 0;
-
   while (1) {
     while (1) {
       blockDataCleanup(pRes);
@@ -263,7 +260,6 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) {
         setOperatorCompleted(pOperator);
         break;
       }
-      st1 = taosGetTimestampUs();
 //      if (pTaskInfo->execModel == OPTR_EXEC_MODEL_QUEUE) {
 //        qDebug("set status recv");
 //        pOperator->status = OP_EXEC_RECV;
@@ -305,8 +301,6 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) {
         continue;
       }
 
-      st2 = taosGetTimestampUs();
-
       break;
     }
 
@@ -352,10 +346,6 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) {
     pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0;
   }
 
-  if (p->info.rows > 0) {
-    qError("doProjection, open:%" PRId64 "us, project:%" PRId64 "us, rows:%" PRId64,st1-st0,st2-st1,p->info.rows);
-  }
-
   return (p->info.rows > 0) ? p : NULL;
 }
 
diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c
index 1ba23e09c9..bea01fa0d8 100644
--- a/source/libs/executor/src/timewindowoperator.c
+++ b/source/libs/executor/src/timewindowoperator.c
@@ -1279,20 +1279,15 @@ static SSDataBlock* doBuildIntervalResult(SOperatorInfo* pOperator) {
     return NULL;
   }
 
-  int64_t st0 = taosGetTimestampUs();
   SSDataBlock* pBlock = pInfo->binfo.pRes;
   pTaskInfo->code = pOperator->fpSet._openFn(pOperator);
   if (pTaskInfo->code != TSDB_CODE_SUCCESS) {
     return NULL;
   }
-  int64_t st1 = taosGetTimestampUs();
-  int64_t st2 = 0, st3 = 0;
 
   while (1) {
     doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf);
-    st2 = taosGetTimestampUs();
     doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL);
-    st3 = taosGetTimestampUs();
 
     bool hasRemain = hasRemainResults(&pInfo->groupResInfo);
     if (!hasRemain) {
@@ -1301,7 +1296,6 @@ static SSDataBlock* doBuildIntervalResult(SOperatorInfo* pOperator) {
     }
 
     if (pBlock->info.rows > 0) {
-      qError("interval open:%" PRId64 "us, build:%" PRId64 "us, filter:%" PRId64 "us, rows:%" PRId64, st1-st0,st2-st1,st3-st2,pBlock->info.rows);
       break;
     }
   }
diff --git a/source/libs/qworker/src/qwMsg.c b/source/libs/qworker/src/qwMsg.c
index 3c6ba2da06..1a3a740b34 100644
--- a/source/libs/qworker/src/qwMsg.c
+++ b/source/libs/qworker/src/qwMsg.c
@@ -381,9 +381,9 @@ int32_t qWorkerPreprocessQueryMsg(void *qWorkerMgmt, SRpcMsg *pMsg, bool chkGran
   SQWMsg qwMsg = {
       .msgType = pMsg->msgType, .msg = msg.msg, .msgLen = msg.msgLen, .connInfo = pMsg->info};
 
-  QW_SCH_TASK_ELOG("prerocessQuery start, handle:%p, SQL:%s", pMsg->info.handle, msg.sql);
+  QW_SCH_TASK_DLOG("prerocessQuery start, handle:%p, SQL:%s", pMsg->info.handle, msg.sql);
   code = qwPreprocessQuery(QW_FPARAMS(), &qwMsg);
-  QW_SCH_TASK_ELOG("prerocessQuery end, handle:%p, code:%x", pMsg->info.handle, code);
+  QW_SCH_TASK_DLOG("prerocessQuery end, handle:%p, code:%x", pMsg->info.handle, code);
 
   tFreeSSubQueryMsg(&msg);
 
@@ -449,11 +449,11 @@ int32_t qWorkerProcessQueryMsg(void *node, void *qWorkerMgmt, SRpcMsg *pMsg, int
   qwMsg.msgInfo.taskType = msg.taskType;
   qwMsg.msgInfo.needFetch = msg.needFetch;
 
-  QW_SCH_TASK_ELOG("processQuery start, node:%p, type:%s, handle:%p, SQL:%s", node, TMSG_INFO(pMsg->msgType),
+  QW_SCH_TASK_DLOG("processQuery start, node:%p, type:%s, handle:%p, SQL:%s", node, TMSG_INFO(pMsg->msgType),
                    pMsg->info.handle, msg.sql);
   code = qwProcessQuery(QW_FPARAMS(), &qwMsg, msg.sql);
   msg.sql = NULL;
-  QW_SCH_TASK_ELOG("processQuery end, node:%p, code:%x", node, code);
+  QW_SCH_TASK_DLOG("processQuery end, node:%p, code:%x", node, code);
 
   tFreeSSubQueryMsg(&msg);
 
diff --git a/source/libs/qworker/src/qworker.c b/source/libs/qworker/src/qworker.c
index 3daec242e7..9db0495081 100644
--- a/source/libs/qworker/src/qworker.c
+++ b/source/libs/qworker/src/qworker.c
@@ -138,7 +138,7 @@ int32_t qwSendQueryRsp(QW_FPARAMS_DEF, int32_t msgType, SQWTaskCtx *ctx, int32_t
   if ((!quickRsp) || QUERY_RSP_POLICY_QUICK == tsQueryRspPolicy) {
     if (!ctx->localExec) {
       qwBuildAndSendQueryRsp(msgType, &ctx->ctrlConnInfo, rspCode, ctx);
-      QW_TASK_ELOG("query msg rsped, handle:%p, code:%x - %s", ctx->ctrlConnInfo.handle, rspCode, tstrerror(rspCode));
+      QW_TASK_DLOG("query msg rsped, handle:%p, code:%x - %s", ctx->ctrlConnInfo.handle, rspCode, tstrerror(rspCode));
     }
 
     ctx->queryRsped = true;
@@ -323,7 +323,6 @@ int32_t qwGetQueryResFromSink(QW_FPARAMS_DEF, SQWTaskCtx *ctx, int32_t *dataLen,
 
     if (len == 0) {
       if (queryEnd) {
-        output.dataSize = 0;
         code = dsGetDataBlock(ctx->sinkHandle, &output);
         if (code) {
           QW_TASK_ELOG("dsGetDataBlock failed, code:%x - %s", code, tstrerror(code));
@@ -359,7 +358,6 @@ int32_t qwGetQueryResFromSink(QW_FPARAMS_DEF, SQWTaskCtx *ctx, int32_t *dataLen,
     QW_ERR_RET(qwMallocFetchRsp(!ctx->localExec, *dataLen, &rsp));
 
     output.pData = rsp->data + *dataLen - len;
-    output.dataSize = len;
     code = dsGetDataBlock(ctx->sinkHandle, &output);
     if (code) {
       QW_TASK_ELOG("dsGetDataBlock failed, code:%x - %s", code, tstrerror(code));
diff --git a/source/libs/scheduler/src/schJob.c b/source/libs/scheduler/src/schJob.c
index ce030ecdf7..e7bfe95795 100644
--- a/source/libs/scheduler/src/schJob.c
+++ b/source/libs/scheduler/src/schJob.c
@@ -440,7 +440,7 @@ int32_t schNotifyUserExecRes(SSchJob *pJob) {
     schDumpJobExecRes(pJob, pRes);
   }
 
-  SCH_JOB_ELOG("sch start to invoke exec cb, code: %s", tstrerror(pJob->errCode));
+  SCH_JOB_DLOG("sch start to invoke exec cb, code: %s", tstrerror(pJob->errCode));
   (*pJob->userRes.execFp)(pRes, pJob->userRes.cbParam, atomic_load_32(&pJob->errCode));
   SCH_JOB_DLOG("sch end from exec cb, code: %s", tstrerror(pJob->errCode));
 
@@ -452,7 +452,7 @@ int32_t schNotifyUserFetchRes(SSchJob *pJob) {
 
   schDumpJobFetchRes(pJob, &pRes);
 
-  SCH_JOB_ELOG("sch start to invoke fetch cb, code: %s", tstrerror(pJob->errCode));
+  SCH_JOB_DLOG("sch start to invoke fetch cb, code: %s", tstrerror(pJob->errCode));
   (*pJob->userRes.fetchFp)(pRes, pJob->userRes.cbParam, atomic_load_32(&pJob->errCode));
   SCH_JOB_DLOG("sch end from fetch cb, code: %s", tstrerror(pJob->errCode));
 
@@ -811,7 +811,7 @@ int32_t schExecJob(SSchJob *pJob, SSchedulerReq *pReq) {
     tsem_wait(&pJob->rspSem);
   }
 
-  SCH_JOB_ELOG("job exec done, job status:%s, jobId:0x%" PRIx64, SCH_GET_JOB_STATUS_STR(pJob), pJob->refId);
+  SCH_JOB_DLOG("job exec done, job status:%s, jobId:0x%" PRIx64, SCH_GET_JOB_STATUS_STR(pJob), pJob->refId);
 
   return TSDB_CODE_SUCCESS;
 }
diff --git a/source/libs/scheduler/src/schRemote.c b/source/libs/scheduler/src/schRemote.c
index f2bb583075..80fdc7594c 100644
--- a/source/libs/scheduler/src/schRemote.c
+++ b/source/libs/scheduler/src/schRemote.c
@@ -923,10 +923,10 @@ int32_t schAsyncSendMsg(SSchJob *pJob, SSchTask *pTask, SSchTrans *trans, SQuery
   SCH_ERR_JRET(schUpdateSendTargetInfo(pMsgSendInfo, addr, pTask));
 
   if (pJob && pTask) {
-    SCH_TASK_ELOG("start to send %s msg to node[%d,%s,%d], pTrans:%p, pHandle:%p", TMSG_INFO(msgType), addr->nodeId,
+    SCH_TASK_DLOG("start to send %s msg to node[%d,%s,%d], pTrans:%p, pHandle:%p", TMSG_INFO(msgType), addr->nodeId,
            epSet->eps[epSet->inUse].fqdn, epSet->eps[epSet->inUse].port, trans->pTrans, trans->pHandle);
   } else {
-    qError("start to send %s msg to node[%d,%s,%d], pTrans:%p, pHandle:%p", TMSG_INFO(msgType), addr->nodeId,
+    qDebug("start to send %s msg to node[%d,%s,%d], pTrans:%p, pHandle:%p", TMSG_INFO(msgType), addr->nodeId,
            epSet->eps[epSet->inUse].fqdn, epSet->eps[epSet->inUse].port, trans->pTrans, trans->pHandle);
   }
   
diff --git a/source/libs/scheduler/src/schTask.c b/source/libs/scheduler/src/schTask.c
index 7e9d672139..207753ae25 100644
--- a/source/libs/scheduler/src/schTask.c
+++ b/source/libs/scheduler/src/schTask.c
@@ -1064,7 +1064,7 @@ int32_t schLaunchTaskImpl(void *param) {
   pTask->retryTimes++;
   pTask->waitRetry = false;
 
-  SCH_TASK_ELOG("start to launch %s task, execId %d, retry %d",
+  SCH_TASK_DLOG("start to launch %s task, execId %d, retry %d",
                 SCH_IS_LOCAL_EXEC_TASK(pJob, pTask) ? "LOCAL" : "REMOTE", pTask->execId, pTask->retryTimes);
 
   SCH_LOG_TASK_START_TS(pTask);
diff --git a/source/libs/scheduler/src/scheduler.c b/source/libs/scheduler/src/scheduler.c
index c4fefb4862..e7561ccb7e 100644
--- a/source/libs/scheduler/src/scheduler.c
+++ b/source/libs/scheduler/src/scheduler.c
@@ -67,7 +67,7 @@ int32_t schedulerInit() {
 }
 
 int32_t schedulerExecJob(SSchedulerReq *pReq, int64_t *pJobId) {
-  qError("scheduler %s exec job start", pReq->syncReq ? "SYNC" : "ASYNC");
+  qDebug("scheduler %s exec job start", pReq->syncReq ? "SYNC" : "ASYNC");
 
   int32_t  code = 0;
   SSchJob *pJob = NULL;
@@ -86,7 +86,7 @@ _return:
 }
 
 int32_t schedulerFetchRows(int64_t jobId, SSchedulerReq *pReq) {
-  qError("scheduler %s fetch rows start", pReq->syncReq ? "SYNC" : "ASYNC");
+  qDebug("scheduler %s fetch rows start", pReq->syncReq ? "SYNC" : "ASYNC");
 
   int32_t  code = 0;
   SSchJob *pJob = NULL;
diff --git a/source/libs/transport/src/transCli.c b/source/libs/transport/src/transCli.c
index 7fcc5921ae..1709fc3cb1 100644
--- a/source/libs/transport/src/transCli.c
+++ b/source/libs/transport/src/transCli.c
@@ -426,7 +426,7 @@ void cliHandleResp(SCliConn* conn) {
   }
 
   STraceId* trace = &transMsg.info.traceId;
-  tGError("%s conn %p %s received from %s, local info:%s, len:%d, code str:%s", CONN_GET_INST_LABEL(conn), conn,
+  tGDebug("%s conn %p %s received from %s, local info:%s, len:%d, code str:%s", CONN_GET_INST_LABEL(conn), conn,
           TMSG_INFO(pHead->msgType), conn->dst, conn->src, pHead->msgLen, tstrerror(transMsg.code));
 
   if (pCtx == NULL && CONN_NO_PERSIST_BY_APP(conn)) {
@@ -966,7 +966,7 @@ static void cliSendCb(uv_write_t* req, int status) {
   }
 
   if (status == 0) {
-    tError("%s conn %p data already was written out", CONN_GET_INST_LABEL(pConn), pConn);
+    tDebug("%s conn %p data already was written out", CONN_GET_INST_LABEL(pConn), pConn);
   } else {
     if (!uv_is_closing((uv_handle_t*)&pConn->stream)) {
       tError("%s conn %p failed to write:%s", CONN_GET_INST_LABEL(pConn), pConn, uv_err_name(status));
@@ -1106,7 +1106,7 @@ void cliSend(SCliConn* pConn) {
     msgLen = (int32_t)ntohl((uint32_t)(pHead->msgLen));
   }
 
-  tGError("%s conn %p %s is sent to %s, local info %s, len:%d", CONN_GET_INST_LABEL(pConn), pConn,
+  tGDebug("%s conn %p %s is sent to %s, local info %s, len:%d", CONN_GET_INST_LABEL(pConn), pConn,
           TMSG_INFO(pHead->msgType), pConn->dst, pConn->src, msgLen);
 
   uv_buf_t    wb = uv_buf_init((char*)pHead, msgLen);
diff --git a/source/libs/transport/src/transSvr.c b/source/libs/transport/src/transSvr.c
index f5d2f66c9d..da3b0ad626 100644
--- a/source/libs/transport/src/transSvr.c
+++ b/source/libs/transport/src/transSvr.c
@@ -236,19 +236,19 @@ static bool uvHandleReq(SSvrConn* pConn) {
   if (pConn->status == ConnNormal && pHead->noResp == 0) {
     transRefSrvHandle(pConn);
     if (cost >= EXCEPTION_LIMIT_US) {
-      tGError("%s conn %p %s received from %s, local info:%s, len:%d, cost:%dus, recv exception", transLabel(pTransInst),
+      tGDebug("%s conn %p %s received from %s, local info:%s, len:%d, cost:%dus, recv exception", transLabel(pTransInst),
              pConn, TMSG_INFO(transMsg.msgType), pConn->dst, pConn->src, msgLen, (int)cost);
     } else {
-      tGError("%s conn %p %s received from %s, local info:%s, len:%d, cost:%dus", transLabel(pTransInst), pConn,
+      tGDebug("%s conn %p %s received from %s, local info:%s, len:%d, cost:%dus", transLabel(pTransInst), pConn,
               TMSG_INFO(transMsg.msgType), pConn->dst, pConn->src, msgLen, (int)cost);
     }
   } else {
     if (cost >= EXCEPTION_LIMIT_US) {
-      tGError("%s conn %p %s received from %s, local info:%s, len:%d, noResp:%d, code:%d, cost:%dus, recv exception",
+      tGDebug("%s conn %p %s received from %s, local info:%s, len:%d, noResp:%d, code:%d, cost:%dus, recv exception",
              transLabel(pTransInst), pConn, TMSG_INFO(transMsg.msgType), pConn->dst, pConn->src, msgLen, pHead->noResp,
              transMsg.code, (int)(cost));
     } else {
-      tGError("%s conn %p %s received from %s, local info:%s, len:%d, noResp:%d, code:%d, cost:%dus",
+      tGDebug("%s conn %p %s received from %s, local info:%s, len:%d, noResp:%d, code:%d, cost:%dus",
               transLabel(pTransInst), pConn, TMSG_INFO(transMsg.msgType), pConn->dst, pConn->src, msgLen, pHead->noResp,
               transMsg.code, (int)(cost));
     }
@@ -447,7 +447,7 @@ static int uvPrepareSendData(SSvrMsg* smsg, uv_buf_t* wb) {
   }
 
   STraceId* trace = &pMsg->info.traceId;
-  tGError("%s conn %p %s is sent to %s, local info:%s, len:%d", transLabel(pTransInst), pConn,
+  tGDebug("%s conn %p %s is sent to %s, local info:%s, len:%d", transLabel(pTransInst), pConn,
           TMSG_INFO(pHead->msgType), pConn->dst, pConn->src, len);
 
   wb->base = (char*)pHead;