From 6e70da62fb12e756fe89465a0202ef39c5b0bcde Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao> Date: Mon, 22 Jul 2024 12:51:25 +0800 Subject: [PATCH] adj operator res --- source/libs/executor/inc/executil.h | 2 +- source/libs/executor/inc/executorInt.h | 8 +- source/libs/executor/src/aggregateoperator.c | 41 ++- .../libs/executor/src/countwindowoperator.c | 66 ++-- .../libs/executor/src/eventwindowoperator.c | 46 +-- source/libs/executor/src/executil.c | 15 +- source/libs/executor/src/executor.c | 259 ++++++++++----- source/libs/executor/src/executorInt.c | 214 ++++++++----- source/libs/executor/src/filloperator.c | 109 +++++-- source/libs/executor/src/groupoperator.c | 301 ++++++++++++------ source/libs/executor/src/scanoperator.c | 5 +- .../executor/src/streamcountwindowoperator.c | 6 +- .../executor/src/streameventwindowoperator.c | 18 +- source/libs/executor/src/streamfilloperator.c | 6 +- .../executor/src/streamtimewindowoperator.c | 35 +- source/libs/executor/src/timewindowoperator.c | 52 +-- 16 files changed, 791 insertions(+), 392 deletions(-) diff --git a/source/libs/executor/inc/executil.h b/source/libs/executor/inc/executil.h index 55b803f6d4..27ea98afd5 100644 --- a/source/libs/executor/inc/executil.h +++ b/source/libs/executor/inc/executil.h @@ -179,7 +179,7 @@ SExprInfo* createExprInfo(SNodeList* pNodeList, SNodeList* pGroupKeys, int32_t* SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, int32_t** rowEntryInfoOffset, SFunctionStateStore* pStore); void relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray* pCols, bool outputEveryColumn); -void initExecTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pQueryWindow); +int32_t initExecTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pQueryWindow); SInterval extractIntervalInfo(const STableScanPhysiNode* pTableScanNode); SColumn extractColumnFromColumnNode(SColumnNode* pColNode); diff --git a/source/libs/executor/inc/executorInt.h b/source/libs/executor/inc/executorInt.h index d8267c4579..fec16f9ef4 100644 --- a/source/libs/executor/inc/executorInt.h +++ b/source/libs/executor/inc/executorInt.h @@ -834,9 +834,8 @@ void doBuildResultDatablock(struct SOperatorInfo* pOperator, SOptrBasicInfo* pbI /** * @brief copydata from hash table, instead of copying from SGroupResInfo's pRow */ -int32_t doCopyToSDataBlockByHash(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf, - SGroupResInfo* pGroupResInfo, SSHashObj* pHashmap, int32_t threshold, - bool ignoreGroup); +void doCopyToSDataBlockByHash(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf, + SGroupResInfo* pGroupResInfo, SSHashObj* pHashmap, int32_t threshold, bool ignoreGroup); bool hasLimitOffsetInfo(SLimitInfo* pLimitInfo); bool hasSlimitOffsetInfo(SLimitInfo* pLimitInfo); @@ -879,7 +878,8 @@ SResultRow* doSetResultOutBufByKey(SDiskbasedBuf* pResultBuf, SResultRowInfo* pR int32_t projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBlock* pSrcBlock, SqlFunctionCtx* pCtx, int32_t numOfOutput, SArray* pPseudoList); -void setInputDataBlock(SExprSupp* pExprSupp, SSDataBlock* pBlock, int32_t order, int32_t scanFlag, bool createDummyCol); +int32_t setInputDataBlock(SExprSupp* pExprSupp, SSDataBlock* pBlock, int32_t order, int32_t scanFlag, + bool createDummyCol); int32_t checkForQueryBuf(size_t numOfTables); diff --git a/source/libs/executor/src/aggregateoperator.c b/source/libs/executor/src/aggregateoperator.c index 5ff0601b7a..55cb8c8302 100644 --- a/source/libs/executor/src/aggregateoperator.c +++ b/source/libs/executor/src/aggregateoperator.c @@ -21,6 +21,7 @@ #include "tname.h" #include "executorInt.h" +#include "index.h" #include "operator.h" #include "query.h" #include "querytask.h" @@ -29,7 +30,6 @@ #include "tglobal.h" #include "thash.h" #include "ttypes.h" -#include "index.h" typedef struct { bool hasAgg; @@ -54,13 +54,13 @@ static void destroyAggOperatorInfo(void* param); static void setExecutionContext(SOperatorInfo* pOperator, int32_t numOfOutput, uint64_t groupId); static int32_t createDataBlockForEmptyInput(SOperatorInfo* pOperator, SSDataBlock** ppBlock); -static void destroyDataBlockForEmptyInput(bool blockAllocated, SSDataBlock** ppBlock); +static void destroyDataBlockForEmptyInput(bool blockAllocated, SSDataBlock** ppBlock); -static int32_t doAggregateImpl(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx); +static int32_t doAggregateImpl(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx); static SSDataBlock* getAggregateResult(SOperatorInfo* pOperator); static int32_t doInitAggInfoSup(SAggSupporter* pAggSup, SqlFunctionCtx* pCtx, int32_t numOfOutput, size_t keyBufSize, - const char* pKey); + const char* pKey); static int32_t addNewResultRowBuf(SResultRow* pWindowRes, SDiskbasedBuf* pResultBuf, uint32_t size); @@ -134,7 +134,7 @@ SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SAggPhysiN return pOperator; - _error: +_error: if (pInfo != NULL) { destroyAggOperatorInfo(pInfo); } @@ -166,6 +166,8 @@ void destroyAggOperatorInfo(void* param) { * if false, fill results of ONE GROUP * */ static bool nextGroupedResult(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SAggOperatorInfo* pAggInfo = pOperator->info; @@ -175,7 +177,6 @@ static bool nextGroupedResult(SOperatorInfo* pOperator) { SOperatorInfo* downstream = pOperator->pDownstream[0]; int64_t st = taosGetTimestampUs(); - int32_t code = TSDB_CODE_SUCCESS; int32_t order = pAggInfo->binfo.inputTsOrder; SSDataBlock* pBlock = pAggInfo->pNewGroupBlock; @@ -183,11 +184,10 @@ static bool nextGroupedResult(SOperatorInfo* pOperator) { pAggInfo->pNewGroupBlock = NULL; tSimpleHashClear(pAggInfo->aggSup.pResultRowHashTable); setExecutionContext(pOperator, pOperator->exprSupp.numOfExprs, pBlock->info.id.groupId); - setInputDataBlock(pSup, pBlock, order, pBlock->info.scanFlag, true); + QUERY_CHECK_CODE(code, lino, _end); + code = setInputDataBlock(pSup, pBlock, order, pBlock->info.scanFlag, true); code = doAggregateImpl(pOperator, pSup->pCtx); - if (code != TSDB_CODE_SUCCESS) { - T_LONG_JMP(pTaskInfo->env, code); - } + QUERY_CHECK_CODE(code, lino, _end); } while (1) { bool blockAllocated = false; @@ -222,7 +222,9 @@ static bool nextGroupedResult(SOperatorInfo* pOperator) { } // the pDataBlock are always the same one, no need to call this again setExecutionContext(pOperator, pOperator->exprSupp.numOfExprs, pBlock->info.id.groupId); - setInputDataBlock(pSup, pBlock, order, pBlock->info.scanFlag, true); + code = setInputDataBlock(pSup, pBlock, order, pBlock->info.scanFlag, true); + QUERY_CHECK_CODE(code, lino, _end); + code = doAggregateImpl(pOperator, pSup->pCtx); if (code != 0) { destroyDataBlockForEmptyInput(blockAllocated, &pBlock); @@ -238,6 +240,13 @@ static bool nextGroupedResult(SOperatorInfo* pOperator) { } initGroupedResultInfo(&pAggInfo->groupResInfo, pAggInfo->aggSup.pResultRowHashTable, 0); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return pBlock != NULL; } @@ -250,7 +259,7 @@ SSDataBlock* getAggregateResult(SOperatorInfo* pOperator) { } SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - bool hasNewGroups = false; + bool hasNewGroups = false; do { hasNewGroups = nextGroupedResult(pOperator); blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); @@ -336,7 +345,6 @@ static int32_t createDataBlockForEmptyInput(SOperatorInfo* pOperator, SSDataBloc colInfo.info.type = TSDB_DATA_TYPE_NULL; colInfo.info.bytes = 1; - SExprInfo* pOneExpr = &pOperator->exprSupp.pExprInfo[i]; for (int32_t j = 0; j < pOneExpr->base.numOfParams; ++j) { SFunctParam* pFuncParam = &pOneExpr->base.pParam[j]; @@ -395,8 +403,9 @@ void doSetTableGroupOutputBuf(SOperatorInfo* pOperator, int32_t numOfOutput, uin SqlFunctionCtx* pCtx = pOperator->exprSupp.pCtx; int32_t* rowEntryInfoOffset = pOperator->exprSupp.rowEntryInfoOffset; - SResultRow* pResultRow = doSetResultOutBufByKey(pAggInfo->aggSup.pResultBuf, pResultRowInfo, (char*)&groupId, - sizeof(groupId), true, groupId, pTaskInfo, false, &pAggInfo->aggSup, true); + SResultRow* pResultRow = + doSetResultOutBufByKey(pAggInfo->aggSup.pResultBuf, pResultRowInfo, (char*)&groupId, sizeof(groupId), true, + groupId, pTaskInfo, false, &pAggInfo->aggSup, true); /* * not assign result buffer yet, add new result buffer * all group belong to one result set, and each group result has different group id so set the id to be one @@ -486,7 +495,7 @@ int32_t doInitAggInfoSup(SAggSupporter* pAggSup, SqlFunctionCtx* pCtx, int32_t n qError("failed to get buff page size, rowSize:%d", pAggSup->resultRowSize); return code; } - + if (!osTempSpaceAvailable()) { code = TSDB_CODE_NO_DISKSPACE; qError("Init stream agg supporter failed since %s, key:%s, tempDir:%s", tstrerror(code), pKey, tsTempDir); diff --git a/source/libs/executor/src/countwindowoperator.c b/source/libs/executor/src/countwindowoperator.c index 3a6c85532a..6e476c4ea0 100644 --- a/source/libs/executor/src/countwindowoperator.c +++ b/source/libs/executor/src/countwindowoperator.c @@ -25,13 +25,13 @@ #include "ttime.h" typedef struct SCountWindowResult { - int32_t winRows; - SResultRow row; + int32_t winRows; + SResultRow row; } SCountWindowResult; typedef struct SCountWindowSupp { - SArray* pWinStates; - int32_t stateIndex; + SArray* pWinStates; + int32_t stateIndex; } SCountWindowSupp; typedef struct SCountWindowOperatorInfo { @@ -61,13 +61,11 @@ void destroyCountWindowOperatorInfo(void* param) { taosMemoryFreeClear(param); } -static void clearWinStateBuff(SCountWindowResult* pBuff) { - pBuff->winRows = 0; -} +static void clearWinStateBuff(SCountWindowResult* pBuff) { pBuff->winRows = 0; } static SCountWindowResult* getCountWinStateInfo(SCountWindowSupp* pCountSup) { SCountWindowResult* pBuffInfo = taosArrayGet(pCountSup->pWinStates, pCountSup->stateIndex); - int32_t size = taosArrayGetSize(pCountSup->pWinStates); + int32_t size = taosArrayGetSize(pCountSup->pWinStates); // coverity scan ASSERTS(size > 0, "WinStates is empty"); if (size > 0) { @@ -76,7 +74,8 @@ static SCountWindowResult* getCountWinStateInfo(SCountWindowSupp* pCountSup) { return pBuffInfo; } -static SCountWindowResult* setCountWindowOutputBuff(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, SResultRow** pResult) { +static SCountWindowResult* setCountWindowOutputBuff(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, + SResultRow** pResult) { SCountWindowResult* pBuff = getCountWinStateInfo(pCountSup); (*pResult) = &pBuff->row; setResultRowInitCtx(*pResult, pExprSup->pCtx, pExprSup->numOfExprs, pExprSup->rowEntryInfoOffset); @@ -100,9 +99,9 @@ int32_t doCountWindowAggImpl(SOperatorInfo* pOperator, SSDataBlock* pBlock) { for (int32_t i = 0; i < pBlock->info.rows;) { SCountWindowResult* pBuffInfo = setCountWindowOutputBuff(pExprSup, &pInfo->countSup, &pInfo->pRow); - int32_t prevRows = pBuffInfo->winRows; - int32_t num = updateCountWindowInfo(i, pBlock->info.rows, pInfo->windowCount, &pBuffInfo->winRows); - int32_t step = num; + int32_t prevRows = pBuffInfo->winRows; + int32_t num = updateCountWindowInfo(i, pBlock->info.rows, pInfo->windowCount, &pBuffInfo->winRows); + int32_t step = num; if (prevRows == 0) { pInfo->pRow->win.skey = tsCols[i]; } @@ -136,12 +135,14 @@ int32_t doCountWindowAggImpl(SOperatorInfo* pOperator, SSDataBlock* pBlock) { return code; } -static void buildCountResult(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, SExecTaskInfo* pTaskInfo, SFilterInfo* pFilterInfo, SSDataBlock* pBlock) { +static void buildCountResult(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, SExecTaskInfo* pTaskInfo, + SFilterInfo* pFilterInfo, SSDataBlock* pBlock) { SResultRow* pResultRow = NULL; for (int32_t i = 0; i < taosArrayGetSize(pCountSup->pWinStates); i++) { SCountWindowResult* pBuff = setCountWindowOutputBuff(pExprSup, pCountSup, &pResultRow); if (pBuff->winRows == 0) { - continue;; + continue; + ; } doUpdateNumOfRows(pExprSup->pCtx, pResultRow, pExprSup->numOfExprs, pExprSup->rowEntryInfoOffset); copyResultrowToDataBlock(pExprSup->pExprInfo, pExprSup->numOfExprs, pResultRow, pExprSup->pCtx, pBlock, @@ -154,6 +155,8 @@ static void buildCountResult(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, S } static SSDataBlock* countWindowAggregate(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SCountWindowOperatorInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SExprSupp* pExprSup = &pOperator->exprSupp; @@ -170,8 +173,11 @@ static SSDataBlock* countWindowAggregate(SOperatorInfo* pOperator) { } pRes->info.scanFlag = pBlock->info.scanFlag; - setInputDataBlock(pExprSup, pBlock, order, MAIN_SCAN, true); - blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId); + code = setInputDataBlock(pExprSup, pBlock, order, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); + + code = blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId); + QUERY_CHECK_CODE(code, lino, _end); // there is an scalar expression that needs to be calculated right before apply the group aggregation. if (pInfo->scalarSup.pExprInfo != NULL) { @@ -196,11 +202,19 @@ static SSDataBlock* countWindowAggregate(SOperatorInfo* pOperator) { } buildCountResult(pExprSup, &pInfo->countSup, pTaskInfo, pOperator->exprSupp.pFilterInfo, pRes); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } return pRes->info.rows == 0 ? NULL : pRes; } SOperatorInfo* createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* physiNode, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SCountWindowOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SCountWindowOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -209,7 +223,6 @@ SOperatorInfo* createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo pOperator->exprSupp.hasWindowOrGroup = true; - int32_t code = TSDB_CODE_SUCCESS; SCountWinodwPhysiNode* pCountWindowNode = (SCountWinodwPhysiNode*)physiNode; pInfo->tsSlotId = ((SColumnNode*)pCountWindowNode->window.pTspk)->slotId; @@ -218,21 +231,17 @@ SOperatorInfo* createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo int32_t numOfScalarExpr = 0; SExprInfo* pScalarExprInfo = createExprInfo(pCountWindowNode->window.pExprs, NULL, &numOfScalarExpr); code = initExprSupp(&pInfo->scalarSup, pScalarExprInfo, numOfScalarExpr, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); } - size_t keyBufSize = 0; + size_t keyBufSize = 0; int32_t num = 0; SExprInfo* pExprInfo = createExprInfo(pCountWindowNode->window.pFuncs, NULL, &num); initResultSizeInfo(&pOperator->resultInfo, 4096); code = initAggSup(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str, pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); SSDataBlock* pResBlock = createDataBlockFromDescNode(pCountWindowNode->window.node.pOutputDataBlockDesc); blockDataEnsureCapacity(pResBlock, pOperator->resultInfo.capacity); @@ -243,7 +252,7 @@ SOperatorInfo* createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo pInfo->binfo.outputTsOrder = physiNode->outputTsOrder; pInfo->windowCount = pCountWindowNode->windowCount; pInfo->windowSliding = pCountWindowNode->windowSliding; - //sizeof(SCountWindowResult) + // sizeof(SCountWindowResult) int32_t itemSize = sizeof(int32_t) + pInfo->aggSup.resultRowSize; int32_t numOfItem = 1; if (pInfo->windowCount != pInfo->windowSliding) { @@ -257,11 +266,10 @@ SOperatorInfo* createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo pInfo->countSup.stateIndex = 0; code = filterInitFromNode((SNode*)pCountWindowNode->window.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + QUERY_CHECK_CODE(code, lino, _error); setOperatorInfo(pOperator, "CountWindowOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT, true, OP_NOT_OPENED, pInfo, pTaskInfo); diff --git a/source/libs/executor/src/eventwindowoperator.c b/source/libs/executor/src/eventwindowoperator.c index b898ea576a..f15b05f817 100644 --- a/source/libs/executor/src/eventwindowoperator.c +++ b/source/libs/executor/src/eventwindowoperator.c @@ -60,6 +60,8 @@ static void doKeepTuple(SWindowRowsSup* pRowSup, int64_t ts, uint64_t groupId) { SOperatorInfo* createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* physiNode, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SEventWindowOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SEventWindowOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -71,29 +73,21 @@ SOperatorInfo* createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo SEventWinodwPhysiNode* pEventWindowNode = (SEventWinodwPhysiNode*)physiNode; int32_t tsSlotId = ((SColumnNode*)pEventWindowNode->window.pTspk)->slotId; - int32_t code = filterInitFromNode((SNode*)pEventWindowNode->pStartCond, &pInfo->pStartCondInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + code = filterInitFromNode((SNode*)pEventWindowNode->pStartCond, &pInfo->pStartCondInfo, 0); + QUERY_CHECK_CODE(code, lino, _error); code = filterInitFromNode((SNode*)pEventWindowNode->pEndCond, &pInfo->pEndCondInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); if (pEventWindowNode->window.pExprs != NULL) { int32_t numOfScalarExpr = 0; SExprInfo* pScalarExprInfo = createExprInfo(pEventWindowNode->window.pExprs, NULL, &numOfScalarExpr); code = initExprSupp(&pInfo->scalarSup, pScalarExprInfo, numOfScalarExpr, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); } code = filterInitFromNode((SNode*)pEventWindowNode->window.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); size_t keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES; @@ -103,12 +97,13 @@ SOperatorInfo* createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo code = initAggSup(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str, pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); SSDataBlock* pResBlock = createDataBlockFromDescNode(pEventWindowNode->window.node.pOutputDataBlockDesc); - blockDataEnsureCapacity(pResBlock, pOperator->resultInfo.capacity); + QUERY_CHECK_NULL(pResBlock, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + + code = blockDataEnsureCapacity(pResBlock, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _error); initBasicInfo(&pInfo->binfo, pResBlock); initResultRowInfo(&pInfo->binfo.resultRowInfo); @@ -118,7 +113,8 @@ SOperatorInfo* createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo pInfo->twAggSup = (STimeWindowAggSupp){.waterMark = pEventWindowNode->window.watermark, .calTrigger = pEventWindowNode->window.triggerType}; - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + QUERY_CHECK_CODE(code, lino, _error); pInfo->tsSlotId = tsSlotId; @@ -173,6 +169,8 @@ void destroyEWindowOperatorInfo(void* param) { } static SSDataBlock* eventWindowAggregate(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SEventWindowOperatorInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; @@ -191,8 +189,11 @@ static SSDataBlock* eventWindowAggregate(SOperatorInfo* pOperator) { } pRes->info.scanFlag = pBlock->info.scanFlag; - setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true); - blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId); + code = setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); + + code = blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId); + QUERY_CHECK_CODE(code, lino, _end); // there is an scalar expression that needs to be calculated right before apply the group aggregation. if (pInfo->scalarSup.pExprInfo != NULL) { @@ -210,6 +211,11 @@ static SSDataBlock* eventWindowAggregate(SOperatorInfo* pOperator) { } } +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } return pRes->info.rows == 0 ? NULL : pRes; } diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c index c623e94a12..aa24e3a8b8 100644 --- a/source/libs/executor/src/executil.c +++ b/source/libs/executor/src/executil.c @@ -2021,18 +2021,27 @@ uint64_t tableListGetTableGroupId(const STableListInfo* pTableList, uint64_t tab // TODO handle the group offset info, fix it, the rule of group output will be broken by this function int32_t tableListAddTableInfo(STableListInfo* pTableList, uint64_t uid, uint64_t gid) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pTableList->map == NULL) { pTableList->map = taosHashInit(32, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_ENTRY_LOCK); + QUERY_CHECK_NULL(pTableList->map, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } STableKeyInfo keyInfo = {.uid = uid, .groupId = gid}; - taosArrayPush(pTableList->pTableList, &keyInfo); + void* tmp = taosArrayPush(pTableList->pTableList, &keyInfo); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); int32_t slot = (int32_t)taosArrayGetSize(pTableList->pTableList) - 1; - taosHashPut(pTableList->map, &uid, sizeof(uid), &slot, sizeof(slot)); + code = taosHashPut(pTableList->map, &uid, sizeof(uid), &slot, sizeof(slot)); + QUERY_CHECK_CODE(code, lino, _end); +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } qDebug("uid:%" PRIu64 ", groupId:%" PRIu64 " added into table list, slot:%d, total:%d", uid, gid, slot, slot + 1); - return TSDB_CODE_SUCCESS; + return code; } int32_t tableListGetGroupList(const STableListInfo* pTableList, int32_t ordinalGroupIndex, STableKeyInfo** pKeyInfo, diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c index 4aff0e69a3..c79f69129c 100644 --- a/source/libs/executor/src/executor.c +++ b/source/libs/executor/src/executor.c @@ -15,14 +15,14 @@ #include "executor.h" #include "executorInt.h" -#include "trpc.h" -#include "wal.h" #include "operator.h" #include "planner.h" #include "querytask.h" #include "tdatablock.h" #include "tref.h" +#include "trpc.h" #include "tudf.h" +#include "wal.h" #include "storageapi.h" @@ -31,15 +31,17 @@ int32_t exchangeObjRefPool = -1; static void cleanupRefPool() { int32_t ref = atomic_val_compare_exchange_32(&exchangeObjRefPool, exchangeObjRefPool, 0); - taosCloseRef(ref); + (void)taosCloseRef(ref); } static void initRefPool() { exchangeObjRefPool = taosOpenRef(1024, doDestroyExchangeOperatorInfo); - atexit(cleanupRefPool); + (void)atexit(cleanupRefPool); } static int32_t doSetSMABlock(SOperatorInfo* pOperator, void* input, size_t numOfBlocks, int32_t type, char* id) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) { if (pOperator->numOfDownstream == 0) { qError("failed to find stream scan operator to set the input data block, %s" PRIx64, id); @@ -60,33 +62,44 @@ static int32_t doSetSMABlock(SOperatorInfo* pOperator, void* input, size_t numOf if (type == STREAM_INPUT__MERGED_SUBMIT) { for (int32_t i = 0; i < numOfBlocks; i++) { SPackedData* pReq = POINTER_SHIFT(input, i * sizeof(SPackedData)); - taosArrayPush(pInfo->pBlockLists, pReq); + void* tmp = taosArrayPush(pInfo->pBlockLists, pReq); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } pInfo->blockType = STREAM_INPUT__DATA_SUBMIT; } else if (type == STREAM_INPUT__DATA_SUBMIT) { - taosArrayPush(pInfo->pBlockLists, &input); + void* tmp = taosArrayPush(pInfo->pBlockLists, &input); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); pInfo->blockType = STREAM_INPUT__DATA_SUBMIT; } else if (type == STREAM_INPUT__DATA_BLOCK) { for (int32_t i = 0; i < numOfBlocks; ++i) { SSDataBlock* pDataBlock = &((SSDataBlock*)input)[i]; - SPackedData tmp = {.pDataBlock = pDataBlock}; - taosArrayPush(pInfo->pBlockLists, &tmp); + SPackedData tmp = {.pDataBlock = pDataBlock}; + void* tmpItem = taosArrayPush(pInfo->pBlockLists, &tmp); + QUERY_CHECK_NULL(tmpItem, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } pInfo->blockType = STREAM_INPUT__DATA_BLOCK; } else if (type == STREAM_INPUT__CHECKPOINT) { SPackedData tmp = {.pDataBlock = input}; - taosArrayPush(pInfo->pBlockLists, &tmp); + void* tmpItem = taosArrayPush(pInfo->pBlockLists, &tmp); + QUERY_CHECK_NULL(tmpItem, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); pInfo->blockType = STREAM_INPUT__CHECKPOINT; } else if (type == STREAM_INPUT__REF_DATA_BLOCK) { - for (int32_t i = 0; i < numOfBlocks; ++i) { + for (int32_t i = 0; i < numOfBlocks; ++i) { SPackedData* pReq = POINTER_SHIFT(input, i * sizeof(SPackedData)); - taosArrayPush(pInfo->pBlockLists, pReq); + void* tmp = taosArrayPush(pInfo->pBlockLists, pReq); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } pInfo->blockType = STREAM_INPUT__DATA_BLOCK; } return TSDB_CODE_SUCCESS; } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + } + return code; } static int32_t doSetStreamOpOpen(SOperatorInfo* pOperator, char* id) { @@ -124,7 +137,10 @@ void resetTaskInfo(qTaskInfo_t tinfo) { clearStreamBlock(pTaskInfo->pRoot); } -static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t numOfBlocks, int32_t type, const char* id) { +static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t numOfBlocks, int32_t type, + const char* id) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) { if (pOperator->numOfDownstream == 0) { qError("failed to find stream scan operator to set the input data block, %s" PRIx64, id); @@ -147,24 +163,30 @@ static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t nu if (type == STREAM_INPUT__MERGED_SUBMIT) { for (int32_t i = 0; i < numOfBlocks; i++) { SPackedData* pReq = POINTER_SHIFT(input, i * sizeof(SPackedData)); - taosArrayPush(pInfo->pBlockLists, pReq); + void* tmp = taosArrayPush(pInfo->pBlockLists, pReq); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } pInfo->blockType = STREAM_INPUT__DATA_SUBMIT; } else if (type == STREAM_INPUT__DATA_SUBMIT) { - taosArrayPush(pInfo->pBlockLists, input); + void* tmp = taosArrayPush(pInfo->pBlockLists, input); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + pInfo->blockType = STREAM_INPUT__DATA_SUBMIT; } else if (type == STREAM_INPUT__DATA_BLOCK) { for (int32_t i = 0; i < numOfBlocks; ++i) { SSDataBlock* pDataBlock = &((SSDataBlock*)input)[i]; SPackedData tmp = {.pDataBlock = pDataBlock}; - taosArrayPush(pInfo->pBlockLists, &tmp); + void* tmpItem = taosArrayPush(pInfo->pBlockLists, &tmp); + QUERY_CHECK_NULL(tmpItem, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } pInfo->blockType = STREAM_INPUT__DATA_BLOCK; } else if (type == STREAM_INPUT__CHECKPOINT_TRIGGER) { SPackedData tmp = {.pDataBlock = input}; - taosArrayPush(pInfo->pBlockLists, &tmp); + void* tmpItem = taosArrayPush(pInfo->pBlockLists, &tmp); + QUERY_CHECK_NULL(tmpItem, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + pInfo->blockType = STREAM_INPUT__CHECKPOINT; } else { ASSERT(0); @@ -172,6 +194,12 @@ static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t nu return TSDB_CODE_SUCCESS; } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } void doSetTaskId(SOperatorInfo* pOperator, SStorageAPI* pAPI) { @@ -330,16 +358,25 @@ qTaskInfo_t qCreateStreamExecTaskInfo(void* msg, SReadHandle* readers, int32_t v return NULL; } - qStreamInfoResetTimewindowFilter(pTaskInfo); + code = qStreamInfoResetTimewindowFilter(pTaskInfo); + if (code != TSDB_CODE_SUCCESS) { + nodesDestroyNode((SNode*)pPlan); + qDestroyTask(pTaskInfo); + terrno = code; + return NULL; + } return pTaskInfo; } -static SArray* filterUnqualifiedTables(const SStreamScanInfo* pScanInfo, const SArray* tableIdList, const char* idstr, - SStorageAPI* pAPI) { +static int32_t filterUnqualifiedTables(const SStreamScanInfo* pScanInfo, const SArray* tableIdList, const char* idstr, + SStorageAPI* pAPI, SArray** ppArrayRes) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SArray* qa = taosArrayInit(4, sizeof(tb_uid_t)); int32_t numOfUids = taosArrayGetSize(tableIdList); if (numOfUids == 0) { - return qa; + (*ppArrayRes) = qa; + goto _end; } STableScanInfo* pTableScanInfo = pScanInfo->pTableScanOp->info; @@ -395,11 +432,18 @@ static SArray* filterUnqualifiedTables(const SStreamScanInfo* pScanInfo, const S } // handle multiple partition - taosArrayPush(qa, id); + void* tmp = taosArrayPush(qa, id); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } pAPI->metaReaderFn.clearReader(&mr); - return qa; + (*ppArrayRes) = qa; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } int32_t qUpdateTableListForStreamScanner(qTaskInfo_t tinfo, const SArray* tableIdList, bool isAdd) { @@ -416,7 +460,12 @@ int32_t qUpdateTableListForStreamScanner(qTaskInfo_t tinfo, const SArray* tableI SStreamScanInfo* pScanInfo = pInfo->info; if (isAdd) { // add new table id - SArray* qa = filterUnqualifiedTables(pScanInfo, tableIdList, id, &pTaskInfo->storageAPI); + SArray* qa = NULL; + code = filterUnqualifiedTables(pScanInfo, tableIdList, id, &pTaskInfo->storageAPI, &qa); + if (code != TSDB_CODE_SUCCESS) { + taosArrayDestroy(qa); + return code; + } int32_t numOfQualifiedTables = taosArrayGetSize(qa); qDebug("%d qualified child tables added into stream scanner, %s", numOfQualifiedTables, id); code = pTaskInfo->storageAPI.tqReaderFn.tqReaderAddTables(pScanInfo->tqReader, qa); @@ -459,7 +508,13 @@ int32_t qUpdateTableListForStreamScanner(qTaskInfo_t tinfo, const SArray* tableI } } - tableListAddTableInfo(pTableListInfo, keyInfo.uid, keyInfo.groupId); + code = tableListAddTableInfo(pTableListInfo, keyInfo.uid, keyInfo.groupId); + if (code != TSDB_CODE_SUCCESS) { + taosMemoryFree(keyBuf); + taosArrayDestroy(qa); + taosWUnLockLatch(&pTaskInfo->lock); + return code; + } } taosWUnLockLatch(&pTaskInfo->lock); @@ -509,16 +564,14 @@ int32_t qGetQueryTableSchemaVersion(qTaskInfo_t tinfo, char* dbName, char* table return TSDB_CODE_SUCCESS; } -bool qIsDynamicExecTask(qTaskInfo_t tinfo) { - return ((SExecTaskInfo*)tinfo)->dynamicTask; -} +bool qIsDynamicExecTask(qTaskInfo_t tinfo) { return ((SExecTaskInfo*)tinfo)->dynamicTask; } void destroyOperatorParam(SOperatorParam* pParam) { if (NULL == pParam) { return; } - //TODO + // TODO } void qUpdateOperatorParam(qTaskInfo_t tinfo, void* pParam) { @@ -531,7 +584,7 @@ int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId, qTaskInfo_t* pTaskInfo, DataSinkHandle* handle, int8_t compressResult, char* sql, EOPTR_EXEC_MODEL model) { SExecTaskInfo** pTask = (SExecTaskInfo**)pTaskInfo; - taosThreadOnce(&initPoolOnce, initRefPool); + (void)taosThreadOnce(&initPoolOnce, initRefPool); qDebug("start to create task, TID:0x%" PRIx64 " QID:0x%" PRIx64 ", vgId:%d", taskId, pSubplan->id.queryId, vgId); @@ -543,7 +596,7 @@ int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId, if (handle) { SDataSinkMgtCfg cfg = {.maxDataBlockNum = 500, .maxDataBlockNumPerQuery = 50, .compress = compressResult}; - void* pSinkManager = NULL; + void* pSinkManager = NULL; code = dsDataSinkMgtInit(&cfg, &(*pTask)->storageAPI, &pSinkManager); if (code != TSDB_CODE_SUCCESS) { qError("failed to dsDataSinkMgtInit, code:%s, %s", tstrerror(code), (*pTask)->id.str); @@ -575,6 +628,8 @@ static void freeBlock(void* param) { } int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bool* hasMore, SLocalFetch* pLocal) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo; int64_t threadId = taosGetSelfPthreadId(); @@ -605,7 +660,7 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo int32_t ret = setjmp(pTaskInfo->env); if (ret != TSDB_CODE_SUCCESS) { pTaskInfo->code = ret; - cleanUpUdfs(); + (void)cleanUpUdfs(); qDebug("%s task abort due to error/cancel occurs, code:%s", GET_TASKID(pTaskInfo), tstrerror(pTaskInfo->code)); atomic_store_64(&pTaskInfo->owner, 0); @@ -627,10 +682,10 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo pRes = pTaskInfo->pRoot->fpSet.getNextFn(pTaskInfo->pRoot); } - if(pRes == NULL) { + if (pRes == NULL) { st = taosGetTimestampUs(); } - + int32_t rowsThreshold = pTaskInfo->pSubplan->rowsThreshold; if (!pTaskInfo->pSubplan->dynamicRowThreshold || 4096 <= pTaskInfo->pSubplan->rowsThreshold) { rowsThreshold = 4096; @@ -640,18 +695,21 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo SSDataBlock* p = NULL; if (blockIndex >= taosArrayGetSize(pTaskInfo->pResultBlockList)) { SSDataBlock* p1 = createOneDataBlock(pRes, true); - taosArrayPush(pTaskInfo->pResultBlockList, &p1); + void* tmp = taosArrayPush(pTaskInfo->pResultBlockList, &p1); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); p = p1; } else { p = *(SSDataBlock**)taosArrayGet(pTaskInfo->pResultBlockList, blockIndex); - copyDataBlock(p, pRes); + code = copyDataBlock(p, pRes); + QUERY_CHECK_CODE(code, lino, _end); } blockIndex += 1; current += p->info.rows; ASSERT(p->info.rows > 0 || p->info.type == STREAM_CHECKPOINT); - taosArrayPush(pResList, &p); + void* tmp = taosArrayPush(pResList, &p); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); if (current >= rowsThreshold) { break; @@ -671,7 +729,10 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo *useconds = pTaskInfo->cost.elapsedTime; } - cleanUpUdfs(); +_end: + + int32_t tmpRes = cleanUpUdfs(); + qTrace("%s at line %d res:%d", __func__, __LINE__, tmpRes); uint64_t total = pTaskInfo->pRoot->resultInfo.totalRows; qDebug("%s task suspended, %d rows in %d blocks returned, total:%" PRId64 " rows, in sinkNode:%d, elapsed:%.2f ms", @@ -730,7 +791,7 @@ int32_t qExecTask(qTaskInfo_t tinfo, SSDataBlock** pRes, uint64_t* useconds) { int32_t ret = setjmp(pTaskInfo->env); if (ret != TSDB_CODE_SUCCESS) { pTaskInfo->code = ret; - cleanUpUdfs(); + (void)cleanUpUdfs(); qDebug("%s task abort due to error/cancel occurs, code:%s", GET_TASKID(pTaskInfo), tstrerror(pTaskInfo->code)); atomic_store_64(&pTaskInfo->owner, 0); return pTaskInfo->code; @@ -748,7 +809,8 @@ int32_t qExecTask(qTaskInfo_t tinfo, SSDataBlock** pRes, uint64_t* useconds) { *useconds = pTaskInfo->cost.elapsedTime; } - cleanUpUdfs(); + int32_t tmpRes = cleanUpUdfs(); + qTrace("%s at line %d res:%d", __func__, __LINE__, tmpRes); int32_t current = (*pRes != NULL) ? (*pRes)->info.rows : 0; uint64_t total = pTaskInfo->pRoot->resultInfo.totalRows; @@ -762,9 +824,13 @@ int32_t qExecTask(qTaskInfo_t tinfo, SSDataBlock** pRes, uint64_t* useconds) { int32_t qAppendTaskStopInfo(SExecTaskInfo* pTaskInfo, SExchangeOpStopInfo* pInfo) { taosWLockLatch(&pTaskInfo->stopInfo.lock); - taosArrayPush(pTaskInfo->stopInfo.pStopInfo, pInfo); + void* tmp = taosArrayPush(pTaskInfo->stopInfo.pStopInfo, pInfo); taosWUnLockLatch(&pTaskInfo->stopInfo.lock); + if (tmp != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); + return TSDB_CODE_OUT_OF_MEMORY; + } return TSDB_CODE_SUCCESS; } @@ -798,8 +864,8 @@ void qStopTaskOperators(SExecTaskInfo* pTaskInfo) { SExchangeOpStopInfo* pStop = taosArrayGet(pTaskInfo->stopInfo.pStopInfo, i); SExchangeInfo* pExchangeInfo = taosAcquireRef(exchangeObjRefPool, pStop->refId); if (pExchangeInfo) { - tsem_post(&pExchangeInfo->ready); - taosReleaseRef(exchangeObjRefPool, pStop->refId); + (void)tsem_post(&pExchangeInfo->ready); + (void)taosReleaseRef(exchangeObjRefPool, pStop->refId); } } @@ -829,12 +895,12 @@ int32_t qKillTask(qTaskInfo_t tinfo, int32_t rspCode) { qDebug("%s sync killed execTask", GET_TASKID(pTaskInfo)); setTaskKilled(pTaskInfo, TSDB_CODE_TSC_QUERY_KILLED); - while(1) { + while (1) { taosWLockLatch(&pTaskInfo->lock); - if (qTaskIsExecuting(pTaskInfo)) { // let's wait for 100 ms and try again + if (qTaskIsExecuting(pTaskInfo)) { // let's wait for 100 ms and try again taosWUnLockLatch(&pTaskInfo->lock); taosMsleep(100); - } else { // not running now + } else { // not running now pTaskInfo->code = rspCode; taosWUnLockLatch(&pTaskInfo->lock); return TSDB_CODE_SUCCESS; @@ -907,7 +973,7 @@ int32_t qExtractStreamScanner(qTaskInfo_t tinfo, void** scanner) { } } -int32_t qStreamSourceScanParamForHistoryScanStep1(qTaskInfo_t tinfo, SVersionRange *pVerRange, STimeWindow* pWindow) { +int32_t qStreamSourceScanParamForHistoryScanStep1(qTaskInfo_t tinfo, SVersionRange* pVerRange, STimeWindow* pWindow) { SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo; ASSERT(pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM); @@ -917,14 +983,14 @@ int32_t qStreamSourceScanParamForHistoryScanStep1(qTaskInfo_t tinfo, SVersionRan pStreamInfo->fillHistoryWindow = *pWindow; pStreamInfo->recoverStep = STREAM_RECOVER_STEP__PREPARE1; - qDebug("%s step 1. set param for stream scanner for scan-history data, verRange:%" PRId64 " - %" PRId64 ", window:%" PRId64 - " - %" PRId64, + qDebug("%s step 1. set param for stream scanner for scan-history data, verRange:%" PRId64 " - %" PRId64 + ", window:%" PRId64 " - %" PRId64, GET_TASKID(pTaskInfo), pStreamInfo->fillHistoryVer.minVer, pStreamInfo->fillHistoryVer.maxVer, pWindow->skey, pWindow->ekey); return 0; } -int32_t qStreamSourceScanParamForHistoryScanStep2(qTaskInfo_t tinfo, SVersionRange *pVerRange, STimeWindow* pWindow) { +int32_t qStreamSourceScanParamForHistoryScanStep2(qTaskInfo_t tinfo, SVersionRange* pVerRange, STimeWindow* pWindow) { SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo; ASSERT(pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM); @@ -955,9 +1021,10 @@ int32_t qSetStreamOperatorOptionForScanHistory(qTaskInfo_t tinfo) { while (1) { int32_t type = pOperator->operatorType; if (type == QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL || type == QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL || - type == QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL || type == QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL) { + type == QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL || + type == QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL) { SStreamIntervalOperatorInfo* pInfo = pOperator->info; - STimeWindowAggSupp* pSup = &pInfo->twAggSup; + STimeWindowAggSupp* pSup = &pInfo->twAggSup; ASSERT(pSup->calTrigger == STREAM_TRIGGER_AT_ONCE || pSup->calTrigger == STREAM_TRIGGER_WINDOW_CLOSE); ASSERT(pSup->calTriggerSaved == 0 && pSup->deleteMarkSaved == 0); @@ -974,7 +1041,7 @@ int32_t qSetStreamOperatorOptionForScanHistory(qTaskInfo_t tinfo) { type == QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION || type == QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION) { SStreamSessionAggOperatorInfo* pInfo = pOperator->info; - STimeWindowAggSupp* pSup = &pInfo->twAggSup; + STimeWindowAggSupp* pSup = &pInfo->twAggSup; ASSERT(pSup->calTrigger == STREAM_TRIGGER_AT_ONCE || pSup->calTrigger == STREAM_TRIGGER_WINDOW_CLOSE); ASSERT(pSup->calTriggerSaved == 0 && pSup->deleteMarkSaved == 0); @@ -989,7 +1056,7 @@ int32_t qSetStreamOperatorOptionForScanHistory(qTaskInfo_t tinfo) { pInfo->ignoreExpiredData = false; } else if (type == QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE) { SStreamStateAggOperatorInfo* pInfo = pOperator->info; - STimeWindowAggSupp* pSup = &pInfo->twAggSup; + STimeWindowAggSupp* pSup = &pInfo->twAggSup; ASSERT(pSup->calTrigger == STREAM_TRIGGER_AT_ONCE || pSup->calTrigger == STREAM_TRIGGER_WINDOW_CLOSE); ASSERT(pSup->calTriggerSaved == 0 && pSup->deleteMarkSaved == 0); @@ -1004,7 +1071,7 @@ int32_t qSetStreamOperatorOptionForScanHistory(qTaskInfo_t tinfo) { pInfo->ignoreExpiredData = false; } else if (type == QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT) { SStreamEventAggOperatorInfo* pInfo = pOperator->info; - STimeWindowAggSupp* pSup = &pInfo->twAggSup; + STimeWindowAggSupp* pSup = &pInfo->twAggSup; ASSERT(pSup->calTrigger == STREAM_TRIGGER_AT_ONCE || pSup->calTrigger == STREAM_TRIGGER_WINDOW_CLOSE); ASSERT(pSup->calTriggerSaved == 0 && pSup->deleteMarkSaved == 0); @@ -1019,7 +1086,7 @@ int32_t qSetStreamOperatorOptionForScanHistory(qTaskInfo_t tinfo) { pInfo->ignoreExpiredData = false; } else if (type == QUERY_NODE_PHYSICAL_PLAN_STREAM_COUNT) { SStreamCountAggOperatorInfo* pInfo = pOperator->info; - STimeWindowAggSupp* pSup = &pInfo->twAggSup; + STimeWindowAggSupp* pSup = &pInfo->twAggSup; ASSERT(pSup->calTrigger == STREAM_TRIGGER_AT_ONCE || pSup->calTrigger == STREAM_TRIGGER_WINDOW_CLOSE); ASSERT(pSup->calTriggerSaved == 0 && pSup->deleteMarkSaved == 0); @@ -1137,20 +1204,21 @@ void qStreamSetSourceExcluded(qTaskInfo_t tinfo, int8_t sourceExcluded) { } int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subType) { + int32_t code = TSDB_CODE_SUCCESS; SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; SOperatorInfo* pOperator = pTaskInfo->pRoot; const char* id = GET_TASKID(pTaskInfo); - if(subType == TOPIC_SUB_TYPE__COLUMN && pOffset->type == TMQ_OFFSET__LOG){ + if (subType == TOPIC_SUB_TYPE__COLUMN && pOffset->type == TMQ_OFFSET__LOG) { pOperator = extractOperatorInTree(pOperator, QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN, id); if (pOperator == NULL) { return -1; } SStreamScanInfo* pInfo = pOperator->info; - SStoreTqReader* pReaderAPI = &pTaskInfo->storageAPI.tqReaderFn; - SWalReader* pWalReader = pReaderAPI->tqReaderGetWalReader(pInfo->tqReader); + SStoreTqReader* pReaderAPI = &pTaskInfo->storageAPI.tqReaderFn; + SWalReader* pWalReader = pReaderAPI->tqReaderGetWalReader(pInfo->tqReader); walReaderVerifyOffset(pWalReader, pOffset); } // if pOffset equal to current offset, means continue consume @@ -1229,9 +1297,9 @@ int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subT int64_t oldSkey = pScanBaseInfo->cond.twindows.skey; // let's start from the next ts that returned to consumer. - if(pTaskInfo->storageAPI.tqReaderFn.tqGetTablePrimaryKey(pInfo->tqReader)){ + if (pTaskInfo->storageAPI.tqReaderFn.tqGetTablePrimaryKey(pInfo->tqReader)) { pScanBaseInfo->cond.twindows.skey = ts; - }else{ + } else { pScanBaseInfo->cond.twindows.skey = ts + 1; } pScanInfo->scanTimes = 0; @@ -1249,8 +1317,17 @@ int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subT qDebug("tsdb reader created with offset(snapshot) uid:%" PRId64 " ts:%" PRId64 " table index:%d, total:%d, %s", uid, pScanBaseInfo->cond.twindows.skey, pScanInfo->currentTable, numOfTables, id); } else { - pTaskInfo->storageAPI.tsdReader.tsdSetQueryTableList(pScanBaseInfo->dataReader, &keyInfo, 1); - pTaskInfo->storageAPI.tsdReader.tsdReaderResetStatus(pScanBaseInfo->dataReader, &pScanBaseInfo->cond); + code = pTaskInfo->storageAPI.tsdReader.tsdSetQueryTableList(pScanBaseInfo->dataReader, &keyInfo, 1); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } + + code = pTaskInfo->storageAPI.tsdReader.tsdReaderResetStatus(pScanBaseInfo->dataReader, &pScanBaseInfo->cond); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } qDebug("tsdb reader offset seek snapshot to uid:%" PRId64 " ts %" PRId64 " table index:%d numOfTable:%d, %s", uid, pScanBaseInfo->cond.twindows.skey, pScanInfo->currentTable, numOfTables, id); } @@ -1289,20 +1366,32 @@ int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subT } pAPI->snapshotFn.taosXSetTablePrimaryKey(sContext, mtInfo.uid); - initQueryTableDataCondForTmq(&pTaskInfo->streamInfo.tableCond, sContext, &mtInfo); - if(pAPI->snapshotFn.taosXGetTablePrimaryKey(sContext)){ + code = initQueryTableDataCondForTmq(&pTaskInfo->streamInfo.tableCond, sContext, &mtInfo); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } + if (pAPI->snapshotFn.taosXGetTablePrimaryKey(sContext)) { pTaskInfo->streamInfo.tableCond.twindows.skey = pOffset->ts; - }else{ + } else { pTaskInfo->streamInfo.tableCond.twindows.skey = pOffset->ts + 1; } - tableListAddTableInfo(pTableListInfo, mtInfo.uid, 0); + code = tableListAddTableInfo(pTableListInfo, mtInfo.uid, 0); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } STableKeyInfo* pList = tableListGetInfo(pTableListInfo, 0); int32_t size = tableListGetSize(pTableListInfo); - pTaskInfo->storageAPI.tsdReader.tsdReaderOpen(pInfo->vnode, &pTaskInfo->streamInfo.tableCond, pList, size, NULL, - (void**)&pInfo->dataReader, NULL, NULL); + code = pTaskInfo->storageAPI.tsdReader.tsdReaderOpen(pInfo->vnode, &pTaskInfo->streamInfo.tableCond, pList, size, + NULL, (void**)&pInfo->dataReader, NULL, NULL); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } cleanupQueryTableDataCond(&pTaskInfo->streamInfo.tableCond); strcpy(pTaskInfo->streamInfo.tbName, mtInfo.tbName); @@ -1353,12 +1442,14 @@ void qProcessRspMsg(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) { } } - pSendInfo->fp(pSendInfo->param, &buf, pMsg->code); + (void)pSendInfo->fp(pSendInfo->param, &buf, pMsg->code); rpcFreeCont(pMsg->pCont); destroySendMsgInfo(pSendInfo); } SArray* qGetQueriedTableListInfo(qTaskInfo_t tinfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = tinfo; SArray* plist = getTableListInfo(pTaskInfo); @@ -1366,30 +1457,50 @@ SArray* qGetQueriedTableListInfo(qTaskInfo_t tinfo) { STableListInfo* pTableListInfo = taosArrayGetP(plist, 0); SArray* pUidList = taosArrayInit(10, sizeof(uint64_t)); + QUERY_CHECK_NULL(pUidList, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); int32_t numOfTables = tableListGetSize(pTableListInfo); for (int32_t i = 0; i < numOfTables; ++i) { STableKeyInfo* pKeyInfo = tableListGetInfo(pTableListInfo, i); - taosArrayPush(pUidList, &pKeyInfo->uid); + void* tmp = taosArrayPush(pUidList, &pKeyInfo->uid); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } taosArrayDestroy(plist); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } return pUidList; } static void extractTableList(SArray* pList, const SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + if (pOperator->operatorType == QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) { SStreamScanInfo* pScanInfo = pOperator->info; STableScanInfo* pTableScanInfo = pScanInfo->pTableScanOp->info; - taosArrayPush(pList, &pTableScanInfo->base.pTableListInfo); + void* tmp = taosArrayPush(pList, &pTableScanInfo->base.pTableListInfo); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } else if (pOperator->operatorType == QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN) { STableScanInfo* pScanInfo = pOperator->info; - taosArrayPush(pList, &pScanInfo->base.pTableListInfo); + void* tmp = taosArrayPush(pList, &pScanInfo->base.pTableListInfo); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } else { if (pOperator->pDownstream != NULL && pOperator->pDownstream[0] != NULL) { extractTableList(pList, pOperator->pDownstream[0]); } } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } SArray* getTableListInfo(const SExecTaskInfo* pTaskInfo) { @@ -1400,13 +1511,13 @@ SArray* getTableListInfo(const SExecTaskInfo* pTaskInfo) { } int32_t qStreamOperatorReleaseState(qTaskInfo_t tInfo) { - SExecTaskInfo* pTaskInfo = (SExecTaskInfo*) tInfo; + SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tInfo; pTaskInfo->pRoot->fpSet.releaseStreamStateFn(pTaskInfo->pRoot); return 0; } int32_t qStreamOperatorReloadState(qTaskInfo_t tInfo) { - SExecTaskInfo* pTaskInfo = (SExecTaskInfo*) tInfo; + SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tInfo; pTaskInfo->pRoot->fpSet.reloadStreamStateFn(pTaskInfo->pRoot); return 0; } diff --git a/source/libs/executor/src/executorInt.c b/source/libs/executor/src/executorInt.c index 0476a7981c..dd6067da34 100644 --- a/source/libs/executor/src/executorInt.c +++ b/source/libs/executor/src/executorInt.c @@ -72,14 +72,14 @@ static UNUSED_FUNC void* u_realloc(void* p, size_t __size) { #define realloc u_realloc #endif -static void setBlockSMAInfo(SqlFunctionCtx* pCtx, SExprInfo* pExpr, SSDataBlock* pBlock); +static int32_t setBlockSMAInfo(SqlFunctionCtx* pCtx, SExprInfo* pExpr, SSDataBlock* pBlock); static void initCtxOutputBuffer(SqlFunctionCtx* pCtx, int32_t size); static void doApplyScalarCalculation(SOperatorInfo* pOperator, SSDataBlock* pBlock, int32_t order, int32_t scanFlag); static int32_t doSetInputDataBlock(SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t order, int32_t scanFlag, bool createDummyCol); -static int32_t doCopyToSDataBlock(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf, +static void doCopyToSDataBlock(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf, SGroupResInfo* pGroupResInfo, int32_t threshold, bool ignoreGroup); SResultRow* getNewResultRow(SDiskbasedBuf* pResultBuf, int32_t* currentPageId, int32_t interBufSize) { @@ -192,8 +192,12 @@ SResultRow* doSetResultOutBufByKey(SDiskbasedBuf* pResultBuf, SResultRowInfo* pR // add a new result set for a new group SResultRowPosition pos = {.pageId = pResult->pageId, .offset = pResult->offset}; - tSimpleHashPut(pSup->pResultRowHashTable, pSup->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes), &pos, - sizeof(SResultRowPosition)); + int32_t code = tSimpleHashPut(pSup->pResultRowHashTable, pSup->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes), &pos, + sizeof(SResultRowPosition)); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } // 2. set the new time window to be the new active time window @@ -209,11 +213,14 @@ SResultRow* doSetResultOutBufByKey(SDiskbasedBuf* pResultBuf, SResultRowInfo* pR } // query_range_start, query_range_end, window_duration, window_start, window_end -void initExecTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pQueryWindow) { +int32_t initExecTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pQueryWindow) { pColData->info.type = TSDB_DATA_TYPE_TIMESTAMP; pColData->info.bytes = sizeof(int64_t); - colInfoDataEnsureCapacity(pColData, 5, false); + int32_t code = colInfoDataEnsureCapacity(pColData, 5, false); + if (code != TSDB_CODE_SUCCESS) { + return code; + } colDataSetInt64(pColData, 0, &pQueryWindow->skey); colDataSetInt64(pColData, 1, &pQueryWindow->ekey); @@ -221,35 +228,46 @@ void initExecTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pQueryWindow colDataSetInt64(pColData, 2, &interval); // this value may be variable in case of 'n' and 'y'. colDataSetInt64(pColData, 3, &pQueryWindow->skey); colDataSetInt64(pColData, 4, &pQueryWindow->ekey); + return TSDB_CODE_SUCCESS; } -static void doSetInputDataBlockInfo(SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t order, int32_t scanFlag) { +static int32_t doSetInputDataBlockInfo(SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t order, int32_t scanFlag) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SqlFunctionCtx* pCtx = pExprSup->pCtx; for (int32_t i = 0; i < pExprSup->numOfExprs; ++i) { pCtx[i].order = order; pCtx[i].input.numOfRows = pBlock->info.rows; - setBlockSMAInfo(&pCtx[i], &pExprSup->pExprInfo[i], pBlock); + code = setBlockSMAInfo(&pCtx[i], &pExprSup->pExprInfo[i], pBlock); + QUERY_CHECK_CODE(code, lino, _end); pCtx[i].pSrcBlock = pBlock; pCtx[i].scanFlag = scanFlag; } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } -void setInputDataBlock(SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t order, int32_t scanFlag, bool createDummyCol) { +int32_t setInputDataBlock(SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t order, int32_t scanFlag, + bool createDummyCol) { if (pBlock->pBlockAgg != NULL) { - doSetInputDataBlockInfo(pExprSup, pBlock, order, scanFlag); + return doSetInputDataBlockInfo(pExprSup, pBlock, order, scanFlag); } else { - doSetInputDataBlock(pExprSup, pBlock, order, scanFlag, createDummyCol); + return doSetInputDataBlock(pExprSup, pBlock, order, scanFlag, createDummyCol); } } static int32_t doCreateConstantValColumnInfo(SInputColumnInfoData* pInput, SFunctParam* pFuncParam, int32_t paramIndex, int32_t numOfRows) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SColumnInfoData* pColInfo = NULL; if (pInput->pData[paramIndex] == NULL) { pColInfo = taosMemoryCalloc(1, sizeof(SColumnInfoData)); - if (pColInfo == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; - } + QUERY_CHECK_NULL(pColInfo, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); // Set the correct column info (data type and bytes) pColInfo->info.type = pFuncParam->param.nType; @@ -260,7 +278,8 @@ static int32_t doCreateConstantValColumnInfo(SInputColumnInfoData* pInput, SFunc pColInfo = pInput->pData[paramIndex]; } - colInfoDataEnsureCapacity(pColInfo, numOfRows, false); + code = colInfoDataEnsureCapacity(pColInfo, numOfRows, false); + QUERY_CHECK_CODE(code, lino, _end); int8_t type = pFuncParam->param.nType; if (type == TSDB_DATA_TYPE_BIGINT || type == TSDB_DATA_TYPE_UBIGINT) { @@ -277,12 +296,17 @@ static int32_t doCreateConstantValColumnInfo(SInputColumnInfoData* pInput, SFunc char* tmp = taosMemoryMalloc(pFuncParam->param.nLen + VARSTR_HEADER_SIZE); STR_WITH_SIZE_TO_VARSTR(tmp, pFuncParam->param.pz, pFuncParam->param.nLen); for (int32_t i = 0; i < numOfRows; ++i) { - colDataSetVal(pColInfo, i, tmp, false); + code = colDataSetVal(pColInfo, i, tmp, false); + QUERY_CHECK_CODE(code, lino, _end); } taosMemoryFree(tmp); } - return TSDB_CODE_SUCCESS; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static int32_t doSetInputDataBlock(SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t order, int32_t scanFlag, @@ -302,7 +326,7 @@ static int32_t doSetInputDataBlock(SExprSupp* pExprSup, SSDataBlock* pBlock, int pInput->colDataSMAIsSet = false; SExprInfo* pOneExpr = &pExprSup->pExprInfo[i]; - bool hasPk = pOneExpr->pExpr->nodeType == QUERY_NODE_FUNCTION && pOneExpr->pExpr->_function.pFunctNode->hasPk; + bool hasPk = pOneExpr->pExpr->nodeType == QUERY_NODE_FUNCTION && pOneExpr->pExpr->_function.pFunctNode->hasPk; pCtx[i].hasPrimaryKey = hasPk; int16_t tsParamIdx = (!hasPk) ? pOneExpr->base.numOfParams - 1 : pOneExpr->base.numOfParams - 2; @@ -320,13 +344,13 @@ static int32_t doSetInputDataBlock(SExprSupp* pExprSup, SSDataBlock* pBlock, int // NOTE: the last parameter is the primary timestamp column // todo: refactor this - + if (fmIsImplicitTsFunc(pCtx[i].functionId) && (j == tsParamIdx)) { pInput->pPTS = pInput->pData[j]; // in case of merge function, this is not always the ts column data. } if (hasPk && (j == pkParamIdx)) { pInput->pPrimaryKey = pInput->pData[j]; - } + } ASSERT(pInput->pData[j] != NULL); } else if (pFuncParam->type == FUNC_PARAM_TYPE_VALUE) { // todo avoid case: top(k, 12), 12 is the value parameter. @@ -419,7 +443,9 @@ static int32_t doCreateConstantValColumnSMAInfo(SInputColumnInfoData* pInput, SF return TSDB_CODE_SUCCESS; } -void setBlockSMAInfo(SqlFunctionCtx* pCtx, SExprInfo* pExprInfo, SSDataBlock* pBlock) { +int32_t setBlockSMAInfo(SqlFunctionCtx* pCtx, SExprInfo* pExprInfo, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; int32_t numOfRows = pBlock->info.rows; SInputColumnInfoData* pInput = &pCtx->input; @@ -443,12 +469,19 @@ void setBlockSMAInfo(SqlFunctionCtx* pCtx, SExprInfo* pExprInfo, SSDataBlock* pB // the data in the corresponding SColumnInfoData will not be used. pInput->pData[j] = taosArrayGet(pBlock->pDataBlock, slotId); } else if (pFuncParam->type == FUNC_PARAM_TYPE_VALUE) { - doCreateConstantValColumnSMAInfo(pInput, pFuncParam, pFuncParam->param.nType, j, pBlock->info.rows); + code = doCreateConstantValColumnSMAInfo(pInput, pFuncParam, pFuncParam->param.nType, j, pBlock->info.rows); + QUERY_CHECK_CODE(code, lino, _end); } } } else { pInput->colDataSMAIsSet = false; } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } ///////////////////////////////////////////////////////////////////////////////////////////// @@ -468,7 +501,8 @@ STimeWindow getAlignQueryTimeWindow(const SInterval* pInterval, int64_t key) { return win; } -int32_t setResultRowInitCtx(SResultRow* pResult, SqlFunctionCtx* pCtx, int32_t numOfOutput, int32_t* rowEntryInfoOffset) { +int32_t setResultRowInitCtx(SResultRow* pResult, SqlFunctionCtx* pCtx, int32_t numOfOutput, + int32_t* rowEntryInfoOffset) { bool init = false; for (int32_t i = 0; i < numOfOutput; ++i) { pCtx[i].resultInfo = getResultEntryInfo(pResult, i, rowEntryInfoOffset); @@ -488,7 +522,7 @@ int32_t setResultRowInitCtx(SResultRow* pResult, SqlFunctionCtx* pCtx, int32_t n if (!pResInfo->initialized) { if (pCtx[i].functionId != -1) { bool ini = pCtx[i].fpSet.init(&pCtx[i], pResInfo); - if (!ini && fmIsUserDefinedFunc(pCtx[i].functionId)){ + if (!ini && fmIsUserDefinedFunc(pCtx[i].functionId)) { pResInfo->initialized = false; return TSDB_CODE_UDF_FUNC_EXEC_FAILURE; } @@ -517,6 +551,8 @@ void clearResultRowInitFlag(SqlFunctionCtx* pCtx, int32_t numOfOutput) { } int32_t doFilter(SSDataBlock* pBlock, SFilterInfo* pFilterInfo, SColMatchInfo* pColMatchInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pFilterInfo == NULL || pBlock->info.rows == 0) { return TSDB_CODE_SUCCESS; } @@ -524,16 +560,12 @@ int32_t doFilter(SSDataBlock* pBlock, SFilterInfo* pFilterInfo, SColMatchInfo* p SFilterColumnParam param1 = {.numOfCols = taosArrayGetSize(pBlock->pDataBlock), .pDataBlock = pBlock->pDataBlock}; SColumnInfoData* p = NULL; - int32_t code = filterSetDataFromSlotId(pFilterInfo, ¶m1); - if (code != TSDB_CODE_SUCCESS) { - goto _err; - } + code = filterSetDataFromSlotId(pFilterInfo, ¶m1); + QUERY_CHECK_CODE(code, lino, _err); int32_t status = 0; code = filterExecute(pFilterInfo, pBlock, &p, NULL, param1.numOfCols, &status); - if (code != TSDB_CODE_SUCCESS) { - goto _err; - } + QUERY_CHECK_CODE(code, lino, _err); extractQualifiedTupleByFilterResult(pBlock, p, status); @@ -544,7 +576,8 @@ int32_t doFilter(SSDataBlock* pBlock, SFilterInfo* pFilterInfo, SColMatchInfo* p if (pInfo->colId == PRIMARYKEY_TIMESTAMP_COL_ID) { SColumnInfoData* pColData = taosArrayGet(pBlock->pDataBlock, pInfo->dstSlotId); if (pColData->info.type == TSDB_DATA_TYPE_TIMESTAMP) { - blockDataUpdateTsWindow(pBlock, pInfo->dstSlotId); + code = blockDataUpdateTsWindow(pBlock, pInfo->dstSlotId); + QUERY_CHECK_CODE(code, lino, _err); break; } } @@ -598,6 +631,8 @@ void doUpdateNumOfRows(SqlFunctionCtx* pCtx, SResultRow* pRow, int32_t numOfExpr void copyResultrowToDataBlock(SExprInfo* pExprInfo, int32_t numOfExprs, SResultRow* pRow, SqlFunctionCtx* pCtx, SSDataBlock* pBlock, const int32_t* rowEntryOffset, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; for (int32_t j = 0; j < numOfExprs; ++j) { int32_t slotId = pExprInfo[j].base.resSchema.slotId; @@ -611,8 +646,10 @@ void copyResultrowToDataBlock(SExprInfo* pExprInfo, int32_t numOfExprs, SResultR } } - blockDataEnsureCapacity(pBlock, pBlock->info.rows + pCtx[j].resultInfo->numOfRes); - int32_t code = pCtx[j].fpSet.finalize(&pCtx[j], pBlock); + code = blockDataEnsureCapacity(pBlock, pBlock->info.rows + pCtx[j].resultInfo->numOfRes); + QUERY_CHECK_CODE(code, lino, _end); + + code = pCtx[j].fpSet.finalize(&pCtx[j], pBlock); if (TAOS_FAILED(code)) { qError("%s build result data block error, code %s", GET_TASKID(pTaskInfo), tstrerror(code)); T_LONG_JMP(pTaskInfo->env, code); @@ -625,10 +662,17 @@ void copyResultrowToDataBlock(SExprInfo* pExprInfo, int32_t numOfExprs, SResultR SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, slotId); char* in = GET_ROWCELL_INTERBUF(pCtx[j].resultInfo); for (int32_t k = 0; k < pRow->numOfRows; ++k) { - colDataSetVal(pColInfoData, pBlock->info.rows + k, in, pCtx[j].resultInfo->isNullRes); + code = colDataSetVal(pColInfoData, pBlock->info.rows + k, in, pCtx[j].resultInfo->isNullRes); + QUERY_CHECK_CODE(code, lino, _end); } } } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } // todo refactor. SResultRow has direct pointer in miainfo @@ -671,9 +715,10 @@ int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPos return 0; } -int32_t doCopyToSDataBlockByHash(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf, - SGroupResInfo* pGroupResInfo, SSHashObj* pHashmap, int32_t threshold, - bool ignoreGroup) { +void doCopyToSDataBlockByHash(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf, + SGroupResInfo* pGroupResInfo, SSHashObj* pHashmap, int32_t threshold, bool ignoreGroup) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExprInfo* pExprInfo = pSup->pExprInfo; int32_t numOfExprs = pSup->numOfExprs; int32_t* rowEntryOffset = pSup->rowEntryInfoOffset; @@ -724,7 +769,8 @@ int32_t doCopyToSDataBlockByHash(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, if (pBlock->info.rows + pRow->numOfRows > pBlock->info.capacity) { uint32_t newSize = pBlock->info.rows + pRow->numOfRows + ((numOfRows - iter) > 1 ? 1 : 0); - blockDataEnsureCapacity(pBlock, newSize); + code = blockDataEnsureCapacity(pBlock, newSize); + QUERY_CHECK_CODE(code, lino, _end); qDebug("datablock capacity not sufficient, expand to required:%d, current capacity:%d, %s", newSize, pBlock->info.capacity, GET_TASKID(pTaskInfo)); // todo set the pOperator->resultInfo size @@ -744,14 +790,22 @@ int32_t doCopyToSDataBlockByHash(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, } qDebug("%s result generated, rows:%" PRId64 ", groupId:%" PRIu64, GET_TASKID(pTaskInfo), pBlock->info.rows, - pBlock->info.id.groupId); + pBlock->info.id.groupId); pBlock->info.dataLoad = 1; - blockDataUpdateTsWindow(pBlock, 0); - return 0; + code = blockDataUpdateTsWindow(pBlock, 0); + QUERY_CHECK_CODE(code, lino, _end); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } -int32_t doCopyToSDataBlock(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf, - SGroupResInfo* pGroupResInfo, int32_t threshold, bool ignoreGroup) { +void doCopyToSDataBlock(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf, + SGroupResInfo* pGroupResInfo, int32_t threshold, bool ignoreGroup) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExprInfo* pExprInfo = pSup->pExprInfo; int32_t numOfExprs = pSup->numOfExprs; int32_t* rowEntryOffset = pSup->rowEntryInfoOffset; @@ -792,7 +846,8 @@ int32_t doCopyToSDataBlock(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprS if (pBlock->info.rows + pRow->numOfRows > pBlock->info.capacity) { uint32_t newSize = pBlock->info.rows + pRow->numOfRows + ((numOfRows - i) > 1 ? 1 : 0); - blockDataEnsureCapacity(pBlock, newSize); + code = blockDataEnsureCapacity(pBlock, newSize); + QUERY_CHECK_CODE(code, lino, _end); qDebug("datablock capacity not sufficient, expand to required:%d, current capacity:%d, %s", newSize, pBlock->info.capacity, GET_TASKID(pTaskInfo)); // todo set the pOperator->resultInfo size @@ -811,8 +866,14 @@ int32_t doCopyToSDataBlock(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprS qDebug("%s result generated, rows:%" PRId64 ", groupId:%" PRIu64, GET_TASKID(pTaskInfo), pBlock->info.rows, pBlock->info.id.groupId); pBlock->info.dataLoad = 1; - blockDataUpdateTsWindow(pBlock, 0); - return 0; + code = blockDataUpdateTsWindow(pBlock, 0); + QUERY_CHECK_CODE(code, lino, _end); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } void doBuildResultDatablock(SOperatorInfo* pOperator, SOptrBasicInfo* pbInfo, SGroupResInfo* pGroupResInfo, @@ -909,9 +970,9 @@ void initBasicInfo(SOptrBasicInfo* pInfo, SSDataBlock* pBlock) { initResultRowInfo(&pInfo->resultRowInfo); } -static void* destroySqlFunctionCtx(SqlFunctionCtx* pCtx, SExprInfo* pExpr, int32_t numOfOutput) { +static void destroySqlFunctionCtx(SqlFunctionCtx* pCtx, SExprInfo* pExpr, int32_t numOfOutput) { if (pCtx == NULL) { - return NULL; + return; } for (int32_t i = 0; i < numOfOutput; ++i) { @@ -939,7 +1000,7 @@ static void* destroySqlFunctionCtx(SqlFunctionCtx* pCtx, SExprInfo* pExpr, int32 } taosMemoryFreeClear(pCtx); - return NULL; + return; } int32_t initExprSupp(SExprSupp* pSup, SExprInfo* pExprInfo, int32_t numOfExpr, SFunctionStateStore* pStore) { @@ -970,7 +1031,10 @@ void cleanupExprSupp(SExprSupp* pSupp) { taosMemoryFree(pSupp->rowEntryInfoOffset); } -void cleanupBasicInfo(SOptrBasicInfo* pInfo) { blockDataDestroy(pInfo->pRes); pInfo->pRes = NULL;} +void cleanupBasicInfo(SOptrBasicInfo* pInfo) { + blockDataDestroy(pInfo->pRes); + pInfo->pRes = NULL; +} bool groupbyTbname(SNodeList* pGroupList) { bool bytbname = false; @@ -1019,7 +1083,12 @@ int32_t createDataSinkParam(SDataSinkNode* pNode, void** pParam, SExecTaskInfo* for (int32_t i = 0; i < numOfTables; ++i) { STableKeyInfo* pTable = tableListGetInfo(pTableListInfo, i); - taosArrayPush(pDeleterParam->pUidList, &pTable->uid); + void* tmp = taosArrayPush(pDeleterParam->pUidList, &pTable->uid); + if (!tmp) { + taosArrayDestroy(pDeleterParam->pUidList); + taosMemoryFree(pDeleterParam); + return TSDB_CODE_OUT_OF_MEMORY; + } } *pParam = pDeleterParam; @@ -1056,7 +1125,7 @@ void freeOperatorParamImpl(SOperatorParam* pParam, SOperatorParamType type) { taosArrayDestroy(pParam->pChildren); taosMemoryFree(pParam->value); - + taosMemoryFree(pParam); } @@ -1077,25 +1146,15 @@ void freeExchangeGetOperatorParam(SOperatorParam* pParam) { freeOperatorParamImpl(pParam, OP_GET_PARAM); } -void freeExchangeNotifyOperatorParam(SOperatorParam* pParam) { - freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM); -} +void freeExchangeNotifyOperatorParam(SOperatorParam* pParam) { freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM); } -void freeGroupCacheGetOperatorParam(SOperatorParam* pParam) { - freeOperatorParamImpl(pParam, OP_GET_PARAM); -} +void freeGroupCacheGetOperatorParam(SOperatorParam* pParam) { freeOperatorParamImpl(pParam, OP_GET_PARAM); } -void freeGroupCacheNotifyOperatorParam(SOperatorParam* pParam) { - freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM); -} +void freeGroupCacheNotifyOperatorParam(SOperatorParam* pParam) { freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM); } -void freeMergeJoinGetOperatorParam(SOperatorParam* pParam) { - freeOperatorParamImpl(pParam, OP_GET_PARAM); -} +void freeMergeJoinGetOperatorParam(SOperatorParam* pParam) { freeOperatorParamImpl(pParam, OP_GET_PARAM); } -void freeMergeJoinNotifyOperatorParam(SOperatorParam* pParam) { - freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM); -} +void freeMergeJoinNotifyOperatorParam(SOperatorParam* pParam) { freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM); } void freeTableScanGetOperatorParam(SOperatorParam* pParam) { STableScanOperatorParam* pTableScanParam = (STableScanOperatorParam*)pParam->value; @@ -1103,16 +1162,13 @@ void freeTableScanGetOperatorParam(SOperatorParam* pParam) { freeOperatorParamImpl(pParam, OP_GET_PARAM); } -void freeTableScanNotifyOperatorParam(SOperatorParam* pParam) { - freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM); -} - +void freeTableScanNotifyOperatorParam(SOperatorParam* pParam) { freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM); } void freeOperatorParam(SOperatorParam* pParam, SOperatorParamType type) { if (NULL == pParam) { return; } - + switch (pParam->opType) { case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE: type == OP_GET_PARAM ? freeExchangeGetOperatorParam(pParam) : freeExchangeNotifyOperatorParam(pParam); @@ -1133,7 +1189,7 @@ void freeOperatorParam(SOperatorParam* pParam, SOperatorParamType type) { } void freeResetOperatorParams(struct SOperatorInfo* pOperator, SOperatorParamType type, bool allFree) { - SOperatorParam** ppParam = NULL; + SOperatorParam** ppParam = NULL; SOperatorParam*** pppDownstramParam = NULL; switch (type) { case OP_GET_PARAM: @@ -1166,22 +1222,22 @@ void freeResetOperatorParams(struct SOperatorInfo* pOperator, SOperatorParamType } } - -FORCE_INLINE SSDataBlock* getNextBlockFromDownstreamImpl(struct SOperatorInfo* pOperator, int32_t idx, bool clearParam) { +FORCE_INLINE SSDataBlock* getNextBlockFromDownstreamImpl(struct SOperatorInfo* pOperator, int32_t idx, + bool clearParam) { if (pOperator->pDownstreamGetParams && pOperator->pDownstreamGetParams[idx]) { qDebug("DynOp: op %s start to get block from downstream %s", pOperator->name, pOperator->pDownstream[idx]->name); - SSDataBlock* pBlock = pOperator->pDownstream[idx]->fpSet.getNextExtFn(pOperator->pDownstream[idx], pOperator->pDownstreamGetParams[idx]); + SSDataBlock* pBlock = pOperator->pDownstream[idx]->fpSet.getNextExtFn(pOperator->pDownstream[idx], + pOperator->pDownstreamGetParams[idx]); if (clearParam) { freeOperatorParam(pOperator->pDownstreamGetParams[idx], OP_GET_PARAM); pOperator->pDownstreamGetParams[idx] = NULL; } return pBlock; } - + return pOperator->pDownstream[idx]->fpSet.getNextFn(pOperator->pDownstream[idx]); } - bool compareVal(const char* v, const SStateKeys* pKey) { if (IS_VAR_DATA_TYPE(pKey->type)) { if (varDataLen(v) != varDataLen(pKey->pData)) { diff --git a/source/libs/executor/src/filloperator.c b/source/libs/executor/src/filloperator.c index ad1c6d67d4..cf31b5b7ad 100644 --- a/source/libs/executor/src/filloperator.c +++ b/source/libs/executor/src/filloperator.c @@ -26,11 +26,11 @@ #include "ttime.h" #include "function.h" +#include "operator.h" #include "querynodes.h" +#include "querytask.h" #include "tdatablock.h" #include "tfill.h" -#include "operator.h" -#include "querytask.h" typedef struct STimeRange { TSKEY skey; @@ -65,9 +65,9 @@ static void doHandleRemainBlockForNewGroupImpl(SOperatorInfo* pOperator, SFillOp pInfo->totalInputRows = pInfo->existNewGroupBlock->info.rows; SSDataBlock* pResBlock = pInfo->pFinalRes; -// int32_t order = TSDB_ORDER_ASC; + // int32_t order = TSDB_ORDER_ASC; int32_t scanFlag = MAIN_SCAN; -// getTableScanInfo(pOperator, &order, &scanFlag, false); + // getTableScanInfo(pOperator, &order, &scanFlag, false); taosResetFillInfo(pInfo->pFillInfo, getFillInfoStart(pInfo->pFillInfo)); blockDataCleanup(pInfo->pRes); @@ -75,7 +75,8 @@ static void doHandleRemainBlockForNewGroupImpl(SOperatorInfo* pOperator, SFillOp revisedFillStartKey(pInfo, pInfo->existNewGroupBlock, order); - int64_t ts = (order == TSDB_ORDER_ASC)? pInfo->existNewGroupBlock->info.window.ekey:pInfo->existNewGroupBlock->info.window.skey; + int64_t ts = (order == TSDB_ORDER_ASC) ? pInfo->existNewGroupBlock->info.window.ekey + : pInfo->existNewGroupBlock->info.window.skey; taosFillSetStartInfo(pInfo->pFillInfo, pInfo->pRes->info.rows, ts); taosFillSetInputDataBlock(pInfo->pFillInfo, pInfo->pRes); @@ -84,7 +85,12 @@ static void doHandleRemainBlockForNewGroupImpl(SOperatorInfo* pOperator, SFillOp } int32_t numOfResultRows = pResultInfo->capacity - pResBlock->info.rows; - taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows); + int32_t code = taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + T_LONG_JMP(pTaskInfo->env, code); + } pInfo->curGroupId = pInfo->existNewGroupBlock->info.id.groupId; pInfo->existNewGroupBlock = NULL; @@ -92,9 +98,14 @@ static void doHandleRemainBlockForNewGroupImpl(SOperatorInfo* pOperator, SFillOp static void doHandleRemainBlockFromNewGroup(SOperatorInfo* pOperator, SFillOperatorInfo* pInfo, SResultInfo* pResultInfo, int32_t order) { + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; if (taosFillHasMoreResults(pInfo->pFillInfo)) { int32_t numOfResultRows = pResultInfo->capacity - pInfo->pFinalRes->info.rows; - taosFillResultDataBlock(pInfo->pFillInfo, pInfo->pFinalRes, numOfResultRows); + int32_t code = taosFillResultDataBlock(pInfo->pFillInfo, pInfo->pFinalRes, numOfResultRows); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } pInfo->pRes->info.id.groupId = pInfo->curGroupId; return; } @@ -106,18 +117,32 @@ static void doHandleRemainBlockFromNewGroup(SOperatorInfo* pOperator, SFillOpera } void doApplyScalarCalculation(SOperatorInfo* pOperator, SSDataBlock* pBlock, int32_t order, int32_t scanFlag) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SFillOperatorInfo* pInfo = pOperator->info; SExprSupp* pSup = &pOperator->exprSupp; - setInputDataBlock(pSup, pBlock, order, scanFlag, false); - projectApplyFunctions(pSup->pExprInfo, pInfo->pRes, pBlock, pSup->pCtx, pSup->numOfExprs, NULL); + code = setInputDataBlock(pSup, pBlock, order, scanFlag, false); + QUERY_CHECK_CODE(code, lino, _end); + code = projectApplyFunctions(pSup->pExprInfo, pInfo->pRes, pBlock, pSup->pCtx, pSup->numOfExprs, NULL); + QUERY_CHECK_CODE(code, lino, _end); // reset the row value before applying the no-fill functions to the input data block, which is "pBlock" in this case. pInfo->pRes->info.rows = 0; SExprSupp* pNoFillSupp = &pInfo->noFillExprSupp; - setInputDataBlock(pNoFillSupp, pBlock, order, scanFlag, false); + code = setInputDataBlock(pNoFillSupp, pBlock, order, scanFlag, false); + QUERY_CHECK_CODE(code, lino, _end); - projectApplyFunctions(pNoFillSupp->pExprInfo, pInfo->pRes, pBlock, pNoFillSupp->pCtx, pNoFillSupp->numOfExprs, NULL); + code = projectApplyFunctions(pNoFillSupp->pExprInfo, pInfo->pRes, pBlock, pNoFillSupp->pCtx, pNoFillSupp->numOfExprs, + NULL); + QUERY_CHECK_CODE(code, lino, _end); pInfo->pRes->info.id.groupId = pBlock->info.id.groupId; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } static void fillResetPrevForNewGroup(SFillInfo* pFillInfo) { @@ -134,13 +159,13 @@ static void revisedFillStartKey(SFillOperatorInfo* pInfo, SSDataBlock* pBlock, i if (order == TSDB_ORDER_ASC) { int64_t skey = pBlock->info.window.skey; if (skey < pInfo->pFillInfo->start) { // the start key may be smaller than the - ASSERT( taosFillNotStarted(pInfo->pFillInfo)); + ASSERT(taosFillNotStarted(pInfo->pFillInfo)); taosFillUpdateStartTimestampInfo(pInfo->pFillInfo, skey); } else if (pInfo->pFillInfo->start < skey) { - int64_t t = skey; + int64_t t = skey; SInterval* pInterval = &pInfo->pFillInfo->interval; - while(1) { + while (1) { int64_t prev = taosTimeAdd(t, -pInterval->sliding, pInterval->slidingUnit, pInterval->precision); if (prev <= pInfo->pFillInfo->start) { t = prev; @@ -155,13 +180,13 @@ static void revisedFillStartKey(SFillOperatorInfo* pInfo, SSDataBlock* pBlock, i } else { int64_t ekey = pBlock->info.window.ekey; if (ekey > pInfo->pFillInfo->start) { - ASSERT( taosFillNotStarted(pInfo->pFillInfo)); + ASSERT(taosFillNotStarted(pInfo->pFillInfo)); taosFillUpdateStartTimestampInfo(pInfo->pFillInfo, ekey); } else if (ekey < pInfo->pFillInfo->start) { - int64_t t = ekey; + int64_t t = ekey; SInterval* pInterval = &pInfo->pFillInfo->interval; int64_t prev = t; - while(1) { + while (1) { int64_t next = taosTimeAdd(t, pInterval->sliding, pInterval->slidingUnit, pInterval->precision); if (next >= pInfo->pFillInfo->start) { prev = t; @@ -180,6 +205,8 @@ static void revisedFillStartKey(SFillOperatorInfo* pInfo, SSDataBlock* pBlock, i } static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SFillOperatorInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; @@ -219,11 +246,14 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) { } else { pResBlock->info.scanFlag = pBlock->info.scanFlag; pBlock->info.dataLoad = 1; - blockDataUpdateTsWindow(pBlock, pInfo->primarySrcSlotId); + code = blockDataUpdateTsWindow(pBlock, pInfo->primarySrcSlotId); + QUERY_CHECK_CODE(code, lino, _end); blockDataCleanup(pInfo->pRes); - blockDataEnsureCapacity(pInfo->pRes, pBlock->info.rows); - blockDataEnsureCapacity(pInfo->pFinalRes, pBlock->info.rows); + code = blockDataEnsureCapacity(pInfo->pRes, pBlock->info.rows); + QUERY_CHECK_CODE(code, lino, _end); + code = blockDataEnsureCapacity(pInfo->pFinalRes, pBlock->info.rows); + QUERY_CHECK_CODE(code, lino, _end); doApplyScalarCalculation(pOperator, pBlock, order, pBlock->info.scanFlag); if (pInfo->curGroupId == 0 || (pInfo->curGroupId == pInfo->pRes->info.id.groupId)) { @@ -234,7 +264,7 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) { pInfo->curGroupId = pInfo->pRes->info.id.groupId; // the first data block pInfo->totalInputRows += pInfo->pRes->info.rows; - int64_t ts = (order == TSDB_ORDER_ASC)? pBlock->info.window.ekey:pBlock->info.window.skey; + int64_t ts = (order == TSDB_ORDER_ASC) ? pBlock->info.window.ekey : pBlock->info.window.skey; taosFillSetStartInfo(pInfo->pFillInfo, pInfo->pRes->info.rows, ts); taosFillSetInputDataBlock(pInfo->pFillInfo, pInfo->pRes); } else if (pInfo->curGroupId != pBlock->info.id.groupId) { // the new group data block @@ -248,7 +278,8 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) { } int32_t numOfResultRows = pOperator->resultInfo.capacity - pResBlock->info.rows; - taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows); + code = taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows); + QUERY_CHECK_CODE(code, lino, _end); // current group has no more result to return if (pResBlock->info.rows > 0) { @@ -276,6 +307,13 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) { return NULL; } } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } + return NULL; } static SSDataBlock* doFill(SOperatorInfo* pOperator) { @@ -294,7 +332,11 @@ static SSDataBlock* doFill(SOperatorInfo* pOperator) { break; } - doFilter(fillResult, pOperator->exprSupp.pFilterInfo, &pInfo->matchInfo); + int32_t code = doFilter(fillResult, pOperator->exprSupp.pFilterInfo, &pInfo->matchInfo); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } if (fillResult->info.rows > 0) { break; } @@ -329,8 +371,8 @@ static int32_t initFillInfo(SFillOperatorInfo* pInfo, SExprInfo* pExpr, int32_t int64_t startKey = (order == TSDB_ORDER_ASC) ? win.skey : win.ekey; -// STimeWindow w = {0}; -// getInitialStartTimeWindow(pInterval, startKey, &w, order == TSDB_ORDER_ASC); + // STimeWindow w = {0}; + // getInitialStartTimeWindow(pInterval, startKey, &w, order == TSDB_ORDER_ASC); pInfo->pFillInfo = taosCreateFillInfo(startKey, numOfCols, numOfNotFillCols, capacity, pInterval, fillType, pColInfo, pInfo->primaryTsCol, order, id); @@ -409,7 +451,8 @@ SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* goto _error; } - code = initExprSupp(pNoFillSupp, pNoFillSupp->pExprInfo, pNoFillSupp->numOfExprs, &pTaskInfo->storageAPI.functionStore); + code = + initExprSupp(pNoFillSupp, pNoFillSupp->pExprInfo, pNoFillSupp->numOfExprs, &pTaskInfo->storageAPI.functionStore); if (code != TSDB_CODE_SUCCESS) { goto _error; } @@ -425,7 +468,10 @@ SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* SResultInfo* pResultInfo = &pOperator->resultInfo; initResultSizeInfo(&pOperator->resultInfo, 4096); - blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + if (code != TSDB_CODE_SUCCESS) { + goto _error; + } code = initExprSupp(&pOperator->exprSupp, pExprInfo, pInfo->numOfExpr, &pTaskInfo->storageAPI.functionStore); if (code != TSDB_CODE_SUCCESS) { goto _error; @@ -446,7 +492,10 @@ SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* } pInfo->pFinalRes = createOneDataBlock(pInfo->pRes, false); - blockDataEnsureCapacity(pInfo->pFinalRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pInfo->pFinalRes, pOperator->resultInfo.capacity); + if (code != TSDB_CODE_SUCCESS) { + goto _error; + } code = filterInitFromNode((SNode*)pPhyFillNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); if (code != TSDB_CODE_SUCCESS) { @@ -455,8 +504,8 @@ SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* setOperatorInfo(pOperator, "FillOperator", QUERY_NODE_PHYSICAL_PLAN_FILL, false, OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->exprSupp.numOfExprs = pInfo->numOfExpr; - pOperator->fpSet = - createOperatorFpSet(optrDummyOpenFn, doFill, NULL, destroyFillOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); + pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doFill, NULL, destroyFillOperatorInfo, optrDefaultBufFn, NULL, + optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); return pOperator; diff --git a/source/libs/executor/src/groupoperator.c b/source/libs/executor/src/groupoperator.c index 2382f10503..dbe844bc32 100644 --- a/source/libs/executor/src/groupoperator.c +++ b/source/libs/executor/src/groupoperator.c @@ -67,7 +67,7 @@ static void* getCurrentDataGroupInfo(const SPartitionOperatorInfo* pInfo, SDa static int32_t* setupColumnOffset(const SSDataBlock* pBlock, int32_t rowCapacity); static int32_t setGroupResultOutputBuf(SOperatorInfo* pOperator, SOptrBasicInfo* binfo, int32_t numOfCols, char* pData, int32_t bytes, uint64_t groupId, SDiskbasedBuf* pBuf, SAggSupporter* pAggSup); -static SArray* extractColumnInfo(SNodeList* pNodeList); +static int32_t extractColumnInfo(SNodeList* pNodeList, SArray** pArrayRes); static void freeGroupKey(void* param) { SGroupKeys* pKey = (SGroupKeys*)param; @@ -111,7 +111,10 @@ static int32_t initGroupOptrInfo(SArray** pGroupColVals, int32_t* keyLen, char** return TSDB_CODE_OUT_OF_MEMORY; } - taosArrayPush((*pGroupColVals), &key); + void* tmp = taosArrayPush((*pGroupColVals), &key); + if (!tmp) { + return TSDB_CODE_OUT_OF_MEMORY; + } } int32_t nullFlagSize = sizeof(int8_t) * numOfGroupCols; @@ -349,12 +352,16 @@ static void doHashGroupbyAgg(SOperatorInfo* pOperator, SSDataBlock* pBlock) { } static SSDataBlock* buildGroupResultDataBlock(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SGroupbyOperatorInfo* pInfo = pOperator->info; + SSDataBlock* pRes = pInfo->binfo.pRes; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - SSDataBlock* pRes = pInfo->binfo.pRes; while (1) { doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf); - doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); if (!hasRemainResults(&pInfo->groupResInfo)) { setOperatorCompleted(pOperator); @@ -367,6 +374,12 @@ static SSDataBlock* buildGroupResultDataBlock(SOperatorInfo* pOperator) { } pOperator->resultInfo.totalRows += pRes->info.rows; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } return (pRes->info.rows == 0) ? NULL : pRes; } @@ -412,6 +425,9 @@ void doBuildResultDatablockByHash(SOperatorInfo* pOperator, SOptrBasicInfo* pbIn } static SSDataBlock* buildGroupResultDataBlockByHash(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SGroupbyOperatorInfo* pInfo = pOperator->info; SSDataBlock* pRes = pInfo->binfo.pRes; @@ -419,7 +435,9 @@ static SSDataBlock* buildGroupResultDataBlockByHash(SOperatorInfo* pOperator) { while (1) { doBuildResultDatablockByHash(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf); - doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); + if (!hasRemainResultByHash(pOperator)) { setOperatorCompleted(pOperator); // clean hash after completed @@ -433,6 +451,12 @@ static SSDataBlock* buildGroupResultDataBlockByHash(SOperatorInfo* pOperator) { } pOperator->resultInfo.totalRows += pRes->info.rows; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } return (pRes->info.rows == 0) ? NULL : pRes; } @@ -441,6 +465,8 @@ static SSDataBlock* hashGroupbyAggregate(SOperatorInfo* pOperator) { return NULL; } + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SGroupbyOperatorInfo* pInfo = pOperator->info; @@ -462,15 +488,14 @@ static SSDataBlock* hashGroupbyAggregate(SOperatorInfo* pOperator) { pInfo->binfo.pRes->info.scanFlag = pBlock->info.scanFlag; // the pDataBlock are always the same one, no need to call this again - setInputDataBlock(&pOperator->exprSupp, pBlock, order, pBlock->info.scanFlag, true); + code = setInputDataBlock(&pOperator->exprSupp, pBlock, order, pBlock->info.scanFlag, true); + QUERY_CHECK_CODE(code, lino, _end); // there is an scalar expression that needs to be calculated right before apply the group aggregation. if (pInfo->scalarSup.pExprInfo != NULL) { - pTaskInfo->code = projectApplyFunctions(pInfo->scalarSup.pExprInfo, pBlock, pBlock, pInfo->scalarSup.pCtx, - pInfo->scalarSup.numOfExprs, NULL); - if (pTaskInfo->code != TSDB_CODE_SUCCESS) { - T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); - } + code = projectApplyFunctions(pInfo->scalarSup.pExprInfo, pBlock, pBlock, pInfo->scalarSup.pCtx, + pInfo->scalarSup.numOfExprs, NULL); + QUERY_CHECK_CODE(code, lino, _end); } doHashGroupbyAgg(pOperator, pBlock); @@ -491,11 +516,19 @@ static SSDataBlock* hashGroupbyAggregate(SOperatorInfo* pOperator) { pGroupResInfo->dataPos = NULL; pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return buildGroupResultDataBlockByHash(pOperator); } SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pAggNode, SExecTaskInfo* pTaskInfo) { int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SGroupbyOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SGroupbyOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -514,32 +547,28 @@ SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pScalarExprInfo = createExprInfo(pAggNode->pExprs, NULL, &numOfScalarExpr); } - pInfo->pGroupCols = extractColumnInfo(pAggNode->pGroupKeys); + pInfo->pGroupCols = NULL; + code = extractColumnInfo(pAggNode->pGroupKeys, &pInfo->pGroupCols); + QUERY_CHECK_CODE(code, lino, _error); + code = initExprSupp(&pInfo->scalarSup, pScalarExprInfo, numOfScalarExpr, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); initResultSizeInfo(&pOperator->resultInfo, 4096); - blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _error); code = initGroupOptrInfo(&pInfo->pGroupColVals, &pInfo->groupKeyLen, &pInfo->keyBuf, pInfo->pGroupCols); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); int32_t num = 0; SExprInfo* pExprInfo = createExprInfo(pAggNode->pAggFuncs, pAggNode->pGroupKeys, &num); code = initAggSup(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, num, pInfo->groupKeyLen, pTaskInfo->id.str, pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); code = filterInitFromNode((SNode*)pAggNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); initResultRowInfo(&pInfo->binfo.resultRowInfo); setOperatorInfo(pOperator, "GroupbyAggOperator", 0, true, OP_NOT_OPENED, pInfo, pTaskInfo); @@ -551,9 +580,7 @@ SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, hashGroupbyAggregate, NULL, destroyGroupOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); return pOperator; @@ -567,6 +594,8 @@ _error: } SSDataBlock* createBlockDataNotLoaded(const SOperatorInfo* pOperator, SSDataBlock* pDataBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pDataBlock == NULL) { return NULL; } @@ -595,27 +624,33 @@ SSDataBlock* createBlockDataNotLoaded(const SOperatorInfo* pOperator, SSDataBloc int32_t slotId = pExpr->base.pParam[0].pCol->slotId; SColumnInfoData* pSrc = taosArrayGet(pDataBlock->pDataBlock, slotId); SColumnInfoData colInfo = {.hasNull = true, .info = pSrc->info}; - blockDataAppendColInfo(pDstBlock, &colInfo); + code = blockDataAppendColInfo(pDstBlock, &colInfo); + QUERY_CHECK_CODE(code, lino, _end); SColumnInfoData* pDst = taosArrayGet(pDstBlock->pDataBlock, i); if (pDataBlock->pBlockAgg && pDataBlock->pBlockAgg[slotId].colId != -1) { pDstBlock->pBlockAgg[i] = pDataBlock->pBlockAgg[slotId]; } else { - int32_t code = doEnsureCapacity(pDst, &pDstBlock->info, pDataBlock->info.rows, false); - if (code != TSDB_CODE_SUCCESS) { - terrno = code; - blockDataDestroy(pDstBlock); - return NULL; - } + code = doEnsureCapacity(pDst, &pDstBlock->info, pDataBlock->info.rows, false); + QUERY_CHECK_CODE(code, lino, _end); - colDataAssign(pDst, pSrc, pDataBlock->info.rows, &pDataBlock->info); + code = colDataAssign(pDst, pSrc, pDataBlock->info.rows, &pDataBlock->info); + QUERY_CHECK_CODE(code, lino, _end); } } +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + blockDataDestroy(pDstBlock); + return NULL; + } return pDstBlock; } static void doHashPartition(SOperatorInfo* pOperator, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SPartitionOperatorInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; @@ -709,24 +744,37 @@ static void doHashPartition(SOperatorInfo* pOperator, SSDataBlock* pBlock) { } if (pGroupInfo->blockForNotLoaded == NULL) { pGroupInfo->blockForNotLoaded = taosArrayInit(0, sizeof(SSDataBlock*)); + QUERY_CHECK_NULL(pGroupInfo->blockForNotLoaded, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); pGroupInfo->offsetForNotLoaded = 0; } dataNotLoadBlock->info.id.groupId = pGroupInfo->groupId; dataNotLoadBlock->info.dataLoad = 0; - taosArrayPush(pGroupInfo->blockForNotLoaded, &dataNotLoadBlock); + void* tmp = taosArrayPush(pGroupInfo->blockForNotLoaded, &dataNotLoadBlock); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); break; } } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } void* getCurrentDataGroupInfo(const SPartitionOperatorInfo* pInfo, SDataGroupInfo** pGroupInfo, int32_t len) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SDataGroupInfo* p = taosHashGet(pInfo->pGroupSet, pInfo->keyBuf, len); void* pPage = NULL; if (p == NULL) { // it is a new group SDataGroupInfo gi = {0}; gi.pPageList = taosArrayInit(100, sizeof(int32_t)); - taosHashPut(pInfo->pGroupSet, pInfo->keyBuf, len, &gi, sizeof(SDataGroupInfo)); + QUERY_CHECK_NULL(gi.pPageList, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + code = taosHashPut(pInfo->pGroupSet, pInfo->keyBuf, len, &gi, sizeof(SDataGroupInfo)); + QUERY_CHECK_CODE(code, lino, _end); p = taosHashGet(pInfo->pGroupSet, pInfo->keyBuf, len); @@ -736,7 +784,9 @@ void* getCurrentDataGroupInfo(const SPartitionOperatorInfo* pInfo, SDataGroupInf return pPage; } - taosArrayPush(p->pPageList, &pageId); + void* tmp = taosArrayPush(p->pPageList, &pageId); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + *(int32_t*)pPage = 0; } else { int32_t* curId = taosArrayGetLast(p->pPageList); @@ -759,12 +809,21 @@ void* getCurrentDataGroupInfo(const SPartitionOperatorInfo* pInfo, SDataGroupInf return NULL; } - taosArrayPush(p->pPageList, &pageId); + void* tmp = taosArrayPush(p->pPageList, &pageId); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + memset(pPage, 0, getBufPageSize(pInfo->pBuf)); } } *pGroupInfo = p; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + return NULL; + } + return pPage; } @@ -832,6 +891,8 @@ static SSDataBlock* buildPartitionResultForNotLoadBlock(SDataGroupInfo* pGroupIn } static SSDataBlock* buildPartitionResult(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SPartitionOperatorInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; @@ -877,8 +938,11 @@ static SSDataBlock* buildPartitionResult(SOperatorInfo* pOperator) { return buildPartitionResult(pOperator); } - blockDataEnsureCapacity(pInfo->binfo.pRes, pInfo->rowCapacity); - blockDataFromBuf1(pInfo->binfo.pRes, page, pInfo->rowCapacity); + code = blockDataEnsureCapacity(pInfo->binfo.pRes, pInfo->rowCapacity); + QUERY_CHECK_CODE(code, lino, _end); + + code = blockDataFromBuf1(pInfo->binfo.pRes, page, pInfo->rowCapacity); + QUERY_CHECK_CODE(code, lino, _end); pInfo->pageIndex += 1; releaseBufPage(pInfo->pBuf, page); @@ -891,13 +955,21 @@ static SSDataBlock* buildPartitionResult(SOperatorInfo* pOperator) { if (pInfo->pOrderInfoArr) { pInfo->binfo.pRes->info.rows += pInfo->remainRows; - blockDataTrimFirstRows(pInfo->binfo.pRes, pInfo->orderedRows); + code = blockDataTrimFirstRows(pInfo->binfo.pRes, pInfo->orderedRows); + QUERY_CHECK_CODE(code, lino, _end); pInfo->orderedRows = blockDataGetSortedRows(pInfo->binfo.pRes, pInfo->pOrderInfoArr); pInfo->remainRows = pInfo->binfo.pRes->info.rows - pInfo->orderedRows; pInfo->binfo.pRes->info.rows = pInfo->orderedRows; } - blockDataUpdateTsWindow(pInfo->binfo.pRes, 0); + code = blockDataUpdateTsWindow(pInfo->binfo.pRes, 0); + QUERY_CHECK_CODE(code, lino, _end); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } pOperator->resultInfo.totalRows += pInfo->binfo.pRes->info.rows; return pInfo->binfo.pRes; @@ -908,8 +980,9 @@ static SSDataBlock* hashPartition(SOperatorInfo* pOperator) { return NULL; } - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SPartitionOperatorInfo* pInfo = pOperator->info; SSDataBlock* pRes = pInfo->binfo.pRes; @@ -948,7 +1021,8 @@ static SSDataBlock* hashPartition(SOperatorInfo* pOperator) { void* pGroupIter = taosHashIterate(pInfo->pGroupSet, NULL); while (pGroupIter != NULL) { SDataGroupInfo* pGroupInfo = pGroupIter; - taosArrayPush(groupArray, pGroupInfo); + void* tmp = taosArrayPush(groupArray, pGroupInfo); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); pGroupIter = taosHashIterate(pInfo->pGroupSet, pGroupIter); } @@ -960,7 +1034,15 @@ static SSDataBlock* hashPartition(SOperatorInfo* pOperator) { pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0; pOperator->status = OP_RES_TO_RETURN; - blockDataEnsureCapacity(pRes, 4096); + code = blockDataEnsureCapacity(pRes, 4096); + QUERY_CHECK_CODE(code, lino, _end); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } + return buildPartitionResult(pOperator); } @@ -1002,6 +1084,8 @@ static void destroyPartitionOperatorInfo(void* param) { SOperatorInfo* createPartitionOperatorInfo(SOperatorInfo* downstream, SPartitionPhysiNode* pPartNode, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SPartitionOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SPartitionOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -1022,7 +1106,8 @@ SOperatorInfo* createPartitionOperatorInfo(SOperatorInfo* downstream, SPartition pTaskInfo->code = terrno; goto _error; } - taosArrayPush(pInfo->pOrderInfoArr, &order); + void* tmp = taosArrayPush(pInfo->pOrderInfoArr, &order); + QUERY_CHECK_NULL(tmp, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); } if (pPartNode->pExprs != NULL) { @@ -1048,7 +1133,7 @@ SOperatorInfo* createPartitionOperatorInfo(SOperatorInfo* downstream, SPartition uint32_t defaultBufsz = 0; pInfo->binfo.pRes = createDataBlockFromDescNode(pPartNode->node.pOutputDataBlockDesc); - int32_t code = getBufferPgSize(pInfo->binfo.pRes->info.rowSize, &defaultPgsz, &defaultBufsz); + code = getBufferPgSize(pInfo->binfo.pRes->info.rowSize, &defaultPgsz, &defaultBufsz); if (code != TSDB_CODE_SUCCESS) { terrno = code; pTaskInfo->code = code; @@ -1101,6 +1186,7 @@ _error: if (pInfo != NULL) { destroyPartitionOperatorInfo(pInfo); } + pTaskInfo->code = code; taosMemoryFreeClear(pOperator); return NULL; } @@ -1156,7 +1242,8 @@ static SSDataBlock* buildStreamPartitionResult(SOperatorInfo* pOperator) { bool isNull = colDataIsNull(pSrcCol, pSrc->info.rows, rowIndex, NULL); char* pSrcData = NULL; if (!isNull) pSrcData = colDataGetData(pSrcCol, rowIndex); - colDataSetVal(pDestCol, pDest->info.rows, pSrcData, isNull); + code = colDataSetVal(pDestCol, pDest->info.rows, pSrcData, isNull); + QUERY_CHECK_CODE(code, lino, _end); } pDest->info.rows++; } @@ -1177,7 +1264,9 @@ static SSDataBlock* buildStreamPartitionResult(SOperatorInfo* pOperator) { pParInfo->rowIds = NULL; pDest->info.dataLoad = 1; - blockDataUpdateTsWindow(pDest, pInfo->tsColIndex); + code = blockDataUpdateTsWindow(pDest, pInfo->tsColIndex); + QUERY_CHECK_CODE(code, lino, _end); + pDest->info.id.groupId = pParInfo->groupId; pOperator->resultInfo.totalRows += pDest->info.rows; pInfo->parIte = taosHashIterate(pInfo->pPartitions, pInfo->parIte); @@ -1288,6 +1377,8 @@ _end: } static void doStreamHashPartitionImpl(SStreamPartitionOperatorInfo* pInfo, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; pInfo->pInputDataBlock = pBlock; for (int32_t i = 0; i < pBlock->info.rows; ++i) { recordNewGroupKeys(pInfo->partitionSup.pGroupCols, pInfo->partitionSup.pGroupColVals, pBlock, i); @@ -1295,15 +1386,25 @@ static void doStreamHashPartitionImpl(SStreamPartitionOperatorInfo* pInfo, SSDat SPartitionDataInfo* pParData = (SPartitionDataInfo*)taosHashGet(pInfo->pPartitions, pInfo->partitionSup.keyBuf, keyLen); if (pParData) { - taosArrayPush(pParData->rowIds, &i); + void* tmp = taosArrayPush(pParData->rowIds, &i); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } else { SPartitionDataInfo newParData = {0}; newParData.groupId = calcGroupId(pInfo->partitionSup.keyBuf, keyLen); newParData.rowIds = taosArrayInit(64, sizeof(int32_t)); - taosArrayPush(newParData.rowIds, &i); - taosHashPut(pInfo->pPartitions, pInfo->partitionSup.keyBuf, keyLen, &newParData, sizeof(SPartitionDataInfo)); + void* tmp = taosArrayPush(newParData.rowIds, &i); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + code = + taosHashPut(pInfo->pPartitions, pInfo->partitionSup.keyBuf, keyLen, &newParData, sizeof(SPartitionDataInfo)); + QUERY_CHECK_CODE(code, lino, _end); } } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } } static SSDataBlock* doStreamHashPartition(SOperatorInfo* pOperator) { @@ -1345,7 +1446,9 @@ static SSDataBlock* doStreamHashPartition(SOperatorInfo* pOperator) { pInfo->binfo.pRes->info.type = pBlock->info.type; break; case STREAM_DELETE_DATA: { - copyDataBlock(pInfo->pDelRes, pBlock); + code = copyDataBlock(pInfo->pDelRes, pBlock); + QUERY_CHECK_CODE(code, lino, _end); + pInfo->pDelRes->info.type = STREAM_DELETE_RESULT; printDataBlock(pInfo->pDelRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo)); return pInfo->pDelRes; @@ -1362,8 +1465,9 @@ static SSDataBlock* doStreamHashPartition(SOperatorInfo* pOperator) { // there is an scalar expression that needs to be calculated right before apply the group aggregation. if (pInfo->scalarSup.pExprInfo != NULL) { - projectApplyFunctions(pInfo->scalarSup.pExprInfo, pBlock, pBlock, pInfo->scalarSup.pCtx, - pInfo->scalarSup.numOfExprs, NULL); + code = projectApplyFunctions(pInfo->scalarSup.pExprInfo, pBlock, pBlock, pInfo->scalarSup.pCtx, + pInfo->scalarSup.numOfExprs, NULL); + QUERY_CHECK_CODE(code, lino, _end); } taosHashClear(pInfo->pPartitions); doStreamHashPartitionImpl(pInfo, pBlock); @@ -1429,6 +1533,8 @@ int32_t initParDownStream(SOperatorInfo* downstream, SPartitionBySupporter* pPar } SSDataBlock* buildCreateTableBlock(SExprSupp* tbName, SExprSupp* tag) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SSDataBlock* pBlock = taosMemoryCalloc(1, sizeof(SSDataBlock)); pBlock->info.hasVarCol = false; pBlock->info.id.groupId = 0; @@ -1446,14 +1552,16 @@ SSDataBlock* buildCreateTableBlock(SExprSupp* tbName, SExprSupp* tag) { } pBlock->info.rowSize += infoData.info.bytes; // sub table name - taosArrayPush(pBlock->pDataBlock, &infoData); + void* tmp = taosArrayPush(pBlock->pDataBlock, &infoData); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); SColumnInfoData gpIdData = {0}; gpIdData.info.type = TSDB_DATA_TYPE_UBIGINT; gpIdData.info.bytes = 8; pBlock->info.rowSize += gpIdData.info.bytes; // group id - taosArrayPush(pBlock->pDataBlock, &gpIdData); + tmp = taosArrayPush(pBlock->pDataBlock, &gpIdData); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); for (int32_t i = 0; i < tag->numOfExprs; i++) { SColumnInfoData tagCol = {0}; @@ -1461,10 +1569,17 @@ SSDataBlock* buildCreateTableBlock(SExprSupp* tbName, SExprSupp* tag) { tagCol.info.bytes = tag->pExprInfo[i].base.resSchema.bytes; tagCol.info.precision = tag->pExprInfo[i].base.resSchema.precision; // tag info - taosArrayPush(pBlock->pDataBlock, &tagCol); + tmp = taosArrayPush(pBlock->pDataBlock, &tagCol); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); pBlock->info.rowSize += tagCol.info.bytes; } +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + blockDataDestroy(pBlock); + return NULL; + } return pBlock; } @@ -1490,42 +1605,33 @@ SOperatorInfo* createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStr int32_t num = 0; SExprInfo* pCalExprInfo = createExprInfo(pPartNode->part.pExprs, NULL, &num); code = initExprSupp(&pInfo->scalarSup, pCalExprInfo, num, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); } pInfo->tbnameCalSup.numOfExprs = 0; if (pPartNode->pSubtable != NULL) { SExprInfo* pSubTableExpr = taosMemoryCalloc(1, sizeof(SExprInfo)); - if (pSubTableExpr == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _error; - } + QUERY_CHECK_NULL(pSubTableExpr, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + pInfo->tbnameCalSup.pExprInfo = pSubTableExpr; createExprFromOneNode(pSubTableExpr, pPartNode->pSubtable, 0); code = initExprSupp(&pInfo->tbnameCalSup, pSubTableExpr, 1, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); } pInfo->tagCalSup.numOfExprs = 0; if (pPartNode->pTags != NULL) { int32_t numOfTags; SExprInfo* pTagExpr = createExpr(pPartNode->pTags, &numOfTags); - if (pTagExpr == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _error; - } - if (initExprSupp(&pInfo->tagCalSup, pTagExpr, numOfTags, &pTaskInfo->storageAPI.functionStore) != 0) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _error; - } + QUERY_CHECK_NULL(pTagExpr, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + + code = initExprSupp(&pInfo->tagCalSup, pTagExpr, numOfTags, &pTaskInfo->storageAPI.functionStore); + QUERY_CHECK_CODE(code, lino, _error); } if (pInfo->tbnameCalSup.numOfExprs != 0 || pInfo->tagCalSup.numOfExprs != 0) { pInfo->pCreateTbRes = buildCreateTableBlock(&pInfo->tbnameCalSup, &pInfo->tagCalSup); + QUERY_CHECK_NULL(pInfo->pCreateTbRes, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); } else { pInfo->pCreateTbRes = NULL; } @@ -1533,18 +1639,15 @@ SOperatorInfo* createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStr int32_t keyLen = 0; code = initGroupOptrInfo(&pInfo->partitionSup.pGroupColVals, &keyLen, &pInfo->partitionSup.keyBuf, pInfo->partitionSup.pGroupCols); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); + pInfo->partitionSup.needCalc = true; pInfo->binfo.pRes = createDataBlockFromDescNode(pPartNode->part.node.pOutputDataBlockDesc); - if (pInfo->binfo.pRes == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _error; - } + QUERY_CHECK_NULL(pInfo->binfo.pRes, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); - blockDataEnsureCapacity(pInfo->binfo.pRes, 4096); + code = blockDataEnsureCapacity(pInfo->binfo.pRes, 4096); + QUERY_CHECK_CODE(code, lino, _error); pInfo->parIte = NULL; pInfo->pTbNameIte = NULL; @@ -1555,6 +1658,7 @@ SOperatorInfo* createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStr taosHashSetFreeFp(pInfo->pPartitions, freePartItem); pInfo->tsColIndex = 0; pInfo->pDelRes = createSpecialDataBlock(STREAM_DELETE_RESULT); + QUERY_CHECK_NULL(pInfo->pDelRes, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); int32_t numOfCols = 0; SExprInfo* pExprInfo = createExprInfo(pPartNode->part.pTargets, NULL, &numOfCols); @@ -1584,12 +1688,15 @@ _error: return NULL; } -SArray* extractColumnInfo(SNodeList* pNodeList) { +int32_t extractColumnInfo(SNodeList* pNodeList, SArray** pArrayRes) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; size_t numOfCols = LIST_LENGTH(pNodeList); SArray* pList = taosArrayInit(numOfCols, sizeof(SColumn)); if (pList == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return NULL; + code = TSDB_CODE_OUT_OF_MEMORY; + (*pArrayRes) = NULL; + QUERY_CHECK_CODE(code, lino, _end); } for (int32_t i = 0; i < numOfCols; ++i) { @@ -1599,7 +1706,8 @@ SArray* extractColumnInfo(SNodeList* pNodeList) { SColumnNode* pColNode = (SColumnNode*)pNode->pExpr; SColumn c = extractColumnFromColumnNode(pColNode); - taosArrayPush(pList, &c); + void* tmp = taosArrayPush(pList, &c); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } else if (nodeType(pNode->pExpr) == QUERY_NODE_VALUE) { SValueNode* pValNode = (SValueNode*)pNode->pExpr; SColumn c = {0}; @@ -1610,9 +1718,16 @@ SArray* extractColumnInfo(SNodeList* pNodeList) { c.scale = pValNode->node.resType.scale; c.precision = pValNode->node.resType.precision; - taosArrayPush(pList, &c); + void* tmp = taosArrayPush(pList, &c); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } } - return pList; + (*pArrayRes) = pList; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index 207c81fcb9..520cba92a1 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -1131,9 +1131,8 @@ static SSDataBlock* groupSeqTableScan(SOperatorInfo* pOperator) { ASSERT(pInfo->base.dataReader == NULL); - code = pAPI->tsdReader.tsdReaderOpen(pInfo->base.readHandle.vnode, &pInfo->base.cond, pList, num, pInfo->pResBlock, + pAPI->tsdReader.tsdReaderOpen(pInfo->base.readHandle.vnode, &pInfo->base.cond, pList, num, pInfo->pResBlock, (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), &pInfo->pIgnoreTables); - QUERY_CHECK_CODE(code, lino, _end); if (pInfo->filesetDelimited) { pAPI->tsdReader.tsdSetFilesetDelimited(pInfo->base.dataReader); } @@ -3782,6 +3781,8 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys pInfo->readHandle = *pHandle; pTaskInfo->streamInfo.snapshotVer = pHandle->version; pInfo->pCreateTbRes = buildCreateTableBlock(&pInfo->tbnameCalSup, &pInfo->tagCalSup); + QUERY_CHECK_NULL(pInfo->pCreateTbRes, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + code = blockDataEnsureCapacity(pInfo->pCreateTbRes, 8); QUERY_CHECK_CODE(code, lino, _error); diff --git a/source/libs/executor/src/streamcountwindowoperator.c b/source/libs/executor/src/streamcountwindowoperator.c index 3471f02bf5..dd05581ff0 100644 --- a/source/libs/executor/src/streamcountwindowoperator.c +++ b/source/libs/executor/src/streamcountwindowoperator.c @@ -683,7 +683,8 @@ static SSDataBlock* doStreamCountAgg(SOperatorInfo* pOperator) { QUERY_CHECK_CODE(code, lino, _end); } // the pDataBlock are always the same one, no need to call this again - setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + code = setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); doStreamCountAggImpl(pOperator, pBlock, pInfo->pStUpdated, pInfo->pStDeleted); pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey); pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.watermark); @@ -821,7 +822,8 @@ SOperatorInfo* createStreamCountAggOperatorInfo(SOperatorInfo* downstream, SPhys pInfo->streamAggSup.windowCount = pCountNode->windowCount; pInfo->streamAggSup.windowSliding = pCountNode->windowSliding; - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + QUERY_CHECK_CODE(code, lino, _error); pInfo->binfo.pRes = pResBlock; _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY); diff --git a/source/libs/executor/src/streameventwindowoperator.c b/source/libs/executor/src/streameventwindowoperator.c index 807cf5a4ba..2cd36a7fb7 100644 --- a/source/libs/executor/src/streameventwindowoperator.c +++ b/source/libs/executor/src/streameventwindowoperator.c @@ -650,7 +650,8 @@ static SSDataBlock* doStreamEventAgg(SOperatorInfo* pOperator) { QUERY_CHECK_CODE(code, lino, _end); } // the pDataBlock are always the same one, no need to call this again - setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + code = setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); doStreamEventAggImpl(pOperator, pBlock, pInfo->pSeUpdated, pInfo->pSeDeleted); pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey); } @@ -846,24 +847,21 @@ SOperatorInfo* createStreamEventAggOperatorInfo(SOperatorInfo* downstream, SPhys .deleteMark = getDeleteMark(&pEventNode->window, 0), }; - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + QUERY_CHECK_CODE(code, lino, _error); SExprSupp* pExpSup = &pOperator->exprSupp; int32_t numOfCols = 0; SExprInfo* pExprInfo = createExprInfo(pEventNode->window.pFuncs, NULL, &numOfCols); SSDataBlock* pResBlock = createDataBlockFromDescNode(pPhyNode->pOutputDataBlockDesc); code = initBasicInfoEx(&pInfo->binfo, pExpSup, pExprInfo, numOfCols, pResBlock, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); pInfo->primaryTsIndex = tsSlotId; code = initStreamAggSupporter(&pInfo->streamAggSup, pExpSup, numOfCols, 0, pTaskInfo->streamInfo.pState, sizeof(bool) + sizeof(bool), 0, &pTaskInfo->storageAPI.stateStore, pHandle, &pInfo->twAggSup, GET_TASKID(pTaskInfo), &pTaskInfo->storageAPI, pInfo->primaryTsIndex); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY); pInfo->pSeDeleted = tSimpleHashInit(64, hashFn); @@ -885,14 +883,18 @@ SOperatorInfo* createStreamEventAggOperatorInfo(SOperatorInfo* downstream, SPhys if (pInfo->isHistoryOp) { pInfo->pAllUpdated = tSimpleHashInit(64, hashFn); + QUERY_CHECK_NULL(pInfo->pAllUpdated, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); } else { pInfo->pAllUpdated = NULL; } pInfo->pCheckpointRes = createSpecialDataBlock(STREAM_CHECKPOINT); + QUERY_CHECK_NULL(pInfo->pCheckpointRes, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + pInfo->reCkBlock = false; pInfo->recvGetAll = false; pInfo->pPkDeleted = tSimpleHashInit(64, hashFn); + QUERY_CHECK_NULL(pInfo->pPkDeleted, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); pInfo->destHasPrimaryKey = pEventNode->window.destHasPrimayKey; setOperatorInfo(pOperator, "StreamEventAggOperator", QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT, true, OP_NOT_OPENED, diff --git a/source/libs/executor/src/streamfilloperator.c b/source/libs/executor/src/streamfilloperator.c index a9cc270f7a..bd254c5e5a 100644 --- a/source/libs/executor/src/streamfilloperator.c +++ b/source/libs/executor/src/streamfilloperator.c @@ -990,13 +990,15 @@ static int32_t doApplyStreamScalarCalculation(SOperatorInfo* pOperator, SSDataBl code = blockDataEnsureCapacity(pDstBlock, pSrcBlock->info.rows); QUERY_CHECK_CODE(code, lino, _end); - setInputDataBlock(pSup, pSrcBlock, TSDB_ORDER_ASC, MAIN_SCAN, false); + code = setInputDataBlock(pSup, pSrcBlock, TSDB_ORDER_ASC, MAIN_SCAN, false); + QUERY_CHECK_CODE(code, lino, _end); code = projectApplyFunctions(pSup->pExprInfo, pDstBlock, pSrcBlock, pSup->pCtx, pSup->numOfExprs, NULL); QUERY_CHECK_CODE(code, lino, _end); pDstBlock->info.rows = 0; pSup = &pInfo->pFillSup->notFillExprSup; - setInputDataBlock(pSup, pSrcBlock, TSDB_ORDER_ASC, MAIN_SCAN, false); + code = setInputDataBlock(pSup, pSrcBlock, TSDB_ORDER_ASC, MAIN_SCAN, false); + QUERY_CHECK_CODE(code, lino, _end); code = projectApplyFunctions(pSup->pExprInfo, pDstBlock, pSrcBlock, pSup->pCtx, pSup->numOfExprs, NULL); QUERY_CHECK_CODE(code, lino, _end); diff --git a/source/libs/executor/src/streamtimewindowoperator.c b/source/libs/executor/src/streamtimewindowoperator.c index b2af12aab9..1135757950 100644 --- a/source/libs/executor/src/streamtimewindowoperator.c +++ b/source/libs/executor/src/streamtimewindowoperator.c @@ -1667,7 +1667,9 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) { code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); QUERY_CHECK_CODE(code, lino, _end); } - setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + code = setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); + doStreamIntervalAggImpl(pOperator, pBlock, pBlock->info.id.groupId, pInfo->pUpdatedMap, pInfo->pDeletedMap); pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey); pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.watermark); @@ -1859,7 +1861,8 @@ SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, pInfo->pState, &pTaskInfo->storageAPI.functionStore); QUERY_CHECK_CODE(code, lino, _error); - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + QUERY_CHECK_CODE(code, lino, _error); initResultRowInfo(&pInfo->binfo.resultRowInfo); pInfo->numOfChild = numOfChild; @@ -3331,7 +3334,9 @@ static SSDataBlock* doStreamSessionAgg(SOperatorInfo* pOperator) { QUERY_CHECK_CODE(code, lino, _end); } // the pDataBlock are always the same one, no need to call this again - setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + code = setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); + doStreamSessionAggImpl(pOperator, pBlock, pInfo->pStUpdated, pInfo->pStDeleted, IS_FINAL_SESSION_OP(pOperator), true); if (IS_FINAL_SESSION_OP(pOperator)) { @@ -3353,7 +3358,8 @@ static SSDataBlock* doStreamSessionAgg(SOperatorInfo* pOperator) { } } SOperatorInfo* pChildOp = taosArrayGetP(pInfo->pChildren, chIndex); - setInputDataBlock(&pChildOp->exprSupp, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + code = setInputDataBlock(&pChildOp->exprSupp, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); doStreamSessionAggImpl(pChildOp, pBlock, NULL, NULL, true, false); } pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey); @@ -3625,7 +3631,8 @@ SOperatorInfo* createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPh goto _error; } - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + QUERY_CHECK_CODE(code, lino, _error); if (pSessionNode->window.pTsEnd) { pInfo->endTsIndex = ((SColumnNode*)pSessionNode->window.pTsEnd)->slotId; @@ -3818,7 +3825,8 @@ static SSDataBlock* doStreamSessionSemiAgg(SOperatorInfo* pOperator) { QUERY_CHECK_CODE(code, lino, _end); } // the pDataBlock are always the same one, no need to call this again - setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + code = setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); doStreamSessionAggImpl(pOperator, pBlock, pInfo->pStUpdated, NULL, false, false); maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey); } @@ -4501,7 +4509,8 @@ static SSDataBlock* doStreamStateAgg(SOperatorInfo* pOperator) { QUERY_CHECK_CODE(code, lino, _end); } // the pDataBlock are always the same one, no need to call this again - setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + code = setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); doStreamStateAggImpl(pOperator, pBlock, pInfo->pSeUpdated, pInfo->pSeDeleted); pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey); } @@ -4688,7 +4697,8 @@ SOperatorInfo* createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhys .deleteMark = getDeleteMark(&pStateNode->window, 0), }; - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + QUERY_CHECK_CODE(code, lino, _error); SExprSupp* pExpSup = &pOperator->exprSupp; int32_t numOfCols = 0; @@ -4874,7 +4884,8 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) { // The timewindow that overlaps the timestamps of the input pBlock need to be recalculated and return to the // caller. Note that all the time window are not close till now. // the pDataBlock are always the same one, no need to call this again - setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + code = (pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); #ifdef BUILD_NO_CALL if (pInfo->invertible) { setInverFunction(pSup->pCtx, pOperator->exprSupp.numOfExprs, pBlock->info.type); @@ -4970,7 +4981,8 @@ SOperatorInfo* createStreamIntervalOperatorInfo(SOperatorInfo* downstream, SPhys pSup->hasWindowOrGroup = true; initBasicInfo(&pInfo->binfo, pResBlock); - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + QUERY_CHECK_CODE(code, lino, _error); pInfo->primaryTsIndex = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->slotId; initResultSizeInfo(&pOperator->resultInfo, 4096); @@ -5359,7 +5371,8 @@ static SSDataBlock* doStreamMidIntervalAgg(SOperatorInfo* pOperator) { code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); QUERY_CHECK_CODE(code, lino, _end); } - setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + code = setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); doStreamMidIntervalAggImpl(pOperator, pBlock, pInfo->pUpdatedMap); pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey); pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.watermark); diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c index 41d398888e..fb3176a2a8 100644 --- a/source/libs/executor/src/timewindowoperator.c +++ b/source/libs/executor/src/timewindowoperator.c @@ -30,7 +30,7 @@ typedef struct SSessionAggOperatorInfo { SOptrBasicInfo binfo; SAggSupporter aggSup; - SExprSupp scalarSupp; // supporter for perform scalar function + SExprSupp scalarSupp; // supporter for perform scalar function SGroupResInfo groupResInfo; SWindowRowsSup winSup; bool reptScan; // next round scan @@ -518,8 +518,8 @@ static void doWindowBorderInterpolation(SIntervalAggOperatorInfo* pInfo, SSDataB // duplicated ts row does not involve in the interpolation of end value for current time window int32_t x = endRowIndex; - while(x > 0) { - if (tsCols[x] == tsCols[x-1]) { + while (x > 0) { + if (tsCols[x] == tsCols[x - 1]) { x -= 1; } else { endRowIndex = x; @@ -528,7 +528,8 @@ static void doWindowBorderInterpolation(SIntervalAggOperatorInfo* pInfo, SSDataB } TSKEY endKey = (pInfo->binfo.inputTsOrder == TSDB_ORDER_ASC) ? pBlock->info.window.ekey : pBlock->info.window.skey; - bool interp = setTimeWindowInterpolationEndTs(pInfo, pSup, endRowIndex, nextRowIndex, pBlock->pDataBlock, tsCols, endKey, win); + bool interp = setTimeWindowInterpolationEndTs(pInfo, pSup, endRowIndex, nextRowIndex, pBlock->pDataBlock, tsCols, + endKey, win); if (interp) { setResultRowInterpo(pResult, RESULT_ROW_END_INTERP); } @@ -1203,6 +1204,8 @@ static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SInt SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SIntervalAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SIntervalAggOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -1223,8 +1226,8 @@ SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPh int32_t num = 0; SExprInfo* pExprInfo = createExprInfo(pPhyNode->window.pFuncs, NULL, &num); - int32_t code = initAggSup(pSup, &pInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str, - pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); + code = initAggSup(pSup, &pInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str, pTaskInfo->streamInfo.pState, + &pTaskInfo->storageAPI.functionStore); if (code != TSDB_CODE_SUCCESS) { goto _error; } @@ -1274,7 +1277,8 @@ SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPh goto _error; } - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pInfo->win); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pInfo->win); + QUERY_CHECK_CODE(code, lino, _error); pInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, pInfo); if (pInfo->timeWindowInterpo) { pInfo->binfo.resultRowInfo.openWindow = tdListNew(sizeof(SOpenWindowInfo)); @@ -1421,7 +1425,7 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) { if (pInfo->scalarSupp.pExprInfo != NULL) { SExprSupp* pExprSup = &pInfo->scalarSupp; projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); - } + } // the pDataBlock are always the same one, no need to call this again setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true); blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId); @@ -1457,6 +1461,8 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) { // todo make this as an non-blocking operator SOperatorInfo* createStatewindowOperatorInfo(SOperatorInfo* downstream, SStateWinodwPhysiNode* pStateNode, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SStateWindowOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStateWindowOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -1487,7 +1493,7 @@ SOperatorInfo* createStatewindowOperatorInfo(SOperatorInfo* downstream, SStateWi pInfo->binfo.inputTsOrder = pStateNode->window.node.inputTsOrder; pInfo->binfo.outputTsOrder = pStateNode->window.node.outputTsOrder; - int32_t code = filterInitFromNode((SNode*)pStateNode->window.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); + code = filterInitFromNode((SNode*)pStateNode->window.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); if (code != TSDB_CODE_SUCCESS) { goto _error; } @@ -1511,7 +1517,8 @@ SOperatorInfo* createStatewindowOperatorInfo(SOperatorInfo* downstream, SStateWi pInfo->twAggSup = (STimeWindowAggSupp){.waterMark = pStateNode->window.watermark, .calTrigger = pStateNode->window.triggerType}; - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + QUERY_CHECK_CODE(code, lino, _error); pInfo->tsSlotId = tsSlotId; @@ -1548,13 +1555,15 @@ void destroySWindowOperatorInfo(void* param) { cleanupAggSup(&pInfo->aggSup); cleanupExprSupp(&pInfo->scalarSupp); - + cleanupGroupResInfo(&pInfo->groupResInfo); taosMemoryFreeClear(param); } SOperatorInfo* createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionWinodwPhysiNode* pSessionNode, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SSessionAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SSessionAggOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -1571,7 +1580,7 @@ SOperatorInfo* createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionW SSDataBlock* pResBlock = createDataBlockFromDescNode(pSessionNode->window.node.pOutputDataBlockDesc); initBasicInfo(&pInfo->binfo, pResBlock); - int32_t code = initAggSup(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, numOfCols, keyBufSize, pTaskInfo->id.str, + code = initAggSup(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, numOfCols, keyBufSize, pTaskInfo->id.str, pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); if (code != TSDB_CODE_SUCCESS) { goto _error; @@ -1582,7 +1591,8 @@ SOperatorInfo* createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionW pInfo->gap = pSessionNode->gap; initResultRowInfo(&pInfo->binfo.resultRowInfo); - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + QUERY_CHECK_CODE(code, lino, _error); pInfo->tsSlotId = ((SColumnNode*)pSessionNode->window.pTspk)->slotId; pInfo->binfo.pRes = pResBlock; @@ -1830,6 +1840,8 @@ static SSDataBlock* mergeAlignedIntervalAgg(SOperatorInfo* pOperator) { SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SMergeAlignedIntervalPhysiNode* pNode, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SMergeAlignedIntervalAggOperatorInfo* miaInfo = taosMemoryCalloc(1, sizeof(SMergeAlignedIntervalAggOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (miaInfo == NULL || pOperator == NULL) { @@ -1852,7 +1864,7 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SExprSupp* pSup = &pOperator->exprSupp; pSup->hasWindowOrGroup = true; - int32_t code = filterInitFromNode((SNode*)pNode->window.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); + code = filterInitFromNode((SNode*)pNode->window.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); if (code != TSDB_CODE_SUCCESS) { goto _error; } @@ -1879,7 +1891,8 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SSDataBlock* pResBlock = createDataBlockFromDescNode(pNode->window.node.pOutputDataBlockDesc); initBasicInfo(&iaInfo->binfo, pResBlock); - initExecTimeWindowInfo(&iaInfo->twAggSup.timeWindowData, &iaInfo->win); + code = initExecTimeWindowInfo(&iaInfo->twAggSup.timeWindowData, &iaInfo->win); + QUERY_CHECK_CODE(code, lino, _error); iaInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, iaInfo); if (iaInfo->timeWindowInterpo) { @@ -2126,6 +2139,8 @@ static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) { SOperatorInfo* createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SMergeIntervalPhysiNode* pIntervalPhyNode, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SMergeIntervalAggOperatorInfo* pMergeIntervalInfo = taosMemoryCalloc(1, sizeof(SMergeIntervalAggOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pMergeIntervalInfo == NULL || pOperator == NULL) { @@ -2158,15 +2173,16 @@ SOperatorInfo* createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SMerge size_t keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES; initResultSizeInfo(&pOperator->resultInfo, 4096); - int32_t code = initAggSup(pExprSupp, &pIntervalInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str, - pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); + code = initAggSup(pExprSupp, &pIntervalInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str, + pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); if (code != TSDB_CODE_SUCCESS) { goto _error; } SSDataBlock* pResBlock = createDataBlockFromDescNode(pIntervalPhyNode->window.node.pOutputDataBlockDesc); initBasicInfo(&pIntervalInfo->binfo, pResBlock); - initExecTimeWindowInfo(&pIntervalInfo->twAggSup.timeWindowData, &pIntervalInfo->win); + code = initExecTimeWindowInfo(&pIntervalInfo->twAggSup.timeWindowData, &pIntervalInfo->win); + QUERY_CHECK_CODE(code, lino, _error); pIntervalInfo->timeWindowInterpo = timeWindowinterpNeeded(pExprSupp->pCtx, num, pIntervalInfo); if (pIntervalInfo->timeWindowInterpo) {