From 115b626f4f5f8b979e2fbff58ac5789fe1695e06 Mon Sep 17 00:00:00 2001 From: yihaoDeng Date: Thu, 1 Aug 2024 20:34:43 +0800 Subject: [PATCH] support query db size --- source/libs/executor/src/sysscanoperator.c | 275 +++++++++ source/libs/nodes/src/nodesCodeFuncs.c | 76 +-- source/libs/nodes/src/nodesUtilFuncs.c | 635 +++++++++++++-------- source/libs/parser/src/parAstCreater.c | 6 +- source/libs/parser/src/parAstParser.c | 21 +- source/libs/parser/src/parAuthenticator.c | 41 +- source/libs/parser/src/parTranslater.c | 11 +- source/libs/planner/src/planOptimizer.c | 3 +- source/libs/planner/src/planPhysiCreater.c | 3 +- 9 files changed, 782 insertions(+), 289 deletions(-) diff --git a/source/libs/executor/src/sysscanoperator.c b/source/libs/executor/src/sysscanoperator.c index 5f4bbd66ce..6c5871e62b 100644 --- a/source/libs/executor/src/sysscanoperator.c +++ b/source/libs/executor/src/sysscanoperator.c @@ -1293,6 +1293,105 @@ _end: return code; } +int32_t buildSysUsageInfoBlock(bool sysInfo, const SSDataBlock* p, const SSysTableMeta* pSysDbTableMeta, size_t size, + const char* dbName, int64_t* pRows) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + char n[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; + int32_t numOfRows = p->info.rows; + + for (int32_t i = 0; i < size; ++i) { + const SSysTableMeta* pm = &pSysDbTableMeta[i]; + if (!sysInfo && pm->sysInfo) { + continue; + } + + // if (strcmp(pm->name, TSDB_INS_TABLE_USERS_FULL) == 0) { + // continue; + // } + int32_t numOfCols = 0; + SColumnInfoData* pColInfoData = taosArrayGet(p->pDataBlock, 0); + + // STR_TO_VARSTR(n, pm->name); + // code = colDataSetVal(pColInfoData, numOfRows, n, false); + // QUERY_CHECK_CODE(code, lino, _end); + + // database name + STR_TO_VARSTR(n, dbName); + pColInfoData = taosArrayGet(p->pDataBlock, numOfCols++); + code = colDataSetVal(pColInfoData, numOfRows, n, false); + QUERY_CHECK_CODE(code, lino, _end); + + // create time + pColInfoData = taosArrayGet(p->pDataBlock, numOfCols++); + colDataSetNULL(pColInfoData, numOfRows); + + // number of columns + pColInfoData = taosArrayGet(p->pDataBlock, numOfCols++); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&pm->colNum, false); + QUERY_CHECK_CODE(code, lino, _end); + + pColInfoData = taosArrayGet(p->pDataBlock, numOfCols++); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&pm->colNum, false); + QUERY_CHECK_CODE(code, lino, _end); + + // for (int32_t j = 4; j <= 8; ++j) { + // pColInfoData = taosArrayGet(p->pDataBlock, j); + // colDataSetNULL(pColInfoData, numOfRows); + // } + + //STR_TO_VARSTR(n, "SYSTEM_TABLE"); + + pColInfoData = taosArrayGet(p->pDataBlock, 9); + code = colDataSetVal(pColInfoData, numOfRows, n, false); + QUERY_CHECK_CODE(code, lino, _end); + + numOfRows += 1; + } + + *pRows = numOfRows; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; + + return code; +} +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); + QUERY_CHECK_NULL(p, code, lino, _end, terrno); + + code = blockDataEnsureCapacity(p, capacity); + QUERY_CHECK_CODE(code, lino, _end); + + size_t size = 0; + const SSysTableMeta* pSysDbTableMeta = NULL; + + getInfosDbMeta(&pSysDbTableMeta, &size); + code = buildSysUsageInfoBlock(pInfo->sysInfo, p, pSysDbTableMeta, size, TSDB_INFORMATION_SCHEMA_DB, &p->info.rows); + QUERY_CHECK_CODE(code, lino, _end); + + // getPerfDbMeta(&pSysDbTableMeta, &size); + // code = buildSysUse(pInfo->sysInfo, p, pSysDbTableMeta, size, TSDB_PERFORMANCE_SCHEMA_DB, &p->info.rows); + QUERY_CHECK_CODE(code, lino, _end); + + pInfo->pRes->info.rows = p->info.rows; + code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); + QUERY_CHECK_CODE(code, lino, _end); + + blockDataDestroy(p); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; +} + static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) { int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; @@ -1741,8 +1840,157 @@ _end: T_LONG_JMP(pTaskInfo->env, code); } return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes; + + } + +static SSDataBlock* sysTableBuildVgUsage(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + SStorageAPI* pAPI = &pTaskInfo->storageAPI; + int8_t firstMetaCursor = 0; + + SSysTableScanInfo* pInfo = pOperator->info; + if (pInfo->readHandle.mnd != NULL) { + // code = buildSysUsageInfo(pInfo, pOperator->resultInfo.capacity); + // QUERY_CHECK_CODE(code, lino, _end); + + // code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + // QUERY_CHECK_CODE(code, lino, _end); + // pInfo->loadInfo.totalRows += pInfo->pRes->info.rows; + + setOperatorCompleted(pOperator); + return NULL; + return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes; + + } + if (pInfo->pCur == NULL) { + pInfo->pCur = pAPI->metaFn.openTableMetaCursor(pInfo->readHandle.vnode); + firstMetaCursor = 1; + } + if (!firstMetaCursor) { + pAPI->metaFn.resumeTableMetaCursor(pInfo->pCur, 0, 1); + } + + blockDataCleanup(pInfo->pRes); + int32_t numOfRows = 0; + + const char* db = NULL; + int32_t vgId = 0; + pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, &db, &vgId, NULL, NULL); + + SName sn = {0}; + char dbname[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; + code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + QUERY_CHECK_CODE(code, lino, _end); + + code = tNameGetDbName(&sn, varDataVal(dbname)); + QUERY_CHECK_CODE(code, lino, _end); + + varDataSetLen(dbname, strlen(varDataVal(dbname))); + + SSDataBlock* p = buildInfoSchemaTableMetaBlock(TSDB_INS_TABLE_USAGE); + QUERY_CHECK_NULL(p, code, lino, _end, terrno); + + code = blockDataEnsureCapacity(p, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _end); + + char n[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; + + int64_t walSize = 1024, totalSize = 0; + int32_t numOfCols = 0; + SColumnInfoData* pColInfoData = taosArrayGet(p->pDataBlock, numOfCols++); + pColInfoData = taosArrayGet(p->pDataBlock, 0); + code = colDataSetVal(pColInfoData, numOfRows, dbname, false); + QUERY_CHECK_CODE(code, lino, _end); + + pColInfoData = taosArrayGet(p->pDataBlock, numOfCols++); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&vgId, false); + QUERY_CHECK_CODE(code, lino, _end); + + pColInfoData = taosArrayGet(p->pDataBlock, numOfCols++); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&walSize, false); // wal + QUERY_CHECK_CODE(code, lino, _end); + + totalSize += walSize; + + pColInfoData = taosArrayGet(p->pDataBlock, numOfCols++); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&walSize, false); // memtable + QUERY_CHECK_CODE(code, lino, _end); + + totalSize += walSize; + + pColInfoData = taosArrayGet(p->pDataBlock, numOfCols++); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&walSize, false); // l1_size + QUERY_CHECK_CODE(code, lino, _end); + + totalSize += walSize; + + pColInfoData = taosArrayGet(p->pDataBlock, numOfCols++); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&walSize, false); // l2_size + QUERY_CHECK_CODE(code, lino, _end); + + totalSize += walSize; + + pColInfoData = taosArrayGet(p->pDataBlock, numOfCols++); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&walSize, false); // l3_size + QUERY_CHECK_CODE(code, lino, _end); + totalSize += walSize; + + + pColInfoData = taosArrayGet(p->pDataBlock, numOfCols++); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&walSize, false); // s3_size + QUERY_CHECK_CODE(code, lino, _end); + totalSize += walSize; + + pColInfoData = taosArrayGet(p->pDataBlock, numOfCols++); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&walSize, false); // estimate_size + QUERY_CHECK_CODE(code, lino, _end); + totalSize += walSize; + + pColInfoData = taosArrayGet(p->pDataBlock, numOfCols++); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&totalSize, false); // totoal size + QUERY_CHECK_CODE(code, lino, _end); + totalSize += walSize; + + + numOfRows +=1; + pAPI->metaFn.closeTableMetaCursor(pInfo->pCur); + pInfo->pCur = NULL; + setOperatorCompleted(pOperator); + + if (numOfRows > 0) { + pAPI->metaFn.closeTableMetaCursor(pInfo->pCur); + pInfo->pCur = NULL; + setOperatorCompleted(pOperator); + + p->info.rows = numOfRows; + pInfo->pRes->info.rows = numOfRows; + + code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); + + blockDataCleanup(p); + numOfRows = 0; + } + + pInfo->loadInfo.totalRows += pInfo->pRes->info.rows; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } + return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes; +} + + static SSDataBlock* sysTableScanUserTables(SOperatorInfo* pOperator) { int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; @@ -1804,6 +2052,31 @@ _end: return NULL; } + +static SSDataBlock* sysTableScanUsage(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + SSysTableScanInfo* pInfo = pOperator->info; + + SNode* pCondition = pInfo->pCondition; + if (pOperator->status == OP_EXEC_DONE) { + return NULL; + } + + + // the retrieve is executed on the mnode, so return tables that belongs to the information schema database. + return sysTableBuildVgUsage(pOperator); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } + return NULL; +} + static SSDataBlock* sysTableScanUserSTables(SOperatorInfo* pOperator) { SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SSysTableScanInfo* pInfo = pOperator->info; @@ -1916,6 +2189,8 @@ 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) { + pBlock = sysTableScanUsage(pOperator); } else { // load the meta from mnode of the given epset pBlock = sysTableScanFromMNode(pOperator, pInfo, name, pTaskInfo); } diff --git a/source/libs/nodes/src/nodesCodeFuncs.c b/source/libs/nodes/src/nodesCodeFuncs.c index b34d1b9a70..bb13e92a6f 100644 --- a/source/libs/nodes/src/nodesCodeFuncs.c +++ b/source/libs/nodes/src/nodesCodeFuncs.c @@ -286,6 +286,8 @@ const char* nodesNodeName(ENodeType type) { return "ShowClusterMachinesStmt"; case QUERY_NODE_SHOW_ENCRYPTIONS_STMT: return "ShowEncryptionsStmt"; + case QUERY_NODE_SHOW_USAGE_STMT: + return "ShowUsageStmt"; case QUERY_NODE_DELETE_STMT: return "DeleteStmt"; case QUERY_NODE_INSERT_STMT: @@ -2222,7 +2224,7 @@ static int32_t physiMergeJoinNodeToJson(const void* pObj, SJson* pJson) { } if (TSDB_CODE_SUCCESS == code) { code = tjsonAddIntegerToObject(pJson, jkJoinPhysiPlanAsofOp, pNode->asofOpType); - } + } if (TSDB_CODE_SUCCESS == code) { code = tjsonAddObject(pJson, jkJoinPhysiPlanLeftPrimExpr, nodeToJson, pNode->leftPrimExpr); } @@ -2231,10 +2233,10 @@ static int32_t physiMergeJoinNodeToJson(const void* pObj, SJson* pJson) { } if (TSDB_CODE_SUCCESS == code) { code = tjsonAddIntegerToObject(pJson, jkJoinPhysiPlanLeftPrimSlotId, pNode->leftPrimSlotId); - } + } if (TSDB_CODE_SUCCESS == code) { code = tjsonAddIntegerToObject(pJson, jkJoinPhysiPlanRightPrimSlotId, pNode->rightPrimSlotId); - } + } if (TSDB_CODE_SUCCESS == code) { code = nodeListToJson(pJson, jkJoinPhysiPlanLeftEqCols, pNode->pEqLeft); } @@ -2336,7 +2338,7 @@ static int32_t jsonToPhysiMergeJoinNode(const SJson* pJson, void* pObj) { if (TSDB_CODE_SUCCESS == code) { code = tjsonGetBoolValue(pJson, jkJoinPhysiPlanGroupJoin, &pNode->grpJoin); } - + return code; } @@ -2349,7 +2351,7 @@ static int32_t physiHashJoinNodeToJson(const void* pObj, SJson* pJson) { } if (TSDB_CODE_SUCCESS == code) { code = tjsonAddIntegerToObject(pJson, jkJoinPhysiPlanSubType, pNode->subType); - } + } if (TSDB_CODE_SUCCESS == code) { code = nodeListToJson(pJson, jkJoinPhysiPlanOnLeftCols, pNode->pOnLeft); } @@ -2364,10 +2366,10 @@ static int32_t physiHashJoinNodeToJson(const void* pObj, SJson* pJson) { } if (TSDB_CODE_SUCCESS == code) { code = tjsonAddIntegerToObject(pJson, jkJoinPhysiPlanLeftPrimSlotId, pNode->leftPrimSlotId); - } + } if (TSDB_CODE_SUCCESS == code) { code = tjsonAddIntegerToObject(pJson, jkJoinPhysiPlanRightPrimSlotId, pNode->rightPrimSlotId); - } + } if (TSDB_CODE_SUCCESS == code) { code = tjsonAddObject(pJson, jkJoinPhysiPlanOnConditions, nodeToJson, pNode->pFullOnCond); } @@ -2414,7 +2416,7 @@ static int32_t jsonToPhysiHashJoinNode(const SJson* pJson, void* pObj) { } if (TSDB_CODE_SUCCESS == code) { tjsonGetNumberValue(pJson, jkJoinPhysiPlanSubType, pNode->subType, code); - } + } if (TSDB_CODE_SUCCESS == code) { code = jsonToNodeList(pJson, jkJoinPhysiPlanOnLeftCols, &pNode->pOnLeft); } @@ -2432,7 +2434,7 @@ static int32_t jsonToPhysiHashJoinNode(const SJson* pJson, void* pObj) { } if (TSDB_CODE_SUCCESS == code) { tjsonGetNumberValue(pJson, jkJoinPhysiPlanRightPrimSlotId, pNode->rightPrimSlotId, code); - } + } if (TSDB_CODE_SUCCESS == code) { code = jsonToNodeObject(pJson, jkJoinPhysiPlanOnConditions, &pNode->pFullOnCond); } @@ -2459,7 +2461,7 @@ static int32_t jsonToPhysiHashJoinNode(const SJson* pJson, void* pObj) { } if (TSDB_CODE_SUCCESS == code) { tjsonGetNumberValue(pJson, jkJoinPhysiPlanTimeRangeTarget, pNode->timeRangeTarget, code); - } + } if (TSDB_CODE_SUCCESS == code) { code = tjsonGetBigIntValue(pJson, jkJoinPhysiPlanTimeRangeSKey, &pNode->timeRange.skey); } @@ -3859,7 +3861,7 @@ static int32_t columnNodeToJson(const void* pObj, SJson* pJson) { } if (TSDB_CODE_SUCCESS == code) { code = tjsonAddBoolToObject(pJson, jkColumnIsPk, pNode->isPk); - } + } if (TSDB_CODE_SUCCESS == code) { code = tjsonAddIntegerToObject(pJson, jkColumnNumOfPKs, pNode->numOfPKs); } @@ -3908,10 +3910,10 @@ static int32_t jsonToColumnNode(const SJson* pJson, void* pObj) { } if (TSDB_CODE_SUCCESS == code) { code = tjsonGetBoolValue(pJson, jkColumnIsPk, &pNode->isPk); - } + } if (TSDB_CODE_SUCCESS == code) { code = tjsonGetSmallIntValue(pJson, jkColumnNumOfPKs, &pNode->numOfPKs); - } + } return code; } @@ -4314,7 +4316,7 @@ static int32_t jsonToFunctionNode(const SJson* pJson, void* pObj) { } if (TSDB_CODE_SUCCESS == code) { code = tjsonGetIntValue(pJson, jkFunctionPkBytes, &pNode->pkBytes); - } + } if (TSDB_CODE_SUCCESS == code) { code = tjsonGetBoolValue(pJson, jkFunctionIsMergeFunc, &pNode->hasOriginalFunc); } @@ -4985,7 +4987,7 @@ static int32_t jsonToColumnDefNode(const SJson* pJson, void* pObj) { code = tjsonGetBoolValue(pJson, jkColumnDefSma, &pNode->sma); } if (TSDB_CODE_SUCCESS == code) { - code = jsonToNodeObject(pJson, jkColumnDefOptions, (SNode**)&pNode->pOptions); + code = jsonToNodeObject(pJson, jkColumnDefOptions, (SNode**)&pNode->pOptions); } return code; } @@ -5038,14 +5040,14 @@ static int32_t jsonToDownstreamSourceNode(const SJson* pJson, void* pObj) { static const char* jkWindowOffsetStartOffset = "StartOffset"; static const char* jkWindowOffsetEndOffset = "EndOffset"; -static int32_t windowOffsetNodeToJson(const void* pObj, SJson* pJson) { - const SWindowOffsetNode* pNode = (const SWindowOffsetNode*)pObj; +static int32_t windowOffsetNodeToJson(const void* pObj, SJson* pJson) { + const SWindowOffsetNode* pNode = (const SWindowOffsetNode*)pObj; - int32_t code = tjsonAddObject(pJson, jkWindowOffsetStartOffset, nodeToJson, pNode->pStartOffset); - if (TSDB_CODE_SUCCESS == code) { - code = tjsonAddObject(pJson, jkWindowOffsetEndOffset, nodeToJson, pNode->pEndOffset); + int32_t code = tjsonAddObject(pJson, jkWindowOffsetStartOffset, nodeToJson, pNode->pStartOffset); + if (TSDB_CODE_SUCCESS == code) { + code = tjsonAddObject(pJson, jkWindowOffsetEndOffset, nodeToJson, pNode->pEndOffset); } - return code; + return code; } static int32_t jsonToWindowOffsetNode(const SJson* pJson, void* pObj) { @@ -5058,7 +5060,6 @@ static int32_t jsonToWindowOffsetNode(const SJson* pJson, void* pObj) { return code; } - static const char* jkDatabaseOptionsBuffer = "Buffer"; static const char* jkDatabaseOptionsCacheModel = "CacheModel"; static const char* jkDatabaseOptionsCompressionLevel = "CompressionLevel"; @@ -5295,11 +5296,11 @@ static const char* jkColumnOptionsEncode = "encode"; static const char* jkColumnOptionsCompress = "compress"; static const char* jkColumnOptionsLevel = "level"; static int32_t columnOptionsToJson(const void* pObj, SJson* pJson) { - const SColumnOptions* pNode = (const SColumnOptions*)pObj; - int32_t code = tjsonAddStringToObject(pJson, jkColumnOptionsEncode, pNode->encode); - code = tjsonAddStringToObject(pJson, jkColumnOptionsCompress, pNode->compress); - code = tjsonAddStringToObject(pJson, jkColumnOptionsLevel, pNode->compressLevel); - return code; + const SColumnOptions* pNode = (const SColumnOptions*)pObj; + int32_t code = tjsonAddStringToObject(pJson, jkColumnOptionsEncode, pNode->encode); + code = tjsonAddStringToObject(pJson, jkColumnOptionsCompress, pNode->compress); + code = tjsonAddStringToObject(pJson, jkColumnOptionsLevel, pNode->compressLevel); + return code; } static int32_t jsonToColumnOptions(const SJson* pJson, void* pObj) { @@ -7067,6 +7068,9 @@ static int32_t jsonToShowClusterMachinesStmt(const SJson* pJson, void* pObj) { r static int32_t jsonToShowEncryptionsStmt(const SJson* pJson, void* pObj) { return jsonToShowStmt(pJson, pObj); } +static int32_t showUsageStmtStmtToJson(const void* pObj, SJson* pJson) { return showStmtToJson(pObj, pJson); } +static int32_t jsonToShowUsageStmt(const SJson* pJson, void* pObj) { return jsonToShowStmt(pJson, pObj); } + static const char* jkShowDnodeVariablesStmtDnodeId = "DnodeId"; static const char* jkShowDnodeVariablesStmtLikePattern = "LikePattern"; @@ -7373,7 +7377,7 @@ static const char* jkTSMAOptionTsPrecision = "Precision"; static int32_t tsmaOptionToJson(const void* pObj, SJson* pJson) { const STSMAOptions* pNode = (const STSMAOptions*)pObj; - int32_t code = nodeListToJson(pJson, jkTSMAOptionFuncs, pNode->pFuncs); + int32_t code = nodeListToJson(pJson, jkTSMAOptionFuncs, pNode->pFuncs); if (TSDB_CODE_SUCCESS == code) { code = tjsonAddObject(pJson, jkTSMAOptionInterval, nodeToJson, pNode->pInterval); } @@ -7385,7 +7389,7 @@ static int32_t tsmaOptionToJson(const void* pObj, SJson* pJson) { static int32_t jsonToTSMAOption(const SJson* pJson, void* pObj) { STSMAOptions* pNode = (STSMAOptions*)pObj; - int32_t code = jsonToNodeList(pJson, jkTSMAOptionFuncs, &pNode->pFuncs); + int32_t code = jsonToNodeList(pJson, jkTSMAOptionFuncs, &pNode->pFuncs); if (TSDB_CODE_SUCCESS == code) { code = jsonToNodeObject(pJson, jkTSMAOptionInterval, &pNode->pInterval); } @@ -7403,7 +7407,7 @@ static const char* jkCreateTSMAStmtpOptions = "Options"; static int32_t createTSMAStmtToJson(const void* pObj, SJson* pJson) { const SCreateTSMAStmt* pNode = (const SCreateTSMAStmt*)pObj; - int32_t code = tjsonAddBoolToObject(pJson, jkCreateTSMAStmtIgnoreExists, pNode->ignoreExists); + int32_t code = tjsonAddBoolToObject(pJson, jkCreateTSMAStmtIgnoreExists, pNode->ignoreExists); if (TSDB_CODE_SUCCESS == code) { code = tjsonAddStringToObject(pJson, jkCreateTSMAStmtTsmaName, pNode->tsmaName); } @@ -7421,7 +7425,7 @@ static int32_t createTSMAStmtToJson(const void* pObj, SJson* pJson) { static int32_t jsonToCreateTSMAStmt(const SJson* pJson, void* pObj) { SCreateTSMAStmt* pNode = (SCreateTSMAStmt*)pObj; - int32_t code = tjsonGetBoolValue(pJson, jkCreateTSMAStmtIgnoreExists, &pNode->ignoreExists); + int32_t code = tjsonGetBoolValue(pJson, jkCreateTSMAStmtIgnoreExists, &pNode->ignoreExists); if (TSDB_CODE_SUCCESS == code) { code = tjsonGetStringValue(pJson, jkCreateTSMAStmtTsmaName, pNode->tsmaName); } @@ -7443,7 +7447,7 @@ static const char* jkDropTSMAStmtTsmaName = "TSMAName"; static int32_t dropTSMAStmtToJson(const void* pObj, SJson* pJson) { const SDropTSMAStmt* pNode = (const SDropTSMAStmt*)pObj; - int32_t code = tjsonAddBoolToObject(pJson, jkDropTSMAStmtIgnoreNotExists, pNode->ignoreNotExists); + int32_t code = tjsonAddBoolToObject(pJson, jkDropTSMAStmtIgnoreNotExists, pNode->ignoreNotExists); if (TSDB_CODE_SUCCESS == code) { code = tjsonAddStringToObject(pJson, jkDropTSMAStmtDbName, pNode->dbName); } @@ -7455,7 +7459,7 @@ static int32_t dropTSMAStmtToJson(const void* pObj, SJson* pJson) { static int32_t jsonToDropTSMAStmt(const SJson* pJson, void* pObj) { SDropTSMAStmt* pNode = (SDropTSMAStmt*)pObj; - int32_t code = tjsonGetBoolValue(pJson, jkDropTSMAStmtIgnoreNotExists, &pNode->ignoreNotExists); + int32_t code = tjsonGetBoolValue(pJson, jkDropTSMAStmtIgnoreNotExists, &pNode->ignoreNotExists); if (TSDB_CODE_SUCCESS == code) { code = tjsonGetStringValue(pJson, jkDropTSMAStmtDbName, pNode->dbName); } @@ -7696,6 +7700,8 @@ static int32_t specificNodeToJson(const void* pObj, SJson* pJson) { return showLocalVariablesStmtToJson(pObj, pJson); case QUERY_NODE_SHOW_TABLE_TAGS_STMT: return showTableTagsStmtToJson(pObj, pJson); + case QUERY_NODE_SHOW_USAGE_STMT: + return showUsageStmtStmtToJson(pObj, pJson); case QUERY_NODE_DELETE_STMT: return deleteStmtToJson(pObj, pJson); case QUERY_NODE_INSERT_STMT: @@ -7968,7 +7974,7 @@ static int32_t jsonToSpecificNode(const SJson* pJson, void* pObj) { case QUERY_NODE_BALANCE_VGROUP_LEADER_STMT: return TSDB_CODE_SUCCESS; case QUERY_NODE_BALANCE_VGROUP_LEADER_DATABASE_STMT: - return TSDB_CODE_SUCCESS; // SBalanceVgroupLeaderStmt has no fields to deserialize. + return TSDB_CODE_SUCCESS; // SBalanceVgroupLeaderStmt has no fields to deserialize. case QUERY_NODE_MERGE_VGROUP_STMT: return jsonToMergeVgroupStmt(pJson, pObj); case QUERY_NODE_REDISTRIBUTE_VGROUP_STMT: @@ -8046,6 +8052,8 @@ static int32_t jsonToSpecificNode(const SJson* pJson, void* pObj) { return jsonToShowLocalVariablesStmt(pJson, pObj); case QUERY_NODE_SHOW_TABLE_TAGS_STMT: return jsonToShowTableTagsStmt(pJson, pObj); + case QUERY_NODE_SHOW_USAGE_STMT: + return jsonToShowUsageStmt(pJson, pObj); case QUERY_NODE_DELETE_STMT: return jsonToDeleteStmt(pJson, pObj); case QUERY_NODE_INSERT_STMT: diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c index 6e69c56687..e19c1c5c17 100644 --- a/source/libs/nodes/src/nodesUtilFuncs.c +++ b/source/libs/nodes/src/nodesUtilFuncs.c @@ -14,6 +14,7 @@ */ #include "cmdnodes.h" +#include "functionMgt.h" #include "nodesUtil.h" #include "plannodes.h" #include "querynodes.h" @@ -22,7 +23,6 @@ #include "tdatablock.h" #include "thash.h" #include "tref.h" -#include "functionMgt.h" typedef struct SNodeMemChunk { int32_t availableSize; @@ -56,15 +56,13 @@ char* getJoinSTypeString(EJoinSubType type) { char* getFullJoinTypeString(EJoinType type, EJoinSubType stype) { static char* joinFullType[][8] = { - {"INNER", "INNER", "INNER", "INNER", "INNER", "INNER ANY", "INNER", "INNER"}, - {"LEFT", "LEFT", "LEFT OUTER", "LEFT SEMI", "LEFT ANTI", "LEFT ANY", "LEFT ASOF", "LEFT WINDOW"}, - {"RIGHT", "RIGHT", "RIGHT OUTER", "RIGHT SEMI", "RIGHT ANTI", "RIGHT ANY", "RIGHT ASOF", "RIGHT WINDOW"}, - {"FULL", "FULL", "FULL OUTER", "FULL", "FULL", "FULL ANY", "FULL", "FULL"} - }; + {"INNER", "INNER", "INNER", "INNER", "INNER", "INNER ANY", "INNER", "INNER"}, + {"LEFT", "LEFT", "LEFT OUTER", "LEFT SEMI", "LEFT ANTI", "LEFT ANY", "LEFT ASOF", "LEFT WINDOW"}, + {"RIGHT", "RIGHT", "RIGHT OUTER", "RIGHT SEMI", "RIGHT ANTI", "RIGHT ANY", "RIGHT ASOF", "RIGHT WINDOW"}, + {"FULL", "FULL", "FULL OUTER", "FULL", "FULL", "FULL ANY", "FULL", "FULL"}}; return joinFullType[type][stype]; } - int32_t mergeJoinConds(SNode** ppDst, SNode** ppSrc) { if (NULL == *ppSrc) { return TSDB_CODE_SUCCESS; @@ -74,14 +72,16 @@ int32_t mergeJoinConds(SNode** ppDst, SNode** ppSrc) { *ppSrc = NULL; return TSDB_CODE_SUCCESS; } - if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppSrc) && ((SLogicConditionNode*)(*ppSrc))->condType == LOGIC_COND_TYPE_AND) { + if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppSrc) && + ((SLogicConditionNode*)(*ppSrc))->condType == LOGIC_COND_TYPE_AND) { TSWAP(*ppDst, *ppSrc); } int32_t code = 0; if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppDst)) { SLogicConditionNode* pDst = (SLogicConditionNode*)*ppDst; if (pDst->condType == LOGIC_COND_TYPE_AND) { - if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppSrc) && ((SLogicConditionNode*)(*ppSrc))->condType == LOGIC_COND_TYPE_AND) { + if (QUERY_NODE_LOGIC_CONDITION == nodeType(*ppSrc) && + ((SLogicConditionNode*)(*ppSrc))->condType == LOGIC_COND_TYPE_AND) { code = nodesListStrictAppendList(pDst->pParameterList, ((SLogicConditionNode*)(*ppSrc))->pParameterList); ((SLogicConditionNode*)(*ppSrc))->pParameterList = NULL; } else { @@ -109,13 +109,12 @@ int32_t mergeJoinConds(SNode** ppDst, SNode** ppSrc) { *ppSrc = NULL; code = nodesListMakeStrictAppend(&pLogicCond->pParameterList, *ppDst); } - if (TSDB_CODE_SUCCESS == code) { + if (TSDB_CODE_SUCCESS == code) { *ppDst = (SNode*)pLogicCond; } return code; } - static int32_t callocNodeChunk(SNodeAllocator* pAllocator, SNodeMemChunk** pOutChunk) { SNodeMemChunk* pNewChunk = taosMemoryCalloc(1, sizeof(SNodeMemChunk) + pAllocator->chunkSize); if (NULL == pNewChunk) { @@ -155,11 +154,12 @@ static int32_t nodesCallocImpl(int32_t size, void** pOut) { void* p = g_pNodeAllocator->pCurrChunk->pBuf + g_pNodeAllocator->pCurrChunk->usedSize; g_pNodeAllocator->pCurrChunk->usedSize += size; *pOut = p; - return TSDB_CODE_SUCCESS;; + return TSDB_CODE_SUCCESS; + ; } static int32_t nodesCalloc(int32_t num, int32_t size, void** pOut) { - void* p = NULL; + void* p = NULL; int32_t code = nodesCallocImpl(num * size + 1, &p); if (TSDB_CODE_SUCCESS != code) { return code; @@ -342,194 +342,282 @@ static int32_t makeNode(ENodeType type, int32_t size, SNode** ppNode) { } int32_t nodesMakeNode(ENodeType type, SNode** ppNodeOut) { - SNode* pNode = NULL; + SNode* pNode = NULL; int32_t code = 0; switch (type) { case QUERY_NODE_COLUMN: - code = makeNode(type, sizeof(SColumnNode), &pNode); break; + code = makeNode(type, sizeof(SColumnNode), &pNode); + break; case QUERY_NODE_VALUE: - code = makeNode(type, sizeof(SValueNode), &pNode); break; + code = makeNode(type, sizeof(SValueNode), &pNode); + break; case QUERY_NODE_OPERATOR: - code = makeNode(type, sizeof(SOperatorNode), &pNode); break; + code = makeNode(type, sizeof(SOperatorNode), &pNode); + break; case QUERY_NODE_LOGIC_CONDITION: - code = makeNode(type, sizeof(SLogicConditionNode), &pNode); break; + code = makeNode(type, sizeof(SLogicConditionNode), &pNode); + break; case QUERY_NODE_FUNCTION: - code = makeNode(type, sizeof(SFunctionNode), &pNode); break; + code = makeNode(type, sizeof(SFunctionNode), &pNode); + break; case QUERY_NODE_REAL_TABLE: - code = makeNode(type, sizeof(SRealTableNode), &pNode); break; + code = makeNode(type, sizeof(SRealTableNode), &pNode); + break; case QUERY_NODE_TEMP_TABLE: - code = makeNode(type, sizeof(STempTableNode), &pNode); break; + code = makeNode(type, sizeof(STempTableNode), &pNode); + break; case QUERY_NODE_JOIN_TABLE: - code = makeNode(type, sizeof(SJoinTableNode), &pNode); break; + code = makeNode(type, sizeof(SJoinTableNode), &pNode); + break; case QUERY_NODE_GROUPING_SET: - code = makeNode(type, sizeof(SGroupingSetNode), &pNode); break; + code = makeNode(type, sizeof(SGroupingSetNode), &pNode); + break; case QUERY_NODE_ORDER_BY_EXPR: - code = makeNode(type, sizeof(SOrderByExprNode), &pNode); break; + code = makeNode(type, sizeof(SOrderByExprNode), &pNode); + break; case QUERY_NODE_LIMIT: - code = makeNode(type, sizeof(SLimitNode), &pNode); break; + code = makeNode(type, sizeof(SLimitNode), &pNode); + break; case QUERY_NODE_STATE_WINDOW: - code = makeNode(type, sizeof(SStateWindowNode), &pNode); break; + code = makeNode(type, sizeof(SStateWindowNode), &pNode); + break; case QUERY_NODE_SESSION_WINDOW: - code = makeNode(type, sizeof(SSessionWindowNode), &pNode); break; + code = makeNode(type, sizeof(SSessionWindowNode), &pNode); + break; case QUERY_NODE_INTERVAL_WINDOW: - code = makeNode(type, sizeof(SIntervalWindowNode), &pNode); break; + code = makeNode(type, sizeof(SIntervalWindowNode), &pNode); + break; case QUERY_NODE_NODE_LIST: - code = makeNode(type, sizeof(SNodeListNode), &pNode); break; + code = makeNode(type, sizeof(SNodeListNode), &pNode); + break; case QUERY_NODE_FILL: - code = makeNode(type, sizeof(SFillNode), &pNode); break; + code = makeNode(type, sizeof(SFillNode), &pNode); + break; case QUERY_NODE_RAW_EXPR: - code = makeNode(type, sizeof(SRawExprNode), &pNode); break; + code = makeNode(type, sizeof(SRawExprNode), &pNode); + break; case QUERY_NODE_TARGET: - code = makeNode(type, sizeof(STargetNode), &pNode); break; + code = makeNode(type, sizeof(STargetNode), &pNode); + break; case QUERY_NODE_DATABLOCK_DESC: - code = makeNode(type, sizeof(SDataBlockDescNode), &pNode); break; + code = makeNode(type, sizeof(SDataBlockDescNode), &pNode); + break; case QUERY_NODE_SLOT_DESC: - code = makeNode(type, sizeof(SSlotDescNode), &pNode); break; + code = makeNode(type, sizeof(SSlotDescNode), &pNode); + break; case QUERY_NODE_COLUMN_DEF: - code = makeNode(type, sizeof(SColumnDefNode), &pNode); break; + code = makeNode(type, sizeof(SColumnDefNode), &pNode); + break; case QUERY_NODE_DOWNSTREAM_SOURCE: - code = makeNode(type, sizeof(SDownstreamSourceNode), &pNode); break; + code = makeNode(type, sizeof(SDownstreamSourceNode), &pNode); + break; case QUERY_NODE_DATABASE_OPTIONS: - code = makeNode(type, sizeof(SDatabaseOptions), &pNode); break; + code = makeNode(type, sizeof(SDatabaseOptions), &pNode); + break; case QUERY_NODE_TABLE_OPTIONS: - code = makeNode(type, sizeof(STableOptions), &pNode); break; + code = makeNode(type, sizeof(STableOptions), &pNode); + break; case QUERY_NODE_COLUMN_OPTIONS: - code = makeNode(type, sizeof(SColumnOptions), &pNode); break; + code = makeNode(type, sizeof(SColumnOptions), &pNode); + break; case QUERY_NODE_INDEX_OPTIONS: - code = makeNode(type, sizeof(SIndexOptions), &pNode); break; + code = makeNode(type, sizeof(SIndexOptions), &pNode); + break; case QUERY_NODE_EXPLAIN_OPTIONS: - code = makeNode(type, sizeof(SExplainOptions), &pNode); break; + code = makeNode(type, sizeof(SExplainOptions), &pNode); + break; case QUERY_NODE_STREAM_OPTIONS: - code = makeNode(type, sizeof(SStreamOptions), &pNode); break; + code = makeNode(type, sizeof(SStreamOptions), &pNode); + break; case QUERY_NODE_LEFT_VALUE: - code = makeNode(type, sizeof(SLeftValueNode), &pNode); break; + code = makeNode(type, sizeof(SLeftValueNode), &pNode); + break; case QUERY_NODE_COLUMN_REF: - code = makeNode(type, sizeof(SColumnRefNode), &pNode); break; + code = makeNode(type, sizeof(SColumnRefNode), &pNode); + break; case QUERY_NODE_WHEN_THEN: - code = makeNode(type, sizeof(SWhenThenNode), &pNode); break; + code = makeNode(type, sizeof(SWhenThenNode), &pNode); + break; case QUERY_NODE_CASE_WHEN: - code = makeNode(type, sizeof(SCaseWhenNode), &pNode); break; + code = makeNode(type, sizeof(SCaseWhenNode), &pNode); + break; case QUERY_NODE_EVENT_WINDOW: - code = makeNode(type, sizeof(SEventWindowNode), &pNode); break; + code = makeNode(type, sizeof(SEventWindowNode), &pNode); + break; case QUERY_NODE_COUNT_WINDOW: - code = makeNode(type, sizeof(SCountWindowNode), &pNode); break; + code = makeNode(type, sizeof(SCountWindowNode), &pNode); + break; case QUERY_NODE_HINT: - code = makeNode(type, sizeof(SHintNode), &pNode); break; + code = makeNode(type, sizeof(SHintNode), &pNode); + break; case QUERY_NODE_VIEW: - code = makeNode(type, sizeof(SViewNode), &pNode); break; + code = makeNode(type, sizeof(SViewNode), &pNode); + break; case QUERY_NODE_WINDOW_OFFSET: - code = makeNode(type, sizeof(SWindowOffsetNode), &pNode); break; + code = makeNode(type, sizeof(SWindowOffsetNode), &pNode); + break; case QUERY_NODE_SET_OPERATOR: - code = makeNode(type, sizeof(SSetOperator), &pNode); break; + code = makeNode(type, sizeof(SSetOperator), &pNode); + break; case QUERY_NODE_SELECT_STMT: - code = makeNode(type, sizeof(SSelectStmt), &pNode); break; + code = makeNode(type, sizeof(SSelectStmt), &pNode); + break; case QUERY_NODE_VNODE_MODIFY_STMT: - code = makeNode(type, sizeof(SVnodeModifyOpStmt), &pNode); break; + code = makeNode(type, sizeof(SVnodeModifyOpStmt), &pNode); + break; case QUERY_NODE_CREATE_DATABASE_STMT: - code = makeNode(type, sizeof(SCreateDatabaseStmt), &pNode); break; + code = makeNode(type, sizeof(SCreateDatabaseStmt), &pNode); + break; case QUERY_NODE_DROP_DATABASE_STMT: - code = makeNode(type, sizeof(SDropDatabaseStmt), &pNode); break; + code = makeNode(type, sizeof(SDropDatabaseStmt), &pNode); + break; case QUERY_NODE_ALTER_DATABASE_STMT: - code = makeNode(type, sizeof(SAlterDatabaseStmt), &pNode); break; + code = makeNode(type, sizeof(SAlterDatabaseStmt), &pNode); + break; case QUERY_NODE_FLUSH_DATABASE_STMT: - code = makeNode(type, sizeof(SFlushDatabaseStmt), &pNode); break; + code = makeNode(type, sizeof(SFlushDatabaseStmt), &pNode); + break; case QUERY_NODE_TRIM_DATABASE_STMT: - code = makeNode(type, sizeof(STrimDatabaseStmt), &pNode); break; + code = makeNode(type, sizeof(STrimDatabaseStmt), &pNode); + break; case QUERY_NODE_S3MIGRATE_DATABASE_STMT: - code = makeNode(type, sizeof(SS3MigrateDatabaseStmt), &pNode); break; + code = makeNode(type, sizeof(SS3MigrateDatabaseStmt), &pNode); + break; case QUERY_NODE_CREATE_TABLE_STMT: - code = makeNode(type, sizeof(SCreateTableStmt), &pNode); break; + code = makeNode(type, sizeof(SCreateTableStmt), &pNode); + break; case QUERY_NODE_CREATE_SUBTABLE_CLAUSE: - code = makeNode(type, sizeof(SCreateSubTableClause), &pNode); break; + code = makeNode(type, sizeof(SCreateSubTableClause), &pNode); + break; case QUERY_NODE_CREATE_SUBTABLE_FROM_FILE_CLAUSE: - code = makeNode(type, sizeof(SCreateSubTableFromFileClause), &pNode); break; + code = makeNode(type, sizeof(SCreateSubTableFromFileClause), &pNode); + break; case QUERY_NODE_CREATE_MULTI_TABLES_STMT: - code = makeNode(type, sizeof(SCreateMultiTablesStmt), &pNode); break; + code = makeNode(type, sizeof(SCreateMultiTablesStmt), &pNode); + break; case QUERY_NODE_DROP_TABLE_CLAUSE: - code = makeNode(type, sizeof(SDropTableClause), &pNode); break; + code = makeNode(type, sizeof(SDropTableClause), &pNode); + break; case QUERY_NODE_DROP_TABLE_STMT: - code = makeNode(type, sizeof(SDropTableStmt), &pNode); break; + code = makeNode(type, sizeof(SDropTableStmt), &pNode); + break; case QUERY_NODE_DROP_SUPER_TABLE_STMT: - code = makeNode(type, sizeof(SDropSuperTableStmt), &pNode); break; + code = makeNode(type, sizeof(SDropSuperTableStmt), &pNode); + break; case QUERY_NODE_ALTER_TABLE_STMT: case QUERY_NODE_ALTER_SUPER_TABLE_STMT: - code = makeNode(type, sizeof(SAlterTableStmt), &pNode); break; + code = makeNode(type, sizeof(SAlterTableStmt), &pNode); + break; case QUERY_NODE_CREATE_USER_STMT: - code = makeNode(type, sizeof(SCreateUserStmt), &pNode); break; + code = makeNode(type, sizeof(SCreateUserStmt), &pNode); + break; case QUERY_NODE_ALTER_USER_STMT: - code = makeNode(type, sizeof(SAlterUserStmt), &pNode); break; + code = makeNode(type, sizeof(SAlterUserStmt), &pNode); + break; case QUERY_NODE_DROP_USER_STMT: - code = makeNode(type, sizeof(SDropUserStmt), &pNode); break; + code = makeNode(type, sizeof(SDropUserStmt), &pNode); + break; case QUERY_NODE_USE_DATABASE_STMT: - code = makeNode(type, sizeof(SUseDatabaseStmt), &pNode); break; + code = makeNode(type, sizeof(SUseDatabaseStmt), &pNode); + break; case QUERY_NODE_CREATE_DNODE_STMT: - code = makeNode(type, sizeof(SCreateDnodeStmt), &pNode); break; + code = makeNode(type, sizeof(SCreateDnodeStmt), &pNode); + break; case QUERY_NODE_DROP_DNODE_STMT: - code = makeNode(type, sizeof(SDropDnodeStmt), &pNode); break; + code = makeNode(type, sizeof(SDropDnodeStmt), &pNode); + break; case QUERY_NODE_ALTER_DNODE_STMT: - code = makeNode(type, sizeof(SAlterDnodeStmt), &pNode); break; + code = makeNode(type, sizeof(SAlterDnodeStmt), &pNode); + break; case QUERY_NODE_CREATE_INDEX_STMT: - code = makeNode(type, sizeof(SCreateIndexStmt), &pNode); break; + code = makeNode(type, sizeof(SCreateIndexStmt), &pNode); + break; case QUERY_NODE_DROP_INDEX_STMT: - code = makeNode(type, sizeof(SDropIndexStmt), &pNode); break; + code = makeNode(type, sizeof(SDropIndexStmt), &pNode); + break; case QUERY_NODE_CREATE_QNODE_STMT: case QUERY_NODE_CREATE_BNODE_STMT: case QUERY_NODE_CREATE_SNODE_STMT: case QUERY_NODE_CREATE_MNODE_STMT: - code = makeNode(type, sizeof(SCreateComponentNodeStmt), &pNode); break; + code = makeNode(type, sizeof(SCreateComponentNodeStmt), &pNode); + break; case QUERY_NODE_DROP_QNODE_STMT: case QUERY_NODE_DROP_BNODE_STMT: case QUERY_NODE_DROP_SNODE_STMT: case QUERY_NODE_DROP_MNODE_STMT: - code = makeNode(type, sizeof(SDropComponentNodeStmt), &pNode); break; + code = makeNode(type, sizeof(SDropComponentNodeStmt), &pNode); + break; case QUERY_NODE_CREATE_TOPIC_STMT: - code = makeNode(type, sizeof(SCreateTopicStmt), &pNode); break; + code = makeNode(type, sizeof(SCreateTopicStmt), &pNode); + break; case QUERY_NODE_DROP_TOPIC_STMT: - code = makeNode(type, sizeof(SDropTopicStmt), &pNode); break; + code = makeNode(type, sizeof(SDropTopicStmt), &pNode); + break; case QUERY_NODE_DROP_CGROUP_STMT: - code = makeNode(type, sizeof(SDropCGroupStmt), &pNode); break; + code = makeNode(type, sizeof(SDropCGroupStmt), &pNode); + break; case QUERY_NODE_ALTER_LOCAL_STMT: - code = makeNode(type, sizeof(SAlterLocalStmt), &pNode); break; + code = makeNode(type, sizeof(SAlterLocalStmt), &pNode); + break; case QUERY_NODE_EXPLAIN_STMT: - code = makeNode(type, sizeof(SExplainStmt), &pNode); break; + code = makeNode(type, sizeof(SExplainStmt), &pNode); + break; case QUERY_NODE_DESCRIBE_STMT: - code = makeNode(type, sizeof(SDescribeStmt), &pNode); break; + code = makeNode(type, sizeof(SDescribeStmt), &pNode); + break; case QUERY_NODE_RESET_QUERY_CACHE_STMT: - code = makeNode(type, sizeof(SNode), &pNode); break; + code = makeNode(type, sizeof(SNode), &pNode); + break; case QUERY_NODE_COMPACT_DATABASE_STMT: - code = makeNode(type, sizeof(SCompactDatabaseStmt), &pNode); break; + code = makeNode(type, sizeof(SCompactDatabaseStmt), &pNode); + break; case QUERY_NODE_CREATE_FUNCTION_STMT: - code = makeNode(type, sizeof(SCreateFunctionStmt), &pNode); break; + code = makeNode(type, sizeof(SCreateFunctionStmt), &pNode); + break; case QUERY_NODE_DROP_FUNCTION_STMT: - code = makeNode(type, sizeof(SDropFunctionStmt), &pNode); break; + code = makeNode(type, sizeof(SDropFunctionStmt), &pNode); + break; case QUERY_NODE_CREATE_STREAM_STMT: - code = makeNode(type, sizeof(SCreateStreamStmt), &pNode); break; + code = makeNode(type, sizeof(SCreateStreamStmt), &pNode); + break; case QUERY_NODE_DROP_STREAM_STMT: - code = makeNode(type, sizeof(SDropStreamStmt), &pNode); break; + code = makeNode(type, sizeof(SDropStreamStmt), &pNode); + break; case QUERY_NODE_PAUSE_STREAM_STMT: - code = makeNode(type, sizeof(SPauseStreamStmt), &pNode); break; + code = makeNode(type, sizeof(SPauseStreamStmt), &pNode); + break; case QUERY_NODE_RESUME_STREAM_STMT: - code = makeNode(type, sizeof(SResumeStreamStmt), &pNode); break; + code = makeNode(type, sizeof(SResumeStreamStmt), &pNode); + break; case QUERY_NODE_BALANCE_VGROUP_STMT: - code = makeNode(type, sizeof(SBalanceVgroupStmt), &pNode); break; + code = makeNode(type, sizeof(SBalanceVgroupStmt), &pNode); + break; case QUERY_NODE_BALANCE_VGROUP_LEADER_STMT: - code = makeNode(type, sizeof(SBalanceVgroupLeaderStmt), &pNode); break; + code = makeNode(type, sizeof(SBalanceVgroupLeaderStmt), &pNode); + break; case QUERY_NODE_BALANCE_VGROUP_LEADER_DATABASE_STMT: - code = makeNode(type, sizeof(SBalanceVgroupLeaderStmt), &pNode); break; + code = makeNode(type, sizeof(SBalanceVgroupLeaderStmt), &pNode); + break; case QUERY_NODE_MERGE_VGROUP_STMT: - code = makeNode(type, sizeof(SMergeVgroupStmt), &pNode); break; + code = makeNode(type, sizeof(SMergeVgroupStmt), &pNode); + break; case QUERY_NODE_REDISTRIBUTE_VGROUP_STMT: - code = makeNode(type, sizeof(SRedistributeVgroupStmt), &pNode); break; + code = makeNode(type, sizeof(SRedistributeVgroupStmt), &pNode); + break; case QUERY_NODE_SPLIT_VGROUP_STMT: - code = makeNode(type, sizeof(SSplitVgroupStmt), &pNode); break; + code = makeNode(type, sizeof(SSplitVgroupStmt), &pNode); + break; case QUERY_NODE_SYNCDB_STMT: break; case QUERY_NODE_GRANT_STMT: - code = makeNode(type, sizeof(SGrantStmt), &pNode); break; + code = makeNode(type, sizeof(SGrantStmt), &pNode); + break; case QUERY_NODE_REVOKE_STMT: - code = makeNode(type, sizeof(SRevokeStmt), &pNode); break; + code = makeNode(type, sizeof(SRevokeStmt), &pNode); + break; case QUERY_NODE_ALTER_CLUSTER_STMT: - code = makeNode(type, sizeof(SAlterClusterStmt), &pNode); break; + code = makeNode(type, sizeof(SAlterClusterStmt), &pNode); + break; case QUERY_NODE_SHOW_DNODES_STMT: case QUERY_NODE_SHOW_MNODES_STMT: case QUERY_NODE_SHOW_MODULES_STMT: @@ -567,181 +655,266 @@ int32_t nodesMakeNode(ENodeType type, SNode** ppNodeOut) { case QUERY_NODE_SHOW_CLUSTER_MACHINES_STMT: case QUERY_NODE_SHOW_ENCRYPTIONS_STMT: case QUERY_NODE_SHOW_TSMAS_STMT: - code = makeNode(type, sizeof(SShowStmt), &pNode); break; + case QUERY_NODE_SHOW_USAGE_STMT: + code = makeNode(type, sizeof(SShowStmt), &pNode); + break; case QUERY_NODE_SHOW_TABLE_TAGS_STMT: - code = makeNode(type, sizeof(SShowTableTagsStmt), &pNode); break; + code = makeNode(type, sizeof(SShowTableTagsStmt), &pNode); + break; case QUERY_NODE_SHOW_DNODE_VARIABLES_STMT: - code = makeNode(type, sizeof(SShowDnodeVariablesStmt), &pNode); break; + code = makeNode(type, sizeof(SShowDnodeVariablesStmt), &pNode); + break; case QUERY_NODE_SHOW_CREATE_DATABASE_STMT: - code = makeNode(type, sizeof(SShowCreateDatabaseStmt), &pNode); break; + code = makeNode(type, sizeof(SShowCreateDatabaseStmt), &pNode); + break; case QUERY_NODE_SHOW_DB_ALIVE_STMT: case QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT: - code = makeNode(type, sizeof(SShowAliveStmt), &pNode); break; + code = makeNode(type, sizeof(SShowAliveStmt), &pNode); + break; case QUERY_NODE_SHOW_CREATE_TABLE_STMT: case QUERY_NODE_SHOW_CREATE_STABLE_STMT: - code = makeNode(type, sizeof(SShowCreateTableStmt), &pNode); break; + code = makeNode(type, sizeof(SShowCreateTableStmt), &pNode); + break; case QUERY_NODE_SHOW_CREATE_VIEW_STMT: - code = makeNode(type, sizeof(SShowCreateViewStmt), &pNode); break; + code = makeNode(type, sizeof(SShowCreateViewStmt), &pNode); + break; case QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT: - code = makeNode(type, sizeof(SShowTableDistributedStmt), &pNode); break; + code = makeNode(type, sizeof(SShowTableDistributedStmt), &pNode); + break; case QUERY_NODE_SHOW_COMPACTS_STMT: - code = makeNode(type, sizeof(SShowCompactsStmt), &pNode); break; + code = makeNode(type, sizeof(SShowCompactsStmt), &pNode); + break; case QUERY_NODE_SHOW_COMPACT_DETAILS_STMT: - code = makeNode(type, sizeof(SShowCompactDetailsStmt), &pNode); break; + code = makeNode(type, sizeof(SShowCompactDetailsStmt), &pNode); + break; case QUERY_NODE_KILL_QUERY_STMT: - code = makeNode(type, sizeof(SKillQueryStmt), &pNode); break; + code = makeNode(type, sizeof(SKillQueryStmt), &pNode); + break; case QUERY_NODE_KILL_TRANSACTION_STMT: case QUERY_NODE_KILL_CONNECTION_STMT: case QUERY_NODE_KILL_COMPACT_STMT: - code = makeNode(type, sizeof(SKillStmt), &pNode); break; + code = makeNode(type, sizeof(SKillStmt), &pNode); + break; case QUERY_NODE_DELETE_STMT: - code = makeNode(type, sizeof(SDeleteStmt), &pNode); break; + code = makeNode(type, sizeof(SDeleteStmt), &pNode); + break; case QUERY_NODE_INSERT_STMT: - code = makeNode(type, sizeof(SInsertStmt), &pNode); break; + code = makeNode(type, sizeof(SInsertStmt), &pNode); + break; case QUERY_NODE_QUERY: - code = makeNode(type, sizeof(SQuery), &pNode); break; + code = makeNode(type, sizeof(SQuery), &pNode); + break; case QUERY_NODE_RESTORE_DNODE_STMT: case QUERY_NODE_RESTORE_QNODE_STMT: case QUERY_NODE_RESTORE_MNODE_STMT: case QUERY_NODE_RESTORE_VNODE_STMT: - code = makeNode(type, sizeof(SRestoreComponentNodeStmt), &pNode); break; + code = makeNode(type, sizeof(SRestoreComponentNodeStmt), &pNode); + break; case QUERY_NODE_CREATE_VIEW_STMT: - code = makeNode(type, sizeof(SCreateViewStmt), &pNode); break; + code = makeNode(type, sizeof(SCreateViewStmt), &pNode); + break; case QUERY_NODE_DROP_VIEW_STMT: - code = makeNode(type, sizeof(SDropViewStmt), &pNode); break; + code = makeNode(type, sizeof(SDropViewStmt), &pNode); + break; case QUERY_NODE_CREATE_TSMA_STMT: - code = makeNode(type, sizeof(SCreateTSMAStmt), &pNode); break; + code = makeNode(type, sizeof(SCreateTSMAStmt), &pNode); + break; case QUERY_NODE_DROP_TSMA_STMT: - code = makeNode(type, sizeof(SDropTSMAStmt), &pNode); break; + code = makeNode(type, sizeof(SDropTSMAStmt), &pNode); + break; case QUERY_NODE_TSMA_OPTIONS: - code = makeNode(type, sizeof(STSMAOptions), &pNode); break; + code = makeNode(type, sizeof(STSMAOptions), &pNode); + break; case QUERY_NODE_LOGIC_PLAN_SCAN: - code = makeNode(type, sizeof(SScanLogicNode), &pNode); break; + code = makeNode(type, sizeof(SScanLogicNode), &pNode); + break; case QUERY_NODE_LOGIC_PLAN_JOIN: - code = makeNode(type, sizeof(SJoinLogicNode), &pNode); break; + code = makeNode(type, sizeof(SJoinLogicNode), &pNode); + break; case QUERY_NODE_LOGIC_PLAN_AGG: - code = makeNode(type, sizeof(SAggLogicNode), &pNode); break; + code = makeNode(type, sizeof(SAggLogicNode), &pNode); + break; case QUERY_NODE_LOGIC_PLAN_PROJECT: - code = makeNode(type, sizeof(SProjectLogicNode), &pNode); break; + code = makeNode(type, sizeof(SProjectLogicNode), &pNode); + break; case QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY: - code = makeNode(type, sizeof(SVnodeModifyLogicNode), &pNode); break; + code = makeNode(type, sizeof(SVnodeModifyLogicNode), &pNode); + break; case QUERY_NODE_LOGIC_PLAN_EXCHANGE: - code = makeNode(type, sizeof(SExchangeLogicNode), &pNode); break; + code = makeNode(type, sizeof(SExchangeLogicNode), &pNode); + break; case QUERY_NODE_LOGIC_PLAN_MERGE: - code = makeNode(type, sizeof(SMergeLogicNode), &pNode); break; + code = makeNode(type, sizeof(SMergeLogicNode), &pNode); + break; case QUERY_NODE_LOGIC_PLAN_WINDOW: - code = makeNode(type, sizeof(SWindowLogicNode), &pNode); break; + code = makeNode(type, sizeof(SWindowLogicNode), &pNode); + break; case QUERY_NODE_LOGIC_PLAN_FILL: - code = makeNode(type, sizeof(SFillLogicNode), &pNode); break; + code = makeNode(type, sizeof(SFillLogicNode), &pNode); + break; case QUERY_NODE_LOGIC_PLAN_SORT: - code = makeNode(type, sizeof(SSortLogicNode), &pNode); break; + code = makeNode(type, sizeof(SSortLogicNode), &pNode); + break; case QUERY_NODE_LOGIC_PLAN_PARTITION: - code = makeNode(type, sizeof(SPartitionLogicNode), &pNode); break; + code = makeNode(type, sizeof(SPartitionLogicNode), &pNode); + break; case QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC: - code = makeNode(type, sizeof(SIndefRowsFuncLogicNode), &pNode); break; + code = makeNode(type, sizeof(SIndefRowsFuncLogicNode), &pNode); + break; case QUERY_NODE_LOGIC_PLAN_INTERP_FUNC: - code = makeNode(type, sizeof(SInterpFuncLogicNode), &pNode); break; + code = makeNode(type, sizeof(SInterpFuncLogicNode), &pNode); + break; case QUERY_NODE_LOGIC_PLAN_GROUP_CACHE: - code = makeNode(type, sizeof(SGroupCacheLogicNode), &pNode); break; + code = makeNode(type, sizeof(SGroupCacheLogicNode), &pNode); + break; case QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL: - code = makeNode(type, sizeof(SDynQueryCtrlLogicNode), &pNode); break; + code = makeNode(type, sizeof(SDynQueryCtrlLogicNode), &pNode); + break; case QUERY_NODE_LOGIC_SUBPLAN: - code = makeNode(type, sizeof(SLogicSubplan), &pNode); break; + code = makeNode(type, sizeof(SLogicSubplan), &pNode); + break; case QUERY_NODE_LOGIC_PLAN: - code = makeNode(type, sizeof(SQueryLogicPlan), &pNode); break; + code = makeNode(type, sizeof(SQueryLogicPlan), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN: - code = makeNode(type, sizeof(STagScanPhysiNode), &pNode); break; + code = makeNode(type, sizeof(STagScanPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN: - code = makeNode(type, sizeof(STableScanPhysiNode), &pNode); break; + code = makeNode(type, sizeof(STableScanPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN: - code = makeNode(type, sizeof(STableSeqScanPhysiNode), &pNode); break; + code = makeNode(type, sizeof(STableSeqScanPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN: - code = makeNode(type, sizeof(STableMergeScanPhysiNode), &pNode); break; + code = makeNode(type, sizeof(STableMergeScanPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN: - code = makeNode(type, sizeof(SStreamScanPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SStreamScanPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN: - code = makeNode(type, sizeof(SSystemTableScanPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SSystemTableScanPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN: - code = makeNode(type, sizeof(SBlockDistScanPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SBlockDistScanPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN: - code = makeNode(type, sizeof(SLastRowScanPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SLastRowScanPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN: - code = makeNode(type, sizeof(STableCountScanPhysiNode), &pNode); break; + code = makeNode(type, sizeof(STableCountScanPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_PROJECT: - code = makeNode(type, sizeof(SProjectPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SProjectPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN: - code = makeNode(type, sizeof(SSortMergeJoinPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SSortMergeJoinPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN: - code = makeNode(type, sizeof(SHashJoinPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SHashJoinPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG: - code = makeNode(type, sizeof(SAggPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SAggPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE: - code = makeNode(type, sizeof(SExchangePhysiNode), &pNode); break; + code = makeNode(type, sizeof(SExchangePhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_MERGE: - code = makeNode(type, sizeof(SMergePhysiNode), &pNode); break; + code = makeNode(type, sizeof(SMergePhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_SORT: - code = makeNode(type, sizeof(SSortPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SSortPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT: - code = makeNode(type, sizeof(SGroupSortPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SGroupSortPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL: - code = makeNode(type, sizeof(SIntervalPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SIntervalPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL: - code = makeNode(type, sizeof(SMergeAlignedIntervalPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SMergeAlignedIntervalPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL: - code = makeNode(type, sizeof(SStreamIntervalPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SStreamIntervalPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL: - code = makeNode(type, sizeof(SStreamFinalIntervalPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SStreamFinalIntervalPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL: - code = makeNode(type, sizeof(SStreamSemiIntervalPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SStreamSemiIntervalPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL: - code = makeNode(type, sizeof(SStreamMidIntervalPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SStreamMidIntervalPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_FILL: case QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL: - code = makeNode(type, sizeof(SFillPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SFillPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION: - code = makeNode(type, sizeof(SSessionWinodwPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SSessionWinodwPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION: - code = makeNode(type, sizeof(SStreamSessionWinodwPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SStreamSessionWinodwPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION: - code = makeNode(type, sizeof(SStreamSemiSessionWinodwPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SStreamSemiSessionWinodwPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION: - code = makeNode(type, sizeof(SStreamFinalSessionWinodwPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SStreamFinalSessionWinodwPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE: - code = makeNode(type, sizeof(SStateWinodwPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SStateWinodwPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE: - code = makeNode(type, sizeof(SStreamStateWinodwPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SStreamStateWinodwPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT: - code = makeNode(type, sizeof(SEventWinodwPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SEventWinodwPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT: - code = makeNode(type, sizeof(SStreamEventWinodwPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SStreamEventWinodwPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT: - code = makeNode(type, sizeof(SCountWinodwPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SCountWinodwPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_COUNT: - code = makeNode(type, sizeof(SStreamCountWinodwPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SStreamCountWinodwPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_PARTITION: - code = makeNode(type, sizeof(SPartitionPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SPartitionPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION: - code = makeNode(type, sizeof(SStreamPartitionPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SStreamPartitionPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC: - code = makeNode(type, sizeof(SIndefRowsFuncPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SIndefRowsFuncPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC: - code = makeNode(type, sizeof(SInterpFuncLogicNode), &pNode); break; + code = makeNode(type, sizeof(SInterpFuncLogicNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_DISPATCH: - code = makeNode(type, sizeof(SDataDispatcherNode), &pNode); break; + code = makeNode(type, sizeof(SDataDispatcherNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_INSERT: - code = makeNode(type, sizeof(SDataInserterNode), &pNode); break; + code = makeNode(type, sizeof(SDataInserterNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT: - code = makeNode(type, sizeof(SQueryInserterNode), &pNode); break; + code = makeNode(type, sizeof(SQueryInserterNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_DELETE: - code = makeNode(type, sizeof(SDataDeleterNode), &pNode); break; + code = makeNode(type, sizeof(SDataDeleterNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE: - code = makeNode(type, sizeof(SGroupCachePhysiNode), &pNode); break; + code = makeNode(type, sizeof(SGroupCachePhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL: - code = makeNode(type, sizeof(SDynQueryCtrlPhysiNode), &pNode); break; + code = makeNode(type, sizeof(SDynQueryCtrlPhysiNode), &pNode); + break; case QUERY_NODE_PHYSICAL_SUBPLAN: - code = makeNode(type, sizeof(SSubplan), &pNode); break; + code = makeNode(type, sizeof(SSubplan), &pNode); + break; case QUERY_NODE_PHYSICAL_PLAN: - code = makeNode(type, sizeof(SQueryPlan), &pNode); break; + code = makeNode(type, sizeof(SQueryPlan), &pNode); + break; default: break; } @@ -931,7 +1104,7 @@ void nodesDestroyNode(SNode* pNode) { case QUERY_NODE_DATABLOCK_DESC: nodesDestroyList(((SDataBlockDescNode*)pNode)->pSlots); break; - case QUERY_NODE_SLOT_DESC: // no pointer field + case QUERY_NODE_SLOT_DESC: // no pointer field break; case QUERY_NODE_COLUMN_DEF: nodesDestroyNode(((SColumnDefNode*)pNode)->pOptions); @@ -1104,7 +1277,7 @@ void nodesDestroyNode(SNode* pNode) { case QUERY_NODE_FLUSH_DATABASE_STMT: // no pointer field case QUERY_NODE_TRIM_DATABASE_STMT: // no pointer field break; - case QUERY_NODE_S3MIGRATE_DATABASE_STMT: // no pointer field + case QUERY_NODE_S3MIGRATE_DATABASE_STMT: // no pointer field break; case QUERY_NODE_CREATE_TABLE_STMT: { SCreateTableStmt* pStmt = (SCreateTableStmt*)pNode; @@ -1217,13 +1390,13 @@ void nodesDestroyNode(SNode* pNode) { taosMemoryFreeClear(pStmt->pReq); break; } - case QUERY_NODE_DROP_STREAM_STMT: // no pointer field - case QUERY_NODE_PAUSE_STREAM_STMT: // no pointer field - case QUERY_NODE_RESUME_STREAM_STMT: // no pointer field - case QUERY_NODE_BALANCE_VGROUP_STMT: // no pointer field - case QUERY_NODE_BALANCE_VGROUP_LEADER_STMT: // no pointer field + case QUERY_NODE_DROP_STREAM_STMT: // no pointer field + case QUERY_NODE_PAUSE_STREAM_STMT: // no pointer field + case QUERY_NODE_RESUME_STREAM_STMT: // no pointer field + case QUERY_NODE_BALANCE_VGROUP_STMT: // no pointer field + case QUERY_NODE_BALANCE_VGROUP_LEADER_STMT: // no pointer field case QUERY_NODE_BALANCE_VGROUP_LEADER_DATABASE_STMT: // no pointer field - case QUERY_NODE_MERGE_VGROUP_STMT: // no pointer field + case QUERY_NODE_MERGE_VGROUP_STMT: // no pointer field break; case QUERY_NODE_REDISTRIBUTE_VGROUP_STMT: nodesDestroyList(((SRedistributeVgroupStmt*)pNode)->pDnodes); @@ -1237,7 +1410,7 @@ void nodesDestroyNode(SNode* pNode) { case QUERY_NODE_REVOKE_STMT: nodesDestroyNode(((SRevokeStmt*)pNode)->pTagCond); break; - case QUERY_NODE_ALTER_CLUSTER_STMT: // no pointer field + case QUERY_NODE_ALTER_CLUSTER_STMT: // no pointer field break; case QUERY_NODE_SHOW_DNODES_STMT: case QUERY_NODE_SHOW_MNODES_STMT: @@ -1275,7 +1448,8 @@ void nodesDestroyNode(SNode* pNode) { case QUERY_NODE_SHOW_GRANTS_LOGS_STMT: case QUERY_NODE_SHOW_CLUSTER_MACHINES_STMT: case QUERY_NODE_SHOW_ENCRYPTIONS_STMT: - case QUERY_NODE_SHOW_TSMAS_STMT: { + case QUERY_NODE_SHOW_TSMAS_STMT: + case QUERY_NODE_SHOW_USAGE_STMT: { SShowStmt* pStmt = (SShowStmt*)pNode; nodesDestroyNode(pStmt->pDbName); nodesDestroyNode(pStmt->pTbName); @@ -1348,12 +1522,12 @@ void nodesDestroyNode(SNode* pNode) { nodesDestroyNode(pQuery->pPrepareRoot); break; } - case QUERY_NODE_RESTORE_DNODE_STMT: // no pointer field - case QUERY_NODE_RESTORE_QNODE_STMT: // no pointer field - case QUERY_NODE_RESTORE_MNODE_STMT: // no pointer field - case QUERY_NODE_RESTORE_VNODE_STMT: // no pointer field + case QUERY_NODE_RESTORE_DNODE_STMT: // no pointer field + case QUERY_NODE_RESTORE_QNODE_STMT: // no pointer field + case QUERY_NODE_RESTORE_MNODE_STMT: // no pointer field + case QUERY_NODE_RESTORE_VNODE_STMT: // no pointer field break; - case QUERY_NODE_CREATE_VIEW_STMT: { + case QUERY_NODE_CREATE_VIEW_STMT: { SCreateViewStmt* pStmt = (SCreateViewStmt*)pNode; taosMemoryFree(pStmt->pQuerySql); tFreeSCMCreateViewReq(&pStmt->createReq); @@ -1370,7 +1544,7 @@ void nodesDestroyNode(SNode* pNode) { taosMemoryFreeClear(pStmt->pReq); } break; - } + } case QUERY_NODE_LOGIC_PLAN_SCAN: { SScanLogicNode* pLogicNode = (SScanLogicNode*)pNode; destroyLogicNode((SLogicNode*)pLogicNode); @@ -1737,7 +1911,7 @@ void nodesDestroyNode(SNode* pNode) { int32_t nodesMakeList(SNodeList** ppListOut) { SNodeList* p = NULL; - int32_t code = nodesCalloc(1, sizeof(SNodeList), (void**)&p); + int32_t code = nodesCalloc(1, sizeof(SNodeList), (void**)&p); if (TSDB_CODE_SUCCESS == code) { *ppListOut = p; } @@ -1749,7 +1923,7 @@ int32_t nodesListAppend(SNodeList* pList, SNode* pNode) { return TSDB_CODE_FAILED; } SListCell* p = NULL; - int32_t code = nodesCalloc(1, sizeof(SListCell), (void**)&p); + int32_t code = nodesCalloc(1, sizeof(SListCell), (void**)&p); if (TSDB_CODE_SUCCESS != code) { return code; } @@ -1828,7 +2002,6 @@ int32_t nodesListStrictAppendList(SNodeList* pTarget, SNodeList* pSrc) { return code; } - int32_t nodesListMakeStrictAppendList(SNodeList** pTarget, SNodeList* pSrc) { if (NULL == *pTarget) { int32_t code = nodesMakeList(pTarget); @@ -1839,7 +2012,7 @@ int32_t nodesListMakeStrictAppendList(SNodeList** pTarget, SNodeList* pSrc) { return nodesListStrictAppendList(*pTarget, pSrc); } -int32_t nodesListMakePushFront(SNodeList** pList, SNode* pNode) { +int32_t nodesListMakePushFront(SNodeList** pList, SNode* pNode) { if (*pList == NULL) { int32_t code = nodesMakeList(pList); if (*pList == NULL) { @@ -1854,7 +2027,7 @@ int32_t nodesListPushFront(SNodeList* pList, SNode* pNode) { return TSDB_CODE_FAILED; } SListCell* p = NULL; - int32_t code = nodesCalloc(1, sizeof(SListCell), (void**)&p); + int32_t code = nodesCalloc(1, sizeof(SListCell), (void**)&p); if (TSDB_CODE_SUCCESS != code) { return code; } @@ -2277,7 +2450,8 @@ static EDealRes doCollect(SCollectColumnsCxt* pCxt, SColumnNode* pCol, SNode* pN static bool isCollectType(ECollectColType collectType, EColumnType colType) { return COLLECT_COL_TYPE_ALL == collectType ? true - : (COLLECT_COL_TYPE_TAG == collectType ? COLUMN_TYPE_TAG == colType : (COLUMN_TYPE_TAG != colType && COLUMN_TYPE_TBNAME != colType)); + : (COLLECT_COL_TYPE_TAG == collectType ? COLUMN_TYPE_TAG == colType + : (COLUMN_TYPE_TAG != colType && COLUMN_TYPE_TBNAME != colType)); } static EDealRes collectColumns(SNode* pNode, void* pContext) { @@ -2297,20 +2471,21 @@ static EDealRes collectColumnsExt(SNode* pNode, void* pContext) { if (QUERY_NODE_COLUMN == nodeType(pNode)) { SColumnNode* pCol = (SColumnNode*)pNode; if (isCollectType(pCxt->collectType, pCol->colType) && 0 != strcmp(pCol->colName, "*") && - (NULL == pCxt->pMultiTableAlias || NULL != (pCxt->pTableAlias = tSimpleHashGet(pCxt->pMultiTableAlias, pCol->tableAlias, strlen(pCol->tableAlias))))) { + (NULL == pCxt->pMultiTableAlias || + NULL != (pCxt->pTableAlias = + tSimpleHashGet(pCxt->pMultiTableAlias, pCol->tableAlias, strlen(pCol->tableAlias))))) { return doCollect(pCxt, pCol, pNode); } } return DEAL_RES_CONTINUE; } - int32_t nodesCollectColumns(SSelectStmt* pSelect, ESqlClause clause, const char* pTableAlias, ECollectColType type, SNodeList** pCols) { if (NULL == pSelect || NULL == pCols) { return TSDB_CODE_FAILED; } - SNodeList * pList = NULL; + SNodeList* pList = NULL; if (!*pCols) { int32_t code = nodesMakeList(&pList); if (TSDB_CODE_SUCCESS != code) { @@ -2342,13 +2517,13 @@ int32_t nodesCollectColumns(SSelectStmt* pSelect, ESqlClause clause, const char* return TSDB_CODE_SUCCESS; } -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) { if (NULL == pSelect || NULL == pCols) { return TSDB_CODE_FAILED; } - SNodeList * pList = NULL; + SNodeList* pList = NULL; if (!*pCols) { int32_t code = nodesMakeList(&pList); if (TSDB_CODE_SUCCESS != code) { @@ -2386,7 +2561,7 @@ int32_t nodesCollectColumnsFromNode(SNode* node, const char* pTableAlias, EColle if (NULL == pCols) { return TSDB_CODE_FAILED; } - SNodeList * pList = NULL; + SNodeList* pList = NULL; if (!*pCols) { int32_t code = nodesMakeList(&pList); if (TSDB_CODE_SUCCESS != code) { @@ -2440,7 +2615,7 @@ static EDealRes collectFuncs(SNode* pNode, void* pContext) { } } - bool bFound = false; + bool bFound = false; SNode* pn = NULL; FOREACH(pn, pCxt->pFuncs) { if (nodesEqualNode(pn, pNode)) { @@ -2472,21 +2647,21 @@ static int32_t funcNodeEqual(const void* pLeft, const void* pRight, size_t len) return nodesEqualNode(*(const SNode**)pLeft, *(const SNode**)pRight) ? 0 : 1; } -int32_t nodesCollectSelectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList* pFuncs) { +int32_t nodesCollectSelectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, + SNodeList* pFuncs) { if (NULL == pSelect || NULL == pFuncs) { return TSDB_CODE_FAILED; } - SCollectFuncsCxt cxt = {.errCode = TSDB_CODE_SUCCESS, - .classifier = classifier, - .tableAlias = tableAlias, - .pFuncs = pFuncs}; + SCollectFuncsCxt cxt = { + .errCode = TSDB_CODE_SUCCESS, .classifier = classifier, .tableAlias = tableAlias, .pFuncs = pFuncs}; nodesWalkSelectStmt(pSelect, clause, collectFuncs, &cxt); return cxt.errCode; } -int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, SNodeList** pFuncs) { +int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAlias, FFuncClassifier classifier, + SNodeList** pFuncs) { if (NULL == pSelect || NULL == pFuncs) { return TSDB_CODE_FAILED; } @@ -2702,7 +2877,7 @@ int32_t nodesMergeConds(SNode** pDst, SNodeList** pSrc) { nodesClearList(*pSrc); } else { SLogicConditionNode* pLogicCond = NULL; - int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogicCond); + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogicCond); if (TSDB_CODE_SUCCESS != code) { return code; } @@ -2734,13 +2909,13 @@ const char* dataOrderStr(EDataOrderLevel order) { } int32_t nodesMakeValueNodeFromString(char* literal, SValueNode** ppValNode) { - int32_t lenStr = strlen(literal); + int32_t lenStr = strlen(literal); SValueNode* pValNode = NULL; - int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValNode); + int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValNode); if (pValNode) { pValNode->node.resType.type = TSDB_DATA_TYPE_VARCHAR; pValNode->node.resType.bytes = lenStr + VARSTR_HEADER_SIZE; - char* p = taosMemoryMalloc(lenStr + 1 + VARSTR_HEADER_SIZE); + char* p = taosMemoryMalloc(lenStr + 1 + VARSTR_HEADER_SIZE); if (p == NULL) { return TSDB_CODE_OUT_OF_MEMORY; } @@ -2757,7 +2932,7 @@ int32_t nodesMakeValueNodeFromString(char* literal, SValueNode** ppValNode) { int32_t nodesMakeValueNodeFromBool(bool b, SValueNode** ppValNode) { SValueNode* pValNode = NULL; - int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValNode); + int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValNode); if (TSDB_CODE_SUCCESS == code) { pValNode->node.resType.type = TSDB_DATA_TYPE_BOOL; pValNode->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes; @@ -2775,7 +2950,7 @@ int32_t nodesMakeValueNodeFromBool(bool b, SValueNode** ppValNode) { int32_t nodesMakeValueNodeFromInt32(int32_t value, SNode** ppNode) { SValueNode* pValNode = NULL; - int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValNode); + int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValNode); if (TSDB_CODE_SUCCESS == code) { pValNode->node.resType.type = TSDB_DATA_TYPE_INT; pValNode->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_INT].bytes; @@ -2804,7 +2979,7 @@ bool nodesIsTableStar(SNode* pNode) { void nodesSortList(SNodeList** pList, int32_t (*comp)(SNode* pNode1, SNode* pNode2)) { if ((*pList)->length == 1) return; - uint32_t inSize = 1; + uint32_t inSize = 1; SListCell* pHead = (*pList)->pHead; while (1) { SListCell* p = pHead; @@ -2815,7 +2990,7 @@ void nodesSortList(SNodeList** pList, int32_t (*comp)(SNode* pNode1, SNode* pNod while (p) { ++nMerges; SListCell* q = p; - uint32_t pSize = 0; + uint32_t pSize = 0; for (uint32_t i = 0; i < inSize; ++i) { ++pSize; q = q->pNext; diff --git a/source/libs/parser/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c index cd7cda01e0..7c00d2c00c 100644 --- a/source/libs/parser/src/parAstCreater.c +++ b/source/libs/parser/src/parAstCreater.c @@ -384,7 +384,7 @@ SNode* createValueNode(SAstCreateContext* pCxt, int32_t dataType, const SToken* pCxt->errCode = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&val); CHECK_MAKE_NODE(val); val->literal = strndup(pLiteral->z, pLiteral->n); - if(!val->literal) { + if (!val->literal) { pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; nodesDestroyNode((SNode*)val); return NULL; @@ -2181,7 +2181,7 @@ static bool needDbShowStmt(ENodeType type) { return QUERY_NODE_SHOW_TABLES_STMT == type || QUERY_NODE_SHOW_STABLES_STMT == type || QUERY_NODE_SHOW_VGROUPS_STMT == type || QUERY_NODE_SHOW_INDEXES_STMT == type || QUERY_NODE_SHOW_TAGS_STMT == type || QUERY_NODE_SHOW_TABLE_TAGS_STMT == type || - QUERY_NODE_SHOW_VIEWS_STMT == type || QUERY_NODE_SHOW_TSMAS_STMT == type; + QUERY_NODE_SHOW_VIEWS_STMT == type || QUERY_NODE_SHOW_TSMAS_STMT == type || QUERY_NODE_SHOW_USAGE_STMT == type; } SNode* createShowStmt(SAstCreateContext* pCxt, ENodeType type) { @@ -2456,7 +2456,7 @@ SNode* addCreateUserStmtWhiteList(SAstCreateContext* pCxt, SNode* pCreateUserStm return pCreateUserStmt; } -SNode* createCreateUserStmt(SAstCreateContext* pCxt, SToken* pUserName, const SToken* pPassword, int8_t sysinfo, +SNode* createCreateUserStmt(SAstCreateContext* pCxt, SToken* pUserName, const SToken* pPassword, int8_t sysinfo, int8_t createDb, int8_t is_import) { CHECK_PARSER_STATUS(pCxt); char password[TSDB_USET_PASSWORD_LEN + 3] = {0}; diff --git a/source/libs/parser/src/parAstParser.c b/source/libs/parser/src/parAstParser.c index 49be0b8d90..ff313216ab 100644 --- a/source/libs/parser/src/parAstParser.c +++ b/source/libs/parser/src/parAstParser.c @@ -182,7 +182,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_COLS) || 0 == strcmp(pTable, TSDB_INS_TABLE_USAGE)) && QUERY_NODE_SELECT_STMT == nodeType(pCxt->pStmt)) { code = collectMetaKeyFromInsTags(pCxt); } @@ -440,7 +440,7 @@ static int32_t collectMetaKeyFromCreateStream(SCollectMetaKeyCxt* pCxt, SCreateS reserveTableMetaInCache(pCxt->pParseCxt->acctId, pStmt->targetDbName, pStmt->targetTabName, pCxt->pMetaCache); if (TSDB_CODE_SUCCESS == code && NULL != pStmt->pSubtable && NULL != pStmt->pQuery) { SSelectStmt* pSelect = (SSelectStmt*)pStmt->pQuery; - int32_t code = nodesCloneNode(pStmt->pSubtable, &pSelect->pSubtable); + int32_t code = nodesCloneNode(pStmt->pSubtable, &pSelect->pSubtable); if (NULL == pSelect->pSubtable) { return code; } @@ -855,6 +855,20 @@ static int32_t collectMetaKeyFromDropTSMAStmt(SCollectMetaKeyCxt* pCxt, SDropTSM return code; } +static int32_t collectMetaKeyFromShowUsage(SCollectMetaKeyCxt* pCxt, SShowStmt* pStmt) { + int32_t code = reserveTableMetaInCache(pCxt->pParseCxt->acctId, TSDB_INFORMATION_SCHEMA_DB, TSDB_INS_TABLE_TABLES, + pCxt->pMetaCache); + if (TSDB_CODE_SUCCESS == code) { + code = reserveDbVgInfoInCache(pCxt->pParseCxt->acctId, ((SValueNode*)pStmt->pDbName)->literal, pCxt->pMetaCache); + } + if (TSDB_CODE_SUCCESS == code) { + code = + reserveUserAuthInCache(pCxt->pParseCxt->acctId, pCxt->pParseCxt->pUser, ((SValueNode*)pStmt->pDbName)->literal, + NULL, AUTH_TYPE_READ_OR_WRITE, pCxt->pMetaCache); + } + return code; +} + static int32_t collectMetaKeyFromShowTSMASStmt(SCollectMetaKeyCxt* pCxt, SShowStmt* pStmt) { return reserveTableMetaInCache(pCxt->pParseCxt->acctId, TSDB_INFORMATION_SCHEMA_DB, TSDB_INS_TABLE_TSMAS, pCxt->pMetaCache); @@ -994,6 +1008,9 @@ static int32_t collectMetaKeyFromQuery(SCollectMetaKeyCxt* pCxt, SNode* pStmt) { return collectMetaKeyFromShowApps(pCxt, (SShowStmt*)pStmt); case QUERY_NODE_SHOW_TRANSACTIONS_STMT: return collectMetaKeyFromShowTransactions(pCxt, (SShowStmt*)pStmt); + case QUERY_NODE_SHOW_USAGE_STMT: + return collectMetaKeyFromShowUsage(pCxt, (SShowStmt*)pStmt); + return 0; case QUERY_NODE_DELETE_STMT: return collectMetaKeyFromDelete(pCxt, (SDeleteStmt*)pStmt); case QUERY_NODE_INSERT_STMT: diff --git a/source/libs/parser/src/parAuthenticator.c b/source/libs/parser/src/parAuthenticator.c index 60cc1024bf..6d26e334f2 100644 --- a/source/libs/parser/src/parAuthenticator.c +++ b/source/libs/parser/src/parAuthenticator.c @@ -29,13 +29,13 @@ typedef struct SSelectAuthCxt { } SSelectAuthCxt; typedef struct SAuthRewriteCxt { - STableNode* pTarget; + STableNode* pTarget; } SAuthRewriteCxt; static int32_t authQuery(SAuthCxt* pCxt, SNode* pStmt); static int32_t setUserAuthInfo(SParseContext* pCxt, const char* pDbName, const char* pTabName, AUTH_TYPE type, - bool isView, bool effective, SUserAuthInfo* pAuth) { + bool isView, bool effective, SUserAuthInfo* pAuth) { if (effective) { snprintf(pAuth->user, sizeof(pAuth->user), "%s", pCxt->pEffectiveUser ? pCxt->pEffectiveUser : ""); } else { @@ -53,7 +53,8 @@ static int32_t setUserAuthInfo(SParseContext* pCxt, const char* pDbName, const c return TSDB_CODE_SUCCESS; } -static int32_t checkAuthImpl(SAuthCxt* pCxt, const char* pDbName, const char* pTabName, AUTH_TYPE type, SNode** pCond, bool isView, bool effective) { +static int32_t checkAuthImpl(SAuthCxt* pCxt, const char* pDbName, const char* pTabName, AUTH_TYPE type, SNode** pCond, + bool isView, bool effective) { SParseContext* pParseCxt = pCxt->pParseCxt; if (pParseCxt->isSuperUser) { return TSDB_CODE_SUCCESS; @@ -61,7 +62,7 @@ static int32_t checkAuthImpl(SAuthCxt* pCxt, const char* pDbName, const char* pT AUTH_RES_TYPE auth_res_type = isView ? AUTH_RES_VIEW : AUTH_RES_BASIC; SUserAuthInfo authInfo = {0}; - int32_t code = setUserAuthInfo(pCxt->pParseCxt, pDbName, pTabName, type, isView, effective, &authInfo); + int32_t code = setUserAuthInfo(pCxt->pParseCxt, pDbName, pTabName, type, isView, effective, &authInfo); if (TSDB_CODE_SUCCESS != code) return code; SUserAuthRes authRes = {0}; if (NULL != pCxt->pMetaCache) { @@ -82,15 +83,16 @@ static int32_t checkAuthImpl(SAuthCxt* pCxt, const char* pDbName, const char* pT if (TSDB_CODE_SUCCESS == code && NULL != pCond) { *pCond = authRes.pCond[auth_res_type]; } - return TSDB_CODE_SUCCESS == code ? (authRes.pass[auth_res_type] ? TSDB_CODE_SUCCESS : TSDB_CODE_PAR_PERMISSION_DENIED) : code; + return TSDB_CODE_SUCCESS == code ? (authRes.pass[auth_res_type] ? TSDB_CODE_SUCCESS : TSDB_CODE_PAR_PERMISSION_DENIED) + : code; } - static int32_t checkAuth(SAuthCxt* pCxt, const char* pDbName, const char* pTabName, AUTH_TYPE type, SNode** pCond) { return checkAuthImpl(pCxt, pDbName, pTabName, type, pCond, false, false); } -static int32_t checkEffectiveAuth(SAuthCxt* pCxt, const char* pDbName, const char* pTabName, AUTH_TYPE type, SNode** pCond) { +static int32_t checkEffectiveAuth(SAuthCxt* pCxt, const char* pDbName, const char* pTabName, AUTH_TYPE type, + SNode** pCond) { return checkAuthImpl(pCxt, pDbName, pTabName, type, NULL, false, true); } @@ -98,7 +100,8 @@ static int32_t checkViewAuth(SAuthCxt* pCxt, const char* pDbName, const char* pT return checkAuthImpl(pCxt, pDbName, pTabName, type, NULL, true, false); } -static int32_t checkViewEffectiveAuth(SAuthCxt* pCxt, const char* pDbName, const char* pTabName, AUTH_TYPE type, SNode** pCond) { +static int32_t checkViewEffectiveAuth(SAuthCxt* pCxt, const char* pDbName, const char* pTabName, AUTH_TYPE type, + SNode** pCond) { return checkAuthImpl(pCxt, pDbName, pTabName, type, NULL, true, true); } @@ -108,7 +111,7 @@ static EDealRes authSubquery(SAuthCxt* pCxt, SNode* pStmt) { static int32_t mergeStableTagCond(SNode** pWhere, SNode* pTagCond) { 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; } @@ -129,7 +132,7 @@ static int32_t mergeStableTagCond(SNode** pWhere, SNode* pTagCond) { EDealRes rewriteAuthTable(SNode* pNode, void* pContext) { if (QUERY_NODE_COLUMN == nodeType(pNode)) { - SColumnNode* pCol = (SColumnNode*)pNode; + SColumnNode* pCol = (SColumnNode*)pNode; SAuthRewriteCxt* pCxt = (SAuthRewriteCxt*)pContext; strcpy(pCol->tableName, pCxt->pTarget->tableName); strcpy(pCol->tableAlias, pCxt->pTarget->tableAlias); @@ -139,7 +142,7 @@ EDealRes rewriteAuthTable(SNode* pNode, void* pContext) { } static int32_t rewriteAppendStableTagCond(SNode** pWhere, SNode* pTagCond, STableNode* pTable) { - SNode* pTagCondCopy = NULL; + SNode* pTagCondCopy = NULL; int32_t code = nodesCloneNode(pTagCond, &pTagCondCopy); if (NULL == pTagCondCopy) { return code; @@ -169,10 +172,11 @@ static EDealRes authSelectImpl(SNode* pNode, void* pContext) { SNode* pTagCond = NULL; STableNode* pTable = (STableNode*)pNode; #ifdef TD_ENTERPRISE - SName name; + SName name; STableMeta* pTableMeta = NULL; - int32_t code = getTargetMetaImpl( - pAuthCxt->pParseCxt, pAuthCxt->pMetaCache, toName(pAuthCxt->pParseCxt->acctId, pTable->dbName, pTable->tableName, &name), &pTableMeta, true); + int32_t code = getTargetMetaImpl(pAuthCxt->pParseCxt, pAuthCxt->pMetaCache, + toName(pAuthCxt->pParseCxt->acctId, pTable->dbName, pTable->tableName, &name), + &pTableMeta, true); if (TSDB_CODE_SUCCESS == code && TSDB_VIEW_TABLE == pTableMeta->tableType) { isView = true; } @@ -245,6 +249,10 @@ static int32_t authShowTables(SAuthCxt* pCxt, SShowStmt* pStmt) { return checkAuth(pCxt, ((SValueNode*)pStmt->pDbName)->literal, NULL, AUTH_TYPE_READ_OR_WRITE, NULL); } +static int32_t authShowUsage(SAuthCxt* pCxt, SShowStmt* pStmt) { + return checkAuth(pCxt, ((SValueNode*)pStmt->pDbName)->literal, NULL, AUTH_TYPE_READ_OR_WRITE, NULL); +} + static int32_t authShowCreateTable(SAuthCxt* pCxt, SShowCreateTableStmt* pStmt) { SNode* pTagCond = NULL; // todo check tag condition for subtable @@ -370,6 +378,7 @@ static int32_t authQuery(SAuthCxt* pCxt, SNode* pStmt) { case QUERY_NODE_SHOW_CLUSTER_MACHINES_STMT: case QUERY_NODE_SHOW_ARBGROUPS_STMT: case QUERY_NODE_SHOW_ENCRYPTIONS_STMT: + case QUERY_NODE_SHOW_USAGE_STMT: return !pCxt->pParseCxt->enableSysInfo ? TSDB_CODE_PAR_PERMISSION_DENIED : TSDB_CODE_SUCCESS; case QUERY_NODE_SHOW_TABLES_STMT: case QUERY_NODE_SHOW_STABLES_STMT: @@ -377,8 +386,8 @@ static int32_t authQuery(SAuthCxt* pCxt, SNode* pStmt) { case QUERY_NODE_SHOW_CREATE_TABLE_STMT: case QUERY_NODE_SHOW_CREATE_STABLE_STMT: return authShowCreateTable(pCxt, (SShowCreateTableStmt*)pStmt); -// case QUERY_NODE_SHOW_CREATE_VIEW_STMT: -// return authShowCreateView(pCxt, (SShowCreateViewStmt*)pStmt); + // case QUERY_NODE_SHOW_CREATE_VIEW_STMT: + // return authShowCreateView(pCxt, (SShowCreateViewStmt*)pStmt); case QUERY_NODE_CREATE_VIEW_STMT: return authCreateView(pCxt, (SCreateViewStmt*)pStmt); case QUERY_NODE_DROP_VIEW_STMT: diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index b033e62711..e5aa153ea2 100755 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -348,6 +348,13 @@ static const SSysTableShowAdapter sysTableShowAdapter[] = { .numOfShowCols = 1, .pShowCols = {"*"} }, + { + .showType = QUERY_NODE_SHOW_USAGE_STMT, + .pDbName = TSDB_INFORMATION_SCHEMA_DB, + .pTableName = TSDB_INS_TABLE_USAGE, + .numOfShowCols = 1, + .pShowCols = {"*"} + } }; // clang-format on @@ -3857,7 +3864,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_COLS) || 0 == strcmp(pRealTable->table.tableName, TSDB_INS_TABLE_USAGE)) { code = addMnodeToVgroupList(&pCxt->pParseCxt->mgmtEpSet, &pVgs); } @@ -3956,7 +3963,7 @@ static bool isSingleTable(SRealTableNode* pRealTable) { if (TSDB_SYSTEM_TABLE == tableType) { 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_COLS) &&0 != strcmp(pRealTable->table.tableName, TSDB_INS_TABLE_USAGE); } return (TSDB_CHILD_TABLE == tableType || TSDB_NORMAL_TABLE == tableType); } diff --git a/source/libs/planner/src/planOptimizer.c b/source/libs/planner/src/planOptimizer.c index 27d3e80ef0..4ec68f1bd2 100644 --- a/source/libs/planner/src/planOptimizer.c +++ b/source/libs/planner/src/planOptimizer.c @@ -5303,7 +5303,8 @@ 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_TABLES) || NULL != pInfo->pScan->pGroupTags || + 0 != strcmp(pInfo->pScan->tableName.tname, TSDB_INS_TABLE_USAGE)) { return false; } if (1 == pInfo->pScan->pVgroupList->numOfVgroups && MNODE_HANDLE == pInfo->pScan->pVgroupList->vgroups[0].vgId) { diff --git a/source/libs/planner/src/planPhysiCreater.c b/source/libs/planner/src/planPhysiCreater.c index d75e02bc6b..fa4eddce1b 100644 --- a/source/libs/planner/src/planPhysiCreater.c +++ b/source/libs/planner/src/planPhysiCreater.c @@ -727,7 +727,8 @@ static int32_t createSystemTableScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pScan->sysInfo = pCxt->pPlanCxt->sysInfo; 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_COLS) || + 0 == strcmp(pScanLogicNode->tableName.tname, TSDB_INS_TABLE_USAGE)) { if (pScanLogicNode->pVgroupList) { vgroupInfoToNodeAddr(pScanLogicNode->pVgroupList->vgroups, &pSubplan->execNode); }