diff --git a/source/common/src/tdatablock.c b/source/common/src/tdatablock.c index cfcf383954..08efd9cc08 100644 --- a/source/common/src/tdatablock.c +++ b/source/common/src/tdatablock.c @@ -456,7 +456,7 @@ int32_t colDataMergeCol(SColumnInfoData* pColumnInfoData, int32_t numOfRow1, int int32_t colDataAssign(SColumnInfoData* pColumnInfoData, const SColumnInfoData* pSource, int32_t numOfRows, const SDataBlockInfo* pBlockInfo) { if (pColumnInfoData->info.type != pSource->info.type || (pBlockInfo != NULL && pBlockInfo->capacity < numOfRows)) { - return TSDB_CODE_FAILED; + return TSDB_CODE_INVALID_PARA; } if (numOfRows <= 0) { diff --git a/source/libs/executor/inc/executorInt.h b/source/libs/executor/inc/executorInt.h index 0d2692267b..03dd0c4581 100644 --- a/source/libs/executor/inc/executorInt.h +++ b/source/libs/executor/inc/executorInt.h @@ -861,7 +861,7 @@ int32_t doFilter(SSDataBlock* pBlock, SFilterInfo* pFilterInfo, SColMatchInfo* p int32_t addTagPseudoColumnData(SReadHandle* pHandle, const SExprInfo* pExpr, int32_t numOfExpr, SSDataBlock* pBlock, int32_t rows, SExecTaskInfo* pTask, STableMetaCacheInfo* pCache); -void appendOneRowToDataBlock(SSDataBlock* pBlock, STupleHandle* pTupleHandle); +int32_t appendOneRowToDataBlock(SSDataBlock* pBlock, STupleHandle* pTupleHandle); int32_t setTbNameColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId, const char* name); int32_t setVgIdColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId, int32_t vgId); @@ -922,7 +922,6 @@ void copyResultrowToDataBlock(SExprInfo* pExprInfo, int32_t numOfExprs, SResultR void doUpdateNumOfRows(SqlFunctionCtx* pCtx, SResultRow* pRow, int32_t numOfExprs, const int32_t* rowEntryOffset); void doClearBufferedBlocks(SStreamScanInfo* pInfo); -uint64_t calcGroupId(char* pData, int32_t len); void streamOpReleaseState(struct SOperatorInfo* pOperator); void streamOpReloadState(struct SOperatorInfo* pOperator); void destroyStreamAggSupporter(SStreamAggSupporter* pSup); @@ -979,13 +978,14 @@ void* decodeSResultWindowInfo(void* buf, SResultWindowInfo* key, int32_t outLe int32_t encodeSTimeWindowAggSupp(void** buf, STimeWindowAggSupp* pTwAggSup); void* decodeSTimeWindowAggSupp(void* buf, STimeWindowAggSupp* pTwAggSup); -void destroyOperatorParamValue(void* pValues); -int32_t mergeOperatorParams(SOperatorParam* pDst, SOperatorParam* pSrc); -int32_t buildTableScanOperatorParam(SOperatorParam** ppRes, SArray* pUidList, int32_t srcOpType, bool tableSeq); -void freeExchangeGetBasicOperatorParam(void* pParam); -void freeOperatorParam(SOperatorParam* pParam, SOperatorParamType type); -void freeResetOperatorParams(struct SOperatorInfo* pOperator, SOperatorParamType type, bool allFree); -SSDataBlock* getNextBlockFromDownstreamImpl(struct SOperatorInfo* pOperator, int32_t idx, bool clearParam); +void destroyOperatorParamValue(void* pValues); +int32_t mergeOperatorParams(SOperatorParam* pDst, SOperatorParam* pSrc); +int32_t buildTableScanOperatorParam(SOperatorParam** ppRes, SArray* pUidList, int32_t srcOpType, bool tableSeq); +void freeExchangeGetBasicOperatorParam(void* pParam); +void freeOperatorParam(SOperatorParam* pParam, SOperatorParamType type); +void freeResetOperatorParams(struct SOperatorInfo* pOperator, SOperatorParamType type, bool allFree); +int32_t getNextBlockFromDownstreamImpl(struct SOperatorInfo* pOperator, int32_t idx, bool clearParam, + SSDataBlock** pResBlock); void getCountWinRange(SStreamAggSupporter* pAggSup, const SSessionKey* pKey, EStreamType mode, SSessionKey* pDelRange); void doDeleteSessionWindow(SStreamAggSupporter* pAggSup, SSessionKey* pKey); diff --git a/source/libs/executor/inc/operator.h b/source/libs/executor/inc/operator.h index 37cdd5d7b3..c047c496ca 100644 --- a/source/libs/executor/inc/operator.h +++ b/source/libs/executor/inc/operator.h @@ -20,6 +20,15 @@ extern "C" { #endif +#define QRY_OPTR_CHECK(_o) \ + do { \ + if ((_o) == NULL) { \ + return TSDB_CODE_INVALID_PARA; \ + } else { \ + *(_o) = NULL; \ + } \ + } while(0) + typedef struct SOperatorCostInfo { double openCost; double totalCost; @@ -27,15 +36,15 @@ typedef struct SOperatorCostInfo { struct SOperatorInfo; -typedef int32_t (*__optr_encode_fn_t)(struct SOperatorInfo* pOperator, char** result, int32_t* length); -typedef int32_t (*__optr_decode_fn_t)(struct SOperatorInfo* pOperator, char* result); +//typedef int32_t (*__optr_encode_fn_t)(struct SOperatorInfo* pOperator, char** result, int32_t* length); +//typedef int32_t (*__optr_decode_fn_t)(struct SOperatorInfo* pOperator, char* result); typedef int32_t (*__optr_open_fn_t)(struct SOperatorInfo* pOptr); typedef SSDataBlock* (*__optr_fn_t)(struct SOperatorInfo* pOptr); typedef void (*__optr_close_fn_t)(void* param); typedef int32_t (*__optr_explain_fn_t)(struct SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len); typedef int32_t (*__optr_reqBuf_fn_t)(struct SOperatorInfo* pOptr); -typedef SSDataBlock* (*__optr_get_ext_fn_t)(struct SOperatorInfo* pOptr, SOperatorParam* param); +typedef int32_t (*__optr_get_ext_fn_t)(struct SOperatorInfo* pOptr, SOperatorParam* param, SSDataBlock** pRes); typedef int32_t (*__optr_notify_fn_t)(struct SOperatorInfo* pOptr, SOperatorParam* param); typedef void (*__optr_state_fn_t)(struct SOperatorInfo* pOptr); @@ -45,8 +54,6 @@ typedef struct SOperatorFpSet { __optr_fn_t cleanupFn; // call this function to release the allocated resources ASAP __optr_close_fn_t closeFn; __optr_reqBuf_fn_t reqBufFn; // total used buffer for blocking operator - __optr_encode_fn_t encodeResultRow; - __optr_decode_fn_t decodeResultRow; __optr_explain_fn_t getExplainFn; __optr_get_ext_fn_t getNextExtFn; __optr_notify_fn_t notifyFn; @@ -86,85 +93,85 @@ typedef struct SOperatorInfo { // operator creater functions // clang-format off -SOperatorInfo* createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode* pExNode, SExecTaskInfo* pTaskInfo); +int32_t createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode* pExNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* pHandle, STableListInfo* pTableList, SExecTaskInfo* pTaskInfo); +int32_t createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* pHandle, STableListInfo* pTableList, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle, STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo); +int32_t createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle, STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysiNode* pPhyNode, STableListInfo* pTableListInfo, SNode* pTagCond, SNode*pTagIndexCond, SExecTaskInfo* pTaskInfo); +int32_t createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysiNode* pPhyNode, STableListInfo* pTableListInfo, SNode* pTagCond, SNode*pTagIndexCond, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createSysTableScanOperatorInfo(void* readHandle, SSystemTableScanPhysiNode* pScanPhyNode, const char* pUser, SExecTaskInfo* pTaskInfo); +int32_t createSysTableScanOperatorInfo(void* readHandle, SSystemTableScanPhysiNode* pScanPhyNode, const char* pUser, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createTableCountScanOperatorInfo(SReadHandle* handle, STableCountScanPhysiNode* pNode, SExecTaskInfo* pTaskInfo); +int32_t createTableCountScanOperatorInfo(SReadHandle* handle, STableCountScanPhysiNode* pNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pNode, SExecTaskInfo* pTaskInfo); +int32_t createAggregateOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createIndefinitOutputOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pNode, SExecTaskInfo* pTaskInfo); +int32_t createIndefinitOutputOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createProjectOperatorInfo(SOperatorInfo* downstream, SProjectPhysiNode* pProjPhyNode, SExecTaskInfo* pTaskInfo); +int32_t createProjectOperatorInfo(SOperatorInfo* downstream, SProjectPhysiNode* pProjPhyNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createSortOperatorInfo(SOperatorInfo* downstream, SSortPhysiNode* pSortNode, SExecTaskInfo* pTaskInfo); +int32_t createSortOperatorInfo(SOperatorInfo* downstream, SSortPhysiNode* pSortNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createMultiwayMergeOperatorInfo(SOperatorInfo** dowStreams, size_t numStreams, SMergePhysiNode* pMergePhysiNode, SExecTaskInfo* pTaskInfo); +int32_t createMultiwayMergeOperatorInfo(SOperatorInfo** dowStreams, size_t numStreams, SMergePhysiNode* pMergePhysiNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pTableScanNode, SReadHandle* readHandle, STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo); +int32_t createCacherowsScanOperator(SLastRowScanPhysiNode* pTableScanNode, SReadHandle* readHandle, STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo); +int32_t createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SMergeIntervalPhysiNode* pIntervalPhyNode, SExecTaskInfo* pTaskInfo); +int32_t createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SMergeIntervalPhysiNode* pIntervalPhyNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SMergeAlignedIntervalPhysiNode* pNode, SExecTaskInfo* pTaskInfo); +int32_t createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SMergeAlignedIntervalPhysiNode* pNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, int32_t numOfChild, SReadHandle* pHandle); +int32_t createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, int32_t numOfChild, SReadHandle* pHandle, SOperatorInfo** pInfo); -SOperatorInfo* createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionWinodwPhysiNode* pSessionNode, SExecTaskInfo* pTaskInfo); +int32_t createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionWinodwPhysiNode* pSessionNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pAggNode, SExecTaskInfo* pTaskInfo); +int32_t createGroupOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pAggNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDistScanPhysiNode* pBlockScanNode, STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo); +int32_t createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDistScanPhysiNode* pBlockScanNode, STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode, SNode* pTagCond, STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo); +int32_t createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode, SNode* pTagCond, STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createRawScanOperatorInfo(SReadHandle* pHandle, SExecTaskInfo* pTaskInfo); +int32_t createRawScanOperatorInfo(SReadHandle* pHandle, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* pPhyFillNode, SExecTaskInfo* pTaskInfo); +int32_t createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* pPhyFillNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createStatewindowOperatorInfo(SOperatorInfo* downstream, SStateWinodwPhysiNode* pStateNode, SExecTaskInfo* pTaskInfo); +int32_t createStatewindowOperatorInfo(SOperatorInfo* downstream, SStateWinodwPhysiNode* pStateNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createPartitionOperatorInfo(SOperatorInfo* downstream, SPartitionPhysiNode* pPartNode, SExecTaskInfo* pTaskInfo); +int32_t createPartitionOperatorInfo(SOperatorInfo* downstream, SPartitionPhysiNode* pPartNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStreamPartitionPhysiNode* pPartNode, SExecTaskInfo* pTaskInfo); +int32_t createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStreamPartitionPhysiNode* pPartNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pNode, SExecTaskInfo* pTaskInfo); +int32_t createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createMergeJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SSortMergeJoinPhysiNode* pJoinNode, SExecTaskInfo* pTaskInfo); +int32_t createMergeJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SSortMergeJoinPhysiNode* pJoinNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createHashJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SHashJoinPhysiNode* pJoinNode, SExecTaskInfo* pTaskInfo); +int32_t createHashJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SHashJoinPhysiNode* pJoinNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle); +int32_t createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, SOperatorInfo** pInfo); -SOperatorInfo* createStreamFinalSessionAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, int32_t numOfChild, SReadHandle* pHandle); +int32_t createStreamFinalSessionAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, int32_t numOfChild, SReadHandle* pHandle, SOperatorInfo** pInfo); -SOperatorInfo* createStreamIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle); +int32_t createStreamIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, SOperatorInfo** pInfo); -SOperatorInfo* createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle); +int32_t createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, SOperatorInfo** pInfo); -SOperatorInfo* createStreamFillOperatorInfo(SOperatorInfo* downstream, SStreamFillPhysiNode* pPhyFillNode, SExecTaskInfo* pTaskInfo); +int32_t createStreamFillOperatorInfo(SOperatorInfo* downstream, SStreamFillPhysiNode* pPhyFillNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createStreamEventAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle); +int32_t createStreamEventAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, SOperatorInfo** pInfo); -SOperatorInfo* createStreamCountAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle); +int32_t createStreamCountAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, SOperatorInfo** pInfo); -SOperatorInfo* createGroupSortOperatorInfo(SOperatorInfo* downstream, SGroupSortPhysiNode* pSortPhyNode, SExecTaskInfo* pTaskInfo); +int32_t createGroupSortOperatorInfo(SOperatorInfo* downstream, SGroupSortPhysiNode* pSortPhyNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* physiNode, SExecTaskInfo* pTaskInfo); +int32_t createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* physiNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* physiNode, SExecTaskInfo* pTaskInfo); +int32_t createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* physiNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createGroupCacheOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SGroupCachePhysiNode* pPhyciNode, SExecTaskInfo* pTaskInfo); +int32_t createGroupCacheOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SGroupCachePhysiNode* pPhyciNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); -SOperatorInfo* createDynQueryCtrlOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SDynQueryCtrlPhysiNode* pPhyciNode, SExecTaskInfo* pTaskInfo); +int32_t createDynQueryCtrlOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, SDynQueryCtrlPhysiNode* pPhyciNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pInfo); // clang-format on @@ -178,17 +185,17 @@ void setOperatorCompleted(SOperatorInfo* pOperator); void setOperatorInfo(SOperatorInfo* pOperator, const char* name, int32_t type, bool blocking, int32_t status, void* pInfo, SExecTaskInfo* pTaskInfo); int32_t optrDefaultBufFn(SOperatorInfo* pOperator); -SSDataBlock* optrDefaultGetNextExtFn(struct SOperatorInfo* pOperator, SOperatorParam* pParam); +int32_t optrDefaultGetNextExtFn(struct SOperatorInfo* pOperator, SOperatorParam* pParam, SSDataBlock** pRes); int32_t optrDefaultNotifyFn(struct SOperatorInfo* pOperator, SOperatorParam* pParam); SSDataBlock* getNextBlockFromDownstream(struct SOperatorInfo* pOperator, int32_t idx); SSDataBlock* getNextBlockFromDownstreamRemain(struct SOperatorInfo* pOperator, int32_t idx); int16_t getOperatorResultBlockId(struct SOperatorInfo* pOperator, int32_t idx); -SOperatorInfo* createOperator(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, SNode* pTagCond, - SNode* pTagIndexCond, const char* pUser, const char* dbname); +int32_t createOperator(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, SNode* pTagCond, + SNode* pTagIndexCond, const char* pUser, const char* dbname, SOperatorInfo** pOptrInfo); void destroyOperator(SOperatorInfo* pOperator); -SOperatorInfo* extractOperatorInTree(SOperatorInfo* pOperator, int32_t type, const char* id); +int32_t extractOperatorInTree(SOperatorInfo* pOperator, int32_t type, const char* id, SOperatorInfo** pOptrInfo); int32_t getTableScanInfo(SOperatorInfo* pOperator, int32_t* order, int32_t* scanFlag, bool inheritUsOrder); int32_t stopTableScanOperator(SOperatorInfo* pOperator, const char* pIdStr, SStorageAPI* pAPI); int32_t getOperatorExplainExecInfo(struct SOperatorInfo* operatorInfo, SArray* pExecInfoList); diff --git a/source/libs/executor/inc/tsort.h b/source/libs/executor/inc/tsort.h index cf1464ccd7..8cfd8f52ac 100644 --- a/source/libs/executor/inc/tsort.h +++ b/source/libs/executor/inc/tsort.h @@ -107,8 +107,8 @@ void tsortClose(SSortHandle* pHandle); * * @return */ -int32_t tsortSetFetchRawDataFp(SSortHandle* pHandle, _sort_fetch_block_fn_t fetchFp, void (*fp)(SSDataBlock*, void*), - void* param); +void tsortSetFetchRawDataFp(SSortHandle* pHandle, _sort_fetch_block_fn_t fetchFp, void (*fp)(SSDataBlock*, void*), + void* param); /** * diff --git a/source/libs/executor/src/aggregateoperator.c b/source/libs/executor/src/aggregateoperator.c index f1e5dcb670..67c449d3ac 100644 --- a/source/libs/executor/src/aggregateoperator.c +++ b/source/libs/executor/src/aggregateoperator.c @@ -69,11 +69,15 @@ static void doSetTableGroupOutputBuf(SOperatorInfo* pOperator, int32_t numOfOutp static void functionCtxSave(SqlFunctionCtx* pCtx, SFunctionCtxStatus* pStatus); static void functionCtxRestore(SqlFunctionCtx* pCtx, SFunctionCtxStatus* pStatus); -SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pAggNode, - SExecTaskInfo* pTaskInfo) { +int32_t createAggregateOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pAggNode, SExecTaskInfo* pTaskInfo, + SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + + int32_t code = 0; SAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SAggOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } @@ -87,7 +91,7 @@ SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SAggPhysiN int32_t num = 0; SExprInfo* pExprInfo = createExprInfo(pAggNode->pAggFuncs, pAggNode->pGroupKeys, &num); - int32_t code = initAggSup(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str, + 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; @@ -132,7 +136,8 @@ SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SAggPhysiN goto _error; } - return pOperator; + *pOptrInfo = pOperator; + return code; _error: if (pInfo != NULL) { @@ -145,7 +150,7 @@ _error: taosMemoryFreeClear(pOperator); pTaskInfo->code = code; - return NULL; + return code; } void destroyAggOperatorInfo(void* param) { diff --git a/source/libs/executor/src/cachescanoperator.c b/source/libs/executor/src/cachescanoperator.c index 8a413f34fb..b6994e7036 100644 --- a/source/libs/executor/src/cachescanoperator.c +++ b/source/libs/executor/src/cachescanoperator.c @@ -51,10 +51,10 @@ typedef struct SCacheRowsScanInfo { } SCacheRowsScanInfo; static SSDataBlock* doScanCache(SOperatorInfo* pOperator); -static void destroyCacheScanOperator(void* param); -static int32_t extractCacheScanSlotId(const SArray* pColMatchInfo, SExecTaskInfo* pTaskInfo, int32_t** pSlotIds, - int32_t** pDstSlotIds); -static int32_t removeRedundantTsCol(SLastRowScanPhysiNode* pScanNode, SColMatchInfo* pColMatchInfo); +static void destroyCacheScanOperator(void* param); +static int32_t extractCacheScanSlotId(const SArray* pColMatchInfo, SExecTaskInfo* pTaskInfo, int32_t** pSlotIds, + int32_t** pDstSlotIds); +static int32_t removeRedundantTsCol(SLastRowScanPhysiNode* pScanNode, SColMatchInfo* pColMatchInfo); #define SCAN_ROW_TYPE(_t) ((_t) ? CACHESCAN_RETRIEVE_LAST : CACHESCAN_RETRIEVE_LAST_ROW) @@ -84,8 +84,11 @@ static void setColIdForCacheReadBlock(SSDataBlock* pBlock, SLastRowScanPhysiNode } } -SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SReadHandle* readHandle, - STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo) { +int32_t createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SReadHandle* readHandle, + STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo, + SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; int32_t numOfCols = 0; @@ -207,7 +210,9 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe NULL, optrDefaultGetNextExtFn, NULL); pOperator->cost.openCost = 0; - return pOperator; + + *pOptrInfo = pOperator; + return code; _error: pTaskInfo->code = code; @@ -216,7 +221,7 @@ _error: } destroyCacheScanOperator(pInfo); taosMemoryFree(pOperator); - return NULL; + return code; } int32_t doScanCacheNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) { diff --git a/source/libs/executor/src/countwindowoperator.c b/source/libs/executor/src/countwindowoperator.c index 4395d00127..b7aa57e4b1 100644 --- a/source/libs/executor/src/countwindowoperator.c +++ b/source/libs/executor/src/countwindowoperator.c @@ -235,13 +235,16 @@ static SSDataBlock* countWindowAggregate(SOperatorInfo* pOperator) { return pRes; } -SOperatorInfo* createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* physiNode, - SExecTaskInfo* pTaskInfo) { +int32_t createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* physiNode, + SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + 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) { + code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } @@ -306,7 +309,8 @@ SOperatorInfo* createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo goto _error; } - return pOperator; + *pOptrInfo = pOperator; + return code; _error: if (pInfo != NULL) { @@ -315,5 +319,5 @@ _error: taosMemoryFreeClear(pOperator); pTaskInfo->code = code; - return NULL; + return code; } diff --git a/source/libs/executor/src/dynqueryctrloperator.c b/source/libs/executor/src/dynqueryctrloperator.c old mode 100755 new mode 100644 index e4ca946f4f..3b025685dc --- a/source/libs/executor/src/dynqueryctrloperator.c +++ b/source/libs/executor/src/dynqueryctrloperator.c @@ -527,8 +527,8 @@ static void seqJoinLaunchNewRetrieveImpl(SOperatorInfo* pOperator, SSDataBlock** } qDebug("%s dynamic post task begin", GET_TASKID(pOperator->pTaskInfo)); - *ppRes = pOperator->pDownstream[1]->fpSet.getNextExtFn(pOperator->pDownstream[1], pParam); - if (*ppRes) { + code = pOperator->pDownstream[1]->fpSet.getNextExtFn(pOperator->pDownstream[1], pParam, ppRes); + if (*ppRes && (code == 0)) { pPost->isStarted = true; pStbJoin->execInfo.postBlkNum++; pStbJoin->execInfo.postBlkRows += (*ppRes)->info.rows; @@ -955,17 +955,20 @@ int32_t initSeqStbJoinTableHash(SStbJoinPrevJoinCtx* pPrev, bool batchFetch) { return TSDB_CODE_SUCCESS; } +int32_t createDynQueryCtrlOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, + SDynQueryCtrlPhysiNode* pPhyciNode, SExecTaskInfo* pTaskInfo, + SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); -SOperatorInfo* createDynQueryCtrlOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, - SDynQueryCtrlPhysiNode* pPhyciNode, SExecTaskInfo* pTaskInfo) { - int32_t code = TSDB_CODE_SUCCESS; - __optr_fn_t nextFp = NULL; + int32_t code = TSDB_CODE_SUCCESS; + __optr_fn_t nextFp = NULL; SDynQueryCtrlOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SDynQueryCtrlOperatorInfo)); if (pInfo == NULL) { code = terrno; goto _error; } - SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pOperator == NULL) { code = terrno; goto _error; @@ -994,23 +997,22 @@ SOperatorInfo* createDynQueryCtrlOperatorInfo(SOperatorInfo** pDownstream, int32 code = TSDB_CODE_INVALID_PARA; goto _error; } - - setOperatorInfo(pOperator, "DynQueryCtrlOperator", QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL, false, OP_NOT_OPENED, pInfo, pTaskInfo); - pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, nextFp, NULL, destroyDynQueryCtrlOperator, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); + setOperatorInfo(pOperator, "DynQueryCtrlOperator", QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL, false, OP_NOT_OPENED, + pInfo, pTaskInfo); - return pOperator; + pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, nextFp, NULL, destroyDynQueryCtrlOperator, optrDefaultBufFn, + NULL, optrDefaultGetNextExtFn, NULL); + + *pOptrInfo = pOperator; + return code; _error: - if (pInfo != NULL) { destroyDynQueryCtrlOperator(pInfo); } taosMemoryFree(pOperator); pTaskInfo->code = code; - - return NULL; + return code; } - - diff --git a/source/libs/executor/src/eventwindowoperator.c b/source/libs/executor/src/eventwindowoperator.c index f5fda4c276..629afbbb8e 100644 --- a/source/libs/executor/src/eventwindowoperator.c +++ b/source/libs/executor/src/eventwindowoperator.c @@ -58,13 +58,16 @@ static void doKeepTuple(SWindowRowsSup* pRowSup, int64_t ts, uint64_t groupId) { pRowSup->groupId = groupId; } -SOperatorInfo* createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* physiNode, - SExecTaskInfo* pTaskInfo) { +int32_t createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* physiNode, + SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + 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) { + code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } @@ -128,7 +131,8 @@ SOperatorInfo* createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo goto _error; } - return pOperator; + *pOptrInfo = pOperator; + return code; _error: if (pInfo != NULL) { @@ -137,7 +141,7 @@ _error: taosMemoryFreeClear(pOperator); pTaskInfo->code = code; - return NULL; + return code; } void destroyEWindowOperatorInfo(void* param) { diff --git a/source/libs/executor/src/exchangeoperator.c b/source/libs/executor/src/exchangeoperator.c index 22d5b6097e..7c74fa7a44 100644 --- a/source/libs/executor/src/exchangeoperator.c +++ b/source/libs/executor/src/exchangeoperator.c @@ -367,12 +367,16 @@ static int32_t initExchangeOperator(SExchangePhysiNode* pExNode, SExchangeInfo* return initDataSource(numOfSources, pInfo, id); } -SOperatorInfo* createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode* pExNode, SExecTaskInfo* pTaskInfo) { - int32_t code = TSDB_CODE_SUCCESS; +int32_t createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode* pExNode, SExecTaskInfo* pTaskInfo, + SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + + int32_t code = 0; int32_t lino = 0; SExchangeInfo* pInfo = taosMemoryCalloc(1, sizeof(SExchangeInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } @@ -403,7 +407,8 @@ SOperatorInfo* createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode pOperator->fpSet = createOperatorFpSet(prepareLoadRemoteData, loadRemoteData, NULL, destroyExchangeOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); - return pOperator; + *pOptrInfo = pOperator; + return code; _error: if (code != TSDB_CODE_SUCCESS) { @@ -416,7 +421,7 @@ _error: taosMemoryFreeClear(pOperator); pTaskInfo->code = code; - return NULL; + return code; } void destroyExchangeOperatorInfo(void* param) { diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c index d58af16655..d864a87f75 100644 --- a/source/libs/executor/src/executor.c +++ b/source/libs/executor/src/executor.c @@ -292,13 +292,11 @@ qTaskInfo_t qCreateQueueExecTaskInfo(void* msg, SReadHandle* pReaderHandle, int3 int32_t code = doCreateTask(0, id, vgId, OPTR_EXEC_MODEL_QUEUE, &pReaderHandle->api, &pTaskInfo); if (NULL == pTaskInfo || code != 0) { - terrno = TSDB_CODE_OUT_OF_MEMORY; return NULL; } - pTaskInfo->pRoot = createRawScanOperatorInfo(pReaderHandle, pTaskInfo); - if (NULL == pTaskInfo->pRoot) { - terrno = TSDB_CODE_OUT_OF_MEMORY; + createRawScanOperatorInfo(pReaderHandle, pTaskInfo, &pTaskInfo->pRoot); + if (NULL == pTaskInfo->pRoot || code != 0) { taosMemoryFree(pTaskInfo); return NULL; } @@ -458,7 +456,12 @@ int32_t qUpdateTableListForStreamScanner(qTaskInfo_t tinfo, const SArray* tableI } // traverse to the stream scanner node to add this table id - SOperatorInfo* pInfo = extractOperatorInTree(pTaskInfo->pRoot, QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN, id); + SOperatorInfo* pInfo = NULL; + code = extractOperatorInTree(pTaskInfo->pRoot, QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN, id, &pInfo); + if (code != 0 || pInfo == NULL) { + return code; + } + SStreamScanInfo* pScanInfo = pInfo->info; if (isAdd) { // add new table id @@ -670,12 +673,11 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo int32_t current = 0; SSDataBlock* pRes = NULL; - - int64_t st = taosGetTimestampUs(); + int64_t st = taosGetTimestampUs(); if (pTaskInfo->pOpParam && !pTaskInfo->paramSet) { pTaskInfo->paramSet = true; - pRes = pTaskInfo->pRoot->fpSet.getNextExtFn(pTaskInfo->pRoot, pTaskInfo->pOpParam); + code = pTaskInfo->pRoot->fpSet.getNextExtFn(pTaskInfo->pRoot, pTaskInfo->pOpParam, &pRes); } else { pRes = pTaskInfo->pRoot->fpSet.getNextFn(pTaskInfo->pRoot); } @@ -688,6 +690,7 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo if (!pTaskInfo->pSubplan->dynamicRowThreshold || 4096 <= pTaskInfo->pSubplan->rowsThreshold) { rowsThreshold = 4096; } + int32_t blockIndex = 0; while (pRes != NULL) { SSDataBlock* p = NULL; @@ -1209,10 +1212,11 @@ int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subT const char* id = GET_TASKID(pTaskInfo); 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 TAOS_GET_TERRNO(TSDB_CODE_OUT_OF_MEMORY); + code = extractOperatorInTree(pOperator, QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN, id, &pOperator); + if (pOperator == NULL || code != 0) { + return code; } + SStreamScanInfo* pInfo = pOperator->info; SStoreTqReader* pReaderAPI = &pTaskInfo->storageAPI.tqReaderFn; SWalReader* pWalReader = pReaderAPI->tqReaderGetWalReader(pInfo->tqReader); @@ -1224,9 +1228,9 @@ int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subT } if (subType == TOPIC_SUB_TYPE__COLUMN) { - pOperator = extractOperatorInTree(pOperator, QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN, id); - if (pOperator == NULL) { - return TAOS_GET_TERRNO(TSDB_CODE_OUT_OF_MEMORY); + extractOperatorInTree(pOperator, QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN, id, &pOperator); + if (pOperator == NULL || code != 0) { + return code; } SStreamScanInfo* pInfo = pOperator->info; @@ -1338,8 +1342,13 @@ int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subT if (pOffset->type == TMQ_OFFSET__SNAPSHOT_DATA) { SStreamRawScanInfo* pInfo = pOperator->info; SSnapContext* sContext = pInfo->sContext; + SOperatorInfo* p = NULL; + + code = extractOperatorInTree(pOperator, QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN, id, &p); + if (code != 0) { + return code; + } - SOperatorInfo* p = extractOperatorInTree(pOperator, QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN, id); STableListInfo* pTableListInfo = ((SStreamRawScanInfo*)(p->info))->pTableListInfo; if (pAPI->snapshotFn.setForSnapShot(sContext, pOffset->uid) != 0) { diff --git a/source/libs/executor/src/executorInt.c b/source/libs/executor/src/executorInt.c index d980244360..d56b288129 100644 --- a/source/libs/executor/src/executorInt.c +++ b/source/libs/executor/src/executorInt.c @@ -74,7 +74,7 @@ static UNUSED_FUNC void* u_realloc(void* p, size_t __size) { static int32_t setBlockSMAInfo(SqlFunctionCtx* pCtx, SExprInfo* pExpr, SSDataBlock* pBlock); -static void initCtxOutputBuffer(SqlFunctionCtx* pCtx, int32_t size); +static int32_t 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, @@ -1227,20 +1227,28 @@ void freeResetOperatorParams(struct SOperatorInfo* pOperator, SOperatorParamType } } -FORCE_INLINE SSDataBlock* getNextBlockFromDownstreamImpl(struct SOperatorInfo* pOperator, int32_t idx, - bool clearParam) { +FORCE_INLINE int32_t getNextBlockFromDownstreamImpl(struct SOperatorInfo* pOperator, int32_t idx, bool clearParam, + SSDataBlock** pResBlock) { + QRY_OPTR_CHECK(pResBlock); + + int32_t code = 0; 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]); - if (clearParam) { + code = pOperator->pDownstream[idx]->fpSet.getNextExtFn(pOperator->pDownstream[idx], + pOperator->pDownstreamGetParams[idx], pResBlock); + if (clearParam && (code == 0)) { freeOperatorParam(pOperator->pDownstreamGetParams[idx], OP_GET_PARAM); pOperator->pDownstreamGetParams[idx] = NULL; } - return pBlock; + return code; } - return pOperator->pDownstream[idx]->fpSet.getNextFn(pOperator->pDownstream[idx]); + *pResBlock = pOperator->pDownstream[idx]->fpSet.getNextFn(pOperator->pDownstream[idx]); + if (*pResBlock == NULL && terrno != 0) { + return terrno; + } else { + return code; + } } bool compareVal(const char* v, const SStateKeys* pKey) { diff --git a/source/libs/executor/src/filloperator.c b/source/libs/executor/src/filloperator.c index 341b1a01ea..1a433ba025 100644 --- a/source/libs/executor/src/filloperator.c +++ b/source/libs/executor/src/filloperator.c @@ -450,11 +450,15 @@ static int32_t createPrimaryTsExprIfNeeded(SFillOperatorInfo* pInfo, SFillPhysiN return TSDB_CODE_SUCCESS; } -SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* pPhyFillNode, - SExecTaskInfo* pTaskInfo) { +int32_t createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* pPhyFillNode, + SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + int32_t code = 0; + SFillOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SFillOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } @@ -464,7 +468,7 @@ SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* SExprSupp* pNoFillSupp = &pInfo->noFillExprSupp; pNoFillSupp->pExprInfo = createExprInfo(pPhyFillNode->pNotFillExprs, NULL, &pNoFillSupp->numOfExprs); - int32_t code = createPrimaryTsExprIfNeeded(pInfo, pPhyFillNode, pNoFillSupp, pTaskInfo->id.str); + code = createPrimaryTsExprIfNeeded(pInfo, pPhyFillNode, pNoFillSupp, pTaskInfo->id.str); if (code != TSDB_CODE_SUCCESS) { goto _error; } @@ -526,7 +530,9 @@ SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); - return pOperator; + + *pOptrInfo = pOperator; + return code; _error: if (pInfo != NULL) { @@ -535,5 +541,5 @@ _error: pTaskInfo->code = code; taosMemoryFreeClear(pOperator); - return NULL; + return code; } diff --git a/source/libs/executor/src/groupcacheoperator.c b/source/libs/executor/src/groupcacheoperator.c old mode 100755 new mode 100644 index e9a6c14141..c753f0fd9b --- a/source/libs/executor/src/groupcacheoperator.c +++ b/source/libs/executor/src/groupcacheoperator.c @@ -699,7 +699,7 @@ static FORCE_INLINE int32_t getBlkFromDownstreamOperator(struct SOperatorInfo* p } if (pDownstreamParam) { - pBlock = pOperator->pDownstream[downstreamIdx]->fpSet.getNextExtFn(pOperator->pDownstream[downstreamIdx], pDownstreamParam); + code = pOperator->pDownstream[downstreamIdx]->fpSet.getNextExtFn(pOperator->pDownstream[downstreamIdx], pDownstreamParam, &pBlock); } else { pBlock = pOperator->pDownstream[downstreamIdx]->fpSet.getNextFn(pOperator->pDownstream[downstreamIdx]); } @@ -1388,15 +1388,18 @@ static int32_t initGroupCacheDownstreamCtx(SOperatorInfo* pOperator) { return TSDB_CODE_SUCCESS; } -static SSDataBlock* groupCacheGetNext(struct SOperatorInfo* pOperator, SOperatorParam* pParam) { +static int32_t groupCacheGetNext(struct SOperatorInfo* pOperator, SOperatorParam* pParam, SSDataBlock** pRes) { + *pRes = NULL; + SSDataBlock* pBlock = NULL; - int64_t st = 0; + int64_t st = 0; + int32_t code = 0; if (pOperator->cost.openCost == 0) { st = taosGetTimestampUs(); } - int32_t code = getBlkFromGroupCache(pOperator, &pBlock, pParam); + code = getBlkFromGroupCache(pOperator, &pBlock, pParam); if (TSDB_CODE_SUCCESS != code) { pOperator->pTaskInfo->code = code; T_LONG_JMP(pOperator->pTaskInfo->env, pOperator->pTaskInfo->code); @@ -1406,7 +1409,8 @@ static SSDataBlock* groupCacheGetNext(struct SOperatorInfo* pOperator, SOperator pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0; } - return pBlock; + *pRes = pBlock; + return code; } static int32_t groupCacheTableCacheEnd(SOperatorInfo* pOperator, SOperatorParam* pParam) { @@ -1424,12 +1428,14 @@ static int32_t groupCacheTableCacheEnd(SOperatorInfo* pOperator, SOperatorParam* return TSDB_CODE_SUCCESS; } -SOperatorInfo* createGroupCacheOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, - SGroupCachePhysiNode* pPhyciNode, SExecTaskInfo* pTaskInfo) { - SGroupCacheOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SGroupCacheOperatorInfo)); - SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); - +int32_t createGroupCacheOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, + SGroupCachePhysiNode* pPhyciNode, SExecTaskInfo* pTaskInfo, + SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; + + SGroupCacheOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SGroupCacheOperatorInfo)); + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pOperator == NULL || pInfo == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; goto _error; @@ -1490,7 +1496,8 @@ SOperatorInfo* createGroupCacheOperatorInfo(SOperatorInfo** pDownstream, int32_t qTrace("new group cache operator, maxCacheSize:%" PRId64 ", globalGrp:%d, batchFetch:%d", pInfo->maxCacheSize, pInfo->globalGrp, pInfo->batchFetch); - return pOperator; + *pOptrInfo = pOperator; + return code; _error: if (pInfo != NULL) { @@ -1499,7 +1506,5 @@ _error: taosMemoryFree(pOperator); pTaskInfo->code = code; - return NULL; + return code; } - - diff --git a/source/libs/executor/src/groupoperator.c b/source/libs/executor/src/groupoperator.c index bd503d4638..173e67cc16 100644 --- a/source/libs/executor/src/groupoperator.c +++ b/source/libs/executor/src/groupoperator.c @@ -535,7 +535,10 @@ static SSDataBlock* hashGroupbyAggregate(SOperatorInfo* pOperator) { return pRes; } -SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pAggNode, SExecTaskInfo* pTaskInfo) { +int32_t createGroupOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pAggNode, SExecTaskInfo* pTaskInfo, + SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; SGroupbyOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SGroupbyOperatorInfo)); @@ -591,7 +594,8 @@ SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* code = appendDownstream(pOperator, &downstream, 1); QUERY_CHECK_CODE(code, lino, _error); - return pOperator; + *pOptrInfo = pOperator; + return code; _error: pTaskInfo->code = code; @@ -599,7 +603,7 @@ _error: destroyGroupOperatorInfo(pInfo); } taosMemoryFreeClear(pOperator); - return NULL; + return code; } SSDataBlock* createBlockDataNotLoaded(const SOperatorInfo* pOperator, SSDataBlock* pDataBlock) { @@ -1104,15 +1108,16 @@ static void destroyPartitionOperatorInfo(void* param) { taosMemoryFreeClear(param); } -SOperatorInfo* createPartitionOperatorInfo(SOperatorInfo* downstream, SPartitionPhysiNode* pPartNode, - SExecTaskInfo* pTaskInfo) { +int32_t createPartitionOperatorInfo(SOperatorInfo* downstream, SPartitionPhysiNode* pPartNode, + SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + 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) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - pTaskInfo->code = terrno; + pTaskInfo->code = code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } @@ -1135,7 +1140,7 @@ SOperatorInfo* createPartitionOperatorInfo(SOperatorInfo* downstream, SPartition if (pPartNode->pExprs != NULL) { int32_t num = 0; SExprInfo* pExprInfo1 = createExprInfo(pPartNode->pExprs, NULL, &num); - int32_t code = initExprSupp(&pInfo->scalarSup, pExprInfo1, num, &pTaskInfo->storageAPI.functionStore); + code = initExprSupp(&pInfo->scalarSup, pExprInfo1, num, &pTaskInfo->storageAPI.functionStore); if (code != TSDB_CODE_SUCCESS) { terrno = code; pTaskInfo->code = terrno; @@ -1202,7 +1207,8 @@ SOperatorInfo* createPartitionOperatorInfo(SOperatorInfo* downstream, SPartition goto _error; } - return pOperator; + *pOptrInfo = pOperator; + return code; _error: if (pInfo != NULL) { @@ -1210,7 +1216,7 @@ _error: } pTaskInfo->code = code; taosMemoryFreeClear(pOperator); - return NULL; + return code; } int32_t setGroupResultOutputBuf(SOperatorInfo* pOperator, SOptrBasicInfo* binfo, int32_t numOfCols, char* pData, @@ -1629,8 +1635,10 @@ void freePartItem(void* ptr) { taosArrayDestroy(pPart->rowIds); } -SOperatorInfo* createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStreamPartitionPhysiNode* pPartNode, - SExecTaskInfo* pTaskInfo) { +int32_t createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStreamPartitionPhysiNode* pPartNode, + SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; SStreamPartitionOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamPartitionOperatorInfo)); @@ -1721,14 +1729,15 @@ SOperatorInfo* createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStr code = appendDownstream(pOperator, &downstream, 1); QUERY_CHECK_CODE(code, lino, _error); - return pOperator; + *pOptrInfo = pOperator; + return code; _error: pTaskInfo->code = code; destroyStreamPartitionOperatorInfo(pInfo); taosMemoryFreeClear(pOperator); qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); - return NULL; + return code; } int32_t extractColumnInfo(SNodeList* pNodeList, SArray** pArrayRes) { diff --git a/source/libs/executor/src/hashjoinoperator.c b/source/libs/executor/src/hashjoinoperator.c old mode 100755 new mode 100644 index 4945faeb09..9f6318b58d --- a/source/libs/executor/src/hashjoinoperator.c +++ b/source/libs/executor/src/hashjoinoperator.c @@ -1177,12 +1177,13 @@ int32_t hJoinInitResBlocks(SHJoinOperatorInfo* pJoin, SHashJoinPhysiNode* pJoinN } -SOperatorInfo* createHashJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, - SHashJoinPhysiNode* pJoinNode, SExecTaskInfo* pTaskInfo) { - SHJoinOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SHJoinOperatorInfo)); - SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); +int32_t createHashJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, + SHashJoinPhysiNode* pJoinNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); - int32_t code = TSDB_CODE_SUCCESS; + int32_t code = TSDB_CODE_SUCCESS; + SHJoinOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SHJoinOperatorInfo)); + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pOperator == NULL || pInfo == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; goto _return; @@ -1223,7 +1224,8 @@ SOperatorInfo* createHashJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t n qDebug("create hash Join operator done"); - return pOperator; + *pOptrInfo = pOperator; + return code; _return: @@ -1233,7 +1235,7 @@ _return: taosMemoryFree(pOperator); pTaskInfo->code = code; - return NULL; + return code; } diff --git a/source/libs/executor/src/mergejoinoperator.c b/source/libs/executor/src/mergejoinoperator.c index 395b04f45b..d425c87019 100644 --- a/source/libs/executor/src/mergejoinoperator.c +++ b/source/libs/executor/src/mergejoinoperator.c @@ -1862,8 +1862,10 @@ int32_t mJoinSetImplFp(SMJoinOperatorInfo* pJoin) { return TSDB_CODE_SUCCESS; } -SOperatorInfo* createMergeJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, - SSortMergeJoinPhysiNode* pJoinNode, SExecTaskInfo* pTaskInfo) { +int32_t createMergeJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t numOfDownstream, + SSortMergeJoinPhysiNode* pJoinNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + bool newDownstreams = false; int32_t code = TSDB_CODE_SUCCESS; SMJoinOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SMJoinOperatorInfo)); @@ -1872,7 +1874,7 @@ SOperatorInfo* createMergeJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t goto _return; } - SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pOperator == NULL) { code = terrno; goto _return; @@ -1903,8 +1905,9 @@ SOperatorInfo* createMergeJoinOperatorInfo(SOperatorInfo** pDownstream, int32_t } else { pOperator->numOfRealDownstream = 2; } - - return pOperator; + + *pOptrInfo = pOperator; + return code; _return: @@ -1918,6 +1921,6 @@ _return: taosMemoryFree(pOperator); pTaskInfo->code = code; - return NULL; + return code; } diff --git a/source/libs/executor/src/mergeoperator.c b/source/libs/executor/src/mergeoperator.c index 384b14ce41..31757ef70c 100644 --- a/source/libs/executor/src/mergeoperator.c +++ b/source/libs/executor/src/mergeoperator.c @@ -57,6 +57,14 @@ typedef struct SMultiwayMergeOperatorInfo { bool inputWithGroupId; } SMultiwayMergeOperatorInfo; +static SSDataBlock* doSortMerge1(SOperatorInfo* pOperator); +static int32_t doSortMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock); +static SSDataBlock* doMultiwayMerge(SOperatorInfo* pOperator); +static int32_t doNonSortMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock); +static SSDataBlock* doNonSortMerge1(SOperatorInfo* pOperator); +static SSDataBlock* doColsMerge1(SOperatorInfo* pOperator); +static int32_t doColsMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock); + SSDataBlock* sortMergeloadNextDataBlock(void* param) { SOperatorInfo* pOperator = (SOperatorInfo*)param; SSDataBlock* pBlock = pOperator->fpSet.getNextFn(pOperator); @@ -83,20 +91,30 @@ int32_t openSortMergeOperator(SOperatorInfo* pOperator) { for (int32_t i = 0; i < pOperator->numOfDownstream; ++i) { SOperatorInfo* pDownstream = pOperator->pDownstream[i]; if (pDownstream->operatorType == QUERY_NODE_PHYSICAL_PLAN_EXCHANGE) { - pDownstream->fpSet._openFn(pDownstream); + code = pDownstream->fpSet._openFn(pDownstream); + if (code) { + return code; + } } SSortSource* ps = taosMemoryCalloc(1, sizeof(SSortSource)); + if (ps == NULL) { + return terrno; + } + ps->param = pDownstream; ps->onlyRef = true; - tsortAddSource(pSortMergeInfo->pSortHandle, ps); + code = tsortAddSource(pSortMergeInfo->pSortHandle, ps); + if (code) { + return code; + } } return tsortOpen(pSortMergeInfo->pSortHandle); } -static void doGetSortedBlockData(SMultiwayMergeOperatorInfo* pInfo, SSortHandle* pHandle, int32_t capacity, +static int32_t doGetSortedBlockData(SMultiwayMergeOperatorInfo* pInfo, SSortHandle* pHandle, int32_t capacity, SSDataBlock* p, bool* newgroup) { SSortMergeInfo* pSortMergeInfo = &pInfo->sortMergeInfo; *newgroup = false; @@ -132,12 +150,20 @@ static void doGetSortedBlockData(SMultiwayMergeOperatorInfo* pInfo, SSortHandle* if (pInfo->groupMerge || pInfo->inputWithGroupId) { uint64_t tupleGroupId = tsortGetGroupId(pTupleHandle); if (pInfo->groupId == 0 || pInfo->groupId == tupleGroupId) { - appendOneRowToDataBlock(p, pTupleHandle); + code = appendOneRowToDataBlock(p, pTupleHandle); + if (code) { + return code; + } + p->info.id.groupId = tupleGroupId; pInfo->groupId = tupleGroupId; } else { if (p->info.rows == 0) { - appendOneRowToDataBlock(p, pTupleHandle); + code = appendOneRowToDataBlock(p, pTupleHandle); + if (code) { + return code; + } + p->info.id.groupId = pInfo->groupId = tupleGroupId; } else { pSortMergeInfo->prefetchedTuple = pTupleHandle; @@ -145,16 +171,27 @@ static void doGetSortedBlockData(SMultiwayMergeOperatorInfo* pInfo, SSortHandle* } } } else { - appendOneRowToDataBlock(p, pTupleHandle); + code = appendOneRowToDataBlock(p, pTupleHandle); + if (code) { + return code; + } } if (p->info.rows >= capacity) { break; } } + + return code; } -SSDataBlock* doSortMerge(SOperatorInfo* pOperator) { +SSDataBlock* doSortMerge1(SOperatorInfo* pOperator) { + SSDataBlock* pBlock = NULL; + pOperator->pTaskInfo->code = doSortMerge(pOperator, &pBlock); + return pBlock; +} + +int32_t doSortMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock) { SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SMultiwayMergeOperatorInfo* pInfo = pOperator->info; SSortMergeInfo* pSortMergeInfo = &pInfo->sortMergeInfo; @@ -162,29 +199,36 @@ SSDataBlock* doSortMerge(SOperatorInfo* pOperator) { SSDataBlock* pDataBlock = pInfo->binfo.pRes; SArray* pColMatchInfo = pSortMergeInfo->matchInfo.pList; int32_t capacity = pOperator->resultInfo.capacity; + int32_t code = 0; + bool newgroup = false; qDebug("start to merge final sorted rows, %s", GET_TASKID(pTaskInfo)); - blockDataCleanup(pDataBlock); if (pSortMergeInfo->pIntermediateBlock == NULL) { pSortMergeInfo->pIntermediateBlock = NULL; - int32_t code = tsortGetSortedDataBlock(pHandle, &pSortMergeInfo->pIntermediateBlock); + code = tsortGetSortedDataBlock(pHandle, &pSortMergeInfo->pIntermediateBlock); if (pSortMergeInfo->pIntermediateBlock == NULL || code != 0) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return NULL; + return code; } - blockDataEnsureCapacity(pSortMergeInfo->pIntermediateBlock, capacity); + + code = blockDataEnsureCapacity(pSortMergeInfo->pIntermediateBlock, capacity); + if (code) { + return code; + } + } else { blockDataCleanup(pSortMergeInfo->pIntermediateBlock); } SSDataBlock* p = pSortMergeInfo->pIntermediateBlock; - bool newgroup = false; - while (1) { - doGetSortedBlockData(pInfo, pHandle, capacity, p, &newgroup); + code = doGetSortedBlockData(pInfo, pHandle, capacity, p, &newgroup); + if (code) { + return code; + } + if (p->info.rows == 0) { break; } @@ -204,10 +248,27 @@ SSDataBlock* doSortMerge(SOperatorInfo* pOperator) { int32_t numOfCols = taosArrayGetSize(pColMatchInfo); for (int32_t i = 0; i < numOfCols; ++i) { SColMatchItem* pmInfo = taosArrayGet(pColMatchInfo, i); + if (pmInfo == NULL) { + code = terrno; + return code; + } SColumnInfoData* pSrc = taosArrayGet(p->pDataBlock, pmInfo->srcSlotId); + if (pSrc == NULL) { + code = terrno; + return code; + } + SColumnInfoData* pDst = taosArrayGet(pDataBlock->pDataBlock, pmInfo->dstSlotId); - colDataAssign(pDst, pSrc, p->info.rows, &pDataBlock->info); + if (pDst == NULL) { + code = terrno; + return code; + } + + code = colDataAssign(pDst, pSrc, p->info.rows, &pDataBlock->info); + if (code) { + return code; + } } pDataBlock->info.rows = p->info.rows; @@ -223,12 +284,16 @@ SSDataBlock* doSortMerge(SOperatorInfo* pOperator) { qDebug("%s get sorted block, groupId:0x%" PRIx64 " rows:%" PRId64 , GET_TASKID(pTaskInfo), pDataBlock->info.id.groupId, pDataBlock->info.rows); - return (pDataBlock->info.rows > 0) ? pDataBlock : NULL; + *pResBlock = (pDataBlock->info.rows > 0) ? pDataBlock : NULL; + return code; } - int32_t getSortMergeExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len) { SSortExecInfo* pSortExecInfo = taosMemoryCalloc(1, sizeof(SSortExecInfo)); + if (pSortExecInfo == NULL) { + pOptr->pTaskInfo->code = terrno; + return terrno; + } SMultiwayMergeOperatorInfo* pInfo = (SMultiwayMergeOperatorInfo*)pOptr->info; SSortMergeInfo* pSortMergeInfo = &pInfo->sortMergeInfo; @@ -265,25 +330,35 @@ int32_t openNonSortMergeOperator(SOperatorInfo* pOperator) { pNonSortMergeInfo->sourceWorkIdx = 0; pNonSortMergeInfo->sourceNum = pOperator->numOfDownstream; pNonSortMergeInfo->lastSourceIdx = -1; - pNonSortMergeInfo->pSourceStatus = taosMemoryCalloc(pOperator->numOfDownstream, sizeof(*pNonSortMergeInfo->pSourceStatus)); + pNonSortMergeInfo->pSourceStatus = + taosMemoryCalloc(pOperator->numOfDownstream, sizeof(*pNonSortMergeInfo->pSourceStatus)); if (NULL == pNonSortMergeInfo->pSourceStatus) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return -1; + pTaskInfo->code = TSDB_CODE_OUT_OF_MEMORY; + return pTaskInfo->code; } - + for (int32_t i = 0; i < pOperator->numOfDownstream; ++i) { pNonSortMergeInfo->pSourceStatus[i] = i; } - return TSDB_CODE_SUCCESS; + return 0; } -SSDataBlock* doNonSortMerge(SOperatorInfo* pOperator) { +SSDataBlock* doNonSortMerge1(SOperatorInfo* pOperator) { + SSDataBlock* pBlock = NULL; + pOperator->pTaskInfo->code = doNonSortMerge(pOperator, &pBlock); + return pBlock; +} + +int32_t doNonSortMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock) { + QRY_OPTR_CHECK(pResBlock); + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SMultiwayMergeOperatorInfo* pInfo = pOperator->info; SNonSortMergeInfo* pNonSortMerge = &pInfo->nsortMergeInfo; SSDataBlock* pBlock = NULL; SSDataBlock* pRes = pInfo->binfo.pRes; + int32_t code = 0; qDebug("start to merge no sorted rows, %s", GET_TASKID(pTaskInfo)); @@ -296,16 +371,18 @@ SSDataBlock* doNonSortMerge(SOperatorInfo* pOperator) { idx = NON_SORT_NEXT_SRC(pNonSortMerge, pNonSortMerge->lastSourceIdx); continue; } + pNonSortMerge->lastSourceIdx = idx - 1; break; } - if (!pBlock) { - return NULL; + if (!pBlock) { // null data + return code; } - copyDataBlock(pRes, pBlock); - return pRes; + code = copyDataBlock(pRes, pBlock); + *pResBlock = pRes; + return code; } void destroyNonSortMergeOperatorInfo(void* param) { @@ -323,30 +400,54 @@ int32_t openColsMergeOperator(SOperatorInfo* pOperator) { } int32_t copyColumnsValue(SNodeList* pNodeList, uint64_t targetBlkId, SSDataBlock* pDst, SSDataBlock* pSrc) { - bool isNull = (NULL == pSrc || pSrc->info.rows <= 0); + bool isNull = (NULL == pSrc || pSrc->info.rows <= 0); size_t numOfCols = LIST_LENGTH(pNodeList); + int32_t code = 0; + for (int32_t i = 0; i < numOfCols; ++i) { STargetNode* pNode = (STargetNode*)nodesListGetNode(pNodeList, i); if (nodeType(pNode->pExpr) == QUERY_NODE_COLUMN && ((SColumnNode*)pNode->pExpr)->dataBlockId == targetBlkId) { SColumnInfoData* pDstCol = taosArrayGet(pDst->pDataBlock, pNode->slotId); + if (pDstCol == NULL) { + return terrno; + } + if (isNull) { - colDataSetVal(pDstCol, 0, NULL, true); + code = colDataSetVal(pDstCol, 0, NULL, true); } else { SColumnInfoData* pSrcCol = taosArrayGet(pSrc->pDataBlock, ((SColumnNode*)pNode->pExpr)->slotId); - colDataAssign(pDstCol, pSrcCol, 1, &pDst->info); + if (pSrcCol == NULL) { + code = terrno; + return code; + } + + code = colDataAssign(pDstCol, pSrcCol, 1, &pDst->info); + } + + if (code) { + break; } } } - return TSDB_CODE_SUCCESS; + return code; } -SSDataBlock* doColsMerge(SOperatorInfo* pOperator) { +SSDataBlock* doColsMerge1(SOperatorInfo* pOperator) { + SSDataBlock* pBlock = NULL; + pOperator->pTaskInfo->code = doColsMerge(pOperator, &pBlock); + return pBlock; +} + +int32_t doColsMerge(SOperatorInfo* pOperator, SSDataBlock** pResBlock) { + QRY_OPTR_CHECK(pResBlock); + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SMultiwayMergeOperatorInfo* pInfo = pOperator->info; SSDataBlock* pBlock = NULL; SColsMergeInfo* pColsMerge = &pInfo->colsMergeInfo; int32_t nullBlkNum = 0; + int32_t code = 0; qDebug("start to merge columns, %s", GET_TASKID(pTaskInfo)); @@ -359,18 +460,21 @@ SSDataBlock* doColsMerge(SOperatorInfo* pOperator) { nullBlkNum++; } - copyColumnsValue(pColsMerge->pTargets, pColsMerge->srcBlkIds[i], pInfo->binfo.pRes, pBlock); + code = copyColumnsValue(pColsMerge->pTargets, pColsMerge->srcBlkIds[i], pInfo->binfo.pRes, pBlock); + if (code) { + return code; + } } setOperatorCompleted(pOperator); - if (2 == nullBlkNum) { - return NULL; + return code; } pInfo->binfo.pRes->info.rows = 1; + *pResBlock = pInfo->binfo.pRes; - return pInfo->binfo.pRes; + return code; } void destroyColsMergeOperatorInfo(void* param) { @@ -383,9 +487,9 @@ int32_t getColsMergeExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplain, u SOperatorFpSet gMultiwayMergeFps[MERGE_TYPE_MAX_VALUE] = { {0}, - {._openFn = openSortMergeOperator, .getNextFn = doSortMerge, .closeFn = destroySortMergeOperatorInfo, .getExplainFn = getSortMergeExplainExecInfo}, - {._openFn = openNonSortMergeOperator, .getNextFn = doNonSortMerge, .closeFn = destroyNonSortMergeOperatorInfo, .getExplainFn = getNonSortMergeExplainExecInfo}, - {._openFn = openColsMergeOperator, .getNextFn = doColsMerge, .closeFn = destroyColsMergeOperatorInfo, .getExplainFn = getColsMergeExplainExecInfo}, + {._openFn = openSortMergeOperator, .getNextFn = doSortMerge1, .closeFn = destroySortMergeOperatorInfo, .getExplainFn = getSortMergeExplainExecInfo}, + {._openFn = openNonSortMergeOperator, .getNextFn = doNonSortMerge1, .closeFn = destroyNonSortMergeOperatorInfo, .getExplainFn = getNonSortMergeExplainExecInfo}, + {._openFn = openColsMergeOperator, .getNextFn = doColsMerge1, .closeFn = destroyColsMergeOperatorInfo, .getExplainFn = getColsMergeExplainExecInfo}, }; @@ -464,15 +568,16 @@ int32_t getMultiwayMergeExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplai return code; } -SOperatorInfo* createMultiwayMergeOperatorInfo(SOperatorInfo** downStreams, size_t numStreams, - SMergePhysiNode* pMergePhyNode, SExecTaskInfo* pTaskInfo) { - SPhysiNode* pPhyNode = (SPhysiNode*)pMergePhyNode; +int32_t createMultiwayMergeOperatorInfo(SOperatorInfo** downStreams, size_t numStreams, SMergePhysiNode* pMergePhyNode, + SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + SPhysiNode* pPhyNode = (SPhysiNode*)pMergePhyNode; + int32_t lino = 0; + int32_t code = TSDB_CODE_SUCCESS; SMultiwayMergeOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SMultiwayMergeOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); SDataBlockDescNode* pDescNode = pPhyNode->pOutputDataBlockDesc; - - int32_t code = TSDB_CODE_SUCCESS; if (pInfo == NULL || pOperator == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; goto _error; @@ -490,19 +595,21 @@ SOperatorInfo* createMultiwayMergeOperatorInfo(SOperatorInfo** downStreams, size SSortMergeInfo* pSortMergeInfo = &pInfo->sortMergeInfo; initLimitInfo(pMergePhyNode->node.pLimit, pMergePhyNode->node.pSlimit, &pInfo->limitInfo); pInfo->binfo.pRes = createDataBlockFromDescNode(pDescNode); - + SPhysiNode* pChildNode = (SPhysiNode*)nodesListGetNode(pPhyNode->pChildren, 0); SSDataBlock* pInputBlock = createDataBlockFromDescNode(pChildNode->pOutputDataBlockDesc); - - initResultSizeInfo(&pOperator->resultInfo, 1024); - blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); - size_t numOfCols = taosArrayGetSize(pInfo->binfo.pRes->pDataBlock); + initResultSizeInfo(&pOperator->resultInfo, 1024); + code = blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); + TSDB_CHECK_CODE(code, lino, _error); + + size_t numOfCols = taosArrayGetSize(pInfo->binfo.pRes->pDataBlock); int32_t rowSize = pInfo->binfo.pRes->info.rowSize; int32_t numOfOutputCols = 0; pSortMergeInfo->pSortInfo = createSortInfo(pMergePhyNode->pMergeKeys); pSortMergeInfo->bufPageSize = getProperSortPageSize(rowSize, numOfCols); - pSortMergeInfo->sortBufSize = pSortMergeInfo->bufPageSize * (numStreams + 1); // one additional is reserved for merged result. + pSortMergeInfo->sortBufSize = + pSortMergeInfo->bufPageSize * (numStreams + 1); // one additional is reserved for merged result. pSortMergeInfo->pInputBlock = pInputBlock; code = extractColMatchInfo(pMergePhyNode->pTargets, pDescNode, &numOfOutputCols, COL_MATCH_FROM_SLOT_ID, &pSortMergeInfo->matchInfo); @@ -515,14 +622,17 @@ SOperatorInfo* createMultiwayMergeOperatorInfo(SOperatorInfo** downStreams, size SNonSortMergeInfo* pNonSortMerge = &pInfo->nsortMergeInfo; pInfo->binfo.pRes = createDataBlockFromDescNode(pDescNode); initResultSizeInfo(&pOperator->resultInfo, 1024); - blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); + TSDB_CHECK_CODE(code, lino, _error); + break; } case MERGE_TYPE_COLUMNS: { SColsMergeInfo* pColsMerge = &pInfo->colsMergeInfo; pInfo->binfo.pRes = createDataBlockFromDescNode(pDescNode); initResultSizeInfo(&pOperator->resultInfo, 1); - blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); + TSDB_CHECK_CODE(code, lino, _error); pColsMerge->pTargets = pMergePhyNode->pTargets; pColsMerge->srcBlkIds[0] = getOperatorResultBlockId(downStreams[0], 0); @@ -535,15 +645,19 @@ SOperatorInfo* createMultiwayMergeOperatorInfo(SOperatorInfo** downStreams, size goto _error; } - setOperatorInfo(pOperator, "MultiwayMergeOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE, false, OP_NOT_OPENED, pInfo, pTaskInfo); - pOperator->fpSet = createOperatorFpSet(openMultiwayMergeOperator, doMultiwayMerge, NULL, - destroyMultiwayMergeOperatorInfo, optrDefaultBufFn, getMultiwayMergeExplainExecInfo, optrDefaultGetNextExtFn, NULL); + setOperatorInfo(pOperator, "MultiwayMergeOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE, false, OP_NOT_OPENED, pInfo, + pTaskInfo); + pOperator->fpSet = + createOperatorFpSet(openMultiwayMergeOperator, doMultiwayMerge, NULL, destroyMultiwayMergeOperatorInfo, + optrDefaultBufFn, getMultiwayMergeExplainExecInfo, optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, downStreams, numStreams); if (code != TSDB_CODE_SUCCESS) { goto _error; } - return pOperator; + + *pOptrInfo = pOperator; + return code; _error: if (pInfo != NULL) { @@ -552,5 +666,5 @@ _error: pTaskInfo->code = code; taosMemoryFree(pOperator); - return NULL; + return code; } diff --git a/source/libs/executor/src/operator.c b/source/libs/executor/src/operator.c index 494794f8c2..9b85f53494 100644 --- a/source/libs/executor/src/operator.c +++ b/source/libs/executor/src/operator.c @@ -131,7 +131,7 @@ void releaseQueryBuf(size_t numOfTables) { int64_t t = getQuerySupportBufSize(numOfTables); // restore value is not enough buffer available - atomic_add_fetch_64(&tsQueryBufferSizeBytes, t); + (void) atomic_add_fetch_64(&tsQueryBufferSizeBytes, t); } typedef enum { @@ -177,21 +177,20 @@ ERetType extractOperatorInfo(SOperatorInfo* pOperator, STraverParam* pParam, con } // QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN -SOperatorInfo* extractOperatorInTree(SOperatorInfo* pOperator, int32_t type, const char* id) { +int32_t extractOperatorInTree(SOperatorInfo* pOperator, int32_t type, const char* id, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + if (pOperator == NULL) { qError("invalid operator, failed to find tableScanOperator %s", id); - terrno = TSDB_CODE_PAR_INTERNAL_ERROR; - return NULL; + return TSDB_CODE_PAR_INTERNAL_ERROR; } STraverParam p = {.pParam = &type, .pRet = NULL}; traverseOperatorTree(pOperator, extractOperatorInfo, &p, id); - if (p.code != 0) { - terrno = p.code; - return NULL; - } else { - return p.pRet; + if (p.code == 0) { + *pOptrInfo = p.pRet; } + return p.code; } typedef struct SExtScanInfo { @@ -274,10 +273,15 @@ int32_t stopTableScanOperator(SOperatorInfo* pOperator, const char* pIdStr, SSto return p.code; } -SOperatorInfo* createOperator(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, SNode* pTagCond, - SNode* pTagIndexCond, const char* pUser, const char* dbname) { +int32_t createOperator(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, SNode* pTagCond, + SNode* pTagIndexCond, const char* pUser, const char* dbname, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + + int32_t code = 0; int32_t type = nodeType(pPhyNode); const char* idstr = GET_TASKID(pTaskInfo); + + if (pPhyNode->pChildren == NULL || LIST_LENGTH(pPhyNode->pChildren) == 0) { SOperatorInfo* pOperator = NULL; if (QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN == type) { @@ -290,11 +294,11 @@ SOperatorInfo* createOperator(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SR STableListInfo* pTableListInfo = tableListCreate(); - int32_t code = initQueriedTableSchemaInfo(pHandle, &pTableScanNode->scan, dbname, pTaskInfo); + code = initQueriedTableSchemaInfo(pHandle, &pTableScanNode->scan, dbname, pTaskInfo); if (code) { pTaskInfo->code = code; tableListDestroy(pTableListInfo); - return NULL; + return code; } if (pTableScanNode->scan.node.dynamicOp) { @@ -308,15 +312,15 @@ SOperatorInfo* createOperator(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SR pTaskInfo->code = code; tableListDestroy(pTableListInfo); qError("failed to createScanTableListInfo, code:%s, %s", tstrerror(code), idstr); - return NULL; + return code; } } - pOperator = createTableScanOperatorInfo(pTableScanNode, pHandle, pTableListInfo, pTaskInfo); - if (NULL == pOperator) { - pTaskInfo->code = terrno; + code = createTableScanOperatorInfo(pTableScanNode, pHandle, pTableListInfo, pTaskInfo, &pOperator); + if (NULL == pOperator || code != 0) { + pTaskInfo->code = code; tableListDestroy(pTableListInfo); - return NULL; + return code; } STableScanInfo* pScanInfo = pOperator->info; @@ -325,232 +329,245 @@ SOperatorInfo* createOperator(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SR STableMergeScanPhysiNode* pTableScanNode = (STableMergeScanPhysiNode*)pPhyNode; STableListInfo* pTableListInfo = tableListCreate(); - int32_t code = createScanTableListInfo(&pTableScanNode->scan, pTableScanNode->pGroupTags, true, pHandle, + code = createScanTableListInfo(&pTableScanNode->scan, pTableScanNode->pGroupTags, true, pHandle, pTableListInfo, pTagCond, pTagIndexCond, pTaskInfo); if (code) { pTaskInfo->code = code; tableListDestroy(pTableListInfo); qError("failed to createScanTableListInfo, code: %s", tstrerror(code)); - return NULL; + return code; } code = initQueriedTableSchemaInfo(pHandle, &pTableScanNode->scan, dbname, pTaskInfo); if (code) { - pTaskInfo->code = terrno; + pTaskInfo->code = code; tableListDestroy(pTableListInfo); - return NULL; + return code; } - pOperator = createTableMergeScanOperatorInfo(pTableScanNode, pHandle, pTableListInfo, pTaskInfo); - if (NULL == pOperator) { - pTaskInfo->code = terrno; + code = createTableMergeScanOperatorInfo(pTableScanNode, pHandle, pTableListInfo, pTaskInfo, &pOperator); + if (NULL == pOperator || code != 0) { + pTaskInfo->code = code; tableListDestroy(pTableListInfo); - return NULL; + return code; } STableScanInfo* pScanInfo = pOperator->info; pTaskInfo->cost.pRecoder = &pScanInfo->base.readRecorder; } else if (QUERY_NODE_PHYSICAL_PLAN_EXCHANGE == type) { - pOperator = createExchangeOperatorInfo(pHandle ? pHandle->pMsgCb->clientRpc : NULL, (SExchangePhysiNode*)pPhyNode, - pTaskInfo); + code = createExchangeOperatorInfo(pHandle ? pHandle->pMsgCb->clientRpc : NULL, (SExchangePhysiNode*)pPhyNode, + pTaskInfo, &pOperator); } else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN == type) { STableScanPhysiNode* pTableScanNode = (STableScanPhysiNode*)pPhyNode; STableListInfo* pTableListInfo = tableListCreate(); if (pHandle->vnode) { - int32_t code = - createScanTableListInfo(&pTableScanNode->scan, pTableScanNode->pGroupTags, pTableScanNode->groupSort, - pHandle, pTableListInfo, pTagCond, pTagIndexCond, pTaskInfo); + code = createScanTableListInfo(&pTableScanNode->scan, pTableScanNode->pGroupTags, pTableScanNode->groupSort, + pHandle, pTableListInfo, pTagCond, pTagIndexCond, pTaskInfo); if (code) { pTaskInfo->code = code; tableListDestroy(pTableListInfo); qError("failed to createScanTableListInfo, code: %s", tstrerror(code)); - return NULL; + return code; } } //pTaskInfo->schemaInfo.qsw = extractQueriedColumnSchema(&pTableScanNode->scan); - pOperator = createStreamScanOperatorInfo(pHandle, pTableScanNode, pTagCond, pTableListInfo, pTaskInfo); + code = createStreamScanOperatorInfo(pHandle, pTableScanNode, pTagCond, pTableListInfo, pTaskInfo, &pOperator); } else if (QUERY_NODE_PHYSICAL_PLAN_SYSTABLE_SCAN == type) { SSystemTableScanPhysiNode* pSysScanPhyNode = (SSystemTableScanPhysiNode*)pPhyNode; - pOperator = createSysTableScanOperatorInfo(pHandle, pSysScanPhyNode, pUser, pTaskInfo); + code = createSysTableScanOperatorInfo(pHandle, pSysScanPhyNode, pUser, pTaskInfo, &pOperator); } else if (QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN == type) { STableCountScanPhysiNode* pTblCountScanNode = (STableCountScanPhysiNode*)pPhyNode; - pOperator = createTableCountScanOperatorInfo(pHandle, pTblCountScanNode, pTaskInfo); + code = createTableCountScanOperatorInfo(pHandle, pTblCountScanNode, pTaskInfo, &pOperator); } else if (QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN == type) { STagScanPhysiNode* pTagScanPhyNode = (STagScanPhysiNode*)pPhyNode; STableListInfo* pTableListInfo = tableListCreate(); if (!pTagScanPhyNode->onlyMetaCtbIdx) { - int32_t code = createScanTableListInfo((SScanPhysiNode*)pTagScanPhyNode, NULL, false, pHandle, pTableListInfo, pTagCond, + code = createScanTableListInfo((SScanPhysiNode*)pTagScanPhyNode, NULL, false, pHandle, pTableListInfo, pTagCond, pTagIndexCond, pTaskInfo); if (code != TSDB_CODE_SUCCESS) { pTaskInfo->code = code; qError("failed to getTableList, code: %s", tstrerror(code)); - return NULL; + return code; } } - pOperator = createTagScanOperatorInfo(pHandle, pTagScanPhyNode, pTableListInfo, pTagCond, pTagIndexCond, pTaskInfo); + code = createTagScanOperatorInfo(pHandle, pTagScanPhyNode, pTableListInfo, pTagCond, pTagIndexCond, pTaskInfo, &pOperator); } else if (QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN == type) { SBlockDistScanPhysiNode* pBlockNode = (SBlockDistScanPhysiNode*)pPhyNode; STableListInfo* pTableListInfo = tableListCreate(); if (pBlockNode->tableType == TSDB_SUPER_TABLE) { SArray* pList = taosArrayInit(4, sizeof(uint64_t)); - int32_t code = pTaskInfo->storageAPI.metaFn.getChildTableList(pHandle->vnode, pBlockNode->uid, pList); + code = pTaskInfo->storageAPI.metaFn.getChildTableList(pHandle->vnode, pBlockNode->uid, pList); if (code != TSDB_CODE_SUCCESS) { pTaskInfo->code = code; taosArrayDestroy(pList); - return NULL; + return code; } size_t num = taosArrayGetSize(pList); for (int32_t i = 0; i < num; ++i) { uint64_t* id = taosArrayGet(pList, i); - tableListAddTableInfo(pTableListInfo, *id, 0); + if (id == NULL) { + pTaskInfo->code = terrno; + return terrno; + } + + code = tableListAddTableInfo(pTableListInfo, *id, 0); + if (code) { + pTaskInfo->code = code; + return code; + } } taosArrayDestroy(pList); } else { // Create group with only one table - tableListAddTableInfo(pTableListInfo, pBlockNode->uid, 0); + code = tableListAddTableInfo(pTableListInfo, pBlockNode->uid, 0); + if (code) { + pTaskInfo->code = code; + return code; + } } - pOperator = createDataBlockInfoScanOperator(pHandle, pBlockNode, pTableListInfo, pTaskInfo); + code = createDataBlockInfoScanOperator(pHandle, pBlockNode, pTableListInfo, pTaskInfo, &pOperator); } else if (QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN == type) { SLastRowScanPhysiNode* pScanNode = (SLastRowScanPhysiNode*)pPhyNode; STableListInfo* pTableListInfo = tableListCreate(); - int32_t code = createScanTableListInfo(&pScanNode->scan, pScanNode->pGroupTags, true, pHandle, pTableListInfo, + code = createScanTableListInfo(&pScanNode->scan, pScanNode->pGroupTags, true, pHandle, pTableListInfo, pTagCond, pTagIndexCond, pTaskInfo); if (code != TSDB_CODE_SUCCESS) { pTaskInfo->code = code; - return NULL; + return code; } code = initQueriedTableSchemaInfo(pHandle, &pScanNode->scan, dbname, pTaskInfo); if (code != TSDB_CODE_SUCCESS) { pTaskInfo->code = code; - return NULL; + return code; } - pOperator = createCacherowsScanOperator(pScanNode, pHandle, pTableListInfo, pTaskInfo); + code = createCacherowsScanOperator(pScanNode, pHandle, pTableListInfo, pTaskInfo, &pOperator); } else if (QUERY_NODE_PHYSICAL_PLAN_PROJECT == type) { - pOperator = createProjectOperatorInfo(NULL, (SProjectPhysiNode*)pPhyNode, pTaskInfo); + code = createProjectOperatorInfo(NULL, (SProjectPhysiNode*)pPhyNode, pTaskInfo, &pOperator); } else { - terrno = TSDB_CODE_INVALID_PARA; - pTaskInfo->code = terrno; - return NULL; + code = TSDB_CODE_INVALID_PARA; + pTaskInfo->code = code; + return code; } if (pOperator != NULL) { // todo moved away pOperator->resultDataBlockId = pPhyNode->pOutputDataBlockDesc->dataBlockId; } - return pOperator; + *pOptrInfo = pOperator; + return code; } size_t size = LIST_LENGTH(pPhyNode->pChildren); SOperatorInfo** ops = taosMemoryCalloc(size, POINTER_BYTES); if (ops == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - pTaskInfo->code = terrno; - return NULL; + code = terrno; + pTaskInfo->code = code; + return code; } for (int32_t i = 0; i < size; ++i) { SPhysiNode* pChildNode = (SPhysiNode*)nodesListGetNode(pPhyNode->pChildren, i); - ops[i] = createOperator(pChildNode, pTaskInfo, pHandle, pTagCond, pTagIndexCond, pUser, dbname); - if (ops[i] == NULL) { + code = createOperator(pChildNode, pTaskInfo, pHandle, pTagCond, pTagIndexCond, pUser, dbname, &ops[i]); + if (ops[i] == NULL || code != 0) { taosMemoryFree(ops); - return NULL; + return code; } } SOperatorInfo* pOptr = NULL; if (QUERY_NODE_PHYSICAL_PLAN_PROJECT == type) { - pOptr = createProjectOperatorInfo(ops[0], (SProjectPhysiNode*)pPhyNode, pTaskInfo); + code = createProjectOperatorInfo(ops[0], (SProjectPhysiNode*)pPhyNode, pTaskInfo, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_HASH_AGG == type) { SAggPhysiNode* pAggNode = (SAggPhysiNode*)pPhyNode; if (pAggNode->pGroupKeys != NULL) { - pOptr = createGroupOperatorInfo(ops[0], pAggNode, pTaskInfo); + code = createGroupOperatorInfo(ops[0], pAggNode, pTaskInfo, &pOptr); } else { - pOptr = createAggregateOperatorInfo(ops[0], pAggNode, pTaskInfo); + code = createAggregateOperatorInfo(ops[0], pAggNode, pTaskInfo, &pOptr); } } else if (QUERY_NODE_PHYSICAL_PLAN_HASH_INTERVAL == type) { SIntervalPhysiNode* pIntervalPhyNode = (SIntervalPhysiNode*)pPhyNode; - pOptr = createIntervalOperatorInfo(ops[0], pIntervalPhyNode, pTaskInfo); + code = createIntervalOperatorInfo(ops[0], pIntervalPhyNode, pTaskInfo, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL == type) { - pOptr = createStreamIntervalOperatorInfo(ops[0], pPhyNode, pTaskInfo, pHandle); + code = createStreamIntervalOperatorInfo(ops[0], pPhyNode, pTaskInfo, pHandle, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL == type) { SMergeAlignedIntervalPhysiNode* pIntervalPhyNode = (SMergeAlignedIntervalPhysiNode*)pPhyNode; - pOptr = createMergeAlignedIntervalOperatorInfo(ops[0], pIntervalPhyNode, pTaskInfo); + code = createMergeAlignedIntervalOperatorInfo(ops[0], pIntervalPhyNode, pTaskInfo, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_MERGE_INTERVAL == type) { SMergeIntervalPhysiNode* pIntervalPhyNode = (SMergeIntervalPhysiNode*)pPhyNode; - pOptr = createMergeIntervalOperatorInfo(ops[0], pIntervalPhyNode, pTaskInfo); + code = createMergeIntervalOperatorInfo(ops[0], pIntervalPhyNode, pTaskInfo, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL == type) { int32_t children = 0; - pOptr = createStreamFinalIntervalOperatorInfo(ops[0], pPhyNode, pTaskInfo, children, pHandle); + code = createStreamFinalIntervalOperatorInfo(ops[0], pPhyNode, pTaskInfo, children, pHandle, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL == type) { int32_t children = pHandle->numOfVgroups; - pOptr = createStreamFinalIntervalOperatorInfo(ops[0], pPhyNode, pTaskInfo, children, pHandle); + code = createStreamFinalIntervalOperatorInfo(ops[0], pPhyNode, pTaskInfo, children, pHandle, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL == type) { int32_t children = pHandle->numOfVgroups; - pOptr = createStreamFinalIntervalOperatorInfo(ops[0], pPhyNode, pTaskInfo, children, pHandle); + code = createStreamFinalIntervalOperatorInfo(ops[0], pPhyNode, pTaskInfo, children, pHandle, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_SORT == type) { - pOptr = createSortOperatorInfo(ops[0], (SSortPhysiNode*)pPhyNode, pTaskInfo); + code = createSortOperatorInfo(ops[0], (SSortPhysiNode*)pPhyNode, pTaskInfo, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT == type) { - pOptr = createGroupSortOperatorInfo(ops[0], (SGroupSortPhysiNode*)pPhyNode, pTaskInfo); + code = createGroupSortOperatorInfo(ops[0], (SGroupSortPhysiNode*)pPhyNode, pTaskInfo, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_MERGE == type) { SMergePhysiNode* pMergePhyNode = (SMergePhysiNode*)pPhyNode; - pOptr = createMultiwayMergeOperatorInfo(ops, size, pMergePhyNode, pTaskInfo); + code = createMultiwayMergeOperatorInfo(ops, size, pMergePhyNode, pTaskInfo, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_MERGE_SESSION == type) { SSessionWinodwPhysiNode* pSessionNode = (SSessionWinodwPhysiNode*)pPhyNode; - pOptr = createSessionAggOperatorInfo(ops[0], pSessionNode, pTaskInfo); + code = createSessionAggOperatorInfo(ops[0], pSessionNode, pTaskInfo, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_SESSION == type) { - pOptr = createStreamSessionAggOperatorInfo(ops[0], pPhyNode, pTaskInfo, pHandle); + code = createStreamSessionAggOperatorInfo(ops[0], pPhyNode, pTaskInfo, pHandle, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION == type) { int32_t children = 0; - pOptr = createStreamFinalSessionAggOperatorInfo(ops[0], pPhyNode, pTaskInfo, children, pHandle); + code = createStreamFinalSessionAggOperatorInfo(ops[0], pPhyNode, pTaskInfo, children, pHandle, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION == type) { int32_t children = pHandle->numOfVgroups; - pOptr = createStreamFinalSessionAggOperatorInfo(ops[0], pPhyNode, pTaskInfo, children, pHandle); + code = createStreamFinalSessionAggOperatorInfo(ops[0], pPhyNode, pTaskInfo, children, pHandle, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_PARTITION == type) { - pOptr = createPartitionOperatorInfo(ops[0], (SPartitionPhysiNode*)pPhyNode, pTaskInfo); + code = createPartitionOperatorInfo(ops[0], (SPartitionPhysiNode*)pPhyNode, pTaskInfo, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_PARTITION == type) { - pOptr = createStreamPartitionOperatorInfo(ops[0], (SStreamPartitionPhysiNode*)pPhyNode, pTaskInfo); + code = createStreamPartitionOperatorInfo(ops[0], (SStreamPartitionPhysiNode*)pPhyNode, pTaskInfo, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_MERGE_STATE == type) { SStateWinodwPhysiNode* pStateNode = (SStateWinodwPhysiNode*)pPhyNode; - pOptr = createStatewindowOperatorInfo(ops[0], pStateNode, pTaskInfo); + code = createStatewindowOperatorInfo(ops[0], pStateNode, pTaskInfo, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE == type) { - pOptr = createStreamStateAggOperatorInfo(ops[0], pPhyNode, pTaskInfo, pHandle); + code = createStreamStateAggOperatorInfo(ops[0], pPhyNode, pTaskInfo, pHandle, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT == type) { - pOptr = createStreamEventAggOperatorInfo(ops[0], pPhyNode, pTaskInfo, pHandle); + code = createStreamEventAggOperatorInfo(ops[0], pPhyNode, pTaskInfo, pHandle, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_MERGE_JOIN == type) { - pOptr = createMergeJoinOperatorInfo(ops, size, (SSortMergeJoinPhysiNode*)pPhyNode, pTaskInfo); + code = createMergeJoinOperatorInfo(ops, size, (SSortMergeJoinPhysiNode*)pPhyNode, pTaskInfo, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_HASH_JOIN == type) { - pOptr = createHashJoinOperatorInfo(ops, size, (SHashJoinPhysiNode*)pPhyNode, pTaskInfo); + code = createHashJoinOperatorInfo(ops, size, (SHashJoinPhysiNode*)pPhyNode, pTaskInfo, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_FILL == type) { - pOptr = createFillOperatorInfo(ops[0], (SFillPhysiNode*)pPhyNode, pTaskInfo); + code = createFillOperatorInfo(ops[0], (SFillPhysiNode*)pPhyNode, pTaskInfo, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL == type) { - pOptr = createStreamFillOperatorInfo(ops[0], (SStreamFillPhysiNode*)pPhyNode, pTaskInfo); + code = createStreamFillOperatorInfo(ops[0], (SStreamFillPhysiNode*)pPhyNode, pTaskInfo, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC == type) { - pOptr = createIndefinitOutputOperatorInfo(ops[0], pPhyNode, pTaskInfo); + code = createIndefinitOutputOperatorInfo(ops[0], pPhyNode, pTaskInfo, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC == type) { - pOptr = createTimeSliceOperatorInfo(ops[0], pPhyNode, pTaskInfo); + code = createTimeSliceOperatorInfo(ops[0], pPhyNode, pTaskInfo, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_MERGE_EVENT == type) { - pOptr = createEventwindowOperatorInfo(ops[0], pPhyNode, pTaskInfo); + code = createEventwindowOperatorInfo(ops[0], pPhyNode, pTaskInfo, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_GROUP_CACHE == type) { - pOptr = createGroupCacheOperatorInfo(ops, size, (SGroupCachePhysiNode*)pPhyNode, pTaskInfo); + code = createGroupCacheOperatorInfo(ops, size, (SGroupCachePhysiNode*)pPhyNode, pTaskInfo, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_DYN_QUERY_CTRL == type) { - pOptr = createDynQueryCtrlOperatorInfo(ops, size, (SDynQueryCtrlPhysiNode*)pPhyNode, pTaskInfo); + code = createDynQueryCtrlOperatorInfo(ops, size, (SDynQueryCtrlPhysiNode*)pPhyNode, pTaskInfo, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_STREAM_COUNT == type) { - pOptr = createStreamCountAggOperatorInfo(ops[0], pPhyNode, pTaskInfo, pHandle); + code = createStreamCountAggOperatorInfo(ops[0], pPhyNode, pTaskInfo, pHandle, &pOptr); } else if (QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT == type) { - pOptr = createCountwindowOperatorInfo(ops[0], pPhyNode, pTaskInfo); + code = createCountwindowOperatorInfo(ops[0], pPhyNode, pTaskInfo, &pOptr); } else { - terrno = TSDB_CODE_INVALID_PARA; - pTaskInfo->code = terrno; + code = TSDB_CODE_INVALID_PARA; + pTaskInfo->code = code; taosMemoryFree(ops); - return NULL; + return code; } taosMemoryFree(ops); @@ -558,7 +575,8 @@ SOperatorInfo* createOperator(SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SR pOptr->resultDataBlockId = pPhyNode->pOutputDataBlockDesc->dataBlockId; } - return pOptr; + *pOptrInfo = pOptr; + return code; } @@ -590,6 +608,9 @@ void destroyOperator(SOperatorInfo* pOperator) { int32_t getOperatorExplainExecInfo(SOperatorInfo* operatorInfo, SArray* pExecInfoList) { SExplainExecInfo execInfo = {0}; SExplainExecInfo* pExplainInfo = taosArrayPush(pExecInfoList, &execInfo); + if (pExplainInfo == NULL) { + return terrno; + } pExplainInfo->numOfRows = operatorInfo->resultInfo.totalRows; pExplainInfo->startupCost = operatorInfo->cost.openCost; @@ -632,31 +653,49 @@ int32_t mergeOperatorParams(SOperatorParam* pDst, SOperatorParam* pSrc) { if (pSExc->basic.vgId != pDExc->basic.vgId) { SExchangeOperatorBatchParam* pBatch = taosMemoryMalloc(sizeof(SExchangeOperatorBatchParam)); if (NULL == pBatch) { - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } + pBatch->multiParams = true; pBatch->pBatchs = tSimpleHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT)); if (NULL == pBatch->pBatchs) { taosMemoryFree(pBatch); - return TSDB_CODE_OUT_OF_MEMORY; + return terrno; } + tSimpleHashSetFreeFp(pBatch->pBatchs, freeExchangeGetBasicOperatorParam); - tSimpleHashPut(pBatch->pBatchs, &pDExc->basic.vgId, sizeof(pDExc->basic.vgId), &pDExc->basic, sizeof(pDExc->basic)); - tSimpleHashPut(pBatch->pBatchs, &pSExc->basic.vgId, sizeof(pSExc->basic.vgId), &pSExc->basic, sizeof(pSExc->basic)); + int32_t code = tSimpleHashPut(pBatch->pBatchs, &pDExc->basic.vgId, sizeof(pDExc->basic.vgId), &pDExc->basic, sizeof(pDExc->basic)); + if (code) { + return code; + } + + code = tSimpleHashPut(pBatch->pBatchs, &pSExc->basic.vgId, sizeof(pSExc->basic.vgId), &pSExc->basic, sizeof(pSExc->basic)); + if (code) { + return code; + } taosMemoryFree(pDst->value); pDst->value = pBatch; } else { - taosArrayAddAll(pDExc->basic.uidList, pSExc->basic.uidList); + void* p = taosArrayAddAll(pDExc->basic.uidList, pSExc->basic.uidList); + if (p == NULL) { + return terrno; + } } } else { SExchangeOperatorBatchParam* pBatch = pDst->value; SExchangeOperatorBasicParam* pBasic = tSimpleHashGet(pBatch->pBatchs, &pSExc->basic.vgId, sizeof(pSExc->basic.vgId)); if (pBasic) { - taosArrayAddAll(pBasic->uidList, pSExc->basic.uidList); + void* p = taosArrayAddAll(pBasic->uidList, pSExc->basic.uidList); + if (p == NULL) { + return terrno; + } } else { - tSimpleHashPut(pBatch->pBatchs, &pSExc->basic.vgId, sizeof(pSExc->basic.vgId), &pSExc->basic, sizeof(pSExc->basic)); + int32_t code = tSimpleHashPut(pBatch->pBatchs, &pSExc->basic.vgId, sizeof(pSExc->basic.vgId), &pSExc->basic, sizeof(pSExc->basic)); + if (code) { + return code; + } } } break; @@ -717,6 +756,10 @@ int32_t setOperatorParams(struct SOperatorInfo* pOperator, SOperatorParam* pInpu for (int32_t i = 0; i < childrenNum; ++i) { SOperatorParam* pChild = *(SOperatorParam**)taosArrayGet((*ppParam)->pChildren, i); + if (pChild == NULL) { + return terrno; + } + if ((*pppDownstramParam)[pChild->downstreamIdx]) { int32_t code = mergeOperatorParams((*pppDownstramParam)[pChild->downstreamIdx], pChild); if (code) { @@ -735,21 +778,28 @@ int32_t setOperatorParams(struct SOperatorInfo* pOperator, SOperatorParam* pInpu SSDataBlock* getNextBlockFromDownstream(struct SOperatorInfo* pOperator, int32_t idx) { - return getNextBlockFromDownstreamImpl(pOperator, idx, true); + SSDataBlock* p = NULL; + int32_t code = getNextBlockFromDownstreamImpl(pOperator, idx, true, &p); + return (code == 0)? p:NULL; } SSDataBlock* getNextBlockFromDownstreamRemain(struct SOperatorInfo* pOperator, int32_t idx) { - return getNextBlockFromDownstreamImpl(pOperator, idx, false); + SSDataBlock* p = NULL; + int32_t code = getNextBlockFromDownstreamImpl(pOperator, idx, false, &p); + return (code == 0)? p:NULL; } +int32_t optrDefaultGetNextExtFn(struct SOperatorInfo* pOperator, SOperatorParam* pParam, SSDataBlock** pRes) { + QRY_OPTR_CHECK(pRes); -SSDataBlock* optrDefaultGetNextExtFn(struct SOperatorInfo* pOperator, SOperatorParam* pParam) { int32_t code = setOperatorParams(pOperator, pParam, OP_GET_PARAM); if (TSDB_CODE_SUCCESS != code) { pOperator->pTaskInfo->code = code; T_LONG_JMP(pOperator->pTaskInfo->env, pOperator->pTaskInfo->code); } - return pOperator->fpSet.getNextFn(pOperator); + + *pRes = pOperator->fpSet.getNextFn(pOperator); + return code; } int32_t optrDefaultNotifyFn(struct SOperatorInfo* pOperator, SOperatorParam* pParam) { diff --git a/source/libs/executor/src/projectoperator.c b/source/libs/executor/src/projectoperator.c index 93901b6b33..cbc3d77faf 100644 --- a/source/libs/executor/src/projectoperator.c +++ b/source/libs/executor/src/projectoperator.c @@ -41,9 +41,11 @@ typedef struct SIndefOperatorInfo { } SIndefOperatorInfo; static int32_t doGenerateSourceData(SOperatorInfo* pOperator); -static SSDataBlock* doProjectOperation(SOperatorInfo* pOperator); -static SSDataBlock* doApplyIndefinitFunction(SOperatorInfo* pOperator); -static SArray* setRowTsColumnOutputInfo(SqlFunctionCtx* pCtx, int32_t numOfCols); +static SSDataBlock* doProjectOperation1(SOperatorInfo* pOperator); +static int32_t doProjectOperation(SOperatorInfo* pOperator, SSDataBlock** pResBlock); +static SSDataBlock* doApplyIndefinitFunction1(SOperatorInfo* pOperator); +static int32_t doApplyIndefinitFunction(SOperatorInfo* pOperator, SSDataBlock** pResBlock); +static int32_t setRowTsColumnOutputInfo(SqlFunctionCtx* pCtx, int32_t numOfCols, SArray** pResList); static int32_t setFunctionResultOutput(SOperatorInfo* pOperator, SOptrBasicInfo* pInfo, SAggSupporter* pSup, int32_t stage, int32_t numOfExprs); @@ -89,9 +91,11 @@ void streamOperatorReloadState(SOperatorInfo* pOperator) { } } -SOperatorInfo* createProjectOperatorInfo(SOperatorInfo* downstream, SProjectPhysiNode* pProjPhyNode, - SExecTaskInfo* pTaskInfo) { - int32_t code = TSDB_CODE_SUCCESS; +int32_t createProjectOperatorInfo(SOperatorInfo* downstream, SProjectPhysiNode* pProjPhyNode, SExecTaskInfo* pTaskInfo, + SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + + int32_t code = TSDB_CODE_SUCCESS; SProjectOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SProjectOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -102,6 +106,7 @@ SOperatorInfo* createProjectOperatorInfo(SOperatorInfo* downstream, SProjectPhys pOperator->exprSupp.hasWindowOrGroup = false; pOperator->pTaskInfo = pTaskInfo; + int32_t lino = 0; int32_t numOfCols = 0; SExprInfo* pExprInfo = createExprInfo(pProjPhyNode->pProjections, NULL, &numOfCols); @@ -114,7 +119,7 @@ SOperatorInfo* createProjectOperatorInfo(SOperatorInfo* downstream, SProjectPhys pInfo->binfo.outputTsOrder = pProjPhyNode->node.outputTsOrder; pInfo->inputIgnoreGroup = pProjPhyNode->inputIgnoreGroup; pInfo->outputIgnoreGroup = pProjPhyNode->ignoreGroupId; - + if (pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM || pTaskInfo->execModel == OPTR_EXEC_MODEL_QUEUE) { pInfo->mergeDataBlocks = false; } else { @@ -137,28 +142,23 @@ SOperatorInfo* createProjectOperatorInfo(SOperatorInfo* downstream, SProjectPhys initResultSizeInfo(&pOperator->resultInfo, numOfRows); 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; - } + TSDB_CHECK_CODE(code, lino, _error); initBasicInfo(&pInfo->binfo, pResBlock); code = setFunctionResultOutput(pOperator, &pInfo->binfo, &pInfo->aggSup, MAIN_SCAN, numOfCols); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + TSDB_CHECK_CODE(code, lino, _error); code = filterInitFromNode((SNode*)pProjPhyNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + TSDB_CHECK_CODE(code, lino, _error); - pInfo->pPseudoColInfo = setRowTsColumnOutputInfo(pOperator->exprSupp.pCtx, numOfCols); + code = setRowTsColumnOutputInfo(pOperator->exprSupp.pCtx, numOfCols, &pInfo->pPseudoColInfo); + TSDB_CHECK_CODE(code, lino, _error); setOperatorInfo(pOperator, "ProjectOperator", QUERY_NODE_PHYSICAL_PLAN_PROJECT, false, OP_NOT_OPENED, pInfo, pTaskInfo); - pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doProjectOperation, NULL, destroyProjectOperatorInfo, + pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doProjectOperation1, NULL, destroyProjectOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); - setOperatorStreamStateFn(pOperator, streamOperatorReleaseState, streamOperatorReloadState); + setOperatorStreamStateFn(pOperator, streamOperatorReleaseState, streamOperatorReloadState); if (NULL != downstream) { code = appendDownstream(pOperator, &downstream, 1); @@ -167,13 +167,14 @@ SOperatorInfo* createProjectOperatorInfo(SOperatorInfo* downstream, SProjectPhys } } - return pOperator; + *pOptrInfo = pOperator; + return code; _error: destroyProjectOperatorInfo(pInfo); taosMemoryFree(pOperator); pTaskInfo->code = code; - return NULL; + return code; } static int32_t discardGroupDataBlock(SSDataBlock* pBlock, SLimitInfo* pLimitInfo) { @@ -248,27 +249,27 @@ static int32_t doIngroupLimitOffset(SLimitInfo* pLimitInfo, uint64_t groupId, SS return PROJECT_RETRIEVE_DONE; } -SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) { +int32_t doProjectOperation(SOperatorInfo* pOperator, SSDataBlock** pResBlock) { + QRY_OPTR_CHECK(pResBlock); + SProjectOperatorInfo* pProjectInfo = pOperator->info; SOptrBasicInfo* pInfo = &pProjectInfo->binfo; SExprSupp* pSup = &pOperator->exprSupp; SSDataBlock* pRes = pInfo->pRes; SSDataBlock* pFinalRes = pProjectInfo->pFinalRes; + int32_t code = 0; + int64_t st = 0; + int32_t order = pInfo->inputTsOrder; + int32_t scanFlag = 0; blockDataCleanup(pFinalRes); - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; if (pOperator->status == OP_EXEC_DONE) { - return NULL; + return code; } - int64_t st = 0; - int32_t order = pInfo->inputTsOrder; - int32_t scanFlag = 0; - int32_t code = TSDB_CODE_SUCCESS; - if (pOperator->cost.openCost == 0) { st = taosGetTimestampUs(); } @@ -286,7 +287,8 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) { pRes->info.id.groupId = 0; } - return (pRes->info.rows > 0) ? pRes : NULL; + *pResBlock = (pRes->info.rows > 0)? pRes:NULL; + return code; } while (1) { @@ -309,7 +311,9 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) { if (pBlock->info.type == STREAM_RETRIEVE || pBlock->info.type == STREAM_DELETE_RESULT || pBlock->info.type == STREAM_DELETE_DATA || pBlock->info.type == STREAM_CREATE_CHILD_TABLE || pBlock->info.type == STREAM_CHECKPOINT) { - return pBlock; + + *pResBlock = pBlock; + return code; } if (pProjectInfo->inputIgnoreGroup) { @@ -321,7 +325,7 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) { continue; } - setInfoForNewGroup(pBlock, pLimitInfo, pOperator); + (void) setInfoForNewGroup(pBlock, pLimitInfo, pOperator); if (pOperator->status == OP_EXEC_DONE) { break; } @@ -332,8 +336,15 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) { pRes->info.scanFlag = scanFlag = pBlock->info.scanFlag; } - setInputDataBlock(pSup, pBlock, order, scanFlag, false); - blockDataEnsureCapacity(pInfo->pRes, pInfo->pRes->info.rows + pBlock->info.rows); + code = setInputDataBlock(pSup, pBlock, order, scanFlag, false); + if (code) { + T_LONG_JMP(pTaskInfo->env, code); + } + + code = blockDataEnsureCapacity(pInfo->pRes, pInfo->pRes->info.rows + pBlock->info.rows); + if (code != TSDB_CODE_SUCCESS) { + T_LONG_JMP(pTaskInfo->env, code); + } code = projectApplyFunctions(pSup->pExprInfo, pInfo->pRes, pBlock, pSup->pCtx, pSup->numOfExprs, pProjectInfo->pPseudoColInfo); @@ -355,14 +366,23 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) { pFinalRes->info.version = pRes->info.version; // continue merge data, ignore the group id - blockDataMerge(pFinalRes, pRes); + code = blockDataMerge(pFinalRes, pRes); + if (code) { + pTaskInfo->code = code; + return code; + } + if (pFinalRes->info.rows + pRes->info.rows <= pOperator->resultInfo.threshold && (pOperator->status != OP_EXEC_DONE)) { continue; } } // do apply filter - doFilter(pFinalRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pFinalRes, pOperator->exprSupp.pFilterInfo, NULL); + if (code) { + pTaskInfo->code = code; + return code; + } // when apply the limit/offset for each group, pRes->info.rows may be 0, due to limit constraint. if (pFinalRes->info.rows > 0 || (pOperator->status == OP_EXEC_DONE)) { @@ -372,7 +392,12 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) { } else { // do apply filter if (pRes->info.rows > 0) { - doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + if (code) { + pTaskInfo->code = code; + return code; + } + if (pRes->info.rows == 0) { continue; } @@ -399,14 +424,32 @@ SSDataBlock* doProjectOperation(SOperatorInfo* pOperator) { printDataBlock(p, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo)); } - return (p->info.rows > 0) ? p : NULL; + *pResBlock = (p->info.rows > 0)? p:NULL; + return code; } -SOperatorInfo* createIndefinitOutputOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pNode, - SExecTaskInfo* pTaskInfo) { +SSDataBlock* doProjectOperation1(SOperatorInfo* pOperator) { + SSDataBlock* pRes = NULL; + int32_t code = doProjectOperation(pOperator, &pRes); + if (code && pOperator->pTaskInfo->code == 0) { + pOperator->pTaskInfo->code = code; + } + + return pRes; +} + +int32_t createIndefinitOutputOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pNode, + SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + int32_t code = 0; + int32_t lino = 0; + int32_t numOfRows = 4096; + size_t keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES; + SIndefOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SIndefOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } @@ -423,7 +466,7 @@ SOperatorInfo* createIndefinitOutputOperatorInfo(SOperatorInfo* downstream, SPhy if (pPhyNode->pExprs != NULL) { int32_t num = 0; SExprInfo* pSExpr = createExprInfo(pPhyNode->pExprs, NULL, &num); - int32_t code = initExprSupp(&pInfo->scalarSup, pSExpr, num, &pTaskInfo->storageAPI.functionStore); + code = initExprSupp(&pInfo->scalarSup, pSExpr, num, &pTaskInfo->storageAPI.functionStore); if (code != TSDB_CODE_SUCCESS) { goto _error; } @@ -431,9 +474,6 @@ SOperatorInfo* createIndefinitOutputOperatorInfo(SOperatorInfo* downstream, SPhy SSDataBlock* pResBlock = createDataBlockFromDescNode(pPhyNode->node.pOutputDataBlockDesc); - int32_t numOfRows = 4096; - size_t keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES; - // Make sure the size of SSDataBlock will never exceed the size of 2MB. int32_t TWOMB = 2 * 1024 * 1024; if (numOfRows * pResBlock->info.rowSize > TWOMB) { @@ -442,32 +482,28 @@ SOperatorInfo* createIndefinitOutputOperatorInfo(SOperatorInfo* downstream, SPhy initBasicInfo(&pInfo->binfo, pResBlock); initResultSizeInfo(&pOperator->resultInfo, numOfRows); - blockDataEnsureCapacity(pResBlock, numOfRows); + code = blockDataEnsureCapacity(pResBlock, numOfRows); + TSDB_CHECK_CODE(code, lino, _error); - int32_t code = initAggSup(pSup, &pInfo->aggSup, pExprInfo, numOfExpr, keyBufSize, pTaskInfo->id.str, + code = initAggSup(pSup, &pInfo->aggSup, pExprInfo, numOfExpr, keyBufSize, pTaskInfo->id.str, pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + TSDB_CHECK_CODE(code, lino, _error); code = setFunctionResultOutput(pOperator, &pInfo->binfo, &pInfo->aggSup, MAIN_SCAN, numOfExpr); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + TSDB_CHECK_CODE(code, lino, _error); code = filterInitFromNode((SNode*)pPhyNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + TSDB_CHECK_CODE(code, lino, _error); pInfo->binfo.pRes = pResBlock; pInfo->binfo.inputTsOrder = pNode->inputTsOrder; pInfo->binfo.outputTsOrder = pNode->outputTsOrder; - pInfo->pPseudoColInfo = setRowTsColumnOutputInfo(pSup->pCtx, numOfExpr); + code = setRowTsColumnOutputInfo(pSup->pCtx, numOfExpr, &pInfo->pPseudoColInfo); + TSDB_CHECK_CODE(code, lino, _error); setOperatorInfo(pOperator, "IndefinitOperator", QUERY_NODE_PHYSICAL_PLAN_INDEF_ROWS_FUNC, false, OP_NOT_OPENED, pInfo, pTaskInfo); - pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doApplyIndefinitFunction, NULL, destroyIndefinitOperatorInfo, + pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doApplyIndefinitFunction1, NULL, destroyIndefinitOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); @@ -475,13 +511,14 @@ SOperatorInfo* createIndefinitOutputOperatorInfo(SOperatorInfo* downstream, SPhy goto _error; } - return pOperator; + *pOptrInfo = pOperator; + return code; _error: destroyIndefinitOperatorInfo(pInfo); taosMemoryFree(pOperator); pTaskInfo->code = code; - return NULL; + return code; } static void doHandleDataBlock(SOperatorInfo* pOperator, SSDataBlock* pBlock, SOperatorInfo* downstream, @@ -504,8 +541,15 @@ static void doHandleDataBlock(SOperatorInfo* pOperator, SSDataBlock* pBlock, SOp } } - setInputDataBlock(pSup, pBlock, order, scanFlag, false); - blockDataEnsureCapacity(pInfo->pRes, pInfo->pRes->info.rows + pBlock->info.rows); + code = setInputDataBlock(pSup, pBlock, order, scanFlag, false); + if (code) { + T_LONG_JMP(pTaskInfo->env, code); + } + + code = blockDataEnsureCapacity(pInfo->pRes, pInfo->pRes->info.rows + pBlock->info.rows); + if (code != TSDB_CODE_SUCCESS) { + T_LONG_JMP(pTaskInfo->env, code); + } code = projectApplyFunctions(pSup->pExprInfo, pInfo->pRes, pBlock, pSup->pCtx, pSup->numOfExprs, pIndefInfo->pPseudoColInfo); @@ -514,21 +558,29 @@ static void doHandleDataBlock(SOperatorInfo* pOperator, SSDataBlock* pBlock, SOp } } -SSDataBlock* doApplyIndefinitFunction(SOperatorInfo* pOperator) { +SSDataBlock* doApplyIndefinitFunction1(SOperatorInfo* pOperator) { + SSDataBlock* pResBlock = NULL; + pOperator->pTaskInfo->code = doApplyIndefinitFunction(pOperator, &pResBlock); + return pResBlock; +} + +int32_t doApplyIndefinitFunction(SOperatorInfo* pOperator, SSDataBlock** pResBlock) { + QRY_OPTR_CHECK(pResBlock); + SIndefOperatorInfo* pIndefInfo = pOperator->info; SOptrBasicInfo* pInfo = &pIndefInfo->binfo; SExprSupp* pSup = &pOperator->exprSupp; + int64_t st = 0; + int32_t code = 0; + SSDataBlock* pRes = pInfo->pRes; - SSDataBlock* pRes = pInfo->pRes; blockDataCleanup(pRes); SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; if (pOperator->status == OP_EXEC_DONE) { - return NULL; + return 0; } - int64_t st = 0; - if (pOperator->cost.openCost == 0) { st = taosGetTimestampUs(); } @@ -577,7 +629,12 @@ SSDataBlock* doApplyIndefinitFunction(SOperatorInfo* pOperator) { } } - doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + if (code) { + pTaskInfo->code = code; + return code; + } + size_t rows = pInfo->pRes->info.rows; if (rows > 0 || pOperator->status == OP_EXEC_DONE) { break; @@ -593,11 +650,11 @@ SSDataBlock* doApplyIndefinitFunction(SOperatorInfo* pOperator) { pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0; } - return (rows > 0) ? pInfo->pRes : NULL; + *pResBlock = (rows > 0) ? pInfo->pRes : NULL; + return code; } int32_t initCtxOutputBuffer(SqlFunctionCtx* pCtx, int32_t size) { - int32_t code = TSDB_CODE_SUCCESS; for (int32_t j = 0; j < size; ++j) { struct SResultRowEntryInfo* pResInfo = GET_RES_INFO(&pCtx[j]); if (isRowEntryInitialized(pResInfo) || fmIsPseudoColumnFunc(pCtx[j].functionId) || pCtx[j].functionId == -1 || @@ -605,12 +662,10 @@ int32_t initCtxOutputBuffer(SqlFunctionCtx* pCtx, int32_t size) { continue; } - code = pCtx[j].fpSet.init(&pCtx[j], pCtx[j].resultInfo); - if (TSDB_CODE_SUCCESS != code) { - return code; - } + (void)pCtx[j].fpSet.init(&pCtx[j], pCtx[j].resultInfo); } - return code; + + return 0; } /* @@ -647,15 +702,24 @@ int32_t setFunctionResultOutput(SOperatorInfo* pOperator, SOptrBasicInfo* pInfo, return initCtxOutputBuffer(pCtx, numOfExprs); } -SArray* setRowTsColumnOutputInfo(SqlFunctionCtx* pCtx, int32_t numOfCols) { +int32_t setRowTsColumnOutputInfo(SqlFunctionCtx* pCtx, int32_t numOfCols, SArray** pResList) { + QRY_OPTR_CHECK(pResList); SArray* pList = taosArrayInit(4, sizeof(int32_t)); + if (pList == NULL) { + return terrno; + } + for (int32_t i = 0; i < numOfCols; ++i) { if (fmIsPseudoColumnFunc(pCtx[i].functionId)) { - taosArrayPush(pList, &i); + void* px = taosArrayPush(pList, &i); + if (px == NULL) { + return terrno; + } } } - return pList; + *pResList = pList; + return 0; } int32_t doGenerateSourceData(SOperatorInfo* pOperator) { @@ -663,23 +727,32 @@ int32_t doGenerateSourceData(SOperatorInfo* pOperator) { SExprSupp* pSup = &pOperator->exprSupp; SSDataBlock* pRes = pProjectInfo->binfo.pRes; + SExprInfo* pExpr = pSup->pExprInfo; + int64_t st = taosGetTimestampUs(); + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - blockDataEnsureCapacity(pRes, pOperator->resultInfo.capacity); - SExprInfo* pExpr = pSup->pExprInfo; - - int64_t st = taosGetTimestampUs(); + int32_t code = blockDataEnsureCapacity(pRes, pOperator->resultInfo.capacity); + if (code) { + return code; + } for (int32_t k = 0; k < pSup->numOfExprs; ++k) { int32_t outputSlotId = pExpr[k].base.resSchema.slotId; if (pExpr[k].pExpr->nodeType == QUERY_NODE_VALUE) { SColumnInfoData* pColInfoData = taosArrayGet(pRes->pDataBlock, outputSlotId); + if (pColInfoData == NULL) { + return terrno; + } int32_t type = pExpr[k].base.pParam[0].param.nType; if (TSDB_DATA_TYPE_NULL == type) { colDataSetNNULL(pColInfoData, 0, 1); } else { - colDataSetVal(pColInfoData, 0, taosVariantGet(&pExpr[k].base.pParam[0].param, type), false); + code = colDataSetVal(pColInfoData, 0, taosVariantGet(&pExpr[k].base.pParam[0].param, type), false); + if (code) { + return code; + } } } else if (pExpr[k].pExpr->nodeType == QUERY_NODE_FUNCTION) { SqlFunctionCtx* pfCtx = &pSup->pCtx[k]; @@ -688,13 +761,24 @@ int32_t doGenerateSourceData(SOperatorInfo* pOperator) { // UDF aggregate functions will be handled in agg operator. if (fmIsScalarFunc(pfCtx->functionId)) { SArray* pBlockList = taosArrayInit(4, POINTER_BYTES); - taosArrayPush(pBlockList, &pRes); + if (pBlockList == NULL) { + return terrno; + } + + void* px = taosArrayPush(pBlockList, &pRes); + if (px == NULL) { + return terrno; + } SColumnInfoData* pResColData = taosArrayGet(pRes->pDataBlock, outputSlotId); + if (pResColData == NULL) { + return terrno; + } + SColumnInfoData idata = {.info = pResColData->info, .hasNull = true}; SScalarParam dest = {.columnData = &idata}; - int32_t code = scalarCalculate((SNode*)pExpr[k].pExpr->_function.pFunctNode, pBlockList, &dest); + code = scalarCalculate((SNode*)pExpr[k].pExpr->_function.pFunctNode, pBlockList, &dest); if (code != TSDB_CODE_SUCCESS) { taosArrayDestroy(pBlockList); return code; @@ -702,9 +786,12 @@ int32_t doGenerateSourceData(SOperatorInfo* pOperator) { int32_t startOffset = pRes->info.rows; ASSERT(pRes->info.capacity > 0); - colDataAssign(pResColData, &idata, dest.numOfRows, &pRes->info); - colDataDestroy(&idata); + code = colDataAssign(pResColData, &idata, dest.numOfRows, &pRes->info); + if (code) { + return code; + } + colDataDestroy(&idata); taosArrayDestroy(pBlockList); } else { return TSDB_CODE_OPS_NOT_SUPPORT; @@ -715,9 +802,13 @@ int32_t doGenerateSourceData(SOperatorInfo* pOperator) { } pRes->info.rows = 1; - doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + if (code) { + pTaskInfo->code = code; + return code; + } - /*int32_t status = */ doIngroupLimitOffset(&pProjectInfo->limitInfo, 0, pRes, pOperator); + (void) doIngroupLimitOffset(&pProjectInfo->limitInfo, 0, pRes, pOperator); pOperator->resultInfo.totalRows += pRes->info.rows; @@ -726,36 +817,44 @@ int32_t doGenerateSourceData(SOperatorInfo* pOperator) { pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0; } - return TSDB_CODE_SUCCESS; + return code; } static void setPseudoOutputColInfo(SSDataBlock* pResult, SqlFunctionCtx* pCtx, SArray* pPseudoList) { size_t num = (pPseudoList != NULL) ? taosArrayGetSize(pPseudoList) : 0; for (int32_t i = 0; i < num; ++i) { pCtx[i].pOutput = taosArrayGet(pResult->pDataBlock, i); + if (pCtx[i].pOutput == NULL) { + qError("failed to get the output buf, ptr is null"); + } } } int32_t projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBlock* pSrcBlock, SqlFunctionCtx* pCtx, int32_t numOfOutput, SArray* pPseudoList) { + int32_t lino = 0; int32_t code = TSDB_CODE_SUCCESS; setPseudoOutputColInfo(pResult, pCtx, pPseudoList); pResult->info.dataLoad = 1; SArray* processByRowFunctionCtx = NULL; - if (pSrcBlock == NULL) { for (int32_t k = 0; k < numOfOutput; ++k) { int32_t outputSlotId = pExpr[k].base.resSchema.slotId; ASSERT(pExpr[k].pExpr->nodeType == QUERY_NODE_VALUE); SColumnInfoData* pColInfoData = taosArrayGet(pResult->pDataBlock, outputSlotId); + if (pColInfoData == NULL) { + code = terrno; + TSDB_CHECK_CODE(code, lino, _exit); + } int32_t type = pExpr[k].base.pParam[0].param.nType; if (TSDB_DATA_TYPE_NULL == type) { colDataSetNNULL(pColInfoData, 0, 1); } else { - colDataSetVal(pColInfoData, 0, taosVariantGet(&pExpr[k].base.pParam[0].param, type), false); + code = colDataSetVal(pColInfoData, 0, taosVariantGet(&pExpr[k].base.pParam[0].param, type), false); + TSDB_CHECK_CODE(code, lino, _exit); } } @@ -772,7 +871,10 @@ int32_t projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBloc // function or some operators. bool createNewColModel = (pResult == pSrcBlock); if (createNewColModel) { - blockDataEnsureCapacity(pResult, pResult->info.rows); + code = blockDataEnsureCapacity(pResult, pResult->info.rows); + if (code) { + goto _exit; + } } int32_t numOfRows = 0; @@ -784,33 +886,60 @@ int32_t projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBloc if (pExpr[k].pExpr->nodeType == QUERY_NODE_COLUMN) { // it is a project query SColumnInfoData* pColInfoData = taosArrayGet(pResult->pDataBlock, outputSlotId); + if (pColInfoData == NULL) { + code = terrno; + TSDB_CHECK_CODE(code, lino, _exit); + } + if (pResult->info.rows > 0 && !createNewColModel) { + int32_t ret = 0; + if (pInputData->pData[0] == NULL) { int32_t slotId = pfCtx->param[0].pCol->slotId; SColumnInfoData* pInput = taosArrayGet(pSrcBlock->pDataBlock, slotId); + if (pInput == NULL) { + code = terrno; + TSDB_CHECK_CODE(code, lino, _exit); + } - colDataMergeCol(pColInfoData, pResult->info.rows, (int32_t*)&pResult->info.capacity, pInput, - pSrcBlock->info.rows); + ret = colDataMergeCol(pColInfoData, pResult->info.rows, (int32_t*)&pResult->info.capacity, pInput, + pSrcBlock->info.rows); } else { - colDataMergeCol(pColInfoData, pResult->info.rows, (int32_t*)&pResult->info.capacity, pInputData->pData[0], - pInputData->numOfRows); + ret = colDataMergeCol(pColInfoData, pResult->info.rows, (int32_t*)&pResult->info.capacity, + pInputData->pData[0], pInputData->numOfRows); } + + if (ret < 0) { + code = ret; + } + + TSDB_CHECK_CODE(code, lino, _exit); } else { if (pInputData->pData[0] == NULL) { int32_t slotId = pfCtx->param[0].pCol->slotId; SColumnInfoData* pInput = taosArrayGet(pSrcBlock->pDataBlock, slotId); - colDataAssign(pColInfoData, pInput, pSrcBlock->info.rows, &pResult->info); + if (pInput == NULL) { + code = terrno; + TSDB_CHECK_CODE(code, lino, _exit); + } + code = colDataAssign(pColInfoData, pInput, pSrcBlock->info.rows, &pResult->info); numOfRows = pSrcBlock->info.rows; } else { - colDataAssign(pColInfoData, pInputData->pData[0], pInputData->numOfRows, &pResult->info); + code = colDataAssign(pColInfoData, pInputData->pData[0], pInputData->numOfRows, &pResult->info); numOfRows = pInputData->numOfRows; } + + TSDB_CHECK_CODE(code, lino, _exit); } } else if (pExpr[k].pExpr->nodeType == QUERY_NODE_VALUE) { SColumnInfoData* pColInfoData = taosArrayGet(pResult->pDataBlock, outputSlotId); + if (pColInfoData == NULL) { + code = terrno; + TSDB_CHECK_CODE(code, lino, _exit); + } int32_t offset = createNewColModel ? 0 : pResult->info.rows; @@ -820,16 +949,33 @@ int32_t projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBloc } else { char* p = taosVariantGet(&pExpr[k].base.pParam[0].param, type); for (int32_t i = 0; i < pSrcBlock->info.rows; ++i) { - colDataSetVal(pColInfoData, i + offset, p, false); + code = colDataSetVal(pColInfoData, i + offset, p, false); + TSDB_CHECK_CODE(code, lino, _exit); } } numOfRows = pSrcBlock->info.rows; } else if (pExpr[k].pExpr->nodeType == QUERY_NODE_OPERATOR) { SArray* pBlockList = taosArrayInit(4, POINTER_BYTES); - taosArrayPush(pBlockList, &pSrcBlock); + if (pBlockList == NULL) { + code = terrno; + goto _exit; + } + + void* px = taosArrayPush(pBlockList, &pSrcBlock); + if (px == NULL) { + code = terrno; + taosArrayDestroy(pBlockList); + goto _exit; + } SColumnInfoData* pResColData = taosArrayGet(pResult->pDataBlock, outputSlotId); + if (pResColData == NULL) { + code = terrno; + taosArrayDestroy(pBlockList); + goto _exit; + } + SColumnInfoData idata = {.info = pResColData->info, .hasNull = true}; SScalarParam dest = {.columnData = &idata}; @@ -842,8 +988,13 @@ int32_t projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBloc int32_t startOffset = createNewColModel ? 0 : pResult->info.rows; ASSERT(pResult->info.capacity > 0); - colDataMergeCol(pResColData, startOffset, (int32_t*)&pResult->info.capacity, &idata, dest.numOfRows); + int32_t ret = colDataMergeCol(pResColData, startOffset, (int32_t*)&pResult->info.capacity, &idata, dest.numOfRows); + if (ret < 0) { + code = ret; + } + colDataDestroy(&idata); + TSDB_CHECK_CODE(code, lino, _exit); numOfRows = dest.numOfRows; taosArrayDestroy(pBlockList); @@ -853,17 +1004,24 @@ int32_t projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBloc // do nothing } else if (fmIsIndefiniteRowsFunc(pfCtx->functionId)) { SResultRowEntryInfo* pResInfo = GET_RES_INFO(pfCtx); - code = pfCtx->fpSet.init(pfCtx, pResInfo); - if (TSDB_CODE_SUCCESS != code) { - goto _exit; - } + (void) pfCtx->fpSet.init(pfCtx, pResInfo); pfCtx->pOutput = taosArrayGet(pResult->pDataBlock, outputSlotId); + if (pfCtx->pOutput == NULL) { + code = terrno; + TSDB_CHECK_CODE(code, lino, _exit); + } + pfCtx->offset = createNewColModel ? 0 : pResult->info.rows; // set the start offset // set the timestamp(_rowts) output buffer if (taosArrayGetSize(pPseudoList) > 0) { int32_t* outputColIndex = taosArrayGet(pPseudoList, 0); + if (outputColIndex == NULL) { + code = terrno; + goto _exit; + } + pfCtx->pTsOutput = (SColumnInfoData*)pCtx[*outputColIndex].pOutput; } @@ -876,6 +1034,7 @@ int32_t projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBloc if (code != TSDB_CODE_SUCCESS) { goto _exit; } + numOfRows = pResInfo->numOfRes; if (fmIsProcessByRowFunc(pfCtx->functionId)) { if (NULL == processByRowFunctionCtx) { @@ -885,7 +1044,12 @@ int32_t projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBloc goto _exit; } } - taosArrayPush(processByRowFunctionCtx, &pfCtx); + + void* px = taosArrayPush(processByRowFunctionCtx, &pfCtx); + if (px == NULL) { + code = terrno; + goto _exit; + } } } else if (fmIsAggFunc(pfCtx->functionId)) { // selective value output should be set during corresponding function execution @@ -894,25 +1058,51 @@ int32_t projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBloc } // _group_key function for "partition by tbname" + csum(col_name) query SColumnInfoData* pOutput = taosArrayGet(pResult->pDataBlock, outputSlotId); + if (pOutput == NULL) { + code = terrno; + TSDB_CHECK_CODE(code, lino, _exit); + } + int32_t slotId = pfCtx->param[0].pCol->slotId; // todo handle the json tag SColumnInfoData* pInput = taosArrayGet(pSrcBlock->pDataBlock, slotId); + if (pInput == NULL) { + code = terrno; + TSDB_CHECK_CODE(code, lino, _exit); + } + for (int32_t f = 0; f < pSrcBlock->info.rows; ++f) { bool isNull = colDataIsNull_s(pInput, f); if (isNull) { colDataSetNULL(pOutput, pResult->info.rows + f); } else { char* data = colDataGetData(pInput, f); - colDataSetVal(pOutput, pResult->info.rows + f, data, isNull); + code = colDataSetVal(pOutput, pResult->info.rows + f, data, isNull); + TSDB_CHECK_CODE(code, lino, _exit); } } } else { SArray* pBlockList = taosArrayInit(4, POINTER_BYTES); - taosArrayPush(pBlockList, &pSrcBlock); + if (pBlockList == NULL) { + code = terrno; + goto _exit; + } + + void* px = taosArrayPush(pBlockList, &pSrcBlock); + if (px == NULL) { + code = terrno; + goto _exit; + } SColumnInfoData* pResColData = taosArrayGet(pResult->pDataBlock, outputSlotId); + if (pResColData == NULL) { + taosArrayDestroy(pBlockList); + code = terrno; + goto _exit; + } + SColumnInfoData idata = {.info = pResColData->info, .hasNull = true}; SScalarParam dest = {.columnData = &idata}; @@ -924,11 +1114,16 @@ int32_t projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBloc int32_t startOffset = createNewColModel ? 0 : pResult->info.rows; ASSERT(pResult->info.capacity > 0); - colDataMergeCol(pResColData, startOffset, (int32_t*)&pResult->info.capacity, &idata, dest.numOfRows); + int32_t ret = colDataMergeCol(pResColData, startOffset, (int32_t*)&pResult->info.capacity, &idata, dest.numOfRows); + if (ret < 0) { + code = ret; + } + colDataDestroy(&idata); numOfRows = dest.numOfRows; taosArrayDestroy(pBlockList); + TSDB_CHECK_CODE(code, lino, _exit); } } else { return TSDB_CODE_OPS_NOT_SUPPORT; @@ -937,19 +1132,23 @@ int32_t projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBloc if (processByRowFunctionCtx && taosArrayGetSize(processByRowFunctionCtx) > 0){ SqlFunctionCtx** pfCtx = taosArrayGet(processByRowFunctionCtx, 0); - code = (*pfCtx)->fpSet.processFuncByRow(processByRowFunctionCtx); - if (code != TSDB_CODE_SUCCESS) { + if (pfCtx == NULL) { + code = terrno; goto _exit; } + + code = (*pfCtx)->fpSet.processFuncByRow(processByRowFunctionCtx); + TSDB_CHECK_CODE(code, lino, _exit); numOfRows = (*pfCtx)->resultInfo->numOfRes; } + if (!createNewColModel) { pResult->info.rows += numOfRows; } + _exit: if(processByRowFunctionCtx) { taosArrayDestroy(processByRowFunctionCtx); - processByRowFunctionCtx = NULL; } return code; } diff --git a/source/libs/executor/src/querytask.c b/source/libs/executor/src/querytask.c index ddba556c7a..9f4d9c4405 100644 --- a/source/libs/executor/src/querytask.c +++ b/source/libs/executor/src/querytask.c @@ -110,17 +110,14 @@ int32_t createExecTaskInfo(SSubplan* pPlan, SExecTaskInfo** pTaskInfo, SReadHand (*pTaskInfo)->pSubplan = pPlan; (*pTaskInfo)->pWorkerCb = pHandle->pWorkerCb; - (*pTaskInfo)->pRoot = createOperator(pPlan->pNode, *pTaskInfo, pHandle, pPlan->pTagCond, pPlan->pTagIndexCond, - pPlan->user, pPlan->dbFName); + code = createOperator(pPlan->pNode, *pTaskInfo, pHandle, pPlan->pTagCond, pPlan->pTagIndexCond, pPlan->user, + pPlan->dbFName, &((*pTaskInfo)->pRoot)); - if (NULL == (*pTaskInfo)->pRoot) { - int32_t code = (*pTaskInfo)->code; + if (NULL == (*pTaskInfo)->pRoot || code != 0) { doDestroyTask(*pTaskInfo); (*pTaskInfo) = NULL; - return code; - } else { - return TSDB_CODE_SUCCESS; } + return code; } void cleanupQueriedTableScanInfo(void* p) { diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index 2daeb78282..600700ab37 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -1310,8 +1310,10 @@ static void destroyTableScanOperatorInfo(void* param) { taosMemoryFreeClear(param); } -SOperatorInfo* createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle, - STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo) { +int32_t createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle, + STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; STableScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableScanInfo)); @@ -1386,7 +1388,8 @@ SOperatorInfo* createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, // for non-blocking operator, the open cost is always 0 pOperator->cost.openCost = 0; - return pOperator; + *pOptrInfo = pOperator; + return code; _error: if (pInfo != NULL) { @@ -1395,12 +1398,19 @@ _error: taosMemoryFreeClear(pOperator); pTaskInfo->code = code; - return NULL; + return code; } -SOperatorInfo* createTableSeqScanOperatorInfo(void* pReadHandle, SExecTaskInfo* pTaskInfo) { +int32_t createTableSeqScanOperatorInfo(void* pReadHandle, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + + int32_t code = 0; STableScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableScanInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + if (pInfo == NULL || pOperator == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _end; + } pInfo->base.dataReader = pReadHandle; // pInfo->prevGroupId = -1; @@ -1409,7 +1419,20 @@ SOperatorInfo* createTableSeqScanOperatorInfo(void* pReadHandle, SExecTaskInfo* pInfo, pTaskInfo); pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableScanImpl, NULL, NULL, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); - return pOperator; + *pOptrInfo = pOperator; + return code; + + _end: + if (pInfo != NULL) { + taosMemoryFree(pInfo); + } + + if (pOperator != NULL) { + taosMemoryFree(pOperator); + } + + pTaskInfo->code = code; + return code; } FORCE_INLINE void doClearBufferedBlocks(SStreamScanInfo* pInfo) { @@ -3574,12 +3597,13 @@ static void destroyRawScanOperatorInfo(void* param) { // for subscribing db or stb (not including column), // if this scan is used, meta data can be return // and schemas are decided when scanning -SOperatorInfo* createRawScanOperatorInfo(SReadHandle* pHandle, SExecTaskInfo* pTaskInfo) { +int32_t createRawScanOperatorInfo(SReadHandle* pHandle, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { // create operator // create tb reader // create meta reader // create tq reader + QRY_OPTR_CHECK(pOptrInfo); int32_t code = TSDB_CODE_SUCCESS; SStreamRawScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamRawScanInfo)); @@ -3599,13 +3623,14 @@ SOperatorInfo* createRawScanOperatorInfo(SReadHandle* pHandle, SExecTaskInfo* pT pOperator->fpSet = createOperatorFpSet(NULL, doRawScan, NULL, destroyRawScanOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); - return pOperator; + *pOptrInfo = pOperator; + return code; _end: taosMemoryFree(pInfo); taosMemoryFree(pOperator); pTaskInfo->code = code; - return NULL; + return code; } static void destroyStreamScanOperatorInfo(void* param) { @@ -3756,8 +3781,10 @@ _end: return code; } -SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode, SNode* pTagCond, - STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo) { +int32_t createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode, SNode* pTagCond, + STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; SArray* pColIds = NULL; @@ -3767,7 +3794,7 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys const char* idstr = pTaskInfo->id.str; if (pInfo == NULL || pOperator == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; tableListDestroy(pTableListInfo); goto _error; } @@ -3847,11 +3874,13 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys } if (pHandle->vnode) { - SOperatorInfo* pTableScanOp = createTableScanOperatorInfo(pTableScanNode, pHandle, pTableListInfo, pTaskInfo); - if (pTableScanOp == NULL) { + SOperatorInfo* pTableScanOp = NULL; + code = createTableScanOperatorInfo(pTableScanNode, pHandle, pTableListInfo, pTaskInfo, &pTableScanOp); + if (pTableScanOp == NULL || code != 0) { qError("createTableScanOperatorInfo error, errorcode: %d", pTaskInfo->code); goto _error; } + STableScanInfo* pTSInfo = (STableScanInfo*)pTableScanOp->info; if (pHandle->version > 0) { pTSInfo->base.cond.endVersion = pHandle->version; @@ -3963,7 +3992,8 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys NULL, optrDefaultGetNextExtFn, NULL); setOperatorStreamStateFn(pOperator, streamScanReleaseState, streamScanReloadState); - return pOperator; + *pOptrInfo = pOperator; + return code; _error: if (pColIds != NULL) { @@ -3975,7 +4005,8 @@ _error: } taosMemoryFreeClear(pOperator); - return NULL; + pTaskInfo->code = code; + return code; } static void doTagScanOneTable(SOperatorInfo* pOperator, const SSDataBlock* pRes, int32_t count, SMetaReader* mr, @@ -4428,21 +4459,26 @@ static void destroyTagScanOperatorInfo(void* param) { taosArrayDestroyEx(pInfo->aUidTags, tagScanFreeUidTag); blockDataDestroy(pInfo->pRes); - pInfo->pRes = NULL; taosArrayDestroy(pInfo->matchInfo.pList); tableListDestroy(pInfo->pTableListInfo); + + pInfo->pRes = NULL; + pInfo->pTableListInfo = NULL; taosMemoryFreeClear(param); } -SOperatorInfo* createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysiNode* pTagScanNode, +int32_t createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysiNode* pTagScanNode, STableListInfo* pTableListInfo, SNode* pTagCond, SNode* pTagIndexCond, - SExecTaskInfo* pTaskInfo) { + SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; SScanPhysiNode* pPhyNode = (SScanPhysiNode*)pTagScanNode; STagScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STagScanInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } @@ -4498,14 +4534,13 @@ SOperatorInfo* createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysi __optr_fn_t tagScanNextFn = (pTagScanNode->onlyMetaCtbIdx) ? doTagScanFromCtbIdx : doTagScanFromMetaEntry; pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, tagScanNextFn, NULL, destroyTagScanOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); - - return pOperator; + *pOptrInfo = pOperator; + return code; _error: taosMemoryFree(pInfo); taosMemoryFree(pOperator); - terrno = TSDB_CODE_OUT_OF_MEMORY; - return NULL; + return code; } // table merge scan operator @@ -5270,7 +5305,7 @@ int32_t startDurationForGroupTableMergeScan(SOperatorInfo* pOperator) { tsortSetMergeLimitReachedFp(pInfo->pSortHandle, tableMergeScanDoSkipTable, pOperator); tsortSetAbortCheckFn(pInfo->pSortHandle, isTaskKilled, pOperator->pTaskInfo); - code = tsortSetFetchRawDataFp(pInfo->pSortHandle, getBlockForTableMergeScan, NULL, NULL); + tsortSetFetchRawDataFp(pInfo->pSortHandle, getBlockForTableMergeScan, NULL, NULL); QUERY_CHECK_CODE(code, lino, _end); STableMergeScanSortSourceParam* param = taosMemoryCalloc(1, sizeof(STableMergeScanSortSourceParam)); @@ -5563,18 +5598,22 @@ int32_t getTableMergeScanExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExpla return TSDB_CODE_SUCCESS; } -SOperatorInfo* createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle, - STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo) { +int32_t createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle, + STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + + int32_t code = 0; STableMergeScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableMergeScanInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } SDataBlockDescNode* pDescNode = pTableScanNode->scan.node.pOutputDataBlockDesc; int32_t numOfCols = 0; - int32_t code = extractColMatchInfo(pTableScanNode->scan.pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, + code = extractColMatchInfo(pTableScanNode->scan.pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, &pInfo->base.matchInfo); int32_t lino = 0; if (code != TSDB_CODE_SUCCESS) { @@ -5674,13 +5713,15 @@ SOperatorInfo* createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanN destroyTableMergeScanOperatorInfo, optrDefaultBufFn, getTableMergeScanExplainExecInfo, optrDefaultGetNextExtFn, NULL); pOperator->cost.openCost = 0; - return pOperator; + + *pOptrInfo = pOperator; + return code; _error: pTaskInfo->code = TSDB_CODE_OUT_OF_MEMORY; taosMemoryFree(pInfo); taosMemoryFree(pOperator); - return NULL; + return code; } // ==================================================================================================================== @@ -5796,16 +5837,17 @@ int32_t getTableCountScanSupp(SNodeList* groupTags, SName* tableName, SNodeList* return code; } -SOperatorInfo* createTableCountScanOperatorInfo(SReadHandle* readHandle, STableCountScanPhysiNode* pTblCountScanNode, - SExecTaskInfo* pTaskInfo) { - int32_t code = TSDB_CODE_SUCCESS; - int32_t lino = 0; +int32_t createTableCountScanOperatorInfo(SReadHandle* readHandle, STableCountScanPhysiNode* pTblCountScanNode, + SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SScanPhysiNode* pScanNode = &pTblCountScanNode->scan; STableCountScanOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STableCountScanOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); - if (!pInfo || !pOperator) { + code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } @@ -5828,7 +5870,8 @@ SOperatorInfo* createTableCountScanOperatorInfo(SReadHandle* readHandle, STableC pInfo, pTaskInfo); pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableCountScan, NULL, destoryTableCountScanOperator, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); - return pOperator; + *pOptrInfo = pOperator; + return code; _error: if (pInfo != NULL) { @@ -5836,7 +5879,7 @@ _error: } taosMemoryFreeClear(pOperator); pTaskInfo->code = code; - return NULL; + return code; } int32_t fillTableCountScanDataBlock(STableCountScanSupp* pSupp, char* dbName, char* stbName, int64_t count, diff --git a/source/libs/executor/src/sortoperator.c b/source/libs/executor/src/sortoperator.c index 9892114735..7dfe88fe85 100644 --- a/source/libs/executor/src/sortoperator.c +++ b/source/libs/executor/src/sortoperator.c @@ -43,20 +43,27 @@ typedef struct SSortOperatorInfo { SSortOpGroupIdCalc* pGroupIdCalc; } SSortOperatorInfo; -static SSDataBlock* doSort(SOperatorInfo* pOperator); +static int32_t doSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock); +static SSDataBlock* doSort1(SOperatorInfo* pOperator); static int32_t doOpenSortOperator(SOperatorInfo* pOperator); static int32_t getExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len); +static SSDataBlock* doGroupSort1(SOperatorInfo* pOperator); +static int32_t doGroupSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock); static void destroySortOperatorInfo(void* param); -static int32_t calcSortOperMaxTupleLength(SSortOperatorInfo* pSortOperInfo, SNodeList* pSortKeys); +static void calcSortOperMaxTupleLength(SSortOperatorInfo* pSortOperInfo, SNodeList* pSortKeys); static void destroySortOpGroupIdCalc(SSortOpGroupIdCalc* pCalc); // todo add limit/offset impl -SOperatorInfo* createSortOperatorInfo(SOperatorInfo* downstream, SSortPhysiNode* pSortNode, SExecTaskInfo* pTaskInfo) { +int32_t createSortOperatorInfo(SOperatorInfo* downstream, SSortPhysiNode* pSortNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + + int32_t code = 0; SSortOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SSortOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } @@ -67,7 +74,7 @@ SOperatorInfo* createSortOperatorInfo(SOperatorInfo* downstream, SSortPhysiNode* pOperator->exprSupp.pExprInfo = createExprInfo(pSortNode->pExprs, NULL, &numOfCols); pOperator->exprSupp.numOfExprs = numOfCols; int32_t numOfOutputCols = 0; - int32_t code = + code = extractColMatchInfo(pSortNode->pTargets, pDescNode, &numOfOutputCols, COL_MATCH_FROM_SLOT_ID, &pInfo->matchInfo); if (code != TSDB_CODE_SUCCESS) { goto _error; @@ -113,7 +120,9 @@ SOperatorInfo* createSortOperatorInfo(SOperatorInfo* downstream, SSortPhysiNode* if (TSDB_CODE_SUCCESS == code) { pGroupIdCalc->lastKeysLen = 0; pGroupIdCalc->keyBuf = taosMemoryCalloc(1, keyLen); - if (!pGroupIdCalc->keyBuf) code = TSDB_CODE_OUT_OF_MEMORY; + if (!pGroupIdCalc->keyBuf) { + code = TSDB_CODE_OUT_OF_MEMORY; + } } } if (code != TSDB_CODE_SUCCESS) goto _error; @@ -131,36 +140,46 @@ SOperatorInfo* createSortOperatorInfo(SOperatorInfo* downstream, SSortPhysiNode* // TODO dynamic set the available sort buffer pOperator->fpSet = - createOperatorFpSet(doOpenSortOperator, doSort, NULL, destroySortOperatorInfo, optrDefaultBufFn, getExplainExecInfo, optrDefaultGetNextExtFn, NULL); + createOperatorFpSet(doOpenSortOperator, doSort1, NULL, destroySortOperatorInfo, optrDefaultBufFn, getExplainExecInfo, optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); if (code != TSDB_CODE_SUCCESS) { goto _error; } - return pOperator; + *pOptrInfo = pOperator; + return code; _error: - pTaskInfo->code = TSDB_CODE_OUT_OF_MEMORY; if (pInfo != NULL) { destroySortOperatorInfo(pInfo); } taosMemoryFree(pOperator); - return NULL; + pTaskInfo->code = code; + return code; } -void appendOneRowToDataBlock(SSDataBlock* pBlock, STupleHandle* pTupleHandle) { +int32_t appendOneRowToDataBlock(SSDataBlock* pBlock, STupleHandle* pTupleHandle) { + int32_t code = 0; for (int32_t i = 0; i < taosArrayGetSize(pBlock->pDataBlock); ++i) { SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, i); - bool isNull = tsortIsNullVal(pTupleHandle, i); + if (pColInfo == NULL) { + return terrno; + } + + bool isNull = tsortIsNullVal(pTupleHandle, i); if (isNull) { colDataSetNULL(pColInfo, pBlock->info.rows); } else { char* pData = NULL; tsortGetValue(pTupleHandle, i, (void**) &pData); + if (pData != NULL) { - colDataSetVal(pColInfo, pBlock->info.rows, pData, false); + code = colDataSetVal(pColInfo, pBlock->info.rows, pData, false); + if (code) { + return code; + } } } } @@ -172,6 +191,7 @@ void appendOneRowToDataBlock(SSDataBlock* pBlock, STupleHandle* pTupleHandle) { pBlock->info.scanFlag = info.scanFlag; pBlock->info.rows += 1; + return code; } /** @@ -224,17 +244,21 @@ static STupleHandle* nextTupleWithGroupId(SSortHandle* pHandle, SSortOperatorInf return retTuple; } -SSDataBlock* getSortedBlockData(SSortHandle* pHandle, SSDataBlock* pDataBlock, int32_t capacity, SArray* pColMatchInfo, - SSortOperatorInfo* pInfo) { +static int32_t getSortedBlockData(SSortHandle* pHandle, SSDataBlock* pDataBlock, int32_t capacity, SArray* pColMatchInfo, + SSortOperatorInfo* pInfo, SSDataBlock** pResBlock) { + QRY_OPTR_CHECK(pResBlock); blockDataCleanup(pDataBlock); SSDataBlock* p = NULL; int32_t code = tsortGetSortedDataBlock(pHandle, &p); if (p == NULL || (code != 0)) { - return NULL; + return code; } - blockDataEnsureCapacity(p, capacity); + code = blockDataEnsureCapacity(p, capacity); + if (code) { + return code; + } STupleHandle* pTupleHandle; while (1) { @@ -247,23 +271,44 @@ SSDataBlock* getSortedBlockData(SSortHandle* pHandle, SSDataBlock* pDataBlock, i break; } - appendOneRowToDataBlock(p, pTupleHandle); + code = appendOneRowToDataBlock(p, pTupleHandle); + if (code) { + return code; + } + if (p->info.rows >= capacity) { break; } } if (p->info.rows > 0) { - blockDataEnsureCapacity(pDataBlock, capacity); + code = blockDataEnsureCapacity(pDataBlock, capacity); + if (code) { + return code; + } // todo extract function to handle this int32_t numOfCols = taosArrayGetSize(pColMatchInfo); for (int32_t i = 0; i < numOfCols; ++i) { SColMatchItem* pmInfo = taosArrayGet(pColMatchInfo, i); + if (pmInfo == NULL) { + return terrno; + } SColumnInfoData* pSrc = taosArrayGet(p->pDataBlock, pmInfo->srcSlotId); + if (pSrc == NULL) { + return terrno; + } + SColumnInfoData* pDst = taosArrayGet(pDataBlock->pDataBlock, pmInfo->dstSlotId); - colDataAssign(pDst, pSrc, p->info.rows, &pDataBlock->info); + if (pDst == NULL) { + return terrno; + } + + code = colDataAssign(pDst, pSrc, p->info.rows, &pDataBlock->info); + if (code) { + return code; + } } pDataBlock->info.dataLoad = 1; @@ -273,7 +318,8 @@ SSDataBlock* getSortedBlockData(SSortHandle* pHandle, SSDataBlock* pDataBlock, i } blockDataDestroy(p); - return (pDataBlock->info.rows > 0) ? pDataBlock : NULL; + *pResBlock = (pDataBlock->info.rows > 0) ? pDataBlock : NULL; + return code; } SSDataBlock* loadNextDataBlock(void* param) { @@ -317,23 +363,33 @@ int32_t doOpenSortOperator(SOperatorInfo* pOperator) { SSortSource* ps = taosMemoryCalloc(1, sizeof(SSortSource)); ps->param = pOperator->pDownstream[0]; ps->onlyRef = true; - tsortAddSource(pInfo->pSortHandle, ps); + code = tsortAddSource(pInfo->pSortHandle, ps); + if (code) { + return code; + } code = tsortOpen(pInfo->pSortHandle); if (code != TSDB_CODE_SUCCESS) { - T_LONG_JMP(pTaskInfo->env, terrno); + T_LONG_JMP(pTaskInfo->env, code); } pOperator->cost.openCost = (taosGetTimestampUs() - pInfo->startTs) / 1000.0; pOperator->status = OP_RES_TO_RETURN; OPTR_SET_OPENED(pOperator); - return TSDB_CODE_SUCCESS; + return code; } -SSDataBlock* doSort(SOperatorInfo* pOperator) { +SSDataBlock* doSort1(SOperatorInfo* pOperator) { + SSDataBlock* pBlock = NULL; + pOperator->pTaskInfo->code = doSort(pOperator, &pBlock); + return pBlock; +} + +int32_t doSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock) { + QRY_OPTR_CHECK(pResBlock); if (pOperator->status == OP_EXEC_DONE) { - return NULL; + return 0; } SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; @@ -348,18 +404,22 @@ SSDataBlock* doSort(SOperatorInfo* pOperator) { SSDataBlock* pBlock = NULL; while (1) { if (tsortIsClosed(pInfo->pSortHandle)) { - terrno = TSDB_CODE_TSC_QUERY_CANCELLED; - T_LONG_JMP(pOperator->pTaskInfo->env, terrno); + code = TSDB_CODE_TSC_QUERY_CANCELLED; + T_LONG_JMP(pOperator->pTaskInfo->env, code); } - pBlock = getSortedBlockData(pInfo->pSortHandle, pInfo->binfo.pRes, pOperator->resultInfo.capacity, - pInfo->matchInfo.pList, pInfo); - if (pBlock == NULL) { + code = getSortedBlockData(pInfo->pSortHandle, pInfo->binfo.pRes, pOperator->resultInfo.capacity, + pInfo->matchInfo.pList, pInfo, &pBlock); + if (pBlock == NULL || code != 0) { setOperatorCompleted(pOperator); - return NULL; + return code; + } + + code = doFilter(pBlock, pOperator->exprSupp.pFilterInfo, &pInfo->matchInfo); + if (code) { + break; } - doFilter(pBlock, pOperator->exprSupp.pFilterInfo, &pInfo->matchInfo); if (blockDataGetNumOfRows(pBlock) == 0) { continue; } @@ -376,7 +436,8 @@ SSDataBlock* doSort(SOperatorInfo* pOperator) { } } - return blockDataGetNumOfRows(pBlock) > 0 ? pBlock : NULL; + *pResBlock = blockDataGetNumOfRows(pBlock) > 0 ? pBlock : NULL; + return code; } void destroySortOperatorInfo(void* param) { @@ -402,18 +463,23 @@ int32_t getExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* return TSDB_CODE_SUCCESS; } -static int32_t calcSortOperMaxTupleLength(SSortOperatorInfo* pSortOperInfo, SNodeList* pSortKeys) { +static void calcSortOperMaxTupleLength(SSortOperatorInfo* pSortOperInfo, SNodeList* pSortKeys) { SColMatchInfo* pColItem = &pSortOperInfo->matchInfo; size_t size = taosArrayGetSize(pColItem->pList); for (size_t i = 0; i < size; ++i) { - pSortOperInfo->maxTupleLength += ((SColMatchItem*)taosArrayGet(pColItem->pList, i))->dataType.bytes; + SColMatchItem* pInfo = taosArrayGet(pColItem->pList, i); + if (pInfo == NULL) { + continue; + } + + pSortOperInfo->maxTupleLength += pInfo->dataType.bytes; } + size = LIST_LENGTH(pSortKeys); for (size_t i = 0; i < size; ++i) { SOrderByExprNode* pOrderExprNode = (SOrderByExprNode*)nodesListGetNode(pSortKeys, i); pSortOperInfo->maxTupleLength += ((SColumnNode*)pOrderExprNode->pExpr)->node.resType.bytes; } - return TSDB_CODE_SUCCESS; } static void destroySortOpGroupIdCalc(SSortOpGroupIdCalc* pCalc) { @@ -442,18 +508,26 @@ typedef struct SGroupSortOperatorInfo { SSortExecInfo sortExecInfo; } SGroupSortOperatorInfo; -SSDataBlock* getGroupSortedBlockData(SSortHandle* pHandle, SSDataBlock* pDataBlock, int32_t capacity, - SArray* pColMatchInfo, SGroupSortOperatorInfo* pInfo) { - blockDataCleanup(pDataBlock); - blockDataEnsureCapacity(pDataBlock, capacity); +int32_t getGroupSortedBlockData(SSortHandle* pHandle, SSDataBlock* pDataBlock, int32_t capacity, SArray* pColMatchInfo, + SGroupSortOperatorInfo* pInfo, SSDataBlock** pResBlock) { + QRY_OPTR_CHECK(pResBlock); - SSDataBlock* p = NULL; - int32_t code = tsortGetSortedDataBlock(pHandle, &p); - if (p == NULL || (code != 0)) { - return NULL; + blockDataCleanup(pDataBlock); + int32_t code = blockDataEnsureCapacity(pDataBlock, capacity); + if (code) { + return code; } - blockDataEnsureCapacity(p, capacity); + SSDataBlock* p = NULL; + code = tsortGetSortedDataBlock(pHandle, &p); + if (p == NULL || (code != 0)) { + return code; + } + + code = blockDataEnsureCapacity(p, capacity); + if (code) { + return code; + } while (1) { STupleHandle* pTupleHandle = NULL; @@ -462,7 +536,11 @@ SSDataBlock* getGroupSortedBlockData(SSortHandle* pHandle, SSDataBlock* pDataBlo break; } - appendOneRowToDataBlock(p, pTupleHandle); + code = appendOneRowToDataBlock(p, pTupleHandle); + if (code) { + break; + } + if (p->info.rows >= capacity) { break; } @@ -472,10 +550,24 @@ SSDataBlock* getGroupSortedBlockData(SSortHandle* pHandle, SSDataBlock* pDataBlo int32_t numOfCols = taosArrayGetSize(pColMatchInfo); for (int32_t i = 0; i < numOfCols; ++i) { SColMatchItem* pmInfo = taosArrayGet(pColMatchInfo, i); + if (pmInfo == NULL) { + return terrno; + } SColumnInfoData* pSrc = taosArrayGet(p->pDataBlock, pmInfo->srcSlotId); + if (pSrc == NULL) { + return terrno; + } + SColumnInfoData* pDst = taosArrayGet(pDataBlock->pDataBlock, pmInfo->dstSlotId); - colDataAssign(pDst, pSrc, p->info.rows, &pDataBlock->info); + if (pDst == NULL) { + return terrno; + } + + code = colDataAssign(pDst, pSrc, p->info.rows, &pDataBlock->info); + if (code) { + return code; + } } pDataBlock->info.rows = p->info.rows; @@ -484,7 +576,8 @@ SSDataBlock* getGroupSortedBlockData(SSortHandle* pHandle, SSDataBlock* pDataBlo } blockDataDestroy(p); - return (pDataBlock->info.rows > 0) ? pDataBlock : NULL; + *pResBlock = (pDataBlock->info.rows > 0) ? pDataBlock : NULL; + return code; } typedef struct SGroupSortSourceParam { @@ -539,11 +632,14 @@ int32_t beginSortGroup(SOperatorInfo* pOperator) { param->grpSortOpInfo = pInfo; ps->param = param; ps->onlyRef = false; - tsortAddSource(pInfo->pCurrSortHandle, ps); + code = tsortAddSource(pInfo->pCurrSortHandle, ps); + if (code) { + T_LONG_JMP(pTaskInfo->env, code); + } code = tsortOpen(pInfo->pCurrSortHandle); if (code != TSDB_CODE_SUCCESS) { - T_LONG_JMP(pTaskInfo->env, terrno); + T_LONG_JMP(pTaskInfo->env, code); } return code; @@ -566,14 +662,21 @@ int32_t finishSortGroup(SOperatorInfo* pOperator) { return TSDB_CODE_SUCCESS; } -SSDataBlock* doGroupSort(SOperatorInfo* pOperator) { - if (pOperator->status == OP_EXEC_DONE) { - return NULL; - } +SSDataBlock* doGroupSort1(SOperatorInfo* pOperator) { + SSDataBlock* pBlock = NULL; + pOperator->pTaskInfo->code = doGroupSort(pOperator, &pBlock); + return pBlock; +} +int32_t doGroupSort(SOperatorInfo* pOperator, SSDataBlock** pResBlock) { + QRY_OPTR_CHECK(pResBlock); SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SGroupSortOperatorInfo* pInfo = pOperator->info; + if (pOperator->status == OP_EXEC_DONE) { + return 0; + } + int32_t code = pOperator->fpSet._openFn(pOperator); if (code != TSDB_CODE_SUCCESS) { T_LONG_JMP(pTaskInfo->env, code); @@ -585,41 +688,47 @@ SSDataBlock* doGroupSort(SOperatorInfo* pOperator) { pInfo->prefetchedSortInput = getNextBlockFromDownstream(pOperator, 0); if (pInfo->prefetchedSortInput == NULL) { setOperatorCompleted(pOperator); - return NULL; + return code; } + pInfo->currGroupId = pInfo->prefetchedSortInput->info.id.groupId; pInfo->childOpStatus = CHILD_OP_NEW_GROUP; - beginSortGroup(pOperator); + code = beginSortGroup(pOperator); + if (code) { + return code; + } } SSDataBlock* pBlock = NULL; while (pInfo->pCurrSortHandle != NULL) { if (tsortIsClosed(pInfo->pCurrSortHandle)) { - terrno = TSDB_CODE_TSC_QUERY_CANCELLED; - T_LONG_JMP(pOperator->pTaskInfo->env, terrno); + code = TSDB_CODE_TSC_QUERY_CANCELLED; + T_LONG_JMP(pOperator->pTaskInfo->env, code); } // beginSortGroup would fetch all child blocks of pInfo->currGroupId; ASSERT(pInfo->childOpStatus != CHILD_OP_SAME_GROUP); - pBlock = getGroupSortedBlockData(pInfo->pCurrSortHandle, pInfo->binfo.pRes, pOperator->resultInfo.capacity, - pInfo->matchInfo.pList, pInfo); - if (pBlock != NULL) { + code = getGroupSortedBlockData(pInfo->pCurrSortHandle, pInfo->binfo.pRes, pOperator->resultInfo.capacity, + pInfo->matchInfo.pList, pInfo, &pBlock); + if (pBlock != NULL && (code == 0)) { pBlock->info.id.groupId = pInfo->currGroupId; pOperator->resultInfo.totalRows += pBlock->info.rows; - return pBlock; + *pResBlock = pBlock; + return code; } else { if (pInfo->childOpStatus == CHILD_OP_NEW_GROUP) { - finishSortGroup(pOperator); + (void) finishSortGroup(pOperator); pInfo->currGroupId = pInfo->prefetchedSortInput->info.id.groupId; - beginSortGroup(pOperator); + code = beginSortGroup(pOperator); } else if (pInfo->childOpStatus == CHILD_OP_FINISHED) { - finishSortGroup(pOperator); + (void) finishSortGroup(pOperator); setOperatorCompleted(pOperator); - return NULL; + return code; } } } - return NULL; + + return code; } int32_t getGroupSortExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len) { @@ -643,41 +752,48 @@ void destroyGroupSortOperatorInfo(void* param) { taosMemoryFreeClear(param); } -SOperatorInfo* createGroupSortOperatorInfo(SOperatorInfo* downstream, SGroupSortPhysiNode* pSortPhyNode, - SExecTaskInfo* pTaskInfo) { +int32_t createGroupSortOperatorInfo(SOperatorInfo* downstream, SGroupSortPhysiNode* pSortPhyNode, + SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + int32_t code = 0; + int32_t lino = 0; + SGroupSortOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SGroupSortOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } - SExprSupp* pSup = &pOperator->exprSupp; + SExprSupp* pSup = &pOperator->exprSupp; SDataBlockDescNode* pDescNode = pSortPhyNode->node.pOutputDataBlockDesc; - int32_t numOfCols = 0; - SExprInfo* pExprInfo = createExprInfo(pSortPhyNode->pExprs, NULL, &numOfCols); + int32_t numOfCols = 0; + SExprInfo* pExprInfo = createExprInfo(pSortPhyNode->pExprs, NULL, &numOfCols); pSup->pExprInfo = pExprInfo; pSup->numOfExprs = numOfCols; initResultSizeInfo(&pOperator->resultInfo, 1024); - pOperator->exprSupp.pCtx = createSqlFunctionCtx(pExprInfo, numOfCols, &pOperator->exprSupp.rowEntryInfoOffset, &pTaskInfo->storageAPI.functionStore); + pOperator->exprSupp.pCtx = createSqlFunctionCtx(pExprInfo, numOfCols, &pOperator->exprSupp.rowEntryInfoOffset, + &pTaskInfo->storageAPI.functionStore); pInfo->binfo.pRes = createDataBlockFromDescNode(pDescNode); - blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); + TSDB_CHECK_CODE(code, lino, _error); + pInfo->binfo.inputTsOrder = pSortPhyNode->node.inputTsOrder; pInfo->binfo.outputTsOrder = pSortPhyNode->node.outputTsOrder; int32_t numOfOutputCols = 0; - int32_t code = extractColMatchInfo(pSortPhyNode->pTargets, pDescNode, &numOfOutputCols, COL_MATCH_FROM_SLOT_ID, - &pInfo->matchInfo); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + code = extractColMatchInfo(pSortPhyNode->pTargets, pDescNode, &numOfOutputCols, COL_MATCH_FROM_SLOT_ID, + &pInfo->matchInfo); + TSDB_CHECK_CODE(code, lino, _error); pInfo->pSortInfo = createSortInfo(pSortPhyNode->pSortKeys); - setOperatorInfo(pOperator, "GroupSortOperator", QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT, false, OP_NOT_OPENED, pInfo, pTaskInfo); - pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doGroupSort, NULL, destroyGroupSortOperatorInfo, + setOperatorInfo(pOperator, "GroupSortOperator", QUERY_NODE_PHYSICAL_PLAN_GROUP_SORT, false, OP_NOT_OPENED, pInfo, + pTaskInfo); + pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doGroupSort1, NULL, destroyGroupSortOperatorInfo, optrDefaultBufFn, getGroupSortExplainExecInfo, optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); @@ -685,7 +801,8 @@ SOperatorInfo* createGroupSortOperatorInfo(SOperatorInfo* downstream, SGroupSort goto _error; } - return pOperator; + *pOptrInfo = pOperator; + return code; _error: pTaskInfo->code = code; @@ -693,8 +810,5 @@ _error: destroyGroupSortOperatorInfo(pInfo); } taosMemoryFree(pOperator); - return NULL; + return code; } - - - diff --git a/source/libs/executor/src/streamcountwindowoperator.c b/source/libs/executor/src/streamcountwindowoperator.c index 90f4b02877..de731299ab 100644 --- a/source/libs/executor/src/streamcountwindowoperator.c +++ b/source/libs/executor/src/streamcountwindowoperator.c @@ -803,8 +803,10 @@ _end: } } -SOperatorInfo* createStreamCountAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, - SExecTaskInfo* pTaskInfo, SReadHandle* pHandle) { +int32_t createStreamCountAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, + SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + SCountWinodwPhysiNode* pCountNode = (SCountWinodwPhysiNode*)pPhyNode; int32_t numOfCols = 0; int32_t code = TSDB_CODE_SUCCESS; @@ -899,7 +901,9 @@ SOperatorInfo* createStreamCountAggOperatorInfo(SOperatorInfo* downstream, SPhys code = appendDownstream(pOperator, &downstream, 1); QUERY_CHECK_CODE(code, lino, _error); } - return pOperator; + + *pOptrInfo = pOperator; + return code; _error: if (pInfo != NULL) { @@ -908,6 +912,6 @@ _error: taosMemoryFreeClear(pOperator); pTaskInfo->code = code; - qError("%s failed at line %d since %s. task:%s", __func__, lino, tstrerror(code), GET_TASKID(pTaskInfo)); - return NULL; + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + return code; } diff --git a/source/libs/executor/src/streameventwindowoperator.c b/source/libs/executor/src/streameventwindowoperator.c index 805d3568d1..aca71d10fc 100644 --- a/source/libs/executor/src/streameventwindowoperator.c +++ b/source/libs/executor/src/streameventwindowoperator.c @@ -848,8 +848,10 @@ _end: } } -SOperatorInfo* createStreamEventAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, - SExecTaskInfo* pTaskInfo, SReadHandle* pHandle) { +int32_t createStreamEventAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, + SReadHandle* pHandle, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + SStreamEventWinodwPhysiNode* pEventNode = (SStreamEventWinodwPhysiNode*)pPhyNode; int32_t tsSlotId = ((SColumnNode*)pEventNode->window.pTspk)->slotId; int32_t code = TSDB_CODE_SUCCESS; @@ -959,12 +961,13 @@ SOperatorInfo* createStreamEventAggOperatorInfo(SOperatorInfo* downstream, SPhys code = filterInitFromNode((SNode*)pEventNode->pEndCond, &pInfo->pEndCondInfo, 0); QUERY_CHECK_CODE(code, lino, _error); - return pOperator; + *pOptrInfo = pOperator; + return code; _error: destroyStreamEventOperatorInfo(pInfo); taosMemoryFreeClear(pOperator); pTaskInfo->code = code; - qError("%s failed at line %d since %s. task:%s", __func__, lino, tstrerror(code), GET_TASKID(pTaskInfo)); - return NULL; + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + return code; } diff --git a/source/libs/executor/src/streamfilloperator.c b/source/libs/executor/src/streamfilloperator.c index 335bfd286c..1cecbc4a31 100644 --- a/source/libs/executor/src/streamfilloperator.c +++ b/source/libs/executor/src/streamfilloperator.c @@ -1327,8 +1327,10 @@ _end: return NULL; } -SOperatorInfo* createStreamFillOperatorInfo(SOperatorInfo* downstream, SStreamFillPhysiNode* pPhyFillNode, - SExecTaskInfo* pTaskInfo) { +int32_t createStreamFillOperatorInfo(SOperatorInfo* downstream, SStreamFillPhysiNode* pPhyFillNode, + SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; SStreamFillOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamFillOperatorInfo)); @@ -1424,7 +1426,9 @@ SOperatorInfo* createStreamFillOperatorInfo(SOperatorInfo* downstream, SStreamFi code = appendDownstream(pOperator, &downstream, 1); QUERY_CHECK_CODE(code, lino, _error); - return pOperator; + + *pOptrInfo = pOperator; + return code; _error: if (code != TSDB_CODE_SUCCESS) { @@ -1433,5 +1437,5 @@ _error: destroyStreamFillOperatorInfo(pInfo); taosMemoryFreeClear(pOperator); pTaskInfo->code = code; - return NULL; + return code; } diff --git a/source/libs/executor/src/streamtimewindowoperator.c b/source/libs/executor/src/streamtimewindowoperator.c index 95cad97a06..f6edf050b1 100644 --- a/source/libs/executor/src/streamtimewindowoperator.c +++ b/source/libs/executor/src/streamtimewindowoperator.c @@ -1840,9 +1840,11 @@ _end: } } -SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, +int32_t createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, int32_t numOfChild, - SReadHandle* pHandle) { + SReadHandle* pHandle, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; SIntervalPhysiNode* pIntervalPhyNode = (SIntervalPhysiNode*)pPhyNode; @@ -1979,13 +1981,14 @@ SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, taosMemoryFree(buff); } - return pOperator; + *pOptrInfo = pOperator; + return code; _error: destroyStreamFinalIntervalOperatorInfo(pInfo); taosMemoryFreeClear(pOperator); pTaskInfo->code = code; - return NULL; + return code; } void destroyStreamAggSupporter(SStreamAggSupporter* pSup) { @@ -3399,19 +3402,21 @@ static int32_t doStreamSessionAggNext(SOperatorInfo* pOperator, SSDataBlock** pp int32_t size = taosArrayGetSize(pInfo->pChildren); // if chIndex + 1 - size > 0, add new child for (int32_t i = 0; i < chIndex + 1 - size; i++) { - SOperatorInfo* pChildOp = - createStreamFinalSessionAggOperatorInfo(NULL, pInfo->pPhyNode, pOperator->pTaskInfo, 0, NULL); - if (!pChildOp) { + SOperatorInfo* pChildOp = NULL; + code = createStreamFinalSessionAggOperatorInfo(NULL, pInfo->pPhyNode, pOperator->pTaskInfo, 0, NULL, &pChildOp); + if (pChildOp == NULL || code != 0) { qError("%s create stream child of final session error", GET_TASKID(pTaskInfo)); code = TSDB_CODE_FAILED; QUERY_CHECK_CODE(code, lino, _end); } + void* tmp = taosArrayPush(pInfo->pChildren, &pChildOp); if (!tmp) { - code = TSDB_CODE_OUT_OF_MEMORY; + code = terrno; QUERY_CHECK_CODE(code, lino, _end); } } + SOperatorInfo* pChildOp = taosArrayGetP(pInfo->pChildren, chIndex); code = setInputDataBlock(&pChildOp->exprSupp, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); QUERY_CHECK_CODE(code, lino, _end); @@ -3651,8 +3656,10 @@ _end: } } -SOperatorInfo* createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, - SExecTaskInfo* pTaskInfo, SReadHandle* pHandle) { +int32_t createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, + SExecTaskInfo* pTaskInfo, SReadHandle* pHandle, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + SSessionWinodwPhysiNode* pSessionNode = (SSessionWinodwPhysiNode*)pPhyNode; int32_t numOfCols = 0; int32_t code = TSDB_CODE_OUT_OF_MEMORY; @@ -3660,6 +3667,7 @@ SOperatorInfo* createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPh SStreamSessionAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamSessionAggOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } @@ -3760,8 +3768,9 @@ SOperatorInfo* createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPh code = appendDownstream(pOperator, &downstream, 1); QUERY_CHECK_CODE(code, lino, _error); } - return pOperator; + *pOptrInfo = pOperator; + return code; _error: if (pInfo != NULL) { destroyStreamSessionAggOperatorInfo(pInfo); @@ -3769,8 +3778,8 @@ _error: taosMemoryFreeClear(pOperator); pTaskInfo->code = code; - qError("%s failed at line %d since %s. task:%s", __func__, lino, tstrerror(code), GET_TASKID(pTaskInfo)); - return NULL; + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + return code; } static void clearStreamSessionOperator(SStreamSessionAggOperatorInfo* pInfo) { @@ -3952,14 +3961,16 @@ static SSDataBlock* doStreamSessionSemiAgg(SOperatorInfo* pOperator) { return pRes; } -SOperatorInfo* createStreamFinalSessionAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, +int32_t createStreamFinalSessionAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, int32_t numOfChild, - SReadHandle* pHandle) { + SReadHandle* pHandle, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; - SOperatorInfo* pOperator = createStreamSessionAggOperatorInfo(downstream, pPhyNode, pTaskInfo, pHandle); - if (pOperator == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + SOperatorInfo* pOperator = NULL; + code = createStreamSessionAggOperatorInfo(downstream, pPhyNode, pTaskInfo, pHandle, &pOperator); + if (pOperator == NULL || code != 0) { QUERY_CHECK_CODE(code, lino, _error); } @@ -3979,11 +3990,12 @@ SOperatorInfo* createStreamFinalSessionAggOperatorInfo(SOperatorInfo* downstream if (numOfChild > 0) { pInfo->pChildren = taosArrayInit(numOfChild, sizeof(void*)); for (int32_t i = 0; i < numOfChild; i++) { - SOperatorInfo* pChildOp = createStreamFinalSessionAggOperatorInfo(NULL, pPhyNode, pTaskInfo, 0, pHandle); - if (pChildOp == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; + SOperatorInfo* pChildOp = NULL; + code = createStreamFinalSessionAggOperatorInfo(NULL, pPhyNode, pTaskInfo, 0, pHandle, &pChildOp); + if (pChildOp == NULL || code != 0) { QUERY_CHECK_CODE(code, lino, _error); } + SStreamSessionAggOperatorInfo* pChInfo = pChildOp->info; pChInfo->twAggSup.calTrigger = STREAM_TRIGGER_AT_ONCE; pAPI->stateStore.streamStateSetNumber(pChInfo->streamAggSup.pState, i, pInfo->primaryTsIndex); @@ -4010,7 +4022,8 @@ SOperatorInfo* createStreamFinalSessionAggOperatorInfo(SOperatorInfo* downstream pInfo->twAggSup.calTrigger = STREAM_TRIGGER_AT_ONCE; } - return pOperator; + *pOptrInfo = pOperator; + return code; _error: if (pInfo != NULL) { @@ -4021,7 +4034,7 @@ _error: if (code != TSDB_CODE_SUCCESS) { qError("%s failed at line %d since %s. task:%s", __func__, lino, tstrerror(code), GET_TASKID(pTaskInfo)); } - return NULL; + return code; } void destroyStreamStateOperatorInfo(void* param) { @@ -4779,14 +4792,15 @@ _end: } } -SOperatorInfo* createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, - SExecTaskInfo* pTaskInfo, SReadHandle* pHandle) { +int32_t createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, + SReadHandle* pHandle, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + int32_t code = 0; + int32_t lino = 0; + SStreamStateWinodwPhysiNode* pStateNode = (SStreamStateWinodwPhysiNode*)pPhyNode; int32_t tsSlotId = ((SColumnNode*)pStateNode->window.pTspk)->slotId; SColumnNode* pColNode = (SColumnNode*)(pStateNode->pStateKey); - int32_t code = TSDB_CODE_SUCCESS; - int32_t lino = 0; - SStreamStateAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamStateAggOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -4878,14 +4892,15 @@ SOperatorInfo* createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhys code = appendDownstream(pOperator, &downstream, 1); QUERY_CHECK_CODE(code, lino, _error); - return pOperator; + *pOptrInfo = pOperator; + return code; _error: destroyStreamStateOperatorInfo(pInfo); taosMemoryFreeClear(pOperator); pTaskInfo->code = code; - qError("%s failed at line %d since %s. task:%s", __func__, lino, tstrerror(code), GET_TASKID(pTaskInfo)); - return NULL; + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + return code; } #ifdef BUILD_NO_CALL @@ -5070,18 +5085,22 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) { return pRes; } -SOperatorInfo* createStreamIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, - SExecTaskInfo* pTaskInfo, SReadHandle* pHandle) { - int32_t code = TSDB_CODE_SUCCESS; - int32_t lino = 0; +int32_t createStreamIntervalOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, + SReadHandle* pHandle, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + int32_t numOfCols = 0; + SStreamIntervalOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamIntervalOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; QUERY_CHECK_CODE(code, lino, _error); } + SStreamIntervalPhysiNode* pIntervalPhyNode = (SStreamIntervalPhysiNode*)pPhyNode; - int32_t numOfCols = 0; SExprInfo* pExprInfo = createExprInfo(pIntervalPhyNode->window.pFuncs, NULL, &numOfCols); SSDataBlock* pResBlock = createDataBlockFromDescNode(pPhyNode->pOutputDataBlockDesc); @@ -5190,13 +5209,14 @@ SOperatorInfo* createStreamIntervalOperatorInfo(SOperatorInfo* downstream, SPhys code = appendDownstream(pOperator, &downstream, 1); QUERY_CHECK_CODE(code, lino, _error); - return pOperator; + *pOptrInfo = pOperator; + return code; _error: destroyStreamFinalIntervalOperatorInfo(pInfo); taosMemoryFreeClear(pOperator); pTaskInfo->code = code; - return NULL; + return code; } static void doStreamMidIntervalAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBlock, SSHashObj* pUpdatedMap) { diff --git a/source/libs/executor/src/sysscanoperator.c b/source/libs/executor/src/sysscanoperator.c index f00a0e175c..dc3c8f8070 100644 --- a/source/libs/executor/src/sysscanoperator.c +++ b/source/libs/executor/src/sysscanoperator.c @@ -1874,7 +1874,6 @@ static void getDBNameFromCondition(SNode* pCondition, const char* dbName) { static int32_t doSysTableScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) { // build message and send to mnode to fetch the content of system tables. - int32_t code = TSDB_CODE_SUCCESS; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SSysTableScanInfo* pInfo = pOperator->info; char dbName[TSDB_DB_NAME_LEN] = {0}; @@ -1883,7 +1882,7 @@ static int32_t doSysTableScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) if (isTaskKilled(pOperator->pTaskInfo)) { setOperatorCompleted(pOperator); (*ppRes) = NULL; - return code; + return pTaskInfo->code; } blockDataCleanup(pInfo->pRes); @@ -1926,10 +1925,10 @@ static int32_t doSysTableScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) continue; } (*ppRes) = pBlock; - return code; + return pTaskInfo->code; } else { (*ppRes) = NULL; - return code; + return pTaskInfo->code; } } } @@ -1937,6 +1936,9 @@ static int32_t doSysTableScanNext(SOperatorInfo* pOperator, SSDataBlock** ppRes) static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator) { SSDataBlock* pRes = NULL; int32_t code = doSysTableScanNext(pOperator, &pRes); + if (code) { + terrno = code; + } return pRes; } @@ -2065,13 +2067,16 @@ static SSDataBlock* sysTableScanFromMNode(SOperatorInfo* pOperator, SSysTableSca } } -SOperatorInfo* createSysTableScanOperatorInfo(void* readHandle, SSystemTableScanPhysiNode* pScanPhyNode, - const char* pUser, SExecTaskInfo* pTaskInfo) { +int32_t createSysTableScanOperatorInfo(void* readHandle, SSystemTableScanPhysiNode* pScanPhyNode, + const char* pUser, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; SSysTableScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SSysTableScanInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } @@ -2122,7 +2127,8 @@ SOperatorInfo* createSysTableScanOperatorInfo(void* readHandle, SSystemTableScan pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock); pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doSysTableScan, NULL, destroySysScanOperator, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); - return pOperator; + *pOptrInfo = pOperator; + return code; _error: if (pInfo != NULL) { @@ -2133,7 +2139,7 @@ _error: } taosMemoryFreeClear(pOperator); pTaskInfo->code = code; - return NULL; + return code; } void extractTbnameSlotId(SSysTableScanInfo* pInfo, const SScanPhysiNode* pScanNode) { @@ -2667,14 +2673,16 @@ static int32_t initTableblockDistQueryCond(uint64_t uid, SQueryTableDataCond* pC return TSDB_CODE_SUCCESS; } -SOperatorInfo* createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDistScanPhysiNode* pBlockScanNode, - STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo) { - int32_t code = TSDB_CODE_SUCCESS; - int32_t lino = 0; +int32_t createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDistScanPhysiNode* pBlockScanNode, + STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + + int32_t code = 0; + int32_t lino = 0; SBlockDistInfo* pInfo = taosMemoryCalloc(1, sizeof(SBlockDistInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { - pTaskInfo->code = TSDB_CODE_OUT_OF_MEMORY; + pTaskInfo->code = code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } @@ -2709,10 +2717,11 @@ SOperatorInfo* createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDi OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doBlockInfoScan, NULL, destroyBlockDistScanOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); - return pOperator; + *pOptrInfo = pOperator; + return code; _error: taosMemoryFreeClear(pInfo); taosMemoryFreeClear(pOperator); - return NULL; + return code; } diff --git a/source/libs/executor/src/timesliceoperator.c b/source/libs/executor/src/timesliceoperator.c index 35ae59a555..6eaef50491 100644 --- a/source/libs/executor/src/timesliceoperator.c +++ b/source/libs/executor/src/timesliceoperator.c @@ -1109,12 +1109,16 @@ static int32_t extractPkColumnFromFuncs(SNodeList* pFuncs, bool* pHasPk, SColumn return TSDB_CODE_SUCCESS; } -SOperatorInfo* createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo) { - int32_t code = TSDB_CODE_SUCCESS; - int32_t lino = 0; +int32_t createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + + int32_t code = 0; + int32_t lino = 0; STimeSliceOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STimeSliceOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + if (pOperator == NULL || pInfo == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } @@ -1184,8 +1188,9 @@ SOperatorInfo* createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode // int32_t code = initKeeperInfo(pSliceInfo, pBlock, &pOperator->exprSupp); code = appendDownstream(pOperator, &downstream, 1); - QUERY_CHECK_CODE(code, lino, _error); - return pOperator; + + *pOptrInfo = pOperator; + return code; _error: if (code != TSDB_CODE_SUCCESS) { @@ -1193,8 +1198,8 @@ _error: } taosMemoryFree(pInfo); taosMemoryFree(pOperator); - pTaskInfo->code = TSDB_CODE_OUT_OF_MEMORY; - return NULL; + pTaskInfo->code = code; + return code; } void destroyTimeSliceOperatorInfo(void* param) { diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c index 1279d5f850..a1ec923352 100644 --- a/source/libs/executor/src/timewindowoperator.c +++ b/source/libs/executor/src/timewindowoperator.c @@ -1271,13 +1271,16 @@ _end: return needed; } -SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPhysiNode* pPhyNode, - SExecTaskInfo* pTaskInfo) { +int32_t createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo, + SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + 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) { + code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } @@ -1367,7 +1370,8 @@ SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPh goto _error; } - return pOperator; + *pOptrInfo = pOperator; + return code; _error: if (pInfo != NULL) { @@ -1375,7 +1379,7 @@ _error: } taosMemoryFreeClear(pOperator); pTaskInfo->code = code; - return NULL; + return code; } // todo handle multiple timeline cases. assume no timeline interweaving @@ -1555,13 +1559,16 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) { } // todo make this as an non-blocking operator -SOperatorInfo* createStatewindowOperatorInfo(SOperatorInfo* downstream, SStateWinodwPhysiNode* pStateNode, - SExecTaskInfo* pTaskInfo) { +int32_t createStatewindowOperatorInfo(SOperatorInfo* downstream, SStateWinodwPhysiNode* pStateNode, + SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + 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) { + code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } @@ -1572,8 +1579,7 @@ SOperatorInfo* createStatewindowOperatorInfo(SOperatorInfo* downstream, SStateWi if (pStateNode->window.pExprs != NULL) { int32_t numOfScalarExpr = 0; SExprInfo* pScalarExprInfo = createExprInfo(pStateNode->window.pExprs, NULL, &numOfScalarExpr); - int32_t code = - initExprSupp(&pInfo->scalarSup, pScalarExprInfo, numOfScalarExpr, &pTaskInfo->storageAPI.functionStore); + code = initExprSupp(&pInfo->scalarSup, pScalarExprInfo, numOfScalarExpr, &pTaskInfo->storageAPI.functionStore); if (code != TSDB_CODE_SUCCESS) { goto _error; } @@ -1628,7 +1634,8 @@ SOperatorInfo* createStatewindowOperatorInfo(SOperatorInfo* downstream, SStateWi goto _error; } - return pOperator; + *pOptrInfo = pOperator; + return code; _error: if (pInfo != NULL) { @@ -1637,7 +1644,7 @@ _error: taosMemoryFreeClear(pOperator); pTaskInfo->code = code; - return NULL; + return code; } void destroySWindowOperatorInfo(void* param) { @@ -1656,13 +1663,16 @@ void destroySWindowOperatorInfo(void* param) { taosMemoryFreeClear(param); } -SOperatorInfo* createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionWinodwPhysiNode* pSessionNode, - SExecTaskInfo* pTaskInfo) { +int32_t createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionWinodwPhysiNode* pSessionNode, + SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + 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) { + code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } @@ -1721,13 +1731,14 @@ SOperatorInfo* createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionW goto _error; } - return pOperator; + *pOptrInfo = pOperator; + return code; _error: destroySWindowOperatorInfo(pInfo); taosMemoryFreeClear(pOperator); pTaskInfo->code = code; - return NULL; + return code; } void destroyMAIOperatorInfo(void* param) { @@ -1956,18 +1967,22 @@ static SSDataBlock* mergeAlignedIntervalAgg(SOperatorInfo* pOperator) { return pRes; } -SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SMergeAlignedIntervalPhysiNode* pNode, - SExecTaskInfo* pTaskInfo) { +int32_t createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SMergeAlignedIntervalPhysiNode* pNode, + SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + 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) { + code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } miaInfo->intervalAggOperatorInfo = taosMemoryCalloc(1, sizeof(SIntervalAggOperatorInfo)); if (miaInfo->intervalAggOperatorInfo == NULL) { + code = terrno; goto _error; } @@ -2025,13 +2040,14 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, code = appendDownstream(pOperator, &downstream, 1); QUERY_CHECK_CODE(code, lino, _error); - return pOperator; + *pOptrInfo = pOperator; + return code; _error: destroyMAIOperatorInfo(miaInfo); taosMemoryFreeClear(pOperator); pTaskInfo->code = code; - return NULL; + return code; } //===================================================================================================================== @@ -2282,13 +2298,16 @@ static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) { return pRes; } -SOperatorInfo* createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SMergeIntervalPhysiNode* pIntervalPhyNode, - SExecTaskInfo* pTaskInfo) { +int32_t createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SMergeIntervalPhysiNode* pIntervalPhyNode, + SExecTaskInfo* pTaskInfo, SOperatorInfo** pOptrInfo) { + QRY_OPTR_CHECK(pOptrInfo); + 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) { + code = TSDB_CODE_OUT_OF_MEMORY; goto _error; } @@ -2348,8 +2367,8 @@ SOperatorInfo* createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SMerge goto _error; } - return pOperator; - + *pOptrInfo = pOperator; + return code; _error: if (pMergeIntervalInfo != NULL) { destroyMergeIntervalOperatorInfo(pMergeIntervalInfo); @@ -2357,5 +2376,5 @@ _error: taosMemoryFreeClear(pOperator); pTaskInfo->code = code; - return NULL; + return code; } diff --git a/source/libs/executor/src/tsort.c b/source/libs/executor/src/tsort.c index b4e5a9a01a..36c3d49810 100644 --- a/source/libs/executor/src/tsort.c +++ b/source/libs/executor/src/tsort.c @@ -169,7 +169,13 @@ static void* tupleGetField(char* t, uint32_t colIdx, uint32_t colNum) { int32_t tsortGetSortedDataBlock(const SSortHandle* pSortHandle, SSDataBlock** pBlock) { if (pBlock == NULL) { - return TSDB_CODE_INVALID_PARA; + *pBlock = NULL; + return TSDB_CODE_SUCCESS; + } + + if (pSortHandle->pDataBlock == NULL) { + *pBlock = NULL; + return TSDB_CODE_SUCCESS; } *pBlock = createOneDataBlock(pSortHandle->pDataBlock, false); @@ -2293,12 +2299,11 @@ void tsortSetMergeLimit(SSortHandle* pHandle, int64_t mergeLimit) { pHandle->mergeLimit = mergeLimit; } -int32_t tsortSetFetchRawDataFp(SSortHandle* pHandle, _sort_fetch_block_fn_t fetchFp, void (*fp)(SSDataBlock*, void*), +void tsortSetFetchRawDataFp(SSortHandle* pHandle, _sort_fetch_block_fn_t fetchFp, void (*fp)(SSDataBlock*, void*), void* param) { pHandle->fetchfp = fetchFp; pHandle->beforeFp = fp; pHandle->param = param; - return TSDB_CODE_SUCCESS; } void tsortSetComparFp(SSortHandle* pHandle, _sort_merge_compar_fn_t fp) { diff --git a/source/libs/executor/test/joinTests.cpp b/source/libs/executor/test/joinTests.cpp index 95a4a5e841..11bb9ad2b1 100755 --- a/source/libs/executor/test/joinTests.cpp +++ b/source/libs/executor/test/joinTests.cpp @@ -2853,7 +2853,7 @@ void resetForJoinRerun(int32_t dsNum, SSortMergeJoinPhysiNode* pNode, SExecTaskI SOperatorInfo* pDownstreams[2]; createDummyDownstreamOperators(2, pDownstreams); SOperatorInfo* ppDownstreams[] = {pDownstreams[0], pDownstreams[1]}; - jtCtx.pJoinOp = createMergeJoinOperatorInfo(ppDownstreams, 2, pNode, pTask); + int32_t code = createMergeJoinOperatorInfo(ppDownstreams, 2, pNode, pTask, &jtCtx.pJoinOp); ASSERT_TRUE(NULL != jtCtx.pJoinOp); } diff --git a/source/libs/stream/src/streamTask.c b/source/libs/stream/src/streamTask.c index 0110a9825c..141bd8fc3e 100644 --- a/source/libs/stream/src/streamTask.c +++ b/source/libs/stream/src/streamTask.c @@ -602,9 +602,11 @@ int32_t streamTaskStop(SStreamTask* pTask) { stError("failed to handle STOP event, s-task:%s", id); } - code = qKillTask(pTask->exec.pExecutor, TSDB_CODE_SUCCESS); - if (code) { - stError("s-task:%s failed to kill task related query handle", id); + if (pTask->info.taskLevel != TASK_LEVEL__SINK) { + code = qKillTask(pTask->exec.pExecutor, TSDB_CODE_SUCCESS); + if (code) { + stError("s-task:%s failed to kill task related query handle", id); + } } while (!streamTaskIsIdle(pTask)) { diff --git a/source/os/src/osThread.c b/source/os/src/osThread.c index 133623ca3c..cf1fef71c2 100644 --- a/source/os/src/osThread.c +++ b/source/os/src/osThread.c @@ -767,7 +767,7 @@ int32_t taosThreadSetSpecific(TdThreadKey key, const void *value) { terrno = TAOS_SYSTEM_ERROR(code); return terrno; } - return code; + return code; } int32_t taosThreadSpinDestroy(TdThreadSpinlock *lock) { @@ -779,7 +779,7 @@ int32_t taosThreadSpinDestroy(TdThreadSpinlock *lock) { terrno = TAOS_SYSTEM_ERROR(code); return terrno; } - return code; + return code; #endif } @@ -794,7 +794,7 @@ int32_t taosThreadSpinInit(TdThreadSpinlock *lock, int32_t pshared) { terrno = TAOS_SYSTEM_ERROR(code); return terrno; } - return code; + return code; #endif } @@ -807,7 +807,7 @@ int32_t taosThreadSpinLock(TdThreadSpinlock *lock) { terrno = TAOS_SYSTEM_ERROR(code); return terrno; } - return code; + return code; #endif } @@ -818,9 +818,9 @@ int32_t taosThreadSpinTrylock(TdThreadSpinlock *lock) { int32_t code = pthread_spin_trylock((pthread_spinlock_t *)lock); if (code) { terrno = TAOS_SYSTEM_ERROR(code); - return terrno; + return code; } - return code; + return code; #endif } @@ -833,7 +833,7 @@ int32_t taosThreadSpinUnlock(TdThreadSpinlock *lock) { terrno = TAOS_SYSTEM_ERROR(code); return terrno; } - return code; + return code; #endif }