diff --git a/include/common/systable.h b/include/common/systable.h
index e38dee8842..71d29dd318 100644
--- a/include/common/systable.h
+++ b/include/common/systable.h
@@ -61,7 +61,7 @@ extern "C" {
 #define TSDB_INS_TABLE_MACHINES          "ins_machines"
 #define TSDB_INS_TABLE_ENCRYPTIONS       "ins_encryptions"
 #define TSDB_INS_TABLE_TSMAS             "ins_tsmas"
-#define TSDB_INS_TABLE_USAGE             "ins_usage"
+#define TSDB_INS_DISK_USAGE              "ins_disk_usage"
 
 #define TSDB_PERFORMANCE_SCHEMA_DB   "performance_schema"
 #define TSDB_PERFS_TABLE_SMAS        "perf_smas"
diff --git a/include/common/tcommon.h b/include/common/tcommon.h
index c3b8a700e8..67b1d13b7f 100644
--- a/include/common/tcommon.h
+++ b/include/common/tcommon.h
@@ -300,20 +300,9 @@ int32_t tSerializeBlockDistInfo(void* buf, int32_t bufLen, const STableBlockDist
 int32_t tDeserializeBlockDistInfo(void* buf, int32_t bufLen, STableBlockDistInfo* pInfo);
 
 typedef struct SDBBlockUsageInfo {
-  uint32_t rowSize;
-  uint16_t numOfFiles;
-  uint32_t numOfTables;
-  uint32_t numOfBlocks;
-  uint64_t totalSize;
-  uint64_t totalRows;
-  int32_t  maxRows;
-  int32_t  minRows;
-  int32_t  defMinRows;
-  int32_t  defMaxRows;
-  int32_t  firstSeekTimeUs;
-  uint32_t numOfInmemRows;
-  uint32_t numOfSttRows;
-  uint32_t numOfVgroups;
+  uint64_t dataInDiskSize;
+  uint64_t walInDiskSize;
+  uint64_t rawDataSize;
 } SDBBlockUsageInfo;
 
 int32_t tSerializeBlockDbUsage(void* buf, int32_t bufLen, const SDBBlockUsageInfo* pInfo);
diff --git a/include/libs/nodes/querynodes.h b/include/libs/nodes/querynodes.h
index 4763077ed9..c47bebab19 100644
--- a/include/libs/nodes/querynodes.h
+++ b/include/libs/nodes/querynodes.h
@@ -22,8 +22,8 @@ extern "C" {
 
 #include "nodes.h"
 #include "tmsg.h"
-#include "tvariant.h"
 #include "tsimplehash.h"
+#include "tvariant.h"
 
 #define TABLE_TOTAL_COL_NUM(pMeta) ((pMeta)->tableInfo.numOfColumns + (pMeta)->tableInfo.numOfTags)
 #define TABLE_META_SIZE(pMeta) \
@@ -41,7 +41,7 @@ typedef struct SRawExprNode {
   char*     p;
   uint32_t  n;
   SNode*    pNode;
-  bool isPseudoColumn;
+  bool      isPseudoColumn;
 } SRawExprNode;
 
 typedef struct SDataType {
@@ -111,8 +111,8 @@ typedef struct STargetNode {
 #define VALUE_FLAG_IS_DURATION    (1 << 0)
 #define VALUE_FLAG_IS_TIME_OFFSET (1 << 1)
 
-#define IS_DURATION_VAL(_flag) ((_flag) & VALUE_FLAG_IS_DURATION)
-#define IS_TIME_OFFSET_VAL(_flag) ((_flag) & VALUE_FLAG_IS_TIME_OFFSET)
+#define IS_DURATION_VAL(_flag)    ((_flag)&VALUE_FLAG_IS_DURATION)
+#define IS_TIME_OFFSET_VAL(_flag) ((_flag)&VALUE_FLAG_IS_TIME_OFFSET)
 
 typedef struct SValueNode {
   SExprNode node;  // QUERY_NODE_VALUE
@@ -190,7 +190,7 @@ typedef struct SFunctionNode {
   bool       hasOriginalFunc;
   int32_t    originalFuncId;
   ETrimType  trimType;
-  bool       dual; // whether select stmt without from stmt, true for without.
+  bool       dual;  // whether select stmt without from stmt, true for without.
 } SFunctionNode;
 
 typedef struct STableNode {
@@ -205,7 +205,7 @@ typedef struct STableNode {
 struct STableMeta;
 
 typedef struct STsmaTargetCTbInfo {
-  char     tableName[TSDB_TABLE_NAME_LEN]; // child table or normal table name
+  char     tableName[TSDB_TABLE_NAME_LEN];  // child table or normal table name
   uint64_t uid;
 } STsmaTargetTbInfo;
 
@@ -219,8 +219,8 @@ typedef struct SRealTableNode {
   int8_t             cacheLastMode;
   int8_t             stbRewrite;
   SArray*            pTsmas;
-  SArray*            tsmaTargetTbVgInfo; // SArray<SVgroupsInfo*>, used for child table or normal table only
-  SArray*            tsmaTargetTbInfo; // SArray<STsmaTargetTbInfo>, used for child table or normal table only
+  SArray*            tsmaTargetTbVgInfo;  // SArray<SVgroupsInfo*>, used for child table or normal table only
+  SArray*            tsmaTargetTbInfo;    // SArray<STsmaTargetTbInfo>, used for child table or normal table only
 } SRealTableNode;
 
 typedef struct STempTableNode {
@@ -238,12 +238,12 @@ typedef struct SViewNode {
   int8_t             cacheLastMode;
 } SViewNode;
 
-#define JOIN_JLIMIT_MAX_VALUE  1024
+#define JOIN_JLIMIT_MAX_VALUE 1024
 
 #define IS_INNER_NONE_JOIN(_type, _stype) ((_type) == JOIN_TYPE_INNER && (_stype) == JOIN_STYPE_NONE)
-#define IS_SEMI_JOIN(_stype) ((_stype) == JOIN_STYPE_SEMI)
-#define IS_WINDOW_JOIN(_stype) ((_stype) == JOIN_STYPE_WIN)
-#define IS_ASOF_JOIN(_stype) ((_stype) == JOIN_STYPE_ASOF)
+#define IS_SEMI_JOIN(_stype)              ((_stype) == JOIN_STYPE_SEMI)
+#define IS_WINDOW_JOIN(_stype)            ((_stype) == JOIN_STYPE_WIN)
+#define IS_ASOF_JOIN(_stype)              ((_stype) == JOIN_STYPE_ASOF)
 
 typedef enum EJoinType {
   JOIN_TYPE_INNER = 0,
@@ -407,7 +407,6 @@ typedef struct SWindowOffsetNode {
   SNode*    pEndOffset;    // SValueNode
 } SWindowOffsetNode;
 
-
 typedef struct SSelectStmt {
   ENodeType     type;  // QUERY_NODE_SELECT_STMT
   bool          isDistinct;
@@ -461,6 +460,7 @@ typedef struct SSelectStmt {
   bool          groupSort;
   bool          tagScan;
   bool          joinContains;
+  bool          mixSysTableAndActualTable;
 } SSelectStmt;
 
 typedef enum ESetOperatorType { SET_OP_TYPE_UNION_ALL = 1, SET_OP_TYPE_UNION } ESetOperatorType;
@@ -630,13 +630,15 @@ void nodesRewriteSelectStmt(SSelectStmt* pSelect, ESqlClause clause, FNodeRewrit
 typedef enum ECollectColType { COLLECT_COL_TYPE_COL = 1, COLLECT_COL_TYPE_TAG, COLLECT_COL_TYPE_ALL } ECollectColType;
 int32_t nodesCollectColumns(SSelectStmt* pSelect, ESqlClause clause, const char* pTableAlias, ECollectColType type,
                             SNodeList** pCols);
-int32_t nodesCollectColumnsExt(SSelectStmt* pSelect, ESqlClause clause, SSHashObj* pMultiTableAlias, ECollectColType type,
-                            SNodeList** pCols);
+int32_t nodesCollectColumnsExt(SSelectStmt* pSelect, ESqlClause clause, SSHashObj* pMultiTableAlias,
+                               ECollectColType type, SNodeList** pCols);
 int32_t nodesCollectColumnsFromNode(SNode* node, const char* pTableAlias, ECollectColType type, SNodeList** pCols);
 
 typedef bool (*FFuncClassifier)(int32_t funcId);
-int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList** pFuncs);
-int32_t nodesCollectSelectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList* pFuncs);
+int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier,
+                          SNodeList** pFuncs);
+int32_t nodesCollectSelectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier,
+                                SNodeList* pFuncs);
 
 int32_t nodesCollectSpecialNodes(SSelectStmt* pSelect, ESqlClause clause, ENodeType type, SNodeList** pNodes);
 
@@ -670,12 +672,11 @@ const char* logicConditionTypeStr(ELogicConditionType type);
 bool nodesIsStar(SNode* pNode);
 bool nodesIsTableStar(SNode* pNode);
 
-char* getJoinTypeString(EJoinType type);
-char* getJoinSTypeString(EJoinSubType type);
-char* getFullJoinTypeString(EJoinType type, EJoinSubType stype);
+char*   getJoinTypeString(EJoinType type);
+char*   getJoinSTypeString(EJoinSubType type);
+char*   getFullJoinTypeString(EJoinType type, EJoinSubType stype);
 int32_t mergeJoinConds(SNode** ppDst, SNode** ppSrc);
 
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/common/src/systable.c b/source/common/src/systable.c
index 49e52671a0..8e7ad8e76b 100644
--- a/source/common/src/systable.c
+++ b/source/common/src/systable.c
@@ -454,13 +454,14 @@ static const SSysDbTableSchema encryptionsSchema[] = {
 static const SSysDbTableSchema usageSchema[] = {
     {.name = "db_name", .bytes = 32 + VARSTR_HEADER_SIZE, .type = TSDB_DATA_TYPE_VARCHAR, .sysInfo = true},
     {.name = "vgroup_id", .bytes = 4, .type = TSDB_DATA_TYPE_INT, .sysInfo = true},
-    {.name = "wal_size", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT, .sysInfo = true},
-    {.name = "mem_rows_size", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT, .sysInfo = true},
-    {.name = "level1_size", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT, .sysInfo = true},
-    {.name = "level2_size", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT, .sysInfo = true},
-    {.name = "level3_size", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT, .sysInfo = true},
-    {.name = "s3_size",.bytes = 8, .type = TSDB_DATA_TYPE_BIGINT, .sysInfo = true},
-    {.name = "estimated_row_data_size", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT, .sysInfo = true},
+    {.name = "wal", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT, .sysInfo = true},
+    {.name = "level1", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT, .sysInfo = true},
+    {.name = "level2", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT, .sysInfo = true},
+    {.name = "level3", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT, .sysInfo = true},
+    {.name = "cache", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT, .sysInfo = true},
+    {.name = "meta", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT, .sysInfo = true},
+    {.name = "s3",.bytes = 8, .type = TSDB_DATA_TYPE_BIGINT, .sysInfo = true},
+    {.name = "estimated_raw_data", .bytes = 8, .type = TSDB_DATA_TYPE_BIGINT, .sysInfo = true},
 };
 
 static const SSysTableMeta infosMeta[] = {
@@ -501,7 +502,7 @@ static const SSysTableMeta infosMeta[] = {
     {TSDB_INS_TABLE_TSMAS, tsmaSchema, tListLen(tsmaSchema), false},
     {TSDB_INS_TABLE_ANODES, anodesSchema, tListLen(anodesSchema), true},
     {TSDB_INS_TABLE_ANODES_FULL, anodesFullSchema, tListLen(anodesFullSchema), true},
-    {TSDB_INS_TABLE_USAGE, usageSchema, tListLen(usageSchema), false},
+    {TSDB_INS_DISK_USAGE, usageSchema, tListLen(usageSchema), false},
 };
 
 static const SSysDbTableSchema connectionsSchema[] = {
diff --git a/source/dnode/mnode/impl/src/mndShow.c b/source/dnode/mnode/impl/src/mndShow.c
index ecdd65ca9e..2bf7bbfac9 100644
--- a/source/dnode/mnode/impl/src/mndShow.c
+++ b/source/dnode/mnode/impl/src/mndShow.c
@@ -142,7 +142,7 @@ static int32_t convertToRetrieveType(char *name, int32_t len) {
     type = TSDB_MGMT_TABLE_ENCRYPTIONS;
   } else if (strncasecmp(name, TSDB_INS_TABLE_TSMAS, len) == 0) {
     type = TSDB_MGMT_TABLE_TSMAS;
-  } else if (strncasecmp(name, TSDB_INS_TABLE_USAGE, len) == 0) {
+  } else if (strncasecmp(name, TSDB_INS_DISK_USAGE, len) == 0) {
     type = TSDB_MGMT_TABLE_USAGE;
   } else {
     mError("invalid show name:%s len:%d", name, len);
@@ -364,9 +364,9 @@ static int32_t mndProcessRetrieveSysTableReq(SRpcMsg *pReq) {
     }
 
     int32_t len = blockEncode(pBlock, pStart, pShow->pMeta->numOfColumns);
-    if(len < 0){
+    if (len < 0) {
       mError("show:0x%" PRIx64 ", failed to retrieve data since %s", pShow->id, tstrerror(code));
-      code =  terrno;
+      code = terrno;
       return code;
     }
   }
@@ -390,7 +390,7 @@ static int32_t mndProcessRetrieveSysTableReq(SRpcMsg *pReq) {
 _exit:
   mndReleaseShowObj(pShow, false);
   blockDataDestroy(pBlock);
-  if(pRsp) {
+  if (pRsp) {
     rpcFreeCont(pRsp);
   }
   return code;
diff --git a/source/libs/executor/src/sysscanoperator.c b/source/libs/executor/src/sysscanoperator.c
index 0815732ecc..9dac1a1117 100644
--- a/source/libs/executor/src/sysscanoperator.c
+++ b/source/libs/executor/src/sysscanoperator.c
@@ -61,6 +61,7 @@ typedef struct SSysTableScanInfo {
   bool                   sysInfo;
   bool                   showRewrite;
   bool                   restore;
+  bool                   skipFilterTable;
   SNode*                 pCondition;  // db_name filter condition, to discard data that are not in current database
   SMTbCursor*            pCur;        // cursor for iterate the local table meta store.
   SSysTableIndex*        pIdx;        // idx for local table meta
@@ -1457,7 +1458,7 @@ _end:
 int32_t buildSysUsageInfo(const SSysTableScanInfo* pInfo, int32_t capacity) {
   int32_t      code = TSDB_CODE_SUCCESS;
   int32_t      lino = 0;
-  SSDataBlock* p = buildInfoSchemaTableMetaBlock(TSDB_INS_TABLE_USAGE);
+  SSDataBlock* p = buildInfoSchemaTableMetaBlock(TSDB_INS_DISK_USAGE);
   QUERY_CHECK_NULL(p, code, lino, _end, terrno);
 
   code = blockDataEnsureCapacity(p, capacity);
@@ -2026,14 +2027,24 @@ static int32_t buildVgDiskUsage(SOperatorInfo* pOperator, SDbSizeStatisInfo* pSt
   const char*        db = NULL;
   pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, &pStaticsInfo->dbname, &vgId, NULL, NULL);
 
-  SDbSizeStatisInfo staticsInfo = {0};
+  pStaticsInfo->vgId = vgId;
 
-  staticsInfo.vgId = vgId;
-
-  code = pAPI->metaFn.getDBSize(pInfo->readHandle.vnode, &staticsInfo);
+  code = pAPI->metaFn.getDBSize(pInfo->readHandle.vnode, pStaticsInfo);
   QUERY_CHECK_CODE(code, lino, _end);
 
-  return vnodeEstimateRawDataSize(pOperator, &staticsInfo);
+  code = vnodeEstimateRawDataSize(pOperator, pStaticsInfo);
+  QUERY_CHECK_CODE(code, lino, _end);
+
+  pStaticsInfo->memSize = pStaticsInfo->memSize >> 10;
+  pStaticsInfo->l1Size = pStaticsInfo->l1Size >> 10;
+  pStaticsInfo->l2Size = pStaticsInfo->l2Size >> 10;
+  pStaticsInfo->l3Size = pStaticsInfo->l3Size >> 10;
+  pStaticsInfo->cacheSize = pStaticsInfo->cacheSize >> 10;
+  pStaticsInfo->walSize = pStaticsInfo->walSize >> 10;
+  pStaticsInfo->metaSize = pStaticsInfo->metaSize >> 10;
+  pStaticsInfo->rawDataSize = pStaticsInfo->rawDataSize >> 10;
+  pStaticsInfo->s3Size = pStaticsInfo->s3Size >> 10;
+
 _end:
   return code;
 }
@@ -2069,9 +2080,9 @@ static SSDataBlock* sysTableBuildVgUsage(SOperatorInfo* pOperator) {
     SDBBlockUsageInfo usageInfo = {0};
     int32_t           len = tSerializeBlockDbUsage(NULL, 0, &usageInfo);
 
-    usageInfo.numOfSttRows = 120;
-    usageInfo.numOfInmemRows = 120;
-    usageInfo.numOfBlocks = 120;
+    usageInfo.dataInDiskSize = staticsInfo.l1Size + staticsInfo.l2Size + staticsInfo.l3Size;
+    usageInfo.walInDiskSize = staticsInfo.walSize;
+    usageInfo.rawDataSize = staticsInfo.rawDataSize;
 
     char* p = taosMemoryCalloc(1, len + VARSTR_HEADER_SIZE);
     QUERY_CHECK_NULL(p, code, lino, _end, terrno);
@@ -2098,7 +2109,6 @@ static SSDataBlock* sysTableBuildVgUsage(SOperatorInfo* pOperator) {
     pBlock->info.rows = 1;
     pOperator->status = OP_EXEC_DONE;
     pInfo->pRes->info.rows = pBlock->info.rows;
-    // code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, pBlock->pDataBlock, false);
     QUERY_CHECK_CODE(code, lino, _end);
   } else {
     SName sn = {0};
@@ -2111,7 +2121,7 @@ static SSDataBlock* sysTableBuildVgUsage(SOperatorInfo* pOperator) {
 
     varDataSetLen(dbname, strlen(varDataVal(dbname)));
 
-    p = buildInfoSchemaTableMetaBlock(TSDB_INS_TABLE_USAGE);
+    p = buildInfoSchemaTableMetaBlock(TSDB_INS_DISK_USAGE);
     QUERY_CHECK_NULL(p, code, lino, _end, terrno);
 
     code = blockDataEnsureCapacity(p, pOperator->resultInfo.capacity);
@@ -2129,10 +2139,6 @@ static SSDataBlock* sysTableBuildVgUsage(SOperatorInfo* pOperator) {
     code = colDataSetVal(pColInfoData, numOfRows, (char*)&staticsInfo.walSize, false);  // wal
     QUERY_CHECK_CODE(code, lino, _end);
 
-    pColInfoData = taosArrayGet(p->pDataBlock, numOfCols++);
-    code = colDataSetVal(pColInfoData, numOfRows, (char*)&staticsInfo.memSize, false);  // memtable
-    QUERY_CHECK_CODE(code, lino, _end);
-
     pColInfoData = taosArrayGet(p->pDataBlock, numOfCols++);
     code = colDataSetVal(pColInfoData, numOfRows, (char*)&staticsInfo.l1Size, false);  // l1_size
     QUERY_CHECK_CODE(code, lino, _end);
@@ -2145,6 +2151,14 @@ static SSDataBlock* sysTableBuildVgUsage(SOperatorInfo* pOperator) {
     code = colDataSetVal(pColInfoData, numOfRows, (char*)&staticsInfo.l3Size, false);  // l3_size
     QUERY_CHECK_CODE(code, lino, _end);
 
+    pColInfoData = taosArrayGet(p->pDataBlock, numOfCols++);
+    code = colDataSetVal(pColInfoData, numOfRows, (char*)&staticsInfo.cacheSize, false);  // cache_size
+    QUERY_CHECK_CODE(code, lino, _end);
+
+    pColInfoData = taosArrayGet(p->pDataBlock, numOfCols++);
+    code = colDataSetVal(pColInfoData, numOfRows, (char*)&staticsInfo.metaSize, false);  // meta_size
+    QUERY_CHECK_CODE(code, lino, _end);
+
     pColInfoData = taosArrayGet(p->pDataBlock, numOfCols++);
     code = colDataSetVal(pColInfoData, numOfRows, (char*)&staticsInfo.s3Size, false);  // s3_size
     QUERY_CHECK_CODE(code, lino, _end);
@@ -2383,16 +2397,13 @@ static int32_t doSysTableScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes)
     } else if (strncasecmp(name, TSDB_INS_TABLE_STABLES, TSDB_TABLE_FNAME_LEN) == 0 && pInfo->showRewrite &&
                IS_SYS_DBNAME(dbName)) {
       pBlock = sysTableScanUserSTables(pOperator);
-    } else if (strncasecmp(name, TSDB_INS_TABLE_USAGE, TSDB_TABLE_FNAME_LEN) == 0) {
-      if (pInfo->showRewrite) {
-        filter = false;
-      }
+    } else if (strncasecmp(name, TSDB_INS_DISK_USAGE, TSDB_TABLE_FNAME_LEN) == 0) {
       pBlock = sysTableScanUsage(pOperator);
     } else {  // load the meta from mnode of the given epset
       pBlock = sysTableScanFromMNode(pOperator, pInfo, name, pTaskInfo);
     }
 
-    if (filter) sysTableScanFillTbName(pOperator, pInfo, name, pBlock);
+    if (!pInfo->skipFilterTable) sysTableScanFillTbName(pOperator, pInfo, name, pBlock);
     if (pBlock != NULL) {
       bool limitReached = applyLimitOffset(&pInfo->limitInfo, pBlock, pTaskInfo);
       if (limitReached) {
@@ -2587,7 +2598,17 @@ int32_t createSysTableScanOperatorInfo(void* readHandle, SSystemTableScanPhysiNo
   QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, terrno);
 
   pInfo->pCondition = pScanNode->node.pConditions;
-  code = filterInitFromNode(pScanNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
+
+  tNameAssign(&pInfo->name, &pScanNode->tableName);
+  const char* name = tNameGetTableName(&pInfo->name);
+  if (pInfo->showRewrite == false) {
+    code = filterInitFromNode(pScanNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0);
+  } else {
+    if (strncasecmp(name, TSDB_INS_DISK_USAGE, TSDB_TABLE_FNAME_LEN) == 0) {
+      pInfo->skipFilterTable = true;
+    }
+    code = filterInitFromNode(NULL, &pOperator->exprSupp.pFilterInfo, 0);
+  }
   QUERY_CHECK_CODE(code, lino, _error);
 
   initLimitInfo(pScanPhyNode->scan.node.pLimit, pScanPhyNode->scan.node.pSlimit, &pInfo->limitInfo);
@@ -2595,9 +2616,6 @@ int32_t createSysTableScanOperatorInfo(void* readHandle, SSystemTableScanPhysiNo
   code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity);
   QUERY_CHECK_CODE(code, lino, _error);
 
-  tNameAssign(&pInfo->name, &pScanNode->tableName);
-  const char* name = tNameGetTableName(&pInfo->name);
-
   if (strncasecmp(name, TSDB_INS_TABLE_TABLES, TSDB_TABLE_FNAME_LEN) == 0 ||
       strncasecmp(name, TSDB_INS_TABLE_TAGS, TSDB_TABLE_FNAME_LEN) == 0) {
     pInfo->readHandle = *(SReadHandle*)readHandle;
@@ -3326,13 +3344,8 @@ static int32_t vnodeEstimateDataSizeByUid(SOperatorInfo* pOperator, STableId* id
 
   void* pList = tableListGetInfo(pTableListInfo, 0);
 
-  if (pInfo->showRewrite) {
-    code = pReadHandle->api.tsdReader.tsdReaderOpen(pReadHandle->vnode, &cond, pList, num, pInfo->pRes,
-                                                    (void**)&pInfo->pHandle, pTaskInfo->id.str, NULL);
-  } else {
-    code = pReadHandle->api.tsdReader.tsdReaderOpen(pReadHandle->vnode, &cond, pList, num, NULL,
-                                                    (void**)&pInfo->pHandle, pTaskInfo->id.str, NULL);
-  }
+  code = pReadHandle->api.tsdReader.tsdReaderOpen(pReadHandle->vnode, &cond, pList, num, NULL, (void**)&pInfo->pHandle,
+                                                  pTaskInfo->id.str, NULL);
   cleanupQueryTableDataCond(&cond);
   QUERY_CHECK_CODE(code, line, _end);
 
diff --git a/source/libs/function/src/builtinsimpl.c b/source/libs/function/src/builtinsimpl.c
index 17c1dcc5ab..2f8ab169e4 100644
--- a/source/libs/function/src/builtinsimpl.c
+++ b/source/libs/function/src/builtinsimpl.c
@@ -6480,7 +6480,6 @@ int32_t blockDBUsageSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResultInfo
   }
 
   SDBBlockUsageInfo* pInfo = GET_ROWCELL_INTERBUF(GET_RES_INFO(pCtx));
-  pInfo->minRows = INT32_MAX;
   return TSDB_CODE_SUCCESS;
 }
 int32_t blockDBUsageFunction(SqlFunctionCtx* pCtx) {
@@ -6497,26 +6496,9 @@ int32_t blockDBUsageFunction(SqlFunctionCtx* pCtx) {
     return TSDB_CODE_FAILED;
   }
 
-  pDistInfo->numOfBlocks += p1.numOfBlocks;
-  pDistInfo->numOfTables += p1.numOfTables;
-  pDistInfo->numOfInmemRows += p1.numOfInmemRows;
-  pDistInfo->numOfSttRows += p1.numOfSttRows;
-  pDistInfo->totalSize += p1.totalSize;
-  pDistInfo->totalRows += p1.totalRows;
-  pDistInfo->numOfFiles += p1.numOfFiles;
-
-  pDistInfo->defMinRows = p1.defMinRows;
-  pDistInfo->defMaxRows = p1.defMaxRows;
-  pDistInfo->rowSize = p1.rowSize;
-
-  if (pDistInfo->minRows > p1.minRows) {
-    pDistInfo->minRows = p1.minRows;
-  }
-  if (pDistInfo->maxRows < p1.maxRows) {
-    pDistInfo->maxRows = p1.maxRows;
-  }
-  pDistInfo->numOfVgroups += (p1.numOfTables != 0 ? 1 : 0);
-
+  pDistInfo->dataInDiskSize += p1.dataInDiskSize;
+  pDistInfo->walInDiskSize += p1.walInDiskSize;
+  pDistInfo->rawDataSize += p1.rawDataSize;
   pResInfo->numOfRes = BLOCK_DISK_USAGE_RESULT_ROWS;  // default output rows
   return TSDB_CODE_SUCCESS;
 }
@@ -6529,21 +6511,10 @@ int32_t tSerializeBlockDbUsage(void* buf, int32_t bufLen, const SDBBlockUsageInf
   tEncoderInit(&encoder, buf, bufLen);
 
   TAOS_CHECK_EXIT(tStartEncode(&encoder));
-  TAOS_CHECK_EXIT(tEncodeU32(&encoder, pInfo->rowSize));
 
-  TAOS_CHECK_EXIT(tEncodeU16(&encoder, pInfo->numOfFiles));
-  TAOS_CHECK_EXIT(tEncodeU32(&encoder, pInfo->numOfBlocks));
-  TAOS_CHECK_EXIT(tEncodeU32(&encoder, pInfo->numOfTables));
-
-  TAOS_CHECK_EXIT(tEncodeU64(&encoder, pInfo->totalSize));
-  TAOS_CHECK_EXIT(tEncodeU64(&encoder, pInfo->totalRows));
-  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pInfo->maxRows));
-  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pInfo->minRows));
-  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pInfo->defMaxRows));
-  TAOS_CHECK_EXIT(tEncodeI32(&encoder, pInfo->defMinRows));
-  TAOS_CHECK_EXIT(tEncodeU32(&encoder, pInfo->numOfInmemRows));
-  TAOS_CHECK_EXIT(tEncodeU32(&encoder, pInfo->numOfSttRows));
-  TAOS_CHECK_EXIT(tEncodeU32(&encoder, pInfo->numOfVgroups));
+  TAOS_CHECK_EXIT(tEncodeU64(&encoder, pInfo->dataInDiskSize));
+  TAOS_CHECK_EXIT(tEncodeU64(&encoder, pInfo->walInDiskSize));
+  TAOS_CHECK_EXIT(tEncodeU64(&encoder, pInfo->rawDataSize));
 
   tEndEncode(&encoder);
 
@@ -6563,21 +6534,9 @@ int32_t tDeserializeBlockDbUsage(void* buf, int32_t bufLen, SDBBlockUsageInfo* p
   tDecoderInit(&decoder, buf, bufLen);
 
   TAOS_CHECK_EXIT(tStartDecode(&decoder));
-  TAOS_CHECK_EXIT(tDecodeU32(&decoder, &pInfo->rowSize));
-
-  TAOS_CHECK_EXIT(tDecodeU16(&decoder, &pInfo->numOfFiles));
-  TAOS_CHECK_EXIT(tDecodeU32(&decoder, &pInfo->numOfBlocks));
-  TAOS_CHECK_EXIT(tDecodeU32(&decoder, &pInfo->numOfTables));
-
-  TAOS_CHECK_EXIT(tDecodeU64(&decoder, &pInfo->totalSize));
-  TAOS_CHECK_EXIT(tDecodeU64(&decoder, &pInfo->totalRows));
-  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pInfo->maxRows));
-  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pInfo->minRows));
-  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pInfo->defMaxRows));
-  TAOS_CHECK_EXIT(tDecodeI32(&decoder, &pInfo->defMinRows));
-  TAOS_CHECK_EXIT(tDecodeU32(&decoder, &pInfo->numOfInmemRows));
-  TAOS_CHECK_EXIT(tDecodeU32(&decoder, &pInfo->numOfSttRows));
-  TAOS_CHECK_EXIT(tDecodeU32(&decoder, &pInfo->numOfVgroups));
+  TAOS_CHECK_EXIT(tDecodeU64(&decoder, &pInfo->dataInDiskSize));
+  TAOS_CHECK_EXIT(tDecodeU64(&decoder, &pInfo->walInDiskSize));
+  TAOS_CHECK_EXIT(tDecodeU64(&decoder, &pInfo->rawDataSize));
 
 _exit:
   tDecoderClear(&decoder);
@@ -6591,26 +6550,17 @@ int32_t blockDBUsageFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
   if (NULL == pColInfo) {
     return TSDB_CODE_OUT_OF_RANGE;
   }
-
-  if (pData->totalRows == 0) {
-    pData->minRows = 0;
-  }
-
   int32_t row = 0;
   char    st[256] = {0};
-  double  averageSize = 0;
-  if (pData->numOfBlocks != 0) {
-    averageSize = ((double)pData->totalSize) / pData->numOfBlocks;
-  }
-  uint64_t totalRawSize = pData->totalRows * pData->rowSize;
-  double   compRatio = 0;
-  if (totalRawSize != 0) {
-    compRatio = pData->totalSize * 100 / (double)totalRawSize;
+
+  uint64_t totalDiskSize = pData->dataInDiskSize;
+  uint64_t rawDataSize = pData->rawDataSize;
+  double   compressRadio = 0;
+  if (rawDataSize != 0) {
+    compressRadio = totalDiskSize * 100 / (double)rawDataSize;
   }
 
-  int32_t len = tsnprintf(varDataVal(st), sizeof(st) - VARSTR_HEADER_SIZE,
-                          "Total_Blocks=[%d] Total_Size=[%.2f KiB] Average_size=[%.2f KiB] Compression_Ratio=[%.2f %c]",
-                          pData->numOfBlocks, pData->totalSize / 1024.0, averageSize / 1024.0, compRatio, '%');
+  int32_t len = tsnprintf(varDataVal(st), sizeof(st) - VARSTR_HEADER_SIZE, "Compress_radio: %.2f", compressRadio);
 
   varDataSetLen(st, len);
   int32_t code = colDataSetVal(pColInfo, row++, st, false);
@@ -6618,14 +6568,8 @@ int32_t blockDBUsageFinalize(SqlFunctionCtx* pCtx, SSDataBlock* pBlock) {
     return code;
   }
 
-  int64_t avgRows = 0;
-  if (pData->numOfBlocks > 0) {
-    avgRows = pData->totalRows / pData->numOfBlocks;
-  }
-
-  len = tsnprintf(varDataVal(st), sizeof(st) - VARSTR_HEADER_SIZE,
-                  "Block_Rows=[%" PRId64 "] MinRows=[%d] MaxRows=[%d] AvgRows=[%" PRId64 "]", pData->totalRows,
-                  pData->minRows, pData->maxRows, avgRows);
+  len =
+      tsnprintf(varDataVal(st), sizeof(st) - VARSTR_HEADER_SIZE, "Disk_occupied: %" PRId64 "k", pData->dataInDiskSize);
   varDataSetLen(st, len);
   code = colDataSetVal(pColInfo, row++, st, false);
   if (TSDB_CODE_SUCCESS != code) {
diff --git a/source/libs/parser/inc/parTranslater.h b/source/libs/parser/inc/parTranslater.h
index 3cb3be4e90..43e2af2e91 100644
--- a/source/libs/parser/inc/parTranslater.h
+++ b/source/libs/parser/inc/parTranslater.h
@@ -20,10 +20,10 @@
 extern "C" {
 #endif
 
+#include "cmdnodes.h"
 #include "parToken.h"
 #include "parUtil.h"
 #include "parser.h"
-#include "cmdnodes.h"
 
 typedef struct STranslateContext {
   SParseContext*   pParseCxt;
@@ -46,14 +46,16 @@ typedef struct STranslateContext {
   bool             withOpt;
   SNode*           pPrevRoot;
   SNode*           pPostRoot;
-  bool             dual; // whether select stmt without from stmt, true for without.
+  bool             dual;  // whether select stmt without from stmt, true for without.
+  bool             skipCheck;
 } STranslateContext;
 
 int32_t biRewriteToTbnameFunc(STranslateContext* pCxt, SNode** ppNode, bool* pRet);
 int32_t biRewriteSelectStar(STranslateContext* pCxt, SSelectStmt* pSelect);
 int32_t biCheckCreateTableTbnameCol(STranslateContext* pCxt, SCreateTableStmt* pStmt);
 int32_t findTable(STranslateContext* pCxt, const char* pTableAlias, STableNode** pOutput);
-int32_t getTargetMetaImpl(SParseContext* pParCxt, SParseMetaCache* pMetaCache, const SName* pName, STableMeta** pMeta, bool couldBeView);
+int32_t getTargetMetaImpl(SParseContext* pParCxt, SParseMetaCache* pMetaCache, const SName* pName, STableMeta** pMeta,
+                          bool couldBeView);
 
 #ifdef __cplusplus
 }
diff --git a/source/libs/parser/src/parAstParser.c b/source/libs/parser/src/parAstParser.c
index e97dc7325c..1436fa85fb 100644
--- a/source/libs/parser/src/parAstParser.c
+++ b/source/libs/parser/src/parAstParser.c
@@ -184,7 +184,7 @@ static int32_t collectMetaKeyFromRealTableImpl(SCollectMetaKeyCxt* pCxt, const c
   }
   if (TSDB_CODE_SUCCESS == code &&
       (0 == strcmp(pTable, TSDB_INS_TABLE_TAGS) || 0 == strcmp(pTable, TSDB_INS_TABLE_TABLES) ||
-       0 == strcmp(pTable, TSDB_INS_TABLE_COLS) || 0 == strcmp(pTable, TSDB_INS_TABLE_USAGE)) &&
+       0 == strcmp(pTable, TSDB_INS_TABLE_COLS) || 0 == strcmp(pTable, TSDB_INS_DISK_USAGE)) &&
       QUERY_NODE_SELECT_STMT == nodeType(pCxt->pStmt)) {
     code = collectMetaKeyFromInsTags(pCxt);
   }
@@ -933,7 +933,7 @@ static int32_t collectMetaKeyFromDropTSMAStmt(SCollectMetaKeyCxt* pCxt, SDropTSM
 }
 
 static int32_t collectMetaKeyFromShowUsage(SCollectMetaKeyCxt* pCxt, SShowStmt* pStmt) {
-  int32_t code = reserveTableMetaInCache(pCxt->pParseCxt->acctId, TSDB_INFORMATION_SCHEMA_DB, TSDB_INS_TABLE_USAGE,
+  int32_t code = reserveTableMetaInCache(pCxt->pParseCxt->acctId, TSDB_INFORMATION_SCHEMA_DB, TSDB_INS_DISK_USAGE,
                                          pCxt->pMetaCache);
   if (TSDB_CODE_SUCCESS == code) {
     code = reserveDbVgInfoInCache(pCxt->pParseCxt->acctId, ((SValueNode*)pStmt->pDbName)->literal, pCxt->pMetaCache);
diff --git a/source/libs/parser/src/parCalcConst.c b/source/libs/parser/src/parCalcConst.c
index e757ec8b24..4a3706f9f2 100644
--- a/source/libs/parser/src/parCalcConst.c
+++ b/source/libs/parser/src/parCalcConst.c
@@ -25,10 +25,10 @@ typedef struct SNodeReplaceContext {
 } SNodeReplaceContext;
 
 typedef struct SCalcConstContext {
-  SParseContext*       pParseCxt;
-  SNodeReplaceContext  replaceCxt;
-  SMsgBuf              msgBuf;
-  int32_t              code;
+  SParseContext*      pParseCxt;
+  SNodeReplaceContext replaceCxt;
+  SMsgBuf             msgBuf;
+  int32_t             code;
 } SCalcConstContext;
 
 static int32_t calcConstQuery(SCalcConstContext* pCxt, SNode* pStmt, bool subquery);
@@ -73,7 +73,7 @@ static bool isCondition(const SNode* pNode) {
 
 static int32_t rewriteIsTrue(SNode* pSrc, SNode** pIsTrue) {
   SOperatorNode* pOp = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pOp);
+  int32_t        code = nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pOp);
   if (NULL == pOp) {
     return code;
   }
@@ -196,7 +196,7 @@ static EDealRes doFindAndReplaceNode(SNode** pNode, void* pContext) {
 static int32_t findAndReplaceNode(SCalcConstContext* pCxt, SNode** pRoot, SNode* pTarget, SNode* pNew, bool strict) {
   pCxt->replaceCxt.pNew = pNew;
   pCxt->replaceCxt.pTarget = pTarget;
-  
+
   nodesRewriteExprPostOrder(pRoot, doFindAndReplaceNode, pCxt);
   if (TSDB_CODE_SUCCESS == pCxt->code && strict && !pCxt->replaceCxt.replaced) {
     parserError("target replace node not found, %p", pTarget);
@@ -214,7 +214,7 @@ static int32_t calcConstProject(SCalcConstContext* pCxt, SNode* pProject, bool d
     }
   }
 
-  char aliasName[TSDB_COL_NAME_LEN] = {0};
+  char    aliasName[TSDB_COL_NAME_LEN] = {0};
   int32_t code = TSDB_CODE_SUCCESS;
   if (dual) {
     code = scalarCalculateConstantsFromDual(pProject, pNew);
@@ -226,7 +226,7 @@ static int32_t calcConstProject(SCalcConstContext* pCxt, SNode* pProject, bool d
       int32_t size = taosArrayGetSize(pAssociation);
       for (int32_t i = 0; i < size; ++i) {
         SAssociationNode* pAssNode = taosArrayGet(pAssociation, i);
-        SNode** pCol = pAssNode->pPlace;
+        SNode**           pCol = pAssNode->pPlace;
         if (*pCol == pAssNode->pAssociationNode) {
           strcpy(aliasName, ((SExprNode*)*pCol)->aliasName);
           SArray* pOrigAss = NULL;
@@ -255,15 +255,15 @@ static int32_t calcConstProject(SCalcConstContext* pCxt, SNode* pProject, bool d
   return code;
 }
 
-typedef struct SIsUselessColCtx  {
-  bool      isUseless;
-} SIsUselessColCtx ;
+typedef struct SIsUselessColCtx {
+  bool isUseless;
+} SIsUselessColCtx;
 
-EDealRes checkUselessCol(SNode *pNode, void *pContext) {
-  SIsUselessColCtx  *ctx = (SIsUselessColCtx *)pContext;
+EDealRes checkUselessCol(SNode* pNode, void* pContext) {
+  SIsUselessColCtx* ctx = (SIsUselessColCtx*)pContext;
   if (QUERY_NODE_FUNCTION == nodeType(pNode) && !fmIsScalarFunc(((SFunctionNode*)pNode)->funcId) &&
       !fmIsPseudoColumnFunc(((SFunctionNode*)pNode)->funcId)) {
-    ctx->isUseless = false;  
+    ctx->isUseless = false;
     return DEAL_RES_END;
   }
 
@@ -272,7 +272,7 @@ EDealRes checkUselessCol(SNode *pNode, void *pContext) {
 
 static bool isUselessCol(SExprNode* pProj) {
   SIsUselessColCtx ctx = {.isUseless = true};
-  nodesWalkExpr((SNode*)pProj, checkUselessCol, (void *)&ctx);
+  nodesWalkExpr((SNode*)pProj, checkUselessCol, (void*)&ctx);
   if (!ctx.isUseless) {
     return false;
   }
@@ -281,7 +281,7 @@ static bool isUselessCol(SExprNode* pProj) {
 
 static int32_t createConstantValue(SValueNode** ppNode) {
   SValueNode* pVal = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal);
+  int32_t     code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal);
   if (NULL == pVal) {
     return code;
   }
@@ -316,7 +316,7 @@ static int32_t calcConstProjections(SCalcConstContext* pCxt, SSelectStmt* pSelec
   }
   if (0 == LIST_LENGTH(pSelect->pProjectionList)) {
     SValueNode* pVal = NULL;
-    int32_t code = createConstantValue(&pVal);
+    int32_t     code = createConstantValue(&pVal);
     if (TSDB_CODE_SUCCESS == code) {
       return nodesListStrictAppend(pSelect->pProjectionList, (SNode*)pVal);
     }
@@ -350,10 +350,13 @@ static int32_t calcConstSelectFrom(SCalcConstContext* pCxt, SSelectStmt* pSelect
   if (TSDB_CODE_SUCCESS == code && QUERY_NODE_TEMP_TABLE == nodeType(pSelect->pFromTable) &&
       ((STempTableNode*)pSelect->pFromTable)->pSubquery != NULL &&
       QUERY_NODE_SELECT_STMT == nodeType(((STempTableNode*)pSelect->pFromTable)->pSubquery) &&
-      ((SSelectStmt*)((STempTableNode*)pSelect->pFromTable)->pSubquery)->isEmptyResult){
+      ((SSelectStmt*)((STempTableNode*)pSelect->pFromTable)->pSubquery)->isEmptyResult) {
     pSelect->isEmptyResult = true;
     return code;
-  }      
+  }
+  if (pSelect->mixSysTableAndActualTable) {
+    return code;
+  }
   if (TSDB_CODE_SUCCESS == code) {
     code = calcConstProjections(pCxt, pSelect, subquery);
   }
@@ -509,7 +512,7 @@ static int32_t calcConstSetOpProjections(SCalcConstContext* pCxt, SSetOperator*
   }
   if (0 == LIST_LENGTH(pSetOp->pProjectionList)) {
     SValueNode* pVal = NULL;
-    int32_t code = createConstantValue(&pVal);
+    int32_t     code = createConstantValue(&pVal);
     if (TSDB_CODE_SUCCESS == code) {
       return nodesListStrictAppend(pSetOp->pProjectionList, (SNode*)pVal);
     }
@@ -612,7 +615,8 @@ int32_t calculateConstant(SParseContext* pParseCxt, SQuery* pQuery) {
                            .msgBuf.buf = pParseCxt->pMsg,
                            .msgBuf.len = pParseCxt->msgLen,
                            .code = TSDB_CODE_SUCCESS};
-  int32_t           code = calcConstQuery(&cxt, pQuery->pRoot, false);
+
+  int32_t code = calcConstQuery(&cxt, pQuery->pRoot, false);
   if (TSDB_CODE_SUCCESS == code) {
     resetProjectNullType(pQuery->pRoot);
     if (isEmptyResultQuery(pQuery->pRoot)) {
diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c
index 2aea8a2098..712a167413 100755
--- a/source/libs/parser/src/parTranslater.c
+++ b/source/libs/parser/src/parTranslater.c
@@ -365,7 +365,7 @@ static const SSysTableShowAdapter sysTableShowAdapter[] = {
   {
     .showType = QUERY_NODE_SHOW_USAGE_STMT,
     .pDbName = TSDB_INFORMATION_SCHEMA_DB,
-    .pTableName = TSDB_INS_TABLE_USAGE,
+    .pTableName = TSDB_INS_DISK_USAGE,
     .numOfShowCols = 1,
     .pShowCols = {"*"}
   },
@@ -1505,6 +1505,17 @@ static int32_t findAndSetColumn(STranslateContext* pCxt, SColumnNode** pColRef,
         break;
       }
     }
+
+    if (pCxt->showRewrite && pMeta->tableType == TSDB_SYSTEM_TABLE) {
+      if (strncmp(pCol->dbName, TSDB_INFORMATION_SCHEMA_DB, strlen(TSDB_INFORMATION_SCHEMA_DB)) == 0 &&
+          strncmp(pCol->tableName, TSDB_INS_DISK_USAGE, strlen(TSDB_INS_DISK_USAGE)) == 0 &&
+          strncmp(pCol->colName, "db_name", strlen("db_name")) == 0) {
+        pCol->node.resType.type = TSDB_DATA_TYPE_TIMESTAMP;
+        pCol->node.resType.bytes = 8;
+        pCxt->skipCheck = true;
+        ((SSelectStmt*)pCxt->pCurrStmt)->mixSysTableAndActualTable = true;
+      }
+    }
   } else {
     STempTableNode* pTempTable = (STempTableNode*)pTable;
     SNodeList*      pProjectList = getProjectList(pTempTable->pSubquery);
@@ -4102,7 +4113,7 @@ static int32_t dnodeToVgroupsInfo(SArray* pDnodes, SVgroupsInfo** pVgsInfo) {
 
 static bool sysTableFromVnode(const char* pTable) {
   return ((0 == strcmp(pTable, TSDB_INS_TABLE_TABLES)) || (0 == strcmp(pTable, TSDB_INS_TABLE_TAGS)) ||
-          (0 == strcmp(pTable, TSDB_INS_TABLE_COLS)) || 0 == strcmp(pTable, TSDB_INS_TABLE_USAGE));
+          (0 == strcmp(pTable, TSDB_INS_TABLE_COLS)) || 0 == strcmp(pTable, TSDB_INS_DISK_USAGE));
 }
 
 static bool sysTableFromDnode(const char* pTable) { return 0 == strcmp(pTable, TSDB_INS_TABLE_DNODE_VARIABLES); }
@@ -4175,7 +4186,7 @@ static int32_t setVnodeSysTableVgroupList(STranslateContext* pCxt, SName* pName,
   if (TSDB_CODE_SUCCESS == code &&
       ((0 == strcmp(pRealTable->table.tableName, TSDB_INS_TABLE_TABLES) && !hasUserDbCond) ||
        0 == strcmp(pRealTable->table.tableName, TSDB_INS_TABLE_COLS) ||
-       (0 == strcmp(pRealTable->table.tableName, TSDB_INS_TABLE_USAGE) && !hasUserDbCond))) {
+       (0 == strcmp(pRealTable->table.tableName, TSDB_INS_DISK_USAGE) && !hasUserDbCond))) {
     code = addMnodeToVgroupList(&pCxt->pParseCxt->mgmtEpSet, &pVgs);
   }
 
@@ -4275,7 +4286,7 @@ static bool isSingleTable(SRealTableNode* pRealTable) {
     return 0 != strcmp(pRealTable->table.tableName, TSDB_INS_TABLE_TABLES) &&
            0 != strcmp(pRealTable->table.tableName, TSDB_INS_TABLE_TAGS) &&
            0 != strcmp(pRealTable->table.tableName, TSDB_INS_TABLE_COLS) &&
-           0 != strcmp(pRealTable->table.tableName, TSDB_INS_TABLE_USAGE);
+           0 != strcmp(pRealTable->table.tableName, TSDB_INS_DISK_USAGE);
   }
   return (TSDB_CHILD_TABLE == tableType || TSDB_NORMAL_TABLE == tableType);
 }
@@ -13717,6 +13728,18 @@ static int32_t rewriteShowTableDist(STranslateContext* pCxt, SQuery* pQuery) {
   return code;
 }
 
+static int32_t createBlockDBUsageInfoFunc(SFunctionNode** ppNode) {
+  SFunctionNode* pFunc = NULL;
+  int32_t        code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc);
+  if (NULL == pFunc) {
+    return code;
+  }
+
+  strcpy(pFunc->functionName, "_db_usage_info");
+  strcpy(pFunc->node.aliasName, "_db_usage_info");
+  *ppNode = pFunc;
+  return code;
+}
 static int32_t createDBUsageFunc(SFunctionNode** ppNode) {
   SFunctionNode* pFunc = NULL;
   int32_t        code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc);
@@ -13727,7 +13750,7 @@ static int32_t createDBUsageFunc(SFunctionNode** ppNode) {
   strcpy(pFunc->functionName, "_db_usage");
   strcpy(pFunc->node.aliasName, "_db_usage");
   SFunctionNode* pFuncNew = NULL;
-  code = createBlockDistInfoFunc(&pFuncNew);
+  code = createBlockDBUsageInfoFunc(&pFuncNew);
   if (TSDB_CODE_SUCCESS == code) {
     code = nodesListMakeStrictAppend(&pFunc->pParameterList, (SNode*)pFuncNew);
   }
diff --git a/source/libs/planner/src/planLogicCreater.c b/source/libs/planner/src/planLogicCreater.c
index c579b66511..7fa8a2fe32 100644
--- a/source/libs/planner/src/planLogicCreater.c
+++ b/source/libs/planner/src/planLogicCreater.c
@@ -13,11 +13,11 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "planInt.h"
 #include "filter.h"
 #include "functionMgt.h"
-#include "tglobal.h"
 #include "parser.h"
+#include "planInt.h"
+#include "tglobal.h"
 
 // primary key column always the second column if exists
 #define PRIMARY_COLUMN_SLOT 1
@@ -163,8 +163,9 @@ static EDealRes doNameExpr(SNode* pNode, void* pContext) {
 
 static int32_t rewriteExprForSelect(SNode* pExpr, SSelectStmt* pSelect, ESqlClause clause) {
   nodesWalkExpr(pExpr, doNameExpr, NULL);
-  bool isPartitionBy = (pSelect->pPartitionByList && pSelect->pPartitionByList->length > 0) ? true : false;
-  SRewriteExprCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .pExprs = NULL, .pOutputs = NULL, .isPartitionBy = isPartitionBy};
+  bool            isPartitionBy = (pSelect->pPartitionByList && pSelect->pPartitionByList->length > 0) ? true : false;
+  SRewriteExprCxt cxt = {
+      .errCode = TSDB_CODE_SUCCESS, .pExprs = NULL, .pOutputs = NULL, .isPartitionBy = isPartitionBy};
   cxt.errCode = nodesListMakeAppend(&cxt.pExprs, pExpr);
   if (TSDB_CODE_SUCCESS == cxt.errCode) {
     nodesRewriteSelectStmt(pSelect, clause, doRewriteExpr, &cxt);
@@ -197,8 +198,9 @@ static int32_t cloneRewriteExprs(SNodeList* pExprs, bool* pOutputs, SNodeList**
 static int32_t rewriteExprsForSelect(SNodeList* pExprs, SSelectStmt* pSelect, ESqlClause clause,
                                      SNodeList** pRewriteExprs) {
   nodesWalkExprs(pExprs, doNameExpr, NULL);
-  bool isPartitionBy = (pSelect->pPartitionByList && pSelect->pPartitionByList->length > 0) ? true : false;
-  SRewriteExprCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .pExprs = pExprs, .pOutputs = NULL, .isPartitionBy = isPartitionBy};
+  bool            isPartitionBy = (pSelect->pPartitionByList && pSelect->pPartitionByList->length > 0) ? true : false;
+  SRewriteExprCxt cxt = {
+      .errCode = TSDB_CODE_SUCCESS, .pExprs = pExprs, .pOutputs = NULL, .isPartitionBy = isPartitionBy};
   if (NULL != pRewriteExprs) {
     cxt.pOutputs = taosMemoryCalloc(LIST_LENGTH(pExprs), sizeof(bool));
     if (NULL == cxt.pOutputs) {
@@ -271,6 +273,10 @@ static EScanType getScanType(SLogicPlanContext* pCxt, SNodeList* pScanPseudoCols
   }
 
   if (TSDB_SYSTEM_TABLE == tableType) {
+    // if (NULL != pScanPseudoCols &&
+    //     FUNCTION_TYPE_DB_USAGE_INFO == ((SFunctionNode*)nodesListGetNode(pScanPseudoCols, 0))->funcType) {
+    //   return SCAN_TYPE_BLOCK_INFO;
+    // }
     return SCAN_TYPE_SYSTEM_TABLE;
   }
 
@@ -291,7 +297,7 @@ static EScanType getScanType(SLogicPlanContext* pCxt, SNodeList* pScanPseudoCols
 }
 
 static bool hasPkInTable(const STableMeta* pTableMeta) {
-  return pTableMeta->tableInfo.numOfColumns>=2 && pTableMeta->schema[1].flags & COL_IS_KEY;
+  return pTableMeta->tableInfo.numOfColumns >= 2 && pTableMeta->schema[1].flags & COL_IS_KEY;
 }
 
 static SNode* createFirstCol(SRealTableNode* pTable, const SSchema* pSchema) {
@@ -338,8 +344,8 @@ static int32_t addSystableFirstCol(SRealTableNode* pTable, SNodeList** pCols) {
 }
 
 static int32_t addPrimaryKeyCol(SRealTableNode* pTable, SNodeList** pCols) {
-  bool   found = false;
-  SNode* pCol = NULL;
+  bool     found = false;
+  SNode*   pCol = NULL;
   SSchema* pSchema = &pTable->pMeta->schema[PRIMARY_COLUMN_SLOT];
   FOREACH(pCol, *pCols) {
     if (pSchema->colId == ((SColumnNode*)pCol)->colId) {
@@ -368,7 +374,7 @@ static int32_t addDefaultScanCol(SRealTableNode* pTable, SNodeList** pCols) {
 static int32_t makeScanLogicNode(SLogicPlanContext* pCxt, SRealTableNode* pRealTable, bool hasRepeatScanFuncs,
                                  SLogicNode** pLogicNode) {
   SScanLogicNode* pScan = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SCAN, (SNode**)&pScan);
+  int32_t         code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SCAN, (SNode**)&pScan);
   if (NULL == pScan) {
     return code;
   }
@@ -427,7 +433,8 @@ static int32_t createScanLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
   }
 
   if (TSDB_CODE_SUCCESS == code) {
-    code = nodesCollectFuncs(pSelect, SQL_CLAUSE_FROM, pRealTable->table.tableAlias, fmIsScanPseudoColumnFunc, &pScan->pScanPseudoCols);
+    code = nodesCollectFuncs(pSelect, SQL_CLAUSE_FROM, pRealTable->table.tableAlias, fmIsScanPseudoColumnFunc,
+                             &pScan->pScanPseudoCols);
   }
 
   pScan->scanType = getScanType(pCxt, pScan->pScanPseudoCols, pScan->pScanCols, pScan->tableType, pSelect->tagScan);
@@ -436,15 +443,15 @@ static int32_t createScanLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
   if (TSDB_CODE_SUCCESS == code) {
     SNodeList* pNewScanPseudoCols = NULL;
     code = rewriteExprsForSelect(pScan->pScanPseudoCols, pSelect, SQL_CLAUSE_FROM, NULL);
-/*
-    if (TSDB_CODE_SUCCESS == code && NULL != pScan->pScanPseudoCols) {
-      code = createColumnByRewriteExprs(pScan->pScanPseudoCols, &pNewScanPseudoCols);
-      if (TSDB_CODE_SUCCESS == code) {
-        nodesDestroyList(pScan->pScanPseudoCols);
-        pScan->pScanPseudoCols = pNewScanPseudoCols;
-      }
-    }
-*/
+    /*
+        if (TSDB_CODE_SUCCESS == code && NULL != pScan->pScanPseudoCols) {
+          code = createColumnByRewriteExprs(pScan->pScanPseudoCols, &pNewScanPseudoCols);
+          if (TSDB_CODE_SUCCESS == code) {
+            nodesDestroyList(pScan->pScanPseudoCols);
+            pScan->pScanPseudoCols = pNewScanPseudoCols;
+          }
+        }
+    */
   }
 
   if (NULL != pScan->pScanCols) {
@@ -507,7 +514,7 @@ static int32_t createSubqueryLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSe
 
 int32_t collectJoinResColumns(SSelectStmt* pSelect, SJoinLogicNode* pJoin, SNodeList** pCols) {
   SSHashObj* pTables = NULL;
-  int32_t code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pTables);
+  int32_t    code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pTables);
   if (TSDB_CODE_SUCCESS != code) {
     return code;
   }
@@ -526,7 +533,7 @@ int32_t collectJoinResColumns(SSelectStmt* pSelect, SJoinLogicNode* pJoin, SNode
 
 static int32_t createJoinLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, SJoinTableNode* pJoinTable,
                                    SLogicNode** pLogicNode) {
-  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t         code = TSDB_CODE_SUCCESS;
   SJoinLogicNode* pJoin = NULL;
   code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_JOIN, (SNode**)&pJoin);
   if (NULL == pJoin) {
@@ -555,7 +562,8 @@ static int32_t createJoinLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
   if (TSDB_CODE_SUCCESS == code) {
     code = nodesMakeList(&pJoin->node.pChildren);
   }
-  pJoin->seqWinGroup = (JOIN_STYPE_WIN == pJoinTable->subType) && (pSelect->hasAggFuncs || pSelect->hasIndefiniteRowsFunc);
+  pJoin->seqWinGroup =
+      (JOIN_STYPE_WIN == pJoinTable->subType) && (pSelect->hasAggFuncs || pSelect->hasIndefiniteRowsFunc);
 
   SLogicNode* pLeft = NULL;
   if (TSDB_CODE_SUCCESS == code) {
@@ -638,7 +646,7 @@ static int32_t createJoinLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
     }
     nodesDestroyList(pColList);
   }
-  
+
   if (TSDB_CODE_SUCCESS == code) {
     rewriteTargetsWithResId(pJoin->node.pTargets);
   }
@@ -649,7 +657,6 @@ static int32_t createJoinLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
 
 #endif
 
-
   if (TSDB_CODE_SUCCESS == code) {
     *pLogicNode = (SLogicNode*)pJoin;
   } else {
@@ -708,7 +715,7 @@ static SColumnNode* createColumnByExpr(const char* pStmtName, SExprNode* pExpr)
 
 static int32_t createGroupingSetNode(SNode* pExpr, SNode** ppNode) {
   SGroupingSetNode* pGroupingSet = NULL;
-  int32_t code = 0;
+  int32_t           code = 0;
   *ppNode = NULL;
   code = nodesMakeNode(QUERY_NODE_GROUPING_SET, (SNode**)&pGroupingSet);
   if (NULL == pGroupingSet) {
@@ -731,13 +738,15 @@ static EGroupAction getDistinctGroupAction(SLogicPlanContext* pCxt, SSelectStmt*
                                                                                               : GROUP_ACTION_NONE;
 }
 
-static bool isWindowJoinStmt(SSelectStmt * pSelect) {
-  return (QUERY_NODE_JOIN_TABLE == nodeType(pSelect->pFromTable) && IS_WINDOW_JOIN(((SJoinTableNode*)pSelect->pFromTable)->subType));
+static bool isWindowJoinStmt(SSelectStmt* pSelect) {
+  return (QUERY_NODE_JOIN_TABLE == nodeType(pSelect->pFromTable) &&
+          IS_WINDOW_JOIN(((SJoinTableNode*)pSelect->pFromTable)->subType));
 }
 
 static EGroupAction getGroupAction(SLogicPlanContext* pCxt, SSelectStmt* pSelect) {
-  return ((pCxt->pPlanCxt->streamQuery || NULL != pSelect->pLimit || NULL != pSelect->pSlimit) && !pSelect->isDistinct) ? GROUP_ACTION_KEEP
-                                                                                              : GROUP_ACTION_NONE;
+  return ((pCxt->pPlanCxt->streamQuery || NULL != pSelect->pLimit || NULL != pSelect->pSlimit) && !pSelect->isDistinct)
+             ? GROUP_ACTION_KEEP
+             : GROUP_ACTION_NONE;
 }
 
 static EDataOrderLevel getRequireDataOrder(bool needTimeline, SSelectStmt* pSelect) {
@@ -747,7 +756,7 @@ static EDataOrderLevel getRequireDataOrder(bool needTimeline, SSelectStmt* pSele
 
 static int32_t addWinJoinPrimKeyToAggFuncs(SSelectStmt* pSelect, SNodeList** pList) {
   SNodeList* pTargets = *pList;
-  int32_t code = 0;
+  int32_t    code = 0;
   if (pTargets) {
     code = nodesMakeList(&pTargets);
   }
@@ -811,7 +820,7 @@ static int32_t createAggLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect,
   }
 
   SAggLogicNode* pAgg = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pAgg);
+  int32_t        code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pAgg);
   if (NULL == pAgg) {
     return code;
   }
@@ -887,7 +896,7 @@ static int32_t createIndefRowsFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt
   }
 
   SIndefRowsFuncLogicNode* pIdfRowsFunc = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC, (SNode**)&pIdfRowsFunc);
+  int32_t                  code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC, (SNode**)&pIdfRowsFunc);
   if (NULL == pIdfRowsFunc) {
     return code;
   }
@@ -920,7 +929,8 @@ static int32_t createIndefRowsFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt
 }
 
 static bool isInterpFunc(int32_t funcId) {
-  return fmIsInterpFunc(funcId) || fmIsInterpPseudoColumnFunc(funcId) || fmIsGroupKeyFunc(funcId) || fmisSelectGroupConstValueFunc(funcId);
+  return fmIsInterpFunc(funcId) || fmIsInterpPseudoColumnFunc(funcId) || fmIsGroupKeyFunc(funcId) ||
+         fmisSelectGroupConstValueFunc(funcId);
 }
 
 static int32_t createInterpFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, SLogicNode** pLogicNode) {
@@ -929,7 +939,7 @@ static int32_t createInterpFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt* p
   }
 
   SInterpFuncLogicNode* pInterpFunc = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_INTERP_FUNC, (SNode**)&pInterpFunc);
+  int32_t               code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_INTERP_FUNC, (SNode**)&pInterpFunc);
   if (NULL == pInterpFunc) {
     return code;
   }
@@ -974,7 +984,8 @@ static int32_t createInterpFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt* p
 }
 
 static bool isForecastFunc(int32_t funcId) {
-  return fmIsForecastFunc(funcId) || fmIsForecastPseudoColumnFunc(funcId) || fmIsGroupKeyFunc(funcId) || fmisSelectGroupConstValueFunc(funcId);
+  return fmIsForecastFunc(funcId) || fmIsForecastPseudoColumnFunc(funcId) || fmIsGroupKeyFunc(funcId) ||
+         fmisSelectGroupConstValueFunc(funcId);
 }
 
 static int32_t createForecastFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, SLogicNode** pLogicNode) {
@@ -983,7 +994,7 @@ static int32_t createForecastFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt*
   }
 
   SForecastFuncLogicNode* pForecastFunc = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_FORECAST_FUNC, (SNode**)&pForecastFunc);
+  int32_t                 code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_FORECAST_FUNC, (SNode**)&pForecastFunc);
   if (NULL == pForecastFunc) {
     return code;
   }
@@ -1051,7 +1062,7 @@ static int32_t createWindowLogicNodeFinalize(SLogicPlanContext* pCxt, SSelectStm
 static int32_t createWindowLogicNodeByState(SLogicPlanContext* pCxt, SStateWindowNode* pState, SSelectStmt* pSelect,
                                             SLogicNode** pLogicNode) {
   SWindowLogicNode* pWindow = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW, (SNode**)&pWindow);
+  int32_t           code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW, (SNode**)&pWindow);
   if (NULL == pWindow) {
     return code;
   }
@@ -1087,7 +1098,7 @@ static int32_t createWindowLogicNodeByState(SLogicPlanContext* pCxt, SStateWindo
 static int32_t createWindowLogicNodeBySession(SLogicPlanContext* pCxt, SSessionWindowNode* pSession,
                                               SSelectStmt* pSelect, SLogicNode** pLogicNode) {
   SWindowLogicNode* pWindow = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW, (SNode**)&pWindow);
+  int32_t           code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW, (SNode**)&pWindow);
   if (NULL == pWindow) {
     return code;
   }
@@ -1120,7 +1131,7 @@ static int32_t createWindowLogicNodeBySession(SLogicPlanContext* pCxt, SSessionW
 static int32_t createWindowLogicNodeByInterval(SLogicPlanContext* pCxt, SIntervalWindowNode* pInterval,
                                                SSelectStmt* pSelect, SLogicNode** pLogicNode) {
   SWindowLogicNode* pWindow = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW, (SNode**)&pWindow);
+  int32_t           code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW, (SNode**)&pWindow);
   if (NULL == pWindow) {
     return code;
   }
@@ -1154,7 +1165,7 @@ static int32_t createWindowLogicNodeByInterval(SLogicPlanContext* pCxt, SInterva
 static int32_t createWindowLogicNodeByEvent(SLogicPlanContext* pCxt, SEventWindowNode* pEvent, SSelectStmt* pSelect,
                                             SLogicNode** pLogicNode) {
   SWindowLogicNode* pWindow = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW, (SNode**)&pWindow);
+  int32_t           code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW, (SNode**)&pWindow);
   if (NULL == pWindow) {
     return code;
   }
@@ -1191,7 +1202,7 @@ static int32_t createWindowLogicNodeByEvent(SLogicPlanContext* pCxt, SEventWindo
 static int32_t createWindowLogicNodeByCount(SLogicPlanContext* pCxt, SCountWindowNode* pCount, SSelectStmt* pSelect,
                                             SLogicNode** pLogicNode) {
   SWindowLogicNode* pWindow = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW, (SNode**)&pWindow);
+  int32_t           code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW, (SNode**)&pWindow);
   if (NULL == pWindow) {
     return code;
   }
@@ -1280,11 +1291,11 @@ static int32_t createWindowLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSele
 }
 
 typedef struct SCollectFillExprsCtx {
-  SHashObj*   pPseudoCols;
-  SNodeList*  pFillExprs;
-  SNodeList*  pNotFillExprs;
-  bool        collectAggFuncs;
-  SNodeList*  pAggFuncCols;
+  SHashObj*  pPseudoCols;
+  SNodeList* pFillExprs;
+  SNodeList* pNotFillExprs;
+  bool       collectAggFuncs;
+  SNodeList* pAggFuncCols;
 } SCollectFillExprsCtx;
 
 typedef struct SWalkFillSubExprCtx {
@@ -1306,8 +1317,8 @@ static bool nodeAlreadyContained(SNodeList* pList, SNode* pNode) {
 }
 
 static EDealRes needFillValueImpl(SNode* pNode, void* pContext) {
-  SWalkFillSubExprCtx *pCtx = pContext;
-  EDealRes res = DEAL_RES_CONTINUE;
+  SWalkFillSubExprCtx* pCtx = pContext;
+  EDealRes             res = DEAL_RES_CONTINUE;
   if (QUERY_NODE_COLUMN == nodeType(pNode)) {
     SColumnNode* pCol = (SColumnNode*)pNode;
     if (COLUMN_TYPE_WINDOW_START == pCol->colType || COLUMN_TYPE_WINDOW_END == pCol->colType ||
@@ -1337,14 +1348,12 @@ static EDealRes needFillValueImpl(SNode* pNode, void* pContext) {
   return res;
 }
 
-static void needFillValue(SNode* pNode, SWalkFillSubExprCtx* pCtx) {
-  nodesWalkExpr(pNode, needFillValueImpl, pCtx);
-}
+static void needFillValue(SNode* pNode, SWalkFillSubExprCtx* pCtx) { nodesWalkExpr(pNode, needFillValueImpl, pCtx); }
 
 static int32_t collectFillExpr(SNode* pNode, SCollectFillExprsCtx* pCollectFillCtx) {
-  SNode*                pNew = NULL;
-  SWalkFillSubExprCtx   collectFillSubExprCtx = {
-        .hasFillCol = false, .hasPseudoWinCol = false, .hasGroupKeyCol = false, .pCollectFillCtx = pCollectFillCtx};
+  SNode*              pNew = NULL;
+  SWalkFillSubExprCtx collectFillSubExprCtx = {
+      .hasFillCol = false, .hasPseudoWinCol = false, .hasGroupKeyCol = false, .pCollectFillCtx = pCollectFillCtx};
   needFillValue(pNode, &collectFillSubExprCtx);
   if (collectFillSubExprCtx.code != TSDB_CODE_SUCCESS) {
     return collectFillSubExprCtx.code;
@@ -1388,7 +1397,7 @@ static int32_t collectFillExprs(SSelectStmt* pSelect, SNodeList** pFillExprs, SN
   if (code == TSDB_CODE_SUCCESS) {
     void* pIter = taosHashIterate(collectFillCtx.pPseudoCols, 0);
     while (pIter) {
-      SNode* pNode = *(SNode**)pIter, *pNew = NULL;
+      SNode *pNode = *(SNode**)pIter, *pNew = NULL;
       code = nodesCloneNode(pNode, &pNew);
       if (code == TSDB_CODE_SUCCESS) {
         code = nodesListMakeStrictAppend(&collectFillCtx.pNotFillExprs, pNew);
@@ -1427,7 +1436,7 @@ static int32_t createFillLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
   }
 
   SFillLogicNode* pFill = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_FILL, (SNode**)&pFill);
+  int32_t         code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_FILL, (SNode**)&pFill);
   if (NULL == pFill) {
     return code;
   }
@@ -1493,7 +1502,7 @@ static int32_t createSortLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
   }
 
   SSortLogicNode* pSort = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT, (SNode**)&pSort);
+  int32_t         code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT, (SNode**)&pSort);
   if (NULL == pSort) {
     return code;
   }
@@ -1531,7 +1540,8 @@ static int32_t createSortLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
       FOREACH(pNode, pSelect->pProjectionList) {
         SExprNode* pExpr = (SExprNode*)pNode;
         if (0 == strcmp(pCol->node.aliasName, pExpr->aliasName)) {
-          pCol->projIdx = projIdx; break;
+          pCol->projIdx = projIdx;
+          break;
         }
         projIdx++;
       }
@@ -1550,12 +1560,12 @@ static int32_t createSortLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect
 static int32_t createColumnByProjections(SLogicPlanContext* pCxt, const char* pStmtName, SNodeList* pExprs,
                                          SNodeList** pCols) {
   SNodeList* pList = NULL;
-  int32_t code = nodesMakeList(&pList);
+  int32_t    code = nodesMakeList(&pList);
   if (NULL == pList) {
     return code;
   }
 
-  SNode* pNode;
+  SNode*  pNode;
   int32_t projIdx = 1;
   FOREACH(pNode, pExprs) {
     SColumnNode* pCol = createColumnByExpr(pStmtName, (SExprNode*)pNode);
@@ -1572,7 +1582,7 @@ static int32_t createColumnByProjections(SLogicPlanContext* pCxt, const char* pS
 
 static int32_t createProjectLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, SLogicNode** pLogicNode) {
   SProjectLogicNode* pProject = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT, (SNode**)&pProject);
+  int32_t            code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT, (SNode**)&pProject);
   if (NULL == pProject) {
     return code;
   }
@@ -1611,7 +1621,7 @@ static int32_t createPartitionLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pS
   }
 
   SPartitionLogicNode* pPartition = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PARTITION, (SNode**)&pPartition);
+  int32_t              code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PARTITION, (SNode**)&pPartition);
   if (NULL == pPartition) {
     return code;
   }
@@ -1633,7 +1643,7 @@ static int32_t createPartitionLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pS
   }
 
   if (TSDB_CODE_SUCCESS == code) {
-//    code = nodesCollectFuncs(pSelect, SQL_CLAUSE_GROUP_BY, NULL, fmIsAggFunc, &pPartition->pAggFuncs);
+    //    code = nodesCollectFuncs(pSelect, SQL_CLAUSE_GROUP_BY, NULL, fmIsAggFunc, &pPartition->pAggFuncs);
     code = nodesCollectFuncs(pSelect, SQL_CLAUSE_PARTITION_BY, NULL, fmIsAggFunc, &pPartition->pAggFuncs);
   }
 
@@ -1646,7 +1656,7 @@ static int32_t createPartitionLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pS
       nodeType(pSelect->pWindow) == QUERY_NODE_INTERVAL_WINDOW) {
     pPartition->needBlockOutputTsOrder = true;
     SIntervalWindowNode* pInterval = (SIntervalWindowNode*)pSelect->pWindow;
-    SColumnNode* pTsCol = (SColumnNode*)pInterval->pCol;
+    SColumnNode*         pTsCol = (SColumnNode*)pInterval->pCol;
     pPartition->pkTsColId = pTsCol->colId;
     pPartition->pkTsColTbId = pTsCol->tableId;
   }
@@ -1682,12 +1692,12 @@ static int32_t createDistinctLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSe
   }
 
   SAggLogicNode* pAgg = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pAgg);
+  int32_t        code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pAgg);
   if (NULL == pAgg) {
     return code;
   }
 
-  pAgg->node.groupAction = GROUP_ACTION_CLEAR;//getDistinctGroupAction(pCxt, pSelect);
+  pAgg->node.groupAction = GROUP_ACTION_CLEAR;  // getDistinctGroupAction(pCxt, pSelect);
   pAgg->node.requireDataOrder = DATA_ORDER_LEVEL_NONE;
   pAgg->node.resultDataOrder = DATA_ORDER_LEVEL_NONE;
 
@@ -1801,7 +1811,7 @@ static int32_t createSetOpSortLogicNode(SLogicPlanContext* pCxt, SSetOperator* p
   }
 
   SSortLogicNode* pSort = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT, (SNode**)&pSort);
+  int32_t         code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT, (SNode**)&pSort);
   if (NULL == pSort) {
     return code;
   }
@@ -1828,7 +1838,7 @@ static int32_t createSetOpSortLogicNode(SLogicPlanContext* pCxt, SSetOperator* p
 static int32_t createSetOpProjectLogicNode(SLogicPlanContext* pCxt, SSetOperator* pSetOperator,
                                            SLogicNode** pLogicNode) {
   SProjectLogicNode* pProject = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT, (SNode**)&pProject);
+  int32_t            code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT, (SNode**)&pProject);
   if (NULL == pProject) {
     return code;
   }
@@ -1858,7 +1868,7 @@ static int32_t createSetOpProjectLogicNode(SLogicPlanContext* pCxt, SSetOperator
 
 static int32_t createSetOpAggLogicNode(SLogicPlanContext* pCxt, SSetOperator* pSetOperator, SLogicNode** pLogicNode) {
   SAggLogicNode* pAgg = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pAgg);
+  int32_t        code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pAgg);
   if (NULL == pAgg) {
     return code;
   }
@@ -1966,7 +1976,7 @@ static int32_t getMsgType(ENodeType sqlType) {
 
 static int32_t createVnodeModifLogicNode(SLogicPlanContext* pCxt, SVnodeModifyOpStmt* pStmt, SLogicNode** pLogicNode) {
   SVnodeModifyLogicNode* pModif = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY, (SNode**)&pModif);
+  int32_t                code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY, (SNode**)&pModif);
   if (NULL == pModif) {
     return code;
   }
@@ -1984,7 +1994,7 @@ static int32_t createDeleteRootLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* p
 
 static int32_t createDeleteScanLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* pDelete, SLogicNode** pLogicNode) {
   SScanLogicNode* pScan = NULL;
-  int32_t          code = makeScanLogicNode(pCxt, (SRealTableNode*)pDelete->pFromTable, false, (SLogicNode**)&pScan);
+  int32_t         code = makeScanLogicNode(pCxt, (SRealTableNode*)pDelete->pFromTable, false, (SLogicNode**)&pScan);
 
   // set columns to scan
   if (TSDB_CODE_SUCCESS == code) {
@@ -2019,7 +2029,7 @@ static int32_t createDeleteScanLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* p
 
 static int32_t createDeleteAggLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* pDelete, SLogicNode** pLogicNode) {
   SAggLogicNode* pAgg = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pAgg);
+  int32_t        code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pAgg);
   if (NULL == pAgg) {
     return code;
   }
@@ -2069,7 +2079,7 @@ static int32_t createDeleteAggLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* pD
 static int32_t createVnodeModifLogicNodeByDelete(SLogicPlanContext* pCxt, SDeleteStmt* pDelete,
                                                  SLogicNode** pLogicNode) {
   SVnodeModifyLogicNode* pModify = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY, (SNode**)&pModify);
+  int32_t                code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY, (SNode**)&pModify);
   if (NULL == pModify) {
     return code;
   }
@@ -2130,7 +2140,7 @@ static int32_t creatInsertRootLogicNode(SLogicPlanContext* pCxt, SInsertStmt* pI
 static int32_t createVnodeModifLogicNodeByInsert(SLogicPlanContext* pCxt, SInsertStmt* pInsert,
                                                  SLogicNode** pLogicNode) {
   SVnodeModifyLogicNode* pModify = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY, (SNode**)&pModify);
+  int32_t                code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY, (SNode**)&pModify);
   if (NULL == pModify) {
     return code;
   }
@@ -2213,7 +2223,7 @@ int32_t createLogicPlan(SPlanContext* pCxt, SLogicSubplan** pLogicSubplan) {
   SLogicPlanContext cxt = {.pPlanCxt = pCxt, .pCurrRoot = NULL, .hasScan = false};
 
   SLogicSubplan* pSubplan = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN, (SNode**)&pSubplan);
+  int32_t        code = nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN, (SNode**)&pSubplan);
   if (NULL == pSubplan) {
     return code;
   }
diff --git a/source/libs/planner/src/planOptimizer.c b/source/libs/planner/src/planOptimizer.c
index 5b24c4a06d..212e12139f 100644
--- a/source/libs/planner/src/planOptimizer.c
+++ b/source/libs/planner/src/planOptimizer.c
@@ -15,11 +15,11 @@
 
 #include "filter.h"
 #include "functionMgt.h"
+#include "parser.h"
 #include "planInt.h"
 #include "systable.h"
 #include "tglobal.h"
 #include "ttime.h"
-#include "parser.h"
 
 #define OPTIMIZE_FLAG_MASK(n) (1 << n)
 
@@ -29,9 +29,9 @@
 #define OPTIMIZE_FLAG_ELIMINATE_PROJ  OPTIMIZE_FLAG_MASK(3)
 #define OPTIMIZE_FLAG_JOIN_COND       OPTIMIZE_FLAG_MASK(4)
 
-#define OPTIMIZE_FLAG_SET_MASK(val, mask)  (val) |= (mask)
-#define OPTIMIZE_FLAG_CLEAR_MASK(val, mask)  (val) &= (~(mask))
-#define OPTIMIZE_FLAG_TEST_MASK(val, mask) (((val) & (mask)) != 0)
+#define OPTIMIZE_FLAG_SET_MASK(val, mask)   (val) |= (mask)
+#define OPTIMIZE_FLAG_CLEAR_MASK(val, mask) (val) &= (~(mask))
+#define OPTIMIZE_FLAG_TEST_MASK(val, mask)  (((val) & (mask)) != 0)
 
 typedef struct SOptimizeContext {
   SPlanContext* pPlanCxt;
@@ -86,7 +86,6 @@ typedef struct SCpdCollRewriteTableColsCxt {
   SSHashObj* pRightCols;
 } SCpdCollRewriteTableColsCxt;
 
-
 typedef struct SCpdCollectTableColCxt {
   SSHashObj* pTables;
   SNodeList* pResCols;
@@ -94,7 +93,6 @@ typedef struct SCpdCollectTableColCxt {
   int32_t    errCode;
 } SCpdCollectTableColCxt;
 
-
 typedef enum ECondAction {
   COND_ACTION_STAY = 1,
   COND_ACTION_PUSH_JOIN,
@@ -126,22 +124,28 @@ static SJoinOptimizeOpt gJoinOpt[JOIN_TYPE_MAX_VALUE][JOIN_STYPE_MAX_VALUE] = {
 };
 #else
 static SJoinOptimizeOpt gJoinWhereOpt[JOIN_TYPE_MAX_VALUE][JOIN_STYPE_MAX_VALUE] = {
-           /* NONE                OUTER                  SEMI                  ANTI                   ASOF                   WINDOW */
-/*INNER*/  {{PUSH_DOWN_ALL_COND}, {0},                   {0},                  {0},                   {0},                   {0}},
-/*LEFT*/   {{0},                  {PUSH_DOWN_LEFT_FLT},  {PUSH_DOWN_LEFT_FLT}, {PUSH_DOWN_LEFT_FLT},  {PUSH_DOWN_LEFT_FLT},  {PUSH_DOWN_LEFT_FLT}},
-/*RIGHT*/  {{0},                  {PUSH_DOWN_RIGHT_FLT}, {PUSH_DOWN_RIGHT_FLT},{PUSH_DOWN_RIGHT_FLT}, {PUSH_DOWN_RIGHT_FLT}, {PUSH_DOWN_RIGHT_FLT}},
-/*FULL*/   {{0},                  {0},                   {0},                  {0},                   {0},                   {0}},
+    /* NONE                OUTER                  SEMI                  ANTI                   ASOF WINDOW */
+    /*INNER*/ {{PUSH_DOWN_ALL_COND}, {0}, {0}, {0}, {0}, {0}},
+    /*LEFT*/
+    {{0}, {PUSH_DOWN_LEFT_FLT}, {PUSH_DOWN_LEFT_FLT}, {PUSH_DOWN_LEFT_FLT}, {PUSH_DOWN_LEFT_FLT}, {PUSH_DOWN_LEFT_FLT}},
+    /*RIGHT*/
+    {{0},
+     {PUSH_DOWN_RIGHT_FLT},
+     {PUSH_DOWN_RIGHT_FLT},
+     {PUSH_DOWN_RIGHT_FLT},
+     {PUSH_DOWN_RIGHT_FLT},
+     {PUSH_DOWN_RIGHT_FLT}},
+    /*FULL*/ {{0}, {0}, {0}, {0}, {0}, {0}},
 };
 
 static SJoinOptimizeOpt gJoinOnOpt[JOIN_TYPE_MAX_VALUE][JOIN_STYPE_MAX_VALUE] = {
-           /* NONE                OUTER                  SEMI                  ANTI                   ASOF                   WINDOW */
-/*INNER*/  {{PUSH_DONW_FLT_COND}, {0},                   {0},                  {0},                   {0},                   {0}},
-/*LEFT*/   {{0},                  {PUSH_DOWN_RIGHT_FLT}, {PUSH_DONW_FLT_COND}, {PUSH_DOWN_RIGHT_FLT}, {0},                   {0}},
-/*RIGHT*/  {{0},                  {PUSH_DOWN_LEFT_FLT},  {PUSH_DONW_FLT_COND}, {PUSH_DOWN_LEFT_FLT},  {0},                   {0}},
-/*FULL*/   {{0},                  {0},                   {0},                  {0},                   {0},                   {0}},
+    /* NONE                OUTER                  SEMI                  ANTI                   ASOF WINDOW */
+    /*INNER*/ {{PUSH_DONW_FLT_COND}, {0}, {0}, {0}, {0}, {0}},
+    /*LEFT*/ {{0}, {PUSH_DOWN_RIGHT_FLT}, {PUSH_DONW_FLT_COND}, {PUSH_DOWN_RIGHT_FLT}, {0}, {0}},
+    /*RIGHT*/ {{0}, {PUSH_DOWN_LEFT_FLT}, {PUSH_DONW_FLT_COND}, {PUSH_DOWN_LEFT_FLT}, {0}, {0}},
+    /*FULL*/ {{0}, {0}, {0}, {0}, {0}, {0}},
 };
 
-
 #endif
 
 static SLogicNode* optFindPossibleNode(SLogicNode* pNode, FMayBeOptimized func, void* pCtx) {
@@ -179,7 +183,7 @@ static void optResetParent(SLogicNode* pNode) {
 static EDealRes optRebuildTbanme(SNode** pNode, void* pContext) {
   if (QUERY_NODE_COLUMN == nodeType(*pNode) && COLUMN_TYPE_TBNAME == ((SColumnNode*)*pNode)->colType) {
     SFunctionNode* pFunc = NULL;
-    int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc);
+    int32_t        code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc);
     if (NULL == pFunc) {
       *(int32_t*)pContext = code;
       return DEAL_RES_ERROR;
@@ -469,7 +473,7 @@ static int32_t scanPathOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub
   }
   if (TSDB_CODE_SUCCESS == code && (NULL != info.pDsoFuncs || NULL != info.pSdrFuncs)) {
     if (pCxt->pPlanCxt->streamQuery) {
-      info.pScan->dataRequired = FUNC_DATA_REQUIRED_DATA_LOAD; // always load all data for stream query
+      info.pScan->dataRequired = FUNC_DATA_REQUIRED_DATA_LOAD;  // always load all data for stream query
     } else {
       info.pScan->dataRequired = scanPathOptGetDataRequired(info.pSdrFuncs);
     }
@@ -486,7 +490,7 @@ static int32_t scanPathOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub
 
 static int32_t pdcMergeCondsToLogic(SNode** pDst, SNode** pSrc) {
   SLogicConditionNode* pLogicCond = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogicCond);
+  int32_t              code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogicCond);
   if (NULL == pLogicCond) {
     return code;
   }
@@ -589,11 +593,12 @@ static bool pdcColBelongThisTable(SNode* pCondCol, SNodeList* pTableCols) {
     if (QUERY_NODE_COLUMN == nodeType(pCondCol) && QUERY_NODE_COLUMN == nodeType(pTableCol)) {
       SColumnNode* pCondColNode = (SColumnNode*)pCondCol;
       SColumnNode* pTblColNode = (SColumnNode*)pTableCol;
-      if (0 == strcmp(pCondColNode->tableAlias, pTblColNode->tableAlias) && 0 == strcmp(pCondColNode->colName, pTblColNode->colName)) {
+      if (0 == strcmp(pCondColNode->tableAlias, pTblColNode->tableAlias) &&
+          0 == strcmp(pCondColNode->colName, pTblColNode->colName)) {
         return true;
       }
     }
-    
+
     if (nodesEqualNode(pCondCol, pTableCol)) {
       return true;
     }
@@ -631,9 +636,9 @@ static EDealRes pdcJoinIsCrossTableCond(SNode* pNode, void* pContext) {
 }
 
 static ECondAction pdcJoinGetCondAction(SJoinLogicNode* pJoin, SSHashObj* pLeftTbls, SSHashObj* pRightTbls,
-                                                SNode* pNode, bool whereCond) {
-  EJoinType t = pJoin->joinType;   
-  EJoinSubType s = pJoin->subType;
+                                        SNode* pNode, bool whereCond) {
+  EJoinType               t = pJoin->joinType;
+  EJoinSubType            s = pJoin->subType;
   SCpdIsMultiTableCondCxt cxt = {
       .pLeftTbls = pLeftTbls, .pRightTbls = pRightTbls, .havaLeftCol = false, .haveRightCol = false};
   nodesWalkExpr(pNode, pdcJoinIsCrossTableCond, &cxt);
@@ -645,14 +650,16 @@ static ECondAction pdcJoinGetCondAction(SJoinLogicNode* pJoin, SSHashObj* pLeftT
       }
       return COND_ACTION_STAY;
     }
-    if ((whereCond && gJoinWhereOpt[t][s].pushDownFlag & PUSH_DOWN_LEFT_FLT) || (!whereCond && gJoinOnOpt[t][s].pushDownFlag & PUSH_DOWN_LEFT_FLT)) {
+    if ((whereCond && gJoinWhereOpt[t][s].pushDownFlag & PUSH_DOWN_LEFT_FLT) ||
+        (!whereCond && gJoinOnOpt[t][s].pushDownFlag & PUSH_DOWN_LEFT_FLT)) {
       return COND_ACTION_PUSH_LEFT_CHILD;
     }
     return COND_ACTION_STAY;
   }
 
   if (cxt.haveRightCol) {
-    if ((whereCond && gJoinWhereOpt[t][s].pushDownFlag & PUSH_DOWN_RIGHT_FLT) || (!whereCond && gJoinOnOpt[t][s].pushDownFlag & PUSH_DOWN_RIGHT_FLT)) {
+    if ((whereCond && gJoinWhereOpt[t][s].pushDownFlag & PUSH_DOWN_RIGHT_FLT) ||
+        (!whereCond && gJoinOnOpt[t][s].pushDownFlag & PUSH_DOWN_RIGHT_FLT)) {
       return COND_ACTION_PUSH_RIGHT_CHILD;
     }
     return COND_ACTION_STAY;
@@ -662,7 +669,7 @@ static ECondAction pdcJoinGetCondAction(SJoinLogicNode* pJoin, SSHashObj* pLeftT
 }
 
 static int32_t pdcJoinSplitLogicCond(SJoinLogicNode* pJoin, SNode** pSrcCond, SNode** pOnCond, SNode** pLeftChildCond,
-                                            SNode** pRightChildCond, bool whereCond) {
+                                     SNode** pRightChildCond, bool whereCond) {
   SLogicConditionNode* pLogicCond = (SLogicConditionNode*)*pSrcCond;
   if (LOGIC_COND_TYPE_AND != pLogicCond->condType) {
     if (whereCond) {
@@ -691,9 +698,11 @@ static int32_t pdcJoinSplitLogicCond(SJoinLogicNode* pJoin, SNode** pSrcCond, SN
   SNode*     pCond = NULL;
   FOREACH(pCond, pLogicCond->pParameterList) {
     ECondAction condAction = pdcJoinGetCondAction(pJoin, pLeftTables, pRightTables, pCond, whereCond);
-    SNode* pNew = NULL;
+    SNode*      pNew = NULL;
     code = nodesCloneNode(pCond, &pNew);
-    if (TSDB_CODE_SUCCESS != code) { break; }
+    if (TSDB_CODE_SUCCESS != code) {
+      break;
+    }
     if (COND_ACTION_PUSH_JOIN == condAction && NULL != pOnCond) {
       code = nodesListMakeAppend(&pOnConds, pNew);
     } else if (COND_ACTION_PUSH_LEFT_CHILD == condAction) {
@@ -751,10 +760,10 @@ static int32_t pdcJoinSplitLogicCond(SJoinLogicNode* pJoin, SNode** pSrcCond, SN
 }
 
 static int32_t pdcJoinSplitOpCond(SJoinLogicNode* pJoin, SNode** pSrcCond, SNode** pOnCond, SNode** pLeftChildCond,
-                                         SNode** pRightChildCond, bool whereCond) {
+                                  SNode** pRightChildCond, bool whereCond) {
   SSHashObj* pLeftTables = NULL;
   SSHashObj* pRightTables = NULL;
-  int32_t code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables);
+  int32_t    code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables);
   if (TSDB_CODE_SUCCESS != code) {
     return code;
   }
@@ -763,7 +772,7 @@ static int32_t pdcJoinSplitOpCond(SJoinLogicNode* pJoin, SNode** pSrcCond, SNode
     tSimpleHashCleanup(pLeftTables);
     return code;
   }
-  
+
   ECondAction condAction = pdcJoinGetCondAction(pJoin, pLeftTables, pRightTables, *pSrcCond, whereCond);
 
   tSimpleHashCleanup(pLeftTables);
@@ -785,7 +794,7 @@ static int32_t pdcJoinSplitOpCond(SJoinLogicNode* pJoin, SNode** pSrcCond, SNode
 }
 
 static int32_t pdcJoinSplitCond(SJoinLogicNode* pJoin, SNode** pSrcCond, SNode** pOnCond, SNode** pLeftChildCond,
-                                       SNode** pRightChildCond, bool whereCond) {
+                                SNode** pRightChildCond, bool whereCond) {
   if (QUERY_NODE_LOGIC_CONDITION == nodeType(*pSrcCond)) {
     return pdcJoinSplitLogicCond(pJoin, pSrcCond, pOnCond, pLeftChildCond, pRightChildCond, whereCond);
   } else {
@@ -843,7 +852,7 @@ static bool pdcJoinIsPrimEqualCond(SJoinLogicNode* pJoin, SNode* pCond) {
 
   SSHashObj* pLeftTables = NULL;
   SSHashObj* pRightTables = NULL;
-  int32_t code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables);
+  int32_t    code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables);
   if (TSDB_CODE_SUCCESS != code) {
     return code;
   }
@@ -962,12 +971,16 @@ static int32_t pdcJoinIsEqualOnCond(SJoinLogicNode* pJoin, SNode* pCond, bool* a
     return code;
   }
   SOperatorNode* pOper = (SOperatorNode*)pCond;
-  if ((QUERY_NODE_COLUMN != nodeType(pOper->pLeft) && !(QUERY_NODE_OPERATOR == nodeType(pOper->pLeft) && OP_TYPE_JSON_GET_VALUE ==((SOperatorNode*)pOper->pLeft)->opType)) 
-      || NULL == pOper->pRight || 
-      (QUERY_NODE_COLUMN != nodeType(pOper->pRight) && !(QUERY_NODE_OPERATOR == nodeType(pOper->pRight) && OP_TYPE_JSON_GET_VALUE ==((SOperatorNode*)pOper->pRight)->opType))) {
+  if ((QUERY_NODE_COLUMN != nodeType(pOper->pLeft) &&
+       !(QUERY_NODE_OPERATOR == nodeType(pOper->pLeft) &&
+         OP_TYPE_JSON_GET_VALUE == ((SOperatorNode*)pOper->pLeft)->opType)) ||
+      NULL == pOper->pRight ||
+      (QUERY_NODE_COLUMN != nodeType(pOper->pRight) &&
+       !(QUERY_NODE_OPERATOR == nodeType(pOper->pRight) &&
+         OP_TYPE_JSON_GET_VALUE == ((SOperatorNode*)pOper->pRight)->opType))) {
     return code;
   }
-  
+
   if (OP_TYPE_EQUAL != pOper->opType) {
     return code;
   }
@@ -976,7 +989,7 @@ static int32_t pdcJoinIsEqualOnCond(SJoinLogicNode* pJoin, SNode* pCond, bool* a
       !(IS_ASOF_JOIN(pJoin->subType) || IS_WINDOW_JOIN(pJoin->subType))) {
     return code;
   }
-  
+
   SColumnNode* pLeft = (SColumnNode*)(pOper->pLeft);
   SColumnNode* pRight = (SColumnNode*)(pOper->pRight);
 
@@ -987,7 +1000,7 @@ static int32_t pdcJoinIsEqualOnCond(SJoinLogicNode* pJoin, SNode* pCond, bool* a
   if (QUERY_NODE_OPERATOR == nodeType(pOper->pRight)) {
     pRight = (SColumnNode*)((SOperatorNode*)pOper->pRight)->pLeft;
   }
-  
+
   *allTags = (COLUMN_TYPE_TAG == pLeft->colType) && (COLUMN_TYPE_TAG == pRight->colType);
 
   if (pLeft->node.resType.type != pRight->node.resType.type ||
@@ -996,7 +1009,7 @@ static int32_t pdcJoinIsEqualOnCond(SJoinLogicNode* pJoin, SNode* pCond, bool* a
   }
   SNodeList* pLeftCols = ((SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 0))->pTargets;
   SNodeList* pRightCols = ((SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 1))->pTargets;
-  bool isEqual = false;
+  bool       isEqual = false;
   if (pdcJoinColInTableColList((SNode*)pLeft, pLeftCols)) {
     isEqual = pdcJoinColInTableColList((SNode*)pRight, pRightCols);
     if (isEqual) {
@@ -1066,15 +1079,15 @@ static int32_t pdcJoinPartLogicEqualOnCond(SJoinLogicNode* pJoin) {
         code = nodesListMakeStrictAppend(&pTagEqOnConds, pNew);
       } else {
         code = nodesListMakeStrictAppend(&pColEqOnConds, pNew);
-        pJoin->allEqTags = false;  
+        pJoin->allEqTags = false;
       }
     } else if (allTags) {
       code = nodesListMakeStrictAppend(&pTagOnConds, pNew);
     } else {
       code = nodesListMakeStrictAppend(&pColOnConds, pNew);
-      pJoin->allEqTags = false;  
+      pJoin->allEqTags = false;
     }
-    
+
     if (code) {
       break;
     }
@@ -1112,7 +1125,7 @@ static int32_t pdcJoinPartLogicEqualOnCond(SJoinLogicNode* pJoin) {
     nodesDestroyNode(pTempTagOnCond);
     nodesDestroyNode(pTempColOnCond);
   }
-  
+
   return code;
 }
 
@@ -1123,15 +1136,15 @@ static int32_t pdcJoinPartEqualOnCond(SOptimizeContext* pCxt, SJoinLogicNode* pJ
     return TSDB_CODE_SUCCESS;
   }
 
-  pJoin->allEqTags = true;  
+  pJoin->allEqTags = true;
 
   if (QUERY_NODE_LOGIC_CONDITION == nodeType(pJoin->pFullOnCond) &&
       LOGIC_COND_TYPE_AND == ((SLogicConditionNode*)(pJoin->pFullOnCond))->condType) {
     return pdcJoinPartLogicEqualOnCond(pJoin);
   }
 
-  bool allTags = false;
-  bool eqOnCond = false;
+  bool    allTags = false;
+  bool    eqOnCond = false;
   int32_t code = pdcJoinIsEqualOnCond(pJoin, pJoin->pFullOnCond, &allTags, &eqOnCond);
   if (TSDB_CODE_SUCCESS != code) {
     return code;
@@ -1146,13 +1159,13 @@ static int32_t pdcJoinPartEqualOnCond(SOptimizeContext* pCxt, SJoinLogicNode* pJ
       pJoin->pTagEqCond = pNew;
     } else {
       pJoin->pColEqCond = pNew;
-      pJoin->allEqTags = false;  
+      pJoin->allEqTags = false;
     }
   } else if (allTags) {
     pJoin->pTagOnCond = pNew;
   } else {
     pJoin->pColOnCond = pNew;
-    pJoin->allEqTags = false;  
+    pJoin->allEqTags = false;
   }
 
   return TSDB_CODE_SUCCESS;
@@ -1163,8 +1176,8 @@ static EDealRes pdcJoinCollectCondCol(SNode* pNode, void* pContext) {
   if (QUERY_NODE_COLUMN == nodeType(pNode)) {
     if (pdcJoinColInTableList(pNode, pCxt->pTables)) {
       SColumnNode* pCol = (SColumnNode*)pNode;
-      char    name[TSDB_TABLE_NAME_LEN + TSDB_COL_NAME_LEN];
-      int32_t len = 0;
+      char         name[TSDB_TABLE_NAME_LEN + TSDB_COL_NAME_LEN];
+      int32_t      len = 0;
       if ('\0' == pCol->tableAlias[0]) {
         len = tsnprintf(name, sizeof(name), "%s", pCol->colName);
       } else {
@@ -1182,27 +1195,26 @@ static EDealRes pdcJoinCollectCondCol(SNode* pNode, void* pContext) {
       }
     }
   }
-  
+
   return (TSDB_CODE_SUCCESS == pCxt->errCode ? DEAL_RES_CONTINUE : DEAL_RES_ERROR);
 }
 
 static int32_t pdcJoinCollectColsFromParent(SJoinLogicNode* pJoin, SSHashObj* pTables, SNodeList* pCondCols) {
   SCpdCollectTableColCxt cxt = {
-    .errCode = TSDB_CODE_SUCCESS,
-    .pTables = pTables, 
-    .pResCols = pCondCols, 
-    .pColHash = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK)
-  };
+      .errCode = TSDB_CODE_SUCCESS,
+      .pTables = pTables,
+      .pResCols = pCondCols,
+      .pColHash = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK)};
   if (NULL == cxt.pColHash) {
     return terrno;
   }
-  
+
   nodesWalkExpr(pJoin->pPrimKeyEqCond, pdcJoinCollectCondCol, &cxt);
   nodesWalkExpr(pJoin->node.pConditions, pdcJoinCollectCondCol, &cxt);
   if (TSDB_CODE_SUCCESS == cxt.errCode) {
     nodesWalkExpr(pJoin->pFullOnCond, pdcJoinCollectCondCol, &cxt);
   }
-  
+
   taosHashCleanup(cxt.pColHash);
   return cxt.errCode;
 }
@@ -1213,7 +1225,7 @@ static int32_t pdcJoinAddParentOnColsToTarget(SOptimizeContext* pCxt, SJoinLogic
   }
 
   SNodeList* pTargets = NULL;
-  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t    code = TSDB_CODE_SUCCESS;
   SNodeList* pCondCols = NULL;
   code = nodesMakeList(&pCondCols);
   if (NULL == pCondCols) {
@@ -1230,7 +1242,7 @@ static int32_t pdcJoinAddParentOnColsToTarget(SOptimizeContext* pCxt, SJoinLogic
     tSimpleHashCleanup(pTables);
     return code;
   }
-  
+
   SJoinLogicNode* pTmp = (SJoinLogicNode*)pJoin->node.pParent;
   do {
     code = pdcJoinCollectColsFromParent(pTmp, pTables, pCondCols);
@@ -1244,18 +1256,18 @@ static int32_t pdcJoinAddParentOnColsToTarget(SOptimizeContext* pCxt, SJoinLogic
   } while (true);
 
   tSimpleHashCleanup(pTables);
-  
+
   if (TSDB_CODE_SUCCESS == code) {
     code = createColumnByRewriteExprs(pCondCols, &pTargets);
   }
-  
+
   nodesDestroyList(pCondCols);
-  
+
   if (TSDB_CODE_SUCCESS == code) {
     SNode* pNode = NULL;
     FOREACH(pNode, pTargets) {
       SNode* pTmp = NULL;
-      bool found = false;
+      bool   found = false;
       FOREACH(pTmp, pJoin->node.pTargets) {
         if (nodesEqualNode(pTmp, pNode)) {
           found = true;
@@ -1273,20 +1285,19 @@ static int32_t pdcJoinAddParentOnColsToTarget(SOptimizeContext* pCxt, SJoinLogic
         }
       }
     }
-  }    
+  }
 
   nodesDestroyList(pTargets);
 
   return code;
 }
 
-
 static int32_t pdcJoinAddPreFilterColsToTarget(SOptimizeContext* pCxt, SJoinLogicNode* pJoin) {
   if (NULL == pJoin->pFullOnCond) {
     return TSDB_CODE_SUCCESS;
   }
 
-  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t    code = TSDB_CODE_SUCCESS;
   SNodeList* pCondCols = NULL;
   code = nodesMakeList(&pCondCols);
   SNodeList* pTargets = NULL;
@@ -1338,7 +1349,7 @@ static int32_t pdcJoinAddFilterColsToTarget(SOptimizeContext* pCxt, SJoinLogicNo
     return TSDB_CODE_SUCCESS;
   }
 
-  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t    code = TSDB_CODE_SUCCESS;
   SNodeList* pCondCols = NULL;
   code = nodesMakeList(&pCondCols);
   SNodeList* pTargets = NULL;
@@ -1355,14 +1366,14 @@ static int32_t pdcJoinAddFilterColsToTarget(SOptimizeContext* pCxt, SJoinLogicNo
   if (TSDB_CODE_SUCCESS == code) {
     code = createColumnByRewriteExprs(pCondCols, &pTargets);
   }
-  
+
   nodesDestroyList(pCondCols);
-  
+
   if (TSDB_CODE_SUCCESS == code) {
     SNode* pNode = NULL;
     FOREACH(pNode, pTargets) {
       SNode* pTmp = NULL;
-      bool found = false;
+      bool   found = false;
       FOREACH(pTmp, pJoin->node.pTargets) {
         if (nodesEqualNode(pTmp, pNode)) {
           found = true;
@@ -1380,37 +1391,38 @@ static int32_t pdcJoinAddFilterColsToTarget(SOptimizeContext* pCxt, SJoinLogicNo
         }
       }
     }
-  }    
+  }
 
   nodesDestroyList(pTargets);
 
   return code;
 }
 
-
 static int32_t pdcJoinCheckAllCond(SOptimizeContext* pCxt, SJoinLogicNode* pJoin) {
   if (NULL == pJoin->pFullOnCond) {
     if (IS_WINDOW_JOIN(pJoin->subType) || IS_ASOF_JOIN(pJoin->subType)) {
       return TSDB_CODE_SUCCESS;
     }
 
-    if (NULL == pJoin->node.pConditions) {      
+    if (NULL == pJoin->node.pConditions) {
       return generateUsageErrMsg(pCxt->pPlanCxt->pMsg, pCxt->pPlanCxt->msgLen, TSDB_CODE_PLAN_NOT_SUPPORT_CROSS_JOIN);
     }
-    
+
     if (!IS_INNER_NONE_JOIN(pJoin->joinType, pJoin->subType)) {
       return generateUsageErrMsg(pCxt->pPlanCxt->pMsg, pCxt->pPlanCxt->msgLen, TSDB_CODE_PLAN_NOT_SUPPORT_CROSS_JOIN);
     }
   }
 
   SNode* pCond = pJoin->pFullOnCond ? pJoin->pFullOnCond : pJoin->node.pConditions;
-  bool errCond = false;
+  bool   errCond = false;
   if (!pdcJoinHasPrimEqualCond(pJoin, pCond, &errCond)) {
-    if (errCond && !(IS_INNER_NONE_JOIN(pJoin->joinType, pJoin->subType) && NULL != pJoin->pFullOnCond && NULL != pJoin->node.pConditions)) {
+    if (errCond && !(IS_INNER_NONE_JOIN(pJoin->joinType, pJoin->subType) && NULL != pJoin->pFullOnCond &&
+                     NULL != pJoin->node.pConditions)) {
       return generateUsageErrMsg(pCxt->pPlanCxt->pMsg, pCxt->pPlanCxt->msgLen, TSDB_CODE_PLAN_NOT_SUPPORT_JOIN_COND);
     }
-    
-    if (IS_INNER_NONE_JOIN(pJoin->joinType, pJoin->subType) && NULL != pJoin->pFullOnCond && NULL != pJoin->node.pConditions) {
+
+    if (IS_INNER_NONE_JOIN(pJoin->joinType, pJoin->subType) && NULL != pJoin->pFullOnCond &&
+        NULL != pJoin->node.pConditions) {
       if (pdcJoinHasPrimEqualCond(pJoin, pJoin->node.pConditions, &errCond)) {
         return TSDB_CODE_SUCCESS;
       }
@@ -1418,22 +1430,22 @@ static int32_t pdcJoinCheckAllCond(SOptimizeContext* pCxt, SJoinLogicNode* pJoin
         return generateUsageErrMsg(pCxt->pPlanCxt->pMsg, pCxt->pPlanCxt->msgLen, TSDB_CODE_PLAN_NOT_SUPPORT_JOIN_COND);
       }
     }
-    
+
     if (IS_WINDOW_JOIN(pJoin->subType) || IS_ASOF_JOIN(pJoin->subType)) {
       return TSDB_CODE_SUCCESS;
     }
-    
+
     return generateUsageErrMsg(pCxt->pPlanCxt->pMsg, pCxt->pPlanCxt->msgLen, TSDB_CODE_PLAN_EXPECTED_TS_EQUAL);
   }
 
   if (IS_ASOF_JOIN(pJoin->subType)) {
     nodesDestroyNode(pJoin->addPrimEqCond);
     pJoin->addPrimEqCond = NULL;
-  } 
+  }
 
   if (IS_WINDOW_JOIN(pJoin->subType)) {
     return generateUsageErrMsg(pCxt->pPlanCxt->pMsg, pCxt->pPlanCxt->msgLen, TSDB_CODE_PLAN_NOT_SUPPORT_JOIN_COND);
-  } 
+  }
 
   return TSDB_CODE_SUCCESS;
 }
@@ -1456,13 +1468,15 @@ static int32_t pdcJoinHandleGrpJoinCond(SOptimizeContext* pCxt, SJoinLogicNode*
         FOREACH(pNode, pJoin->pLeftEqNodes) {
           SColumnNode* pCol = (SColumnNode*)pNode;
           if (COLUMN_TYPE_TAG != pCol->colType && PRIMARYKEY_TIMESTAMP_COL_ID == pCol->colId) {
-            return generateUsageErrMsg(pCxt->pPlanCxt->pMsg, pCxt->pPlanCxt->msgLen, TSDB_CODE_PLAN_NOT_SUPPORT_JOIN_COND);
+            return generateUsageErrMsg(pCxt->pPlanCxt->pMsg, pCxt->pPlanCxt->msgLen,
+                                       TSDB_CODE_PLAN_NOT_SUPPORT_JOIN_COND);
           }
         }
         FOREACH(pNode, pJoin->pRightEqNodes) {
           SColumnNode* pCol = (SColumnNode*)pNode;
           if (COLUMN_TYPE_TAG != pCol->colType && PRIMARYKEY_TIMESTAMP_COL_ID == pCol->colId) {
-            return generateUsageErrMsg(pCxt->pPlanCxt->pMsg, pCxt->pPlanCxt->msgLen, TSDB_CODE_PLAN_NOT_SUPPORT_JOIN_COND);
+            return generateUsageErrMsg(pCxt->pPlanCxt->pMsg, pCxt->pPlanCxt->msgLen,
+                                       TSDB_CODE_PLAN_NOT_SUPPORT_JOIN_COND);
           }
         }
       }
@@ -1483,7 +1497,7 @@ static EDealRes pdcCheckTableCondType(SNode* pNode, void* pContext) {
       } else if (pdcJoinColInTableList(pNode, pCxt->pRightTbls)) {
         pCxt->haveRightCol = true;
       }
-      
+
       break;
     }
     case QUERY_NODE_OPERATOR: {
@@ -1496,13 +1510,17 @@ static EDealRes pdcCheckTableCondType(SNode* pNode, void* pContext) {
     default:
       break;
   }
-  
+
   return DEAL_RES_CONTINUE;
 }
 
-static int32_t pdcJoinGetOpTableCondTypes(SNode* pCond, SSHashObj* pLeftTables, SSHashObj* pRightTables, bool* tableCondTypes) {
-  SCpdIsMultiTableCondCxt cxt = {
-      .pLeftTbls = pLeftTables, .pRightTbls = pRightTables, .havaLeftCol = false, .haveRightCol = false, .condIsNull = false};
+static int32_t pdcJoinGetOpTableCondTypes(SNode* pCond, SSHashObj* pLeftTables, SSHashObj* pRightTables,
+                                          bool* tableCondTypes) {
+  SCpdIsMultiTableCondCxt cxt = {.pLeftTbls = pLeftTables,
+                                 .pRightTbls = pRightTables,
+                                 .havaLeftCol = false,
+                                 .haveRightCol = false,
+                                 .condIsNull = false};
   nodesWalkExpr(pCond, pdcCheckTableCondType, &cxt);
 
   if (cxt.havaLeftCol) {
@@ -1513,7 +1531,7 @@ static int32_t pdcJoinGetOpTableCondTypes(SNode* pCond, SSHashObj* pLeftTables,
       } else {
         tableCondTypes[0] = true;
         tableCondTypes[2] = true;
-      }      
+      }
       return TSDB_CODE_SUCCESS;
     }
 
@@ -1537,12 +1555,11 @@ static int32_t pdcJoinGetOpTableCondTypes(SNode* pCond, SSHashObj* pLeftTables,
   return TSDB_CODE_SUCCESS;
 }
 
-
-
-static int32_t pdcJoinGetLogicTableCondTypes(SNode* pCond, SSHashObj* pLeftTables, SSHashObj* pRightTables, bool* tableCondTypes) {
+static int32_t pdcJoinGetLogicTableCondTypes(SNode* pCond, SSHashObj* pLeftTables, SSHashObj* pRightTables,
+                                             bool* tableCondTypes) {
   SLogicConditionNode* pLogicCond = (SLogicConditionNode*)pCond;
-  int32_t code = 0;
-  SNode* pSCond = NULL;
+  int32_t              code = 0;
+  SNode*               pSCond = NULL;
   FOREACH(pSCond, pLogicCond->pParameterList) {
     if (QUERY_NODE_LOGIC_CONDITION == nodeType(pSCond)) {
       code = pdcJoinGetLogicTableCondTypes(pSCond, pLeftTables, pRightTables, tableCondTypes);
@@ -1558,7 +1575,8 @@ static int32_t pdcJoinGetLogicTableCondTypes(SNode* pCond, SSHashObj* pLeftTable
   return code;
 }
 
-static int32_t pdcGetTableCondTypes(SNode* pCond, SSHashObj* pLeftTables, SSHashObj* pRightTables, bool* tableCondTypes) {
+static int32_t pdcGetTableCondTypes(SNode* pCond, SSHashObj* pLeftTables, SSHashObj* pRightTables,
+                                    bool* tableCondTypes) {
   if (QUERY_NODE_LOGIC_CONDITION == nodeType(pCond)) {
     return pdcJoinGetLogicTableCondTypes(pCond, pLeftTables, pRightTables, tableCondTypes);
   } else {
@@ -1573,7 +1591,7 @@ static int32_t pdcRewriteTypeBasedOnConds(SOptimizeContext* pCxt, SJoinLogicNode
 
   SSHashObj* pLeftTables = NULL;
   SSHashObj* pRightTables = NULL;
-  int32_t code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables);
+  int32_t    code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables);
   if (TSDB_CODE_SUCCESS != code) {
     return code;
   }
@@ -1583,7 +1601,7 @@ static int32_t pdcRewriteTypeBasedOnConds(SOptimizeContext* pCxt, SJoinLogicNode
     tSimpleHashCleanup(pLeftTables);
     return code;
   }
-  
+
   bool tableCondTypes[4] = {0};
   code = pdcGetTableCondTypes(pJoin->node.pConditions, pLeftTables, pRightTables, tableCondTypes);
   tSimpleHashCleanup(pLeftTables);
@@ -1638,10 +1656,14 @@ static EDealRes pdcCheckTableResType(SNode* pNode, void* pContext) {
     case QUERY_NODE_GROUPING_SET:
       break;
     case QUERY_NODE_FUNCTION: {
-      SFunctionNode* pFunc = (SFunctionNode*)pNode;
-      SCpdIsMultiTableResCxt cxt = {.pLeftTbls = pCxt->pLeftTbls, .pRightTbls = pCxt->pRightTbls, 
-        .haveLeftCol = false, .haveRightCol = false, .leftColNonNull = true, .rightColNonNull = true};
-      
+      SFunctionNode*         pFunc = (SFunctionNode*)pNode;
+      SCpdIsMultiTableResCxt cxt = {.pLeftTbls = pCxt->pLeftTbls,
+                                    .pRightTbls = pCxt->pRightTbls,
+                                    .haveLeftCol = false,
+                                    .haveRightCol = false,
+                                    .leftColNonNull = true,
+                                    .rightColNonNull = true};
+
       nodesWalkExprs(pFunc->pParameterList, pdcCheckTableResType, &cxt);
       if (!cxt.leftColNonNull) {
         pCxt->leftColNonNull = false;
@@ -1683,7 +1705,7 @@ static EDealRes pdcCheckTableResType(SNode* pNode, void* pContext) {
       pCxt->rightColNonNull = false;
       return DEAL_RES_END;
   }
-  
+
   return DEAL_RES_CONTINUE;
 }
 
@@ -1692,7 +1714,7 @@ static int32_t pdcRewriteTypeBasedOnJoinRes(SOptimizeContext* pCxt, SJoinLogicNo
     return TSDB_CODE_SUCCESS;
   }
 
-  int32_t code = 0;
+  int32_t    code = 0;
   SSHashObj* pLeftTables = NULL;
   SSHashObj* pRightTables = NULL;
   code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables);
@@ -1706,17 +1728,23 @@ static int32_t pdcRewriteTypeBasedOnJoinRes(SOptimizeContext* pCxt, SJoinLogicNo
   }
 
   SLogicNode* pParent = pJoin->node.pParent;
-  bool tableResNonNull[2] = {true, true};
-  bool tableResOp[2] = {false, false};
+  bool        tableResNonNull[2] = {true, true};
+  bool        tableResOp[2] = {false, false};
   if (QUERY_NODE_LOGIC_PLAN_AGG == nodeType(pParent)) {
     SAggLogicNode* pAgg = (SAggLogicNode*)pParent;
     if (NULL != pAgg->pGroupKeys) {
       tableResNonNull[0] = false;
       tableResNonNull[1] = false;
     } else {
-      SCpdIsMultiTableResCxt cxt = {.pLeftTbls = pLeftTables, .pRightTbls = pRightTables, 
-        .haveLeftCol = false, .haveRightCol = false, .leftColNonNull = true, .rightColNonNull = true, .leftColOp = false, .rightColOp = false};
-      
+      SCpdIsMultiTableResCxt cxt = {.pLeftTbls = pLeftTables,
+                                    .pRightTbls = pRightTables,
+                                    .haveLeftCol = false,
+                                    .haveRightCol = false,
+                                    .leftColNonNull = true,
+                                    .rightColNonNull = true,
+                                    .leftColOp = false,
+                                    .rightColOp = false};
+
       nodesWalkExprs(pAgg->pAggFuncs, pdcCheckTableResType, &cxt);
       if (!cxt.leftColNonNull) {
         tableResNonNull[0] = false;
@@ -1779,12 +1807,12 @@ static int32_t pdcDealJoin(SOptimizeContext* pCxt, SJoinLogicNode* pJoin) {
     return TSDB_CODE_SUCCESS;
   }
 
-  EJoinType t = pJoin->joinType;
+  EJoinType    t = pJoin->joinType;
   EJoinSubType s = pJoin->subType;
-  SNode*  pOnCond = NULL;
-  SNode*  pLeftChildCond = NULL;
-  SNode*  pRightChildCond = NULL;
-  int32_t code = pdcJoinCheckAllCond(pCxt, pJoin);
+  SNode*       pOnCond = NULL;
+  SNode*       pLeftChildCond = NULL;
+  SNode*       pRightChildCond = NULL;
+  int32_t      code = pdcJoinCheckAllCond(pCxt, pJoin);
   while (true) {
     if (TSDB_CODE_SUCCESS == code && NULL != pJoin->node.pConditions) {
       if (0 != gJoinWhereOpt[t][s].pushDownFlag) {
@@ -1796,7 +1824,8 @@ static int32_t pdcDealJoin(SOptimizeContext* pCxt, SJoinLogicNode* pJoin) {
           code = pdcPushDownCondToChild(pCxt, (SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 0), &pLeftChildCond);
         }
         if (TSDB_CODE_SUCCESS == code && NULL != pRightChildCond) {
-          code = pdcPushDownCondToChild(pCxt, (SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 1), &pRightChildCond);
+          code =
+              pdcPushDownCondToChild(pCxt, (SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 1), &pRightChildCond);
         }
       }
       if (TSDB_CODE_SUCCESS == code && NULL != pJoin->node.pConditions) {
@@ -1807,11 +1836,11 @@ static int32_t pdcDealJoin(SOptimizeContext* pCxt, SJoinLogicNode* pJoin) {
     if (TSDB_CODE_SUCCESS == code) {
       code = pdcRewriteTypeBasedOnJoinRes(pCxt, pJoin);
     }
-    
+
     if (TSDB_CODE_SUCCESS != code || t == pJoin->joinType) {
       break;
     }
-    
+
     t = pJoin->joinType;
     s = pJoin->subType;
   }
@@ -1826,7 +1855,8 @@ static int32_t pdcDealJoin(SOptimizeContext* pCxt, SJoinLogicNode* pJoin) {
     }
   }
 
-  if (TSDB_CODE_SUCCESS == code && NULL != pJoin->pFullOnCond && !IS_WINDOW_JOIN(pJoin->subType) && NULL == pJoin->addPrimEqCond) {
+  if (TSDB_CODE_SUCCESS == code && NULL != pJoin->pFullOnCond && !IS_WINDOW_JOIN(pJoin->subType) &&
+      NULL == pJoin->addPrimEqCond) {
     code = pdcJoinSplitPrimEqCond(pCxt, pJoin);
   }
 
@@ -1842,9 +1872,9 @@ static int32_t pdcDealJoin(SOptimizeContext* pCxt, SJoinLogicNode* pJoin) {
     code = pdcJoinAddParentOnColsToTarget(pCxt, pJoin);
   }
 
-  //if (TSDB_CODE_SUCCESS == code) {
-  //  code = pdcJoinAddPreFilterColsToTarget(pCxt, pJoin);
-  //}
+  // if (TSDB_CODE_SUCCESS == code) {
+  //   code = pdcJoinAddPreFilterColsToTarget(pCxt, pJoin);
+  // }
 
   if (TSDB_CODE_SUCCESS == code) {
     code = pdcJoinAddFilterColsToTarget(pCxt, pJoin);
@@ -2144,12 +2174,11 @@ static int32_t pdcOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan)
   return pdcOptimizeImpl(pCxt, pLogicSubplan->pNode);
 }
 
-
 static bool eliminateNotNullCondMayBeOptimized(SLogicNode* pNode, void* pCtx) {
   if (QUERY_NODE_LOGIC_PLAN_AGG != nodeType(pNode)) {
     return false;
   }
-  
+
   SAggLogicNode* pAgg = (SAggLogicNode*)pNode;
   if (pNode->pChildren->length != 1 || NULL != pAgg->pGroupKeys) {
     return false;
@@ -2209,7 +2238,7 @@ static int32_t eliminateNotNullCondOptimize(SOptimizeContext* pCxt, SLogicSubpla
   if (NULL == pNode) {
     return TSDB_CODE_SUCCESS;
   }
-  
+
   SScanLogicNode* pScan = (SScanLogicNode*)nodesListGetNode(pNode->pChildren, 0);
   nodesDestroyNode(pScan->node.pConditions);
   pScan->node.pConditions = NULL;
@@ -2219,7 +2248,6 @@ static int32_t eliminateNotNullCondOptimize(SOptimizeContext* pCxt, SLogicSubpla
   return TSDB_CODE_SUCCESS;
 }
 
-
 static bool sortPriKeyOptIsPriKeyOrderBy(SNodeList* pSortKeys) {
   if (1 != LIST_LENGTH(pSortKeys)) {
     return false;
@@ -2244,7 +2272,7 @@ static bool sortPriKeyOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
       return false;
     }
   }
-  
+
   FOREACH(pChild, pSort->node.pChildren) {
     SLogicNode* pSortDescendent = optFindPossibleNode((SLogicNode*)pChild, sortPriKeyOptMayBeOptimized, NULL);
     if (pSortDescendent != NULL) {
@@ -2254,45 +2282,46 @@ static bool sortPriKeyOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
   return true;
 }
 
-static int32_t sortPriKeyOptHandleLeftRightJoinSort(SJoinLogicNode* pJoin, SSortLogicNode* pSort, bool* pNotOptimize, bool* keepSort) {
+static int32_t sortPriKeyOptHandleLeftRightJoinSort(SJoinLogicNode* pJoin, SSortLogicNode* pSort, bool* pNotOptimize,
+                                                    bool* keepSort) {
   if (JOIN_STYPE_SEMI == pJoin->subType || JOIN_STYPE_NONE == pJoin->subType) {
     return TSDB_CODE_SUCCESS;
   }
 
   SSHashObj* pLeftTables = NULL;
   SSHashObj* pRightTables = NULL;
-  bool sortByProbe = true;
-/*  
-  bool sortByLeft = true, sortByRight = true, sortByProbe = false;
-  collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables);
-  collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables);
+  bool       sortByProbe = true;
+  /*
+    bool sortByLeft = true, sortByRight = true, sortByProbe = false;
+    collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables);
+    collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables);
 
-  SOrderByExprNode* pExprNode = (SOrderByExprNode*)nodesListGetNode(pSort->pSortKeys, 0);
-  SColumnNode* pSortCol = (SColumnNode*)pExprNode->pExpr;
-  if (NULL == tSimpleHashGet(pLeftTables, pSortCol->tableAlias, strlen(pSortCol->tableAlias))) {
-    sortByLeft = false;
-  }
-  if (NULL == tSimpleHashGet(pRightTables, pSortCol->tableAlias, strlen(pSortCol->tableAlias))) {
-    sortByRight = false;
-  }
+    SOrderByExprNode* pExprNode = (SOrderByExprNode*)nodesListGetNode(pSort->pSortKeys, 0);
+    SColumnNode* pSortCol = (SColumnNode*)pExprNode->pExpr;
+    if (NULL == tSimpleHashGet(pLeftTables, pSortCol->tableAlias, strlen(pSortCol->tableAlias))) {
+      sortByLeft = false;
+    }
+    if (NULL == tSimpleHashGet(pRightTables, pSortCol->tableAlias, strlen(pSortCol->tableAlias))) {
+      sortByRight = false;
+    }
 
-  tSimpleHashCleanup(pLeftTables);
-  tSimpleHashCleanup(pRightTables);
+    tSimpleHashCleanup(pLeftTables);
+    tSimpleHashCleanup(pRightTables);
 
-  if (!sortByLeft && !sortByRight) {
-    planError("sort by primary key not in any join subtable, tableAlias: %s", pSortCol->tableAlias);
-    return TSDB_CODE_PLAN_INTERNAL_ERROR;
-  }
+    if (!sortByLeft && !sortByRight) {
+      planError("sort by primary key not in any join subtable, tableAlias: %s", pSortCol->tableAlias);
+      return TSDB_CODE_PLAN_INTERNAL_ERROR;
+    }
 
-  if (sortByLeft && sortByRight) {
-    planError("sort by primary key in both join subtables, tableAlias: %s", pSortCol->tableAlias);
-    return TSDB_CODE_PLAN_INTERNAL_ERROR;
-  }
+    if (sortByLeft && sortByRight) {
+      planError("sort by primary key in both join subtables, tableAlias: %s", pSortCol->tableAlias);
+      return TSDB_CODE_PLAN_INTERNAL_ERROR;
+    }
 
-  if ((JOIN_TYPE_LEFT == pJoin->joinType && sortByLeft) || (JOIN_TYPE_RIGHT == pJoin->joinType && sortByRight)) {
-    sortByProbe = true;
-  }
-*/
+    if ((JOIN_TYPE_LEFT == pJoin->joinType && sortByLeft) || (JOIN_TYPE_RIGHT == pJoin->joinType && sortByRight)) {
+      sortByProbe = true;
+    }
+  */
   switch (pJoin->subType) {
     case JOIN_STYPE_OUTER: {
       if (sortByProbe) {
@@ -2304,7 +2333,7 @@ static int32_t sortPriKeyOptHandleLeftRightJoinSort(SJoinLogicNode* pJoin, SSort
         return TSDB_CODE_SUCCESS;
       }
     }
-    case JOIN_STYPE_ASOF: 
+    case JOIN_STYPE_ASOF:
     case JOIN_STYPE_WIN: {
       if (sortByProbe) {
         if (NULL != pJoin->pLeftEqNodes && pJoin->pLeftEqNodes->length > 0) {
@@ -2320,11 +2349,10 @@ static int32_t sortPriKeyOptHandleLeftRightJoinSort(SJoinLogicNode* pJoin, SSort
   return TSDB_CODE_SUCCESS;
 }
 
-
-static int32_t sortPriKeyOptHandleJoinSort(SLogicNode* pNode, bool groupSort, SSortLogicNode* pSort,
-                                                   bool* pNotOptimize, SNodeList** pSequencingNodes, bool* keepSort) {
+static int32_t sortPriKeyOptHandleJoinSort(SLogicNode* pNode, bool groupSort, SSortLogicNode* pSort, bool* pNotOptimize,
+                                           SNodeList** pSequencingNodes, bool* keepSort) {
   SJoinLogicNode* pJoin = (SJoinLogicNode*)pNode;
-  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t         code = TSDB_CODE_SUCCESS;
 
   switch (pJoin->joinType) {
     case JOIN_TYPE_LEFT:
@@ -2342,22 +2370,20 @@ static int32_t sortPriKeyOptHandleJoinSort(SLogicNode* pNode, bool groupSort, SS
       break;
   }
 
-  code = sortPriKeyOptGetSequencingNodesImpl((SLogicNode*)nodesListGetNode(pNode->pChildren, 0), groupSort,
-                                                     pSort, pNotOptimize, pSequencingNodes, keepSort);
+  code = sortPriKeyOptGetSequencingNodesImpl((SLogicNode*)nodesListGetNode(pNode->pChildren, 0), groupSort, pSort,
+                                             pNotOptimize, pSequencingNodes, keepSort);
   if (TSDB_CODE_SUCCESS == code) {
-    code = sortPriKeyOptGetSequencingNodesImpl((SLogicNode*)nodesListGetNode(pNode->pChildren, 1), groupSort,
-                                               pSort, pNotOptimize, pSequencingNodes, keepSort);
+    code = sortPriKeyOptGetSequencingNodesImpl((SLogicNode*)nodesListGetNode(pNode->pChildren, 1), groupSort, pSort,
+                                               pNotOptimize, pSequencingNodes, keepSort);
   }
 
   return code;
 }
 
-                                                   
 static EOrder sortPriKeyOptGetPriKeyOrder(SSortLogicNode* pSort) {
- return ((SOrderByExprNode*)nodesListGetNode(pSort->pSortKeys, 0))->order;
+  return ((SOrderByExprNode*)nodesListGetNode(pSort->pSortKeys, 0))->order;
 }
 
-
 static bool sortPriKeyOptHasUnsupportedPkFunc(SLogicNode* pLogicNode, EOrder sortOrder) {
   if (sortOrder == ORDER_ASC) {
     return false;
@@ -2385,18 +2411,16 @@ static bool sortPriKeyOptHasUnsupportedPkFunc(SLogicNode* pLogicNode, EOrder sor
     default:
       break;
   }
-  
+
   SNode* pNode = 0;
   FOREACH(pNode, pFuncList) {
     if (nodeType(pNode) != QUERY_NODE_FUNCTION) {
       continue;
     }
     SFunctionNode* pFuncNode = (SFunctionNode*)pLogicNode;
-    if (pFuncNode->hasPk && 
-        (pFuncNode->funcType == FUNCTION_TYPE_DIFF || 
-         pFuncNode->funcType == FUNCTION_TYPE_DERIVATIVE || 
-         pFuncNode->funcType == FUNCTION_TYPE_IRATE ||
-         pFuncNode->funcType == FUNCTION_TYPE_TWA)) {
+    if (pFuncNode->hasPk &&
+        (pFuncNode->funcType == FUNCTION_TYPE_DIFF || pFuncNode->funcType == FUNCTION_TYPE_DERIVATIVE ||
+         pFuncNode->funcType == FUNCTION_TYPE_IRATE || pFuncNode->funcType == FUNCTION_TYPE_TWA)) {
       return true;
     }
   }
@@ -2404,7 +2428,7 @@ static bool sortPriKeyOptHasUnsupportedPkFunc(SLogicNode* pLogicNode, EOrder sor
 }
 
 int32_t sortPriKeyOptGetSequencingNodesImpl(SLogicNode* pNode, bool groupSort, SSortLogicNode* pSort,
-                                                   bool* pNotOptimize, SNodeList** pSequencingNodes, bool* keepSort) {
+                                            bool* pNotOptimize, SNodeList** pSequencingNodes, bool* keepSort) {
   EOrder sortOrder = sortPriKeyOptGetPriKeyOrder(pSort);
   if (sortPriKeyOptHasUnsupportedPkFunc(pNode, sortOrder)) {
     *pNotOptimize = true;
@@ -2427,7 +2451,7 @@ int32_t sortPriKeyOptGetSequencingNodesImpl(SLogicNode* pNode, bool groupSort, S
     }
     case QUERY_NODE_LOGIC_PLAN_SORT: {
       *keepSort = true;
-      NODES_CLEAR_LIST(*pSequencingNodes);      
+      NODES_CLEAR_LIST(*pSequencingNodes);
       return TSDB_CODE_SUCCESS;
     }
     case QUERY_NODE_LOGIC_PLAN_JOIN: {
@@ -2459,12 +2483,11 @@ int32_t sortPriKeyOptGetSequencingNodesImpl(SLogicNode* pNode, bool groupSort, S
                                              pNotOptimize, pSequencingNodes, keepSort);
 }
 
-
-static int32_t sortPriKeyOptGetSequencingNodes(SSortLogicNode* pSort, bool groupSort, SNodeList** pSequencingNodes, bool* keepSort) {
+static int32_t sortPriKeyOptGetSequencingNodes(SSortLogicNode* pSort, bool groupSort, SNodeList** pSequencingNodes,
+                                               bool* keepSort) {
   bool    notOptimize = false;
-  int32_t code =
-      sortPriKeyOptGetSequencingNodesImpl((SLogicNode*)nodesListGetNode(pSort->node.pChildren, 0), groupSort,
-                                          pSort, &notOptimize, pSequencingNodes, keepSort);
+  int32_t code = sortPriKeyOptGetSequencingNodesImpl((SLogicNode*)nodesListGetNode(pSort->node.pChildren, 0), groupSort,
+                                                     pSort, &notOptimize, pSequencingNodes, keepSort);
   if (TSDB_CODE_SUCCESS != code || notOptimize) {
     NODES_CLEAR_LIST(*pSequencingNodes);
   }
@@ -2510,7 +2533,7 @@ static int32_t sortPriKeyOptApply(SOptimizeContext* pCxt, SLogicSubplan* pLogicS
 
 static int32_t sortPrimaryKeyOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan, SSortLogicNode* pSort) {
   SNodeList* pSequencingNodes = NULL;
-  bool keepSort = true;
+  bool       keepSort = true;
   int32_t    code = sortPriKeyOptGetSequencingNodes(pSort, pSort->groupSort, &pSequencingNodes, &keepSort);
   if (TSDB_CODE_SUCCESS == code) {
     if (pSequencingNodes != NULL) {
@@ -2547,20 +2570,22 @@ static int32_t sortPrimaryKeyOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLo
 }
 
 static int32_t sortForJoinOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan, SJoinLogicNode* pJoin) {
-  SLogicNode* pLeft = (SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 0);
-  SLogicNode* pRight = (SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 1);
+  SLogicNode*     pLeft = (SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 0);
+  SLogicNode*     pRight = (SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 1);
   SScanLogicNode* pScan = NULL;
-  SLogicNode* pChild = NULL;
-  SNode** pChildPos = NULL;
-  EOrder targetOrder = 0;
-  SSHashObj* pTables = NULL;
-  
-  if (QUERY_NODE_LOGIC_PLAN_SCAN == nodeType(pLeft) && ((SScanLogicNode*)pLeft)->node.outputTsOrder != SCAN_ORDER_BOTH) {
+  SLogicNode*     pChild = NULL;
+  SNode**         pChildPos = NULL;
+  EOrder          targetOrder = 0;
+  SSHashObj*      pTables = NULL;
+
+  if (QUERY_NODE_LOGIC_PLAN_SCAN == nodeType(pLeft) &&
+      ((SScanLogicNode*)pLeft)->node.outputTsOrder != SCAN_ORDER_BOTH) {
     pScan = (SScanLogicNode*)pLeft;
     pChild = pRight;
     pChildPos = &pJoin->node.pChildren->pTail->pNode;
     targetOrder = pScan->node.outputTsOrder;
-  } else if (QUERY_NODE_LOGIC_PLAN_SCAN == nodeType(pRight) && ((SScanLogicNode*)pRight)->node.outputTsOrder != SCAN_ORDER_BOTH) {
+  } else if (QUERY_NODE_LOGIC_PLAN_SCAN == nodeType(pRight) &&
+             ((SScanLogicNode*)pRight)->node.outputTsOrder != SCAN_ORDER_BOTH) {
     pScan = (SScanLogicNode*)pRight;
     pChild = pLeft;
     pChildPos = &pJoin->node.pChildren->pHead->pNode;
@@ -2575,7 +2600,7 @@ static int32_t sortForJoinOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* pL
     return TSDB_CODE_PLAN_INTERNAL_ERROR;
   }
 
-  bool res = false;
+  bool           res = false;
   SOperatorNode* pOp = (SOperatorNode*)pJoin->pPrimKeyEqCond;
   if (QUERY_NODE_COLUMN != nodeType(pOp->pLeft) || QUERY_NODE_COLUMN != nodeType(pOp->pRight)) {
     return TSDB_CODE_PLAN_INTERNAL_ERROR;
@@ -2583,13 +2608,15 @@ static int32_t sortForJoinOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* pL
 
   SNode* pOrderByNode = NULL;
 
-  int32_t code = collectTableAliasFromNodes((SNode*)pChild, &pTables);  
+  int32_t code = collectTableAliasFromNodes((SNode*)pChild, &pTables);
   if (TSDB_CODE_SUCCESS != code) {
     return code;
   }
-  if (NULL != tSimpleHashGet(pTables, ((SColumnNode*)pOp->pLeft)->tableAlias, strlen(((SColumnNode*)pOp->pLeft)->tableAlias))) {
+  if (NULL !=
+      tSimpleHashGet(pTables, ((SColumnNode*)pOp->pLeft)->tableAlias, strlen(((SColumnNode*)pOp->pLeft)->tableAlias))) {
     pOrderByNode = pOp->pLeft;
-  } else if (NULL != tSimpleHashGet(pTables, ((SColumnNode*)pOp->pRight)->tableAlias, strlen(((SColumnNode*)pOp->pRight)->tableAlias))) {
+  } else if (NULL != tSimpleHashGet(pTables, ((SColumnNode*)pOp->pRight)->tableAlias,
+                                    strlen(((SColumnNode*)pOp->pRight)->tableAlias))) {
     pOrderByNode = pOp->pRight;
   }
 
@@ -2609,15 +2636,15 @@ static int32_t sortForJoinOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* pL
   pSort->node.pTargets = NULL;
   code = nodesCloneList(pChild->pTargets, &pSort->node.pTargets);
   if (NULL == pSort->node.pTargets) {
-    nodesDestroyNode((SNode *)pSort);
+    nodesDestroyNode((SNode*)pSort);
     return code;
   }
-  
+
   pSort->groupSort = false;
   SOrderByExprNode* pOrder = NULL;
   code = nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR, (SNode**)&pOrder);
   if (NULL == pOrder) {
-    nodesDestroyNode((SNode *)pSort);
+    nodesDestroyNode((SNode*)pSort);
     return code;
   }
 
@@ -2631,7 +2658,7 @@ static int32_t sortForJoinOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* pL
   pOrder->nullOrder = (ORDER_ASC == pOrder->order) ? NULL_ORDER_FIRST : NULL_ORDER_LAST;
   code = nodesCloneNode(pOrderByNode, &pOrder->pExpr);
   if (!pOrder->pExpr) {
-    nodesDestroyNode((SNode *)pSort);
+    nodesDestroyNode((SNode*)pSort);
     return code;
   }
 
@@ -2641,7 +2668,8 @@ static int32_t sortForJoinOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* pL
     return code;
   }
   *pChildPos = (SNode*)pSort;
-  pSort->node.pParent = (SLogicNode*)pJoin;;
+  pSort->node.pParent = (SLogicNode*)pJoin;
+  ;
 
 _return:
 
@@ -2650,12 +2678,11 @@ _return:
   return TSDB_CODE_SUCCESS;
 }
 
-
 static bool sortForJoinOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
   if (QUERY_NODE_LOGIC_PLAN_JOIN != nodeType(pNode)) {
     return false;
   }
-  
+
   SJoinLogicNode* pJoin = (SJoinLogicNode*)pNode;
   if (pNode->pChildren->length != 2 || !pJoin->hasSubQuery || pJoin->isLowLevelJoin) {
     return false;
@@ -2678,9 +2705,9 @@ static bool sortForJoinOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
   return true;
 }
 
-
 static int32_t sortForJoinOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
-  SJoinLogicNode* pJoin = (SJoinLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, sortForJoinOptMayBeOptimized, NULL);
+  SJoinLogicNode* pJoin =
+      (SJoinLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, sortForJoinOptMayBeOptimized, NULL);
   if (NULL == pJoin) {
     return TSDB_CODE_SUCCESS;
   }
@@ -2723,14 +2750,15 @@ static int32_t joinCondGetAllScanNodes(SLogicNode* pNode, SNodeList** pList) {
   }
 }
 
-
 static bool joinCondMayBeOptimized(SLogicNode* pNode, void* pCtx) {
-  if (QUERY_NODE_LOGIC_PLAN_JOIN != nodeType(pNode) || OPTIMIZE_FLAG_TEST_MASK(pNode->optimizedFlag, OPTIMIZE_FLAG_JOIN_COND)) {
+  if (QUERY_NODE_LOGIC_PLAN_JOIN != nodeType(pNode) ||
+      OPTIMIZE_FLAG_TEST_MASK(pNode->optimizedFlag, OPTIMIZE_FLAG_JOIN_COND)) {
     return false;
   }
-  
+
   SJoinLogicNode* pJoin = (SJoinLogicNode*)pNode;
-  if (pNode->pChildren->length != 2 || JOIN_STYPE_ASOF == pJoin->subType || JOIN_STYPE_WIN == pJoin->subType || JOIN_TYPE_FULL == pJoin->joinType) {
+  if (pNode->pChildren->length != 2 || JOIN_STYPE_ASOF == pJoin->subType || JOIN_STYPE_WIN == pJoin->subType ||
+      JOIN_TYPE_FULL == pJoin->joinType) {
     OPTIMIZE_FLAG_SET_MASK(pNode->optimizedFlag, OPTIMIZE_FLAG_JOIN_COND);
     return false;
   }
@@ -2738,21 +2766,26 @@ static bool joinCondMayBeOptimized(SLogicNode* pNode, void* pCtx) {
   SLogicNode* pLeft = (SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 0);
   SLogicNode* pRight = (SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 1);
 
-  if ((JOIN_TYPE_LEFT == pJoin->joinType || JOIN_TYPE_RIGHT == pJoin->joinType) && (QUERY_NODE_LOGIC_PLAN_SCAN != nodeType(pLeft) || QUERY_NODE_LOGIC_PLAN_SCAN != nodeType(pRight))) {
+  if ((JOIN_TYPE_LEFT == pJoin->joinType || JOIN_TYPE_RIGHT == pJoin->joinType) &&
+      (QUERY_NODE_LOGIC_PLAN_SCAN != nodeType(pLeft) || QUERY_NODE_LOGIC_PLAN_SCAN != nodeType(pRight))) {
     OPTIMIZE_FLAG_SET_MASK(pNode->optimizedFlag, OPTIMIZE_FLAG_JOIN_COND);
     return false;
   }
 
-  if (JOIN_TYPE_INNER == pJoin->joinType && ((QUERY_NODE_LOGIC_PLAN_SCAN != nodeType(pLeft) && QUERY_NODE_LOGIC_PLAN_JOIN != nodeType(pLeft)) || (QUERY_NODE_LOGIC_PLAN_SCAN != nodeType(pRight) && QUERY_NODE_LOGIC_PLAN_JOIN != nodeType(pRight)))) {
+  if (JOIN_TYPE_INNER == pJoin->joinType &&
+      ((QUERY_NODE_LOGIC_PLAN_SCAN != nodeType(pLeft) && QUERY_NODE_LOGIC_PLAN_JOIN != nodeType(pLeft)) ||
+       (QUERY_NODE_LOGIC_PLAN_SCAN != nodeType(pRight) && QUERY_NODE_LOGIC_PLAN_JOIN != nodeType(pRight)))) {
     OPTIMIZE_FLAG_SET_MASK(pNode->optimizedFlag, OPTIMIZE_FLAG_JOIN_COND);
     return false;
   }
 
   if (JOIN_TYPE_INNER == pJoin->joinType) {
-    if (QUERY_NODE_LOGIC_PLAN_JOIN == nodeType(pLeft) && !OPTIMIZE_FLAG_TEST_MASK(pLeft->optimizedFlag, OPTIMIZE_FLAG_JOIN_COND)) {
+    if (QUERY_NODE_LOGIC_PLAN_JOIN == nodeType(pLeft) &&
+        !OPTIMIZE_FLAG_TEST_MASK(pLeft->optimizedFlag, OPTIMIZE_FLAG_JOIN_COND)) {
       return false;
     }
-    if (QUERY_NODE_LOGIC_PLAN_JOIN == nodeType(pRight) && !OPTIMIZE_FLAG_TEST_MASK(pRight->optimizedFlag, OPTIMIZE_FLAG_JOIN_COND)) {
+    if (QUERY_NODE_LOGIC_PLAN_JOIN == nodeType(pRight) &&
+        !OPTIMIZE_FLAG_TEST_MASK(pRight->optimizedFlag, OPTIMIZE_FLAG_JOIN_COND)) {
       return false;
     }
   }
@@ -2769,7 +2802,7 @@ static bool joinCondMayBeOptimized(SLogicNode* pNode, void* pCtx) {
     OPTIMIZE_FLAG_SET_MASK(pNode->optimizedFlag, OPTIMIZE_FLAG_JOIN_COND);
     return false;
   }
-  
+
   return true;
 }
 
@@ -2791,7 +2824,7 @@ static int32_t joinCondOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub
   switch (pJoin->joinType) {
     case JOIN_TYPE_INNER: {
       SNodeList* pScanList = NULL;
-      int32_t code = joinCondGetAllScanNodes((SLogicNode*)pJoin, &pScanList);
+      int32_t    code = joinCondGetAllScanNodes((SLogicNode*)pJoin, &pScanList);
       if (TSDB_CODE_SUCCESS != code) {
         return code;
       }
@@ -2799,11 +2832,9 @@ static int32_t joinCondOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub
         nodesClearList(pScanList);
         return TSDB_CODE_SUCCESS;
       }
-      SNode* pNode = NULL;
-      STimeWindow   scanRange = TSWINDOW_INITIALIZER;
-      FOREACH(pNode, pScanList) {
-        joinCondMergeScanRand(&scanRange, &((SScanLogicNode*)pNode)->scanRange);
-      }
+      SNode*      pNode = NULL;
+      STimeWindow scanRange = TSWINDOW_INITIALIZER;
+      FOREACH(pNode, pScanList) { joinCondMergeScanRand(&scanRange, &((SScanLogicNode*)pNode)->scanRange); }
       FOREACH(pNode, pScanList) {
         ((SScanLogicNode*)pNode)->scanRange.skey = scanRange.skey;
         ((SScanLogicNode*)pNode)->scanRange.ekey = scanRange.ekey;
@@ -2812,11 +2843,11 @@ static int32_t joinCondOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub
       break;
     }
     case JOIN_TYPE_LEFT: {
-      SLogicNode* pLeft = (SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 0);
-      SLogicNode* pRight = (SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 1);
+      SLogicNode*     pLeft = (SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 0);
+      SLogicNode*     pRight = (SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 1);
       SScanLogicNode* pLScan = joinCondGetScanNode(pLeft);
       SScanLogicNode* pRScan = joinCondGetScanNode(pRight);
-      
+
       if (NULL == pLScan || NULL == pRScan) {
         return TSDB_CODE_SUCCESS;
       }
@@ -2824,11 +2855,11 @@ static int32_t joinCondOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub
       break;
     }
     case JOIN_TYPE_RIGHT: {
-      SLogicNode* pLeft = (SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 0);
-      SLogicNode* pRight = (SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 1);
+      SLogicNode*     pLeft = (SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 0);
+      SLogicNode*     pRight = (SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 1);
       SScanLogicNode* pLScan = joinCondGetScanNode(pLeft);
       SScanLogicNode* pRScan = joinCondGetScanNode(pRight);
-      
+
       if (NULL == pLScan || NULL == pRScan) {
         return TSDB_CODE_SUCCESS;
       }
@@ -2864,7 +2895,7 @@ static bool smaIndexOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
 static int32_t smaIndexOptCreateSmaScan(SScanLogicNode* pScan, STableIndexInfo* pIndex, SNodeList* pCols,
                                         SLogicNode** pOutput) {
   SScanLogicNode* pSmaScan = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SCAN, (SNode**)&pSmaScan);
+  int32_t         code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SCAN, (SNode**)&pSmaScan);
   if (NULL == pSmaScan) {
     return code;
   }
@@ -2918,7 +2949,7 @@ static bool smaIndexOptEqualInterval(SScanLogicNode* pScan, SWindowLogicNode* pW
 
 static int32_t smaIndexOptCreateSmaCol(SNode* pFunc, uint64_t tableId, int32_t colId, SColumnNode** ppNode) {
   SColumnNode* pCol = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol);
+  int32_t      code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol);
   if (NULL == pCol) {
     return code;
   }
@@ -3180,8 +3211,8 @@ static int32_t partTagsCreateWrapperFunc(const char* pFuncName, SNode* pNode, SF
 
   snprintf(pFunc->functionName, sizeof(pFunc->functionName), "%s", pFuncName);
   if ((QUERY_NODE_COLUMN == nodeType(pNode) && COLUMN_TYPE_TBNAME != ((SColumnNode*)pNode)->colType) ||
-   (QUERY_NODE_COLUMN == nodeType(pNode) && COLUMN_TYPE_TBNAME == ((SColumnNode*)pNode)->colType &&
-   ((SColumnNode*)pNode)->tableAlias[0] != '\0')){
+      (QUERY_NODE_COLUMN == nodeType(pNode) && COLUMN_TYPE_TBNAME == ((SColumnNode*)pNode)->colType &&
+       ((SColumnNode*)pNode)->tableAlias[0] != '\0')) {
     SColumnNode* pCol = (SColumnNode*)pNode;
     partTagsSetAlias(pFunc->node.aliasName, pCol->tableAlias, pCol->colName);
   } else {
@@ -3348,9 +3379,10 @@ static int32_t eliminateProjOptCheckProjColumnNames(SProjectLogicNode* pProjectN
 
 static bool eliminateProjOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
   // Super table scan requires project operator to merge packets to improve performance.
-  if (NULL == pNode->pParent && (QUERY_NODE_LOGIC_PLAN_PROJECT != nodeType(pNode) || 1 != LIST_LENGTH(pNode->pChildren) ||
-      (QUERY_NODE_LOGIC_PLAN_SCAN == nodeType(nodesListGetNode(pNode->pChildren, 0)) &&
-       TSDB_SUPER_TABLE == ((SScanLogicNode*)nodesListGetNode(pNode->pChildren, 0))->tableType))) {
+  if (NULL == pNode->pParent &&
+      (QUERY_NODE_LOGIC_PLAN_PROJECT != nodeType(pNode) || 1 != LIST_LENGTH(pNode->pChildren) ||
+       (QUERY_NODE_LOGIC_PLAN_SCAN == nodeType(nodesListGetNode(pNode->pChildren, 0)) &&
+        TSDB_SUPER_TABLE == ((SScanLogicNode*)nodesListGetNode(pNode->pChildren, 0))->tableType))) {
     return false;
   }
 
@@ -3358,18 +3390,20 @@ static bool eliminateProjOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
     return false;
   }
 
-  if (NULL != pNode->pParent && (QUERY_NODE_LOGIC_PLAN_PROJECT != nodeType(pNode) || 1 != LIST_LENGTH(pNode->pChildren) ||
-      QUERY_NODE_LOGIC_PLAN_SCAN != nodeType(nodesListGetNode(pNode->pChildren, 0)) || QUERY_NODE_LOGIC_PLAN_JOIN != nodeType(pNode->pParent))) {
+  if (NULL != pNode->pParent &&
+      (QUERY_NODE_LOGIC_PLAN_PROJECT != nodeType(pNode) || 1 != LIST_LENGTH(pNode->pChildren) ||
+       QUERY_NODE_LOGIC_PLAN_SCAN != nodeType(nodesListGetNode(pNode->pChildren, 0)) ||
+       QUERY_NODE_LOGIC_PLAN_JOIN != nodeType(pNode->pParent))) {
     return false;
-  }  
+  }
 
   if (QUERY_NODE_LOGIC_PLAN_PROJECT != nodeType(pNode) || 1 != LIST_LENGTH(pNode->pChildren)) {
     return false;
   }
-  
+
   if (QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL == nodeType(nodesListGetNode(pNode->pChildren, 0))) {
     SLogicNode* pChild = (SLogicNode*)nodesListGetNode(pNode->pChildren, 0);
-    if(LIST_LENGTH(pChild->pTargets) != LIST_LENGTH(pNode->pTargets)) {
+    if (LIST_LENGTH(pChild->pTargets) != LIST_LENGTH(pNode->pTargets)) {
       return false;
     }
   }
@@ -3430,7 +3464,7 @@ static bool eliminateProjOptCanChildConditionUseChildTargets(SLogicNode* pChild,
 
   if (QUERY_NODE_LOGIC_PLAN_JOIN == nodeType(pChild) && ((SJoinLogicNode*)pChild)->joinAlgo != JOIN_ALGO_UNKNOWN) {
     return false;
-  }  
+  }
   if (QUERY_NODE_LOGIC_PLAN_JOIN == nodeType(pChild) && ((SJoinLogicNode*)pChild)->pFullOnCond) {
     SJoinLogicNode*         pJoinLogicNode = (SJoinLogicNode*)pChild;
     CheckNewChildTargetsCxt cxt = {.pNewChildTargets = pNewChildTargets, .canUse = false};
@@ -3469,16 +3503,15 @@ typedef struct RewriteTableAliasCxt {
 
 static EDealRes eliminateProjOptRewriteScanTableAlias(SNode* pNode, void* pContext) {
   if (QUERY_NODE_COLUMN == nodeType(pNode)) {
-    SColumnNode* pCol = (SColumnNode*)pNode;
+    SColumnNode*          pCol = (SColumnNode*)pNode;
     RewriteTableAliasCxt* pCtx = (RewriteTableAliasCxt*)pContext;
     strncpy(pCol->tableAlias, pCtx->newTableAlias, TSDB_TABLE_NAME_LEN);
   }
   return DEAL_RES_CONTINUE;
 }
 
-
 static void eliminateProjPushdownProjIdx(SNodeList* pParentProjects, SNodeList* pChildTargets) {
-  SNode* pChildTarget = NULL, *pParentProject = NULL;
+  SNode *pChildTarget = NULL, *pParentProject = NULL;
   FOREACH(pChildTarget, pChildTargets) {
     SColumnNode* pTargetCol = (SColumnNode*)pChildTarget;
     FOREACH(pParentProject, pParentProjects) {
@@ -3502,9 +3535,9 @@ static int32_t eliminateProjOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan*
     if (TSDB_CODE_SUCCESS != code) {
       return code;
     }
-    SNode *    pProjection = NULL, *pChildTarget = NULL;
-    bool       orderMatch = true;
-    bool       needOrderMatch =
+    SNode *pProjection = NULL, *pChildTarget = NULL;
+    bool   orderMatch = true;
+    bool   needOrderMatch =
         QUERY_NODE_LOGIC_PLAN_PROJECT == nodeType(pChild) && ((SProjectLogicNode*)pChild)->isSetOpProj;
     if (needOrderMatch) {
       // For sql: select ... from (select ... union all select ...);
@@ -3557,14 +3590,14 @@ static int32_t eliminateProjOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan*
     }
   } else {
     RewriteTableAliasCxt cxt = {.newTableAlias = pProjectNode->stmtName, .rewriteColName = false};
-    SScanLogicNode* pScan = (SScanLogicNode*)pChild;
+    SScanLogicNode*      pScan = (SScanLogicNode*)pChild;
     nodesWalkExprs(pScan->pScanCols, eliminateProjOptRewriteScanTableAlias, &cxt);
-    nodesWalkExprs(pScan->pScanPseudoCols, eliminateProjOptRewriteScanTableAlias, &cxt);    
+    nodesWalkExprs(pScan->pScanPseudoCols, eliminateProjOptRewriteScanTableAlias, &cxt);
     nodesWalkExpr(pScan->node.pConditions, eliminateProjOptRewriteScanTableAlias, &cxt);
     nodesWalkExprs(pChild->pTargets, eliminateProjOptRewriteScanTableAlias, &cxt);
     eliminateProjPushdownProjIdx(pProjectNode->pProjections, pChild->pTargets);
   }
-  
+
   if (TSDB_CODE_SUCCESS == code) {
     code = replaceLogicNode(pLogicSubplan, (SLogicNode*)pProjectNode, pChild);
   }
@@ -3597,7 +3630,7 @@ static bool rewriteTailOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
 
 static int32_t rewriteTailOptCreateOrderByExpr(SNode* pSortKey, SNode** ppNode) {
   SOrderByExprNode* pOrder = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR, (SNode**)&pOrder);
+  int32_t           code = nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR, (SNode**)&pOrder);
   if (NULL == pOrder) {
     return code;
   }
@@ -3614,7 +3647,7 @@ static int32_t rewriteTailOptCreateOrderByExpr(SNode* pSortKey, SNode** ppNode)
 
 static int32_t rewriteTailOptCreateLimit(SNode* pLimit, SNode* pOffset, SNode** pOutput) {
   SLimitNode* pLimitNode = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LIMIT, (SNode**)&pLimitNode);
+  int32_t     code = nodesMakeNode(QUERY_NODE_LIMIT, (SNode**)&pLimitNode);
   if (NULL == pLimitNode) {
     return code;
   }
@@ -3635,7 +3668,7 @@ static bool rewriteTailOptNeedGroupSort(SIndefRowsFuncLogicNode* pIndef) {
 
 static int32_t rewriteTailOptCreateSort(SIndefRowsFuncLogicNode* pIndef, SLogicNode** pOutput) {
   SSortLogicNode* pSort = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT, (SNode**)&pSort);
+  int32_t         code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT, (SNode**)&pSort);
   if (NULL == pSort) {
     return code;
   }
@@ -3676,7 +3709,7 @@ static int32_t rewriteTailOptCreateSort(SIndefRowsFuncLogicNode* pIndef, SLogicN
 }
 
 static int32_t rewriteTailOptCreateProjectExpr(SFunctionNode* pFunc, SNode** ppNode) {
-  SNode* pExpr = NULL;
+  SNode*  pExpr = NULL;
   int32_t code = nodesCloneNode(nodesListGetNode(pFunc->pParameterList, 0), &pExpr);
   if (NULL == pExpr) {
     return code;
@@ -3688,7 +3721,7 @@ static int32_t rewriteTailOptCreateProjectExpr(SFunctionNode* pFunc, SNode** ppN
 
 static int32_t rewriteTailOptCreateProject(SIndefRowsFuncLogicNode* pIndef, SLogicNode** pOutput) {
   SProjectLogicNode* pProject = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT, (SNode**)&pProject);
+  int32_t            code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT, (SNode**)&pProject);
   if (NULL == pProject) {
     return TSDB_CODE_OUT_OF_MEMORY;
   }
@@ -3812,7 +3845,7 @@ static bool rewriteUniqueOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
 
 static int32_t rewriteUniqueOptCreateGroupingSet(SNode* pExpr, SNode** ppNode) {
   SGroupingSetNode* pGroupingSet = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_GROUPING_SET, (SNode**)&pGroupingSet);
+  int32_t           code = nodesMakeNode(QUERY_NODE_GROUPING_SET, (SNode**)&pGroupingSet);
   if (NULL == pGroupingSet) {
     return code;
   }
@@ -3832,7 +3865,7 @@ static int32_t rewriteUniqueOptCreateGroupingSet(SNode* pExpr, SNode** ppNode) {
 
 static int32_t rewriteUniqueOptCreateFirstFunc(SFunctionNode* pSelectValue, SNode* pCol, SNode** ppNode) {
   SFunctionNode* pFunc = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc);
+  int32_t        code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc);
   if (NULL == pFunc) {
     return code;
   }
@@ -3866,7 +3899,7 @@ static int32_t rewriteUniqueOptCreateFirstFunc(SFunctionNode* pSelectValue, SNod
 
 static int32_t rewriteUniqueOptCreateAgg(SIndefRowsFuncLogicNode* pIndef, SLogicNode** pOutput) {
   SAggLogicNode* pAgg = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pAgg);
+  int32_t        code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pAgg);
   if (NULL == pAgg) {
     return code;
   }
@@ -3877,9 +3910,9 @@ static int32_t rewriteUniqueOptCreateAgg(SIndefRowsFuncLogicNode* pIndef, SLogic
   pAgg->node.requireDataOrder = DATA_ORDER_LEVEL_IN_BLOCK;  // first function requirement
   pAgg->node.resultDataOrder = DATA_ORDER_LEVEL_NONE;
 
-  bool    hasSelectPrimaryKey = false;
-  SNode*  pPrimaryKey = NULL;
-  SNode*  pNode = NULL;
+  bool   hasSelectPrimaryKey = false;
+  SNode* pPrimaryKey = NULL;
+  SNode* pNode = NULL;
   FOREACH(pNode, pIndef->pFuncs) {
     SFunctionNode* pFunc = (SFunctionNode*)pNode;
     SNode*         pExpr = nodesListGetNode(pFunc->pParameterList, 0);
@@ -3934,7 +3967,7 @@ static int32_t rewriteUniqueOptCreateAgg(SIndefRowsFuncLogicNode* pIndef, SLogic
 
 static int32_t rewriteUniqueOptCreateProjectCol(SFunctionNode* pFunc, SNode** ppNode) {
   SColumnNode* pCol = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol);
+  int32_t      code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol);
   if (NULL == pCol) {
     return code;
   }
@@ -3958,7 +3991,7 @@ static int32_t rewriteUniqueOptCreateProjectCol(SFunctionNode* pFunc, SNode** pp
 
 static int32_t rewriteUniqueOptCreateProject(SIndefRowsFuncLogicNode* pIndef, SLogicNode** pOutput) {
   SProjectLogicNode* pProject = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT, (SNode**)&pProject);
+  int32_t            code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT, (SNode**)&pProject);
   if (NULL == pProject) {
     return code;
   }
@@ -3968,7 +4001,7 @@ static int32_t rewriteUniqueOptCreateProject(SIndefRowsFuncLogicNode* pIndef, SL
   pProject->node.requireDataOrder = DATA_ORDER_LEVEL_NONE;
   pProject->node.resultDataOrder = DATA_ORDER_LEVEL_NONE;
 
-  SNode*  pNode = NULL;
+  SNode* pNode = NULL;
   FOREACH(pNode, pIndef->pFuncs) {
     SNode* pNew = NULL;
     code = rewriteUniqueOptCreateProjectCol((SFunctionNode*)pNode, &pNew);
@@ -4093,26 +4126,30 @@ static bool lastRowScanOptCheckColNum(int32_t lastColNum, col_id_t lastColId, in
 
 static bool isNeedSplitCacheLastFunc(SFunctionNode* pFunc, SScanLogicNode* pScan) {
   int32_t funcType = pFunc->funcType;
-  if ((FUNCTION_TYPE_LAST_ROW != funcType || (FUNCTION_TYPE_LAST_ROW == funcType && TSDB_CACHE_MODEL_LAST_VALUE == pScan->cacheLastMode)) &&
-       (FUNCTION_TYPE_LAST != funcType || (FUNCTION_TYPE_LAST == funcType && (TSDB_CACHE_MODEL_LAST_ROW == pScan->cacheLastMode ||
-         QUERY_NODE_OPERATOR == nodeType(nodesListGetNode(pFunc->pParameterList, 0)) || QUERY_NODE_VALUE == nodeType(nodesListGetNode(pFunc->pParameterList, 0)) ||
+  if ((FUNCTION_TYPE_LAST_ROW != funcType ||
+       (FUNCTION_TYPE_LAST_ROW == funcType && TSDB_CACHE_MODEL_LAST_VALUE == pScan->cacheLastMode)) &&
+      (FUNCTION_TYPE_LAST != funcType ||
+       (FUNCTION_TYPE_LAST == funcType &&
+        (TSDB_CACHE_MODEL_LAST_ROW == pScan->cacheLastMode ||
+         QUERY_NODE_OPERATOR == nodeType(nodesListGetNode(pFunc->pParameterList, 0)) ||
+         QUERY_NODE_VALUE == nodeType(nodesListGetNode(pFunc->pParameterList, 0)) ||
          COLUMN_TYPE_COLUMN != ((SColumnNode*)nodesListGetNode(pFunc->pParameterList, 0))->colType))) &&
-        FUNCTION_TYPE_SELECT_VALUE != funcType && FUNCTION_TYPE_GROUP_KEY != funcType) {
+      FUNCTION_TYPE_SELECT_VALUE != funcType && FUNCTION_TYPE_GROUP_KEY != funcType) {
     return true;
   }
   return false;
 }
 
 static bool lastRowScanOptCheckFuncList(SLogicNode* pNode, int8_t cacheLastModel, bool* hasOtherFunc) {
-  bool     hasNonPKSelectFunc = false;
-  SNode*   pFunc = NULL;
-  int32_t  lastColNum = 0, selectNonPKColNum = 0;
-  col_id_t lastColId = -1, selectNonPKColId = -1;
+  bool            hasNonPKSelectFunc = false;
+  SNode*          pFunc = NULL;
+  int32_t         lastColNum = 0, selectNonPKColNum = 0;
+  col_id_t        lastColId = -1, selectNonPKColId = -1;
   SScanLogicNode* pScan = (SScanLogicNode*)nodesListGetNode(((SAggLogicNode*)pNode)->node.pChildren, 0);
-  uint32_t needSplitFuncCount = 0;
+  uint32_t        needSplitFuncCount = 0;
   FOREACH(pFunc, ((SAggLogicNode*)pNode)->pAggFuncs) {
     SFunctionNode* pAggFunc = (SFunctionNode*)pFunc;
-    SNode* pParam = nodesListGetNode(pAggFunc->pParameterList, 0);
+    SNode*         pParam = nodesListGetNode(pAggFunc->pParameterList, 0);
     if (FUNCTION_TYPE_LAST == pAggFunc->funcType) {
       if (QUERY_NODE_COLUMN == nodeType(pParam)) {
         SColumnNode* pCol = (SColumnNode*)pParam;
@@ -4124,8 +4161,7 @@ static bool lastRowScanOptCheckFuncList(SLogicNode* pNode, int8_t cacheLastModel
           lastColId = pCol->colId;
           lastColNum++;
         }
-      }
-      else if (QUERY_NODE_VALUE == nodeType(pParam) || QUERY_NODE_OPERATOR == nodeType(pParam)) {
+      } else if (QUERY_NODE_VALUE == nodeType(pParam) || QUERY_NODE_OPERATOR == nodeType(pParam)) {
         needSplitFuncCount++;
         *hasOtherFunc = true;
       }
@@ -4171,7 +4207,8 @@ static bool lastRowScanOptCheckFuncList(SLogicNode* pNode, int8_t cacheLastModel
 }
 
 static bool lastRowScanOptCheckLastCache(SAggLogicNode* pAgg, SScanLogicNode* pScan) {
-  if ((pAgg->hasLastRow == pAgg->hasLast && !pAgg->hasLastRow) || (!pAgg->hasLast && !pAgg->hasLastRow) || NULL != pAgg->pGroupKeys || NULL != pScan->node.pConditions ||
+  if ((pAgg->hasLastRow == pAgg->hasLast && !pAgg->hasLastRow) || (!pAgg->hasLast && !pAgg->hasLastRow) ||
+      NULL != pAgg->pGroupKeys || NULL != pScan->node.pConditions ||
       !hasSuitableCache(pScan->cacheLastMode, pAgg->hasLastRow, pAgg->hasLast) ||
       IS_TSWINDOW_SPECIFIED(pScan->scanRange)) {
     return false;
@@ -4236,7 +4273,8 @@ static EDealRes lastRowScanOptSetColDataType(SNode* pNode, void* pContext) {
   return DEAL_RES_CONTINUE;
 }
 
-static void lastRowScanOptSetLastTargets(SNodeList* pTargets, SNodeList* pLastCols, SNodeList* pLastRowCols, bool erase, int32_t pkBytes) {
+static void lastRowScanOptSetLastTargets(SNodeList* pTargets, SNodeList* pLastCols, SNodeList* pLastRowCols, bool erase,
+                                         int32_t pkBytes) {
   SNode* pTarget = NULL;
   WHERE_EACH(pTarget, pTargets) {
     bool   found = false;
@@ -4260,7 +4298,8 @@ static void lastRowScanOptSetLastTargets(SNodeList* pTargets, SNodeList* pLastCo
   }
 }
 
-static void lastRowScanOptRemoveUslessTargets(SNodeList* pTargets, SNodeList* pList1, SNodeList* pList2, SNodeList* pList3) {
+static void lastRowScanOptRemoveUslessTargets(SNodeList* pTargets, SNodeList* pList1, SNodeList* pList2,
+                                              SNodeList* pList3) {
   SNode* pTarget = NULL;
   WHERE_EACH(pTarget, pTargets) {
     bool   found = false;
@@ -4305,7 +4344,7 @@ static int32_t lastRowScanBuildFuncTypes(SScanLogicNode* pScan, SColumnNode* pCo
       return terrno;
     }
   }
- 
+
   pFuncTypeParam->pCol = taosMemoryCalloc(1, sizeof(SColumn));
   if (NULL == pFuncTypeParam->pCol) {
     taosMemoryFree(pFuncTypeParam);
@@ -4354,7 +4393,7 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic
     FOREACH(pParamNode, pFunc->pParameterList) {
       if (FUNCTION_TYPE_LAST_ROW == funcType || FUNCTION_TYPE_LAST == funcType) {
         int32_t len = tsnprintf(pFunc->functionName, sizeof(pFunc->functionName),
-                              FUNCTION_TYPE_LAST_ROW == funcType ? "_cache_last_row" : "_cache_last");
+                                FUNCTION_TYPE_LAST_ROW == funcType ? "_cache_last_row" : "_cache_last");
         pFunc->functionName[len] = '\0';
         code = fmGetFuncInfo(pFunc, NULL, 0);
         if (TSDB_CODE_SUCCESS != code) {
@@ -4367,9 +4406,9 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic
         if (pAgg->hasLast && pAgg->hasLastRow) {
           if (QUERY_NODE_COLUMN == nodeType(pParamNode)) {
             SNode* pColNode = NULL;
-            int i = 0;
+            int    i = 0;
             FOREACH(pColNode, pScan->pScanCols) {
-              bool isDup = false;
+              bool  isDup = false;
               bool* isDuplicate = taosArrayGet(isDuplicateCol, i);
               if (NULL == isDuplicate) {
                 if (NULL == taosArrayInsert(isDuplicateCol, i, &isDup)) {
@@ -4455,7 +4494,8 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic
                 }
               }
             }
-            if (TSDB_CODE_SUCCESS != code) break;;
+            if (TSDB_CODE_SUCCESS != code) break;
+            ;
             FOREACH(pColNode, pScan->pScanPseudoCols) {
               if (nodesEqualNode(pParamNode, pColNode)) {
                 if (funcType != FUNCTION_TYPE_LAST) {
@@ -4472,7 +4512,8 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic
 
         if (TSDB_CODE_SUCCESS != code) break;
         if (pFunc->hasPk) {
-          code = nodesListMakeAppend(&cxt.pOtherCols, nodesListGetNode(pFunc->pParameterList, LIST_LENGTH(pFunc->pParameterList) - 1));
+          code = nodesListMakeAppend(&cxt.pOtherCols,
+                                     nodesListGetNode(pFunc->pParameterList, LIST_LENGTH(pFunc->pParameterList) - 1));
         }
         if (TSDB_CODE_SUCCESS != code) break;
       } else {
@@ -4583,7 +4624,7 @@ static bool splitCacheLastFuncOptMayBeOptimized(SLogicNode* pNode, void* pCtx) {
 static int32_t splitCacheLastFuncOptCreateAggLogicNode(SAggLogicNode** pNewAgg, SAggLogicNode* pAgg, SNodeList* pFunc,
                                                        SNodeList* pTargets) {
   SAggLogicNode* pNew = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pNew);
+  int32_t        code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pNew);
   if (NULL == pNew) {
     nodesDestroyList(pFunc);
     nodesDestroyList(pTargets);
@@ -4629,7 +4670,7 @@ static int32_t splitCacheLastFuncOptCreateAggLogicNode(SAggLogicNode** pNewAgg,
     return code;
   }
 
-  SNode*  pNode = nodesListGetNode(pNew->node.pChildren, 0);
+  SNode* pNode = nodesListGetNode(pNew->node.pChildren, 0);
   if (QUERY_NODE_LOGIC_PLAN_SCAN == nodeType(pNode)) {
     SScanLogicNode* pScan = (SScanLogicNode*)pNode;
     SNodeList*      pOldScanCols = NULL;
@@ -4708,7 +4749,7 @@ static int32_t splitCacheLastFuncOptModifyAggLogicNode(SAggLogicNode* pAgg) {
 static int32_t splitCacheLastFuncOptCreateMergeLogicNode(SMergeLogicNode** pNew, SAggLogicNode* pAgg1,
                                                          SAggLogicNode* pAgg2) {
   SMergeLogicNode* pMerge = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_MERGE, (SNode**)&pMerge);
+  int32_t          code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_MERGE, (SNode**)&pMerge);
   if (NULL == pMerge) {
     return code;
   }
@@ -4769,7 +4810,8 @@ static int32_t splitCacheLastFuncOptCreateMergeLogicNode(SMergeLogicNode** pNew,
 }
 
 static int32_t splitCacheLastFuncOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
-  SAggLogicNode* pAgg = (SAggLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, splitCacheLastFuncOptMayBeOptimized, NULL);
+  SAggLogicNode* pAgg =
+      (SAggLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, splitCacheLastFuncOptMayBeOptimized, NULL);
 
   if (NULL == pAgg) {
     return TSDB_CODE_SUCCESS;
@@ -4798,12 +4840,12 @@ static int32_t splitCacheLastFuncOptimize(SOptimizeContext* pCxt, SLogicSubplan*
         ERASE_NODE(pAgg->pAggFuncs);
         continue;
       }
-      if (FUNCTION_TYPE_LAST_ROW == funcType ) {
+      if (FUNCTION_TYPE_LAST_ROW == funcType) {
         hasLastRow = true;
       } else if (FUNCTION_TYPE_LAST == funcType) {
         hasLast = true;
       }
-      WHERE_NEXT;    
+      WHERE_NEXT;
     }
     pAgg->hasLast = hasLast;
     pAgg->hasLastRow = hasLastRow;
@@ -4905,8 +4947,8 @@ static EDealRes mergeProjectionsExpr2(SNode** pNode, void* pContext) {
   SProjectLogicNode*        pChildProj = pCxt->pChildProj;
   if (QUERY_NODE_COLUMN == nodeType(*pNode)) {
     SColumnNode* pProjCol = (SColumnNode*)(*pNode);
-    SNode* pProjection;
-    int32_t projIdx = 1;
+    SNode*       pProjection;
+    int32_t      projIdx = 1;
     FOREACH(pProjection, pChildProj->pProjections) {
       if (isColRefExpr(pProjCol, (SExprNode*)pProjection)) {
         SNode* pExpr = NULL;
@@ -4915,7 +4957,7 @@ static EDealRes mergeProjectionsExpr2(SNode** pNode, void* pContext) {
           return DEAL_RES_ERROR;
         }
         snprintf(((SExprNode*)pExpr)->aliasName, sizeof(((SExprNode*)pExpr)->aliasName), "%s",
-            ((SExprNode*)*pNode)->aliasName);
+                 ((SExprNode*)*pNode)->aliasName);
         nodesDestroyNode(*pNode);
         *pNode = pExpr;
         return DEAL_RES_IGNORE_CHILD;
@@ -5023,7 +5065,8 @@ static bool tagScanOptShouldBeOptimized(SLogicNode* pNode, void* pCtx) {
 }
 
 static int32_t tagScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
-  SScanLogicNode* pScanNode = (SScanLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, tagScanOptShouldBeOptimized, NULL);
+  SScanLogicNode* pScanNode =
+      (SScanLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, tagScanOptShouldBeOptimized, NULL);
   if (NULL == pScanNode) {
     return TSDB_CODE_SUCCESS;
   }
@@ -5042,7 +5085,7 @@ static int32_t tagScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubp
   SLogicNode* pAgg = pScanNode->node.pParent;
   if (NULL == pAgg->pParent) {
     SNodeList* pScanTargets = NULL;
-    int32_t code = nodesMakeList(&pScanTargets);
+    int32_t    code = nodesMakeList(&pScanTargets);
     if (TSDB_CODE_SUCCESS != code) {
       return code;
     }
@@ -5055,7 +5098,7 @@ static int32_t tagScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubp
           SNode* pNew = NULL;
           code = nodesCloneNode(pScanTarget, &pNew);
           if (TSDB_CODE_SUCCESS == code) {
-           code = nodesListAppend(pScanTargets, pNew);
+            code = nodesListAppend(pScanTargets, pNew);
           }
           break;
         }
@@ -5092,7 +5135,7 @@ static void swapLimit(SLogicNode* pParent, SLogicNode* pChild) {
 static int32_t pushDownLimitHow(SLogicNode* pNodeWithLimit, SLogicNode* pNodeLimitPushTo, bool* pPushed);
 static int32_t pushDownLimitTo(SLogicNode* pNodeWithLimit, SLogicNode* pNodeLimitPushTo, bool* pPushed) {
   int32_t code = 0;
-  bool cloned;
+  bool    cloned;
   switch (nodeType(pNodeLimitPushTo)) {
     case QUERY_NODE_LOGIC_PLAN_WINDOW: {
       SWindowLogicNode* pWindow = (SWindowLogicNode*)pNodeLimitPushTo;
@@ -5189,7 +5232,8 @@ static int32_t pushDownLimitHow(SLogicNode* pNodeWithLimit, SLogicNode* pNodeLim
       return pushDownLimitTo(pNodeWithLimit, pNodeLimitPushTo, pPushed);
     case QUERY_NODE_LOGIC_PLAN_SORT: {
       SSortLogicNode* pSort = (SSortLogicNode*)pNodeWithLimit;
-      if (sortPriKeyOptIsPriKeyOrderBy(pSort->pSortKeys)) return pushDownLimitTo(pNodeWithLimit, pNodeLimitPushTo, pPushed);
+      if (sortPriKeyOptIsPriKeyOrderBy(pSort->pSortKeys))
+        return pushDownLimitTo(pNodeWithLimit, pNodeLimitPushTo, pPushed);
     }
     default:
       break;
@@ -5206,7 +5250,7 @@ static int32_t pushDownLimitOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLog
 
   SLogicNode* pChild = (SLogicNode*)nodesListGetNode(pNode->pChildren, 0);
   nodesDestroyNode(pChild->pLimit);
-  bool pushed = false;
+  bool    pushed = false;
   int32_t code = pushDownLimitHow(pNode, pChild, &pushed);
   if (TSDB_CODE_SUCCESS != code) {
     return code;
@@ -5346,7 +5390,7 @@ static bool tbCntScanOptIsEligibleConds(STbCntScanOptInfo* pInfo, SNode* pCondit
 static bool tbCntScanOptIsEligibleScan(STbCntScanOptInfo* pInfo) {
   if (0 != strcmp(pInfo->pScan->tableName.dbname, TSDB_INFORMATION_SCHEMA_DB) ||
       0 != strcmp(pInfo->pScan->tableName.tname, TSDB_INS_TABLE_TABLES) || NULL != pInfo->pScan->pGroupTags ||
-      0 != strcmp(pInfo->pScan->tableName.tname, TSDB_INS_TABLE_USAGE)) {
+      0 != strcmp(pInfo->pScan->tableName.tname, TSDB_INS_DISK_USAGE)) {
     return false;
   }
   if (1 == pInfo->pScan->pVgroupList->numOfVgroups && MNODE_HANDLE == pInfo->pScan->pVgroupList->vgroups[0].vgId) {
@@ -5368,7 +5412,7 @@ static bool tbCntScanOptShouldBeOptimized(SLogicNode* pNode, STbCntScanOptInfo*
 
 static int32_t tbCntScanOptCreateTableCountFunc(SNode** ppNode) {
   SFunctionNode* pFunc = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc);
+  int32_t        code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc);
   if (NULL == pFunc) {
     return code;
   }
@@ -5391,7 +5435,7 @@ static int32_t tbCntScanOptRewriteScan(STbCntScanOptInfo* pInfo) {
   NODES_DESTORY_LIST(pInfo->pScan->pScanCols);
   NODES_DESTORY_NODE(pInfo->pScan->node.pConditions);
   NODES_DESTORY_LIST(pInfo->pScan->pScanPseudoCols);
-  SNode* pNew = NULL;
+  SNode*  pNew = NULL;
   int32_t code = tbCntScanOptCreateTableCountFunc(&pNew);
   if (TSDB_CODE_SUCCESS == code) {
     code = nodesListMakeStrictAppend(&pInfo->pScan->pScanPseudoCols, pNew);
@@ -5400,7 +5444,7 @@ static int32_t tbCntScanOptRewriteScan(STbCntScanOptInfo* pInfo) {
     code = createColumnByRewriteExpr(nodesListGetNode(pInfo->pScan->pScanPseudoCols, 0), &pInfo->pScan->node.pTargets);
   }
   SNode* pGroupKey = NULL;
-  if (TSDB_CODE_SUCCESS  == code) {
+  if (TSDB_CODE_SUCCESS == code) {
     FOREACH(pGroupKey, pInfo->pAgg->pGroupKeys) {
       SNode* pGroupCol = nodesListGetNode(((SGroupingSetNode*)pGroupKey)->pParameterList, 0);
       SNode* pNew = NULL;
@@ -5432,7 +5476,7 @@ static int32_t tbCntScanOptRewriteScan(STbCntScanOptInfo* pInfo) {
 
 static int32_t tbCntScanOptCreateSumFunc(SFunctionNode* pCntFunc, SNode* pParam, SNode** pOutput) {
   SFunctionNode* pFunc = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc);
+  int32_t        code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc);
   if (NULL == pFunc) {
     return code;
   }
@@ -5517,7 +5561,7 @@ static bool sortNonPriKeyShouldOptimize(SLogicNode* pNode, void* pInfo) {
 
 static int32_t sortNonPriKeyOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
   SNodeList* pNodeList = NULL;
-  int32_t code = nodesMakeList(&pNodeList);
+  int32_t    code = nodesMakeList(&pNodeList);
   if (TSDB_CODE_SUCCESS != code) {
     return code;
   }
@@ -5549,12 +5593,13 @@ static bool hashJoinOptShouldBeOptimized(SLogicNode* pNode, void* pCtx) {
   if (pJoin->joinAlgo != JOIN_ALGO_UNKNOWN) {
     return res;
   }
-  
+
   if (!pJoin->hashJoinHint) {
     goto _return;
   }
 
-  if ((JOIN_STYPE_NONE != pJoin->subType && JOIN_STYPE_OUTER != pJoin->subType) || JOIN_TYPE_FULL == pJoin->joinType || pNode->pChildren->length != 2 ) {
+  if ((JOIN_STYPE_NONE != pJoin->subType && JOIN_STYPE_OUTER != pJoin->subType) || JOIN_TYPE_FULL == pJoin->joinType ||
+      pNode->pChildren->length != 2) {
     goto _return;
   }
 
@@ -5564,8 +5609,8 @@ _return:
 
   if (!res && DATA_ORDER_LEVEL_NONE == pJoin->node.requireDataOrder) {
     pJoin->node.requireDataOrder = DATA_ORDER_LEVEL_GLOBAL;
-    int32_t *pCode = pCtx;
-    int32_t code = adjustLogicNodeDataRequirement(pNode, pJoin->node.requireDataOrder);
+    int32_t* pCode = pCtx;
+    int32_t  code = adjustLogicNodeDataRequirement(pNode, pJoin->node.requireDataOrder);
     if (TSDB_CODE_SUCCESS != code) {
       *pCode = code;
     }
@@ -5574,11 +5619,11 @@ _return:
   return res;
 }
 
-static int32_t hashJoinOptSplitPrimFromLogicCond(SNode **pCondition, SNode **pPrimaryKeyCond) {
-  SLogicConditionNode *pLogicCond = (SLogicConditionNode *)(*pCondition);
-  int32_t code = TSDB_CODE_SUCCESS;
-  SNodeList *pPrimaryKeyConds = NULL;
-  SNode     *pCond = NULL;
+static int32_t hashJoinOptSplitPrimFromLogicCond(SNode** pCondition, SNode** pPrimaryKeyCond) {
+  SLogicConditionNode* pLogicCond = (SLogicConditionNode*)(*pCondition);
+  int32_t              code = TSDB_CODE_SUCCESS;
+  SNodeList*           pPrimaryKeyConds = NULL;
+  SNode*               pCond = NULL;
   WHERE_EACH(pCond, pLogicCond->pParameterList) {
     bool result = false;
     code = filterIsMultiTableColsCond(pCond, &result);
@@ -5599,11 +5644,11 @@ static int32_t hashJoinOptSplitPrimFromLogicCond(SNode **pCondition, SNode **pPr
     if (TSDB_CODE_SUCCESS != code) {
       break;
     }
-    
+
     ERASE_NODE(pLogicCond->pParameterList);
   }
 
-  SNode *pTempPrimaryKeyCond = NULL;
+  SNode* pTempPrimaryKeyCond = NULL;
   if (TSDB_CODE_SUCCESS == code && pPrimaryKeyConds) {
     code = nodesMergeConds(&pTempPrimaryKeyCond, &pPrimaryKeyConds);
   }
@@ -5623,18 +5668,17 @@ static int32_t hashJoinOptSplitPrimFromLogicCond(SNode **pCondition, SNode **pPr
   return code;
 }
 
-
-int32_t hashJoinOptSplitPrimCond(SNode **pCondition, SNode **pPrimaryKeyCond) {
+int32_t hashJoinOptSplitPrimCond(SNode** pCondition, SNode** pPrimaryKeyCond) {
   if (QUERY_NODE_LOGIC_CONDITION == nodeType(*pCondition)) {
-    if (LOGIC_COND_TYPE_AND == ((SLogicConditionNode *)*pCondition)->condType) {
+    if (LOGIC_COND_TYPE_AND == ((SLogicConditionNode*)*pCondition)->condType) {
       return hashJoinOptSplitPrimFromLogicCond(pCondition, pPrimaryKeyCond);
     }
 
     return TSDB_CODE_SUCCESS;
   }
 
-  bool needOutput = false;
-  bool result = false;
+  bool    needOutput = false;
+  bool    result = false;
   int32_t code = filterIsMultiTableColsCond(*pCondition, &result);
   if (TSDB_CODE_SUCCESS != code) {
     return code;
@@ -5652,10 +5696,9 @@ int32_t hashJoinOptSplitPrimCond(SNode **pCondition, SNode **pPrimaryKeyCond) {
   return TSDB_CODE_SUCCESS;
 }
 
-
 static int32_t hashJoinOptRewriteJoin(SOptimizeContext* pCxt, SLogicNode* pNode, SLogicSubplan* pLogicSubplan) {
   SJoinLogicNode* pJoin = (SJoinLogicNode*)pNode;
-  int32_t code = TSDB_CODE_SUCCESS;
+  int32_t         code = TSDB_CODE_SUCCESS;
 
   pJoin->joinAlgo = JOIN_ALGO_HASH;
 
@@ -5718,7 +5761,7 @@ static int32_t hashJoinOptRewriteJoin(SOptimizeContext* pCxt, SLogicNode* pNode,
       pJoin->timeRange.skey = TMAX(ltimeRange.skey, rtimeRange.skey);
       pJoin->timeRange.ekey = TMIN(ltimeRange.ekey, rtimeRange.ekey);
     }
-#else 
+#else
     SNode* pPrimaryKeyCond = NULL;
     code = hashJoinOptSplitPrimCond(&pJoin->pColOnCond, &pPrimaryKeyCond);
     if (TSDB_CODE_SUCCESS != code) {
@@ -5788,14 +5831,14 @@ static int32_t hashJoinOptRewriteJoin(SOptimizeContext* pCxt, SLogicNode* pNode,
   pJoin->timeRangeTarget = 0;
 
   if (!TSWINDOW_IS_EQUAL(pJoin->timeRange, TSWINDOW_INITIALIZER)) {
-    SNode* pChild = NULL;
+    SNode*  pChild = NULL;
     int32_t timeRangeTarget = 1;
     FOREACH(pChild, pJoin->node.pChildren) {
       if (QUERY_NODE_LOGIC_PLAN_SCAN != nodeType(pChild)) {
         timeRangeTarget++;
         continue;
       }
-    
+
       SScanLogicNode* pScan = (SScanLogicNode*)pChild;
       if (TSWINDOW_IS_EQUAL(pScan->scanRange, pJoin->timeRange)) {
         timeRangeTarget++;
@@ -5831,7 +5874,7 @@ static int32_t hashJoinOptRewriteJoin(SOptimizeContext* pCxt, SLogicNode* pNode,
         timeRangeTarget++;
         continue;
       }
-      
+
       pJoin->timeRangeTarget += timeRangeTarget;
       timeRangeTarget++;
     }
@@ -5839,13 +5882,12 @@ static int32_t hashJoinOptRewriteJoin(SOptimizeContext* pCxt, SLogicNode* pNode,
 
   pCxt->optimized = true;
   OPTIMIZE_FLAG_SET_MASK(pJoin->node.optimizedFlag, OPTIMIZE_FLAG_STB_JOIN);
-  
+
   return TSDB_CODE_SUCCESS;
 }
 
-
 static int32_t hashJoinOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
-  int32_t code = 0;
+  int32_t     code = 0;
   SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, hashJoinOptShouldBeOptimized, &code);
   if (TSDB_CODE_SUCCESS != code) {
     return code;
@@ -5858,7 +5900,8 @@ static int32_t hashJoinOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub
 }
 
 static bool stbJoinOptShouldBeOptimized(SLogicNode* pNode, void* pCtx) {
-  if (QUERY_NODE_LOGIC_PLAN_JOIN != nodeType(pNode) || OPTIMIZE_FLAG_TEST_MASK(pNode->optimizedFlag, OPTIMIZE_FLAG_STB_JOIN)) {
+  if (QUERY_NODE_LOGIC_PLAN_JOIN != nodeType(pNode) ||
+      OPTIMIZE_FLAG_TEST_MASK(pNode->optimizedFlag, OPTIMIZE_FLAG_STB_JOIN)) {
     return false;
   }
 
@@ -5867,8 +5910,8 @@ static bool stbJoinOptShouldBeOptimized(SLogicNode* pNode, void* pCtx) {
     pJoin->joinAlgo = JOIN_ALGO_MERGE;
   }
 
-  if (JOIN_STYPE_NONE != pJoin->subType || pJoin->isSingleTableJoin || NULL == pJoin->pTagEqCond || pNode->pChildren->length != 2 
-      || pJoin->isLowLevelJoin) {
+  if (JOIN_STYPE_NONE != pJoin->subType || pJoin->isSingleTableJoin || NULL == pJoin->pTagEqCond ||
+      pNode->pChildren->length != 2 || pJoin->isLowLevelJoin) {
     return false;
   }
 
@@ -5883,7 +5926,7 @@ static bool stbJoinOptShouldBeOptimized(SLogicNode* pNode, void* pCtx) {
 
 int32_t stbJoinOptAddFuncToScanNode(char* funcName, SScanLogicNode* pScan) {
   SFunctionNode* pUidFunc = NULL;
-  int32_t code = createFunction(funcName, NULL, &pUidFunc);
+  int32_t        code = createFunction(funcName, NULL, &pUidFunc);
   if (TSDB_CODE_SUCCESS != code) {
     return code;
   }
@@ -5906,8 +5949,8 @@ int32_t stbJoinOptRewriteToTagScan(SLogicNode* pJoin, SNode* pNode) {
   pScan->node.resultDataOrder = DATA_ORDER_LEVEL_NONE;
 
   SNodeList* pTags = NULL;
-  int32_t code = nodesMakeList(&pTags);
-  if (TSDB_CODE_SUCCESS  == code) {
+  int32_t    code = nodesMakeList(&pTags);
+  if (TSDB_CODE_SUCCESS == code) {
     code = nodesCollectColumnsFromNode(pJoinNode->pTagEqCond, NULL, COLLECT_COL_TYPE_TAG, &pTags);
   }
   if (TSDB_CODE_SUCCESS == code) {
@@ -5922,7 +5965,8 @@ int32_t stbJoinOptRewriteToTagScan(SLogicNode* pJoin, SNode* pNode) {
       SColumnNode* pTargetCol = (SColumnNode*)pTarget;
       FOREACH(pTag, pTags) {
         SColumnNode* pTagCol = (SColumnNode*)pTag;
-        if (0 == strcasecmp(pTargetCol->node.aliasName, pTagCol->colName) && 0 == strcasecmp(pTargetCol->tableAlias, pTagCol->tableAlias)) {
+        if (0 == strcasecmp(pTargetCol->node.aliasName, pTagCol->colName) &&
+            0 == strcasecmp(pTargetCol->tableAlias, pTagCol->tableAlias)) {
           found = true;
           break;
         }
@@ -5954,12 +5998,12 @@ int32_t stbJoinOptRewriteToTagScan(SLogicNode* pJoin, SNode* pNode) {
 
 static int32_t stbJoinOptCreateTagScanNode(SLogicNode* pJoin, SNodeList** ppList) {
   SNodeList* pList = NULL;
-  int32_t code = nodesCloneList(pJoin->pChildren, &pList);
+  int32_t    code = nodesCloneList(pJoin->pChildren, &pList);
   if (NULL == pList) {
     return code;
   }
 
-  SNode*  pNode = NULL;
+  SNode* pNode = NULL;
   FOREACH(pNode, pList) {
     code = stbJoinOptRewriteToTagScan(pJoin, pNode);
     if (code) {
@@ -5979,7 +6023,7 @@ static int32_t stbJoinOptCreateTagScanNode(SLogicNode* pJoin, SNodeList** ppList
 static int32_t stbJoinOptCreateTagHashJoinNode(SLogicNode* pOrig, SNodeList* pChildren, SLogicNode** ppLogic) {
   SJoinLogicNode* pOrigJoin = (SJoinLogicNode*)pOrig;
   SJoinLogicNode* pJoin = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_JOIN, (SNode**)&pJoin);
+  int32_t         code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_JOIN, (SNode**)&pJoin);
   if (NULL == pJoin) {
     return code;
   }
@@ -5994,7 +6038,7 @@ static int32_t stbJoinOptCreateTagHashJoinNode(SLogicNode* pOrig, SNodeList* pCh
   pJoin->node.requireDataOrder = DATA_ORDER_LEVEL_NONE;
   pJoin->node.resultDataOrder = DATA_ORDER_LEVEL_NONE;
   code = nodesCloneNode(pOrigJoin->pTagEqCond, &pJoin->pTagEqCond);
-  if (TSDB_CODE_SUCCESS  != code) {
+  if (TSDB_CODE_SUCCESS != code) {
     nodesDestroyNode((SNode*)pJoin);
     return code;
   }
@@ -6003,7 +6047,7 @@ static int32_t stbJoinOptCreateTagHashJoinNode(SLogicNode* pOrig, SNodeList* pCh
     nodesDestroyNode((SNode*)pJoin);
     return code;
   }
-  
+
   pJoin->node.pChildren = pChildren;
 
   SNode* pNode = NULL;
@@ -6039,7 +6083,7 @@ static int32_t stbJoinOptCreateTagHashJoinNode(SLogicNode* pOrig, SNodeList* pCh
   nodesDestroyList(pCols);
 
   if (TSDB_CODE_SUCCESS == code) {
-    *ppLogic = (SLogicNode*)pJoin;    
+    *ppLogic = (SLogicNode*)pJoin;
     OPTIMIZE_FLAG_SET_MASK(pJoin->node.optimizedFlag, OPTIMIZE_FLAG_STB_JOIN);
   } else {
     nodesDestroyNode((SNode*)pJoin);
@@ -6050,7 +6094,7 @@ static int32_t stbJoinOptCreateTagHashJoinNode(SLogicNode* pOrig, SNodeList* pCh
 
 static int32_t stbJoinOptCreateTableScanNodes(SLogicNode* pJoin, SNodeList** ppList, bool* srcScan) {
   SNodeList* pList = NULL;
-  int32_t code = nodesCloneList(pJoin->pChildren, &pList);
+  int32_t    code = nodesCloneList(pJoin->pChildren, &pList);
   if (NULL == pList) {
     return code;
   }
@@ -6059,16 +6103,16 @@ static int32_t stbJoinOptCreateTableScanNodes(SLogicNode* pJoin, SNodeList** ppL
   SNode*  pNode = NULL;
   FOREACH(pNode, pList) {
     SScanLogicNode* pScan = (SScanLogicNode*)pNode;
-    //code = stbJoinOptAddFuncToScanNode("_tbuid", pScan);
-    //if (code) {
-    //  break;
-    //}
+    // code = stbJoinOptAddFuncToScanNode("_tbuid", pScan);
+    // if (code) {
+    //   break;
+    // }
 
     nodesDestroyNode(pScan->pTagCond);
     pScan->pTagCond = NULL;
     nodesDestroyNode(pScan->pTagIndexCond);
     pScan->pTagIndexCond = NULL;
-    
+
     pScan->node.dynamicOp = true;
     *(srcScan + i++) = pScan->pVgroupList->numOfVgroups <= 1;
 
@@ -6097,7 +6141,7 @@ static int32_t stbJoinOptCreateGroupCacheNode(SLogicNode* pRoot, SNodeList* pChi
   code = nodesMakeList(&pGrpCache->node.pTargets);
   if (TSDB_CODE_SUCCESS == code) {
     SScanLogicNode* pScan = (SScanLogicNode*)nodesListGetNode(pChildren, 0);
-    SNodeList* pNewList = NULL;
+    SNodeList*      pNewList = NULL;
     code = nodesCloneList(pScan->node.pTargets, &pNewList);
     if (TSDB_CODE_SUCCESS == code) {
       code = nodesListStrictAppendList(pGrpCache->node.pTargets, pNewList);
@@ -6143,15 +6187,15 @@ static void stbJoinOptRemoveTagEqCond(SJoinLogicNode* pJoin) {
   }
   if (QUERY_NODE_LOGIC_CONDITION == nodeType(pJoin->pFullOnCond)) {
     SLogicConditionNode* pLogic = (SLogicConditionNode*)pJoin->pFullOnCond;
-    SNode* pNode = NULL;
+    SNode*               pNode = NULL;
     FOREACH(pNode, pLogic->pParameterList) {
       if (nodesEqualNode(pNode, pJoin->pTagEqCond)) {
         ERASE_NODE(pLogic->pParameterList);
         break;
       } else if (QUERY_NODE_LOGIC_CONDITION == nodeType(pJoin->pTagEqCond)) {
         SLogicConditionNode* pTags = (SLogicConditionNode*)pJoin->pTagEqCond;
-        SNode* pTag = NULL;
-        bool found = false;
+        SNode*               pTag = NULL;
+        bool                 found = false;
         FOREACH(pTag, pTags->pParameterList) {
           if (nodesEqualNode(pTag, pNode)) {
             found = true;
@@ -6173,7 +6217,7 @@ static void stbJoinOptRemoveTagEqCond(SJoinLogicNode* pJoin) {
 static int32_t stbJoinOptCreateMergeJoinNode(SLogicNode* pOrig, SLogicNode* pChild, SLogicNode** ppLogic) {
   SJoinLogicNode* pOrigJoin = (SJoinLogicNode*)pOrig;
   SJoinLogicNode* pJoin = NULL;
-  int32_t code = nodesCloneNode((SNode*)pOrig, (SNode**)&pJoin);
+  int32_t         code = nodesCloneNode((SNode*)pOrig, (SNode**)&pJoin);
   if (NULL == pJoin) {
     return code;
   }
@@ -6335,9 +6379,10 @@ static bool grpJoinOptShouldBeOptimized(SLogicNode* pNode, void* pCtx) {
   return true;
 }
 
-static int32_t grpJoinOptCreatePartitionNode(SLogicNode* pParent, SLogicNode* pChild, bool leftChild, SLogicNode** pNew) {
+static int32_t grpJoinOptCreatePartitionNode(SLogicNode* pParent, SLogicNode* pChild, bool leftChild,
+                                             SLogicNode** pNew) {
   SPartitionLogicNode* pPartition = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PARTITION, (SNode**)&pPartition);
+  int32_t              code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PARTITION, (SNode**)&pPartition);
   if (NULL == pPartition) {
     return code;
   }
@@ -6356,12 +6401,12 @@ static int32_t grpJoinOptCreatePartitionNode(SLogicNode* pParent, SLogicNode* pC
   SJoinLogicNode* pJoin = (SJoinLogicNode*)pParent;
   pPartition->pPartitionKeys = NULL;
   code = nodesCloneList(leftChild ? pJoin->pLeftEqNodes : pJoin->pRightEqNodes, &pPartition->pPartitionKeys);
-  if (TSDB_CODE_SUCCESS  != code) {
+  if (TSDB_CODE_SUCCESS != code) {
     nodesDestroyNode((SNode*)pPartition);
     return code;
   }
-  code = nodesListMakeStrictAppend(&pPartition->node.pChildren, (SNode *)pChild);
-  if (TSDB_CODE_SUCCESS  == code) {
+  code = nodesListMakeStrictAppend(&pPartition->node.pChildren, (SNode*)pChild);
+  if (TSDB_CODE_SUCCESS == code) {
     *pNew = (SLogicNode*)pPartition;
     pChild->pParent = (SLogicNode*)pPartition;
     pPartition->node.pParent = pParent;
@@ -6373,9 +6418,9 @@ static int32_t grpJoinOptCreatePartitionNode(SLogicNode* pParent, SLogicNode* pC
 
 static int32_t grpJoinOptInsertPartitionNode(SLogicNode* pJoin) {
   int32_t code = TSDB_CODE_SUCCESS;
-  SNode* pNode = NULL;
-  SNode* pNew = NULL;
-  bool leftChild = true;
+  SNode*  pNode = NULL;
+  SNode*  pNew = NULL;
+  bool    leftChild = true;
   FOREACH(pNode, pJoin->pChildren) {
     code = grpJoinOptCreatePartitionNode(pJoin, (SLogicNode*)pNode, leftChild, (SLogicNode**)&pNew);
     if (code) {
@@ -6389,10 +6434,10 @@ static int32_t grpJoinOptInsertPartitionNode(SLogicNode* pJoin) {
 }
 
 static int32_t grpJoinOptPartByTags(SLogicNode* pNode) {
-  int32_t code = TSDB_CODE_SUCCESS;
-  SNode* pChild = NULL;
-  SNode* pNew = NULL;
-  bool leftChild = true;
+  int32_t         code = TSDB_CODE_SUCCESS;
+  SNode*          pChild = NULL;
+  SNode*          pNew = NULL;
+  bool            leftChild = true;
   SJoinLogicNode* pJoin = (SJoinLogicNode*)pNode;
   FOREACH(pChild, pNode->pChildren) {
     if (QUERY_NODE_LOGIC_PLAN_SCAN != nodeType(pChild)) {
@@ -6400,7 +6445,7 @@ static int32_t grpJoinOptPartByTags(SLogicNode* pNode) {
     }
 
     SScanLogicNode* pScan = (SScanLogicNode*)pChild;
-    SNodeList* pNewList = NULL;
+    SNodeList*      pNewList = NULL;
     code = nodesCloneList(pJoin->pLeftEqNodes, &pNewList);
     if (TSDB_CODE_SUCCESS == code) {
       if (leftChild) {
@@ -6413,7 +6458,7 @@ static int32_t grpJoinOptPartByTags(SLogicNode* pNode) {
     if (TSDB_CODE_SUCCESS != code) {
       break;
     }
-    
+
     pScan->groupSort = true;
     pScan->groupOrderScan = true;
   }
@@ -6423,7 +6468,9 @@ static int32_t grpJoinOptPartByTags(SLogicNode* pNode) {
 
 static int32_t grpJoinOptRewriteGroupJoin(SOptimizeContext* pCxt, SLogicNode* pNode, SLogicSubplan* pLogicSubplan) {
   SJoinLogicNode* pJoin = (SJoinLogicNode*)pNode;
-  int32_t code = (pJoin->allEqTags && !pJoin->hasSubQuery && !pJoin->batchScanHint) ? grpJoinOptPartByTags(pNode) : grpJoinOptInsertPartitionNode(pNode);
+  int32_t         code = (pJoin->allEqTags && !pJoin->hasSubQuery && !pJoin->batchScanHint)
+                             ? grpJoinOptPartByTags(pNode)
+                             : grpJoinOptInsertPartitionNode(pNode);
   if (TSDB_CODE_SUCCESS == code) {
     pJoin->grpJoin = true;
     pCxt->optimized = true;
@@ -6431,7 +6478,6 @@ static int32_t grpJoinOptRewriteGroupJoin(SOptimizeContext* pCxt, SLogicNode* pN
   return code;
 }
 
-
 static int32_t groupJoinOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) {
   SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, grpJoinOptShouldBeOptimized, NULL);
   if (NULL == pNode) {
@@ -6460,20 +6506,20 @@ static int32_t partColOptCreateSort(SPartitionLogicNode* pPartition, SSortLogicN
     FOREACH(node, pPartition->pPartitionKeys) {
       SOrderByExprNode* pOrder = NULL;
       code = nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR, (SNode**)&pOrder);
-      if (TSDB_CODE_SUCCESS  != code) {
+      if (TSDB_CODE_SUCCESS != code) {
         break;
       }
       if (QUERY_NODE_COLUMN == nodeType(node) && ((SColumnNode*)node)->colId == pPartition->pkTsColId &&
           ((SColumnNode*)node)->tableId == pPartition->pkTsColTbId)
         alreadyPartByPKTs = true;
       code = nodesListMakeStrictAppend(&pSort->pSortKeys, (SNode*)pOrder);
-      if (TSDB_CODE_SUCCESS  == code) {
+      if (TSDB_CODE_SUCCESS == code) {
         pOrder->order = ORDER_ASC;
         pOrder->pExpr = NULL;
         pOrder->nullOrder = NULL_ORDER_FIRST;
         code = nodesCloneNode(node, &pOrder->pExpr);
       }
-      if (TSDB_CODE_SUCCESS  != code) {
+      if (TSDB_CODE_SUCCESS != code) {
         break;
       }
     }
@@ -6488,7 +6534,7 @@ static int32_t partColOptCreateSort(SPartitionLogicNode* pPartition, SSortLogicN
       if (pOrder) {
         pSort->excludePkCol = true;
         code = nodesListMakeStrictAppend(&pSort->pSortKeys, (SNode*)pOrder);
-        if (TSDB_CODE_SUCCESS  == code) {
+        if (TSDB_CODE_SUCCESS == code) {
           pOrder->order = ORDER_ASC;
           pOrder->pExpr = 0;
           FOREACH(node, pPartition->node.pTargets) {
@@ -6725,8 +6771,8 @@ static bool tsmaOptCheckValidInterval(int64_t tsmaInterval, int8_t unit, const S
 
 static int32_t tsmaOptCheckValidFuncs(const SArray* pTsmaFuncs, const SNodeList* pQueryFuncs, SArray* pTsmaScanCols,
                                       bool* pIsValid) {
-  SNode*  pNode;
-  bool    failed = false, found = false;
+  SNode* pNode;
+  bool   failed = false, found = false;
 
   taosArrayClear(pTsmaScanCols);
   FOREACH(pNode, pQueryFuncs) {
@@ -6768,7 +6814,7 @@ static int32_t tsmaOptCheckValidFuncs(const SArray* pTsmaFuncs, const SNodeList*
 
 typedef struct STsmaOptTagCheckCtx {
   const STableTSMAInfo* pTsma;
-  bool  ok;
+  bool                  ok;
 } STsmaOptTagCheckCtx;
 
 static EDealRes tsmaOptTagCheck(SNode* pNode, void* pContext) {
@@ -6794,7 +6840,7 @@ static EDealRes tsmaOptTagCheck(SNode* pNode, void* pContext) {
 
 static bool tsmaOptCheckTags(STSMAOptCtx* pCtx, const STableTSMAInfo* pTsma) {
   const SScanLogicNode* pScan = pCtx->pScan;
-  STsmaOptTagCheckCtx ctx = {.pTsma = pTsma, .ok = true};
+  STsmaOptTagCheckCtx   ctx = {.pTsma = pTsma, .ok = true};
   nodesWalkExpr(pScan->pTagCond, tsmaOptTagCheck, &ctx);
   if (!ctx.ok) return false;
   nodesWalkExprs(pScan->pScanPseudoCols, tsmaOptTagCheck, &ctx);
@@ -6806,8 +6852,8 @@ static bool tsmaOptCheckTags(STSMAOptCtx* pCtx, const STableTSMAInfo* pTsma) {
 static int32_t tsmaOptFilterTsmas(STSMAOptCtx* pTsmaOptCtx) {
   STSMAOptUsefulTsma usefulTsma = {
       .pTsma = NULL, .scanRange = {.skey = TSKEY_MIN, .ekey = TSKEY_MAX}, .precision = pTsmaOptCtx->precision};
-  SArray*            pTsmaScanCols = NULL;
-  int32_t            code = 0;
+  SArray* pTsmaScanCols = NULL;
+  int32_t code = 0;
 
   for (int32_t i = 0; i < pTsmaOptCtx->pTsmas->size; ++i) {
     if (!pTsmaScanCols) {
@@ -6816,11 +6862,13 @@ static int32_t tsmaOptFilterTsmas(STSMAOptCtx* pTsmaOptCtx) {
     }
     if (pTsmaOptCtx->pScan->tableType == TSDB_CHILD_TABLE || pTsmaOptCtx->pScan->tableType == TSDB_NORMAL_TABLE) {
       const STsmaTargetTbInfo* ptbInfo = taosArrayGet(pTsmaOptCtx->pScan->pTsmaTargetTbInfo, i);
-      if (ptbInfo->uid == 0) continue; // tsma res table meta not found, skip this tsma, this is possible when there is no data in this ctb
+      if (ptbInfo->uid == 0)
+        continue;  // tsma res table meta not found, skip this tsma, this is possible when there is no data in this ctb
     }
 
     STableTSMAInfo* pTsma = taosArrayGetP(pTsmaOptCtx->pTsmas, i);
-    if (!pTsma->fillHistoryFinished || tsMaxTsmaCalcDelay * 1000 < (pTsma->rspTs - pTsma->reqTs) + pTsma->delayDuration) {
+    if (!pTsma->fillHistoryFinished ||
+        tsMaxTsmaCalcDelay * 1000 < (pTsma->rspTs - pTsma->reqTs) + pTsma->delayDuration) {
       continue;
     }
     // filter with interval
@@ -6828,9 +6876,9 @@ static int32_t tsmaOptFilterTsmas(STSMAOptCtx* pTsmaOptCtx) {
       continue;
     }
     // filter with funcs, note that tsma funcs has been sorted by funcId and ColId
-    bool valid = false;
+    bool    valid = false;
     int32_t code = tsmaOptCheckValidFuncs(pTsma->pFuncs, pTsmaOptCtx->pAggFuncs, pTsmaScanCols, &valid);
-    if (TSDB_CODE_SUCCESS != code)  break;
+    if (TSDB_CODE_SUCCESS != code) break;
     if (!valid) continue;
 
     if (!tsmaOptCheckTags(pTsmaOptCtx, pTsma)) continue;
@@ -6849,18 +6897,18 @@ static int32_t tsmaOptFilterTsmas(STSMAOptCtx* pTsmaOptCtx) {
 }
 
 static int32_t tsmaInfoCompWithIntervalDesc(const void* pLeft, const void* pRight) {
-  const int64_t factors[3] = {NANOSECOND_PER_MSEC, NANOSECOND_PER_USEC, 1};
+  const int64_t             factors[3] = {NANOSECOND_PER_MSEC, NANOSECOND_PER_USEC, 1};
   const STSMAOptUsefulTsma *p = pLeft, *q = pRight;
   int64_t                   pInterval = p->pTsma->interval, qInterval = q->pTsma->interval;
   int8_t                    pUnit = p->pTsma->unit, qUnit = q->pTsma->unit;
   if (TIME_UNIT_MONTH == pUnit) {
     pInterval = pInterval * 31 * (NANOSECOND_PER_DAY / factors[p->precision]);
-  } else if (TIME_UNIT_YEAR == pUnit){
+  } else if (TIME_UNIT_YEAR == pUnit) {
     pInterval = pInterval * 365 * (NANOSECOND_PER_DAY / factors[p->precision]);
   }
   if (TIME_UNIT_MONTH == qUnit) {
     qInterval = qInterval * 31 * (NANOSECOND_PER_DAY / factors[q->precision]);
-  } else if (TIME_UNIT_YEAR == qUnit){
+  } else if (TIME_UNIT_YEAR == qUnit) {
     qInterval = qInterval * 365 * (NANOSECOND_PER_DAY / factors[q->precision]);
   }
 
@@ -6947,21 +6995,19 @@ static int32_t tsmaOptSplitWindows(STSMAOptCtx* pTsmaOptCtx, const STimeWindow*
     STSMAOptUsefulTsma usefulTsma = {.pTsma = pTsmaFound ? pTsmaFound->pTsma : NULL,
                                      .scanRange = scanRange,
                                      .pTsmaScanCols = pTsmaFound ? pTsmaFound->pTsmaScanCols : NULL};
-    if (NULL == taosArrayPush(pTsmaOptCtx->pUsedTsmas, &usefulTsma))
-      return terrno;
+    if (NULL == taosArrayPush(pTsmaOptCtx->pUsedTsmas, &usefulTsma)) return terrno;
   }
 
   // the main tsma
-  if (endOfSkeyFirstWin < startOfEkeyFirstWin || (endOfSkeyFirstWin == startOfEkeyFirstWin && (isSkeyAlignedWithTsma || isEkeyAlignedWithTsma))) {
-    scanRange.ekey =
-        TMIN(pScanRange->ekey, isEkeyAlignedWithTsma ? pScanRange->ekey : startOfEkeyFirstWin - 1);
+  if (endOfSkeyFirstWin < startOfEkeyFirstWin ||
+      (endOfSkeyFirstWin == startOfEkeyFirstWin && (isSkeyAlignedWithTsma || isEkeyAlignedWithTsma))) {
+    scanRange.ekey = TMIN(pScanRange->ekey, isEkeyAlignedWithTsma ? pScanRange->ekey : startOfEkeyFirstWin - 1);
     if (!isSkeyAlignedWithTsma) {
       scanRange.skey = endOfSkeyFirstWin;
     }
     STSMAOptUsefulTsma usefulTsma = {
         .pTsma = pTsma, .scanRange = scanRange, .pTsmaScanCols = pUsefulTsma->pTsmaScanCols};
-    if (NULL == taosArrayPush(pTsmaOptCtx->pUsedTsmas, &usefulTsma))
-      return terrno;
+    if (NULL == taosArrayPush(pTsmaOptCtx->pUsedTsmas, &usefulTsma)) return terrno;
   }
 
   // add tail tsma if possible
@@ -6974,8 +7020,7 @@ static int32_t tsmaOptSplitWindows(STSMAOptCtx* pTsmaOptCtx, const STimeWindow*
     STSMAOptUsefulTsma usefulTsma = {.pTsma = pTsmaFound ? pTsmaFound->pTsma : NULL,
                                      .scanRange = scanRange,
                                      .pTsmaScanCols = pTsmaFound ? pTsmaFound->pTsmaScanCols : NULL};
-    if (NULL == taosArrayPush(pTsmaOptCtx->pUsedTsmas, &usefulTsma))
-      return terrno;
+    if (NULL == taosArrayPush(pTsmaOptCtx->pUsedTsmas, &usefulTsma)) return terrno;
   }
   return code;
 }
@@ -7044,8 +7089,8 @@ static int32_t tsmaOptRewriteTag(const STSMAOptCtx* pTsmaOptCtx, const STSMAOptU
 
 static int32_t tsmaOptRewriteTbname(const STSMAOptCtx* pTsmaOptCtx, SNode** pTbNameNode,
                                     const STSMAOptUsefulTsma* pTsma) {
-  int32_t     code = 0;
-  SExprNode*  pRewrittenFunc = NULL;
+  int32_t    code = 0;
+  SExprNode* pRewrittenFunc = NULL;
   code = nodesMakeNode(pTsma ? QUERY_NODE_COLUMN : QUERY_NODE_FUNCTION, (SNode**)&pRewrittenFunc);
   SValueNode* pValue = NULL;
   if (code == TSDB_CODE_SUCCESS) {
@@ -7054,7 +7099,7 @@ static int32_t tsmaOptRewriteTbname(const STSMAOptCtx* pTsmaOptCtx, SNode** pTbN
 
   if (pTsma && code == TSDB_CODE_SUCCESS) {
     nodesDestroyNode(*pTbNameNode);
-    SColumnNode* pCol = (SColumnNode*)pRewrittenFunc;
+    SColumnNode*   pCol = (SColumnNode*)pRewrittenFunc;
     const SSchema* pSchema = taosArrayGet(pTsma->pTsma->pTags, pTsma->pTsma->pTags->size - 1);
     strcpy(pCol->tableName, pTsma->targetTbName);
     strcpy(pCol->tableAlias, pTsma->targetTbName);
@@ -7124,7 +7169,8 @@ EDealRes tsmaOptNodeRewriter(SNode** ppNode, void* ctx) {
   return DEAL_RES_CONTINUE;
 }
 
-static int32_t tsmaOptRewriteNode(SNode** pNode, STSMAOptCtx* pCtx, const STSMAOptUsefulTsma* pTsma, bool rewriteTbName, bool rewriteTag) {
+static int32_t tsmaOptRewriteNode(SNode** pNode, STSMAOptCtx* pCtx, const STSMAOptUsefulTsma* pTsma, bool rewriteTbName,
+                                  bool rewriteTag) {
   struct TsmaOptRewriteCtx ctx = {
       .pTsmaOptCtx = pCtx, .pTsma = pTsma, .rewriteTag = rewriteTag, .rewriteTbname = rewriteTbName, .code = 0};
   SNode* pOut = *pNode;
@@ -7175,7 +7221,7 @@ static int32_t tsmaOptRewriteScan(STSMAOptCtx* pTsmaOptCtx, SScanLogicNode* pNew
       tstrncpy(pPkTsCol->tableAlias, pTsma->targetTbName, TSDB_TABLE_NAME_LEN);
       pPkTsCol->tableId = pTsma->targetTbUid;
       code = nodesListMakeStrictAppend(&pNewScan->pScanCols, (SNode*)pPkTsCol);
-    } else if (pPkTsCol){
+    } else if (pPkTsCol) {
       nodesDestroyNode((SNode*)pPkTsCol);
     }
     if (code == TSDB_CODE_SUCCESS) {
@@ -7230,7 +7276,7 @@ static int32_t tsmaOptRewriteScan(STSMAOptCtx* pTsmaOptCtx, SScanLogicNode* pNew
 
 static int32_t tsmaOptCreateWStart(int8_t precision, SFunctionNode** pWStartOut) {
   SFunctionNode* pWStart = NULL;
-  int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pWStart);
+  int32_t        code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pWStart);
   if (NULL == pWStart) {
     return code;
   }
@@ -7252,7 +7298,7 @@ static int32_t tsmaOptCreateWStart(int8_t precision, SFunctionNode** pWStartOut)
 }
 
 static int32_t tsmaOptRewriteParent(STSMAOptCtx* pTsmaOptCtx, SLogicNode* pParent, SScanLogicNode* pScan,
-                                  const STSMAOptUsefulTsma* pTsma) {
+                                    const STSMAOptUsefulTsma* pTsma) {
   int32_t           code = 0;
   SColumnNode*      pColNode;
   SWindowLogicNode* pWindow = NULL;
@@ -7299,7 +7345,7 @@ static int32_t tsmaOptRewriteParent(STSMAOptCtx* pTsmaOptCtx, SLogicNode* pParen
     (void)nodesListErase(pMerge->pParameterList, pMerge->pParameterList->pHead);
     SNode* pNew = NULL;
     code = nodesCloneNode((SNode*)pColNode, &pNew);
-    if (TSDB_CODE_SUCCESS  == code) {
+    if (TSDB_CODE_SUCCESS == code) {
       code = nodesListPushFront(pMerge->pParameterList, pNew);
     }
     nodesDestroyNode((SNode*)pPartial);
@@ -7394,7 +7440,7 @@ static bool tsmaOptIsUsingTsmas(STSMAOptCtx* pCtx) {
     return false;
   }
   for (int32_t i = 0; i < pCtx->pUsedTsmas->size; ++i) {
-    const STSMAOptUsefulTsma*pTsma = taosArrayGet(pCtx->pUsedTsmas, i);
+    const STSMAOptUsefulTsma* pTsma = taosArrayGet(pCtx->pUsedTsmas, i);
     if (pTsma->pTsma) return true;
   }
   return false;
@@ -7492,7 +7538,7 @@ static int32_t dumpLogicSubplan(const char* pRuleName, SLogicSubplan* pSubplan)
 static int32_t applyOptimizeRule(SPlanContext* pCxt, SLogicSubplan* pLogicSubplan) {
   SOptimizeContext cxt = {.pPlanCxt = pCxt, .optimized = false};
   bool             optimized = false;
-  int32_t code = dumpLogicSubplan(NULL, pLogicSubplan);
+  int32_t          code = dumpLogicSubplan(NULL, pLogicSubplan);
   if (TSDB_CODE_SUCCESS != code) {
     return code;
   }
diff --git a/source/libs/planner/src/planPhysiCreater.c b/source/libs/planner/src/planPhysiCreater.c
index 103e54ca0b..6ec20ee19c 100644
--- a/source/libs/planner/src/planPhysiCreater.c
+++ b/source/libs/planner/src/planPhysiCreater.c
@@ -820,7 +820,7 @@ static int32_t createSystemTableScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan*
   if (0 == strcmp(pScanLogicNode->tableName.tname, TSDB_INS_TABLE_TABLES) ||
       0 == strcmp(pScanLogicNode->tableName.tname, TSDB_INS_TABLE_TAGS) ||
       0 == strcmp(pScanLogicNode->tableName.tname, TSDB_INS_TABLE_COLS) ||
-      0 == strcmp(pScanLogicNode->tableName.tname, TSDB_INS_TABLE_USAGE)) {
+      0 == strcmp(pScanLogicNode->tableName.tname, TSDB_INS_DISK_USAGE)) {
     if (pScanLogicNode->pVgroupList) {
       vgroupInfoToNodeAddr(pScanLogicNode->pVgroupList->vgroups, &pSubplan->execNode);
     }
diff --git a/source/os/src/osDir.c b/source/os/src/osDir.c
index 0931069f4a..262080374c 100644
--- a/source/os/src/osDir.c
+++ b/source/os/src/osDir.c
@@ -591,23 +591,24 @@ int taosGetDirSize(const char *path, int64_t *size) {
       return TSDB_CODE_OUT_OF_RANGE;
     }
 
+    int64_t subSize = 0;
     if (taosIsDir(fullPath)) {
-      code = taosGetDirSize(fullPath, &totalSize);
+      code = taosGetDirSize(fullPath, &subSize);
       if (code != 0) {
         taosCloseDir(&pDir);
         return code;
       }
     } else {
-      int64_t fileSize = 0;
-      code = taosStatFile(fullPath, &fileSize, NULL, NULL);
+      code = taosStatFile(fullPath, &subSize, NULL, NULL);
       if (code != 0) {
         taosCloseDir(&pDir);
         return code;
       }
-      totalSize += fileSize;
     }
+    totalSize += subSize;
     fullPath[0] = 0;
   }
+
   *size = totalSize;
   TAOS_UNUSED(taosCloseDir(&pDir));
   return 0;