From 4d5cd9cd1ae44aaff634fa9a026d4cc50f6ce02f Mon Sep 17 00:00:00 2001 From: wangjiaming0909 <604227650@qq.com> Date: Tue, 23 Jul 2024 15:59:10 +0800 Subject: [PATCH] planner/nodes/parser ret check --- include/libs/parser/parser.h | 1 + source/client/src/clientEnv.c | 1 + source/libs/nodes/src/nodesCodeFuncs.c | 8 +- source/libs/nodes/src/nodesUtilFuncs.c | 27 +- source/libs/nodes/test/nodesTestMain.cpp | 10 +- source/libs/parser/inc/parInsertUtil.h | 2 +- source/libs/parser/inc/parToken.h | 3 +- source/libs/parser/inc/parUtil.h | 2 +- source/libs/parser/inc/sql.y | 2 +- source/libs/parser/src/parInsertSql.c | 134 +++++-- source/libs/parser/src/parInsertStmt.c | 23 +- source/libs/parser/src/parInsertUtil.c | 80 ++-- source/libs/parser/src/parTokenizer.c | 19 +- source/libs/parser/src/parTranslater.c | 7 +- source/libs/parser/src/parUtil.c | 140 +++++-- source/libs/parser/src/parser.c | 8 +- .../libs/parser/test/mockCatalogService.cpp | 212 ++++++++-- .../parser/test/parAlterToBalanceTest.cpp | 14 +- source/libs/parser/test/parInitialCTest.cpp | 24 +- source/libs/parser/test/parTestMain.cpp | 7 +- source/libs/parser/test/parTestUtil.cpp | 2 +- source/libs/planner/src/planLogicCreater.c | 15 +- source/libs/planner/src/planOptimizer.c | 375 +++++++++++------- source/libs/planner/src/planPhysiCreater.c | 23 +- source/libs/planner/src/planSpliter.c | 38 +- source/libs/planner/src/planUtil.c | 27 +- source/libs/planner/src/planner.c | 30 +- source/libs/planner/test/planStmtTest.cpp | 8 +- source/libs/planner/test/planTestMain.cpp | 9 +- source/libs/planner/test/planTestUtil.cpp | 14 +- 30 files changed, 873 insertions(+), 392 deletions(-) diff --git a/include/libs/parser/parser.h b/include/libs/parser/parser.h index fe0faa28ad..cefce8a9c0 100644 --- a/include/libs/parser/parser.h +++ b/include/libs/parser/parser.h @@ -118,6 +118,7 @@ void qDestroyQuery(SQuery* pQueryNode); int32_t qExtractResultSchema(const SNode* pRoot, int32_t* numOfCols, SSchema** pSchema); int32_t qSetSTableIdForRsma(SNode* pStmt, int64_t uid); +int32_t qInitKeywordsTable(); void qCleanupKeywordsTable(); int32_t qAppendStmtTableOutput(SQuery* pQuery, SHashObj* pAllVgHash, STableColsData* pTbData, STableDataCxt* pTbCtx, SStbInterlaceInfo* pBuildInfo); diff --git a/source/client/src/clientEnv.c b/source/client/src/clientEnv.c index a315033296..f4ecc6929b 100644 --- a/source/client/src/clientEnv.c +++ b/source/client/src/clientEnv.c @@ -988,6 +988,7 @@ void taos_init_imp(void) { ENV_ERR_RET(taosGetAppName(appInfo.appName, NULL), "failed to get app name"); ENV_ERR_RET(taosThreadMutexInit(&appInfo.mutex, NULL), "failed to init thread mutex"); ENV_ERR_RET(tscCrashReportInit(), "failed to init crash report"); + ENV_ERR_RET(qInitKeywordsTable(), "failed to init parser keywords table"); tscDebug("client is initialized successfully"); } diff --git a/source/libs/nodes/src/nodesCodeFuncs.c b/source/libs/nodes/src/nodesCodeFuncs.c index 92a3540590..b34d1b9a70 100644 --- a/source/libs/nodes/src/nodesCodeFuncs.c +++ b/source/libs/nodes/src/nodesCodeFuncs.c @@ -1338,7 +1338,7 @@ static int32_t jsonToLogicDynQueryCtrlNode(const SJson* pJson, void* pObj) { tjsonGetNumberValue(pJson, jkDynQueryCtrlLogicPlanQueryType, pNode->qType, code); } if (TSDB_CODE_SUCCESS == code) { - tjsonGetBoolValue(pJson, jkDynQueryCtrlLogicPlanStbJoinBatchFetch, &pNode->stbJoin.batchFetch); + code = tjsonGetBoolValue(pJson, jkDynQueryCtrlLogicPlanStbJoinBatchFetch, &pNode->stbJoin.batchFetch); } if (TSDB_CODE_SUCCESS == code) { code = jsonToNodeList(pJson, jkDynQueryCtrlLogicPlanStbJoinVgList, &pNode->stbJoin.pVgList); @@ -3031,10 +3031,10 @@ static int32_t physiPartitionNodeToJson(const void* pObj, SJson* pJson) { code = nodeListToJson(pJson, jkPartitionPhysiPlanTargets, pNode->pTargets); } if (TSDB_CODE_SUCCESS == code) { - tjsonAddBoolToObject(pJson, jkPartitionPhysiPlanNeedBlockOutputTsOrder, pNode->needBlockOutputTsOrder); + code = tjsonAddBoolToObject(pJson, jkPartitionPhysiPlanNeedBlockOutputTsOrder, pNode->needBlockOutputTsOrder); } if (TSDB_CODE_SUCCESS == code) { - tjsonAddIntegerToObject(pJson, jkPartitionPhysiPlanTsSlotId, pNode->tsSlotId); + code = tjsonAddIntegerToObject(pJson, jkPartitionPhysiPlanTsSlotId, pNode->tsSlotId); } return code; @@ -7390,7 +7390,7 @@ static int32_t jsonToTSMAOption(const SJson* pJson, void* pObj) { code = jsonToNodeObject(pJson, jkTSMAOptionInterval, &pNode->pInterval); } if (TSDB_CODE_SUCCESS == code) { - tjsonGetUTinyIntValue(pJson, jkTSMAOptionTsPrecision, &pNode->tsPrecision); + code = tjsonGetUTinyIntValue(pJson, jkTSMAOptionTsPrecision, &pNode->tsPrecision); } return code; } diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c index a6db870573..b0261aa41a 100644 --- a/source/libs/nodes/src/nodesUtilFuncs.c +++ b/source/libs/nodes/src/nodesUtilFuncs.c @@ -77,25 +77,26 @@ int32_t mergeJoinConds(SNode** ppDst, SNode** ppSrc) { 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) { - nodesListStrictAppendList(pDst->pParameterList, ((SLogicConditionNode*)(*ppSrc))->pParameterList); + code = nodesListStrictAppendList(pDst->pParameterList, ((SLogicConditionNode*)(*ppSrc))->pParameterList); ((SLogicConditionNode*)(*ppSrc))->pParameterList = NULL; } else { - nodesListStrictAppend(pDst->pParameterList, *ppSrc); + code = nodesListStrictAppend(pDst->pParameterList, *ppSrc); *ppSrc = NULL; } nodesDestroyNode(*ppSrc); *ppSrc = NULL; - return TSDB_CODE_SUCCESS; + return code; } } SLogicConditionNode* pLogicCond = NULL; - int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogicCond); + code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogicCond); if (TSDB_CODE_SUCCESS != code) { return code; } @@ -187,7 +188,9 @@ static int32_t createNodeAllocator(int32_t chunkSize, SNodeAllocator** pAllocato taosMemoryFreeClear(*pAllocator); return code; } - taosThreadMutexInit(&(*pAllocator)->mutex, NULL); + if (0 != taosThreadMutexInit(&(*pAllocator)->mutex, NULL)) { + return TAOS_SYSTEM_ERROR(errno); + } return TSDB_CODE_SUCCESS; } @@ -207,7 +210,7 @@ static void destroyNodeAllocator(void* p) { taosMemoryFree(pChunk); pChunk = pTemp; } - taosThreadMutexDestroy(&pAllocator->mutex); + (void)taosThreadMutexDestroy(&pAllocator->mutex); taosMemoryFree(pAllocator); } @@ -232,10 +235,10 @@ void nodesDestroyAllocatorSet() { int64_t refId = 0; while (NULL != pAllocator) { refId = pAllocator->self; - taosRemoveRef(g_allocatorReqRefPool, refId); + (void)taosRemoveRef(g_allocatorReqRefPool, refId); pAllocator = taosIterateRef(g_allocatorReqRefPool, refId); } - taosCloseRef(g_allocatorReqRefPool); + (void)taosCloseRef(g_allocatorReqRefPool); } } @@ -282,7 +285,7 @@ int32_t nodesAcquireAllocator(int64_t allocatorId) { if (NULL == pAllocator) { return terrno; } - taosThreadMutexLock(&pAllocator->mutex); + (void)taosThreadMutexLock(&pAllocator->mutex); g_pNodeAllocator = pAllocator; return TSDB_CODE_SUCCESS; } @@ -301,7 +304,7 @@ int32_t nodesReleaseAllocator(int64_t allocatorId) { } SNodeAllocator* pAllocator = g_pNodeAllocator; g_pNodeAllocator = NULL; - taosThreadMutexUnlock(&pAllocator->mutex); + (void)taosThreadMutexUnlock(&pAllocator->mutex); return taosReleaseRef(g_allocatorReqRefPool, allocatorId); } @@ -325,7 +328,7 @@ void nodesDestroyAllocator(int64_t allocatorId) { return; } - taosRemoveRef(g_allocatorReqRefPool, allocatorId); + (void)taosRemoveRef(g_allocatorReqRefPool, allocatorId); } static int32_t makeNode(ENodeType type, int32_t size, SNode** ppNode) { @@ -1087,7 +1090,7 @@ void nodesDestroyNode(SNode* pNode) { pStmt->destroyParseFileCxt(&pStmt->pParFileCxt); } - taosCloseFile(&pStmt->fp); + assert(TSDB_CODE_SUCCESS == taosCloseFile(&pStmt->fp)); break; } case QUERY_NODE_CREATE_DATABASE_STMT: diff --git a/source/libs/nodes/test/nodesTestMain.cpp b/source/libs/nodes/test/nodesTestMain.cpp index f3d1657e56..eb69017b11 100644 --- a/source/libs/nodes/test/nodesTestMain.cpp +++ b/source/libs/nodes/test/nodesTestMain.cpp @@ -115,11 +115,11 @@ TEST(NodesTest, sort) { vn5->datum.i = 0; SNodeList* l = NULL; - nodesListMakeAppend(&l, (SNode*)vn1); - nodesListMakeAppend(&l, (SNode*)vn2); - nodesListMakeAppend(&l, (SNode*)vn3); - nodesListMakeAppend(&l, (SNode*)vn4); - nodesListMakeAppend(&l, (SNode*)vn5); + ASSERT_EQ(TSDB_CODE_SUCCESS, nodesListMakeAppend(&l, (SNode*)vn1)); + ASSERT_EQ(TSDB_CODE_SUCCESS, nodesListMakeAppend(&l, (SNode*)vn2)); + ASSERT_EQ(TSDB_CODE_SUCCESS, nodesListMakeAppend(&l, (SNode*)vn3)); + ASSERT_EQ(TSDB_CODE_SUCCESS, nodesListMakeAppend(&l, (SNode*)vn4)); + ASSERT_EQ(TSDB_CODE_SUCCESS, nodesListMakeAppend(&l, (SNode*)vn5)); nodesSortList(&l, compareValueNode); diff --git a/source/libs/parser/inc/parInsertUtil.h b/source/libs/parser/inc/parInsertUtil.h index 899661a18c..df9f698dc1 100644 --- a/source/libs/parser/inc/parInsertUtil.h +++ b/source/libs/parser/inc/parInsertUtil.h @@ -46,7 +46,7 @@ void insBuildCreateTbReq(SVCreateTbReq *pTbReq, const char *tname, STag *pTag SArray *tagName, uint8_t tagNum, int32_t ttl); int32_t insInitBoundColsInfo(int32_t numOfBound, SBoundColInfo *pInfo); void insResetBoundColsInfo(SBoundColInfo *pInfo); -void insInitColValues(STableMeta *pTableMeta, SArray *aColValues); +int32_t insInitColValues(STableMeta *pTableMeta, SArray *aColValues); void insCheckTableDataOrder(STableDataCxt *pTableCxt, SRowKey *rowKey); int32_t insGetTableDataCxt(SHashObj *pHash, void *id, int32_t idLen, STableMeta *pTableMeta, SVCreateTbReq **pCreateTbReq, STableDataCxt **pTableCxt, bool colMode, bool ignoreColVals); diff --git a/source/libs/parser/inc/parToken.h b/source/libs/parser/inc/parToken.h index 87e9a82d2b..98f77843f9 100644 --- a/source/libs/parser/inc/parToken.h +++ b/source/libs/parser/inc/parToken.h @@ -182,7 +182,8 @@ _end: return (i < pToken->n) ? TK_NK_ILLEGAL : type; } -void taosCleanupKeywordsTable(); +int32_t taosInitKeywordsTable(); +void taosCleanupKeywordsTable(); #ifdef __cplusplus } diff --git a/source/libs/parser/inc/parUtil.h b/source/libs/parser/inc/parUtil.h index f519bd37a8..f0f1ea51b0 100644 --- a/source/libs/parser/inc/parUtil.h +++ b/source/libs/parser/inc/parUtil.h @@ -172,7 +172,7 @@ int32_t getTableIndexFromCache(SParseMetaCache* pMetaCache, const SName* pName, int32_t getTableCfgFromCache(SParseMetaCache* pMetaCache, const SName* pName, STableCfg** pOutput); int32_t getDnodeListFromCache(SParseMetaCache* pMetaCache, SArray** pDnodes); void destoryParseMetaCache(SParseMetaCache* pMetaCache, bool request); -int32_t createSelectStmtImpl(bool isDistinct, SNodeList* pProjectionList, SNode* pTable, SNodeList* pHint, SNode** ppSelect); +int32_t createSelectStmtImpl(bool isDistinct, SNodeList* pProjectionList, SNode* pTable, SNodeList* pHint, SNode** ppSelect); int32_t getTableTsmasFromCache(SParseMetaCache* pMetaCache, const SName* pTbName, SArray** pTsmas); int32_t getTsmaFromCache(SParseMetaCache* pMetaCache, const SName* pTsmaName, STableTSMAInfo** pTsma); diff --git a/source/libs/parser/inc/sql.y b/source/libs/parser/inc/sql.y index c53180eb87..f2d804df27 100644 --- a/source/libs/parser/inc/sql.y +++ b/source/libs/parser/inc/sql.y @@ -1107,7 +1107,7 @@ expr_or_subquery(A) ::= expression(B). //expr_or_subquery(A) ::= subquery(B). { A = createTempTableNode(pCxt, releaseRawExprNode(pCxt, B), NULL); } expression(A) ::= literal(B). { A = B; } -expression(A) ::= pseudo_column(B). { A = B; setRawExprNodeIsPseudoColumn(pCxt, A, true); } +expression(A) ::= pseudo_column(B). { A = B; (void)setRawExprNodeIsPseudoColumn(pCxt, A, true); } expression(A) ::= column_reference(B). { A = B; } expression(A) ::= function_expression(B). { A = B; } expression(A) ::= case_when_expression(B). { A = B; } diff --git a/source/libs/parser/src/parInsertSql.c b/source/libs/parser/src/parInsertSql.c index 04e5542870..020eb028de 100644 --- a/source/libs/parser/src/parInsertSql.c +++ b/source/libs/parser/src/parInsertSql.c @@ -142,7 +142,10 @@ static int32_t parseDuplicateUsingClause(SInsertParseContext* pCxt, SVnodeModify *pDuplicate = false; char tbFName[TSDB_TABLE_FNAME_LEN]; - tNameExtractFullName(&pStmt->targetTableName, tbFName); + code = tNameExtractFullName(&pStmt->targetTableName, tbFName); + if (TSDB_CODE_SUCCESS != code) { + return code; + } STableMeta** pMeta = taosHashGet(pStmt->pSubTableHashObj, tbFName, strlen(tbFName)); if (NULL != pMeta) { *pDuplicate = true; @@ -708,7 +711,10 @@ static int32_t parseTagToken(const char** end, SToken* pToken, SSchema* pSchema, // input pStmt->pSql: [(tag1_name, ...)] TAGS (tag1_value, ...) ... // output pStmt->pSql: TAGS (tag1_value, ...) ... static int32_t parseBoundTagsClause(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt) { - insInitBoundColsInfo(getNumOfTags(pStmt->pTableMeta), &pCxt->tags); + int32_t code = insInitBoundColsInfo(getNumOfTags(pStmt->pTableMeta), &pCxt->tags); + if (TSDB_CODE_SUCCESS != code) { + return code; + } SToken token; int32_t index = 0; @@ -725,7 +731,9 @@ int32_t parseTagValue(SMsgBuf* pMsgBuf, const char** pSql, uint8_t precision, SS SArray* pTagName, SArray* pTagVals, STag** pTag) { bool isNull = isNullValue(pTagSchema->type, pToken); if (!isNull && pTagName) { - taosArrayPush(pTagName, pTagSchema->name); + if (NULL == taosArrayPush(pTagName, pTagSchema->name)) { + return TSDB_CODE_OUT_OF_MEMORY; + } } if (pTagSchema->type == TSDB_DATA_TYPE_JSON) { @@ -745,7 +753,9 @@ int32_t parseTagValue(SMsgBuf* pMsgBuf, const char** pSql, uint8_t precision, SS STagVal val = {0}; int32_t code = parseTagToken(pSql, pToken, pTagSchema, precision, &val, pMsgBuf); if (TSDB_CODE_SUCCESS == code) { - taosArrayPush(pTagVals, &val); + if (NULL == taosArrayPush(pTagVals, &val)){ + code = TSDB_CODE_OUT_OF_MEMORY; + } } return code; @@ -1029,8 +1039,16 @@ static int32_t storeChildTableMeta(SInsertParseContext* pCxt, SVnodeModifyOpStmt } char tbFName[TSDB_TABLE_FNAME_LEN]; - tNameExtractFullName(&pStmt->targetTableName, tbFName); - return taosHashPut(pStmt->pSubTableHashObj, tbFName, strlen(tbFName), &pBackup, POINTER_BYTES); + int32_t code = tNameExtractFullName(&pStmt->targetTableName, tbFName); + if (TSDB_CODE_SUCCESS != code) { + taosMemoryFree(pBackup); + return code; + } + code = taosHashPut(pStmt->pSubTableHashObj, tbFName, strlen(tbFName), &pBackup, POINTER_BYTES); + if (TSDB_CODE_SUCCESS != code) { + taosMemoryFree(pBackup); + } + return code; } static int32_t parseTableOptions(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt) { @@ -1216,13 +1234,19 @@ static int32_t getTargetTableMetaAndVgroup(SInsertParseContext* pCxt, SVnodeModi static int32_t collectUseTable(const SName* pName, SHashObj* pTable) { char fullName[TSDB_TABLE_FNAME_LEN]; - tNameExtractFullName(pName, fullName); + int32_t code = tNameExtractFullName(pName, fullName); + if (TSDB_CODE_SUCCESS != code) { + return code; + } return taosHashPut(pTable, fullName, strlen(fullName), pName, sizeof(SName)); } static int32_t collectUseDatabase(const SName* pName, SHashObj* pDbs) { char dbFName[TSDB_DB_FNAME_LEN] = {0}; - tNameGetFullDbName(pName, dbFName); + int32_t code = tNameGetFullDbName(pName, dbFName); + if (TSDB_CODE_SUCCESS != code) { + return code; + } return taosHashPut(pDbs, dbFName, strlen(dbFName), dbFName, sizeof(dbFName)); } @@ -1359,7 +1383,10 @@ static int32_t getTableDataCxt(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pS } char tbFName[TSDB_TABLE_FNAME_LEN]; - tNameExtractFullName(&pStmt->targetTableName, tbFName); + int32_t code = tNameExtractFullName(&pStmt->targetTableName, tbFName); + if (TSDB_CODE_SUCCESS != code) { + return code; + } if (pStmt->usingTableProcessing) { pStmt->pTableMeta->uid = 0; } @@ -1862,9 +1889,11 @@ static int32_t getStbRowValues(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pS } bool ctbFirst = true; + char ctbFName[TSDB_TABLE_FNAME_LEN]; if (code == TSDB_CODE_SUCCESS) { - char ctbFName[TSDB_TABLE_FNAME_LEN]; - tNameExtractFullName(&pStbRowsCxt->ctbName, ctbFName); + code = tNameExtractFullName(&pStbRowsCxt->ctbName, ctbFName); + } + if (TSDB_CODE_SUCCESS == code) { STableMeta** pCtbMeta = taosHashGet(pStmt->pSubTableHashObj, ctbFName, strlen(ctbFName)); ctbFirst = (pCtbMeta == NULL); if (!ctbFirst) { @@ -1901,23 +1930,31 @@ static int32_t processCtbAutoCreationAndCtbMeta(SInsertParseContext* pCxt, SVnod if (code == TSDB_CODE_SUCCESS) { char ctbFName[TSDB_TABLE_FNAME_LEN]; - tNameExtractFullName(&pStbRowsCxt->ctbName, ctbFName); + code = tNameExtractFullName(&pStbRowsCxt->ctbName, ctbFName); SVgroupInfo vg; SRequestConnInfo conn = {.pTrans = pCxt->pComCxt->pTransporter, - .requestId = pCxt->pComCxt->requestId, - .requestObjRefId = pCxt->pComCxt->requestRid, - .mgmtEps = pCxt->pComCxt->mgmtEpSet}; - code = catalogGetTableHashVgroup(pCxt->pComCxt->pCatalog, &conn, &pStbRowsCxt->ctbName, &vg); + .requestId = pCxt->pComCxt->requestId, + .requestObjRefId = pCxt->pComCxt->requestRid, + .mgmtEps = pCxt->pComCxt->mgmtEpSet}; + if (TSDB_CODE_SUCCESS == code) { + code = catalogGetTableHashVgroup(pCxt->pComCxt->pCatalog, &conn, &pStbRowsCxt->ctbName, &vg); + } if (code == TSDB_CODE_SUCCESS) { - taosHashPut(pStmt->pVgroupsHashObj, (const char*)(&vg.vgId), sizeof(vg.vgId), &vg, sizeof(vg)); + code = taosHashPut(pStmt->pVgroupsHashObj, (const char*)(&vg.vgId), sizeof(vg.vgId), &vg, sizeof(vg)); + } + STableMeta* pBackup = NULL; + if (TSDB_CODE_SUCCESS == code) { pStbRowsCxt->pCtbMeta->uid = taosHashGetSize(pStmt->pSubTableHashObj) + 1; pStbRowsCxt->pCtbMeta->vgId = vg.vgId; - STableMeta* pBackup = NULL; - cloneTableMeta(pStbRowsCxt->pCtbMeta, &pBackup); - taosHashPut(pStmt->pSubTableHashObj, ctbFName, strlen(ctbFName), &pBackup, POINTER_BYTES); + code = cloneTableMeta(pStbRowsCxt->pCtbMeta, &pBackup); + } + if (TSDB_CODE_SUCCESS == code) { + code = taosHashPut(pStmt->pSubTableHashObj, ctbFName, strlen(ctbFName), &pBackup, POINTER_BYTES); + } + if (TSDB_CODE_SUCCESS == code) { + code = collectUseTable(&pStbRowsCxt->ctbName, pStmt->pTableNameHashObj); } - collectUseTable(&pStbRowsCxt->ctbName, pStmt->pTableNameHashObj); } return code; } @@ -2128,7 +2165,7 @@ static int32_t parseCsvFile(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt bool gotRow = false; if (TSDB_CODE_SUCCESS == code) { SToken token; - strtolower(pLine, pLine); + (void)strtolower(pLine, pLine); const char* pRow = pLine; if (!pStmt->stbSyntax) { code = parseOneRow(pCxt, (const char**)&pRow, rowsDataCxt.pTableDataCxt, &gotRow, &token); @@ -2139,8 +2176,11 @@ static int32_t parseCsvFile(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt if (code == TSDB_CODE_SUCCESS) { SStbRowsDataContext* pStbRowsCxt = rowsDataCxt.pStbRowsCxt; void* pData = pTableDataCxt; - taosHashPut(pStmt->pTableCxtHashObj, &pStbRowsCxt->pCtbMeta->uid, sizeof(pStbRowsCxt->pCtbMeta->uid), &pData, + code = taosHashPut(pStmt->pTableCxtHashObj, &pStbRowsCxt->pCtbMeta->uid, sizeof(pStbRowsCxt->pCtbMeta->uid), &pData, POINTER_BYTES); + if (TSDB_CODE_SUCCESS != code) { + break; + } } } if (code && firstLine) { @@ -2188,7 +2228,10 @@ static int32_t parseDataFromFileImpl(SInsertParseContext* pCxt, SVnodeModifyOpSt rowsDataCxt.pTableDataCxt->pData->flags |= SUBMIT_REQ_FROM_FILE; } if (!pStmt->fileProcessing) { - taosCloseFile(&pStmt->fp); + code = taosCloseFile(&pStmt->fp); + if (TSDB_CODE_SUCCESS != code) { + parserWarn("0x%" PRIx64 " failed to close file.", pCxt->pComCxt->requestId); + } } else { parserDebug("0x%" PRIx64 " insert from csv. File is too large, do it in batches.", pCxt->pComCxt->requestId); } @@ -2200,7 +2243,7 @@ static int32_t parseDataFromFileImpl(SInsertParseContext* pCxt, SVnodeModifyOpSt // just record pTableCxt whose data come from file if (!pStmt->stbSyntax && numOfRows > 0) { void* pData = rowsDataCxt.pTableDataCxt; - taosHashPut(pStmt->pTableCxtHashObj, &pStmt->pTableMeta->uid, sizeof(pStmt->pTableMeta->uid), &pData, + code = taosHashPut(pStmt->pTableCxtHashObj, &pStmt->pTableMeta->uid, sizeof(pStmt->pTableMeta->uid), &pData, POINTER_BYTES); } @@ -2211,7 +2254,7 @@ static int32_t parseDataFromFile(SInsertParseContext* pCxt, SVnodeModifyOpStmt* SRowsDataContext rowsDataCxt) { char filePathStr[TSDB_FILENAME_LEN] = {0}; if (TK_NK_STRING == pFilePath->type) { - trimString(pFilePath->z, pFilePath->n, filePathStr, sizeof(filePathStr)); + (void)trimString(pFilePath->z, pFilePath->n, filePathStr, sizeof(filePathStr)); } else { strncpy(filePathStr, pFilePath->z, pFilePath->n); } @@ -2296,18 +2339,35 @@ static int32_t constructStbRowsDataContext(SVnodeModifyOpStmt* pStmt, SStbRowsDa pStbRowsCxt->pCtbMeta->suid = pStbRowsCxt->pStbMeta->uid; pStbRowsCxt->aTagNames = taosArrayInit(8, TSDB_COL_NAME_LEN); + if (!pStbRowsCxt->aTagNames) { + code = TSDB_CODE_OUT_OF_MEMORY; + } } - pStbRowsCxt->aTagVals = taosArrayInit(8, sizeof(STagVal)); - - // col values and bound cols info of STableDataContext is not used - pStbRowsCxt->aColVals = taosArrayInit(getNumOfColumns(pStbRowsCxt->pStbMeta), sizeof(SColVal)); - insInitColValues(pStbRowsCxt->pStbMeta, pStbRowsCxt->aColVals); - - STableComInfo tblInfo = getTableInfo(pStmt->pTableMeta); - insInitBoundColsInfo(tblInfo.numOfColumns + tblInfo.numOfTags + 1, &pStbRowsCxt->boundColsInfo); - - *ppStbRowsCxt = pStbRowsCxt; - return TSDB_CODE_SUCCESS; + if (TSDB_CODE_SUCCESS == code) { + pStbRowsCxt->aTagVals = taosArrayInit(8, sizeof(STagVal)); + if (!pStbRowsCxt->aTagVals) { + code = TSDB_CODE_OUT_OF_MEMORY; + } + } + if (TSDB_CODE_SUCCESS == code) { + // col values and bound cols info of STableDataContext is not used + pStbRowsCxt->aColVals = taosArrayInit(getNumOfColumns(pStbRowsCxt->pStbMeta), sizeof(SColVal)); + if (!pStbRowsCxt->aColVals) + code = TSDB_CODE_OUT_OF_MEMORY; + } + if (TSDB_CODE_SUCCESS == code) { + code = insInitColValues(pStbRowsCxt->pStbMeta, pStbRowsCxt->aColVals); + } + if (TSDB_CODE_SUCCESS == code) { + STableComInfo tblInfo = getTableInfo(pStmt->pTableMeta); + code = insInitBoundColsInfo(tblInfo.numOfColumns + tblInfo.numOfTags + 1, &pStbRowsCxt->boundColsInfo); + } + if (TSDB_CODE_SUCCESS == code) { + *ppStbRowsCxt = pStbRowsCxt; + } else { + clearStbRowsDataContext(pStbRowsCxt); + } + return code; } static int32_t parseInsertStbClauseBottom(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt) { diff --git a/source/libs/parser/src/parInsertStmt.c b/source/libs/parser/src/parInsertStmt.c index 2bcc7501fb..ffead946ce 100644 --- a/source/libs/parser/src/parInsertStmt.c +++ b/source/libs/parser/src/parInsertStmt.c @@ -39,8 +39,17 @@ int32_t qCloneCurrentTbData(STableDataCxt* pDataBlock, SSubmitTbData** pData) { *pNew = *pDataBlock->pData; - cloneSVreateTbReq(pDataBlock->pData->pCreateTbReq, &pNew->pCreateTbReq); + int32_t code = cloneSVreateTbReq(pDataBlock->pData->pCreateTbReq, &pNew->pCreateTbReq); + if (TSDB_CODE_SUCCESS != code) { + taosMemoryFreeClear(*pData); + return code; + } pNew->aCol = taosArrayDup(pDataBlock->pData->aCol, NULL); + if (!pNew->aCol) { + code = TSDB_CODE_OUT_OF_MEMORY; + taosMemoryFreeClear(*pData); + return code; + } int32_t colNum = taosArrayGetSize(pNew->aCol); for (int32_t i = 0; i < colNum; ++i) { @@ -152,7 +161,10 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, const ch goto end; } } - taosArrayPush(tagName, pTagSchema->name); + if (NULL == taosArrayPush(tagName, pTagSchema->name)) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto end; + } if (pTagSchema->type == TSDB_DATA_TYPE_JSON) { if (colLen > (TSDB_MAX_JSON_TAG_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE) { code = buildSyntaxErrMsg(&pBuf, "json string too long than 4095", bind[c].buffer); @@ -198,7 +210,10 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, const ch } else { memcpy(&val.i64, bind[c].buffer, colLen); } - taosArrayPush(pTagArray, &val); + if (NULL == taosArrayPush(pTagArray, &val)) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto end; + } } } @@ -433,7 +448,7 @@ int32_t qBindStmtSingleColValue(void* pBlock, SArray* pCols, TAOS_MULTI_BIND* bi pBind = bind; } - tColDataAddValueByBind(pCol, pBind, IS_VAR_DATA_TYPE(pColSchema->type) ? pColSchema->bytes - VARSTR_HEADER_SIZE : -1); + code = tColDataAddValueByBind(pCol, pBind, IS_VAR_DATA_TYPE(pColSchema->type) ? pColSchema->bytes - VARSTR_HEADER_SIZE : -1); qDebug("stmt col %d bind %d rows data", colIdx, rowNum); diff --git a/source/libs/parser/src/parInsertUtil.c b/source/libs/parser/src/parInsertUtil.c index 7e1893ae00..3eb69afa40 100644 --- a/source/libs/parser/src/parInsertUtil.c +++ b/source/libs/parser/src/parInsertUtil.c @@ -94,7 +94,7 @@ int32_t insCreateSName(SName* pName, SToken* pTableName, int32_t acctId, const c char tbname[TSDB_TABLE_FNAME_LEN] = {0}; strncpy(tbname, p + 1, tbLen); - /*tbLen = */ strdequote(tbname); + /*tbLen = */ (void)strdequote(tbname); code = tNameFromString(pName, tbname, T_NAME_TABLE); if (code != 0) { @@ -110,7 +110,7 @@ int32_t insCreateSName(SName* pName, SToken* pTableName, int32_t acctId, const c char name[TSDB_TABLE_FNAME_LEN] = {0}; strncpy(name, pTableName->z, pTableName->n); - strdequote(name); + (void)strdequote(name); if (dbName == NULL) { return buildInvalidOperationMsg(pMsgBuf, msg3); @@ -167,15 +167,20 @@ static void initBoundCols(int32_t ncols, int16_t* pBoundCols) { } } -static void initColValues(STableMeta* pTableMeta, SArray* pValues) { +static int32_t initColValues(STableMeta* pTableMeta, SArray* pValues) { SSchema* pSchemas = getTableColumnSchema(pTableMeta); + int32_t code = 0; for (int32_t i = 0; i < pTableMeta->tableInfo.numOfColumns; ++i) { SColVal val = COL_VAL_NONE(pSchemas[i].colId, pSchemas[i].type); - taosArrayPush(pValues, &val); + if (NULL == taosArrayPush(pValues, &val)) { + code = TSDB_CODE_OUT_OF_MEMORY; + break; + } } + return code; } -void insInitColValues(STableMeta* pTableMeta, SArray* aColValues) { initColValues(pTableMeta, aColValues); } +int32_t insInitColValues(STableMeta* pTableMeta, SArray* aColValues) { return initColValues(pTableMeta, aColValues); } int32_t insInitBoundColsInfo(int32_t numOfBound, SBoundColInfo* pInfo) { pInfo->numOfCols = numOfBound; @@ -253,7 +258,7 @@ static int32_t createTableDataCxt(STableMeta* pTableMeta, SVCreateTbReq** pCreat if (NULL == pTableCxt->pValues) { code = TSDB_CODE_OUT_OF_MEMORY; } else { - initColValues(pTableMeta, pTableCxt->pValues); + code = initColValues(pTableMeta, pTableCxt->pValues); } } if (TSDB_CODE_SUCCESS == code) { @@ -281,9 +286,12 @@ static int32_t createTableDataCxt(STableMeta* pTableMeta, SVCreateTbReq** pCreat } } } - - *pOutput = pTableCxt; - qDebug("tableDataCxt created, code:%d, uid:%" PRId64 ", vgId:%d", code, pTableMeta->uid, pTableMeta->vgId); + if (TSDB_CODE_SUCCESS == code) { + *pOutput = pTableCxt; + qDebug("tableDataCxt created, code:%d, uid:%" PRId64 ", vgId:%d", code, pTableMeta->uid, pTableMeta->vgId); + } else { + insDestroyTableDataCxt(pTableCxt); + } return code; } @@ -301,24 +309,27 @@ static int32_t rebuildTableData(SSubmitTbData* pSrc, SSubmitTbData** pDst) { pTmp->pCreateTbReq = NULL; if (pTmp->flags & SUBMIT_REQ_AUTO_CREATE_TABLE) { if (pSrc->pCreateTbReq) { - cloneSVreateTbReq(pSrc->pCreateTbReq, &pTmp->pCreateTbReq); + code = cloneSVreateTbReq(pSrc->pCreateTbReq, &pTmp->pCreateTbReq); } else { pTmp->flags &= ~SUBMIT_REQ_AUTO_CREATE_TABLE; } } - - if (pTmp->flags & SUBMIT_REQ_COLUMN_DATA_FORMAT) { - pTmp->aCol = taosArrayInit(128, sizeof(SColData)); - if (NULL == pTmp->aCol) { - code = TSDB_CODE_OUT_OF_MEMORY; - taosMemoryFree(pTmp); + if (TSDB_CODE_SUCCESS == code) { + if (pTmp->flags & SUBMIT_REQ_COLUMN_DATA_FORMAT) { + pTmp->aCol = taosArrayInit(128, sizeof(SColData)); + if (NULL == pTmp->aCol) { + code = TSDB_CODE_OUT_OF_MEMORY; + taosMemoryFree(pTmp); + } + } else { + pTmp->aRowP = taosArrayInit(128, POINTER_BYTES); + if (NULL == pTmp->aRowP) { + code = TSDB_CODE_OUT_OF_MEMORY; + taosMemoryFree(pTmp); + } } } else { - pTmp->aRowP = taosArrayInit(128, POINTER_BYTES); - if (NULL == pTmp->aRowP) { - code = TSDB_CODE_OUT_OF_MEMORY; - taosMemoryFree(pTmp); - } + taosMemoryFree(pTmp); } } @@ -447,16 +458,19 @@ static int32_t fillVgroupDataCxt(STableDataCxt* pTableCxt, SVgroupDataCxt* pVgCx } // push data to submit, rebuild empty data for next submit - taosArrayPush(pVgCxt->pData->aSubmitTbData, pTableCxt->pData); + if (NULL == taosArrayPush(pVgCxt->pData->aSubmitTbData, pTableCxt->pData)) { + return TSDB_CODE_OUT_OF_MEMORY; + } + int32_t code = 0; if (isRebuild) { - rebuildTableData(pTableCxt->pData, &pTableCxt->pData); + code = rebuildTableData(pTableCxt->pData, &pTableCxt->pData); } else if (clear) { taosMemoryFreeClear(pTableCxt->pData); } qDebug("add tableDataCxt uid:%" PRId64 " to vgId:%d", pTableCxt->pMeta->uid, pVgCxt->vgId); - return TSDB_CODE_SUCCESS; + return code; } static int32_t createVgroupDataCxt(STableDataCxt* pTableCxt, SHashObj* pVgroupHash, SArray* pVgroupList, @@ -474,7 +488,11 @@ static int32_t createVgroupDataCxt(STableDataCxt* pTableCxt, SHashObj* pVgroupHa pVgCxt->vgId = pTableCxt->pMeta->vgId; int32_t code = taosHashPut(pVgroupHash, &pVgCxt->vgId, sizeof(pVgCxt->vgId), &pVgCxt, POINTER_BYTES); if (TSDB_CODE_SUCCESS == code) { - taosArrayPush(pVgroupList, &pVgCxt); + if (NULL == taosArrayPush(pVgroupList, &pVgCxt)) { + code = TSDB_CODE_OUT_OF_MEMORY; + insDestroyVgroupDataCxt(pVgCxt); + return code; + } // uDebug("td23101 2vgId:%d, uid:%" PRIu64, pVgCxt->vgId, pTableCxt->pMeta->uid); *pOutput = pVgCxt; } else { @@ -531,7 +549,10 @@ int32_t insGetStmtTableVgUid(SHashObj* pAllVgHash, SStbInterlaceInfo* pBuildInfo if (NULL == pTbInfo) { SName sname; - qCreateSName(&sname, pTbData->tbName, pBuildInfo->acctId, pBuildInfo->dbname, NULL, 0); + code = qCreateSName(&sname, pTbData->tbName, pBuildInfo->acctId, pBuildInfo->dbname, NULL, 0); + if (TSDB_CODE_SUCCESS != code) { + return code; + } STableMeta* pTableMeta = NULL; SRequestConnInfo conn = {.pTrans = pBuildInfo->transport, @@ -553,9 +574,10 @@ int32_t insGetStmtTableVgUid(SHashObj* pAllVgHash, SStbInterlaceInfo* pBuildInfo *vgId = pTableMeta->vgId; STableVgUid tbInfo = {.uid = *uid, .vgid = *vgId}; - tSimpleHashPut(pBuildInfo->pTableHash, pTbData->tbName, strlen(pTbData->tbName), &tbInfo, sizeof(tbInfo)); - - code = insTryAddTableVgroupInfo(pAllVgHash, pBuildInfo, vgId, pTbData, &sname); + code = tSimpleHashPut(pBuildInfo->pTableHash, pTbData->tbName, strlen(pTbData->tbName), &tbInfo, sizeof(tbInfo)); + if (TSDB_CODE_SUCCESS == code) { + code = insTryAddTableVgroupInfo(pAllVgHash, pBuildInfo, vgId, pTbData, &sname); + } taosMemoryFree(pTableMeta); } else { diff --git a/source/libs/parser/src/parTokenizer.c b/source/libs/parser/src/parTokenizer.c index cc5d2a1cdf..deec310862 100644 --- a/source/libs/parser/src/parTokenizer.c +++ b/source/libs/parser/src/parTokenizer.c @@ -352,22 +352,23 @@ static const char isIdChar[] = { static void* keywordHashTable = NULL; -static void doInitKeywordsTable(void) { +static int32_t doInitKeywordsTable(void) { int numOfEntries = tListLen(keywordTable); keywordHashTable = taosHashInit(numOfEntries, MurmurHash3_32, true, false); for (int32_t i = 0; i < numOfEntries; i++) { keywordTable[i].len = (uint8_t)strlen(keywordTable[i].name); void* ptr = &keywordTable[i]; - taosHashPut(keywordHashTable, keywordTable[i].name, keywordTable[i].len, (void*)&ptr, POINTER_BYTES); + int32_t code = taosHashPut(keywordHashTable, keywordTable[i].name, keywordTable[i].len, (void*)&ptr, POINTER_BYTES); + if (TSDB_CODE_SUCCESS != code) { + taosHashCleanup(keywordHashTable); + return code; + } } + return TSDB_CODE_SUCCESS; } -static TdThreadOnce keywordsHashTableInit = PTHREAD_ONCE_INIT; - static int32_t tKeywordCode(const char* z, int n) { - taosThreadOnce(&keywordsHashTableInit, doInitKeywordsTable); - char key[512] = {0}; if (n > tListLen(key)) { // too long token, can not be any other token type return TK_NK_ID; @@ -792,7 +793,7 @@ SToken tStrGetToken(const char* str, int32_t* i, bool isPrevOptr, bool* pIgnoreC // check the table name is '?', db.?asf is not valid. if (TK_NK_QUESTION == type) { - tGetToken(&str[*i + t0.n + 2], &type); + (void)tGetToken(&str[*i + t0.n + 2], &type); if (TK_NK_SPACE != type) { t0.type = TK_NK_ILLEGAL; t0.n = 0; @@ -821,6 +822,10 @@ SToken tStrGetToken(const char* str, int32_t* i, bool isPrevOptr, bool* pIgnoreC bool taosIsKeyWordToken(const char* z, int32_t len) { return (tKeywordCode((char*)z, len) != TK_NK_ID); } +int32_t taosInitKeywordsTable() { + return doInitKeywordsTable(); +} + void taosCleanupKeywordsTable() { void* m = keywordHashTable; if (m != NULL && atomic_val_compare_exchange_ptr(&keywordHashTable, m, 0) == m) { diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index 75269f2707..32bd9bdf7a 100644 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -3183,9 +3183,9 @@ static EDealRes rewriteExprToGroupKeyFunc(STranslateContext* pCxt, SNode** pNode } static EDealRes rewriteExprToSelectTagFunc(STranslateContext* pCxt, SNode** pNode) { - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); + SFunctionNode* pFunc = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); if (NULL == pFunc) { - pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; return DEAL_RES_ERROR; } @@ -7537,6 +7537,9 @@ static int32_t buildCmdMsg(STranslateContext* pCxt, int16_t msgType, FSerializeF pCxt->pCmdMsg->epSet = pCxt->pParseCxt->mgmtEpSet; pCxt->pCmdMsg->msgType = msgType; pCxt->pCmdMsg->msgLen = func(NULL, 0, pReq); + if (pCxt->pCmdMsg->msgLen < 0) { + return terrno; + } pCxt->pCmdMsg->pMsg = taosMemoryMalloc(pCxt->pCmdMsg->msgLen); if (NULL == pCxt->pCmdMsg->pMsg) { taosMemoryFreeClear(pCxt->pCmdMsg); diff --git a/source/libs/parser/src/parUtil.c b/source/libs/parser/src/parUtil.c index 2683343fb9..35d54ad43c 100644 --- a/source/libs/parser/src/parUtil.c +++ b/source/libs/parser/src/parUtil.c @@ -233,7 +233,7 @@ static char* getSyntaxErrFormat(int32_t errCode) { int32_t generateSyntaxErrMsg(SMsgBuf* pBuf, int32_t errCode, ...) { va_list vArgList; va_start(vArgList, errCode); - vsnprintf(pBuf->buf, pBuf->len, getSyntaxErrFormat(errCode), vArgList); + (void)vsnprintf(pBuf->buf, pBuf->len, getSyntaxErrFormat(errCode), vArgList); va_end(vArgList); return errCode; } @@ -241,7 +241,7 @@ int32_t generateSyntaxErrMsg(SMsgBuf* pBuf, int32_t errCode, ...) { int32_t generateSyntaxErrMsgExt(SMsgBuf* pBuf, int32_t errCode, const char* pFormat, ...) { va_list vArgList; va_start(vArgList, pFormat); - vsnprintf(pBuf->buf, pBuf->len, pFormat, vArgList); + (void)vsnprintf(pBuf->buf, pBuf->len, pFormat, vArgList); va_end(vArgList); return errCode; } @@ -254,7 +254,7 @@ int32_t buildInvalidOperationMsg(SMsgBuf* pBuf, const char* msg) { int32_t buildInvalidOperationMsgExt(SMsgBuf* pBuf, const char* pFormat, ...) { va_list vArgList; va_start(vArgList, pFormat); - vsnprintf(pBuf->buf, pBuf->len, pFormat, vArgList); + (void)vsnprintf(pBuf->buf, pBuf->len, pFormat, vArgList); va_end(vArgList); return TSDB_CODE_TSC_INVALID_OPERATION; } @@ -423,6 +423,10 @@ int32_t parseJsontoTagData(const char* json, SArray* pTagVals, STag** ppTag, voi } keyHash = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, false); + if (!keyHash) { + retCode = TSDB_CODE_OUT_OF_MEMORY; + goto end; + } for (int32_t i = 0; i < size; i++) { cJSON* item = cJSON_GetArrayItem(root, i); if (!item) { @@ -448,8 +452,11 @@ int32_t parseJsontoTagData(const char* json, SArray* pTagVals, STag** ppTag, voi STagVal val = {0}; // strcpy(val.colName, colName); val.pKey = jsonKey; - taosHashPut(keyHash, jsonKey, keyLen, &keyLen, - CHAR_BYTES); // add key to hash to remove dumplicate, value is useless + retCode = taosHashPut(keyHash, jsonKey, keyLen, &keyLen, + CHAR_BYTES); // add key to hash to remove dumplicate, value is useless + if (TSDB_CODE_SUCCESS != retCode) { + goto end; + } if (item->type == cJSON_String) { // add json value format: type|data char* jsonValue = item->valuestring; @@ -486,7 +493,10 @@ int32_t parseJsontoTagData(const char* json, SArray* pTagVals, STag** ppTag, voi retCode = buildSyntaxErrMsg(pMsgBuf, "invalidate json value", json); goto end; } - taosArrayPush(pTagVals, &val); + if (NULL == taosArrayPush(pTagVals, &val)) { + retCode = TSDB_CODE_OUT_OF_MEMORY; + goto end; + } } end: @@ -534,10 +544,11 @@ static int32_t getInsTagsTableTargetNameFromOp(int32_t acctId, SOperatorNode* pO return TSDB_CODE_SUCCESS; } -static void getInsTagsTableTargetObjName(int32_t acctId, SNode* pNode, SName* pName) { +static int32_t getInsTagsTableTargetObjName(int32_t acctId, SNode* pNode, SName* pName) { if (QUERY_NODE_OPERATOR == nodeType(pNode)) { - getInsTagsTableTargetNameFromOp(acctId, (SOperatorNode*)pNode, pName); + return getInsTagsTableTargetNameFromOp(acctId, (SOperatorNode*)pNode, pName); } + return TSDB_CODE_SUCCESS; } static int32_t getInsTagsTableTargetNameFromCond(int32_t acctId, SLogicConditionNode* pCond, SName* pName) { @@ -546,7 +557,12 @@ static int32_t getInsTagsTableTargetNameFromCond(int32_t acctId, SLogicCondition } SNode* pNode = NULL; - FOREACH(pNode, pCond->pParameterList) { getInsTagsTableTargetObjName(acctId, pNode, pName); } + FOREACH(pNode, pCond->pParameterList) { + int32_t code = getInsTagsTableTargetObjName(acctId, pNode, pName); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + } if ('\0' == pName->dbname[0]) { pName->type = 0; } @@ -634,8 +650,18 @@ static int32_t buildTableReq(SHashObj* pTablesHash, SArray** pTables) { char fullName[TSDB_TABLE_FNAME_LEN] = {0}; strncpy(fullName, pKey, len); SName name = {0}; - tNameFromString(&name, fullName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); - taosArrayPush(*pTables, &name); + int32_t code = tNameFromString(&name, fullName, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); + if (TSDB_CODE_SUCCESS == code) { + if (NULL == taosArrayPush(*pTables, &name)) { + code = TSDB_CODE_OUT_OF_MEMORY; + } + } + if (TSDB_CODE_SUCCESS != code) { + taosHashCancelIterate(pTablesHash, p); + taosArrayDestroy(*pTables); + *pTables = NULL; + return code; + } p = taosHashIterate(pTablesHash, p); } } @@ -654,7 +680,12 @@ static int32_t buildDbReq(SHashObj* pDbsHash, SArray** pDbs) { char* pKey = taosHashGetKey(p, &len); char fullName[TSDB_DB_FNAME_LEN] = {0}; strncpy(fullName, pKey, len); - taosArrayPush(*pDbs, fullName); + if (NULL == taosArrayPush(*pDbs, fullName)) { + taosHashCancelIterate(pDbsHash, p); + taosArrayDestroy(*pDbs); + *pDbs = NULL; + return TSDB_CODE_OUT_OF_MEMORY; + } p = taosHashIterate(pDbsHash, p); } } @@ -673,8 +704,18 @@ static int32_t buildTableReqFromDb(SHashObj* pDbsHash, SArray** pDbs) { while (NULL != p) { STablesReq req = {0}; strcpy(req.dbFName, p->dbFName); - buildTableReq(p->pTables, &req.pTables); - taosArrayPush(*pDbs, &req); + int32_t code = buildTableReq(p->pTables, &req.pTables); + if (TSDB_CODE_SUCCESS == code) { + if (NULL == taosArrayPush(*pDbs, &req)) { + code = TSDB_CODE_OUT_OF_MEMORY; + } + } + if (TSDB_CODE_SUCCESS != code) { + taosHashCancelIterate(pDbsHash, p); + taosArrayDestroy(*pDbs); + *pDbs = NULL; + return code; + } p = taosHashIterate(pDbsHash, p); } } @@ -695,7 +736,12 @@ static int32_t buildUserAuthReq(SHashObj* pUserAuthHash, SArray** pUserAuth) { strncpy(key, pKey, len); SUserAuthInfo userAuth = {0}; stringToUserAuth(key, len, &userAuth); - taosArrayPush(*pUserAuth, &userAuth); + if (NULL == taosArrayPush(*pUserAuth, &userAuth)) { + taosHashCancelIterate(pUserAuthHash, p); + taosArrayDestroy(*pUserAuth); + *pUserAuth = NULL; + return TSDB_CODE_OUT_OF_MEMORY; + } p = taosHashIterate(pUserAuthHash, p); } } @@ -714,7 +760,12 @@ static int32_t buildUdfReq(SHashObj* pUdfHash, SArray** pUdf) { char* pFunc = taosHashGetKey(p, &len); char func[TSDB_FUNC_NAME_LEN] = {0}; strncpy(func, pFunc, len); - taosArrayPush(*pUdf, func); + if (NULL == taosArrayPush(*pUdf, func)) { + taosHashCancelIterate(pUdfHash, p); + taosArrayDestroy(*pUdf); + *pUdf = NULL; + return TSDB_CODE_OUT_OF_MEMORY; + } p = taosHashIterate(pUdfHash, p); } } @@ -808,7 +859,10 @@ static int32_t putTableDataToCache(const SArray* pTableReq, const SArray* pTable int32_t ntables = taosArrayGetSize(pTableReq); for (int32_t i = 0; i < ntables; ++i) { char fullName[TSDB_TABLE_FNAME_LEN]; - tNameExtractFullName(taosArrayGet(pTableReq, i), fullName); + int32_t code = tNameExtractFullName(taosArrayGet(pTableReq, i), fullName); + if (TSDB_CODE_SUCCESS != code) { + return code; + } if (TSDB_CODE_SUCCESS != putMetaDataToHash(fullName, strlen(fullName), pTableData, i, pTable)) { return TSDB_CODE_OUT_OF_MEMORY; } @@ -836,7 +890,10 @@ static int32_t putDbTableDataToCache(const SArray* pDbReq, const SArray* pTableD int32_t ntables = taosArrayGetSize(pReq->pTables); for (int32_t j = 0; j < ntables; ++j) { char fullName[TSDB_TABLE_FNAME_LEN]; - tNameExtractFullName(taosArrayGet(pReq->pTables, j), fullName); + int32_t code = tNameExtractFullName(taosArrayGet(pReq->pTables, j), fullName); + if (TSDB_CODE_SUCCESS != code) { + return code; + } if (TSDB_CODE_SUCCESS != putMetaDataToHash(fullName, strlen(fullName), pTableData, tableNo, pTable)) { return TSDB_CODE_OUT_OF_MEMORY; } @@ -964,9 +1021,12 @@ int32_t reserveTableMetaInCacheExt(const SName* pName, SParseMetaCache* pMetaCac int32_t getTableMetaFromCache(SParseMetaCache* pMetaCache, const SName* pName, STableMeta** pMeta) { char fullName[TSDB_TABLE_FNAME_LEN]; - tNameExtractFullName(pName, fullName); + int32_t code = tNameExtractFullName(pName, fullName); + if (TSDB_CODE_SUCCESS != code) { + return code; + } STableMeta* pTableMeta = NULL; - int32_t code = getMetaDataFromHash(fullName, strlen(fullName), pMetaCache->pTableMeta, (void**)&pTableMeta); + code = getMetaDataFromHash(fullName, strlen(fullName), pMetaCache->pTableMeta, (void**)&pTableMeta); if (TSDB_CODE_SUCCESS == code) { *pMeta = tableMetaDup(pTableMeta); if (NULL == *pMeta) { @@ -998,9 +1058,12 @@ int32_t buildTableMetaFromViewMeta(STableMeta** pMeta, SViewMeta* pViewMeta) { int32_t getViewMetaFromCache(SParseMetaCache* pMetaCache, const SName* pName, STableMeta** pMeta) { char fullName[TSDB_TABLE_FNAME_LEN]; - tNameExtractFullName(pName, fullName); + int32_t code = tNameExtractFullName(pName, fullName); + if (TSDB_CODE_SUCCESS != code) { + return code; + } SViewMeta* pViewMeta = NULL; - int32_t code = getMetaDataFromHash(fullName, strlen(fullName), pMetaCache->pViews, (void**)&pViewMeta); + code = getMetaDataFromHash(fullName, strlen(fullName), pMetaCache->pViews, (void**)&pViewMeta); if (TSDB_CODE_SUCCESS == code) { code = buildTableMetaFromViewMeta(pMeta, pViewMeta); } @@ -1046,9 +1109,12 @@ int32_t reserveTableVgroupInCacheExt(const SName* pName, SParseMetaCache* pMetaC int32_t getTableVgroupFromCache(SParseMetaCache* pMetaCache, const SName* pName, SVgroupInfo* pVgroup) { char fullName[TSDB_TABLE_FNAME_LEN]; - tNameExtractFullName(pName, fullName); + int32_t code = tNameExtractFullName(pName, fullName); + if (TSDB_CODE_SUCCESS != code) { + return code; + } SVgroupInfo* pVg = NULL; - int32_t code = getMetaDataFromHash(fullName, strlen(fullName), pMetaCache->pTableVgroup, (void**)&pVg); + code = getMetaDataFromHash(fullName, strlen(fullName), pMetaCache->pTableVgroup, (void**)&pVg); if (TSDB_CODE_SUCCESS == code) { memcpy(pVgroup, pVg, sizeof(SVgroupInfo)); } @@ -1180,9 +1246,10 @@ int32_t reserveTSMAInfoInCache(int32_t acctId, const char* pDb, const char* pTsm int32_t getTableIndexFromCache(SParseMetaCache* pMetaCache, const SName* pName, SArray** pIndexes) { char fullName[TSDB_TABLE_FNAME_LEN]; - tNameExtractFullName(pName, fullName); + int32_t code = tNameExtractFullName(pName, fullName); + if (TSDB_CODE_SUCCESS != code) return code;; SArray* pSmaIndexes = NULL; - int32_t code = getMetaDataFromHash(fullName, strlen(fullName), pMetaCache->pTableIndex, (void**)&pSmaIndexes); + code = getMetaDataFromHash(fullName, strlen(fullName), pMetaCache->pTableIndex, (void**)&pSmaIndexes); if (TSDB_CODE_SUCCESS == code && NULL != pSmaIndexes) { *pIndexes = smaIndexesDup(pSmaIndexes); if (NULL == *pIndexes) { @@ -1194,9 +1261,12 @@ int32_t getTableIndexFromCache(SParseMetaCache* pMetaCache, const SName* pName, int32_t getTableTsmasFromCache(SParseMetaCache* pMetaCache, const SName* pTbName, SArray** pTsmas) { char tbFName[TSDB_TABLE_FNAME_LEN]; - tNameExtractFullName(pTbName, tbFName); + int32_t code = tNameExtractFullName(pTbName, tbFName); + if (TSDB_CODE_SUCCESS != code) { + return code; + } STableTSMAInfoRsp* pTsmasRsp = NULL; - int32_t code = getMetaDataFromHash(tbFName, strlen(tbFName), pMetaCache->pTableTSMAs, (void**)&pTsmasRsp); + code = getMetaDataFromHash(tbFName, strlen(tbFName), pMetaCache->pTableTSMAs, (void**)&pTsmasRsp); if (TSDB_CODE_SUCCESS == code && pTsmasRsp) { *pTsmas = pTsmasRsp->pTsmas; } @@ -1205,9 +1275,12 @@ int32_t getTableTsmasFromCache(SParseMetaCache* pMetaCache, const SName* pTbName int32_t getTsmaFromCache(SParseMetaCache* pMetaCache, const SName* pTsmaName, STableTSMAInfo** pTsma) { char tsmaFName[TSDB_TABLE_FNAME_LEN]; - tNameExtractFullName(pTsmaName, tsmaFName); + int32_t code = tNameExtractFullName(pTsmaName, tsmaFName); + if (TSDB_CODE_SUCCESS != code) { + return code; + } STableTSMAInfoRsp* pTsmaRsp = NULL; - int32_t code = getMetaDataFromHash(tsmaFName, strlen(tsmaFName), pMetaCache->pTSMAs, (void**)&pTsmaRsp); + code = getMetaDataFromHash(tsmaFName, strlen(tsmaFName), pMetaCache->pTSMAs, (void**)&pTsmaRsp); if (TSDB_CODE_SUCCESS == code && pTsmaRsp) { ASSERT(pTsmaRsp->pTsmas->size == 1); *pTsma = taosArrayGetP(pTsmaRsp->pTsmas, 0); @@ -1252,9 +1325,12 @@ STableCfg* tableCfgDup(STableCfg* pCfg) { int32_t getTableCfgFromCache(SParseMetaCache* pMetaCache, const SName* pName, STableCfg** pOutput) { char fullName[TSDB_TABLE_FNAME_LEN]; - tNameExtractFullName(pName, fullName); + int32_t code = tNameExtractFullName(pName, fullName); + if (TSDB_CODE_SUCCESS != code) { + return code; + } STableCfg* pCfg = NULL; - int32_t code = getMetaDataFromHash(fullName, strlen(fullName), pMetaCache->pTableCfg, (void**)&pCfg); + code = getMetaDataFromHash(fullName, strlen(fullName), pMetaCache->pTableCfg, (void**)&pCfg); if (TSDB_CODE_SUCCESS == code && NULL != pCfg) { *pOutput = tableCfgDup(pCfg); if (NULL == *pOutput) { diff --git a/source/libs/parser/src/parser.c b/source/libs/parser/src/parser.c index 3f753b7d16..e96aaf52ed 100644 --- a/source/libs/parser/src/parser.c +++ b/source/libs/parser/src/parser.c @@ -283,7 +283,7 @@ int32_t qParseSqlSyntax(SParseContext* pCxt, SQuery** pQuery, struct SCatalogReq code = parseQuerySyntax(pCxt, pQuery, pCatalogReq); } } - nodesReleaseAllocator(pCxt->allocatorId); + (void)nodesReleaseAllocator(pCxt->allocatorId); terrno = code; return code; } @@ -298,7 +298,7 @@ int32_t qAnalyseSqlSemantic(SParseContext* pCxt, const struct SCatalogReq* pCata if (TSDB_CODE_SUCCESS == code) { code = analyseSemantic(pCxt, pQuery, &metaCache); } - nodesReleaseAllocator(pCxt->allocatorId); + (void)nodesReleaseAllocator(pCxt->allocatorId); destoryParseMetaCache(&metaCache, false); terrno = code; return code; @@ -410,6 +410,10 @@ int32_t qSetSTableIdForRsma(SNode* pStmt, int64_t uid) { return TSDB_CODE_FAILED; } +int32_t qInitKeywordsTable() { + return taosInitKeywordsTable(); +} + void qCleanupKeywordsTable() { taosCleanupKeywordsTable(); } int32_t qStmtBindParams(SQuery* pQuery, TAOS_MULTI_BIND* pParams, int32_t colIdx) { diff --git a/source/libs/parser/test/mockCatalogService.cpp b/source/libs/parser/test/mockCatalogService.cpp index c0348ab43b..528ae2d2dd 100644 --- a/source/libs/parser/test/mockCatalogService.cpp +++ b/source/libs/parser/test/mockCatalogService.cpp @@ -46,12 +46,12 @@ class TableBuilder : public ITableBuilder { schema()->vgId = vgid; SVgroupInfo vgroup = {vgid, 0, 0, {0}, 0}; - addEpIntoEpSet(&vgroup.epSet, "dnode_1", 6030); - addEpIntoEpSet(&vgroup.epSet, "dnode_2", 6030); - addEpIntoEpSet(&vgroup.epSet, "dnode_3", 6030); + assert(TSDB_CODE_SUCCESS == addEpIntoEpSet(&vgroup.epSet, "dnode_1", 6030)); + assert(TSDB_CODE_SUCCESS == addEpIntoEpSet(&vgroup.epSet, "dnode_2", 6030)); + assert(TSDB_CODE_FAILED == addEpIntoEpSet(&vgroup.epSet, "dnode_3", 6030)); vgroup.epSet.inUse = 0; - meta_->vgs.emplace_back(vgroup); + (void)meta_->vgs.emplace_back(vgroup); return *this; } @@ -117,7 +117,7 @@ class MockCatalogServiceImpl { std::unique_ptr table; char db[TSDB_DB_NAME_LEN] = {0}; - tNameGetDbName(pTableName, db); + (void)tNameGetDbName(pTableName, db); const char* tname = tNameGetTableName(pTableName); int32_t code = copyTableSchemaMeta(db, tname, &table); @@ -140,7 +140,7 @@ class MockCatalogServiceImpl { int32_t catalogGetTableDistVgInfo(const SName* pTableName, SArray** vgList) const { char db[TSDB_DB_NAME_LEN] = {0}; - tNameGetDbName(pTableName, db); + (void)tNameGetDbName(pTableName, db); return copyTableVgroup(db, tNameGetTableName(pTableName), vgList); } @@ -174,7 +174,10 @@ class MockCatalogServiceImpl { int32_t catalogGetTableIndex(const SName* pTableName, SArray** pIndexes) const { char tbFName[TSDB_TABLE_FNAME_LEN] = {0}; - tNameExtractFullName(pTableName, tbFName); + int32_t code = tNameExtractFullName(pTableName, tbFName); + if (TSDB_CODE_SUCCESS != code) { + return code; + } auto it = index_.find(tbFName); if (index_.end() == it) { return TSDB_CODE_SUCCESS; @@ -183,15 +186,26 @@ class MockCatalogServiceImpl { for (const auto& index : it->second) { STableIndexInfo info; - taosArrayPush(*pIndexes, copyTableIndexInfo(&info, &index)); + if (nullptr == taosArrayPush(*pIndexes, copyTableIndexInfo(&info, &index))) { + taosArrayDestroy(*pIndexes); + *pIndexes = nullptr; + return TSDB_CODE_OUT_OF_MEMORY; + } } return TSDB_CODE_SUCCESS; } int32_t catalogGetDnodeList(SArray** pDnodes) const { *pDnodes = taosArrayInit(dnode_.size(), sizeof(SEpSet)); + if (!pDnodes) { + return TSDB_CODE_OUT_OF_MEMORY; + } for (const auto& dnode : dnode_) { - taosArrayPush(*pDnodes, &dnode.second); + if (nullptr == taosArrayPush(*pDnodes, &dnode.second)) { + taosArrayDestroy(*pDnodes); + *pDnodes = nullptr; + return TSDB_CODE_OUT_OF_MEMORY; + } } return TSDB_CODE_SUCCESS; } @@ -252,9 +266,9 @@ class MockCatalogServiceImpl { SVgroupInfo vgroup = {vgid, 0, 0, {0}, 0}; genEpSet(&vgroup.epSet); - meta_[db][tbname]->vgs.emplace_back(vgroup); + (void)meta_[db][tbname]->vgs.emplace_back(vgroup); // super table - meta_[db][stbname]->vgs.emplace_back(vgroup); + (void)meta_[db][stbname]->vgs.emplace_back(vgroup); } void showTables() const { @@ -345,7 +359,7 @@ class MockCatalogServiceImpl { void createDnode(int32_t dnodeId, const string& host, int16_t port) { SEpSet epSet = {0}; - addEpIntoEpSet(&epSet, host.c_str(), port); + assert(TSDB_CODE_SUCCESS == addEpIntoEpSet(&epSet, host.c_str(), port)); dnode_.insert(std::make_pair(dnodeId, epSet)); } @@ -370,9 +384,9 @@ class MockCatalogServiceImpl { uint64_t getNextId() { return id_++; } void genEpSet(SEpSet* pEpSet) { - addEpIntoEpSet(pEpSet, "dnode_1", 6030); - addEpIntoEpSet(pEpSet, "dnode_2", 6030); - addEpIntoEpSet(pEpSet, "dnode_3", 6030); + assert(TSDB_CODE_SUCCESS == addEpIntoEpSet(pEpSet, "dnode_1", 6030)); + assert(TSDB_CODE_SUCCESS == addEpIntoEpSet(pEpSet, "dnode_2", 6030)); + assert(TSDB_CODE_SUCCESS == addEpIntoEpSet(pEpSet, "dnode_3", 6030)); pEpSet->inUse = 0; } @@ -456,8 +470,15 @@ class MockCatalogServiceImpl { return TSDB_CODE_SUCCESS; } *vgList = taosArrayInit(table->vgs.size(), sizeof(SVgroupInfo)); + if (!*vgList) { + return TSDB_CODE_OUT_OF_MEMORY; + } for (const SVgroupInfo& vg : table->vgs) { - taosArrayPush(*vgList, &vg); + if (nullptr == taosArrayPush(*vgList, &vg)) { + taosArrayDestroy(*vgList); + *vgList = nullptr; + return TSDB_CODE_OUT_OF_MEMORY; + } } return TSDB_CODE_SUCCESS; } @@ -478,13 +499,21 @@ class MockCatalogServiceImpl { if (NULL != pTableMetaReq) { int32_t ndbs = taosArrayGetSize(pTableMetaReq); *pTableMetaData = taosArrayInit(ndbs, sizeof(SMetaRes)); + if (!*pTableMetaData) { + return TSDB_CODE_OUT_OF_MEMORY; + } for (int32_t i = 0; i < ndbs; ++i) { STablesReq* pReq = (STablesReq*)taosArrayGet(pTableMetaReq, i); int32_t ntables = taosArrayGetSize(pReq->pTables); for (int32_t j = 0; j < ntables; ++j) { SMetaRes res = {0}; res.code = catalogGetTableMeta((const SName*)taosArrayGet(pReq->pTables, j), (STableMeta**)&res.pRes); - taosArrayPush(*pTableMetaData, &res); + if (nullptr == taosArrayPush(*pTableMetaData, &res)) { + MockCatalogService::destoryMetaRes(&res); + taosArrayDestroyEx(*pTableMetaData, MockCatalogService::destoryMetaRes); + *pTableMetaData = nullptr; + return TSDB_CODE_OUT_OF_MEMORY; + } } } } @@ -495,14 +524,27 @@ class MockCatalogServiceImpl { if (NULL != pTableVgroupReq) { int32_t ndbs = taosArrayGetSize(pTableVgroupReq); *pTableVgroupData = taosArrayInit(ndbs, sizeof(SMetaRes)); + if (!*pTableVgroupData) { + return TSDB_CODE_OUT_OF_MEMORY; + } for (int32_t i = 0; i < ndbs; ++i) { STablesReq* pReq = (STablesReq*)taosArrayGet(pTableVgroupReq, i); int32_t ntables = taosArrayGetSize(pReq->pTables); for (int32_t j = 0; j < ntables; ++j) { SMetaRes res = {0}; res.pRes = taosMemoryCalloc(1, sizeof(SVgroupInfo)); + if (!res.pRes) { + taosArrayDestroyEx(*pTableVgroupData, MockCatalogService::destoryMetaRes); + *pTableVgroupData = nullptr; + return TSDB_CODE_OUT_OF_MEMORY; + } res.code = catalogGetTableHashVgroup((const SName*)taosArrayGet(pReq->pTables, j), (SVgroupInfo*)res.pRes); - taosArrayPush(*pTableVgroupData, &res); + if (nullptr == taosArrayPush(*pTableVgroupData, &res)) { + MockCatalogService::destoryMetaRes(&res); + taosArrayDestroyEx(*pTableVgroupData, MockCatalogService::destoryMetaRes); + *pTableVgroupData = nullptr; + return TSDB_CODE_OUT_OF_MEMORY; + } } } } @@ -514,9 +556,16 @@ class MockCatalogServiceImpl { if (NULL != pDbVgroupReq) { int32_t ndbs = taosArrayGetSize(pDbVgroupReq); *pDbVgroupData = taosArrayInit(ndbs, sizeof(SMetaRes)); + if (!*pDbVgroupData) { + return TSDB_CODE_OUT_OF_MEMORY; + } for (int32_t i = 0; i < ndbs; ++i) { SMetaRes res = {0}; - taosArrayPush(*pDbVgroupData, &res); + if (nullptr == taosArrayPush(*pDbVgroupData, &res)) { + taosArrayDestroyEx(*pDbVgroupData, MockCatalogService::destoryMetaRes); + *pDbVgroupData = nullptr; + return TSDB_CODE_OUT_OF_MEMORY; + } } } return code; @@ -529,11 +578,17 @@ class MockCatalogServiceImpl { } std::set vgSet; *pVgList = taosArrayInit(it->second.size(), sizeof(SVgroupInfo)); + if (!*pVgList) { + return TSDB_CODE_OUT_OF_MEMORY; + } for (const auto& vgs : it->second) { for (const auto& vg : vgs.second->vgs) { if (0 == vgSet.count(vg.vgId)) { - taosArrayPush(*pVgList, &vg); - vgSet.insert(vg.vgId); + if (nullptr == taosArrayPush(*pVgList, &vg)) { + taosArrayDestroy(*pVgList); + return TSDB_CODE_OUT_OF_MEMORY; + } + (void)vgSet.insert(vg.vgId); } } } @@ -543,12 +598,18 @@ class MockCatalogServiceImpl { int32_t catalogGetAllDBVgList(SArray** pVgList) const { std::set vgSet; *pVgList = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SVgroupInfo)); + if (!*pVgList) { + return TSDB_CODE_OUT_OF_MEMORY; + } for (const auto& db : meta_) { for (const auto& vgs : db.second) { for (const auto& vg : vgs.second->vgs) { if (0 == vgSet.count(vg.vgId)) { - taosArrayPush(*pVgList, &vg); - vgSet.insert(vg.vgId); + if (nullptr == taosArrayPush(*pVgList, &vg)) { + taosArrayDestroy(*pVgList); + return TSDB_CODE_OUT_OF_MEMORY; + } + (void)vgSet.insert(vg.vgId); } } } @@ -561,11 +622,24 @@ class MockCatalogServiceImpl { if (NULL != pDbCfgReq) { int32_t ndbs = taosArrayGetSize(pDbCfgReq); *pDbCfgData = taosArrayInit(ndbs, sizeof(SMetaRes)); + if (!*pDbCfgData) { + return TSDB_CODE_OUT_OF_MEMORY; + } for (int32_t i = 0; i < ndbs; ++i) { SMetaRes res = {0}; res.pRes = taosMemoryCalloc(1, sizeof(SDbCfgInfo)); + if (!res.pRes) { + taosArrayDestroyEx(*pDbCfgData, MockCatalogService::destoryMetaRes); + *pDbCfgData = nullptr; + return TSDB_CODE_OUT_OF_MEMORY; + } res.code = catalogGetDBCfg((const char*)taosArrayGet(pDbCfgReq, i), (SDbCfgInfo*)res.pRes); - taosArrayPush(*pDbCfgData, &res); + if (nullptr == taosArrayPush(*pDbCfgData, &res)) { + MockCatalogService::destoryMetaRes(&res); + taosArrayDestroyEx(*pDbCfgData, MockCatalogService::destoryMetaRes); + *pDbCfgData = nullptr; + return TSDB_CODE_OUT_OF_MEMORY; + } } } return code; @@ -576,10 +650,18 @@ class MockCatalogServiceImpl { if (NULL != pDbInfoReq) { int32_t ndbs = taosArrayGetSize(pDbInfoReq); *pDbInfoData = taosArrayInit(ndbs, sizeof(SMetaRes)); + if (!*pDbInfoData) { + return TSDB_CODE_OUT_OF_MEMORY; + } for (int32_t i = 0; i < ndbs; ++i) { SMetaRes res = {0}; res.pRes = taosMemoryCalloc(1, sizeof(SDbInfo)); - taosArrayPush(*pDbInfoData, &res); + if (!res.pRes || (nullptr == taosArrayPush(*pDbInfoData, &res))) { + MockCatalogService::destoryMetaRes(&res); + taosArrayDestroyEx(*pDbInfoData, MockCatalogService::destoryMetaRes); + *pDbInfoData = nullptr; + return TSDB_CODE_OUT_OF_MEMORY; + } } } return code; @@ -590,11 +672,25 @@ class MockCatalogServiceImpl { if (NULL != pUserAuthReq) { int32_t num = taosArrayGetSize(pUserAuthReq); *pUserAuthData = taosArrayInit(num, sizeof(SMetaRes)); + if (!*pUserAuthData) { + return TSDB_CODE_OUT_OF_MEMORY; + } + int32_t code = TSDB_CODE_SUCCESS; for (int32_t i = 0; i < num; ++i) { SMetaRes res = {0}; res.pRes = taosMemoryCalloc(1, sizeof(SUserAuthRes)); + if (!res.pRes) { + taosArrayDestroy(*pUserAuthData); + *pUserAuthData = nullptr; + return TSDB_CODE_OUT_OF_MEMORY; + } ((SUserAuthRes*)res.pRes)->pass[0] = true; - taosArrayPush(*pUserAuthData, &res); + if (nullptr == taosArrayPush(*pUserAuthData, &res)) { + MockCatalogService::destoryMetaRes(&res); + taosArrayDestroyEx(*pUserAuthData, MockCatalogService::destoryMetaRes); + *pUserAuthData = nullptr; + return TSDB_CODE_OUT_OF_MEMORY; + } } } return code; @@ -604,11 +700,24 @@ class MockCatalogServiceImpl { if (NULL != pUdfReq) { int32_t num = taosArrayGetSize(pUdfReq); *pUdfData = taosArrayInit(num, sizeof(SMetaRes)); + if (!*pUdfData) { + return TSDB_CODE_OUT_OF_MEMORY; + } for (int32_t i = 0; i < num; ++i) { SMetaRes res = {0}; res.pRes = taosMemoryCalloc(1, sizeof(SFuncInfo)); + if (!res.pRes) { + taosArrayDestroyEx(*pUdfData, MockCatalogService::destoryMetaRes); + *pUdfData = nullptr; + return TSDB_CODE_OUT_OF_MEMORY; + } res.code = catalogGetUdfInfo((char*)taosArrayGet(pUdfReq, i), (SFuncInfo*)res.pRes); - taosArrayPush(*pUdfData, &res); + if (nullptr == taosArrayPush(*pUdfData, &res)) { + MockCatalogService::destoryMetaRes(&res); + taosArrayDestroyEx(*pUdfData, MockCatalogService::destoryMetaRes); + *pUdfData = nullptr; + return TSDB_CODE_OUT_OF_MEMORY; + } } } return TSDB_CODE_SUCCESS; @@ -618,10 +727,18 @@ class MockCatalogServiceImpl { if (NULL != pTableIndex) { int32_t num = taosArrayGetSize(pTableIndex); *pTableIndexData = taosArrayInit(num, sizeof(SMetaRes)); + if (!*pTableIndexData) { + return TSDB_CODE_OUT_OF_MEMORY; + } for (int32_t i = 0; i < num; ++i) { SMetaRes res = {0}; res.code = catalogGetTableIndex((const SName*)taosArrayGet(pTableIndex, i), (SArray**)(&res.pRes)); - taosArrayPush(*pTableIndexData, &res); + if (nullptr == taosArrayPush(*pTableIndexData, &res)) { + MockCatalogService::destoryMetaRes(&res); + taosArrayDestroyEx(*pTableIndexData, MockCatalogService::destoryMetaRes); + *pTableIndexData = nullptr; + return TSDB_CODE_OUT_OF_MEMORY; + } } } return TSDB_CODE_SUCCESS; @@ -631,11 +748,20 @@ class MockCatalogServiceImpl { if (NULL != pTableCfgReq) { int32_t ntables = taosArrayGetSize(pTableCfgReq); *pTableCfgData = taosArrayInit(ntables, sizeof(SMetaRes)); + if (!*pTableCfgData) { + return TSDB_CODE_OUT_OF_MEMORY; + } + int32_t code = 0; for (int32_t i = 0; i < ntables; ++i) { SMetaRes res = {0}; - res.pRes = taosMemoryCalloc(1, sizeof(STableCfg)); res.code = TSDB_CODE_SUCCESS; - taosArrayPush(*pTableCfgData, &res); + res.pRes = taosMemoryCalloc(1, sizeof(STableCfg)); + if (!res.pRes || (nullptr == taosArrayPush(*pTableCfgData, &res))) { + taosMemoryFree(res.pRes); + taosArrayDestroy(*pTableCfgData); + *pTableCfgData = nullptr; + return TSDB_CODE_OUT_OF_MEMORY; + } } } return TSDB_CODE_SUCCESS; @@ -645,11 +771,18 @@ class MockCatalogServiceImpl { if (NULL != pViewMetaReq) { int32_t nviews = taosArrayGetSize(pViewMetaReq); *pViewMetaData = taosArrayInit(nviews, sizeof(SMetaRes)); + if (!*pViewMetaData) { + return TSDB_CODE_OUT_OF_MEMORY; + } for (int32_t i = 0; i < nviews; ++i) { SMetaRes res = {0}; - res.pRes = NULL; + res.pRes = nullptr; res.code = TSDB_CODE_PAR_TABLE_NOT_EXIST; - taosArrayPush(*pViewMetaData, &res); + if (nullptr == taosArrayPush(*pViewMetaData, &res)) { + taosArrayDestroyEx(*pViewMetaData, MockCatalogService::destoryMetaRes); + *pViewMetaData = nullptr; + return TSDB_CODE_OUT_OF_MEMORY; + } } } return TSDB_CODE_SUCCESS; @@ -657,9 +790,20 @@ class MockCatalogServiceImpl { int32_t getAllDnodeList(SArray** pDnodes) const { SMetaRes res = {0}; - catalogGetDnodeList((SArray**)&res.pRes); + int32_t code = catalogGetDnodeList((SArray**)&res.pRes); + if (TSDB_CODE_SUCCESS != code) { + return code; + } *pDnodes = taosArrayInit(1, sizeof(SMetaRes)); - taosArrayPush(*pDnodes, &res); + if (!*pDnodes) { + return TSDB_CODE_OUT_OF_MEMORY; + } + if (nullptr == taosArrayPush(*pDnodes, &res)) { + MockCatalogService::destoryMetaArrayRes(&res); + taosArrayDestroyEx(*pDnodes, MockCatalogService::destoryMetaArrayRes); + *pDnodes = nullptr; + return TSDB_CODE_OUT_OF_MEMORY; + } return TSDB_CODE_SUCCESS; } diff --git a/source/libs/parser/test/parAlterToBalanceTest.cpp b/source/libs/parser/test/parAlterToBalanceTest.cpp index 4e7325c9b2..d25435913f 100644 --- a/source/libs/parser/test/parAlterToBalanceTest.cpp +++ b/source/libs/parser/test/parAlterToBalanceTest.cpp @@ -358,9 +358,9 @@ TEST_F(ParserInitialATest, alterLocal) { }; auto setAlterLocal = [&](const char* pConfig, const char* pValue = nullptr) { - expect.first.assign(pConfig); + (void)expect.first.assign(pConfig); if (nullptr != pValue) { - expect.second.assign(pValue); + (void)expect.second.assign(pValue); } }; @@ -429,9 +429,10 @@ TEST_F(ParserInitialATest, alterSTable) { expect.numOfFields = numOfFields; if (NULL == expect.pFields) { expect.pFields = taosArrayInit(2, sizeof(TAOS_FIELD)); + ASSERT_TRUE(expect.pFields); TAOS_FIELD field = {0}; - taosArrayPush(expect.pFields, &field); - taosArrayPush(expect.pFields, &field); + ASSERT_TRUE(nullptr != taosArrayPush(expect.pFields, &field)); + ASSERT_TRUE(nullptr != taosArrayPush(expect.pFields, &field)); } TAOS_FIELD* pField = (TAOS_FIELD*)taosArrayGet(expect.pFields, 0); @@ -706,9 +707,10 @@ TEST_F(ParserInitialATest, alterTable) { expect.numOfFields = numOfFields; if (NULL == expect.pFields) { expect.pFields = taosArrayInit(2, sizeof(TAOS_FIELD)); + ASSERT_TRUE(expect.pFields); TAOS_FIELD field = {0}; - taosArrayPush(expect.pFields, &field); - taosArrayPush(expect.pFields, &field); + ASSERT_TRUE(nullptr != taosArrayPush(expect.pFields, &field)); + ASSERT_TRUE(nullptr != taosArrayPush(expect.pFields, &field)); } TAOS_FIELD* pField = (TAOS_FIELD*)taosArrayGet(expect.pFields, 0); diff --git a/source/libs/parser/test/parInitialCTest.cpp b/source/libs/parser/test/parInitialCTest.cpp index 1a3559316c..4d314a6edf 100644 --- a/source/libs/parser/test/parInitialCTest.cpp +++ b/source/libs/parser/test/parInitialCTest.cpp @@ -192,8 +192,9 @@ TEST_F(ParserInitialCTest, createDatabase) { retention.keepUnit = keepUnit; if (NULL == expect.pRetensions) { expect.pRetensions = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SRetention)); + ASSERT_TRUE(expect.pRetensions); } - taosArrayPush(expect.pRetensions, &retention); + ASSERT_TRUE(taosArrayPush(expect.pRetensions, &retention) != nullptr); ++expect.numOfRetensions; }; auto setDbSchemaless = [&](int8_t schemaless) { expect.schemaless = schemaless; }; @@ -449,7 +450,7 @@ TEST_F(ParserInitialCTest, createFunction) { file << 123 << "abc" << '\n'; file.close(); } - ~udfFile() { remove(path_.c_str()); } + ~udfFile() { assert(0 == remove(path_.c_str())); } std::string path_; } udffile("udf"); @@ -506,7 +507,7 @@ TEST_F(ParserInitialCTest, createView) { if (NULL == expect.pTags) { expect.pTags = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SField)); } - taosArrayPush(expect.pTags, &field); + ASSERT_TRUE(nullptr != taosArrayPush(expect.pTags, &field)); expect.numOfTags += 1; }; @@ -684,7 +685,7 @@ TEST_F(ParserInitialCTest, createSmaIndex) { pCmdMsg->msgLen = tSerializeSMCreateSmaReq(NULL, 0, pStmt->pReq); pCmdMsg->pMsg = taosMemoryMalloc(pCmdMsg->msgLen); if (!pCmdMsg->pMsg) FAIL(); - tSerializeSMCreateSmaReq(pCmdMsg->pMsg, pCmdMsg->msgLen, pStmt->pReq); + ASSERT_EQ(TSDB_CODE_SUCCESS, tSerializeSMCreateSmaReq(pCmdMsg->pMsg, pCmdMsg->msgLen, pStmt->pReq)); ((SQuery*)pQuery)->pCmdMsg = pCmdMsg; ASSERT_TRUE(TSDB_CODE_SUCCESS == tDeserializeSMCreateSmaReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req)); @@ -797,13 +798,13 @@ TEST_F(ParserInitialCTest, createStable) { if (NULL == expect.pColumns) { expect.pColumns = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SField)); } - taosArrayPush(expect.pColumns, &field); + ASSERT_TRUE(nullptr != taosArrayPush(expect.pColumns, &field)); expect.numOfColumns += 1; } else { if (NULL == expect.pTags) { expect.pTags = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SField)); } - taosArrayPush(expect.pTags, &field); + ASSERT_TRUE(taosArrayPush(expect.pTags, &field) != nullptr); expect.numOfTags += 1; } }; @@ -983,7 +984,7 @@ TEST_F(ParserInitialCTest, createStream) { if (NULL == expect.pTags) { expect.pTags = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SField)); } - taosArrayPush(expect.pTags, &field); + ASSERT_TRUE(taosArrayPush(expect.pTags, &field) != nullptr); expect.numOfTags += 1; }; @@ -1123,8 +1124,9 @@ TEST_F(ParserInitialCTest, createTable) { ++expect.nReqs; if (nullptr == expect.pArray) { expect.pArray = taosArrayInit(TARRAY_MIN_SIZE, sizeof(SVCreateTbReq)); + ASSERT_TRUE(expect.pArray != nullptr); } - taosArrayPush(expect.pArray, &req); + ASSERT_TRUE(taosArrayPush(expect.pArray, &req) != nullptr); }; setCheckDdlFunc([&](const SQuery* pQuery, ParserStage stage) { @@ -1200,11 +1202,11 @@ TEST_F(ParserInitialCTest, createTableSemanticCheck) { string sql = "CREATE TABLE st1(ts TIMESTAMP, "; for (int32_t i = 1; i < 4096; ++i) { if (i > 1) { - sql.append(", "); + (void)sql.append(", "); } - sql.append("c" + to_string(i) + " INT"); + (void)sql.append("c" + to_string(i) + " INT"); } - sql.append(") TAGS (t1 int)"); + (void)sql.append(") TAGS (t1 int)"); run(sql, TSDB_CODE_PAR_TOO_MANY_COLUMNS); } diff --git a/source/libs/parser/test/parTestMain.cpp b/source/libs/parser/test/parTestMain.cpp index c8925b3df7..87ecf34ebc 100644 --- a/source/libs/parser/test/parTestMain.cpp +++ b/source/libs/parser/test/parTestMain.cpp @@ -35,8 +35,7 @@ namespace ParserTest { class ParserEnv : public testing::Environment { public: virtual void SetUp() { - // TODO(smj) : How to handle return value of fmFuncMgtInit - (void)fmFuncMgtInit(); + ASSERT_EQ(TSDB_CODE_SUCCESS, fmFuncMgtInit()); initMetaDataEnv(); generateMetaData(); initLog(TD_TMP_DIR_PATH "td"); @@ -71,7 +70,7 @@ class ParserEnv : public testing::Environment { tsAsyncLog = 0; taosRemoveDir(path); - taosMkDir(path); + ASSERT_EQ(TSDB_CODE_SUCCESS, taosMkDir(path)); tstrncpy(tsLogDir, path, PATH_MAX); if (taosInitLog("taoslog", 1) != 0) { std::cout << "failed to init log file" << std::endl; @@ -118,7 +117,7 @@ static void parseArg(int argc, char* argv[]) { } // namespace ParserTest int main(int argc, char* argv[]) { - testing::AddGlobalTestEnvironment(new ParserTest::ParserEnv()); + (void)testing::AddGlobalTestEnvironment(new ParserTest::ParserEnv()); testing::InitGoogleTest(&argc, argv); ParserTest::parseArg(argc, argv); return RUN_ALL_TESTS(); diff --git a/source/libs/parser/test/parTestUtil.cpp b/source/libs/parser/test/parTestUtil.cpp index dfe9fcf96e..854036bcd0 100644 --- a/source/libs/parser/test/parTestUtil.cpp +++ b/source/libs/parser/test/parTestUtil.cpp @@ -216,7 +216,7 @@ class ParserTestBaseImpl { void setParseContext(const string& sql, SParseContext* pCxt, bool async = false) { stmtEnv_.sql_ = sql; - strtolower((char*)stmtEnv_.sql_.c_str(), sql.c_str()); + (void)strtolower((char*)stmtEnv_.sql_.c_str(), sql.c_str()); pCxt->acctId = atoi(caseEnv_.acctId_.c_str()); pCxt->db = caseEnv_.db_.c_str(); diff --git a/source/libs/planner/src/planLogicCreater.c b/source/libs/planner/src/planLogicCreater.c index 998f2cd2f4..d5ee5c51df 100644 --- a/source/libs/planner/src/planLogicCreater.c +++ b/source/libs/planner/src/planLogicCreater.c @@ -506,10 +506,17 @@ static int32_t createSubqueryLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSe int32_t collectJoinResColumns(SSelectStmt* pSelect, SJoinLogicNode* pJoin, SNodeList** pCols) { SSHashObj* pTables = NULL; - collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pTables); - collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pTables); - - int32_t code = nodesCollectColumnsExt(pSelect, SQL_CLAUSE_WHERE, pTables, COLLECT_COL_TYPE_ALL, pCols); + int32_t code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pTables); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pTables); + if (TSDB_CODE_SUCCESS != code) { + tSimpleHashCleanup(pTables); + return code; + } else { + code = nodesCollectColumnsExt(pSelect, SQL_CLAUSE_WHERE, pTables, COLLECT_COL_TYPE_ALL, pCols); + } tSimpleHashCleanup(pTables); diff --git a/source/libs/planner/src/planOptimizer.c b/source/libs/planner/src/planOptimizer.c index 6184b2310f..27d3e80ef0 100644 --- a/source/libs/planner/src/planOptimizer.c +++ b/source/libs/planner/src/planOptimizer.c @@ -113,7 +113,7 @@ typedef struct SJoinOptimizeOpt { int8_t pushDownFlag; } SJoinOptimizeOpt; -typedef bool (*FMayBeOptimized)(SLogicNode* pNode); +typedef bool (*FMayBeOptimized)(SLogicNode* pNode, void* pCtx); typedef bool (*FShouldBeOptimized)(SLogicNode* pNode, void* pInfo); #if 0 @@ -144,13 +144,13 @@ static SJoinOptimizeOpt gJoinOnOpt[JOIN_TYPE_MAX_VALUE][JOIN_STYPE_MAX_VALUE] = #endif -static SLogicNode* optFindPossibleNode(SLogicNode* pNode, FMayBeOptimized func) { - if (func(pNode)) { +static SLogicNode* optFindPossibleNode(SLogicNode* pNode, FMayBeOptimized func, void* pCtx) { + if (func(pNode, pCtx)) { return pNode; } SNode* pChild; FOREACH(pChild, pNode->pChildren) { - SLogicNode* pScanNode = optFindPossibleNode((SLogicNode*)pChild, func); + SLogicNode* pScanNode = optFindPossibleNode((SLogicNode*)pChild, func, pCtx); if (NULL != pScanNode) { return pScanNode; } @@ -240,7 +240,7 @@ static bool scanPathOptHaveNormalCol(SNodeList* pList) { return res; } -static bool scanPathOptMayBeOptimized(SLogicNode* pNode) { +static bool scanPathOptMayBeOptimized(SLogicNode* pNode, void* pCtx) { if (OPTIMIZE_FLAG_TEST_MASK(pNode->optimizedFlag, OPTIMIZE_FLAG_SCAN_PATH)) { return false; } @@ -372,7 +372,7 @@ static int32_t scanPathOptSetOsdInfo(SOsdInfo* pInfo) { } static int32_t scanPathOptMatch(SOptimizeContext* pCxt, SLogicNode* pLogicNode, SOsdInfo* pInfo) { - pInfo->pScan = (SScanLogicNode*)optFindPossibleNode(pLogicNode, scanPathOptMayBeOptimized); + pInfo->pScan = (SScanLogicNode*)optFindPossibleNode(pLogicNode, scanPathOptMayBeOptimized, NULL); if (NULL == pInfo->pScan) { return TSDB_CODE_SUCCESS; } @@ -674,8 +674,15 @@ static int32_t pdcJoinSplitLogicCond(SJoinLogicNode* pJoin, SNode** pSrcCond, SN int32_t code = TSDB_CODE_SUCCESS; SSHashObj* pLeftTables = NULL; SSHashObj* pRightTables = NULL; - collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables); - collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables); + code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables); + if (TSDB_CODE_SUCCESS != code) { + tSimpleHashCleanup(pLeftTables); + return code; + } SNodeList* pOnConds = NULL; SNodeList* pLeftChildConds = NULL; @@ -747,8 +754,15 @@ static int32_t pdcJoinSplitOpCond(SJoinLogicNode* pJoin, SNode** pSrcCond, SNode SNode** pRightChildCond, bool whereCond) { SSHashObj* pLeftTables = NULL; SSHashObj* pRightTables = NULL; - collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables); - collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables); + int32_t code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables); + if (TSDB_CODE_SUCCESS != code) { + tSimpleHashCleanup(pLeftTables); + return code; + } ECondAction condAction = pdcJoinGetCondAction(pJoin, pLeftTables, pRightTables, *pSrcCond, whereCond); @@ -829,8 +843,15 @@ static bool pdcJoinIsPrimEqualCond(SJoinLogicNode* pJoin, SNode* pCond) { SSHashObj* pLeftTables = NULL; SSHashObj* pRightTables = NULL; - collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables); - collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables); + int32_t code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables); + if (TSDB_CODE_SUCCESS != code) { + tSimpleHashCleanup(pLeftTables); + return code; + } bool res = false; if (pdcJoinIsPrim(pOper->pLeft, pLeftTables)) { @@ -1200,8 +1221,15 @@ static int32_t pdcJoinAddParentOnColsToTarget(SOptimizeContext* pCxt, SJoinLogic } SSHashObj* pTables = NULL; - collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pTables); - collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pTables); + code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pTables); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pTables); + if (TSDB_CODE_SUCCESS != code) { + tSimpleHashCleanup(pTables); + return code; + } SJoinLogicNode* pTmp = (SJoinLogicNode*)pJoin->node.pParent; do { @@ -1545,15 +1573,24 @@ static int32_t pdcRewriteTypeBasedOnConds(SOptimizeContext* pCxt, SJoinLogicNode SSHashObj* pLeftTables = NULL; SSHashObj* pRightTables = NULL; - collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables); - collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables); + int32_t code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + + code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables); + if (TSDB_CODE_SUCCESS != code) { + tSimpleHashCleanup(pLeftTables); + return code; + } bool tableCondTypes[4] = {0}; - int32_t code = pdcGetTableCondTypes(pJoin->node.pConditions, pLeftTables, pRightTables, tableCondTypes); - + code = pdcGetTableCondTypes(pJoin->node.pConditions, pLeftTables, pRightTables, tableCondTypes); tSimpleHashCleanup(pLeftTables); tSimpleHashCleanup(pRightTables); + if (TSDB_CODE_SUCCESS != code) return code; + switch (pJoin->joinType) { case JOIN_TYPE_LEFT: if (tableCondTypes[2] && !tableCondTypes[3]) { @@ -1658,8 +1695,15 @@ static int32_t pdcRewriteTypeBasedOnJoinRes(SOptimizeContext* pCxt, SJoinLogicNo int32_t code = 0; SSHashObj* pLeftTables = NULL; SSHashObj* pRightTables = NULL; - collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables); - collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables); + code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 0), &pLeftTables); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + code = collectTableAliasFromNodes(nodesListGetNode(pJoin->node.pChildren, 1), &pRightTables); + if (TSDB_CODE_SUCCESS != code) { + tSimpleHashCleanup(pLeftTables); + return code; + } SLogicNode* pParent = pJoin->node.pParent; bool tableResNonNull[2] = {true, true}; @@ -2101,7 +2145,7 @@ static int32_t pdcOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) } -static bool eliminateNotNullCondMayBeOptimized(SLogicNode* pNode) { +static bool eliminateNotNullCondMayBeOptimized(SLogicNode* pNode, void* pCtx) { if (QUERY_NODE_LOGIC_PLAN_AGG != nodeType(pNode)) { return false; } @@ -2161,7 +2205,7 @@ static bool eliminateNotNullCondMayBeOptimized(SLogicNode* pNode) { } static int32_t eliminateNotNullCondOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { - SLogicNode* pNode = (SLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, eliminateNotNullCondMayBeOptimized); + SLogicNode* pNode = (SLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, eliminateNotNullCondMayBeOptimized, NULL); if (NULL == pNode) { return TSDB_CODE_SUCCESS; } @@ -2184,7 +2228,7 @@ static bool sortPriKeyOptIsPriKeyOrderBy(SNodeList* pSortKeys) { return (QUERY_NODE_COLUMN == nodeType(pNode) ? isPrimaryKeyImpl(pNode) : false); } -static bool sortPriKeyOptMayBeOptimized(SLogicNode* pNode) { +static bool sortPriKeyOptMayBeOptimized(SLogicNode* pNode, void* pCtx) { if (QUERY_NODE_LOGIC_PLAN_SORT != nodeType(pNode)) { return false; } @@ -2202,7 +2246,7 @@ static bool sortPriKeyOptMayBeOptimized(SLogicNode* pNode) { } FOREACH(pChild, pSort->node.pChildren) { - SLogicNode* pSortDescendent = optFindPossibleNode((SLogicNode*)pChild, sortPriKeyOptMayBeOptimized); + SLogicNode* pSortDescendent = optFindPossibleNode((SLogicNode*)pChild, sortPriKeyOptMayBeOptimized, NULL); if (pSortDescendent != NULL) { return false; } @@ -2493,7 +2537,7 @@ static int32_t sortPrimaryKeyOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* } static int32_t sortPrimaryKeyOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { - SSortLogicNode* pSort = (SSortLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, sortPriKeyOptMayBeOptimized); + SSortLogicNode* pSort = (SSortLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, sortPriKeyOptMayBeOptimized, NULL); if (NULL == pSort) { return TSDB_CODE_SUCCESS; } @@ -2537,7 +2581,10 @@ static int32_t sortForJoinOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* pL SNode* pOrderByNode = NULL; - 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))) { pOrderByNode = pOp->pLeft; } else if (NULL != tSimpleHashGet(pTables, ((SColumnNode*)pOp->pRight)->tableAlias, strlen(((SColumnNode*)pOp->pRight)->tableAlias))) { @@ -2551,7 +2598,7 @@ static int32_t sortForJoinOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* pL } SSortLogicNode* pSort = NULL; - int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT, (SNode**)&pSort); + code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT, (SNode**)&pSort); if (NULL == pSort) { return code; } @@ -2602,7 +2649,7 @@ _return: } -static bool sortForJoinOptMayBeOptimized(SLogicNode* pNode) { +static bool sortForJoinOptMayBeOptimized(SLogicNode* pNode, void* pCtx) { if (QUERY_NODE_LOGIC_PLAN_JOIN != nodeType(pNode)) { return false; } @@ -2631,7 +2678,7 @@ static bool sortForJoinOptMayBeOptimized(SLogicNode* pNode) { static int32_t sortForJoinOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { - SJoinLogicNode* pJoin = (SJoinLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, sortForJoinOptMayBeOptimized); + SJoinLogicNode* pJoin = (SJoinLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, sortForJoinOptMayBeOptimized, NULL); if (NULL == pJoin) { return TSDB_CODE_SUCCESS; } @@ -2675,7 +2722,7 @@ static int32_t joinCondGetAllScanNodes(SLogicNode* pNode, SNodeList** pList) { } -static bool joinCondMayBeOptimized(SLogicNode* pNode) { +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)) { return false; } @@ -2734,7 +2781,7 @@ static void joinCondMergeScanRand(STimeWindow* pDst, STimeWindow* pSrc) { } static int32_t joinCondOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { - SJoinLogicNode* pJoin = (SJoinLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, joinCondMayBeOptimized); + SJoinLogicNode* pJoin = (SJoinLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, joinCondMayBeOptimized, NULL); if (NULL == pJoin) { return TSDB_CODE_SUCCESS; } @@ -2797,7 +2844,7 @@ static int32_t joinCondOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub return TSDB_CODE_SUCCESS; } -static bool smaIndexOptMayBeOptimized(SLogicNode* pNode) { +static bool smaIndexOptMayBeOptimized(SLogicNode* pNode, void* pCtx) { if (QUERY_NODE_LOGIC_PLAN_SCAN != nodeType(pNode) || NULL == pNode->pParent || QUERY_NODE_LOGIC_PLAN_WINDOW != nodeType(pNode->pParent) || WINDOW_TYPE_INTERVAL != ((SWindowLogicNode*)pNode->pParent)->winType) { @@ -3014,7 +3061,7 @@ static int32_t smaIndexOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* pLogi } static int32_t smaIndexOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { - SScanLogicNode* pScan = (SScanLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, smaIndexOptMayBeOptimized); + SScanLogicNode* pScan = (SScanLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, smaIndexOptMayBeOptimized, NULL); if (NULL == pScan) { return TSDB_CODE_SUCCESS; } @@ -3098,7 +3145,7 @@ static bool partTagsOptAreSupportedFuncs(SNodeList* pFuncs) { return true; } -static bool partTagsOptMayBeOptimized(SLogicNode* pNode) { +static bool partTagsOptMayBeOptimized(SLogicNode* pNode, void* pCtx) { if (!partTagsIsOptimizableNode(pNode)) { return false; } @@ -3117,7 +3164,7 @@ static void partTagsSetAlias(char* pAlias, const char* pTableAlias, const char* char name[TSDB_COL_FNAME_LEN + 1] = {0}; int32_t len = snprintf(name, TSDB_COL_FNAME_LEN, "%s.%s", pTableAlias, pColName); - taosCreateMD5Hash(name, len); + (void)taosCreateMD5Hash(name, len); strncpy(pAlias, name, TSDB_COL_NAME_LEN - 1); } @@ -3207,7 +3254,7 @@ static int32_t partTagsRewriteGroupTagsToFuncs(SNodeList* pGroupTags, int32_t st } static int32_t partTagsOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { - SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, partTagsOptMayBeOptimized); + SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, partTagsOptMayBeOptimized, NULL); if (NULL == pNode) { return TSDB_CODE_SUCCESS; } @@ -3274,7 +3321,8 @@ static int32_t partTagsOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub return code; } -static bool eliminateProjOptCheckProjColumnNames(SProjectLogicNode* pProjectNode) { +static int32_t eliminateProjOptCheckProjColumnNames(SProjectLogicNode* pProjectNode, bool* pRet) { + int32_t code = 0; SHashObj* pProjColNameHash = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK); SNode* pProjection; FOREACH(pProjection, pProjectNode->pProjections) { @@ -3285,14 +3333,18 @@ static bool eliminateProjOptCheckProjColumnNames(SProjectLogicNode* pProjectNode return false; } else { int32_t exist = 1; - taosHashPut(pProjColNameHash, projColumnName, strlen(projColumnName), &exist, sizeof(exist)); + code = taosHashPut(pProjColNameHash, projColumnName, strlen(projColumnName), &exist, sizeof(exist)); + if (TSDB_CODE_SUCCESS != code) { + break; + } } } taosHashCleanup(pProjColNameHash); - return true; + *pRet = true; + return code; } -static bool eliminateProjOptMayBeOptimized(SLogicNode* pNode) { +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)) && @@ -3337,8 +3389,13 @@ static bool eliminateProjOptMayBeOptimized(SLogicNode* pNode) { return false; } } - - return eliminateProjOptCheckProjColumnNames(pProjectNode); + int32_t* pCode = pCtx; + bool ret = false; + int32_t code = eliminateProjOptCheckProjColumnNames(pProjectNode, &ret); + if (TSDB_CODE_SUCCESS != code) { + *pCode = code; + } + return ret; } typedef struct CheckNewChildTargetsCxt { @@ -3398,7 +3455,7 @@ static void alignProjectionWithTarget(SLogicNode* pNode) { } } if (!keep) { - nodesListErase(pProjectNode->pProjections, cell); + (void)nodesListErase(pProjectNode->pProjections, cell); } } } @@ -3506,8 +3563,9 @@ static int32_t eliminateProjOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* } static int32_t eliminateProjOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { + int32_t code = 0; SProjectLogicNode* pProjectNode = - (SProjectLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, eliminateProjOptMayBeOptimized); + (SProjectLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, eliminateProjOptMayBeOptimized, &code); if (NULL == pProjectNode) { return TSDB_CODE_SUCCESS; @@ -3516,7 +3574,7 @@ static int32_t eliminateProjOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLog return eliminateProjOptimizeImpl(pCxt, pLogicSubplan, pProjectNode); } -static bool rewriteTailOptMayBeOptimized(SLogicNode* pNode) { +static bool rewriteTailOptMayBeOptimized(SLogicNode* pNode, void* pCtx) { return QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC == nodeType(pNode) && ((SIndefRowsFuncLogicNode*)pNode)->isTailFunc; } @@ -3681,7 +3739,7 @@ static int32_t rewriteTailOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* pL static int32_t rewriteTailOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { SIndefRowsFuncLogicNode* pIndef = - (SIndefRowsFuncLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, rewriteTailOptMayBeOptimized); + (SIndefRowsFuncLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, rewriteTailOptMayBeOptimized, NULL); if (NULL == pIndef) { return TSDB_CODE_SUCCESS; @@ -3690,7 +3748,7 @@ static int32_t rewriteTailOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic return rewriteTailOptimizeImpl(pCxt, pLogicSubplan, pIndef); } -static bool eliminateSetOpMayBeOptimized(SLogicNode* pNode) { +static bool eliminateSetOpMayBeOptimized(SLogicNode* pNode, void* pCtx) { SLogicNode* pParent = pNode->pParent; if (NULL == pParent || QUERY_NODE_LOGIC_PLAN_AGG != nodeType(pParent) && QUERY_NODE_LOGIC_PLAN_PROJECT != nodeType(pParent) || @@ -3723,7 +3781,7 @@ static int32_t eliminateSetOpOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* } static int32_t eliminateSetOpOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { - SLogicNode* pSetOpNode = optFindPossibleNode(pLogicSubplan->pNode, eliminateSetOpMayBeOptimized); + SLogicNode* pSetOpNode = optFindPossibleNode(pLogicSubplan->pNode, eliminateSetOpMayBeOptimized, NULL); if (NULL == pSetOpNode) { return TSDB_CODE_SUCCESS; } @@ -3731,7 +3789,7 @@ static int32_t eliminateSetOpOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLo return eliminateSetOpOptimizeImpl(pCxt, pLogicSubplan, pSetOpNode); } -static bool rewriteUniqueOptMayBeOptimized(SLogicNode* pNode) { +static bool rewriteUniqueOptMayBeOptimized(SLogicNode* pNode, void* pCtx) { return QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC == nodeType(pNode) && ((SIndefRowsFuncLogicNode*)pNode)->isUniqueFunc; } @@ -3769,7 +3827,7 @@ static int32_t rewriteUniqueOptCreateFirstFunc(SFunctionNode* pSelectValue, SNod int64_t pointer = (int64_t)pFunc; char name[TSDB_FUNC_NAME_LEN + TSDB_POINTER_PRINT_BYTES + TSDB_NAME_DELIMITER_LEN + 1] = {0}; int32_t len = snprintf(name, sizeof(name) - 1, "%s.%" PRId64 "", pFunc->functionName, pointer); - taosCreateMD5Hash(name, len); + (void)taosCreateMD5Hash(name, len); strncpy(pFunc->node.aliasName, name, TSDB_COL_NAME_LEN - 1); } SNode* pNew = NULL; @@ -3946,7 +4004,7 @@ static int32_t rewriteUniqueOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* static int32_t rewriteUniqueOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { SIndefRowsFuncLogicNode* pIndef = - (SIndefRowsFuncLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, rewriteUniqueOptMayBeOptimized); + (SIndefRowsFuncLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, rewriteUniqueOptMayBeOptimized, NULL); if (NULL == pIndef) { return TSDB_CODE_SUCCESS; @@ -4105,7 +4163,7 @@ static bool lastRowScanOptCheckLastCache(SAggLogicNode* pAgg, SScanLogicNode* pS return true; } -static bool lastRowScanOptMayBeOptimized(SLogicNode* pNode) { +static bool lastRowScanOptMayBeOptimized(SLogicNode* pNode, void* pCtx) { if (QUERY_NODE_LOGIC_PLAN_AGG != nodeType(pNode) || 1 != LIST_LENGTH(pNode->pChildren) || QUERY_NODE_LOGIC_PLAN_SCAN != nodeType(nodesListGetNode(pNode->pChildren, 0))) { return false; @@ -4238,14 +4296,17 @@ static int32_t lastRowScanBuildFuncTypes(SScanLogicNode* pScan, SColumnNode* pCo } pFuncTypeParam->pCol->colId = pColNode->colId; strcpy(pFuncTypeParam->pCol->name, pColNode->colName); - taosArrayPush(pScan->pFuncTypes, pFuncTypeParam); + if (NULL == taosArrayPush(pScan->pFuncTypes, pFuncTypeParam)) { + taosMemoryFree(pFuncTypeParam); + return TSDB_CODE_OUT_OF_MEMORY; + } taosMemoryFree(pFuncTypeParam); return TSDB_CODE_SUCCESS; } static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { - SAggLogicNode* pAgg = (SAggLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, lastRowScanOptMayBeOptimized); + SAggLogicNode* pAgg = (SAggLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, lastRowScanOptMayBeOptimized, NULL); if (NULL == pAgg) { return TSDB_CODE_SUCCESS; @@ -4269,7 +4330,7 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic int32_t funcType = pFunc->funcType; SNode* pParamNode = NULL; if (FUNCTION_TYPE_LAST == funcType) { - nodesListErase(pFunc->pParameterList, nodesListGetCell(pFunc->pParameterList, 1)); + (void)nodesListErase(pFunc->pParameterList, nodesListGetCell(pFunc->pParameterList, 1)); nodesWalkExpr(nodesListGetNode(pFunc->pParameterList, 0), lastRowScanOptSetColDataType, &cxt); if (TSDB_CODE_SUCCESS != cxt.code) break; } @@ -4478,7 +4539,7 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic return TSDB_CODE_SUCCESS; } -static bool splitCacheLastFuncOptMayBeOptimized(SLogicNode* pNode) { +static bool splitCacheLastFuncOptMayBeOptimized(SLogicNode* pNode, void* pCtx) { if (QUERY_NODE_LOGIC_PLAN_AGG != nodeType(pNode) || 1 != LIST_LENGTH(pNode->pChildren) || QUERY_NODE_LOGIC_PLAN_SCAN != nodeType(nodesListGetNode(pNode->pChildren, 0))) { return false; @@ -4691,7 +4752,7 @@ static int32_t splitCacheLastFuncOptCreateMergeLogicNode(SMergeLogicNode** pNew, } static int32_t splitCacheLastFuncOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { - SAggLogicNode* pAgg = (SAggLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, splitCacheLastFuncOptMayBeOptimized); + SAggLogicNode* pAgg = (SAggLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, splitCacheLastFuncOptMayBeOptimized, NULL); if (NULL == pAgg) { return TSDB_CODE_SUCCESS; @@ -4804,7 +4865,7 @@ static int32_t splitCacheLastFuncOptimize(SOptimizeContext* pCxt, SLogicSubplan* } // merge projects -static bool mergeProjectsMayBeOptimized(SLogicNode* pNode) { +static bool mergeProjectsMayBeOptimized(SLogicNode* pNode, void* pCtx) { if (QUERY_NODE_LOGIC_PLAN_PROJECT != nodeType(pNode) || 1 != LIST_LENGTH(pNode->pChildren)) { return false; } @@ -4877,7 +4938,7 @@ static int32_t mergeProjectsOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* } static int32_t mergeProjectsOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { - SLogicNode* pProjectNode = optFindPossibleNode(pLogicSubplan->pNode, mergeProjectsMayBeOptimized); + SLogicNode* pProjectNode = optFindPossibleNode(pLogicSubplan->pNode, mergeProjectsMayBeOptimized, NULL); if (NULL == pProjectNode) { return TSDB_CODE_SUCCESS; } @@ -4885,7 +4946,7 @@ static int32_t mergeProjectsOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLog return mergeProjectsOptimizeImpl(pCxt, pLogicSubplan, pProjectNode); } -static bool tagScanOptShouldBeOptimized(SLogicNode* pNode) { +static bool tagScanOptShouldBeOptimized(SLogicNode* pNode, void* pCtx) { if (QUERY_NODE_LOGIC_PLAN_SCAN != nodeType(pNode) || (SCAN_TYPE_TAG == ((SScanLogicNode*)pNode)->scanType)) { return false; } @@ -4920,7 +4981,7 @@ static bool tagScanOptShouldBeOptimized(SLogicNode* pNode) { } static int32_t tagScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { - SScanLogicNode* pScanNode = (SScanLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, tagScanOptShouldBeOptimized); + SScanLogicNode* pScanNode = (SScanLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, tagScanOptShouldBeOptimized, NULL); if (NULL == pScanNode) { return TSDB_CODE_SUCCESS; } @@ -4971,7 +5032,7 @@ static int32_t tagScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubp return TSDB_CODE_SUCCESS; } -static bool pushDownLimitOptShouldBeOptimized(SLogicNode* pNode) { +static bool pushDownLimitOptShouldBeOptimized(SLogicNode* pNode, void* pCtx) { if ((NULL == pNode->pLimit && pNode->pSlimit == NULL) || 1 != LIST_LENGTH(pNode->pChildren)) { return false; } @@ -5096,7 +5157,7 @@ static int32_t pushDownLimitHow(SLogicNode* pNodeWithLimit, SLogicNode* pNodeLim } static int32_t pushDownLimitOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { - SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, pushDownLimitOptShouldBeOptimized); + SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, pushDownLimitOptShouldBeOptimized, NULL); if (NULL == pNode) { return TSDB_CODE_SUCCESS; } @@ -5418,7 +5479,7 @@ static int32_t sortNonPriKeyOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLog return code; } SOptimizePKCtx ctx = {.pList = pNodeList, .code = 0}; - optFindEligibleNode(pLogicSubplan->pNode, sortNonPriKeyShouldOptimize, &ctx); + (void)optFindEligibleNode(pLogicSubplan->pNode, sortNonPriKeyShouldOptimize, &ctx); if (TSDB_CODE_SUCCESS != ctx.code) { nodesClearList(pNodeList); return code; @@ -5435,7 +5496,7 @@ static int32_t sortNonPriKeyOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLog return TSDB_CODE_SUCCESS; } -static bool hashJoinOptShouldBeOptimized(SLogicNode* pNode) { +static bool hashJoinOptShouldBeOptimized(SLogicNode* pNode, void* pCtx) { bool res = false; if (QUERY_NODE_LOGIC_PLAN_JOIN != nodeType(pNode)) { return res; @@ -5460,7 +5521,11 @@ _return: if (!res && DATA_ORDER_LEVEL_NONE == pJoin->node.requireDataOrder) { pJoin->node.requireDataOrder = DATA_ORDER_LEVEL_GLOBAL; - (void)adjustLogicNodeDataRequirement(pNode, pJoin->node.requireDataOrder); + int32_t *pCode = pCtx; + int32_t code = adjustLogicNodeDataRequirement(pNode, pJoin->node.requireDataOrder); + if (TSDB_CODE_SUCCESS != code) { + *pCode = code; + } } return res; @@ -5737,7 +5802,11 @@ static int32_t hashJoinOptRewriteJoin(SOptimizeContext* pCxt, SLogicNode* pNode, static int32_t hashJoinOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { - SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, hashJoinOptShouldBeOptimized); + int32_t code = 0; + SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, hashJoinOptShouldBeOptimized, &code); + if (TSDB_CODE_SUCCESS != code) { + return code; + } if (NULL == pNode) { return TSDB_CODE_SUCCESS; } @@ -5745,7 +5814,7 @@ static int32_t hashJoinOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub return hashJoinOptRewriteJoin(pCxt, pNode, pLogicSubplan); } -static bool stbJoinOptShouldBeOptimized(SLogicNode* pNode) { +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)) { return false; } @@ -5829,7 +5898,9 @@ int32_t stbJoinOptRewriteToTagScan(SLogicNode* pJoin, SNode* pNode) { code = stbJoinOptAddFuncToScanNode("_vgid", pScan); } - tagScanSetExecutionMode(pScan); + if (TSDB_CODE_SUCCESS == code) { + code = tagScanSetExecutionMode(pScan); + } if (code) { nodesDestroyList(pTags); @@ -5912,15 +5983,16 @@ static int32_t stbJoinOptCreateTagHashJoinNode(SLogicNode* pOrig, SNodeList* pCh } SNodeList* pCols = NULL; - nodesCollectColumnsFromNode(pJoin->pFullOnCond, NULL, COLLECT_COL_TYPE_ALL, &pCols); + code = nodesCollectColumnsFromNode(pJoin->pFullOnCond, NULL, COLLECT_COL_TYPE_ALL, &pCols); - FOREACH(pNode, pCols) { - code = createColumnByRewriteExpr(pNode, &pJoin->node.pTargets); - if (code) { - break; + if (TSDB_CODE_SUCCESS == code) { + FOREACH(pNode, pCols) { + code = createColumnByRewriteExpr(pNode, &pJoin->node.pTargets); + if (code) { + break; + } } } - nodesDestroyList(pCols); if (TSDB_CODE_SUCCESS == code) { @@ -6121,10 +6193,16 @@ static int32_t stbJoinOptCreateDynQueryCtrlNode(SLogicNode* pRoot, SLogicNode* p } SJoinLogicNode* pHJoin = (SJoinLogicNode*)pPrev; - nodesListStrictAppend(pDynCtrl->stbJoin.pUidList, nodesListGetNode(pHJoin->node.pTargets, 0)); - nodesListStrictAppend(pDynCtrl->stbJoin.pUidList, nodesListGetNode(pHJoin->node.pTargets, 2)); - nodesListStrictAppend(pDynCtrl->stbJoin.pVgList, nodesListGetNode(pHJoin->node.pTargets, 1)); - nodesListStrictAppend(pDynCtrl->stbJoin.pVgList, nodesListGetNode(pHJoin->node.pTargets, 3)); + code = nodesListStrictAppend(pDynCtrl->stbJoin.pUidList, nodesListGetNode(pHJoin->node.pTargets, 0)); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pDynCtrl->stbJoin.pUidList, nodesListGetNode(pHJoin->node.pTargets, 2)); + } + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pDynCtrl->stbJoin.pVgList, nodesListGetNode(pHJoin->node.pTargets, 1)); + } + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pDynCtrl->stbJoin.pVgList, nodesListGetNode(pHJoin->node.pTargets, 3)); + } if (TSDB_CODE_SUCCESS == code) { code = nodesListStrictAppend(pDynCtrl->node.pChildren, (SNode*)pPrev); @@ -6189,7 +6267,7 @@ static int32_t stbJoinOptRewriteStableJoin(SOptimizeContext* pCxt, SLogicNode* p } static int32_t stableJoinOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { - SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, stbJoinOptShouldBeOptimized); + SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, stbJoinOptShouldBeOptimized, NULL); if (NULL == pNode) { return TSDB_CODE_SUCCESS; } @@ -6197,7 +6275,7 @@ static int32_t stableJoinOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicS return stbJoinOptRewriteStableJoin(pCxt, pNode, pLogicSubplan); } -static bool grpJoinOptShouldBeOptimized(SLogicNode* pNode) { +static bool grpJoinOptShouldBeOptimized(SLogicNode* pNode, void* pCtx) { if (QUERY_NODE_LOGIC_PLAN_JOIN != nodeType(pNode)) { return false; } @@ -6283,10 +6361,10 @@ static int32_t grpJoinOptPartByTags(SLogicNode* pNode) { code = nodesCloneList(pJoin->pLeftEqNodes, &pNewList); if (TSDB_CODE_SUCCESS == code) { if (leftChild) { - nodesListMakeStrictAppendList(&pScan->pGroupTags, pNewList); + code = nodesListMakeStrictAppendList(&pScan->pGroupTags, pNewList); leftChild = false; } else { - nodesListMakeStrictAppendList(&pScan->pGroupTags, pNewList); + code = nodesListMakeStrictAppendList(&pScan->pGroupTags, pNewList); } } if (TSDB_CODE_SUCCESS != code) { @@ -6312,7 +6390,7 @@ static int32_t grpJoinOptRewriteGroupJoin(SOptimizeContext* pCxt, SLogicNode* pN static int32_t groupJoinOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { - SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, grpJoinOptShouldBeOptimized); + SLogicNode* pNode = optFindPossibleNode(pLogicSubplan->pNode, grpJoinOptShouldBeOptimized, NULL); if (NULL == pNode) { return TSDB_CODE_SUCCESS; } @@ -6320,7 +6398,7 @@ static int32_t groupJoinOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSu return grpJoinOptRewriteGroupJoin(pCxt, pNode, pLogicSubplan); } -static bool partColOptShouldBeOptimized(SLogicNode* pNode) { +static bool partColOptShouldBeOptimized(SLogicNode* pNode, void* pCtx) { if (QUERY_NODE_LOGIC_PLAN_PARTITION == nodeType(pNode)) { SPartitionLogicNode* pPartition = (SPartitionLogicNode*)pNode; if (keysHasCol(pPartition->pPartitionKeys)) return true; @@ -6397,7 +6475,7 @@ static int32_t partitionColsOpt(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub SNode* node; int32_t code = TSDB_CODE_SUCCESS; SPartitionLogicNode* pNode = - (SPartitionLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, partColOptShouldBeOptimized); + (SPartitionLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, partColOptShouldBeOptimized, NULL); if (NULL == pNode) return TSDB_CODE_SUCCESS; SLogicNode* pRootNode = getLogicNodeRootNode((SLogicNode*)pNode); @@ -6469,7 +6547,7 @@ static int32_t partitionColsOpt(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub return code; } -static bool tsmaOptMayBeOptimized(SLogicNode* pNode) { +static bool tsmaOptMayBeOptimized(SLogicNode* pNode, void* pCtx) { if (QUERY_NODE_LOGIC_PLAN_SCAN == nodeType(pNode)) { SNode* pTmpNode; SNodeList* pFuncs = NULL; @@ -6603,7 +6681,8 @@ static bool tsmaOptCheckValidInterval(int64_t tsmaInterval, int8_t unit, const S return validInterval && validSliding && validOffset; } -static bool tsmaOptCheckValidFuncs(const SArray* pTsmaFuncs, const SNodeList* pQueryFuncs, SArray* pTsmaScanCols) { +static int32_t tsmaOptCheckValidFuncs(const SArray* pTsmaFuncs, const SNodeList* pQueryFuncs, SArray* pTsmaScanCols, + bool* pIsValid) { SNode* pNode; bool failed = false, found = false; @@ -6632,14 +6711,17 @@ static bool tsmaOptCheckValidFuncs(const SArray* pTsmaFuncs, const SNodeList* pQ continue; } found = true; - taosArrayPush(pTsmaScanCols, &i); + if (NULL == taosArrayPush(pTsmaScanCols, &i)) { + return TSDB_CODE_OUT_OF_MEMORY; + } break; } if (failed || !found) { break; } } - return found; + *pIsValid = found; + return TSDB_CODE_SUCCESS; } typedef struct STsmaOptTagCheckCtx { @@ -6683,6 +6765,7 @@ 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; for (int32_t i = 0; i < pTsmaOptCtx->pTsmas->size; ++i) { if (!pTsmaScanCols) { @@ -6703,18 +6786,24 @@ static int32_t tsmaOptFilterTsmas(STSMAOptCtx* pTsmaOptCtx) { continue; } // filter with funcs, note that tsma funcs has been sorted by funcId and ColId - if (!tsmaOptCheckValidFuncs(pTsma->pFuncs, pTsmaOptCtx->pAggFuncs, pTsmaScanCols)) { - continue; - } + bool valid = false; + int32_t code = tsmaOptCheckValidFuncs(pTsma->pFuncs, pTsmaOptCtx->pAggFuncs, pTsmaScanCols, &valid); + if (TSDB_CODE_SUCCESS != code) break; + if (!valid) continue; if (!tsmaOptCheckTags(pTsmaOptCtx, pTsma)) continue; usefulTsma.pTsma = pTsma; usefulTsma.pTsmaScanCols = pTsmaScanCols; pTsmaScanCols = NULL; - taosArrayPush(pTsmaOptCtx->pUsefulTsmas, &usefulTsma); + if (NULL == taosArrayPush(pTsmaOptCtx->pUsefulTsmas, &usefulTsma)) { + if (pTsmaScanCols) { + taosArrayDestroy(pTsmaScanCols); + } + return TSDB_CODE_OUT_OF_MEMORY; + } } if (pTsmaScanCols) taosArrayDestroy(pTsmaScanCols); - return TSDB_CODE_SUCCESS; + return code; } static int32_t tsmaInfoCompWithIntervalDesc(const void* pLeft, const void* pRight) { @@ -6763,9 +6852,10 @@ static const STSMAOptUsefulTsma* tsmaOptFindUsefulTsma(const SArray* pUsefulTsma return NULL; } -static void tsmaOptSplitWindows(STSMAOptCtx* pTsmaOptCtx, const STimeWindow* pScanRange) { +static int32_t tsmaOptSplitWindows(STSMAOptCtx* pTsmaOptCtx, const STimeWindow* pScanRange) { bool needTailWindow = false; bool isSkeyAlignedWithTsma = true, isEkeyAlignedWithTsma = true; + int32_t code = 0; int64_t winSkey = TSKEY_MIN, winEkey = TSKEY_MAX; int64_t startOfSkeyFirstWin = pScanRange->skey, endOfSkeyFirstWin; int64_t startOfEkeyFirstWin = pScanRange->ekey, endOfEkeyFirstWin; @@ -6775,7 +6865,7 @@ static void tsmaOptSplitWindows(STSMAOptCtx* pTsmaOptCtx, const STimeWindow* pSc const STSMAOptUsefulTsma* pUsefulTsma = taosArrayGet(pTsmaOptCtx->pUsefulTsmas, 0); const STableTSMAInfo* pTsma = pUsefulTsma->pTsma; - if (pScanRange->ekey <= pScanRange->skey) return; + if (pScanRange->ekey <= pScanRange->skey) return code; if (!pInterval) { tsmaOptInitIntervalFromTsma(&interval, pTsma, pTsmaOptCtx->precision); @@ -6815,7 +6905,8 @@ static void tsmaOptSplitWindows(STSMAOptCtx* pTsmaOptCtx, const STimeWindow* pSc STSMAOptUsefulTsma usefulTsma = {.pTsma = pTsmaFound ? pTsmaFound->pTsma : NULL, .scanRange = scanRange, .pTsmaScanCols = pTsmaFound ? pTsmaFound->pTsmaScanCols : NULL}; - taosArrayPush(pTsmaOptCtx->pUsedTsmas, &usefulTsma); + if (NULL == taosArrayPush(pTsmaOptCtx->pUsedTsmas, &usefulTsma)) + return TSDB_CODE_OUT_OF_MEMORY; } // the main tsma @@ -6827,7 +6918,8 @@ static void tsmaOptSplitWindows(STSMAOptCtx* pTsmaOptCtx, const STimeWindow* pSc } STSMAOptUsefulTsma usefulTsma = { .pTsma = pTsma, .scanRange = scanRange, .pTsmaScanCols = pUsefulTsma->pTsmaScanCols}; - taosArrayPush(pTsmaOptCtx->pUsedTsmas, &usefulTsma); + if (NULL == taosArrayPush(pTsmaOptCtx->pUsedTsmas, &usefulTsma)) + return TSDB_CODE_OUT_OF_MEMORY; } // add tail tsma if possible @@ -6840,8 +6932,10 @@ static void tsmaOptSplitWindows(STSMAOptCtx* pTsmaOptCtx, const STimeWindow* pSc STSMAOptUsefulTsma usefulTsma = {.pTsma = pTsmaFound ? pTsmaFound->pTsma : NULL, .scanRange = scanRange, .pTsmaScanCols = pTsmaFound ? pTsmaFound->pTsmaScanCols : NULL}; - taosArrayPush(pTsmaOptCtx->pUsedTsmas, &usefulTsma); + if (NULL == taosArrayPush(pTsmaOptCtx->pUsedTsmas, &usefulTsma)) + return TSDB_CODE_OUT_OF_MEMORY; } + return code; } int32_t tsmaOptCreateTsmaScanCols(const STSMAOptUsefulTsma* pTsma, const SNodeList* pAggFuncs, SNodeList** ppList) { @@ -7039,11 +7133,9 @@ static int32_t tsmaOptRewriteScan(STSMAOptCtx* pTsmaOptCtx, SScanLogicNode* pNew tstrncpy(pPkTsCol->tableName, pTsma->targetTbName, TSDB_TABLE_NAME_LEN); tstrncpy(pPkTsCol->tableAlias, pTsma->targetTbName, TSDB_TABLE_NAME_LEN); pPkTsCol->tableId = pTsma->targetTbUid; - SNode* pNew = NULL; - code = nodesCloneNode((SNode*)pPkTsCol, &pNew); - if (TSDB_CODE_SUCCESS == code) { - code = nodesListMakeStrictAppend(&pNewScan->pScanCols, pNew); - } + code = nodesListMakeStrictAppend(&pNewScan->pScanCols, (SNode*)pPkTsCol); + } else if (pPkTsCol){ + nodesDestroyNode((SNode*)pPkTsCol); } if (code == TSDB_CODE_SUCCESS) { pNewScan->stableId = pTsma->pTsma->destTbUid; @@ -7059,17 +7151,23 @@ static int32_t tsmaOptRewriteScan(STSMAOptCtx* pTsmaOptCtx, SScanLogicNode* pNew if (code == TSDB_CODE_SUCCESS) { code = tsmaOptRewriteNodeList(pNewScan->pGroupTags, pTsmaOptCtx, pTsma, true, true); } - pTsmaOptCtx->pScan->dataRequired = FUNC_DATA_REQUIRED_DATA_LOAD; - if (pTsmaOptCtx->pScan->pTsmaTargetTbVgInfo && pTsmaOptCtx->pScan->pTsmaTargetTbVgInfo->size > 0) { - for (int32_t i = 0; i < taosArrayGetSize(pTsmaOptCtx->pScan->pTsmas); ++i) { - STableTSMAInfo* pTsmaInfo = taosArrayGetP(pTsmaOptCtx->pScan->pTsmas, i); - if (pTsmaInfo == pTsma->pTsma) { - const SVgroupsInfo* pVgpsInfo = taosArrayGetP(pTsmaOptCtx->pScan->pTsmaTargetTbVgInfo, i); - taosMemoryFreeClear(pNewScan->pVgroupList); - int32_t len = sizeof(int32_t) + sizeof(SVgroupInfo) * pVgpsInfo->numOfVgroups; - pNewScan->pVgroupList = taosMemoryCalloc(1, len); - memcpy(pNewScan->pVgroupList, pVgpsInfo, len); - break; + if (TSDB_CODE_SUCCESS == code) { + pTsmaOptCtx->pScan->dataRequired = FUNC_DATA_REQUIRED_DATA_LOAD; + if (pTsmaOptCtx->pScan->pTsmaTargetTbVgInfo && pTsmaOptCtx->pScan->pTsmaTargetTbVgInfo->size > 0) { + for (int32_t i = 0; i < taosArrayGetSize(pTsmaOptCtx->pScan->pTsmas); ++i) { + STableTSMAInfo* pTsmaInfo = taosArrayGetP(pTsmaOptCtx->pScan->pTsmas, i); + if (pTsmaInfo == pTsma->pTsma) { + const SVgroupsInfo* pVgpsInfo = taosArrayGetP(pTsmaOptCtx->pScan->pTsmaTargetTbVgInfo, i); + taosMemoryFreeClear(pNewScan->pVgroupList); + int32_t len = sizeof(int32_t) + sizeof(SVgroupInfo) * pVgpsInfo->numOfVgroups; + pNewScan->pVgroupList = taosMemoryCalloc(1, len); + if (!pNewScan->pVgroupList) { + code = TSDB_CODE_OUT_OF_MEMORY; + break; + } + memcpy(pNewScan->pVgroupList, pVgpsInfo, len); + break; + } } } } @@ -7099,7 +7197,7 @@ static int32_t tsmaOptCreateWStart(int8_t precision, SFunctionNode** pWStartOut) int64_t pointer = (int64_t)pWStart; char name[TSDB_COL_NAME_LEN + TSDB_POINTER_PRINT_BYTES + TSDB_NAME_DELIMITER_LEN + 1] = {0}; int32_t len = snprintf(name, sizeof(name) - 1, "%s.%" PRId64 "", pWStart->functionName, pointer); - taosCreateMD5Hash(name, len); + (void)taosCreateMD5Hash(name, len); strncpy(pWStart->node.aliasName, name, TSDB_COL_NAME_LEN - 1); pWStart->node.resType.precision = precision; @@ -7157,7 +7255,7 @@ static int32_t tsmaOptRewriteParent(STSMAOptCtx* pTsmaOptCtx, SLogicNode* pParen pScanListCell = pScanListCell->pNext; pColNode->node.resType = pPartial->node.resType; // currently we assume that the first parameter must be the scan column - nodesListErase(pMerge->pParameterList, pMerge->pParameterList->pHead); + (void)nodesListErase(pMerge->pParameterList, pMerge->pParameterList->pHead); SNode* pNew = NULL; code = nodesCloneNode((SNode*)pColNode, &pNew); if (TSDB_CODE_SUCCESS == code) { @@ -7266,7 +7364,7 @@ static bool tsmaOptIsUsingTsmas(STSMAOptCtx* pCtx) { static int32_t tsmaOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { int32_t code = 0; STSMAOptCtx tsmaOptCtx = {0}; - SScanLogicNode* pScan = (SScanLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, tsmaOptMayBeOptimized); + SScanLogicNode* pScan = (SScanLogicNode*)optFindPossibleNode(pLogicSubplan->pNode, tsmaOptMayBeOptimized, NULL); if (!pScan) return code; SLogicNode* pRootNode = getLogicNodeRootNode((SLogicNode*)pScan); @@ -7281,17 +7379,17 @@ static int32_t tsmaOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan // 2. sort useful tsmas with interval taosArraySort(tsmaOptCtx.pUsefulTsmas, tsmaInfoCompWithIntervalDesc); // 3. split windows - tsmaOptSplitWindows(&tsmaOptCtx, tsmaOptCtx.pTimeRange); - if (tsmaOptIsUsingTsmas(&tsmaOptCtx)) { + code = tsmaOptSplitWindows(&tsmaOptCtx, tsmaOptCtx.pTimeRange); + if (TSDB_CODE_SUCCESS == code && tsmaOptIsUsingTsmas(&tsmaOptCtx)) { // 4. create logic plan code = tsmaOptGeneratePlan(&tsmaOptCtx); if (TSDB_CODE_SUCCESS == code) { - for (int32_t i = 0; i < 2; i++) { + for (int32_t i = 0; i < 2 && (TSDB_CODE_SUCCESS == code); i++) { SLogicSubplan* pSubplan = tsmaOptCtx.generatedSubPlans[i]; if (!pSubplan) continue; pSubplan->subplanType = SUBPLAN_TYPE_SCAN; - nodesListMakeAppend(tsmaOptCtx.ppParentTsmaSubplans, (SNode*)pSubplan); + code = nodesListMakeAppend(tsmaOptCtx.ppParentTsmaSubplans, (SNode*)pSubplan); } pCxt->optimized = true; } @@ -7334,24 +7432,31 @@ static const SOptimizeRule optimizeRuleSet[] = { static const int32_t optimizeRuleNum = (sizeof(optimizeRuleSet) / sizeof(SOptimizeRule)); -static void dumpLogicSubplan(const char* pRuleName, SLogicSubplan* pSubplan) { +static int32_t dumpLogicSubplan(const char* pRuleName, SLogicSubplan* pSubplan) { + int32_t code = 0; if (!tsQueryPlannerTrace) { - return; + return code; } char* pStr = NULL; - nodesNodeToString((SNode*)pSubplan, false, &pStr, NULL); - if (NULL == pRuleName) { - qDebugL("before optimize, JsonPlan: %s", pStr); - } else { - qDebugL("apply optimize %s rule, JsonPlan: %s", pRuleName, pStr); + code = nodesNodeToString((SNode*)pSubplan, false, &pStr, NULL); + if (TSDB_CODE_SUCCESS == code) { + if (NULL == pRuleName) { + qDebugL("before optimize, JsonPlan: %s", pStr); + } else { + qDebugL("apply optimize %s rule, JsonPlan: %s", pRuleName, pStr); + } + taosMemoryFree(pStr); } - taosMemoryFree(pStr); + return code; } static int32_t applyOptimizeRule(SPlanContext* pCxt, SLogicSubplan* pLogicSubplan) { SOptimizeContext cxt = {.pPlanCxt = pCxt, .optimized = false}; bool optimized = false; - dumpLogicSubplan(NULL, pLogicSubplan); + int32_t code = dumpLogicSubplan(NULL, pLogicSubplan); + if (TSDB_CODE_SUCCESS != code) { + return code; + } do { optimized = false; for (int32_t i = 0; i < optimizeRuleNum; ++i) { @@ -7362,12 +7467,12 @@ static int32_t applyOptimizeRule(SPlanContext* pCxt, SLogicSubplan* pLogicSubpla } if (cxt.optimized) { optimized = true; - dumpLogicSubplan(optimizeRuleSet[i].pName, pLogicSubplan); + code = dumpLogicSubplan(optimizeRuleSet[i].pName, pLogicSubplan); break; } } - } while (optimized); - return TSDB_CODE_SUCCESS; + } while (optimized && (TSDB_CODE_SUCCESS == code)); + return code; } int32_t optimizeLogicPlan(SPlanContext* pCxt, SLogicSubplan* pLogicSubplan) { diff --git a/source/libs/planner/src/planPhysiCreater.c b/source/libs/planner/src/planPhysiCreater.c index c4c9f358fa..d75e02bc6b 100644 --- a/source/libs/planner/src/planPhysiCreater.c +++ b/source/libs/planner/src/planPhysiCreater.c @@ -115,7 +115,9 @@ static int32_t putSlotToHashImpl(int16_t dataBlockId, int16_t slotId, const char SSlotIndex* pIndex = taosHashGet(pHash, pName, len); if (NULL != pIndex) { SSlotIdInfo info = {.slotId = slotId, .set = false}; - taosArrayPush(pIndex->pSlotIdsInfo, &info); + if (NULL == taosArrayPush(pIndex->pSlotIdsInfo, &info)) { + return TSDB_CODE_OUT_OF_MEMORY; + } return TSDB_CODE_SUCCESS; } @@ -124,7 +126,9 @@ static int32_t putSlotToHashImpl(int16_t dataBlockId, int16_t slotId, const char return TSDB_CODE_OUT_OF_MEMORY; } SSlotIdInfo info = {.slotId = slotId, .set = false}; - taosArrayPush(index.pSlotIdsInfo, &info); + if (NULL == taosArrayPush(index.pSlotIdsInfo, &info)) { + return TSDB_CODE_OUT_OF_MEMORY; + } return taosHashPut(pHash, pName, len, &index, sizeof(SSlotIndex)); } @@ -159,7 +163,7 @@ static int32_t buildDataBlockSlots(SPhysiPlanContext* pCxt, SNodeList* pList, SD SNode* pNode = NULL; FOREACH(pNode, pList) { char name[TSDB_COL_FNAME_LEN + 1] = {0}; - getSlotKey(pNode, NULL, name, TSDB_COL_FNAME_LEN); + (void)getSlotKey(pNode, NULL, name, TSDB_COL_FNAME_LEN); code = nodesListStrictAppend(pDataBlockDesc->pSlots, createSlotDesc(pCxt, name, pNode, slotId, true, false)); if (TSDB_CODE_SUCCESS == code) { code = putSlotToHash(name, pDataBlockDesc->dataBlockId, slotId, pNode, pHash); @@ -736,7 +740,7 @@ static int32_t createSystemTableScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* } else { pScan->mgmtEpSet = pCxt->pPlanCxt->mgmtEpSet; } - tNameGetFullDbName(&pScanLogicNode->tableName, pSubplan->dbFName); + (void)tNameGetFullDbName(&pScanLogicNode->tableName, pSubplan->dbFName); pCxt->hasSysScan = true; return createScanPhysiNodeFinalize(pCxt, pSubplan, pScanLogicNode, (SScanPhysiNode*)pScan, pPhyNode); @@ -2921,14 +2925,17 @@ static void setExplainInfo(SPlanContext* pCxt, SQueryPlan* pPlan) { } } -static void setExecNodeList(SPhysiPlanContext* pCxt, SArray* pExecNodeList) { +static int32_t setExecNodeList(SPhysiPlanContext* pCxt, SArray* pExecNodeList) { + int32_t code = 0; if (NULL == pExecNodeList) { - return; + return code; } if (pCxt->hasSysScan || !pCxt->hasScan) { SQueryNodeLoad node = {.addr = {.nodeId = MNODE_HANDLE, .epSet = pCxt->pPlanCxt->mgmtEpSet}, .load = 0}; - taosArrayPush(pExecNodeList, &node); + if (NULL == taosArrayPush(pExecNodeList, &node)) + code = TSDB_CODE_OUT_OF_MEMORY; } + return code; } int32_t createPhysiPlan(SPlanContext* pCxt, SQueryLogicPlan* pLogicPlan, SQueryPlan** pPlan, SArray* pExecNodeList) { @@ -2945,7 +2952,7 @@ int32_t createPhysiPlan(SPlanContext* pCxt, SQueryLogicPlan* pLogicPlan, SQueryP int32_t code = doCreatePhysiPlan(&cxt, pLogicPlan, pPlan); if (TSDB_CODE_SUCCESS == code) { setExplainInfo(pCxt, *pPlan); - setExecNodeList(&cxt, pExecNodeList); + code = setExecNodeList(&cxt, pExecNodeList); } destoryPhysiPlanContext(&cxt); diff --git a/source/libs/planner/src/planSpliter.c b/source/libs/planner/src/planSpliter.c index e2eeeabfa6..efbcd79b69 100644 --- a/source/libs/planner/src/planSpliter.c +++ b/source/libs/planner/src/planSpliter.c @@ -432,7 +432,7 @@ static int32_t stbSplAppendWStart(SNodeList* pFuncs, int32_t* pIndex, uint8_t pr int64_t pointer = (int64_t)pWStart; char name[TSDB_COL_NAME_LEN + TSDB_POINTER_PRINT_BYTES + TSDB_NAME_DELIMITER_LEN + 1] = {0}; int32_t len = snprintf(name, sizeof(name) - 1, "%s.%" PRId64 "", pWStart->functionName, pointer); - taosCreateMD5Hash(name, len); + (void)taosCreateMD5Hash(name, len); strncpy(pWStart->node.aliasName, name, TSDB_COL_NAME_LEN - 1); pWStart->node.resType.precision = precision; @@ -464,7 +464,7 @@ static int32_t stbSplAppendWEnd(SWindowLogicNode* pWin, int32_t* pIndex) { int64_t pointer = (int64_t)pWEnd; char name[TSDB_COL_NAME_LEN + TSDB_POINTER_PRINT_BYTES + TSDB_NAME_DELIMITER_LEN + 1] = {0}; int32_t len = snprintf(name, sizeof(name) - 1, "%s.%" PRId64 "", pWEnd->functionName, pointer); - taosCreateMD5Hash(name, len); + (void)taosCreateMD5Hash(name, len); strncpy(pWEnd->node.aliasName, name, TSDB_COL_NAME_LEN - 1); code = fmGetFuncInfo(pWEnd, NULL, 0); @@ -1108,7 +1108,7 @@ static int32_t stbSplAggNodeCreateMerge(SSplitContext* pCtx, SStableSplitInfo* p code = createColumnByRewriteExprs(extraAggFuncs, &pChildAgg->pTargets); } if (code == TSDB_CODE_SUCCESS) { - nodesListAppendList(((SAggLogicNode*)pChildAgg)->pAggFuncs, extraAggFuncs); + code = nodesListAppendList(((SAggLogicNode*)pChildAgg)->pAggFuncs, extraAggFuncs); extraAggFuncs = NULL; } @@ -1781,7 +1781,7 @@ static int32_t unionSplitSubplan(SSplitContext* pCxt, SLogicSubplan* pUnionSubpl if (TSDB_CODE_SUCCESS == code) { if (NULL != pSubplanChildren) { if (pSubplanChildren->length > 0) { - nodesListMakeStrictAppendList(&pUnionSubplan->pChildren, pSubplanChildren); + code = nodesListMakeStrictAppendList(&pUnionSubplan->pChildren, pSubplanChildren); } else { nodesDestroyList(pSubplanChildren); } @@ -2053,25 +2053,32 @@ static const SSplitRule splitRuleSet[] = { static const int32_t splitRuleNum = (sizeof(splitRuleSet) / sizeof(SSplitRule)); -static void dumpLogicSubplan(const char* pRuleName, SLogicSubplan* pSubplan) { +static int32_t dumpLogicSubplan(const char* pRuleName, SLogicSubplan* pSubplan) { + int32_t code = 0; if (!tsQueryPlannerTrace) { - return; + return code; } char* pStr = NULL; - nodesNodeToString((SNode*)pSubplan, false, &pStr, NULL); - if (NULL == pRuleName) { - qDebugL("before split, JsonPlan: %s", pStr); - } else { - qDebugL("apply split %s rule, JsonPlan: %s", pRuleName, pStr); + code = nodesNodeToString((SNode*)pSubplan, false, &pStr, NULL); + if (TSDB_CODE_SUCCESS == code) { + if (NULL == pRuleName) { + qDebugL("before split, JsonPlan: %s", pStr); + } else { + qDebugL("apply split %s rule, JsonPlan: %s", pRuleName, pStr); + } + taosMemoryFree(pStr); } - taosMemoryFree(pStr); + return code; } static int32_t applySplitRule(SPlanContext* pCxt, SLogicSubplan* pSubplan) { SSplitContext cxt = { .pPlanCxt = pCxt, .queryId = pSubplan->id.queryId, .groupId = pSubplan->id.groupId + 1, .split = false}; bool split = false; - dumpLogicSubplan(NULL, pSubplan); + int32_t code = dumpLogicSubplan(NULL, pSubplan); + if (TSDB_CODE_SUCCESS != code) { + return code; + } do { split = false; for (int32_t i = 0; i < splitRuleNum; ++i) { @@ -2082,7 +2089,10 @@ static int32_t applySplitRule(SPlanContext* pCxt, SLogicSubplan* pSubplan) { } if (cxt.split) { split = true; - dumpLogicSubplan(splitRuleSet[i].pName, pSubplan); + code = dumpLogicSubplan(splitRuleSet[i].pName, pSubplan); + if (TSDB_CODE_SUCCESS != code) { + return code; + } } } } while (split); diff --git a/source/libs/planner/src/planUtil.c b/source/libs/planner/src/planUtil.c index 95a2f1463d..91dc36b99f 100644 --- a/source/libs/planner/src/planUtil.c +++ b/source/libs/planner/src/planUtil.c @@ -35,7 +35,7 @@ static char* getUsageErrFormat(int32_t errCode) { int32_t generateUsageErrMsg(char* pBuf, int32_t len, int32_t errCode, ...) { va_list vArgList; va_start(vArgList, errCode); - vsnprintf(pBuf, len, getUsageErrFormat(errCode), vArgList); + (void)vsnprintf(pBuf, len, getUsageErrFormat(errCode), vArgList); va_end(vArgList); return errCode; } @@ -525,17 +525,26 @@ int32_t collectTableAliasFromNodes(SNode* pNode, SSHashObj** ppRes) { } } - tSimpleHashPut(*ppRes, pCol->tableAlias, strlen(pCol->tableAlias), NULL, 0); - } - - FOREACH(pNode, pCurr->pChildren) { - code = collectTableAliasFromNodes(pNode, ppRes); + code = tSimpleHashPut(*ppRes, pCol->tableAlias, strlen(pCol->tableAlias), NULL, 0); if (TSDB_CODE_SUCCESS != code) { - return code; + break; } } - return TSDB_CODE_SUCCESS; + if (TSDB_CODE_SUCCESS == code) { + FOREACH(pNode, pCurr->pChildren) { + code = collectTableAliasFromNodes(pNode, ppRes); + if (TSDB_CODE_SUCCESS != code) { + break; + } + } + } + if (TSDB_CODE_SUCCESS != code) { + tSimpleHashCleanup(*ppRes); + *ppRes = NULL; + } + + return code; } bool isPartTagAgg(SAggLogicNode* pAgg) { @@ -622,7 +631,7 @@ SFunctionNode* createGroupKeyAggFunc(SColumnNode* pGroupCol) { if (TSDB_CODE_SUCCESS == code) { char name[TSDB_FUNC_NAME_LEN + TSDB_NAME_DELIMITER_LEN + TSDB_POINTER_PRINT_BYTES + 1] = {0}; int32_t len = snprintf(name, sizeof(name) - 1, "%s.%p", pFunc->functionName, pFunc); - taosCreateMD5Hash(name, len); + (void)taosCreateMD5Hash(name, len); strncpy(pFunc->node.aliasName, name, TSDB_COL_NAME_LEN - 1); } } diff --git a/source/libs/planner/src/planner.c b/source/libs/planner/src/planner.c index eb5b47f011..1b53819c7b 100644 --- a/source/libs/planner/src/planner.c +++ b/source/libs/planner/src/planner.c @@ -19,22 +19,28 @@ #include "scalar.h" #include "tglobal.h" -static void debugPrintNode(SNode* pNode) { +static int32_t debugPrintNode(SNode* pNode) { char* pStr = NULL; - nodesNodeToString(pNode, false, &pStr, NULL); - printf("%s\n", pStr); - taosMemoryFree(pStr); - return; + int32_t code = nodesNodeToString(pNode, false, &pStr, NULL); + if (TSDB_CODE_SUCCESS == code) { + (void)printf("%s\n", pStr); + taosMemoryFree(pStr); + } + return code; } -static void dumpQueryPlan(SQueryPlan* pPlan) { +static int32_t dumpQueryPlan(SQueryPlan* pPlan) { + int32_t code = 0; if (!tsQueryPlannerTrace) { - return; + return code; } char* pStr = NULL; - nodesNodeToString((SNode*)pPlan, false, &pStr, NULL); - planDebugL("QID:0x%" PRIx64 " Query Plan, JsonPlan: %s", pPlan->queryId, pStr); - taosMemoryFree(pStr); + code = nodesNodeToString((SNode*)pPlan, false, &pStr, NULL); + if (TSDB_CODE_SUCCESS == code) { + planDebugL("QID:0x%" PRIx64 " Query Plan, JsonPlan: %s", pPlan->queryId, pStr); + taosMemoryFree(pStr); + } + return code; } int32_t qCreateQueryPlan(SPlanContext* pCxt, SQueryPlan** pPlan, SArray* pExecNodeList) { @@ -61,9 +67,9 @@ int32_t qCreateQueryPlan(SPlanContext* pCxt, SQueryPlan** pPlan, SArray* pExecNo code = validateQueryPlan(pCxt, *pPlan); } if (TSDB_CODE_SUCCESS == code) { - dumpQueryPlan(*pPlan); + code = dumpQueryPlan(*pPlan); } - nodesReleaseAllocator(pCxt->allocatorId); + (void)nodesReleaseAllocator(pCxt->allocatorId); nodesDestroyNode((SNode*)pLogicSubplan); nodesDestroyNode((SNode*)pLogicPlan); diff --git a/source/libs/planner/test/planStmtTest.cpp b/source/libs/planner/test/planStmtTest.cpp index df8a509d12..f9db50faf9 100644 --- a/source/libs/planner/test/planStmtTest.cpp +++ b/source/libs/planner/test/planStmtTest.cpp @@ -146,8 +146,8 @@ TEST_F(PlanStmtTest, basic) { { prepare("SELECT * FROM t1 WHERE c1 = ? AND c2 = ?"); TAOS_MULTI_BIND* pBindParams = createBindParams(2); - buildIntegerParam(pBindParams, 0, 10, TSDB_DATA_TYPE_INT); - buildStringParam(pBindParams, 1, "abc", TSDB_DATA_TYPE_VARCHAR, strlen("abc")); + (void)buildIntegerParam(pBindParams, 0, 10, TSDB_DATA_TYPE_INT); + (void)buildStringParam(pBindParams, 1, "abc", TSDB_DATA_TYPE_VARCHAR, strlen("abc")); bindParams(pBindParams, -1); exec(); destoryBindParams(pBindParams, 2); @@ -156,8 +156,8 @@ TEST_F(PlanStmtTest, basic) { { prepare("SELECT MAX(?), MAX(?) FROM t1"); TAOS_MULTI_BIND* pBindParams = createBindParams(2); - buildIntegerParam(pBindParams, 0, 10, TSDB_DATA_TYPE_TINYINT); - buildIntegerParam(pBindParams, 1, 20, TSDB_DATA_TYPE_INT); + (void)buildIntegerParam(pBindParams, 0, 10, TSDB_DATA_TYPE_TINYINT); + (void)buildIntegerParam(pBindParams, 1, 20, TSDB_DATA_TYPE_INT); bindParams(pBindParams, -1); exec(); destoryBindParams(pBindParams, 2); diff --git a/source/libs/planner/test/planTestMain.cpp b/source/libs/planner/test/planTestMain.cpp index e05fa27c1e..99f71e1bc6 100644 --- a/source/libs/planner/test/planTestMain.cpp +++ b/source/libs/planner/test/planTestMain.cpp @@ -27,13 +27,12 @@ class PlannerEnv : public testing::Environment { public: virtual void SetUp() { - // TODO(smj) : How to handle return value of fmFuncMgtInit - (void)fmFuncMgtInit(); + ASSERT_EQ(TSDB_CODE_SUCCESS, fmFuncMgtInit()); initMetaDataEnv(); generateMetaData(); initLog(TD_TMP_DIR_PATH "td"); initCfg(); - nodesInitAllocatorSet(); + ASSERT_EQ(TSDB_CODE_SUCCESS, nodesInitAllocatorSet()); } virtual void TearDown() { @@ -66,7 +65,7 @@ class PlannerEnv : public testing::Environment { tsAsyncLog = 0; taosRemoveDir(path); - taosMkDir(path); + ASSERT_EQ(TSDB_CODE_SUCCESS,taosMkDir(path)); tstrncpy(tsLogDir, path, PATH_MAX); if (taosInitLog("taoslog", 1) != 0) { std::cout << "failed to init log file" << std::endl; @@ -117,7 +116,7 @@ static void parseArg(int argc, char* argv[]) { } int main(int argc, char* argv[]) { - testing::AddGlobalTestEnvironment(new PlannerEnv()); + (void)testing::AddGlobalTestEnvironment(new PlannerEnv()); testing::InitGoogleTest(&argc, argv); parseArg(argc, argv); return RUN_ALL_TESTS(); diff --git a/source/libs/planner/test/planTestUtil.cpp b/source/libs/planner/test/planTestUtil.cpp index 3b432b9890..901ab7e131 100644 --- a/source/libs/planner/test/planTestUtil.cpp +++ b/source/libs/planner/test/planTestUtil.cpp @@ -131,8 +131,8 @@ class PlannerTestBaseImpl { void runImpl(const string& sql, int32_t queryPolicy) { int64_t allocatorId = 0; if (g_useNodeAllocator) { - nodesCreateAllocator(sqlNo_, 32 * 1024, &allocatorId); - nodesAcquireAllocator(allocatorId); + ASSERT_EQ(TSDB_CODE_SUCCESS, nodesCreateAllocator(sqlNo_, 32 * 1024, &allocatorId)); + ASSERT_EQ(TSDB_CODE_SUCCESS, nodesAcquireAllocator(allocatorId)); } reset(); @@ -166,12 +166,12 @@ class PlannerTestBaseImpl { dump(g_dumpModule); } catch (...) { dump(DUMP_MODULE_ALL); - nodesReleaseAllocator(allocatorId); + ASSERT_EQ(TSDB_CODE_SUCCESS, nodesReleaseAllocator(allocatorId)); nodesDestroyAllocator(allocatorId); throw; } - nodesReleaseAllocator(allocatorId); + ASSERT_EQ(TSDB_CODE_SUCCESS, nodesReleaseAllocator(allocatorId)); nodesDestroyAllocator(allocatorId); } @@ -448,12 +448,12 @@ class PlannerTestBaseImpl { pCmdMsg->msgLen = tSerializeSMCreateSmaReq(NULL, 0, pStmt->pReq); pCmdMsg->pMsg = taosMemoryMalloc(pCmdMsg->msgLen); if (!pCmdMsg->pMsg) FAIL(); - tSerializeSMCreateSmaReq(pCmdMsg->pMsg, pCmdMsg->msgLen, pStmt->pReq); + ASSERT_EQ(TSDB_CODE_SUCCESS, tSerializeSMCreateSmaReq(pCmdMsg->pMsg, pCmdMsg->msgLen, pStmt->pReq)); ((SQuery*)pQuery)->pCmdMsg = pCmdMsg; - tDeserializeSMCreateSmaReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req); + ASSERT_EQ(TSDB_CODE_SUCCESS, tDeserializeSMCreateSmaReq(pQuery->pCmdMsg->pMsg, pQuery->pCmdMsg->msgLen, &req)); g_mockCatalogService->createSmaIndex(&req); - nodesStringToNode(req.ast, &pCxt->pAstRoot); + ASSERT_EQ(TSDB_CODE_SUCCESS, nodesStringToNode(req.ast, &pCxt->pAstRoot)); pCxt->deleteMark = req.deleteMark; tFreeSMCreateSmaReq(&req); nodesDestroyNode(pQuery->pRoot);