From 1994c3339b936d6cc4c7e561b7cb9a749d79e335 Mon Sep 17 00:00:00 2001 From: wangjiaming0909 Date: Sun, 21 Jul 2024 18:20:30 +0800 Subject: [PATCH] nodes add ret check --- include/libs/nodes/nodes.h | 8 +- include/libs/nodes/querynodes.h | 6 +- source/client/src/clientMain.c | 9 +- source/client/src/clientRawBlockWrite.c | 27 +- source/libs/command/src/explain.c | 4 +- source/libs/executor/inc/executorInt.h | 1 + source/libs/executor/src/executil.c | 76 +- source/libs/executor/src/scanoperator.c | 14 +- .../executor/src/streamtimewindowoperator.c | 6 +- source/libs/executor/test/joinTests.cpp | 93 +- source/libs/function/src/builtins.c | 24 +- source/libs/function/src/functionMgt.c | 54 +- source/libs/nodes/src/nodesCloneFuncs.c | 89 +- source/libs/nodes/src/nodesCodeFuncs.c | 8 +- source/libs/nodes/src/nodesMsgFuncs.c | 11 +- source/libs/nodes/src/nodesUtilFuncs.c | 619 ++++---- source/libs/nodes/test/nodesCloneTest.cpp | 86 +- source/libs/nodes/test/nodesTestMain.cpp | 31 +- source/libs/parser/inc/parUtil.h | 2 +- source/libs/parser/src/parAstCreater.c | 768 +++++---- source/libs/parser/src/parAstParser.c | 13 +- source/libs/parser/src/parAuthenticator.c | 24 +- source/libs/parser/src/parCalcConst.c | 53 +- source/libs/parser/src/parInsertSml.c | 10 +- source/libs/parser/src/parInsertSql.c | 26 +- source/libs/parser/src/parTranslater.c | 1402 +++++++++++------ source/libs/parser/src/parUtil.c | 10 +- source/libs/parser/src/parser.c | 5 +- source/libs/planner/inc/planInt.h | 2 +- source/libs/planner/src/planLogicCreater.c | 502 +++--- source/libs/planner/src/planOptimizer.c | 1190 ++++++++++---- source/libs/planner/src/planPhysiCreater.c | 589 ++++--- source/libs/planner/src/planScaleOut.c | 35 +- source/libs/planner/src/planSpliter.c | 340 ++-- source/libs/planner/src/planUtil.c | 104 +- source/libs/planner/src/planner.c | 23 +- source/libs/scalar/src/filter.c | 76 +- source/libs/scalar/src/scalar.c | 24 +- .../libs/scalar/test/filter/filterTests.cpp | 33 +- .../libs/scalar/test/scalar/scalarTests.cpp | 60 +- source/libs/scheduler/test/schedulerTests.cpp | 118 +- 41 files changed, 4228 insertions(+), 2347 deletions(-) diff --git a/include/libs/nodes/nodes.h b/include/libs/nodes/nodes.h index d0bf2e2dd4..24a062bfa3 100644 --- a/include/libs/nodes/nodes.h +++ b/include/libs/nodes/nodes.h @@ -112,11 +112,11 @@ int64_t nodesMakeAllocatorWeakRef(int64_t allocatorId); int64_t nodesReleaseAllocatorWeakRef(int64_t allocatorId); void nodesDestroyAllocator(int64_t allocatorId); -SNode* nodesMakeNode(ENodeType type); +int32_t nodesMakeNode(ENodeType type, SNode** ppNodeOut); void nodesDestroyNode(SNode* pNode); void nodesFree(void* p); -SNodeList* nodesMakeList(); +int32_t nodesMakeList(SNodeList** ppListOut); int32_t nodesListAppend(SNodeList* pList, SNode* pNode); int32_t nodesListStrictAppend(SNodeList* pList, SNode* pNode); int32_t nodesListMakeAppend(SNodeList** pList, SNode* pNode); @@ -156,8 +156,8 @@ bool nodeListNodeEqual(const SNodeList* a, const SNode* b); bool nodesMatchNode(const SNode* pSub, const SNode* pNode); -SNode* nodesCloneNode(const SNode* pNode); -SNodeList* nodesCloneList(const SNodeList* pList); +int32_t nodesCloneNode(const SNode* pNode, SNode** ppNodeOut); +int32_t nodesCloneList(const SNodeList* pList, SNodeList** ppList); const char* nodesNodeName(ENodeType type); int32_t nodesNodeToString(const SNode* pNode, bool format, char** pStr, int32_t* pLen); diff --git a/include/libs/nodes/querynodes.h b/include/libs/nodes/querynodes.h index 08b4c8fccb..54c8686161 100644 --- a/include/libs/nodes/querynodes.h +++ b/include/libs/nodes/querynodes.h @@ -636,9 +636,9 @@ void* nodesGetValueFromNode(SValueNode* pNode); int32_t nodesSetValueNodeValue(SValueNode* pNode, void* value); char* nodesGetStrValueFromNode(SValueNode* pNode); void nodesValueNodeToVariant(const SValueNode* pNode, SVariant* pVal); -SValueNode* nodesMakeValueNodeFromString(char* literal); -SValueNode* nodesMakeValueNodeFromBool(bool b); -SNode* nodesMakeValueNodeFromInt32(int32_t value); +int32_t nodesMakeValueNodeFromString(char* literal, SValueNode** ppValNode); +int32_t nodesMakeValueNodeFromBool(bool b, SValueNode** ppValNode); +int32_t nodesMakeValueNodeFromInt32(int32_t value, SNode** ppNode); char* nodesGetFillModeString(EFillMode mode); int32_t nodesMergeConds(SNode** pDst, SNodeList** pSrc); diff --git a/source/client/src/clientMain.c b/source/client/src/clientMain.c index ea8cec97ba..ae494301d2 100644 --- a/source/client/src/clientMain.c +++ b/source/client/src/clientMain.c @@ -999,10 +999,9 @@ void handleSubQueryFromAnalyse(SSqlCallbackWrapper *pWrapper, SMetaData *pResult return; } - pNewRequest->pQuery = (SQuery *)nodesMakeNode(QUERY_NODE_QUERY); - if (NULL == pNewRequest->pQuery) { - code = TSDB_CODE_OUT_OF_MEMORY; - } else { + pNewRequest->pQuery = NULL; + code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pNewRequest->pQuery); + if (pNewRequest->pQuery) { pNewRequest->pQuery->pRoot = pRoot; pRoot = NULL; pNewRequest->pQuery->execStage = QUERY_EXEC_STAGE_ANALYSE; @@ -1901,4 +1900,4 @@ int taos_set_conn_mode(TAOS* taos, int mode, int value) { char* getBuildInfo(){ return buildinfo; -} \ No newline at end of file +} diff --git a/source/client/src/clientRawBlockWrite.c b/source/client/src/clientRawBlockWrite.c index e028f76fe3..be33033cf9 100644 --- a/source/client/src/clientRawBlockWrite.c +++ b/source/client/src/clientRawBlockWrite.c @@ -1214,12 +1214,14 @@ static int32_t taosCreateTable(TAOS* taos, void* meta, int32_t metaLen) { } SArray* pBufArray = NULL; RAW_RETURN_CHECK(serializeVgroupsCreateTableBatch(pVgroupHashmap, &pBufArray)); - pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY); - RAW_NULL_CHECK(pQuery); + pQuery = NULL; + code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pQuery); + if (TSDB_CODE_SUCCESS != code) goto end; pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE; pQuery->msgType = TDMT_VND_CREATE_TABLE; pQuery->stableQuery = false; - pQuery->pRoot = nodesMakeNode(QUERY_NODE_CREATE_TABLE_STMT); + code = nodesMakeNode(QUERY_NODE_CREATE_TABLE_STMT, &pQuery->pRoot); + if (TSDB_CODE_SUCCESS != code) goto end; RAW_NULL_CHECK(pQuery->pRoot); RAW_RETURN_CHECK(rewriteToVnodeModifyOpStmt(pQuery, pBufArray)); @@ -1343,13 +1345,14 @@ static int32_t taosDropTable(TAOS* taos, void* meta, int32_t metaLen) { } SArray* pBufArray = NULL; RAW_RETURN_CHECK(serializeVgroupsDropTableBatch(pVgroupHashmap, &pBufArray)); - pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY); - RAW_NULL_CHECK(pQuery); + code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pQuery); + if (TSDB_CODE_SUCCESS != code) goto end; pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE; pQuery->msgType = TDMT_VND_DROP_TABLE; pQuery->stableQuery = false; - pQuery->pRoot = nodesMakeNode(QUERY_NODE_DROP_TABLE_STMT); - RAW_NULL_CHECK(pQuery->pRoot); + pQuery->pRoot = NULL; + code = nodesMakeNode(QUERY_NODE_DROP_TABLE_STMT, &pQuery->pRoot); + if (TSDB_CODE_SUCCESS != code) goto end; RAW_RETURN_CHECK(rewriteToVnodeModifyOpStmt(pQuery, pBufArray)); (void)launchQueryImpl(pRequest, pQuery, true, NULL); @@ -1486,13 +1489,15 @@ static int32_t taosAlterTable(TAOS* taos, void* meta, int32_t metaLen) { pVgData->numOfTables = 1; RAW_NULL_CHECK(taosArrayPush(pArray, &pVgData)); - pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY); - RAW_NULL_CHECK(pQuery); + pQuery = NULL; + code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pQuery); + if (NULL == pQuery) goto end; pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE; pQuery->msgType = TDMT_VND_ALTER_TABLE; pQuery->stableQuery = false; - pQuery->pRoot = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT); - RAW_NULL_CHECK(pQuery->pRoot); + pQuery->pRoot = NULL; + code = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT, &pQuery->pRoot); + if (TSDB_CODE_SUCCESS != code) goto end; RAW_RETURN_CHECK(rewriteToVnodeModifyOpStmt(pQuery, pArray)); diff --git a/source/libs/command/src/explain.c b/source/libs/command/src/explain.c index e0040ac0e1..1c95735c14 100644 --- a/source/libs/command/src/explain.c +++ b/source/libs/command/src/explain.c @@ -163,10 +163,10 @@ int32_t qExplainGenerateResChildren(SPhysiNode *pNode, SExplainGroup *group, SNo SNodeList *pPhysiChildren = pNode->pChildren; if (pPhysiChildren) { - *pChildren = nodesMakeList(); + int32_t code = nodesMakeList(pChildren); if (NULL == *pChildren) { qError("nodesMakeList failed"); - QRY_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + QRY_ERR_RET(code); } } diff --git a/source/libs/executor/inc/executorInt.h b/source/libs/executor/inc/executorInt.h index eb36141ef0..0d2692267b 100644 --- a/source/libs/executor/inc/executorInt.h +++ b/source/libs/executor/inc/executorInt.h @@ -364,6 +364,7 @@ typedef struct STagScanFilterContext { SHashObj* colHash; int32_t index; SArray* cInfoList; + int32_t code; } STagScanFilterContext; typedef struct STagScanInfo { diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c index 5db27478fc..444cc52645 100644 --- a/source/libs/executor/src/executil.c +++ b/source/libs/executor/src/executil.c @@ -33,8 +33,14 @@ typedef struct tagFilterAssist { SHashObj* colHash; int32_t index; SArray* cInfoList; + int32_t code; } tagFilterAssist; +typedef struct STransTagExprCtx { + int32_t code; + SMetaReader* pReader; +} STransTagExprCtx; + typedef enum { FILTER_NO_LOGIC = 1, FILTER_AND, @@ -300,8 +306,9 @@ int32_t prepareDataBlockBuf(SSDataBlock* pDataBlock, SColMatchInfo* pMatchInfo) } EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) { - SMetaReader* mr = (SMetaReader*)pContext; - bool isTagCol = false, isTbname = false; + STransTagExprCtx* pCtx = pContext; + SMetaReader* mr = pCtx->pReader; + bool isTagCol = false, isTbname = false; if (nodeType(*pNode) == QUERY_NODE_COLUMN) { SColumnNode* pCol = (SColumnNode*)*pNode; if (pCol->colType == COLUMN_TYPE_TBNAME) @@ -315,7 +322,8 @@ EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) { if (isTagCol) { SColumnNode* pSColumnNode = *(SColumnNode**)pNode; - SValueNode* res = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode* res = NULL; + pCtx->code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res); if (NULL == res) { return DEAL_RES_ERROR; } @@ -345,7 +353,8 @@ EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) { nodesDestroyNode(*pNode); *pNode = (SNode*)res; } else if (isTbname) { - SValueNode* res = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode* res = NULL; + pCtx->code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res); if (NULL == res) { return DEAL_RES_ERROR; } @@ -377,10 +386,20 @@ int32_t isQualifiedTable(STableKeyInfo* info, SNode* pTagCond, void* metaHandle, return TSDB_CODE_SUCCESS; } - SNode* pTagCondTmp = nodesCloneNode(pTagCond); - - nodesRewriteExprPostOrder(&pTagCondTmp, doTranslateTagExpr, &mr); + SNode* pTagCondTmp = NULL; + code = nodesCloneNode(pTagCond, &pTagCondTmp); + if (TSDB_CODE_SUCCESS != code) { + *pQualified = false; + return code; + } + STransTagExprCtx ctx = {.code = 0, .pReader = &mr}; + nodesRewriteExprPostOrder(&pTagCondTmp, doTranslateTagExpr, &ctx); pAPI->metaReaderFn.clearReader(&mr); + if (TSDB_CODE_SUCCESS != ctx.code) { + *pQualified = false; + terrno = code; + return code; + } SNode* pNew = NULL; code = scalarCalculateConstants(pTagCondTmp, &pNew); @@ -400,13 +419,14 @@ int32_t isQualifiedTable(STableKeyInfo* info, SNode* pTagCond, void* metaHandle, } static EDealRes getColumn(SNode** pNode, void* pContext) { + tagFilterAssist* pData = (tagFilterAssist*)pContext; SColumnNode* pSColumnNode = NULL; if (QUERY_NODE_COLUMN == nodeType((*pNode))) { pSColumnNode = *(SColumnNode**)pNode; } else if (QUERY_NODE_FUNCTION == nodeType((*pNode))) { SFunctionNode* pFuncNode = *(SFunctionNode**)(pNode); if (pFuncNode->funcType == FUNCTION_TYPE_TBNAME) { - pSColumnNode = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + pData->code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pSColumnNode); if (NULL == pSColumnNode) { return DEAL_RES_ERROR; } @@ -423,7 +443,6 @@ static EDealRes getColumn(SNode** pNode, void* pContext) { return DEAL_RES_CONTINUE; } - tagFilterAssist* pData = (tagFilterAssist*)pContext; void* data = taosHashGet(pData->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId)); if (!data) { int32_t tempRes = @@ -571,12 +590,20 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf SNode* pNode = NULL; FOREACH(pNode, group) { nodesRewriteExprPostOrder(&pNode, getColumn, (void*)&ctx); + if (TSDB_CODE_SUCCESS != ctx.code) { + code = ctx.code; + goto end; + } REPLACE_NODE(pNode); } T_MD5_CTX context = {0}; if (tsTagFilterCache) { - SNodeListNode* listNode = (SNodeListNode*)nodesMakeNode(QUERY_NODE_NODE_LIST); + SNodeListNode* listNode = NULL; + code = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&listNode); + if (TSDB_CODE_SUCCESS != code) { + goto end; + } listNode->pNodeList = group; code = genTbGroupDigest((SNode*)listNode, digest, &context); QUERY_CHECK_CODE(code, lino, end); @@ -1166,6 +1193,10 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN } nodesRewriteExprPostOrder(&pTagCond, getColumn, (void*)&ctx); + if (TSDB_CODE_SUCCESS != ctx.code) { + terrno = code = ctx.code; + goto end; + } SDataType type = {.type = TSDB_DATA_TYPE_BOOL, .bytes = sizeof(bool)}; @@ -1414,9 +1445,20 @@ int32_t getGroupIdFromTagsVal(void* pVnode, uint64_t uid, SNodeList* pGroupNode, return TSDB_CODE_PAR_TABLE_NOT_EXIST; } - SNodeList* groupNew = nodesCloneList(pGroupNode); + SNodeList* groupNew = NULL; + int32_t code = nodesCloneList(pGroupNode, &groupNew); + if (TSDB_CODE_SUCCESS != code) { + pAPI->metaReaderFn.clearReader(&mr); + return code; + } - nodesRewriteExprsPostOrder(groupNew, doTranslateTagExpr, &mr); + STransTagExprCtx ctx = {.code = 0, .pReader = &mr}; + nodesRewriteExprsPostOrder(groupNew, doTranslateTagExpr, &ctx); + if (TSDB_CODE_SUCCESS != ctx.code) { + nodesDestroyList(groupNew); + pAPI->metaReaderFn.clearReader(&mr); + return code; + } char* isNull = (char*)keyBuf; char* pStart = (char*)keyBuf + sizeof(int8_t) * LIST_LENGTH(pGroupNode); @@ -1667,9 +1709,13 @@ int32_t createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) { if (!pFuncNode->pParameterList && (memcmp(pExprNode->_function.functionName, name, len) == 0) && pExprNode->_function.functionName[len] == 0) { - pFuncNode->pParameterList = nodesMakeList(); - SValueNode* res = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); - if (NULL == res) { // todo handle error + pFuncNode->pParameterList = NULL; + int32_t code = nodesMakeList(&pFuncNode->pParameterList); + SValueNode* res = NULL; + if (TSDB_CODE_SUCCESS == code) { + code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res); + } + if (TSDB_CODE_SUCCESS != code) { // todo handle error } else { res->node.resType = (SDataType){.bytes = sizeof(int64_t), .type = TSDB_DATA_TYPE_BIGINT}; code = nodesListAppend(pFuncNode->pParameterList, (SNode*)res); diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index 8cb4bfeb2f..01a716f698 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -382,7 +382,7 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanBase* pTableSca } } - // free the sma info, since it should not be involved in later computing process. + // free the sma info, since it should not be involved in *later computing process. taosMemoryFreeClear(pBlock->pBlockAgg); // try to filter data block according to current results @@ -4073,15 +4073,17 @@ static int32_t tagScanCreateResultData(SDataType* pType, int32_t numOfRows, SSca } static EDealRes tagScanRewriteTagColumn(SNode** pNode, void* pContext) { - int32_t code = TSDB_CODE_SUCCESS; - int32_t lino = 0; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + STagScanFilterContext* pCtx = (STagScanFilterContext*)pContext; SColumnNode* pSColumnNode = NULL; if (QUERY_NODE_COLUMN == nodeType((*pNode))) { pSColumnNode = *(SColumnNode**)pNode; } else if (QUERY_NODE_FUNCTION == nodeType((*pNode))) { SFunctionNode* pFuncNode = *(SFunctionNode**)(pNode); if (pFuncNode->funcType == FUNCTION_TYPE_TBNAME) { - pSColumnNode = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + pSColumnNode = NULL; + pCtx->code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pSColumnNode); if (NULL == pSColumnNode) { return DEAL_RES_ERROR; } @@ -4098,8 +4100,7 @@ static EDealRes tagScanRewriteTagColumn(SNode** pNode, void* pContext) { return DEAL_RES_CONTINUE; } - STagScanFilterContext* pCtx = (STagScanFilterContext*)pContext; - void* data = taosHashGet(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId)); + void* data = taosHashGet(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId)); if (!data) { code = taosHashPut(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode))); if (code == TSDB_CODE_DUP_KEY) { @@ -4493,6 +4494,7 @@ SOperatorInfo* createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysi nodesRewriteExprPostOrder(&pTagCond, tagScanRewriteTagColumn, (void*)&pInfo->filterCtx); } } + //TODO wjm check pInfo->filterCtx.code __optr_fn_t tagScanNextFn = (pTagScanNode->onlyMetaCtbIdx) ? doTagScanFromCtbIdx : doTagScanFromMetaEntry; pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, tagScanNextFn, NULL, destroyTagScanOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); diff --git a/source/libs/executor/src/streamtimewindowoperator.c b/source/libs/executor/src/streamtimewindowoperator.c index 5aa7cac45d..95cad97a06 100644 --- a/source/libs/executor/src/streamtimewindowoperator.c +++ b/source/libs/executor/src/streamtimewindowoperator.c @@ -1905,7 +1905,11 @@ SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, initResultRowInfo(&pInfo->binfo.resultRowInfo); pInfo->numOfChild = numOfChild; - pInfo->pPhyNode = (SPhysiNode*)nodesCloneNode((SNode*)pPhyNode); + pInfo->pPhyNode = NULL; + code = nodesCloneNode((SNode*)pPhyNode, (SNode**)&pInfo->pPhyNode); + if (TSDB_CODE_SUCCESS != code) { + goto _error; + } pInfo->pPullWins = taosArrayInit(8, sizeof(SPullWindowInfo)); pInfo->pullIndex = 0; diff --git a/source/libs/executor/test/joinTests.cpp b/source/libs/executor/test/joinTests.cpp index e3daf6ff27..95a4a5e841 100755 --- a/source/libs/executor/test/joinTests.cpp +++ b/source/libs/executor/test/joinTests.cpp @@ -305,14 +305,16 @@ static int32_t jtMergeEqCond(SNode** ppDst, SNode** ppSrc) { return TSDB_CODE_SUCCESS; } - SLogicConditionNode* pLogicCond = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); + SLogicConditionNode* pLogicCond = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogicCond); if (NULL == pLogicCond) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL; pLogicCond->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes; pLogicCond->condType = LOGIC_COND_TYPE_AND; - pLogicCond->pParameterList = nodesMakeList(); + pLogicCond->pParameterList = NULL; + code = nodesMakeList(&pLogicCond->pParameterList); assert(0 == nodesListStrictAppend(pLogicCond->pParameterList, *ppSrc)); assert(0 == nodesListStrictAppend(pLogicCond->pParameterList, *ppDst)); @@ -387,8 +389,10 @@ void createTargetSlotList(SSortMergeJoinPhysiNode* p) { jtCtx.keyColOffset = dstOffset; } - STargetNode* pTarget = (STargetNode*)nodesMakeNode(QUERY_NODE_TARGET); - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + STargetNode* pTarget = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_TARGET, (SNode**)&pTarget); + SColumnNode* pCol = NULL; + code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); assert(NULL != pTarget && NULL != pCol); pCol->dataBlockId = LEFT_BLK_ID; pCol->slotId = i; @@ -412,8 +416,10 @@ void createTargetSlotList(SSortMergeJoinPhysiNode* p) { jtCtx.keyColOffset = dstOffset; } - STargetNode* pTarget = (STargetNode*)nodesMakeNode(QUERY_NODE_TARGET); - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + STargetNode* pTarget = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_TARGET, (SNode**)&pTarget); + SColumnNode* pCol = NULL; + code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); assert(NULL != pTarget && NULL != pCol); pCol->dataBlockId = RIGHT_BLK_ID; pCol->slotId = i; @@ -454,9 +460,9 @@ void createColEqCondStart(SSortMergeJoinPhysiNode* p) { for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) { if (jtCtx.colEqList[i]) { - SColumnNode* pCol1 = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + SColumnNode* pCol1 = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol1); assert(pCol1); - pCol1->dataBlockId = LEFT_BLK_ID; pCol1->slotId = i; pCol1->node.resType.type = jtInputColType[i]; @@ -464,7 +470,8 @@ void createColEqCondStart(SSortMergeJoinPhysiNode* p) { assert(0 == nodesListMakeStrictAppend(&p->pEqLeft, (SNode*)pCol1)); - SColumnNode* pCol2 = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + SColumnNode* pCol2 = NULL; + code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol2); pCol2->dataBlockId = RIGHT_BLK_ID; pCol2->slotId = i; pCol2->node.resType.type = jtInputColType[i]; @@ -511,7 +518,7 @@ void createColEqCondEnd(SSortMergeJoinPhysiNode* p) { SLogicConditionNode* pLogic = NULL; if (jtCtx.colEqNum > 1) { - pLogic = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogic); assert(pLogic); pLogic->node.resType.type = TSDB_DATA_TYPE_BOOL; pLogic->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes; @@ -520,21 +527,24 @@ void createColEqCondEnd(SSortMergeJoinPhysiNode* p) { for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) { if (jtCtx.colEqList[i]) { - SColumnNode* pCol1 = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + SColumnNode* pCol1 = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol1); assert(pCol1); pCol1->dataBlockId = RES_BLK_ID; pCol1->slotId = getDstSlotId(i); pCol1->node.resType.type = jtInputColType[i]; pCol1->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; - SColumnNode* pCol2 = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + SColumnNode* pCol2 = NULL; + code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol2); assert(pCol2); pCol2->dataBlockId = RES_BLK_ID; pCol2->slotId = getDstSlotId(MAX_SLOT_NUM + i); pCol2->node.resType.type = jtInputColType[i]; pCol2->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; - SOperatorNode* pOp = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR); + SOperatorNode* pOp = NULL; + code = nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pOp); assert(pOp); pOp->opType = OP_TYPE_EQUAL; pOp->node.resType.type = TSDB_DATA_TYPE_BOOL; @@ -563,7 +573,7 @@ void createColOnCondEnd(SSortMergeJoinPhysiNode* p) { SLogicConditionNode* pLogic = NULL; if (jtCtx.colOnNum > 1) { - pLogic = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogic); assert(pLogic); pLogic->node.resType.type = TSDB_DATA_TYPE_BOOL; pLogic->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes; @@ -572,21 +582,24 @@ void createColOnCondEnd(SSortMergeJoinPhysiNode* p) { for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) { if (jtCtx.colOnList[i]) { - SColumnNode* pCol1 = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + SColumnNode* pCol1 = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol1); assert(pCol1); pCol1->dataBlockId = RES_BLK_ID; pCol1->slotId = getDstSlotId(i); pCol1->node.resType.type = jtInputColType[i]; pCol1->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; - SColumnNode* pCol2 = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + SColumnNode* pCol2 = NULL; + code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol2); assert(pCol2); pCol2->dataBlockId = RES_BLK_ID; pCol2->slotId = getDstSlotId(MAX_SLOT_NUM + i); pCol2->node.resType.type = jtInputColType[i]; pCol2->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; - SOperatorNode* pOp = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR); + SOperatorNode* pOp = NULL; + code = nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pOp); assert(pOp); pOp->opType = OP_TYPE_GREATER_THAN; pOp->node.resType.type = TSDB_DATA_TYPE_BOOL; @@ -607,7 +620,8 @@ void createColOnCondEnd(SSortMergeJoinPhysiNode* p) { p->pColOnCond = (SNode*)pLogic; } - SNode* pTmp = nodesCloneNode(p->pColOnCond); + SNode* pTmp = NULL; + int32_t code = nodesCloneNode(p->pColOnCond, &pTmp); assert(pTmp); assert(0 == jtMergeEqCond(&p->pFullOnCond, &pTmp)); } @@ -721,7 +735,7 @@ void createFilterEnd(SSortMergeJoinPhysiNode* p, bool filter) { SLogicConditionNode* pLogic = NULL; if ((jtCtx.leftFilterNum + jtCtx.rightFilterNum) > 1) { - pLogic = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogic); assert(pLogic); pLogic->node.resType.type = TSDB_DATA_TYPE_BOOL; pLogic->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes; @@ -730,7 +744,8 @@ void createFilterEnd(SSortMergeJoinPhysiNode* p, bool filter) { for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) { if (jtCtx.leftFilterColList[i]) { - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + SColumnNode* pCol = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN,(SNode**)&pCol); assert(pCol); pCol->dataBlockId = RES_BLK_ID; pCol->slotId = getDstSlotId(i); @@ -738,13 +753,15 @@ void createFilterEnd(SSortMergeJoinPhysiNode* p, bool filter) { pCol->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; (void)sprintf(pCol->colName, "l%d", i); - SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode* pVal = NULL; + code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal); assert(pVal); pVal->node.resType.type = jtInputColType[i]; pVal->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; assert(0 == nodesSetValueNodeValue(pVal, getFilterValue(jtInputColType[i]))); - SOperatorNode* pOp = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR); + SOperatorNode* pOp = NULL; + code = nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pOp); assert(pOp); pOp->opType = OP_TYPE_GREATER_THAN; pOp->node.resType.type = TSDB_DATA_TYPE_BOOL; @@ -763,7 +780,8 @@ void createFilterEnd(SSortMergeJoinPhysiNode* p, bool filter) { for (int32_t i = 0; i < MAX_SLOT_NUM; ++i) { if (jtCtx.rightFilterColList[i]) { - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + SColumnNode* pCol = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); assert(pCol); pCol->dataBlockId = RES_BLK_ID; pCol->slotId = getDstSlotId(MAX_SLOT_NUM + i); @@ -771,13 +789,15 @@ void createFilterEnd(SSortMergeJoinPhysiNode* p, bool filter) { pCol->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; (void)sprintf(pCol->colName, "r%d", i); - SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode* pVal = NULL; + code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal); assert(pVal); pVal->node.resType.type = jtInputColType[i]; pVal->node.resType.bytes = tDataTypes[jtInputColType[i]].bytes; assert(0 == nodesSetValueNodeValue(pVal, getFilterValue(jtInputColType[i]))); - SOperatorNode* pOp = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR); + SOperatorNode* pOp = NULL; + code = nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pOp); assert(pOp); pOp->opType = OP_TYPE_GREATER_THAN; pOp->node.resType.type = TSDB_DATA_TYPE_BOOL; @@ -810,13 +830,15 @@ void updateColRowInfo() { } void createBlockDescNode(SDataBlockDescNode** ppNode) { - SDataBlockDescNode* pDesc = (SDataBlockDescNode*)nodesMakeNode(QUERY_NODE_DATABLOCK_DESC); + SDataBlockDescNode* pDesc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_DATABLOCK_DESC, (SNode**)&pDesc); assert(pDesc); pDesc->dataBlockId = RES_BLK_ID; pDesc->totalRowSize = jtCtx.resColSize - MAX_SLOT_NUM * 2 * sizeof(bool); pDesc->outputRowSize = pDesc->totalRowSize; for (int32_t i = 0; i < jtCtx.resColNum; ++i) { - SSlotDescNode* pSlot = (SSlotDescNode*)nodesMakeNode(QUERY_NODE_SLOT_DESC); + SSlotDescNode* pSlot = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_SLOT_DESC, (SNode**)&pSlot); assert(pSlot); pSlot->slotId = i; int32_t slotIdx = jtCtx.resColInSlot[i] >= MAX_SLOT_NUM ? jtCtx.resColInSlot[i] - MAX_SLOT_NUM : jtCtx.resColInSlot[i]; @@ -830,14 +852,16 @@ void createBlockDescNode(SDataBlockDescNode** ppNode) { } SSortMergeJoinPhysiNode* createDummySortMergeJoinPhysiNode(SJoinTestParam* param) { - SSortMergeJoinPhysiNode* p = (SSortMergeJoinPhysiNode*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN); + SSortMergeJoinPhysiNode* p = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN, (SNode**)&p); assert(p); p->joinType = param->joinType; p->subType = param->subType; p->asofOpType = param->asofOp; p->grpJoin = param->grpJoin; if (p->subType == JOIN_STYPE_WIN || param->jLimit > 1 || taosRand() % 2) { - SLimitNode* limitNode = (SLimitNode*)nodesMakeNode(QUERY_NODE_LIMIT); + SLimitNode* limitNode = NULL; + code = nodesMakeNode(QUERY_NODE_LIMIT, (SNode**)&limitNode); assert(limitNode); limitNode->limit = param->jLimit; p->pJLimit = (SNode*)limitNode; @@ -847,11 +871,14 @@ SSortMergeJoinPhysiNode* createDummySortMergeJoinPhysiNode(SJoinTestParam* param p->rightPrimSlotId = JT_PRIM_TS_SLOT_ID; p->node.inputTsOrder = param->asc ? ORDER_ASC : ORDER_DESC; if (JOIN_STYPE_WIN == p->subType) { - SWindowOffsetNode* pOffset = (SWindowOffsetNode*)nodesMakeNode(QUERY_NODE_WINDOW_OFFSET); + SWindowOffsetNode* pOffset = NULL; + code = nodesMakeNode(QUERY_NODE_WINDOW_OFFSET, (SNode**)&pOffset); assert(pOffset); - SValueNode* pStart = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode* pStart = NULL; + code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pStart); assert(pStart); - SValueNode* pEnd = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode* pEnd = NULL; + code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pEnd); assert(pEnd); pStart->node.resType.type = TSDB_DATA_TYPE_BIGINT; pStart->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes; diff --git a/source/libs/function/src/builtins.c b/source/libs/function/src/builtins.c index 9c57c682cf..72e6ab7b42 100644 --- a/source/libs/function/src/builtins.c +++ b/source/libs/function/src/builtins.c @@ -216,9 +216,10 @@ static int32_t addTimezoneParam(SNodeList* pList) { } int32_t len = (int32_t)strlen(buf); - SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode* pVal = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal); if (pVal == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pVal->literal = strndup(buf, len); @@ -247,9 +248,10 @@ static int32_t addTimezoneParam(SNodeList* pList) { } static int32_t addDbPrecisonParam(SNodeList** pList, uint8_t precision) { - SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode* pVal = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal); if (pVal == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pVal->literal = NULL; @@ -835,9 +837,13 @@ static int32_t translateTopBot(SFunctionNode* pFunc, char* pErrBuf, int32_t len) static int32_t reserveFirstMergeParam(SNodeList* pRawParameters, SNode* pPartialRes, SNodeList** pParameters) { int32_t code = nodesListMakeAppend(pParameters, pPartialRes); if (TSDB_CODE_SUCCESS == code) { - code = nodesListStrictAppend(*pParameters, nodesCloneNode(nodesListGetNode(pRawParameters, 1))); + SNode* pNew = NULL; + code = nodesCloneNode(nodesListGetNode(pRawParameters, 1), &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(*pParameters, pNew); + } } - return TSDB_CODE_SUCCESS; + return code; } int32_t topBotCreateMergeParam(SNodeList* pRawParameters, SNode* pPartialRes, SNodeList** pParameters) { @@ -847,7 +853,11 @@ int32_t topBotCreateMergeParam(SNodeList* pRawParameters, SNode* pPartialRes, SN int32_t apercentileCreateMergeParam(SNodeList* pRawParameters, SNode* pPartialRes, SNodeList** pParameters) { int32_t code = reserveFirstMergeParam(pRawParameters, pPartialRes, pParameters); if (TSDB_CODE_SUCCESS == code && pRawParameters->length >= 3) { - code = nodesListStrictAppend(*pParameters, nodesCloneNode(nodesListGetNode(pRawParameters, 2))); + SNode* pNew = NULL; + code = nodesCloneNode(nodesListGetNode(pRawParameters, 2), &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(*pParameters, pNew); + } } return code; } diff --git a/source/libs/function/src/functionMgt.c b/source/libs/function/src/functionMgt.c index 0424b2f179..1a3a137aea 100644 --- a/source/libs/function/src/functionMgt.c +++ b/source/libs/function/src/functionMgt.c @@ -382,29 +382,30 @@ static int32_t getFuncInfo(SFunctionNode* pFunc) { return fmGetFuncInfo(pFunc, msg, sizeof(msg)); } -int32_t createFunction(const char* pName, SNodeList* pParameterList, SFunctionNode** pFunc) { - *pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); - if (NULL == *pFunc) { - return TSDB_CODE_OUT_OF_MEMORY; +int32_t createFunction(const char* pName, SNodeList* pParameterList, SFunctionNode** ppFunc) { + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)ppFunc); + if (NULL == *ppFunc) { + return code; } - (void)snprintf((*pFunc)->functionName, sizeof((*pFunc)->functionName), "%s", pName); - (*pFunc)->pParameterList = pParameterList; - int32_t code = getFuncInfo((*pFunc)); + (void)snprintf((*ppFunc)->functionName, sizeof((*ppFunc)->functionName), "%s", pName); + (*ppFunc)->pParameterList = pParameterList; + code = getFuncInfo((*ppFunc)); if (TSDB_CODE_SUCCESS != code) { - (*pFunc)->pParameterList = NULL; - nodesDestroyNode((SNode*)*pFunc); + (*ppFunc)->pParameterList = NULL; + nodesDestroyNode((SNode*)*ppFunc); + *ppFunc = NULL; return code; } return code; } -static int32_t createColumnByFunc(const SFunctionNode* pFunc, SColumnNode** pCol) { - *pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); - if (NULL == *pCol) { - return TSDB_CODE_OUT_OF_MEMORY; +static int32_t createColumnByFunc(const SFunctionNode* pFunc, SColumnNode** ppCol) { + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&ppCol); + if (NULL == *ppCol) { + return code; } - (void)strcpy((*pCol)->colName, pFunc->node.aliasName); - (*pCol)->node.resType = pFunc->node.resType; + (void)strcpy((*ppCol)->colName, pFunc->node.aliasName); + (*ppCol)->node.resType = pFunc->node.resType; return TSDB_CODE_SUCCESS; } @@ -419,11 +420,12 @@ bool fmIsDistExecFunc(int32_t funcId) { } static int32_t createPartialFunction(const SFunctionNode* pSrcFunc, SFunctionNode** pPartialFunc) { - SNodeList* pParameterList = nodesCloneList(pSrcFunc->pParameterList); + SNodeList* pParameterList = NULL; + int32_t code = nodesCloneList(pSrcFunc->pParameterList, &pParameterList); if (NULL == pParameterList) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - int32_t code = createFunction(funcMgtBuiltins[pSrcFunc->funcId].pPartialFunc, pParameterList,pPartialFunc ); + code = createFunction(funcMgtBuiltins[pSrcFunc->funcId].pPartialFunc, pParameterList,pPartialFunc ); if (TSDB_CODE_SUCCESS != code) { nodesDestroyList(pParameterList); return code; @@ -542,12 +544,13 @@ char* fmGetFuncName(int32_t funcId) { /// @retval 0 for succ, otherwise err occured static int32_t fmCreateStateFunc(const SFunctionNode* pFunc, SFunctionNode** pStateFunc) { if (funcMgtBuiltins[pFunc->funcId].pStateFunc) { - SNodeList* pParams = nodesCloneList(pFunc->pParameterList); - if (!pParams) return TSDB_CODE_OUT_OF_MEMORY; - int32_t code = createFunction(funcMgtBuiltins[pFunc->funcId].pStateFunc, pParams, pStateFunc); + SNodeList* pParams = NULL; + int32_t code = nodesCloneList(pFunc->pParameterList, &pParams); + if (!pParams) return code; + code = createFunction(funcMgtBuiltins[pFunc->funcId].pStateFunc, pParams, pStateFunc); if (TSDB_CODE_SUCCESS != code) { nodesDestroyList(pParams); - return TSDB_CODE_FUNC_FUNTION_ERROR; + return terrno; } (void)strcpy((*pStateFunc)->node.aliasName, pFunc->node.aliasName); (void)strcpy((*pStateFunc)->node.userAlias, pFunc->node.userAlias); @@ -588,9 +591,10 @@ int32_t fmCreateStateFuncs(SNodeList* pFuncs) { static int32_t fmCreateStateMergeFunc(SFunctionNode* pFunc, SFunctionNode** pStateMergeFunc) { if (funcMgtBuiltins[pFunc->funcId].pMergeFunc) { - SNodeList* pParams = nodesCloneList(pFunc->pParameterList); - if (!pParams) return TSDB_CODE_OUT_OF_MEMORY; - int32_t code = createFunction(funcMgtBuiltins[pFunc->funcId].pMergeFunc, pParams, pStateMergeFunc); + SNodeList* pParams = NULL; + int32_t code = nodesCloneList(pFunc->pParameterList, &pParams); + if (!pParams) return code; + code = createFunction(funcMgtBuiltins[pFunc->funcId].pMergeFunc, pParams, pStateMergeFunc); if (TSDB_CODE_SUCCESS != code) { nodesDestroyList(pParams); return code; diff --git a/source/libs/nodes/src/nodesCloneFuncs.c b/source/libs/nodes/src/nodesCloneFuncs.c index f02fefd977..2b2c260138 100644 --- a/source/libs/nodes/src/nodesCloneFuncs.c +++ b/source/libs/nodes/src/nodesCloneFuncs.c @@ -47,37 +47,37 @@ } \ } while (0) -#define CLONE_NODE_FIELD(fldname) \ - do { \ - if (NULL == (pSrc)->fldname) { \ - break; \ - } \ - (pDst)->fldname = nodesCloneNode((pSrc)->fldname); \ - if (NULL == (pDst)->fldname) { \ - return TSDB_CODE_OUT_OF_MEMORY; \ - } \ +#define CLONE_NODE_FIELD(fldname) \ + do { \ + if (NULL == (pSrc)->fldname) { \ + break; \ + } \ + int32_t code = nodesCloneNode((pSrc)->fldname, &((pDst)->fldname)); \ + if (NULL == (pDst)->fldname) { \ + return code; \ + } \ } while (0) -#define CLONE_NODE_FIELD_EX(fldname, nodePtrType) \ - do { \ - if (NULL == (pSrc)->fldname) { \ - break; \ - } \ - (pDst)->fldname = (nodePtrType)nodesCloneNode((SNode*)(pSrc)->fldname); \ - if (NULL == (pDst)->fldname) { \ - return TSDB_CODE_OUT_OF_MEMORY; \ - } \ +#define CLONE_NODE_FIELD_EX(fldname, nodePtrType) \ + do { \ + if (NULL == (pSrc)->fldname) { \ + break; \ + } \ + int32_t code = nodesCloneNode((SNode*)(pSrc)->fldname, (SNode**)&((pDst)->fldname)); \ + if (NULL == (pDst)->fldname) { \ + return code; \ + } \ } while (0) -#define CLONE_NODE_LIST_FIELD(fldname) \ - do { \ - if (NULL == (pSrc)->fldname) { \ - break; \ - } \ - (pDst)->fldname = nodesCloneList((pSrc)->fldname); \ - if (NULL == (pDst)->fldname) { \ - return TSDB_CODE_OUT_OF_MEMORY; \ - } \ +#define CLONE_NODE_LIST_FIELD(fldname) \ + do { \ + if (NULL == (pSrc)->fldname) { \ + break; \ + } \ + int32_t code = nodesCloneList((pSrc)->fldname, &((pDst)->fldname)); \ + if (NULL == (pDst)->fldname) { \ + return code; \ + } \ } while (0) #define CLONE_OBJECT_FIELD(fldname, cloneFunc) \ @@ -869,18 +869,17 @@ static int32_t setOperatorCopy(const SSetOperator* pSrc, SSetOperator* pDst) { return TSDB_CODE_SUCCESS; } -SNode* nodesCloneNode(const SNode* pNode) { +int32_t nodesCloneNode(const SNode* pNode, SNode** ppNode) { if (NULL == pNode) { - return NULL; + return TSDB_CODE_SUCCESS; } - SNode* pDst = nodesMakeNode(nodeType(pNode)); - if (NULL == pDst) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return NULL; + SNode* pDst = NULL; + int32_t code = nodesMakeNode(nodeType(pNode), &pDst); + if (TSDB_CODE_SUCCESS != code) { + return code; } - int32_t code = TSDB_CODE_SUCCESS; switch (nodeType(pNode)) { case QUERY_NODE_COLUMN: code = columnNodeCopy((const SColumnNode*)pNode, (SColumnNode*)pDst); @@ -1058,25 +1057,31 @@ SNode* nodesCloneNode(const SNode* pNode) { terrno = TSDB_CODE_OUT_OF_MEMORY; nodesDestroyNode(pDst); nodesError("nodesCloneNode failed node = %s", nodesNodeName(nodeType(pNode))); - return NULL; + return code; } - return pDst; + *ppNode = pDst; + return code; } -SNodeList* nodesCloneList(const SNodeList* pList) { +int32_t nodesCloneList(const SNodeList* pList, SNodeList** ppList) { if (NULL == pList) { - return NULL; + return TSDB_CODE_SUCCESS; } SNodeList* pDst = NULL; SNode* pNode; FOREACH(pNode, pList) { - int32_t code = nodesListMakeStrictAppend(&pDst, nodesCloneNode(pNode)); + SNode* pNew = NULL; + int32_t code = nodesCloneNode(pNode, &pNew); if (TSDB_CODE_SUCCESS != code) { - terrno = TSDB_CODE_OUT_OF_MEMORY; nodesDestroyList(pDst); - return NULL; + return code; + } + code = nodesListMakeStrictAppend(&pDst, pNew); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyList(pDst); + return code; } } - return pDst; + return TSDB_CODE_SUCCESS; } diff --git a/source/libs/nodes/src/nodesCodeFuncs.c b/source/libs/nodes/src/nodesCodeFuncs.c index d5b36aa1a8..92a3540590 100644 --- a/source/libs/nodes/src/nodesCodeFuncs.c +++ b/source/libs/nodes/src/nodesCodeFuncs.c @@ -456,9 +456,9 @@ static int32_t nodeListToJson(SJson* pJson, const char* pName, const SNodeList* static int32_t jsonToNodeListImpl(const SJson* pJsonArray, SNodeList** pList) { int32_t size = (NULL == pJsonArray ? 0 : tjsonGetArraySize(pJsonArray)); if (size > 0) { - *pList = nodesMakeList(); + int32_t code = nodesMakeList(pList); if (NULL == *pList) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } } @@ -8212,9 +8212,9 @@ static int32_t makeNodeByJson(const SJson* pJson, SNode** pNode) { int32_t val = 0; int32_t code = tjsonGetIntValue(pJson, jkNodeType, &val); if (TSDB_CODE_SUCCESS == code) { - *pNode = nodesMakeNode(val); + code = nodesMakeNode(val, pNode); if (NULL == *pNode) { - return TSDB_CODE_FAILED; + return code; } code = jsonToNode(pJson, *pNode); } diff --git a/source/libs/nodes/src/nodesMsgFuncs.c b/source/libs/nodes/src/nodesMsgFuncs.c index 54cf685235..2d3f2b1f3a 100644 --- a/source/libs/nodes/src/nodesMsgFuncs.c +++ b/source/libs/nodes/src/nodesMsgFuncs.c @@ -60,7 +60,7 @@ typedef struct STlvDecoder { typedef int32_t (*FToMsg)(const void* pObj, STlvEncoder* pEncoder); typedef int32_t (*FToObject)(STlvDecoder* pDecoder, void* pObj); -typedef void* (*FMakeObject)(int16_t type); +typedef int32_t (*FMakeObject)(int16_t type, SNode** ppNode); typedef int32_t (*FSetObject)(STlv* pTlv, void* pObj); static int32_t nodeToMsg(const void* pObj, STlvEncoder* pEncoder); @@ -568,9 +568,9 @@ static int32_t tlvDecodeObjArrayFromTlv(STlv* pTlv, FToObject func, void* pArray } static int32_t tlvDecodeDynObjFromTlv(STlv* pTlv, FMakeObject makeFunc, FToObject toFunc, void** pObj) { - *pObj = makeFunc(pTlv->type); + int32_t code = makeFunc(pTlv->type, (SNode**)pObj); if (NULL == *pObj) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } return tlvDecodeObjFromTlv(pTlv, toFunc, *pObj); } @@ -4786,9 +4786,10 @@ static int32_t SArrayToMsg(const void* pObj, STlvEncoder* pEncoder) { static int32_t msgToNodeList(STlvDecoder* pDecoder, void** pObj) { - SNodeList* pList = nodesMakeList(); - + SNodeList* pList = NULL; int32_t code = TSDB_CODE_SUCCESS; + code = nodesMakeList(&pList); + while (TSDB_CODE_SUCCESS == code && !tlvDecodeEnd(pDecoder)) { SNode* pNode = NULL; code = msgToNode(pDecoder, (void**)&pNode); diff --git a/source/libs/nodes/src/nodesUtilFuncs.c b/source/libs/nodes/src/nodesUtilFuncs.c index c306cf2c7a..a6db870573 100644 --- a/source/libs/nodes/src/nodesUtilFuncs.c +++ b/source/libs/nodes/src/nodesUtilFuncs.c @@ -94,28 +94,32 @@ int32_t mergeJoinConds(SNode** ppDst, SNode** ppSrc) { } } - SLogicConditionNode* pLogicCond = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); - if (NULL == pLogicCond) { - return TSDB_CODE_OUT_OF_MEMORY; + SLogicConditionNode* pLogicCond = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogicCond); + if (TSDB_CODE_SUCCESS != code) { + return code; } pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL; pLogicCond->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes; pLogicCond->condType = LOGIC_COND_TYPE_AND; - pLogicCond->pParameterList = nodesMakeList(); - nodesListStrictAppend(pLogicCond->pParameterList, *ppSrc); - nodesListStrictAppend(pLogicCond->pParameterList, *ppDst); - - *ppDst = (SNode*)pLogicCond; - *ppSrc = NULL; - - return TSDB_CODE_SUCCESS; + pLogicCond->pParameterList = NULL; + code = nodesListMakeStrictAppend(&pLogicCond->pParameterList, *ppSrc); + if (TSDB_CODE_SUCCESS == code) { + *ppSrc = NULL; + code = nodesListMakeStrictAppend(&pLogicCond->pParameterList, *ppDst); + } + if (TSDB_CODE_SUCCESS == code) { + *ppDst = (SNode*)pLogicCond; + } + return code; } -static SNodeMemChunk* callocNodeChunk(SNodeAllocator* pAllocator) { +static int32_t callocNodeChunk(SNodeAllocator* pAllocator, SNodeMemChunk** pOutChunk) { SNodeMemChunk* pNewChunk = taosMemoryCalloc(1, sizeof(SNodeMemChunk) + pAllocator->chunkSize); if (NULL == pNewChunk) { - return NULL; + if (pOutChunk) *pOutChunk = NULL; + return TSDB_CODE_OUT_OF_MEMORY; } pNewChunk->pBuf = (char*)(pNewChunk + 1); pNewChunk->availableSize = pAllocator->chunkSize; @@ -129,31 +133,39 @@ static SNodeMemChunk* callocNodeChunk(SNodeAllocator* pAllocator) { pAllocator->pChunks = pNewChunk; } ++(pAllocator->chunkNum); - return pNewChunk; + if (pOutChunk) *pOutChunk = pNewChunk; + return TSDB_CODE_SUCCESS; } -static void* nodesCallocImpl(int32_t size) { +static int32_t nodesCallocImpl(int32_t size, void** pOut) { if (NULL == g_pNodeAllocator) { - return taosMemoryCalloc(1, size); + *pOut = taosMemoryCalloc(1, size); + if (!pOut) return TSDB_CODE_OUT_OF_MEMORY; + return TSDB_CODE_SUCCESS; } if (g_pNodeAllocator->pCurrChunk->usedSize + size > g_pNodeAllocator->pCurrChunk->availableSize) { - if (NULL == callocNodeChunk(g_pNodeAllocator)) { - return NULL; + int32_t code = callocNodeChunk(g_pNodeAllocator, NULL); + if (TSDB_CODE_SUCCESS != code) { + *pOut = NULL; + return code; } } void* p = g_pNodeAllocator->pCurrChunk->pBuf + g_pNodeAllocator->pCurrChunk->usedSize; g_pNodeAllocator->pCurrChunk->usedSize += size; - return p; + *pOut = p; + return TSDB_CODE_SUCCESS;; } -static void* nodesCalloc(int32_t num, int32_t size) { - void* p = nodesCallocImpl(num * size + 1); - if (NULL == p) { - return NULL; +static int32_t nodesCalloc(int32_t num, int32_t size, void** pOut) { + void* p = NULL; + int32_t code = nodesCallocImpl(num * size + 1, &p); + if (TSDB_CODE_SUCCESS != code) { + return code; } *(char*)p = (NULL != g_pNodeAllocator) ? 1 : 0; - return (char*)p + 1; + *pOut = (char*)p + 1; + return TSDB_CODE_SUCCESS; } void nodesFree(void* p) { @@ -170,9 +182,10 @@ static int32_t createNodeAllocator(int32_t chunkSize, SNodeAllocator** pAllocato return TSDB_CODE_OUT_OF_MEMORY; } (*pAllocator)->chunkSize = chunkSize; - if (NULL == callocNodeChunk(*pAllocator)) { + int32_t code = callocNodeChunk(*pAllocator, NULL); + if (TSDB_CODE_SUCCESS != code) { taosMemoryFreeClear(*pAllocator); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } taosThreadMutexInit(&(*pAllocator)->mutex, NULL); return TSDB_CODE_SUCCESS; @@ -315,202 +328,205 @@ void nodesDestroyAllocator(int64_t allocatorId) { taosRemoveRef(g_allocatorReqRefPool, allocatorId); } -static SNode* makeNode(ENodeType type, int32_t size) { - SNode* p = nodesCalloc(1, size); - if (NULL == p) { - return NULL; +static int32_t makeNode(ENodeType type, int32_t size, SNode** ppNode) { + SNode* p = NULL; + int32_t code = nodesCalloc(1, size, (void**)&p); + if (TSDB_CODE_SUCCESS == code) { + setNodeType(p, type); + *ppNode = p; } - setNodeType(p, type); - return p; + return code; } -SNode* nodesMakeNode(ENodeType type) { +int32_t nodesMakeNode(ENodeType type, SNode** ppNodeOut) { + SNode* pNode = NULL; + int32_t code = 0; switch (type) { case QUERY_NODE_COLUMN: - return makeNode(type, sizeof(SColumnNode)); + code = makeNode(type, sizeof(SColumnNode), &pNode); break; case QUERY_NODE_VALUE: - return makeNode(type, sizeof(SValueNode)); + code = makeNode(type, sizeof(SValueNode), &pNode); break; case QUERY_NODE_OPERATOR: - return makeNode(type, sizeof(SOperatorNode)); + code = makeNode(type, sizeof(SOperatorNode), &pNode); break; case QUERY_NODE_LOGIC_CONDITION: - return makeNode(type, sizeof(SLogicConditionNode)); + code = makeNode(type, sizeof(SLogicConditionNode), &pNode); break; case QUERY_NODE_FUNCTION: - return makeNode(type, sizeof(SFunctionNode)); + code = makeNode(type, sizeof(SFunctionNode), &pNode); break; case QUERY_NODE_REAL_TABLE: - return makeNode(type, sizeof(SRealTableNode)); + code = makeNode(type, sizeof(SRealTableNode), &pNode); break; case QUERY_NODE_TEMP_TABLE: - return makeNode(type, sizeof(STempTableNode)); + code = makeNode(type, sizeof(STempTableNode), &pNode); break; case QUERY_NODE_JOIN_TABLE: - return makeNode(type, sizeof(SJoinTableNode)); + code = makeNode(type, sizeof(SJoinTableNode), &pNode); break; case QUERY_NODE_GROUPING_SET: - return makeNode(type, sizeof(SGroupingSetNode)); + code = makeNode(type, sizeof(SGroupingSetNode), &pNode); break; case QUERY_NODE_ORDER_BY_EXPR: - return makeNode(type, sizeof(SOrderByExprNode)); + code = makeNode(type, sizeof(SOrderByExprNode), &pNode); break; case QUERY_NODE_LIMIT: - return makeNode(type, sizeof(SLimitNode)); + code = makeNode(type, sizeof(SLimitNode), &pNode); break; case QUERY_NODE_STATE_WINDOW: - return makeNode(type, sizeof(SStateWindowNode)); + code = makeNode(type, sizeof(SStateWindowNode), &pNode); break; case QUERY_NODE_SESSION_WINDOW: - return makeNode(type, sizeof(SSessionWindowNode)); + code = makeNode(type, sizeof(SSessionWindowNode), &pNode); break; case QUERY_NODE_INTERVAL_WINDOW: - return makeNode(type, sizeof(SIntervalWindowNode)); + code = makeNode(type, sizeof(SIntervalWindowNode), &pNode); break; case QUERY_NODE_NODE_LIST: - return makeNode(type, sizeof(SNodeListNode)); + code = makeNode(type, sizeof(SNodeListNode), &pNode); break; case QUERY_NODE_FILL: - return makeNode(type, sizeof(SFillNode)); + code = makeNode(type, sizeof(SFillNode), &pNode); break; case QUERY_NODE_RAW_EXPR: - return makeNode(type, sizeof(SRawExprNode)); + code = makeNode(type, sizeof(SRawExprNode), &pNode); break; case QUERY_NODE_TARGET: - return makeNode(type, sizeof(STargetNode)); + code = makeNode(type, sizeof(STargetNode), &pNode); break; case QUERY_NODE_DATABLOCK_DESC: - return makeNode(type, sizeof(SDataBlockDescNode)); + code = makeNode(type, sizeof(SDataBlockDescNode), &pNode); break; case QUERY_NODE_SLOT_DESC: - return makeNode(type, sizeof(SSlotDescNode)); + code = makeNode(type, sizeof(SSlotDescNode), &pNode); break; case QUERY_NODE_COLUMN_DEF: - return makeNode(type, sizeof(SColumnDefNode)); + code = makeNode(type, sizeof(SColumnDefNode), &pNode); break; case QUERY_NODE_DOWNSTREAM_SOURCE: - return makeNode(type, sizeof(SDownstreamSourceNode)); + code = makeNode(type, sizeof(SDownstreamSourceNode), &pNode); break; case QUERY_NODE_DATABASE_OPTIONS: - return makeNode(type, sizeof(SDatabaseOptions)); + code = makeNode(type, sizeof(SDatabaseOptions), &pNode); break; case QUERY_NODE_TABLE_OPTIONS: - return makeNode(type, sizeof(STableOptions)); + code = makeNode(type, sizeof(STableOptions), &pNode); break; case QUERY_NODE_COLUMN_OPTIONS: - return makeNode(type, sizeof(SColumnOptions)); + code = makeNode(type, sizeof(SColumnOptions), &pNode); break; case QUERY_NODE_INDEX_OPTIONS: - return makeNode(type, sizeof(SIndexOptions)); + code = makeNode(type, sizeof(SIndexOptions), &pNode); break; case QUERY_NODE_EXPLAIN_OPTIONS: - return makeNode(type, sizeof(SExplainOptions)); + code = makeNode(type, sizeof(SExplainOptions), &pNode); break; case QUERY_NODE_STREAM_OPTIONS: - return makeNode(type, sizeof(SStreamOptions)); + code = makeNode(type, sizeof(SStreamOptions), &pNode); break; case QUERY_NODE_LEFT_VALUE: - return makeNode(type, sizeof(SLeftValueNode)); + code = makeNode(type, sizeof(SLeftValueNode), &pNode); break; case QUERY_NODE_COLUMN_REF: - return makeNode(type, sizeof(SColumnRefNode)); + code = makeNode(type, sizeof(SColumnRefNode), &pNode); break; case QUERY_NODE_WHEN_THEN: - return makeNode(type, sizeof(SWhenThenNode)); + code = makeNode(type, sizeof(SWhenThenNode), &pNode); break; case QUERY_NODE_CASE_WHEN: - return makeNode(type, sizeof(SCaseWhenNode)); + code = makeNode(type, sizeof(SCaseWhenNode), &pNode); break; case QUERY_NODE_EVENT_WINDOW: - return makeNode(type, sizeof(SEventWindowNode)); + code = makeNode(type, sizeof(SEventWindowNode), &pNode); break; case QUERY_NODE_COUNT_WINDOW: - return makeNode(type, sizeof(SCountWindowNode)); + code = makeNode(type, sizeof(SCountWindowNode), &pNode); break; case QUERY_NODE_HINT: - return makeNode(type, sizeof(SHintNode)); + code = makeNode(type, sizeof(SHintNode), &pNode); break; case QUERY_NODE_VIEW: - return makeNode(type, sizeof(SViewNode)); + code = makeNode(type, sizeof(SViewNode), &pNode); break; case QUERY_NODE_WINDOW_OFFSET: - return makeNode(type, sizeof(SWindowOffsetNode)); + code = makeNode(type, sizeof(SWindowOffsetNode), &pNode); break; case QUERY_NODE_SET_OPERATOR: - return makeNode(type, sizeof(SSetOperator)); + code = makeNode(type, sizeof(SSetOperator), &pNode); break; case QUERY_NODE_SELECT_STMT: - return makeNode(type, sizeof(SSelectStmt)); + code = makeNode(type, sizeof(SSelectStmt), &pNode); break; case QUERY_NODE_VNODE_MODIFY_STMT: - return makeNode(type, sizeof(SVnodeModifyOpStmt)); + code = makeNode(type, sizeof(SVnodeModifyOpStmt), &pNode); break; case QUERY_NODE_CREATE_DATABASE_STMT: - return makeNode(type, sizeof(SCreateDatabaseStmt)); + code = makeNode(type, sizeof(SCreateDatabaseStmt), &pNode); break; case QUERY_NODE_DROP_DATABASE_STMT: - return makeNode(type, sizeof(SDropDatabaseStmt)); + code = makeNode(type, sizeof(SDropDatabaseStmt), &pNode); break; case QUERY_NODE_ALTER_DATABASE_STMT: - return makeNode(type, sizeof(SAlterDatabaseStmt)); + code = makeNode(type, sizeof(SAlterDatabaseStmt), &pNode); break; case QUERY_NODE_FLUSH_DATABASE_STMT: - return makeNode(type, sizeof(SFlushDatabaseStmt)); + code = makeNode(type, sizeof(SFlushDatabaseStmt), &pNode); break; case QUERY_NODE_TRIM_DATABASE_STMT: - return makeNode(type, sizeof(STrimDatabaseStmt)); + code = makeNode(type, sizeof(STrimDatabaseStmt), &pNode); break; case QUERY_NODE_S3MIGRATE_DATABASE_STMT: - return makeNode(type, sizeof(SS3MigrateDatabaseStmt)); + code = makeNode(type, sizeof(SS3MigrateDatabaseStmt), &pNode); break; case QUERY_NODE_CREATE_TABLE_STMT: - return makeNode(type, sizeof(SCreateTableStmt)); + code = makeNode(type, sizeof(SCreateTableStmt), &pNode); break; case QUERY_NODE_CREATE_SUBTABLE_CLAUSE: - return makeNode(type, sizeof(SCreateSubTableClause)); + code = makeNode(type, sizeof(SCreateSubTableClause), &pNode); break; case QUERY_NODE_CREATE_SUBTABLE_FROM_FILE_CLAUSE: - return makeNode(type, sizeof(SCreateSubTableFromFileClause)); + code = makeNode(type, sizeof(SCreateSubTableFromFileClause), &pNode); break; case QUERY_NODE_CREATE_MULTI_TABLES_STMT: - return makeNode(type, sizeof(SCreateMultiTablesStmt)); + code = makeNode(type, sizeof(SCreateMultiTablesStmt), &pNode); break; case QUERY_NODE_DROP_TABLE_CLAUSE: - return makeNode(type, sizeof(SDropTableClause)); + code = makeNode(type, sizeof(SDropTableClause), &pNode); break; case QUERY_NODE_DROP_TABLE_STMT: - return makeNode(type, sizeof(SDropTableStmt)); + code = makeNode(type, sizeof(SDropTableStmt), &pNode); break; case QUERY_NODE_DROP_SUPER_TABLE_STMT: - return makeNode(type, sizeof(SDropSuperTableStmt)); + code = makeNode(type, sizeof(SDropSuperTableStmt), &pNode); break; case QUERY_NODE_ALTER_TABLE_STMT: case QUERY_NODE_ALTER_SUPER_TABLE_STMT: - return makeNode(type, sizeof(SAlterTableStmt)); + code = makeNode(type, sizeof(SAlterTableStmt), &pNode); break; case QUERY_NODE_CREATE_USER_STMT: - return makeNode(type, sizeof(SCreateUserStmt)); + code = makeNode(type, sizeof(SCreateUserStmt), &pNode); break; case QUERY_NODE_ALTER_USER_STMT: - return makeNode(type, sizeof(SAlterUserStmt)); + code = makeNode(type, sizeof(SAlterUserStmt), &pNode); break; case QUERY_NODE_DROP_USER_STMT: - return makeNode(type, sizeof(SDropUserStmt)); + code = makeNode(type, sizeof(SDropUserStmt), &pNode); break; case QUERY_NODE_USE_DATABASE_STMT: - return makeNode(type, sizeof(SUseDatabaseStmt)); + code = makeNode(type, sizeof(SUseDatabaseStmt), &pNode); break; case QUERY_NODE_CREATE_DNODE_STMT: - return makeNode(type, sizeof(SCreateDnodeStmt)); + code = makeNode(type, sizeof(SCreateDnodeStmt), &pNode); break; case QUERY_NODE_DROP_DNODE_STMT: - return makeNode(type, sizeof(SDropDnodeStmt)); + code = makeNode(type, sizeof(SDropDnodeStmt), &pNode); break; case QUERY_NODE_ALTER_DNODE_STMT: - return makeNode(type, sizeof(SAlterDnodeStmt)); + code = makeNode(type, sizeof(SAlterDnodeStmt), &pNode); break; case QUERY_NODE_CREATE_INDEX_STMT: - return makeNode(type, sizeof(SCreateIndexStmt)); + code = makeNode(type, sizeof(SCreateIndexStmt), &pNode); break; case QUERY_NODE_DROP_INDEX_STMT: - return makeNode(type, sizeof(SDropIndexStmt)); + code = makeNode(type, sizeof(SDropIndexStmt), &pNode); break; case QUERY_NODE_CREATE_QNODE_STMT: case QUERY_NODE_CREATE_BNODE_STMT: case QUERY_NODE_CREATE_SNODE_STMT: case QUERY_NODE_CREATE_MNODE_STMT: - return makeNode(type, sizeof(SCreateComponentNodeStmt)); + code = makeNode(type, sizeof(SCreateComponentNodeStmt), &pNode); break; case QUERY_NODE_DROP_QNODE_STMT: case QUERY_NODE_DROP_BNODE_STMT: case QUERY_NODE_DROP_SNODE_STMT: case QUERY_NODE_DROP_MNODE_STMT: - return makeNode(type, sizeof(SDropComponentNodeStmt)); + code = makeNode(type, sizeof(SDropComponentNodeStmt), &pNode); break; case QUERY_NODE_CREATE_TOPIC_STMT: - return makeNode(type, sizeof(SCreateTopicStmt)); + code = makeNode(type, sizeof(SCreateTopicStmt), &pNode); break; case QUERY_NODE_DROP_TOPIC_STMT: - return makeNode(type, sizeof(SDropTopicStmt)); + code = makeNode(type, sizeof(SDropTopicStmt), &pNode); break; case QUERY_NODE_DROP_CGROUP_STMT: - return makeNode(type, sizeof(SDropCGroupStmt)); + code = makeNode(type, sizeof(SDropCGroupStmt), &pNode); break; case QUERY_NODE_ALTER_LOCAL_STMT: - return makeNode(type, sizeof(SAlterLocalStmt)); + code = makeNode(type, sizeof(SAlterLocalStmt), &pNode); break; case QUERY_NODE_EXPLAIN_STMT: - return makeNode(type, sizeof(SExplainStmt)); + code = makeNode(type, sizeof(SExplainStmt), &pNode); break; case QUERY_NODE_DESCRIBE_STMT: - return makeNode(type, sizeof(SDescribeStmt)); + code = makeNode(type, sizeof(SDescribeStmt), &pNode); break; case QUERY_NODE_RESET_QUERY_CACHE_STMT: - return makeNode(type, sizeof(SNode)); + code = makeNode(type, sizeof(SNode), &pNode); break; case QUERY_NODE_COMPACT_DATABASE_STMT: - return makeNode(type, sizeof(SCompactDatabaseStmt)); + code = makeNode(type, sizeof(SCompactDatabaseStmt), &pNode); break; case QUERY_NODE_CREATE_FUNCTION_STMT: - return makeNode(type, sizeof(SCreateFunctionStmt)); + code = makeNode(type, sizeof(SCreateFunctionStmt), &pNode); break; case QUERY_NODE_DROP_FUNCTION_STMT: - return makeNode(type, sizeof(SDropFunctionStmt)); + code = makeNode(type, sizeof(SDropFunctionStmt), &pNode); break; case QUERY_NODE_CREATE_STREAM_STMT: - return makeNode(type, sizeof(SCreateStreamStmt)); + code = makeNode(type, sizeof(SCreateStreamStmt), &pNode); break; case QUERY_NODE_DROP_STREAM_STMT: - return makeNode(type, sizeof(SDropStreamStmt)); + code = makeNode(type, sizeof(SDropStreamStmt), &pNode); break; case QUERY_NODE_PAUSE_STREAM_STMT: - return makeNode(type, sizeof(SPauseStreamStmt)); + code = makeNode(type, sizeof(SPauseStreamStmt), &pNode); break; case QUERY_NODE_RESUME_STREAM_STMT: - return makeNode(type, sizeof(SResumeStreamStmt)); + code = makeNode(type, sizeof(SResumeStreamStmt), &pNode); break; case QUERY_NODE_BALANCE_VGROUP_STMT: - return makeNode(type, sizeof(SBalanceVgroupStmt)); + code = makeNode(type, sizeof(SBalanceVgroupStmt), &pNode); break; case QUERY_NODE_BALANCE_VGROUP_LEADER_STMT: - return makeNode(type, sizeof(SBalanceVgroupLeaderStmt)); + code = makeNode(type, sizeof(SBalanceVgroupLeaderStmt), &pNode); break; case QUERY_NODE_BALANCE_VGROUP_LEADER_DATABASE_STMT: - return makeNode(type, sizeof(SBalanceVgroupLeaderStmt)); + code = makeNode(type, sizeof(SBalanceVgroupLeaderStmt), &pNode); break; case QUERY_NODE_MERGE_VGROUP_STMT: - return makeNode(type, sizeof(SMergeVgroupStmt)); + code = makeNode(type, sizeof(SMergeVgroupStmt), &pNode); break; case QUERY_NODE_REDISTRIBUTE_VGROUP_STMT: - return makeNode(type, sizeof(SRedistributeVgroupStmt)); + code = makeNode(type, sizeof(SRedistributeVgroupStmt), &pNode); break; case QUERY_NODE_SPLIT_VGROUP_STMT: - return makeNode(type, sizeof(SSplitVgroupStmt)); + code = makeNode(type, sizeof(SSplitVgroupStmt), &pNode); break; case QUERY_NODE_SYNCDB_STMT: break; case QUERY_NODE_GRANT_STMT: - return makeNode(type, sizeof(SGrantStmt)); + code = makeNode(type, sizeof(SGrantStmt), &pNode); break; case QUERY_NODE_REVOKE_STMT: - return makeNode(type, sizeof(SRevokeStmt)); + code = makeNode(type, sizeof(SRevokeStmt), &pNode); break; case QUERY_NODE_ALTER_CLUSTER_STMT: - return makeNode(type, sizeof(SAlterClusterStmt)); + code = makeNode(type, sizeof(SAlterClusterStmt), &pNode); break; case QUERY_NODE_SHOW_DNODES_STMT: case QUERY_NODE_SHOW_MNODES_STMT: case QUERY_NODE_SHOW_MODULES_STMT: @@ -548,186 +564,189 @@ SNode* nodesMakeNode(ENodeType type) { case QUERY_NODE_SHOW_CLUSTER_MACHINES_STMT: case QUERY_NODE_SHOW_ENCRYPTIONS_STMT: case QUERY_NODE_SHOW_TSMAS_STMT: - return makeNode(type, sizeof(SShowStmt)); + code = makeNode(type, sizeof(SShowStmt), &pNode); break; case QUERY_NODE_SHOW_TABLE_TAGS_STMT: - return makeNode(type, sizeof(SShowTableTagsStmt)); + code = makeNode(type, sizeof(SShowTableTagsStmt), &pNode); break; case QUERY_NODE_SHOW_DNODE_VARIABLES_STMT: - return makeNode(type, sizeof(SShowDnodeVariablesStmt)); + code = makeNode(type, sizeof(SShowDnodeVariablesStmt), &pNode); break; case QUERY_NODE_SHOW_CREATE_DATABASE_STMT: - return makeNode(type, sizeof(SShowCreateDatabaseStmt)); + code = makeNode(type, sizeof(SShowCreateDatabaseStmt), &pNode); break; case QUERY_NODE_SHOW_DB_ALIVE_STMT: case QUERY_NODE_SHOW_CLUSTER_ALIVE_STMT: - return makeNode(type, sizeof(SShowAliveStmt)); + code = makeNode(type, sizeof(SShowAliveStmt), &pNode); break; case QUERY_NODE_SHOW_CREATE_TABLE_STMT: case QUERY_NODE_SHOW_CREATE_STABLE_STMT: - return makeNode(type, sizeof(SShowCreateTableStmt)); + code = makeNode(type, sizeof(SShowCreateTableStmt), &pNode); break; case QUERY_NODE_SHOW_CREATE_VIEW_STMT: - return makeNode(type, sizeof(SShowCreateViewStmt)); + code = makeNode(type, sizeof(SShowCreateViewStmt), &pNode); break; case QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT: - return makeNode(type, sizeof(SShowTableDistributedStmt)); + code = makeNode(type, sizeof(SShowTableDistributedStmt), &pNode); break; case QUERY_NODE_SHOW_COMPACTS_STMT: - return makeNode(type, sizeof(SShowCompactsStmt)); + code = makeNode(type, sizeof(SShowCompactsStmt), &pNode); break; case QUERY_NODE_SHOW_COMPACT_DETAILS_STMT: - return makeNode(type, sizeof(SShowCompactDetailsStmt)); + code = makeNode(type, sizeof(SShowCompactDetailsStmt), &pNode); break; case QUERY_NODE_KILL_QUERY_STMT: - return makeNode(type, sizeof(SKillQueryStmt)); + code = makeNode(type, sizeof(SKillQueryStmt), &pNode); break; case QUERY_NODE_KILL_TRANSACTION_STMT: case QUERY_NODE_KILL_CONNECTION_STMT: case QUERY_NODE_KILL_COMPACT_STMT: - return makeNode(type, sizeof(SKillStmt)); + code = makeNode(type, sizeof(SKillStmt), &pNode); break; case QUERY_NODE_DELETE_STMT: - return makeNode(type, sizeof(SDeleteStmt)); + code = makeNode(type, sizeof(SDeleteStmt), &pNode); break; case QUERY_NODE_INSERT_STMT: - return makeNode(type, sizeof(SInsertStmt)); + code = makeNode(type, sizeof(SInsertStmt), &pNode); break; case QUERY_NODE_QUERY: - return makeNode(type, sizeof(SQuery)); + code = makeNode(type, sizeof(SQuery), &pNode); break; case QUERY_NODE_RESTORE_DNODE_STMT: case QUERY_NODE_RESTORE_QNODE_STMT: case QUERY_NODE_RESTORE_MNODE_STMT: case QUERY_NODE_RESTORE_VNODE_STMT: - return makeNode(type, sizeof(SRestoreComponentNodeStmt)); + code = makeNode(type, sizeof(SRestoreComponentNodeStmt), &pNode); break; case QUERY_NODE_CREATE_VIEW_STMT: - return makeNode(type, sizeof(SCreateViewStmt)); + code = makeNode(type, sizeof(SCreateViewStmt), &pNode); break; case QUERY_NODE_DROP_VIEW_STMT: - return makeNode(type, sizeof(SDropViewStmt)); + code = makeNode(type, sizeof(SDropViewStmt), &pNode); break; case QUERY_NODE_CREATE_TSMA_STMT: - return makeNode(type, sizeof(SCreateTSMAStmt)); + code = makeNode(type, sizeof(SCreateTSMAStmt), &pNode); break; case QUERY_NODE_DROP_TSMA_STMT: - return makeNode(type, sizeof(SDropTSMAStmt)); + code = makeNode(type, sizeof(SDropTSMAStmt), &pNode); break; case QUERY_NODE_TSMA_OPTIONS: - return makeNode(type, sizeof(STSMAOptions)); + code = makeNode(type, sizeof(STSMAOptions), &pNode); break; case QUERY_NODE_LOGIC_PLAN_SCAN: - return makeNode(type, sizeof(SScanLogicNode)); + code = makeNode(type, sizeof(SScanLogicNode), &pNode); break; case QUERY_NODE_LOGIC_PLAN_JOIN: - return makeNode(type, sizeof(SJoinLogicNode)); + code = makeNode(type, sizeof(SJoinLogicNode), &pNode); break; case QUERY_NODE_LOGIC_PLAN_AGG: - return makeNode(type, sizeof(SAggLogicNode)); + code = makeNode(type, sizeof(SAggLogicNode), &pNode); break; case QUERY_NODE_LOGIC_PLAN_PROJECT: - return makeNode(type, sizeof(SProjectLogicNode)); + code = makeNode(type, sizeof(SProjectLogicNode), &pNode); break; case QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY: - return makeNode(type, sizeof(SVnodeModifyLogicNode)); + code = makeNode(type, sizeof(SVnodeModifyLogicNode), &pNode); break; case QUERY_NODE_LOGIC_PLAN_EXCHANGE: - return makeNode(type, sizeof(SExchangeLogicNode)); + code = makeNode(type, sizeof(SExchangeLogicNode), &pNode); break; case QUERY_NODE_LOGIC_PLAN_MERGE: - return makeNode(type, sizeof(SMergeLogicNode)); + code = makeNode(type, sizeof(SMergeLogicNode), &pNode); break; case QUERY_NODE_LOGIC_PLAN_WINDOW: - return makeNode(type, sizeof(SWindowLogicNode)); + code = makeNode(type, sizeof(SWindowLogicNode), &pNode); break; case QUERY_NODE_LOGIC_PLAN_FILL: - return makeNode(type, sizeof(SFillLogicNode)); + code = makeNode(type, sizeof(SFillLogicNode), &pNode); break; case QUERY_NODE_LOGIC_PLAN_SORT: - return makeNode(type, sizeof(SSortLogicNode)); + code = makeNode(type, sizeof(SSortLogicNode), &pNode); break; case QUERY_NODE_LOGIC_PLAN_PARTITION: - return makeNode(type, sizeof(SPartitionLogicNode)); + code = makeNode(type, sizeof(SPartitionLogicNode), &pNode); break; case QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC: - return makeNode(type, sizeof(SIndefRowsFuncLogicNode)); + code = makeNode(type, sizeof(SIndefRowsFuncLogicNode), &pNode); break; case QUERY_NODE_LOGIC_PLAN_INTERP_FUNC: - return makeNode(type, sizeof(SInterpFuncLogicNode)); + code = makeNode(type, sizeof(SInterpFuncLogicNode), &pNode); break; case QUERY_NODE_LOGIC_PLAN_GROUP_CACHE: - return makeNode(type, sizeof(SGroupCacheLogicNode)); + code = makeNode(type, sizeof(SGroupCacheLogicNode), &pNode); break; case QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL: - return makeNode(type, sizeof(SDynQueryCtrlLogicNode)); + code = makeNode(type, sizeof(SDynQueryCtrlLogicNode), &pNode); break; case QUERY_NODE_LOGIC_SUBPLAN: - return makeNode(type, sizeof(SLogicSubplan)); + code = makeNode(type, sizeof(SLogicSubplan), &pNode); break; case QUERY_NODE_LOGIC_PLAN: - return makeNode(type, sizeof(SQueryLogicPlan)); + code = makeNode(type, sizeof(SQueryLogicPlan), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN: - return makeNode(type, sizeof(STagScanPhysiNode)); + code = makeNode(type, sizeof(STagScanPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN: - return makeNode(type, sizeof(STableScanPhysiNode)); + code = makeNode(type, sizeof(STableScanPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN: - return makeNode(type, sizeof(STableSeqScanPhysiNode)); + code = makeNode(type, sizeof(STableSeqScanPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_TABLE_MERGE_SCAN: - return makeNode(type, sizeof(STableMergeScanPhysiNode)); + code = makeNode(type, sizeof(STableMergeScanPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN: - return makeNode(type, sizeof(SStreamScanPhysiNode)); + code = makeNode(type, sizeof(SStreamScanPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN: - return makeNode(type, sizeof(SSystemTableScanPhysiNode)); + code = makeNode(type, sizeof(SSystemTableScanPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN: - return makeNode(type, sizeof(SBlockDistScanPhysiNode)); + code = makeNode(type, sizeof(SBlockDistScanPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN: - return makeNode(type, sizeof(SLastRowScanPhysiNode)); + code = makeNode(type, sizeof(SLastRowScanPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN: - return makeNode(type, sizeof(STableCountScanPhysiNode)); + code = makeNode(type, sizeof(STableCountScanPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_PROJECT: - return makeNode(type, sizeof(SProjectPhysiNode)); + code = makeNode(type, sizeof(SProjectPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN: - return makeNode(type, sizeof(SSortMergeJoinPhysiNode)); + code = makeNode(type, sizeof(SSortMergeJoinPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN: - return makeNode(type, sizeof(SHashJoinPhysiNode)); + code = makeNode(type, sizeof(SHashJoinPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_HASH_AGG: - return makeNode(type, sizeof(SAggPhysiNode)); + code = makeNode(type, sizeof(SAggPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE: - return makeNode(type, sizeof(SExchangePhysiNode)); + code = makeNode(type, sizeof(SExchangePhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_MERGE: - return makeNode(type, sizeof(SMergePhysiNode)); + code = makeNode(type, sizeof(SMergePhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_SORT: - return makeNode(type, sizeof(SSortPhysiNode)); + code = makeNode(type, sizeof(SSortPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT: - return makeNode(type, sizeof(SGroupSortPhysiNode)); + code = makeNode(type, sizeof(SGroupSortPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL: - return makeNode(type, sizeof(SIntervalPhysiNode)); + code = makeNode(type, sizeof(SIntervalPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL: - return makeNode(type, sizeof(SMergeAlignedIntervalPhysiNode)); + code = makeNode(type, sizeof(SMergeAlignedIntervalPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL: - return makeNode(type, sizeof(SStreamIntervalPhysiNode)); + code = makeNode(type, sizeof(SStreamIntervalPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL: - return makeNode(type, sizeof(SStreamFinalIntervalPhysiNode)); + code = makeNode(type, sizeof(SStreamFinalIntervalPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL: - return makeNode(type, sizeof(SStreamSemiIntervalPhysiNode)); + code = makeNode(type, sizeof(SStreamSemiIntervalPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL: - return makeNode(type, sizeof(SStreamMidIntervalPhysiNode)); + code = makeNode(type, sizeof(SStreamMidIntervalPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_FILL: case QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL: - return makeNode(type, sizeof(SFillPhysiNode)); + code = makeNode(type, sizeof(SFillPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION: - return makeNode(type, sizeof(SSessionWinodwPhysiNode)); + code = makeNode(type, sizeof(SSessionWinodwPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION: - return makeNode(type, sizeof(SStreamSessionWinodwPhysiNode)); + code = makeNode(type, sizeof(SStreamSessionWinodwPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION: - return makeNode(type, sizeof(SStreamSemiSessionWinodwPhysiNode)); + code = makeNode(type, sizeof(SStreamSemiSessionWinodwPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION: - return makeNode(type, sizeof(SStreamFinalSessionWinodwPhysiNode)); + code = makeNode(type, sizeof(SStreamFinalSessionWinodwPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE: - return makeNode(type, sizeof(SStateWinodwPhysiNode)); + code = makeNode(type, sizeof(SStateWinodwPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE: - return makeNode(type, sizeof(SStreamStateWinodwPhysiNode)); + code = makeNode(type, sizeof(SStreamStateWinodwPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT: - return makeNode(type, sizeof(SEventWinodwPhysiNode)); + code = makeNode(type, sizeof(SEventWinodwPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT: - return makeNode(type, sizeof(SStreamEventWinodwPhysiNode)); + code = makeNode(type, sizeof(SStreamEventWinodwPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT: - return makeNode(type, sizeof(SCountWinodwPhysiNode)); + code = makeNode(type, sizeof(SCountWinodwPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_COUNT: - return makeNode(type, sizeof(SStreamCountWinodwPhysiNode)); + code = makeNode(type, sizeof(SStreamCountWinodwPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_PARTITION: - return makeNode(type, sizeof(SPartitionPhysiNode)); + code = makeNode(type, sizeof(SPartitionPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION: - return makeNode(type, sizeof(SStreamPartitionPhysiNode)); + code = makeNode(type, sizeof(SStreamPartitionPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC: - return makeNode(type, sizeof(SIndefRowsFuncPhysiNode)); + code = makeNode(type, sizeof(SIndefRowsFuncPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC: - return makeNode(type, sizeof(SInterpFuncLogicNode)); + code = makeNode(type, sizeof(SInterpFuncLogicNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_DISPATCH: - return makeNode(type, sizeof(SDataDispatcherNode)); + code = makeNode(type, sizeof(SDataDispatcherNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_INSERT: - return makeNode(type, sizeof(SDataInserterNode)); + code = makeNode(type, sizeof(SDataInserterNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT: - return makeNode(type, sizeof(SQueryInserterNode)); + code = makeNode(type, sizeof(SQueryInserterNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_DELETE: - return makeNode(type, sizeof(SDataDeleterNode)); + code = makeNode(type, sizeof(SDataDeleterNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE: - return makeNode(type, sizeof(SGroupCachePhysiNode)); + code = makeNode(type, sizeof(SGroupCachePhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL: - return makeNode(type, sizeof(SDynQueryCtrlPhysiNode)); + code = makeNode(type, sizeof(SDynQueryCtrlPhysiNode), &pNode); break; case QUERY_NODE_PHYSICAL_SUBPLAN: - return makeNode(type, sizeof(SSubplan)); + code = makeNode(type, sizeof(SSubplan), &pNode); break; case QUERY_NODE_PHYSICAL_PLAN: - return makeNode(type, sizeof(SQueryPlan)); + code = makeNode(type, sizeof(SQueryPlan), &pNode); break; default: break; } - nodesError("nodesMakeNode unknown node = %s", nodesNodeName(type)); - return NULL; + if (TSDB_CODE_SUCCESS != code) + nodesError("nodesMakeNode unknown node = %s", nodesNodeName(type)); + else + *ppNodeOut = pNode; + return code; } static void destroyVgDataBlockArray(SArray* pArray) { @@ -1713,22 +1732,23 @@ void nodesDestroyNode(SNode* pNode) { return; } -SNodeList* nodesMakeList() { - SNodeList* p = nodesCalloc(1, sizeof(SNodeList)); - if (NULL == p) { - return NULL; +int32_t nodesMakeList(SNodeList** ppListOut) { + SNodeList* p = NULL; + int32_t code = nodesCalloc(1, sizeof(SNodeList), (void**)&p); + if (TSDB_CODE_SUCCESS == code) { + *ppListOut = p; } - return p; + return code; } int32_t nodesListAppend(SNodeList* pList, SNode* pNode) { if (NULL == pList || NULL == pNode) { return TSDB_CODE_FAILED; } - SListCell* p = nodesCalloc(1, sizeof(SListCell)); - if (NULL == p) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return TSDB_CODE_OUT_OF_MEMORY; + SListCell* p = NULL; + int32_t code = nodesCalloc(1, sizeof(SListCell), (void**)&p); + if (TSDB_CODE_SUCCESS != code) { + return code; } p->pNode = pNode; if (NULL == pList->pHead) { @@ -1745,8 +1765,7 @@ int32_t nodesListAppend(SNodeList* pList, SNode* pNode) { int32_t nodesListStrictAppend(SNodeList* pList, SNode* pNode) { if (NULL == pNode) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } int32_t code = nodesListAppend(pList, pNode); if (TSDB_CODE_SUCCESS != code) { @@ -1757,10 +1776,9 @@ int32_t nodesListStrictAppend(SNodeList* pList, SNode* pNode) { int32_t nodesListMakeAppend(SNodeList** pList, SNode* pNode) { if (NULL == *pList) { - *pList = nodesMakeList(); + int32_t code = nodesMakeList(pList); if (NULL == *pList) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return TSDB_CODE_OUT_OF_MEMORY; + return code; } } return nodesListAppend(*pList, pNode); @@ -1768,10 +1786,9 @@ int32_t nodesListMakeAppend(SNodeList** pList, SNode* pNode) { int32_t nodesListMakeStrictAppend(SNodeList** pList, SNode* pNode) { if (NULL == *pList) { - *pList = nodesMakeList(); + int32_t code = nodesMakeList(pList); if (NULL == *pList) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return TSDB_CODE_OUT_OF_MEMORY; + return code; } } return nodesListStrictAppend(*pList, pNode); @@ -1811,10 +1828,9 @@ int32_t nodesListStrictAppendList(SNodeList* pTarget, SNodeList* pSrc) { int32_t nodesListMakeStrictAppendList(SNodeList** pTarget, SNodeList* pSrc) { if (NULL == *pTarget) { - *pTarget = nodesMakeList(); + int32_t code = nodesMakeList(pTarget); if (NULL == *pTarget) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return TSDB_CODE_OUT_OF_MEMORY; + return code; } } return nodesListStrictAppendList(*pTarget, pSrc); @@ -1822,10 +1838,9 @@ int32_t nodesListMakeStrictAppendList(SNodeList** pTarget, SNodeList* pSrc) { int32_t nodesListMakePushFront(SNodeList** pList, SNode* pNode) { if (*pList == NULL) { - *pList = nodesMakeList(); + int32_t code = nodesMakeList(pList); if (*pList == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return TSDB_CODE_OUT_OF_MEMORY; + return code; } } return nodesListPushFront(*pList, pNode); @@ -1835,10 +1850,10 @@ int32_t nodesListPushFront(SNodeList* pList, SNode* pNode) { if (NULL == pList || NULL == pNode) { return TSDB_CODE_FAILED; } - SListCell* p = nodesCalloc(1, sizeof(SListCell)); - if (NULL == p) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return TSDB_CODE_OUT_OF_MEMORY; + SListCell* p = NULL; + int32_t code = nodesCalloc(1, sizeof(SListCell), (void**)&p); + if (TSDB_CODE_SUCCESS != code) { + return code; } p->pNode = pNode; if (NULL != pList->pHead) { @@ -2245,7 +2260,11 @@ static EDealRes doCollect(SCollectColumnsCxt* pCxt, SColumnNode* pCol, SNode* pN if (NULL == taosHashGet(pCxt->pColHash, name, len)) { pCxt->errCode = taosHashPut(pCxt->pColHash, name, len, NULL, 0); if (TSDB_CODE_SUCCESS == pCxt->errCode) { - pCxt->errCode = nodesListStrictAppend(pCxt->pCols, nodesCloneNode(pNode)); + SNode* pNew = NULL; + pCxt->errCode = nodesCloneNode(pNode, &pNew); + if (TSDB_CODE_SUCCESS == pCxt->errCode) { + pCxt->errCode = nodesListStrictAppend(pCxt->pCols, pNew); + } } return (TSDB_CODE_SUCCESS == pCxt->errCode ? DEAL_RES_IGNORE_CHILD : DEAL_RES_ERROR); } @@ -2288,12 +2307,18 @@ int32_t nodesCollectColumns(SSelectStmt* pSelect, ESqlClause clause, const char* if (NULL == pSelect || NULL == pCols) { return TSDB_CODE_FAILED; } - + SNodeList * pList = NULL; + if (!*pCols) { + int32_t code = nodesMakeList(&pList); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + } SCollectColumnsCxt cxt = { .errCode = TSDB_CODE_SUCCESS, .pTableAlias = pTableAlias, .collectType = type, - .pCols = (NULL == *pCols ? nodesMakeList() : *pCols), + .pCols = (NULL == *pCols ? pList : *pCols), .pColHash = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK)}; if (NULL == cxt.pCols || NULL == cxt.pColHash) { return TSDB_CODE_OUT_OF_MEMORY; @@ -2320,12 +2345,20 @@ int32_t nodesCollectColumnsExt(SSelectStmt* pSelect, ESqlClause clause, SSHashOb return TSDB_CODE_FAILED; } + SNodeList * pList = NULL; + if (!*pCols) { + int32_t code = nodesMakeList(&pList); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + } + SCollectColumnsCxt cxt = { .errCode = TSDB_CODE_SUCCESS, .pTableAlias = NULL, .pMultiTableAlias = pMultiTableAlias, .collectType = type, - .pCols = (NULL == *pCols ? nodesMakeList() : *pCols), + .pCols = (NULL == *pCols ? pList : *pCols), .pColHash = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK)}; if (NULL == cxt.pCols || NULL == cxt.pColHash) { return TSDB_CODE_OUT_OF_MEMORY; @@ -2350,11 +2383,19 @@ int32_t nodesCollectColumnsFromNode(SNode* node, const char* pTableAlias, EColle if (NULL == pCols) { return TSDB_CODE_FAILED; } + SNodeList * pList = NULL; + if (!*pCols) { + int32_t code = nodesMakeList(&pList); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + } + SCollectColumnsCxt cxt = { .errCode = TSDB_CODE_SUCCESS, .pTableAlias = pTableAlias, .collectType = type, - .pCols = (NULL == *pCols ? nodesMakeList() : *pCols), + .pCols = (NULL == *pCols ? pList : *pCols), .pColHash = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK)}; if (NULL == cxt.pCols || NULL == cxt.pColHash) { return TSDB_CODE_OUT_OF_MEMORY; @@ -2405,7 +2446,11 @@ static EDealRes collectFuncs(SNode* pNode, void* pContext) { } } if (!bFound) { - pCxt->errCode = nodesListStrictAppend(pCxt->pFuncs, nodesCloneNode(pNode)); + SNode* pNew = NULL; + pCxt->errCode = nodesCloneNode(pNode, &pNew); + if (TSDB_CODE_SUCCESS == pCxt->errCode) { + pCxt->errCode = nodesListStrictAppend(pCxt->pFuncs, pNew); + } } return (TSDB_CODE_SUCCESS == pCxt->errCode ? DEAL_RES_IGNORE_CHILD : DEAL_RES_ERROR); } @@ -2442,11 +2487,17 @@ int32_t nodesCollectFuncs(SSelectStmt* pSelect, ESqlClause clause, char* tableAl if (NULL == pSelect || NULL == pFuncs) { return TSDB_CODE_FAILED; } - + SNodeList* pList = NULL; + if (!*pFuncs) { + int32_t code = nodesMakeList(&pList); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + } SCollectFuncsCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .classifier = classifier, .tableAlias = tableAlias, - .pFuncs = (NULL == *pFuncs ? nodesMakeList() : *pFuncs)}; + .pFuncs = (NULL == *pFuncs ? pList : *pFuncs)}; if (NULL == cxt.pFuncs) { return TSDB_CODE_OUT_OF_MEMORY; } @@ -2474,30 +2525,37 @@ typedef struct SCollectSpecialNodesCxt { static EDealRes collectSpecialNodes(SNode* pNode, void* pContext) { SCollectSpecialNodesCxt* pCxt = (SCollectSpecialNodesCxt*)pContext; if (pCxt->type == nodeType(pNode)) { - pCxt->errCode = nodesListStrictAppend(pCxt->pNodes, nodesCloneNode(pNode)); + SNode* pNew = NULL; + pCxt->errCode = nodesCloneNode(pNode, &pNew); + if (TSDB_CODE_SUCCESS == pCxt->errCode) { + pCxt->errCode = nodesListStrictAppend(pCxt->pNodes, pNew); + } return (TSDB_CODE_SUCCESS == pCxt->errCode ? DEAL_RES_IGNORE_CHILD : DEAL_RES_ERROR); } return DEAL_RES_CONTINUE; } -int32_t nodesCollectSpecialNodes(SSelectStmt* pSelect, ESqlClause clause, ENodeType type, SNodeList** pNodes) { - if (NULL == pSelect || NULL == pNodes) { +int32_t nodesCollectSpecialNodes(SSelectStmt* pSelect, ESqlClause clause, ENodeType type, SNodeList** ppNodes) { + if (NULL == pSelect || NULL == ppNodes) { return TSDB_CODE_FAILED; } - - SCollectSpecialNodesCxt cxt = { - .errCode = TSDB_CODE_SUCCESS, .type = type, .pNodes = (NULL == *pNodes ? nodesMakeList() : *pNodes)}; - if (NULL == cxt.pNodes) { - return TSDB_CODE_OUT_OF_MEMORY; + SCollectSpecialNodesCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .type = type, .pNodes = NULL}; + if (!*ppNodes) { + cxt.errCode = nodesMakeList(&cxt.pNodes); + } else { + cxt.pNodes = *ppNodes; } - *pNodes = NULL; + if (NULL == cxt.pNodes) { + return cxt.errCode; + } + *ppNodes = NULL; nodesWalkSelectStmt(pSelect, SQL_CLAUSE_GROUP_BY, collectSpecialNodes, &cxt); if (TSDB_CODE_SUCCESS != cxt.errCode) { nodesDestroyList(cxt.pNodes); return cxt.errCode; } if (LIST_LENGTH(cxt.pNodes) > 0) { - *pNodes = cxt.pNodes; + *ppNodes = cxt.pNodes; } else { nodesDestroyList(cxt.pNodes); } @@ -2640,9 +2698,10 @@ int32_t nodesMergeConds(SNode** pDst, SNodeList** pSrc) { *pDst = nodesListGetNode(*pSrc, 0); nodesClearList(*pSrc); } else { - SLogicConditionNode* pLogicCond = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); - if (NULL == pLogicCond) { - return TSDB_CODE_OUT_OF_MEMORY; + SLogicConditionNode* pLogicCond = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogicCond); + if (TSDB_CODE_SUCCESS != code) { + return code; } pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL; pLogicCond->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes; @@ -2671,15 +2730,16 @@ const char* dataOrderStr(EDataOrderLevel order) { return "unknown"; } -SValueNode* nodesMakeValueNodeFromString(char* literal) { +int32_t nodesMakeValueNodeFromString(char* literal, SValueNode** ppValNode) { int32_t lenStr = strlen(literal); - SValueNode* pValNode = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode* pValNode = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValNode); if (pValNode) { pValNode->node.resType.type = TSDB_DATA_TYPE_VARCHAR; pValNode->node.resType.bytes = lenStr + VARSTR_HEADER_SIZE; char* p = taosMemoryMalloc(lenStr + 1 + VARSTR_HEADER_SIZE); if (p == NULL) { - return NULL; + return TSDB_CODE_OUT_OF_MEMORY; } varDataSetLen(p, lenStr); memcpy(varDataVal(p), literal, lenStr + 1); @@ -2687,32 +2747,45 @@ SValueNode* nodesMakeValueNodeFromString(char* literal) { pValNode->literal = tstrdup(literal); pValNode->translate = true; pValNode->isNull = false; + *ppValNode = pValNode; } - return pValNode; + return code; } -SValueNode* nodesMakeValueNodeFromBool(bool b) { - SValueNode* pValNode = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); - if (pValNode) { +int32_t nodesMakeValueNodeFromBool(bool b, SValueNode** ppValNode) { + SValueNode* pValNode = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValNode); + if (TSDB_CODE_SUCCESS == code) { pValNode->node.resType.type = TSDB_DATA_TYPE_BOOL; pValNode->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes; - nodesSetValueNodeValue(pValNode, &b); - pValNode->translate = true; - pValNode->isNull = false; + code = nodesSetValueNodeValue(pValNode, &b); + if (TSDB_CODE_SUCCESS == code) { + pValNode->translate = true; + pValNode->isNull = false; + *ppValNode = pValNode; + } else { + nodesDestroyNode((SNode*)pValNode); + } } - return pValNode; + return code; } -SNode* nodesMakeValueNodeFromInt32(int32_t value) { - SValueNode* pValNode = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); - if (pValNode) { +int32_t nodesMakeValueNodeFromInt32(int32_t value, SNode** ppNode) { + SValueNode* pValNode = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValNode); + if (TSDB_CODE_SUCCESS == code) { pValNode->node.resType.type = TSDB_DATA_TYPE_INT; pValNode->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_INT].bytes; - nodesSetValueNodeValue(pValNode, &value); - pValNode->translate = true; - pValNode->isNull = false; + code = nodesSetValueNodeValue(pValNode, &value); + if (TSDB_CODE_SUCCESS == code) { + pValNode->translate = true; + pValNode->isNull = false; + *ppNode = (SNode*)pValNode; + } else { + nodesDestroyNode((SNode*)pValNode); + } } - return (SNode*)pValNode; + return code; } bool nodesIsStar(SNode* pNode) { diff --git a/source/libs/nodes/test/nodesCloneTest.cpp b/source/libs/nodes/test/nodesCloneTest.cpp index 8b8893d317..75a4f6c66f 100644 --- a/source/libs/nodes/test/nodesCloneTest.cpp +++ b/source/libs/nodes/test/nodesCloneTest.cpp @@ -24,7 +24,9 @@ class NodesCloneTest : public testing::Test { void registerCheckFunc(const std::function& func) { checkFunc_ = func; } void run(const SNode* pSrc) { - std::unique_ptr pDst(nodesCloneNode(pSrc), nodesDestroyNode); + SNode* pNew = NULL; + int32_t code = nodesCloneNode(pSrc, &pNew); + std::unique_ptr pDst(pNew, nodesDestroyNode); checkFunc_(pSrc, pDst.get()); } @@ -43,9 +45,13 @@ TEST_F(NodesCloneTest, tempTable) { std::unique_ptr srcNode(nullptr, nodesDestroyNode); run([&]() { - srcNode.reset(nodesMakeNode(QUERY_NODE_TEMP_TABLE)); + SNode* pNew = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_TEMP_TABLE, &pNew); + srcNode.reset(pNew); STempTableNode* pNode = (STempTableNode*)srcNode.get(); - pNode->pSubquery = nodesMakeNode(QUERY_NODE_SELECT_STMT); + pNew = NULL; + code = nodesMakeNode(QUERY_NODE_SELECT_STMT, &pNew); + pNode->pSubquery = pNew; return srcNode.get(); }()); } @@ -66,12 +72,14 @@ TEST_F(NodesCloneTest, joinTable) { std::unique_ptr srcNode(nullptr, nodesDestroyNode); run([&]() { - srcNode.reset(nodesMakeNode(QUERY_NODE_JOIN_TABLE)); + SNode* pNew = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_JOIN_TABLE, &pNew); + srcNode.reset(pNew); SJoinTableNode* pNode = (SJoinTableNode*)srcNode.get(); pNode->joinType = JOIN_TYPE_INNER; - pNode->pLeft = nodesMakeNode(QUERY_NODE_REAL_TABLE); - pNode->pRight = nodesMakeNode(QUERY_NODE_REAL_TABLE); - pNode->pOnCond = nodesMakeNode(QUERY_NODE_OPERATOR); + code = nodesMakeNode(QUERY_NODE_REAL_TABLE, &pNode->pLeft); + code = nodesMakeNode(QUERY_NODE_REAL_TABLE, &pNode->pRight); + code = nodesMakeNode(QUERY_NODE_OPERATOR, &pNode->pOnCond); return srcNode.get(); }()); } @@ -88,10 +96,12 @@ TEST_F(NodesCloneTest, stateWindow) { std::unique_ptr srcNode(nullptr, nodesDestroyNode); run([&]() { - srcNode.reset(nodesMakeNode(QUERY_NODE_STATE_WINDOW)); + SNode* pNew = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_STATE_WINDOW, &pNew); + srcNode.reset(pNew); SStateWindowNode* pNode = (SStateWindowNode*)srcNode.get(); - pNode->pCol = nodesMakeNode(QUERY_NODE_COLUMN); - pNode->pExpr = nodesMakeNode(QUERY_NODE_OPERATOR); + code = nodesMakeNode(QUERY_NODE_COLUMN, &pNode->pCol); + code = nodesMakeNode(QUERY_NODE_OPERATOR, &pNode->pExpr); return srcNode.get(); }()); } @@ -108,10 +118,12 @@ TEST_F(NodesCloneTest, sessionWindow) { std::unique_ptr srcNode(nullptr, nodesDestroyNode); run([&]() { - srcNode.reset(nodesMakeNode(QUERY_NODE_SESSION_WINDOW)); + SNode* pNew = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_SESSION_WINDOW, &pNew); + srcNode.reset(pNew); SSessionWindowNode* pNode = (SSessionWindowNode*)srcNode.get(); - pNode->pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); - pNode->pGap = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pNode->pCol); + code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pNode->pGap); return srcNode.get(); }()); } @@ -136,12 +148,14 @@ TEST_F(NodesCloneTest, intervalWindow) { std::unique_ptr srcNode(nullptr, nodesDestroyNode); run([&]() { - srcNode.reset(nodesMakeNode(QUERY_NODE_INTERVAL_WINDOW)); + SNode* pNew = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_INTERVAL_WINDOW, &pNew); + srcNode.reset(pNew); SIntervalWindowNode* pNode = (SIntervalWindowNode*)srcNode.get(); - pNode->pInterval = nodesMakeNode(QUERY_NODE_VALUE); - pNode->pOffset = nodesMakeNode(QUERY_NODE_VALUE); - pNode->pSliding = nodesMakeNode(QUERY_NODE_VALUE); - pNode->pFill = nodesMakeNode(QUERY_NODE_FILL); + code = nodesMakeNode(QUERY_NODE_VALUE, &pNode->pInterval); + code = nodesMakeNode(QUERY_NODE_VALUE, &pNode->pOffset); + code = nodesMakeNode(QUERY_NODE_VALUE, &pNode->pSliding); + code = nodesMakeNode(QUERY_NODE_FILL, &pNode->pFill); return srcNode.get(); }()); } @@ -163,11 +177,13 @@ TEST_F(NodesCloneTest, fill) { std::unique_ptr srcNode(nullptr, nodesDestroyNode); run([&]() { - srcNode.reset(nodesMakeNode(QUERY_NODE_FILL)); + SNode* pNew = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FILL, &pNew); + srcNode.reset(pNew); SFillNode* pNode = (SFillNode*)srcNode.get(); pNode->mode = FILL_MODE_VALUE; - pNode->pValues = nodesMakeNode(QUERY_NODE_NODE_LIST); - pNode->pWStartTs = nodesMakeNode(QUERY_NODE_COLUMN); + code = nodesMakeNode(QUERY_NODE_NODE_LIST, &pNode->pValues); + code = nodesMakeNode(QUERY_NODE_COLUMN, &pNode->pWStartTs); pNode->timeRange.skey = 1666756692907; pNode->timeRange.ekey = 1666756699907; return srcNode.get(); @@ -188,7 +204,9 @@ TEST_F(NodesCloneTest, logicSubplan) { std::unique_ptr srcNode(nullptr, nodesDestroyNode); run([&]() { - srcNode.reset(nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN)); + SNode* pNew = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN, &pNew); + srcNode.reset(pNew); SLogicSubplan* pNode = (SLogicSubplan*)srcNode.get(); return srcNode.get(); }()); @@ -208,7 +226,9 @@ TEST_F(NodesCloneTest, physiScan) { std::unique_ptr srcNode(nullptr, nodesDestroyNode); run([&]() { - srcNode.reset(nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN)); + SNode* pNew = nullptr; + int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN, &pNew); + srcNode.reset(pNew); STagScanPhysiNode* pNode = (STagScanPhysiNode*)srcNode.get(); return srcNode.get(); }()); @@ -227,7 +247,9 @@ TEST_F(NodesCloneTest, physiSystemTableScan) { std::unique_ptr srcNode(nullptr, nodesDestroyNode); run([&]() { - srcNode.reset(nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN)); + SNode* pNew = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN, &pNew); + srcNode.reset(pNew); SSystemTableScanPhysiNode* pNode = (SSystemTableScanPhysiNode*)srcNode.get(); return srcNode.get(); }()); @@ -244,7 +266,9 @@ TEST_F(NodesCloneTest, physiStreamSemiSessionWinodw) { std::unique_ptr srcNode(nullptr, nodesDestroyNode); run([&]() { - srcNode.reset(nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION)); + SNode* pNew = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION, &pNew); + srcNode.reset(pNew); SStreamSemiSessionWinodwPhysiNode* pNode = (SStreamSemiSessionWinodwPhysiNode*)srcNode.get(); return srcNode.get(); }()); @@ -261,7 +285,9 @@ TEST_F(NodesCloneTest, physiStreamFinalSessionWinodw) { std::unique_ptr srcNode(nullptr, nodesDestroyNode); run([&]() { - srcNode.reset(nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION)); + SNode* pNew = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION, &pNew); + srcNode.reset(pNew); SStreamFinalSessionWinodwPhysiNode* pNode = (SStreamFinalSessionWinodwPhysiNode*)srcNode.get(); return srcNode.get(); }()); @@ -277,7 +303,9 @@ TEST_F(NodesCloneTest, physiStreamPartition) { std::unique_ptr srcNode(nullptr, nodesDestroyNode); run([&]() { - srcNode.reset(nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION)); + SNode* pNew = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION, &pNew); + srcNode.reset(pNew); SStreamPartitionPhysiNode* pNode = (SStreamPartitionPhysiNode*)srcNode.get(); return srcNode.get(); }()); @@ -293,7 +321,9 @@ TEST_F(NodesCloneTest, physiPartition) { std::unique_ptr srcNode(nullptr, nodesDestroyNode); run([&]() { - srcNode.reset(nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_PARTITION)); + SNode* pNew = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_PARTITION, &pNew); + srcNode.reset(pNew); SPartitionPhysiNode* pNode = (SPartitionPhysiNode*)srcNode.get(); return srcNode.get(); }()); diff --git a/source/libs/nodes/test/nodesTestMain.cpp b/source/libs/nodes/test/nodesTestMain.cpp index 4e50595b62..f3d1657e56 100644 --- a/source/libs/nodes/test/nodesTestMain.cpp +++ b/source/libs/nodes/test/nodesTestMain.cpp @@ -26,7 +26,8 @@ static EDealRes rewriterTest(SNode** pNode, void* pContext) { if (QUERY_NODE_VALUE != nodeType(pOp->pLeft) || QUERY_NODE_VALUE != nodeType(pOp->pRight)) { *pRes = DEAL_RES_ERROR; } - SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode* pVal = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal); string tmp = to_string(stoi(((SValueNode*)(pOp->pLeft))->literal) + stoi(((SValueNode*)(pOp->pRight))->literal)); pVal->literal = taosStrdup(tmp.c_str()); nodesDestroyNode(*pNode); @@ -36,15 +37,18 @@ static EDealRes rewriterTest(SNode** pNode, void* pContext) { } TEST(NodesTest, traverseTest) { - SNode* pRoot = (SNode*)nodesMakeNode(QUERY_NODE_OPERATOR); + SNode* pRoot = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_OPERATOR,(SNode**)&pRoot); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SOperatorNode* pOp = (SOperatorNode*)pRoot; - SOperatorNode* pLeft = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR); - pLeft->pLeft = (SNode*)nodesMakeNode(QUERY_NODE_VALUE); + SOperatorNode* pLeft = NULL; + ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pLeft)); + ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_VALUE, &pLeft->pLeft)); ((SValueNode*)(pLeft->pLeft))->literal = taosStrdup("10"); - pLeft->pRight = (SNode*)nodesMakeNode(QUERY_NODE_VALUE); + ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_VALUE, &pLeft->pRight)); ((SValueNode*)(pLeft->pRight))->literal = taosStrdup("5"); pOp->pLeft = (SNode*)pLeft; - pOp->pRight = (SNode*)nodesMakeNode(QUERY_NODE_VALUE); + ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_VALUE, &pOp->pRight)); ((SValueNode*)(pOp->pRight))->literal = taosStrdup("3"); EXPECT_EQ(nodeType(pRoot), QUERY_NODE_OPERATOR); @@ -90,19 +94,24 @@ void assert_sort_result(SNodeList* pList) { } TEST(NodesTest, sort) { - SValueNode *vn1 = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode *vn1 = NULL; + ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&vn1)); vn1->datum.i = 4; - SValueNode *vn2 = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode *vn2 = NULL; + ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&vn2)); vn2->datum.i = 3; - SValueNode *vn3 = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode *vn3 = NULL; + ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&vn3)); vn3->datum.i = 2; - SValueNode *vn4 = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode *vn4 = NULL; + ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&vn4)); vn4->datum.i = 1; - SValueNode *vn5 = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode *vn5 = NULL; + ASSERT_EQ(TSDB_CODE_SUCCESS, nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&vn5)); vn5->datum.i = 0; SNodeList* l = NULL; diff --git a/source/libs/parser/inc/parUtil.h b/source/libs/parser/inc/parUtil.h index f550840f41..f519bd37a8 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); -SNode* createSelectStmtImpl(bool isDistinct, SNodeList* pProjectionList, SNode* pTable, SNodeList* pHint); +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/src/parAstCreater.c b/source/libs/parser/src/parAstCreater.c index d61d80a691..93bcf86a1f 100644 --- a/source/libs/parser/src/parAstCreater.c +++ b/source/libs/parser/src/parAstCreater.c @@ -21,11 +21,16 @@ #include "tglobal.h" #include "ttime.h" +#define CHECK_MAKE_NODE(p) \ + do { \ + if (NULL == (p)) { \ + return NULL; \ + } \ + } while (0) + #define CHECK_OUT_OF_MEM(p) \ do { \ if (NULL == (p)) { \ - pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; \ - snprintf(pCxt->pQueryCxt->pMsg, pCxt->pQueryCxt->msgLen, "Out of memory"); \ return NULL; \ } \ } while (0) @@ -262,7 +267,8 @@ static bool checkTsmaName(SAstCreateContext* pCxt, SToken* pTsmaToken) { SNode* createRawExprNode(SAstCreateContext* pCxt, const SToken* pToken, SNode* pNode) { CHECK_PARSER_STATUS(pCxt); - SRawExprNode* target = (SRawExprNode*)nodesMakeNode(QUERY_NODE_RAW_EXPR); + SRawExprNode* target = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_RAW_EXPR, (SNode**)&target); CHECK_OUT_OF_MEM(target); target->p = pToken->z; target->n = pToken->n; @@ -272,7 +278,8 @@ SNode* createRawExprNode(SAstCreateContext* pCxt, const SToken* pToken, SNode* p SNode* createRawExprNodeExt(SAstCreateContext* pCxt, const SToken* pStart, const SToken* pEnd, SNode* pNode) { CHECK_PARSER_STATUS(pCxt); - SRawExprNode* target = (SRawExprNode*)nodesMakeNode(QUERY_NODE_RAW_EXPR); + SRawExprNode* target = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_RAW_EXPR, (SNode**)&target); CHECK_OUT_OF_MEM(target); target->p = pStart->z; target->n = (pEnd->z + pEnd->n) - pStart->z; @@ -338,9 +345,14 @@ SToken getTokenFromRawExprNode(SAstCreateContext* pCxt, SNode* pNode) { SNodeList* createNodeList(SAstCreateContext* pCxt, SNode* pNode) { CHECK_PARSER_STATUS(pCxt); - SNodeList* list = nodesMakeList(); + SNodeList* list = NULL; + pCxt->errCode = nodesMakeList(&list); CHECK_OUT_OF_MEM(list); pCxt->errCode = nodesListAppend(list, pNode); + if (TSDB_CODE_SUCCESS != pCxt->errCode) { + nodesDestroyList(list); + return NULL; + } return list; } @@ -355,7 +367,8 @@ SNode* createColumnNode(SAstCreateContext* pCxt, SToken* pTableAlias, SToken* pC if (!checkTableName(pCxt, pTableAlias) || !checkColumnName(pCxt, pColumnName)) { return NULL; } - SColumnNode* col = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + SColumnNode* col = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&col); CHECK_OUT_OF_MEM(col); if (NULL != pTableAlias) { COPY_STRING_FORM_ID_TOKEN(col->tableAlias, pTableAlias); @@ -366,14 +379,19 @@ SNode* createColumnNode(SAstCreateContext* pCxt, SToken* pTableAlias, SToken* pC SNode* createValueNode(SAstCreateContext* pCxt, int32_t dataType, const SToken* pLiteral) { CHECK_PARSER_STATUS(pCxt); - SValueNode* val = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode* val = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&val); CHECK_OUT_OF_MEM(val); val->literal = strndup(pLiteral->z, pLiteral->n); if (TK_NK_ID != pLiteral->type && TK_TIMEZONE != pLiteral->type && (IS_VAR_DATA_TYPE(dataType) || TSDB_DATA_TYPE_TIMESTAMP == dataType)) { (void)trimString(pLiteral->z, pLiteral->n, val->literal, pLiteral->n); } - CHECK_OUT_OF_MEM(val->literal); + if(!val->literal) { + pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; + nodesDestroyNode((SNode*)val); + return NULL; + } val->node.resType.type = dataType; val->node.resType.bytes = IS_VAR_DATA_TYPE(dataType) ? strlen(val->literal) : tDataTypes[dataType].bytes; if (TSDB_DATA_TYPE_TIMESTAMP == dataType) { @@ -386,9 +404,9 @@ SNode* createValueNode(SAstCreateContext* pCxt, int32_t dataType, const SToken* SNode* createRawValueNode(SAstCreateContext* pCxt, int32_t dataType, const SToken* pLiteral, SNode* pNode) { CHECK_PARSER_STATUS(pCxt); SValueNode* val = NULL; - - if (!(val = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE))) { - pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_OUT_OF_MEMORY, "Out of memory"); + pCxt->errCode = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&val); + if (TSDB_CODE_SUCCESS != pCxt->errCode) { + pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, pCxt->errCode, ""); goto _exit; } if (pLiteral) { @@ -428,8 +446,9 @@ SNode* createRawValueNodeExt(SAstCreateContext* pCxt, int32_t dataType, const ST CHECK_PARSER_STATUS(pCxt); SValueNode* val = NULL; - if (!(val = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE))) { - pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_OUT_OF_MEMORY, "Out of memory"); + pCxt->errCode = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&val); + if (TSDB_CODE_SUCCESS != pCxt->errCode) { + pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, pCxt->errCode, ""); goto _exit; } if (pLiteral) { @@ -501,13 +520,14 @@ bool addHintNodeToList(SAstCreateContext* pCxt, SNodeList** ppHintList, EHintOpt return true; } - SHintNode* hint = (SHintNode*)nodesMakeNode(QUERY_NODE_HINT); + SHintNode* hint = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_HINT, (SNode**)&hint); CHECK_OUT_OF_MEM(hint); hint->option = opt; hint->value = value; if (NULL == *ppHintList) { - *ppHintList = nodesMakeList(); + pCxt->errCode = nodesMakeList(ppHintList); CHECK_OUT_OF_MEM(*ppHintList); } @@ -659,7 +679,8 @@ SNode* createIdentifierValueNode(SAstCreateContext* pCxt, SToken* pLiteral) { SNode* createDurationValueNode(SAstCreateContext* pCxt, const SToken* pLiteral) { CHECK_PARSER_STATUS(pCxt); - SValueNode* val = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode* val = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&val); CHECK_OUT_OF_MEM(val); if (pLiteral->type == TK_NK_STRING) { // like '100s' or "100d" @@ -695,7 +716,11 @@ SNode* createDurationValueNode(SAstCreateContext* pCxt, const SToken* pLiteral) } else { val->literal = strndup(pLiteral->z, pLiteral->n); } - CHECK_OUT_OF_MEM(val->literal); + if (!val->literal) { + nodesDestroyNode((SNode*)val); + pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } val->flag |= VALUE_FLAG_IS_DURATION; val->translate = false; val->node.resType.type = TSDB_DATA_TYPE_BIGINT; @@ -706,7 +731,8 @@ SNode* createDurationValueNode(SAstCreateContext* pCxt, const SToken* pLiteral) SNode* createTimeOffsetValueNode(SAstCreateContext* pCxt, const SToken* pLiteral) { CHECK_PARSER_STATUS(pCxt); - SValueNode* val = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode* val = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&val); CHECK_OUT_OF_MEM(val); if (pLiteral->type == TK_NK_STRING) { // like '100s' or "100d" @@ -740,7 +766,11 @@ SNode* createTimeOffsetValueNode(SAstCreateContext* pCxt, const SToken* pLiteral } else { val->literal = strndup(pLiteral->z, pLiteral->n); } - CHECK_OUT_OF_MEM(val->literal); + if (!val->literal) { + nodesDestroyNode((SNode*)val); + pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } val->flag |= VALUE_FLAG_IS_TIME_OFFSET; val->translate = false; val->node.resType.type = TSDB_DATA_TYPE_BIGINT; @@ -755,10 +785,15 @@ SNode* createDefaultDatabaseCondValue(SAstCreateContext* pCxt) { return NULL; } - SValueNode* val = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); - CHECK_OUT_OF_MEM(val); + SValueNode* val = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&val); + CHECK_MAKE_NODE(val); val->literal = taosStrdup(pCxt->pQueryCxt->db); - CHECK_OUT_OF_MEM(val->literal); + if (!val->literal) { + pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; + nodesDestroyNode((SNode*)val); + return NULL; + } val->translate = false; val->node.resType.type = TSDB_DATA_TYPE_BINARY; val->node.resType.bytes = strlen(val->literal); @@ -772,10 +807,15 @@ SNode* createPlaceholderValueNode(SAstCreateContext* pCxt, const SToken* pLitera pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_SYNTAX_ERROR, pLiteral->z); return NULL; } - SValueNode* val = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); - CHECK_OUT_OF_MEM(val); + SValueNode* val = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&val); + CHECK_MAKE_NODE(val); val->literal = strndup(pLiteral->z, pLiteral->n); - CHECK_OUT_OF_MEM(val->literal); + if (!val->literal) { + pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; + nodesDestroyNode((SNode*)val); + return NULL; + } val->placeholderNo = ++pCxt->placeholderNo; if (NULL == pCxt->pPlaceholderValues) { pCxt->pPlaceholderValues = taosArrayInit(TARRAY_MIN_SIZE, POINTER_BYTES); @@ -804,15 +844,19 @@ static int32_t addParamToLogicConditionNode(SLogicConditionNode* pCond, SNode* p SNode* createLogicConditionNode(SAstCreateContext* pCxt, ELogicConditionType type, SNode* pParam1, SNode* pParam2) { CHECK_PARSER_STATUS(pCxt); - SLogicConditionNode* cond = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); - CHECK_OUT_OF_MEM(cond); + SLogicConditionNode* cond = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&cond); + CHECK_MAKE_NODE(cond); cond->condType = type; - cond->pParameterList = nodesMakeList(); - int32_t code = addParamToLogicConditionNode(cond, pParam1); - if (TSDB_CODE_SUCCESS == code && NULL != pParam2) { - code = addParamToLogicConditionNode(cond, pParam2); + cond->pParameterList = NULL; + pCxt->errCode = nodesMakeList(&cond->pParameterList); + if (TSDB_CODE_SUCCESS == pCxt->errCode) { + pCxt->errCode = addParamToLogicConditionNode(cond, pParam1); } - if (TSDB_CODE_SUCCESS != code) { + if (TSDB_CODE_SUCCESS == pCxt->errCode && NULL != pParam2) { + pCxt->errCode = addParamToLogicConditionNode(cond, pParam2); + } + if (TSDB_CODE_SUCCESS != pCxt->errCode) { nodesDestroyNode((SNode*)cond); return NULL; } @@ -837,7 +881,10 @@ SNode* createOperatorNode(SAstCreateContext* pCxt, EOperatorType type, SNode* pL if (OP_TYPE_MINUS == type && QUERY_NODE_VALUE == nodeType(pLeft)) { SValueNode* pVal = (SValueNode*)pLeft; char* pNewLiteral = taosMemoryCalloc(1, strlen(pVal->literal) + 2); - CHECK_OUT_OF_MEM(pNewLiteral); + if (!pNewLiteral) { + pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } if ('+' == pVal->literal[0]) { sprintf(pNewLiteral, "-%s", pVal->literal + 1); } else if ('-' == pVal->literal[0]) { @@ -850,7 +897,8 @@ SNode* createOperatorNode(SAstCreateContext* pCxt, EOperatorType type, SNode* pL pVal->node.resType.type = getMinusDataType(pVal->node.resType.type); return pLeft; } - SOperatorNode* op = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR); + SOperatorNode* op = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&op); CHECK_OUT_OF_MEM(op); op->opType = type; op->pLeft = pLeft; @@ -860,21 +908,58 @@ SNode* createOperatorNode(SAstCreateContext* pCxt, EOperatorType type, SNode* pL SNode* createBetweenAnd(SAstCreateContext* pCxt, SNode* pExpr, SNode* pLeft, SNode* pRight) { CHECK_PARSER_STATUS(pCxt); - return createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, - createOperatorNode(pCxt, OP_TYPE_GREATER_EQUAL, pExpr, pLeft), - createOperatorNode(pCxt, OP_TYPE_LOWER_EQUAL, nodesCloneNode(pExpr), pRight)); + SNode* pNew = NULL; + pCxt->errCode = nodesCloneNode(pExpr, &pNew); + CHECK_PARSER_STATUS(pCxt); + SNode* pGE = createOperatorNode(pCxt, OP_TYPE_GREATER_EQUAL, pExpr, pLeft); + if (TSDB_CODE_SUCCESS != pCxt->errCode) { + nodesDestroyNode(pNew); + return NULL; + } + SNode* pLE = createOperatorNode(pCxt, OP_TYPE_LOWER_EQUAL, pNew, pRight); + if (TSDB_CODE_SUCCESS != pCxt->errCode) { + nodesDestroyNode(pNew); + nodesDestroyNode(pGE); + return NULL; + } + SNode* pRet = createLogicConditionNode(pCxt, LOGIC_COND_TYPE_AND, pGE, pLE); + if (TSDB_CODE_SUCCESS != pCxt->errCode) { + nodesDestroyNode(pNew); + nodesDestroyNode(pGE); + nodesDestroyNode(pLE); + } + return pRet; } SNode* createNotBetweenAnd(SAstCreateContext* pCxt, SNode* pExpr, SNode* pLeft, SNode* pRight) { CHECK_PARSER_STATUS(pCxt); - return createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, createOperatorNode(pCxt, OP_TYPE_LOWER_THAN, pExpr, pLeft), - createOperatorNode(pCxt, OP_TYPE_GREATER_THAN, nodesCloneNode(pExpr), pRight)); + SNode* pLT = createOperatorNode(pCxt, OP_TYPE_LOWER_THAN, pExpr, pLeft); + CHECK_MAKE_NODE(pLT); + SNode* pNew = NULL; + pCxt->errCode = nodesCloneNode(pExpr, &pNew); + if (TSDB_CODE_SUCCESS != pCxt->errCode) { + nodesDestroyNode(pLT); + return NULL; + } + SNode* pGT = createOperatorNode(pCxt, OP_TYPE_GREATER_THAN, pNew, pRight); + if (TSDB_CODE_SUCCESS != pCxt->errCode) { + nodesDestroyNode(pLT); + nodesDestroyNode(pNew); + } + SNode* pRet = createLogicConditionNode(pCxt, LOGIC_COND_TYPE_OR, pLT, pGT); + if (TSDB_CODE_SUCCESS != pCxt->errCode) { + nodesDestroyNode(pLT); + nodesDestroyNode(pGT); + nodesDestroyNode(pNew); + } + return pRet; } static SNode* createPrimaryKeyCol(SAstCreateContext* pCxt, const SToken* pFuncName) { CHECK_PARSER_STATUS(pCxt); - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); - CHECK_OUT_OF_MEM(pCol); + SColumnNode* pCol = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); + CHECK_MAKE_NODE(pCol); pCol->colId = PRIMARYKEY_TIMESTAMP_COL_ID; if (NULL == pFuncName) { strcpy(pCol->colName, ROWTS_PSEUDO_COLUMN_NAME); @@ -890,8 +975,9 @@ SNode* createFunctionNode(SAstCreateContext* pCxt, const SToken* pFuncName, SNod if (0 == strncasecmp("_rowts", pFuncName->z, pFuncName->n) || 0 == strncasecmp("_c0", pFuncName->z, pFuncName->n)) { return createPrimaryKeyCol(pCxt, pFuncName); } - SFunctionNode* func = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); - CHECK_OUT_OF_MEM(func); + SFunctionNode* func = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&func); + CHECK_MAKE_NODE(func); COPY_STRING_FORM_ID_TOKEN(func->functionName, pFuncName); func->pParameterList = pParameterList; return (SNode*)func; @@ -899,8 +985,9 @@ SNode* createFunctionNode(SAstCreateContext* pCxt, const SToken* pFuncName, SNod SNode* createCastFunctionNode(SAstCreateContext* pCxt, SNode* pExpr, SDataType dt) { CHECK_PARSER_STATUS(pCxt); - SFunctionNode* func = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); - CHECK_OUT_OF_MEM(func); + SFunctionNode* func = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&func); + CHECK_MAKE_NODE(func); strcpy(func->functionName, "cast"); func->node.resType = dt; if (TSDB_DATA_TYPE_VARCHAR == dt.type || TSDB_DATA_TYPE_GEOMETRY == dt.type || TSDB_DATA_TYPE_VARBINARY == dt.type) { @@ -915,17 +1002,19 @@ SNode* createCastFunctionNode(SAstCreateContext* pCxt, SNode* pExpr, SDataType d SNode* createNodeListNode(SAstCreateContext* pCxt, SNodeList* pList) { CHECK_PARSER_STATUS(pCxt); - SNodeListNode* list = (SNodeListNode*)nodesMakeNode(QUERY_NODE_NODE_LIST); - CHECK_OUT_OF_MEM(list); + SNodeListNode* list = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&list); + CHECK_MAKE_NODE(list); list->pNodeList = pList; return (SNode*)list; } SNode* createNodeListNodeEx(SAstCreateContext* pCxt, SNode* p1, SNode* p2) { CHECK_PARSER_STATUS(pCxt); - SNodeListNode* list = (SNodeListNode*)nodesMakeNode(QUERY_NODE_NODE_LIST); - CHECK_OUT_OF_MEM(list); - list->pNodeList = nodesMakeList(); + SNodeListNode* list = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&list); + CHECK_MAKE_NODE(list); + pCxt->errCode = nodesMakeList(&list->pNodeList); CHECK_OUT_OF_MEM(list->pNodeList); pCxt->errCode = nodesListAppend(list->pNodeList, p1); CHECK_PARSER_STATUS(pCxt); @@ -939,8 +1028,9 @@ SNode* createRealTableNode(SAstCreateContext* pCxt, SToken* pDbName, SToken* pTa if (!checkDbName(pCxt, pDbName, true) || !checkTableName(pCxt, pTableName) || !checkTableName(pCxt, pTableAlias)) { return NULL; } - SRealTableNode* realTable = (SRealTableNode*)nodesMakeNode(QUERY_NODE_REAL_TABLE); - CHECK_OUT_OF_MEM(realTable); + SRealTableNode* realTable = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_REAL_TABLE, (SNode**)&realTable); + CHECK_MAKE_NODE(realTable); if (NULL != pDbName) { COPY_STRING_FORM_ID_TOKEN(realTable->table.dbName, pDbName); } else { @@ -960,8 +1050,9 @@ SNode* createTempTableNode(SAstCreateContext* pCxt, SNode* pSubquery, SToken* pT if (!checkTableName(pCxt, pTableAlias)) { return NULL; } - STempTableNode* tempTable = (STempTableNode*)nodesMakeNode(QUERY_NODE_TEMP_TABLE); - CHECK_OUT_OF_MEM(tempTable); + STempTableNode* tempTable = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_TEMP_TABLE, (SNode**)&tempTable); + CHECK_MAKE_NODE(tempTable); tempTable->pSubquery = pSubquery; if (NULL != pTableAlias && TK_NK_NIL != pTableAlias->type) { COPY_STRING_FORM_ID_TOKEN(tempTable->table.tableAlias, pTableAlias); @@ -980,8 +1071,9 @@ SNode* createTempTableNode(SAstCreateContext* pCxt, SNode* pSubquery, SToken* pT SNode* createJoinTableNode(SAstCreateContext* pCxt, EJoinType type, EJoinSubType stype, SNode* pLeft, SNode* pRight, SNode* pJoinCond) { CHECK_PARSER_STATUS(pCxt); - SJoinTableNode* joinTable = (SJoinTableNode*)nodesMakeNode(QUERY_NODE_JOIN_TABLE); - CHECK_OUT_OF_MEM(joinTable); + SJoinTableNode* joinTable = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_JOIN_TABLE, (SNode**)&joinTable); + CHECK_MAKE_NODE(joinTable); joinTable->joinType = type; joinTable->subType = stype; joinTable->pLeft = pLeft; @@ -995,8 +1087,9 @@ SNode* createViewNode(SAstCreateContext* pCxt, SToken* pDbName, SToken* pViewNam if (!checkDbName(pCxt, pDbName, true) || !checkViewName(pCxt, pViewName)) { return NULL; } - SViewNode* pView = (SViewNode*)nodesMakeNode(QUERY_NODE_VIEW); - CHECK_OUT_OF_MEM(pView); + SViewNode* pView = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_VIEW, (SNode**)&pView); + CHECK_MAKE_NODE(pView); if (NULL != pDbName) { COPY_STRING_FORM_ID_TOKEN(pView->table.dbName, pDbName); } else { @@ -1008,8 +1101,9 @@ SNode* createViewNode(SAstCreateContext* pCxt, SToken* pDbName, SToken* pViewNam SNode* createLimitNode(SAstCreateContext* pCxt, const SToken* pLimit, const SToken* pOffset) { CHECK_PARSER_STATUS(pCxt); - SLimitNode* limitNode = (SLimitNode*)nodesMakeNode(QUERY_NODE_LIMIT); - CHECK_OUT_OF_MEM(limitNode); + SLimitNode* limitNode = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_LIMIT, (SNode**)&limitNode); + CHECK_MAKE_NODE(limitNode); limitNode->limit = taosStr2Int64(pLimit->z, NULL, 10); if (NULL != pOffset) { limitNode->offset = taosStr2Int64(pOffset->z, NULL, 10); @@ -1019,8 +1113,9 @@ SNode* createLimitNode(SAstCreateContext* pCxt, const SToken* pLimit, const STok SNode* createOrderByExprNode(SAstCreateContext* pCxt, SNode* pExpr, EOrder order, ENullOrder nullOrder) { CHECK_PARSER_STATUS(pCxt); - SOrderByExprNode* orderByExpr = (SOrderByExprNode*)nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR); - CHECK_OUT_OF_MEM(orderByExpr); + SOrderByExprNode* orderByExpr = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR, (SNode**)&orderByExpr); + CHECK_MAKE_NODE(orderByExpr); orderByExpr->pExpr = pExpr; orderByExpr->order = order; if (NULL_ORDER_DEFAULT == nullOrder) { @@ -1032,8 +1127,9 @@ SNode* createOrderByExprNode(SAstCreateContext* pCxt, SNode* pExpr, EOrder order SNode* createSessionWindowNode(SAstCreateContext* pCxt, SNode* pCol, SNode* pGap) { CHECK_PARSER_STATUS(pCxt); - SSessionWindowNode* session = (SSessionWindowNode*)nodesMakeNode(QUERY_NODE_SESSION_WINDOW); - CHECK_OUT_OF_MEM(session); + SSessionWindowNode* session = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_SESSION_WINDOW, (SNode**)&session); + CHECK_MAKE_NODE(session); session->pCol = (SColumnNode*)pCol; session->pGap = (SValueNode*)pGap; return (SNode*)session; @@ -1041,8 +1137,9 @@ SNode* createSessionWindowNode(SAstCreateContext* pCxt, SNode* pCol, SNode* pGap SNode* createStateWindowNode(SAstCreateContext* pCxt, SNode* pExpr) { CHECK_PARSER_STATUS(pCxt); - SStateWindowNode* state = (SStateWindowNode*)nodesMakeNode(QUERY_NODE_STATE_WINDOW); - CHECK_OUT_OF_MEM(state); + SStateWindowNode* state = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_STATE_WINDOW, (SNode**)&state); + CHECK_MAKE_NODE(state); state->pCol = createPrimaryKeyCol(pCxt, NULL); if (NULL == state->pCol) { nodesDestroyNode((SNode*)state); @@ -1054,8 +1151,9 @@ SNode* createStateWindowNode(SAstCreateContext* pCxt, SNode* pExpr) { SNode* createEventWindowNode(SAstCreateContext* pCxt, SNode* pStartCond, SNode* pEndCond) { CHECK_PARSER_STATUS(pCxt); - SEventWindowNode* pEvent = (SEventWindowNode*)nodesMakeNode(QUERY_NODE_EVENT_WINDOW); - CHECK_OUT_OF_MEM(pEvent); + SEventWindowNode* pEvent = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_EVENT_WINDOW, (SNode**)&pEvent); + CHECK_MAKE_NODE(pEvent); pEvent->pCol = createPrimaryKeyCol(pCxt, NULL); if (NULL == pEvent->pCol) { nodesDestroyNode((SNode*)pEvent); @@ -1068,8 +1166,9 @@ SNode* createEventWindowNode(SAstCreateContext* pCxt, SNode* pStartCond, SNode* SNode* createCountWindowNode(SAstCreateContext* pCxt, const SToken* pCountToken, const SToken* pSlidingToken) { CHECK_PARSER_STATUS(pCxt); - SCountWindowNode* pCount = (SCountWindowNode*)nodesMakeNode(QUERY_NODE_COUNT_WINDOW); - CHECK_OUT_OF_MEM(pCount); + SCountWindowNode* pCount = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_COUNT_WINDOW, (SNode**)&pCount); + CHECK_MAKE_NODE(pCount); pCount->pCol = createPrimaryKeyCol(pCxt, NULL); if (NULL == pCount->pCol) { nodesDestroyNode((SNode*)pCount); @@ -1083,8 +1182,9 @@ SNode* createCountWindowNode(SAstCreateContext* pCxt, const SToken* pCountToken, SNode* createIntervalWindowNode(SAstCreateContext* pCxt, SNode* pInterval, SNode* pOffset, SNode* pSliding, SNode* pFill) { CHECK_PARSER_STATUS(pCxt); - SIntervalWindowNode* interval = (SIntervalWindowNode*)nodesMakeNode(QUERY_NODE_INTERVAL_WINDOW); - CHECK_OUT_OF_MEM(interval); + SIntervalWindowNode* interval = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_INTERVAL_WINDOW, (SNode**)&interval); + CHECK_MAKE_NODE(interval); interval->pCol = createPrimaryKeyCol(pCxt, NULL); if (NULL == interval->pCol) { nodesDestroyNode((SNode*)interval); @@ -1099,8 +1199,9 @@ SNode* createIntervalWindowNode(SAstCreateContext* pCxt, SNode* pInterval, SNode SNode* createWindowOffsetNode(SAstCreateContext* pCxt, SNode* pStartOffset, SNode* pEndOffset) { CHECK_PARSER_STATUS(pCxt); - SWindowOffsetNode* winOffset = (SWindowOffsetNode*)nodesMakeNode(QUERY_NODE_WINDOW_OFFSET); - CHECK_OUT_OF_MEM(winOffset); + SWindowOffsetNode* winOffset = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_WINDOW_OFFSET, (SNode**)&winOffset); + CHECK_MAKE_NODE(winOffset); winOffset->pStartOffset = pStartOffset; winOffset->pEndOffset = pEndOffset; return (SNode*)winOffset; @@ -1108,14 +1209,16 @@ SNode* createWindowOffsetNode(SAstCreateContext* pCxt, SNode* pStartOffset, SNod SNode* createFillNode(SAstCreateContext* pCxt, EFillMode mode, SNode* pValues) { CHECK_PARSER_STATUS(pCxt); - SFillNode* fill = (SFillNode*)nodesMakeNode(QUERY_NODE_FILL); - CHECK_OUT_OF_MEM(fill); + SFillNode* fill = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_FILL, (SNode**)&fill); + CHECK_MAKE_NODE(fill); fill->mode = mode; fill->pValues = pValues; - fill->pWStartTs = nodesMakeNode(QUERY_NODE_FUNCTION); + fill->pWStartTs = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&(fill->pWStartTs)); if (NULL == fill->pWStartTs) { nodesDestroyNode((SNode*)fill); - CHECK_OUT_OF_MEM(NULL); + return NULL; } strcpy(((SFunctionNode*)fill->pWStartTs)->functionName, "_wstart"); return (SNode*)fill; @@ -1123,11 +1226,16 @@ SNode* createFillNode(SAstCreateContext* pCxt, EFillMode mode, SNode* pValues) { SNode* createGroupingSetNode(SAstCreateContext* pCxt, SNode* pNode) { CHECK_PARSER_STATUS(pCxt); - SGroupingSetNode* groupingSet = (SGroupingSetNode*)nodesMakeNode(QUERY_NODE_GROUPING_SET); - CHECK_OUT_OF_MEM(groupingSet); + SGroupingSetNode* groupingSet = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_GROUPING_SET, (SNode**)&groupingSet); + CHECK_MAKE_NODE(groupingSet); groupingSet->groupingSetType = GP_TYPE_NORMAL; - groupingSet->pParameterList = nodesMakeList(); - pCxt->errCode = nodesListAppend(groupingSet->pParameterList, pNode); + groupingSet->pParameterList = NULL; + pCxt->errCode = nodesListMakeAppend(&groupingSet->pParameterList, pNode); + if (TSDB_CODE_SUCCESS != pCxt->errCode) { + nodesDestroyNode((SNode*)groupingSet); + return NULL; + } CHECK_PARSER_STATUS(pCxt); return (SNode*)groupingSet; } @@ -1144,8 +1252,9 @@ SNode* createInterpTimePoint(SAstCreateContext* pCxt, SNode* pPoint) { SNode* createWhenThenNode(SAstCreateContext* pCxt, SNode* pWhen, SNode* pThen) { CHECK_PARSER_STATUS(pCxt); - SWhenThenNode* pWhenThen = (SWhenThenNode*)nodesMakeNode(QUERY_NODE_WHEN_THEN); - CHECK_OUT_OF_MEM(pWhenThen); + SWhenThenNode* pWhenThen = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_WHEN_THEN, (SNode**)&pWhenThen); + CHECK_MAKE_NODE(pWhenThen); pWhenThen->pWhen = pWhen; pWhenThen->pThen = pThen; return (SNode*)pWhenThen; @@ -1153,8 +1262,9 @@ SNode* createWhenThenNode(SAstCreateContext* pCxt, SNode* pWhen, SNode* pThen) { SNode* createCaseWhenNode(SAstCreateContext* pCxt, SNode* pCase, SNodeList* pWhenThenList, SNode* pElse) { CHECK_PARSER_STATUS(pCxt); - SCaseWhenNode* pCaseWhen = (SCaseWhenNode*)nodesMakeNode(QUERY_NODE_CASE_WHEN); - CHECK_OUT_OF_MEM(pCaseWhen); + SCaseWhenNode* pCaseWhen = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_CASE_WHEN, (SNode**)&pCaseWhen); + CHECK_MAKE_NODE(pCaseWhen); pCaseWhen->pCase = pCase; pCaseWhen->pWhenThenList = pWhenThenList; pCaseWhen->pElse = pElse; @@ -1303,8 +1413,9 @@ SNode* addWindowOffsetClause(SAstCreateContext* pCxt, SNode* pJoin, SNode* pWinO SNode* createSelectStmt(SAstCreateContext* pCxt, bool isDistinct, SNodeList* pProjectionList, SNode* pTable, SNodeList* pHint) { CHECK_PARSER_STATUS(pCxt); - SNode* select = createSelectStmtImpl(isDistinct, pProjectionList, pTable, pHint); - CHECK_OUT_OF_MEM(select); + SNode* select = NULL; + pCxt->errCode = createSelectStmtImpl(isDistinct, pProjectionList, pTable, pHint, &select); + CHECK_MAKE_NODE(select); return select; } @@ -1327,8 +1438,9 @@ static void setSubquery(SNode* pStmt) { SNode* createSetOperator(SAstCreateContext* pCxt, ESetOperatorType type, SNode* pLeft, SNode* pRight) { CHECK_PARSER_STATUS(pCxt); - SSetOperator* setOp = (SSetOperator*)nodesMakeNode(QUERY_NODE_SET_OPERATOR); - CHECK_OUT_OF_MEM(setOp); + SSetOperator* setOp = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_SET_OPERATOR, (SNode**)&setOp); + CHECK_MAKE_NODE(setOp); setOp->opType = type; setOp->pLeft = pLeft; setSubquery(setOp->pLeft); @@ -1354,8 +1466,9 @@ static void updateWalOptionsDefault(SDatabaseOptions* pOptions) { SNode* createDefaultDatabaseOptions(SAstCreateContext* pCxt) { CHECK_PARSER_STATUS(pCxt); - SDatabaseOptions* pOptions = (SDatabaseOptions*)nodesMakeNode(QUERY_NODE_DATABASE_OPTIONS); - CHECK_OUT_OF_MEM(pOptions); + SDatabaseOptions* pOptions = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_DATABASE_OPTIONS, (SNode**)&pOptions); + CHECK_MAKE_NODE(pOptions); pOptions->buffer = TSDB_DEFAULT_BUFFER_PER_VNODE; pOptions->cacheModel = TSDB_DEFAULT_CACHE_MODEL; pOptions->cacheLastSize = TSDB_DEFAULT_CACHE_SIZE; @@ -1392,8 +1505,9 @@ SNode* createDefaultDatabaseOptions(SAstCreateContext* pCxt) { SNode* createAlterDatabaseOptions(SAstCreateContext* pCxt) { CHECK_PARSER_STATUS(pCxt); - SDatabaseOptions* pOptions = (SDatabaseOptions*)nodesMakeNode(QUERY_NODE_DATABASE_OPTIONS); - CHECK_OUT_OF_MEM(pOptions); + SDatabaseOptions* pOptions = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_DATABASE_OPTIONS, (SNode**)&pOptions); + CHECK_MAKE_NODE(pOptions); pOptions->buffer = -1; pOptions->cacheModel = -1; pOptions->cacheLastSize = -1; @@ -1592,8 +1706,9 @@ SNode* createCreateDatabaseStmt(SAstCreateContext* pCxt, bool ignoreExists, STok if (!checkDbName(pCxt, pDbName, false)) { return NULL; } - SCreateDatabaseStmt* pStmt = (SCreateDatabaseStmt*)nodesMakeNode(QUERY_NODE_CREATE_DATABASE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SCreateDatabaseStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_CREATE_DATABASE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbName); pStmt->ignoreExists = ignoreExists; pStmt->pOptions = (SDatabaseOptions*)pOptions; @@ -1605,8 +1720,9 @@ SNode* createDropDatabaseStmt(SAstCreateContext* pCxt, bool ignoreNotExists, STo if (!checkDbName(pCxt, pDbName, false)) { return NULL; } - SDropDatabaseStmt* pStmt = (SDropDatabaseStmt*)nodesMakeNode(QUERY_NODE_DROP_DATABASE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SDropDatabaseStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_DROP_DATABASE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbName); pStmt->ignoreNotExists = ignoreNotExists; return (SNode*)pStmt; @@ -1617,8 +1733,9 @@ SNode* createAlterDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName, SNode* if (!checkDbName(pCxt, pDbName, false)) { return NULL; } - SAlterDatabaseStmt* pStmt = (SAlterDatabaseStmt*)nodesMakeNode(QUERY_NODE_ALTER_DATABASE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SAlterDatabaseStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_ALTER_DATABASE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbName); pStmt->pOptions = (SDatabaseOptions*)pOptions; return (SNode*)pStmt; @@ -1629,8 +1746,9 @@ SNode* createFlushDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName) { if (!checkDbName(pCxt, pDbName, false)) { return NULL; } - SFlushDatabaseStmt* pStmt = (SFlushDatabaseStmt*)nodesMakeNode(QUERY_NODE_FLUSH_DATABASE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SFlushDatabaseStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_FLUSH_DATABASE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbName); return (SNode*)pStmt; } @@ -1640,8 +1758,9 @@ SNode* createTrimDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName, int32_t if (!checkDbName(pCxt, pDbName, false)) { return NULL; } - STrimDatabaseStmt* pStmt = (STrimDatabaseStmt*)nodesMakeNode(QUERY_NODE_TRIM_DATABASE_STMT); - CHECK_OUT_OF_MEM(pStmt); + STrimDatabaseStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_TRIM_DATABASE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbName); pStmt->maxSpeed = maxSpeed; return (SNode*)pStmt; @@ -1652,8 +1771,9 @@ SNode* createS3MigrateDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName) { if (!checkDbName(pCxt, pDbName, false)) { return NULL; } - SS3MigrateDatabaseStmt* pStmt = (SS3MigrateDatabaseStmt*)nodesMakeNode(QUERY_NODE_S3MIGRATE_DATABASE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SS3MigrateDatabaseStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_S3MIGRATE_DATABASE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbName); return (SNode*)pStmt; } @@ -1663,8 +1783,9 @@ SNode* createCompactStmt(SAstCreateContext* pCxt, SToken* pDbName, SNode* pStart if (!checkDbName(pCxt, pDbName, false)) { return NULL; } - SCompactDatabaseStmt* pStmt = (SCompactDatabaseStmt*)nodesMakeNode(QUERY_NODE_COMPACT_DATABASE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SCompactDatabaseStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_COMPACT_DATABASE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbName); pStmt->pStart = pStart; pStmt->pEnd = pEnd; @@ -1673,8 +1794,9 @@ SNode* createCompactStmt(SAstCreateContext* pCxt, SToken* pDbName, SNode* pStart SNode* createDefaultTableOptions(SAstCreateContext* pCxt) { CHECK_PARSER_STATUS(pCxt); - STableOptions* pOptions = (STableOptions*)nodesMakeNode(QUERY_NODE_TABLE_OPTIONS); - CHECK_OUT_OF_MEM(pOptions); + STableOptions* pOptions = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_TABLE_OPTIONS, (SNode**)&pOptions); + CHECK_MAKE_NODE(pOptions); pOptions->maxDelay1 = -1; pOptions->maxDelay2 = -1; pOptions->watermark1 = TSDB_DEFAULT_ROLLUP_WATERMARK; @@ -1686,8 +1808,9 @@ SNode* createDefaultTableOptions(SAstCreateContext* pCxt) { SNode* createAlterTableOptions(SAstCreateContext* pCxt) { CHECK_PARSER_STATUS(pCxt); - STableOptions* pOptions = (STableOptions*)nodesMakeNode(QUERY_NODE_TABLE_OPTIONS); - CHECK_OUT_OF_MEM(pOptions); + STableOptions* pOptions = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_TABLE_OPTIONS, (SNode**)&pOptions); + CHECK_MAKE_NODE(pOptions); pOptions->ttl = -1; pOptions->commentNull = true; // mark null return (SNode*)pOptions; @@ -1734,8 +1857,9 @@ SNode* setTableOption(SAstCreateContext* pCxt, SNode* pOptions, ETableOptionType SNode* createDefaultColumnOptions(SAstCreateContext* pCxt) { CHECK_PARSER_STATUS(pCxt); - SColumnOptions* pOptions = (SColumnOptions*)nodesMakeNode(QUERY_NODE_COLUMN_OPTIONS); - CHECK_OUT_OF_MEM(pOptions); + SColumnOptions* pOptions = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_COLUMN_OPTIONS, (SNode**)&pOptions); + CHECK_MAKE_NODE(pOptions); pOptions->commentNull = true; pOptions->bPrimaryKey = false; return (SNode*)pOptions; @@ -1783,8 +1907,9 @@ SNode* createColumnDefNode(SAstCreateContext* pCxt, SToken* pColName, SDataType pCxt->errCode = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_VAR_COLUMN_LEN); return NULL; } - SColumnDefNode* pCol = (SColumnDefNode*)nodesMakeNode(QUERY_NODE_COLUMN_DEF); - CHECK_OUT_OF_MEM(pCol); + SColumnDefNode* pCol = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_COLUMN_DEF, (SNode**)&pCol); + CHECK_MAKE_NODE(pCol); COPY_STRING_FORM_ID_TOKEN(pCol->colName, pColName); pCol->dataType = dataType; pCol->pOptions = pNode; @@ -1808,8 +1933,9 @@ SDataType createVarLenDataType(uint8_t type, const SToken* pLen) { SNode* createCreateTableStmt(SAstCreateContext* pCxt, bool ignoreExists, SNode* pRealTable, SNodeList* pCols, SNodeList* pTags, SNode* pOptions) { CHECK_PARSER_STATUS(pCxt); - SCreateTableStmt* pStmt = (SCreateTableStmt*)nodesMakeNode(QUERY_NODE_CREATE_TABLE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SCreateTableStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_CREATE_TABLE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); strcpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName); strcpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName); pStmt->ignoreExists = ignoreExists; @@ -1823,8 +1949,9 @@ SNode* createCreateTableStmt(SAstCreateContext* pCxt, bool ignoreExists, SNode* SNode* createCreateSubTableClause(SAstCreateContext* pCxt, bool ignoreExists, SNode* pRealTable, SNode* pUseRealTable, SNodeList* pSpecificTags, SNodeList* pValsOfTags, SNode* pOptions) { CHECK_PARSER_STATUS(pCxt); - SCreateSubTableClause* pStmt = (SCreateSubTableClause*)nodesMakeNode(QUERY_NODE_CREATE_SUBTABLE_CLAUSE); - CHECK_OUT_OF_MEM(pStmt); + SCreateSubTableClause* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_CREATE_SUBTABLE_CLAUSE, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); strcpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName); strcpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName); strcpy(pStmt->useDbName, ((SRealTableNode*)pUseRealTable)->table.dbName); @@ -1841,9 +1968,9 @@ SNode* createCreateSubTableClause(SAstCreateContext* pCxt, bool ignoreExists, SN SNode* createCreateSubTableFromFileClause(SAstCreateContext* pCxt, bool ignoreExists, SNode* pUseRealTable, SNodeList* pSpecificTags, const SToken* pFilePath) { CHECK_PARSER_STATUS(pCxt); - SCreateSubTableFromFileClause* pStmt = - (SCreateSubTableFromFileClause*)nodesMakeNode(QUERY_NODE_CREATE_SUBTABLE_FROM_FILE_CLAUSE); - CHECK_OUT_OF_MEM(pStmt); + SCreateSubTableFromFileClause* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_CREATE_SUBTABLE_FROM_FILE_CLAUSE, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); strcpy(pStmt->useDbName, ((SRealTableNode*)pUseRealTable)->table.dbName); strcpy(pStmt->useTableName, ((SRealTableNode*)pUseRealTable)->table.tableName); pStmt->ignoreExists = ignoreExists; @@ -1860,16 +1987,18 @@ SNode* createCreateSubTableFromFileClause(SAstCreateContext* pCxt, bool ignoreEx SNode* createCreateMultiTableStmt(SAstCreateContext* pCxt, SNodeList* pSubTables) { CHECK_PARSER_STATUS(pCxt); - SCreateMultiTablesStmt* pStmt = (SCreateMultiTablesStmt*)nodesMakeNode(QUERY_NODE_CREATE_MULTI_TABLES_STMT); - CHECK_OUT_OF_MEM(pStmt); + SCreateMultiTablesStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_CREATE_MULTI_TABLES_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->pSubTables = pSubTables; return (SNode*)pStmt; } SNode* createDropTableClause(SAstCreateContext* pCxt, bool ignoreNotExists, SNode* pRealTable) { CHECK_PARSER_STATUS(pCxt); - SDropTableClause* pStmt = (SDropTableClause*)nodesMakeNode(QUERY_NODE_DROP_TABLE_CLAUSE); - CHECK_OUT_OF_MEM(pStmt); + SDropTableClause* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_DROP_TABLE_CLAUSE, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); strcpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName); strcpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName); pStmt->ignoreNotExists = ignoreNotExists; @@ -1879,16 +2008,18 @@ SNode* createDropTableClause(SAstCreateContext* pCxt, bool ignoreNotExists, SNod SNode* createDropTableStmt(SAstCreateContext* pCxt, SNodeList* pTables) { CHECK_PARSER_STATUS(pCxt); - SDropTableStmt* pStmt = (SDropTableStmt*)nodesMakeNode(QUERY_NODE_DROP_TABLE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SDropTableStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_DROP_TABLE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->pTables = pTables; return (SNode*)pStmt; } SNode* createDropSuperTableStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SNode* pRealTable) { CHECK_PARSER_STATUS(pCxt); - SDropSuperTableStmt* pStmt = (SDropSuperTableStmt*)nodesMakeNode(QUERY_NODE_DROP_SUPER_TABLE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SDropSuperTableStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_DROP_SUPER_TABLE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); strcpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName); strcpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName); pStmt->ignoreNotExists = ignoreNotExists; @@ -1905,8 +2036,9 @@ static SNode* createAlterTableStmtFinalize(SNode* pRealTable, SAlterTableStmt* p SNode* createAlterTableModifyOptions(SAstCreateContext* pCxt, SNode* pRealTable, SNode* pOptions) { CHECK_PARSER_STATUS(pCxt); - SAlterTableStmt* pStmt = (SAlterTableStmt*)nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SAlterTableStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->alterType = TSDB_ALTER_TABLE_UPDATE_OPTIONS; pStmt->pOptions = (STableOptions*)pOptions; return createAlterTableStmtFinalize(pRealTable, pStmt); @@ -1918,8 +2050,9 @@ SNode* createAlterTableAddModifyCol(SAstCreateContext* pCxt, SNode* pRealTable, if (!checkColumnName(pCxt, pColName)) { return NULL; } - SAlterTableStmt* pStmt = (SAlterTableStmt*)nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SAlterTableStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->alterType = alterType; COPY_STRING_FORM_ID_TOKEN(pStmt->colName, pColName); pStmt->dataType = dataType; @@ -1932,8 +2065,9 @@ SNode* createAlterTableAddModifyColOptions2(SAstCreateContext* pCxt, SNode* pRea return NULL; } - SAlterTableStmt* pStmt = (SAlterTableStmt*)nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SAlterTableStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->alterType = alterType; COPY_STRING_FORM_ID_TOKEN(pStmt->colName, pColName); pStmt->dataType = dataType; @@ -1964,8 +2098,9 @@ SNode* createAlterTableAddModifyColOptions(SAstCreateContext* pCxt, SNode* pReal if (!checkColumnName(pCxt, pColName)) { return NULL; } - SAlterTableStmt* pStmt = (SAlterTableStmt*)nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SAlterTableStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->alterType = TSDB_ALTER_TABLE_UPDATE_COLUMN_COMPRESS; COPY_STRING_FORM_ID_TOKEN(pStmt->colName, pColName); pStmt->pColOptions = (SColumnOptions*)pOptions; @@ -1977,8 +2112,9 @@ SNode* createAlterTableDropCol(SAstCreateContext* pCxt, SNode* pRealTable, int8_ if (!checkColumnName(pCxt, pColName)) { return NULL; } - SAlterTableStmt* pStmt = (SAlterTableStmt*)nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SAlterTableStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->alterType = alterType; COPY_STRING_FORM_ID_TOKEN(pStmt->colName, pColName); return createAlterTableStmtFinalize(pRealTable, pStmt); @@ -1990,8 +2126,9 @@ SNode* createAlterTableRenameCol(SAstCreateContext* pCxt, SNode* pRealTable, int if (!checkColumnName(pCxt, pOldColName) || !checkColumnName(pCxt, pNewColName)) { return NULL; } - SAlterTableStmt* pStmt = (SAlterTableStmt*)nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SAlterTableStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->alterType = alterType; COPY_STRING_FORM_ID_TOKEN(pStmt->colName, pOldColName); COPY_STRING_FORM_ID_TOKEN(pStmt->newColName, pNewColName); @@ -2004,8 +2141,9 @@ SNode* createAlterTableSetTag(SAstCreateContext* pCxt, SNode* pRealTable, SToken nodesDestroyNode(pVal); return NULL; } - SAlterTableStmt* pStmt = (SAlterTableStmt*)nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SAlterTableStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_ALTER_TABLE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->alterType = TSDB_ALTER_TABLE_UPDATE_TAG_VAL; COPY_STRING_FORM_ID_TOKEN(pStmt->colName, pTagName); pStmt->pVal = (SValueNode*)pVal; @@ -2023,8 +2161,9 @@ SNode* createUseDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName) { if (!checkDbName(pCxt, pDbName, false)) { return NULL; } - SUseDatabaseStmt* pStmt = (SUseDatabaseStmt*)nodesMakeNode(QUERY_NODE_USE_DATABASE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SUseDatabaseStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_USE_DATABASE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbName); return (SNode*)pStmt; } @@ -2038,24 +2177,27 @@ static bool needDbShowStmt(ENodeType type) { SNode* createShowStmt(SAstCreateContext* pCxt, ENodeType type) { CHECK_PARSER_STATUS(pCxt); - SShowStmt* pStmt = (SShowStmt*)nodesMakeNode(type); - CHECK_OUT_OF_MEM(pStmt); + SShowStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(type, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->withFull = false; return (SNode*)pStmt; } SNode* createShowStmtWithFull(SAstCreateContext* pCxt, ENodeType type) { CHECK_PARSER_STATUS(pCxt); - SShowStmt* pStmt = (SShowStmt*)nodesMakeNode(type); - CHECK_OUT_OF_MEM(pStmt); + SShowStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(type, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->withFull = true; return (SNode*)pStmt; } SNode* createShowCompactsStmt(SAstCreateContext* pCxt, ENodeType type) { CHECK_PARSER_STATUS(pCxt); - SShowCompactsStmt* pStmt = (SShowCompactsStmt*)nodesMakeNode(type); - CHECK_OUT_OF_MEM(pStmt); + SShowCompactsStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(type, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); return (SNode*)pStmt; } @@ -2076,8 +2218,9 @@ SNode* createShowStmtWithCond(SAstCreateContext* pCxt, ENodeType type, SNode* pD pCxt->errCode = TSDB_CODE_PAR_SYNTAX_ERROR; return NULL; } - SShowStmt* pStmt = (SShowStmt*)nodesMakeNode(type); - CHECK_OUT_OF_MEM(pStmt); + SShowStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(type, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->pDbName = pDbName; pStmt->pTbName = pTbName; pStmt->tableCondType = tableCondType; @@ -2103,8 +2246,9 @@ SNode* createShowCreateDatabaseStmt(SAstCreateContext* pCxt, SToken* pDbName) { if (!checkDbName(pCxt, pDbName, true)) { return NULL; } - SShowCreateDatabaseStmt* pStmt = (SShowCreateDatabaseStmt*)nodesMakeNode(QUERY_NODE_SHOW_CREATE_DATABASE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SShowCreateDatabaseStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_SHOW_CREATE_DATABASE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbName); return (SNode*)pStmt; } @@ -2128,8 +2272,14 @@ SNode* createShowAliveStmt(SAstCreateContext* pCxt, SNode* pNode, ENodeType type return NULL; } - SShowAliveStmt* pStmt = (SShowAliveStmt*)nodesMakeNode(type); - CHECK_OUT_OF_MEM(pStmt); + SShowAliveStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(type, (SNode**)&pStmt); + if (TSDB_CODE_SUCCESS != pCxt->errCode) { + if (pNode) { + nodesDestroyNode(pNode); + } + return NULL; + } if (pDbToken) { COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbToken); @@ -2143,8 +2293,9 @@ SNode* createShowAliveStmt(SAstCreateContext* pCxt, SNode* pNode, ENodeType type SNode* createShowCreateTableStmt(SAstCreateContext* pCxt, ENodeType type, SNode* pRealTable) { CHECK_PARSER_STATUS(pCxt); - SShowCreateTableStmt* pStmt = (SShowCreateTableStmt*)nodesMakeNode(type); - CHECK_OUT_OF_MEM(pStmt); + SShowCreateTableStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(type, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); strcpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName); strcpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName); nodesDestroyNode(pRealTable); @@ -2153,8 +2304,9 @@ SNode* createShowCreateTableStmt(SAstCreateContext* pCxt, ENodeType type, SNode* SNode* createShowCreateViewStmt(SAstCreateContext* pCxt, ENodeType type, SNode* pRealTable) { CHECK_PARSER_STATUS(pCxt); - SShowCreateViewStmt* pStmt = (SShowCreateViewStmt*)nodesMakeNode(type); - CHECK_OUT_OF_MEM(pStmt); + SShowCreateViewStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(type, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); strcpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName); strcpy(pStmt->viewName, ((SRealTableNode*)pRealTable)->table.tableName); nodesDestroyNode(pRealTable); @@ -2163,8 +2315,9 @@ SNode* createShowCreateViewStmt(SAstCreateContext* pCxt, ENodeType type, SNode* SNode* createShowTableDistributedStmt(SAstCreateContext* pCxt, SNode* pRealTable) { CHECK_PARSER_STATUS(pCxt); - SShowTableDistributedStmt* pStmt = (SShowTableDistributedStmt*)nodesMakeNode(QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT); - CHECK_OUT_OF_MEM(pStmt); + SShowTableDistributedStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_SHOW_TABLE_DISTRIBUTED_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); strcpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName); strcpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName); nodesDestroyNode(pRealTable); @@ -2173,8 +2326,9 @@ SNode* createShowTableDistributedStmt(SAstCreateContext* pCxt, SNode* pRealTable SNode* createShowDnodeVariablesStmt(SAstCreateContext* pCxt, SNode* pDnodeId, SNode* pLikePattern) { CHECK_PARSER_STATUS(pCxt); - SShowDnodeVariablesStmt* pStmt = (SShowDnodeVariablesStmt*)nodesMakeNode(QUERY_NODE_SHOW_DNODE_VARIABLES_STMT); - CHECK_OUT_OF_MEM(pStmt); + SShowDnodeVariablesStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_SHOW_DNODE_VARIABLES_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->pDnodeId = pDnodeId; pStmt->pLikePattern = pLikePattern; return (SNode*)pStmt; @@ -2182,8 +2336,9 @@ SNode* createShowDnodeVariablesStmt(SAstCreateContext* pCxt, SNode* pDnodeId, SN SNode* createShowVnodesStmt(SAstCreateContext* pCxt, SNode* pDnodeId, SNode* pDnodeEndpoint) { CHECK_PARSER_STATUS(pCxt); - SShowVnodesStmt* pStmt = (SShowVnodesStmt*)nodesMakeNode(QUERY_NODE_SHOW_VNODES_STMT); - CHECK_OUT_OF_MEM(pStmt); + SShowVnodesStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_SHOW_VNODES_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->pDnodeId = pDnodeId; pStmt->pDnodeEndpoint = pDnodeEndpoint; return (SNode*)pStmt; @@ -2196,8 +2351,9 @@ SNode* createShowTableTagsStmt(SAstCreateContext* pCxt, SNode* pTbName, SNode* p pCxt->errCode = TSDB_CODE_PAR_SYNTAX_ERROR; return NULL; } - SShowTableTagsStmt* pStmt = (SShowTableTagsStmt*)nodesMakeNode(QUERY_NODE_SHOW_TABLE_TAGS_STMT); - CHECK_OUT_OF_MEM(pStmt); + SShowTableTagsStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_SHOW_TABLE_TAGS_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->pDbName = pDbName; pStmt->pTbName = pTbName; pStmt->pTags = pTags; @@ -2206,7 +2362,9 @@ SNode* createShowTableTagsStmt(SAstCreateContext* pCxt, SNode* pTbName, SNode* p SNode* createShowCompactDetailsStmt(SAstCreateContext* pCxt, SNode* pCompactId) { CHECK_PARSER_STATUS(pCxt); - SShowCompactDetailsStmt* pStmt = (SShowCompactDetailsStmt*)nodesMakeNode(QUERY_NODE_SHOW_COMPACT_DETAILS_STMT); + SShowCompactDetailsStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_SHOW_COMPACT_DETAILS_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->pCompactId = pCompactId; return (SNode*)pStmt; } @@ -2296,8 +2454,9 @@ SNode* createCreateUserStmt(SAstCreateContext* pCxt, SToken* pUserName, const ST if (!checkUserName(pCxt, pUserName) || !checkPassword(pCxt, pPassword, password)) { return NULL; } - SCreateUserStmt* pStmt = (SCreateUserStmt*)nodesMakeNode(QUERY_NODE_CREATE_USER_STMT); - CHECK_OUT_OF_MEM(pStmt); + SCreateUserStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_CREATE_USER_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); COPY_STRING_FORM_ID_TOKEN(pStmt->userName, pUserName); strcpy(pStmt->password, password); pStmt->sysinfo = sysinfo; @@ -2311,8 +2470,9 @@ SNode* createAlterUserStmt(SAstCreateContext* pCxt, SToken* pUserName, int8_t al if (!checkUserName(pCxt, pUserName)) { return NULL; } - SAlterUserStmt* pStmt = (SAlterUserStmt*)nodesMakeNode(QUERY_NODE_ALTER_USER_STMT); - CHECK_OUT_OF_MEM(pStmt); + SAlterUserStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_ALTER_USER_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); COPY_STRING_FORM_ID_TOKEN(pStmt->userName, pUserName); pStmt->alterType = alterType; switch (alterType) { @@ -2371,16 +2531,18 @@ SNode* createDropUserStmt(SAstCreateContext* pCxt, SToken* pUserName) { if (!checkUserName(pCxt, pUserName)) { return NULL; } - SDropUserStmt* pStmt = (SDropUserStmt*)nodesMakeNode(QUERY_NODE_DROP_USER_STMT); - CHECK_OUT_OF_MEM(pStmt); + SDropUserStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_DROP_USER_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); COPY_STRING_FORM_ID_TOKEN(pStmt->userName, pUserName); return (SNode*)pStmt; } SNode* createCreateDnodeStmt(SAstCreateContext* pCxt, const SToken* pFqdn, const SToken* pPort) { CHECK_PARSER_STATUS(pCxt); - SCreateDnodeStmt* pStmt = (SCreateDnodeStmt*)nodesMakeNode(QUERY_NODE_CREATE_DNODE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SCreateDnodeStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_CREATE_DNODE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); if (!checkAndSplitEndpoint(pCxt, pFqdn, pPort, pStmt->fqdn, &pStmt->port)) { nodesDestroyNode((SNode*)pStmt); return NULL; @@ -2390,8 +2552,9 @@ SNode* createCreateDnodeStmt(SAstCreateContext* pCxt, const SToken* pFqdn, const SNode* createDropDnodeStmt(SAstCreateContext* pCxt, const SToken* pDnode, bool force, bool unsafe) { CHECK_PARSER_STATUS(pCxt); - SDropDnodeStmt* pStmt = (SDropDnodeStmt*)nodesMakeNode(QUERY_NODE_DROP_DNODE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SDropDnodeStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_DROP_DNODE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); if (TK_NK_INTEGER == pDnode->type) { pStmt->dnodeId = taosStr2Int32(pDnode->z, NULL, 10); } else { @@ -2408,8 +2571,9 @@ SNode* createDropDnodeStmt(SAstCreateContext* pCxt, const SToken* pDnode, bool f SNode* createAlterDnodeStmt(SAstCreateContext* pCxt, const SToken* pDnode, const SToken* pConfig, const SToken* pValue) { CHECK_PARSER_STATUS(pCxt); - SAlterDnodeStmt* pStmt = (SAlterDnodeStmt*)nodesMakeNode(QUERY_NODE_ALTER_DNODE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SAlterDnodeStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_ALTER_DNODE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); if (NULL != pDnode) { pStmt->dnodeId = taosStr2Int32(pDnode->z, NULL, 10); } else { @@ -2440,8 +2604,9 @@ SNode* createRealTableNodeForIndexName(SAstCreateContext* pCxt, SToken* pDbName, SNode* createCreateIndexStmt(SAstCreateContext* pCxt, EIndexType type, bool ignoreExists, SNode* pIndexName, SNode* pRealTable, SNodeList* pCols, SNode* pOptions) { CHECK_PARSER_STATUS(pCxt); - SCreateIndexStmt* pStmt = (SCreateIndexStmt*)nodesMakeNode(QUERY_NODE_CREATE_INDEX_STMT); - CHECK_OUT_OF_MEM(pStmt); + SCreateIndexStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_CREATE_INDEX_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->indexType = type; pStmt->ignoreExists = ignoreExists; @@ -2473,8 +2638,9 @@ SNode* createCreateIndexStmt(SAstCreateContext* pCxt, EIndexType type, bool igno SNode* createIndexOption(SAstCreateContext* pCxt, SNodeList* pFuncs, SNode* pInterval, SNode* pOffset, SNode* pSliding, SNode* pStreamOptions) { CHECK_PARSER_STATUS(pCxt); - SIndexOptions* pOptions = (SIndexOptions*)nodesMakeNode(QUERY_NODE_INDEX_OPTIONS); - CHECK_OUT_OF_MEM(pOptions); + SIndexOptions* pOptions = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_INDEX_OPTIONS, (SNode**)&pOptions); + CHECK_MAKE_NODE(pOptions); pOptions->pFuncs = pFuncs; pOptions->pInterval = pInterval; pOptions->pOffset = pOffset; @@ -2485,8 +2651,9 @@ SNode* createIndexOption(SAstCreateContext* pCxt, SNodeList* pFuncs, SNode* pInt SNode* createDropIndexStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SNode* pIndexName) { CHECK_PARSER_STATUS(pCxt); - SDropIndexStmt* pStmt = (SDropIndexStmt*)nodesMakeNode(QUERY_NODE_DROP_INDEX_STMT); - CHECK_OUT_OF_MEM(pStmt); + SDropIndexStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_DROP_INDEX_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->ignoreNotExists = ignoreNotExists; snprintf(pStmt->indexDbName, sizeof(pStmt->indexDbName), "%s", ((SRealTableNode*)pIndexName)->table.dbName); snprintf(pStmt->indexName, sizeof(pStmt->indexName), "%s", ((SRealTableNode*)pIndexName)->table.tableName); @@ -2496,24 +2663,27 @@ SNode* createDropIndexStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SNode* SNode* createCreateComponentNodeStmt(SAstCreateContext* pCxt, ENodeType type, const SToken* pDnodeId) { CHECK_PARSER_STATUS(pCxt); - SCreateComponentNodeStmt* pStmt = (SCreateComponentNodeStmt*)nodesMakeNode(type); - CHECK_OUT_OF_MEM(pStmt); + SCreateComponentNodeStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(type, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->dnodeId = taosStr2Int32(pDnodeId->z, NULL, 10); return (SNode*)pStmt; } SNode* createDropComponentNodeStmt(SAstCreateContext* pCxt, ENodeType type, const SToken* pDnodeId) { CHECK_PARSER_STATUS(pCxt); - SDropComponentNodeStmt* pStmt = (SDropComponentNodeStmt*)nodesMakeNode(type); - CHECK_OUT_OF_MEM(pStmt); + SDropComponentNodeStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(type, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->dnodeId = taosStr2Int32(pDnodeId->z, NULL, 10); return (SNode*)pStmt; } SNode* createRestoreComponentNodeStmt(SAstCreateContext* pCxt, ENodeType type, const SToken* pDnodeId) { CHECK_PARSER_STATUS(pCxt); - SRestoreComponentNodeStmt* pStmt = (SRestoreComponentNodeStmt*)nodesMakeNode(type); - CHECK_OUT_OF_MEM(pStmt); + SRestoreComponentNodeStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(type, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->dnodeId = taosStr2Int32(pDnodeId->z, NULL, 10); return (SNode*)pStmt; } @@ -2524,8 +2694,9 @@ SNode* createCreateTopicStmtUseQuery(SAstCreateContext* pCxt, bool ignoreExists, nodesDestroyNode(pQuery); return NULL; } - SCreateTopicStmt* pStmt = (SCreateTopicStmt*)nodesMakeNode(QUERY_NODE_CREATE_TOPIC_STMT); - CHECK_OUT_OF_MEM(pStmt); + SCreateTopicStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_CREATE_TOPIC_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); COPY_STRING_FORM_ID_TOKEN(pStmt->topicName, pTopicName); pStmt->ignoreExists = ignoreExists; pStmt->pQuery = pQuery; @@ -2538,8 +2709,9 @@ SNode* createCreateTopicStmtUseDb(SAstCreateContext* pCxt, bool ignoreExists, ST if (!checkTopicName(pCxt, pTopicName) || !checkDbName(pCxt, pSubDbName, true)) { return NULL; } - SCreateTopicStmt* pStmt = (SCreateTopicStmt*)nodesMakeNode(QUERY_NODE_CREATE_TOPIC_STMT); - CHECK_OUT_OF_MEM(pStmt); + SCreateTopicStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_CREATE_TOPIC_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); COPY_STRING_FORM_ID_TOKEN(pStmt->topicName, pTopicName); pStmt->ignoreExists = ignoreExists; COPY_STRING_FORM_ID_TOKEN(pStmt->subDbName, pSubDbName); @@ -2553,8 +2725,9 @@ SNode* createCreateTopicStmtUseTable(SAstCreateContext* pCxt, bool ignoreExists, if (!checkTopicName(pCxt, pTopicName)) { return NULL; } - SCreateTopicStmt* pStmt = (SCreateTopicStmt*)nodesMakeNode(QUERY_NODE_CREATE_TOPIC_STMT); - CHECK_OUT_OF_MEM(pStmt); + SCreateTopicStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_CREATE_TOPIC_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); COPY_STRING_FORM_ID_TOKEN(pStmt->topicName, pTopicName); pStmt->ignoreExists = ignoreExists; pStmt->withMeta = withMeta; @@ -2571,8 +2744,9 @@ SNode* createDropTopicStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SToken if (!checkTopicName(pCxt, pTopicName)) { return NULL; } - SDropTopicStmt* pStmt = (SDropTopicStmt*)nodesMakeNode(QUERY_NODE_DROP_TOPIC_STMT); - CHECK_OUT_OF_MEM(pStmt); + SDropTopicStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_DROP_TOPIC_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); COPY_STRING_FORM_ID_TOKEN(pStmt->topicName, pTopicName); pStmt->ignoreNotExists = ignoreNotExists; return (SNode*)pStmt; @@ -2586,8 +2760,9 @@ SNode* createDropCGroupStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SToke if (!checkCGroupName(pCxt, pCGroupId)) { return NULL; } - SDropCGroupStmt* pStmt = (SDropCGroupStmt*)nodesMakeNode(QUERY_NODE_DROP_CGROUP_STMT); - CHECK_OUT_OF_MEM(pStmt); + SDropCGroupStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_DROP_CGROUP_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->ignoreNotExists = ignoreNotExists; COPY_STRING_FORM_ID_TOKEN(pStmt->topicName, pTopicName); COPY_STRING_FORM_ID_TOKEN(pStmt->cgroup, pCGroupId); @@ -2596,8 +2771,9 @@ SNode* createDropCGroupStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SToke SNode* createAlterClusterStmt(SAstCreateContext* pCxt, const SToken* pConfig, const SToken* pValue) { CHECK_PARSER_STATUS(pCxt); - SAlterClusterStmt* pStmt = (SAlterClusterStmt*)nodesMakeNode(QUERY_NODE_ALTER_CLUSTER_STMT); - CHECK_OUT_OF_MEM(pStmt); + SAlterClusterStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_ALTER_CLUSTER_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); (void)trimString(pConfig->z, pConfig->n, pStmt->config, sizeof(pStmt->config)); if (NULL != pValue) { (void)trimString(pValue->z, pValue->n, pStmt->value, sizeof(pStmt->value)); @@ -2607,8 +2783,9 @@ SNode* createAlterClusterStmt(SAstCreateContext* pCxt, const SToken* pConfig, co SNode* createAlterLocalStmt(SAstCreateContext* pCxt, const SToken* pConfig, const SToken* pValue) { CHECK_PARSER_STATUS(pCxt); - SAlterLocalStmt* pStmt = (SAlterLocalStmt*)nodesMakeNode(QUERY_NODE_ALTER_LOCAL_STMT); - CHECK_OUT_OF_MEM(pStmt); + SAlterLocalStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_ALTER_LOCAL_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); (void)trimString(pConfig->z, pConfig->n, pStmt->config, sizeof(pStmt->config)); if (NULL != pValue) { (void)trimString(pValue->z, pValue->n, pStmt->value, sizeof(pStmt->value)); @@ -2618,8 +2795,9 @@ SNode* createAlterLocalStmt(SAstCreateContext* pCxt, const SToken* pConfig, cons SNode* createDefaultExplainOptions(SAstCreateContext* pCxt) { CHECK_PARSER_STATUS(pCxt); - SExplainOptions* pOptions = (SExplainOptions*)nodesMakeNode(QUERY_NODE_EXPLAIN_OPTIONS); - CHECK_OUT_OF_MEM(pOptions); + SExplainOptions* pOptions = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_EXPLAIN_OPTIONS, (SNode**)&pOptions); + CHECK_MAKE_NODE(pOptions); pOptions->verbose = TSDB_DEFAULT_EXPLAIN_VERBOSE; pOptions->ratio = TSDB_DEFAULT_EXPLAIN_RATIO; return (SNode*)pOptions; @@ -2639,8 +2817,9 @@ SNode* setExplainRatio(SAstCreateContext* pCxt, SNode* pOptions, const SToken* p SNode* createExplainStmt(SAstCreateContext* pCxt, bool analyze, SNode* pOptions, SNode* pQuery) { CHECK_PARSER_STATUS(pCxt); - SExplainStmt* pStmt = (SExplainStmt*)nodesMakeNode(QUERY_NODE_EXPLAIN_STMT); - CHECK_OUT_OF_MEM(pStmt); + SExplainStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_EXPLAIN_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->analyze = analyze; pStmt->pOptions = (SExplainOptions*)pOptions; pStmt->pQuery = pQuery; @@ -2649,8 +2828,9 @@ SNode* createExplainStmt(SAstCreateContext* pCxt, bool analyze, SNode* pOptions, SNode* createDescribeStmt(SAstCreateContext* pCxt, SNode* pRealTable) { CHECK_PARSER_STATUS(pCxt); - SDescribeStmt* pStmt = (SDescribeStmt*)nodesMakeNode(QUERY_NODE_DESCRIBE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SDescribeStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_DESCRIBE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); strcpy(pStmt->dbName, ((SRealTableNode*)pRealTable)->table.dbName); strcpy(pStmt->tableName, ((SRealTableNode*)pRealTable)->table.tableName); nodesDestroyNode(pRealTable); @@ -2659,8 +2839,9 @@ SNode* createDescribeStmt(SAstCreateContext* pCxt, SNode* pRealTable) { SNode* createResetQueryCacheStmt(SAstCreateContext* pCxt) { CHECK_PARSER_STATUS(pCxt); - SNode* pStmt = nodesMakeNode(QUERY_NODE_RESET_QUERY_CACHE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SNode* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_RESET_QUERY_CACHE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); return pStmt; } @@ -2688,8 +2869,9 @@ SNode* createCreateFunctionStmt(SAstCreateContext* pCxt, bool ignoreExists, bool if (TSDB_CODE_SUCCESS != convertUdfLanguageType(pCxt, pLanguage, &language)) { return NULL; } - SCreateFunctionStmt* pStmt = (SCreateFunctionStmt*)nodesMakeNode(QUERY_NODE_CREATE_FUNCTION_STMT); - CHECK_OUT_OF_MEM(pStmt); + SCreateFunctionStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_CREATE_FUNCTION_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->orReplace = orReplace; pStmt->ignoreExists = ignoreExists; COPY_STRING_FORM_ID_TOKEN(pStmt->funcName, pFuncName); @@ -2703,8 +2885,9 @@ SNode* createCreateFunctionStmt(SAstCreateContext* pCxt, bool ignoreExists, bool SNode* createDropFunctionStmt(SAstCreateContext* pCxt, bool ignoreNotExists, const SToken* pFuncName) { CHECK_PARSER_STATUS(pCxt); - SDropFunctionStmt* pStmt = (SDropFunctionStmt*)nodesMakeNode(QUERY_NODE_DROP_FUNCTION_STMT); - CHECK_OUT_OF_MEM(pStmt); + SDropFunctionStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_DROP_FUNCTION_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->ignoreNotExists = ignoreNotExists; COPY_STRING_FORM_ID_TOKEN(pStmt->funcName, pFuncName); return (SNode*)pStmt; @@ -2712,8 +2895,9 @@ SNode* createDropFunctionStmt(SAstCreateContext* pCxt, bool ignoreNotExists, con SNode* createCreateViewStmt(SAstCreateContext* pCxt, bool orReplace, SNode* pView, const SToken* pAs, SNode* pQuery) { CHECK_PARSER_STATUS(pCxt); - SCreateViewStmt* pStmt = (SCreateViewStmt*)nodesMakeNode(QUERY_NODE_CREATE_VIEW_STMT); - CHECK_OUT_OF_MEM(pStmt); + SCreateViewStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_CREATE_VIEW_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); int32_t i = pAs->n; while (isspace(*(pAs->z + i))) { ++i; @@ -2730,8 +2914,9 @@ SNode* createCreateViewStmt(SAstCreateContext* pCxt, bool orReplace, SNode* pVie SNode* createDropViewStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SNode* pView) { CHECK_PARSER_STATUS(pCxt); - SDropViewStmt* pStmt = (SDropViewStmt*)nodesMakeNode(QUERY_NODE_DROP_VIEW_STMT); - CHECK_OUT_OF_MEM(pStmt); + SDropViewStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_DROP_VIEW_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->ignoreNotExists = ignoreNotExists; strcpy(pStmt->dbName, ((SViewNode*)pView)->table.dbName); strcpy(pStmt->viewName, ((SViewNode*)pView)->table.tableName); @@ -2741,8 +2926,9 @@ SNode* createDropViewStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SNode* SNode* createStreamOptions(SAstCreateContext* pCxt) { CHECK_PARSER_STATUS(pCxt); - SStreamOptions* pOptions = (SStreamOptions*)nodesMakeNode(QUERY_NODE_STREAM_OPTIONS); - CHECK_OUT_OF_MEM(pOptions); + SStreamOptions* pOptions = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_STREAM_OPTIONS, (SNode**)&pOptions); + CHECK_MAKE_NODE(pOptions); pOptions->triggerType = STREAM_TRIGGER_WINDOW_CLOSE; pOptions->fillHistory = STREAM_DEFAULT_FILL_HISTORY; pOptions->ignoreExpired = STREAM_DEFAULT_IGNORE_EXPIRED; @@ -2811,8 +2997,9 @@ SNode* createCreateStreamStmt(SAstCreateContext* pCxt, bool ignoreExists, SToken nodesDestroyNode(pOptions); return NULL; } - SCreateStreamStmt* pStmt = (SCreateStreamStmt*)nodesMakeNode(QUERY_NODE_CREATE_STREAM_STMT); - CHECK_OUT_OF_MEM(pStmt); + SCreateStreamStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_CREATE_STREAM_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); COPY_STRING_FORM_ID_TOKEN(pStmt->streamName, pStreamName); strcpy(pStmt->targetDbName, ((SRealTableNode*)pRealTable)->table.dbName); strcpy(pStmt->targetTabName, ((SRealTableNode*)pRealTable)->table.tableName); @@ -2831,8 +3018,9 @@ SNode* createDropStreamStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SToke if (!checkStreamName(pCxt, pStreamName)) { return NULL; } - SDropStreamStmt* pStmt = (SDropStreamStmt*)nodesMakeNode(QUERY_NODE_DROP_STREAM_STMT); - CHECK_OUT_OF_MEM(pStmt); + SDropStreamStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_DROP_STREAM_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); COPY_STRING_FORM_ID_TOKEN(pStmt->streamName, pStreamName); pStmt->ignoreNotExists = ignoreNotExists; return (SNode*)pStmt; @@ -2843,8 +3031,9 @@ SNode* createPauseStreamStmt(SAstCreateContext* pCxt, bool ignoreNotExists, STok if (!checkStreamName(pCxt, pStreamName)) { return NULL; } - SPauseStreamStmt* pStmt = (SPauseStreamStmt*)nodesMakeNode(QUERY_NODE_PAUSE_STREAM_STMT); - CHECK_OUT_OF_MEM(pStmt); + SPauseStreamStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_PAUSE_STREAM_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); COPY_STRING_FORM_ID_TOKEN(pStmt->streamName, pStreamName); pStmt->ignoreNotExists = ignoreNotExists; return (SNode*)pStmt; @@ -2856,8 +3045,9 @@ SNode* createResumeStreamStmt(SAstCreateContext* pCxt, bool ignoreNotExists, boo if (!checkStreamName(pCxt, pStreamName)) { return NULL; } - SResumeStreamStmt* pStmt = (SResumeStreamStmt*)nodesMakeNode(QUERY_NODE_RESUME_STREAM_STMT); - CHECK_OUT_OF_MEM(pStmt); + SResumeStreamStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_RESUME_STREAM_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); COPY_STRING_FORM_ID_TOKEN(pStmt->streamName, pStreamName); pStmt->ignoreNotExists = ignoreNotExists; pStmt->ignoreUntreated = ignoreUntreated; @@ -2866,31 +3056,35 @@ SNode* createResumeStreamStmt(SAstCreateContext* pCxt, bool ignoreNotExists, boo SNode* createKillStmt(SAstCreateContext* pCxt, ENodeType type, const SToken* pId) { CHECK_PARSER_STATUS(pCxt); - SKillStmt* pStmt = (SKillStmt*)nodesMakeNode(type); - CHECK_OUT_OF_MEM(pStmt); + SKillStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(type, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->targetId = taosStr2Int32(pId->z, NULL, 10); return (SNode*)pStmt; } SNode* createKillQueryStmt(SAstCreateContext* pCxt, const SToken* pQueryId) { CHECK_PARSER_STATUS(pCxt); - SKillQueryStmt* pStmt = (SKillQueryStmt*)nodesMakeNode(QUERY_NODE_KILL_QUERY_STMT); - CHECK_OUT_OF_MEM(pStmt); + SKillQueryStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_KILL_QUERY_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); (void)trimString(pQueryId->z, pQueryId->n, pStmt->queryId, sizeof(pStmt->queryId) - 1); return (SNode*)pStmt; } SNode* createBalanceVgroupStmt(SAstCreateContext* pCxt) { CHECK_PARSER_STATUS(pCxt); - SBalanceVgroupStmt* pStmt = (SBalanceVgroupStmt*)nodesMakeNode(QUERY_NODE_BALANCE_VGROUP_STMT); - CHECK_OUT_OF_MEM(pStmt); + SBalanceVgroupStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_BALANCE_VGROUP_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); return (SNode*)pStmt; } SNode* createBalanceVgroupLeaderStmt(SAstCreateContext* pCxt, const SToken* pVgId) { CHECK_PARSER_STATUS(pCxt); - SBalanceVgroupLeaderStmt* pStmt = (SBalanceVgroupLeaderStmt*)nodesMakeNode(QUERY_NODE_BALANCE_VGROUP_LEADER_STMT); - CHECK_OUT_OF_MEM(pStmt); + SBalanceVgroupLeaderStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_BALANCE_VGROUP_LEADER_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); if (NULL != pVgId && NULL != pVgId->z) { pStmt->vgId = taosStr2Int32(pVgId->z, NULL, 10); } @@ -2899,9 +3093,9 @@ SNode* createBalanceVgroupLeaderStmt(SAstCreateContext* pCxt, const SToken* pVgI SNode* createBalanceVgroupLeaderDBNameStmt(SAstCreateContext* pCxt, const SToken* pDbName) { CHECK_PARSER_STATUS(pCxt); - SBalanceVgroupLeaderStmt* pStmt = - (SBalanceVgroupLeaderStmt*)nodesMakeNode(QUERY_NODE_BALANCE_VGROUP_LEADER_DATABASE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SBalanceVgroupLeaderStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_BALANCE_VGROUP_LEADER_DATABASE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); if (NULL != pDbName) { COPY_STRING_FORM_ID_TOKEN(pStmt->dbName, pDbName); } @@ -2910,8 +3104,9 @@ SNode* createBalanceVgroupLeaderDBNameStmt(SAstCreateContext* pCxt, const SToken SNode* createMergeVgroupStmt(SAstCreateContext* pCxt, const SToken* pVgId1, const SToken* pVgId2) { CHECK_PARSER_STATUS(pCxt); - SMergeVgroupStmt* pStmt = (SMergeVgroupStmt*)nodesMakeNode(QUERY_NODE_MERGE_VGROUP_STMT); - CHECK_OUT_OF_MEM(pStmt); + SMergeVgroupStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_MERGE_VGROUP_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->vgId1 = taosStr2Int32(pVgId1->z, NULL, 10); pStmt->vgId2 = taosStr2Int32(pVgId2->z, NULL, 10); return (SNode*)pStmt; @@ -2919,8 +3114,9 @@ SNode* createMergeVgroupStmt(SAstCreateContext* pCxt, const SToken* pVgId1, cons SNode* createRedistributeVgroupStmt(SAstCreateContext* pCxt, const SToken* pVgId, SNodeList* pDnodes) { CHECK_PARSER_STATUS(pCxt); - SRedistributeVgroupStmt* pStmt = (SRedistributeVgroupStmt*)nodesMakeNode(QUERY_NODE_REDISTRIBUTE_VGROUP_STMT); - CHECK_OUT_OF_MEM(pStmt); + SRedistributeVgroupStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_REDISTRIBUTE_VGROUP_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->vgId = taosStr2Int32(pVgId->z, NULL, 10); pStmt->pDnodes = pDnodes; return (SNode*)pStmt; @@ -2928,16 +3124,18 @@ SNode* createRedistributeVgroupStmt(SAstCreateContext* pCxt, const SToken* pVgId SNode* createSplitVgroupStmt(SAstCreateContext* pCxt, const SToken* pVgId) { CHECK_PARSER_STATUS(pCxt); - SSplitVgroupStmt* pStmt = (SSplitVgroupStmt*)nodesMakeNode(QUERY_NODE_SPLIT_VGROUP_STMT); - CHECK_OUT_OF_MEM(pStmt); + SSplitVgroupStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_SPLIT_VGROUP_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->vgId = taosStr2Int32(pVgId->z, NULL, 10); return (SNode*)pStmt; } SNode* createSyncdbStmt(SAstCreateContext* pCxt, const SToken* pDbName) { CHECK_PARSER_STATUS(pCxt); - SNode* pStmt = nodesMakeNode(QUERY_NODE_SYNCDB_STMT); - CHECK_OUT_OF_MEM(pStmt); + SNode* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_SYNCDB_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); return pStmt; } @@ -2948,8 +3146,9 @@ SNode* createGrantStmt(SAstCreateContext* pCxt, int64_t privileges, STokenPair* !checkTableName(pCxt, &pPrivLevel->second)) { return NULL; } - SGrantStmt* pStmt = (SGrantStmt*)nodesMakeNode(QUERY_NODE_GRANT_STMT); - CHECK_OUT_OF_MEM(pStmt); + SGrantStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_GRANT_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->privileges = privileges; COPY_STRING_FORM_ID_TOKEN(pStmt->objName, &pPrivLevel->first); if (TK_NK_NIL != pPrivLevel->second.type && TK_NK_STAR != pPrivLevel->second.type) { @@ -2966,8 +3165,9 @@ SNode* createRevokeStmt(SAstCreateContext* pCxt, int64_t privileges, STokenPair* if (!checkDbName(pCxt, &pPrivLevel->first, false) || !checkUserName(pCxt, pUserName)) { return NULL; } - SRevokeStmt* pStmt = (SRevokeStmt*)nodesMakeNode(QUERY_NODE_REVOKE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SRevokeStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_REVOKE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->privileges = privileges; COPY_STRING_FORM_ID_TOKEN(pStmt->objName, &pPrivLevel->first); if (TK_NK_NIL != pPrivLevel->second.type && TK_NK_STAR != pPrivLevel->second.type) { @@ -2979,8 +3179,9 @@ SNode* createRevokeStmt(SAstCreateContext* pCxt, int64_t privileges, STokenPair* } SNode* createFuncForDelete(SAstCreateContext* pCxt, const char* pFuncName) { - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); - CHECK_OUT_OF_MEM(pFunc); + SFunctionNode* pFunc = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); + CHECK_MAKE_NODE(pFunc); snprintf(pFunc->functionName, sizeof(pFunc->functionName), "%s", pFuncName); if (TSDB_CODE_SUCCESS != nodesListMakeStrictAppend(&pFunc->pParameterList, createPrimaryKeyCol(pCxt, NULL))) { nodesDestroyNode((SNode*)pFunc); @@ -2991,8 +3192,9 @@ SNode* createFuncForDelete(SAstCreateContext* pCxt, const char* pFuncName) { SNode* createDeleteStmt(SAstCreateContext* pCxt, SNode* pTable, SNode* pWhere) { CHECK_PARSER_STATUS(pCxt); - SDeleteStmt* pStmt = (SDeleteStmt*)nodesMakeNode(QUERY_NODE_DELETE_STMT); - CHECK_OUT_OF_MEM(pStmt); + SDeleteStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_DELETE_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->pFromTable = pTable; pStmt->pWhere = pWhere; pStmt->pCountFunc = createFuncForDelete(pCxt, "count"); @@ -3007,8 +3209,9 @@ SNode* createDeleteStmt(SAstCreateContext* pCxt, SNode* pTable, SNode* pWhere) { SNode* createInsertStmt(SAstCreateContext* pCxt, SNode* pTable, SNodeList* pCols, SNode* pQuery) { CHECK_PARSER_STATUS(pCxt); - SInsertStmt* pStmt = (SInsertStmt*)nodesMakeNode(QUERY_NODE_INSERT_STMT); - CHECK_OUT_OF_MEM(pStmt); + SInsertStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_INSERT_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->pTable = pTable; pStmt->pCols = pCols; pStmt->pQuery = pQuery; @@ -3028,18 +3231,18 @@ SNode* createCreateTSMAStmt(SAstCreateContext* pCxt, bool ignoreExists, SToken* return NULL; } - SCreateTSMAStmt* pStmt = (SCreateTSMAStmt*)nodesMakeNode(QUERY_NODE_CREATE_TSMA_STMT); - CHECK_OUT_OF_MEM(pStmt); + SCreateTSMAStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_CREATE_TSMA_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->ignoreExists = ignoreExists; if (!pOptions) { // recursive tsma - pStmt->pOptions = (STSMAOptions*)nodesMakeNode(QUERY_NODE_TSMA_OPTIONS); + pStmt->pOptions = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_TSMA_OPTIONS, (SNode**)&pStmt->pOptions); if (!pStmt->pOptions) { nodesDestroyNode(pInterval); nodesDestroyNode((SNode*)pStmt); - pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; - snprintf(pCxt->pQueryCxt->pMsg, pCxt->pQueryCxt->msgLen, "Out of memory"); return NULL; } pStmt->pOptions->recursiveTsma = true; @@ -3060,28 +3263,26 @@ SNode* createCreateTSMAStmt(SAstCreateContext* pCxt, bool ignoreExists, SToken* SNode* createTSMAOptions(SAstCreateContext* pCxt, SNodeList* pFuncs) { CHECK_PARSER_STATUS(pCxt); - STSMAOptions* pOptions = (STSMAOptions*)nodesMakeNode(QUERY_NODE_TSMA_OPTIONS); - if (!pOptions) { - // nodesDestroyList(pTSMAFuncs); - pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; - snprintf(pCxt->pQueryCxt->pMsg, pCxt->pQueryCxt->msgLen, "Out of memory"); - return NULL; - } + STSMAOptions* pOptions = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_TSMA_OPTIONS, (SNode**)&pOptions); + CHECK_MAKE_NODE(pOptions); pOptions->pFuncs = pFuncs; return (SNode*)pOptions; } SNode* createDefaultTSMAOptions(SAstCreateContext* pCxt) { CHECK_PARSER_STATUS(pCxt); - STSMAOptions* pOptions = (STSMAOptions*)nodesMakeNode(QUERY_NODE_TSMA_OPTIONS); - CHECK_OUT_OF_MEM(pOptions); + STSMAOptions* pOptions = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_TSMA_OPTIONS, (SNode**)&pOptions); + CHECK_MAKE_NODE(pOptions); return (SNode*)pOptions; } SNode* createDropTSMAStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SNode* pRealTable) { CHECK_PARSER_STATUS(pCxt); - SDropTSMAStmt* pStmt = (SDropTSMAStmt*)nodesMakeNode(QUERY_NODE_DROP_TSMA_STMT); - CHECK_OUT_OF_MEM(pStmt); + SDropTSMAStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_DROP_TSMA_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->ignoreNotExists = ignoreNotExists; SRealTableNode* pTableNode = (SRealTableNode*)pRealTable; @@ -3096,8 +3297,9 @@ SNode* createDropTSMAStmt(SAstCreateContext* pCxt, bool ignoreNotExists, SNode* SNode* createShowTSMASStmt(SAstCreateContext* pCxt, SNode* dbName) { CHECK_PARSER_STATUS(pCxt); - SShowStmt* pStmt = (SShowStmt*)nodesMakeNode(QUERY_NODE_SHOW_TSMAS_STMT); - CHECK_OUT_OF_MEM(pStmt); + SShowStmt* pStmt = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_SHOW_TSMAS_STMT, (SNode**)&pStmt); + CHECK_MAKE_NODE(pStmt); pStmt->pDbName = dbName; return (SNode*)pStmt; diff --git a/source/libs/parser/src/parAstParser.c b/source/libs/parser/src/parAstParser.c index fa4b57c2b4..49be0b8d90 100644 --- a/source/libs/parser/src/parAstParser.c +++ b/source/libs/parser/src/parAstParser.c @@ -30,9 +30,10 @@ extern void ParseFree(void*, FFree); extern void ParseTrace(FILE*, char*); int32_t buildQueryAfterParse(SQuery** pQuery, SNode* pRootNode, int16_t placeholderNo, SArray** pPlaceholderValues) { - *pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY); + *pQuery = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)pQuery); if (NULL == *pQuery) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } (*pQuery)->pRoot = pRootNode; (*pQuery)->placeholderNum = placeholderNo; @@ -424,7 +425,7 @@ static int32_t collectMetaKeyFromDescribe(SCollectMetaKeyCxt* pCxt, SDescribeStm #ifdef TD_ENTERPRISE if (TSDB_CODE_SUCCESS == code) { char dbFName[TSDB_DB_FNAME_LEN]; - tNameGetFullDbName(&name, dbFName); + (void)tNameGetFullDbName(&name, dbFName); code = catalogRemoveViewMeta(pCxt->pParseCxt->pCatalog, dbFName, 0, pStmt->tableName, 0); } #endif @@ -439,9 +440,9 @@ static int32_t collectMetaKeyFromCreateStream(SCollectMetaKeyCxt* pCxt, SCreateS reserveTableMetaInCache(pCxt->pParseCxt->acctId, pStmt->targetDbName, pStmt->targetTabName, pCxt->pMetaCache); if (TSDB_CODE_SUCCESS == code && NULL != pStmt->pSubtable && NULL != pStmt->pQuery) { SSelectStmt* pSelect = (SSelectStmt*)pStmt->pQuery; - pSelect->pSubtable = nodesCloneNode(pStmt->pSubtable); + int32_t code = nodesCloneNode(pStmt->pSubtable, &pSelect->pSubtable); if (NULL == pSelect->pSubtable) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } } if (TSDB_CODE_SUCCESS == code) { @@ -724,7 +725,7 @@ static int32_t collectMetaKeyFromShowCreateView(SCollectMetaKeyCxt* pCxt, SShowC strcpy(name.dbname, pStmt->dbName); strcpy(name.tname, pStmt->viewName); char dbFName[TSDB_DB_FNAME_LEN]; - tNameGetFullDbName(&name, dbFName); + (void)tNameGetFullDbName(&name, dbFName); int32_t code = catalogRemoveViewMeta(pCxt->pParseCxt->pCatalog, dbFName, 0, pStmt->viewName, 0); if (TSDB_CODE_SUCCESS == code) { code = reserveViewUserAuthInCache(pCxt->pParseCxt->acctId, pCxt->pParseCxt->pUser, pStmt->dbName, pStmt->viewName, diff --git a/source/libs/parser/src/parAuthenticator.c b/source/libs/parser/src/parAuthenticator.c index 03fda3681f..60cc1024bf 100644 --- a/source/libs/parser/src/parAuthenticator.c +++ b/source/libs/parser/src/parAuthenticator.c @@ -34,7 +34,7 @@ typedef struct SAuthRewriteCxt { static int32_t authQuery(SAuthCxt* pCxt, SNode* pStmt); -static void setUserAuthInfo(SParseContext* pCxt, const char* pDbName, const char* pTabName, AUTH_TYPE type, +static int32_t setUserAuthInfo(SParseContext* pCxt, const char* pDbName, const char* pTabName, AUTH_TYPE type, bool isView, bool effective, SUserAuthInfo* pAuth) { if (effective) { snprintf(pAuth->user, sizeof(pAuth->user), "%s", pCxt->pEffectiveUser ? pCxt->pEffectiveUser : ""); @@ -43,12 +43,14 @@ static void setUserAuthInfo(SParseContext* pCxt, const char* pDbName, const char } if (NULL == pTabName) { - tNameSetDbName(&pAuth->tbName, pCxt->acctId, pDbName, strlen(pDbName)); + int32_t code = tNameSetDbName(&pAuth->tbName, pCxt->acctId, pDbName, strlen(pDbName)); + if (TSDB_CODE_SUCCESS != code) return code; } else { - toName(pCxt->acctId, pDbName, pTabName, &pAuth->tbName); + (void)toName(pCxt->acctId, pDbName, pTabName, &pAuth->tbName); } pAuth->type = type; pAuth->isView = isView; + return TSDB_CODE_SUCCESS; } static int32_t checkAuthImpl(SAuthCxt* pCxt, const char* pDbName, const char* pTabName, AUTH_TYPE type, SNode** pCond, bool isView, bool effective) { @@ -59,8 +61,8 @@ static int32_t checkAuthImpl(SAuthCxt* pCxt, const char* pDbName, const char* pT AUTH_RES_TYPE auth_res_type = isView ? AUTH_RES_VIEW : AUTH_RES_BASIC; SUserAuthInfo authInfo = {0}; - setUserAuthInfo(pCxt->pParseCxt, pDbName, pTabName, type, isView, effective, &authInfo); - int32_t code = TSDB_CODE_SUCCESS; + int32_t code = setUserAuthInfo(pCxt->pParseCxt, pDbName, pTabName, type, isView, effective, &authInfo); + if (TSDB_CODE_SUCCESS != code) return code; SUserAuthRes authRes = {0}; if (NULL != pCxt->pMetaCache) { code = getUserAuthFromCache(pCxt->pMetaCache, &authInfo, &authRes); @@ -105,14 +107,15 @@ static EDealRes authSubquery(SAuthCxt* pCxt, SNode* pStmt) { } static int32_t mergeStableTagCond(SNode** pWhere, SNode* pTagCond) { - SLogicConditionNode* pLogicCond = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); + SLogicConditionNode* pLogicCond = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogicCond); if (NULL == pLogicCond) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL; pLogicCond->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes; pLogicCond->condType = LOGIC_COND_TYPE_AND; - int32_t code = nodesListMakeStrictAppend(&pLogicCond->pParameterList, pTagCond); + code = nodesListMakeStrictAppend(&pLogicCond->pParameterList, pTagCond); if (TSDB_CODE_SUCCESS == code) { code = nodesListMakeAppend(&pLogicCond->pParameterList, *pWhere); } @@ -136,9 +139,10 @@ EDealRes rewriteAuthTable(SNode* pNode, void* pContext) { } static int32_t rewriteAppendStableTagCond(SNode** pWhere, SNode* pTagCond, STableNode* pTable) { - SNode* pTagCondCopy = nodesCloneNode(pTagCond); + SNode* pTagCondCopy = NULL; + int32_t code = nodesCloneNode(pTagCond, &pTagCondCopy); if (NULL == pTagCondCopy) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } SAuthRewriteCxt cxt = {.pTarget = pTable}; diff --git a/source/libs/parser/src/parCalcConst.c b/source/libs/parser/src/parCalcConst.c index af24624067..58a0fb3641 100644 --- a/source/libs/parser/src/parCalcConst.c +++ b/source/libs/parser/src/parCalcConst.c @@ -72,9 +72,10 @@ static bool isCondition(const SNode* pNode) { } static int32_t rewriteIsTrue(SNode* pSrc, SNode** pIsTrue) { - SOperatorNode* pOp = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR); + SOperatorNode* pOp = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pOp); if (NULL == pOp) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pOp->opType = OP_TYPE_IS_TRUE; pOp->pLeft = pSrc; @@ -179,9 +180,9 @@ static EDealRes doFindAndReplaceNode(SNode** pNode, void* pContext) { char aliasName[TSDB_COL_NAME_LEN] = {0}; strcpy(aliasName, ((SExprNode*)*pNode)->aliasName); nodesDestroyNode(*pNode); - *pNode = nodesCloneNode(pCxt->replaceCxt.pNew); + *pNode = NULL; + pCxt->code = nodesCloneNode(pCxt->replaceCxt.pNew, pNode); if (NULL == *pNode) { - pCxt->code = TSDB_CODE_OUT_OF_MEMORY; return DEAL_RES_ERROR; } strcpy(((SExprNode*)*pNode)->aliasName, aliasName); @@ -231,12 +232,14 @@ static int32_t calcConstProject(SCalcConstContext* pCxt, SNode* pProject, bool d SArray* pOrigAss = NULL; TSWAP(((SExprNode*)*pCol)->pAssociation, pOrigAss); nodesDestroyNode(*pCol); - *pCol = nodesCloneNode(*pNew); - TSWAP(pOrigAss, ((SExprNode*)*pCol)->pAssociation); + *pCol = NULL; + code = nodesCloneNode(*pNew, pCol); + if (TSDB_CODE_SUCCESS == code) { + strcpy(((SExprNode*)*pCol)->aliasName, aliasName); + TSWAP(pOrigAss, ((SExprNode*)*pCol)->pAssociation); + } taosArrayDestroy(pOrigAss); - strcpy(((SExprNode*)*pCol)->aliasName, aliasName); - if (NULL == *pCol) { - code = TSDB_CODE_OUT_OF_MEMORY; + if (TSDB_CODE_SUCCESS != code) { break; } } else { @@ -276,17 +279,23 @@ static bool isUselessCol(SExprNode* pProj) { return NULL == ((SExprNode*)pProj)->pAssociation; } -static SNode* createConstantValue() { - SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); +static int32_t createConstantValue(SValueNode** ppNode) { + SValueNode* pVal = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal); if (NULL == pVal) { - return NULL; + return code; } pVal->node.resType.type = TSDB_DATA_TYPE_INT; pVal->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_INT].bytes; const int32_t val = 1; - nodesSetValueNodeValue(pVal, (void*)&val); - pVal->translate = true; - return (SNode*)pVal; + code = nodesSetValueNodeValue(pVal, (void*)&val); + if (TSDB_CODE_SUCCESS == code) { + pVal->translate = true; + *ppNode = pVal; + } else { + nodesDestroyNode((SNode*)pVal); + } + return code; } static int32_t calcConstProjections(SCalcConstContext* pCxt, SSelectStmt* pSelect, bool subquery) { @@ -306,7 +315,11 @@ static int32_t calcConstProjections(SCalcConstContext* pCxt, SSelectStmt* pSelec WHERE_NEXT; } if (0 == LIST_LENGTH(pSelect->pProjectionList)) { - return nodesListStrictAppend(pSelect->pProjectionList, createConstantValue()); + SValueNode* pVal = NULL; + int32_t code = createConstantValue(&pVal); + if (TSDB_CODE_SUCCESS == code) { + return nodesListStrictAppend(pSelect->pProjectionList, (SNode*)pVal); + } } return TSDB_CODE_SUCCESS; } @@ -417,7 +430,7 @@ static void eraseSetOpChildProjection(SSetOperator* pSetOp, int32_t index) { eraseSetOpChildProjection((SSetOperator*)pSetOp->pLeft, index); } SNodeList* pRightProjs = getChildProjection(pSetOp->pRight); - nodesListErase(pRightProjs, nodesListGetCell(pRightProjs, index)); + (void)nodesListErase(pRightProjs, nodesListGetCell(pRightProjs, index)); if (QUERY_NODE_SET_OPERATOR == nodeType(pSetOp->pRight)) { eraseSetOpChildProjection((SSetOperator*)pSetOp->pRight, index); } @@ -495,7 +508,11 @@ static int32_t calcConstSetOpProjections(SCalcConstContext* pCxt, SSetOperator* WHERE_NEXT; } if (0 == LIST_LENGTH(pSetOp->pProjectionList)) { - return nodesListStrictAppend(pSetOp->pProjectionList, createConstantValue()); + SValueNode* pVal = NULL; + int32_t code = createConstantValue(&pVal); + if (TSDB_CODE_SUCCESS == code) { + return nodesListStrictAppend(pSetOp->pProjectionList, (SNode*)pVal); + } } return TSDB_CODE_SUCCESS; } diff --git a/source/libs/parser/src/parInsertSml.c b/source/libs/parser/src/parInsertSml.c index 89eaf14f75..0c564ca00b 100644 --- a/source/libs/parser/src/parInsertSml.c +++ b/source/libs/parser/src/parInsertSml.c @@ -459,19 +459,21 @@ end: int32_t smlInitHandle(SQuery** query) { *query = NULL; - SQuery* pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY); + SQuery* pQuery = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pQuery); if (NULL == pQuery) { uError("create pQuery error"); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE; pQuery->haveResultSet = false; pQuery->msgType = TDMT_VND_SUBMIT; - SVnodeModifyOpStmt* stmt = (SVnodeModifyOpStmt*)nodesMakeNode(QUERY_NODE_VNODE_MODIFY_STMT); + SVnodeModifyOpStmt* stmt = NULL; + code = nodesMakeNode(QUERY_NODE_VNODE_MODIFY_STMT, (SNode**)&stmt); if (NULL == stmt) { uError("create SVnodeModifyOpStmt error"); qDestroyQuery(pQuery); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } stmt->pTableBlockHashObj = taosHashInit(16, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK); if (stmt->pTableBlockHashObj == NULL){ diff --git a/source/libs/parser/src/parInsertSql.c b/source/libs/parser/src/parInsertSql.c index 0d0fe75ddb..c044e885cf 100644 --- a/source/libs/parser/src/parInsertSql.c +++ b/source/libs/parser/src/parInsertSql.c @@ -796,9 +796,10 @@ typedef struct SRewriteTagCondCxt { } SRewriteTagCondCxt; static int32_t rewriteTagCondColumnImpl(STagVal* pVal, SNode** pNode) { - SValueNode* pValue = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode* pValue = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValue); if (NULL == pValue) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pValue->node.resType = ((SColumnNode*)*pNode)->node.resType; @@ -1240,7 +1241,8 @@ static int32_t getTargetTableSchema(SInsertParseContext* pCxt, SVnodeModifyOpStm pCxt->needTableTagVal = (NULL != pTagCond); pCxt->missCache = (NULL != pTagCond); } else { - pStmt->pTagCond = nodesCloneNode(pTagCond); + pStmt->pTagCond = NULL; + code = nodesCloneNode(pTagCond, &pStmt->pTagCond); } } nodesDestroyNode(pTagCond); @@ -2535,9 +2537,10 @@ static int32_t parseInsertBody(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pS static void destroySubTableHashElem(void* p) { taosMemoryFree(*(STableMeta**)p); } static int32_t createVnodeModifOpStmt(SInsertParseContext* pCxt, bool reentry, SNode** pOutput) { - SVnodeModifyOpStmt* pStmt = (SVnodeModifyOpStmt*)nodesMakeNode(QUERY_NODE_VNODE_MODIFY_STMT); + SVnodeModifyOpStmt* pStmt = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_VNODE_MODIFY_STMT, (SNode**)&pStmt); if (NULL == pStmt) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } if (pCxt->pComCxt->pStmtCb) { @@ -2575,16 +2578,17 @@ static int32_t createVnodeModifOpStmt(SInsertParseContext* pCxt, bool reentry, S } static int32_t createInsertQuery(SInsertParseContext* pCxt, SQuery** pOutput) { - SQuery* pQuery = (SQuery*)nodesMakeNode(QUERY_NODE_QUERY); + SQuery* pQuery = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_QUERY, (SNode**)&pQuery); if (NULL == pQuery) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pQuery->execMode = QUERY_EXEC_MODE_SCHEDULE; pQuery->haveResultSet = false; pQuery->msgType = TDMT_VND_SUBMIT; - int32_t code = createVnodeModifOpStmt(pCxt, false, &pQuery->pRoot); + code = createVnodeModifOpStmt(pCxt, false, &pQuery->pRoot); if (TSDB_CODE_SUCCESS == code) { *pOutput = pQuery; } else { @@ -2601,10 +2605,10 @@ static int32_t checkAuthFromMetaData(const SArray* pUsers, SNode** pTagCond) { SMetaRes* pRes = taosArrayGet(pUsers, 0); if (TSDB_CODE_SUCCESS == pRes->code) { SUserAuthRes* pAuth = pRes->pRes; - if (NULL != pAuth->pCond) { - *pTagCond = nodesCloneNode(pAuth->pCond[AUTH_RES_BASIC]); + pRes->code = nodesCloneNode(pAuth->pCond[AUTH_RES_BASIC], pTagCond); + if (TSDB_CODE_SUCCESS == pRes->code) { + return pAuth->pass[AUTH_RES_BASIC] ? TSDB_CODE_SUCCESS : TSDB_CODE_PAR_PERMISSION_DENIED; } - return pAuth->pass[AUTH_RES_BASIC] ? TSDB_CODE_SUCCESS : TSDB_CODE_PAR_PERMISSION_DENIED; } return pRes->code; } diff --git a/source/libs/parser/src/parTranslater.c b/source/libs/parser/src/parTranslater.c index e67001889e..2703a2998d 100644 --- a/source/libs/parser/src/parTranslater.c +++ b/source/libs/parser/src/parTranslater.c @@ -35,15 +35,16 @@ #define CHECK_RES_OUT_OF_MEM(p) \ do { \ - if (TSDB_CODE_SUCCESS != (p)) { \ - return TSDB_CODE_OUT_OF_MEMORY; \ + int32_t code = (p); \ + if (TSDB_CODE_SUCCESS != code) { \ + return code; \ } \ } while (0) #define CHECK_POINTER_OUT_OF_MEM(p) \ do { \ if (NULL == (p)) { \ - return TSDB_CODE_OUT_OF_MEMORY; \ + return code; \ } \ } while (0) @@ -57,6 +58,7 @@ typedef struct SBuildTopicContext { bool colNotFound; STableMeta* pMeta; SNodeList* pTags; + int32_t code; } SBuildTopicContext; typedef struct SFullDatabaseName { @@ -83,6 +85,11 @@ typedef struct SCollectJoinCondsContext { int32_t code; } SCollectJoinCondsContext; +typedef struct SCollectWindowsPseudocolumnsContext { + int32_t code; + SNodeList* pCols; +} SCollectWindowsPseudocolumnsContext; + // clang-format off static const SSysTableShowAdapter sysTableShowAdapter[] = { { @@ -1054,7 +1061,10 @@ int32_t buildPartitionListFromOrderList(SNodeList* pOrderList, int32_t nodesNum, for (int32_t i = 0; i < nodesNum; ++i) { pNode = nodesListGetNode(pOrderList, i); pOrder = (SOrderByExprNode*)pNode; - code = nodesListMakeStrictAppend(&pPartitionList, nodesCloneNode(pOrder->pExpr)); + SNode* pClonedNode = NULL; + code = nodesCloneNode(pOrder->pExpr, &pClonedNode); + if (TSDB_CODE_SUCCESS != code) break; + code = nodesListMakeStrictAppend(&pPartitionList, pClonedNode); if (TSDB_CODE_SUCCESS != code) { break; } @@ -1271,9 +1281,10 @@ static int32_t createColumnsByTable(STranslateContext* pCxt, const STableNode* p pCxt->pParseCxt->hasInvisibleCol = true; continue; } - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); - if (NULL == pCol) { - return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_OUT_OF_MEMORY); + SColumnNode* pCol = NULL; + code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); + if (TSDB_CODE_SUCCESS != code) { + return generateSyntaxErrMsg(&pCxt->msgBuf, code); } setColumnInfoBySchema((SRealTableNode*)pTable, pMeta->schema + i, (i - pMeta->tableInfo.numOfColumns), pCol); setColumnPrimTs(pCxt, pCol, pTable); @@ -1284,9 +1295,10 @@ static int32_t createColumnsByTable(STranslateContext* pCxt, const STableNode* p SNodeList* pProjectList = getProjectList(pTempTable->pSubquery); SNode* pNode; FOREACH(pNode, pProjectList) { - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); - if (NULL == pCol) { - return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_OUT_OF_MEMORY); + SColumnNode* pCol = NULL; + code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); + if (TSDB_CODE_SUCCESS != code) { + return generateSyntaxErrMsg(&pCxt->msgBuf, code); } code = nodesListStrictAppend(pList, (SNode*)pCol); if (TSDB_CODE_SUCCESS == code) { @@ -1458,9 +1470,10 @@ static EDealRes translateColumnUseAlias(STranslateContext* pCxt, SColumnNode** p } } if (*pFound) { - SNode* pNew = nodesCloneNode(pFoundNode); + SNode* pNew = NULL; + int32_t code = nodesCloneNode(pFoundNode, &pNew); if (NULL == pNew) { - pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; + pCxt->errCode = code; return DEAL_RES_ERROR; } nodesDestroyNode(*(SNode**)pCol); @@ -1485,8 +1498,9 @@ static int32_t biMakeTbnameProjectAstNode(char* funcName, char* tableAlias, SNod int32_t code = 0; SValueNode* valNode = NULL; if (tableAlias != NULL) { - SValueNode* n = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); - if (!n) return TSDB_CODE_OUT_OF_MEMORY; + SValueNode* n = NULL; + code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&n); + if (TSDB_CODE_SUCCESS != code) return code; n->literal = tstrdup(tableAlias); if (!n->literal) { nodesDestroyNode((SNode*)n); @@ -1498,11 +1512,11 @@ static int32_t biMakeTbnameProjectAstNode(char* funcName, char* tableAlias, SNod valNode = n; } - SFunctionNode* tbNameFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); - if (!tbNameFunc) { + SFunctionNode* tbNameFunc = NULL; + code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&tbNameFunc); + if (TSDB_CODE_SUCCESS != code) { nodesDestroyNode((SNode*)valNode); valNode = NULL; - code = TSDB_CODE_OUT_OF_MEMORY; } if (TSDB_CODE_SUCCESS == code) { tstrncpy(tbNameFunc->functionName, "tbname", TSDB_FUNC_NAME_LEN); @@ -1519,10 +1533,8 @@ static int32_t biMakeTbnameProjectAstNode(char* funcName, char* tableAlias, SNod *pOutNode = (SNode*)tbNameFunc; return code; } else { - SFunctionNode* multiResFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); - if (!multiResFunc) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + SFunctionNode* multiResFunc = NULL; + code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&multiResFunc); if (TSDB_CODE_SUCCESS == code) { tstrncpy(multiResFunc->functionName, funcName, TSDB_FUNC_NAME_LEN); @@ -1553,9 +1565,9 @@ static int32_t biMakeTbnameProjectAstNode(char* funcName, char* tableAlias, SNod static int32_t biRewriteSelectFuncParamStar(STranslateContext* pCxt, SSelectStmt* pSelect, SNode* pNode, SListCell* pSelectListCell) { - SNodeList* pTbnameNodeList = nodesMakeList(); - if (!pTbnameNodeList) return TSDB_CODE_OUT_OF_MEMORY; - int32_t code = 0; + SNodeList* pTbnameNodeList = NULL; + int32_t code = nodesMakeList(&pTbnameNodeList); + if (!pTbnameNodeList) return code; SFunctionNode* pFunc = (SFunctionNode*)pNode; if (strcasecmp(pFunc->functionName, "last") == 0 || strcasecmp(pFunc->functionName, "last_row") == 0 || @@ -1609,8 +1621,9 @@ static int32_t biRewriteSelectFuncParamStar(STranslateContext* pCxt, SSelectStmt int32_t biRewriteSelectStar(STranslateContext* pCxt, SSelectStmt* pSelect) { int32_t code = TSDB_CODE_SUCCESS; SNode* pNode = NULL; - SNodeList* pTbnameNodeList = nodesMakeList(); - if (!pTbnameNodeList) return TSDB_CODE_OUT_OF_MEMORY; + SNodeList* pTbnameNodeList = NULL; + code = nodesMakeList(&pTbnameNodeList); + if (!pTbnameNodeList) return code; WHERE_EACH(pNode, pSelect->pProjectionList) { if (nodesIsStar(pNode)) { SArray* pTables = taosArrayGetP(pCxt->pNsLevel, pCxt->currLevel); @@ -2121,17 +2134,20 @@ static bool isCountStar(SFunctionNode* pFunc) { static int32_t rewriteCountStarAsCount1(STranslateContext* pCxt, SFunctionNode* pCount) { int32_t code = TSDB_CODE_SUCCESS; - SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); - if (NULL == pVal) { - return TSDB_CODE_OUT_OF_MEMORY; + SValueNode* pVal = NULL; + code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal); + if (TSDB_CODE_SUCCESS != code) { + return code; } pVal->node.resType.type = TSDB_DATA_TYPE_INT; pVal->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_INT].bytes; const int32_t val = 1; - (void)nodesSetValueNodeValue(pVal, (void*)&val); - pVal->translate = true; - (void)nodesListErase(pCount->pParameterList, nodesListGetCell(pCount->pParameterList, 0)); - code = nodesListAppend(pCount->pParameterList, (SNode*)pVal); + code = nodesSetValueNodeValue(pVal, (void*)&val); + if (TSDB_CODE_SUCCESS == code) { + pVal->translate = true; + (void)nodesListErase(pCount->pParameterList, nodesListGetCell(pCount->pParameterList, 0)); + code = nodesListAppend(pCount->pParameterList, (SNode*)pVal); + } return code; } @@ -2196,10 +2212,9 @@ static int32_t rewriteCountNotNullValue(STranslateContext* pCxt, SFunctionNode* STableNode* pTable = NULL; int32_t code = findTable(pCxt, NULL, &pTable); if (TSDB_CODE_SUCCESS == code && QUERY_NODE_REAL_TABLE == nodeType(pTable)) { - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); - if (NULL == pCol) { - code = TSDB_CODE_OUT_OF_MEMORY; - } else { + SColumnNode* pCol = NULL; + code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); + if (TSDB_CODE_SUCCESS == code) { setColumnInfoBySchema((SRealTableNode*)pTable, ((SRealTableNode*)pTable)->pMeta->schema, -1, pCol); NODES_DESTORY_LIST(pCount->pParameterList); code = nodesListMakeAppend(&pCount->pParameterList, (SNode*)pCol); @@ -2226,10 +2241,9 @@ static int32_t rewriteCountTbname(STranslateContext* pCxt, SFunctionNode* pCount STableNode* pTable = NULL; int32_t code = findTable(pCxt, pTableAlias, &pTable); if (TSDB_CODE_SUCCESS == code) { - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); - if (NULL == pCol) { - code = TSDB_CODE_OUT_OF_MEMORY; - } else { + SColumnNode* pCol = NULL; + code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); + if (TSDB_CODE_SUCCESS == code) { setColumnInfoBySchema((SRealTableNode*)pTable, ((SRealTableNode*)pTable)->pMeta->schema, -1, pCol); NODES_DESTORY_LIST(pCount->pParameterList); code = nodesListMakeAppend(&pCount->pParameterList, (SNode*)pCol); @@ -2595,9 +2609,10 @@ static void setFuncClassification(SNode* pCurrStmt, SFunctionNode* pFunc) { } static int32_t rewriteFuncToValue(STranslateContext* pCxt, char** pLiteral, SNode** pNode) { - SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); - if (NULL == pVal) { - return TSDB_CODE_OUT_OF_MEMORY; + SValueNode* pVal = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal); + if (TSDB_CODE_SUCCESS != code) { + return code; } strcpy(pVal->node.aliasName, ((SExprNode*)*pNode)->aliasName); strcpy(pVal->node.userAlias, ((SExprNode*)*pNode)->userAlias); @@ -2700,9 +2715,10 @@ static int32_t rewriteSystemInfoFunc(STranslateContext* pCxt, SNode** pNode) { } static int32_t replacePsedudoColumnFuncWithColumn(STranslateContext* pCxt, SNode** ppNode) { - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); - if (pCol == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + SColumnNode* pCol = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); + if (TSDB_CODE_SUCCESS != code) { + return code; } SExprNode* pOldExpr = (SExprNode*)(*ppNode); // rewrite a.tbname == tbname(a) @@ -2955,9 +2971,10 @@ static EDealRes translateLogicCond(STranslateContext* pCxt, SLogicConditionNode* } static int32_t createCastFunc(STranslateContext* pCxt, SNode* pExpr, SDataType dt, SNode** pCast) { - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); - if (NULL == pFunc) { - return TSDB_CODE_OUT_OF_MEMORY; + SFunctionNode* pFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); + if (TSDB_CODE_SUCCESS != code) { + return code; } strcpy(pFunc->functionName, "cast"); pFunc->node.resType = dt; @@ -2965,7 +2982,7 @@ static int32_t createCastFunc(STranslateContext* pCxt, SNode* pExpr, SDataType d nodesDestroyNode((SNode*)pFunc); return TSDB_CODE_OUT_OF_MEMORY; } - int32_t code = getFuncInfo(pCxt, pFunc); + code = getFuncInfo(pCxt, pFunc); if (TSDB_CODE_SUCCESS != code) { nodesClearList(pFunc->pParameterList); pFunc->pParameterList = NULL; @@ -2989,9 +3006,10 @@ static bool isCondition(const SNode* pNode) { } static int32_t rewriteIsTrue(SNode* pSrc, SNode** pIsTrue) { - SOperatorNode* pOp = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR); - if (NULL == pOp) { - return TSDB_CODE_OUT_OF_MEMORY; + SOperatorNode* pOp = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pOp); + if (TSDB_CODE_SUCCESS != code) { + return code; } pOp->opType = OP_TYPE_IS_TRUE; pOp->pLeft = pSrc; @@ -3122,9 +3140,10 @@ static int32_t getGroupByErrorCode(STranslateContext* pCxt) { } static EDealRes rewriteColToSelectValFunc(STranslateContext* pCxt, SNode** pNode) { - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); - if (NULL == pFunc) { - pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; + SFunctionNode* pFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); + if (TSDB_CODE_SUCCESS != code) { + pCxt->errCode = code; return DEAL_RES_ERROR; } strcpy(pFunc->functionName, "_select_value"); @@ -3144,9 +3163,10 @@ static EDealRes rewriteColToSelectValFunc(STranslateContext* pCxt, SNode** pNode } static EDealRes rewriteExprToGroupKeyFunc(STranslateContext* pCxt, SNode** pNode) { - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); - if (NULL == pFunc) { - pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; + SFunctionNode* pFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); + if (TSDB_CODE_SUCCESS != code) { + pCxt->errCode = code; return DEAL_RES_ERROR; } @@ -3554,8 +3574,10 @@ static int32_t resetSelectFuncNumWithoutDup(SSelectStmt* pSelect) { if (pSelect->selectFuncNum <= 1) return TSDB_CODE_SUCCESS; pSelect->selectFuncNum = 0; pSelect->lastProcessByRowFuncId = -1; - SNodeList* pNodeList = nodesMakeList(); - int32_t code = nodesCollectSelectFuncs(pSelect, SQL_CLAUSE_FROM, NULL, fmIsSelectFunc, pNodeList); + SNodeList* pNodeList = NULL; + int32_t code = nodesMakeList(&pNodeList); + if (TSDB_CODE_SUCCESS != code) return code; + code = nodesCollectSelectFuncs(pSelect, SQL_CLAUSE_FROM, NULL, fmIsSelectFunc, pNodeList); if (TSDB_CODE_SUCCESS != code) { nodesDestroyList(pNodeList); return code; @@ -4016,9 +4038,10 @@ static EDealRes doTranslateTbName(SNode** pNode, void* pContext) { SFunctionNode* pFunc = (SFunctionNode*)*pNode; if (FUNCTION_TYPE_TBNAME == pFunc->funcType) { SRewriteTbNameContext* pCxt = (SRewriteTbNameContext*)pContext; - SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); - if (NULL == pVal) { - pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; + SValueNode* pVal = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal); + if (TSDB_CODE_SUCCESS != code) { + pCxt->errCode = code; return DEAL_RES_ERROR; } @@ -4073,9 +4096,10 @@ static int32_t addPrimJoinEqCond(SNode** pCond, SRealTableNode* leftTable, SReal struct STableMeta* pLMeta = leftTable->pMeta; struct STableMeta* pRMeta = rightTable->pMeta; - *pCond = nodesMakeNode(QUERY_NODE_OPERATOR); - if (NULL == *pCond) { - return TSDB_CODE_OUT_OF_MEMORY; + *pCond = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_OPERATOR, pCond); + if (TSDB_CODE_SUCCESS != code) { + return code; } SOperatorNode* pOp = (SOperatorNode*)*pCond; @@ -4089,10 +4113,11 @@ static int32_t addPrimJoinEqCond(SNode** pCond, SRealTableNode* leftTable, SReal pOp->opType = OP_TYPE_LOWER_EQUAL; } - SColumnNode* pLeft = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); - if (NULL == pLeft) { + SColumnNode* pLeft = NULL; + code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pLeft); + if (TSDB_CODE_SUCCESS != code) { nodesDestroyNode(*pCond); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pLeft->node.resType.type = pLMeta->schema[0].type; pLeft->node.resType.bytes = pLMeta->schema[0].bytes; @@ -4105,10 +4130,11 @@ static int32_t addPrimJoinEqCond(SNode** pCond, SRealTableNode* leftTable, SReal pOp->pLeft = (SNode*)pLeft; - SColumnNode* pRight = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); - if (NULL == pRight) { + SColumnNode* pRight = NULL; + code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pRight); + if (TSDB_CODE_SUCCESS != code) { nodesDestroyNode(*pCond); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pRight->node.resType.type = pRMeta->schema[0].type; pRight->node.resType.bytes = pRMeta->schema[0].bytes; @@ -4688,9 +4714,9 @@ int32_t translateTable(STranslateContext* pCxt, SNode** pTable, SNode* pJoinPare } static int32_t createAllColumns(STranslateContext* pCxt, bool igTags, SNodeList** pCols) { - *pCols = nodesMakeList(); + int32_t code = nodesMakeList(pCols); if (NULL == *pCols) { - return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_OUT_OF_MEMORY); + return generateSyntaxErrMsg(&pCxt->msgBuf, code); } SArray* pTables = taosArrayGetP(pCxt->pNsLevel, pCxt->currLevel); size_t nums = taosArrayGetSize(pTables); @@ -4704,16 +4730,18 @@ static int32_t createAllColumns(STranslateContext* pCxt, bool igTags, SNodeList* return TSDB_CODE_SUCCESS; } -static SNode* createMultiResFunc(SFunctionNode* pSrcFunc, SExprNode* pExpr) { - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); - if (NULL == pFunc) { - return NULL; +static int32_t createMultiResFunc(SFunctionNode* pSrcFunc, SExprNode* pExpr, SNode** ppNodeOut) { + SFunctionNode* pFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); + if (TSDB_CODE_SUCCESS != code) { + return code; } - pFunc->pParameterList = nodesMakeList(); - if (NULL == pFunc->pParameterList || - TSDB_CODE_SUCCESS != nodesListStrictAppend(pFunc->pParameterList, nodesCloneNode((SNode*)pExpr))) { + code = nodesMakeList(&pFunc->pParameterList); + SNode* pClonedNode = NULL; + if (NULL == pFunc->pParameterList || TSDB_CODE_SUCCESS != (code = nodesCloneNode((SNode*)pExpr, &pClonedNode)) || + TSDB_CODE_SUCCESS != (code = nodesListStrictAppend(pFunc->pParameterList, pClonedNode))) { nodesDestroyNode((SNode*)pFunc); - return NULL; + return code; } pFunc->node.resType = pExpr->resType; @@ -4743,17 +4771,17 @@ static SNode* createMultiResFunc(SFunctionNode* pSrcFunc, SExprNode* pExpr) { // note: userAlias could be truncated here strncpy(pFunc->node.userAlias, buf, TSDB_COL_NAME_LEN - 1); } - - return (SNode*)pFunc; + *ppNodeOut = (SNode*)pFunc; + return code; } static int32_t createTableAllCols(STranslateContext* pCxt, SColumnNode* pCol, bool igTags, SNodeList** pOutput) { STableNode* pTable = NULL; int32_t code = findTable(pCxt, pCol->tableAlias, &pTable); if (TSDB_CODE_SUCCESS == code && NULL == *pOutput) { - *pOutput = nodesMakeList(); + code = nodesMakeList(pOutput); if (NULL == *pOutput) { - code = generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_OUT_OF_MEMORY); + code = generateSyntaxErrMsg(&pCxt->msgBuf, code); } } if (TSDB_CODE_SUCCESS == code) { @@ -4773,7 +4801,10 @@ static int32_t createMultiResFuncsParas(STranslateContext* pCxt, SNodeList* pSrc } else if (nodesIsTableStar(pPara)) { code = createTableAllCols(pCxt, (SColumnNode*)pPara, !tsMultiResultFunctionStarReturnTags, &pExprs); } else { - code = nodesListMakeStrictAppend(&pExprs, nodesCloneNode(pPara)); + SNode* pClonedNode = NULL; + code = nodesCloneNode(pPara, &pClonedNode); + if (TSDB_CODE_SUCCESS != code) break; + code = nodesListMakeStrictAppend(&pExprs, pClonedNode); } if (TSDB_CODE_SUCCESS != code) { break; @@ -4790,15 +4821,18 @@ static int32_t createMultiResFuncsParas(STranslateContext* pCxt, SNodeList* pSrc } static int32_t createMultiResFuncs(SFunctionNode* pSrcFunc, SNodeList* pExprs, SNodeList** pOutput) { - SNodeList* pFuncs = nodesMakeList(); + SNodeList* pFuncs = NULL; + int32_t code = nodesMakeList(&pFuncs); if (NULL == pFuncs) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - int32_t code = TSDB_CODE_SUCCESS; SNode* pExpr = NULL; FOREACH(pExpr, pExprs) { - code = nodesListStrictAppend(pFuncs, createMultiResFunc(pSrcFunc, (SExprNode*)pExpr)); + SNode* pNode = NULL; + code = createMultiResFunc(pSrcFunc, (SExprNode*)pExpr, &pNode); + if (TSDB_CODE_SUCCESS != code) break; + code = nodesListStrictAppend(pFuncs, pNode); if (TSDB_CODE_SUCCESS != code) { break; } @@ -4839,8 +4873,9 @@ static int32_t createTags(STranslateContext* pCxt, SNodeList** pOutput) { SSchema* pTagsSchema = getTableTagSchema(pMeta); for (int32_t i = 0; i < pMeta->tableInfo.numOfTags; ++i) { - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); - if (NULL == pCol) { + SColumnNode* pCol = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); + if (TSDB_CODE_SUCCESS != code) { return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_OUT_OF_MEMORY); } setColumnInfoBySchema(pTable, pTagsSchema + i, 1, pCol); @@ -5157,13 +5192,14 @@ static int32_t getQueryTimeRange(STranslateContext* pCxt, SNode* pWhere, STimeWi return TSDB_CODE_SUCCESS; } - SNode* pCond = nodesCloneNode(pWhere); + SNode* pCond = NULL; + int32_t code = nodesCloneNode(pWhere, &pCond); if (NULL == pCond) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } SNode* pPrimaryKeyCond = NULL; - int32_t code = filterPartitionCond(&pCond, &pPrimaryKeyCond, NULL, NULL, NULL); + code = filterPartitionCond(&pCond, &pPrimaryKeyCond, NULL, NULL, NULL); if (TSDB_CODE_SUCCESS == code) { if (NULL != pPrimaryKeyCond) { @@ -5476,12 +5512,15 @@ static int32_t translateSpecificWindow(STranslateContext* pCxt, SSelectStmt* pSe } static EDealRes collectWindowsPseudocolumns(SNode* pNode, void* pContext) { - SNodeList* pCols = (SNodeList*)pContext; + SCollectWindowsPseudocolumnsContext* pCtx = pContext; + SNodeList* pCols = pCtx->pCols; if (QUERY_NODE_FUNCTION == nodeType(pNode)) { SFunctionNode* pFunc = (SFunctionNode*)pNode; if (FUNCTION_TYPE_WSTART == pFunc->funcType || FUNCTION_TYPE_WEND == pFunc->funcType || FUNCTION_TYPE_WDURATION == pFunc->funcType) { - if (TSDB_CODE_SUCCESS != nodesListStrictAppend(pCols, nodesCloneNode(pNode))) { + SNode* pClonedNode = NULL; + if (TSDB_CODE_SUCCESS != (pCtx->code = nodesCloneNode(pNode, &pClonedNode))) return DEAL_RES_ERROR; + if (TSDB_CODE_SUCCESS != (pCtx->code = nodesListStrictAppend(pCols, pClonedNode))) { return DEAL_RES_ERROR; } } @@ -5494,17 +5533,19 @@ static int32_t checkWindowsConditonValid(SNode* pNode) { if (QUERY_NODE_EVENT_WINDOW != nodeType(pNode)) return code; SEventWindowNode* pEventWindowNode = (SEventWindowNode*)pNode; - SNodeList* pCols = nodesMakeList(); + SNodeList* pCols = NULL; + code = nodesMakeList(&pCols); if (NULL == pCols) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - nodesWalkExpr(pEventWindowNode->pStartCond, collectWindowsPseudocolumns, pCols); - if (pCols->length > 0) { + SCollectWindowsPseudocolumnsContext ctx = {.code = 0, .pCols = pCols}; + nodesWalkExpr(pEventWindowNode->pStartCond, collectWindowsPseudocolumns, &ctx); + if (TSDB_CODE_SUCCESS == ctx.code && pCols->length > 0) { code = TSDB_CODE_QRY_INVALID_WINDOW_CONDITION; } if (TSDB_CODE_SUCCESS == code) { - nodesWalkExpr(pEventWindowNode->pEndCond, collectWindowsPseudocolumns, pCols); - if (pCols->length > 0) { + nodesWalkExpr(pEventWindowNode->pEndCond, collectWindowsPseudocolumns, &ctx); + if (TSDB_CODE_SUCCESS == ctx.code && pCols->length > 0) { code = TSDB_CODE_QRY_INVALID_WINDOW_CONDITION; } } @@ -5562,17 +5603,19 @@ static int32_t translateWindow(STranslateContext* pCxt, SSelectStmt* pSelect) { } static int32_t createDefaultFillNode(STranslateContext* pCxt, SNode** pOutput) { - SFillNode* pFill = (SFillNode*)nodesMakeNode(QUERY_NODE_FILL); - if (NULL == pFill) { - return TSDB_CODE_OUT_OF_MEMORY; + SFillNode* pFill = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FILL, (SNode**)&pFill); + if (TSDB_CODE_SUCCESS != code) { + return code; } pFill->mode = FILL_MODE_NONE; - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); - if (NULL == pCol) { + SColumnNode* pCol = NULL; + code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); + if (TSDB_CODE_SUCCESS != code) { nodesDestroyNode((SNode*)pFill); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pCol->colId = PRIMARYKEY_TIMESTAMP_COL_ID; strcpy(pCol->colName, ROWTS_PSEUDO_COLUMN_NAME); @@ -5583,9 +5626,10 @@ static int32_t createDefaultFillNode(STranslateContext* pCxt, SNode** pOutput) { } static int32_t createDefaultEveryNode(STranslateContext* pCxt, SNode** pOutput) { - SValueNode* pEvery = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); - if (NULL == pEvery) { - return TSDB_CODE_OUT_OF_MEMORY; + SValueNode* pEvery = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pEvery); + if (TSDB_CODE_SUCCESS != code) { + return code; } pEvery->node.resType.type = TSDB_DATA_TYPE_BIGINT; @@ -6112,14 +6156,15 @@ static int32_t checkLimit(STranslateContext* pCxt, SSelectStmt* pSelect) { } static int32_t createPrimaryKeyColByTable(STranslateContext* pCxt, STableNode* pTable, SNode** pPrimaryKey) { - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); - if (NULL == pCol) { - return TSDB_CODE_OUT_OF_MEMORY; + SColumnNode* pCol = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); + if (TSDB_CODE_SUCCESS != code) { + return code; } pCol->colId = PRIMARYKEY_TIMESTAMP_COL_ID; strcpy(pCol->colName, ROWTS_PSEUDO_COLUMN_NAME); bool found = false; - int32_t code = findAndSetColumn(pCxt, &pCol, pTable, &found, true); + code = findAndSetColumn(pCxt, &pCol, pTable, &found, true); if (TSDB_CODE_SUCCESS != code || !found) { return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_VALID_PRIM_TS_REQUIRED); } @@ -6210,14 +6255,15 @@ static int32_t appendTsForImplicitTsFunc(STranslateContext* pCxt, SSelectStmt* p } static int32_t createPkColByTable(STranslateContext* pCxt, SRealTableNode* pTable, SNode** pPk) { - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); - if (NULL == pCol) { - return TSDB_CODE_OUT_OF_MEMORY; + SColumnNode* pCol = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); + if (TSDB_CODE_SUCCESS != code) { + return code; } pCol->colId = pTable->pMeta->schema[1].colId; strcpy(pCol->colName, pTable->pMeta->schema[1].name); bool found = false; - int32_t code = findAndSetColumn(pCxt, &pCol, (STableNode*)pTable, &found, true); + code = findAndSetColumn(pCxt, &pCol, (STableNode*)pTable, &found, true); if (TSDB_CODE_SUCCESS != code || !found) { return generateSyntaxErrMsg(&pCxt->msgBuf, TSDB_CODE_PAR_INTERNAL_ERROR); } @@ -6284,9 +6330,10 @@ static EDealRes replaceOrderByAliasImpl(SNode** pNode, void* pContext) { (QUERY_NODE_COLUMN == nodeType(pProject) && !nodesEqualNode(*pNode, pProject)))) { continue; } - SNode* pNew = nodesCloneNode(pProject); + SNode* pNew = NULL; + int32_t code = nodesCloneNode(pProject, &pNew); if (NULL == pNew) { - pCxt->pTranslateCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; + pCxt->pTranslateCxt->errCode = code; return DEAL_RES_ERROR; } ((SExprNode*)pNew)->orderAlias = true; @@ -6307,9 +6354,10 @@ static EDealRes replaceOrderByAliasImpl(SNode** pNode, void* pContext) { } int32_t pos = getPositionValue(pVal); if (0 < pos && pos <= LIST_LENGTH(pProjectionList)) { - SNode* pNew = nodesCloneNode(nodesListGetNode(pProjectionList, pos - 1)); + SNode* pNew = NULL; + int32_t code = nodesCloneNode(nodesListGetNode(pProjectionList, pos - 1), &pNew); if (NULL == pNew) { - pCxt->pTranslateCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; + pCxt->pTranslateCxt->errCode = code; return DEAL_RES_ERROR; } ((SExprNode*)pNew)->orderAlias = true; @@ -6464,8 +6512,9 @@ static int32_t translateSelect(STranslateContext* pCxt, SSelectStmt* pSelect) { } static SNode* createSetOperProject(const char* pTableAlias, SNode* pNode) { - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); - if (NULL == pCol) { + SColumnNode* pCol = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); + if (TSDB_CODE_SUCCESS != code) { return NULL; } pCol->node.resType = ((SExprNode*)pNode)->resType; @@ -6672,16 +6721,17 @@ static int32_t translateInsertQuery(STranslateContext* pCxt, SInsertStmt* pInser static int32_t addOrderByPrimaryKeyToQueryImpl(STranslateContext* pCxt, SNode* pPrimaryKeyExpr, SNodeList** pOrderByList) { - SOrderByExprNode* pOrderByExpr = (SOrderByExprNode*)nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR); - if (NULL == pOrderByExpr) { - return TSDB_CODE_OUT_OF_MEMORY; + SOrderByExprNode* pOrderByExpr = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR, (SNode**)&pOrderByExpr); + if (TSDB_CODE_SUCCESS != code) { + return code; } pOrderByExpr->nullOrder = NULL_ORDER_FIRST; pOrderByExpr->order = ORDER_ASC; - pOrderByExpr->pExpr = nodesCloneNode(pPrimaryKeyExpr); + code = nodesCloneNode(pPrimaryKeyExpr, &pOrderByExpr->pExpr); if (NULL == pOrderByExpr->pExpr) { nodesDestroyNode((SNode*)pOrderByExpr); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } ((SExprNode*)pOrderByExpr->pExpr)->orderAlias = true; // NODES_DESTORY_LIST(*pOrderByList); @@ -8100,9 +8150,10 @@ typedef struct SSampleAstInfo { } SSampleAstInfo; static int32_t buildTableForSampleAst(SSampleAstInfo* pInfo, SNode** pOutput) { - SRealTableNode* pTable = (SRealTableNode*)nodesMakeNode(QUERY_NODE_REAL_TABLE); - if (NULL == pTable) { - return TSDB_CODE_OUT_OF_MEMORY; + SRealTableNode* pTable = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_REAL_TABLE, (SNode**)&pTable); + if (TSDB_CODE_SUCCESS != code) { + return code; } snprintf(pTable->table.dbName, sizeof(pTable->table.dbName), "%s", pInfo->pDbName); snprintf(pTable->table.tableName, sizeof(pTable->table.tableName), "%s", pInfo->pTableName); @@ -8113,9 +8164,10 @@ static int32_t buildTableForSampleAst(SSampleAstInfo* pInfo, SNode** pOutput) { } static int32_t addWstartToSampleProjects(SNodeList* pProjectionList) { - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); + SFunctionNode* pFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); if (NULL == pFunc) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } strcpy(pFunc->functionName, "_wstart"); strcpy(pFunc->node.userAlias, "_wstart"); @@ -8123,9 +8175,10 @@ static int32_t addWstartToSampleProjects(SNodeList* pProjectionList) { } static int32_t addWendToSampleProjects(SNodeList* pProjectionList) { - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); + SFunctionNode* pFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); if (NULL == pFunc) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } strcpy(pFunc->functionName, "_wend"); strcpy(pFunc->node.userAlias, "_wend"); @@ -8133,9 +8186,10 @@ static int32_t addWendToSampleProjects(SNodeList* pProjectionList) { } static int32_t addWdurationToSampleProjects(SNodeList* pProjectionList) { - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); + SFunctionNode* pFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); if (NULL == pFunc) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } strcpy(pFunc->functionName, "_wduration"); strcpy(pFunc->node.userAlias, "_wduration"); @@ -8169,17 +8223,19 @@ static int32_t buildProjectsForSampleAst(SSampleAstInfo* pInfo, SNodeList** pLis } static int32_t buildIntervalForSampleAst(SSampleAstInfo* pInfo, SNode** pOutput) { - SIntervalWindowNode* pInterval = (SIntervalWindowNode*)nodesMakeNode(QUERY_NODE_INTERVAL_WINDOW); + SIntervalWindowNode* pInterval = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_INTERVAL_WINDOW, (SNode**)&pInterval); if (NULL == pInterval) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } TSWAP(pInterval->pInterval, pInfo->pInterval); TSWAP(pInterval->pOffset, pInfo->pOffset); TSWAP(pInterval->pSliding, pInfo->pSliding); - pInterval->pCol = nodesMakeNode(QUERY_NODE_COLUMN); + pInterval->pCol = NULL; + code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pInterval->pCol); if (NULL == pInterval->pCol) { nodesDestroyNode((SNode*)pInterval); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } ((SColumnNode*)pInterval->pCol)->colId = PRIMARYKEY_TIMESTAMP_COL_ID; strcpy(((SColumnNode*)pInterval->pCol)->colName, ROWTS_PSEUDO_COLUMN_NAME); @@ -8189,13 +8245,14 @@ static int32_t buildIntervalForSampleAst(SSampleAstInfo* pInfo, SNode** pOutput) static int32_t buildSampleAst(STranslateContext* pCxt, SSampleAstInfo* pInfo, char** pAst, int32_t* pLen, char** pExpr, int32_t* pExprLen, int32_t* pProjectionTotalLen) { - SSelectStmt* pSelect = (SSelectStmt*)nodesMakeNode(QUERY_NODE_SELECT_STMT); + SSelectStmt* pSelect = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_SELECT_STMT, (SNode**)&pSelect); if (NULL == pSelect) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } sprintf(pSelect->stmtName, "%p", pSelect); - int32_t code = buildTableForSampleAst(pInfo, &pSelect->pFromTable); + code = buildTableForSampleAst(pInfo, &pSelect->pFromTable); if (TSDB_CODE_SUCCESS == code) { code = buildProjectsForSampleAst(pInfo, &pSelect->pProjectionList, pProjectionTotalLen); } @@ -8228,10 +8285,11 @@ static void clearSampleAstInfo(SSampleAstInfo* pInfo) { nodesDestroyList(pInfo->pTags); } -static SNode* makeIntervalVal(SRetention* pRetension, int8_t precision) { - SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); +static int32_t makeIntervalVal(SRetention* pRetension, int8_t precision, SNode** ppNode) { + SValueNode* pVal = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal); if (NULL == pVal) { - return NULL; + return code; } int64_t timeVal = -1; convertTimeFromPrecisionToUnit(pRetension->freq, precision, pRetension->freqUnit, &timeVal); @@ -8240,40 +8298,52 @@ static SNode* makeIntervalVal(SRetention* pRetension, int8_t precision) { pVal->literal = strndup(buf, len); if (NULL == pVal->literal) { nodesDestroyNode((SNode*)pVal); - return NULL; + return TSDB_CODE_OUT_OF_MEMORY; } pVal->flag |= VALUE_FLAG_IS_DURATION; pVal->node.resType.type = TSDB_DATA_TYPE_BIGINT; pVal->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes; pVal->node.resType.precision = precision; - return (SNode*)pVal; + *ppNode = (SNode*)pVal; + return code; } -static SNode* createColumnFromDef(SColumnDefNode* pDef) { - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); +static int32_t createColumnFromDef(SColumnDefNode* pDef, SNode** ppCol) { + SColumnNode* pCol = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); if (NULL == pCol) { - return NULL; + return code; } strcpy(pCol->colName, pDef->colName); - return (SNode*)pCol; + *ppCol = (SNode*)pCol; + return code; } -static SNode* createRollupFunc(SNode* pSrcFunc, SColumnDefNode* pColDef) { - SFunctionNode* pFunc = (SFunctionNode*)nodesCloneNode(pSrcFunc); +static int32_t createRollupFunc(SNode* pSrcFunc, SColumnDefNode* pColDef, SNode** ppRollupFunc) { + SFunctionNode* pFunc = NULL; + int32_t code = nodesCloneNode(pSrcFunc, (SNode**)&pFunc); if (NULL == pFunc) { - return NULL; + return code; } - if (TSDB_CODE_SUCCESS != nodesListMakeStrictAppend(&pFunc->pParameterList, createColumnFromDef(pColDef))) { + SNode* pCol = NULL; + code = createColumnFromDef(pColDef, &pCol); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pFunc->pParameterList, pCol); + pCol = NULL; + } + if (TSDB_CODE_SUCCESS != code) { nodesDestroyNode((SNode*)pFunc); - return NULL; + } else { + *ppRollupFunc = (SNode*)pFunc; } - return (SNode*)pFunc; + return code; } -static SNodeList* createRollupFuncs(SCreateTableStmt* pStmt) { - SNodeList* pFuncs = nodesMakeList(); +static int32_t createRollupFuncs(SCreateTableStmt* pStmt, SNodeList** ppList) { + SNodeList* pFuncs = NULL; + int32_t code = nodesMakeList(&pFuncs); if (NULL == pFuncs) { - return NULL; + return code; } SNode* pFunc = NULL; @@ -8285,21 +8355,28 @@ static SNodeList* createRollupFuncs(SCreateTableStmt* pStmt) { primaryKey = false; continue; } - if (TSDB_CODE_SUCCESS != nodesListStrictAppend(pFuncs, createRollupFunc(pFunc, (SColumnDefNode*)pCol))) { + SNode* pRollupFunc = NULL; + code = createRollupFunc(pFunc, (SColumnDefNode*)pCol, &pRollupFunc); + if (TSDB_CODE_SUCCESS != code) { nodesDestroyList(pFuncs); - return NULL; + return code; + } + code = nodesListStrictAppend(pFuncs, pRollupFunc); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyList(pFuncs); + return code; } } } - return pFuncs; + return code;; } -static STableMeta* createRollupTableMeta(SCreateTableStmt* pStmt, int8_t precision) { +static int32_t createRollupTableMeta(SCreateTableStmt* pStmt, int8_t precision, STableMeta** ppTbMeta) { int32_t numOfField = LIST_LENGTH(pStmt->pCols) + LIST_LENGTH(pStmt->pTags); STableMeta* pMeta = taosMemoryCalloc(1, sizeof(STableMeta) + numOfField * sizeof(SSchema)); if (NULL == pMeta) { - return NULL; + return TSDB_CODE_OUT_OF_MEMORY; } pMeta->tableType = TSDB_SUPER_TABLE; pMeta->tableInfo.numOfTags = LIST_LENGTH(pStmt->pTags); @@ -8318,31 +8395,39 @@ static STableMeta* createRollupTableMeta(SCreateTableStmt* pStmt, int8_t precisi ++index; } - return pMeta; + *ppTbMeta = pMeta; + return TSDB_CODE_SUCCESS; } -static SNode* createTbnameFunction() { - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); +static int32_t createTbnameFunction(SFunctionNode** ppFunc) { + SFunctionNode* pFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); if (NULL == pFunc) { - return NULL; + return code; } strcpy(pFunc->functionName, "tbname"); strcpy(pFunc->node.aliasName, "tbname"); strcpy(pFunc->node.userAlias, "tbname"); - return (SNode*)pFunc; + *ppFunc = pFunc; + return code; } static int32_t buildSampleAstInfoByTable(STranslateContext* pCxt, SCreateTableStmt* pStmt, SRetention* pRetension, int8_t precision, SSampleAstInfo* pInfo) { pInfo->pDbName = pStmt->dbName; pInfo->pTableName = pStmt->tableName; - pInfo->pFuncs = createRollupFuncs(pStmt); - pInfo->pInterval = makeIntervalVal(pRetension, precision); - pInfo->pRollupTableMeta = createRollupTableMeta(pStmt, precision); - if (NULL == pInfo->pFuncs || NULL == pInfo->pInterval || NULL == pInfo->pRollupTableMeta) { - return TSDB_CODE_OUT_OF_MEMORY; - } - return nodesListMakeStrictAppend(&pInfo->pPartitionByList, createTbnameFunction()); + int32_t code = createRollupFuncs(pStmt, &pInfo->pFuncs); + if (TSDB_CODE_SUCCESS != code) return code; + pInfo->pInterval = NULL; + code = makeIntervalVal(pRetension, precision, (SNode**)&pInfo->pInterval); + if (TSDB_CODE_SUCCESS != code) return code; + pInfo->pRollupTableMeta = NULL; + code = createRollupTableMeta(pStmt, precision, &pInfo->pRollupTableMeta); + if (TSDB_CODE_SUCCESS != code) return code; + SFunctionNode* pFunc = NULL; + code = createTbnameFunction(&pFunc); + if (!pFunc) return code; + return nodesListMakeStrictAppend(&pInfo->pPartitionByList, (SNode*)pFunc); } static int32_t getRollupAst(STranslateContext* pCxt, SCreateTableStmt* pStmt, SRetention* pRetension, int8_t precision, @@ -8973,15 +9058,14 @@ static int32_t buildSampleAstInfoByIndex(STranslateContext* pCxt, SCreateIndexSt pInfo->createSmaIndex = true; pInfo->pDbName = pStmt->dbName; pInfo->pTableName = pStmt->tableName; - pInfo->pFuncs = nodesCloneList(pStmt->pOptions->pFuncs); - pInfo->pInterval = nodesCloneNode(pStmt->pOptions->pInterval); - pInfo->pOffset = nodesCloneNode(pStmt->pOptions->pOffset); - pInfo->pSliding = nodesCloneNode(pStmt->pOptions->pSliding); - if (NULL == pInfo->pFuncs || NULL == pInfo->pInterval || - (NULL != pStmt->pOptions->pOffset && NULL == pInfo->pOffset) || - (NULL != pStmt->pOptions->pSliding && NULL == pInfo->pSliding)) { - return TSDB_CODE_OUT_OF_MEMORY; - } + int32_t code = nodesCloneList(pStmt->pOptions->pFuncs, &pInfo->pFuncs); + if (TSDB_CODE_SUCCESS != code) return code; + code = nodesCloneNode(pStmt->pOptions->pInterval, &pInfo->pInterval); + if (TSDB_CODE_SUCCESS != code) return code; + code = nodesCloneNode(pStmt->pOptions->pOffset, &pInfo->pOffset); + if (TSDB_CODE_SUCCESS != code) return code; + code = nodesCloneNode(pStmt->pOptions->pSliding, &pInfo->pSliding); + if (TSDB_CODE_SUCCESS != code) return code; return TSDB_CODE_SUCCESS; } @@ -9337,14 +9421,14 @@ static int32_t buildCreateTopicReq(STranslateContext* pCxt, SCreateTopicStmt* pS return code; } -static int32_t addTagList(SNodeList** ppList, SNode** pNode) { +static int32_t addTagList(SNodeList** ppList, SNode* pNode) { + int32_t code = 0; if (NULL == *ppList) { - *ppList = nodesMakeList(); - if (!*ppList) return TSDB_CODE_OUT_OF_MEMORY; + code = nodesMakeList(ppList); + if (!*ppList) return code; } - int32_t code = nodesListStrictAppend(*ppList, *pNode); - *pNode = NULL; + code = nodesListAppend(*ppList, pNode); if (TSDB_CODE_SUCCESS != code) { nodesDestroyList(*ppList); *ppList = NULL; @@ -9362,10 +9446,14 @@ static EDealRes checkColumnTagsInCond(SNode* pNode, void* pContext) { pCxt->colExists = true; return DEAL_RES_ERROR; } else if (type == TCOL_TYPE_TAG) { - SNode* pNodeClone = nodesCloneNode(pNode); - int32_t code = addTagList(&pCxt->pTags, &pNodeClone); - if (TSDB_CODE_SUCCESS != code) nodesDestroyNode(pNodeClone); - return DEAL_RES_ERROR; + SNode* pNew = NULL; + pCxt->code = nodesCloneNode(pNode, &pNew); + if (TSDB_CODE_SUCCESS != pCxt->code) return DEAL_RES_ERROR; + pCxt->code = addTagList(&pCxt->pTags, pNew); + if (TSDB_CODE_SUCCESS != pCxt->code) { + nodesDestroyNode(pNew); + return DEAL_RES_ERROR; + } } else { pCxt->colNotFound = true; return DEAL_RES_ERROR; @@ -9373,9 +9461,11 @@ static EDealRes checkColumnTagsInCond(SNode* pNode, void* pContext) { } else if (QUERY_NODE_FUNCTION == nodeType(pNode)) { SFunctionNode* pFunc = (SFunctionNode*)pNode; if (0 == strcasecmp(pFunc->functionName, "tbname")) { - SNode* pNodeClone = nodesCloneNode(pNode); - if (TSDB_CODE_SUCCESS != addTagList(&pCxt->pTags, &pNodeClone)) { - nodesDestroyNode(pNodeClone); + SNode* pNew = NULL; + pCxt->code = nodesCloneNode(pNode, &pNew); + if (TSDB_CODE_SUCCESS != pCxt->code) return DEAL_RES_ERROR; + if (TSDB_CODE_SUCCESS != (pCxt->code = addTagList(&pCxt->pTags, pNew))) { + nodesDestroyNode(pNew); return DEAL_RES_ERROR; } } @@ -9398,14 +9488,15 @@ static int32_t checkCollectTopicTags(STranslateContext* pCxt, SCreateTopicStmt* if (NULL == colCxt.pTags) { // put one column to select // for (int32_t i = 0; i < pMeta->tableInfo.numOfColumns; ++i) { SSchema* column = &pMeta->schema[0]; - SColumnNode* col = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + SColumnNode* col = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&col); if (NULL == col) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } strcpy(col->colName, column->name); strcpy(col->node.aliasName, col->colName); strcpy(col->node.userAlias, col->colName); - int32_t code = addTagList(&colCxt.pTags, (SNode**)&col); + code = addTagList(&colCxt.pTags, (SNode*)col); if (TSDB_CODE_SUCCESS != code) { nodesDestroyNode((SNode*)col); return code; @@ -9416,7 +9507,7 @@ static int32_t checkCollectTopicTags(STranslateContext* pCxt, SCreateTopicStmt* return TSDB_CODE_SUCCESS; } -static int32_t buildQueryForTableTopic(STranslateContext* pCxt, SCreateTopicStmt* pStmt, SNode** pSelect) { +static int32_t buildQueryForTableTopic(STranslateContext* pCxt, SCreateTopicStmt* pStmt, SNode** ppSelect) { SParseContext* pParCxt = pCxt->pParseCxt; SRequestConnInfo connInfo = {.pTrans = pParCxt->pTransporter, .requestId = pParCxt->requestId, @@ -9436,18 +9527,29 @@ static int32_t buildQueryForTableTopic(STranslateContext* pCxt, SCreateTopicStmt } SNodeList* pProjection = NULL; + SRealTableNode* realTable = NULL; code = checkCollectTopicTags(pCxt, pStmt, pMeta, &pProjection); if (TSDB_CODE_SUCCESS == code) { - SRealTableNode* realTable = (SRealTableNode*)nodesMakeNode(QUERY_NODE_REAL_TABLE); - strcpy(realTable->table.dbName, pStmt->subDbName); - strcpy(realTable->table.tableName, pStmt->subSTbName); - strcpy(realTable->table.tableAlias, pStmt->subSTbName); - *pSelect = createSelectStmtImpl(true, pProjection, (SNode*)realTable, NULL); - ((SSelectStmt*)*pSelect)->pWhere = nodesCloneNode(pStmt->pWhere); - pCxt->pParseCxt->topicQuery = true; - code = translateQuery(pCxt, *pSelect); + code = nodesMakeNode(QUERY_NODE_REAL_TABLE, (SNode**)&realTable); + if (realTable) { + strcpy(realTable->table.dbName, pStmt->subDbName); + strcpy(realTable->table.tableName, pStmt->subSTbName); + strcpy(realTable->table.tableAlias, pStmt->subSTbName); + code = createSelectStmtImpl(true, pProjection, (SNode*)realTable, NULL, ppSelect); + } + if (TSDB_CODE_SUCCESS == code) { + pProjection = NULL; + realTable = NULL; + SNode** ppWhere = &((SSelectStmt*)*ppSelect)->pWhere; + code = nodesCloneNode(pStmt->pWhere, ppWhere); + } + if (TSDB_CODE_SUCCESS == code) { + pCxt->pParseCxt->topicQuery = true; + code = translateQuery(pCxt, *ppSelect); + } } - + nodesDestroyNode((SNode*)realTable); + nodesDestroyList(pProjection); taosMemoryFree(pMeta); return code; } @@ -9696,14 +9798,15 @@ static void getStreamQueryFirstProjectAliasName(SHashObj* pUserAliasSet, char* a return; } -static void setColumnDefNodePrimaryKey(SColumnDefNode* pNode, bool isPk) { - if (!pNode) return; - if (!isPk && !pNode->pOptions) return; +static int32_t setColumnDefNodePrimaryKey(SColumnDefNode* pNode, bool isPk) { + int32_t code = 0; + if (!pNode) return code; + if (!isPk && !pNode->pOptions) return code; if (!pNode->pOptions) { - pNode->pOptions = nodesMakeNode(QUERY_NODE_COLUMN_OPTIONS); + code = nodesMakeNode(QUERY_NODE_COLUMN_OPTIONS, &pNode->pOptions); } - ((SColumnOptions*)pNode->pOptions)->bPrimaryKey = isPk; - return; + if (TSDB_CODE_SUCCESS ==code) ((SColumnOptions*)pNode->pOptions)->bPrimaryKey = isPk; + return code; } static int32_t addWstartTsToCreateStreamQueryImpl(STranslateContext* pCxt, SSelectStmt* pSelect, @@ -9713,24 +9816,29 @@ static int32_t addWstartTsToCreateStreamQueryImpl(STranslateContext* pCxt, SSele (QUERY_NODE_FUNCTION == nodeType(pProj) && 0 == strcmp("_wstart", ((SFunctionNode*)pProj)->functionName))) { return TSDB_CODE_SUCCESS; } - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); + SFunctionNode* pFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); if (NULL == pFunc) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } strcpy(pFunc->functionName, "_wstart"); getStreamQueryFirstProjectAliasName(pUserAliasSet, pFunc->node.aliasName, sizeof(pFunc->node.aliasName)); - int32_t code = getFuncInfo(pCxt, pFunc); + code = getFuncInfo(pCxt, pFunc); if (TSDB_CODE_SUCCESS == code) { code = nodesListPushFront(pSelect->pProjectionList, (SNode*)pFunc); } if (TSDB_CODE_SUCCESS == code && STREAM_CREATE_STABLE_TRUE == pReq->createStb) { - SColumnDefNode* pColDef = (SColumnDefNode*)nodesMakeNode(QUERY_NODE_COLUMN_DEF); - strcpy(pColDef->colName, pFunc->node.aliasName); - pColDef->dataType = pFunc->node.resType; - pColDef->sma = true; - setColumnDefNodePrimaryKey(pColDef, false); - code = nodesListPushFront(pCols, (SNode*)pColDef); + SColumnDefNode* pColDef = NULL; + code = nodesMakeNode(QUERY_NODE_COLUMN_DEF, (SNode**)&pColDef); + if (TSDB_CODE_SUCCESS == code) { + strcpy(pColDef->colName, pFunc->node.aliasName); + pColDef->dataType = pFunc->node.resType; + pColDef->sma = true; + code = setColumnDefNodePrimaryKey(pColDef, false); + } + if (TSDB_CODE_SUCCESS == code) code = nodesListPushFront(pCols, (SNode*)pColDef); + if (TSDB_CODE_SUCCESS != code) nodesDestroyNode((SNode*)pColDef); } if (TSDB_CODE_SUCCESS != code) { nodesDestroyNode((SNode*)pFunc); @@ -9768,8 +9876,11 @@ static int32_t addTagsToCreateStreamQuery(STranslateContext* pCxt, SCreateStream SNode* pPart = NULL; FOREACH(pPart, pSelect->pPartitionByList) { if (0 == strcmp(getTagNameForCreateStreamTag(pTag), ((SExprNode*)pPart)->userAlias)) { - if (TSDB_CODE_SUCCESS != nodesListMakeStrictAppend(&pSelect->pTags, nodesCloneNode(pPart))) { - return TSDB_CODE_OUT_OF_MEMORY; + SNode* pNew = NULL; + int32_t code = nodesCloneNode(pPart, &pNew); + if (TSDB_CODE_SUCCESS != code) return code; + if (TSDB_CODE_SUCCESS != (code = nodesListMakeStrictAppend(&pSelect->pTags, pNew))) { + return code; } found = true; break; @@ -9782,22 +9893,27 @@ static int32_t addTagsToCreateStreamQuery(STranslateContext* pCxt, SCreateStream return TSDB_CODE_SUCCESS; } -static SNode* createNullValue() { - SValueNode* pValue = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); +static int32_t createNullValue(SNode** ppNode) { + SValueNode* pValue = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValue); if (NULL == pValue) { - return NULL; + return code; } pValue->isNull = true; pValue->node.resType.type = TSDB_DATA_TYPE_NULL; pValue->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_NULL].bytes; - return (SNode*)pValue; + *ppNode = (SNode*)pValue; + return code; } static int32_t addNullTagsForExistTable(STranslateContext* pCxt, STableMeta* pMeta, SSelectStmt* pSelect) { int32_t numOfTags = getNumOfTags(pMeta); int32_t code = TSDB_CODE_SUCCESS; for (int32_t i = 0; TSDB_CODE_SUCCESS == code && i < numOfTags; ++i) { - code = nodesListMakeStrictAppend(&pSelect->pTags, createNullValue()); + SNode* pNull = NULL; + code = createNullValue(&pNull); + if (TSDB_CODE_SUCCESS == code) + code = nodesListMakeStrictAppend(&pSelect->pTags, pNull); } return code; } @@ -9814,9 +9930,10 @@ static EDealRes rewriteSubtable(SNode** pNode, void* pContext) { SNode* pPart = NULL; FOREACH(pPart, pCxt->pPartitionList) { if (0 == strcmp(((SColumnNode*)*pNode)->colName, ((SExprNode*)pPart)->userAlias)) { - SNode* pNew = nodesCloneNode(pPart); + SNode* pNew = NULL; + int32_t code = nodesCloneNode(pPart, &pNew); if (NULL == pNew) { - pCxt->pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; + pCxt->pCxt->errCode = code; return DEAL_RES_ERROR; } nodesDestroyNode(*pNode); @@ -9839,9 +9956,10 @@ static int32_t addSubtableNameToCreateStreamQuery(STranslateContext* pCxt, SCrea return TSDB_CODE_SUCCESS; } if (NULL == pSelect->pSubtable) { - pSelect->pSubtable = nodesCloneNode(pStmt->pSubtable); + pSelect->pSubtable = NULL; + int32_t code = nodesCloneNode(pStmt->pSubtable, &pSelect->pSubtable); if (NULL == pSelect->pSubtable) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } } @@ -9853,7 +9971,10 @@ static int32_t addSubtableNameToCreateStreamQuery(STranslateContext* pCxt, SCrea static int32_t addNullTagsForCreateTable(STranslateContext* pCxt, SCreateStreamStmt* pStmt) { int32_t code = TSDB_CODE_SUCCESS; for (int32_t i = 0; TSDB_CODE_SUCCESS == code && i < LIST_LENGTH(pStmt->pTags); ++i) { - code = nodesListMakeStrictAppend(&((SSelectStmt*)pStmt->pQuery)->pTags, createNullValue()); + SNode* pNull = NULL; + code = createNullValue(&pNull); + if (TSDB_CODE_SUCCESS == code) + code = nodesListMakeStrictAppend(&((SSelectStmt*)pStmt->pQuery)->pTags, pNull); } return code; } @@ -9867,12 +9988,19 @@ static int32_t addNullTagsToCreateStreamQuery(STranslateContext* pCxt, STableMet static int32_t addColDefNodeByProj(SNodeList** ppCols, const SNode* pProject, int8_t flags) { const SExprNode* pExpr = (const SExprNode*)pProject; - SColumnDefNode* pColDef = (SColumnDefNode*)nodesMakeNode(QUERY_NODE_COLUMN_DEF); + SColumnDefNode* pColDef = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN_DEF, (SNode**)&pColDef); + if (TSDB_CODE_SUCCESS != code) return code; strcpy(pColDef->colName, pExpr->userAlias); pColDef->dataType = pExpr->resType; pColDef->sma = flags & COL_SMA_ON; - setColumnDefNodePrimaryKey(pColDef, flags & COL_IS_KEY); - return nodesListMakeAppend(ppCols, (SNode*)pColDef); + code = setColumnDefNodePrimaryKey(pColDef, flags & COL_IS_KEY); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pColDef); + } else { + code = nodesListMakeStrictAppend(ppCols, (SNode*)pColDef); + } + return code; } static int32_t addColsToCreateStreamQuery(STranslateContext* pCxt, SCreateStreamStmt* pStmt, SCMCreateStreamReq* pReq) { @@ -10043,12 +10171,18 @@ static int32_t adjustDataTypeOfProjections(STranslateContext* pCxt, const STable } REPLACE_NODE(pFunc); } - SColumnDefNode* pColDef = (SColumnDefNode*)nodesMakeNode(QUERY_NODE_COLUMN_DEF); + SColumnDefNode* pColDef = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN_DEF, (SNode**)&pColDef); + if (TSDB_CODE_SUCCESS != code) return code; strcpy(pColDef->colName, pSchema->name); pColDef->dataType = dt; pColDef->sma = pSchema->flags & COL_SMA_ON; - setColumnDefNodePrimaryKey(pColDef, pSchema->flags & COL_IS_KEY); - int32_t code = nodesListMakeAppend(ppCols, (SNode*)pColDef); + code = setColumnDefNodePrimaryKey(pColDef, pSchema->flags & COL_IS_KEY); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pColDef); + return code; + } + code = nodesListMakeStrictAppend(ppCols, (SNode*)pColDef); if (TSDB_CODE_SUCCESS != code) { return code; } @@ -10073,12 +10207,12 @@ static int32_t projColPosCompar(const void* l, const void* r) { static void projColPosDelete(void* p) { nodesDestroyNode(((SProjColPos*)p)->pProj); } static int32_t addProjToProjColPos(STranslateContext* pCxt, const SSchema* pSchema, SNode* pProj, SArray* pProjColPos) { - SNode* pNewProj = nodesCloneNode(pProj); + SNode* pNewProj = NULL; + int32_t code = nodesCloneNode(pProj, &pNewProj); if (NULL == pNewProj) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - int32_t code = TSDB_CODE_SUCCESS; SDataType dt = {.type = pSchema->type, .bytes = pSchema->bytes}; if (!dataTypeEqual(&dt, &((SExprNode*)pNewProj)->resType)) { SNode* pFunc = NULL; @@ -10174,10 +10308,11 @@ static int32_t adjustOrderOfProjections(STranslateContext* pCxt, SNodeList** ppC if (TSDB_CODE_SUCCESS == code) { taosArraySort(pProjColPos, projColPosCompar); int32_t num = taosArrayGetSize(pProjColPos); - pNewProjections = nodesMakeList(); - pNewCols = nodesMakeList(); - if (NULL == pNewProjections || !pNewCols) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = nodesMakeList(&pNewProjections); + if (TSDB_CODE_SUCCESS != code) return code; + code = nodesMakeList(&pNewCols); + if (TSDB_CODE_SUCCESS != code) { + code = code; } for (int32_t i = 0; TSDB_CODE_SUCCESS == code && i < num; ++i) { SProjColPos* pPos = taosArrayGet(pProjColPos, i); @@ -10283,9 +10418,9 @@ static int32_t adjustOrderOfTags(STranslateContext* pCxt, SNodeList* pTags, cons int32_t numOfBoundTags = taosArrayGetSize(pTagPos); int32_t numOfTags = getNumOfTags(pMeta); const SSchema* pTagsSchema = getTableTagSchema(pMeta); - pNewTagExprs = nodesMakeList(); + code = nodesMakeList(&pNewTagExprs); if (NULL == pNewTagExprs) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = code; } for (int32_t i = 0; TSDB_CODE_SUCCESS == code && i < numOfTags; ++i) { const SSchema* pTagSchema = pTagsSchema + i; @@ -10298,7 +10433,10 @@ static int32_t adjustOrderOfTags(STranslateContext* pCxt, SNodeList* pTags, cons continue; } } - code = nodesListStrictAppend(pNewTagExprs, createNullValue()); + SNode* pNull = NULL; + code = createNullValue(&pNull); + if (TSDB_CODE_SUCCESS == code) + code = nodesListStrictAppend(pNewTagExprs, pNull); } } @@ -10401,20 +10539,22 @@ static int32_t translateStreamTargetTable(STranslateContext* pCxt, SCreateStream } static int32_t createLastTsSelectStmt(char* pDb, const char* pTable, const char* pkColName, SNode** pQuery) { - SColumnNode* col = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + SColumnNode* col = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&col); if (NULL == col) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } tstrncpy(col->tableAlias, pTable, tListLen(col->tableAlias)); tstrncpy(col->colName, pkColName, tListLen(col->colName)); - SNodeList* pParameterList = nodesMakeList(); + SNodeList* pParameterList = NULL; + code = nodesMakeList(&pParameterList); if (NULL == pParameterList) { nodesDestroyNode((SNode*)col); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - int32_t code = nodesListStrictAppend(pParameterList, (SNode*)col); + code = nodesListStrictAppend(pParameterList, (SNode*)col); if (code) { nodesDestroyList(pParameterList); return code; @@ -10424,13 +10564,14 @@ static int32_t createLastTsSelectStmt(char* pDb, const char* pTable, const char* code = createFunction("last", pParameterList, (SFunctionNode**)&pFunc); if (code) { nodesDestroyList(pParameterList); - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } - SNodeList* pProjectionList = nodesMakeList(); + SNodeList* pProjectionList = NULL; + code = nodesMakeList(&pProjectionList); if (NULL == pProjectionList) { nodesDestroyNode(pFunc); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } code = nodesListStrictAppend(pProjectionList, pFunc); @@ -10443,7 +10584,7 @@ static int32_t createLastTsSelectStmt(char* pDb, const char* pTable, const char* code = createFunction("_vgid", NULL, &pFunc1); if (code) { nodesDestroyList(pProjectionList); - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } snprintf(pFunc1->node.aliasName, sizeof(pFunc1->node.aliasName), "%s.%p", pFunc1->functionName, pFunc1); @@ -10457,7 +10598,7 @@ static int32_t createLastTsSelectStmt(char* pDb, const char* pTable, const char* code = createFunction("_vgver", NULL, &pFunc2); if (code) { nodesDestroyList(pProjectionList); - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } snprintf(pFunc2->node.aliasName, sizeof(pFunc2->node.aliasName), "%s.%p", pFunc2->functionName, pFunc2); @@ -10474,24 +10615,31 @@ static int32_t createLastTsSelectStmt(char* pDb, const char* pTable, const char* } SSelectStmt** pSelect1 = (SSelectStmt**)pQuery; - (*pSelect1)->pGroupByList = nodesMakeList(); + code = nodesMakeList(&(*pSelect1)->pGroupByList); if (NULL == (*pSelect1)->pGroupByList) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - SGroupingSetNode* pNode1 = (SGroupingSetNode*)nodesMakeNode(QUERY_NODE_GROUPING_SET); + SGroupingSetNode* pNode1 = NULL; + code = nodesMakeNode(QUERY_NODE_GROUPING_SET, (SNode**)&pNode1); if (NULL == pNode1) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pNode1->groupingSetType = GP_TYPE_NORMAL; - pNode1->pParameterList = nodesMakeList(); + code = nodesMakeList(&pNode1->pParameterList); if (NULL == pNode1->pParameterList) { nodesDestroyNode((SNode*)pNode1); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - code = nodesListStrictAppend(pNode1->pParameterList, nodesCloneNode((SNode*)pFunc1)); + SNode* pNew = NULL; + code = nodesCloneNode((SNode*)pFunc1, &pNew); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pNode1); + return code; + } + code = nodesListStrictAppend(pNode1->pParameterList, pNew); if (code) { nodesDestroyNode((SNode*)pNode1); return code; @@ -10502,25 +10650,32 @@ static int32_t createLastTsSelectStmt(char* pDb, const char* pTable, const char* return code; } - SGroupingSetNode* pNode2 = (SGroupingSetNode*)nodesMakeNode(QUERY_NODE_GROUPING_SET); + SGroupingSetNode* pNode2 = NULL; + code = nodesMakeNode(QUERY_NODE_GROUPING_SET, (SNode**)&pNode2); if (NULL == pNode2) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pNode2->groupingSetType = GP_TYPE_NORMAL; - pNode2->pParameterList = nodesMakeList(); + code = nodesMakeList(&pNode2->pParameterList); if (NULL == pNode2->pParameterList) { nodesDestroyNode((SNode*)pNode2); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - code = nodesListStrictAppend(pNode2->pParameterList, nodesCloneNode((SNode*)pFunc2)); + pNew = NULL; + code = nodesCloneNode((SNode*)pFunc2, &pNew); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pNode2); + return code; + } + code = nodesListStrictAppend(pNode2->pParameterList, pNew); if (code) { nodesDestroyNode((SNode*)pNode2); return code; } - return nodesListAppend((*pSelect1)->pGroupByList, (SNode*)pNode2); + return nodesListStrictAppend((*pSelect1)->pGroupByList, (SNode*)pNode2); } static int32_t checkAndAdjStreamDestTableSchema(STranslateContext* pCxt, SCreateStreamStmt* pStmt, @@ -10551,7 +10706,8 @@ static int32_t checkAndAdjStreamDestTableSchema(STranslateContext* pCxt, SCreate pNode = nodesListGetNode(pStmt->pCols, 1); pCol = (SColumnDefNode*)pNode; if (STREAM_CREATE_STABLE_TRUE == pReq->createStb) { - setColumnDefNodePrimaryKey(pCol, true); + int32_t code = setColumnDefNodePrimaryKey(pCol, true); + if (TSDB_CODE_SUCCESS != code) return code; } if (!pCol->pOptions || !((SColumnOptions*)pCol->pOptions)->bPrimaryKey) { return generateSyntaxErrMsgExt(&pCxt->msgBuf, TSDB_CODE_PAR_INVALID_STREAM_QUERY, @@ -10974,9 +11130,10 @@ static int32_t translateDropFunction(STranslateContext* pCxt, SDropFunctionStmt* } static int32_t createRealTableForGrantTable(SGrantStmt* pStmt, SRealTableNode** pTable) { - SRealTableNode* pRealTable = (SRealTableNode*)nodesMakeNode(QUERY_NODE_REAL_TABLE); + SRealTableNode* pRealTable = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_REAL_TABLE, (SNode**)&pRealTable); if (NULL == pRealTable) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } strcpy(pRealTable->table.dbName, pStmt->objName); strcpy(pRealTable->table.tableName, pStmt->tabName); @@ -11209,13 +11366,15 @@ static int32_t translateShowCreateView(STranslateContext* pCxt, SShowCreateViewS #endif } -static SColumnNode* createColumnNodeWithName(const char* name) { - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); - if (!pCol) return NULL; +static int32_t createColumnNodeWithName(const char* name, SNode** ppCol) { + SColumnNode* pCol = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); + if (!pCol) return code; tstrncpy(pCol->colName, name, TSDB_COL_NAME_LEN); tstrncpy(pCol->node.aliasName, name, TSDB_COL_NAME_LEN); tstrncpy(pCol->node.userAlias, name, TSDB_COL_NAME_LEN); - return pCol; + *ppCol = (SNode*)pCol; + return code; } static int32_t compareTsmaColWithColId(SNode* pNode1, SNode* pNode2) { @@ -11265,13 +11424,16 @@ static void deduplicateTsmaFuncs(SNodeList* pFuncs) { static int32_t buildTSMAAstStreamSubTable(SCreateTSMAStmt* pStmt, SMCreateSmaReq* pReq, const SNode* pTbname, SNode** pSubTable) { int32_t code = 0; - SFunctionNode* pMd5Func = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); - SFunctionNode* pConcatFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); - SValueNode* pVal = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); - if (!pMd5Func || !pConcatFunc || !pVal) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _end; - } + SFunctionNode* pMd5Func = NULL; + code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pMd5Func); + if (TSDB_CODE_SUCCESS != code) goto _end; + SFunctionNode* pConcatFunc = NULL; + code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pConcatFunc); + if (TSDB_CODE_SUCCESS != code) goto _end; + SValueNode* pVal = NULL; + code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pVal); + if (TSDB_CODE_SUCCESS != code) goto _end; + sprintf(pMd5Func->functionName, "%s", "md5"); sprintf(pConcatFunc->functionName, "%s", "concat"); pVal->literal = taosMemoryMalloc(TSDB_TABLE_FNAME_LEN + 1); @@ -11288,7 +11450,10 @@ static int32_t buildTSMAAstStreamSubTable(SCreateTSMAStmt* pStmt, SMCreateSmaReq // not recursive tsma, md5(concat('1.test.tsma1_', tbname)) // recursive tsma, md5(concat('1.test.tsma1_', `tbname`)), `tbname` is the last tag - code = nodesListStrictAppend(pConcatFunc->pParameterList, nodesCloneNode(pTbname)); + SNode* pNew = NULL; + code = nodesCloneNode(pTbname, &pNew); + if (TSDB_CODE_SUCCESS != code) goto _end; + code = nodesListStrictAppend(pConcatFunc->pParameterList, pNew); if (code != TSDB_CODE_SUCCESS) goto _end; code = nodesListMakeAppend(&pMd5Func->pParameterList, (SNode*)pConcatFunc); @@ -11312,19 +11477,19 @@ static int32_t buildTSMAAst(STranslateContext* pCxt, SCreateTSMAStmt* pStmt, SMC info.createSmaIndex = true; info.pDbName = pStmt->dbName; info.pTableName = tbName; - info.pFuncs = nodesCloneList(pStmt->pOptions->pFuncs); - info.pInterval = nodesCloneNode(pStmt->pOptions->pInterval); - if (!info.pFuncs || !info.pInterval) code = TSDB_CODE_OUT_OF_MEMORY; + code = nodesCloneList(pStmt->pOptions->pFuncs, &info.pFuncs); + if (TSDB_CODE_SUCCESS == code) + code = nodesCloneNode(pStmt->pOptions->pInterval, &info.pInterval); SFunctionNode* pTbnameFunc = NULL; if (TSDB_CODE_SUCCESS == code) { // append partition by tbname - pTbnameFunc = (SFunctionNode*)createTbnameFunction(); + code = createTbnameFunction(&pTbnameFunc); if (pTbnameFunc) { sprintf(pTbnameFunc->node.userAlias, "tbname"); code = nodesListMakeStrictAppend(&info.pPartitionByList, (SNode*)pTbnameFunc); } else { - code = TSDB_CODE_OUT_OF_MEMORY; + code = code; } } if (TSDB_CODE_SUCCESS == code) { @@ -11332,14 +11497,18 @@ static int32_t buildTSMAAst(STranslateContext* pCxt, SCreateTSMAStmt* pStmt, SMC // append partition by tags SNode* pTagCol = NULL; for (int32_t idx = 0; idx < partitionTagNum; ++idx) { - pTagCol = (SNode*)createColumnNodeWithName(pTags[idx].name); + pTagCol = NULL; + code = createColumnNodeWithName(pTags[idx].name, &pTagCol); if (!pTagCol) { - code = TSDB_CODE_OUT_OF_MEMORY; break; } code = nodesListAppend(info.pPartitionByList, pTagCol); - if (TSDB_CODE_SUCCESS == code) - code = nodesListMakeStrictAppend(&info.pTags, nodesCloneNode(pTagCol)); + if (TSDB_CODE_SUCCESS == code) { + SNode*pNew = NULL; + code = nodesCloneNode(pTagCol, &pNew); + if (TSDB_CODE_SUCCESS == code) + code = nodesListMakeStrictAppend(&info.pTags, pNew); + } } // sub table @@ -11347,17 +11516,22 @@ static int32_t buildTSMAAst(STranslateContext* pCxt, SCreateTSMAStmt* pStmt, SMC SFunctionNode* pSubTable = NULL; pTagCol = NULL; if (pTags && numOfTags > 0) { - pTagCol = (SNode*)createColumnNodeWithName(pTags[numOfTags - 1].name); - if (!pTagCol) code = TSDB_CODE_OUT_OF_MEMORY; + code = createColumnNodeWithName(pTags[numOfTags - 1].name, &pTagCol); } if (code == TSDB_CODE_SUCCESS) { code = buildTSMAAstStreamSubTable(pStmt, pReq, pStmt->pOptions->recursiveTsma ? pTagCol : (SNode*)pTbnameFunc, (SNode**)&pSubTable); info.pSubTable = (SNode*)pSubTable; } - if (code == TSDB_CODE_SUCCESS) - code = nodesListMakeStrictAppend( - &info.pTags, pStmt->pOptions->recursiveTsma ? pTagCol : nodesCloneNode((SNode*)pTbnameFunc)); + if (code == TSDB_CODE_SUCCESS) { + if (pStmt->pOptions->recursiveTsma) { + code = nodesListMakeStrictAppend(&info.pTags, pTagCol); + } else { + SNode* pNew = NULL; + code = nodesCloneNode((SNode*)pTbnameFunc, &pNew); + if (TSDB_CODE_SUCCESS == code) code = nodesListMakeStrictAppend(&info.pTags, pNew); + } + } } } @@ -11375,9 +11549,8 @@ static int32_t buildTSMAAst(STranslateContext* pCxt, SCreateTSMAStmt* pStmt, SMC } static int32_t createColumnBySchema(const SSchema* pSchema, SColumnNode** ppCol) { - *ppCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); - int32_t code = 0; - if (!*ppCol) return TSDB_CODE_OUT_OF_MEMORY; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)ppCol); + if (!*ppCol) return code; (*ppCol)->colId = pSchema->colId; (*ppCol)->node.resType.type = pSchema->type; @@ -11523,7 +11696,10 @@ static int32_t buildCreateTSMAReq(STranslateContext* pCxt, SCreateTSMAStmt* pStm FOREACH(pNode, pSelect->pProjectionList) { SFunctionNode* pFuncNode = (SFunctionNode*)pNode; if (!fmIsTSMASupportedFunc(pFuncNode->funcId)) continue; - code = nodesListMakeStrictAppend(&pStmt->pOptions->pFuncs, nodesCloneNode(pNode)); + SNode* pNew = NULL; + code = nodesCloneNode(pNode, &pNew); + if (TSDB_CODE_SUCCESS != code) break; + code = nodesListMakeStrictAppend(&pStmt->pOptions->pFuncs, pNew); if (TSDB_CODE_SUCCESS != code) { break; } @@ -12114,29 +12290,36 @@ int32_t extractResultSchema(const SNode* pRoot, int32_t* numOfCols, SSchema** pS return TSDB_CODE_FAILED; } -static SNode* createStarCol() { - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); +static int32_t createStarCol(SNode** ppNode) { + SColumnNode* pCol = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); if (NULL == pCol) { - return NULL; + return code; } strcpy(pCol->colName, "*"); - return (SNode*)pCol; + *ppNode = (SNode*)pCol; + return code; } -static SNode* createProjectCol(const char* pProjCol) { - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); +static int32_t createProjectCol(const char* pProjCol, SNode** ppNode) { + SColumnNode* pCol = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); if (NULL == pCol) { - return NULL; + return code; } snprintf(pCol->colName, sizeof(pCol->colName), "%s", pProjCol); - return (SNode*)pCol; + *ppNode = (SNode*)pCol; + return code; } static int32_t createProjectCols(int32_t ncols, const char* const pCols[], SNodeList** pResList) { SNodeList* pProjections = NULL; int32_t code = TSDB_CODE_SUCCESS; if (0 == ncols) { - code = nodesListMakeStrictAppend(&pProjections, createStarCol()); + SNode* pStar = NULL; + code = createStarCol(&pStar); + if (TSDB_CODE_SUCCESS != code) return code; + code = nodesListMakeStrictAppend(&pProjections, pStar); if (TSDB_CODE_SUCCESS == code) *pResList = pProjections; else @@ -12144,7 +12327,13 @@ static int32_t createProjectCols(int32_t ncols, const char* const pCols[], SNode return code; } for (int32_t i = 0; i < ncols; ++i) { - code = nodesListMakeStrictAppend(&pProjections, createProjectCol(pCols[i])); + SNode* pPrjCol = NULL; + code = createProjectCol(pCols[i], (SNode**)&pPrjCol); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyList(pProjections); + break; + } + code = nodesListMakeStrictAppend(&pProjections, pPrjCol); if (TSDB_CODE_SUCCESS != code) { nodesDestroyList(pProjections); break; @@ -12156,16 +12345,18 @@ static int32_t createProjectCols(int32_t ncols, const char* const pCols[], SNode static int32_t createSimpleSelectStmtImpl(const char* pDb, const char* pTable, SNodeList* pProjectionList, SSelectStmt** pStmt) { - SSelectStmt* pSelect = (SSelectStmt*)nodesMakeNode(QUERY_NODE_SELECT_STMT); + SSelectStmt* pSelect = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_SELECT_STMT, (SNode**)&pSelect); if (NULL == pSelect) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } sprintf(pSelect->stmtName, "%p", pSelect); - SRealTableNode* pRealTable = (SRealTableNode*)nodesMakeNode(QUERY_NODE_REAL_TABLE); + SRealTableNode* pRealTable = NULL; + code = nodesMakeNode(QUERY_NODE_REAL_TABLE, (SNode**)&pRealTable); if (NULL == pRealTable) { nodesDestroyNode((SNode*)pSelect); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } snprintf(pRealTable->table.dbName, sizeof(pRealTable->table.dbName), "%s", pDb); snprintf(pRealTable->table.tableName, sizeof(pRealTable->table.tableName), "%s", pTable); @@ -12204,22 +12395,27 @@ static int32_t createSelectStmtForShowTableDist(SShowTableDistributedStmt* pStmt return createSimpleSelectStmtFromCols(pStmt->dbName, pStmt->tableName, 0, NULL, pOutput); } -static int32_t createOperatorNode(EOperatorType opType, const char* pColName, SNode* pRight, SNode** pOp) { +static int32_t createOperatorNode(EOperatorType opType, const char* pColName, const SNode* pRight, SNode** pOp) { if (NULL == pRight) { return TSDB_CODE_SUCCESS; } - SOperatorNode* pOper = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR); + SOperatorNode* pOper = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pOper); if (NULL == pOper) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pOper->opType = opType; - pOper->pLeft = nodesMakeNode(QUERY_NODE_COLUMN); - pOper->pRight = nodesCloneNode(pRight); - if (NULL == pOper->pLeft || NULL == pOper->pRight) { + code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pOper->pLeft); + if (TSDB_CODE_SUCCESS != code) { nodesDestroyNode((SNode*)pOper); - return TSDB_CODE_OUT_OF_MEMORY; + return code; + } + code = nodesCloneNode(pRight, (SNode**)&pOper->pRight); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pOper); + return code; } snprintf(((SColumnNode*)pOper->pLeft)->colName, sizeof(((SColumnNode*)pOper->pLeft)->colName), "%s", pColName); @@ -12229,15 +12425,20 @@ static int32_t createOperatorNode(EOperatorType opType, const char* pColName, SN static int32_t createParOperatorNode(EOperatorType opType, const char* pLeftCol, const char* pRightCol, SNode** ppResOp) { - SOperatorNode* pOper = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR); - CHECK_POINTER_OUT_OF_MEM(pOper); + SOperatorNode* pOper = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pOper); + if (TSDB_CODE_SUCCESS != code) return code; pOper->opType = opType; - pOper->pLeft = nodesMakeNode(QUERY_NODE_COLUMN); - pOper->pRight = nodesMakeNode(QUERY_NODE_COLUMN); - if (NULL == pOper->pLeft || NULL == pOper->pRight) { + code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pOper->pLeft); + if (TSDB_CODE_SUCCESS != code) { nodesDestroyNode((SNode*)pOper); - return TSDB_CODE_OUT_OF_MEMORY; + return code; + } + code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pOper->pRight); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pOper); + return code; } strcpy(((SColumnNode*)pOper->pLeft)->colName, pLeftCol); strcpy(((SColumnNode*)pOper->pRight)->colName, pRightCol); @@ -12264,15 +12465,16 @@ static const char* getTbNameColName(ENodeType type) { static int32_t createLogicCondNode(SNode** pCond1, SNode** pCond2, SNode** pCond, ELogicConditionType logicCondType) { int32_t code = TSDB_CODE_SUCCESS; - SLogicConditionNode* pCondition = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); + SLogicConditionNode* pCondition = NULL; + code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pCondition); if (NULL == pCondition) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pCondition->condType = logicCondType; - pCondition->pParameterList = nodesMakeList(); + code = nodesMakeList(&pCondition->pParameterList); if (NULL == pCondition->pParameterList) { nodesDestroyNode((SNode*)pCondition); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } code = nodesListAppend(pCondition->pParameterList, *pCond1); if (TSDB_CODE_SUCCESS == code) { @@ -12326,7 +12528,8 @@ static int32_t insertCondIntoSelectStmt(SSelectStmt* pSelect, SNode** pCond) { } if (TSDB_CODE_SUCCESS == code) { - SLogicConditionNode* pWhere = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); + SLogicConditionNode* pWhere = NULL; + code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pWhere); if (pWhere) { pWhere->condType = LOGIC_COND_TYPE_AND; pWhere->pParameterList = pLogicCondListWhere; @@ -12348,13 +12551,10 @@ static int32_t addShowUserDatabasesCond(SSelectStmt* pSelect) { SNode* pNameCond2 = NULL; SNode* pNameCond = NULL; SValueNode* pValNode1 = NULL, *pValNode2 = NULL; - pValNode1 = nodesMakeValueNodeFromString(TSDB_INFORMATION_SCHEMA_DB); - if (!pValNode1) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + code = nodesMakeValueNodeFromString(TSDB_INFORMATION_SCHEMA_DB, &pValNode1); + if (TSDB_CODE_SUCCESS == code) { - pValNode2 = nodesMakeValueNodeFromString(TSDB_PERFORMANCE_SCHEMA_DB); - if (!pValNode2) code = TSDB_CODE_OUT_OF_MEMORY; + code = nodesMakeValueNodeFromString(TSDB_PERFORMANCE_SCHEMA_DB, &pValNode2); } if (TSDB_CODE_SUCCESS == code) { code = createOperatorNode(OP_TYPE_NOT_EQUAL, "name", (SNode*)pValNode1, &pNameCond1); @@ -12384,13 +12584,9 @@ static int32_t addShowSystemDatabasesCond(SSelectStmt* pSelect) { SNode* pNameCond2 = NULL; SValueNode* pValNode1 = NULL, * pValNode2 = NULL; SNode* pNameCond = NULL; - pValNode1 = nodesMakeValueNodeFromString(TSDB_INFORMATION_SCHEMA_DB); - if (!pValNode1) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + code = nodesMakeValueNodeFromString(TSDB_INFORMATION_SCHEMA_DB, &pValNode1); if (TSDB_CODE_SUCCESS == code) { - pValNode2 = nodesMakeValueNodeFromString(TSDB_PERFORMANCE_SCHEMA_DB); - if (!pValNode2) code = terrno; + code = nodesMakeValueNodeFromString(TSDB_PERFORMANCE_SCHEMA_DB, &pValNode2); } if (TSDB_CODE_SUCCESS == code) { code = createOperatorNode(OP_TYPE_EQUAL, "name", (SNode*)pValNode1, &pNameCond1); @@ -12418,8 +12614,8 @@ static int32_t addShowSystemDatabasesCond(SSelectStmt* pSelect) { static int32_t addShowNormalTablesCond(SSelectStmt* pSelect) { SNode* pTypeCond = NULL; int32_t code = TSDB_CODE_SUCCESS; - SValueNode* pValNode1 = nodesMakeValueNodeFromString("NORMAL_TABLE"); - if (!pValNode1) code = TSDB_CODE_OUT_OF_MEMORY; + SValueNode* pValNode1 = NULL; + code = nodesMakeValueNodeFromString("NORMAL_TABLE", &pValNode1); if (TSDB_CODE_SUCCESS == code) code = createOperatorNode(OP_TYPE_EQUAL, "type", (SNode*)pValNode1, &pTypeCond); @@ -12434,8 +12630,8 @@ static int32_t addShowNormalTablesCond(SSelectStmt* pSelect) { static int32_t addShowChildTablesCond(SSelectStmt* pSelect) { int32_t code = TSDB_CODE_SUCCESS; SNode* pTypeCond = NULL; - SValueNode* pValNode1 = nodesMakeValueNodeFromString("CHILD_TABLE"); - if (!pValNode1) code = TSDB_CODE_OUT_OF_MEMORY; + SValueNode* pValNode1 = NULL; + code = nodesMakeValueNodeFromString("CHILD_TABLE", &pValNode1); if (TSDB_CODE_SUCCESS == code) code = createOperatorNode(OP_TYPE_EQUAL, "type", (SNode*)pValNode1, &pTypeCond); @@ -12564,13 +12760,15 @@ static int32_t rewriteShowTags(STranslateContext* pCxt, SQuery* pQuery) { return code; } -static SNode* createTagsFunction() { - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); +static int32_t createTagsFunction(SNode** ppNode) { + SFunctionNode* pFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); if (NULL == pFunc) { - return NULL; + return code; } strcpy(pFunc->functionName, "_tags"); - return (SNode*)pFunc; + *ppNode = (SNode*)pFunc; + return code; } static int32_t createShowTableTagsProjections(SNodeList** pProjections, SNodeList** pTags) { @@ -12578,9 +12776,16 @@ static int32_t createShowTableTagsProjections(SNodeList** pProjections, SNodeLis TSWAP(*pProjections, *pTags); return TSDB_CODE_SUCCESS; } - int32_t code = nodesListMakeStrictAppend(pProjections, createTbnameFunction()); + SFunctionNode* pTbNameFunc = NULL; + int32_t code = createTbnameFunction(&pTbNameFunc); if (TSDB_CODE_SUCCESS == code) { - code = nodesListStrictAppend(*pProjections, createTagsFunction()); + code = nodesListMakeStrictAppend(pProjections, (SNode*)pTbNameFunc); + } + if (TSDB_CODE_SUCCESS == code) { + code = createTbnameFunction(&pTbNameFunc); + } + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(*pProjections, (SNode*)pTbNameFunc); } return code; } @@ -12651,30 +12856,39 @@ static int32_t rewriteShowVnodes(STranslateContext* pCxt, SQuery* pQuery) { return code; } -static SNode* createBlockDistInfoFunc() { - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); +static int32_t createBlockDistInfoFunc(SFunctionNode** ppNode) { + SFunctionNode* pFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); if (NULL == pFunc) { - return NULL; + return code; } strcpy(pFunc->functionName, "_block_dist_info"); strcpy(pFunc->node.aliasName, "_block_dist_info"); - return (SNode*)pFunc; + *ppNode = pFunc; + return code; } -static SNode* createBlockDistFunc() { - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); +static int32_t createBlockDistFunc(SFunctionNode** ppNode) { + SFunctionNode* pFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); if (NULL == pFunc) { - return NULL; + return code; } strcpy(pFunc->functionName, "_block_dist"); strcpy(pFunc->node.aliasName, "_block_dist"); - if (TSDB_CODE_SUCCESS != nodesListMakeStrictAppend(&pFunc->pParameterList, createBlockDistInfoFunc())) { - nodesDestroyNode((SNode*)pFunc); - return NULL; + SFunctionNode* pFuncNew = NULL; + code = createBlockDistInfoFunc(&pFuncNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pFunc->pParameterList, (SNode*)pFuncNew); } - return (SNode*)pFunc; + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pFunc); + return code; + } + *ppNode = pFunc; + return code; } static int32_t rewriteShowTableDist(STranslateContext* pCxt, SQuery* pQuery) { @@ -12682,7 +12896,10 @@ static int32_t rewriteShowTableDist(STranslateContext* pCxt, SQuery* pQuery) { int32_t code = createSelectStmtForShowTableDist((SShowTableDistributedStmt*)pQuery->pRoot, &pStmt); if (TSDB_CODE_SUCCESS == code) { NODES_DESTORY_LIST(pStmt->pProjectionList); - code = nodesListMakeStrictAppend(&pStmt->pProjectionList, createBlockDistFunc()); + SFunctionNode* pFuncNew = NULL; + code = createBlockDistFunc(&pFuncNew); + if (TSDB_CODE_SUCCESS == code) + code = nodesListMakeStrictAppend(&pStmt->pProjectionList, (SNode*)pFuncNew); } if (TSDB_CODE_SUCCESS == code) { pCxt->showRewrite = true; @@ -12821,9 +13038,10 @@ static void destroyCreateTbReqBatch(void* data) { } int32_t rewriteToVnodeModifyOpStmt(SQuery* pQuery, SArray* pBufArray) { - SVnodeModifyOpStmt* pNewStmt = (SVnodeModifyOpStmt*)nodesMakeNode(QUERY_NODE_VNODE_MODIFY_STMT); + SVnodeModifyOpStmt* pNewStmt = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_VNODE_MODIFY_STMT, (SNode**)&pNewStmt); if (pNewStmt == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pNewStmt->sqlNodeType = nodeType(pQuery->pRoot); pNewStmt->pDataBlocks = pBufArray; @@ -12950,11 +13168,12 @@ static int32_t addCreateTbReqIntoVgroup(SHashObj* pVgroupHashmap, const char* db } static int32_t createCastFuncForTag(STranslateContext* pCxt, SNode* pNode, SDataType dt, SNode** pCast) { - SNode* pExpr = nodesCloneNode(pNode); + SNode* pExpr = NULL; + int32_t code = nodesCloneNode(pNode, (SNode**)&pExpr); if (NULL == pExpr) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - int32_t code = translateExpr(pCxt, &pExpr); + code = translateExpr(pCxt, &pExpr); if (TSDB_CODE_SUCCESS == code) { code = createCastFunc(pCxt, pExpr, dt, pCast); } @@ -13654,9 +13873,10 @@ static int32_t rewriteCreateMultiTable(STranslateContext* pCxt, SQuery* pQuery) } static int32_t rewriteCreateTableFromFile(STranslateContext* pCxt, SQuery* pQuery) { - SVnodeModifyOpStmt* pModifyStmt = (SVnodeModifyOpStmt*)nodesMakeNode(QUERY_NODE_VNODE_MODIFY_STMT); + SVnodeModifyOpStmt* pModifyStmt = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_VNODE_MODIFY_STMT, (SNode**)&pModifyStmt); if (pModifyStmt == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pModifyStmt->sqlNodeType = nodeType(pQuery->pRoot); pModifyStmt->fileProcessing = false; @@ -13669,7 +13889,7 @@ static int32_t rewriteCreateTableFromFile(STranslateContext* pCxt, SQuery* pQuer SCreateSubTableFromFileClause* pCreateStmt = (SCreateSubTableFromFileClause*)pQuery->pRoot; - int32_t code = prepareReadCsvFile(pCxt, pCreateStmt, pModifyStmt); + code = prepareReadCsvFile(pCxt, pCreateStmt, pModifyStmt); if (TSDB_CODE_SUCCESS != code) { taosHashCleanup(pModifyStmt->pVgroupsHashObj); return code; @@ -14459,8 +14679,9 @@ static int32_t rewriteShowCompactDetailsStmt(STranslateContext* pCxt, SQuery* pQ } static int32_t createParWhenThenNode(SNode* pWhen, SNode* pThen, SNode** ppResWhenThen) { - SWhenThenNode* pWThen = (SWhenThenNode*)nodesMakeNode(QUERY_NODE_WHEN_THEN); - CHECK_POINTER_OUT_OF_MEM(pWThen); + SWhenThenNode* pWThen = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_WHEN_THEN, (SNode**)&pWThen); + if (TSDB_CODE_SUCCESS != code) return code; pWThen->pWhen = pWhen; pWThen->pThen = pThen; @@ -14470,8 +14691,11 @@ static int32_t createParWhenThenNode(SNode* pWhen, SNode* pThen, SNode** ppResWh static int32_t createParCaseWhenNode(SNode* pCase, SNodeList* pWhenThenList, SNode* pElse, const char* pAias, SNode** ppResCaseWhen) { - SCaseWhenNode* pCaseWhen = (SCaseWhenNode*)nodesMakeNode(QUERY_NODE_CASE_WHEN); - CHECK_POINTER_OUT_OF_MEM(pCaseWhen); + SCaseWhenNode* pCaseWhen = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_CASE_WHEN, (SNode**)&pCaseWhen); + if (TSDB_CODE_SUCCESS != code) { + return code; + } pCaseWhen->pCase = pCase; pCaseWhen->pWhenThenList = pWhenThenList; @@ -14486,8 +14710,11 @@ static int32_t createParCaseWhenNode(SNode* pCase, SNodeList* pWhenThenList, SNo static int32_t createParFunctionNode(const char* pFunName, const char* pAias, SNodeList* pParameterList, SNode** ppResFunc) { - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); - CHECK_POINTER_OUT_OF_MEM(pFunc); + SFunctionNode* pFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); + if (TSDB_CODE_SUCCESS != code) { + return code; + } strcpy(pFunc->functionName, pFunName); strcpy(pFunc->node.aliasName, pAias); strcpy(pFunc->node.userAlias, pAias); @@ -14497,16 +14724,22 @@ static int32_t createParFunctionNode(const char* pFunName, const char* pAias, SN } static int32_t createParListNode(SNode* pItem, SNodeList** ppResList) { - SNodeList* pList = nodesMakeList(); - CHECK_POINTER_OUT_OF_MEM(pList); - CHECK_RES_OUT_OF_MEM(nodesListStrictAppend(pList, pItem)); + SNodeList* pList = NULL; + int32_t code = nodesMakeList(&pList); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + CHECK_RES_OUT_OF_MEM(nodesListAppend(pList, pItem)); *ppResList = pList; return TSDB_CODE_SUCCESS; } static int32_t createParTempTableNode(SSelectStmt* pSubquery, SNode** ppResTempTable) { - STempTableNode* pTempTable = (STempTableNode*)nodesMakeNode(QUERY_NODE_TEMP_TABLE); - CHECK_POINTER_OUT_OF_MEM(pTempTable); + STempTableNode* pTempTable = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_TEMP_TABLE, (SNode**)&pTempTable); + if (TSDB_CODE_SUCCESS != code) { + return code; + } pTempTable->pSubquery = (SNode*)pSubquery; taosRandStr(pTempTable->table.tableAlias, 8); strcpy(pSubquery->stmtName, pTempTable->table.tableAlias); @@ -14526,128 +14759,389 @@ static int32_t rewriteShowAliveStmt(STranslateContext* pCxt, SQuery* pQuery) { } } - SValueNode* pValNode = nodesMakeValueNodeFromString("leader"); - CHECK_POINTER_OUT_OF_MEM(pValNode); + SValueNode* pValNode = NULL; + code = nodesMakeValueNodeFromString("leader", &pValNode); + if (TSDB_CODE_SUCCESS != code) return code; SNode* pCond1 = NULL; SNode* pCond2 = NULL; SNode* pCond3 = NULL; SNode* pCond4 = NULL; - CHECK_RES_OUT_OF_MEM(createOperatorNode(OP_TYPE_EQUAL, "v1_status", (SNode*)pValNode, &pCond1)); - CHECK_RES_OUT_OF_MEM(createOperatorNode(OP_TYPE_EQUAL, "v2_status", (SNode*)pValNode, &pCond2)); - CHECK_RES_OUT_OF_MEM(createOperatorNode(OP_TYPE_EQUAL, "v3_status", (SNode*)pValNode, &pCond3)); - CHECK_RES_OUT_OF_MEM(createOperatorNode(OP_TYPE_EQUAL, "v4_status", (SNode*)pValNode, &pCond4)); + code = createOperatorNode(OP_TYPE_EQUAL, "v1_status", (SNode*)pValNode, &pCond1); + if (TSDB_CODE_SUCCESS == code) + code = createOperatorNode(OP_TYPE_EQUAL, "v2_status", (SNode*)pValNode, &pCond2); + if (TSDB_CODE_SUCCESS == code) + code = createOperatorNode(OP_TYPE_EQUAL, "v3_status", (SNode*)pValNode, &pCond3); + if (TSDB_CODE_SUCCESS == code) + code = createOperatorNode(OP_TYPE_EQUAL, "v4_status", (SNode*)pValNode, &pCond4); nodesDestroyNode((SNode*)pValNode); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode(pCond1); + nodesDestroyNode(pCond2); + nodesDestroyNode(pCond3); + nodesDestroyNode(pCond4); + return code; + } + // pCond1-4 need to free if error SNode* pTemp1 = NULL; SNode* pTemp2 = NULL; SNode* pFullCond = NULL; - CHECK_RES_OUT_OF_MEM(createLogicCondNode(&pCond1, &pCond2, &pTemp1, LOGIC_COND_TYPE_OR)); - CHECK_RES_OUT_OF_MEM(createLogicCondNode(&pTemp1, &pCond3, &pTemp2, LOGIC_COND_TYPE_OR)); - CHECK_RES_OUT_OF_MEM(createLogicCondNode(&pTemp2, &pCond4, &pFullCond, LOGIC_COND_TYPE_OR)); + code = createLogicCondNode(&pCond1, &pCond2, &pTemp1, LOGIC_COND_TYPE_OR); + if (TSDB_CODE_SUCCESS == code) + code = createLogicCondNode(&pTemp1, &pCond3, &pTemp2, LOGIC_COND_TYPE_OR); + if (TSDB_CODE_SUCCESS == code) + code = createLogicCondNode(&pTemp2, &pCond4, &pFullCond, LOGIC_COND_TYPE_OR); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode(pCond1); + nodesDestroyNode(pCond2); + nodesDestroyNode(pCond3); + nodesDestroyNode(pCond4); + nodesDestroyNode(pTemp1); + nodesDestroyNode(pTemp2); + nodesDestroyNode(pFullCond); + return code; + } - SNode* pThen = nodesMakeValueNodeFromInt32(1); - CHECK_POINTER_OUT_OF_MEM(pThen); + // only pFullCond needs to free if err + + SNode* pThen = NULL; + code = nodesMakeValueNodeFromInt32(1, &pThen); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode(pFullCond); + return code; + } + + // pFullCond and pThen need to free SNode* pWhenThen = NULL; - CHECK_RES_OUT_OF_MEM(createParWhenThenNode(pFullCond, pThen, &pWhenThen)); - SNodeList* pWhenThenlist = NULL; - CHECK_RES_OUT_OF_MEM(createParListNode(pWhenThen, &pWhenThenlist)); + code = createParWhenThenNode(pFullCond, pThen, &pWhenThen); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode(pFullCond); + nodesDestroyNode(pThen); + return code; + } + // pWhenThen needs to free - SNode* pElse = nodesMakeValueNodeFromInt32(0); - CHECK_POINTER_OUT_OF_MEM(pElse); + SNodeList* pWhenThenlist = NULL; + code = createParListNode(pWhenThen, &pWhenThenlist); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode(pWhenThen); + return code; + } + + // pWhenThenlist needs to free + + SNode* pElse = NULL; + code = nodesMakeValueNodeFromInt32(0, &pElse); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyList(pWhenThenlist); + return code; + } + + // pWhenThenlist and pElse need to free // case when (v1_status = "leader" or v2_status = "lead er" or v3_status = "leader" or v4_status = "leader") then 1 // else 0 end SNode* pCaseWhen = NULL; - CHECK_RES_OUT_OF_MEM(createParCaseWhenNode(NULL, pWhenThenlist, pElse, NULL, &pCaseWhen)); + code = createParCaseWhenNode(NULL, pWhenThenlist, pElse, NULL, &pCaseWhen); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyList(pWhenThenlist); + nodesDestroyNode(pElse); + return code; + } + + // pCaseWhen needs to free SNodeList* pParaList = NULL; - CHECK_RES_OUT_OF_MEM(createParListNode(pCaseWhen, &pParaList)); + code = createParListNode(pCaseWhen, &pParaList); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode(pCaseWhen); + return code; + } + + // pParaList needs to free // sum( case when ... end) as leader_col SNode* pSumFun = NULL; const char* pSumColAlias = "leader_col"; - CHECK_RES_OUT_OF_MEM(createParFunctionNode("sum", pSumColAlias, pParaList, &pSumFun)); + code = createParFunctionNode("sum", pSumColAlias, pParaList, &pSumFun); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyList(pParaList); + return code; + } - SNode* pPara1 = nodesMakeValueNodeFromInt32(1); - CHECK_POINTER_OUT_OF_MEM(pThen); + // pSumFun needs to free + + SNode* pPara1 = NULL; + code = nodesMakeValueNodeFromInt32(1, &pPara1); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode(pSumFun); + return code; + } + + // pSumFun and pPara1 need to free pParaList = NULL; - CHECK_RES_OUT_OF_MEM(createParListNode(pPara1, &pParaList)); + code = createParListNode(pPara1, &pParaList); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode(pSumFun); + nodesDestroyNode(pPara1); + return code; + } + + // pSumFun and pParaList need to free // count(1) as count_col SNode* pCountFun = NULL; const char* pCountColAlias = "count_col"; - CHECK_RES_OUT_OF_MEM(createParFunctionNode("count", pCountColAlias, pParaList, &pCountFun)); + code = createParFunctionNode("count", pCountColAlias, pParaList, &pCountFun); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode(pSumFun); + nodesDestroyList(pParaList); + return code; + } + + // pSumFun and pCountFun need to free SNodeList* pProjList = NULL; - CHECK_RES_OUT_OF_MEM(createParListNode(pSumFun, &pProjList)); - CHECK_RES_OUT_OF_MEM(nodesListStrictAppend(pProjList, pCountFun)); + code = createParListNode(pSumFun, &pProjList); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode(pSumFun); + nodesDestroyNode(pCountFun); + return code; + } + + // pProjList and pCountFun need to free + + code = nodesListStrictAppend(pProjList, pCountFun); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyList(pProjList); + return code; + } + + // pProjList needs to free SSelectStmt* pSubSelect = NULL; // select sum( case when .... end) as leader_col, count(*) as count_col from information_schema.ins_vgroups - CHECK_RES_OUT_OF_MEM( - createSimpleSelectStmtFromProjList(TSDB_INFORMATION_SCHEMA_DB, TSDB_INS_TABLE_VGROUPS, pProjList, &pSubSelect)); + code = createSimpleSelectStmtFromProjList(TSDB_INFORMATION_SCHEMA_DB, TSDB_INS_TABLE_VGROUPS, pProjList, &pSubSelect); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyList(pProjList); + return code; + } + + // pSubSelect needs to free if (pDbName && pDbName[0] != 0) { // for show db.alive // select sum( case when .... end) as leader_col, count(*) as count_col from information_schema.ins_vgroups where // db_name = "..." SNode* pDbCond = NULL; - pValNode = nodesMakeValueNodeFromString(pDbName); - CHECK_RES_OUT_OF_MEM(createOperatorNode(OP_TYPE_EQUAL, "db_name", (SNode*)pValNode, &pDbCond)); + code = nodesMakeValueNodeFromString(pDbName, &pValNode); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSubSelect); + return code; + } + // pSubSelect and pValNode need to free + + code = createOperatorNode(OP_TYPE_EQUAL, "db_name", (SNode*)pValNode, &pDbCond); nodesDestroyNode((SNode*)pValNode); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSubSelect); + return code; + } + pCxt->showRewrite = false; pQuery->showRewrite = false; pSubSelect->pWhere = pDbCond; + // pSubSelect need to free } + // pSubSelect need to free + pCond1 = NULL; - CHECK_RES_OUT_OF_MEM(createParOperatorNode(OP_TYPE_EQUAL, pSumColAlias, pCountColAlias, &pCond1)); + code = createParOperatorNode(OP_TYPE_EQUAL, pSumColAlias, pCountColAlias, &pCond1); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSubSelect); + return code; + } + // pSubSelect and pCond1 need to free + pCond2 = NULL; - SNode* pTempVal = nodesMakeValueNodeFromInt32(0); - CHECK_RES_OUT_OF_MEM(createOperatorNode(OP_TYPE_GREATER_THAN, pSumColAlias, pTempVal, &pCond2)); + SNode* pTempVal = NULL; + code = nodesMakeValueNodeFromInt32(0, &pTempVal); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSubSelect); + nodesDestroyNode(pCond1); + return code; + } + // pSubSelect, pCond1, pTempVal need to free + + code = createOperatorNode(OP_TYPE_GREATER_THAN, pSumColAlias, pTempVal, &pCond2); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSubSelect); + nodesDestroyNode(pCond1); + nodesDestroyNode(pTempVal); + return code; + } + // pSubSelect, pCond1, pCond2, pTempVal need to free + // leader_col = count_col and leader_col > 0 pTemp1 = NULL; - CHECK_RES_OUT_OF_MEM(createLogicCondNode(&pCond1, &pCond2, &pTemp1, LOGIC_COND_TYPE_AND)); + code = createLogicCondNode(&pCond1, &pCond2, &pTemp1, LOGIC_COND_TYPE_AND); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSubSelect); + nodesDestroyNode(pCond1); + nodesDestroyNode(pCond2); + nodesDestroyNode(pTempVal); + return code; + } + + // pSubSelect, pTemp1, pTempVal need to free + + pThen = NULL; + code = nodesMakeValueNodeFromInt32(1, &pThen); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSubSelect); + nodesDestroyNode(pTemp1); + nodesDestroyNode(pTempVal); + return code; + } + // pSubSelect, pTemp1, pThen, pTempVal need to free - pThen = nodesMakeValueNodeFromInt32(1); - CHECK_POINTER_OUT_OF_MEM(pThen); pWhenThen = NULL; - CHECK_RES_OUT_OF_MEM(createParWhenThenNode(pTemp1, pThen, &pWhenThen)); + code = createParWhenThenNode(pTemp1, pThen, &pWhenThen); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSubSelect); + nodesDestroyNode(pTemp1); + nodesDestroyNode(pThen); + nodesDestroyNode(pTempVal); + return code; + } + // pSubSelect, pWhenThen, pTempVal need to free + pWhenThenlist = NULL; - CHECK_RES_OUT_OF_MEM(createParListNode(pWhenThen, &pWhenThenlist)); + code = createParListNode(pWhenThen, &pWhenThenlist); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSubSelect); + nodesDestroyNode(pWhenThen); + nodesDestroyNode(pTempVal); + return code; + } + + // pSubSelect, pWhenThenlist, pTempVal need to free pCond1 = NULL; - CHECK_RES_OUT_OF_MEM(createParOperatorNode(OP_TYPE_LOWER_THAN, pSumColAlias, pCountColAlias, &pCond1)); + code = createParOperatorNode(OP_TYPE_LOWER_THAN, pSumColAlias, pCountColAlias, &pCond1); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSubSelect); + nodesDestroyList(pWhenThenlist); + nodesDestroyNode(pTempVal); + return code; + } + // pSubSelect, pWhenThenlist, pCond1, pTempVal need to free + pCond2 = NULL; - CHECK_RES_OUT_OF_MEM(createOperatorNode(OP_TYPE_GREATER_THAN, pSumColAlias, pTempVal, &pCond2)); + code = createOperatorNode(OP_TYPE_GREATER_THAN, pSumColAlias, pTempVal, &pCond2); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSubSelect); + nodesDestroyList(pWhenThenlist); + nodesDestroyNode(pTempVal); + nodesDestroyNode(pCond1); + return code; + } + // pSubSelect, pWhenThenlist, pCond1, pTempVal, pCond2 need to free + // leader_col < count_col and leader_col > 0 pTemp2 = NULL; - CHECK_RES_OUT_OF_MEM(createLogicCondNode(&pCond1, &pCond2, &pTemp2, LOGIC_COND_TYPE_AND)); + code = createLogicCondNode(&pCond1, &pCond2, &pTemp2, LOGIC_COND_TYPE_AND); nodesDestroyNode((SNode*)pTempVal); - pThen = nodesMakeValueNodeFromInt32(2); - CHECK_POINTER_OUT_OF_MEM(pThen); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSubSelect); + nodesDestroyList(pWhenThenlist); + nodesDestroyNode(pCond1); + nodesDestroyNode(pCond2); + return code; + } + + // pSubSelect, pWhenThenlist, pTemp2 need to free + + pThen = NULL; + code = nodesMakeValueNodeFromInt32(2, &pThen); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSubSelect); + nodesDestroyList(pWhenThenlist); + nodesDestroyNode(pTemp2); + return code; + } + // pSubSelect, pWhenThenlist, pTemp2, pThen need to free + pWhenThen = NULL; - CHECK_RES_OUT_OF_MEM(createParWhenThenNode(pTemp2, pThen, &pWhenThen)); - CHECK_RES_OUT_OF_MEM(nodesListStrictAppend(pWhenThenlist, pWhenThen)); + code = createParWhenThenNode(pTemp2, pThen, &pWhenThen); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSubSelect); + nodesDestroyList(pWhenThenlist); + nodesDestroyNode(pTemp2); + nodesDestroyNode(pThen); + return code; + } + // pSubSelect, pWhenThenlist, pWhenThen need to free + + code = nodesListStrictAppend(pWhenThenlist, pWhenThen); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSubSelect); + nodesDestroyList(pWhenThenlist); + return code; + } + // pSubSelect, pWhenThenlist need to free // case when leader_col = count_col and count_col > 0 then 1 when leader_col < count_col and count_col > 0 then 2 else // 0 end as status + pElse = NULL; + code = nodesMakeValueNodeFromInt32(0, &pElse); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSubSelect); + nodesDestroyList(pWhenThenlist); + return code; + } + // pSubSelect, pWhenThenlist, pElse need to free + pCaseWhen = NULL; - pElse = nodesMakeValueNodeFromInt32(0); - CHECK_POINTER_OUT_OF_MEM(pElse); - CHECK_RES_OUT_OF_MEM(createParCaseWhenNode(NULL, pWhenThenlist, pElse, "status", &pCaseWhen)); + code = createParCaseWhenNode(NULL, pWhenThenlist, pElse, "status", &pCaseWhen); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSubSelect); + nodesDestroyList(pWhenThenlist); + nodesDestroyNode(pElse); + return code; + } + // pSubSelect, pCaseWhen need to free pProjList = NULL; - CHECK_RES_OUT_OF_MEM(createParListNode(pCaseWhen, &pProjList)); + code = createParListNode(pCaseWhen, &pProjList); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSubSelect); + nodesDestroyNode(pCaseWhen); + return code; + } + // pSubSelect, pProjList need to free SNode* pTempTblNode = NULL; - CHECK_RES_OUT_OF_MEM(createParTempTableNode(pSubSelect, &pTempTblNode)); + code = createParTempTableNode(pSubSelect, &pTempTblNode); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSubSelect); + nodesDestroyList(pProjList); + return code; + } + // pTempTblNode, pProjList need to free + + SSelectStmt* pStmt = NULL; + code = nodesMakeNode(QUERY_NODE_SELECT_STMT, (SNode**)&pStmt); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode(pTempTblNode); + nodesDestroyList(pProjList); + return code; + } - SSelectStmt* pStmt = (SSelectStmt*)nodesMakeNode(QUERY_NODE_SELECT_STMT); - CHECK_POINTER_OUT_OF_MEM(pStmt); pStmt->pProjectionList = pProjList; pStmt->pFromTable = pTempTblNode; sprintf(pStmt->stmtName, "%p", pStmt); diff --git a/source/libs/parser/src/parUtil.c b/source/libs/parser/src/parUtil.c index e6b6bcc903..2683343fb9 100644 --- a/source/libs/parser/src/parUtil.c +++ b/source/libs/parser/src/parUtil.c @@ -762,10 +762,11 @@ int32_t buildCatalogReq(const SParseMetaCache* pMetaCache, SCatalogReq* pCatalog return code; } -SNode* createSelectStmtImpl(bool isDistinct, SNodeList* pProjectionList, SNode* pTable, SNodeList* pHint) { - SSelectStmt* select = (SSelectStmt*)nodesMakeNode(QUERY_NODE_SELECT_STMT); +int32_t createSelectStmtImpl(bool isDistinct, SNodeList* pProjectionList, SNode* pTable, SNodeList* pHint, SNode** ppSelect) { + SSelectStmt* select = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_SELECT_STMT, (SNode**)&select); if (NULL == select) { - return NULL; + return code; } select->isDistinct = isDistinct; select->pProjectionList = pProjectionList; @@ -777,7 +778,8 @@ SNode* createSelectStmtImpl(bool isDistinct, SNodeList* pProjectionList, SNode* select->timeRange = TSWINDOW_INITIALIZER; select->pHint = pHint; select->lastProcessByRowFuncId = -1; - return (SNode*)select; + *ppSelect = (SNode*)select; + return code; } static int32_t putMetaDataToHash(const char* pKey, int32_t len, const SArray* pData, int32_t index, SHashObj** pHash) { diff --git a/source/libs/parser/src/parser.c b/source/libs/parser/src/parser.c index 7d042aeddb..3f753b7d16 100644 --- a/source/libs/parser/src/parser.c +++ b/source/libs/parser/src/parser.c @@ -429,9 +429,10 @@ int32_t qStmtBindParams(SQuery* pQuery, TAOS_MULTI_BIND* pParams, int32_t colIdx if (TSDB_CODE_SUCCESS == code && (colIdx < 0 || colIdx + 1 == pQuery->placeholderNum)) { nodesDestroyNode(pQuery->pRoot); - pQuery->pRoot = nodesCloneNode(pQuery->pPrepareRoot); + pQuery->pRoot = NULL; + code = nodesCloneNode(pQuery->pPrepareRoot, &pQuery->pRoot); if (NULL == pQuery->pRoot) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = code; } } if (TSDB_CODE_SUCCESS == code) { diff --git a/source/libs/planner/inc/planInt.h b/source/libs/planner/inc/planInt.h index 79cf87d941..090071ee7f 100644 --- a/source/libs/planner/inc/planInt.h +++ b/source/libs/planner/inc/planInt.h @@ -65,7 +65,7 @@ int32_t tagScanSetExecutionMode(SScanLogicNode* pScan); #define CLONE_LIMIT 1 #define CLONE_SLIMIT 1 << 1 #define CLONE_LIMIT_SLIMIT (CLONE_LIMIT | CLONE_SLIMIT) -bool cloneLimit(SLogicNode* pParent, SLogicNode* pChild, uint8_t cloneWhat); +int32_t cloneLimit(SLogicNode* pParent, SLogicNode* pChild, uint8_t cloneWhat, bool* pCloned); int32_t sortPriKeyOptGetSequencingNodesImpl(SLogicNode* pNode, bool groupSort, SSortLogicNode* pSort, bool* pNotOptimize, SNodeList** pSequencingNodes, bool* keepSort); diff --git a/source/libs/planner/src/planLogicCreater.c b/source/libs/planner/src/planLogicCreater.c index cee765ff94..e727c4227b 100644 --- a/source/libs/planner/src/planLogicCreater.c +++ b/source/libs/planner/src/planLogicCreater.c @@ -112,7 +112,8 @@ static EDealRes doRewriteExpr(SNode** pNode, void* pContext) { pExpr = nodesListGetNode(((SGroupingSetNode*)pExpr)->pParameterList, 0); } if (nodesEqualNode(pExpr, *pNode)) { - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + SColumnNode* pCol = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); if (NULL == pCol) { return DEAL_RES_ERROR; } @@ -177,7 +178,11 @@ static int32_t cloneRewriteExprs(SNodeList* pExprs, bool* pOutputs, SNodeList** SNode* pExpr = NULL; FOREACH(pExpr, pExprs) { if (pOutputs[index]) { - code = nodesListMakeStrictAppend(pRewriteExpr, nodesCloneNode(pExpr)); + SNode* pNew = NULL; + code = nodesCloneNode(pExpr, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(pRewriteExpr, pNew); + } if (TSDB_CODE_SUCCESS != code) { NODES_DESTORY_LIST(*pRewriteExpr); break; @@ -223,9 +228,9 @@ static int32_t rewriteExprs(SNodeList* pExprs, SNodeList* pTarget) { static int32_t pushLogicNode(SLogicPlanContext* pCxt, SLogicNode** pOldRoot, SLogicNode* pNewRoot) { if (NULL == pNewRoot->pChildren) { - pNewRoot->pChildren = nodesMakeList(); + int32_t code = nodesMakeList(&pNewRoot->pChildren); if (NULL == pNewRoot->pChildren) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } } if (TSDB_CODE_SUCCESS != nodesListAppend(pNewRoot->pChildren, (SNode*)*pOldRoot)) { @@ -289,7 +294,8 @@ static bool hasPkInTable(const STableMeta* pTableMeta) { } static SNode* createFirstCol(SRealTableNode* pTable, const SSchema* pSchema) { - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + SColumnNode* pCol = NULL; + terrno = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); if (NULL == pCol) { return NULL; } @@ -360,9 +366,10 @@ static int32_t addDefaultScanCol(SRealTableNode* pTable, SNodeList** pCols) { static int32_t makeScanLogicNode(SLogicPlanContext* pCxt, SRealTableNode* pRealTable, bool hasRepeatScanFuncs, SLogicNode** pLogicNode) { - SScanLogicNode* pScan = (SScanLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SCAN); + SScanLogicNode* pScan = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SCAN, (SNode**)&pScan); if (NULL == pScan) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } TSWAP(pScan->pVgroupList, pRealTable->pVgroupList); @@ -448,17 +455,11 @@ static int32_t createScanLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect } if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pTags && NULL == pSelect->pPartitionByList) { - pScan->pTags = nodesCloneList(pSelect->pTags); - if (NULL == pScan->pTags) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + code = nodesCloneList(pSelect->pTags, &pScan->pTags); } if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pSubtable && NULL == pSelect->pPartitionByList) { - pScan->pSubtable = nodesCloneNode(pSelect->pSubtable); - if (NULL == pScan->pSubtable) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + code = nodesCloneNode(pSelect->pSubtable, &pScan->pSubtable); } // set output @@ -518,9 +519,10 @@ int32_t collectJoinResColumns(SSelectStmt* pSelect, SJoinLogicNode* pJoin, SNode static int32_t createJoinLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, SJoinTableNode* pJoinTable, SLogicNode** pLogicNode) { int32_t code = TSDB_CODE_SUCCESS; - SJoinLogicNode* pJoin = (SJoinLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_JOIN); + SJoinLogicNode* pJoin = NULL; + code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_JOIN, (SNode**)&pJoin); if (NULL == pJoin) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pJoin->joinType = pJoinTable->joinType; @@ -535,15 +537,17 @@ static int32_t createJoinLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect pJoin->node.requireDataOrder = pJoin->hashJoinHint ? DATA_ORDER_LEVEL_NONE : DATA_ORDER_LEVEL_GLOBAL; pJoin->node.resultDataOrder = DATA_ORDER_LEVEL_NONE; pJoin->isLowLevelJoin = pJoinTable->isLowLevelJoin; - pJoin->pWindowOffset = nodesCloneNode(pJoinTable->pWindowOffset); - pJoin->pJLimit = nodesCloneNode(pJoinTable->pJLimit); - pJoin->addPrimEqCond = nodesCloneNode(pJoinTable->addPrimCond); - pJoin->node.pChildren = nodesMakeList(); - pJoin->seqWinGroup = (JOIN_STYPE_WIN == pJoinTable->subType) && (pSelect->hasAggFuncs || pSelect->hasIndefiniteRowsFunc); - - if (NULL == pJoin->node.pChildren) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = nodesCloneNode(pJoinTable->pWindowOffset, &pJoin->pWindowOffset); + if (TSDB_CODE_SUCCESS == code) { + code = nodesCloneNode(pJoinTable->pJLimit, &pJoin->pJLimit); } + if (TSDB_CODE_SUCCESS == code) { + code = nodesCloneNode(pJoinTable->addPrimCond, &pJoin->addPrimEqCond); + } + if (TSDB_CODE_SUCCESS == code) { + code = nodesMakeList(&pJoin->node.pChildren); + } + pJoin->seqWinGroup = (JOIN_STYPE_WIN == pJoinTable->subType) && (pSelect->hasAggFuncs || pSelect->hasIndefiniteRowsFunc); SLogicNode* pLeft = NULL; if (TSDB_CODE_SUCCESS == code) { @@ -566,10 +570,7 @@ static int32_t createJoinLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect // set on conditions if (TSDB_CODE_SUCCESS == code && NULL != pJoinTable->pOnCond) { - pJoin->pFullOnCond = nodesCloneNode(pJoinTable->pOnCond); - if (NULL == pJoin->pFullOnCond) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + code = nodesCloneNode(pJoinTable->pOnCond, &pJoin->pFullOnCond); } #if 0 @@ -631,10 +632,7 @@ static int32_t createJoinLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect } if (NULL == pJoin->node.pTargets && NULL != pLeft) { - pJoin->node.pTargets = nodesCloneList(pLeft->pTargets); - if (NULL == pJoin->node.pTargets) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + code = nodesCloneList(pLeft->pTargets, &pJoin->node.pTargets); } #endif @@ -669,10 +667,11 @@ static int32_t createLogicNodeByTable(SLogicPlanContext* pCxt, SSelectStmt* pSel SLogicNode* pNode = NULL; int32_t code = doCreateLogicNodeByTable(pCxt, pSelect, pTable, &pNode); if (TSDB_CODE_SUCCESS == code) { - pNode->pConditions = nodesCloneNode(pSelect->pWhere); + pNode->pConditions = NULL; + code = nodesCloneNode(pSelect->pWhere, &pNode->pConditions); if (NULL != pSelect->pWhere && NULL == pNode->pConditions) { nodesDestroyNode((SNode*)pNode); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pNode->precision = pSelect->precision; *pLogicNode = pNode; @@ -682,7 +681,8 @@ static int32_t createLogicNodeByTable(SLogicPlanContext* pCxt, SSelectStmt* pSel } static SColumnNode* createColumnByExpr(const char* pStmtName, SExprNode* pExpr) { - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + SColumnNode* pCol = NULL; + terrno = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); if (NULL == pCol) { return NULL; } @@ -694,17 +694,24 @@ static SColumnNode* createColumnByExpr(const char* pStmtName, SExprNode* pExpr) return pCol; } -static SNode* createGroupingSetNode(SNode* pExpr) { - SGroupingSetNode* pGroupingSet = (SGroupingSetNode*)nodesMakeNode(QUERY_NODE_GROUPING_SET); +static int32_t createGroupingSetNode(SNode* pExpr, SNode** ppNode) { + SGroupingSetNode* pGroupingSet = NULL; + int32_t code = 0; + *ppNode = NULL; + code = nodesMakeNode(QUERY_NODE_GROUPING_SET, (SNode**)&pGroupingSet); if (NULL == pGroupingSet) { - return NULL; + return code; } pGroupingSet->groupingSetType = GP_TYPE_NORMAL; - if (TSDB_CODE_SUCCESS != nodesListMakeStrictAppend(&pGroupingSet->pParameterList, nodesCloneNode(pExpr))) { - nodesDestroyNode((SNode*)pGroupingSet); - return NULL; + SNode* pNew = NULL; + code = nodesCloneNode(pExpr, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pGroupingSet->pParameterList, pNew); } - return (SNode*)pGroupingSet; + if (TSDB_CODE_SUCCESS == code) { + *ppNode = (SNode*)pGroupingSet; + } + return code; } static EGroupAction getDistinctGroupAction(SLogicPlanContext* pCxt, SSelectStmt* pSelect) { @@ -727,7 +734,14 @@ static EDataOrderLevel getRequireDataOrder(bool needTimeline, SSelectStmt* pSele } static int32_t addWinJoinPrimKeyToAggFuncs(SSelectStmt* pSelect, SNodeList** pList) { - SNodeList* pTargets = (NULL == *pList) ? nodesMakeList() : *pList; + SNodeList* pTargets = *pList; + int32_t code = 0; + if (pTargets) { + code = nodesMakeList(&pTargets); + } + if (TSDB_CODE_SUCCESS != code) { + return code; + } SJoinTableNode* pJoinTable = (SJoinTableNode*)pSelect->pFromTable; SRealTableNode* pProbeTable = NULL; switch (pJoinTable->joinType) { @@ -742,10 +756,11 @@ static int32_t addWinJoinPrimKeyToAggFuncs(SSelectStmt* pSelect, SNodeList** pLi return TSDB_CODE_PLAN_INTERNAL_ERROR; } - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + SColumnNode* pCol = NULL; + code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); if (NULL == pCol) { if (!*pList) nodesDestroyList(pTargets); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } SSchema* pColSchema = &pProbeTable->pMeta->schema[0]; @@ -765,10 +780,17 @@ static int32_t addWinJoinPrimKeyToAggFuncs(SSelectStmt* pSelect, SNodeList** pLi pCol->node.resType.precision = pProbeTable->pMeta->tableInfo.precision; SNode* pFunc = (SNode*)createGroupKeyAggFunc(pCol); + if (!pFunc) { + nodesDestroyList(pTargets); + return terrno; + } - nodesListAppend(pTargets, pFunc); + code = nodesListStrictAppend(pTargets, pFunc); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyList(pTargets); + } - return TSDB_CODE_SUCCESS; + return code; } static int32_t createAggLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, SLogicNode** pLogicNode) { @@ -776,9 +798,10 @@ static int32_t createAggLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, return TSDB_CODE_SUCCESS; } - SAggLogicNode* pAgg = (SAggLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG); + SAggLogicNode* pAgg = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pAgg); if (NULL == pAgg) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } bool winJoin = isWindowJoinStmt(pSelect); @@ -792,8 +815,6 @@ static int32_t createAggLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, pAgg->node.resultDataOrder = pAgg->onlyHasKeepOrderFunc ? pAgg->node.requireDataOrder : DATA_ORDER_LEVEL_NONE; pAgg->node.forceCreateNonBlockingOptr = winJoin ? true : false; - int32_t code = TSDB_CODE_SUCCESS; - // set grouyp keys, agg funcs and having conditions if (TSDB_CODE_SUCCESS == code) { code = nodesCollectFuncs(pSelect, SQL_CLAUSE_GROUP_BY, NULL, fmIsAggFunc, &pAgg->pAggFuncs); @@ -805,10 +826,8 @@ static int32_t createAggLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, } if (NULL != pSelect->pGroupByList) { - pAgg->pGroupKeys = nodesCloneList(pSelect->pGroupByList); - if (NULL == pAgg->pGroupKeys) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + pAgg->pGroupKeys = NULL; + code = nodesCloneList(pSelect->pGroupByList, &pAgg->pGroupKeys); } // rewrite the expression in subsequent clauses @@ -818,10 +837,8 @@ static int32_t createAggLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, } if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pHaving) { - pAgg->node.pConditions = nodesCloneNode(pSelect->pHaving); - if (NULL == pAgg->node.pConditions) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + pAgg->node.pConditions = NULL; + code = nodesCloneNode(pSelect->pHaving, &pAgg->node.pConditions); } // set the output @@ -857,10 +874,10 @@ static int32_t createIndefRowsFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt return TSDB_CODE_SUCCESS; } - SIndefRowsFuncLogicNode* pIdfRowsFunc = - (SIndefRowsFuncLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC); + SIndefRowsFuncLogicNode* pIdfRowsFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC, (SNode**)&pIdfRowsFunc); if (NULL == pIdfRowsFunc) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pIdfRowsFunc->isTailFunc = pSelect->hasTailFunc; @@ -871,7 +888,7 @@ static int32_t createIndefRowsFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt pIdfRowsFunc->node.resultDataOrder = pIdfRowsFunc->node.requireDataOrder; // indefinite rows functions and _select_values functions - int32_t code = nodesCollectFuncs(pSelect, SQL_CLAUSE_SELECT, NULL, fmIsVectorFunc, &pIdfRowsFunc->pFuncs); + code = nodesCollectFuncs(pSelect, SQL_CLAUSE_SELECT, NULL, fmIsVectorFunc, &pIdfRowsFunc->pFuncs); if (TSDB_CODE_SUCCESS == code) { code = rewriteExprsForSelect(pIdfRowsFunc->pFuncs, pSelect, SQL_CLAUSE_SELECT, NULL); } @@ -899,9 +916,10 @@ static int32_t createInterpFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt* p return TSDB_CODE_SUCCESS; } - SInterpFuncLogicNode* pInterpFunc = (SInterpFuncLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_INTERP_FUNC); + SInterpFuncLogicNode* pInterpFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_INTERP_FUNC, (SNode**)&pInterpFunc); if (NULL == pInterpFunc) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pInterpFunc->node.groupAction = getGroupAction(pCxt, pSelect); @@ -909,7 +927,7 @@ static int32_t createInterpFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt* p pInterpFunc->node.resultDataOrder = pInterpFunc->node.requireDataOrder; // interp functions and _group_key functions - int32_t code = nodesCollectFuncs(pSelect, SQL_CLAUSE_SELECT, NULL, isInterpFunc, &pInterpFunc->pFuncs); + code = nodesCollectFuncs(pSelect, SQL_CLAUSE_SELECT, NULL, isInterpFunc, &pInterpFunc->pFuncs); if (TSDB_CODE_SUCCESS == code) { code = rewriteExprsForSelect(pInterpFunc->pFuncs, pSelect, SQL_CLAUSE_SELECT, NULL); } @@ -918,10 +936,10 @@ static int32_t createInterpFuncLogicNode(SLogicPlanContext* pCxt, SSelectStmt* p SFillNode* pFill = (SFillNode*)pSelect->pFill; pInterpFunc->timeRange = pFill->timeRange; pInterpFunc->fillMode = pFill->mode; - pInterpFunc->pTimeSeries = nodesCloneNode(pFill->pWStartTs); - pInterpFunc->pFillValues = nodesCloneNode(pFill->pValues); - if (NULL == pInterpFunc->pTimeSeries || (NULL != pFill->pValues && NULL == pInterpFunc->pFillValues)) { - code = TSDB_CODE_OUT_OF_MEMORY; + pInterpFunc->pTimeSeries = NULL; + code = nodesCloneNode(pFill->pWStartTs, &pInterpFunc->pTimeSeries); + if (TSDB_CODE_SUCCESS == code) { + code = nodesCloneNode(pFill->pValues, &pInterpFunc->pFillValues); } } @@ -965,10 +983,7 @@ static int32_t createWindowLogicNodeFinalize(SLogicPlanContext* pCxt, SSelectStm } if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pHaving) { - pWindow->node.pConditions = nodesCloneNode(pSelect->pHaving); - if (NULL == pWindow->node.pConditions) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + code = nodesCloneNode(pSelect->pHaving, &pWindow->node.pConditions); } pSelect->hasAggFuncs = false; @@ -984,9 +999,10 @@ static int32_t createWindowLogicNodeFinalize(SLogicPlanContext* pCxt, SSelectStm static int32_t createWindowLogicNodeByState(SLogicPlanContext* pCxt, SStateWindowNode* pState, SSelectStmt* pSelect, SLogicNode** pLogicNode) { - SWindowLogicNode* pWindow = (SWindowLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW); + SWindowLogicNode* pWindow = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW, (SNode**)&pWindow); if (NULL == pWindow) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pWindow->winType = WINDOW_TYPE_STATE; @@ -995,16 +1011,23 @@ static int32_t createWindowLogicNodeByState(SLogicPlanContext* pCxt, SStateWindo pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_IN_BLOCK : getRequireDataOrder(true, pSelect); pWindow->node.resultDataOrder = pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_GLOBAL : pWindow->node.requireDataOrder; - pWindow->pStateExpr = nodesCloneNode(pState->pExpr); - pWindow->pTspk = nodesCloneNode(pState->pCol); - if (NULL == pWindow->pStateExpr || NULL == pWindow->pTspk) { + pWindow->pStateExpr = NULL; + code = nodesCloneNode(pState->pExpr, &pWindow->pStateExpr); + if (TSDB_CODE_SUCCESS == code) { nodesDestroyNode((SNode*)pWindow); - return TSDB_CODE_OUT_OF_MEMORY; + return code; + } + code = nodesCloneNode(pState->pCol, &pWindow->pTspk); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pWindow); + return code; } // rewrite the expression in subsequent clauses - int32_t code = rewriteExprForSelect(pWindow->pStateExpr, pSelect, SQL_CLAUSE_WINDOW); + code = rewriteExprForSelect(pWindow->pStateExpr, pSelect, SQL_CLAUSE_WINDOW); if (TSDB_CODE_SUCCESS == code) { code = createWindowLogicNodeFinalize(pCxt, pSelect, pWindow, pLogicNode); + } else { + nodesDestroyNode((SNode*)pWindow); } return code; @@ -1012,9 +1035,10 @@ static int32_t createWindowLogicNodeByState(SLogicPlanContext* pCxt, SStateWindo static int32_t createWindowLogicNodeBySession(SLogicPlanContext* pCxt, SSessionWindowNode* pSession, SSelectStmt* pSelect, SLogicNode** pLogicNode) { - SWindowLogicNode* pWindow = (SWindowLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW); + SWindowLogicNode* pWindow = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW, (SNode**)&pWindow); if (NULL == pWindow) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pWindow->winType = WINDOW_TYPE_SESSION; @@ -1026,21 +1050,28 @@ static int32_t createWindowLogicNodeBySession(SLogicPlanContext* pCxt, SSessionW pWindow->node.resultDataOrder = pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_GLOBAL : pWindow->node.requireDataOrder; - pWindow->pTspk = nodesCloneNode((SNode*)pSession->pCol); + pWindow->pTspk = NULL; + code = nodesCloneNode((SNode*)pSession->pCol, &pWindow->pTspk); if (NULL == pWindow->pTspk) { nodesDestroyNode((SNode*)pWindow); - return TSDB_CODE_OUT_OF_MEMORY; + return code; + } + pWindow->pTsEnd = NULL; + code = nodesCloneNode((SNode*)pSession->pCol, &pWindow->pTsEnd); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pWindow); + return code; } - pWindow->pTsEnd = nodesCloneNode((SNode*)pSession->pCol); return createWindowLogicNodeFinalize(pCxt, pSelect, pWindow, pLogicNode); } static int32_t createWindowLogicNodeByInterval(SLogicPlanContext* pCxt, SIntervalWindowNode* pInterval, SSelectStmt* pSelect, SLogicNode** pLogicNode) { - SWindowLogicNode* pWindow = (SWindowLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW); + SWindowLogicNode* pWindow = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW, (SNode**)&pWindow); if (NULL == pWindow) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pWindow->winType = WINDOW_TYPE_INTERVAL; @@ -1058,10 +1089,11 @@ static int32_t createWindowLogicNodeByInterval(SLogicPlanContext* pCxt, SInterva : (pSelect->hasTimeLineFunc ? getRequireDataOrder(true, pSelect) : DATA_ORDER_LEVEL_IN_BLOCK); pWindow->node.resultDataOrder = pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_GLOBAL : getRequireDataOrder(true, pSelect); - pWindow->pTspk = nodesCloneNode(pInterval->pCol); + pWindow->pTspk = NULL; + code = nodesCloneNode(pInterval->pCol, &pWindow->pTspk); if (NULL == pWindow->pTspk) { nodesDestroyNode((SNode*)pWindow); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pWindow->isPartTb = pSelect->pPartitionByList ? keysHasTbname(pSelect->pPartitionByList) : 0; @@ -1070,9 +1102,10 @@ static int32_t createWindowLogicNodeByInterval(SLogicPlanContext* pCxt, SInterva static int32_t createWindowLogicNodeByEvent(SLogicPlanContext* pCxt, SEventWindowNode* pEvent, SSelectStmt* pSelect, SLogicNode** pLogicNode) { - SWindowLogicNode* pWindow = (SWindowLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW); + SWindowLogicNode* pWindow = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW, (SNode**)&pWindow); if (NULL == pWindow) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pWindow->winType = WINDOW_TYPE_EVENT; @@ -1081,9 +1114,22 @@ static int32_t createWindowLogicNodeByEvent(SLogicPlanContext* pCxt, SEventWindo pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_IN_BLOCK : getRequireDataOrder(true, pSelect); pWindow->node.resultDataOrder = pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_GLOBAL : pWindow->node.requireDataOrder; - pWindow->pStartCond = nodesCloneNode(pEvent->pStartCond); - pWindow->pEndCond = nodesCloneNode(pEvent->pEndCond); - pWindow->pTspk = nodesCloneNode(pEvent->pCol); + pWindow->pStartCond = NULL; + code = nodesCloneNode(pEvent->pStartCond, &pWindow->pStartCond); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pWindow); + return code; + } + code = nodesCloneNode(pEvent->pEndCond, &pWindow->pEndCond); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pWindow); + return code; + } + code = nodesCloneNode(pEvent->pCol, &pWindow->pTspk); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pWindow); + return code; + } if (NULL == pWindow->pStartCond || NULL == pWindow->pEndCond || NULL == pWindow->pTspk) { nodesDestroyNode((SNode*)pWindow); return TSDB_CODE_OUT_OF_MEMORY; @@ -1093,9 +1139,10 @@ static int32_t createWindowLogicNodeByEvent(SLogicPlanContext* pCxt, SEventWindo static int32_t createWindowLogicNodeByCount(SLogicPlanContext* pCxt, SCountWindowNode* pCount, SSelectStmt* pSelect, SLogicNode** pLogicNode) { - SWindowLogicNode* pWindow = (SWindowLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW); + SWindowLogicNode* pWindow = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_WINDOW, (SNode**)&pWindow); if (NULL == pWindow) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pWindow->winType = WINDOW_TYPE_COUNT; @@ -1106,10 +1153,11 @@ static int32_t createWindowLogicNodeByCount(SLogicPlanContext* pCxt, SCountWindo pCxt->pPlanCxt->streamQuery ? DATA_ORDER_LEVEL_GLOBAL : pWindow->node.requireDataOrder; pWindow->windowCount = pCount->windowCount; pWindow->windowSliding = pCount->windowSliding; - pWindow->pTspk = nodesCloneNode(pCount->pCol); + pWindow->pTspk = NULL; + code = nodesCloneNode(pCount->pCol, &pWindow->pTspk); if (NULL == pWindow->pTspk) { nodesDestroyNode((SNode*)pWindow); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } return createWindowLogicNodeFinalize(pCxt, pSelect, pWindow, pLogicNode); } @@ -1159,9 +1207,17 @@ static int32_t partFillExprs(SSelectStmt* pSelect, SNodeList** pFillExprs, SNode SNode* pProject = NULL; FOREACH(pProject, pSelect->pProjectionList) { if (needFillValue(pProject)) { - code = nodesListMakeStrictAppend(pFillExprs, nodesCloneNode(pProject)); + SNode* pNew = NULL; + code = nodesCloneNode(pProject, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(pFillExprs, pNew); + } } else if (QUERY_NODE_VALUE != nodeType(pProject)) { - code = nodesListMakeStrictAppend(pNotFillExprs, nodesCloneNode(pProject)); + SNode* pNew = NULL; + code = nodesCloneNode(pProject, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(pNotFillExprs, pNew); + } } if (TSDB_CODE_SUCCESS != code) { NODES_DESTORY_LIST(*pFillExprs); @@ -1174,9 +1230,17 @@ static int32_t partFillExprs(SSelectStmt* pSelect, SNodeList** pFillExprs, SNode FOREACH(pOrderExpr, pSelect->pOrderByList) { SNode* pExpr = ((SOrderByExprNode*)pOrderExpr)->pExpr; if (needFillValue(pExpr)) { - code = nodesListMakeStrictAppend(pFillExprs, nodesCloneNode(pExpr)); + SNode* pNew = NULL; + code = nodesCloneNode(pProject, &pExpr); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(pFillExprs, pNew); + } } else if (QUERY_NODE_VALUE != nodeType(pExpr)) { - code = nodesListMakeStrictAppend(pNotFillExprs, nodesCloneNode(pExpr)); + SNode* pNew = NULL; + code = nodesCloneNode(pProject, &pExpr); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(pNotFillExprs, pNew); + } } if (TSDB_CODE_SUCCESS != code) { NODES_DESTORY_LIST(*pFillExprs); @@ -1199,9 +1263,10 @@ static int32_t createFillLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect return TSDB_CODE_SUCCESS; } - SFillLogicNode* pFill = (SFillLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_FILL); + SFillLogicNode* pFill = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_FILL, (SNode**)&pFill); if (NULL == pFill) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pFill->node.groupAction = getGroupAction(pCxt, pSelect); @@ -1209,7 +1274,7 @@ static int32_t createFillLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect pFill->node.resultDataOrder = pFill->node.requireDataOrder; pFill->node.inputTsOrder = TSDB_ORDER_ASC; - int32_t code = partFillExprs(pSelect, &pFill->pFillExprs, &pFill->pNotFillExprs); + code = partFillExprs(pSelect, &pFill->pFillExprs, &pFill->pNotFillExprs); if (TSDB_CODE_SUCCESS == code) { code = rewriteExprsForSelect(pFill->pFillExprs, pSelect, SQL_CLAUSE_FILL, NULL); } @@ -1225,10 +1290,10 @@ static int32_t createFillLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect pFill->mode = pFillNode->mode; pFill->timeRange = pFillNode->timeRange; - pFill->pValues = nodesCloneNode(pFillNode->pValues); - pFill->pWStartTs = nodesCloneNode(pFillNode->pWStartTs); - if ((NULL != pFillNode->pValues && NULL == pFill->pValues) || NULL == pFill->pWStartTs) { - code = TSDB_CODE_OUT_OF_MEMORY; + pFill->pValues = NULL; + code = nodesCloneNode(pFillNode->pValues, &pFill->pValues); + if (TSDB_CODE_SUCCESS == code) { + code = nodesCloneNode(pFillNode->pWStartTs, &pFillNode->pWStartTs); } if (TSDB_CODE_SUCCESS == code && 0 == LIST_LENGTH(pFill->node.pTargets)) { @@ -1257,9 +1322,10 @@ static int32_t createSortLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect return TSDB_CODE_SUCCESS; } - SSortLogicNode* pSort = (SSortLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT); + SSortLogicNode* pSort = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT, (SNode**)&pSort); if (NULL == pSort) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pSort->groupSort = pSelect->groupSort; @@ -1268,16 +1334,20 @@ static int32_t createSortLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect pSort->node.resultDataOrder = isPrimaryKeySort(pSelect->pOrderByList) ? (pSort->groupSort ? DATA_ORDER_LEVEL_IN_GROUP : DATA_ORDER_LEVEL_GLOBAL) : DATA_ORDER_LEVEL_NONE; - int32_t code = nodesCollectColumns(pSelect, SQL_CLAUSE_ORDER_BY, NULL, COLLECT_COL_TYPE_ALL, &pSort->node.pTargets); + code = nodesCollectColumns(pSelect, SQL_CLAUSE_ORDER_BY, NULL, COLLECT_COL_TYPE_ALL, &pSort->node.pTargets); if (TSDB_CODE_SUCCESS == code && NULL == pSort->node.pTargets) { - code = nodesListMakeStrictAppend(&pSort->node.pTargets, - nodesCloneNode(nodesListGetNode(pCxt->pCurrRoot->pTargets, 0))); + SNode* pNew = NULL; + code = nodesCloneNode(nodesListGetNode(pCxt->pCurrRoot->pTargets, 0), &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pSort->node.pTargets, pNew); + } } if (TSDB_CODE_SUCCESS == code) { - pSort->pSortKeys = nodesCloneList(pSelect->pOrderByList); + pSort->pSortKeys = NULL; + code = nodesCloneList(pSelect->pOrderByList, &pSort->pSortKeys); if (NULL == pSort->pSortKeys) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = code; } SNode* pNode = NULL; SOrderByExprNode* firstSortKey = (SOrderByExprNode*)nodesListGetNode(pSort->pSortKeys, 0); @@ -1306,16 +1376,17 @@ static int32_t createSortLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect static int32_t createColumnByProjections(SLogicPlanContext* pCxt, const char* pStmtName, SNodeList* pExprs, SNodeList** pCols) { - SNodeList* pList = nodesMakeList(); + SNodeList* pList = NULL; + int32_t code = nodesMakeList(&pList); if (NULL == pList) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } SNode* pNode; FOREACH(pNode, pExprs) { - if (TSDB_CODE_SUCCESS != nodesListAppend(pList, (SNode*)createColumnByExpr(pStmtName, (SExprNode*)pNode))) { + if (TSDB_CODE_SUCCESS != (code = nodesListStrictAppend(pList, (SNode*)createColumnByExpr(pStmtName, (SExprNode*)pNode)))) { nodesDestroyList(pList); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } } @@ -1324,9 +1395,10 @@ static int32_t createColumnByProjections(SLogicPlanContext* pCxt, const char* pS } static int32_t createProjectLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSelect, SLogicNode** pLogicNode) { - SProjectLogicNode* pProject = (SProjectLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT); + SProjectLogicNode* pProject = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT, (SNode**)&pProject); if (NULL == pProject) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } TSWAP(pProject->node.pLimit, pSelect->pLimit); @@ -1337,11 +1409,10 @@ static int32_t createProjectLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSel pProject->node.requireDataOrder = DATA_ORDER_LEVEL_NONE; pProject->node.resultDataOrder = DATA_ORDER_LEVEL_NONE; - int32_t code = TSDB_CODE_SUCCESS; - - pProject->pProjections = nodesCloneList(pSelect->pProjectionList); + pProject->pProjections = NULL; + code = nodesCloneList(pSelect->pProjectionList, &pProject->pProjections); if (NULL == pProject->pProjections) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = code; } strcpy(pProject->stmtName, pSelect->stmtName); @@ -1363,20 +1434,23 @@ static int32_t createPartitionLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pS return TSDB_CODE_SUCCESS; } - SPartitionLogicNode* pPartition = (SPartitionLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PARTITION); + SPartitionLogicNode* pPartition = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PARTITION, (SNode**)&pPartition); if (NULL == pPartition) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pPartition->node.groupAction = GROUP_ACTION_SET; pPartition->node.requireDataOrder = DATA_ORDER_LEVEL_NONE; pPartition->node.resultDataOrder = DATA_ORDER_LEVEL_NONE; - int32_t code = - nodesCollectColumns(pSelect, SQL_CLAUSE_PARTITION_BY, NULL, COLLECT_COL_TYPE_ALL, &pPartition->node.pTargets); + code = nodesCollectColumns(pSelect, SQL_CLAUSE_PARTITION_BY, NULL, COLLECT_COL_TYPE_ALL, &pPartition->node.pTargets); if (TSDB_CODE_SUCCESS == code && NULL == pPartition->node.pTargets) { - code = nodesListMakeStrictAppend(&pPartition->node.pTargets, - nodesCloneNode(nodesListGetNode(pCxt->pCurrRoot->pTargets, 0))); + SNode* pNew = NULL; + code = nodesCloneNode(nodesListGetNode(pCxt->pCurrRoot->pTargets, 0), &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pPartition->node.pTargets, pNew); + } } if (TSDB_CODE_SUCCESS == code) { @@ -1385,10 +1459,8 @@ static int32_t createPartitionLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pS } if (TSDB_CODE_SUCCESS == code) { - pPartition->pPartitionKeys = nodesCloneList(pSelect->pPartitionByList); - if (NULL == pPartition->pPartitionKeys) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + pPartition->pPartitionKeys = NULL; + code = nodesCloneList(pSelect->pPartitionByList, &pPartition->pPartitionKeys); } if (keysHasCol(pPartition->pPartitionKeys) && pSelect->pWindow && @@ -1401,25 +1473,19 @@ static int32_t createPartitionLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pS } if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pTags) { - pPartition->pTags = nodesCloneList(pSelect->pTags); - if (NULL == pPartition->pTags) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + pPartition->pTags = NULL; + code = nodesCloneList(pSelect->pTags, &pPartition->pTags); } if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pSubtable) { - pPartition->pSubtable = nodesCloneNode(pSelect->pSubtable); - if (NULL == pPartition->pSubtable) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + pPartition->pSubtable = NULL; + code = nodesCloneNode(pSelect->pSubtable, &pPartition->pSubtable); } if (TSDB_CODE_SUCCESS == code && NULL != pSelect->pHaving && !pSelect->hasAggFuncs && NULL == pSelect->pGroupByList && NULL == pSelect->pWindow) { - pPartition->node.pConditions = nodesCloneNode(pSelect->pHaving); - if (NULL == pPartition->node.pConditions) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + pPartition->node.pConditions = NULL; + code = nodesCloneNode(pSelect->pHaving, &pPartition->node.pConditions); } if (TSDB_CODE_SUCCESS == code) { @@ -1436,21 +1502,25 @@ static int32_t createDistinctLogicNode(SLogicPlanContext* pCxt, SSelectStmt* pSe return TSDB_CODE_SUCCESS; } - SAggLogicNode* pAgg = (SAggLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG); + SAggLogicNode* pAgg = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pAgg); if (NULL == pAgg) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pAgg->node.groupAction = GROUP_ACTION_CLEAR;//getDistinctGroupAction(pCxt, pSelect); pAgg->node.requireDataOrder = DATA_ORDER_LEVEL_NONE; pAgg->node.resultDataOrder = DATA_ORDER_LEVEL_NONE; - int32_t code = TSDB_CODE_SUCCESS; // set grouyp keys, agg funcs and having conditions SNodeList* pGroupKeys = NULL; SNode* pProjection = NULL; FOREACH(pProjection, pSelect->pProjectionList) { - code = nodesListMakeStrictAppend(&pGroupKeys, createGroupingSetNode(pProjection)); + SNode* pNew = NULL; + code = createGroupingSetNode(pProjection, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pGroupKeys, pNew); + } if (TSDB_CODE_SUCCESS != code) { nodesDestroyList(pGroupKeys); break; @@ -1548,25 +1618,20 @@ static int32_t createSetOpSortLogicNode(SLogicPlanContext* pCxt, SSetOperator* p return TSDB_CODE_SUCCESS; } - SSortLogicNode* pSort = (SSortLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT); + SSortLogicNode* pSort = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT, (SNode**)&pSort); if (NULL == pSort) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } TSWAP(pSort->node.pLimit, pSetOperator->pLimit); - int32_t code = TSDB_CODE_SUCCESS; - - pSort->node.pTargets = nodesCloneList(pSetOperator->pProjectionList); - if (NULL == pSort->node.pTargets) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + pSort->node.pTargets = NULL; + code = nodesCloneList(pSetOperator->pProjectionList, &pSort->node.pTargets); if (TSDB_CODE_SUCCESS == code) { - pSort->pSortKeys = nodesCloneList(pSetOperator->pOrderByList); - if (NULL == pSort->pSortKeys) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + pSort->pSortKeys = NULL; + code = nodesCloneList(pSetOperator->pOrderByList, &pSort->pSortKeys); } if (TSDB_CODE_SUCCESS == code) { @@ -1580,9 +1645,10 @@ static int32_t createSetOpSortLogicNode(SLogicPlanContext* pCxt, SSetOperator* p static int32_t createSetOpProjectLogicNode(SLogicPlanContext* pCxt, SSetOperator* pSetOperator, SLogicNode** pLogicNode) { - SProjectLogicNode* pProject = (SProjectLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT); + SProjectLogicNode* pProject = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT, (SNode**)&pProject); if (NULL == pProject) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } if (NULL == pSetOperator->pOrderByList) { @@ -1591,12 +1657,8 @@ static int32_t createSetOpProjectLogicNode(SLogicPlanContext* pCxt, SSetOperator pProject->ignoreGroupId = true; pProject->isSetOpProj = true; - int32_t code = TSDB_CODE_SUCCESS; - - pProject->pProjections = nodesCloneList(pSetOperator->pProjectionList); - if (NULL == pProject->pProjections) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + pProject->pProjections = NULL; + code = nodesCloneList(pSetOperator->pProjectionList, &pProject->pProjections); if (TSDB_CODE_SUCCESS == code) { code = createColumnByProjections(pCxt, pSetOperator->stmtName, pSetOperator->pProjectionList, @@ -1613,20 +1675,18 @@ static int32_t createSetOpProjectLogicNode(SLogicPlanContext* pCxt, SSetOperator } static int32_t createSetOpAggLogicNode(SLogicPlanContext* pCxt, SSetOperator* pSetOperator, SLogicNode** pLogicNode) { - SAggLogicNode* pAgg = (SAggLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG); + SAggLogicNode* pAgg = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pAgg); if (NULL == pAgg) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } if (NULL == pSetOperator->pOrderByList) { TSWAP(pAgg->node.pSlimit, pSetOperator->pLimit); } - int32_t code = TSDB_CODE_SUCCESS; - pAgg->pGroupKeys = nodesCloneList(pSetOperator->pProjectionList); - if (NULL == pAgg->pGroupKeys) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + pAgg->pGroupKeys = NULL; + code = nodesCloneList(pSetOperator->pProjectionList, &pAgg->pGroupKeys); // rewrite the expression in subsequent clauses if (TSDB_CODE_SUCCESS == code) { @@ -1723,9 +1783,10 @@ static int32_t getMsgType(ENodeType sqlType) { } static int32_t createVnodeModifLogicNode(SLogicPlanContext* pCxt, SVnodeModifyOpStmt* pStmt, SLogicNode** pLogicNode) { - SVnodeModifyLogicNode* pModif = (SVnodeModifyLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY); + SVnodeModifyLogicNode* pModif = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY, (SNode**)&pModif); if (NULL == pModif) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pModif->modifyType = MODIFY_TABLE_TYPE_INSERT; TSWAP(pModif->pDataBlocks, pStmt->pDataBlocks); @@ -1747,10 +1808,8 @@ static int32_t createDeleteScanLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* p if (TSDB_CODE_SUCCESS == code) { pScan->scanType = SCAN_TYPE_TABLE; pScan->scanRange = pDelete->timeRange; - pScan->pScanCols = nodesCloneList(((SFunctionNode*)pDelete->pCountFunc)->pParameterList); - if (NULL == pScan->pScanCols) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + pScan->pScanCols = NULL; + code = nodesCloneList(((SFunctionNode*)pDelete->pCountFunc)->pParameterList, &pScan->pScanCols); } STableMeta* pMeta = ((SRealTableNode*)pDelete->pFromTable)->pMeta; @@ -1759,10 +1818,7 @@ static int32_t createDeleteScanLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* p } if (TSDB_CODE_SUCCESS == code && NULL != pDelete->pTagCond) { - pScan->pTagCond = nodesCloneNode(pDelete->pTagCond); - if (NULL == pScan->pTagCond) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + code = nodesCloneNode(pDelete->pTagCond, &pScan->pTagCond); } // set output @@ -1780,17 +1836,30 @@ static int32_t createDeleteScanLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* p } static int32_t createDeleteAggLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* pDelete, SLogicNode** pLogicNode) { - SAggLogicNode* pAgg = (SAggLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG); + SAggLogicNode* pAgg = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pAgg); if (NULL == pAgg) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - int32_t code = nodesListMakeStrictAppend(&pAgg->pAggFuncs, nodesCloneNode(pDelete->pCountFunc)); + SNode* pNew = NULL; + code = nodesCloneNode(pDelete->pCountFunc, &pNew); if (TSDB_CODE_SUCCESS == code) { - code = nodesListStrictAppend(pAgg->pAggFuncs, nodesCloneNode(pDelete->pFirstFunc)); + code = nodesListMakeStrictAppend(&pAgg->pAggFuncs, pNew); } if (TSDB_CODE_SUCCESS == code) { - code = nodesListStrictAppend(pAgg->pAggFuncs, nodesCloneNode(pDelete->pLastFunc)); + SNode* pNew = NULL; + code = nodesCloneNode(pDelete->pFirstFunc, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pAgg->pAggFuncs, pNew); + } + } + if (TSDB_CODE_SUCCESS == code) { + SNode* pNew = NULL; + code = nodesCloneNode(pDelete->pLastFunc, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pAgg->pAggFuncs, pNew); + } } if (TSDB_CODE_SUCCESS == code) { code = rewriteExpr(pAgg->pAggFuncs, &pDelete->pCountFunc); @@ -1817,9 +1886,10 @@ static int32_t createDeleteAggLogicNode(SLogicPlanContext* pCxt, SDeleteStmt* pD static int32_t createVnodeModifLogicNodeByDelete(SLogicPlanContext* pCxt, SDeleteStmt* pDelete, SLogicNode** pLogicNode) { - SVnodeModifyLogicNode* pModify = (SVnodeModifyLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY); + SVnodeModifyLogicNode* pModify = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY, (SNode**)&pModify); if (NULL == pModify) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } SRealTableNode* pRealTable = (SRealTableNode*)pDelete->pFromTable; @@ -1830,12 +1900,21 @@ static int32_t createVnodeModifLogicNodeByDelete(SLogicPlanContext* pCxt, SDelet snprintf(pModify->tableName, sizeof(pModify->tableName), "%s", pRealTable->table.tableName); strcpy(pModify->tsColName, pRealTable->pMeta->schema->name); pModify->deleteTimeRange = pDelete->timeRange; - pModify->pAffectedRows = nodesCloneNode(pDelete->pCountFunc); - pModify->pStartTs = nodesCloneNode(pDelete->pFirstFunc); - pModify->pEndTs = nodesCloneNode(pDelete->pLastFunc); - if (NULL == pModify->pAffectedRows || NULL == pModify->pStartTs || NULL == pModify->pEndTs) { + pModify->pAffectedRows = NULL; + code = nodesCloneNode(pDelete->pCountFunc, &pModify->pAffectedRows); + if (TSDB_CODE_SUCCESS != code) { nodesDestroyNode((SNode*)pModify); - return TSDB_CODE_OUT_OF_MEMORY; + return code; + } + code = nodesCloneNode(pDelete->pFirstFunc, &pModify->pStartTs); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pModify); + return code; + } + code = nodesCloneNode(pDelete->pLastFunc, &pModify->pEndTs); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pModify); + return code; } *pLogicNode = (SLogicNode*)pModify; @@ -1868,9 +1947,10 @@ static int32_t creatInsertRootLogicNode(SLogicPlanContext* pCxt, SInsertStmt* pI static int32_t createVnodeModifLogicNodeByInsert(SLogicPlanContext* pCxt, SInsertStmt* pInsert, SLogicNode** pLogicNode) { - SVnodeModifyLogicNode* pModify = (SVnodeModifyLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY); + SVnodeModifyLogicNode* pModify = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_VNODE_MODIFY, (SNode**)&pModify); if (NULL == pModify) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } SRealTableNode* pRealTable = (SRealTableNode*)pInsert->pTable; @@ -1881,10 +1961,11 @@ static int32_t createVnodeModifLogicNodeByInsert(SLogicPlanContext* pCxt, SInser pModify->tableType = pRealTable->pMeta->tableType; snprintf(pModify->tableName, sizeof(pModify->tableName), "%s", pRealTable->table.tableName); TSWAP(pModify->pVgroupList, pRealTable->pVgroupList); - pModify->pInsertCols = nodesCloneList(pInsert->pCols); + pModify->pInsertCols = NULL; + code = nodesCloneList(pInsert->pCols, &pModify->pInsertCols); if (NULL == pModify->pInsertCols) { nodesDestroyNode((SNode*)pModify); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } *pLogicNode = (SLogicNode*)pModify; @@ -1949,15 +2030,16 @@ static void setLogicSubplanType(bool hasScan, SLogicSubplan* pSubplan) { int32_t createLogicPlan(SPlanContext* pCxt, SLogicSubplan** pLogicSubplan) { SLogicPlanContext cxt = {.pPlanCxt = pCxt, .pCurrRoot = NULL, .hasScan = false}; - SLogicSubplan* pSubplan = (SLogicSubplan*)nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN); + SLogicSubplan* pSubplan = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN, (SNode**)&pSubplan); if (NULL == pSubplan) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pSubplan->id.queryId = pCxt->queryId; pSubplan->id.groupId = 1; pSubplan->id.subplanId = 1; - int32_t code = createQueryLogicNode(&cxt, pCxt->pAstRoot, &pSubplan->pNode); + code = createQueryLogicNode(&cxt, pCxt->pAstRoot, &pSubplan->pNode); if (TSDB_CODE_SUCCESS == code) { setLogicNodeParent(pSubplan->pNode); setLogicSubplanType(cxt.hasScan, pSubplan); diff --git a/source/libs/planner/src/planOptimizer.c b/source/libs/planner/src/planOptimizer.c index b72cad012d..6184b2310f 100644 --- a/source/libs/planner/src/planOptimizer.c +++ b/source/libs/planner/src/planOptimizer.c @@ -45,6 +45,11 @@ typedef struct SOptimizeRule { FOptimize optimizeFunc; } SOptimizeRule; +typedef struct SOptimizePKCtx { + SNodeList* pList; + int32_t code; +} SOptimizePKCtx; + typedef enum EScanOrder { SCAN_ORDER_ASC = 1, SCAN_ORDER_DESC, SCAN_ORDER_BOTH } EScanOrder; typedef struct SOsdInfo { @@ -173,9 +178,10 @@ static void optResetParent(SLogicNode* pNode) { static EDealRes optRebuildTbanme(SNode** pNode, void* pContext) { if (QUERY_NODE_COLUMN == nodeType(*pNode) && COLUMN_TYPE_TBNAME == ((SColumnNode*)*pNode)->colType) { - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); + SFunctionNode* pFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); if (NULL == pFunc) { - *(int32_t*)pContext = TSDB_CODE_OUT_OF_MEMORY; + *(int32_t*)pContext = code; return DEAL_RES_ERROR; } strcpy(pFunc->functionName, "tbname"); @@ -298,9 +304,17 @@ static int32_t scanPathOptGetRelatedFuncs(SScanLogicNode* pScan, SNodeList** pSd SFunctionNode* pFunc = (SFunctionNode*)pNode; int32_t code = TSDB_CODE_SUCCESS; if (scanPathOptIsSpecifiedFuncType(pFunc, fmIsSpecialDataRequiredFunc)) { - code = nodesListMakeStrictAppend(&pTmpSdrFuncs, nodesCloneNode(pNode)); + SNode* pNew = NULL; + code = nodesCloneNode(pNode, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pTmpSdrFuncs, pNew); + } } else if (scanPathOptIsSpecifiedFuncType(pFunc, fmIsDynamicScanOptimizedFunc)) { - code = nodesListMakeStrictAppend(&pTmpDsoFuncs, nodesCloneNode(pNode)); + SNode* pNew = NULL; + code = nodesCloneNode(pNode, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pTmpDsoFuncs, pNew); + } } else if (scanPathOptIsSpecifiedFuncType(pFunc, fmIsSkipScanCheckFunc)) { continue; } else { @@ -471,14 +485,15 @@ static int32_t scanPathOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub } static int32_t pdcMergeCondsToLogic(SNode** pDst, SNode** pSrc) { - SLogicConditionNode* pLogicCond = (SLogicConditionNode*)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); + SLogicConditionNode* pLogicCond = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, (SNode**)&pLogicCond); if (NULL == pLogicCond) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pLogicCond->node.resType.type = TSDB_DATA_TYPE_BOOL; pLogicCond->node.resType.bytes = tDataTypes[TSDB_DATA_TYPE_BOOL].bytes; pLogicCond->condType = LOGIC_COND_TYPE_AND; - int32_t code = nodesListMakeAppend(&pLogicCond->pParameterList, *pSrc); + code = nodesListMakeAppend(&pLogicCond->pParameterList, *pSrc); if (TSDB_CODE_SUCCESS == code) { *pSrc = NULL; code = nodesListMakeAppend(&pLogicCond->pParameterList, *pDst); @@ -669,14 +684,17 @@ static int32_t pdcJoinSplitLogicCond(SJoinLogicNode* pJoin, SNode** pSrcCond, SN SNode* pCond = NULL; FOREACH(pCond, pLogicCond->pParameterList) { ECondAction condAction = pdcJoinGetCondAction(pJoin, pLeftTables, pRightTables, pCond, whereCond); + SNode* pNew = NULL; + code = nodesCloneNode(pCond, &pNew); + if (TSDB_CODE_SUCCESS != code) { break; } if (COND_ACTION_PUSH_JOIN == condAction && NULL != pOnCond) { - code = nodesListMakeAppend(&pOnConds, nodesCloneNode(pCond)); + code = nodesListMakeAppend(&pOnConds, pNew); } else if (COND_ACTION_PUSH_LEFT_CHILD == condAction) { - code = nodesListMakeAppend(&pLeftChildConds, nodesCloneNode(pCond)); + code = nodesListMakeAppend(&pLeftChildConds, pNew); } else if (COND_ACTION_PUSH_RIGHT_CHILD == condAction) { - code = nodesListMakeAppend(&pRightChildConds, nodesCloneNode(pCond)); + code = nodesListMakeAppend(&pRightChildConds, pNew); } else { - code = nodesListMakeAppend(&pRemainConds, nodesCloneNode(pCond)); + code = nodesListMakeAppend(&pRemainConds, pNew); } if (TSDB_CODE_SUCCESS != code) { break; @@ -857,11 +875,15 @@ static int32_t pdcJoinSplitPrimInLogicCond(SJoinLogicNode* pJoin, SNode** ppPrim SNodeList* pOnConds = NULL; SNode* pCond = NULL; WHERE_EACH(pCond, pLogicCond->pParameterList) { + SNode* pNew = NULL; + code = nodesCloneNode(pCond, &pNew); + if (TSDB_CODE_SUCCESS != code) break; if (pdcJoinIsPrimEqualCond(pJoin, pCond) && (NULL == *ppPrimEqCond)) { - *ppPrimEqCond = nodesCloneNode(pCond); + *ppPrimEqCond = pNew; ERASE_NODE(pLogicCond->pParameterList); } else { - code = nodesListMakeAppend(&pOnConds, nodesCloneNode(pCond)); + code = nodesListMakeAppend(&pOnConds, pNew); + if (TSDB_CODE_SUCCESS != code) break; WHERE_NEXT; } } @@ -912,24 +934,26 @@ static int32_t pdcJoinSplitPrimEqCond(SOptimizeContext* pCxt, SJoinLogicNode* pJ return code; } -static bool pdcJoinIsEqualOnCond(SJoinLogicNode* pJoin, SNode* pCond, bool* allTags) { +static int32_t pdcJoinIsEqualOnCond(SJoinLogicNode* pJoin, SNode* pCond, bool* allTags, bool* pRes) { + *pRes = false; + int32_t code = 0; if (QUERY_NODE_OPERATOR != nodeType(pCond)) { - return false; + return code; } SOperatorNode* pOper = (SOperatorNode*)pCond; if ((QUERY_NODE_COLUMN != nodeType(pOper->pLeft) && !(QUERY_NODE_OPERATOR == nodeType(pOper->pLeft) && OP_TYPE_JSON_GET_VALUE ==((SOperatorNode*)pOper->pLeft)->opType)) || NULL == pOper->pRight || (QUERY_NODE_COLUMN != nodeType(pOper->pRight) && !(QUERY_NODE_OPERATOR == nodeType(pOper->pRight) && OP_TYPE_JSON_GET_VALUE ==((SOperatorNode*)pOper->pRight)->opType))) { - return false; + return code; } if (OP_TYPE_EQUAL != pOper->opType) { - return false; + return code; } if ((QUERY_NODE_OPERATOR == nodeType(pOper->pLeft) || QUERY_NODE_OPERATOR == nodeType(pOper->pRight)) && !(IS_ASOF_JOIN(pJoin->subType) || IS_WINDOW_JOIN(pJoin->subType))) { - return false; + return code; } SColumnNode* pLeft = (SColumnNode*)(pOper->pLeft); @@ -947,7 +971,7 @@ static bool pdcJoinIsEqualOnCond(SJoinLogicNode* pJoin, SNode* pCond, bool* allT if (pLeft->node.resType.type != pRight->node.resType.type || pLeft->node.resType.bytes != pRight->node.resType.bytes) { - return false; + return code; } SNodeList* pLeftCols = ((SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 0))->pTargets; SNodeList* pRightCols = ((SLogicNode*)nodesListGetNode(pJoin->node.pChildren, 1))->pTargets; @@ -955,18 +979,46 @@ static bool pdcJoinIsEqualOnCond(SJoinLogicNode* pJoin, SNode* pCond, bool* allT if (pdcJoinColInTableColList((SNode*)pLeft, pLeftCols)) { isEqual = pdcJoinColInTableColList((SNode*)pRight, pRightCols); if (isEqual) { - nodesListMakeStrictAppend(&pJoin->pLeftEqNodes, nodesCloneNode(pOper->pLeft)); - nodesListMakeStrictAppend(&pJoin->pRightEqNodes, nodesCloneNode(pOper->pRight)); + SNode* pNewLeft = NULL; + code = nodesCloneNode(pOper->pLeft, &pNewLeft); + if (TSDB_CODE_SUCCESS != code) return code; + SNode* pNewRight = NULL; + code = nodesCloneNode(pOper->pRight, &pNewRight); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode(pNewLeft); + return code; + } + code = nodesListMakeStrictAppend(&pJoin->pLeftEqNodes, pNewLeft); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode(pNewRight); + return code; + } + code = nodesListMakeStrictAppend(&pJoin->pRightEqNodes, pNewRight); } } else if (pdcJoinColInTableColList((SNode*)pLeft, pRightCols)) { isEqual = pdcJoinColInTableColList((SNode*)pRight, pLeftCols); if (isEqual) { - nodesListMakeStrictAppend(&pJoin->pLeftEqNodes, nodesCloneNode(pOper->pRight)); - nodesListMakeStrictAppend(&pJoin->pRightEqNodes, nodesCloneNode(pOper->pLeft)); + SNode* pNewLeft = NULL; + code = nodesCloneNode(pOper->pLeft, &pNewLeft); + if (TSDB_CODE_SUCCESS != code) return code; + SNode* pNewRight = NULL; + code = nodesCloneNode(pOper->pRight, &pNewRight); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode(pNewLeft); + return code; + } + code = nodesListMakeStrictAppend(&pJoin->pLeftEqNodes, pNewRight); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode(pNewLeft); + return code; + } + code = nodesListMakeStrictAppend(&pJoin->pRightEqNodes, pNewLeft); } } - - return isEqual; + if (TSDB_CODE_SUCCESS == code) { + *pRes = isEqual; + } + return code; } static int32_t pdcJoinPartLogicEqualOnCond(SJoinLogicNode* pJoin) { @@ -981,17 +1033,24 @@ static int32_t pdcJoinPartLogicEqualOnCond(SJoinLogicNode* pJoin) { bool allTags = false; FOREACH(pCond, pLogicCond->pParameterList) { allTags = false; - if (pdcJoinIsEqualOnCond(pJoin, pCond, &allTags)) { + bool eqOnCond = false; + SNode* pNew = NULL; + code = pdcJoinIsEqualOnCond(pJoin, pCond, &allTags, &eqOnCond); + if (TSDB_CODE_SUCCESS != code) break; + code = nodesCloneNode(pCond, &pNew); + if (TSDB_CODE_SUCCESS != code) break; + + if (eqOnCond) { if (allTags) { - code = nodesListMakeAppend(&pTagEqOnConds, nodesCloneNode(pCond)); + code = nodesListMakeStrictAppend(&pTagEqOnConds, pNew); } else { - code = nodesListMakeAppend(&pColEqOnConds, nodesCloneNode(pCond)); + code = nodesListMakeStrictAppend(&pColEqOnConds, pNew); pJoin->allEqTags = false; } } else if (allTags) { - code = nodesListMakeAppend(&pTagOnConds, nodesCloneNode(pCond)); + code = nodesListMakeStrictAppend(&pTagOnConds, pNew); } else { - code = nodesListMakeAppend(&pColOnConds, nodesCloneNode(pCond)); + code = nodesListMakeStrictAppend(&pColOnConds, pNew); pJoin->allEqTags = false; } @@ -1051,17 +1110,27 @@ static int32_t pdcJoinPartEqualOnCond(SOptimizeContext* pCxt, SJoinLogicNode* pJ } bool allTags = false; - if (pdcJoinIsEqualOnCond(pJoin, pJoin->pFullOnCond, &allTags)) { + bool eqOnCond = false; + int32_t code = pdcJoinIsEqualOnCond(pJoin, pJoin->pFullOnCond, &allTags, &eqOnCond); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + SNode* pNew = NULL; + code = nodesCloneNode(pJoin->pFullOnCond, &pNew); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + if (eqOnCond) { if (allTags) { - pJoin->pTagEqCond = nodesCloneNode(pJoin->pFullOnCond); + pJoin->pTagEqCond = pNew; } else { - pJoin->pColEqCond = nodesCloneNode(pJoin->pFullOnCond); + pJoin->pColEqCond = pNew; pJoin->allEqTags = false; } } else if (allTags) { - pJoin->pTagOnCond = nodesCloneNode(pJoin->pFullOnCond); + pJoin->pTagOnCond = pNew; } else { - pJoin->pColOnCond = nodesCloneNode(pJoin->pFullOnCond); + pJoin->pColOnCond = pNew; pJoin->allEqTags = false; } @@ -1083,7 +1152,11 @@ static EDealRes pdcJoinCollectCondCol(SNode* pNode, void* pContext) { if (NULL == taosHashGet(pCxt->pColHash, name, len)) { pCxt->errCode = taosHashPut(pCxt->pColHash, name, len, NULL, 0); if (TSDB_CODE_SUCCESS == pCxt->errCode) { - pCxt->errCode = nodesListStrictAppend(pCxt->pResCols, nodesCloneNode(pNode)); + SNode* pNew = NULL; + pCxt->errCode = nodesCloneNode(pNode, &pNew); + if (TSDB_CODE_SUCCESS == pCxt->errCode) { + pCxt->errCode = nodesListStrictAppend(pCxt->pResCols, pNew); + } } } } @@ -1120,9 +1193,10 @@ static int32_t pdcJoinAddParentOnColsToTarget(SOptimizeContext* pCxt, SJoinLogic SNodeList* pTargets = NULL; int32_t code = TSDB_CODE_SUCCESS; - SNodeList* pCondCols = nodesMakeList(); + SNodeList* pCondCols = NULL; + code = nodesMakeList(&pCondCols); if (NULL == pCondCols) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } SSHashObj* pTables = NULL; @@ -1161,7 +1235,14 @@ static int32_t pdcJoinAddParentOnColsToTarget(SOptimizeContext* pCxt, SJoinLogic } } if (!found) { - nodesListStrictAppend(pJoin->node.pTargets, nodesCloneNode(pNode)); + SNode* pNew = NULL; + code = nodesCloneNode(pNode, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pJoin->node.pTargets, pNew); + } + if (TSDB_CODE_SUCCESS != code) { + break; + } } } } @@ -1178,10 +1259,11 @@ static int32_t pdcJoinAddPreFilterColsToTarget(SOptimizeContext* pCxt, SJoinLogi } int32_t code = TSDB_CODE_SUCCESS; - SNodeList* pCondCols = nodesMakeList(); + SNodeList* pCondCols = NULL; + code = nodesMakeList(&pCondCols); SNodeList* pTargets = NULL; if (NULL == pCondCols) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = code; } else { code = nodesCollectColumnsFromNode(pJoin->pColOnCond, NULL, COLLECT_COL_TYPE_ALL, &pCondCols); } @@ -1206,7 +1288,14 @@ static int32_t pdcJoinAddPreFilterColsToTarget(SOptimizeContext* pCxt, SJoinLogi } } if (!found) { - nodesListStrictAppend(pJoin->node.pTargets, nodesCloneNode(pNode)); + SNode* pNew = NULL; + code = nodesCloneNode(pNode, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pJoin->node.pTargets, pNew); + } + if (TSDB_CODE_SUCCESS != code) { + break; + } } } } @@ -1222,10 +1311,11 @@ static int32_t pdcJoinAddFilterColsToTarget(SOptimizeContext* pCxt, SJoinLogicNo } int32_t code = TSDB_CODE_SUCCESS; - SNodeList* pCondCols = nodesMakeList(); + SNodeList* pCondCols = NULL; + code = nodesMakeList(&pCondCols); SNodeList* pTargets = NULL; if (NULL == pCondCols) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } if (NULL != pJoin->node.pConditions) { @@ -1252,7 +1342,14 @@ static int32_t pdcJoinAddFilterColsToTarget(SOptimizeContext* pCxt, SJoinLogicNo } } if (!found) { - nodesListStrictAppend(pJoin->node.pTargets, nodesCloneNode(pNode)); + SNode* pNew = NULL; + code = nodesCloneNode(pNode, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pJoin->node.pTargets, pNew); + } + if (TSDB_CODE_SUCCESS != code) { + break; + } } } } @@ -1754,10 +1851,15 @@ static int32_t partitionAggCondConj(SAggLogicNode* pAgg, SNode** ppAggFuncCond, SNodeList* pGroupKeyConds = NULL; SNode* pCond = NULL; FOREACH(pCond, pLogicCond->pParameterList) { + SNode* pNew = NULL; + code = nodesCloneNode(pCond, &pNew); + if (TSDB_CODE_SUCCESS != code) { + break; + } if (partitionAggCondHasAggFunc(pAgg, pCond)) { - code = nodesListMakeAppend(&pAggFuncConds, nodesCloneNode(pCond)); + code = nodesListMakeStrictAppend(&pAggFuncConds, pNew); } else { - code = nodesListMakeAppend(&pGroupKeyConds, nodesCloneNode(pCond)); + code = nodesListMakeStrictAppend(&pGroupKeyConds, pNew); } if (TSDB_CODE_SUCCESS != code) { break; @@ -1820,9 +1922,9 @@ static EDealRes rewriteAggGroupKeyCondForPushDownImpl(SNode** pNode, void* pCont SNode* pGroup = NULL; FOREACH(pGroup, ((SGroupingSetNode*)pGroupKey)->pParameterList) { if (0 == strcmp(((SExprNode*)pGroup)->aliasName, ((SColumnNode*)(*pNode))->colName)) { - SNode* pExpr = nodesCloneNode(pGroup); + SNode* pExpr = NULL; + pCxt->errCode = nodesCloneNode(pGroup, &pExpr); if (pExpr == NULL) { - pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; return DEAL_RES_ERROR; } nodesDestroyNode(*pNode); @@ -1889,9 +1991,9 @@ static EDealRes rewriteProjectCondForPushDownImpl(SNode** ppNode, void* pContext SNode* pProjection = NULL; FOREACH(pProjection, pProj->pProjections) { if (0 == strcmp(((SExprNode*)pProjection)->aliasName, ((SColumnNode*)(*ppNode))->colName)) { - SNode* pExpr = nodesCloneNode(pProjection); + SNode* pExpr = NULL; + pCxt->errCode = nodesCloneNode(pProjection, &pExpr); if (pExpr == NULL) { - pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; return DEAL_RES_ERROR; } nodesDestroyNode(*ppNode); @@ -2448,36 +2550,47 @@ static int32_t sortForJoinOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* pL return TSDB_CODE_PLAN_INTERNAL_ERROR; } - SSortLogicNode* pSort = (SSortLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT); + SSortLogicNode* pSort = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT, (SNode**)&pSort); if (NULL == pSort) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pSort->node.outputTsOrder = targetOrder; - pSort->node.pTargets = nodesCloneList(pChild->pTargets); + pSort->node.pTargets = NULL; + code = nodesCloneList(pChild->pTargets, &pSort->node.pTargets); if (NULL == pSort->node.pTargets) { nodesDestroyNode((SNode *)pSort); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pSort->groupSort = false; - SOrderByExprNode* pOrder = (SOrderByExprNode*)nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR); + SOrderByExprNode* pOrder = NULL; + code = nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR, (SNode**)&pOrder); if (NULL == pOrder) { nodesDestroyNode((SNode *)pSort); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - nodesListMakeAppend(&pSort->pSortKeys, (SNode*)pOrder); + code = nodesListMakeStrictAppend(&pSort->pSortKeys, (SNode*)pOrder); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSort); + return code; + } pOrder->order = targetOrder; - pOrder->pExpr = nodesCloneNode(pOrderByNode); + pOrder->pExpr = NULL; pOrder->nullOrder = (ORDER_ASC == pOrder->order) ? NULL_ORDER_FIRST : NULL_ORDER_LAST; + code = nodesCloneNode(pOrderByNode, &pOrder->pExpr); if (!pOrder->pExpr) { nodesDestroyNode((SNode *)pSort); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pChild->pParent = (SLogicNode*)pSort; - nodesListMakeAppend(&pSort->node.pChildren, (SNode*)pChild); + code = nodesListMakeAppend(&pSort->node.pChildren, (SNode*)pChild); + if (TSDB_CODE_SUCCESS != code) { + return code; + } *pChildPos = (SNode*)pSort; pSort->node.pParent = (SLogicNode*)pJoin;; @@ -2701,9 +2814,10 @@ static bool smaIndexOptMayBeOptimized(SLogicNode* pNode) { static int32_t smaIndexOptCreateSmaScan(SScanLogicNode* pScan, STableIndexInfo* pIndex, SNodeList* pCols, SLogicNode** pOutput) { - SScanLogicNode* pSmaScan = (SScanLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SCAN); + SScanLogicNode* pSmaScan = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SCAN, (SNode**)&pSmaScan); if (NULL == pSmaScan) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pSmaScan->pScanCols = pCols; pSmaScan->tableType = TSDB_SUPER_TABLE; @@ -2716,11 +2830,15 @@ static int32_t smaIndexOptCreateSmaScan(SScanLogicNode* pScan, STableIndexInfo* pSmaScan->dataRequired = FUNC_DATA_REQUIRED_DATA_LOAD; pSmaScan->pVgroupList = taosMemoryCalloc(1, sizeof(SVgroupsInfo) + sizeof(SVgroupInfo)); - pSmaScan->node.pTargets = nodesCloneList(pCols); - if (NULL == pSmaScan->pVgroupList || NULL == pSmaScan->node.pTargets) { + if (!pSmaScan->pVgroupList) { nodesDestroyNode((SNode*)pSmaScan); return TSDB_CODE_OUT_OF_MEMORY; } + code = nodesCloneList(pCols, &pSmaScan->node.pTargets); + if (NULL == pSmaScan->node.pTargets) { + nodesDestroyNode((SNode*)pSmaScan); + return code; + } pSmaScan->pVgroupList->numOfVgroups = 1; pSmaScan->pVgroupList->vgroups[0].vgId = pIndex->dstVgId; memcpy(&(pSmaScan->pVgroupList->vgroups[0].epSet), &pIndex->epSet, sizeof(SEpSet)); @@ -2749,10 +2867,11 @@ static bool smaIndexOptEqualInterval(SScanLogicNode* pScan, SWindowLogicNode* pW return true; } -static SNode* smaIndexOptCreateSmaCol(SNode* pFunc, uint64_t tableId, int32_t colId) { - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); +static int32_t smaIndexOptCreateSmaCol(SNode* pFunc, uint64_t tableId, int32_t colId, SColumnNode** ppNode) { + SColumnNode* pCol = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); if (NULL == pCol) { - return NULL; + return code; } pCol->tableId = tableId; pCol->tableType = TSDB_SUPER_TABLE; @@ -2761,7 +2880,8 @@ static SNode* smaIndexOptCreateSmaCol(SNode* pFunc, uint64_t tableId, int32_t co strcpy(pCol->colName, ((SExprNode*)pFunc)->aliasName); pCol->node.resType = ((SExprNode*)pFunc)->resType; strcpy(pCol->node.aliasName, ((SExprNode*)pFunc)->aliasName); - return (SNode*)pCol; + *ppNode = pCol; + return code; } static int32_t smaIndexOptFindSmaFunc(SNode* pQueryFunc, SNodeList* pSmaFuncs) { @@ -2799,7 +2919,12 @@ static int32_t smaIndexOptCreateSmaCols(SNodeList* pFuncs, uint64_t tableId, SNo if (smaFuncIndex < 0) { break; } else { - code = nodesListMakeStrictAppend(&pCols, smaIndexOptCreateSmaCol(pFunc, tableId, smaFuncIndex + 1)); + SColumnNode* pCol = NULL; + code = smaIndexOptCreateSmaCol(pFunc, tableId, smaFuncIndex + 1, &pCol); + if (TSDB_CODE_SUCCESS != code) { + break; + } + code = nodesListMakeStrictAppend(&pCols, (SNode*)pCol); if (TSDB_CODE_SUCCESS != code) { break; } @@ -2824,10 +2949,15 @@ static int32_t smaIndexOptCreateSmaCols(SNodeList* pFuncs, uint64_t tableId, SNo SExprNode exprNode; exprNode.resType = ((SExprNode*)pWsNode)->resType; sprintf(exprNode.aliasName, "#expr_%d", index + 1); - SNode* pkNode = smaIndexOptCreateSmaCol((SNode*)&exprNode, tableId, PRIMARYKEY_TIMESTAMP_COL_ID); - code = nodesListPushFront(pCols, pkNode); + SColumnNode* pkNode = NULL; + code = smaIndexOptCreateSmaCol((SNode*)&exprNode, tableId, PRIMARYKEY_TIMESTAMP_COL_ID, &pkNode); if (TSDB_CODE_SUCCESS != code) { - nodesDestroyNode(pkNode); + nodesDestroyList(pCols); + return code; + } + code = nodesListPushFront(pCols, (SNode*)pkNode); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pkNode); nodesDestroyList(pCols); return code; } @@ -2991,10 +3121,12 @@ static void partTagsSetAlias(char* pAlias, const char* pTableAlias, const char* strncpy(pAlias, name, TSDB_COL_NAME_LEN - 1); } -static SNode* partTagsCreateWrapperFunc(const char* pFuncName, SNode* pNode) { - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); +static int32_t partTagsCreateWrapperFunc(const char* pFuncName, SNode* pNode, SFunctionNode** ppNode) { + SNode* pNew = NULL; + SFunctionNode* pFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); if (NULL == pFunc) { - return NULL; + return code; } snprintf(pFunc->functionName, sizeof(pFunc->functionName), "%s", pFuncName); @@ -3006,17 +3138,20 @@ static SNode* partTagsCreateWrapperFunc(const char* pFuncName, SNode* pNode) { } else { strcpy(pFunc->node.aliasName, ((SExprNode*)pNode)->aliasName); } - int32_t code = nodesListMakeStrictAppend(&pFunc->pParameterList, nodesCloneNode(pNode)); + code = nodesCloneNode(pNode, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pFunc->pParameterList, pNew); + } if (TSDB_CODE_SUCCESS == code) { code = fmGetFuncInfo(pFunc, NULL, 0); } if (TSDB_CODE_SUCCESS != code) { nodesDestroyNode((SNode*)pFunc); - return NULL; + return code; } - - return (SNode*)pFunc; + *ppNode = pFunc; + return code; } static bool partTagsHasIndefRowsSelectFunc(SNodeList* pFuncs) { @@ -3052,10 +3187,17 @@ static int32_t partTagsRewriteGroupTagsToFuncs(SNodeList* pGroupTags, int32_t st if (index++ < start || !partTagsNeedOutput(pNode, pAgg->node.pTargets)) { continue; } + SFunctionNode* pFunc = NULL; if (hasIndefRowsSelectFunc) { - code = nodesListStrictAppend(pAgg->pAggFuncs, partTagsCreateWrapperFunc("_select_value", pNode)); + code = partTagsCreateWrapperFunc("_select_value", pNode, &pFunc); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pAgg->pAggFuncs, (SNode*)pFunc); + } } else { - code = nodesListStrictAppend(pAgg->pAggFuncs, partTagsCreateWrapperFunc("_group_key", pNode)); + code = partTagsCreateWrapperFunc("_group_key", pNode, &pFunc); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pAgg->pAggFuncs, (SNode*)pFunc); + } } if (TSDB_CODE_SUCCESS != code) { break; @@ -3108,7 +3250,11 @@ static int32_t partTagsOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub if (start < 0) { start = LIST_LENGTH(pScan->pGroupTags); } - code = nodesListMakeStrictAppend(&pScan->pGroupTags, nodesCloneNode(pGroupExpr)); + SNode* pNew = NULL; + code = nodesCloneNode(pGroupExpr, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pScan->pGroupTags, pNew); + } if (TSDB_CODE_SUCCESS != code) { break; } @@ -3275,9 +3421,14 @@ static EDealRes eliminateProjOptRewriteScanTableAlias(SNode* pNode, void* pConte static int32_t eliminateProjOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan, SProjectLogicNode* pProjectNode) { SLogicNode* pChild = (SLogicNode*)nodesListGetNode(pProjectNode->node.pChildren, 0); + int32_t code = 0; if (NULL == pProjectNode->node.pParent) { - SNodeList* pNewChildTargets = nodesMakeList(); + SNodeList* pNewChildTargets = NULL; + code = nodesMakeList(&pNewChildTargets); + if (TSDB_CODE_SUCCESS != code) { + return code; + } SNode * pProjection = NULL, *pChildTarget = NULL; bool orderMatch = true; bool needOrderMatch = @@ -3292,18 +3443,34 @@ static int32_t eliminateProjOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* orderMatch = false; break; } - nodesListAppend(pNewChildTargets, nodesCloneNode(pChildTarget)); + SNode* pNew = NULL; + code = nodesCloneNode(pChildTarget, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pNewChildTargets, pNew); + } + if (TSDB_CODE_SUCCESS != code) break; } } else { FOREACH(pProjection, pProjectNode->pProjections) { FOREACH(pChildTarget, pChild->pTargets) { if (0 == strcmp(((SColumnNode*)pProjection)->colName, ((SColumnNode*)pChildTarget)->colName)) { - nodesListAppend(pNewChildTargets, nodesCloneNode(pChildTarget)); + SNode* pNew = NULL; + code = nodesCloneNode(pChildTarget, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pNewChildTargets, pNew); + } break; } } + if (TSDB_CODE_SUCCESS != code) { + break; + } } } + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyList(pNewChildTargets); + return code; + } if (eliminateProjOptCanChildConditionUseChildTargets(pChild, pNewChildTargets) && (!needOrderMatch || (needOrderMatch && orderMatch))) { @@ -3324,9 +3491,11 @@ static int32_t eliminateProjOptimizeImpl(SOptimizeContext* pCxt, SLogicSubplan* nodesWalkExprs(pChild->pTargets, eliminateProjOptRewriteScanTableAlias, &cxt); } - int32_t code = replaceLogicNode(pLogicSubplan, (SLogicNode*)pProjectNode, pChild); - if (pProjectNode->node.pHint && !pChild->pHint) TSWAP(pProjectNode->node.pHint, pChild->pHint); if (TSDB_CODE_SUCCESS == code) { + code = replaceLogicNode(pLogicSubplan, (SLogicNode*)pProjectNode, pChild); + } + if (TSDB_CODE_SUCCESS == code) { + if (pProjectNode->node.pHint && !pChild->pHint) TSWAP(pProjectNode->node.pHint, pChild->pHint); NODES_CLEAR_LIST(pProjectNode->node.pChildren); nodesDestroyNode((SNode*)pProjectNode); // if pChild is a project logic node, remove its projection which is not reference by its target. @@ -3351,24 +3520,28 @@ static bool rewriteTailOptMayBeOptimized(SLogicNode* pNode) { return QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC == nodeType(pNode) && ((SIndefRowsFuncLogicNode*)pNode)->isTailFunc; } -static SNode* rewriteTailOptCreateOrderByExpr(SNode* pSortKey) { - SOrderByExprNode* pOrder = (SOrderByExprNode*)nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR); +static int32_t rewriteTailOptCreateOrderByExpr(SNode* pSortKey, SNode** ppNode) { + SOrderByExprNode* pOrder = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR, (SNode**)&pOrder); if (NULL == pOrder) { - return NULL; + return code; } pOrder->order = ORDER_DESC; - pOrder->pExpr = nodesCloneNode(pSortKey); + pOrder->pExpr = NULL; + code = nodesCloneNode(pSortKey, &pOrder->pExpr); if (NULL == pOrder->pExpr) { nodesDestroyNode((SNode*)pOrder); - return NULL; + return code; } - return (SNode*)pOrder; + *ppNode = (SNode*)pOrder; + return code; } static int32_t rewriteTailOptCreateLimit(SNode* pLimit, SNode* pOffset, SNode** pOutput) { - SLimitNode* pLimitNode = (SLimitNode*)nodesMakeNode(QUERY_NODE_LIMIT); + SLimitNode* pLimitNode = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LIMIT, (SNode**)&pLimitNode); if (NULL == pLimitNode) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pLimitNode->limit = NULL == pLimit ? -1 : ((SValueNode*)pLimit)->datum.i; pLimitNode->offset = NULL == pOffset ? 0 : ((SValueNode*)pOffset)->datum.i; @@ -3386,9 +3559,10 @@ static bool rewriteTailOptNeedGroupSort(SIndefRowsFuncLogicNode* pIndef) { } static int32_t rewriteTailOptCreateSort(SIndefRowsFuncLogicNode* pIndef, SLogicNode** pOutput) { - SSortLogicNode* pSort = (SSortLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT); + SSortLogicNode* pSort = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT, (SNode**)&pSort); if (NULL == pSort) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pSort->groupSort = rewriteTailOptNeedGroupSort(pIndef); @@ -3408,13 +3582,13 @@ static int32_t rewriteTailOptCreateSort(SIndefRowsFuncLogicNode* pIndef, SLogicN // tail(expr, [limit, offset,] _rowts) int32_t rowtsIndex = LIST_LENGTH(pTail->pParameterList) - 1; - int32_t code = nodesListMakeStrictAppend( - &pSort->pSortKeys, rewriteTailOptCreateOrderByExpr(nodesListGetNode(pTail->pParameterList, rowtsIndex))); + SNode* pNewNode = NULL; + code = rewriteTailOptCreateOrderByExpr(nodesListGetNode(pTail->pParameterList, rowtsIndex), &pNewNode); if (TSDB_CODE_SUCCESS == code) { - pSort->node.pTargets = nodesCloneList(((SLogicNode*)nodesListGetNode(pSort->node.pChildren, 0))->pTargets); - if (NULL == pSort->node.pTargets) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + code = nodesListMakeStrictAppend(&pSort->pSortKeys, pNewNode); + } + if (TSDB_CODE_SUCCESS == code) { + code = nodesCloneList(((SLogicNode*)nodesListGetNode(pSort->node.pChildren, 0))->pTargets, &pSort->node.pTargets); } if (TSDB_CODE_SUCCESS == code) { @@ -3426,17 +3600,20 @@ static int32_t rewriteTailOptCreateSort(SIndefRowsFuncLogicNode* pIndef, SLogicN return code; } -static SNode* rewriteTailOptCreateProjectExpr(SFunctionNode* pFunc) { - SNode* pExpr = nodesCloneNode(nodesListGetNode(pFunc->pParameterList, 0)); +static int32_t rewriteTailOptCreateProjectExpr(SFunctionNode* pFunc, SNode** ppNode) { + SNode* pExpr = NULL; + int32_t code = nodesCloneNode(nodesListGetNode(pFunc->pParameterList, 0), &pExpr); if (NULL == pExpr) { - return NULL; + return code; } strcpy(((SExprNode*)pExpr)->aliasName, pFunc->node.aliasName); - return pExpr; + *ppNode = pExpr; + return code; } static int32_t rewriteTailOptCreateProject(SIndefRowsFuncLogicNode* pIndef, SLogicNode** pOutput) { - SProjectLogicNode* pProject = (SProjectLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT); + SProjectLogicNode* pProject = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT, (SNode**)&pProject); if (NULL == pProject) { return TSDB_CODE_OUT_OF_MEMORY; } @@ -3444,11 +3621,14 @@ static int32_t rewriteTailOptCreateProject(SIndefRowsFuncLogicNode* pIndef, SLog TSWAP(pProject->node.pTargets, pIndef->node.pTargets); pProject->node.precision = pIndef->node.precision; - int32_t code = TSDB_CODE_SUCCESS; SFunctionNode* pTail = NULL; SNode* pFunc = NULL; FOREACH(pFunc, pIndef->pFuncs) { - code = nodesListMakeStrictAppend(&pProject->pProjections, rewriteTailOptCreateProjectExpr((SFunctionNode*)pFunc)); + SNode* pNew = NULL; + code = rewriteTailOptCreateProjectExpr((SFunctionNode*)pFunc, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pProject->pProjections, pNew); + } if (TSDB_CODE_SUCCESS != code) { break; } @@ -3555,24 +3735,31 @@ static bool rewriteUniqueOptMayBeOptimized(SLogicNode* pNode) { return QUERY_NODE_LOGIC_PLAN_INDEF_ROWS_FUNC == nodeType(pNode) && ((SIndefRowsFuncLogicNode*)pNode)->isUniqueFunc; } -static SNode* rewriteUniqueOptCreateGroupingSet(SNode* pExpr) { - SGroupingSetNode* pGroupingSet = (SGroupingSetNode*)nodesMakeNode(QUERY_NODE_GROUPING_SET); +static int32_t rewriteUniqueOptCreateGroupingSet(SNode* pExpr, SNode** ppNode) { + SGroupingSetNode* pGroupingSet = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_GROUPING_SET, (SNode**)&pGroupingSet); if (NULL == pGroupingSet) { - return NULL; + return code; } pGroupingSet->groupingSetType = GP_TYPE_NORMAL; - SExprNode* pGroupExpr = (SExprNode*)nodesCloneNode(pExpr); - if (TSDB_CODE_SUCCESS != nodesListMakeStrictAppend(&pGroupingSet->pParameterList, (SNode*)pGroupExpr)) { - nodesDestroyNode((SNode*)pGroupingSet); - return NULL; + SExprNode* pGroupExpr = NULL; + code = nodesCloneNode(pExpr, (SNode**)&pGroupExpr); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pGroupingSet->pParameterList, (SNode*)pGroupExpr); } - return (SNode*)pGroupingSet; + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pGroupingSet); + return code; + } + *ppNode = (SNode*)pGroupingSet; + return code; } -static SNode* rewriteUniqueOptCreateFirstFunc(SFunctionNode* pSelectValue, SNode* pCol) { - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); +static int32_t rewriteUniqueOptCreateFirstFunc(SFunctionNode* pSelectValue, SNode* pCol, SNode** ppNode) { + SFunctionNode* pFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); if (NULL == pFunc) { - return NULL; + return code; } strcpy(pFunc->functionName, "first"); @@ -3585,23 +3772,28 @@ static SNode* rewriteUniqueOptCreateFirstFunc(SFunctionNode* pSelectValue, SNode taosCreateMD5Hash(name, len); strncpy(pFunc->node.aliasName, name, TSDB_COL_NAME_LEN - 1); } - int32_t code = nodesListMakeStrictAppend(&pFunc->pParameterList, nodesCloneNode(pCol)); + SNode* pNew = NULL; + code = nodesCloneNode(pCol, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pFunc->pParameterList, pNew); + } if (TSDB_CODE_SUCCESS == code) { code = fmGetFuncInfo(pFunc, NULL, 0); } if (TSDB_CODE_SUCCESS != code) { nodesDestroyNode((SNode*)pFunc); - return NULL; + return code; } - - return (SNode*)pFunc; + *ppNode = (SNode*)pFunc; + return code; } static int32_t rewriteUniqueOptCreateAgg(SIndefRowsFuncLogicNode* pIndef, SLogicNode** pOutput) { - SAggLogicNode* pAgg = (SAggLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG); + SAggLogicNode* pAgg = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pAgg); if (NULL == pAgg) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } TSWAP(pAgg->node.pChildren, pIndef->node.pChildren); @@ -3610,7 +3802,6 @@ static int32_t rewriteUniqueOptCreateAgg(SIndefRowsFuncLogicNode* pIndef, SLogic pAgg->node.requireDataOrder = DATA_ORDER_LEVEL_IN_BLOCK; // first function requirement pAgg->node.resultDataOrder = DATA_ORDER_LEVEL_NONE; - int32_t code = TSDB_CODE_SUCCESS; bool hasSelectPrimaryKey = false; SNode* pPrimaryKey = NULL; SNode* pNode = NULL; @@ -3619,12 +3810,24 @@ static int32_t rewriteUniqueOptCreateAgg(SIndefRowsFuncLogicNode* pIndef, SLogic SNode* pExpr = nodesListGetNode(pFunc->pParameterList, 0); if (FUNCTION_TYPE_UNIQUE == pFunc->funcType) { pPrimaryKey = nodesListGetNode(pFunc->pParameterList, 1); - code = nodesListMakeStrictAppend(&pAgg->pGroupKeys, rewriteUniqueOptCreateGroupingSet(pExpr)); + SNode* pNew = NULL; + code = rewriteUniqueOptCreateGroupingSet(pExpr, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pAgg->pGroupKeys, pNew); + } } else if (PRIMARYKEY_TIMESTAMP_COL_ID == ((SColumnNode*)pExpr)->colId) { // _select_value(ts) => first(ts) hasSelectPrimaryKey = true; - code = nodesListMakeStrictAppend(&pAgg->pAggFuncs, rewriteUniqueOptCreateFirstFunc(pFunc, pExpr)); + SNode* pNew = NULL; + code = rewriteUniqueOptCreateFirstFunc(pFunc, pExpr, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pAgg->pAggFuncs, pNew); + } } else { // _select_value(other_col) - code = nodesListMakeStrictAppend(&pAgg->pAggFuncs, nodesCloneNode(pNode)); + SNode* pNew = NULL; + code = nodesCloneNode(pNode, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pAgg->pAggFuncs, pNew); + } } if (TSDB_CODE_SUCCESS != code) { break; @@ -3639,7 +3842,11 @@ static int32_t rewriteUniqueOptCreateAgg(SIndefRowsFuncLogicNode* pIndef, SLogic } if (TSDB_CODE_SUCCESS == code && !hasSelectPrimaryKey && NULL != pAgg->pAggFuncs) { - code = nodesListMakeStrictAppend(&pAgg->pAggFuncs, rewriteUniqueOptCreateFirstFunc(NULL, pPrimaryKey)); + SNode* pNew = NULL; + code = rewriteUniqueOptCreateFirstFunc(NULL, pPrimaryKey, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pAgg->pAggFuncs, pNew); + } } if (TSDB_CODE_SUCCESS == code) { @@ -3650,10 +3857,11 @@ static int32_t rewriteUniqueOptCreateAgg(SIndefRowsFuncLogicNode* pIndef, SLogic return code; } -static SNode* rewriteUniqueOptCreateProjectCol(SFunctionNode* pFunc) { - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); +static int32_t rewriteUniqueOptCreateProjectCol(SFunctionNode* pFunc, SNode** ppNode) { + SColumnNode* pCol = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); if (NULL == pCol) { - return NULL; + return code; } pCol->node.resType = pFunc->node.resType; @@ -3669,14 +3877,15 @@ static SNode* rewriteUniqueOptCreateProjectCol(SFunctionNode* pFunc) { strcpy(pCol->colName, pFunc->node.aliasName); } strcpy(pCol->node.aliasName, pFunc->node.aliasName); - - return (SNode*)pCol; + *ppNode = (SNode*)pCol; + return code; } static int32_t rewriteUniqueOptCreateProject(SIndefRowsFuncLogicNode* pIndef, SLogicNode** pOutput) { - SProjectLogicNode* pProject = (SProjectLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT); + SProjectLogicNode* pProject = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PROJECT, (SNode**)&pProject); if (NULL == pProject) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } TSWAP(pProject->node.pTargets, pIndef->node.pTargets); @@ -3684,10 +3893,13 @@ static int32_t rewriteUniqueOptCreateProject(SIndefRowsFuncLogicNode* pIndef, SL pProject->node.requireDataOrder = DATA_ORDER_LEVEL_NONE; pProject->node.resultDataOrder = DATA_ORDER_LEVEL_NONE; - int32_t code = TSDB_CODE_SUCCESS; SNode* pNode = NULL; FOREACH(pNode, pIndef->pFuncs) { - code = nodesListMakeStrictAppend(&pProject->pProjections, rewriteUniqueOptCreateProjectCol((SFunctionNode*)pNode)); + SNode* pNew = NULL; + code = rewriteUniqueOptCreateProjectCol((SFunctionNode*)pNode, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pProject->pProjections, pNew); + } if (TSDB_CODE_SUCCESS != code) { break; } @@ -3923,13 +4135,17 @@ typedef struct SLastRowScanOptSetColDataTypeCxt { SNodeList* pOtherCols; int32_t funcType; int32_t pkBytes; + int32_t code; } SLastRowScanOptSetColDataTypeCxt; static EDealRes lastRowScanOptSetColDataType(SNode* pNode, void* pContext) { if (QUERY_NODE_COLUMN == nodeType(pNode)) { SLastRowScanOptSetColDataTypeCxt* pCxt = pContext; if (pCxt->doAgg) { - nodesListMakeAppend(&pCxt->pLastCols, pNode); + pCxt->code = nodesListMakeAppend(&pCxt->pLastCols, pNode); + if (TSDB_CODE_SUCCESS != pCxt->code) { + return DEAL_RES_ERROR; + } getLastCacheDataType(&(((SColumnNode*)pNode)->node.resType), pCxt->pkBytes); } else { SNode* pCol = NULL; @@ -4046,6 +4262,7 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic SNodeList* pLastRowCols = NULL; bool adjLastRowTsColName = false; char tsColName[TSDB_COL_NAME_LEN] = {0}; + int32_t code = 0; FOREACH(pNode, pAgg->pAggFuncs) { SFunctionNode* pFunc = (SFunctionNode*)pNode; @@ -4054,16 +4271,17 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic if (FUNCTION_TYPE_LAST == funcType) { nodesListErase(pFunc->pParameterList, nodesListGetCell(pFunc->pParameterList, 1)); nodesWalkExpr(nodesListGetNode(pFunc->pParameterList, 0), lastRowScanOptSetColDataType, &cxt); + if (TSDB_CODE_SUCCESS != cxt.code) break; } FOREACH(pParamNode, pFunc->pParameterList) { if (FUNCTION_TYPE_LAST_ROW == funcType || FUNCTION_TYPE_LAST == funcType) { int32_t len = snprintf(pFunc->functionName, sizeof(pFunc->functionName), FUNCTION_TYPE_LAST_ROW == funcType ? "_cache_last_row" : "_cache_last"); pFunc->functionName[len] = '\0'; - int32_t code = fmGetFuncInfo(pFunc, NULL, 0); + code = fmGetFuncInfo(pFunc, NULL, 0); if (TSDB_CODE_SUCCESS != code) { nodesClearList(cxt.pLastCols); - return code; + break; } cxt.funcType = pFunc->funcType; cxt.pkBytes = (pFunc->hasPk) ? pFunc->pkBytes : 0; @@ -4076,7 +4294,10 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic bool isDup = false; bool* isDuplicate = taosArrayGet(isDuplicateCol, i); if (NULL == isDuplicate) { - taosArrayInsert(isDuplicateCol, i, &isDup); + if (NULL == taosArrayInsert(isDuplicateCol, i, &isDup)) { + code = terrno; + break; + } isDuplicate = taosArrayGet(isDuplicateCol, i); } i++; @@ -4085,7 +4306,11 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic if (0 == strncmp(((SColumnNode*)pColNode)->colName, "#dup_col.", 9)) { continue; } - SNode* newColNode = nodesCloneNode(pColNode); + SNode* newColNode = NULL; + code = nodesCloneNode(pColNode, &newColNode); + if (TSDB_CODE_SUCCESS != code) { + break; + } sprintf(((SColumnNode*)newColNode)->colName, "#dup_col.%p", newColNode); sprintf(((SColumnNode*)pParamNode)->colName, "#dup_col.%p", newColNode); if (FUNCTION_TYPE_LAST_ROW == funcType && @@ -4100,51 +4325,82 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic } } - nodesListAppend(pScan->pScanCols, newColNode); + code = nodesListStrictAppend(pScan->pScanCols, newColNode); + if (TSDB_CODE_SUCCESS != code) break; isDup = true; - taosArrayInsert(isDuplicateCol, pScan->pScanCols->length, &isDup); - nodesListAppend(pScan->node.pTargets, nodesCloneNode(newColNode)); + if (NULL == taosArrayInsert(isDuplicateCol, pScan->pScanCols->length, &isDup)) { + code = terrno; + break; + } + SNode* pNew = NULL; + code = nodesCloneNode(newColNode, &pNew); + if (TSDB_CODE_SUCCESS != code) break; + code = nodesListStrictAppend(pScan->node.pTargets, pNew); + if (TSDB_CODE_SUCCESS != code) break; if (funcType != FUNCTION_TYPE_LAST) { - nodesListMakeAppend(&pLastRowCols, nodesCloneNode(newColNode)); + pNew = NULL; + code = nodesCloneNode(newColNode, &pNew); + if (TSDB_CODE_SUCCESS != code) break; + code = nodesListMakeAppend(&pLastRowCols, pNew); + if (TSDB_CODE_SUCCESS != code) break; } - lastRowScanBuildFuncTypes(pScan, (SColumnNode*)newColNode, pFunc->funcType); + code = lastRowScanBuildFuncTypes(pScan, (SColumnNode*)newColNode, pFunc->funcType); + if (TSDB_CODE_SUCCESS != code) break; } else { isDup = true; *isDuplicate = isDup; if (funcType != FUNCTION_TYPE_LAST && !nodeListNodeEqual(cxt.pLastCols, pColNode)) { - nodesListMakeAppend(&pLastRowCols, nodesCloneNode(pColNode)); + SNode* pNew = NULL; + code = nodesCloneNode(pColNode, &pNew); + if (TSDB_CODE_SUCCESS != code) break; + code = nodesListMakeStrictAppend(&pLastRowCols, pNew); + if (TSDB_CODE_SUCCESS != code) break; } - lastRowScanBuildFuncTypes(pScan, (SColumnNode*)pColNode, pFunc->funcType); + code = lastRowScanBuildFuncTypes(pScan, (SColumnNode*)pColNode, pFunc->funcType); + if (TSDB_CODE_SUCCESS != code) break; } continue; - }else if (nodeListNodeEqual(pFunc->pParameterList, pColNode)) { + } else if (nodeListNodeEqual(pFunc->pParameterList, pColNode)) { if (funcType != FUNCTION_TYPE_LAST && ((SColumnNode*)pColNode)->colId == PRIMARYKEY_TIMESTAMP_COL_ID && !nodeListNodeEqual(pLastRowCols, pColNode)) { - nodesListMakeAppend(&pLastRowCols, nodesCloneNode(pColNode)); + SNode* pNew = NULL; + code = nodesCloneNode(pColNode, &pNew); + if (TSDB_CODE_SUCCESS != code) break; + code = nodesListMakeAppend(&pLastRowCols, pNew); + if (TSDB_CODE_SUCCESS != code) break; - lastRowScanBuildFuncTypes(pScan, (SColumnNode*)pColNode, pFunc->funcType); + code = lastRowScanBuildFuncTypes(pScan, (SColumnNode*)pColNode, pFunc->funcType); + if (TSDB_CODE_SUCCESS != code) break; isDup = true; *isDuplicate = isDup; } } } + if (TSDB_CODE_SUCCESS != code) break;; FOREACH(pColNode, pScan->pScanPseudoCols) { if (nodesEqualNode(pParamNode, pColNode)) { if (funcType != FUNCTION_TYPE_LAST) { - nodesListMakeAppend(&pLastRowCols, nodesCloneNode(pColNode)); + SNode* pNew = NULL; + code = nodesCloneNode(pColNode, &pNew); + if (TSDB_CODE_SUCCESS != code) break; + code = nodesListMakeAppend(&pLastRowCols, pNew); + if (TSDB_CODE_SUCCESS != code) break; } } } } } + if (TSDB_CODE_SUCCESS != code) break; if (pFunc->hasPk) { - nodesListMakeAppend(&cxt.pOtherCols, nodesListGetNode(pFunc->pParameterList, LIST_LENGTH(pFunc->pParameterList) - 1)); + code = nodesListMakeAppend(&cxt.pOtherCols, nodesListGetNode(pFunc->pParameterList, LIST_LENGTH(pFunc->pParameterList) - 1)); } + if (TSDB_CODE_SUCCESS != code) break; } else { pNode = nodesListGetNode(pFunc->pParameterList, 0); - nodesListMakeAppend(&cxt.pOtherCols, pNode); + code = nodesListMakeAppend(&cxt.pOtherCols, pNode); + if (TSDB_CODE_SUCCESS != code) break; if (FUNCTION_TYPE_SELECT_VALUE == funcType) { if (nodeType(pNode) == QUERY_NODE_COLUMN) { @@ -4158,6 +4414,13 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic } } } + if (TSDB_CODE_SUCCESS != code) break; + } + + if (TSDB_CODE_SUCCESS != code) { + taosArrayDestroy(isDuplicateCol); + nodesClearList(cxt.pLastCols); + return code; } if (NULL != cxt.pLastCols) { @@ -4166,7 +4429,12 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic lastRowScanOptSetLastTargets(pScan->pScanCols, cxt.pLastCols, pLastRowCols, true, cxt.pkBytes); nodesWalkExprs(pScan->pScanPseudoCols, lastRowScanOptSetColDataType, &cxt); - + if (TSDB_CODE_SUCCESS != cxt.code) { + nodesClearList(cxt.pLastCols); + nodesClearList(cxt.pOtherCols); + taosArrayDestroy(isDuplicateCol); + return cxt.code; + } lastRowScanOptSetLastTargets(pScan->node.pTargets, cxt.pLastCols, pLastRowCols, false, cxt.pkBytes); lastRowScanOptRemoveUslessTargets(pScan->node.pTargets, cxt.pLastCols, cxt.pOtherCols, pLastRowCols); if (pPKTsCol && @@ -4174,14 +4442,28 @@ static int32_t lastRowScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogic (pScan->node.pTargets->length == 2 && cxt.pkBytes > 0))) { // when select last(ts),tbname,ts from ..., we add another ts to targets sprintf(pPKTsCol->colName, "#sel_val.%p", pPKTsCol); - nodesListAppend(pScan->node.pTargets, nodesCloneNode((SNode*)pPKTsCol)); + SNode* pNew = NULL; + code = nodesCloneNode((SNode*)pPKTsCol, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListAppend(pScan->node.pTargets, pNew); + } + if (TSDB_CODE_SUCCESS != code) { + nodesClearList(cxt.pLastCols); + nodesClearList(cxt.pOtherCols); + taosArrayDestroy(isDuplicateCol); + return code; + } } if (pNonPKCol && cxt.pLastCols->length == 1 && nodesEqualNode((SNode*)pNonPKCol, nodesListGetNode(cxt.pLastCols, 0))) { // when select last(c1), c1 from ..., we add c1 to targets sprintf(pNonPKCol->colName, "#sel_val.%p", pNonPKCol); - nodesListAppend(pScan->node.pTargets, nodesCloneNode((SNode*)pNonPKCol)); + SNode* pNew = NULL; + code = nodesCloneNode((SNode*)pNonPKCol, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListAppend(pScan->node.pTargets, pNew); + } } nodesClearList(cxt.pLastCols); @@ -4222,11 +4504,12 @@ static bool splitCacheLastFuncOptMayBeOptimized(SLogicNode* pNode) { static int32_t splitCacheLastFuncOptCreateAggLogicNode(SAggLogicNode** pNewAgg, SAggLogicNode* pAgg, SNodeList* pFunc, SNodeList* pTargets) { - SAggLogicNode* pNew = (SAggLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG); + SAggLogicNode* pNew = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_AGG, (SNode**)&pNew); if (NULL == pNew) { nodesDestroyList(pFunc); nodesDestroyList(pTargets); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pNew->hasLastRow = false; @@ -4249,14 +4532,25 @@ static int32_t splitCacheLastFuncOptCreateAggLogicNode(SAggLogicNode** pNewAgg, pNew->node.resultDataOrder = pAgg->node.resultDataOrder; pNew->node.pTargets = pTargets; pNew->pAggFuncs = pFunc; - pNew->pGroupKeys = nodesCloneList(pAgg->pGroupKeys); - pNew->node.pConditions = nodesCloneNode(pAgg->node.pConditions); + code = nodesCloneList(pAgg->pGroupKeys, &pNew->pGroupKeys); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pNew); + return code; + } + code = nodesCloneNode(pAgg->node.pConditions, &pNew->node.pConditions); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pNew); + return code; + } pNew->isGroupTb = pAgg->isGroupTb; pNew->isPartTb = pAgg->isPartTb; pNew->hasGroup = pAgg->hasGroup; - pNew->node.pChildren = nodesCloneList(pAgg->node.pChildren); + code = nodesCloneList(pAgg->node.pChildren, &pNew->node.pChildren); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pNew); + return code; + } - int32_t code = 0; SNode* pNode = nodesListGetNode(pNew->node.pChildren, 0); if (QUERY_NODE_LOGIC_PLAN_SCAN == nodeType(pNode)) { SScanLogicNode* pScan = (SScanLogicNode*)pNode; @@ -4266,15 +4560,21 @@ static int32_t splitCacheLastFuncOptCreateAggLogicNode(SAggLogicNode** pNewAgg, pScan->pScanPseudoCols = NULL; nodesDestroyList(pScan->node.pTargets); pScan->node.pTargets = NULL; - SNodeListNode* list = (SNodeListNode*)nodesMakeNode(QUERY_NODE_NODE_LIST); - if (!list) return TSDB_CODE_OUT_OF_MEMORY; + SNodeListNode* list = NULL; + code = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&list); + if (!list) { + nodesDestroyNode((SNode*)pNew); + return code; + } list->pNodeList = pFunc; code = nodesCollectColumnsFromNode((SNode*)list, NULL, COLLECT_COL_TYPE_COL, &pScan->pScanCols); if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pNew); return code; } code = nodesCollectColumnsFromNode((SNode*)list, NULL, COLLECT_COL_TYPE_TAG, &pScan->pScanPseudoCols); if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pNew); return code; } nodesFree(list); @@ -4288,18 +4588,28 @@ static int32_t splitCacheLastFuncOptCreateAggLogicNode(SAggLogicNode** pNewAgg, if (!found) { FOREACH(pNode, pOldScanCols) { if (PRIMARYKEY_TIMESTAMP_COL_ID == ((SColumnNode*)pNode)->colId) { - nodesListMakeStrictAppend(&pScan->pScanCols, nodesCloneNode(pNode)); + SNode* pTmp = NULL; + code = nodesCloneNode(pNode, &pTmp); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pScan->pScanCols, pTmp); + } break; } } + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pNew); + return code; + } } nodesDestroyList(pOldScanCols); code = createColumnByRewriteExprs(pScan->pScanCols, &pScan->node.pTargets); if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pNew); return code; } code = createColumnByRewriteExprs(pScan->pScanPseudoCols, &pScan->node.pTargets); if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pNew); return code; } OPTIMIZE_FLAG_CLEAR_MASK(pScan->node.optimizedFlag, OPTIMIZE_FLAG_SCAN_PATH); @@ -4319,21 +4629,28 @@ static int32_t splitCacheLastFuncOptModifyAggLogicNode(SAggLogicNode* pAgg) { static int32_t splitCacheLastFuncOptCreateMergeLogicNode(SMergeLogicNode** pNew, SAggLogicNode* pAgg1, SAggLogicNode* pAgg2) { - SMergeLogicNode* pMerge = (SMergeLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_MERGE); + SMergeLogicNode* pMerge = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_MERGE, (SNode**)&pMerge); if (NULL == pMerge) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pMerge->colsMerge = true; pMerge->numOfChannels = 2; pMerge->srcGroupId = -1; pMerge->node.precision = pAgg1->node.precision; - SNode* pNewAgg1 = nodesCloneNode((SNode*)pAgg1); - SNode* pNewAgg2 = nodesCloneNode((SNode*)pAgg2); - if (NULL == pNewAgg1 || NULL == pNewAgg2) { + SNode* pNewAgg1 = NULL; + code = nodesCloneNode((SNode*)pAgg1, &pNewAgg1); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pMerge); + return code; + } + SNode* pNewAgg2 = NULL; + code = nodesCloneNode((SNode*)pAgg2, &pNewAgg2); + if (TSDB_CODE_SUCCESS != code) { nodesDestroyNode(pNewAgg1); - nodesDestroyNode(pNewAgg2); - return TSDB_CODE_OUT_OF_MEMORY; + nodesDestroyNode((SNode*)pMerge); + return code; } ((SAggLogicNode*)pNewAgg1)->node.pParent = (SLogicNode*)pMerge; @@ -4343,9 +4660,17 @@ static int32_t splitCacheLastFuncOptCreateMergeLogicNode(SMergeLogicNode** pNew, FOREACH(pNode, ((SAggLogicNode*)pNewAgg1)->node.pChildren) { ((SLogicNode*)pNode)->pParent = (SLogicNode*)pNewAgg1; } FOREACH(pNode, ((SAggLogicNode*)pNewAgg2)->node.pChildren) { ((SLogicNode*)pNode)->pParent = (SLogicNode*)pNewAgg2; } - int32_t code = nodesListMakeStrictAppendList(&pMerge->node.pTargets, nodesCloneList(pAgg1->node.pTargets)); + SNodeList* pNewTargets1 = NULL; + code = nodesCloneList(pAgg1->node.pTargets, &pNewTargets1); if (TSDB_CODE_SUCCESS == code) { - code = nodesListMakeStrictAppendList(&pMerge->node.pTargets, nodesCloneList(pAgg2->node.pTargets)); + code = nodesListMakeStrictAppendList(&pMerge->node.pTargets, pNewTargets1); + } + SNodeList* pNewTargets2 = NULL; + if (TSDB_CODE_SUCCESS == code) { + code = nodesCloneList(pAgg2->node.pTargets, &pNewTargets2); + } + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppendList(&pMerge->node.pTargets, pNewTargets2); } if (TSDB_CODE_SUCCESS == code) { code = nodesListMakeStrictAppend(&pMerge->node.pChildren, pNewAgg1); @@ -4372,8 +4697,9 @@ static int32_t splitCacheLastFuncOptimize(SOptimizeContext* pCxt, SLogicSubplan* return TSDB_CODE_SUCCESS; } SScanLogicNode* pScan = (SScanLogicNode*)nodesListGetNode(pAgg->node.pChildren, 0); - SNode* pNode = NULL; - SNodeList* pAggFuncList = NULL; + SNode* pNode = NULL; + SNodeList* pAggFuncList = NULL; + int32_t code = 0; { bool hasLast = false; @@ -4383,7 +4709,14 @@ static int32_t splitCacheLastFuncOptimize(SOptimizeContext* pCxt, SLogicSubplan* int32_t funcType = pFunc->funcType; if (isNeedSplitCacheLastFunc(pFunc, pScan)) { - nodesListMakeStrictAppend(&pAggFuncList, nodesCloneNode(pNode)); + SNode* pNew = NULL; + code = nodesCloneNode(pNode, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pAggFuncList, pNew); + } + if (TSDB_CODE_SUCCESS != code) { + break; + } ERASE_NODE(pAgg->pAggFuncs); continue; } @@ -4397,6 +4730,10 @@ static int32_t splitCacheLastFuncOptimize(SOptimizeContext* pCxt, SLogicSubplan* pAgg->hasLast = hasLast; pAgg->hasLastRow = hasLastRow; } + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyList(pAggFuncList); + return code; + } if (NULL == pAggFuncList) { planError("empty agg func list while splite projections, funcNum:%d", pAgg->pAggFuncs->length); @@ -4412,11 +4749,18 @@ static int32_t splitCacheLastFuncOptimize(SOptimizeContext* pCxt, SLogicSubplan* FOREACH(pFuncNode, pAggFuncList) { SFunctionNode* pFunc = (SFunctionNode*)pFuncNode; if (0 == strcmp(pFunc->node.aliasName, pCol->colName)) { - nodesListMakeStrictAppend(&pTargets, nodesCloneNode(pNode)); + SNode* pNew = NULL; + code = nodesCloneNode(pNode, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pTargets, pNew); + } found = true; break; } } + if (TSDB_CODE_SUCCESS != code) { + break; + } if (found) { ERASE_NODE(pAgg->node.pTargets); continue; @@ -4424,6 +4768,10 @@ static int32_t splitCacheLastFuncOptimize(SOptimizeContext* pCxt, SLogicSubplan* WHERE_NEXT; } } + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyList(pTargets); + return code; + } if (NULL == pTargets) { planError("empty target func list while splite projections, targetsNum:%d", pAgg->node.pTargets->length); @@ -4433,7 +4781,7 @@ static int32_t splitCacheLastFuncOptimize(SOptimizeContext* pCxt, SLogicSubplan* SMergeLogicNode* pMerge = NULL; SAggLogicNode* pNewAgg = NULL; - int32_t code = splitCacheLastFuncOptCreateAggLogicNode(&pNewAgg, pAgg, pAggFuncList, pTargets); + code = splitCacheLastFuncOptCreateAggLogicNode(&pNewAgg, pAgg, pAggFuncList, pTargets); if (TSDB_CODE_SUCCESS == code) { code = splitCacheLastFuncOptModifyAggLogicNode(pAgg); } @@ -4484,9 +4832,9 @@ static EDealRes mergeProjectionsExpr(SNode** pNode, void* pContext) { SNode* pProjection; FOREACH(pProjection, pChildProj->pProjections) { if (0 == strcmp(((SColumnNode*)pTarget)->colName, ((SExprNode*)pProjection)->aliasName)) { - SNode* pExpr = nodesCloneNode(pProjection); + SNode* pExpr = NULL; + pCxt->errCode = nodesCloneNode(pProjection, &pExpr); if (pExpr == NULL) { - pCxt->errCode = terrno; return DEAL_RES_ERROR; } snprintf(((SExprNode*)pExpr)->aliasName, sizeof(((SExprNode*)pExpr)->aliasName), "%s", @@ -4590,17 +4938,28 @@ static int32_t tagScanOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubp SLogicNode* pAgg = pScanNode->node.pParent; if (NULL == pAgg->pParent) { - SNodeList* pScanTargets = nodesMakeList(); + SNodeList* pScanTargets = NULL; + int32_t code = nodesMakeList(&pScanTargets); + if (TSDB_CODE_SUCCESS != code) { + return code; + } SNode* pAggTarget = NULL; FOREACH(pAggTarget, pAgg->pTargets) { SNode* pScanTarget = NULL; FOREACH(pScanTarget, pScanNode->node.pTargets) { if (0 == strcmp(((SColumnNode*)pAggTarget)->colName, ((SColumnNode*)pScanTarget)->colName)) { - nodesListAppend(pScanTargets, nodesCloneNode(pScanTarget)); + SNode* pNew = NULL; + code = nodesCloneNode(pScanTarget, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListAppend(pScanTargets, pNew); + } break; } } + if (TSDB_CODE_SUCCESS != code) { + break; + } } nodesDestroyList(pScanNode->node.pTargets); pScanNode->node.pTargets = pScanTargets; @@ -4627,29 +4986,48 @@ static void swapLimit(SLogicNode* pParent, SLogicNode* pChild) { pParent->pLimit = NULL; } -static bool pushDownLimitHow(SLogicNode* pNodeWithLimit, SLogicNode* pNodeLimitPushTo); -static bool pushDownLimitTo(SLogicNode* pNodeWithLimit, SLogicNode* pNodeLimitPushTo) { +static int32_t pushDownLimitHow(SLogicNode* pNodeWithLimit, SLogicNode* pNodeLimitPushTo, bool* pPushed); +static int32_t pushDownLimitTo(SLogicNode* pNodeWithLimit, SLogicNode* pNodeLimitPushTo, bool* pPushed) { + int32_t code = 0; + bool cloned; switch (nodeType(pNodeLimitPushTo)) { case QUERY_NODE_LOGIC_PLAN_WINDOW: { SWindowLogicNode* pWindow = (SWindowLogicNode*)pNodeLimitPushTo; if (pWindow->winType != WINDOW_TYPE_INTERVAL) break; - cloneLimit(pNodeWithLimit, pNodeLimitPushTo, CLONE_LIMIT_SLIMIT); - return true; + code = cloneLimit(pNodeWithLimit, pNodeLimitPushTo, CLONE_LIMIT_SLIMIT, &cloned); + if (TSDB_CODE_SUCCESS == code) { + *pPushed = true; + } + return code; } case QUERY_NODE_LOGIC_PLAN_SORT: if (((SSortLogicNode*)pNodeLimitPushTo)->calcGroupId) break; // fall through - case QUERY_NODE_LOGIC_PLAN_FILL: - cloneLimit(pNodeWithLimit, pNodeLimitPushTo, CLONE_LIMIT_SLIMIT); + case QUERY_NODE_LOGIC_PLAN_FILL: { SNode* pChild = NULL; - FOREACH(pChild, pNodeLimitPushTo->pChildren) { pushDownLimitHow(pNodeLimitPushTo, (SLogicNode*)pChild); } - return true; + code = cloneLimit(pNodeWithLimit, pNodeLimitPushTo, CLONE_LIMIT_SLIMIT, &cloned); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + FOREACH(pChild, pNodeLimitPushTo->pChildren) { + code = pushDownLimitHow(pNodeLimitPushTo, (SLogicNode*)pChild, &cloned); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + } + *pPushed = true; + return code; + } case QUERY_NODE_LOGIC_PLAN_AGG: { if (nodeType(pNodeWithLimit) == QUERY_NODE_LOGIC_PLAN_PROJECT && (isPartTagAgg((SAggLogicNode*)pNodeLimitPushTo) || isPartTableAgg((SAggLogicNode*)pNodeLimitPushTo))) { // when part by tag/tbname, slimit will be cloned to agg, and it will be pipelined. // The scan below will do scanning with group order - return cloneLimit(pNodeWithLimit, pNodeLimitPushTo, CLONE_SLIMIT); + code = cloneLimit(pNodeWithLimit, pNodeLimitPushTo, CLONE_SLIMIT, &cloned); + if (TSDB_CODE_SUCCESS == code) { + *pPushed = cloned; + } + return code; } // else if not part by tag and tbname, the partition node below indicates that results are sorted, the agg node // can be pipelined. @@ -4657,14 +5035,22 @@ static bool pushDownLimitTo(SLogicNode* pNodeWithLimit, SLogicNode* pNodeLimitPu SLogicNode* pChild = (SLogicNode*)nodesListGetNode(pNodeLimitPushTo->pChildren, 0); if (nodeType(pChild) == QUERY_NODE_LOGIC_PLAN_PARTITION) { pNodeLimitPushTo->forceCreateNonBlockingOptr = true; - return cloneLimit(pNodeWithLimit, pNodeLimitPushTo, CLONE_SLIMIT); + code = cloneLimit(pNodeWithLimit, pNodeLimitPushTo, CLONE_SLIMIT, &cloned); + if (TSDB_CODE_SUCCESS == code) { + *pPushed = cloned; + } + return code; } // Currently, partColOpt is executed after pushDownLimitOpt, and partColOpt will replace partition node with // sort node. // To avoid dependencies between these two optimizations, we add sort node too. if (nodeType(pChild) == QUERY_NODE_LOGIC_PLAN_SORT && ((SSortLogicNode*)pChild)->calcGroupId) { pNodeLimitPushTo->forceCreateNonBlockingOptr = true; - return cloneLimit(pNodeWithLimit, pNodeLimitPushTo, CLONE_SLIMIT); + code = cloneLimit(pNodeWithLimit, pNodeLimitPushTo, CLONE_SLIMIT, &cloned); + if (TSDB_CODE_SUCCESS == code) { + *pPushed = cloned; + } + return code; } } break; @@ -4672,36 +5058,41 @@ static bool pushDownLimitTo(SLogicNode* pNodeWithLimit, SLogicNode* pNodeLimitPu case QUERY_NODE_LOGIC_PLAN_SCAN: if (nodeType(pNodeWithLimit) == QUERY_NODE_LOGIC_PLAN_PROJECT && pNodeWithLimit->pLimit) { if (((SProjectLogicNode*)pNodeWithLimit)->inputIgnoreGroup) { - cloneLimit(pNodeWithLimit, pNodeLimitPushTo, CLONE_LIMIT); + code = cloneLimit(pNodeWithLimit, pNodeLimitPushTo, CLONE_LIMIT, &cloned); } else { swapLimit(pNodeWithLimit, pNodeLimitPushTo); } - return true; + if (TSDB_CODE_SUCCESS == code) { + *pPushed = true; + } + return code; } break; case QUERY_NODE_LOGIC_PLAN_JOIN: { - cloneLimit(pNodeWithLimit, pNodeLimitPushTo, CLONE_LIMIT); - break; + code = cloneLimit(pNodeWithLimit, pNodeLimitPushTo, CLONE_LIMIT, &cloned); + break; } default: break; } - return false; + *pPushed = false; + return code; } -static bool pushDownLimitHow(SLogicNode* pNodeWithLimit, SLogicNode* pNodeLimitPushTo) { +static int32_t pushDownLimitHow(SLogicNode* pNodeWithLimit, SLogicNode* pNodeLimitPushTo, bool* pPushed) { switch (nodeType(pNodeWithLimit)) { case QUERY_NODE_LOGIC_PLAN_PROJECT: case QUERY_NODE_LOGIC_PLAN_FILL: - return pushDownLimitTo(pNodeWithLimit, pNodeLimitPushTo); + return pushDownLimitTo(pNodeWithLimit, pNodeLimitPushTo, pPushed); case QUERY_NODE_LOGIC_PLAN_SORT: { SSortLogicNode* pSort = (SSortLogicNode*)pNodeWithLimit; - if (sortPriKeyOptIsPriKeyOrderBy(pSort->pSortKeys)) return pushDownLimitTo(pNodeWithLimit, pNodeLimitPushTo); + if (sortPriKeyOptIsPriKeyOrderBy(pSort->pSortKeys)) return pushDownLimitTo(pNodeWithLimit, pNodeLimitPushTo, pPushed); } default: break; } - return false; + *pPushed = false; + return TSDB_CODE_SUCCESS; } static int32_t pushDownLimitOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { @@ -4712,7 +5103,12 @@ static int32_t pushDownLimitOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLog SLogicNode* pChild = (SLogicNode*)nodesListGetNode(pNode->pChildren, 0); nodesDestroyNode(pChild->pLimit); - if (pushDownLimitHow(pNode, pChild)) { + bool pushed = false; + int32_t code = pushDownLimitHow(pNode, pChild, &pushed); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + if (pushed) { pCxt->optimized = true; } return TSDB_CODE_SUCCESS; @@ -4866,18 +5262,21 @@ static bool tbCntScanOptShouldBeOptimized(SLogicNode* pNode, STbCntScanOptInfo* return tbCntScanOptIsEligibleAgg(pInfo->pAgg) && tbCntScanOptIsEligibleScan(pInfo); } -static SNode* tbCntScanOptCreateTableCountFunc() { - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); +static int32_t tbCntScanOptCreateTableCountFunc(SNode** ppNode) { + SFunctionNode* pFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); if (NULL == pFunc) { - return NULL; + return code; } strcpy(pFunc->functionName, "_table_count"); strcpy(pFunc->node.aliasName, "_table_count"); - if (TSDB_CODE_SUCCESS != fmGetFuncInfo(pFunc, NULL, 0)) { + code = fmGetFuncInfo(pFunc, NULL, 0); + if (TSDB_CODE_SUCCESS != code) { nodesDestroyNode((SNode*)pFunc); - return NULL; + return code; } - return (SNode*)pFunc; + *ppNode = (SNode*)pFunc; + return code; } static int32_t tbCntScanOptRewriteScan(STbCntScanOptInfo* pInfo) { @@ -4888,35 +5287,54 @@ static int32_t tbCntScanOptRewriteScan(STbCntScanOptInfo* pInfo) { NODES_DESTORY_LIST(pInfo->pScan->pScanCols); NODES_DESTORY_NODE(pInfo->pScan->node.pConditions); NODES_DESTORY_LIST(pInfo->pScan->pScanPseudoCols); - int32_t code = nodesListMakeStrictAppend(&pInfo->pScan->pScanPseudoCols, tbCntScanOptCreateTableCountFunc()); + SNode* pNew = NULL; + int32_t code = tbCntScanOptCreateTableCountFunc(&pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pInfo->pScan->pScanPseudoCols, pNew); + } if (TSDB_CODE_SUCCESS == code) { code = createColumnByRewriteExpr(nodesListGetNode(pInfo->pScan->pScanPseudoCols, 0), &pInfo->pScan->node.pTargets); } SNode* pGroupKey = NULL; - FOREACH(pGroupKey, pInfo->pAgg->pGroupKeys) { - SNode* pGroupCol = nodesListGetNode(((SGroupingSetNode*)pGroupKey)->pParameterList, 0); - code = nodesListMakeStrictAppend(&pInfo->pScan->pGroupTags, nodesCloneNode(pGroupCol)); - if (TSDB_CODE_SUCCESS == code) { - code = nodesListMakeStrictAppend(&pInfo->pScan->pScanCols, nodesCloneNode(pGroupCol)); - } - if (TSDB_CODE_SUCCESS == code) { - code = nodesListMakeStrictAppend(&pInfo->pScan->node.pTargets, nodesCloneNode(pGroupCol)); - } - if (TSDB_CODE_SUCCESS != code) { - break; + if (TSDB_CODE_SUCCESS == code) { + FOREACH(pGroupKey, pInfo->pAgg->pGroupKeys) { + SNode* pGroupCol = nodesListGetNode(((SGroupingSetNode*)pGroupKey)->pParameterList, 0); + SNode* pNew = NULL; + code = nodesCloneNode(pGroupCol, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pInfo->pScan->pGroupTags, pNew); + } + if (TSDB_CODE_SUCCESS == code) { + pNew = NULL; + code = nodesCloneNode(pGroupCol, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pInfo->pScan->pScanCols, pNew); + } + } + if (TSDB_CODE_SUCCESS == code) { + pNew = NULL; + code = nodesCloneNode(pGroupCol, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pInfo->pScan->node.pTargets, pNew); + } + } + if (TSDB_CODE_SUCCESS != code) { + break; + } } } return code; } static int32_t tbCntScanOptCreateSumFunc(SFunctionNode* pCntFunc, SNode* pParam, SNode** pOutput) { - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); + SFunctionNode* pFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); if (NULL == pFunc) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } strcpy(pFunc->functionName, "sum"); strcpy(pFunc->node.aliasName, pCntFunc->node.aliasName); - int32_t code = createColumnByRewriteExpr(pParam, &pFunc->pParameterList); + code = createColumnByRewriteExpr(pParam, &pFunc->pParameterList); if (TSDB_CODE_SUCCESS == code) { code = fmGetFuncInfo(pFunc, NULL, 0); } @@ -4988,14 +5406,23 @@ static SSortLogicNode* sortNonPriKeySatisfied(SLogicNode* pNode) { static bool sortNonPriKeyShouldOptimize(SLogicNode* pNode, void* pInfo) { SSortLogicNode* pSort = sortNonPriKeySatisfied(pNode); if (!pSort) return false; - SNodeList* pSortNodeList = pInfo; - nodesListAppend(pSortNodeList, (SNode*)pSort); + SOptimizePKCtx* ctx = pInfo; + ctx->code = nodesListAppend(ctx->pList, (SNode*)pSort); return false; } static int32_t sortNonPriKeyOptimize(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { - SNodeList* pNodeList = nodesMakeList(); - optFindEligibleNode(pLogicSubplan->pNode, sortNonPriKeyShouldOptimize, pNodeList); + SNodeList* pNodeList = NULL; + int32_t code = nodesMakeList(&pNodeList); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + SOptimizePKCtx ctx = {.pList = pNodeList, .code = 0}; + optFindEligibleNode(pLogicSubplan->pNode, sortNonPriKeyShouldOptimize, &ctx); + if (TSDB_CODE_SUCCESS != ctx.code) { + nodesClearList(pNodeList); + return code; + } SNode* pNode = NULL; FOREACH(pNode, pNodeList) { SSortLogicNode* pSort = (SSortLogicNode*)pNode; @@ -5056,7 +5483,11 @@ static int32_t hashJoinOptSplitPrimFromLogicCond(SNode **pCondition, SNode **pPr continue; } - code = nodesListMakeAppend(&pPrimaryKeyConds, nodesCloneNode(pCond)); + SNode* pNew = NULL; + code = nodesCloneNode(pCond, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeAppend(&pPrimaryKeyConds, pNew); + } if (TSDB_CODE_SUCCESS != code) { break; } @@ -5181,7 +5612,10 @@ static int32_t hashJoinOptRewriteJoin(SOptimizeContext* pCxt, SLogicNode* pNode, } #else SNode* pPrimaryKeyCond = NULL; - hashJoinOptSplitPrimCond(&pJoin->pColOnCond, &pPrimaryKeyCond); + code = hashJoinOptSplitPrimCond(&pJoin->pColOnCond, &pPrimaryKeyCond); + if (TSDB_CODE_SUCCESS != code) { + return code; + } if (NULL != pPrimaryKeyCond) { bool isStrict = false; code = getTimeRangeFromNode(&pPrimaryKeyCond, &pJoin->timeRange, &isStrict); @@ -5359,8 +5793,11 @@ int32_t stbJoinOptRewriteToTagScan(SLogicNode* pJoin, SNode* pNode) { pScan->node.requireDataOrder = DATA_ORDER_LEVEL_NONE; pScan->node.resultDataOrder = DATA_ORDER_LEVEL_NONE; - SNodeList* pTags = nodesMakeList(); - int32_t code = nodesCollectColumnsFromNode(pJoinNode->pTagEqCond, NULL, COLLECT_COL_TYPE_TAG, &pTags); + SNodeList* pTags = NULL; + int32_t code = nodesMakeList(&pTags); + if (TSDB_CODE_SUCCESS == code) { + code = nodesCollectColumnsFromNode(pJoinNode->pTagEqCond, NULL, COLLECT_COL_TYPE_TAG, &pTags); + } if (TSDB_CODE_SUCCESS == code) { code = nodesCollectColumnsFromNode(pJoinNode->pTagOnCond, NULL, COLLECT_COL_TYPE_TAG, &pTags); } @@ -5402,12 +5839,12 @@ int32_t stbJoinOptRewriteToTagScan(SLogicNode* pJoin, SNode* pNode) { } static int32_t stbJoinOptCreateTagScanNode(SLogicNode* pJoin, SNodeList** ppList) { - SNodeList* pList = nodesCloneList(pJoin->pChildren); + SNodeList* pList = NULL; + int32_t code = nodesCloneList(pJoin->pChildren, &pList); if (NULL == pList) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - int32_t code = TSDB_CODE_SUCCESS; SNode* pNode = NULL; FOREACH(pNode, pList) { code = stbJoinOptRewriteToTagScan(pJoin, pNode); @@ -5427,9 +5864,10 @@ static int32_t stbJoinOptCreateTagScanNode(SLogicNode* pJoin, SNodeList** ppList static int32_t stbJoinOptCreateTagHashJoinNode(SLogicNode* pOrig, SNodeList* pChildren, SLogicNode** ppLogic) { SJoinLogicNode* pOrigJoin = (SJoinLogicNode*)pOrig; - SJoinLogicNode* pJoin = (SJoinLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_JOIN); + SJoinLogicNode* pJoin = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_JOIN, (SNode**)&pJoin); if (NULL == pJoin) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pJoin->joinType = pOrigJoin->joinType; @@ -5441,10 +5879,17 @@ static int32_t stbJoinOptCreateTagHashJoinNode(SLogicNode* pOrig, SNodeList* pCh pJoin->node.groupAction = pOrigJoin->node.groupAction; pJoin->node.requireDataOrder = DATA_ORDER_LEVEL_NONE; pJoin->node.resultDataOrder = DATA_ORDER_LEVEL_NONE; - pJoin->pTagEqCond = nodesCloneNode(pOrigJoin->pTagEqCond); - pJoin->pTagOnCond = nodesCloneNode(pOrigJoin->pTagOnCond); + code = nodesCloneNode(pOrigJoin->pTagEqCond, &pJoin->pTagEqCond); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pJoin); + return code; + } + code = nodesCloneNode(pOrigJoin->pTagOnCond, &pJoin->pTagOnCond); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pJoin); + return code; + } - int32_t code = TSDB_CODE_SUCCESS; pJoin->node.pChildren = pChildren; SNode* pNode = NULL; @@ -5489,12 +5934,12 @@ static int32_t stbJoinOptCreateTagHashJoinNode(SLogicNode* pOrig, SNodeList* pCh } static int32_t stbJoinOptCreateTableScanNodes(SLogicNode* pJoin, SNodeList** ppList, bool* srcScan) { - SNodeList* pList = nodesCloneList(pJoin->pChildren); + SNodeList* pList = NULL; + int32_t code = nodesCloneList(pJoin->pChildren, &pList); if (NULL == pList) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - int32_t code = TSDB_CODE_SUCCESS; int32_t i = 0; SNode* pNode = NULL; FOREACH(pNode, pList) { @@ -5522,9 +5967,10 @@ static int32_t stbJoinOptCreateTableScanNodes(SLogicNode* pJoin, SNodeList** ppL static int32_t stbJoinOptCreateGroupCacheNode(SLogicNode* pRoot, SNodeList* pChildren, SLogicNode** ppLogic) { int32_t code = TSDB_CODE_SUCCESS; - SGroupCacheLogicNode* pGrpCache = (SGroupCacheLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_GROUP_CACHE); + SGroupCacheLogicNode* pGrpCache = NULL; + code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_GROUP_CACHE, (SNode**)&pGrpCache); if (NULL == pGrpCache) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } // pGrpCache->node.dynamicOp = true; @@ -5532,13 +5978,15 @@ static int32_t stbJoinOptCreateGroupCacheNode(SLogicNode* pRoot, SNodeList* pChi pGrpCache->grpByUid = true; pGrpCache->batchFetch = getBatchScanOptionFromHint(pRoot->pHint); pGrpCache->node.pChildren = pChildren; - pGrpCache->node.pTargets = nodesMakeList(); - if (NULL == pGrpCache->node.pTargets) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + pGrpCache->node.pTargets = NULL; + code = nodesMakeList(&pGrpCache->node.pTargets); if (TSDB_CODE_SUCCESS == code) { SScanLogicNode* pScan = (SScanLogicNode*)nodesListGetNode(pChildren, 0); - code = nodesListStrictAppendList(pGrpCache->node.pTargets, nodesCloneList(pScan->node.pTargets)); + SNodeList* pNewList = NULL; + code = nodesCloneList(pScan->node.pTargets, &pNewList); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppendList(pGrpCache->node.pTargets, pNewList); + } } SScanLogicNode* pScan = (SScanLogicNode*)nodesListGetNode(pChildren, 0); @@ -5609,9 +6057,10 @@ static void stbJoinOptRemoveTagEqCond(SJoinLogicNode* pJoin) { static int32_t stbJoinOptCreateMergeJoinNode(SLogicNode* pOrig, SLogicNode* pChild, SLogicNode** ppLogic) { SJoinLogicNode* pOrigJoin = (SJoinLogicNode*)pOrig; - SJoinLogicNode* pJoin = (SJoinLogicNode*)nodesCloneNode((SNode*)pOrig); + SJoinLogicNode* pJoin = NULL; + int32_t code = nodesCloneNode((SNode*)pOrig, (SNode**)&pJoin); if (NULL == pJoin) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pJoin->joinAlgo = JOIN_ALGO_MERGE; @@ -5622,7 +6071,7 @@ static int32_t stbJoinOptCreateMergeJoinNode(SLogicNode* pOrig, SLogicNode* pChi SNode* pNode = NULL; FOREACH(pNode, pJoin->node.pChildren) { ERASE_NODE(pJoin->node.pChildren); } - int32_t code = nodesListStrictAppend(pJoin->node.pChildren, (SNode*)pChild); + code = nodesListStrictAppend(pJoin->node.pChildren, (SNode*)pChild); if (TSDB_CODE_SUCCESS == code) { pChild->pParent = (SLogicNode*)pJoin; *ppLogic = (SLogicNode*)pJoin; @@ -5637,9 +6086,10 @@ static int32_t stbJoinOptCreateMergeJoinNode(SLogicNode* pOrig, SLogicNode* pChi static int32_t stbJoinOptCreateDynQueryCtrlNode(SLogicNode* pRoot, SLogicNode* pPrev, SLogicNode* pPost, bool* srcScan, SLogicNode** ppDynNode) { int32_t code = TSDB_CODE_SUCCESS; - SDynQueryCtrlLogicNode* pDynCtrl = (SDynQueryCtrlLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL); + SDynQueryCtrlLogicNode* pDynCtrl = NULL; + code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_DYN_QUERY_CTRL, (SNode**)&pDynCtrl); if (NULL == pDynCtrl) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pDynCtrl->qType = DYN_QTYPE_STB_HASH; @@ -5647,23 +6097,26 @@ static int32_t stbJoinOptCreateDynQueryCtrlNode(SLogicNode* pRoot, SLogicNode* p memcpy(pDynCtrl->stbJoin.srcScan, srcScan, sizeof(pDynCtrl->stbJoin.srcScan)); if (TSDB_CODE_SUCCESS == code) { - pDynCtrl->node.pChildren = nodesMakeList(); + pDynCtrl->node.pChildren = NULL; + code = nodesMakeList(&pDynCtrl->node.pChildren); if (NULL == pDynCtrl->node.pChildren) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = code; } } if (TSDB_CODE_SUCCESS == code) { - pDynCtrl->stbJoin.pVgList = nodesMakeList(); + pDynCtrl->stbJoin.pVgList = NULL; + code = nodesMakeList(&pDynCtrl->stbJoin.pVgList); if (NULL == pDynCtrl->stbJoin.pVgList) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = code; } } if (TSDB_CODE_SUCCESS == code) { - pDynCtrl->stbJoin.pUidList = nodesMakeList(); + pDynCtrl->stbJoin.pUidList = NULL; + code = nodesMakeList(&pDynCtrl->stbJoin.pUidList); if (NULL == pDynCtrl->stbJoin.pUidList) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = code; } } @@ -5679,9 +6132,10 @@ static int32_t stbJoinOptCreateDynQueryCtrlNode(SLogicNode* pRoot, SLogicNode* p code = nodesListStrictAppend(pDynCtrl->node.pChildren, (SNode*)pPost); } if (TSDB_CODE_SUCCESS == code) { - pDynCtrl->node.pTargets = nodesCloneList(pPost->pTargets); + pDynCtrl->node.pTargets = NULL; + code = nodesCloneList(pPost->pTargets, &pDynCtrl->node.pTargets); if (!pDynCtrl->node.pTargets) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = code; } } } @@ -5761,30 +6215,39 @@ static bool grpJoinOptShouldBeOptimized(SLogicNode* pNode) { } static int32_t grpJoinOptCreatePartitionNode(SLogicNode* pParent, SLogicNode* pChild, bool leftChild, SLogicNode** pNew) { - SPartitionLogicNode* pPartition = (SPartitionLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PARTITION); + SPartitionLogicNode* pPartition = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_PARTITION, (SNode**)&pPartition); if (NULL == pPartition) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pPartition->node.groupAction = GROUP_ACTION_SET; pPartition->node.requireDataOrder = DATA_ORDER_LEVEL_GLOBAL; pPartition->node.resultDataOrder = DATA_ORDER_LEVEL_IN_GROUP; - pPartition->node.pTargets = nodesCloneList(pChild->pTargets); + pPartition->node.pTargets = NULL; + code = nodesCloneList(pChild->pTargets, &pPartition->node.pTargets); if (NULL == pPartition->node.pTargets) { nodesDestroyNode((SNode*)pPartition); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } SJoinLogicNode* pJoin = (SJoinLogicNode*)pParent; - pPartition->pPartitionKeys = nodesCloneList(leftChild ? pJoin->pLeftEqNodes : pJoin->pRightEqNodes); - pChild->pParent = (SLogicNode*)pPartition; - pPartition->node.pParent = pParent; - nodesListMakeStrictAppend(&pPartition->node.pChildren, (SNode *)pChild); - - *pNew = (SLogicNode*)pPartition; - - return TSDB_CODE_SUCCESS; + pPartition->pPartitionKeys = NULL; + code = nodesCloneList(leftChild ? pJoin->pLeftEqNodes : pJoin->pRightEqNodes, &pPartition->pPartitionKeys); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pPartition); + return code; + } + code = nodesListMakeStrictAppend(&pPartition->node.pChildren, (SNode *)pChild); + if (TSDB_CODE_SUCCESS == code) { + *pNew = (SLogicNode*)pPartition; + pChild->pParent = (SLogicNode*)pPartition; + pPartition->node.pParent = pParent; + } else { + nodesDestroyNode((SNode*)pPartition); + } + return code; } static int32_t grpJoinOptInsertPartitionNode(SLogicNode* pJoin) { @@ -5816,11 +6279,18 @@ static int32_t grpJoinOptPartByTags(SLogicNode* pNode) { } SScanLogicNode* pScan = (SScanLogicNode*)pChild; - if (leftChild) { - nodesListMakeStrictAppendList(&pScan->pGroupTags, nodesCloneList(pJoin->pLeftEqNodes)); - leftChild = false; - } else { - nodesListMakeStrictAppendList(&pScan->pGroupTags, nodesCloneList(pJoin->pRightEqNodes)); + SNodeList* pNewList = NULL; + code = nodesCloneList(pJoin->pLeftEqNodes, &pNewList); + if (TSDB_CODE_SUCCESS == code) { + if (leftChild) { + nodesListMakeStrictAppendList(&pScan->pGroupTags, pNewList); + leftChild = false; + } else { + nodesListMakeStrictAppendList(&pScan->pGroupTags, pNewList); + } + } + if (TSDB_CODE_SUCCESS != code) { + break; } pScan->groupSort = true; @@ -5858,58 +6328,69 @@ static bool partColOptShouldBeOptimized(SLogicNode* pNode) { return false; } -static SSortLogicNode* partColOptCreateSort(SPartitionLogicNode* pPartition) { +static int32_t partColOptCreateSort(SPartitionLogicNode* pPartition, SSortLogicNode** ppSort) { SNode* node; int32_t code = TSDB_CODE_SUCCESS; - SSortLogicNode* pSort = (SSortLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT); + SSortLogicNode* pSort = NULL; + code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_SORT, (SNode**)&pSort); if (pSort) { bool alreadyPartByPKTs = false; pSort->groupSort = false; FOREACH(node, pPartition->pPartitionKeys) { - SOrderByExprNode* pOrder = (SOrderByExprNode*)nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR); + SOrderByExprNode* pOrder = NULL; + code = nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR, (SNode**)&pOrder); + if (TSDB_CODE_SUCCESS != code) { + break; + } if (QUERY_NODE_COLUMN == nodeType(node) && ((SColumnNode*)node)->colId == pPartition->pkTsColId && ((SColumnNode*)node)->tableId == pPartition->pkTsColTbId) alreadyPartByPKTs = true; - if (!pOrder) { - code = TSDB_CODE_OUT_OF_MEMORY; - } else { - nodesListMakeAppend(&pSort->pSortKeys, (SNode*)pOrder); + code = nodesListMakeStrictAppend(&pSort->pSortKeys, (SNode*)pOrder); + if (TSDB_CODE_SUCCESS == code) { pOrder->order = ORDER_ASC; - pOrder->pExpr = nodesCloneNode(node); + pOrder->pExpr = NULL; pOrder->nullOrder = NULL_ORDER_FIRST; - if (!pOrder->pExpr) code = TSDB_CODE_OUT_OF_MEMORY; + code = nodesCloneNode(node, &pOrder->pExpr); } + if (TSDB_CODE_SUCCESS != code) { + break; + } + } + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pSort); + return code; } if (pPartition->needBlockOutputTsOrder && !alreadyPartByPKTs) { - SOrderByExprNode* pOrder = (SOrderByExprNode*)nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR); - if (!pOrder) { - code = TSDB_CODE_OUT_OF_MEMORY; - } else { + SOrderByExprNode* pOrder = NULL; + code = nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR, (SNode**)&pOrder); + if (pOrder) { pSort->excludePkCol = true; - nodesListMakeAppend(&pSort->pSortKeys, (SNode*)pOrder); - pOrder->order = ORDER_ASC; - pOrder->pExpr = 0; - FOREACH(node, pPartition->node.pTargets) { - if (nodeType(node) == QUERY_NODE_COLUMN) { - SColumnNode* pCol = (SColumnNode*)node; - if (pCol->colId == pPartition->pkTsColId && pCol->tableId == pPartition->pkTsColTbId) { - pOrder->pExpr = nodesCloneNode((SNode*)pCol); - break; + code = nodesListMakeStrictAppend(&pSort->pSortKeys, (SNode*)pOrder); + if (TSDB_CODE_SUCCESS == code) { + pOrder->order = ORDER_ASC; + pOrder->pExpr = 0; + FOREACH(node, pPartition->node.pTargets) { + if (nodeType(node) == QUERY_NODE_COLUMN) { + SColumnNode* pCol = (SColumnNode*)node; + if (pCol->colId == pPartition->pkTsColId && pCol->tableId == pPartition->pkTsColTbId) { + pOrder->pExpr = NULL; + code = nodesCloneNode((SNode*)pCol, &pOrder->pExpr); + break; + } } } } - if (!pOrder->pExpr) { - code = TSDB_CODE_PAR_INTERNAL_ERROR; - } } } } if (code != TSDB_CODE_SUCCESS) { nodesDestroyNode((SNode*)pSort); pSort = NULL; + } else { + *ppSort = pSort; } - return pSort; + return code; } static int32_t partitionColsOpt(SOptimizeContext* pCxt, SLogicSubplan* pLogicSubplan) { @@ -5922,7 +6403,8 @@ static int32_t partitionColsOpt(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub if (pRootNode->pHint && getSortForGroupOptHint(pRootNode->pHint)) { // replace with sort node - SSortLogicNode* pSort = partColOptCreateSort(pNode); + SSortLogicNode* pSort = NULL; + code = partColOptCreateSort(pNode, &pSort); if (!pSort) { // if sort create failed, we eat the error, skip the optimization code = TSDB_CODE_SUCCESS; @@ -5944,15 +6426,19 @@ static int32_t partitionColsOpt(SOptimizeContext* pCxt, SLogicSubplan* pLogicSub // Check if we can delete partition node SAggLogicNode* pAgg = (SAggLogicNode*)pNode->node.pParent; FOREACH(node, pNode->pPartitionKeys) { - SGroupingSetNode* pgsNode = (SGroupingSetNode*)nodesMakeNode(QUERY_NODE_GROUPING_SET); - if (!pgsNode) code = TSDB_CODE_OUT_OF_MEMORY; + SGroupingSetNode* pgsNode = NULL; + code = nodesMakeNode(QUERY_NODE_GROUPING_SET, (SNode**)&pgsNode); if (code == TSDB_CODE_SUCCESS) { pgsNode->groupingSetType = GP_TYPE_NORMAL; - pgsNode->pParameterList = nodesMakeList(); - if (!pgsNode->pParameterList) code = TSDB_CODE_OUT_OF_MEMORY; + pgsNode->pParameterList = NULL; + code = nodesMakeList(&pgsNode->pParameterList); } if (code == TSDB_CODE_SUCCESS) { - code = nodesListAppend(pgsNode->pParameterList, nodesCloneNode(node)); + SNode* pNew = NULL; + code = nodesCloneNode(node, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pgsNode->pParameterList, pNew); + } } if (code == TSDB_CODE_SUCCESS) { // Now we are using hash agg @@ -6358,7 +6844,7 @@ static void tsmaOptSplitWindows(STSMAOptCtx* pTsmaOptCtx, const STimeWindow* pSc } } -SNodeList* tsmaOptCreateTsmaScanCols(const STSMAOptUsefulTsma* pTsma, const SNodeList* pAggFuncs) { +int32_t tsmaOptCreateTsmaScanCols(const STSMAOptUsefulTsma* pTsma, const SNodeList* pAggFuncs, SNodeList** ppList) { ASSERT(pTsma->pTsma); ASSERT(pTsma->pTsmaScanCols); int32_t code; @@ -6373,7 +6859,8 @@ SNodeList* tsmaOptCreateTsmaScanCols(const STSMAOptUsefulTsma* pTsma, const SNod continue; } const int32_t* idx = taosArrayGet(pTsma->pTsmaScanCols, i); - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + SColumnNode* pCol = NULL; + code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); if (pCol) { pCol->colId = *idx + 2; pCol->tableType = TSDB_SUPER_TABLE; @@ -6385,8 +6872,6 @@ SNodeList* tsmaOptCreateTsmaScanCols(const STSMAOptUsefulTsma* pTsma, const SNod strcpy(pCol->node.aliasName, pFunc->node.aliasName); pCol->node.resType.type = TSDB_DATA_TYPE_BINARY; code = nodesListMakeStrictAppend(&pScanCols, (SNode*)pCol); - } else { - code = TSDB_CODE_OUT_OF_MEMORY; } if (code) break; ++i; @@ -6395,8 +6880,10 @@ SNodeList* tsmaOptCreateTsmaScanCols(const STSMAOptUsefulTsma* pTsma, const SNod if (code) { nodesDestroyList(pScanCols); pScanCols = NULL; + } else { + *ppList = pScanCols; } - return pScanCols; + return code; } static int32_t tsmaOptRewriteTag(const STSMAOptCtx* pTsmaOptCtx, const STSMAOptUsefulTsma* pTsma, @@ -6422,9 +6909,9 @@ static int32_t tsmaOptRewriteTag(const STSMAOptCtx* pTsmaOptCtx, const STSMAOptU static int32_t tsmaOptRewriteTbname(const STSMAOptCtx* pTsmaOptCtx, SNode** pTbNameNode, const STSMAOptUsefulTsma* pTsma) { int32_t code = 0; - SExprNode* pRewrittenFunc = (SExprNode*)nodesMakeNode(pTsma ? QUERY_NODE_COLUMN : QUERY_NODE_FUNCTION); + SExprNode* pRewrittenFunc = NULL; + code = nodesMakeNode(pTsma ? QUERY_NODE_COLUMN : QUERY_NODE_FUNCTION, (SNode**)&pRewrittenFunc); SValueNode* pValue = NULL; - if (!pRewrittenFunc) code = TSDB_CODE_OUT_OF_MEMORY; if (code == TSDB_CODE_SUCCESS) { pRewrittenFunc->resType = ((SExprNode*)(*pTbNameNode))->resType; } @@ -6444,7 +6931,7 @@ static int32_t tsmaOptRewriteTbname(const STSMAOptCtx* pTsmaOptCtx, SNode** pTbN SFunctionNode* pFunc = (SFunctionNode*)pRewrittenFunc; pFunc->funcId = fmGetFuncId("concat"); snprintf(pFunc->functionName, TSDB_FUNC_NAME_LEN, "concat"); - pValue = (SValueNode*)nodesMakeNode(QUERY_NODE_VALUE); + code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&pValue); if (!pValue) code = TSDB_CODE_OUT_OF_MEMORY; if (code == TSDB_CODE_SUCCESS) { @@ -6537,24 +7024,26 @@ static int32_t tsmaOptRewriteScan(STSMAOptCtx* pTsmaOptCtx, SScanLogicNode* pNew SColumnNode* pCol = (SColumnNode*)pNode; ASSERT(pTsma->pTsmaScanCols); if (pCol->colId == PRIMARYKEY_TIMESTAMP_COL_ID) { - pPkTsCol = (SColumnNode*)nodesCloneNode((SNode*)pCol); - if (!pPkTsCol) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + pPkTsCol = NULL; + code = nodesCloneNode((SNode*)pCol, (SNode**)&pPkTsCol); break; } } if (code == TSDB_CODE_SUCCESS) { nodesDestroyList(pNewScan->pScanCols); // normal cols - pNewScan->pScanCols = tsmaOptCreateTsmaScanCols(pTsma, pTsmaOptCtx->pAggFuncs); - if (!pNewScan->pScanCols) code = TSDB_CODE_OUT_OF_MEMORY; + pNewScan->pScanCols = NULL; + code = tsmaOptCreateTsmaScanCols(pTsma, pTsmaOptCtx->pAggFuncs, &pNewScan->pScanCols); } if (code == TSDB_CODE_SUCCESS && pPkTsCol) { tstrncpy(pPkTsCol->tableName, pTsma->targetTbName, TSDB_TABLE_NAME_LEN); tstrncpy(pPkTsCol->tableAlias, pTsma->targetTbName, TSDB_TABLE_NAME_LEN); pPkTsCol->tableId = pTsma->targetTbUid; - nodesListMakeStrictAppend(&pNewScan->pScanCols, nodesCloneNode((SNode*)pPkTsCol)); + SNode* pNew = NULL; + code = nodesCloneNode((SNode*)pPkTsCol, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pNewScan->pScanCols, pNew); + } } if (code == TSDB_CODE_SUCCESS) { pNewScan->stableId = pTsma->pTsma->destTbUid; @@ -6601,9 +7090,10 @@ static int32_t tsmaOptRewriteScan(STSMAOptCtx* pTsmaOptCtx, SScanLogicNode* pNew } static int32_t tsmaOptCreateWStart(int8_t precision, SFunctionNode** pWStartOut) { - SFunctionNode* pWStart = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); + SFunctionNode* pWStart = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pWStart); if (NULL == pWStart) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } strcpy(pWStart->functionName, "_wstart"); int64_t pointer = (int64_t)pWStart; @@ -6613,7 +7103,7 @@ static int32_t tsmaOptCreateWStart(int8_t precision, SFunctionNode** pWStartOut) strncpy(pWStart->node.aliasName, name, TSDB_COL_NAME_LEN - 1); pWStart->node.resType.precision = precision; - int32_t code = fmGetFuncInfo(pWStart, NULL, 0); + code = fmGetFuncInfo(pWStart, NULL, 0); if (code) { nodesDestroyNode((SNode*)pWStart); } else { @@ -6652,6 +7142,7 @@ static int32_t tsmaOptRewriteParent(STSMAOptCtx* pTsmaOptCtx, SLogicNode* pParen nodesRewriteExpr(&pAggFuncNode, tsmaOptNodeRewriter, &ctx); if (ctx.code) { code = ctx.code; + break; } else { REPLACE_NODE(pAggFuncNode); } @@ -6667,9 +7158,17 @@ static int32_t tsmaOptRewriteParent(STSMAOptCtx* pTsmaOptCtx, SLogicNode* pParen pColNode->node.resType = pPartial->node.resType; // currently we assume that the first parameter must be the scan column nodesListErase(pMerge->pParameterList, pMerge->pParameterList->pHead); - nodesListPushFront(pMerge->pParameterList, nodesCloneNode((SNode*)pColNode)); - + SNode* pNew = NULL; + code = nodesCloneNode((SNode*)pColNode, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListPushFront(pMerge->pParameterList, pNew); + } nodesDestroyNode((SNode*)pPartial); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode(pNew); + break; + } + REPLACE_NODE(pMerge); } @@ -6677,7 +7176,8 @@ static int32_t tsmaOptRewriteParent(STSMAOptCtx* pTsmaOptCtx, SLogicNode* pParen SColumnNode* pCol = (SColumnNode*)pScan->pScanCols->pTail->pNode; assert(pCol->colId == PRIMARYKEY_TIMESTAMP_COL_ID); nodesDestroyNode(pWindow->pTspk); - pWindow->pTspk = nodesCloneNode((SNode*)pCol); + pWindow->pTspk = NULL; + code = nodesCloneNode((SNode*)pCol, &pWindow->pTspk); } if (code == TSDB_CODE_SUCCESS) { @@ -6717,17 +7217,17 @@ static int32_t tsmaOptGeneratePlan(STSMAOptCtx* pTsmaOptCtx) { for (int32_t i = 1; i < pTsmaOptCtx->pUsedTsmas->size && code == TSDB_CODE_SUCCESS; ++i) { pTsma = taosArrayGet(pTsmaOptCtx->pUsedTsmas, i); - SLogicSubplan* pSubplan = (SLogicSubplan*)nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN); + SLogicSubplan* pSubplan = NULL; + code = nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN, (SNode**)&pSubplan); if (!pSubplan) { - code = TSDB_CODE_OUT_OF_MEMORY; break; } pSubplan->subplanType = SUBPLAN_TYPE_SCAN; pTsmaOptCtx->generatedSubPlans[i - 1] = pSubplan; hasSubPlan = true; - SLogicNode* pParent = (SLogicNode*)nodesCloneNode((SNode*)pTsmaOptCtx->pParent); + SLogicNode* pParent = NULL; + code = nodesCloneNode((SNode*)pTsmaOptCtx->pParent, (SNode**)&pParent); if (!pParent) { - code = TSDB_CODE_OUT_OF_MEMORY; break; } pSubplan->pNode = pParent; diff --git a/source/libs/planner/src/planPhysiCreater.c b/source/libs/planner/src/planPhysiCreater.c index 1b896e03c3..584cefe4d3 100644 --- a/source/libs/planner/src/planPhysiCreater.c +++ b/source/libs/planner/src/planPhysiCreater.c @@ -82,8 +82,10 @@ static int32_t getSlotKey(SNode* pNode, const char* pStmtName, char* pKey, int32 static SNode* createSlotDesc(SPhysiPlanContext* pCxt, const char* pName, const SNode* pNode, int16_t slotId, bool output, bool reserve) { - SSlotDescNode* pSlot = (SSlotDescNode*)nodesMakeNode(QUERY_NODE_SLOT_DESC); + SSlotDescNode* pSlot = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_SLOT_DESC, (SNode**)&pSlot); if (NULL == pSlot) { + terrno = code; return NULL; } snprintf(pSlot->name, sizeof(pSlot->name), "%s", pName); @@ -95,9 +97,10 @@ static SNode* createSlotDesc(SPhysiPlanContext* pCxt, const char* pName, const S } static int32_t createTarget(SNode* pNode, int16_t dataBlockId, int16_t slotId, SNode** pOutput) { - STargetNode* pTarget = (STargetNode*)nodesMakeNode(QUERY_NODE_TARGET); + STargetNode* pTarget = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_TARGET, (SNode**)&pTarget); if (NULL == pTarget) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pTarget->dataBlockId = dataBlockId; @@ -146,12 +149,12 @@ static int32_t createDataBlockDescHash(SPhysiPlanContext* pCxt, int32_t capacity static int32_t buildDataBlockSlots(SPhysiPlanContext* pCxt, SNodeList* pList, SDataBlockDescNode* pDataBlockDesc, SHashObj* pHash) { - pDataBlockDesc->pSlots = nodesMakeList(); + pDataBlockDesc->pSlots = NULL; + int32_t code = nodesMakeList(&pDataBlockDesc->pSlots); if (NULL == pDataBlockDesc->pSlots) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - int32_t code = TSDB_CODE_SUCCESS; int16_t slotId = 0; SNode* pNode = NULL; FOREACH(pNode, pList) { @@ -173,14 +176,15 @@ static int32_t buildDataBlockSlots(SPhysiPlanContext* pCxt, SNodeList* pList, SD } static int32_t createDataBlockDesc(SPhysiPlanContext* pCxt, SNodeList* pList, SDataBlockDescNode** pDataBlockDesc) { - SDataBlockDescNode* pDesc = (SDataBlockDescNode*)nodesMakeNode(QUERY_NODE_DATABLOCK_DESC); + SDataBlockDescNode* pDesc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_DATABLOCK_DESC, (SNode**)&pDesc); if (NULL == pDesc) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pDesc->dataBlockId = pCxt->nextDataBlockId++; SHashObj* pHash = NULL; - int32_t code = createDataBlockDescHash(pCxt, LIST_LENGTH(pList), pDesc->dataBlockId, &pHash); + code = createDataBlockDescHash(pCxt, LIST_LENGTH(pList), pDesc->dataBlockId, &pHash); if (TSDB_CODE_SUCCESS == code) { code = buildDataBlockSlots(pCxt, pList, pDesc, pHash); } @@ -334,9 +338,10 @@ static int32_t setNodeSlotId(SPhysiPlanContext* pCxt, int16_t leftDataBlockId, i return TSDB_CODE_SUCCESS; } - SNode* pRes = nodesCloneNode(pNode); + SNode* pRes = NULL; + int32_t code = nodesCloneNode(pNode, &pRes); if (NULL == pRes) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } SSetSlotIdCxt cxt = { @@ -359,9 +364,10 @@ static int32_t setListSlotId(SPhysiPlanContext* pCxt, int16_t leftDataBlockId, i return TSDB_CODE_SUCCESS; } - SNodeList* pRes = nodesCloneList(pList); + SNodeList* pRes = NULL; + int32_t code = nodesCloneList(pList, &pRes); if (NULL == pRes) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } SSetSlotIdCxt cxt = { @@ -378,8 +384,10 @@ static int32_t setListSlotId(SPhysiPlanContext* pCxt, int16_t leftDataBlockId, i } static SPhysiNode* makePhysiNode(SPhysiPlanContext* pCxt, SLogicNode* pLogicNode, ENodeType type) { - SPhysiNode* pPhysiNode = (SPhysiNode*)nodesMakeNode(type); + SPhysiNode* pPhysiNode = NULL; + int32_t code = nodesMakeNode(type, (SNode**)&pPhysiNode); if (NULL == pPhysiNode) { + terrno = code; return NULL; } @@ -389,9 +397,10 @@ static SPhysiNode* makePhysiNode(SPhysiPlanContext* pCxt, SLogicNode* pLogicNode pPhysiNode->inputTsOrder = pLogicNode->inputTsOrder; pPhysiNode->outputTsOrder = pLogicNode->outputTsOrder; - int32_t code = createDataBlockDesc(pCxt, pLogicNode->pTargets, &pPhysiNode->pOutputDataBlockDesc); + code = createDataBlockDesc(pCxt, pLogicNode->pTargets, &pPhysiNode->pOutputDataBlockDesc); if (TSDB_CODE_SUCCESS != code) { nodesDestroyNode((SNode*)pPhysiNode); + terrno = code; return NULL; } pPhysiNode->pOutputDataBlockDesc->precision = pLogicNode->precision; @@ -418,8 +427,18 @@ static int32_t sortScanCols(SNodeList* pScanCols) { return TSDB_CODE_OUT_OF_MEMORY; } + int32_t code = 0; SNode* pCol = NULL; - FOREACH(pCol, pScanCols) { taosArrayPush(pArray, &pCol); } + FOREACH(pCol, pScanCols) { + if (NULL == taosArrayPush(pArray, &pCol)) { + code = TSDB_CODE_OUT_OF_MEMORY; + break; + } + } + if (TSDB_CODE_SUCCESS != code) { + taosArrayDestroy(pArray); + return code; + } taosArraySort(pArray, colIdCompare); int32_t index = 0; @@ -434,9 +453,10 @@ static int32_t createScanCols(SPhysiPlanContext* pCxt, SScanPhysiNode* pScanPhys return TSDB_CODE_SUCCESS; } - pScanPhysiNode->pScanCols = nodesCloneList(pScanCols); + pScanPhysiNode->pScanCols = NULL; + int32_t code = nodesCloneList(pScanCols, &pScanPhysiNode->pScanCols); if (NULL == pScanPhysiNode->pScanCols) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } return sortScanCols(pScanPhysiNode->pScanCols); } @@ -449,9 +469,10 @@ static int32_t createScanPhysiNodeFinalize(SPhysiPlanContext* pCxt, SSubplan* pS } if (TSDB_CODE_SUCCESS == code && NULL != pScanLogicNode->pScanPseudoCols) { - pScanPhysiNode->pScanPseudoCols = nodesCloneList(pScanLogicNode->pScanPseudoCols); + pScanPhysiNode->pScanPseudoCols = NULL; + code = nodesCloneList(pScanLogicNode->pScanPseudoCols, &pScanPhysiNode->pScanPseudoCols); if (NULL == pScanPhysiNode->pScanPseudoCols) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = code; } } @@ -470,18 +491,20 @@ static int32_t createScanPhysiNodeFinalize(SPhysiPlanContext* pCxt, SSubplan* pS pScanPhysiNode->groupOrderScan = pScanLogicNode->groupOrderScan; memcpy(&pScanPhysiNode->tableName, &pScanLogicNode->tableName, sizeof(SName)); if (NULL != pScanLogicNode->pTagCond) { - pSubplan->pTagCond = nodesCloneNode(pScanLogicNode->pTagCond); + pSubplan->pTagCond = NULL; + code = nodesCloneNode(pScanLogicNode->pTagCond, &pSubplan->pTagCond); if (NULL == pSubplan->pTagCond) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = code; } } } if (TSDB_CODE_SUCCESS == code) { if (NULL != pScanLogicNode->pTagIndexCond) { - pSubplan->pTagIndexCond = nodesCloneNode(pScanLogicNode->pTagIndexCond); + pSubplan->pTagIndexCond = NULL; + code = nodesCloneNode(pScanLogicNode->pTagIndexCond, &pSubplan->pTagIndexCond); if (NULL == pSubplan->pTagIndexCond) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = code; } } } @@ -525,7 +548,7 @@ static int32_t createSimpleScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSub SScanPhysiNode* pScan = (SScanPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pScanLogicNode, getScanOperatorType(pScanLogicNode->scanType)); if (NULL == pScan) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } if (pScanLogicNode->pVgroupList) { @@ -539,7 +562,7 @@ static int32_t createTagScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSubpla STagScanPhysiNode* pScan = (STagScanPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pScanLogicNode, QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN); if (NULL == pScan) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } if (pScanLogicNode->pVgroupList) { vgroupInfoToNodeAddr(pScanLogicNode->pVgroupList->vgroups, &pSubplan->execNode); @@ -554,14 +577,19 @@ static int32_t createLastRowScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSu SLastRowScanPhysiNode* pScan = (SLastRowScanPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pScanLogicNode, QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN); if (NULL == pScan) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } - pScan->pTargets = nodesCloneList(pScanLogicNode->node.pTargets); - - pScan->pGroupTags = nodesCloneList(pScanLogicNode->pGroupTags); - if (NULL != pScanLogicNode->pGroupTags && NULL == pScan->pGroupTags) { + pScan->pTargets = NULL; + int32_t code = nodesCloneList(pScanLogicNode->node.pTargets, &pScan->pTargets); + if (TSDB_CODE_SUCCESS != code) { nodesDestroyNode((SNode*)pScan); - return TSDB_CODE_OUT_OF_MEMORY; + return code; + } + pScan->pGroupTags = NULL; + code = nodesCloneList(pScanLogicNode->pGroupTags, &pScan->pGroupTags); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pScan); + return code; } pScan->groupSort = pScanLogicNode->groupSort; @@ -571,7 +599,7 @@ static int32_t createLastRowScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSu vgroupInfoToNodeAddr(pScanLogicNode->pVgroupList->vgroups, &pSubplan->execNode); } - int32_t code = createScanPhysiNodeFinalize(pCxt, pSubplan, pScanLogicNode, (SScanPhysiNode*)pScan, pPhyNode); + code = createScanPhysiNodeFinalize(pCxt, pSubplan, pScanLogicNode, (SScanPhysiNode*)pScan, pPhyNode); if (TSDB_CODE_SUCCESS == code && pScanLogicNode->pFuncTypes != NULL) { pScan->pFuncTypes = taosArrayInit(taosArrayGetSize(pScanLogicNode->pFuncTypes), sizeof(int32_t)); if (NULL == pScan->pFuncTypes) { @@ -590,7 +618,9 @@ static int32_t createLastRowScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSu SFunctParam* pFunctParam = taosArrayGet(pScanLogicNode->pFuncTypes, i); if (pColNode->colId == pFunctParam->pCol->colId && 0 == strncmp(pColNode->colName, pFunctParam->pCol->name, strlen(pColNode->colName))) { - taosArrayInsert(pScan->pFuncTypes, funcTypeIndex, &pFunctParam->type); + if (NULL == taosArrayInsert(pScan->pFuncTypes, funcTypeIndex, &pFunctParam->type)) { + code = TSDB_CODE_OUT_OF_MEMORY; + } break; } } @@ -605,13 +635,14 @@ static int32_t createTableCountScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* STableCountScanPhysiNode* pScan = (STableCountScanPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pScanLogicNode, QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN); if (NULL == pScan) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } - pScan->pGroupTags = nodesCloneList(pScanLogicNode->pGroupTags); + pScan->pGroupTags = NULL; + int32_t code = nodesCloneList(pScanLogicNode->pGroupTags, &pScan->pGroupTags); if (NULL != pScanLogicNode->pGroupTags && NULL == pScan->pGroupTags) { nodesDestroyNode((SNode*)pScan); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pScan->groupSort = pScanLogicNode->groupSort; @@ -626,7 +657,7 @@ static int32_t createTableScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSubp STableScanPhysiNode* pTableScan = (STableScanPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pScanLogicNode, getScanOperatorType(pScanLogicNode->scanType)); if (NULL == pTableScan) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } memcpy(pTableScan->scanSeq, pScanLogicNode->scanSeq, sizeof(pScanLogicNode->scanSeq)); @@ -636,14 +667,19 @@ static int32_t createTableScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSubp vgroupInfoToNodeAddr(pScanLogicNode->pVgroupList->vgroups, &pSubplan->execNode); pSubplan->execNodeStat.tableNum = pScanLogicNode->pVgroupList->vgroups[0].numOfTable; } - tNameGetFullDbName(&pScanLogicNode->tableName, pSubplan->dbFName); + (void)tNameGetFullDbName(&pScanLogicNode->tableName, pSubplan->dbFName); pTableScan->dataRequired = pScanLogicNode->dataRequired; - pTableScan->pDynamicScanFuncs = nodesCloneList(pScanLogicNode->pDynamicScanFuncs); - pTableScan->pGroupTags = nodesCloneList(pScanLogicNode->pGroupTags); - if ((NULL != pScanLogicNode->pDynamicScanFuncs && NULL == pTableScan->pDynamicScanFuncs) || - (NULL != pScanLogicNode->pGroupTags && NULL == pTableScan->pGroupTags)) { + pTableScan->pDynamicScanFuncs = NULL; + int32_t code = nodesCloneList(pScanLogicNode->pDynamicScanFuncs, &pTableScan->pDynamicScanFuncs); + if (TSDB_CODE_SUCCESS != code) { nodesDestroyNode((SNode*)pTableScan); - return TSDB_CODE_OUT_OF_MEMORY; + return code; + } + pTableScan->pGroupTags = NULL; + code = nodesCloneList(pScanLogicNode->pGroupTags, &pTableScan->pGroupTags); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pTableScan); + return code; } pTableScan->groupSort = pScanLogicNode->groupSort; pTableScan->interval = pScanLogicNode->interval; @@ -661,7 +697,7 @@ static int32_t createTableScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* pSubp pTableScan->paraTablesSort = pScanLogicNode->paraTablesSort; pTableScan->smallDataTsSort = pScanLogicNode->smallDataTsSort; - int32_t code = createScanPhysiNodeFinalize(pCxt, pSubplan, pScanLogicNode, (SScanPhysiNode*)pTableScan, pPhyNode); + code = createScanPhysiNodeFinalize(pCxt, pSubplan, pScanLogicNode, (SScanPhysiNode*)pTableScan, pPhyNode); if (TSDB_CODE_SUCCESS == code) { code = setListSlotId(pCxt, pTableScan->scan.node.pOutputDataBlockDesc->dataBlockId, -1, pScanLogicNode->pTags, &pTableScan->pTags); @@ -678,7 +714,7 @@ static int32_t createSystemTableScanPhysiNode(SPhysiPlanContext* pCxt, SSubplan* SSystemTableScanPhysiNode* pScan = (SSystemTableScanPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pScanLogicNode, QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN); if (NULL == pScan) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } pSubplan->showRewrite = pScanLogicNode->showRewrite; @@ -757,24 +793,40 @@ static int32_t getJoinDataBlockDescNode(SNodeList* pChildren, int32_t idx, SData } static int32_t setColEqList(SNode* pEqCond, int16_t leftBlkId, int16_t rightBlkId, SNodeList** ppLeft, SNodeList** ppRight) { + int32_t code = 0; if (QUERY_NODE_OPERATOR == nodeType(pEqCond) && ((SOperatorNode*)pEqCond)->opType == OP_TYPE_EQUAL) { SOperatorNode* pOp = (SOperatorNode*)pEqCond; + SNode* pNew = NULL; if (leftBlkId == ((SColumnNode*)pOp->pLeft)->dataBlockId) { - nodesListMakeStrictAppend(ppLeft, nodesCloneNode(pOp->pLeft)); + code = nodesCloneNode(pOp->pLeft, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(ppLeft, pNew); + } } else if (rightBlkId == ((SColumnNode*)pOp->pLeft)->dataBlockId) { - nodesListMakeStrictAppend(ppRight, nodesCloneNode(pOp->pLeft)); + code = nodesCloneNode(pOp->pLeft, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(ppRight, pNew); + } } else { planError("invalid col equal list, leftBlockId:%d", ((SColumnNode*)pOp->pLeft)->dataBlockId); return TSDB_CODE_PLAN_INTERNAL_ERROR; } - - if (leftBlkId == ((SColumnNode*)pOp->pRight)->dataBlockId) { - nodesListMakeStrictAppend(ppLeft, nodesCloneNode(pOp->pRight)); - } else if (rightBlkId == ((SColumnNode*)pOp->pRight)->dataBlockId) { - nodesListMakeStrictAppend(ppRight, nodesCloneNode(pOp->pRight)); - } else { - planError("invalid col equal list, rightBlockId:%d", ((SColumnNode*)pOp->pRight)->dataBlockId); - return TSDB_CODE_PLAN_INTERNAL_ERROR; + if (TSDB_CODE_SUCCESS == code) { + pNew = NULL; + if (leftBlkId == ((SColumnNode*)pOp->pRight)->dataBlockId) { + code = nodesCloneNode(pOp->pRight, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(ppLeft, pNew); + } + } else if (rightBlkId == ((SColumnNode*)pOp->pRight)->dataBlockId) { + code = nodesCloneNode(pOp->pRight, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(ppRight, pNew); + } + } else { + planError("invalid col equal list, rightBlockId:%d", ((SColumnNode*)pOp->pRight)->dataBlockId); + return TSDB_CODE_PLAN_INTERNAL_ERROR; + } } } else if (QUERY_NODE_LOGIC_CONDITION == nodeType(pEqCond) && ((SLogicConditionNode*)pEqCond)->condType == LOGIC_COND_TYPE_AND) { SLogicConditionNode* pLogic = (SLogicConditionNode*)pEqCond; @@ -790,10 +842,11 @@ static int32_t setColEqList(SNode* pEqCond, int16_t leftBlkId, int16_t rightBlkI return TSDB_CODE_PLAN_INTERNAL_ERROR; } - return TSDB_CODE_SUCCESS; + return code; } static int32_t setMergeJoinPrimColEqCond(SNode* pEqCond, int32_t subType, int16_t leftBlkId, int16_t rightBlkId, SSortMergeJoinPhysiNode* pJoin) { + int32_t code = 0; if (QUERY_NODE_OPERATOR == nodeType(pEqCond)) { SOperatorNode* pOp = (SOperatorNode*)pEqCond; if (pOp->opType != OP_TYPE_EQUAL && JOIN_STYPE_ASOF != subType) { @@ -830,10 +883,12 @@ static int32_t setMergeJoinPrimColEqCond(SNode* pEqCond, int32_t subType, int16_ if (leftBlkId == pCol->dataBlockId) { pJoin->leftPrimSlotId = pCol->slotId; pJoin->asofOpType = pOp->opType; - pJoin->leftPrimExpr = nodesCloneNode((SNode*)pFunc); + pJoin->leftPrimExpr = NULL; + code = nodesCloneNode((SNode*)pFunc, &pJoin->leftPrimExpr); } else if (rightBlkId == pCol->dataBlockId) { pJoin->rightPrimSlotId = pCol->slotId; - pJoin->rightPrimExpr = nodesCloneNode((SNode*)pFunc); + pJoin->rightPrimExpr = NULL; + code = nodesCloneNode((SNode*)pFunc, &pJoin->rightPrimExpr); } else { planError("invalid primary key col equal cond, leftBlockId:%d", pCol->dataBlockId); return TSDB_CODE_PLAN_INTERNAL_ERROR; @@ -844,7 +899,9 @@ static int32_t setMergeJoinPrimColEqCond(SNode* pEqCond, int32_t subType, int16_ planError("invalid primary cond left node type, leftNodeType:%d", nodeType(pOp->pLeft)); return TSDB_CODE_PLAN_INTERNAL_ERROR; } - + if (TSDB_CODE_SUCCESS != code) { + return code; + } switch (nodeType(pOp->pRight)) { case QUERY_NODE_COLUMN: { SColumnNode* pCol = (SColumnNode*)pOp->pRight; @@ -874,10 +931,12 @@ static int32_t setMergeJoinPrimColEqCond(SNode* pEqCond, int32_t subType, int16_ if (leftBlkId == pCol->dataBlockId) { pJoin->leftPrimSlotId = pCol->slotId; pJoin->asofOpType = getAsofJoinReverseOp(pOp->opType); - pJoin->leftPrimExpr = nodesCloneNode((SNode*)pFunc); + pJoin->leftPrimExpr = NULL; + code = nodesCloneNode((SNode*)pFunc, &pJoin->leftPrimExpr); } else if (rightBlkId == pCol->dataBlockId) { pJoin->rightPrimSlotId = pCol->slotId; - pJoin->rightPrimExpr = nodesCloneNode((SNode*)pFunc); + pJoin->rightPrimExpr = NULL; + code = nodesCloneNode((SNode*)pFunc, &pJoin->rightPrimExpr); } else { planError("invalid primary key col equal cond, rightBlockId:%d", pCol->dataBlockId); return TSDB_CODE_PLAN_INTERNAL_ERROR; @@ -893,7 +952,7 @@ static int32_t setMergeJoinPrimColEqCond(SNode* pEqCond, int32_t subType, int16_ return TSDB_CODE_PLAN_INTERNAL_ERROR; } - return TSDB_CODE_SUCCESS; + return code; } static int32_t createMergeJoinPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren, SJoinLogicNode* pJoinLogicNode, @@ -901,20 +960,26 @@ static int32_t createMergeJoinPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChi SSortMergeJoinPhysiNode* pJoin = (SSortMergeJoinPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pJoinLogicNode, QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN); if (NULL == pJoin) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } - pJoin->joinType = pJoinLogicNode->joinType; - pJoin->subType = pJoinLogicNode->subType; - pJoin->pWindowOffset = nodesCloneNode(pJoinLogicNode->pWindowOffset); - pJoin->pJLimit = nodesCloneNode(pJoinLogicNode->pJLimit); - pJoin->node.inputTsOrder = pJoinLogicNode->node.inputTsOrder; - pJoin->seqWinGroup = pJoinLogicNode->seqWinGroup; - pJoin->grpJoin = pJoinLogicNode->grpJoin; - SDataBlockDescNode* pLeftDesc = NULL; SDataBlockDescNode* pRightDesc = NULL; - int32_t code = getJoinDataBlockDescNode(pChildren, 0, &pLeftDesc); + pJoin->joinType = pJoinLogicNode->joinType; + pJoin->subType = pJoinLogicNode->subType; + pJoin->pWindowOffset = NULL; + int32_t code = nodesCloneNode(pJoinLogicNode->pWindowOffset, &pJoin->pWindowOffset); + if (TSDB_CODE_SUCCESS == code) { + pJoin->pJLimit = NULL; + code = nodesCloneNode(pJoinLogicNode->pJLimit, (SNode**)&pJoin->pJLimit); + } + if (TSDB_CODE_SUCCESS == code) { + pJoin->node.inputTsOrder = pJoinLogicNode->node.inputTsOrder; + pJoin->seqWinGroup = pJoinLogicNode->seqWinGroup; + pJoin->grpJoin = pJoinLogicNode->grpJoin; + code = getJoinDataBlockDescNode(pChildren, 0, &pLeftDesc); + } + if (TSDB_CODE_SUCCESS == code) { code = getJoinDataBlockDescNode(pChildren, 1, &pRightDesc); } @@ -1009,22 +1074,41 @@ static int32_t createMergeJoinPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChi } static int32_t extractHashJoinOpCols(int16_t lBlkId, int16_t rBlkId, SNode* pEq, SHashJoinPhysiNode* pJoin) { + int32_t code = 0; if (QUERY_NODE_OPERATOR == nodeType(pEq)) { SOperatorNode* pOp = (SOperatorNode*)pEq; SColumnNode* pLeft = (SColumnNode*)pOp->pLeft; SColumnNode* pRight = (SColumnNode*)pOp->pRight; if (lBlkId == pLeft->dataBlockId && rBlkId == pRight->dataBlockId) { - nodesListStrictAppend(pJoin->pOnLeft, nodesCloneNode(pOp->pLeft)); - nodesListStrictAppend(pJoin->pOnRight, nodesCloneNode(pOp->pRight)); + SNode* pL = NULL, *pR = NULL; + code = nodesCloneNode(pOp->pLeft, &pL); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pJoin->pOnLeft, pL); + } + if (TSDB_CODE_SUCCESS == code) { + code = nodesCloneNode(pOp->pRight, &pR); + } + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pJoin->pOnRight, pR); + } } else if (rBlkId == pLeft->dataBlockId && lBlkId == pRight->dataBlockId) { - nodesListStrictAppend(pJoin->pOnLeft, nodesCloneNode(pOp->pRight)); - nodesListStrictAppend(pJoin->pOnRight, nodesCloneNode(pOp->pLeft)); + SNode* pL = NULL, *pR = NULL; + code = nodesCloneNode(pOp->pRight, &pR); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pJoin->pOnLeft, pR); + } + if (TSDB_CODE_SUCCESS == code) { + code = nodesCloneNode(pOp->pLeft, &pL); + } + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pJoin->pOnRight, pL); + } } else { planError("Invalid join equal cond, lbid:%d, rbid:%d, oplid:%d, oprid:%d", lBlkId, rBlkId, pLeft->dataBlockId, pRight->dataBlockId); return TSDB_CODE_PLAN_INTERNAL_ERROR; } - return TSDB_CODE_SUCCESS; + return code; } planError("Invalid join equal node type:%d", nodeType(pEq)); @@ -1058,10 +1142,15 @@ static int32_t extractHashJoinOnCols(int16_t lBlkId, int16_t rBlkId, SNode* pEq, static int32_t createHashJoinColList(int16_t lBlkId, int16_t rBlkId, SNode* pEq1, SNode* pEq2, SNode* pEq3, SHashJoinPhysiNode* pJoin) { int32_t code = TSDB_CODE_SUCCESS; - pJoin->pOnLeft = nodesMakeList(); - pJoin->pOnRight = nodesMakeList(); - if (NULL == pJoin->pOnLeft || NULL == pJoin->pOnRight) { - return TSDB_CODE_OUT_OF_MEMORY; + pJoin->pOnLeft = NULL; + code = nodesMakeList(&pJoin->pOnLeft); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + pJoin->pOnRight = NULL; + code = nodesMakeList(&pJoin->pOnRight); + if (TSDB_CODE_SUCCESS != code) { + return code; } code = extractHashJoinOnCols(lBlkId, rBlkId, pEq1, pJoin); @@ -1086,56 +1175,82 @@ static int32_t sortHashJoinTargets(int16_t lBlkId, int16_t rBlkId, SHashJoinPhys if (NULL == pHash) { return TSDB_CODE_OUT_OF_MEMORY; } - SNodeList* pNew = nodesMakeList(); + SNodeList* pNew = NULL; + int32_t code = nodesMakeList(&pNew); - FOREACH(pNode, pJoin->pTargets) { - SColumnNode* pCol = (SColumnNode*)pNode; - int32_t len = getSlotKey(pNode, NULL, name, TSDB_COL_FNAME_LEN); - tSimpleHashPut(pHash, name, len, &pCol, POINTER_BYTES); - } - - nodesClearList(pJoin->pTargets); - pJoin->pTargets = pNew; - - FOREACH(pNode, pJoin->pOnLeft) { - SColumnNode* pCol = (SColumnNode*)pNode; - int32_t len = getSlotKey(pNode, NULL, name, TSDB_COL_FNAME_LEN); - SNode** p = tSimpleHashGet(pHash, name, len); - if (p) { - nodesListStrictAppend(pJoin->pTargets, *p); - tSimpleHashRemove(pHash, name, len); - } - } - FOREACH(pNode, pJoin->pOnRight) { - SColumnNode* pCol = (SColumnNode*)pNode; - int32_t len = getSlotKey(pNode, NULL, name, TSDB_COL_FNAME_LEN); - SNode** p = tSimpleHashGet(pHash, name, len); - if (p) { - nodesListStrictAppend(pJoin->pTargets, *p); - tSimpleHashRemove(pHash, name, len); - } - } - - if (tSimpleHashGetSize(pHash) > 0) { - SNode** p = NULL; - int32_t iter = 0; - while (1) { - p = tSimpleHashIterate(pHash, p, &iter); - if (p == NULL) { + if (TSDB_CODE_SUCCESS == code) { + FOREACH(pNode, pJoin->pTargets) { + SColumnNode* pCol = (SColumnNode*)pNode; + int32_t len = getSlotKey(pNode, NULL, name, TSDB_COL_FNAME_LEN); + code = tSimpleHashPut(pHash, name, len, &pCol, POINTER_BYTES); + if (TSDB_CODE_SUCCESS != code) { break; } + } + } + if (TSDB_CODE_SUCCESS == code) { + nodesClearList(pJoin->pTargets); + pJoin->pTargets = pNew; - nodesListStrictAppend(pJoin->pTargets, *p); + FOREACH(pNode, pJoin->pOnLeft) { + SColumnNode* pCol = (SColumnNode*)pNode; + int32_t len = getSlotKey(pNode, NULL, name, TSDB_COL_FNAME_LEN); + SNode** p = tSimpleHashGet(pHash, name, len); + if (p) { + code = nodesListStrictAppend(pJoin->pTargets, *p); + if (TSDB_CODE_SUCCESS != code) { + break; + } + code = tSimpleHashRemove(pHash, name, len); + if (TSDB_CODE_SUCCESS != code) { + break; + } + } + } + } + if (TSDB_CODE_SUCCESS == code) { + FOREACH(pNode, pJoin->pOnRight) { + SColumnNode* pCol = (SColumnNode*)pNode; + int32_t len = getSlotKey(pNode, NULL, name, TSDB_COL_FNAME_LEN); + SNode** p = tSimpleHashGet(pHash, name, len); + if (p) { + code = nodesListStrictAppend(pJoin->pTargets, *p); + if (TSDB_CODE_SUCCESS != code) { + break; + } + code = tSimpleHashRemove(pHash, name, len); + if (TSDB_CODE_SUCCESS != code) { + break; + } + } + } + } + if (TSDB_CODE_SUCCESS == code) { + if (tSimpleHashGetSize(pHash) > 0) { + SNode** p = NULL; + int32_t iter = 0; + while (1) { + p = tSimpleHashIterate(pHash, p, &iter); + if (p == NULL) { + break; + } + + code = nodesListStrictAppend(pJoin->pTargets, *p); + if (TSDB_CODE_SUCCESS != code) { + break; + } + } } } tSimpleHashCleanup(pHash); - return TSDB_CODE_SUCCESS; + return code; } static int32_t setHashJoinPrimColEqCond(SNode* pEqCond, int16_t leftBlkId, int16_t rightBlkId, SHashJoinPhysiNode* pJoin) { + int32_t code = 0; if (QUERY_NODE_OPERATOR == nodeType(pEqCond)) { SOperatorNode* pOp = (SOperatorNode*)pEqCond; if (pOp->opType != OP_TYPE_EQUAL) { @@ -1170,10 +1285,12 @@ static int32_t setHashJoinPrimColEqCond(SNode* pEqCond, int16_t leftBlkId, int16 SColumnNode* pCol = (SColumnNode*)pParam; if (leftBlkId == pCol->dataBlockId) { pJoin->leftPrimSlotId = pCol->slotId; - pJoin->leftPrimExpr = nodesCloneNode((SNode*)pFunc); + pJoin->leftPrimExpr = NULL; + code = nodesCloneNode((SNode*)pFunc, &pJoin->leftPrimExpr); } else if (rightBlkId == pCol->dataBlockId) { pJoin->rightPrimSlotId = pCol->slotId; - pJoin->rightPrimExpr = nodesCloneNode((SNode*)pFunc); + pJoin->rightPrimExpr = NULL; + code = nodesCloneNode((SNode*)pFunc, &pJoin->rightPrimExpr); } else { planError("invalid primary key col equal cond, leftBlockId:%d", pCol->dataBlockId); return TSDB_CODE_PLAN_INTERNAL_ERROR; @@ -1184,7 +1301,9 @@ static int32_t setHashJoinPrimColEqCond(SNode* pEqCond, int16_t leftBlkId, int16 planError("invalid primary cond left node type, leftNodeType:%d", nodeType(pOp->pLeft)); return TSDB_CODE_PLAN_INTERNAL_ERROR; } - + if (TSDB_CODE_SUCCESS != code) { + return code; + } switch (nodeType(pOp->pRight)) { case QUERY_NODE_COLUMN: { SColumnNode* pCol = (SColumnNode*)pOp->pRight; @@ -1212,10 +1331,12 @@ static int32_t setHashJoinPrimColEqCond(SNode* pEqCond, int16_t leftBlkId, int16 SColumnNode* pCol = (SColumnNode*)pParam; if (leftBlkId == pCol->dataBlockId) { pJoin->leftPrimSlotId = pCol->slotId; - pJoin->leftPrimExpr = nodesCloneNode((SNode*)pFunc); + pJoin->leftPrimExpr = NULL; + code = nodesCloneNode((SNode*)pFunc, &pJoin->leftPrimExpr); } else if (rightBlkId == pCol->dataBlockId) { pJoin->rightPrimSlotId = pCol->slotId; - pJoin->rightPrimExpr = nodesCloneNode((SNode*)pFunc); + pJoin->rightPrimExpr = NULL; + code = nodesCloneNode((SNode*)pFunc, &pJoin->rightPrimExpr); } else { planError("invalid primary key col equal cond, rightBlockId:%d", pCol->dataBlockId); return TSDB_CODE_PLAN_INTERNAL_ERROR; @@ -1231,7 +1352,7 @@ static int32_t setHashJoinPrimColEqCond(SNode* pEqCond, int16_t leftBlkId, int16 return TSDB_CODE_PLAN_INTERNAL_ERROR; } - return TSDB_CODE_SUCCESS; + return code; } @@ -1240,7 +1361,7 @@ static int32_t createHashJoinPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChil SHashJoinPhysiNode* pJoin = (SHashJoinPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pJoinLogicNode, QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN); if (NULL == pJoin) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } SDataBlockDescNode* pLeftDesc = ((SPhysiNode*)nodesListGetNode(pChildren, 0))->pOutputDataBlockDesc; @@ -1249,8 +1370,18 @@ static int32_t createHashJoinPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChil pJoin->joinType = pJoinLogicNode->joinType; pJoin->subType = pJoinLogicNode->subType; - pJoin->pWindowOffset = nodesCloneNode(pJoinLogicNode->pWindowOffset); - pJoin->pJLimit = nodesCloneNode(pJoinLogicNode->pJLimit); + pJoin->pWindowOffset = NULL; + code = nodesCloneNode(pJoinLogicNode->pWindowOffset, &pJoin->pWindowOffset); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pJoin); + return code; + } + pJoin->pJLimit = NULL; + code = nodesCloneNode(pJoinLogicNode->pJLimit, &pJoin->pJLimit); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pJoin); + return code; + } pJoin->node.inputTsOrder = pJoinLogicNode->node.inputTsOrder; pJoin->timeRangeTarget = pJoinLogicNode->timeRangeTarget; pJoin->timeRange.skey = pJoinLogicNode->timeRange.skey; @@ -1333,7 +1464,7 @@ static int32_t createGroupCachePhysiNode(SPhysiPlanContext* pCxt, SNodeList* pCh SGroupCachePhysiNode* pGrpCache = (SGroupCachePhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pLogicNode, QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE); if (NULL == pGrpCache) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } pGrpCache->grpColsMayBeNull = pLogicNode->grpColsMayBeNull; @@ -1390,7 +1521,7 @@ static int32_t createDynQueryCtrlPhysiNode(SPhysiPlanContext* pCxt, SNodeList* p SDynQueryCtrlPhysiNode* pDynCtrl = (SDynQueryCtrlPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pLogicNode, QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL); if (NULL == pDynCtrl) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } switch (pLogicNode->qType) { @@ -1418,19 +1549,18 @@ typedef struct SRewritePrecalcExprsCxt { } SRewritePrecalcExprsCxt; static EDealRes collectAndRewrite(SRewritePrecalcExprsCxt* pCxt, SNode** pNode) { - SNode* pExpr = nodesCloneNode(*pNode); + SNode* pExpr = NULL; + pCxt->errCode = nodesCloneNode(*pNode, &pExpr); if (NULL == pExpr) { - pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; return DEAL_RES_ERROR; } - if (nodesListAppend(pCxt->pPrecalcExprs, pExpr)) { - pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; + if (TSDB_CODE_SUCCESS != (pCxt->errCode = nodesListAppend(pCxt->pPrecalcExprs, pExpr))) { nodesDestroyNode(pExpr); return DEAL_RES_ERROR; } - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + SColumnNode* pCol = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); if (NULL == pCol) { - pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY; nodesDestroyNode(pExpr); return DEAL_RES_ERROR; } @@ -1449,14 +1579,16 @@ static EDealRes collectAndRewrite(SRewritePrecalcExprsCxt* pCxt, SNode** pNode) } static int32_t rewriteValueToOperator(SRewritePrecalcExprsCxt* pCxt, SNode** pNode) { - SOperatorNode* pOper = (SOperatorNode*)nodesMakeNode(QUERY_NODE_OPERATOR); + SOperatorNode* pOper = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_OPERATOR, (SNode**)&pOper); if (NULL == pOper) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - pOper->pLeft = nodesMakeNode(QUERY_NODE_LEFT_VALUE); + pOper->pLeft = NULL; + code = nodesMakeNode(QUERY_NODE_LEFT_VALUE, &pOper->pLeft); if (NULL == pOper->pLeft) { nodesDestroyNode((SNode*)pOper); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } SValueNode* pVal = (SValueNode*)*pNode; pOper->node.resType = pVal->node.resType; @@ -1501,32 +1633,32 @@ static int32_t rewritePrecalcExprs(SPhysiPlanContext* pCxt, SNodeList* pList, SN if (NULL == pList) { return TSDB_CODE_SUCCESS; } - + int32_t code = 0; if (NULL == *pPrecalcExprs) { - *pPrecalcExprs = nodesMakeList(); + code = nodesMakeList(pPrecalcExprs); if (NULL == *pPrecalcExprs) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } } if (NULL == *pRewrittenList) { - *pRewrittenList = nodesMakeList(); + code = nodesMakeList(pRewrittenList); if (NULL == *pRewrittenList) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } } SNode* pNode = NULL; FOREACH(pNode, pList) { SNode* pNew = NULL; if (QUERY_NODE_GROUPING_SET == nodeType(pNode)) { - pNew = nodesCloneNode(nodesListGetNode(((SGroupingSetNode*)pNode)->pParameterList, 0)); + code = nodesCloneNode(nodesListGetNode(((SGroupingSetNode*)pNode)->pParameterList, 0), &pNew); } else { - pNew = nodesCloneNode(pNode); + code = nodesCloneNode(pNode, &pNew); } if (NULL == pNew) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - if (TSDB_CODE_SUCCESS != nodesListAppend(*pRewrittenList, pNew)) { - return TSDB_CODE_OUT_OF_MEMORY; + if (TSDB_CODE_SUCCESS != (code = nodesListAppend(*pRewrittenList, pNew))) { + return code; } } SRewritePrecalcExprsCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .pPrecalcExprs = *pPrecalcExprs}; @@ -1573,7 +1705,7 @@ static int32_t createAggPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren, SAggPhysiNode* pAgg = (SAggPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pAggLogicNode, QUERY_NODE_PHYSICAL_PLAN_HASH_AGG); if (NULL == pAgg) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } if (pAgg->node.pSlimit) { pSubPlan->dynamicRowThreshold = true; @@ -1638,7 +1770,7 @@ static int32_t createIndefRowsFuncPhysiNode(SPhysiPlanContext* pCxt, SNodeList* SIndefRowsFuncPhysiNode* pIdfRowsFunc = (SIndefRowsFuncPhysiNode*)makePhysiNode( pCxt, (SLogicNode*)pFuncLogicNode, QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC); if (NULL == pIdfRowsFunc) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } SNodeList* pPrecalcExprs = NULL; @@ -1687,7 +1819,7 @@ static int32_t createInterpFuncPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pCh SInterpFuncPhysiNode* pInterpFunc = (SInterpFuncPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pFuncLogicNode, QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC); if (NULL == pInterpFunc) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } SNodeList* pPrecalcExprs = NULL; @@ -1714,9 +1846,10 @@ static int32_t createInterpFuncPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pCh pInterpFunc->timeRange = pFuncLogicNode->timeRange; pInterpFunc->interval = pFuncLogicNode->interval; pInterpFunc->fillMode = pFuncLogicNode->fillMode; - pInterpFunc->pFillValues = nodesCloneNode(pFuncLogicNode->pFillValues); - if (NULL != pFuncLogicNode->pFillValues && NULL == pInterpFunc->pFillValues) { - code = TSDB_CODE_OUT_OF_MEMORY; + pInterpFunc->pFillValues = NULL; + code = nodesCloneNode(pFuncLogicNode->pFillValues, &pInterpFunc->pFillValues); + if (TSDB_CODE_SUCCESS != code) { + code = code; } } @@ -1759,7 +1892,7 @@ static int32_t createProjectPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChild SProjectPhysiNode* pProject = (SProjectPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pProjectLogicNode, QUERY_NODE_PHYSICAL_PLAN_PROJECT); if (NULL == pProject) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } pProject->mergeDataBlock = projectCanMergeDataBlock(pProjectLogicNode); @@ -1768,10 +1901,7 @@ static int32_t createProjectPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChild int32_t code = TSDB_CODE_SUCCESS; if (0 == LIST_LENGTH(pChildren)) { - pProject->pProjections = nodesCloneList(pProjectLogicNode->pProjections); - if (NULL == pProject->pProjections) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + code = nodesCloneList(pProjectLogicNode->pProjections, &pProject->pProjections); } else { code = setListSlotId(pCxt, ((SPhysiNode*)nodesListGetNode(pChildren, 0))->pOutputDataBlockDesc->dataBlockId, -1, pProjectLogicNode->pProjections, &pProject->pProjections); @@ -1798,7 +1928,7 @@ static int32_t doCreateExchangePhysiNode(SPhysiPlanContext* pCxt, SExchangeLogic SExchangePhysiNode* pExchange = (SExchangePhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pExchangeLogicNode, QUERY_NODE_PHYSICAL_PLAN_EXCHANGE); if (NULL == pExchange) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } pExchange->srcStartGroupId = pExchangeLogicNode->srcStartGroupId; @@ -1820,15 +1950,13 @@ static int32_t createStreamScanPhysiNodeByExchange(SPhysiPlanContext* pCxt, SExc SScanPhysiNode* pScan = (SScanPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pExchangeLogicNode, QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN); if (NULL == pScan) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } int32_t code = TSDB_CODE_SUCCESS; - pScan->pScanCols = nodesCloneList(pExchangeLogicNode->node.pTargets); - if (NULL == pScan->pScanCols) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + pScan->pScanCols = NULL; + code = nodesCloneList(pExchangeLogicNode->node.pTargets, &pScan->pScanCols); if (TSDB_CODE_SUCCESS == code) { code = sortScanCols(pScan->pScanCols); @@ -1948,7 +2076,7 @@ static int32_t createIntervalPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChil SIntervalPhysiNode* pInterval = (SIntervalPhysiNode*)makePhysiNode( pCxt, (SLogicNode*)pWindowLogicNode, getIntervalOperatorType(pWindowLogicNode->windowAlgo)); if (NULL == pInterval) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } pInterval->interval = pWindowLogicNode->interval; @@ -1972,7 +2100,7 @@ static int32_t createSessionWindowPhysiNode(SPhysiPlanContext* pCxt, SNodeList* SSessionWinodwPhysiNode* pSession = (SSessionWinodwPhysiNode*)makePhysiNode( pCxt, (SLogicNode*)pWindowLogicNode, getIntervalOperatorType(pWindowLogicNode->windowAlgo)); if (NULL == pSession) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } pSession->gap = pWindowLogicNode->sessionGap; @@ -1993,7 +2121,7 @@ static int32_t createStateWindowPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pC pCxt, (SLogicNode*)pWindowLogicNode, (pCxt->pPlanCxt->streamQuery ? QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE : QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE)); if (NULL == pState) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } SNodeList* pPrecalcExprs = NULL; @@ -2038,7 +2166,7 @@ static int32_t createEventWindowPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pC pCxt, (SLogicNode*)pWindowLogicNode, (pCxt->pPlanCxt->streamQuery ? QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT : QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT)); if (NULL == pEvent) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } SDataBlockDescNode* pChildTupe = (((SPhysiNode*)nodesListGetNode(pChildren, 0))->pOutputDataBlockDesc); @@ -2065,7 +2193,7 @@ static int32_t createCountWindowPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pC pCxt, (SLogicNode*)pWindowLogicNode, (pCxt->pPlanCxt->streamQuery ? QUERY_NODE_PHYSICAL_PLAN_STREAM_COUNT : QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT)); if (NULL == pCount) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } pCount->windowCount = pWindowLogicNode->windowCount; pCount->windowSliding = pWindowLogicNode->windowSliding; @@ -2105,7 +2233,7 @@ static int32_t createSortPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren pCxt, (SLogicNode*)pSortLogicNode, pSortLogicNode->groupSort ? QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT : QUERY_NODE_PHYSICAL_PLAN_SORT); if (NULL == pSort) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } SNodeList* pPrecalcExprs = NULL; @@ -2155,7 +2283,7 @@ static int32_t createPartitionPhysiNodeImpl(SPhysiPlanContext* pCxt, SNodeList* SPhysiNode** pPhyNode) { SPartitionPhysiNode* pPart = (SPartitionPhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pPartLogicNode, type); if (NULL == pPart) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } SNodeList* pPrecalcExprs = NULL; @@ -2249,7 +2377,7 @@ static int32_t createFillPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren pCxt, (SLogicNode*)pFillNode, pCxt->pPlanCxt->streamQuery ? QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL : QUERY_NODE_PHYSICAL_PLAN_FILL); if (NULL == pFill) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } pFill->mode = pFillNode->mode; @@ -2276,9 +2404,9 @@ static int32_t createFillPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren } if (TSDB_CODE_SUCCESS == code && NULL != pFillNode->pValues) { - pFill->pValues = nodesCloneNode(pFillNode->pValues); + code = nodesCloneNode(pFillNode->pValues, &pFillNode->pValues); if (NULL == pFill->pValues) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = code; } } @@ -2296,18 +2424,20 @@ static int32_t createFillPhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildren } static int32_t createExchangePhysiNodeByMerge(SMergePhysiNode* pMerge, int32_t idx) { - SExchangePhysiNode* pExchange = (SExchangePhysiNode*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_EXCHANGE); + SExchangePhysiNode* pExchange = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_EXCHANGE, (SNode**)&pExchange); if (NULL == pExchange) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pExchange->srcStartGroupId = pMerge->srcGroupId + idx; pExchange->srcEndGroupId = pMerge->srcGroupId + idx; pExchange->singleChannel = true; pExchange->node.pParent = (SPhysiNode*)pMerge; - pExchange->node.pOutputDataBlockDesc = (SDataBlockDescNode*)nodesCloneNode((SNode*)pMerge->node.pOutputDataBlockDesc); + pExchange->node.pOutputDataBlockDesc = NULL; + code = nodesCloneNode((SNode*)pMerge->node.pOutputDataBlockDesc, (SNode**)&pExchange->node.pOutputDataBlockDesc); if (NULL == pExchange->node.pOutputDataBlockDesc) { nodesDestroyNode((SNode*)pExchange); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } SNode* pSlot = NULL; FOREACH(pSlot, pExchange->node.pOutputDataBlockDesc->pSlots) { ((SSlotDescNode*)pSlot)->output = true; } @@ -2319,7 +2449,7 @@ static int32_t createMergePhysiNode(SPhysiPlanContext* pCxt, SNodeList* pChildre SMergePhysiNode* pMerge = (SMergePhysiNode*)makePhysiNode(pCxt, (SLogicNode*)pMergeLogicNode, QUERY_NODE_PHYSICAL_PLAN_MERGE); if (NULL == pMerge) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } if (pMergeLogicNode->colsMerge) { @@ -2423,13 +2553,12 @@ static int32_t doCreatePhysiNode(SPhysiPlanContext* pCxt, SLogicNode* pLogicNode static int32_t createPhysiNode(SPhysiPlanContext* pCxt, SLogicNode* pLogicNode, SSubplan* pSubplan, SPhysiNode** pPhyNode) { - SNodeList* pChildren = nodesMakeList(); + SNodeList* pChildren = NULL; + int32_t code = nodesMakeList(&pChildren); if (NULL == pChildren) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - int32_t code = TSDB_CODE_SUCCESS; - SNode* pLogicChild; FOREACH(pLogicChild, pLogicNode->pChildren) { SPhysiNode* pChild = NULL; @@ -2462,9 +2591,10 @@ static int32_t createPhysiNode(SPhysiPlanContext* pCxt, SLogicNode* pLogicNode, } static int32_t createDataInserter(SPhysiPlanContext* pCxt, SVgDataBlocks* pBlocks, SDataSinkNode** pSink) { - SDataInserterNode* pInserter = (SDataInserterNode*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_INSERT); + SDataInserterNode* pInserter = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_INSERT, (SNode**)&pInserter); if (NULL == pInserter) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pInserter->numOfTables = pBlocks->numOfTables; @@ -2476,25 +2606,28 @@ static int32_t createDataInserter(SPhysiPlanContext* pCxt, SVgDataBlocks* pBlock } static int32_t createDataDispatcher(SPhysiPlanContext* pCxt, const SPhysiNode* pRoot, SDataSinkNode** pSink) { - SDataDispatcherNode* pDispatcher = (SDataDispatcherNode*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_DISPATCH); + SDataDispatcherNode* pDispatcher = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_DISPATCH, (SNode**)&pDispatcher); if (NULL == pDispatcher) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - pDispatcher->sink.pInputDataBlockDesc = (SDataBlockDescNode*)nodesCloneNode((SNode*)pRoot->pOutputDataBlockDesc); + pDispatcher->sink.pInputDataBlockDesc = NULL; + code = nodesCloneNode((SNode*)pRoot->pOutputDataBlockDesc, (SNode**)&pDispatcher->sink.pInputDataBlockDesc); if (NULL == pDispatcher->sink.pInputDataBlockDesc) { nodesDestroyNode((SNode*)pDispatcher); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } *pSink = (SDataSinkNode*)pDispatcher; return TSDB_CODE_SUCCESS; } -static SSubplan* makeSubplan(SPhysiPlanContext* pCxt, SLogicSubplan* pLogicSubplan) { - SSubplan* pSubplan = (SSubplan*)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN); +static int32_t makeSubplan(SPhysiPlanContext* pCxt, SLogicSubplan* pLogicSubplan, SSubplan** ppSubplan) { + SSubplan* pSubplan = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN, (SNode**)&pSubplan); if (NULL == pSubplan) { - return NULL; + return code; } pSubplan->id = pLogicSubplan->id; pSubplan->subplanType = pLogicSubplan->subplanType; @@ -2506,7 +2639,8 @@ static SSubplan* makeSubplan(SPhysiPlanContext* pCxt, SLogicSubplan* pLogicSubpl if (NULL != pCxt->pPlanCxt->pUser) { snprintf(pSubplan->user, sizeof(pSubplan->user), "%s", pCxt->pPlanCxt->pUser); } - return pSubplan; + *ppSubplan = pSubplan; + return code; } static int32_t buildInsertValuesSubplan(SPhysiPlanContext* pCxt, SVnodeModifyLogicNode* pModify, SSubplan* pSubplan) { @@ -2518,9 +2652,10 @@ static int32_t buildInsertValuesSubplan(SPhysiPlanContext* pCxt, SVnodeModifyLog static int32_t createQueryInserter(SPhysiPlanContext* pCxt, SVnodeModifyLogicNode* pModify, SSubplan* pSubplan, SDataSinkNode** pSink) { - SQueryInserterNode* pInserter = (SQueryInserterNode*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT); + SQueryInserterNode* pInserter = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_QUERY_INSERT, (SNode**)&pInserter); if (NULL == pInserter) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pInserter->tableId = pModify->tableId; @@ -2533,13 +2668,13 @@ static int32_t createQueryInserter(SPhysiPlanContext* pCxt, SVnodeModifyLogicNod pInserter->epSet = pModify->pVgroupList->vgroups[0].epSet; vgroupInfoToNodeAddr(pModify->pVgroupList->vgroups, &pSubplan->execNode); } - int32_t code = setListSlotId(pCxt, pSubplan->pNode->pOutputDataBlockDesc->dataBlockId, -1, pModify->pInsertCols, + code = setListSlotId(pCxt, pSubplan->pNode->pOutputDataBlockDesc->dataBlockId, -1, pModify->pInsertCols, &pInserter->pCols); if (TSDB_CODE_SUCCESS == code) { - pInserter->sink.pInputDataBlockDesc = - (SDataBlockDescNode*)nodesCloneNode((SNode*)pSubplan->pNode->pOutputDataBlockDesc); + pInserter->sink.pInputDataBlockDesc = NULL; + code = nodesCloneNode((SNode*)pSubplan->pNode->pOutputDataBlockDesc, (SNode**)&pInserter->sink.pInputDataBlockDesc); if (NULL == pInserter->sink.pInputDataBlockDesc) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = code; } } @@ -2571,9 +2706,10 @@ static int32_t buildInsertSubplan(SPhysiPlanContext* pCxt, SVnodeModifyLogicNode static int32_t createDataDeleter(SPhysiPlanContext* pCxt, SVnodeModifyLogicNode* pModify, const SPhysiNode* pRoot, SDataSinkNode** pSink) { - SDataDeleterNode* pDeleter = (SDataDeleterNode*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_DELETE); + SDataDeleterNode* pDeleter = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_DELETE, (SNode**)&pDeleter); if (NULL == pDeleter) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pDeleter->tableId = pModify->tableId; @@ -2582,7 +2718,7 @@ static int32_t createDataDeleter(SPhysiPlanContext* pCxt, SVnodeModifyLogicNode* strcpy(pDeleter->tsColName, pModify->tsColName); pDeleter->deleteTimeRange = pModify->deleteTimeRange; - int32_t code = setNodeSlotId(pCxt, pRoot->pOutputDataBlockDesc->dataBlockId, -1, pModify->pAffectedRows, + code = setNodeSlotId(pCxt, pRoot->pOutputDataBlockDesc->dataBlockId, -1, pModify->pAffectedRows, &pDeleter->pAffectedRows); if (TSDB_CODE_SUCCESS == code) { code = setNodeSlotId(pCxt, pRoot->pOutputDataBlockDesc->dataBlockId, -1, pModify->pStartTs, &pDeleter->pStartTs); @@ -2591,9 +2727,10 @@ static int32_t createDataDeleter(SPhysiPlanContext* pCxt, SVnodeModifyLogicNode* code = setNodeSlotId(pCxt, pRoot->pOutputDataBlockDesc->dataBlockId, -1, pModify->pEndTs, &pDeleter->pEndTs); } if (TSDB_CODE_SUCCESS == code) { - pDeleter->sink.pInputDataBlockDesc = (SDataBlockDescNode*)nodesCloneNode((SNode*)pRoot->pOutputDataBlockDesc); + pDeleter->sink.pInputDataBlockDesc = NULL; + code = nodesCloneNode((SNode*)pRoot->pOutputDataBlockDesc, (SNode**)&pDeleter->sink.pInputDataBlockDesc); if (NULL == pDeleter->sink.pInputDataBlockDesc) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = code; } } @@ -2634,13 +2771,12 @@ static int32_t buildVnodeModifySubplan(SPhysiPlanContext* pCxt, SLogicSubplan* p } static int32_t createPhysiSubplan(SPhysiPlanContext* pCxt, SLogicSubplan* pLogicSubplan, SSubplan** pPhysiSubplan) { - SSubplan* pSubplan = makeSubplan(pCxt, pLogicSubplan); + SSubplan* pSubplan = NULL; + int32_t code = makeSubplan(pCxt, pLogicSubplan, &pSubplan); if (NULL == pSubplan) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - int32_t code = TSDB_CODE_SUCCESS; - if (SUBPLAN_TYPE_MODIFY == pLogicSubplan->subplanType) { code = buildVnodeModifySubplan(pCxt, pLogicSubplan, pSubplan); } else { @@ -2664,26 +2800,30 @@ static int32_t createPhysiSubplan(SPhysiPlanContext* pCxt, SLogicSubplan* pLogic return code; } -static SQueryPlan* makeQueryPhysiPlan(SPhysiPlanContext* pCxt) { - SQueryPlan* pPlan = (SQueryPlan*)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN); +static int32_t makeQueryPhysiPlan(SPhysiPlanContext* pCxt, SQueryPlan** ppQueryPlan) { + SQueryPlan* pPlan = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN, (SNode**)&pPlan); if (NULL == pPlan) { - return NULL; + return code; } - pPlan->pSubplans = nodesMakeList(); + pPlan->pSubplans = NULL; + code = nodesMakeList(&pPlan->pSubplans); if (NULL == pPlan->pSubplans) { nodesDestroyNode((SNode*)pPlan); - return NULL; + return code; } pPlan->queryId = pCxt->pPlanCxt->queryId; - return pPlan; + *ppQueryPlan = pPlan; + return code; } static int32_t pushSubplan(SPhysiPlanContext* pCxt, SNode* pSubplan, int32_t level, SNodeList* pSubplans) { SNodeListNode* pGroup = NULL; if (level >= LIST_LENGTH(pSubplans)) { - pGroup = (SNodeListNode*)nodesMakeNode(QUERY_NODE_NODE_LIST); + pGroup = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&pGroup); if (NULL == pGroup) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } if (TSDB_CODE_SUCCESS != nodesListStrictAppend(pSubplans, (SNode*)pGroup)) { return TSDB_CODE_OUT_OF_MEMORY; @@ -2692,9 +2832,9 @@ static int32_t pushSubplan(SPhysiPlanContext* pCxt, SNode* pSubplan, int32_t lev pGroup = (SNodeListNode*)nodesListGetNode(pSubplans, level); } if (NULL == pGroup->pNodeList) { - pGroup->pNodeList = nodesMakeList(); + int32_t code = nodesMakeList(&pGroup->pNodeList); if (NULL == pGroup->pNodeList) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } } return nodesListAppend(pGroup->pNodeList, (SNode*)pSubplan); @@ -2736,13 +2876,12 @@ static int32_t buildPhysiPlan(SPhysiPlanContext* pCxt, SLogicSubplan* pLogicSubp } static int32_t doCreatePhysiPlan(SPhysiPlanContext* pCxt, SQueryLogicPlan* pLogicPlan, SQueryPlan** pPhysiPlan) { - SQueryPlan* pPlan = (SQueryPlan*)makeQueryPhysiPlan(pCxt); + SQueryPlan* pPlan = NULL; + int32_t code = makeQueryPhysiPlan(pCxt, &pPlan); if (NULL == pPlan) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - int32_t code = TSDB_CODE_SUCCESS; - SNode* pSubplan = NULL; FOREACH(pSubplan, pLogicPlan->pTopSubplans) { code = buildPhysiPlan(pCxt, (SLogicSubplan*)pSubplan, NULL, pPlan); diff --git a/source/libs/planner/src/planScaleOut.c b/source/libs/planner/src/planScaleOut.c index 1f43d54333..bcac7ddd7e 100644 --- a/source/libs/planner/src/planScaleOut.c +++ b/source/libs/planner/src/planScaleOut.c @@ -21,12 +21,16 @@ typedef struct SScaleOutContext { } SScaleOutContext; static SLogicSubplan* singleCloneSubLogicPlan(SScaleOutContext* pCxt, SLogicSubplan* pSrc, int32_t level) { - SLogicSubplan* pDst = (SLogicSubplan*)nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN); + SLogicSubplan* pDst = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN, (SNode**)&pDst); if (NULL == pDst) { + terrno = code; return NULL; } - pDst->pNode = (SLogicNode*)nodesCloneNode((SNode*)pSrc->pNode); + pDst->pNode = NULL; + code = nodesCloneNode((SNode*)pSrc->pNode, (SNode**)&pDst->pNode); if (NULL == pDst->pNode) { + terrno = code; nodesDestroyNode((SNode*)pDst); return NULL; } @@ -69,7 +73,7 @@ static int32_t scaleOutByVgroups(SScaleOutContext* pCxt, SLogicSubplan* pSubplan for (int32_t i = 0; i < pSubplan->pVgroupList->numOfVgroups; ++i) { SLogicSubplan* pNewSubplan = singleCloneSubLogicPlan(pCxt, pSubplan, level); if (NULL == pNewSubplan) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } code = setScanVgroup(pNewSubplan->pNode, pSubplan->pVgroupList->vgroups + i); if (TSDB_CODE_SUCCESS == code) { @@ -90,14 +94,15 @@ static int32_t scaleOutForInsertValues(SScaleOutContext* pCxt, SLogicSubplan* pS SNodeList* pGroup) { SVnodeModifyLogicNode* pNode = (SVnodeModifyLogicNode*)pSubplan->pNode; size_t numOfVgroups = taosArrayGetSize(pNode->pDataBlocks); + int32_t code = 0; for (int32_t i = 0; i < numOfVgroups; ++i) { SLogicSubplan* pNewSubplan = singleCloneSubLogicPlan(pCxt, pSubplan, level); if (NULL == pNewSubplan) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } ((SVnodeModifyLogicNode*)pNewSubplan->pNode)->pVgDataBlocks = (SVgDataBlocks*)taosArrayGetP(pNode->pDataBlocks, i); - if (TSDB_CODE_SUCCESS != nodesListStrictAppend(pGroup, (SNode*)pNewSubplan)) { - return TSDB_CODE_OUT_OF_MEMORY; + if (TSDB_CODE_SUCCESS != (code = nodesListStrictAppend(pGroup, (SNode*)pNewSubplan))) { + return code; } } return TSDB_CODE_SUCCESS; @@ -132,7 +137,7 @@ static int32_t scaleOutForCompute(SScaleOutContext* pCxt, SLogicSubplan* pSubpla for (int32_t i = 0; i < pSubplan->numOfComputeNodes; ++i) { SLogicSubplan* pNewSubplan = singleCloneSubLogicPlan(pCxt, pSubplan, level); if (NULL == pNewSubplan) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } code = nodesListStrictAppend(pGroup, (SNode*)pNewSubplan); if (TSDB_CODE_SUCCESS != code) { @@ -196,12 +201,12 @@ static int32_t pushHierarchicalPlan(SNodeList* pParentsGroup, SNodeList* pCurren } static int32_t doScaleOut(SScaleOutContext* pCxt, SLogicSubplan* pSubplan, int32_t level, SNodeList* pParentsGroup) { - SNodeList* pCurrentGroup = nodesMakeList(); + SNodeList* pCurrentGroup = NULL; + int32_t code = nodesMakeList(&pCurrentGroup); if (NULL == pCurrentGroup) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - int32_t code = TSDB_CODE_SUCCESS; switch (pSubplan->subplanType) { case SUBPLAN_TYPE_MERGE: code = scaleOutForMerge(pCxt, pSubplan, level, pCurrentGroup); @@ -243,13 +248,17 @@ static int32_t doScaleOut(SScaleOutContext* pCxt, SLogicSubplan* pSubplan, int32 } static SQueryLogicPlan* makeQueryLogicPlan() { - SQueryLogicPlan* pLogicPlan = (SQueryLogicPlan*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN); + SQueryLogicPlan* pLogicPlan = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN, (SNode**)&pLogicPlan); if (NULL == pLogicPlan) { + terrno = code; return NULL; } - pLogicPlan->pTopSubplans = nodesMakeList(); + pLogicPlan->pTopSubplans = NULL; + code = nodesMakeList(&pLogicPlan->pTopSubplans); if (NULL == pLogicPlan->pTopSubplans) { nodesDestroyNode((SNode*)pLogicPlan); + terrno = code; return NULL; } return pLogicPlan; @@ -258,7 +267,7 @@ static SQueryLogicPlan* makeQueryLogicPlan() { int32_t scaleOutLogicPlan(SPlanContext* pCxt, SLogicSubplan* pLogicSubplan, SQueryLogicPlan** pLogicPlan) { SQueryLogicPlan* pPlan = makeQueryLogicPlan(); if (NULL == pPlan) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } SScaleOutContext cxt = {.pPlanCxt = pCxt, .subplanId = 1}; diff --git a/source/libs/planner/src/planSpliter.c b/source/libs/planner/src/planSpliter.c index 45322e62a8..e2eeeabfa6 100644 --- a/source/libs/planner/src/planSpliter.c +++ b/source/libs/planner/src/planSpliter.c @@ -59,7 +59,8 @@ static void splSetSubplanVgroups(SLogicSubplan* pSubplan, SLogicNode* pNode) { } static SLogicSubplan* splCreateScanSubplan(SSplitContext* pCxt, SLogicNode* pNode, int32_t flag) { - SLogicSubplan* pSubplan = (SLogicSubplan*)nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN); + SLogicSubplan* pSubplan = NULL; + terrno = nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN, (SNode**)&pSubplan); if (NULL == pSubplan) { return NULL; } @@ -93,37 +94,44 @@ static void splSetSubplanType(SLogicSubplan* pSubplan) { pSubplan->subplanType = splHasScan(pSubplan->pNode) ? SUBPLAN_TYPE_SCAN : SUBPLAN_TYPE_MERGE; } -static SLogicSubplan* splCreateSubplan(SSplitContext* pCxt, SLogicNode* pNode) { - SLogicSubplan* pSubplan = (SLogicSubplan*)nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN); +static int32_t splCreateSubplan(SSplitContext* pCxt, SLogicNode* pNode, SLogicSubplan** ppSubplan) { + SLogicSubplan* pSubplan = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_SUBPLAN, (SNode**)&pSubplan); if (NULL == pSubplan) { - return NULL; + return code; } pSubplan->id.queryId = pCxt->queryId; pSubplan->id.groupId = pCxt->groupId; pSubplan->pNode = pNode; pNode->pParent = NULL; splSetSubplanType(pSubplan); - return pSubplan; + *ppSubplan = pSubplan; + return code; } static int32_t splCreateExchangeNode(SSplitContext* pCxt, SLogicNode* pChild, SExchangeLogicNode** pOutput) { - SExchangeLogicNode* pExchange = (SExchangeLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_EXCHANGE); + SExchangeLogicNode* pExchange = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_EXCHANGE, (SNode**)&pExchange); if (NULL == pExchange) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pExchange->srcStartGroupId = pCxt->groupId; pExchange->srcEndGroupId = pCxt->groupId; pExchange->node.precision = pChild->precision; pExchange->node.dynamicOp = pChild->dynamicOp; - pExchange->node.pTargets = nodesCloneList(pChild->pTargets); + pExchange->node.pTargets = NULL; + code = nodesCloneList(pChild->pTargets, &pExchange->node.pTargets); if (NULL == pExchange->node.pTargets) { - return TSDB_CODE_OUT_OF_MEMORY; + nodesDestroyNode((SNode*)pExchange); + return code; } if (NULL != pChild->pLimit) { - pExchange->node.pLimit = nodesCloneNode(pChild->pLimit); + pExchange->node.pLimit = NULL; + code = nodesCloneNode(pChild->pLimit, &pExchange->node.pLimit); if (NULL == pExchange->node.pLimit) { - return TSDB_CODE_OUT_OF_MEMORY; + nodesDestroyNode((SNode*)pExchange); + return code; } ((SLimitNode*)pChild->pLimit)->limit += ((SLimitNode*)pChild->pLimit)->offset; ((SLimitNode*)pChild->pLimit)->offset = 0; @@ -368,18 +376,14 @@ static int32_t stbSplRewriteFuns(const SNodeList* pFuncs, SNodeList** pPartialFu SFunctionNode* pMergeFunc = NULL; int32_t code = TSDB_CODE_SUCCESS; if (fmIsWindowPseudoColumnFunc(pFunc->funcId)) { - pPartFunc = (SFunctionNode*)nodesCloneNode(pNode); - pMergeFunc = (SFunctionNode*)nodesCloneNode(pNode); - if (NULL == pPartFunc || NULL == pMergeFunc) { - nodesDestroyNode((SNode*)pPartFunc); - nodesDestroyNode((SNode*)pMergeFunc); - code = TSDB_CODE_OUT_OF_MEMORY; + code = nodesCloneNode(pNode, (SNode**)&pPartFunc); + if (TSDB_CODE_SUCCESS == code) { + code = nodesCloneNode(pNode, (SNode**)&pMergeFunc); } - if(pMidFuncs != NULL){ - pMidFunc = (SFunctionNode*)nodesCloneNode(pNode); + if(TSDB_CODE_SUCCESS == code && pMidFuncs != NULL){ + code = nodesCloneNode(pNode, (SNode**)&pMidFunc); if (NULL == pMidFunc) { nodesDestroyNode((SNode*)pMidFunc); - code = TSDB_CODE_OUT_OF_MEMORY; } } } else { @@ -419,9 +423,10 @@ static int32_t stbSplAppendWStart(SNodeList* pFuncs, int32_t* pIndex, uint8_t pr ++index; } - SFunctionNode* pWStart = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); + SFunctionNode* pWStart = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pWStart); if (NULL == pWStart) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } strcpy(pWStart->functionName, "_wstart"); int64_t pointer = (int64_t)pWStart; @@ -431,7 +436,7 @@ static int32_t stbSplAppendWStart(SNodeList* pFuncs, int32_t* pIndex, uint8_t pr strncpy(pWStart->node.aliasName, name, TSDB_COL_NAME_LEN - 1); pWStart->node.resType.precision = precision; - int32_t code = fmGetFuncInfo(pWStart, NULL, 0); + code = fmGetFuncInfo(pWStart, NULL, 0); if (TSDB_CODE_SUCCESS == code) { code = nodesListStrictAppend(pFuncs, (SNode*)pWStart); } @@ -450,9 +455,10 @@ static int32_t stbSplAppendWEnd(SWindowLogicNode* pWin, int32_t* pIndex) { ++index; } - SFunctionNode* pWEnd = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); + SFunctionNode* pWEnd = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pWEnd); if (NULL == pWEnd) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } strcpy(pWEnd->functionName, "_wend"); int64_t pointer = (int64_t)pWEnd; @@ -461,7 +467,7 @@ static int32_t stbSplAppendWEnd(SWindowLogicNode* pWin, int32_t* pIndex) { taosCreateMD5Hash(name, len); strncpy(pWEnd->node.aliasName, name, TSDB_COL_NAME_LEN - 1); - int32_t code = fmGetFuncInfo(pWEnd, NULL, 0); + code = fmGetFuncInfo(pWEnd, NULL, 0); if (TSDB_CODE_SUCCESS == code) { code = nodesListStrictAppend(pWin->pFuncs, (SNode*)pWEnd); } @@ -482,9 +488,10 @@ static int32_t stbSplCreatePartWindowNode(SWindowLogicNode* pMergeWindow, SLogic SNode* pConditions = pMergeWindow->node.pConditions; pMergeWindow->node.pConditions = NULL; - SWindowLogicNode* pPartWin = (SWindowLogicNode*)nodesCloneNode((SNode*)pMergeWindow); + SWindowLogicNode* pPartWin = NULL; + int32_t code = nodesCloneNode((SNode*)pMergeWindow, (SNode**)&pPartWin); if (NULL == pPartWin) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pPartWin->node.groupAction = GROUP_ACTION_KEEP; @@ -494,7 +501,7 @@ static int32_t stbSplCreatePartWindowNode(SWindowLogicNode* pMergeWindow, SLogic splSetParent((SLogicNode*)pPartWin); int32_t index = 0; - int32_t code = stbSplRewriteFuns(pFunc, &pPartWin->pFuncs, NULL, &pMergeWindow->pFuncs); + code = stbSplRewriteFuns(pFunc, &pPartWin->pFuncs, NULL, &pMergeWindow->pFuncs); if (TSDB_CODE_SUCCESS == code) { code = stbSplAppendWStart(pPartWin->pFuncs, &index, ((SColumnNode*)pMergeWindow->pTspk)->node.resType.precision); } @@ -503,10 +510,8 @@ static int32_t stbSplCreatePartWindowNode(SWindowLogicNode* pMergeWindow, SLogic } if (TSDB_CODE_SUCCESS == code) { nodesDestroyNode(pMergeWindow->pTspk); - pMergeWindow->pTspk = nodesCloneNode(nodesListGetNode(pPartWin->node.pTargets, index)); - if (NULL == pMergeWindow->pTspk) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + pMergeWindow->pTspk = NULL; + code = nodesCloneNode(nodesListGetNode(pPartWin->node.pTargets, index), &pMergeWindow->pTspk); } nodesDestroyList(pFunc); @@ -529,14 +534,17 @@ static int32_t stbSplCreatePartMidWindowNode(SWindowLogicNode* pMergeWindow, SLo SNode* pConditions = pMergeWindow->node.pConditions; pMergeWindow->node.pConditions = NULL; - SWindowLogicNode* pPartWin = (SWindowLogicNode*)nodesCloneNode((SNode*)pMergeWindow); + SWindowLogicNode* pPartWin = NULL; + int32_t code = nodesCloneNode((SNode*)pMergeWindow, (SNode**)&pPartWin); if (NULL == pPartWin) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - SWindowLogicNode* pMidWin = (SWindowLogicNode*)nodesCloneNode((SNode*)pMergeWindow); + SWindowLogicNode* pMidWin = NULL; + code = nodesCloneNode((SNode*)pMergeWindow, (SNode**)&pMidWin); if (NULL == pMidWin) { - return TSDB_CODE_OUT_OF_MEMORY; + nodesDestroyNode((SNode*)pPartWin); + return code; } pPartWin->node.groupAction = GROUP_ACTION_KEEP; @@ -550,7 +558,7 @@ static int32_t stbSplCreatePartMidWindowNode(SWindowLogicNode* pMergeWindow, SLo SNodeList* pFuncPart = NULL; SNodeList* pFuncMid = NULL; SNodeList* pFuncMerge = NULL; - int32_t code = stbSplRewriteFuns(pFunc, &pFuncPart, &pFuncMid, &pFuncMerge); + code = stbSplRewriteFuns(pFunc, &pFuncPart, &pFuncMid, &pFuncMerge); pPartWin->pFuncs = pFuncPart; pMidWin->pFuncs = pFuncMid; pMergeWindow->pFuncs = pFuncMerge; @@ -565,10 +573,8 @@ static int32_t stbSplCreatePartMidWindowNode(SWindowLogicNode* pMergeWindow, SLo if (TSDB_CODE_SUCCESS == code) { nodesDestroyNode(pMidWin->pTspk); - pMidWin->pTspk = nodesCloneNode(nodesListGetNode(pPartWin->node.pTargets, index)); - if (NULL == pMidWin->pTspk) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + pMidWin->pTspk = NULL; + code = nodesCloneNode(nodesListGetNode(pPartWin->node.pTargets, index), &pMidWin->pTspk); } if (TSDB_CODE_SUCCESS == code) { @@ -580,10 +586,7 @@ static int32_t stbSplCreatePartMidWindowNode(SWindowLogicNode* pMergeWindow, SLo if (TSDB_CODE_SUCCESS == code) { nodesDestroyNode(pMergeWindow->pTspk); - pMergeWindow->pTspk = nodesCloneNode(nodesListGetNode(pMidWin->node.pTargets, index)); - if (NULL == pMergeWindow->pTspk) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + code = nodesCloneNode(nodesListGetNode(pMidWin->node.pTargets, index), &pMergeWindow->pTspk); } nodesDestroyList(pFunc); @@ -649,9 +652,10 @@ static int32_t stbSplRewriteFromMergeNode(SMergeLogicNode* pMerge, SLogicNode* p static int32_t stbSplCreateMergeNode(SSplitContext* pCxt, SLogicSubplan* pSubplan, SLogicNode* pSplitNode, SNodeList* pMergeKeys, SLogicNode* pPartChild, bool groupSort, bool needSort) { - SMergeLogicNode* pMerge = (SMergeLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_MERGE); + SMergeLogicNode* pMerge = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_MERGE, (SNode**)&pMerge); if (NULL == pMerge) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pMerge->needSort = needSort; pMerge->numOfChannels = stbSplGetNumOfVgroups(pPartChild); @@ -662,22 +666,19 @@ static int32_t stbSplCreateMergeNode(SSplitContext* pCxt, SLogicSubplan* pSubpla pMerge->groupSort = groupSort; pMerge->numOfSubplans = 1; - int32_t code = TSDB_CODE_SUCCESS; - pMerge->pInputs = nodesCloneList(pPartChild->pTargets); - // NULL != pSubplan means 'merge node' replaces 'split node'. - if (NULL == pSubplan) { - pMerge->node.pTargets = nodesCloneList(pPartChild->pTargets); - } else { - pMerge->node.pTargets = nodesCloneList(pSplitNode->pTargets); - } - if (NULL == pMerge->node.pTargets || NULL == pMerge->pInputs) { - code = TSDB_CODE_OUT_OF_MEMORY; + pMerge->pInputs = NULL; + code = nodesCloneList(pPartChild->pTargets, &pMerge->pInputs); + if (TSDB_CODE_SUCCESS == code) { + // NULL != pSubplan means 'merge node' replaces 'split node'. + if (NULL == pSubplan) { + code = nodesCloneList(pPartChild->pTargets, &pMerge->node.pTargets); + } else { + code = nodesCloneList(pSplitNode->pTargets, &pMerge->node.pTargets); + } } if (TSDB_CODE_SUCCESS == code && NULL != pSplitNode->pLimit) { - pMerge->node.pLimit = nodesCloneNode(pSplitNode->pLimit); - if (NULL == pMerge->node.pLimit) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + pMerge->node.pLimit = NULL; + code = nodesCloneNode(pSplitNode->pLimit, &pMerge->node.pLimit); ((SLimitNode*)pSplitNode->pLimit)->limit += ((SLimitNode*)pSplitNode->pLimit)->offset; ((SLimitNode*)pSplitNode->pLimit)->offset = 0; } @@ -708,14 +709,16 @@ static int32_t stbSplCreateExchangeNode(SSplitContext* pCxt, SLogicNode* pParent } static int32_t stbSplCreateMergeKeysByExpr(SNode* pExpr, EOrder order, SNodeList** pMergeKeys) { - SOrderByExprNode* pOrderByExpr = (SOrderByExprNode*)nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR); + SOrderByExprNode* pOrderByExpr = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR, (SNode**)&pOrderByExpr); if (NULL == pOrderByExpr) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } - pOrderByExpr->pExpr = nodesCloneNode(pExpr); + pOrderByExpr->pExpr = NULL; + code = nodesCloneNode(pExpr, &pOrderByExpr->pExpr); if (NULL == pOrderByExpr->pExpr) { nodesDestroyNode((SNode*)pOrderByExpr); - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pOrderByExpr->order = order; pOrderByExpr->nullOrder = (order == ORDER_ASC) ? NULL_ORDER_FIRST : NULL_ORDER_LAST; @@ -745,7 +748,7 @@ static int32_t stbSplSplitIntervalForBatch(SSplitContext* pCxt, SStableSplitInfo SLogicSubplan* pSplitSubPlan = NULL; if (TSDB_CODE_SUCCESS == code) { pSplitSubPlan = splCreateScanSubplan(pCxt, pPartWindow, SPLIT_FLAG_STABLE_SPLIT); - if (!pSplitSubPlan) code = TSDB_CODE_OUT_OF_MEMORY; + if (!pSplitSubPlan) code = terrno; } if (code == TSDB_CODE_SUCCESS) { SNode* pNode; @@ -793,11 +796,14 @@ static int32_t stbSplSplitIntervalForStreamMultiAgg(SSplitContext* pCxt, SStable } if (TSDB_CODE_SUCCESS == code) { - SNode* subPlan = (SNode*)splCreateSubplan(pCxt, pMidWindow); - ((SLogicSubplan*)subPlan)->subplanType = SUBPLAN_TYPE_MERGE; + SNode* subPlan = NULL; + code = splCreateSubplan(pCxt, pMidWindow, (SLogicSubplan**)&subPlan); + if (TSDB_CODE_SUCCESS == code) { + ((SLogicSubplan*)subPlan)->subplanType = SUBPLAN_TYPE_MERGE; - code = nodesListMakeStrictAppend(&((SLogicSubplan*)subPlan)->pChildren, - (SNode*)splCreateScanSubplan(pCxt, pPartWindow, SPLIT_FLAG_STABLE_SPLIT)); + code = nodesListMakeStrictAppend(&((SLogicSubplan*)subPlan)->pChildren, + (SNode*)splCreateScanSubplan(pCxt, pPartWindow, SPLIT_FLAG_STABLE_SPLIT)); + } if (TSDB_CODE_SUCCESS == code) { code = nodesListMakeStrictAppend(&pInfo->pSubplan->pChildren, subPlan); } @@ -828,9 +834,10 @@ static int32_t stbSplSplitSessionForStream(SSplitContext* pCxt, SStableSplitInfo int32_t code = stbSplAppendWEnd(pPartWin, &index); if (TSDB_CODE_SUCCESS == code) { nodesDestroyNode(pMergeWin->pTsEnd); - pMergeWin->pTsEnd = nodesCloneNode(nodesListGetNode(pPartWin->node.pTargets, index)); + pMergeWin->pTsEnd = NULL; + code = nodesCloneNode(nodesListGetNode(pPartWin->node.pTargets, index), &pMergeWin->pTsEnd); if (NULL == pMergeWin->pTsEnd) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = code; } } code = stbSplCreateExchangeNode(pCxt, pInfo->pSplitNode, pPartWindow); @@ -1006,24 +1013,21 @@ static int32_t stbSplCreatePartAggNode(SAggLogicNode* pMergeAgg, SLogicNode** pO SNode* pConditions = pMergeAgg->node.pConditions; pMergeAgg->node.pConditions = NULL; - SAggLogicNode* pPartAgg = (SAggLogicNode*)nodesCloneNode((SNode*)pMergeAgg); + SAggLogicNode* pPartAgg = NULL; + int32_t code = nodesCloneNode((SNode*)pMergeAgg, (SNode**)&pPartAgg); if (NULL == pPartAgg) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pPartAgg->node.groupAction = GROUP_ACTION_KEEP; - int32_t code = TSDB_CODE_SUCCESS; - if (NULL != pGroupKeys) { pPartAgg->pGroupKeys = pGroupKeys; code = createColumnByRewriteExprs(pPartAgg->pGroupKeys, &pPartAgg->node.pTargets); } if (TSDB_CODE_SUCCESS == code && NULL != pGroupKeys) { - pMergeAgg->pGroupKeys = nodesCloneList(pPartAgg->node.pTargets); - if (NULL == pMergeAgg->pGroupKeys) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + pMergeAgg->pGroupKeys = NULL; + code = nodesCloneList(pPartAgg->node.pTargets, &pMergeAgg->pGroupKeys); } if (TSDB_CODE_SUCCESS == code) { pMergeAgg->node.pConditions = pConditions; @@ -1090,7 +1094,7 @@ static int32_t stbSplAggNodeCreateMerge(SSplitContext* pCtx, SStableSplitInfo* p if (idx++ < originalLen) continue; SFunctionNode* pGroupKeyFunc = createGroupKeyAggFunc((SColumnNode*)node); if (!pGroupKeyFunc) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; break; } code = nodesListMakeStrictAppend(&extraAggFuncs, (SNode*)pGroupKeyFunc); @@ -1165,7 +1169,7 @@ static int32_t stbSplSplitAggNodeForCrossTableMulSubplan(SSplitContext* pCxt, SS if (code == TSDB_CODE_SUCCESS) { pFirstScanSubplan = splCreateScanSubplan(pCxt, pPartAgg, SPLIT_FLAG_STABLE_SPLIT); - if (!pFirstScanSubplan) code = TSDB_CODE_OUT_OF_MEMORY; + if (!pFirstScanSubplan) code = terrno; } if (code == TSDB_CODE_SUCCESS) { @@ -1220,7 +1224,7 @@ static int32_t stbSplSplitAggNodeForCrossTable(SSplitContext* pCxt, SStableSplit SLogicSubplan* pScanSubplan = NULL; if (TSDB_CODE_SUCCESS == code) { pScanSubplan = splCreateScanSubplan(pCxt, pPartAgg, SPLIT_FLAG_STABLE_SPLIT); - if (!pScanSubplan) code = TSDB_CODE_OUT_OF_MEMORY; + if (!pScanSubplan) code = terrno; } if (code == TSDB_CODE_SUCCESS) { @@ -1242,10 +1246,11 @@ static int32_t stbSplSplitAggNode(SSplitContext* pCxt, SStableSplitInfo* pInfo) return stbSplSplitAggNodeForCrossTable(pCxt, pInfo); } -static SNode* stbSplCreateColumnNode(SExprNode* pExpr) { - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); +static int32_t stbSplCreateColumnNode(SExprNode* pExpr, SNode** ppNode) { + SColumnNode* pCol = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); if (NULL == pCol) { - return NULL; + return code; } if (QUERY_NODE_COLUMN == nodeType(pExpr)) { strcpy(pCol->dbName, ((SColumnNode*)pExpr)->dbName); @@ -1258,22 +1263,26 @@ static SNode* stbSplCreateColumnNode(SExprNode* pExpr) { strcpy(pCol->node.aliasName, pExpr->aliasName); strcpy(pCol->node.userAlias, pExpr->userAlias); pCol->node.resType = pExpr->resType; - return (SNode*)pCol; + *ppNode = (SNode*)pCol; + return code; } -static SNode* stbSplCreateOrderByExpr(SOrderByExprNode* pSortKey, SNode* pCol) { - SOrderByExprNode* pOutput = (SOrderByExprNode*)nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR); +static int32_t stbSplCreateOrderByExpr(SOrderByExprNode* pSortKey, SNode* pCol, SNode** ppNode) { + SOrderByExprNode* pOutput = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_ORDER_BY_EXPR, (SNode**)&pOutput); if (NULL == pOutput) { - return NULL; + return code; } - pOutput->pExpr = nodesCloneNode(pCol); + pOutput->pExpr = NULL; + code = nodesCloneNode(pCol, &pOutput->pExpr); if (NULL == pOutput->pExpr) { nodesDestroyNode((SNode*)pOutput); - return NULL; + return code; } pOutput->order = pSortKey->order; pOutput->nullOrder = pSortKey->nullOrder; - return (SNode*)pOutput; + *ppNode = (SNode*)pOutput; + return code; } static int32_t stbSplCreateMergeKeys(SNodeList* pSortKeys, SNodeList* pTargets, SNodeList** pOutput) { @@ -1288,7 +1297,11 @@ static int32_t stbSplCreateMergeKeys(SNodeList* pSortKeys, SNodeList* pTargets, FOREACH(pTarget, pTargets) { if ((QUERY_NODE_COLUMN == nodeType(pSortExpr) && nodesEqualNode((SNode*)pSortExpr, pTarget)) || (0 == strcmp(pSortExpr->aliasName, ((SColumnNode*)pTarget)->colName))) { - code = nodesListMakeStrictAppend(&pMergeKeys, stbSplCreateOrderByExpr(pSortKey, pTarget)); + SNode* pNew = NULL; + code = stbSplCreateOrderByExpr(pSortKey, pTarget, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pMergeKeys, pNew); + } if (TSDB_CODE_SUCCESS != code) { break; } @@ -1296,8 +1309,15 @@ static int32_t stbSplCreateMergeKeys(SNodeList* pSortKeys, SNodeList* pTargets, } } if (TSDB_CODE_SUCCESS == code && !found) { - SNode* pCol = stbSplCreateColumnNode(pSortExpr); - code = nodesListMakeStrictAppend(&pMergeKeys, stbSplCreateOrderByExpr(pSortKey, pCol)); + SNode* pCol = NULL; + code = stbSplCreateColumnNode(pSortExpr, &pCol); + if (TSDB_CODE_SUCCESS == code) { + SNode* pNew = NULL; + code = stbSplCreateOrderByExpr(pSortKey, pCol, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pMergeKeys, pNew); + } + } if (TSDB_CODE_SUCCESS == code) { code = nodesListStrictAppend(pTargets, pCol); } else { @@ -1324,9 +1344,10 @@ static int32_t stbSplCreatePartSortNode(SSortLogicNode* pSort, SLogicNode** pOut pSort->node.pChildren = NULL; int32_t code = TSDB_CODE_SUCCESS; - SSortLogicNode* pPartSort = (SSortLogicNode*)nodesCloneNode((SNode*)pSort); + SSortLogicNode* pPartSort = NULL; + code = nodesCloneNode((SNode*)pSort, (SNode**)&pPartSort); if (NULL == pPartSort) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = code; } SNodeList* pMergeKeys = NULL; @@ -1392,9 +1413,10 @@ static int32_t stbSplGetSplitNodeForScan(SStableSplitInfo* pInfo, SLogicNode** p !((SProjectLogicNode*)pInfo->pSplitNode->pParent)->inputIgnoreGroup) { *pSplitNode = pInfo->pSplitNode->pParent; if (NULL != pInfo->pSplitNode->pLimit) { - (*pSplitNode)->pLimit = nodesCloneNode(pInfo->pSplitNode->pLimit); + (*pSplitNode)->pLimit = NULL; + int32_t code = nodesCloneNode(pInfo->pSplitNode->pLimit, &(*pSplitNode)->pLimit); if (NULL == (*pSplitNode)->pLimit) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } ((SLimitNode*)pInfo->pSplitNode->pLimit)->limit += ((SLimitNode*)pInfo->pSplitNode->pLimit)->offset; ((SLimitNode*)pInfo->pSplitNode->pLimit)->offset = 0; @@ -1436,7 +1458,7 @@ static int32_t stbSplSplitScanNodeWithPartTags(SSplitContext* pCxt, SStableSplit return code; } -static SNode* stbSplFindPrimaryKeyFromScan(SScanLogicNode* pScan) { +static int32_t stbSplFindPrimaryKeyFromScan(SScanLogicNode* pScan, SNode** ppNode) { bool find = false; SNode* pCol = NULL; FOREACH(pCol, pScan->pScanCols) { @@ -1446,19 +1468,29 @@ static SNode* stbSplFindPrimaryKeyFromScan(SScanLogicNode* pScan) { } } if (!find) { - return NULL; + *ppNode = NULL; + return TSDB_CODE_SUCCESS; } SNode* pTarget = NULL; FOREACH(pTarget, pScan->node.pTargets) { if (nodesEqualNode(pTarget, pCol)) { - return pCol; + *ppNode = pCol; + return TSDB_CODE_SUCCESS; } } - nodesListStrictAppend(pScan->node.pTargets, nodesCloneNode(pCol)); - return pCol; + SNode* pNew = NULL; + int32_t code = nodesCloneNode(pCol, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pScan->node.pTargets, pNew); + } + if (TSDB_CODE_SUCCESS == code) { + *ppNode = pCol; + } + return code; } -static SNode* stbSplFindPkFromScan(SScanLogicNode* pScan) { +static int32_t stbSplFindPkFromScan(SScanLogicNode* pScan, SNode** ppNode) { + int32_t code = 0; bool find = false; SNode* pCol = NULL; FOREACH(pCol, pScan->pScanCols) { @@ -1468,16 +1500,25 @@ static SNode* stbSplFindPkFromScan(SScanLogicNode* pScan) { } } if (!find) { - return NULL; + *ppNode = NULL; + return code; } SNode* pTarget = NULL; FOREACH(pTarget, pScan->node.pTargets) { if (nodesEqualNode(pTarget, pCol)) { - return pCol; + *ppNode = pCol; + return code; } } - nodesListStrictAppend(pScan->node.pTargets, nodesCloneNode(pCol)); - return pCol; + SNode* pNew = NULL; + code = nodesCloneNode(pCol, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListStrictAppend(pScan->node.pTargets, pNew); + } + if (TSDB_CODE_SUCCESS == code) { + *ppNode = pCol; + } + return code; } static int32_t stbSplCreateMergeScanNode(SScanLogicNode* pScan, SLogicNode** pOutputMergeScan, @@ -1486,9 +1527,10 @@ static int32_t stbSplCreateMergeScanNode(SScanLogicNode* pScan, SLogicNode** pOu pScan->node.pChildren = NULL; int32_t code = TSDB_CODE_SUCCESS; - SScanLogicNode* pMergeScan = (SScanLogicNode*)nodesCloneNode((SNode*)pScan); + SScanLogicNode* pMergeScan = NULL; + code = nodesCloneNode((SNode*)pScan, (SNode**)&pMergeScan); if (NULL == pMergeScan) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = code; } SNodeList* pMergeKeys = NULL; @@ -1498,9 +1540,15 @@ static int32_t stbSplCreateMergeScanNode(SScanLogicNode* pScan, SLogicNode** pOu pMergeScan->node.pChildren = pChildren; splSetParent((SLogicNode*)pMergeScan); - SNode* pTs = stbSplFindPrimaryKeyFromScan(pMergeScan); - code = stbSplCreateMergeKeysByPrimaryKey(pTs, pMergeScan->scanSeq[0] > 0 ? ORDER_ASC : ORDER_DESC, &pMergeKeys); - SNode* pPk = stbSplFindPkFromScan(pMergeScan); + SNode* pTs = NULL; + code = stbSplFindPrimaryKeyFromScan(pMergeScan, &pTs); + if (TSDB_CODE_SUCCESS == code) { + code = stbSplCreateMergeKeysByPrimaryKey(pTs, pMergeScan->scanSeq[0] > 0 ? ORDER_ASC : ORDER_DESC, &pMergeKeys); + } + SNode* pPk = NULL; + if (TSDB_CODE_SUCCESS == code) { + code = stbSplFindPkFromScan(pMergeScan, &pPk); + } if (TSDB_CODE_SUCCESS == code && NULL != pPk) { code = stbSplCreateMergeKeysByExpr(pPk, pMergeScan->scanSeq[0] > 0 ? ORDER_ASC : ORDER_DESC, &pMergeKeys); } @@ -1589,11 +1637,16 @@ static int32_t stbSplSplitJoinNode(SSplitContext* pCxt, SStableSplitInfo* pInfo) static int32_t stbSplCreateMergeKeysForPartitionNode(SLogicNode* pPart, SNodeList** pMergeKeys) { SScanLogicNode* pScan = (SScanLogicNode*)nodesListGetNode(pPart->pChildren, 0); - SNode* pPrimaryKey = nodesCloneNode(stbSplFindPrimaryKeyFromScan(pScan)); - if (NULL == pPrimaryKey) { - return TSDB_CODE_OUT_OF_MEMORY; + SNode* pPK = NULL; + SNode* pPrimaryKey = NULL; + int32_t code = stbSplFindPrimaryKeyFromScan(pScan, &pPK); + if (TSDB_CODE_SUCCESS == code) { + code = nodesCloneNode(pPK, &pPrimaryKey); } - int32_t code = nodesListAppend(pPart->pTargets, pPrimaryKey); + if (NULL == pPrimaryKey) { + return code; + } + code = nodesListStrictAppend(pPart->pTargets, pPrimaryKey); if (TSDB_CODE_SUCCESS == code) { code = stbSplCreateMergeKeysByPrimaryKey(pPrimaryKey, pScan->scanSeq[0] > 0 ? ORDER_ASC : ORDER_DESC, pMergeKeys); } @@ -1711,8 +1764,11 @@ static int32_t unionSplitSubplan(SSplitContext* pCxt, SLogicSubplan* pUnionSubpl SNode* pChild = NULL; FOREACH(pChild, pSplitNode->pChildren) { - SLogicSubplan* pNewSubplan = splCreateSubplan(pCxt, (SLogicNode*)pChild); - code = nodesListMakeStrictAppend(&pUnionSubplan->pChildren, (SNode*)pNewSubplan); + SLogicSubplan* pNewSubplan = NULL; + code = splCreateSubplan(pCxt, (SLogicNode*)pChild, &pNewSubplan); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pUnionSubplan->pChildren, (SNode*)pNewSubplan); + } if (TSDB_CODE_SUCCESS == code) { REPLACE_NODE(NULL); code = splMountSubplan(pNewSubplan, pSubplanChildren); @@ -1752,17 +1808,25 @@ static bool unAllSplFindSplitNode(SSplitContext* pCxt, SLogicSubplan* pSubplan, static int32_t unAllSplCreateExchangeNode(SSplitContext* pCxt, int32_t startGroupId, SLogicSubplan* pSubplan, SProjectLogicNode* pProject) { - SExchangeLogicNode* pExchange = (SExchangeLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_EXCHANGE); + SExchangeLogicNode* pExchange = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_EXCHANGE, (SNode**)&pExchange); if (NULL == pExchange) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pExchange->srcStartGroupId = startGroupId; pExchange->srcEndGroupId = pCxt->groupId - 1; pExchange->node.precision = pProject->node.precision; - pExchange->node.pTargets = nodesCloneList(pProject->node.pTargets); - pExchange->node.pConditions = nodesCloneNode(pProject->node.pConditions); - if (NULL == pExchange->node.pTargets || (NULL != pProject->node.pConditions && NULL == pExchange->node.pConditions)) { - return TSDB_CODE_OUT_OF_MEMORY; + pExchange->node.pTargets = NULL; + code = nodesCloneList(pProject->node.pTargets, &pExchange->node.pTargets); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pExchange); + return code; + } + pExchange->node.pConditions = NULL; + code = nodesCloneNode(pProject->node.pConditions, &pExchange->node.pConditions); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode((SNode*)pExchange); + return code; } TSWAP(pExchange->node.pLimit, pProject->node.pLimit); @@ -1808,21 +1872,24 @@ typedef struct SUnionDistinctSplitInfo { static int32_t unDistSplCreateExchangeNode(SSplitContext* pCxt, int32_t startGroupId, SLogicSubplan* pSubplan, SAggLogicNode* pAgg) { - SExchangeLogicNode* pExchange = (SExchangeLogicNode*)nodesMakeNode(QUERY_NODE_LOGIC_PLAN_EXCHANGE); + SExchangeLogicNode* pExchange = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_PLAN_EXCHANGE, (SNode**)&pExchange); if (NULL == pExchange) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } pExchange->srcStartGroupId = startGroupId; pExchange->srcEndGroupId = pCxt->groupId - 1; pExchange->node.precision = pAgg->node.precision; - pExchange->node.pTargets = nodesCloneList(pAgg->pGroupKeys); + pExchange->node.pTargets = NULL; + code = nodesCloneList(pAgg->pGroupKeys, &pExchange->node.pTargets); if (NULL == pExchange->node.pTargets) { - return TSDB_CODE_OUT_OF_MEMORY; + nodesDestroyNode((SNode*)pExchange); + return code; } pSubplan->subplanType = SUBPLAN_TYPE_MERGE; - return nodesListMakeAppend(&pAgg->node.pChildren, (SNode*)pExchange); + return nodesListMakeStrictAppend(&pAgg->node.pChildren, (SNode*)pExchange); } static bool unDistSplFindSplitNode(SSplitContext* pCxt, SLogicSubplan* pSubplan, SLogicNode* pNode, @@ -1910,10 +1977,7 @@ static int32_t insertSelectSplit(SSplitContext* pCxt, SLogicSubplan* pSubplan) { SNodeList* pSubplanChildren = info.pSubplan->pChildren; int32_t code = splCreateExchangeNodeForSubplan(pCxt, info.pSubplan, info.pQueryRoot, SUBPLAN_TYPE_MODIFY); if (TSDB_CODE_SUCCESS == code) { - pNewSubplan = splCreateSubplan(pCxt, info.pQueryRoot); - if (NULL == pNewSubplan) { - code = TSDB_CODE_OUT_OF_MEMORY; - } + code = splCreateSubplan(pCxt, info.pQueryRoot, &pNewSubplan); } if (TSDB_CODE_SUCCESS == code) { code = nodesListMakeStrictAppend(&info.pSubplan->pChildren, (SNode*)pNewSubplan); @@ -1967,7 +2031,7 @@ static int32_t qnodeSplit(SSplitContext* pCxt, SLogicSubplan* pSubplan) { } code = nodesListMakeStrictAppend(&info.pSubplan->pChildren, (SNode*)pScanSubplan); } else { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; } } info.pSubplan->subplanType = SUBPLAN_TYPE_COMPUTE; diff --git a/source/libs/planner/src/planUtil.c b/source/libs/planner/src/planUtil.c index 02572a1a90..95a2f1463d 100644 --- a/source/libs/planner/src/planUtil.c +++ b/source/libs/planner/src/planUtil.c @@ -49,7 +49,8 @@ static EDealRes doCreateColumn(SNode* pNode, void* pContext) { SCreateColumnCxt* pCxt = (SCreateColumnCxt*)pContext; switch (nodeType(pNode)) { case QUERY_NODE_COLUMN: { - SNode* pCol = nodesCloneNode(pNode); + SNode* pCol = NULL; + pCxt->errCode = nodesCloneNode(pNode, &pCol); if (NULL == pCol) { return DEAL_RES_ERROR; } @@ -61,7 +62,8 @@ static EDealRes doCreateColumn(SNode* pNode, void* pContext) { case QUERY_NODE_FUNCTION: case QUERY_NODE_CASE_WHEN: { SExprNode* pExpr = (SExprNode*)pNode; - SColumnNode* pCol = (SColumnNode*)nodesMakeNode(QUERY_NODE_COLUMN); + SColumnNode* pCol = NULL; + pCxt->errCode = nodesMakeNode(QUERY_NODE_COLUMN, (SNode**)&pCol); if (NULL == pCol) { return DEAL_RES_ERROR; } @@ -88,9 +90,12 @@ static EDealRes doCreateColumn(SNode* pNode, void* pContext) { } int32_t createColumnByRewriteExprs(SNodeList* pExprs, SNodeList** pList) { - SCreateColumnCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .pList = (NULL == *pList ? nodesMakeList() : *pList)}; - if (NULL == cxt.pList) { - return TSDB_CODE_OUT_OF_MEMORY; + SCreateColumnCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .pList = *pList}; + if (!cxt.pList) { + int32_t code = nodesMakeList(&cxt.pList); + if (TSDB_CODE_SUCCESS != code) { + return code; + } } nodesWalkExprs(pExprs, doCreateColumn, &cxt); @@ -105,9 +110,12 @@ int32_t createColumnByRewriteExprs(SNodeList* pExprs, SNodeList** pList) { } int32_t createColumnByRewriteExpr(SNode* pExpr, SNodeList** pList) { - SCreateColumnCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .pList = (NULL == *pList ? nodesMakeList() : *pList)}; - if (NULL == cxt.pList) { - return TSDB_CODE_OUT_OF_MEMORY; + SCreateColumnCxt cxt = {.errCode = TSDB_CODE_SUCCESS, .pList = *pList}; + if (!cxt.pList) { + int32_t code = nodesMakeList(&cxt.pList); + if (TSDB_CODE_SUCCESS != code) { + return code; + } } nodesWalkExpr(pExpr, doCreateColumn, &cxt); @@ -545,25 +553,35 @@ bool isPartTableWinodw(SWindowLogicNode* pWindow) { return pWindow->isPartTb || keysHasTbname(stbGetPartKeys((SLogicNode*)nodesListGetNode(pWindow->node.pChildren, 0))); } -bool cloneLimit(SLogicNode* pParent, SLogicNode* pChild, uint8_t cloneWhat) { - SLimitNode* pLimit; - bool cloned = false; +int32_t cloneLimit(SLogicNode* pParent, SLogicNode* pChild, uint8_t cloneWhat, bool* pCloned) { + SLimitNode* pLimit = NULL, *pSlimit = NULL; + int32_t code = 0; + bool cloned = false; if (pParent->pLimit && (cloneWhat & CLONE_LIMIT)) { - pChild->pLimit = nodesCloneNode(pParent->pLimit); - pLimit = (SLimitNode*)pChild->pLimit; - pLimit->limit += pLimit->offset; - pLimit->offset = 0; - cloned = true; + code = nodesCloneNode(pParent->pLimit, (SNode**)&pLimit); + if (TSDB_CODE_SUCCESS == code) { + pLimit->limit += pLimit->offset; + pLimit->offset = 0; + cloned = true; + } } if (pParent->pSlimit && (cloneWhat & CLONE_SLIMIT)) { - pChild->pSlimit = nodesCloneNode(pParent->pSlimit); - pLimit = (SLimitNode*)pChild->pSlimit; - pLimit->limit += pLimit->offset; - pLimit->offset = 0; - cloned = true; + code = nodesCloneNode(pParent->pSlimit, (SNode**)&pSlimit); + if (TSDB_CODE_SUCCESS == code) { + pSlimit->limit += pSlimit->offset; + pSlimit->offset = 0; + cloned = true; + } } - return cloned; + if (TSDB_CODE_SUCCESS == code) { + pChild->pLimit = (SNode*)pLimit; + pChild->pSlimit = (SNode*)pSlimit; + *pCloned = cloned; + } else { + nodesDestroyNode((SNode*)pLimit); + } + return code; } static EDealRes partTagsOptHasColImpl(SNode* pNode, void* pContext) { @@ -583,12 +601,17 @@ bool keysHasCol(SNodeList* pKeys) { } SFunctionNode* createGroupKeyAggFunc(SColumnNode* pGroupCol) { - SFunctionNode* pFunc = (SFunctionNode*)nodesMakeNode(QUERY_NODE_FUNCTION); + SFunctionNode* pFunc = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_FUNCTION, (SNode**)&pFunc); if (pFunc) { strcpy(pFunc->functionName, "_group_key"); strcpy(pFunc->node.aliasName, pGroupCol->node.aliasName); strcpy(pFunc->node.userAlias, pGroupCol->node.userAlias); - int32_t code = nodesListMakeStrictAppend(&pFunc->pParameterList, nodesCloneNode((SNode*)pGroupCol)); + SNode* pNew = NULL; + code = nodesCloneNode((SNode*)pGroupCol, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeStrictAppend(&pFunc->pParameterList, pNew); + } if (code == TSDB_CODE_SUCCESS) { code = fmGetFuncInfo(pFunc, NULL, 0); } @@ -596,10 +619,17 @@ SFunctionNode* createGroupKeyAggFunc(SColumnNode* pGroupCol) { nodesDestroyNode((SNode*)pFunc); pFunc = NULL; } - 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); - strncpy(pFunc->node.aliasName, name, TSDB_COL_NAME_LEN - 1); + 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); + strncpy(pFunc->node.aliasName, name, TSDB_COL_NAME_LEN - 1); + } + } + if (TSDB_CODE_SUCCESS != code) { + terrno = code; + nodesDestroyNode((SNode*)pFunc); + pFunc = NULL; } return pFunc; } @@ -656,14 +686,20 @@ int32_t tagScanSetExecutionMode(SScanLogicNode* pScan) { return TSDB_CODE_SUCCESS; } - SNode* pCond = nodesCloneNode(pScan->node.pConditions); + SNode* pCond = NULL; + int32_t code = nodesCloneNode(pScan->node.pConditions, &pCond); + if (TSDB_CODE_SUCCESS != code) { + return code; + } SNode* pTagCond = NULL; SNode* pTagIndexCond = NULL; - filterPartitionCond(&pCond, NULL, &pTagIndexCond, &pTagCond, NULL); - if (pTagIndexCond || tagScanNodeHasTbname(pTagCond)) { - pScan->onlyMetaCtbIdx = false; - } else { - pScan->onlyMetaCtbIdx = true; + code = filterPartitionCond(&pCond, NULL, &pTagIndexCond, &pTagCond, NULL); + if (TSDB_CODE_SUCCESS == code) { + if (pTagIndexCond || tagScanNodeHasTbname(pTagCond)) { + pScan->onlyMetaCtbIdx = false; + } else { + pScan->onlyMetaCtbIdx = true; + } } nodesDestroyNode(pCond); nodesDestroyNode(pTagIndexCond); diff --git a/source/libs/planner/src/planner.c b/source/libs/planner/src/planner.c index 78ae541166..eb5b47f011 100644 --- a/source/libs/planner/src/planner.c +++ b/source/libs/planner/src/planner.c @@ -72,10 +72,15 @@ int32_t qCreateQueryPlan(SPlanContext* pCxt, SQueryPlan** pPlan, SArray* pExecNo } static int32_t setSubplanExecutionNode(SPhysiNode* pNode, int32_t groupId, SDownstreamSourceNode* pSource) { + int32_t code = 0; if (QUERY_NODE_PHYSICAL_PLAN_EXCHANGE == nodeType(pNode)) { SExchangePhysiNode* pExchange = (SExchangePhysiNode*)pNode; if (groupId >= pExchange->srcStartGroupId && groupId <= pExchange->srcEndGroupId) { - return nodesListMakeStrictAppend(&pExchange->pSrcEndPoints, nodesCloneNode((SNode*)pSource)); + SNode* pNew = NULL; + code = nodesCloneNode((SNode*)pSource, &pNew); + if (TSDB_CODE_SUCCESS == code) { + return nodesListMakeStrictAppend(&pExchange->pSrcEndPoints, pNew); + } } } else if (QUERY_NODE_PHYSICAL_PLAN_MERGE == nodeType(pNode)) { SMergePhysiNode* pMerge = (SMergePhysiNode*)pNode; @@ -87,17 +92,23 @@ static int32_t setSubplanExecutionNode(SPhysiNode* pNode, int32_t groupId, SDown } else { --(pMerge->numOfChannels); } - return nodesListMakeStrictAppend(&pExchange->pSrcEndPoints, nodesCloneNode((SNode*)pSource)); + SNode* pNew = NULL; + code = nodesCloneNode((SNode*)pSource, &pNew); + if (TSDB_CODE_SUCCESS == code) { + return nodesListMakeStrictAppend(&pExchange->pSrcEndPoints, pNew); + } } } SNode* pChild = NULL; - FOREACH(pChild, pNode->pChildren) { - if (TSDB_CODE_SUCCESS != setSubplanExecutionNode((SPhysiNode*)pChild, groupId, pSource)) { - return TSDB_CODE_OUT_OF_MEMORY; + if (TSDB_CODE_SUCCESS == code) { + FOREACH(pChild, pNode->pChildren) { + if (TSDB_CODE_SUCCESS != (code = setSubplanExecutionNode((SPhysiNode*)pChild, groupId, pSource))) { + return code; + } } } - return TSDB_CODE_SUCCESS; + return code; } int32_t qContinuePlanPostQuery(void *pPostPlan) { diff --git a/source/libs/scalar/src/filter.c b/source/libs/scalar/src/filter.c index 19b4c521a4..29dba30669 100644 --- a/source/libs/scalar/src/filter.c +++ b/source/libs/scalar/src/filter.c @@ -3931,8 +3931,9 @@ int32_t fltSclGetOrCreateColumnRange(SColumnNode *colNode, SArray *colRangeList, } // TODO(smj):wait for nodesCloneNode change it's return value, use terrno for now. terrno = TSDB_CODE_SUCCESS; - SColumnNode *pColumnNode = (SColumnNode *)nodesCloneNode((SNode *)colNode); - FLT_ERR_RET(terrno); + SColumnNode *pColumnNode = NULL; + int32_t code = nodesCloneNode((SNode *)colNode, (SNode**)&pColumnNode); + FLT_ERR_RET(code); SFltSclColumnRange newColRange = {.colNode = pColumnNode, .points = taosArrayInit(4, sizeof(SFltSclPoint))}; if (NULL == newColRange.points) { FLT_ERR_RET(terrno); @@ -4915,16 +4916,22 @@ static int32_t fltSclCollectOperatorFromNode(SNode *pNode, SArray *sclOpList) { SValueNode *valNode = (SValueNode *)pOper->pRight; if (IS_NUMERIC_TYPE(valNode->node.resType.type) || valNode->node.resType.type == TSDB_DATA_TYPE_TIMESTAMP) { - SFltSclOperator sclOp = {.colNode = (SColumnNode *)nodesCloneNode(pOper->pLeft), - .valNode = (SValueNode *)nodesCloneNode(pOper->pRight), + SNode* pLeft = NULL, *pRight = NULL; + int32_t code = nodesCloneNode(pOper->pLeft, &pLeft); + if (TSDB_CODE_SUCCESS != code) { + FLT_ERR_RET(code); + } + code = nodesCloneNode(pOper->pRight, &pRight); + if (TSDB_CODE_SUCCESS != code) { + nodesDestroyNode(pLeft); + FLT_ERR_RET(code); + } + SFltSclOperator sclOp = {.colNode = (SColumnNode *)pLeft, + .valNode = (SValueNode *)pRight, .type = pOper->opType}; - if (NULL == sclOp.colNode) { - FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); - } - if (NULL == sclOp.valNode) { - FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); - } if (NULL == taosArrayPush(sclOpList, &sclOp)) { + nodesDestroyNode(pLeft); + nodesDestroyNode(pRight); FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); } } @@ -5209,8 +5216,12 @@ EConditionType filterClassifyCondition(SNode *pNode) { } int32_t filterIsMultiTableColsCond(SNode *pCond, bool *res) { - SNodeList *pCondCols = nodesMakeList(); - int32_t code = nodesCollectColumnsFromNode(pCond, NULL, COLLECT_COL_TYPE_ALL, &pCondCols); + SNodeList *pCondCols = NULL; + int32_t code = nodesMakeList(&pCondCols); + if (TSDB_CODE_SUCCESS!= code) { + return code; + } + code = nodesCollectColumnsFromNode(pCond, NULL, COLLECT_COL_TYPE_ALL, &pCondCols); if (code == TSDB_CODE_SUCCESS) { if (LIST_LENGTH(pCondCols) >= 2) { SColumnNode *pFirstCol = (SColumnNode *)nodesListGetNode(pCondCols, 0); @@ -5249,32 +5260,56 @@ static int32_t partitionLogicCond(SNode **pCondition, SNode **pPrimaryKeyCond, S } if (result) { if (NULL != pOtherCond) { - code = nodesListMakeAppend(&pOtherConds, nodesCloneNode(pCond)); + SNode* pNew = NULL; + code = nodesCloneNode(pCond, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeAppend(&pOtherConds, pNew); + } } } else { switch (filterClassifyCondition(pCond)) { case COND_TYPE_PRIMARY_KEY: if (NULL != pPrimaryKeyCond) { - code = nodesListMakeAppend(&pPrimaryKeyConds, nodesCloneNode(pCond)); + SNode* pNew = NULL; + code = nodesCloneNode(pCond, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeAppend(&pPrimaryKeyConds, pNew); + } } break; case COND_TYPE_TAG_INDEX: if (NULL != pTagIndexCond) { - code = nodesListMakeAppend(&pTagIndexConds, nodesCloneNode(pCond)); + SNode* pNew = NULL; + code = nodesCloneNode(pCond, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeAppend(&pTagIndexConds, pNew); + } } if (NULL != pTagCond) { - code = nodesListMakeAppend(&pTagConds, nodesCloneNode(pCond)); + SNode* pNew = NULL; + code = nodesCloneNode(pCond, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeAppend(&pTagConds, pNew); + } } break; case COND_TYPE_TAG: if (NULL != pTagCond) { - code = nodesListMakeAppend(&pTagConds, nodesCloneNode(pCond)); + SNode* pNew = NULL; + code = nodesCloneNode(pCond, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeAppend(&pTagConds, pNew); + } } break; case COND_TYPE_NORMAL: default: if (NULL != pOtherCond) { - code = nodesListMakeAppend(&pOtherConds, nodesCloneNode(pCond)); + SNode* pNew = NULL; + code = nodesCloneNode(pCond, &pNew); + if (TSDB_CODE_SUCCESS == code) { + code = nodesListMakeAppend(&pOtherConds, pNew); + } } break; } @@ -5361,9 +5396,10 @@ int32_t filterPartitionCond(SNode **pCondition, SNode **pPrimaryKeyCond, SNode * if (NULL != pTagCond) { SNode *pTempCond = *pCondition; if (NULL != pTagIndexCond) { - pTempCond = nodesCloneNode(*pCondition); + pTempCond = NULL; + int32_t code = nodesCloneNode(*pCondition, &pTempCond); if (NULL == pTempCond) { - return TSDB_CODE_OUT_OF_MEMORY; + return code; } } *pTagCond = pTempCond; diff --git a/source/libs/scalar/src/scalar.c b/source/libs/scalar/src/scalar.c index 040e090661..5e9c61eac6 100644 --- a/source/libs/scalar/src/scalar.c +++ b/source/libs/scalar/src/scalar.c @@ -1028,10 +1028,10 @@ _return: EDealRes sclRewriteNullInOptr(SNode **pNode, SScalarCtx *ctx, EOperatorType opType) { if (opType <= OP_TYPE_CALC_MAX) { - SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode *res = NULL; + ctx->code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res); if (NULL == res) { sclError("make value node failed"); - ctx->code = TSDB_CODE_OUT_OF_MEMORY; return DEAL_RES_ERROR; } @@ -1040,10 +1040,10 @@ EDealRes sclRewriteNullInOptr(SNode **pNode, SScalarCtx *ctx, EOperatorType opTy nodesDestroyNode(*pNode); *pNode = (SNode *)res; } else { - SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode *res = NULL; + ctx->code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res); if (NULL == res) { sclError("make value node failed"); - ctx->code = TSDB_CODE_OUT_OF_MEMORY; return DEAL_RES_ERROR; } @@ -1221,11 +1221,11 @@ EDealRes sclRewriteFunction(SNode **pNode, SScalarCtx *ctx) { return DEAL_RES_ERROR; } - SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode *res = NULL; + ctx->code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res); if (NULL == res) { sclError("make value node failed"); sclFreeParam(&output); - ctx->code = TSDB_CODE_OUT_OF_MEMORY; return DEAL_RES_ERROR; } @@ -1295,11 +1295,11 @@ EDealRes sclRewriteLogic(SNode **pNode, SScalarCtx *ctx) { return DEAL_RES_CONTINUE; } - SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode *res = NULL; + ctx->code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res); if (NULL == res) { sclError("make value node failed"); sclFreeParam(&output); - ctx->code = TSDB_CODE_OUT_OF_MEMORY; return DEAL_RES_ERROR; } @@ -1345,11 +1345,11 @@ EDealRes sclRewriteOperator(SNode **pNode, SScalarCtx *ctx) { return DEAL_RES_ERROR; } - SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode *res = NULL; + ctx->code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res); if (NULL == res) { sclError("make value node failed"); sclFreeParam(&output); - ctx->code = TSDB_CODE_OUT_OF_MEMORY; return DEAL_RES_ERROR; } @@ -1408,11 +1408,11 @@ EDealRes sclRewriteCaseWhen(SNode **pNode, SScalarCtx *ctx) { return DEAL_RES_ERROR; } - SValueNode *res = (SValueNode *)nodesMakeNode(QUERY_NODE_VALUE); + SValueNode *res = NULL; + ctx->code = nodesMakeNode(QUERY_NODE_VALUE, (SNode**)&res); if (NULL == res) { sclError("make value node failed"); sclFreeParam(&output); - ctx->code = TSDB_CODE_OUT_OF_MEMORY; return DEAL_RES_ERROR; } diff --git a/source/libs/scalar/test/filter/filterTests.cpp b/source/libs/scalar/test/filter/filterTests.cpp index 26f9024f3e..b210e2c326 100644 --- a/source/libs/scalar/test/filter/filterTests.cpp +++ b/source/libs/scalar/test/filter/filterTests.cpp @@ -63,9 +63,10 @@ void flttInitLogFile() { } int32_t flttMakeValueNode(SNode **pNode, int32_t dataType, void *value) { - SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_VALUE); + SNode *node = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_VALUE, &node); if (NULL == node) { - FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + FLT_ERR_RET(code); } SValueNode *vnode = (SValueNode *)node; vnode->node.resType.type = dataType; @@ -90,9 +91,10 @@ int32_t flttMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType, void *value) { static uint64_t dbidx = 0; - SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_COLUMN); + SNode *node = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, &node); if (NULL == node) { - FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + FLT_ERR_RET(code); } SColumnNode *rnode = (SColumnNode *)node; rnode->node.resType.type = dataType; @@ -170,9 +172,10 @@ int32_t flttMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType, } int32_t flttMakeOpNode(SNode **pNode, EOperatorType opType, int32_t resType, SNode *pLeft, SNode *pRight) { - SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_OPERATOR); + SNode *node = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_OPERATOR, &node); if (NULL == node) { - FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + FLT_ERR_RET(code); } SOperatorNode *onode = (SOperatorNode *)node; onode->node.resType.type = resType; @@ -187,16 +190,18 @@ int32_t flttMakeOpNode(SNode **pNode, EOperatorType opType, int32_t resType, SNo } int32_t flttMakeLogicNode(SNode **pNode, ELogicConditionType opType, SNode **nodeList, int32_t nodeNum) { - SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); + SNode *node = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, &node); if (NULL == node) { - FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + FLT_ERR_RET(code); } SLogicConditionNode *onode = (SLogicConditionNode *)node; onode->condType = opType; onode->node.resType.type = TSDB_DATA_TYPE_BOOL; onode->node.resType.bytes = sizeof(bool); - onode->pParameterList = nodesMakeList(); + onode->pParameterList = NULL; + code = nodesMakeList(&onode->pParameterList); for (int32_t i = 0; i < nodeNum; ++i) { FLT_ERR_RET(nodesListAppend(onode->pParameterList, nodeList[i])); } @@ -206,9 +211,10 @@ int32_t flttMakeLogicNode(SNode **pNode, ELogicConditionType opType, SNode **nod } int32_t flttMakeLogicNodeFromList(SNode **pNode, ELogicConditionType opType, SNodeList *nodeList) { - SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); + SNode *node = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, &node); if (NULL == node) { - FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + FLT_ERR_RET(code); } SLogicConditionNode *onode = (SLogicConditionNode *)node; onode->condType = opType; @@ -222,9 +228,10 @@ int32_t flttMakeLogicNodeFromList(SNode **pNode, ELogicConditionType opType, SNo } int32_t flttMakeListNode(SNode **pNode, SNodeList *list, int32_t resType) { - SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_NODE_LIST); + SNode *node = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_NODE_LIST, &node); if (NULL == node) { - FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + FLT_ERR_RET(code); } SNodeListNode *lnode = (SNodeListNode *)node; lnode->node.resType.type = resType; diff --git a/source/libs/scalar/test/scalar/scalarTests.cpp b/source/libs/scalar/test/scalar/scalarTests.cpp index 4601002844..f247eb8432 100644 --- a/source/libs/scalar/test/scalar/scalarTests.cpp +++ b/source/libs/scalar/test/scalar/scalarTests.cpp @@ -143,9 +143,10 @@ int32_t scltAppendReservedSlot(SArray *pBlockList, int16_t *dataBlockId, int16_t } int32_t scltMakeValueNode(SNode **pNode, int32_t dataType, void *value) { - SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_VALUE); + SNode *node = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_VALUE, &node); if (NULL == node) { - SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + SCL_ERR_RET(code); } SValueNode *vnode = (SValueNode *)node; vnode->node.resType.type = dataType; @@ -168,9 +169,10 @@ int32_t scltMakeValueNode(SNode **pNode, int32_t dataType, void *value) { int32_t scltMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType, int32_t dataBytes, int32_t rowNum, void *value) { - SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_COLUMN); + SNode *node = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_COLUMN, &node); if (NULL == node) { - SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + SCL_ERR_RET(code); } SColumnNode *rnode = (SColumnNode *)node; rnode->node.resType.type = dataType; @@ -182,7 +184,6 @@ int32_t scltMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType, SCL_RET(TSDB_CODE_SUCCESS); } - int32_t code = TSDB_CODE_SUCCESS; if (NULL == *block) { SSDataBlock *res = createDataBlock(); for (int32_t i = 0; i < 2; ++i) { @@ -266,9 +267,10 @@ int32_t scltMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType, int32_t scltMakeOpNode2(SNode **pNode, EOperatorType opType, int32_t resType, SNode *pLeft, SNode *pRight, bool isReverse) { - SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_OPERATOR); + SNode *node = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_OPERATOR, &node); if (NULL == node) { - SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + SCL_ERR_RET(code); } SOperatorNode *onode = (SOperatorNode *)node; onode->node.resType.type = resType; @@ -288,9 +290,10 @@ int32_t scltMakeOpNode2(SNode **pNode, EOperatorType opType, int32_t resType, SN } int32_t scltMakeOpNode(SNode **pNode, EOperatorType opType, int32_t resType, SNode *pLeft, SNode *pRight) { - SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_OPERATOR); + SNode *node = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_OPERATOR, &node); if (NULL == node) { - SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + SCL_ERR_RET(code); } SOperatorNode *onode = (SOperatorNode *)node; onode->node.resType.type = resType; @@ -305,9 +308,10 @@ int32_t scltMakeOpNode(SNode **pNode, EOperatorType opType, int32_t resType, SNo } int32_t scltMakeListNode(SNode **pNode, SNodeList *list, int32_t resType) { - SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_NODE_LIST); + SNode *node = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_NODE_LIST, &node); if (NULL == node) { - SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + SCL_ERR_RET(code); } SNodeListNode *lnode = (SNodeListNode *)node; lnode->node.resType.type = resType; @@ -318,16 +322,21 @@ int32_t scltMakeListNode(SNode **pNode, SNodeList *list, int32_t resType) { } int32_t scltMakeLogicNode(SNode **pNode, ELogicConditionType opType, SNode **nodeList, int32_t nodeNum) { - SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); + SNode *node = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_LOGIC_CONDITION, &node); if (NULL == node) { - SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + SCL_ERR_RET(code); } SLogicConditionNode *onode = (SLogicConditionNode *)node; onode->condType = opType; onode->node.resType.type = TSDB_DATA_TYPE_BOOL; onode->node.resType.bytes = sizeof(bool); - onode->pParameterList = nodesMakeList(); + onode->pParameterList = NULL; + code = nodesMakeList(&onode->pParameterList); + if (TSDB_CODE_SUCCESS != code) { + SCL_ERR_RET(code); + } for (int32_t i = 0; i < nodeNum; ++i) { SCL_ERR_RET(nodesListAppend(onode->pParameterList, nodeList[i])); } @@ -337,9 +346,10 @@ int32_t scltMakeLogicNode(SNode **pNode, ELogicConditionType opType, SNode **nod } int32_t scltMakeTargetNode(SNode **pNode, int16_t dataBlockId, int16_t slotId, SNode *snode) { - SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_TARGET); + SNode *node = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_TARGET, &node); if (NULL == node) { - SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + SCL_ERR_RET(code); } STargetNode *onode = (STargetNode *)node; onode->pExpr = snode; @@ -632,7 +642,8 @@ TEST(constantTest, int_in_smallint1) { int32_t code = TSDB_CODE_SUCCESS; code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); ASSERT_EQ(code, TSDB_CODE_SUCCESS); - SNodeList *list = nodesMakeList(); + SNodeList *list = NULL; + code = nodesMakeList(&list); ASSERT_NE(list, nullptr); code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1); ASSERT_EQ(code, TSDB_CODE_SUCCESS); @@ -669,7 +680,8 @@ TEST(constantTest, int_in_smallint2) { int32_t code = TSDB_CODE_SUCCESS; code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); ASSERT_EQ(code, TSDB_CODE_SUCCESS); - SNodeList *list = nodesMakeList(); + SNodeList* list = NULL; + code = nodesMakeList(&list); ASSERT_NE(list, nullptr); code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1); ASSERT_EQ(code, TSDB_CODE_SUCCESS); @@ -704,7 +716,8 @@ TEST(constantTest, int_not_in_smallint1) { int32_t code = TSDB_CODE_SUCCESS; code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); ASSERT_EQ(code, TSDB_CODE_SUCCESS); - SNodeList *list = nodesMakeList(); + SNodeList *list = NULL; + code = nodesMakeList(&list); ASSERT_NE(list, nullptr); code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1); ASSERT_EQ(code, TSDB_CODE_SUCCESS); @@ -741,7 +754,8 @@ TEST(constantTest, int_not_in_smallint2) { int32_t code = TSDB_CODE_SUCCESS; code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); ASSERT_EQ(code, TSDB_CODE_SUCCESS); - SNodeList *list = nodesMakeList(); + SNodeList *list = NULL; + code = nodesMakeList(&list); ASSERT_NE(list, nullptr); code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1); ASSERT_EQ(code, TSDB_CODE_SUCCESS); @@ -2084,7 +2098,8 @@ TEST(columnTest, int_column_in_double_list) { int32_t code = TSDB_CODE_SUCCESS; code = scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_INT, sizeof(int32_t), rowNum, leftv); ASSERT_EQ(code, TSDB_CODE_SUCCESS); - SNodeList *list = nodesMakeList(); + SNodeList *list = NULL; + code = nodesMakeList(&list); ASSERT_NE(list, nullptr); code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_DOUBLE, &rightv1); ASSERT_EQ(code, TSDB_CODE_SUCCESS); @@ -2157,7 +2172,8 @@ TEST(columnTest, binary_column_in_binary_list) { int32_t code = TSDB_CODE_SUCCESS; code = scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_BINARY, 3, rowNum, leftv); ASSERT_EQ(code, TSDB_CODE_SUCCESS); - SNodeList *list = nodesMakeList(); + SNodeList *list = NULL; + code = nodesMakeList(&list); ASSERT_NE(list, nullptr); code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv[0]); ASSERT_EQ(code, TSDB_CODE_SUCCESS); diff --git a/source/libs/scheduler/test/schedulerTests.cpp b/source/libs/scheduler/test/schedulerTests.cpp index 37860ac202..f7c3fb8847 100644 --- a/source/libs/scheduler/test/schedulerTests.cpp +++ b/source/libs/scheduler/test/schedulerTests.cpp @@ -154,24 +154,29 @@ void schtBuildQueryDag(SQueryPlan *dag) { dag->queryId = qId; dag->numOfSubplans = 2; - dag->pSubplans = nodesMakeList(); + dag->pSubplans = NULL; + int32_t code = nodesMakeList(&dag->pSubplans); if (NULL == dag->pSubplans) { return; } - SNodeListNode *scan = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST); + SNodeListNode *scan = NULL; + code = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&scan); if (NULL == scan) { return; } - SNodeListNode *merge = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST); + SNodeListNode *merge = NULL; + code = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&merge); if (NULL == merge) { return; } - SSubplan *scanPlan = (SSubplan *)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN); + SSubplan *scanPlan = NULL; + code = nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN, (SNode**)&scanPlan); if (NULL == scanPlan) { return; } - SSubplan *mergePlan = (SSubplan *)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN); + SSubplan *mergePlan = NULL; + code = nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN, (SNode**)&mergePlan); if (NULL == mergePlan) { return; } @@ -187,11 +192,13 @@ void schtBuildQueryDag(SQueryPlan *dag) { scanPlan->pChildren = NULL; scanPlan->level = 1; - scanPlan->pParents = nodesMakeList(); + scanPlan->pParents = NULL; + code = nodesMakeList(&scanPlan->pParents); if (NULL == scanPlan->pParents) { return; } - scanPlan->pNode = (SPhysiNode *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN); + scanPlan->pNode = NULL; + code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN, (SNode**)&scanPlan->pNode); if (NULL == scanPlan->pNode) { return; } @@ -204,22 +211,26 @@ void schtBuildQueryDag(SQueryPlan *dag) { mergePlan->level = 0; mergePlan->execNode.epSet.numOfEps = 0; - mergePlan->pChildren = nodesMakeList(); + mergePlan->pChildren = NULL; + code = nodesMakeList(&mergePlan->pChildren); if (NULL == mergePlan->pChildren) { return; } mergePlan->pParents = NULL; - mergePlan->pNode = (SPhysiNode *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_MERGE); + mergePlan->pNode = NULL; + code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_MERGE, (SNode**)&mergePlan->pNode); if (NULL == mergePlan->pNode) { return; } mergePlan->msgType = TDMT_SCH_QUERY; - merge->pNodeList = nodesMakeList(); + merge->pNodeList = NULL; + code = nodesMakeList(&merge->pNodeList); if (NULL == merge->pNodeList) { return; } - scan->pNodeList = nodesMakeList(); + scan->pNodeList = NULL; + code = nodesMakeList(&scan->pNodeList); if (NULL == scan->pNodeList) { return; } @@ -240,40 +251,48 @@ void schtBuildQueryFlowCtrlDag(SQueryPlan *dag) { dag->queryId = qId; dag->numOfSubplans = 2; - dag->pSubplans = nodesMakeList(); + dag->pSubplans = NULL; + int32_t code = nodesMakeList(&dag->pSubplans); if (NULL == dag->pSubplans) { return; } - SNodeListNode *scan = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST); + SNodeListNode *scan = NULL; + code = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&scan); if (NULL == scan) { return; } - SNodeListNode *merge = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST); + SNodeListNode *merge = NULL; + code = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&merge); if (NULL == merge) { return; } - SSubplan *mergePlan = (SSubplan *)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN); + SSubplan *mergePlan = NULL; + code = nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN, (SNode**)&mergePlan); if (NULL == mergePlan) { return; } - merge->pNodeList = nodesMakeList(); + merge->pNodeList = NULL; + code = nodesMakeList(&merge->pNodeList); if (NULL == merge->pNodeList) { return; } - scan->pNodeList = nodesMakeList(); + scan->pNodeList = NULL; + code = nodesMakeList(&scan->pNodeList); if (NULL == scan->pNodeList) { return; } - mergePlan->pChildren = nodesMakeList(); + mergePlan->pChildren = NULL; + code = nodesMakeList(&mergePlan->pChildren); if (NULL == mergePlan->pChildren) { return; } for (int32_t i = 0; i < scanPlanNum; ++i) { - SSubplan *scanPlan = (SSubplan *)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN); + SSubplan *scanPlan = NULL; + code = nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN, (SNode**)&scanPlan); if (NULL == scanPlan) { return; } @@ -292,11 +311,13 @@ void schtBuildQueryFlowCtrlDag(SQueryPlan *dag) { scanPlan->pChildren = NULL; scanPlan->level = 1; - scanPlan->pParents = nodesMakeList(); + scanPlan->pParents = NULL; + code = nodesMakeList(&scanPlan->pParents); if (NULL == scanPlan->pParents) { return; } - scanPlan->pNode = (SPhysiNode *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN); + scanPlan->pNode = NULL; + code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN, (SNode**)&scanPlan->pNode); if (NULL == scanPlan->pNode) { return; } @@ -316,7 +337,8 @@ void schtBuildQueryFlowCtrlDag(SQueryPlan *dag) { mergePlan->execNode.epSet.numOfEps = 0; mergePlan->pParents = NULL; - mergePlan->pNode = (SPhysiNode *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_MERGE); + mergePlan->pNode = NULL; + code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_MERGE, (SNode**)&mergePlan->pNode); if (NULL == mergePlan->pNode) { return; } @@ -335,20 +357,24 @@ void schtBuildInsertDag(SQueryPlan *dag) { dag->queryId = qId; dag->numOfSubplans = 2; - dag->pSubplans = nodesMakeList(); + dag->pSubplans = NULL; + int32_t code = nodesMakeList(&dag->pSubplans); if (NULL == dag->pSubplans) { return; } - SNodeListNode *inserta = (SNodeListNode *)nodesMakeNode(QUERY_NODE_NODE_LIST); + SNodeListNode *inserta = NULL; + code = nodesMakeNode(QUERY_NODE_NODE_LIST, (SNode**)&inserta); if (NULL == inserta) { return; } - inserta->pNodeList = nodesMakeList(); + inserta->pNodeList = NULL; + code = nodesMakeList(&inserta->pNodeList); if (NULL == inserta->pNodeList) { return; } - SSubplan *insertPlan = (SSubplan *)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN); + SSubplan *insertPlan = NULL; + code = nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN, (SNode**)&insertPlan); if (NULL == insertPlan) { return; } @@ -366,7 +392,8 @@ void schtBuildInsertDag(SQueryPlan *dag) { insertPlan->pChildren = NULL; insertPlan->pParents = NULL; insertPlan->pNode = NULL; - insertPlan->pDataSink = (SDataSinkNode *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_INSERT); + insertPlan->pDataSink = NULL; + code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_INSERT, (SNode**)&insertPlan->pDataSink); if (NULL == insertPlan->pDataSink) { return; } @@ -379,7 +406,8 @@ void schtBuildInsertDag(SQueryPlan *dag) { (void)nodesListAppend(inserta->pNodeList, (SNode *)insertPlan); - insertPlan = (SSubplan *)nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN); + insertPlan = NULL; + code = nodesMakeNode(QUERY_NODE_PHYSICAL_SUBPLAN, (SNode**)&insertPlan); if (NULL == insertPlan) { return; } @@ -397,7 +425,8 @@ void schtBuildInsertDag(SQueryPlan *dag) { insertPlan->pChildren = NULL; insertPlan->pParents = NULL; insertPlan->pNode = NULL; - insertPlan->pDataSink = (SDataSinkNode *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_INSERT); + insertPlan->pDataSink = NULL; + code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN_INSERT, (SNode**)&insertPlan->pDataSink); if (NULL == insertPlan->pDataSink) { return; } @@ -640,11 +669,12 @@ void *schtRunJobThread(void *aa) { char *dbname = "1.db1"; char *tablename = "table1"; SVgroupInfo vgInfo = {0}; - SQueryPlan *dag = (SQueryPlan *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN); - + SQueryPlan *dag = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN, (SNode**)&dag); + assert(code == 0); schtInitLogFile(); - int32_t code = schedulerInit(); + code = schedulerInit(); assert(code == 0); schtSetPlanToString(); @@ -828,7 +858,9 @@ TEST(queryTest, normalCase) { char *tablename = "table1"; SVgroupInfo vgInfo = {0}; int64_t job = 0; - SQueryPlan *dag = (SQueryPlan *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN); + SQueryPlan *dag = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN, (SNode**)&dag); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SArray *qnodeList = taosArrayInit(1, sizeof(SQueryNodeLoad)); @@ -838,7 +870,7 @@ TEST(queryTest, normalCase) { load.addr.epSet.eps[0].port = 6031; assert(taosArrayPush(qnodeList, &load) != NULL); - int32_t code = schedulerInit(); + code = schedulerInit(); ASSERT_EQ(code, 0); schtBuildQueryDag(dag); @@ -942,7 +974,9 @@ TEST(queryTest, readyFirstCase) { char *tablename = "table1"; SVgroupInfo vgInfo = {0}; int64_t job = 0; - SQueryPlan *dag = (SQueryPlan *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN); + SQueryPlan *dag = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN, (SNode**)&dag); + ASSERT_EQ(TSDB_CODE_SUCCESS, code); SArray *qnodeList = taosArrayInit(1, sizeof(SQueryNodeLoad)); @@ -952,7 +986,7 @@ TEST(queryTest, readyFirstCase) { load.addr.epSet.eps[0].port = 6031; assert(NULL != taosArrayPush(qnodeList, &load)); - int32_t code = schedulerInit(); + code = schedulerInit(); ASSERT_EQ(code, 0); schtBuildQueryDag(dag); @@ -1055,7 +1089,9 @@ TEST(queryTest, flowCtrlCase) { char *tablename = "table1"; SVgroupInfo vgInfo = {0}; int64_t job = 0; - SQueryPlan *dag = (SQueryPlan *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN); + SQueryPlan *dag = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN, (SNode**)&dag); + ASSERT_EQ(TSDB_CODE_SUCCESS, code); schtInitLogFile(); @@ -1069,7 +1105,7 @@ TEST(queryTest, flowCtrlCase) { load.addr.epSet.eps[0].port = 6031; assert(NULL != taosArrayPush(qnodeList, &load)); - int32_t code = schedulerInit(); + code = schedulerInit(); ASSERT_EQ(code, 0); schtBuildQueryFlowCtrlDag(dag); @@ -1151,7 +1187,9 @@ TEST(insertTest, normalCase) { char *dbname = "1.db1"; char *tablename = "table1"; SVgroupInfo vgInfo = {0}; - SQueryPlan *dag = (SQueryPlan *)nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN); + SQueryPlan *dag = NULL; + int32_t code = nodesMakeNode(QUERY_NODE_PHYSICAL_PLAN, (SNode**)&dag); + ASSERT_EQ(TSDB_CODE_SUCCESS, code); uint64_t numOfRows = 0; SArray *qnodeList = taosArrayInit(1, sizeof(SQueryNodeLoad)); @@ -1162,7 +1200,7 @@ TEST(insertTest, normalCase) { load.addr.epSet.eps[0].port = 6031; assert(NULL != taosArrayPush(qnodeList, &load)); - int32_t code = schedulerInit(); + code = schedulerInit(); ASSERT_EQ(code, 0); schtBuildInsertDag(dag);