diff --git a/source/libs/executor/inc/executil.h b/source/libs/executor/inc/executil.h index 27ea98afd5..7b27b41177 100644 --- a/source/libs/executor/inc/executil.h +++ b/source/libs/executor/inc/executil.h @@ -106,9 +106,9 @@ typedef struct STableListInfo { int32_t numOfOuputGroups; // the data block will be generated one by one int32_t* groupOffset; // keep the offset value for each group in the tableList SArray* pTableList; - SHashObj* map; // speedup acquire the tableQueryInfo by table uid - SHashObj* remainGroups; // remaining group has not yet processed the empty group - STableListIdInfo idInfo; // this maybe the super table or ordinary table + SHashObj* map; // speedup acquire the tableQueryInfo by table uid + SHashObj* remainGroups; // remaining group has not yet processed the empty group + STableListIdInfo idInfo; // this maybe the super table or ordinary table } STableListInfo; struct SqlFunctionCtx; @@ -118,7 +118,7 @@ int32_t createScanTableListInfo(SScanPhysiNode* pScanNode, SNodeList* pGroupTags SExecTaskInfo* pTaskInfo); STableListInfo* tableListCreate(); -void* tableListDestroy(STableListInfo* pTableListInfo); +void tableListDestroy(STableListInfo* pTableListInfo); void tableListClear(STableListInfo* pTableListInfo); int32_t tableListGetOutputGroups(const STableListInfo* pTableList); bool oneTableForEachGroup(const STableListInfo* pTableList); @@ -130,7 +130,7 @@ uint64_t tableListGetSize(const STableListInfo* pTableList); uint64_t tableListGetSuid(const STableListInfo* pTableList); STableKeyInfo* tableListGetInfo(const STableListInfo* pTableList, int32_t index); int32_t tableListFind(const STableListInfo* pTableList, uint64_t uid, int32_t startIndex); -void tableListGetSourceTableInfo(const STableListInfo* pTableList, uint64_t* psuid, uint64_t* uid, int32_t* type); +void tableListGetSourceTableInfo(const STableListInfo* pTableList, uint64_t* psuid, uint64_t* uid, int32_t* type); size_t getResultRowSize(struct SqlFunctionCtx* pCtx, int32_t numOfOutput); void initResultRowInfo(SResultRowInfo* pResultRowInfo); @@ -165,7 +165,8 @@ SSDataBlock* createDataBlockFromDescNode(SDataBlockDescNode* pNode); int32_t prepareDataBlockBuf(SSDataBlock* pDataBlock, SColMatchInfo* pMatchInfo); EDealRes doTranslateTagExpr(SNode** pNode, void* pContext); -int32_t getGroupIdFromTagsVal(void* pVnode, uint64_t uid, SNodeList* pGroupNode, char* keyBuf, uint64_t* pGroupId, SStorageAPI* pAPI); +int32_t getGroupIdFromTagsVal(void* pVnode, uint64_t uid, SNodeList* pGroupNode, char* keyBuf, uint64_t* pGroupId, + SStorageAPI* pAPI); size_t getTableTagsBufLen(const SNodeList* pGroups); SArray* createSortInfo(SNodeList* pNodeList); @@ -173,18 +174,20 @@ SArray* makeColumnArrayFromList(SNodeList* pNodeList); int32_t extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNodeList, int32_t* numOfOutputCols, int32_t type, SColMatchInfo* pMatchInfo); -void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId); -void createExprFromTargetNode(SExprInfo* pExp, STargetNode* pTargetNode); +int32_t createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId); +int32_t createExprFromTargetNode(SExprInfo* pExp, STargetNode* pTargetNode); SExprInfo* createExprInfo(SNodeList* pNodeList, SNodeList* pGroupKeys, int32_t* numOfExprs); -SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, int32_t** rowEntryInfoOffset, SFunctionStateStore* pStore); -void relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray* pCols, bool outputEveryColumn); +SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, int32_t** rowEntryInfoOffset, + SFunctionStateStore* pStore); +int32_t relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray* pCols, bool outputEveryColumn); int32_t initExecTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pQueryWindow); SInterval extractIntervalInfo(const STableScanPhysiNode* pTableScanNode); SColumn extractColumnFromColumnNode(SColumnNode* pColNode); -int32_t initQueryTableDataCond(SQueryTableDataCond* pCond, const STableScanPhysiNode* pTableScanNode, const SReadHandle* readHandle); +int32_t initQueryTableDataCond(SQueryTableDataCond* pCond, const STableScanPhysiNode* pTableScanNode, + const SReadHandle* readHandle); void cleanupQueryTableDataCond(SQueryTableDataCond* pCond); int32_t convertFillType(int32_t mode); @@ -198,7 +201,7 @@ void getNextTimeWindow(const SInterval* pInterval, STimeWindow* tw, int32_t orde void getInitialStartTimeWindow(SInterval* pInterval, TSKEY ts, STimeWindow* w, bool ascQuery); TSKEY getStartTsKey(STimeWindow* win, const TSKEY* tsCols); -void updateTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pWin, int64_t delta); +void updateTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pWin, int64_t delta); SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, SArray* pUidTagList, void* pVnode, SStorageAPI* pStorageAPI); @@ -212,9 +215,9 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S int32_t buildKeys(char* keyBuf, const SArray* pSortGroupCols, const SSDataBlock* pBlock, int32_t rowIndex); int32_t compKeys(const SArray* pSortGroupCols, const char* oldkeyBuf, int32_t oldKeysLen, const SSDataBlock* pDataBlock, - int32_t rowIndex); + int32_t rowIndex); -uint64_t calcGroupId(char *pData, int32_t len); +uint64_t calcGroupId(char* pData, int32_t len); SNodeList* makeColsNodeArrFromSortKeys(SNodeList* pSortKeys); diff --git a/source/libs/executor/inc/executorInt.h b/source/libs/executor/inc/executorInt.h index fec16f9ef4..31fdc5b291 100644 --- a/source/libs/executor/inc/executorInt.h +++ b/source/libs/executor/inc/executorInt.h @@ -903,7 +903,7 @@ int32_t appendDataToSpecialBlock(SSDataBlock* pBlock, TSKEY* pStartTs, TSKEY* pE uint64_t calGroupIdByData(SPartitionBySupporter* pParSup, SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t rowId); -int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, SExprSupp* pSup, +void finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, SExprSupp* pSup, SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo); bool groupbyTbname(SNodeList* pGroupList); diff --git a/source/libs/executor/inc/tfill.h b/source/libs/executor/inc/tfill.h index 82d422302c..cd003ebd15 100644 --- a/source/libs/executor/inc/tfill.h +++ b/source/libs/executor/inc/tfill.h @@ -20,6 +20,7 @@ extern "C" { #endif +#include "executil.h" #include "os.h" #include "taosdef.h" #include "tcommon.h" @@ -77,6 +78,7 @@ typedef struct SFillInfo { SFillColInfo* pFillCol; // column info for fill operations SFillTagColInfo* pTags; // tags value for filling gap const char* id; + SExecTaskInfo* pTaskInfo; } SFillInfo; typedef struct SResultCellData { @@ -128,10 +130,10 @@ bool taosFillHasMoreResults(struct SFillInfo* pFillInfo); SFillInfo* taosCreateFillInfo(TSKEY skey, int32_t numOfFillCols, int32_t numOfNotFillCols, int32_t capacity, SInterval* pInterval, int32_t fillType, struct SFillColInfo* pCol, int32_t slotId, - int32_t order, const char* id); + int32_t order, const char* id, SExecTaskInfo* pTaskInfo); void* taosDestroyFillInfo(struct SFillInfo* pFillInfo); -void taosFillResultDataBlock(struct SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity); +int32_t taosFillResultDataBlock(struct SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity); int64_t getFillInfoStart(struct SFillInfo* pFillInfo); bool fillIfWindowPseudoColumn(SFillInfo* pFillInfo, SFillColInfo* pCol, SColumnInfoData* pDstColInfoData, diff --git a/source/libs/executor/src/aggregateoperator.c b/source/libs/executor/src/aggregateoperator.c index 55cb8c8302..1e86b90d3b 100644 --- a/source/libs/executor/src/aggregateoperator.c +++ b/source/libs/executor/src/aggregateoperator.c @@ -194,7 +194,9 @@ static bool nextGroupedResult(SOperatorInfo* pOperator) { pBlock = getNextBlockFromDownstream(pOperator, 0); if (pBlock == NULL) { if (!pAggInfo->hasValidBlock) { - createDataBlockForEmptyInput(pOperator, &pBlock); + code = createDataBlockForEmptyInput(pOperator, &pBlock); + QUERY_CHECK_CODE(code, lino, _end); + if (pBlock == NULL) { break; } @@ -240,7 +242,7 @@ static bool nextGroupedResult(SOperatorInfo* pOperator) { } initGroupedResultInfo(&pAggInfo->groupResInfo, pAggInfo->aggSup.pResultRowHashTable, 0); - + _end: if (code != TSDB_CODE_SUCCESS) { qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); @@ -251,6 +253,8 @@ _end: } SSDataBlock* getAggregateResult(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SAggOperatorInfo* pAggInfo = pOperator->info; SOptrBasicInfo* pInfo = &pAggInfo->binfo; @@ -262,11 +266,13 @@ SSDataBlock* getAggregateResult(SOperatorInfo* pOperator) { bool hasNewGroups = false; do { hasNewGroups = nextGroupedResult(pOperator); - blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _end); while (1) { doBuildResultDatablock(pOperator, pInfo, &pAggInfo->groupResInfo, pAggInfo->aggSup.pResultBuf); - doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); if (!hasRemainResults(&pAggInfo->groupResInfo)) { if (!hasNewGroups) setOperatorCompleted(pOperator); @@ -282,6 +288,12 @@ SSDataBlock* getAggregateResult(SOperatorInfo* pOperator) { size_t rows = blockDataGetNumOfRows(pInfo->pRes); pOperator->resultInfo.totalRows += rows; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } + return (rows == 0) ? NULL : pInfo->pRes; } @@ -312,6 +324,8 @@ int32_t doAggregateImpl(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx) { } static int32_t createDataBlockForEmptyInput(SOperatorInfo* pOperator, SSDataBlock** ppBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (!tsCountAlwaysReturnValue) { return TSDB_CODE_SUCCESS; } @@ -352,9 +366,12 @@ static int32_t createDataBlockForEmptyInput(SOperatorInfo* pOperator, SSDataBloc int32_t slotId = pFuncParam->pCol->slotId; int32_t numOfCols = taosArrayGetSize(pBlock->pDataBlock); if (slotId >= numOfCols) { - taosArrayEnsureCap(pBlock->pDataBlock, slotId + 1); + code = taosArrayEnsureCap(pBlock->pDataBlock, slotId + 1); + QUERY_CHECK_CODE(code, lino, _end); + for (int32_t k = numOfCols; k < slotId + 1; ++k) { - taosArrayPush(pBlock->pDataBlock, &colInfo); + void* tmp = taosArrayPush(pBlock->pDataBlock, &colInfo); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } } } else if (pFuncParam->type == FUNC_PARAM_TYPE_VALUE) { @@ -363,14 +380,20 @@ static int32_t createDataBlockForEmptyInput(SOperatorInfo* pOperator, SSDataBloc } } - blockDataEnsureCapacity(pBlock, pBlock->info.rows); + code = blockDataEnsureCapacity(pBlock, pBlock->info.rows); + QUERY_CHECK_CODE(code, lino, _end); + for (int32_t i = 0; i < blockDataGetNumOfCols(pBlock); ++i) { SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, i); colDataSetNULL(pColInfoData, 0); } *ppBlock = pBlock; - return TSDB_CODE_SUCCESS; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + } + return code; } void destroyDataBlockForEmptyInput(bool blockAllocated, SSDataBlock** ppBlock) { @@ -571,7 +594,12 @@ void applyAggFunctionOnPartialTuples(SExecTaskInfo* taskInfo, SqlFunctionCtx* pC SScalarParam out = {.columnData = &idata}; SScalarParam tw = {.numOfRows = 5, .columnData = pTimeWindowData}; - pCtx[k].sfp.process(&tw, 1, &out); + int32_t code = pCtx[k].sfp.process(&tw, 1, &out); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + taskInfo->code = code; + T_LONG_JMP(taskInfo->env, code); + } pEntryInfo->numOfRes = 1; } else { int32_t code = TSDB_CODE_SUCCESS; diff --git a/source/libs/executor/src/cachescanoperator.c b/source/libs/executor/src/cachescanoperator.c index ad7d089da9..8559a44348 100644 --- a/source/libs/executor/src/cachescanoperator.c +++ b/source/libs/executor/src/cachescanoperator.c @@ -13,8 +13,8 @@ * along with this program. If not, see . */ -#include "os.h" #include "function.h" +#include "os.h" #include "tname.h" #include "tdatablock.h" @@ -63,7 +63,7 @@ static void setColIdForCacheReadBlock(SSDataBlock* pBlock, SLastRowScanPhysiNode int32_t idx = 0; FOREACH(pNode, pScan->pTargets) { if (nodeType(pNode) == QUERY_NODE_COLUMN) { - SColumnNode* pCol = (SColumnNode*)pNode; + SColumnNode* pCol = (SColumnNode*)pNode; SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, idx); pColInfo->info.colId = pCol->colId; } @@ -87,6 +87,7 @@ static void setColIdForCacheReadBlock(SSDataBlock* pBlock, SLastRowScanPhysiNode SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SReadHandle* readHandle, STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo) { int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; int32_t numOfCols = 0; SNodeList* pScanCols = pScanNode->scan.pScanCols; SCacheRowsScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SCacheRowsScanInfo)); @@ -105,9 +106,7 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe pInfo->pRes = createDataBlockFromDescNode(pDescNode); code = extractColMatchInfo(pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); // todo: the pk information should comes from the physical plan // pk info may not in pScanCols, so extract primary key from pInfo->matchInfo may failed @@ -121,7 +120,7 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe pInfo->pkCol.pk = 1; } } else { - for(int32_t i = 0; i < taosArrayGetSize(pInfo->matchInfo.pList); ++i) { + for (int32_t i = 0; i < taosArrayGetSize(pInfo->matchInfo.pList); ++i) { SColMatchItem* pItem = taosArrayGet(pInfo->matchInfo.pList, i); if (pItem->isPk) { pInfo->numOfPks += 1; @@ -134,23 +133,24 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe SArray* pCidList = taosArrayInit(numOfCols, sizeof(int16_t)); pInfo->pFuncTypeList = taosArrayInit(taosArrayGetSize(pScanNode->pFuncTypes), sizeof(int32_t)); - taosArrayAddAll(pInfo->pFuncTypeList, pScanNode->pFuncTypes); + void* tmp = taosArrayAddAll(pInfo->pFuncTypeList, pScanNode->pFuncTypes); + QUERY_CHECK_NULL(tmp, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); for (int i = 0; i < TARRAY_SIZE(pInfo->matchInfo.pList); ++i) { SColMatchItem* pColInfo = taosArrayGet(pInfo->matchInfo.pList, i); - taosArrayPush(pCidList, &pColInfo->colId); + void* tmp = taosArrayPush(pCidList, &pColInfo->colId); + QUERY_CHECK_NULL(tmp, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); if (pInfo->pFuncTypeList != NULL && taosArrayGetSize(pInfo->pFuncTypeList) > i) { pColInfo->funcType = *(int32_t*)taosArrayGet(pInfo->pFuncTypeList, i); } } pInfo->pCidList = pCidList; - removeRedundantTsCol(pScanNode, &pInfo->matchInfo); + code = removeRedundantTsCol(pScanNode, &pInfo->matchInfo); + QUERY_CHECK_CODE(code, lino, _error); code = extractCacheScanSlotId(pInfo->matchInfo.pList, pTaskInfo, &pInfo->pSlotIds, &pInfo->pDstSlotIds); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); int32_t totalTables = tableListGetSize(pTableListInfo); int32_t capacity = 0; @@ -166,17 +166,16 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe uint64_t suid = tableListGetSuid(pTableListInfo); code = pInfo->readHandle.api.cacheFn.openReader(pInfo->readHandle.vnode, pInfo->retrieveType, pList, totalTables, taosArrayGetSize(pInfo->matchInfo.pList), pCidList, pInfo->pSlotIds, - suid, &pInfo->pLastrowReader, pTaskInfo->id.str, pScanNode->pFuncTypes, - &pInfo->pkCol, pInfo->numOfPks); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + suid, &pInfo->pLastrowReader, pTaskInfo->id.str, + pScanNode->pFuncTypes, &pInfo->pkCol, pInfo->numOfPks); + QUERY_CHECK_CODE(code, lino, _error); capacity = TMIN(totalTables, 4096); pInfo->pBufferedRes = createOneDataBlock(pInfo->pRes, false); setColIdForCacheReadBlock(pInfo->pBufferedRes, pScanNode); - blockDataEnsureCapacity(pInfo->pBufferedRes, capacity); + code = blockDataEnsureCapacity(pInfo->pBufferedRes, capacity); + QUERY_CHECK_CODE(code, lino, _error); } else { // by tags pInfo->retrieveType = CACHESCAN_RETRIEVE_TYPE_SINGLE | SCAN_ROW_TYPE(pScanNode->ignoreNull); capacity = 1; // only one row output @@ -184,26 +183,31 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe } initResultSizeInfo(&pOperator->resultInfo, capacity); - blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _error); if (pScanNode->scan.pScanPseudoCols != NULL) { SExprSupp* p = &pInfo->pseudoExprSup; p->pExprInfo = createExprInfo(pScanNode->scan.pScanPseudoCols, NULL, &p->numOfExprs); - p->pCtx = createSqlFunctionCtx(p->pExprInfo, p->numOfExprs, &p->rowEntryInfoOffset, &pTaskInfo->storageAPI.functionStore); + p->pCtx = + createSqlFunctionCtx(p->pExprInfo, p->numOfExprs, &p->rowEntryInfoOffset, &pTaskInfo->storageAPI.functionStore); } setOperatorInfo(pOperator, "CachedRowScanOperator", QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN, false, OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock); - pOperator->fpSet = - createOperatorFpSet(optrDummyOpenFn, doScanCache, NULL, destroyCacheScanOperator, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); + pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doScanCache, NULL, destroyCacheScanOperator, optrDefaultBufFn, + NULL, optrDefaultGetNextExtFn, NULL); pOperator->cost.openCost = 0; return pOperator; _error: pTaskInfo->code = code; + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + } destroyCacheScanOperator(pInfo); taosMemoryFree(pOperator); return NULL; @@ -258,7 +262,7 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) { if (pInfo->indexOfBufferedRes < pBufRes->info.rows) { for (int32_t i = 0; i < taosArrayGetSize(pBufRes->pDataBlock); ++i) { SColumnInfoData* pCol = taosArrayGet(pRes->pDataBlock, i); - int32_t slotId = pCol->info.slotId; + int32_t slotId = pCol->info.slotId; SColumnInfoData* pSrc = taosArrayGet(pBufRes->pDataBlock, slotId); SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, slotId); @@ -267,8 +271,12 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) { colDataSetNULL(pDst, 0); } else { if (pSrc->pData) { - char* p = colDataGetData(pSrc, pInfo->indexOfBufferedRes); - colDataSetVal(pDst, 0, p, false); + char* p = colDataGetData(pSrc, pInfo->indexOfBufferedRes); + int32_t code = colDataSetVal(pDst, 0, p, false); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } } } @@ -320,7 +328,11 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) { continue; } } else { - pReaderFn->reuseReader(pInfo->pLastrowReader, pList, num); + code = pReaderFn->reuseReader(pInfo->pLastrowReader, pList, num); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } taosArrayClear(pInfo->pUidList); @@ -352,10 +364,10 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) { } } - //pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader); + // pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader); return pInfo->pRes; } else { - //pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader); + // pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader); } } @@ -400,12 +412,12 @@ int32_t extractCacheScanSlotId(const SArray* pColMatchInfo, SExecTaskInfo* pTask return TSDB_CODE_OUT_OF_MEMORY; } - SSchemaInfo* pSchemaInfo = taosArrayGetLast(pTaskInfo->schemaInfos); + SSchemaInfo* pSchemaInfo = taosArrayGetLast(pTaskInfo->schemaInfos); SSchemaWrapper* pWrapper = pSchemaInfo->sw; for (int32_t i = 0; i < numOfCols; ++i) { SColMatchItem* pColMatch = taosArrayGet(pColMatchInfo, i); - bool found = false; + bool found = false; for (int32_t j = 0; j < pWrapper->nCols; ++j) { /* if (pColMatch->colId == pWrapper->pSchema[j].colId && pColMatch->colId == PRIMARYKEY_TIMESTAMP_COL_ID) { (*pSlotIds)[pColMatch->dstSlotId] = -1; @@ -429,12 +441,15 @@ int32_t extractCacheScanSlotId(const SArray* pColMatchInfo, SExecTaskInfo* pTask } int32_t removeRedundantTsCol(SLastRowScanPhysiNode* pScanNode, SColMatchInfo* pColMatchInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (!pScanNode->ignoreNull) { // retrieve cached last value return TSDB_CODE_SUCCESS; } size_t size = taosArrayGetSize(pColMatchInfo->pList); SArray* pMatchInfo = taosArrayInit(size, sizeof(SColMatchItem)); + QUERY_CHECK_NULL(pMatchInfo, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); for (int32_t i = 0; i < size; ++i) { SColMatchItem* pColInfo = taosArrayGet(pColMatchInfo->pList, i); @@ -444,13 +459,20 @@ int32_t removeRedundantTsCol(SLastRowScanPhysiNode* pScanNode, SColMatchInfo* pC SSlotDescNode* pDesc = (SSlotDescNode*)nodesListGetNode(pList, slotId); if (pDesc->dataType.type != TSDB_DATA_TYPE_TIMESTAMP) { - taosArrayPush(pMatchInfo, pColInfo); - } else if (FUNCTION_TYPE_CACHE_LAST_ROW == pColInfo->funcType){ - taosArrayPush(pMatchInfo, pColInfo); + void* tmp = taosArrayPush(pMatchInfo, pColInfo); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + } else if (FUNCTION_TYPE_CACHE_LAST_ROW == pColInfo->funcType) { + void* tmp = taosArrayPush(pMatchInfo, pColInfo); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } } taosArrayDestroy(pColMatchInfo->pList); pColMatchInfo->pList = pMatchInfo; - return TSDB_CODE_SUCCESS; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } diff --git a/source/libs/executor/src/countwindowoperator.c b/source/libs/executor/src/countwindowoperator.c index 55f73b9417..58d289efe4 100644 --- a/source/libs/executor/src/countwindowoperator.c +++ b/source/libs/executor/src/countwindowoperator.c @@ -74,12 +74,15 @@ static SCountWindowResult* getCountWinStateInfo(SCountWindowSupp* pCountSup) { return pBuffInfo; } -static SCountWindowResult* setCountWindowOutputBuff(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, - SResultRow** pResult) { +static int32_t setCountWindowOutputBuff(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, SResultRow** pResult, + SCountWindowResult** ppResBuff) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SCountWindowResult* pBuff = getCountWinStateInfo(pCountSup); (*pResult) = &pBuff->row; - setResultRowInitCtx(*pResult, pExprSup->pCtx, pExprSup->numOfExprs, pExprSup->rowEntryInfoOffset); - return pBuff; + code = setResultRowInitCtx(*pResult, pExprSup->pCtx, pExprSup->numOfExprs, pExprSup->rowEntryInfoOffset); + (*ppResBuff) = pBuff; + return code; } static int32_t updateCountWindowInfo(int32_t start, int32_t blockRows, int32_t countWinRows, int32_t* pCurrentRows) { @@ -88,20 +91,26 @@ static int32_t updateCountWindowInfo(int32_t start, int32_t blockRows, int32_t c return rows; } -int32_t doCountWindowAggImpl(SOperatorInfo* pOperator, SSDataBlock* pBlock) { +void doCountWindowAggImpl(SOperatorInfo* pOperator, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SExprSupp* pExprSup = &pOperator->exprSupp; SCountWindowOperatorInfo* pInfo = pOperator->info; SSDataBlock* pRes = pInfo->binfo.pRes; SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, pInfo->tsSlotId); TSKEY* tsCols = (TSKEY*)pColInfoData->pData; - int32_t code = TSDB_CODE_SUCCESS; for (int32_t i = 0; i < pBlock->info.rows;) { - SCountWindowResult* pBuffInfo = setCountWindowOutputBuff(pExprSup, &pInfo->countSup, &pInfo->pRow); - int32_t prevRows = pBuffInfo->winRows; - int32_t num = updateCountWindowInfo(i, pBlock->info.rows, pInfo->windowCount, &pBuffInfo->winRows); - int32_t step = num; + SCountWindowResult* pBuffInfo = NULL; + code = setCountWindowOutputBuff(pExprSup, &pInfo->countSup, &pInfo->pRow, &pBuffInfo); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } + int32_t prevRows = pBuffInfo->winRows; + int32_t num = updateCountWindowInfo(i, pBlock->info.rows, pInfo->windowCount, &pBuffInfo->winRows); + int32_t step = num; if (prevRows == 0) { pInfo->pRow->win.skey = tsCols[i]; } @@ -131,15 +140,17 @@ int32_t doCountWindowAggImpl(SOperatorInfo* pOperator, SSDataBlock* pBlock) { } i += step; } - - return code; } static void buildCountResult(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, SExecTaskInfo* pTaskInfo, SFilterInfo* pFilterInfo, SSDataBlock* pBlock) { SResultRow* pResultRow = NULL; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; for (int32_t i = 0; i < taosArrayGetSize(pCountSup->pWinStates); i++) { - SCountWindowResult* pBuff = setCountWindowOutputBuff(pExprSup, pCountSup, &pResultRow); + SCountWindowResult* pBuff = NULL; + code = setCountWindowOutputBuff(pExprSup, pCountSup, &pResultRow, &pBuff); + QUERY_CHECK_CODE(code, lino, _end); if (pBuff->winRows == 0) { continue; } @@ -150,7 +161,14 @@ static void buildCountResult(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, S clearWinStateBuff(pBuff); clearResultRowInitFlag(pExprSup->pCtx, pExprSup->numOfExprs); } - doFilter(pBlock, pFilterInfo, NULL); + code = doFilter(pBlock, pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } static SSDataBlock* countWindowAggregate(SOperatorInfo* pOperator) { @@ -243,7 +261,8 @@ SOperatorInfo* createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo QUERY_CHECK_CODE(code, lino, _error); SSDataBlock* pResBlock = createDataBlockFromDescNode(pCountWindowNode->window.node.pOutputDataBlockDesc); - blockDataEnsureCapacity(pResBlock, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pResBlock, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _error); initBasicInfo(&pInfo->binfo, pResBlock); initResultRowInfo(&pInfo->binfo.resultRowInfo); diff --git a/source/libs/executor/src/eventwindowoperator.c b/source/libs/executor/src/eventwindowoperator.c index f15b05f817..75153e3a08 100644 --- a/source/libs/executor/src/eventwindowoperator.c +++ b/source/libs/executor/src/eventwindowoperator.c @@ -204,8 +204,12 @@ static SSDataBlock* eventWindowAggregate(SOperatorInfo* pOperator) { } } - eventWindowAggImpl(pOperator, pInfo, pBlock); - doFilter(pRes, pSup->pFilterInfo, NULL); + code = eventWindowAggImpl(pOperator, pInfo, pBlock); + QUERY_CHECK_CODE(code, lino, _end); + + code = doFilter(pRes, pSup->pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); + if (pRes->info.rows >= pOperator->resultInfo.threshold) { return pRes; } @@ -253,6 +257,8 @@ static void doEventWindowAggImpl(SEventWindowOperatorInfo* pInfo, SExprSupp* pSu } int32_t eventWindowAggImpl(SOperatorInfo* pOperator, SEventWindowOperatorInfo* pInfo, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SExprSupp* pSup = &pOperator->exprSupp; SSDataBlock* pRes = pInfo->binfo.pRes; @@ -274,22 +280,20 @@ int32_t eventWindowAggImpl(SOperatorInfo* pOperator, SEventWindowOperatorInfo* p SFilterColumnParam param1 = {.numOfCols = taosArrayGetSize(pBlock->pDataBlock), .pDataBlock = pBlock->pDataBlock}; - int32_t code = filterSetDataFromSlotId(pInfo->pStartCondInfo, ¶m1); - if (code != TSDB_CODE_SUCCESS) { - return code; - } + code = filterSetDataFromSlotId(pInfo->pStartCondInfo, ¶m1); + QUERY_CHECK_CODE(code, lino, _return); int32_t status1 = 0; - filterExecute(pInfo->pStartCondInfo, pBlock, &ps, NULL, param1.numOfCols, &status1); + code = filterExecute(pInfo->pStartCondInfo, pBlock, &ps, NULL, param1.numOfCols, &status1); + QUERY_CHECK_CODE(code, lino, _return); SFilterColumnParam param2 = {.numOfCols = taosArrayGetSize(pBlock->pDataBlock), .pDataBlock = pBlock->pDataBlock}; code = filterSetDataFromSlotId(pInfo->pEndCondInfo, ¶m2); - if (code != TSDB_CODE_SUCCESS) { - goto _return; - } + QUERY_CHECK_CODE(code, lino, _return); int32_t status2 = 0; - filterExecute(pInfo->pEndCondInfo, pBlock, &pe, NULL, param2.numOfCols, &status2); + code = filterExecute(pInfo->pEndCondInfo, pBlock, &pe, NULL, param2.numOfCols, &status2); + QUERY_CHECK_CODE(code, lino, _return); int32_t startIndex = pInfo->inWindow ? 0 : -1; while (rowIndex < pBlock->info.rows) { @@ -307,7 +311,8 @@ int32_t eventWindowAggImpl(SOperatorInfo* pOperator, SEventWindowOperatorInfo* p // check buffer size if (pRes->info.rows + pInfo->pRow->numOfRows >= pRes->info.capacity) { int32_t newSize = pRes->info.rows + pInfo->pRow->numOfRows; - blockDataEnsureCapacity(pRes, newSize); + code = blockDataEnsureCapacity(pRes, newSize); + QUERY_CHECK_CODE(code, lino, _return); } copyResultrowToDataBlock(pSup->pExprInfo, pSup->numOfExprs, pInfo->pRow, pSup->pCtx, pRes, @@ -344,6 +349,9 @@ int32_t eventWindowAggImpl(SOperatorInfo* pOperator, SEventWindowOperatorInfo* p _return: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + } colDataDestroy(ps); taosMemoryFree(ps); colDataDestroy(pe); diff --git a/source/libs/executor/src/exchangeoperator.c b/source/libs/executor/src/exchangeoperator.c index a6a273cce8..87b5b3c4ec 100644 --- a/source/libs/executor/src/exchangeoperator.c +++ b/source/libs/executor/src/exchangeoperator.c @@ -45,10 +45,10 @@ typedef struct SSourceDataInfo { int32_t decompBufSize; } SSourceDataInfo; -static void destroyExchangeOperatorInfo(void* param); -static void freeBlock(void* pParam); -static void freeSourceDataInfo(void* param); -static void* setAllSourcesCompleted(SOperatorInfo* pOperator); +static void destroyExchangeOperatorInfo(void* param); +static void freeBlock(void* pParam); +static void freeSourceDataInfo(void* param); +static void setAllSourcesCompleted(SOperatorInfo* pOperator); static int32_t loadRemoteDataCallback(void* param, SDataBuf* pMsg, int32_t code); static int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTaskInfo, int32_t sourceIndex); @@ -171,6 +171,7 @@ _error: } static SSDataBlock* doLoadRemoteDataImpl(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; SExchangeInfo* pExchangeInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; @@ -192,11 +193,22 @@ static SSDataBlock* doLoadRemoteDataImpl(SOperatorInfo* pOperator) { } if (p != NULL) { - taosArrayPush(pExchangeInfo->pRecycledBlocks, &p); + void* tmp = taosArrayPush(pExchangeInfo->pRecycledBlocks, &p); + if (!tmp) { + code = TSDB_CODE_OUT_OF_MEMORY; + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return p; } else { if (pExchangeInfo->seqLoadData) { - seqLoadRemoteData(pOperator); + code = seqLoadRemoteData(pOperator); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } } else { concurrentlyLoadRemoteDataImpl(pOperator, pExchangeInfo, pTaskInfo); } @@ -206,7 +218,13 @@ static SSDataBlock* doLoadRemoteDataImpl(SOperatorInfo* pOperator) { } else { p = taosArrayGetP(pExchangeInfo->pResultBlockList, 0); taosArrayRemove(pExchangeInfo->pResultBlockList, 0); - taosArrayPush(pExchangeInfo->pRecycledBlocks, &p); + void* tmp = taosArrayPush(pExchangeInfo->pRecycledBlocks, &p); + if (!tmp) { + code = TSDB_CODE_OUT_OF_MEMORY; + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return p; } } @@ -231,7 +249,11 @@ static SSDataBlock* loadRemoteData(SOperatorInfo* pOperator) { return NULL; } - doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL); + pTaskInfo->code = doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL); + if (pTaskInfo->code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(pTaskInfo->code)); + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + } if (blockDataGetNumOfRows(pBlock) == 0) { continue; } @@ -293,21 +315,32 @@ static int32_t initExchangeOperator(SExchangePhysiNode* pExNode, SExchangeInfo* pInfo->pSources = taosArrayInit(numOfSources, sizeof(SDownstreamSourceNode)); if (pInfo->pSources == NULL) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); return TSDB_CODE_OUT_OF_MEMORY; } if (pExNode->node.dynamicOp) { pInfo->pHashSources = tSimpleHashInit(numOfSources * 2, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT)); if (NULL == pInfo->pHashSources) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); return TSDB_CODE_OUT_OF_MEMORY; } } for (int32_t i = 0; i < numOfSources; ++i) { SDownstreamSourceNode* pNode = (SDownstreamSourceNode*)nodesListGetNode((SNodeList*)pExNode->pSrcEndPoints, i); - taosArrayPush(pInfo->pSources, pNode); + void* tmp = taosArrayPush(pInfo->pSources, pNode); + if (!tmp) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); + return TSDB_CODE_OUT_OF_MEMORY; + } SExchangeSrcIndex idx = {.srcIdx = i, .inUseIdx = -1}; - tSimpleHashPut(pInfo->pHashSources, &pNode->addr.nodeId, sizeof(pNode->addr.nodeId), &idx, sizeof(idx)); + int32_t code = + tSimpleHashPut(pInfo->pHashSources, &pNode->addr.nodeId, sizeof(pNode->addr.nodeId), &idx, sizeof(idx)); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } } initLimitInfo(pExNode->node.pLimit, pExNode->node.pSlimit, &pInfo->limitInfo); @@ -317,6 +350,8 @@ static int32_t initExchangeOperator(SExchangePhysiNode* pExNode, SExchangeInfo* } SOperatorInfo* createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode* pExNode, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExchangeInfo* pInfo = taosMemoryCalloc(1, sizeof(SExchangeInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -324,18 +359,19 @@ SOperatorInfo* createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode } pInfo->dynamicOp = pExNode->node.dynamicOp; - int32_t code = initExchangeOperator(pExNode, pInfo, GET_TASKID(pTaskInfo)); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + code = initExchangeOperator(pExNode, pInfo, GET_TASKID(pTaskInfo)); + QUERY_CHECK_CODE(code, lino, _error); + + code = tsem_init(&pInfo->ready, 0, 0); + QUERY_CHECK_CODE(code, lino, _error); - tsem_init(&pInfo->ready, 0, 0); pInfo->pDummyBlock = createDataBlockFromDescNode(pExNode->node.pOutputDataBlockDesc); pInfo->pResultBlockList = taosArrayInit(64, POINTER_BYTES); pInfo->pRecycledBlocks = taosArrayInit(64, POINTER_BYTES); SExchangeOpStopInfo stopInfo = {QUERY_NODE_PHYSICAL_PLAN_EXCHANGE, pInfo->self}; - qAppendTaskStopInfo(pTaskInfo, &stopInfo); + code = qAppendTaskStopInfo(pTaskInfo, &stopInfo); + QUERY_CHECK_CODE(code, lino, _error); pInfo->seqLoadData = pExNode->seqRecvData; pInfo->pTransporter = pTransporter; @@ -345,15 +381,17 @@ SOperatorInfo* createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pDummyBlock->pDataBlock); code = filterInitFromNode((SNode*)pExNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); pOperator->fpSet = createOperatorFpSet(prepareLoadRemoteData, loadRemoteData, NULL, destroyExchangeOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); return pOperator; _error: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + } if (pInfo != NULL) { doDestroyExchangeOperatorInfo(pInfo); } @@ -365,7 +403,7 @@ _error: void destroyExchangeOperatorInfo(void* param) { SExchangeInfo* pExInfo = (SExchangeInfo*)param; - taosRemoveRef(exchangeObjRefPool, pExInfo->self); + (void)taosRemoveRef(exchangeObjRefPool, pExInfo->self); } void freeBlock(void* pParam) { @@ -393,7 +431,7 @@ void doDestroyExchangeOperatorInfo(void* param) { blockDataDestroy(pExInfo->pDummyBlock); tSimpleHashCleanup(pExInfo->pHashSources); - tsem_destroy(&pExInfo->ready); + (void)tsem_destroy(&pExInfo->ready); taosMemoryFreeClear(pExInfo->pTaskId); taosMemoryFreeClear(param); @@ -445,7 +483,7 @@ int32_t loadRemoteDataCallback(void* param, SDataBuf* pMsg, int32_t code) { qError("failed to invoke post when fetch rsp is ready, code:%s, %p", tstrerror(code), pExchangeInfo); } - taosReleaseRef(exchangeObjRefPool, pWrapper->exchangeId); + (void)taosReleaseRef(exchangeObjRefPool, pWrapper->exchangeId); return code; } @@ -478,6 +516,8 @@ int32_t buildTableScanOperatorParam(SOperatorParam** ppRes, SArray* pUidList, in } int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTaskInfo, int32_t sourceIndex) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SSourceDataInfo* pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, sourceIndex); if (EX_SOURCE_DATA_NOT_READY != pDataInfo->status) { return TSDB_CODE_SUCCESS; @@ -489,6 +529,7 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources); SFetchRspHandleWrapper* pWrapper = taosMemoryCalloc(1, sizeof(SFetchRspHandleWrapper)); + QUERY_CHECK_NULL(pWrapper, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); pWrapper->exchangeId = pExchangeInfo->self; pWrapper->sourceIndex = sourceIndex; @@ -497,7 +538,8 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas int32_t code = (*pTaskInfo->localFetch.fp)(pTaskInfo->localFetch.handle, pSource->schedId, pTaskInfo->id.queryId, pSource->taskId, 0, pSource->execId, &pBuf.pData, pTaskInfo->localFetch.explainRes); - loadRemoteDataCallback(pWrapper, &pBuf, code); + code = loadRemoteDataCallback(pWrapper, &pBuf, code); + QUERY_CHECK_CODE(code, lino, _end); taosMemoryFree(pWrapper); } else { SResFetchReq req = {0}; @@ -566,11 +608,15 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas pMsgSendInfo->fp = loadRemoteDataCallback; int64_t transporterId = 0; - int32_t code = - asyncSendMsgToServer(pExchangeInfo->pTransporter, &pSource->addr.epSet, &transporterId, pMsgSendInfo); + code = asyncSendMsgToServer(pExchangeInfo->pTransporter, &pSource->addr.epSet, &transporterId, pMsgSendInfo); + QUERY_CHECK_CODE(code, lino, _end); } - return TSDB_CODE_SUCCESS; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } void updateLoadRemoteInfo(SLoadRemoteDataInfo* pInfo, int64_t numOfRows, int32_t dataLen, int64_t startTs, @@ -582,6 +628,8 @@ void updateLoadRemoteInfo(SLoadRemoteDataInfo* pInfo, int64_t numOfRows, int32_t } int32_t extractDataBlockFromFetchRsp(SSDataBlock* pRes, char* pData, SArray* pColList, char** pNextStart) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pColList == NULL) { // data from other sources blockDataCleanup(pRes); *pNextStart = (char*)blockDecode(pRes, pData); @@ -604,24 +652,32 @@ int32_t extractDataBlockFromFetchRsp(SSDataBlock* pRes, char* pData, SArray* pCo SSDataBlock* pBlock = createDataBlock(); for (int32_t i = 0; i < numOfCols; ++i) { SColumnInfoData idata = createColumnInfoData(pSchema[i].type, pSchema[i].bytes, pSchema[i].colId); - blockDataAppendColInfo(pBlock, &idata); + code = blockDataAppendColInfo(pBlock, &idata); + QUERY_CHECK_CODE(code, lino, _end); } - (void) blockDecode(pBlock, pStart); - blockDataEnsureCapacity(pRes, pBlock->info.rows); + (void)blockDecode(pBlock, pStart); + code = blockDataEnsureCapacity(pRes, pBlock->info.rows); + QUERY_CHECK_CODE(code, lino, _end); // data from mnode pRes->info.dataLoad = 1; pRes->info.rows = pBlock->info.rows; pRes->info.scanFlag = MAIN_SCAN; - relocateColumnData(pRes, pColList, pBlock->pDataBlock, false); + code = relocateColumnData(pRes, pColList, pBlock->pDataBlock, false); + QUERY_CHECK_CODE(code, lino, _end); + blockDataDestroy(pBlock); } - return TSDB_CODE_SUCCESS; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } -void* setAllSourcesCompleted(SOperatorInfo* pOperator) { +void setAllSourcesCompleted(SOperatorInfo* pOperator) { SExchangeInfo* pExchangeInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; @@ -632,7 +688,6 @@ void* setAllSourcesCompleted(SOperatorInfo* pOperator) { pLoadInfo->totalElapsed / 1000.0); setOperatorCompleted(pOperator); - return NULL; } int32_t getCompletedSources(const SArray* pArray) { @@ -679,21 +734,24 @@ int32_t prepareConcurrentlyLoad(SOperatorInfo* pOperator) { } int32_t doExtractResultBlocks(SExchangeInfo* pExchangeInfo, SSourceDataInfo* pDataInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SRetrieveTableRsp* pRetrieveRsp = pDataInfo->pRsp; - char* pNextStart = pRetrieveRsp->data; - char* pStart = pNextStart; + char* pNextStart = pRetrieveRsp->data; + char* pStart = pNextStart; int32_t index = 0; - int32_t code = 0; if (pRetrieveRsp->compressed) { // decompress the data if (pDataInfo->decompBuf == NULL) { pDataInfo->decompBuf = taosMemoryMalloc(pRetrieveRsp->payloadLen); + QUERY_CHECK_NULL(pDataInfo->decompBuf, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); pDataInfo->decompBufSize = pRetrieveRsp->payloadLen; } else { if (pDataInfo->decompBufSize < pRetrieveRsp->payloadLen) { char* p = taosMemoryRealloc(pDataInfo->decompBuf, pRetrieveRsp->payloadLen); + QUERY_CHECK_NULL(p, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); if (p != NULL) { pDataInfo->decompBuf = p; pDataInfo->decompBufSize = pRetrieveRsp->payloadLen; @@ -702,7 +760,6 @@ int32_t doExtractResultBlocks(SExchangeInfo* pExchangeInfo, SSourceDataInfo* pDa } } - while (index++ < pRetrieveRsp->numOfBlocks) { SSDataBlock* pb = NULL; pStart = pNextStart; @@ -712,12 +769,13 @@ int32_t doExtractResultBlocks(SExchangeInfo* pExchangeInfo, SSourceDataInfo* pDa blockDataCleanup(pb); } else { pb = createOneDataBlock(pExchangeInfo->pDummyBlock, false); + QUERY_CHECK_NULL(pb, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } - int32_t compLen = *(int32_t*) pStart; + int32_t compLen = *(int32_t*)pStart; pStart += sizeof(int32_t); - int32_t rawLen = *(int32_t*) pStart; + int32_t rawLen = *(int32_t*)pStart; pStart += sizeof(int32_t); ASSERT(compLen <= rawLen && compLen != 0); @@ -734,9 +792,14 @@ int32_t doExtractResultBlocks(SExchangeInfo* pExchangeInfo, SSourceDataInfo* pDa return code; } - taosArrayPush(pExchangeInfo->pResultBlockList, &pb); + void* tmp = taosArrayPush(pExchangeInfo->pResultBlockList, &pb); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } return code; } @@ -757,7 +820,13 @@ int32_t seqLoadRemoteData(SOperatorInfo* pOperator) { SSourceDataInfo* pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, pExchangeInfo->current); pDataInfo->status = EX_SOURCE_DATA_NOT_READY; - doSendFetchDataRequest(pExchangeInfo, pTaskInfo, pExchangeInfo->current); + code = doSendFetchDataRequest(pExchangeInfo, pTaskInfo, pExchangeInfo->current); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + } + code = exchangeWait(pOperator, pExchangeInfo); if (code != TSDB_CODE_SUCCESS || isTaskKilled(pTaskInfo)) { T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); @@ -838,7 +907,11 @@ int32_t addSingleExchangeSource(SOperatorInfo* pOperator, SExchangeOperatorBasic dataInfo.srcOpType = pBasicParam->srcOpType; dataInfo.tableSeq = pBasicParam->tableSeq; - taosArrayPush(pExchangeInfo->pSourceDataInfo, &dataInfo); + void* tmp = taosArrayPush(pExchangeInfo->pSourceDataInfo, &dataInfo); + if (!tmp) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); + return TSDB_CODE_OUT_OF_MEMORY; + } pIdx->inUseIdx = taosArrayGetSize(pExchangeInfo->pSourceDataInfo) - 1; } else { SSourceDataInfo* pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, pIdx->inUseIdx); @@ -984,7 +1057,7 @@ static int32_t exchangeWait(SOperatorInfo* pOperator, SExchangeInfo* pExchangeIn return pTask->code; } } - tsem_wait(&pExchangeInfo->ready); + (void)tsem_wait(&pExchangeInfo->ready); if (pTask->pWorkerCb) { code = pTask->pWorkerCb->afterRecoverFromBlocking(pTask->pWorkerCb->pPool); if (code != TSDB_CODE_SUCCESS) { diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c index 698ace3e4e..2c1d3983cd 100644 --- a/source/libs/executor/src/executil.c +++ b/source/libs/executor/src/executil.c @@ -143,7 +143,7 @@ void initGroupedResultInfo(SGroupResInfo* pGroupResInfo, SSHashObj* pHashmap, in // todo move away and record this during create window while ((pData = tSimpleHashIterate(pHashmap, pData, &iter)) != NULL) { - /*void* key = */ tSimpleHashGetKey(pData, &keyLen); + /*void* key = */ (void)tSimpleHashGetKey(pData, &keyLen); bufLen += keyLen + sizeof(SResultRowPosition); } @@ -222,7 +222,13 @@ SArray* createSortInfo(SNodeList* pNodeList) { SColumnNode* pColNode = (SColumnNode*)pSortKey->pExpr; bi.slotId = pColNode->slotId; - taosArrayPush(pList, &bi); + void* tmp = taosArrayPush(pList, &bi); + if (!tmp) { + taosArrayDestroy(pList); + pList = NULL; + terrno = TSDB_CODE_OUT_OF_MEMORY; + break; + } } return pList; @@ -245,7 +251,14 @@ SSDataBlock* createDataBlockFromDescNode(SDataBlockDescNode* pNode) { idata.info.scale = pDescNode->dataType.scale; idata.info.precision = pDescNode->dataType.precision; - blockDataAppendColInfo(pBlock, &idata); + int32_t code = blockDataAppendColInfo(pBlock, &idata); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + blockDataDestroy(pBlock); + pBlock = NULL; + terrno = code; + break; + } } return pBlock; @@ -288,7 +301,7 @@ int32_t prepareDataBlockBuf(SSDataBlock* pDataBlock, SColMatchInfo* pMatchInfo) EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) { SMetaReader* mr = (SMetaReader*)pContext; - bool isTagCol = false, isTbname = false; + bool isTagCol = false, isTbname = false; if (nodeType(*pNode) == QUERY_NODE_COLUMN) { SColumnNode* pCol = (SColumnNode*)*pNode; if (pCol->colType == COLUMN_TYPE_TBNAME) @@ -297,8 +310,7 @@ EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) { isTagCol = true; } else if (nodeType(*pNode) == QUERY_NODE_FUNCTION) { SFunctionNode* pFunc = (SFunctionNode*)*pNode; - if (pFunc->funcType == FUNCTION_TYPE_TBNAME) - isTbname = true; + if (pFunc->funcType == FUNCTION_TYPE_TBNAME) isTbname = true; } if (isTagCol) { SColumnNode* pSColumnNode = *(SColumnNode**)pNode; @@ -325,7 +337,10 @@ EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) { memcpy(varDataVal(res->datum.p), tagVal.pData, tagVal.nData); varDataSetLen(res->datum.p, tagVal.nData); } else { - nodesSetValueNodeValue(res, &(tagVal.i64)); + int32_t code = nodesSetValueNodeValue(res, &(tagVal.i64)); + if (code != TSDB_CODE_SUCCESS) { + return DEAL_RES_ERROR; + } } nodesDestroyNode(*pNode); *pNode = (SNode*)res; @@ -411,7 +426,11 @@ static EDealRes getColumn(SNode** pNode, void* pContext) { tagFilterAssist* pData = (tagFilterAssist*)pContext; void* data = taosHashGet(pData->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId)); if (!data) { - taosHashPut(pData->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode))); + int32_t code = + taosHashPut(pData->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode))); + if (code != TSDB_CODE_SUCCESS) { + return DEAL_RES_ERROR; + } pSColumnNode->slotId = pData->index++; SColumnInfo cInfo = {.colId = pSColumnNode->colId, .type = pSColumnNode->node.resType.type, @@ -420,7 +439,10 @@ static EDealRes getColumn(SNode** pNode, void* pContext) { #if TAG_FILTER_DEBUG qDebug("tagfilter build column info, slotId:%d, colId:%d, type:%d", pSColumnNode->slotId, cInfo.colId, cInfo.type); #endif - taosArrayPush(pData->cInfoList, &cInfo); + void* tmp = taosArrayPush(pData->cInfoList, &cInfo); + if(!tmp) { + return DEAL_RES_ERROR; + } } else { SColumnNode* col = *(SColumnNode**)data; pSColumnNode->slotId = col->slotId; @@ -468,28 +490,38 @@ void freeItem(void* p) { } } -static void genTagFilterDigest(const SNode* pTagCond, T_MD5_CTX* pContext) { +static int32_t genTagFilterDigest(const SNode* pTagCond, T_MD5_CTX* pContext) { if (pTagCond == NULL) { - return; + return TSDB_CODE_SUCCESS; } char* payload = NULL; int32_t len = 0; - nodesNodeToMsg(pTagCond, &payload, &len); + int32_t code = nodesNodeToMsg(pTagCond, &payload, &len); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } tMD5Init(pContext); tMD5Update(pContext, (uint8_t*)payload, (uint32_t)len); tMD5Final(pContext); taosMemoryFree(payload); + return TSDB_CODE_SUCCESS; } -static void genTbGroupDigest(const SNode* pGroup, uint8_t* filterDigest, T_MD5_CTX* pContext) { +static int32_t genTbGroupDigest(const SNode* pGroup, uint8_t* filterDigest, T_MD5_CTX* pContext) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; char* payload = NULL; int32_t len = 0; - nodesNodeToMsg(pGroup, &payload, &len); + code = nodesNodeToMsg(pGroup, &payload, &len); + QUERY_CHECK_CODE(code, lino, _end); + if (filterDigest[0]) { payload = taosMemoryRealloc(payload, len + tListLen(pContext->digest)); + QUERY_CHECK_NULL(payload, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); memcpy(payload + len, filterDigest + 1, tListLen(pContext->digest)); len += tListLen(pContext->digest); } @@ -498,12 +530,18 @@ static void genTbGroupDigest(const SNode* pGroup, uint8_t* filterDigest, T_MD5_C tMD5Update(pContext, (uint8_t*)payload, (uint32_t)len); tMD5Final(pContext); +_end: taosMemoryFree(payload); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInfo* pTableListInfo, uint8_t* digest, SStorageAPI* pAPI, bool initRemainGroups) { int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SArray* pBlockList = NULL; SSDataBlock* pResBlock = NULL; void* keyBuf = NULL; @@ -540,11 +578,15 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf if (tsTagFilterCache) { SNodeListNode* listNode = (SNodeListNode*)nodesMakeNode(QUERY_NODE_NODE_LIST); listNode->pNodeList = group; - genTbGroupDigest((SNode*)listNode, digest, &context); + code = genTbGroupDigest((SNode*)listNode, digest, &context); + QUERY_CHECK_CODE(code, lino, end); + nodesFree(listNode); - pAPI->metaFn.metaGetCachedTbGroup(pVnode, pTableListInfo->idInfo.suid, context.digest, tListLen(context.digest), - &tableList); + code = pAPI->metaFn.metaGetCachedTbGroup(pVnode, pTableListInfo->idInfo.suid, context.digest, + tListLen(context.digest), &tableList); + QUERY_CHECK_CODE(code, lino, end); + if (tableList) { taosArrayDestroy(pTableListInfo->pTableList); pTableListInfo->pTableList = tableList; @@ -555,10 +597,13 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf } pUidTagList = taosArrayInit(8, sizeof(STUidTagInfo)); + QUERY_CHECK_NULL(pUidTagList, code, lino, end, TSDB_CODE_OUT_OF_MEMORY); + for (int32_t i = 0; i < rows; ++i) { STableKeyInfo* pkeyInfo = taosArrayGet(pTableListInfo->pTableList, i); STUidTagInfo info = {.uid = pkeyInfo->uid}; - taosArrayPush(pUidTagList, &info); + void* tmp = taosArrayPush(pUidTagList, &info); + QUERY_CHECK_NULL(tmp, code, lino, end, TSDB_CODE_OUT_OF_MEMORY); } code = pAPI->metaFn.getTableTags(pVnode, pTableListInfo->idInfo.suid, pUidTagList); @@ -577,9 +622,14 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf // qDebug("generate tag block rows:%d, cost:%ld us", rows, st1-st); pBlockList = taosArrayInit(2, POINTER_BYTES); - taosArrayPush(pBlockList, &pResBlock); + QUERY_CHECK_NULL(pBlockList, code, lino, end, TSDB_CODE_OUT_OF_MEMORY); + + void* tmp = taosArrayPush(pBlockList, &pResBlock); + QUERY_CHECK_NULL(tmp, code, lino, end, TSDB_CODE_OUT_OF_MEMORY); groupData = taosArrayInit(2, POINTER_BYTES); + QUERY_CHECK_NULL(groupData, code, lino, end, TSDB_CODE_OUT_OF_MEMORY); + FOREACH(pNode, group) { SScalarParam output = {0}; @@ -617,7 +667,8 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf goto end; } - taosArrayPush(groupData, &output.columnData); + void* tmp = taosArrayPush(groupData, &output.columnData); + QUERY_CHECK_NULL(tmp, code, lino, end, TSDB_CODE_OUT_OF_MEMORY); } int32_t keyLen = 0; @@ -688,15 +739,18 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf info->groupId = calcGroupId(keyBuf, len); if (initRemainGroups) { // groupId ~ table uid - taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId), &(info->uid), - sizeof(info->uid)); + code = taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId), &(info->uid), + sizeof(info->uid)); + QUERY_CHECK_CODE(code, lino, end); } } if (tsTagFilterCache) { tableList = taosArrayDup(pTableListInfo->pTableList, NULL); - pAPI->metaFn.metaPutTbGroupToCache(pVnode, pTableListInfo->idInfo.suid, context.digest, tListLen(context.digest), - tableList, taosArrayGetSize(tableList) * sizeof(STableKeyInfo)); + code = pAPI->metaFn.metaPutTbGroupToCache(pVnode, pTableListInfo->idInfo.suid, context.digest, + tListLen(context.digest), tableList, + taosArrayGetSize(tableList) * sizeof(STableKeyInfo)); + QUERY_CHECK_CODE(code, lino, end); } // int64_t st2 = taosGetTimestampUs(); @@ -726,10 +780,14 @@ static int32_t nameComparFn(const void* p1, const void* p2) { } static SArray* getTableNameList(const SNodeListNode* pList) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; int32_t len = LIST_LENGTH(pList->pNodeList); SListCell* cell = pList->pNodeList->pHead; SArray* pTbList = taosArrayInit(len, POINTER_BYTES); + QUERY_CHECK_NULL(pTbList, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + for (int i = 0; i < pList->pNodeList->length; i++) { SValueNode* valueNode = (SValueNode*)cell->pNode; if (!IS_VAR_DATA_TYPE(valueNode->node.resType.type)) { @@ -739,7 +797,8 @@ static SArray* getTableNameList(const SNodeListNode* pList) { } char* name = varDataVal(valueNode->datum.p); - taosArrayPush(pTbList, &name); + void* tmp = taosArrayPush(pTbList, &name); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); cell = cell->pNext; } @@ -750,7 +809,8 @@ static SArray* getTableNameList(const SNodeListNode* pList) { // remove the duplicates SArray* pNewList = taosArrayInit(taosArrayGetSize(pTbList), sizeof(void*)); - taosArrayPush(pNewList, taosArrayGet(pTbList, 0)); + void* tmp = taosArrayPush(pNewList, taosArrayGet(pTbList, 0)); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); for (int32_t i = 1; i < numOfTables; ++i) { char** name = taosArrayGetLast(pNewList); @@ -759,10 +819,16 @@ static SArray* getTableNameList(const SNodeListNode* pList) { continue; } - taosArrayPush(pNewList, nameInOldList); + tmp = taosArrayPush(pNewList, nameInOldList); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } +_end: taosArrayDestroy(pTbList); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + return NULL; + } return pNewList; } @@ -868,9 +934,18 @@ static int32_t optimizeTbnameInCondImpl(void* pVnode, SArray* pExistedUidList, S size_t numOfExisted = taosArrayGetSize(pExistedUidList); // len > 0 means there already have uids if (numOfExisted > 0) { uHash = taosHashInit(numOfExisted / 0.7, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK); + if (!uHash) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); + return TSDB_CODE_OUT_OF_MEMORY; + } + for (int i = 0; i < numOfExisted; i++) { STUidTagInfo* pTInfo = taosArrayGet(pExistedUidList, i); - taosHashPut(uHash, &pTInfo->uid, sizeof(uint64_t), &i, sizeof(i)); + int32_t code = taosHashPut(uHash, &pTInfo->uid, sizeof(uint64_t), &i, sizeof(i)); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } } } @@ -883,7 +958,10 @@ static int32_t optimizeTbnameInCondImpl(void* pVnode, SArray* pExistedUidList, S if (pStoreAPI->metaFn.getTableTypeByName(pVnode, name, &tbType) == 0 && tbType == TSDB_CHILD_TABLE) { if (NULL == uHash || taosHashGet(uHash, &uid, sizeof(uid)) == NULL) { STUidTagInfo s = {.uid = uid, .name = name, .pTagVal = NULL}; - taosArrayPush(pExistedUidList, &s); + void* tmp = taosArrayPush(pExistedUidList, &s); + if (!tmp) { + return TSDB_CODE_OUT_OF_MEMORY; + } } } else { taosArrayDestroy(pTbList); @@ -906,6 +984,8 @@ static int32_t optimizeTbnameInCondImpl(void* pVnode, SArray* pExistedUidList, S SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, SArray* pUidTagList, void* pVnode, SStorageAPI* pStorageAPI) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SSDataBlock* pResBlock = createDataBlock(); if (pResBlock == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; @@ -915,10 +995,11 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S for (int32_t i = 0; i < taosArrayGetSize(pColList); ++i) { SColumnInfoData colInfo = {0}; colInfo.info = *(SColumnInfo*)taosArrayGet(pColList, i); - blockDataAppendColInfo(pResBlock, &colInfo); + code = blockDataAppendColInfo(pResBlock, &colInfo); + QUERY_CHECK_CODE(code, lino, _end); } - int32_t code = blockDataEnsureCapacity(pResBlock, numOfTables); + code = blockDataEnsureCapacity(pResBlock, numOfTables); if (code != TSDB_CODE_SUCCESS) { terrno = code; taosMemoryFree(pResBlock); @@ -940,10 +1021,12 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S if (p1->name != NULL) { STR_TO_VARSTR(str, p1->name); } else { // name is not retrieved during filter - pStorageAPI->metaFn.getTableNameByUid(pVnode, p1->uid, str); + code = pStorageAPI->metaFn.getTableNameByUid(pVnode, p1->uid, str); + QUERY_CHECK_CODE(code, lino, _end); } - colDataSetVal(pColInfo, i, str, false); + code = colDataSetVal(pColInfo, i, str, false); + QUERY_CHECK_CODE(code, lino, _end); #if TAG_FILTER_DEBUG qDebug("tagfilter uid:%ld, tbname:%s", *uid, str + 2); #endif @@ -958,18 +1041,22 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S if (p == NULL || (pColInfo->info.type == TSDB_DATA_TYPE_JSON && ((STag*)p)->nTag == 0)) { colDataSetNULL(pColInfo, i); } else if (pColInfo->info.type == TSDB_DATA_TYPE_JSON) { - colDataSetVal(pColInfo, i, p, false); + code = colDataSetVal(pColInfo, i, p, false); + QUERY_CHECK_CODE(code, lino, _end); } else if (IS_VAR_DATA_TYPE(pColInfo->info.type)) { char* tmp = taosMemoryMalloc(tagVal.nData + VARSTR_HEADER_SIZE + 1); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); varDataSetLen(tmp, tagVal.nData); memcpy(tmp + VARSTR_HEADER_SIZE, tagVal.pData, tagVal.nData); - colDataSetVal(pColInfo, i, tmp, false); + code = colDataSetVal(pColInfo, i, tmp, false); + QUERY_CHECK_CODE(code, lino, _end); #if TAG_FILTER_DEBUG qDebug("tagfilter varch:%s", tmp + 2); #endif taosMemoryFree(tmp); } else { - colDataSetVal(pColInfo, i, (const char*)&tagVal.i64, false); + code = colDataSetVal(pColInfo, i, (const char*)&tagVal.i64, false); + QUERY_CHECK_CODE(code, lino, _end); #if TAG_FILTER_DEBUG if (pColInfo->info.type == TSDB_DATA_TYPE_INT) { qDebug("tagfilter int:%d", *(int*)(&tagVal.i64)); @@ -983,6 +1070,12 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S } } +_end: + if (code != TSDB_CODE_SUCCESS) { + taosMemoryFree(pResBlock); + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + return NULL; + } return pResBlock; } @@ -1004,7 +1097,10 @@ static int32_t doSetQualifiedUid(STableListInfo* pListInfo, SArray* pUidList, co } if (addUid) { - taosArrayPush(pUidList, &uid); + void* tmp = taosArrayPush(pUidList, &uid); + if (tmp == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } } } } @@ -1012,17 +1108,23 @@ static int32_t doSetQualifiedUid(STableListInfo* pListInfo, SArray* pUidList, co return TSDB_CODE_SUCCESS; } -static void copyExistedUids(SArray* pUidTagList, const SArray* pUidList) { +static int32_t copyExistedUids(SArray* pUidTagList, const SArray* pUidList) { + int32_t code = TSDB_CODE_SUCCESS; int32_t numOfExisted = taosArrayGetSize(pUidList); if (numOfExisted == 0) { - return; + return code; } for (int32_t i = 0; i < numOfExisted; ++i) { uint64_t* uid = taosArrayGet(pUidList, i); STUidTagInfo info = {.uid = *uid}; - taosArrayPush(pUidTagList, &info); + void* tmp = taosArrayPush(pUidTagList, &info); + if (!tmp) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); + return code; + } } + return code; } static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SNode* pTagCond, void* pVnode, @@ -1034,6 +1136,7 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN terrno = TSDB_CODE_SUCCESS; + int32_t lino = 0; int32_t code = TSDB_CODE_SUCCESS; SArray* pBlockList = NULL; SSDataBlock* pResBlock = NULL; @@ -1059,7 +1162,10 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN // int64_t stt = taosGetTimestampUs(); pUidTagList = taosArrayInit(10, sizeof(STUidTagInfo)); - copyExistedUids(pUidTagList, pUidList); + QUERY_CHECK_NULL(pUidTagList, code, lino, end, TSDB_CODE_OUT_OF_MEMORY); + + code = copyExistedUids(pUidTagList, pUidList); + QUERY_CHECK_CODE(code, lino, end); FilterCondType condType = checkTagCond(pTagCond); @@ -1068,10 +1174,13 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN taosArrayClear(pUidList); int32_t numOfRows = taosArrayGetSize(pUidTagList); - taosArrayEnsureCap(pUidList, numOfRows); + code = taosArrayEnsureCap(pUidList, numOfRows); + QUERY_CHECK_CODE(code, lino, end); + for (int32_t i = 0; i < numOfRows; ++i) { STUidTagInfo* pInfo = taosArrayGet(pUidTagList, i); - taosArrayPush(pUidList, &pInfo->uid); + void* tmp = taosArrayPush(pUidList, &pInfo->uid); + QUERY_CHECK_NULL(tmp, code, lino, end, TSDB_CODE_OUT_OF_MEMORY); } terrno = 0; } else { @@ -1101,7 +1210,10 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN // int64_t st1 = taosGetTimestampUs(); // qDebug("generate tag block rows:%d, cost:%ld us", rows, st1-st); pBlockList = taosArrayInit(2, POINTER_BYTES); - taosArrayPush(pBlockList, &pResBlock); + QUERY_CHECK_NULL(pBlockList, code, lino, end, TSDB_CODE_OUT_OF_MEMORY); + + void* tmp = taosArrayPush(pBlockList, &pResBlock); + QUERY_CHECK_NULL(tmp, code, lino, end, TSDB_CODE_OUT_OF_MEMORY); code = createResultData(&type, numOfTables, &output); if (code != TSDB_CODE_SUCCESS) { @@ -1124,6 +1236,9 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN *listAdded = true; end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } taosHashCleanup(ctx.colHash); taosArrayDestroy(ctx.cInfoList); blockDataDestroy(pResBlock); @@ -1138,6 +1253,7 @@ end: int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, SNode* pTagIndexCond, STableListInfo* pListInfo, uint8_t* digest, const char* idstr, SStorageAPI* pStorageAPI) { int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; size_t numOfTables = 0; bool listAdded = false; @@ -1145,12 +1261,14 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S pListInfo->idInfo.tableType = pScanNode->tableType; SArray* pUidList = taosArrayInit(8, sizeof(uint64_t)); + QUERY_CHECK_NULL(pUidList, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); SIdxFltStatus status = SFLT_NOT_INDEX; if (pScanNode->tableType != TSDB_SUPER_TABLE) { pListInfo->idInfo.uid = pScanNode->uid; if (pStorageAPI->metaFn.isTableExisted(pVnode, pScanNode->uid)) { - taosArrayPush(pUidList, &pScanNode->uid); + void* tmp = taosArrayPush(pUidList, &pScanNode->uid); + QUERY_CHECK_NULL(tmp, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); } code = doFilterByTagCond(pListInfo, pUidList, pTagCond, pVnode, status, pStorageAPI, false, &listAdded); if (code != TSDB_CODE_SUCCESS) { @@ -1161,11 +1279,14 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S if (tsTagFilterCache) { // try to retrieve the result from meta cache - genTagFilterDigest(pTagCond, &context); + code = genTagFilterDigest(pTagCond, &context); + QUERY_CHECK_CODE(code, lino, _error); bool acquired = false; - pStorageAPI->metaFn.getCachedTableList(pVnode, pScanNode->suid, context.digest, tListLen(context.digest), - pUidList, &acquired); + code = pStorageAPI->metaFn.getCachedTableList(pVnode, pScanNode->suid, context.digest, tListLen(context.digest), + pUidList, &acquired); + QUERY_CHECK_CODE(code, lino, _error); + if (acquired) { digest[0] = 1; memcpy(digest + 1, context.digest, tListLen(context.digest)); @@ -1175,7 +1296,8 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S } if (!pTagCond) { // no tag filter condition exists, let's fetch all tables of this super table - pStorageAPI->metaFn.getChildTableList(pVnode, pScanNode->suid, pUidList); + code = pStorageAPI->metaFn.getChildTableList(pVnode, pScanNode->suid, pUidList); + QUERY_CHECK_CODE(code, lino, _error); } else { // failed to find the result in the cache, let try to calculate the results if (pTagIndexCond) { @@ -1207,14 +1329,17 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S if (tsTagFilterCache) { size_t size = numOfTables * sizeof(uint64_t) + sizeof(int32_t); char* pPayload = taosMemoryMalloc(size); + QUERY_CHECK_NULL(pPayload, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); *(int32_t*)pPayload = numOfTables; if (numOfTables > 0) { memcpy(pPayload + sizeof(int32_t), taosArrayGet(pUidList, 0), numOfTables * sizeof(uint64_t)); } - pStorageAPI->metaFn.putCachedTableList(pVnode, pScanNode->suid, context.digest, tListLen(context.digest), - pPayload, size, 1); + code = pStorageAPI->metaFn.putCachedTableList(pVnode, pScanNode->suid, context.digest, tListLen(context.digest), + pPayload, size, 1); + QUERY_CHECK_CODE(code, lino, _error); + digest[0] = 1; memcpy(digest + 1, context.digest, tListLen(context.digest)); } @@ -1236,7 +1361,11 @@ _end: } } +_error: taosArrayDestroy(pUidList); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } return code; } @@ -1360,7 +1489,12 @@ SArray* makeColumnArrayFromList(SNodeList* pNodeList) { c.precision = pColNode->node.resType.precision; c.scale = pColNode->node.resType.scale; - taosArrayPush(pList, &c); + void* tmp = taosArrayPush(pList, &c); + if (!tmp) { + taosArrayDestroy(pList); + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); + return NULL; + } } return pList; @@ -1369,7 +1503,8 @@ SArray* makeColumnArrayFromList(SNodeList* pNodeList) { int32_t extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNodeList, int32_t* numOfOutputCols, int32_t type, SColMatchInfo* pMatchInfo) { size_t numOfCols = LIST_LENGTH(pNodeList); - int32_t code = 0; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; pMatchInfo->matchType = type; @@ -1390,7 +1525,8 @@ int32_t extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNod c.dstSlotId = pNode->slotId; c.isPk = pColNode->isPk; c.dataType = pColNode->node.resType; - taosArrayPush(pList, &c); + void* tmp = taosArrayPush(pList, &c); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } } @@ -1424,6 +1560,11 @@ int32_t extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNod } pMatchInfo->pList = pList; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } return code; } @@ -1458,8 +1599,12 @@ static SColumn* createColumn(int32_t blockId, int32_t slotId, int32_t colId, SDa return pCol; } -void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) { +int32_t createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; pExp->pExpr = taosMemoryCalloc(1, sizeof(tExprNode)); + QUERY_CHECK_NULL(pExp->pExpr, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + pExp->pExpr->_function.num = 1; pExp->pExpr->_function.functionId = -1; @@ -1470,6 +1615,8 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) { SColumnNode* pColNode = (SColumnNode*)pNode; pExp->base.pParam = taosMemoryCalloc(1, sizeof(SFunctParam)); + QUERY_CHECK_NULL(pExp->base.pParam, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + pExp->base.numOfParams = 1; SDataType* pType = &pColNode->node.resType; @@ -1483,6 +1630,8 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) { SValueNode* pValNode = (SValueNode*)pNode; pExp->base.pParam = taosMemoryCalloc(1, sizeof(SFunctParam)); + QUERY_CHECK_NULL(pExp->base.pParam, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + pExp->base.numOfParams = 1; SDataType* pType = &pValNode->node.resType; @@ -1518,7 +1667,8 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) { if (NULL == res) { // todo handle error } else { res->node.resType = (SDataType){.bytes = sizeof(int64_t), .type = TSDB_DATA_TYPE_BIGINT}; - nodesListAppend(pFuncNode->pParameterList, (SNode*)res); + code = nodesListAppend(pFuncNode->pParameterList, (SNode*)res); + QUERY_CHECK_CODE(code, lino, _end); } } #endif @@ -1567,10 +1717,16 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) { } else { ASSERT(0); } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } -void createExprFromTargetNode(SExprInfo* pExp, STargetNode* pTargetNode) { - createExprFromOneNode(pExp, pTargetNode->pExpr, pTargetNode->slotId); +int32_t createExprFromTargetNode(SExprInfo* pExp, STargetNode* pTargetNode) { + return createExprFromOneNode(pExp, pTargetNode->pExpr, pTargetNode->slotId); } SExprInfo* createExpr(SNodeList* pNodeList, int32_t* numOfExprs) { @@ -1579,7 +1735,12 @@ SExprInfo* createExpr(SNodeList* pNodeList, int32_t* numOfExprs) { for (int32_t i = 0; i < (*numOfExprs); ++i) { SExprInfo* pExp = &pExprs[i]; - createExprFromOneNode(pExp, nodesListGetNode(pNodeList, i), i + UD_TAG_COLUMN_INDEX); + int32_t code = createExprFromOneNode(pExp, nodesListGetNode(pNodeList, i), i + UD_TAG_COLUMN_INDEX); + if (code != TSDB_CODE_SUCCESS) { + taosMemoryFreeClear(pExprs); + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return NULL; + } } return pExprs; @@ -1608,7 +1769,12 @@ SExprInfo* createExprInfo(SNodeList* pNodeList, SNodeList* pGroupKeys, int32_t* } SExprInfo* pExp = &pExprs[i]; - createExprFromTargetNode(pExp, pTargetNode); + int32_t code = createExprFromTargetNode(pExp, pTargetNode); + if (code != TSDB_CODE_SUCCESS) { + taosMemoryFreeClear(pExprs); + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return NULL; + } } return pExprs; @@ -1636,7 +1802,11 @@ static int32_t setSelectValueColumnInfo(SqlFunctionCtx* pCtx, int32_t numOfOutpu p = NULL; break; } else { - taosHashPut(pSelectFuncs, pName, strlen(pName), &num, sizeof(num)); + int32_t code = taosHashPut(pSelectFuncs, pName, strlen(pName), &num, sizeof(num)); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } p = &pCtx[i]; } } @@ -1655,6 +1825,8 @@ static int32_t setSelectValueColumnInfo(SqlFunctionCtx* pCtx, int32_t numOfOutpu SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, int32_t** rowEntryInfoOffset, SFunctionStateStore* pStore) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SqlFunctionCtx* pFuncCtx = (SqlFunctionCtx*)taosMemoryCalloc(numOfOutput, sizeof(SqlFunctionCtx)); if (pFuncCtx == NULL) { return NULL; @@ -1684,17 +1856,29 @@ SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, if (fmIsAggFunc(pCtx->functionId) || fmIsIndefiniteRowsFunc(pCtx->functionId)) { bool isUdaf = fmIsUserDefinedFunc(pCtx->functionId); if (!isUdaf) { - fmGetFuncExecFuncs(pCtx->functionId, &pCtx->fpSet); + code = fmGetFuncExecFuncs(pCtx->functionId, &pCtx->fpSet); + QUERY_CHECK_CODE(code, lino, _end); } else { char* udfName = pExpr->pExpr->_function.pFunctNode->functionName; pCtx->udfName = taosStrdup(udfName); - fmGetUdafExecFuncs(pCtx->functionId, &pCtx->fpSet); + code = fmGetUdafExecFuncs(pCtx->functionId, &pCtx->fpSet); + QUERY_CHECK_CODE(code, lino, _end); + } + bool tmp = pCtx->fpSet.getEnv(pExpr->pExpr->_function.pFunctNode, &env); + if (!tmp) { + code = TSDB_CODE_OUT_OF_MEMORY; + QUERY_CHECK_CODE(code, lino, _end); } - pCtx->fpSet.getEnv(pExpr->pExpr->_function.pFunctNode, &env); } else { - fmGetScalarFuncExecFuncs(pCtx->functionId, &pCtx->sfp); + code = fmGetScalarFuncExecFuncs(pCtx->functionId, &pCtx->sfp); + QUERY_CHECK_CODE(code, lino, _end); + if (pCtx->sfp.getEnv != NULL) { - pCtx->sfp.getEnv(pExpr->pExpr->_function.pFunctNode, &env); + bool tmp = pCtx->sfp.getEnv(pExpr->pExpr->_function.pFunctNode, &env); + if (!tmp) { + code = TSDB_CODE_OUT_OF_MEMORY; + QUERY_CHECK_CODE(code, lino, _end); + } } } pCtx->resDataInfo.interBufSize = env.calcMemSize; @@ -1706,7 +1890,9 @@ SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, pCtx->input.numOfInputCols = pFunct->numOfParams; pCtx->input.pData = taosMemoryCalloc(pFunct->numOfParams, POINTER_BYTES); + QUERY_CHECK_NULL(pCtx->input.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); pCtx->input.pColumnDataAgg = taosMemoryCalloc(pFunct->numOfParams, POINTER_BYTES); + QUERY_CHECK_NULL(pCtx->input.pColumnDataAgg, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); pCtx->pTsOutput = NULL; pCtx->resDataInfo.bytes = pFunct->resSchema.bytes; @@ -1726,14 +1912,27 @@ SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, pFuncCtx[i - 1].resDataInfo.interBufSize); } - setSelectValueColumnInfo(pFuncCtx, numOfOutput); + code = setSelectValueColumnInfo(pFuncCtx, numOfOutput); + QUERY_CHECK_CODE(code, lino, _end); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + for (int32_t i = 0; i < numOfOutput; ++i) { + taosMemoryFree(pFuncCtx[i].input.pData); + taosMemoryFree(pFuncCtx[i].input.pColumnDataAgg); + } + taosMemoryFreeClear(pFuncCtx); + return NULL; + } return pFuncCtx; } // NOTE: sources columns are more than the destination SSDatablock columns. // doFilter in table scan needs every column even its output is false -void relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray* pCols, bool outputEveryColumn) { - size_t numOfSrcCols = taosArrayGetSize(pCols); +int32_t relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray* pCols, bool outputEveryColumn) { + int32_t code = TSDB_CODE_SUCCESS; + size_t numOfSrcCols = taosArrayGetSize(pCols); int32_t i = 0, j = 0; while (i < numOfSrcCols && j < taosArrayGetSize(pColMatchInfo)) { @@ -1742,7 +1941,11 @@ void relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray if (p->info.colId == pmInfo->colId) { SColumnInfoData* pDst = taosArrayGet(pBlock->pDataBlock, pmInfo->dstSlotId); - colDataAssign(pDst, p, pBlock->info.rows, &pBlock->info); + code = colDataAssign(pDst, p, pBlock->info.rows, &pBlock->info); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } i++; j++; } else if (p->info.colId < pmInfo->colId) { @@ -1751,6 +1954,7 @@ void relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray ASSERT(0); } } + return code; } SInterval extractIntervalInfo(const STableScanPhysiNode* pTableScanNode) { @@ -2022,15 +2226,15 @@ uint64_t tableListGetTableGroupId(const STableListInfo* pTableList, uint64_t tab // TODO handle the group offset info, fix it, the rule of group output will be broken by this function int32_t tableListAddTableInfo(STableListInfo* pTableList, uint64_t uid, uint64_t gid) { - int32_t code = TSDB_CODE_SUCCESS; - int32_t lino = 0; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pTableList->map == NULL) { pTableList->map = taosHashInit(32, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_ENTRY_LOCK); QUERY_CHECK_NULL(pTableList->map, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } STableKeyInfo keyInfo = {.uid = uid, .groupId = gid}; - void* tmp = taosArrayPush(pTableList->pTableList, &keyInfo); + void* tmp = taosArrayPush(pTableList->pTableList, &keyInfo); QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); int32_t slot = (int32_t)taosArrayGetSize(pTableList->pTableList) - 1; @@ -2108,9 +2312,9 @@ _error: return NULL; } -void* tableListDestroy(STableListInfo* pTableListInfo) { +void tableListDestroy(STableListInfo* pTableListInfo) { if (pTableListInfo == NULL) { - return NULL; + return; } taosArrayDestroy(pTableListInfo->pTableList); @@ -2122,7 +2326,6 @@ void* tableListDestroy(STableListInfo* pTableListInfo) { pTableListInfo->pTableList = NULL; pTableListInfo->map = NULL; taosMemoryFree(pTableListInfo); - return NULL; } void tableListClear(STableListInfo* pTableListInfo) { @@ -2159,12 +2362,20 @@ static int32_t sortTableGroup(STableListInfo* pTableListInfo) { uint64_t gid = pInfo->groupId; int32_t start = 0; - taosArrayPush(pList, &start); + void* tmp = taosArrayPush(pList, &start); + if (!tmp) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); + return TSDB_CODE_OUT_OF_MEMORY; + } for (int32_t i = 1; i < size; ++i) { pInfo = taosArrayGet(pTableListInfo->pTableList, i); if (pInfo->groupId != gid) { - taosArrayPush(pList, &i); + tmp = taosArrayPush(pList, &i); + if (!tmp) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); + return TSDB_CODE_OUT_OF_MEMORY; + } gid = pInfo->groupId; } } @@ -2191,19 +2402,24 @@ int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle* return code; } if (group == NULL || groupByTbname) { - if (tsCountAlwaysReturnValue && QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN == nodeType(pScanNode) && ((STableScanPhysiNode*)pScanNode)->needCountEmptyTable) { + if (tsCountAlwaysReturnValue && QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN == nodeType(pScanNode) && + ((STableScanPhysiNode*)pScanNode)->needCountEmptyTable) { pTableListInfo->remainGroups = taosHashInit(numOfTables, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK); if (pTableListInfo->remainGroups == NULL) { return TSDB_CODE_OUT_OF_MEMORY; } - + for (int i = 0; i < numOfTables; i++) { STableKeyInfo* info = taosArrayGet(pTableListInfo->pTableList, i); info->groupId = groupByTbname ? info->uid : 0; - - taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId), &(info->uid), - sizeof(info->uid)); + + code = taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId), &(info->uid), + sizeof(info->uid)); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } } } else { for (int32_t i = 0; i < numOfTables; i++) { @@ -2251,7 +2467,11 @@ int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle* size_t size = taosArrayGetSize(pTableListInfo->pTableList); for (int32_t i = 0; i < size; ++i) { STableKeyInfo* p = taosArrayGet(pTableListInfo->pTableList, i); - taosHashPut(pTableListInfo->map, &p->uid, sizeof(uint64_t), &i, sizeof(int32_t)); + code = taosHashPut(pTableListInfo->map, &p->uid, sizeof(uint64_t), &i, sizeof(int32_t)); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } } return code; @@ -2457,7 +2677,11 @@ SNodeList* makeColsNodeArrFromSortKeys(SNodeList* pSortKeys) { SNodeList* ret = NULL; FOREACH(node, pSortKeys) { SOrderByExprNode* pSortKey = (SOrderByExprNode*)node; - nodesListMakeAppend(&ret, pSortKey->pExpr); + int32_t code = nodesListMakeAppend(&ret, pSortKey->pExpr); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return NULL; + } } return ret; } diff --git a/source/libs/executor/src/executorInt.c b/source/libs/executor/src/executorInt.c index a3e3501114..08103da96c 100644 --- a/source/libs/executor/src/executorInt.c +++ b/source/libs/executor/src/executorInt.c @@ -677,7 +677,7 @@ _end: } // todo refactor. SResultRow has direct pointer in miainfo -int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, SExprSupp* pSup, +void finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, SExprSupp* pSup, SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo) { SFilePage* page = getBufPage(pBuf, resultRowPosition->pageId); if (page == NULL) { @@ -694,7 +694,7 @@ int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPos doUpdateNumOfRows(pCtx, pRow, pSup->numOfExprs, rowEntryOffset); if (pRow->numOfRows == 0) { releaseBufPage(pBuf, page); - return 0; + return ; } int32_t size = pBlock->info.capacity; @@ -713,7 +713,6 @@ int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPos releaseBufPage(pBuf, page); pBlock->info.rows += pRow->numOfRows; - return 0; } void doCopyToSDataBlockByHash(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf, diff --git a/source/libs/executor/src/filloperator.c b/source/libs/executor/src/filloperator.c index 79e2d4b7c9..66655090bc 100644 --- a/source/libs/executor/src/filloperator.c +++ b/source/libs/executor/src/filloperator.c @@ -63,7 +63,8 @@ static void fillResetPrevForNewGroup(SFillInfo* pFillInfo); static void doHandleRemainBlockForNewGroupImpl(SOperatorInfo* pOperator, SFillOperatorInfo* pInfo, SResultInfo* pResultInfo, int32_t order) { pInfo->totalInputRows = pInfo->existNewGroupBlock->info.rows; - SSDataBlock* pResBlock = pInfo->pFinalRes; + SSDataBlock* pResBlock = pInfo->pFinalRes; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; // int32_t order = TSDB_ORDER_ASC; int32_t scanFlag = MAIN_SCAN; @@ -85,7 +86,11 @@ static void doHandleRemainBlockForNewGroupImpl(SOperatorInfo* pOperator, SFillOp } int32_t numOfResultRows = pResultInfo->capacity - pResBlock->info.rows; - taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows); + int32_t code = taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } pInfo->curGroupId = pInfo->existNewGroupBlock->info.id.groupId; pInfo->existNewGroupBlock = NULL; @@ -96,7 +101,11 @@ static void doHandleRemainBlockFromNewGroup(SOperatorInfo* pOperator, SFillOpera SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; if (taosFillHasMoreResults(pInfo->pFillInfo)) { int32_t numOfResultRows = pResultInfo->capacity - pInfo->pFinalRes->info.rows; - taosFillResultDataBlock(pInfo->pFillInfo, pInfo->pFinalRes, numOfResultRows); + int32_t code = taosFillResultDataBlock(pInfo->pFillInfo, pInfo->pFinalRes, numOfResultRows); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } pInfo->pRes->info.id.groupId = pInfo->curGroupId; return; } @@ -269,7 +278,8 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) { } int32_t numOfResultRows = pOperator->resultInfo.capacity - pResBlock->info.rows; - taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows); + code = taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows); + QUERY_CHECK_CODE(code, lino, _end); // current group has no more result to return if (pResBlock->info.rows > 0) { @@ -356,7 +366,8 @@ void destroyFillOperatorInfo(void* param) { static int32_t initFillInfo(SFillOperatorInfo* pInfo, SExprInfo* pExpr, int32_t numOfCols, SExprInfo* pNotFillExpr, int32_t numOfNotFillCols, SNodeListNode* pValNode, STimeWindow win, int32_t capacity, - const char* id, SInterval* pInterval, int32_t fillType, int32_t order) { + const char* id, SInterval* pInterval, int32_t fillType, int32_t order, + SExecTaskInfo* pTaskInfo) { SFillColInfo* pColInfo = createFillColInfo(pExpr, numOfCols, pNotFillExpr, numOfNotFillCols, pValNode); int64_t startKey = (order == TSDB_ORDER_ASC) ? win.skey : win.ekey; @@ -364,7 +375,7 @@ static int32_t initFillInfo(SFillOperatorInfo* pInfo, SExprInfo* pExpr, int32_t // STimeWindow w = {0}; // getInitialStartTimeWindow(pInterval, startKey, &w, order == TSDB_ORDER_ASC); pInfo->pFillInfo = taosCreateFillInfo(startKey, numOfCols, numOfNotFillCols, capacity, pInterval, fillType, pColInfo, - pInfo->primaryTsCol, order, id); + pInfo->primaryTsCol, order, id, pTaskInfo); if (order == TSDB_ORDER_ASC) { pInfo->win.skey = win.skey; @@ -414,7 +425,13 @@ static int32_t createPrimaryTsExprIfNeeded(SFillOperatorInfo* pInfo, SFillPhysiN return TSDB_CODE_OUT_OF_MEMORY; } - createExprFromTargetNode(&pExpr[pExprSupp->numOfExprs], (STargetNode*)pPhyFillNode->pWStartTs); + int32_t code = createExprFromTargetNode(&pExpr[pExprSupp->numOfExprs], (STargetNode*)pPhyFillNode->pWStartTs); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + taosMemoryFreeClear(pExpr); + return code; + } + pExprSupp->numOfExprs += 1; pExprSupp->pExprInfo = pExpr; } @@ -476,7 +493,7 @@ SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* code = initFillInfo(pInfo, pExprInfo, pInfo->numOfExpr, pNoFillSupp->pExprInfo, pNoFillSupp->numOfExprs, (SNodeListNode*)pPhyFillNode->pValues, pPhyFillNode->timeRange, pResultInfo->capacity, - pTaskInfo->id.str, pInterval, type, order); + pTaskInfo->id.str, pInterval, type, order, pTaskInfo); if (code != TSDB_CODE_SUCCESS) { goto _error; } diff --git a/source/libs/executor/src/groupoperator.c b/source/libs/executor/src/groupoperator.c index dbe844bc32..2e660ef1bc 100644 --- a/source/libs/executor/src/groupoperator.c +++ b/source/libs/executor/src/groupoperator.c @@ -1614,7 +1614,9 @@ SOperatorInfo* createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStr QUERY_CHECK_NULL(pSubTableExpr, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); pInfo->tbnameCalSup.pExprInfo = pSubTableExpr; - createExprFromOneNode(pSubTableExpr, pPartNode->pSubtable, 0); + code = createExprFromOneNode(pSubTableExpr, pPartNode->pSubtable, 0); + QUERY_CHECK_CODE(code, lino, _error); + code = initExprSupp(&pInfo->tbnameCalSup, pSubTableExpr, 1, &pTaskInfo->storageAPI.functionStore); QUERY_CHECK_CODE(code, lino, _error); } diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index 520cba92a1..103378c3ef 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -359,11 +359,10 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanBase* pTableSca if (success) { size_t size = taosArrayGetSize(pBlock->pDataBlock); bool keep = false; - int32_t code = + code = doFilterByBlockSMA(pOperator->exprSupp.pFilterInfo, pBlock->pBlockAgg, size, pBlockInfo->rows, &keep); - if (TSDB_CODE_SUCCESS != code) { - return code; - } + QUERY_CHECK_CODE(code, lino, _end); + if (!keep) { qDebug("%s data block filter out by block SMA, brange:%" PRId64 "-%" PRId64 ", rows:%" PRId64, GET_TASKID(pTaskInfo), pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows); @@ -1125,14 +1124,16 @@ static SSDataBlock* groupSeqTableScan(SOperatorInfo* pOperator) { taosRLockLatch(&pTaskInfo->lock); code = initNextGroupScan(pInfo, &pList, &num); - QUERY_CHECK_CODE(code, lino, _end); taosRUnLockLatch(&pTaskInfo->lock); + QUERY_CHECK_CODE(code, lino, _end); ASSERT(pInfo->base.dataReader == NULL); - pAPI->tsdReader.tsdReaderOpen(pInfo->base.readHandle.vnode, &pInfo->base.cond, pList, num, pInfo->pResBlock, + code = pAPI->tsdReader.tsdReaderOpen(pInfo->base.readHandle.vnode, &pInfo->base.cond, pList, num, pInfo->pResBlock, (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), &pInfo->pIgnoreTables); + QUERY_CHECK_CODE(code, lino, _end); + if (pInfo->filesetDelimited) { pAPI->tsdReader.tsdSetFilesetDelimited(pInfo->base.dataReader); } @@ -1260,7 +1261,7 @@ static void destroyTableScanBase(STableScanBase* pBase, TsdReader* pAPI) { taosArrayDestroy(pBase->matchInfo.pList); } - (void)tableListDestroy(pBase->pTableListInfo); + tableListDestroy(pBase->pTableListInfo); taosLRUCacheCleanup(pBase->metaCache.pTableMetaEntryCache); cleanupExprSupp(&pBase->pseudoSup); } @@ -3472,7 +3473,7 @@ static void destroyRawScanOperatorInfo(void* param) { SStreamRawScanInfo* pRawScan = (SStreamRawScanInfo*)param; pRawScan->pAPI->tsdReader.tsdReaderClose(pRawScan->dataReader); (void)pRawScan->pAPI->snapshotFn.destroySnapshot(pRawScan->sContext); - (void)tableListDestroy(pRawScan->pTableListInfo); + tableListDestroy(pRawScan->pTableListInfo); taosMemoryFree(pRawScan); } @@ -3665,7 +3666,7 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys if (pInfo == NULL || pOperator == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - (void)tableListDestroy(pTableListInfo); + tableListDestroy(pTableListInfo); goto _error; } @@ -3678,7 +3679,7 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys int32_t numOfCols = 0; code = extractColMatchInfo(pScanPhyNode->pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo); if (code != TSDB_CODE_SUCCESS) { - (void)tableListDestroy(pTableListInfo); + tableListDestroy(pTableListInfo); goto _error; } @@ -3707,14 +3708,16 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys SExprInfo* pSubTableExpr = taosMemoryCalloc(1, sizeof(SExprInfo)); if (pSubTableExpr == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - (void)tableListDestroy(pTableListInfo); + tableListDestroy(pTableListInfo); goto _error; } pInfo->tbnameCalSup.pExprInfo = pSubTableExpr; - createExprFromOneNode(pSubTableExpr, pTableScanNode->pSubtable, 0); + code = createExprFromOneNode(pSubTableExpr, pTableScanNode->pSubtable, 0); + QUERY_CHECK_CODE(code, lino, _error); + if (initExprSupp(&pInfo->tbnameCalSup, pSubTableExpr, 1, &pTaskInfo->storageAPI.functionStore) != 0) { - (void)tableListDestroy(pTableListInfo); + tableListDestroy(pTableListInfo); goto _error; } } @@ -3724,12 +3727,12 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys SExprInfo* pTagExpr = createExpr(pTableScanNode->pTags, &numOfTags); if (pTagExpr == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - (void)tableListDestroy(pTableListInfo); + tableListDestroy(pTableListInfo); goto _error; } if (initExprSupp(&pInfo->tagCalSup, pTagExpr, numOfTags, &pTaskInfo->storageAPI.functionStore) != 0) { terrno = TSDB_CODE_OUT_OF_MEMORY; - (void)tableListDestroy(pTableListInfo); + tableListDestroy(pTableListInfo); goto _error; } } @@ -3737,7 +3740,7 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys pInfo->pBlockLists = taosArrayInit(4, sizeof(SPackedData)); if (pInfo->pBlockLists == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - (void)tableListDestroy(pTableListInfo); + tableListDestroy(pTableListInfo); goto _error; } @@ -3802,7 +3805,7 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys memcpy(&pTaskInfo->streamInfo.tableCond, &pTSInfo->base.cond, sizeof(SQueryTableDataCond)); } else { taosArrayDestroy(pColIds); - (void)tableListDestroy(pTableListInfo); + tableListDestroy(pTableListInfo); pColIds = NULL; } @@ -4307,7 +4310,7 @@ static void destroyTagScanOperatorInfo(void* param) { blockDataDestroy(pInfo->pRes); pInfo->pRes = NULL; taosArrayDestroy(pInfo->matchInfo.pList); - pInfo->pTableListInfo = tableListDestroy(pInfo->pTableListInfo); + tableListDestroy(pInfo->pTableListInfo); taosMemoryFreeClear(param); } @@ -5341,7 +5344,6 @@ SSDataBlock* doTableMergeScan(SOperatorInfo* pOperator) { } pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0; - ; return pBlock; } diff --git a/source/libs/executor/src/sysscanoperator.c b/source/libs/executor/src/sysscanoperator.c index dd6c653a8a..1b09c47f05 100644 --- a/source/libs/executor/src/sysscanoperator.c +++ b/source/libs/executor/src/sysscanoperator.c @@ -14,9 +14,9 @@ */ #include "executorInt.h" -#include "geosWrapper.h" #include "filter.h" #include "functionMgt.h" +#include "geosWrapper.h" #include "querynodes.h" #include "systable.h" #include "tname.h" @@ -129,7 +129,7 @@ const SSTabFltFuncDef filterDict[] = { #define SYSTAB_FILTER_DICT_SIZE (sizeof(filterDict) / sizeof(filterDict[0])) static int32_t buildDbTableInfoBlock(bool sysInfo, const SSDataBlock* p, const SSysTableMeta* pSysDbTableMeta, - size_t size, const char* dbName); + size_t size, const char* dbName, int64_t* pRows); static char* SYSTABLE_IDX_COLUMN[] = {"table_name", "db_name", "create_time", "columns", "ttl", "stable_name", "vgroup_id', 'uid", "type"}; @@ -151,7 +151,7 @@ static int32_t sysTableUserColsFillOneTableCols(const SSysTableScanInfo* pInfo, char* tableType); static void relocateAndFilterSysTagsScanResult(SSysTableScanInfo* pInfo, int32_t numOfRows, SSDataBlock* dataBlock, - SFilterInfo* pFilterInfo); + SFilterInfo* pFilterInfo, SExecTaskInfo* pTaskInfo); int32_t sysFilte__DbName(void* arg, SNode* pNode, SArray* result) { SSTabFltArg* pArg = arg; @@ -162,9 +162,17 @@ int32_t sysFilte__DbName(void* arg, SNode* pNode, SArray* result) { SName sn = {0}; char dbname[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; - tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + int32_t code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } - tNameGetDbName(&sn, varDataVal(dbname)); + code = tNameGetDbName(&sn, varDataVal(dbname)); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } varDataSetLen(dbname, strlen(varDataVal(dbname))); SOperatorNode* pOper = (SOperatorNode*)pNode; @@ -481,11 +489,18 @@ static SSDataBlock* doOptimizeTableNameFilter(SOperatorInfo* pOperator, SSDataBl STR_TO_VARSTR(typeName, "NORMAL_TABLE"); } - sysTableUserColsFillOneTableCols(pInfo, dbname, &numOfRows, dataBlock, tableName, schemaRow, typeName); + code = sysTableUserColsFillOneTableCols(pInfo, dbname, &numOfRows, dataBlock, tableName, schemaRow, typeName); + if (code != TSDB_CODE_SUCCESS) { + pAPI->metaReaderFn.clearReader(&smrTable); + pInfo->loadInfo.totalRows = 0; + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } pAPI->metaReaderFn.clearReader(&smrTable); if (numOfRows > 0) { - relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo); + relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo, pTaskInfo); numOfRows = 0; } @@ -498,19 +513,30 @@ static SSDataBlock* doOptimizeTableNameFilter(SOperatorInfo* pOperator, SSDataBl } int32_t doExtractDbName(char* dbname, SSysTableScanInfo* pInfo, SStorageAPI* pAPI) { - SName sn = {0}; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SName sn = {0}; const char* db = NULL; int32_t vgId = 0; pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, &db, &vgId, NULL, NULL); - tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + QUERY_CHECK_CODE(code, lino, _end); + + code = tNameGetDbName(&sn, varDataVal(dbname)); + QUERY_CHECK_CODE(code, lino, _end); - tNameGetDbName(&sn, varDataVal(dbname)); varDataSetLen(dbname, strlen(varDataVal(dbname))); - return TSDB_CODE_SUCCESS; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; SSysTableScanInfo* pInfo = pOperator->info; @@ -526,8 +552,11 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { blockDataCleanup(pInfo->pRes); pDataBlock = buildInfoSchemaTableMetaBlock(TSDB_INS_TABLE_COLS); - blockDataEnsureCapacity(pDataBlock, pOperator->resultInfo.capacity); - doExtractDbName(dbname, pInfo, pAPI); + code = blockDataEnsureCapacity(pDataBlock, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _end); + + code = doExtractDbName(dbname, pInfo, pAPI); + QUERY_CHECK_CODE(code, lino, _end); // optimize when sql like where table_name='tablename' and xxx. if (pInfo->req.filterTb[0]) { @@ -555,7 +584,6 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { return NULL; } - while (((ret = pAPI->metaFn.cursorNext(pInfo->pCur, TSDB_TABLE_MAX)) == 0)) { char typeName[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; char tableName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; @@ -567,7 +595,8 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { void* schema = taosHashGet(pInfo->pSchema, &pInfo->pCur->mr.me.uid, sizeof(int64_t)); if (schema == NULL) { SSchemaWrapper* schemaWrapper = tCloneSSchemaWrapper(&pInfo->pCur->mr.me.stbEntry.schemaRow); - taosHashPut(pInfo->pSchema, &pInfo->pCur->mr.me.uid, sizeof(int64_t), &schemaWrapper, POINTER_BYTES); + code = taosHashPut(pInfo->pSchema, &pInfo->pCur->mr.me.uid, sizeof(int64_t), &schemaWrapper, POINTER_BYTES); + QUERY_CHECK_CODE(code, lino, _end); } continue; } else if (pInfo->pCur->mr.me.type == TSDB_CHILD_TABLE) { @@ -582,10 +611,11 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { } else { SMetaReader smrSuperTable = {0}; pAPI->metaReaderFn.initReader(&smrSuperTable, pInfo->readHandle.vnode, META_READER_NOLOCK, &pAPI->metaFn); - int code = pAPI->metaReaderFn.getTableEntryByUid(&smrSuperTable, suid); + code = pAPI->metaReaderFn.getTableEntryByUid(&smrSuperTable, suid); if (code != TSDB_CODE_SUCCESS) { // terrno has been set by pAPI->metaReaderFn.getTableEntryByName, therefore, return directly - qError("sysTableScanUserCols get meta by suid:%" PRId64 " error, code:%d, %s", suid, code, GET_TASKID(pTaskInfo)); + qError("sysTableScanUserCols get meta by suid:%" PRId64 " error, code:%d, %s", suid, code, + GET_TASKID(pTaskInfo)); pAPI->metaReaderFn.clearReader(&smrSuperTable); blockDataDestroy(pDataBlock); @@ -593,7 +623,9 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { return NULL; } SSchemaWrapper* schemaWrapper = tCloneSSchemaWrapper(&smrSuperTable.me.stbEntry.schemaRow); - taosHashPut(pInfo->pSchema, &suid, sizeof(int64_t), &schemaWrapper, POINTER_BYTES); + code = taosHashPut(pInfo->pSchema, &suid, sizeof(int64_t), &schemaWrapper, POINTER_BYTES); + QUERY_CHECK_CODE(code, lino, _end); + schemaRow = schemaWrapper; pAPI->metaReaderFn.clearReader(&smrSuperTable); } @@ -608,7 +640,7 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { } if ((numOfRows + schemaRow->nCols) > pOperator->resultInfo.capacity) { - relocateAndFilterSysTagsScanResult(pInfo, numOfRows, pDataBlock, pOperator->exprSupp.pFilterInfo); + relocateAndFilterSysTagsScanResult(pInfo, numOfRows, pDataBlock, pOperator->exprSupp.pFilterInfo, pTaskInfo); numOfRows = 0; if (pInfo->pRes->info.rows > 0) { @@ -616,13 +648,14 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { break; } } else { - sysTableUserColsFillOneTableCols(pInfo, dbname, &numOfRows, pDataBlock, tableName, schemaRow, typeName); + code = sysTableUserColsFillOneTableCols(pInfo, dbname, &numOfRows, pDataBlock, tableName, schemaRow, typeName); + QUERY_CHECK_CODE(code, lino, _end); } } if (numOfRows > 0) { pAPI->metaFn.pauseTableMetaCursor(pInfo->pCur); - relocateAndFilterSysTagsScanResult(pInfo, numOfRows, pDataBlock, pOperator->exprSupp.pFilterInfo); + relocateAndFilterSysTagsScanResult(pInfo, numOfRows, pDataBlock, pOperator->exprSupp.pFilterInfo, pTaskInfo); numOfRows = 0; } @@ -635,10 +668,19 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { pInfo->loadInfo.totalRows += pInfo->pRes->info.rows; qDebug("get cols success, rows:%" PRIu64 " %s", pInfo->loadInfo.totalRows, GET_TASKID(pTaskInfo)); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes; } static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; @@ -651,7 +693,8 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) { int32_t numOfRows = 0; SSDataBlock* dataBlock = buildInfoSchemaTableMetaBlock(TSDB_INS_TABLE_TAGS); - blockDataEnsureCapacity(dataBlock, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(dataBlock, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _end); const char* db = NULL; int32_t vgId = 0; @@ -659,9 +702,12 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) { SName sn = {0}; char dbname[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; - tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + QUERY_CHECK_CODE(code, lino, _end); + + code = tNameGetDbName(&sn, varDataVal(dbname)); + QUERY_CHECK_CODE(code, lino, _end); - tNameGetDbName(&sn, varDataVal(dbname)); varDataSetLen(dbname, strlen(varDataVal(dbname))); char condTableName[TSDB_TABLE_NAME_LEN] = {0}; @@ -699,12 +745,14 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) { return NULL; } - sysTableUserTagsFillOneTableTags(pInfo, &smrSuperTable, &smrChildTable, dbname, tableName, &numOfRows, dataBlock); + code = sysTableUserTagsFillOneTableTags(pInfo, &smrSuperTable, &smrChildTable, dbname, tableName, &numOfRows, dataBlock); + QUERY_CHECK_CODE(code, lino, _end); + pAPI->metaReaderFn.clearReader(&smrSuperTable); pAPI->metaReaderFn.clearReader(&smrChildTable); if (numOfRows > 0) { - relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo); + relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo, pTaskInfo); numOfRows = 0; } blockDataDestroy(dataBlock); @@ -731,7 +779,7 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) { SMetaReader smrSuperTable = {0}; pAPI->metaReaderFn.initReader(&smrSuperTable, pInfo->readHandle.vnode, META_READER_NOLOCK, &pAPI->metaFn); uint64_t suid = pInfo->pCur->mr.me.ctbEntry.suid; - int32_t code = pAPI->metaReaderFn.getTableEntryByUid(&smrSuperTable, suid); + code = pAPI->metaReaderFn.getTableEntryByUid(&smrSuperTable, suid); if (code != TSDB_CODE_SUCCESS) { qError("failed to get super table meta, uid:0x%" PRIx64 ", code:%s, %s", suid, tstrerror(terrno), GET_TASKID(pTaskInfo)); @@ -742,7 +790,7 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) { } if ((smrSuperTable.me.stbEntry.schemaTag.nCols + numOfRows) > pOperator->resultInfo.capacity) { - relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo); + relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo, pTaskInfo); numOfRows = 0; if (pInfo->pRes->info.rows > 0) { @@ -751,15 +799,16 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) { break; } } else { - sysTableUserTagsFillOneTableTags(pInfo, &smrSuperTable, &pInfo->pCur->mr, dbname, tableName, &numOfRows, - dataBlock); + code = sysTableUserTagsFillOneTableTags(pInfo, &smrSuperTable, &pInfo->pCur->mr, dbname, tableName, &numOfRows, + dataBlock); + QUERY_CHECK_CODE(code, lino, _end); } pAPI->metaReaderFn.clearReader(&smrSuperTable); } if (numOfRows > 0) { pAPI->metaFn.pauseTableMetaCursor(pInfo->pCur); - relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo); + relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo, pTaskInfo); numOfRows = 0; } @@ -771,17 +820,39 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) { } pInfo->loadInfo.totalRows += pInfo->pRes->info.rows; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pAPI->metaFn.closeTableMetaCursor(pInfo->pCur); + pInfo->pCur = NULL; + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes; } void relocateAndFilterSysTagsScanResult(SSysTableScanInfo* pInfo, int32_t numOfRows, SSDataBlock* dataBlock, - SFilterInfo* pFilterInfo) { + SFilterInfo* pFilterInfo, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; dataBlock->info.rows = numOfRows; pInfo->pRes->info.rows = numOfRows; - relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, dataBlock->pDataBlock, false); - doFilter(pInfo->pRes, pFilterInfo, NULL); + code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, dataBlock->pDataBlock, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = doFilter(pInfo->pRes, pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); + blockDataCleanup(dataBlock); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } } int32_t convertTagDataToStr(char* str, int type, void* buf, int32_t bufSize, int32_t* len) { @@ -894,7 +965,9 @@ static int32_t sysTableGetGeomText(char* iGeom, int32_t nGeom, char** output, in static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo, SMetaReader* smrSuperTable, SMetaReader* smrChildTable, const char* dbname, const char* tableName, int32_t* pNumOfRows, const SSDataBlock* dataBlock) { - char stableName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + char stableName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(stableName, (*smrSuperTable).me.name); int32_t numOfRows = *pNumOfRows; @@ -905,21 +978,25 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo, // table name pColInfoData = taosArrayGet(dataBlock->pDataBlock, 0); - colDataSetVal(pColInfoData, numOfRows, tableName, false); + code = colDataSetVal(pColInfoData, numOfRows, tableName, false); + QUERY_CHECK_CODE(code, lino, _end); // database name pColInfoData = taosArrayGet(dataBlock->pDataBlock, 1); - colDataSetVal(pColInfoData, numOfRows, dbname, false); + code = colDataSetVal(pColInfoData, numOfRows, dbname, false); + QUERY_CHECK_CODE(code, lino, _end); // super table name pColInfoData = taosArrayGet(dataBlock->pDataBlock, 2); - colDataSetVal(pColInfoData, numOfRows, stableName, false); + code = colDataSetVal(pColInfoData, numOfRows, stableName, false); + QUERY_CHECK_CODE(code, lino, _end); // tag name char tagName[TSDB_COL_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(tagName, (*smrSuperTable).me.stbEntry.schemaTag.pSchema[i].name); pColInfoData = taosArrayGet(dataBlock->pDataBlock, 3); - colDataSetVal(pColInfoData, numOfRows, tagName, false); + code = colDataSetVal(pColInfoData, numOfRows, tagName, false); + QUERY_CHECK_CODE(code, lino, _end); // tag type int8_t tagType = (*smrSuperTable).me.stbEntry.schemaTag.pSchema[i].type; @@ -935,7 +1012,8 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo, (int32_t)((*smrSuperTable).me.stbEntry.schemaTag.pSchema[i].bytes - VARSTR_HEADER_SIZE)); } varDataSetLen(tagTypeStr, tagTypeLen); - colDataSetVal(pColInfoData, numOfRows, (char*)tagTypeStr, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)tagTypeStr, false); + QUERY_CHECK_CODE(code, lino, _end); STagVal tagVal = {0}; tagVal.cid = (*smrSuperTable).me.stbEntry.schemaTag.pSchema[i].colId; @@ -948,7 +1026,8 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo, bool exist = tTagGet((STag*)smrChildTable->me.ctbEntry.pTags, &tagVal); if (exist) { if (tagType == TSDB_DATA_TYPE_GEOMETRY) { - sysTableGetGeomText(tagVal.pData, tagVal.nData, &tagData, &tagLen); + code = sysTableGetGeomText(tagVal.pData, tagVal.nData, &tagData, &tagLen); + QUERY_CHECK_CODE(code, lino, _end); } else if (tagType == TSDB_DATA_TYPE_VARBINARY) { if (taosAscii2Hex(tagVal.pData, tagVal.nData, (void**)&tagData, &tagLen) < 0) { qError("varbinary for systable failed since %s", tstrerror(TSDB_CODE_OUT_OF_MEMORY)); @@ -969,6 +1048,7 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo, char* tagJson = NULL; parseTagDatatoJson(tagData, &tagJson); tagVarChar = taosMemoryMalloc(strlen(tagJson) + VARSTR_HEADER_SIZE); + QUERY_CHECK_NULL(tagVarChar, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); memcpy(varDataVal(tagVarChar), tagJson, strlen(tagJson)); varDataSetLen(tagVarChar, strlen(tagJson)); taosMemoryFree(tagJson); @@ -976,6 +1056,7 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo, int32_t bufSize = IS_VAR_DATA_TYPE(tagType) ? (tagLen + VARSTR_HEADER_SIZE) : (3 + DBL_MANT_DIG - DBL_MIN_EXP + VARSTR_HEADER_SIZE); tagVarChar = taosMemoryCalloc(1, bufSize + 1); + QUERY_CHECK_NULL(tagVarChar, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); int32_t len = -1; if (tagLen > 0) convertTagDataToStr(varDataVal(tagVarChar), tagType, tagData, tagLen, &len); @@ -985,8 +1066,10 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo, } } pColInfoData = taosArrayGet(dataBlock->pDataBlock, 5); - colDataSetVal(pColInfoData, numOfRows, tagVarChar, - (tagData == NULL) || (tagType == TSDB_DATA_TYPE_JSON && tTagIsJsonNull(tagData))); + code = colDataSetVal(pColInfoData, numOfRows, tagVarChar, + (tagData == NULL) || (tagType == TSDB_DATA_TYPE_JSON && tTagIsJsonNull(tagData))); + QUERY_CHECK_CODE(code, lino, _end); + if (tagType == TSDB_DATA_TYPE_GEOMETRY || tagType == TSDB_DATA_TYPE_VARBINARY) taosMemoryFreeClear(tagData); taosMemoryFree(tagVarChar); ++numOfRows; @@ -994,12 +1077,18 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo, *pNumOfRows = numOfRows; - return TSDB_CODE_SUCCESS; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static int32_t sysTableUserColsFillOneTableCols(const SSysTableScanInfo* pInfo, const char* dbname, int32_t* pNumOfRows, const SSDataBlock* dataBlock, char* tName, SSchemaWrapper* schemaRow, char* tableType) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (schemaRow == NULL) { qError("sysTableUserColsFillOneTableCols schemaRow is NULL"); return TSDB_CODE_SUCCESS; @@ -1012,20 +1101,24 @@ static int32_t sysTableUserColsFillOneTableCols(const SSysTableScanInfo* pInfo, // table name pColInfoData = taosArrayGet(dataBlock->pDataBlock, 0); - colDataSetVal(pColInfoData, numOfRows, tName, false); + code = colDataSetVal(pColInfoData, numOfRows, tName, false); + QUERY_CHECK_CODE(code, lino, _end); // database name pColInfoData = taosArrayGet(dataBlock->pDataBlock, 1); - colDataSetVal(pColInfoData, numOfRows, dbname, false); + code = colDataSetVal(pColInfoData, numOfRows, dbname, false); + QUERY_CHECK_CODE(code, lino, _end); pColInfoData = taosArrayGet(dataBlock->pDataBlock, 2); - colDataSetVal(pColInfoData, numOfRows, tableType, false); + code = colDataSetVal(pColInfoData, numOfRows, tableType, false); + QUERY_CHECK_CODE(code, lino, _end); // col name char colName[TSDB_COL_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(colName, schemaRow->pSchema[i].name); pColInfoData = taosArrayGet(dataBlock->pDataBlock, 3); - colDataSetVal(pColInfoData, numOfRows, colName, false); + code = colDataSetVal(pColInfoData, numOfRows, colName, false); + QUERY_CHECK_CODE(code, lino, _end); // col type int8_t colType = schemaRow->pSchema[i].type; @@ -1040,10 +1133,12 @@ static int32_t sysTableUserColsFillOneTableCols(const SSysTableScanInfo* pInfo, (int32_t)((schemaRow->pSchema[i].bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE)); } varDataSetLen(colTypeStr, colTypeLen); - colDataSetVal(pColInfoData, numOfRows, (char*)colTypeStr, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)colTypeStr, false); + QUERY_CHECK_CODE(code, lino, _end); pColInfoData = taosArrayGet(dataBlock->pDataBlock, 5); - colDataSetVal(pColInfoData, numOfRows, (const char*)&schemaRow->pSchema[i].bytes, false); + code = colDataSetVal(pColInfoData, numOfRows, (const char*)&schemaRow->pSchema[i].bytes, false); + QUERY_CHECK_CODE(code, lino, _end); for (int32_t j = 6; j <= 8; ++j) { pColInfoData = taosArrayGet(dataBlock->pDataBlock, j); @@ -1054,7 +1149,11 @@ static int32_t sysTableUserColsFillOneTableCols(const SSysTableScanInfo* pInfo, *pNumOfRows = numOfRows; - return TSDB_CODE_SUCCESS; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static SSDataBlock* buildInfoSchemaTableMetaBlock(char* tableName) { @@ -1074,14 +1173,23 @@ static SSDataBlock* buildInfoSchemaTableMetaBlock(char* tableName) { for (int32_t i = 0; i < pMeta[index].colNum; ++i) { SColumnInfoData colInfoData = createColumnInfoData(pMeta[index].schema[i].type, pMeta[index].schema[i].bytes, i + 1); - blockDataAppendColInfo(pBlock, &colInfoData); + int32_t code = blockDataAppendColInfo(pBlock, &colInfoData); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + blockDataDestroy(pBlock); + pBlock = NULL; + terrno = code; + break; + } } return pBlock; } int32_t buildDbTableInfoBlock(bool sysInfo, const SSDataBlock* p, const SSysTableMeta* pSysDbTableMeta, size_t size, - const char* dbName) { + const char* dbName, int64_t* pRows) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; char n[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; int32_t numOfRows = p->info.rows; @@ -1091,19 +1199,21 @@ int32_t buildDbTableInfoBlock(bool sysInfo, const SSDataBlock* p, const SSysTabl continue; } - if(strcmp(pm->name, TSDB_INS_TABLE_USERS_FULL) == 0){ + if (strcmp(pm->name, TSDB_INS_TABLE_USERS_FULL) == 0) { continue; } SColumnInfoData* pColInfoData = taosArrayGet(p->pDataBlock, 0); STR_TO_VARSTR(n, pm->name); - colDataSetVal(pColInfoData, numOfRows, n, false); + code = colDataSetVal(pColInfoData, numOfRows, n, false); + QUERY_CHECK_CODE(code, lino, _end); // database name STR_TO_VARSTR(n, dbName); pColInfoData = taosArrayGet(p->pDataBlock, 1); - colDataSetVal(pColInfoData, numOfRows, n, false); + code = colDataSetVal(pColInfoData, numOfRows, n, false); + QUERY_CHECK_CODE(code, lino, _end); // create time pColInfoData = taosArrayGet(p->pDataBlock, 2); @@ -1111,7 +1221,8 @@ int32_t buildDbTableInfoBlock(bool sysInfo, const SSDataBlock* p, const SSysTabl // number of columns pColInfoData = taosArrayGet(p->pDataBlock, 3); - colDataSetVal(pColInfoData, numOfRows, (char*)&pm->colNum, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&pm->colNum, false); + QUERY_CHECK_CODE(code, lino, _end); for (int32_t j = 4; j <= 8; ++j) { pColInfoData = taosArrayGet(p->pDataBlock, j); @@ -1121,41 +1232,61 @@ int32_t buildDbTableInfoBlock(bool sysInfo, const SSDataBlock* p, const SSysTabl STR_TO_VARSTR(n, "SYSTEM_TABLE"); pColInfoData = taosArrayGet(p->pDataBlock, 9); - colDataSetVal(pColInfoData, numOfRows, n, false); + code = colDataSetVal(pColInfoData, numOfRows, n, false); + QUERY_CHECK_CODE(code, lino, _end); numOfRows += 1; } - return numOfRows; + *pRows = numOfRows; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } int32_t buildSysDbTableInfo(const SSysTableScanInfo* pInfo, int32_t capacity) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SSDataBlock* p = buildInfoSchemaTableMetaBlock(TSDB_INS_TABLE_TABLES); - blockDataEnsureCapacity(p, capacity); + QUERY_CHECK_NULL(p, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + code = blockDataEnsureCapacity(p, capacity); + QUERY_CHECK_CODE(code, lino, _end); size_t size = 0; const SSysTableMeta* pSysDbTableMeta = NULL; getInfosDbMeta(&pSysDbTableMeta, &size); - p->info.rows = buildDbTableInfoBlock(pInfo->sysInfo, p, pSysDbTableMeta, size, TSDB_INFORMATION_SCHEMA_DB); + code = buildDbTableInfoBlock(pInfo->sysInfo, p, pSysDbTableMeta, size, TSDB_INFORMATION_SCHEMA_DB, &p->info.rows); + QUERY_CHECK_CODE(code, lino, _end); getPerfDbMeta(&pSysDbTableMeta, &size); - p->info.rows = buildDbTableInfoBlock(pInfo->sysInfo, p, pSysDbTableMeta, size, TSDB_PERFORMANCE_SCHEMA_DB); + code = buildDbTableInfoBlock(pInfo->sysInfo, p, pSysDbTableMeta, size, TSDB_PERFORMANCE_SCHEMA_DB, &p->info.rows); + QUERY_CHECK_CODE(code, lino, _end); pInfo->pRes->info.rows = p->info.rows; - relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); + code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); + QUERY_CHECK_CODE(code, lino, _end); + blockDataDestroy(p); - return pInfo->pRes->info.rows; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) { - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - SStorageAPI* pAPI = &pTaskInfo->storageAPI; - + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + SStorageAPI* pAPI = &pTaskInfo->storageAPI; SSysTableScanInfo* pInfo = pOperator->info; - - SSysTableIndex* pIdx = pInfo->pIdx; + SSysTableIndex* pIdx = pInfo->pIdx; blockDataCleanup(pInfo->pRes); int32_t numOfRows = 0; @@ -1167,13 +1298,17 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) { SName sn = {0}; char dbname[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; - tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + QUERY_CHECK_CODE(code, lino, _end); + + code = tNameGetDbName(&sn, varDataVal(dbname)); + QUERY_CHECK_CODE(code, lino, _end); - tNameGetDbName(&sn, varDataVal(dbname)); varDataSetLen(dbname, strlen(varDataVal(dbname))); SSDataBlock* p = buildInfoSchemaTableMetaBlock(TSDB_INS_TABLE_TABLES); - blockDataEnsureCapacity(p, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(p, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _end); char n[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; int32_t i = pIdx->lastIdx; @@ -1191,28 +1326,32 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) { // table name SColumnInfoData* pColInfoData = taosArrayGet(p->pDataBlock, 0); - colDataSetVal(pColInfoData, numOfRows, n, false); + code = colDataSetVal(pColInfoData, numOfRows, n, false); + QUERY_CHECK_CODE(code, lino, _end); // database name pColInfoData = taosArrayGet(p->pDataBlock, 1); - colDataSetVal(pColInfoData, numOfRows, dbname, false); + code = colDataSetVal(pColInfoData, numOfRows, dbname, false); + QUERY_CHECK_CODE(code, lino, _end); // vgId pColInfoData = taosArrayGet(p->pDataBlock, 6); - colDataSetVal(pColInfoData, numOfRows, (char*)&vgId, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&vgId, false); + QUERY_CHECK_CODE(code, lino, _end); int32_t tableType = mr.me.type; if (tableType == TSDB_CHILD_TABLE) { // create time int64_t ts = mr.me.ctbEntry.btime; pColInfoData = taosArrayGet(p->pDataBlock, 2); - colDataSetVal(pColInfoData, numOfRows, (char*)&ts, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&ts, false); + QUERY_CHECK_CODE(code, lino, _end); SMetaReader mr1 = {0}; pAPI->metaReaderFn.initReader(&mr1, pInfo->readHandle.vnode, META_READER_NOLOCK, &pAPI->metaFn); int64_t suid = mr.me.ctbEntry.suid; - int32_t code = pAPI->metaReaderFn.getTableEntryByUid(&mr1, suid); + code = pAPI->metaReaderFn.getTableEntryByUid(&mr1, suid); if (code != TSDB_CODE_SUCCESS) { qError("failed to get super table meta, cname:%s, suid:0x%" PRIx64 ", code:%s, %s", pInfo->pCur->mr.me.name, suid, tstrerror(terrno), GET_TASKID(pTaskInfo)); @@ -1221,12 +1360,14 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) { T_LONG_JMP(pTaskInfo->env, terrno); } pColInfoData = taosArrayGet(p->pDataBlock, 3); - colDataSetVal(pColInfoData, numOfRows, (char*)&mr1.me.stbEntry.schemaRow.nCols, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr1.me.stbEntry.schemaRow.nCols, false); + QUERY_CHECK_CODE(code, lino, _end); // super table name STR_TO_VARSTR(n, mr1.me.name); pColInfoData = taosArrayGet(p->pDataBlock, 4); - colDataSetVal(pColInfoData, numOfRows, n, false); + code = colDataSetVal(pColInfoData, numOfRows, n, false); + QUERY_CHECK_CODE(code, lino, _end); pAPI->metaReaderFn.clearReader(&mr1); // table comment @@ -1234,33 +1375,39 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) { if (mr.me.ctbEntry.commentLen > 0) { char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(comment, mr.me.ctbEntry.comment); - colDataSetVal(pColInfoData, numOfRows, comment, false); + code = colDataSetVal(pColInfoData, numOfRows, comment, false); + QUERY_CHECK_CODE(code, lino, _end); } else if (mr.me.ctbEntry.commentLen == 0) { char comment[VARSTR_HEADER_SIZE + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(comment, ""); - colDataSetVal(pColInfoData, numOfRows, comment, false); + code = colDataSetVal(pColInfoData, numOfRows, comment, false); + QUERY_CHECK_CODE(code, lino, _end); } else { colDataSetNULL(pColInfoData, numOfRows); } // uid pColInfoData = taosArrayGet(p->pDataBlock, 5); - colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.uid, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.uid, false); + QUERY_CHECK_CODE(code, lino, _end); // ttl pColInfoData = taosArrayGet(p->pDataBlock, 7); - colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.ctbEntry.ttlDays, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.ctbEntry.ttlDays, false); + QUERY_CHECK_CODE(code, lino, _end); STR_TO_VARSTR(n, "CHILD_TABLE"); } else if (tableType == TSDB_NORMAL_TABLE) { // create time pColInfoData = taosArrayGet(p->pDataBlock, 2); - colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.btime, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.btime, false); + QUERY_CHECK_CODE(code, lino, _end); // number of columns pColInfoData = taosArrayGet(p->pDataBlock, 3); - colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.schemaRow.nCols, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.schemaRow.nCols, false); + QUERY_CHECK_CODE(code, lino, _end); // super table name pColInfoData = taosArrayGet(p->pDataBlock, 4); @@ -1271,22 +1418,26 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) { if (mr.me.ntbEntry.commentLen > 0) { char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(comment, mr.me.ntbEntry.comment); - colDataSetVal(pColInfoData, numOfRows, comment, false); + code = colDataSetVal(pColInfoData, numOfRows, comment, false); + QUERY_CHECK_CODE(code, lino, _end); } else if (mr.me.ntbEntry.commentLen == 0) { char comment[VARSTR_HEADER_SIZE + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(comment, ""); - colDataSetVal(pColInfoData, numOfRows, comment, false); + code = colDataSetVal(pColInfoData, numOfRows, comment, false); + QUERY_CHECK_CODE(code, lino, _end); } else { colDataSetNULL(pColInfoData, numOfRows); } // uid pColInfoData = taosArrayGet(p->pDataBlock, 5); - colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.uid, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.uid, false); + QUERY_CHECK_CODE(code, lino, _end); // ttl pColInfoData = taosArrayGet(p->pDataBlock, 7); - colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.ntbEntry.ttlDays, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.ntbEntry.ttlDays, false); + QUERY_CHECK_CODE(code, lino, _end); STR_TO_VARSTR(n, "NORMAL_TABLE"); // impl later @@ -1295,14 +1446,18 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) { pAPI->metaReaderFn.clearReader(&mr); pColInfoData = taosArrayGet(p->pDataBlock, 9); - colDataSetVal(pColInfoData, numOfRows, n, false); + code = colDataSetVal(pColInfoData, numOfRows, n, false); + QUERY_CHECK_CODE(code, lino, _end); if (++numOfRows >= pOperator->resultInfo.capacity) { p->info.rows = numOfRows; pInfo->pRes->info.rows = numOfRows; - relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); - doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); blockDataCleanup(p); numOfRows = 0; @@ -1317,8 +1472,11 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) { p->info.rows = numOfRows; pInfo->pRes->info.rows = numOfRows; - relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); - doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); blockDataCleanup(p); numOfRows = 0; @@ -1333,10 +1491,19 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) { blockDataDestroy(p); pInfo->loadInfo.totalRows += pInfo->pRes->info.rows; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes; } static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; int8_t firstMetaCursor = 0; @@ -1359,13 +1526,19 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) { SName sn = {0}; char dbname[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; - tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + QUERY_CHECK_CODE(code, lino, _end); + + code = tNameGetDbName(&sn, varDataVal(dbname)); + QUERY_CHECK_CODE(code, lino, _end); - tNameGetDbName(&sn, varDataVal(dbname)); varDataSetLen(dbname, strlen(varDataVal(dbname))); SSDataBlock* p = buildInfoSchemaTableMetaBlock(TSDB_INS_TABLE_TABLES); - blockDataEnsureCapacity(p, pOperator->resultInfo.capacity); + QUERY_CHECK_NULL(p, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + code = blockDataEnsureCapacity(p, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _end); char n[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; @@ -1375,28 +1548,32 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) { // table name SColumnInfoData* pColInfoData = taosArrayGet(p->pDataBlock, 0); - colDataSetVal(pColInfoData, numOfRows, n, false); + code = colDataSetVal(pColInfoData, numOfRows, n, false); + QUERY_CHECK_CODE(code, lino, _end); // database name pColInfoData = taosArrayGet(p->pDataBlock, 1); - colDataSetVal(pColInfoData, numOfRows, dbname, false); + code = colDataSetVal(pColInfoData, numOfRows, dbname, false); + QUERY_CHECK_CODE(code, lino, _end); // vgId pColInfoData = taosArrayGet(p->pDataBlock, 6); - colDataSetVal(pColInfoData, numOfRows, (char*)&vgId, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&vgId, false); + QUERY_CHECK_CODE(code, lino, _end); int32_t tableType = pInfo->pCur->mr.me.type; if (tableType == TSDB_CHILD_TABLE) { // create time int64_t ts = pInfo->pCur->mr.me.ctbEntry.btime; pColInfoData = taosArrayGet(p->pDataBlock, 2); - colDataSetVal(pColInfoData, numOfRows, (char*)&ts, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&ts, false); + QUERY_CHECK_CODE(code, lino, _end); SMetaReader mr = {0}; pAPI->metaReaderFn.initReader(&mr, pInfo->readHandle.vnode, META_READER_NOLOCK, &pAPI->metaFn); uint64_t suid = pInfo->pCur->mr.me.ctbEntry.suid; - int32_t code = pAPI->metaReaderFn.getTableEntryByUid(&mr, suid); + code = pAPI->metaReaderFn.getTableEntryByUid(&mr, suid); if (code != TSDB_CODE_SUCCESS) { qError("failed to get super table meta, cname:%s, suid:0x%" PRIx64 ", code:%s, %s", pInfo->pCur->mr.me.name, suid, tstrerror(terrno), GET_TASKID(pTaskInfo)); @@ -1413,12 +1590,14 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) { // number of columns pColInfoData = taosArrayGet(p->pDataBlock, 3); - colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.stbEntry.schemaRow.nCols, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.stbEntry.schemaRow.nCols, false); + QUERY_CHECK_CODE(code, lino, _end); // super table name STR_TO_VARSTR(n, mr.me.name); pColInfoData = taosArrayGet(p->pDataBlock, 4); - colDataSetVal(pColInfoData, numOfRows, n, false); + code = colDataSetVal(pColInfoData, numOfRows, n, false); + QUERY_CHECK_CODE(code, lino, _end); pAPI->metaReaderFn.clearReader(&mr); // table comment @@ -1426,32 +1605,38 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) { if (pInfo->pCur->mr.me.ctbEntry.commentLen > 0) { char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(comment, pInfo->pCur->mr.me.ctbEntry.comment); - colDataSetVal(pColInfoData, numOfRows, comment, false); + code = colDataSetVal(pColInfoData, numOfRows, comment, false); + QUERY_CHECK_CODE(code, lino, _end); } else if (pInfo->pCur->mr.me.ctbEntry.commentLen == 0) { char comment[VARSTR_HEADER_SIZE + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(comment, ""); - colDataSetVal(pColInfoData, numOfRows, comment, false); + code = colDataSetVal(pColInfoData, numOfRows, comment, false); + QUERY_CHECK_CODE(code, lino, _end); } else { colDataSetNULL(pColInfoData, numOfRows); } // uid pColInfoData = taosArrayGet(p->pDataBlock, 5); - colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.uid, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.uid, false); + QUERY_CHECK_CODE(code, lino, _end); // ttl pColInfoData = taosArrayGet(p->pDataBlock, 7); - colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ctbEntry.ttlDays, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ctbEntry.ttlDays, false); + QUERY_CHECK_CODE(code, lino, _end); STR_TO_VARSTR(n, "CHILD_TABLE"); } else if (tableType == TSDB_NORMAL_TABLE) { // create time pColInfoData = taosArrayGet(p->pDataBlock, 2); - colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.btime, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.btime, false); + QUERY_CHECK_CODE(code, lino, _end); // number of columns pColInfoData = taosArrayGet(p->pDataBlock, 3); - colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.schemaRow.nCols, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.schemaRow.nCols, false); + QUERY_CHECK_CODE(code, lino, _end); // super table name pColInfoData = taosArrayGet(p->pDataBlock, 4); @@ -1462,35 +1647,43 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) { if (pInfo->pCur->mr.me.ntbEntry.commentLen > 0) { char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(comment, pInfo->pCur->mr.me.ntbEntry.comment); - colDataSetVal(pColInfoData, numOfRows, comment, false); + code = colDataSetVal(pColInfoData, numOfRows, comment, false); + QUERY_CHECK_CODE(code, lino, _end); } else if (pInfo->pCur->mr.me.ntbEntry.commentLen == 0) { char comment[VARSTR_HEADER_SIZE + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(comment, ""); - colDataSetVal(pColInfoData, numOfRows, comment, false); + code = colDataSetVal(pColInfoData, numOfRows, comment, false); + QUERY_CHECK_CODE(code, lino, _end); } else { colDataSetNULL(pColInfoData, numOfRows); } // uid pColInfoData = taosArrayGet(p->pDataBlock, 5); - colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.uid, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.uid, false); + QUERY_CHECK_CODE(code, lino, _end); // ttl pColInfoData = taosArrayGet(p->pDataBlock, 7); - colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.ttlDays, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.ttlDays, false); + QUERY_CHECK_CODE(code, lino, _end); STR_TO_VARSTR(n, "NORMAL_TABLE"); } pColInfoData = taosArrayGet(p->pDataBlock, 9); - colDataSetVal(pColInfoData, numOfRows, n, false); + code = colDataSetVal(pColInfoData, numOfRows, n, false); + QUERY_CHECK_CODE(code, lino, _end); if (++numOfRows >= pOperator->resultInfo.capacity) { p->info.rows = numOfRows; pInfo->pRes->info.rows = numOfRows; - relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); - doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); blockDataCleanup(p); numOfRows = 0; @@ -1507,8 +1700,11 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) { p->info.rows = numOfRows; pInfo->pRes->info.rows = numOfRows; - relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); - doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); blockDataCleanup(p); numOfRows = 0; @@ -1524,10 +1720,19 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) { } pInfo->loadInfo.totalRows += pInfo->pRes->info.rows; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes; } static SSDataBlock* sysTableScanUserTables(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SSysTableScanInfo* pInfo = pOperator->info; @@ -1538,8 +1743,11 @@ static SSDataBlock* sysTableScanUserTables(SOperatorInfo* pOperator) { // the retrieve is executed on the mnode, so return tables that belongs to the information schema database. if (pInfo->readHandle.mnd != NULL) { - buildSysDbTableInfo(pInfo, pOperator->resultInfo.capacity); - doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = buildSysDbTableInfo(pInfo, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _end); + + code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); pInfo->loadInfo.totalRows += pInfo->pRes->info.rows; setOperatorCompleted(pOperator); @@ -1573,6 +1781,13 @@ static SSDataBlock* sysTableScanUserTables(SOperatorInfo* pOperator) { return sysTableBuildUserTables(pOperator); } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return NULL; } @@ -1657,7 +1872,6 @@ static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator) { char dbName[TSDB_DB_NAME_LEN] = {0}; while (1) { - if (isTaskKilled(pOperator->pTaskInfo)) { setOperatorCompleted(pOperator); return NULL; @@ -1675,7 +1889,7 @@ static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator) { } else if (strncasecmp(name, TSDB_INS_TABLE_COLS, TSDB_TABLE_FNAME_LEN) == 0) { getDBNameFromCondition(pInfo->pCondition, dbName); if (dbName[0]) sprintf(pInfo->req.db, "%d.%s", pInfo->accountId, dbName); - sysTableIsCondOnOneTable(pInfo->pCondition, pInfo->req.filterTb); + (void)sysTableIsCondOnOneTable(pInfo->pCondition, pInfo->req.filterTb); } SSDataBlock* pBlock = NULL; @@ -1686,7 +1900,7 @@ static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator) { } else if (strncasecmp(name, TSDB_INS_TABLE_COLS, TSDB_TABLE_FNAME_LEN) == 0 && pInfo->readHandle.mnd == NULL) { pBlock = sysTableScanUserCols(pOperator); } else if (strncasecmp(name, TSDB_INS_TABLE_STABLES, TSDB_TABLE_FNAME_LEN) == 0 && pInfo->showRewrite && - IS_SYS_DBNAME(dbName)) { + IS_SYS_DBNAME(dbName)) { pBlock = sysTableScanUserSTables(pOperator); } else { // load the meta from mnode of the given epset pBlock = sysTableScanFromMNode(pOperator, pInfo, name, pTaskInfo); @@ -1711,6 +1925,9 @@ static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator) { static void sysTableScanFillTbName(SOperatorInfo* pOperator, const SSysTableScanInfo* pInfo, const char* name, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; if (pBlock == NULL) { return; } @@ -1720,14 +1937,25 @@ static void sysTableScanFillTbName(SOperatorInfo* pOperator, const SSysTableScan char varTbName[TSDB_TABLE_FNAME_LEN - 1 + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(varTbName, name); - colDataSetNItems(pColumnInfoData, 0, varTbName, pBlock->info.rows, true); + code = colDataSetNItems(pColumnInfoData, 0, varTbName, pBlock->info.rows, true); + QUERY_CHECK_CODE(code, lino, _end); } - doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } } static SSDataBlock* sysTableScanFromMNode(SOperatorInfo* pOperator, SSysTableScanInfo* pInfo, const char* name, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pOperator->status == OP_EXEC_DONE) { return NULL; } @@ -1739,7 +1967,7 @@ static SSDataBlock* sysTableScanFromMNode(SOperatorInfo* pOperator, SSysTableSca int32_t contLen = tSerializeSRetrieveTableReq(NULL, 0, &pInfo->req); char* buf1 = taosMemoryCalloc(1, contLen); - tSerializeSRetrieveTableReq(buf1, contLen, &pInfo->req); + (void)tSerializeSRetrieveTableReq(buf1, contLen, &pInfo->req); // send the fetch remote task result reques SMsgSendInfo* pMsgSendInfo = taosMemoryCalloc(1, sizeof(SMsgSendInfo)); @@ -1760,9 +1988,14 @@ static SSDataBlock* sysTableScanFromMNode(SOperatorInfo* pOperator, SSysTableSca pMsgSendInfo->requestId = pTaskInfo->id.queryId; int64_t transporterId = 0; - int32_t code = - asyncSendMsgToServer(pInfo->readHandle.pMsgCb->clientRpc, &pInfo->epSet, &transporterId, pMsgSendInfo); - tsem_wait(&pInfo->ready); + code = asyncSendMsgToServer(pInfo->readHandle.pMsgCb->clientRpc, &pInfo->epSet, &transporterId, pMsgSendInfo); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } + + (void)tsem_wait(&pInfo->ready); if (pTaskInfo->code) { qError("%s load meta data from mnode failed, totalRows:%" PRIu64 ", code:%s", GET_TASKID(pTaskInfo), @@ -1785,11 +2018,23 @@ static SSDataBlock* sysTableScanFromMNode(SOperatorInfo* pOperator, SSysTableSca } char* pStart = pRsp->data; - extractDataBlockFromFetchRsp(pInfo->pRes, pRsp->data, pInfo->matchInfo.pList, &pStart); + code = extractDataBlockFromFetchRsp(pInfo->pRes, pRsp->data, pInfo->matchInfo.pList, &pStart); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + taosMemoryFreeClear(pRsp); + T_LONG_JMP(pTaskInfo->env, code); + } updateLoadRemoteInfo(&pInfo->loadInfo, pRsp->numOfRows, pRsp->compLen, startTs, pOperator); // todo log the filter info - doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + taosMemoryFreeClear(pRsp); + T_LONG_JMP(pTaskInfo->env, code); + } taosMemoryFree(pRsp); if (pInfo->pRes->info.rows > 0) { return pInfo->pRes; @@ -1802,6 +2047,7 @@ static SSDataBlock* sysTableScanFromMNode(SOperatorInfo* pOperator, SSysTableSca SOperatorInfo* createSysTableScanOperatorInfo(void* readHandle, SSystemTableScanPhysiNode* pScanPhyNode, const char* pUser, SExecTaskInfo* pTaskInfo) { 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) { @@ -1828,13 +2074,12 @@ SOperatorInfo* createSysTableScanOperatorInfo(void* readHandle, SSystemTableScan pInfo->pRes = createDataBlockFromDescNode(pDescNode); pInfo->pCondition = pScanNode->node.pConditions; code = filterInitFromNode(pScanNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); initLimitInfo(pScanPhyNode->scan.node.pLimit, pScanPhyNode->scan.node.pSlimit, &pInfo->limitInfo); initResultSizeInfo(&pOperator->resultInfo, 4096); - blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _error); tNameAssign(&pInfo->name, &pScanNode->tableName); const char* name = tNameGetTableName(&pInfo->name); @@ -1843,7 +2088,10 @@ SOperatorInfo* createSysTableScanOperatorInfo(void* readHandle, SSystemTableScan strncasecmp(name, TSDB_INS_TABLE_TAGS, TSDB_TABLE_FNAME_LEN) == 0) { pInfo->readHandle = *(SReadHandle*)readHandle; } else { - tsem_init(&pInfo->ready, 0, 0); + if (tsem_init(&pInfo->ready, 0, 0) != TSDB_CODE_SUCCESS) { + code = TSDB_CODE_FAILED; + goto _error; + } pInfo->epSet = pScanPhyNode->mgmtEpSet; pInfo->readHandle = *(SReadHandle*)readHandle; } @@ -1859,6 +2107,9 @@ _error: if (pInfo != NULL) { destroySysScanOperator(pInfo); } + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } taosMemoryFreeClear(pOperator); pTaskInfo->code = code; return NULL; @@ -1886,7 +2137,7 @@ void extractTbnameSlotId(SSysTableScanInfo* pInfo, const SScanPhysiNode* pScanNo void destroySysScanOperator(void* param) { SSysTableScanInfo* pInfo = (SSysTableScanInfo*)param; - tsem_destroy(&pInfo->ready); + (void)tsem_destroy(&pInfo->ready); blockDataDestroy(pInfo->pRes); const char* name = tNameGetTableName(&pInfo->name); @@ -1938,7 +2189,7 @@ int32_t loadSysTableCallback(void* param, SDataBuf* pMsg, int32_t code) { } } - tsem_post(&pScanResInfo->ready); + (void)tsem_post(&pScanResInfo->ready); return TSDB_CODE_SUCCESS; } @@ -2082,12 +2333,15 @@ static FORCE_INLINE int optSysBinarySearch(SArray* arr, int s, int e, uint64_t k return s; } -void optSysIntersection(SArray* in, SArray* out) { +int32_t optSysIntersection(SArray* in, SArray* out) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; int32_t sz = (int32_t)taosArrayGetSize(in); if (sz <= 0) { - return; + goto _end; } MergeIndex* mi = taosMemoryCalloc(sz, sizeof(MergeIndex)); + QUERY_CHECK_NULL(mi, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); for (int i = 0; i < sz; i++) { SArray* t = taosArrayGetP(in, i); mi[i].len = (int32_t)taosArrayGetSize(t); @@ -2110,10 +2364,20 @@ void optSysIntersection(SArray* in, SArray* out) { } } if (has == true) { - taosArrayPush(out, &tgt); + void* tmp = taosArrayPush(out, &tgt); + if (!tmp) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _end; + } } } + +_end: taosMemoryFreeClear(mi); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static int tableUidCompare(const void* a, const void* b) { @@ -2131,8 +2395,7 @@ static int32_t optSysMergeRslt(SArray* mRslt, SArray* rslt) { SArray* arslt = taosArrayGetP(mRslt, i); taosArraySort(arslt, tableUidCompare); } - optSysIntersection(mRslt, rslt); - return 0; + return optSysIntersection(mRslt, rslt); } static int32_t optSysSpecialColumn(SNode* cond) { @@ -2147,7 +2410,7 @@ static int32_t optSysSpecialColumn(SNode* cond) { } static int32_t optSysTabFilte(void* arg, SNode* cond, SArray* result) { - int ret = -1; + int ret = TSDB_CODE_FAILED; if (nodeType(cond) == QUERY_NODE_OPERATOR) { ret = optSysTabFilteImpl(arg, cond, result); if (ret == 0) { @@ -2185,7 +2448,10 @@ static int32_t optSysTabFilte(void* arg, SNode* cond, SArray* result) { // has index hasIdx = true; if (optSysSpecialColumn(cell->pNode) == 0) { - taosArrayPush(mRslt, &aRslt); + void* tmp = taosArrayPush(mRslt, &aRslt); + if (!tmp) { + return TSDB_CODE_FAILED; + } } else { // db_name/vgroup not result taosArrayDestroy(aRslt); @@ -2202,7 +2468,10 @@ static int32_t optSysTabFilte(void* arg, SNode* cond, SArray* result) { cell = cell->pNext; } if (hasRslt && hasIdx) { - optSysMergeRslt(mRslt, result); + int32_t code = optSysMergeRslt(mRslt, result); + if (code != TSDB_CODE_SUCCESS) { + return code; + } } for (int i = 0; i < taosArrayGetSize(mRslt); i++) { @@ -2273,6 +2542,8 @@ static int32_t doGetTableRowSize(SReadHandle* pHandle, uint64_t uid, int32_t* ro } static SSDataBlock* doBlockInfoScan(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pOperator->status == OP_EXEC_DONE) { return NULL; } @@ -2282,13 +2553,13 @@ static SSDataBlock* doBlockInfoScan(SOperatorInfo* pOperator) { SStorageAPI* pAPI = &pTaskInfo->storageAPI; STableBlockDistInfo blockDistInfo = {.minRows = INT_MAX, .maxRows = INT_MIN}; - int32_t code = doGetTableRowSize(&pBlockScanInfo->readHandle, pBlockScanInfo->uid, (int32_t*)&blockDistInfo.rowSize, - GET_TASKID(pTaskInfo)); - if (code != TSDB_CODE_SUCCESS) { - T_LONG_JMP(pTaskInfo->env, code); - } + code = doGetTableRowSize(&pBlockScanInfo->readHandle, pBlockScanInfo->uid, (int32_t*)&blockDistInfo.rowSize, + GET_TASKID(pTaskInfo)); + QUERY_CHECK_CODE(code, lino, _end); + + code = pAPI->tsdReader.tsdReaderGetDataBlockDistInfo(pBlockScanInfo->pHandle, &blockDistInfo); + QUERY_CHECK_CODE(code, lino, _end); - pAPI->tsdReader.tsdReaderGetDataBlockDistInfo(pBlockScanInfo->pHandle, &blockDistInfo); blockDistInfo.numOfInmemRows = (int32_t)pAPI->tsdReader.tsdReaderGetNumOfInMemRows(pBlockScanInfo->pHandle); SSDataBlock* pBlock = pBlockScanInfo->pResBlock; @@ -2298,10 +2569,15 @@ static SSDataBlock* doBlockInfoScan(SOperatorInfo* pOperator) { int32_t len = tSerializeBlockDistInfo(NULL, 0, &blockDistInfo); char* p = taosMemoryCalloc(1, len + VARSTR_HEADER_SIZE); - tSerializeBlockDistInfo(varDataVal(p), len, &blockDistInfo); + QUERY_CHECK_NULL(p, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + code = tSerializeBlockDistInfo(varDataVal(p), len, &blockDistInfo); + QUERY_CHECK_CODE(code, lino, _end); varDataSetLen(p, len); - colDataSetVal(pColInfo, 0, p, false); + code = colDataSetVal(pColInfo, 0, p, false); + QUERY_CHECK_CODE(code, lino, _end); + taosMemoryFree(p); // make the valgrind happy that all memory buffer has been initialized already. @@ -2313,6 +2589,13 @@ static SSDataBlock* doBlockInfoScan(SOperatorInfo* pOperator) { pBlock->info.rows = 1; pOperator->status = OP_EXEC_DONE; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return pBlock; } @@ -2354,6 +2637,8 @@ static int32_t initTableblockDistQueryCond(uint64_t uid, SQueryTableDataCond* pC SOperatorInfo* createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDistScanPhysiNode* pBlockScanNode, STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SBlockDistInfo* pInfo = taosMemoryCalloc(1, sizeof(SBlockDistInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -2362,14 +2647,13 @@ SOperatorInfo* createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDi } pInfo->pResBlock = createDataBlockFromDescNode(pBlockScanNode->node.pOutputDataBlockDesc); - blockDataEnsureCapacity(pInfo->pResBlock, 1); + code = blockDataEnsureCapacity(pInfo->pResBlock, 1); + QUERY_CHECK_CODE(code, lino, _error); { SQueryTableDataCond cond = {0}; - int32_t code = initTableblockDistQueryCond(pBlockScanNode->suid, &cond); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + code = initTableblockDistQueryCond(pBlockScanNode->suid, &cond); + QUERY_CHECK_CODE(code, lino, _error); pInfo->pTableListInfo = pTableListInfo; size_t num = tableListGetSize(pTableListInfo); @@ -2378,9 +2662,7 @@ SOperatorInfo* createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDi code = readHandle->api.tsdReader.tsdReaderOpen(readHandle->vnode, &cond, pList, num, pInfo->pResBlock, (void**)&pInfo->pHandle, pTaskInfo->id.str, NULL); cleanupQueryTableDataCond(&cond); - if (code != 0) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); } pInfo->readHandle = *readHandle; @@ -2388,10 +2670,8 @@ SOperatorInfo* createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDi int32_t numOfCols = 0; SExprInfo* pExprInfo = createExprInfo(pBlockScanNode->pScanPseudoCols, NULL, &numOfCols); - int32_t code = initExprSupp(&pOperator->exprSupp, pExprInfo, numOfCols, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + code = initExprSupp(&pOperator->exprSupp, pExprInfo, numOfCols, &pTaskInfo->storageAPI.functionStore); + QUERY_CHECK_CODE(code, lino, _error); setOperatorInfo(pOperator, "DataBlockDistScanOperator", QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN, false, OP_NOT_OPENED, pInfo, pTaskInfo); diff --git a/source/libs/executor/src/tfill.c b/source/libs/executor/src/tfill.c index 5a8697d7b8..3a024bc22d 100644 --- a/source/libs/executor/src/tfill.c +++ b/source/libs/executor/src/tfill.c @@ -28,6 +28,7 @@ #include "executorInt.h" #include "function.h" #include "querynodes.h" +#include "querytask.h" #include "tdatablock.h" #include "tfill.h" @@ -35,7 +36,7 @@ #define DO_INTERPOLATION(_v1, _v2, _k1, _k2, _k) \ ((_v1) + ((_v2) - (_v1)) * (((double)(_k)) - ((double)(_k1))) / (((double)(_k2)) - ((double)(_k1)))) -static void doSetVal(SColumnInfoData* pDstColInfoData, int32_t rowIndex, const SGroupKeys* pKey); +static int32_t doSetVal(SColumnInfoData* pDstColInfoData, int32_t rowIndex, const SGroupKeys* pKey); static void setNotFillColumn(SFillInfo* pFillInfo, SColumnInfoData* pDstColInfo, int32_t rowIndex, int32_t colIdx) { SRowVal* p = NULL; @@ -46,7 +47,11 @@ static void setNotFillColumn(SFillInfo* pFillInfo, SColumnInfoData* pDstColInfo, } SGroupKeys* pKey = taosArrayGet(p->pRowVal, colIdx); - doSetVal(pDstColInfo, rowIndex, pKey); + int32_t code = doSetVal(pDstColInfo, rowIndex, pKey); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pFillInfo->pTaskInfo->env, code); + } } static void setNullRow(SSDataBlock* pBlock, SFillInfo* pFillInfo, int32_t rowIndex) { @@ -65,39 +70,55 @@ static void setNullRow(SSDataBlock* pBlock, SFillInfo* pFillInfo, int32_t rowInd } } -static void doSetUserSpecifiedValue(SColumnInfoData* pDst, SVariant* pVar, int32_t rowIndex, int64_t currentKey) { - bool isNull = (TSDB_DATA_TYPE_NULL == pVar->nType) ? true : false; +static int32_t doSetUserSpecifiedValue(SColumnInfoData* pDst, SVariant* pVar, int32_t rowIndex, int64_t currentKey) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + bool isNull = (TSDB_DATA_TYPE_NULL == pVar->nType) ? true : false; if (pDst->info.type == TSDB_DATA_TYPE_FLOAT) { float v = 0; GET_TYPED_DATA(v, float, pVar->nType, &pVar->f); - colDataSetVal(pDst, rowIndex, (char*)&v, isNull); + code = colDataSetVal(pDst, rowIndex, (char*)&v, isNull); + QUERY_CHECK_CODE(code, lino, _end); } else if (pDst->info.type == TSDB_DATA_TYPE_DOUBLE) { double v = 0; GET_TYPED_DATA(v, double, pVar->nType, &pVar->d); - colDataSetVal(pDst, rowIndex, (char*)&v, isNull); + code = colDataSetVal(pDst, rowIndex, (char*)&v, isNull); + QUERY_CHECK_CODE(code, lino, _end); } else if (IS_SIGNED_NUMERIC_TYPE(pDst->info.type) || pDst->info.type == TSDB_DATA_TYPE_BOOL) { int64_t v = 0; GET_TYPED_DATA(v, int64_t, pVar->nType, &pVar->i); - colDataSetVal(pDst, rowIndex, (char*)&v, isNull); + code = colDataSetVal(pDst, rowIndex, (char*)&v, isNull); + QUERY_CHECK_CODE(code, lino, _end); } else if (IS_UNSIGNED_NUMERIC_TYPE(pDst->info.type)) { uint64_t v = 0; GET_TYPED_DATA(v, uint64_t, pVar->nType, &pVar->u); - colDataSetVal(pDst, rowIndex, (char*)&v, isNull); + code = colDataSetVal(pDst, rowIndex, (char*)&v, isNull); + QUERY_CHECK_CODE(code, lino, _end); } else if (pDst->info.type == TSDB_DATA_TYPE_TIMESTAMP) { int64_t v = 0; GET_TYPED_DATA(v, int64_t, pVar->nType, &pVar->u); - colDataSetVal(pDst, rowIndex, (const char*)&v, isNull); + code = colDataSetVal(pDst, rowIndex, (const char*)&v, isNull); + QUERY_CHECK_CODE(code, lino, _end); } else if (pDst->info.type == TSDB_DATA_TYPE_NCHAR || pDst->info.type == TSDB_DATA_TYPE_VARCHAR || pDst->info.type == TSDB_DATA_TYPE_VARBINARY) { - colDataSetVal(pDst, rowIndex, pVar->pz, isNull); + code = colDataSetVal(pDst, rowIndex, pVar->pz, isNull); + QUERY_CHECK_CODE(code, lino, _end); } else { // others data colDataSetNULL(pDst, rowIndex); } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } // fill windows pseudo column, _wstart, _wend, _wduration and return true, otherwise return false bool fillIfWindowPseudoColumn(SFillInfo* pFillInfo, SFillColInfo* pCol, SColumnInfoData* pDstColInfoData, int32_t rowIndex) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (!pCol->notFillCol) { return false; } @@ -106,26 +127,37 @@ bool fillIfWindowPseudoColumn(SFillInfo* pFillInfo, SFillColInfo* pCol, SColumnI return false; } if (pCol->pExpr->base.pParam[0].pCol->colType == COLUMN_TYPE_WINDOW_START) { - colDataSetVal(pDstColInfoData, rowIndex, (const char*)&pFillInfo->currentKey, false); + code = colDataSetVal(pDstColInfoData, rowIndex, (const char*)&pFillInfo->currentKey, false); + QUERY_CHECK_CODE(code, lino, _end); return true; } else if (pCol->pExpr->base.pParam[0].pCol->colType == COLUMN_TYPE_WINDOW_END) { // TODO: include endpoint SInterval* pInterval = &pFillInfo->interval; int64_t windowEnd = taosTimeAdd(pFillInfo->currentKey, pInterval->interval, pInterval->intervalUnit, pInterval->precision); - colDataSetVal(pDstColInfoData, rowIndex, (const char*)&windowEnd, false); + code = colDataSetVal(pDstColInfoData, rowIndex, (const char*)&windowEnd, false); + QUERY_CHECK_CODE(code, lino, _end); return true; } else if (pCol->pExpr->base.pParam[0].pCol->colType == COLUMN_TYPE_WINDOW_DURATION) { // TODO: include endpoint - colDataSetVal(pDstColInfoData, rowIndex, (const char*)&pFillInfo->interval.sliding, false); + code = colDataSetVal(pDstColInfoData, rowIndex, (const char*)&pFillInfo->interval.sliding, false); + QUERY_CHECK_CODE(code, lino, _end); return true; } } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pFillInfo->pTaskInfo->env, code); + } return false; } static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock* pSrcBlock, int64_t ts, bool outOfBound) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SPoint point1, point2, point; int32_t step = GET_FORWARD_DIRECTION_FACTOR(pFillInfo->order); @@ -171,7 +203,7 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock* setNotFillColumn(pFillInfo, pDstCol, index, i); } } else { - SRowVal* pRVal = FILL_IS_ASC_FILL(pFillInfo) ? &pFillInfo->prev : &pFillInfo->next; + SRowVal* pRVal = FILL_IS_ASC_FILL(pFillInfo) ? &pFillInfo->prev : &pFillInfo->next; SGroupKeys* pKey = taosArrayGet(pRVal->pRowVal, i); if (IS_VAR_DATA_TYPE(type) || type == TSDB_DATA_TYPE_BOOL || pKey->isNull) { colDataSetNULL(pDstCol, index); @@ -193,7 +225,8 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock* point = (SPoint){.key = pFillInfo->currentKey, .val = &out}; taosGetLinearInterpolationVal(&point, type, &point1, &point2, type); - colDataSetVal(pDstCol, index, (const char*)&out, false); + code = colDataSetVal(pDstCol, index, (const char*)&out, false); + QUERY_CHECK_CODE(code, lino, _end); } } } @@ -213,7 +246,8 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock* } } else { SVariant* pVar = &pFillInfo->pFillCol[i].fillVal; - doSetUserSpecifiedValue(pDst, pVar, index, pFillInfo->currentKey); + code = doSetUserSpecifiedValue(pDst, pVar, index, pFillInfo->currentKey); + QUERY_CHECK_CODE(code, lino, _end); } } } @@ -224,19 +258,36 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock* taosTimeAdd(pFillInfo->currentKey, pInterval->sliding * step, pInterval->slidingUnit, pInterval->precision); pBlock->info.rows += 1; pFillInfo->numOfCurrent++; -} -void doSetVal(SColumnInfoData* pDstCol, int32_t rowIndex, const SGroupKeys* pKey) { - if (pKey->isNull) { - colDataSetNULL(pDstCol, rowIndex); - } else { - colDataSetVal(pDstCol, rowIndex, pKey->pData, false); +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pFillInfo->pTaskInfo->env, code); } } -static void initBeforeAfterDataBuf(SFillInfo* pFillInfo) { +int32_t doSetVal(SColumnInfoData* pDstCol, int32_t rowIndex, const SGroupKeys* pKey) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + if (pKey->isNull) { + colDataSetNULL(pDstCol, rowIndex); + } else { + code = colDataSetVal(pDstCol, rowIndex, pKey->pData, false); + QUERY_CHECK_CODE(code, lino, _end); + } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; +} + +static int32_t initBeforeAfterDataBuf(SFillInfo* pFillInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (taosArrayGetSize(pFillInfo->next.pRowVal) > 0) { - return; + goto _end; } for (int i = 0; i < pFillInfo->numOfCols; i++) { @@ -245,15 +296,26 @@ static void initBeforeAfterDataBuf(SFillInfo* pFillInfo) { SGroupKeys key = {0}; SResSchema* pSchema = &pCol->pExpr->base.resSchema; key.pData = taosMemoryMalloc(pSchema->bytes); + QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); key.isNull = true; key.bytes = pSchema->bytes; key.type = pSchema->type; - taosArrayPush(pFillInfo->next.pRowVal, &key); + void* tmp = taosArrayPush(pFillInfo->next.pRowVal, &key); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); key.pData = taosMemoryMalloc(pSchema->bytes); - taosArrayPush(pFillInfo->prev.pRowVal, &key); + QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + tmp = taosArrayPush(pFillInfo->prev.pRowVal, &key); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static void saveColData(SArray* rowBuf, int32_t columnIndex, const char* src, bool isNull); @@ -264,7 +326,7 @@ static void copyCurrentRowIntoBuf(SFillInfo* pFillInfo, int32_t rowIndex, SRowVa for (int32_t i = 0; i < pFillInfo->numOfCols; ++i) { int32_t type = pFillInfo->pFillCol[i].pExpr->pExpr->nodeType; - if ( type == QUERY_NODE_COLUMN || type == QUERY_NODE_OPERATOR || type == QUERY_NODE_FUNCTION) { + if (type == QUERY_NODE_COLUMN || type == QUERY_NODE_OPERATOR || type == QUERY_NODE_FUNCTION) { if (!pFillInfo->pFillCol[i].notFillCol && pFillInfo->type != TSDB_FILL_NEXT) { continue; } @@ -288,7 +350,8 @@ static void copyCurrentRowIntoBuf(SFillInfo* pFillInfo, int32_t rowIndex, SRowVa static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t outputRows) { pFillInfo->numOfCurrent = 0; - + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SColumnInfoData* pTsCol = taosArrayGet(pFillInfo->pSrcBlock->pDataBlock, pFillInfo->srcTsSlotId); int32_t step = GET_FORWARD_DIRECTION_FACTOR(pFillInfo->order); @@ -321,7 +384,7 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t // output buffer is full, abort if (pFillInfo->numOfCurrent == outputRows) { pFillInfo->numOfTotal += pFillInfo->numOfCurrent; - return outputRows; + goto _end; } } else { ASSERT(pFillInfo->currentKey == ts); @@ -348,7 +411,8 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t char* src = colDataGetData(pSrc, pFillInfo->index); if (!colDataIsNull_s(pSrc, pFillInfo->index)) { - colDataSetVal(pDst, index, src, false); + code = colDataSetVal(pDst, index, src, false); + QUERY_CHECK_CODE(code, lino, _end); SRowVal* pRVal = FILL_IS_ASC_FILL(pFillInfo) ? &pFillInfo->prev : &pFillInfo->next; saveColData(pRVal->pRowVal, i, src, false); if (pFillInfo->srcTsSlotId == dstSlotId) { @@ -356,15 +420,19 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t } } else { // the value is null if (pDst->info.type == TSDB_DATA_TYPE_TIMESTAMP) { - colDataSetVal(pDst, index, (const char*)&pFillInfo->currentKey, false); + code = colDataSetVal(pDst, index, (const char*)&pFillInfo->currentKey, false); + QUERY_CHECK_CODE(code, lino, _end); } else { // i > 0 and data is null , do interpolation if (pFillInfo->type == TSDB_FILL_PREV) { SArray* p = FILL_IS_ASC_FILL(pFillInfo) ? pFillInfo->prev.pRowVal : pFillInfo->next.pRowVal; SGroupKeys* pKey = taosArrayGet(p, i); - doSetVal(pDst, index, pKey); + code = doSetVal(pDst, index, pKey); + QUERY_CHECK_CODE(code, lino, _end); } else if (pFillInfo->type == TSDB_FILL_LINEAR) { bool isNull = colDataIsNull_s(pSrc, pFillInfo->index); - colDataSetVal(pDst, index, src, isNull); + code = colDataSetVal(pDst, index, src, isNull); + QUERY_CHECK_CODE(code, lino, _end); + SArray* p = FILL_IS_ASC_FILL(pFillInfo) ? pFillInfo->prev.pRowVal : pFillInfo->next.pRowVal; saveColData(p, i, src, isNull); // todo: } else if (pFillInfo->type == TSDB_FILL_NULL || pFillInfo->type == TSDB_FILL_NULL_F) { @@ -372,10 +440,12 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t } else if (pFillInfo->type == TSDB_FILL_NEXT) { SArray* p = FILL_IS_ASC_FILL(pFillInfo) ? pFillInfo->next.pRowVal : pFillInfo->prev.pRowVal; SGroupKeys* pKey = taosArrayGet(p, i); - doSetVal(pDst, index, pKey); + code = doSetVal(pDst, index, pKey); + QUERY_CHECK_CODE(code, lino, _end); } else { SVariant* pVar = &pFillInfo->pFillCol[i].fillVal; - doSetUserSpecifiedValue(pDst, pVar, index, pFillInfo->currentKey); + code = doSetUserSpecifiedValue(pDst, pVar, index, pFillInfo->currentKey); + QUERY_CHECK_CODE(code, lino, _end); } } } @@ -393,11 +463,15 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t if (pFillInfo->index >= pFillInfo->numOfRows || pFillInfo->numOfCurrent >= outputRows) { pFillInfo->numOfTotal += pFillInfo->numOfCurrent; - return pFillInfo->numOfCurrent; + goto _end; } } - return pFillInfo->numOfCurrent; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static void saveColData(SArray* rowBuf, int32_t columnIndex, const char* src, bool isNull) { @@ -414,7 +488,7 @@ static void saveColData(SArray* rowBuf, int32_t columnIndex, const char* src, bo } } -static int64_t appendFilledResult(SFillInfo* pFillInfo, SSDataBlock* pBlock, int64_t resultCapacity) { +static void appendFilledResult(SFillInfo* pFillInfo, SSDataBlock* pBlock, int64_t resultCapacity) { /* * These data are generated according to fill strategy, since the current timestamp is out of the time window of * real result set. Note that we need to keep the direct previous result rows, to generated the filled data. @@ -427,7 +501,6 @@ static int64_t appendFilledResult(SFillInfo* pFillInfo, SSDataBlock* pBlock, int pFillInfo->numOfTotal += pFillInfo->numOfCurrent; ASSERT(pFillInfo->numOfCurrent == resultCapacity); - return resultCapacity; } static int32_t taosNumOfRemainRows(SFillInfo* pFillInfo) { @@ -440,7 +513,9 @@ static int32_t taosNumOfRemainRows(SFillInfo* pFillInfo) { struct SFillInfo* taosCreateFillInfo(TSKEY skey, int32_t numOfFillCols, int32_t numOfNotFillCols, int32_t capacity, SInterval* pInterval, int32_t fillType, struct SFillColInfo* pCol, - int32_t primaryTsSlotId, int32_t order, const char* id) { + int32_t primaryTsSlotId, int32_t order, const char* id, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (fillType == TSDB_FILL_NONE) { return NULL; } @@ -473,9 +548,23 @@ struct SFillInfo* taosCreateFillInfo(TSKEY skey, int32_t numOfFillCols, int32_t pFillInfo->interval = *pInterval; pFillInfo->next.pRowVal = taosArrayInit(pFillInfo->numOfCols, sizeof(SGroupKeys)); - pFillInfo->prev.pRowVal = taosArrayInit(pFillInfo->numOfCols, sizeof(SGroupKeys)); + QUERY_CHECK_NULL(pFillInfo->next.pRowVal, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); - initBeforeAfterDataBuf(pFillInfo); + pFillInfo->prev.pRowVal = taosArrayInit(pFillInfo->numOfCols, sizeof(SGroupKeys)); + QUERY_CHECK_NULL(pFillInfo->prev.pRowVal, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + code = initBeforeAfterDataBuf(pFillInfo); + QUERY_CHECK_CODE(code, lino, _end); + + pFillInfo->pTaskInfo = pTaskInfo; + +_end: + if (code != TSDB_CODE_SUCCESS) { + taosArrayDestroy(pFillInfo->next.pRowVal); + taosArrayDestroy(pFillInfo->prev.pRowVal); + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } return pFillInfo; } @@ -559,7 +648,7 @@ void taosFillUpdateStartTimestampInfo(SFillInfo* pFillInfo, int64_t ts) { pFillInfo->currentKey = ts; } -bool taosFillNotStarted(const SFillInfo* pFillInfo) {return pFillInfo->start == pFillInfo->currentKey;} +bool taosFillNotStarted(const SFillInfo* pFillInfo) { return pFillInfo->start == pFillInfo->currentKey; } bool taosFillHasMoreResults(SFillInfo* pFillInfo) { int32_t remain = taosNumOfRemainRows(pFillInfo); @@ -577,16 +666,17 @@ bool taosFillHasMoreResults(SFillInfo* pFillInfo) { } int64_t getNumOfResultsAfterFillGap(SFillInfo* pFillInfo, TSKEY ekey, int32_t maxNumOfRows) { - int32_t numOfRows = taosNumOfRemainRows(pFillInfo); + int32_t numOfRows = taosNumOfRemainRows(pFillInfo); TSKEY ekey1 = ekey; int64_t numOfRes = -1; if (numOfRows > 0) { // still fill gap within current data block, not generating data after the result set. - SColumnInfoData* pCol = taosArrayGet(pFillInfo->pSrcBlock->pDataBlock, pFillInfo->srcTsSlotId); - int64_t* tsList = (int64_t*)pCol->pData; - TSKEY lastKey = tsList[pFillInfo->numOfRows - 1]; - numOfRes = taosTimeCountIntervalForFill(lastKey, pFillInfo->currentKey, pFillInfo->interval.sliding, + SColumnInfoData* pCol = taosArrayGet(pFillInfo->pSrcBlock->pDataBlock, pFillInfo->srcTsSlotId); + int64_t* tsList = (int64_t*)pCol->pData; + TSKEY lastKey = tsList[pFillInfo->numOfRows - 1]; + numOfRes = + taosTimeCountIntervalForFill(lastKey, pFillInfo->currentKey, pFillInfo->interval.sliding, pFillInfo->interval.slidingUnit, pFillInfo->interval.precision, pFillInfo->order); ASSERT(numOfRes >= numOfRows); } else { // reach the end of data @@ -595,7 +685,8 @@ int64_t getNumOfResultsAfterFillGap(SFillInfo* pFillInfo, TSKEY ekey, int32_t ma return 0; } - numOfRes = taosTimeCountIntervalForFill(ekey1, pFillInfo->currentKey, pFillInfo->interval.sliding, + numOfRes = + taosTimeCountIntervalForFill(ekey1, pFillInfo->currentKey, pFillInfo->interval.sliding, pFillInfo->interval.slidingUnit, pFillInfo->interval.precision, pFillInfo->order); } @@ -603,7 +694,7 @@ int64_t getNumOfResultsAfterFillGap(SFillInfo* pFillInfo, TSKEY ekey, int32_t ma } void taosGetLinearInterpolationVal(SPoint* point, int32_t outputType, SPoint* point1, SPoint* point2, - int32_t inputType) { + int32_t inputType) { double v1 = -1, v2 = -1; GET_TYPED_DATA(v1, double, inputType, point1->val); GET_TYPED_DATA(v2, double, inputType, point2->val); @@ -617,7 +708,8 @@ void taosGetLinearInterpolationVal(SPoint* point, int32_t outputType, SPoint* po SET_TYPED_DATA(point->val, outputType, r); } -void taosFillResultDataBlock(SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity) { +int32_t taosFillResultDataBlock(SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity) { + int32_t code = TSDB_CODE_SUCCESS; int32_t remain = taosNumOfRemainRows(pFillInfo); int64_t numOfRes = getNumOfResultsAfterFillGap(pFillInfo, pFillInfo->end, capacity); @@ -627,7 +719,7 @@ void taosFillResultDataBlock(SFillInfo* pFillInfo, SSDataBlock* p, int32_t capac if (remain == 0) { appendFilledResult(pFillInfo, p, numOfRes); } else { - fillResultImpl(pFillInfo, p, (int32_t)numOfRes); + code = fillResultImpl(pFillInfo, p, (int32_t)numOfRes); ASSERT(numOfRes == pFillInfo->numOfCurrent); } @@ -635,6 +727,7 @@ void taosFillResultDataBlock(SFillInfo* pFillInfo, SSDataBlock* p, int32_t capac ", current : % d, total : % d, %s", pFillInfo, pFillInfo->numOfRows, pFillInfo->index, pFillInfo->start, pFillInfo->end, pFillInfo->currentKey, pFillInfo->numOfCurrent, pFillInfo->numOfTotal, pFillInfo->id); + return code; } int64_t getFillInfoStart(struct SFillInfo* pFillInfo) { return pFillInfo->start; } diff --git a/source/libs/executor/src/timesliceoperator.c b/source/libs/executor/src/timesliceoperator.c index e5a1bd0701..c2e7b16dea 100644 --- a/source/libs/executor/src/timesliceoperator.c +++ b/source/libs/executor/src/timesliceoperator.c @@ -44,8 +44,8 @@ typedef struct STimeSliceOperatorInfo { uint64_t groupId; SGroupKeys* pPrevGroupKey; SSDataBlock* pNextGroupRes; - SSDataBlock* pRemainRes; // save block unfinished processing - int32_t remainIndex; // the remaining index in the block to be processed + SSDataBlock* pRemainRes; // save block unfinished processing + int32_t remainIndex; // the remaining index in the block to be processed bool hasPk; SColumn pkCol; } STimeSliceOperatorInfo; @@ -163,18 +163,22 @@ static FORCE_INLINE int32_t timeSliceEnsureBlockCapacity(STimeSliceOperatorInfo* uint32_t winNum = (pSliceInfo->win.ekey - pSliceInfo->win.skey) / pSliceInfo->interval.interval; uint32_t newRowsNum = pBlock->info.rows + TMIN(winNum / 4 + 1, 1048576); - blockDataEnsureCapacity(pBlock, newRowsNum); + int32_t code = blockDataEnsureCapacity(pBlock, newRowsNum); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } return TSDB_CODE_SUCCESS; } static bool isIrowtsPseudoColumn(SExprInfo* pExprInfo) { - char *name = pExprInfo->pExpr->_function.functionName; + char* name = pExprInfo->pExpr->_function.functionName; return (IS_TIMESTAMP_TYPE(pExprInfo->base.resSchema.type) && strcasecmp(name, "_irowts") == 0); } static bool isIsfilledPseudoColumn(SExprInfo* pExprInfo) { - char *name = pExprInfo->pExpr->_function.functionName; + char* name = pExprInfo->pExpr->_function.functionName; return (IS_BOOLEAN_TYPE(pExprInfo->base.resSchema.type) && strcasecmp(name, "_isfilled") == 0); } @@ -202,7 +206,7 @@ static bool checkDuplicateTimestamps(STimeSliceOperatorInfo* pSliceInfo, SColumn return false; } - SRowKey cur = {.ts = currentTs, .numOfPKs = (pPkCol != NULL)? 1:0}; + SRowKey cur = {.ts = currentTs, .numOfPKs = (pPkCol != NULL) ? 1 : 0}; if (pPkCol != NULL) { cur.pks[0].type = pPkCol->info.type; if (IS_VAR_DATA_TYPE(pPkCol->info.type)) { @@ -244,7 +248,7 @@ static bool getIgoreNullRes(SExprSupp* pExprSup) { if (isInterpFunc(pExprInfo)) { for (int32_t j = 0; j < pExprInfo->base.numOfParams; ++j) { - SFunctParam *pFuncParam = &pExprInfo->base.pParam[j]; + SFunctParam* pFuncParam = &pExprInfo->base.pParam[j]; if (pFuncParam->type == FUNC_PARAM_TYPE_VALUE) { return pFuncParam->param.i ? true : false; } @@ -264,7 +268,7 @@ static bool checkNullRow(SExprSupp* pExprSup, SSDataBlock* pSrcBlock, int32_t in SExprInfo* pExprInfo = &pExprSup->pExprInfo[j]; if (isInterpFunc(pExprInfo)) { - int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId; + int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId; SColumnInfoData* pSrc = taosArrayGet(pSrcBlock->pDataBlock, srcSlot); if (colDataIsNull_s(pSrc, index)) { @@ -276,34 +280,37 @@ static bool checkNullRow(SExprSupp* pExprSup, SSDataBlock* pSrcBlock, int32_t in return false; } - static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp* pExprSup, SSDataBlock* pResBlock, - SSDataBlock* pSrcBlock, int32_t index, bool beforeTs) { + SSDataBlock* pSrcBlock, int32_t index, bool beforeTs, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; int32_t rows = pResBlock->info.rows; - timeSliceEnsureBlockCapacity(pSliceInfo, pResBlock); + code = timeSliceEnsureBlockCapacity(pSliceInfo, pResBlock); + QUERY_CHECK_CODE(code, lino, _end); // todo set the correct primary timestamp column - // output the result int32_t fillColIndex = 0; - bool hasInterp = true; + bool hasInterp = true; for (int32_t j = 0; j < pExprSup->numOfExprs; ++j) { SExprInfo* pExprInfo = &pExprSup->pExprInfo[j]; - int32_t dstSlot = pExprInfo->base.resSchema.slotId; + int32_t dstSlot = pExprInfo->base.resSchema.slotId; SColumnInfoData* pDst = taosArrayGet(pResBlock->pDataBlock, dstSlot); if (isIrowtsPseudoColumn(pExprInfo)) { - colDataSetVal(pDst, rows, (char*)&pSliceInfo->current, false); + code = colDataSetVal(pDst, rows, (char*)&pSliceInfo->current, false); + QUERY_CHECK_CODE(code, lino, _end); continue; } else if (isIsfilledPseudoColumn(pExprInfo)) { bool isFilled = true; - colDataSetVal(pDst, pResBlock->info.rows, (char*)&isFilled, false); + code = colDataSetVal(pDst, pResBlock->info.rows, (char*)&isFilled, false); + QUERY_CHECK_CODE(code, lino, _end); continue; } else if (!isInterpFunc(pExprInfo)) { if (isGroupKeyFunc(pExprInfo) || isSelectGroupConstValueFunc(pExprInfo)) { if (pSrcBlock != NULL) { - int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId; + int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId; SColumnInfoData* pSrc = taosArrayGet(pSrcBlock->pDataBlock, srcSlot); if (colDataIsNull_s(pSrc, index)) { @@ -312,12 +319,14 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp } char* v = colDataGetData(pSrc, index); - colDataSetVal(pDst, pResBlock->info.rows, v, false); + code = colDataSetVal(pDst, pResBlock->info.rows, v, false); + QUERY_CHECK_CODE(code, lino, _end); } else if(!isSelectGroupConstValueFunc(pExprInfo)){ // use stored group key SGroupKeys* pkey = pSliceInfo->pPrevGroupKey; if (pkey->isNull == false) { - colDataSetVal(pDst, rows, pkey->pData, false); + code = colDataSetVal(pDst, rows, pkey->pData, false); + QUERY_CHECK_CODE(code, lino, _end); } else { colDataSetNULL(pDst, rows); } @@ -354,7 +363,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp } else { v = taosStr2Float(varDataVal(pVar->pz), NULL); } - colDataSetVal(pDst, rows, (char*)&v, isNull); + code = colDataSetVal(pDst, rows, (char*)&v, isNull); + QUERY_CHECK_CODE(code, lino, _end); } else if (pDst->info.type == TSDB_DATA_TYPE_DOUBLE) { double v = 0; if (!IS_VAR_DATA_TYPE(pVar->nType)) { @@ -362,7 +372,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp } else { v = taosStr2Double(varDataVal(pVar->pz), NULL); } - colDataSetVal(pDst, rows, (char*)&v, isNull); + code = colDataSetVal(pDst, rows, (char*)&v, isNull); + QUERY_CHECK_CODE(code, lino, _end); } else if (IS_SIGNED_NUMERIC_TYPE(pDst->info.type)) { int64_t v = 0; if (!IS_VAR_DATA_TYPE(pVar->nType)) { @@ -370,7 +381,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp } else { v = taosStr2Int64(varDataVal(pVar->pz), NULL, 10); } - colDataSetVal(pDst, rows, (char*)&v, isNull); + code = colDataSetVal(pDst, rows, (char*)&v, isNull); + QUERY_CHECK_CODE(code, lino, _end); } else if (IS_UNSIGNED_NUMERIC_TYPE(pDst->info.type)) { uint64_t v = 0; if (!IS_VAR_DATA_TYPE(pVar->nType)) { @@ -378,7 +390,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp } else { v = taosStr2UInt64(varDataVal(pVar->pz), NULL, 10); } - colDataSetVal(pDst, rows, (char*)&v, isNull); + code = colDataSetVal(pDst, rows, (char*)&v, isNull); + QUERY_CHECK_CODE(code, lino, _end); } else if (IS_BOOLEAN_TYPE(pDst->info.type)) { bool v = false; if (!IS_VAR_DATA_TYPE(pVar->nType)) { @@ -386,7 +399,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp } else { v = taosStr2Int8(varDataVal(pVar->pz), NULL, 10); } - colDataSetVal(pDst, rows, (char*)&v, isNull); + code = colDataSetVal(pDst, rows, (char*)&v, isNull); + QUERY_CHECK_CODE(code, lino, _end); } ++fillColIndex; @@ -421,8 +435,10 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp } current.val = taosMemoryCalloc(pLinearInfo->bytes, 1); + QUERY_CHECK_NULL(current.val, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); taosGetLinearInterpolationVal(¤t, pLinearInfo->type, &start, &end, pLinearInfo->type); - colDataSetVal(pDst, rows, (char*)current.val, false); + code = colDataSetVal(pDst, rows, (char*)current.val, false); + QUERY_CHECK_CODE(code, lino, _end); taosMemoryFree(current.val); break; @@ -435,7 +451,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp SGroupKeys* pkey = taosArrayGet(pSliceInfo->pPrevRow, srcSlot); if (pkey->isNull == false) { - colDataSetVal(pDst, rows, pkey->pData, false); + code = colDataSetVal(pDst, rows, pkey->pData, false); + QUERY_CHECK_CODE(code, lino, _end); } else { colDataSetNULL(pDst, rows); } @@ -450,7 +467,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp SGroupKeys* pkey = taosArrayGet(pSliceInfo->pNextRow, srcSlot); if (pkey->isNull == false) { - colDataSetVal(pDst, rows, pkey->pData, false); + code = colDataSetVal(pDst, rows, pkey->pData, false); + QUERY_CHECK_CODE(code, lino, _end); } else { colDataSetNULL(pDst, rows); } @@ -467,12 +485,21 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp pResBlock->info.rows += 1; } +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return hasInterp; } -static void addCurrentRowToResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp* pExprSup, SSDataBlock* pResBlock, - SSDataBlock* pSrcBlock, int32_t index) { - timeSliceEnsureBlockCapacity(pSliceInfo, pResBlock); +static int32_t addCurrentRowToResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp* pExprSup, SSDataBlock* pResBlock, + SSDataBlock* pSrcBlock, int32_t index) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + code = timeSliceEnsureBlockCapacity(pSliceInfo, pResBlock); + QUERY_CHECK_CODE(code, lino, _end); for (int32_t j = 0; j < pExprSup->numOfExprs; ++j) { SExprInfo* pExprInfo = &pExprSup->pExprInfo[j]; @@ -480,12 +507,14 @@ static void addCurrentRowToResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp* SColumnInfoData* pDst = taosArrayGet(pResBlock->pDataBlock, dstSlot); if (isIrowtsPseudoColumn(pExprInfo)) { - colDataSetVal(pDst, pResBlock->info.rows, (char*)&pSliceInfo->current, false); + code = colDataSetVal(pDst, pResBlock->info.rows, (char*)&pSliceInfo->current, false); + QUERY_CHECK_CODE(code, lino, _end); } else if (isIsfilledPseudoColumn(pExprInfo)) { bool isFilled = false; - colDataSetVal(pDst, pResBlock->info.rows, (char*)&isFilled, false); + code = colDataSetVal(pDst, pResBlock->info.rows, (char*)&isFilled, false); + QUERY_CHECK_CODE(code, lino, _end); } else { - int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId; + int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId; SColumnInfoData* pSrc = taosArrayGet(pSrcBlock->pDataBlock, srcSlot); if (colDataIsNull_s(pSrc, index)) { @@ -494,15 +523,23 @@ static void addCurrentRowToResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp* } char* v = colDataGetData(pSrc, index); - colDataSetVal(pDst, pResBlock->info.rows, v, false); + code = colDataSetVal(pDst, pResBlock->info.rows, v, false); + QUERY_CHECK_CODE(code, lino, _end); } } pResBlock->info.rows += 1; - return; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static int32_t initPrevRowsKeeper(STimeSliceOperatorInfo* pInfo, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pInfo->pPrevRow != NULL) { return TSDB_CODE_SUCCESS; } @@ -521,14 +558,23 @@ static int32_t initPrevRowsKeeper(STimeSliceOperatorInfo* pInfo, SSDataBlock* pB key.type = pColInfo->info.type; key.isNull = false; key.pData = taosMemoryCalloc(1, pColInfo->info.bytes); - taosArrayPush(pInfo->pPrevRow, &key); + QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + void* tmp = taosArrayPush(pInfo->pPrevRow, &key); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } pInfo->isPrevRowSet = false; - return TSDB_CODE_SUCCESS; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static int32_t initNextRowsKeeper(STimeSliceOperatorInfo* pInfo, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pInfo->pNextRow != NULL) { return TSDB_CODE_SUCCESS; } @@ -547,15 +593,24 @@ static int32_t initNextRowsKeeper(STimeSliceOperatorInfo* pInfo, SSDataBlock* pB key.type = pColInfo->info.type; key.isNull = false; key.pData = taosMemoryCalloc(1, pColInfo->info.bytes); - taosArrayPush(pInfo->pNextRow, &key); + QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + void* tmp = taosArrayPush(pInfo->pNextRow, &key); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } pInfo->isNextRowSet = false; - return TSDB_CODE_SUCCESS; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static int32_t initFillLinearInfo(STimeSliceOperatorInfo* pInfo, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pInfo->pLinearInfo != NULL) { return TSDB_CODE_SUCCESS; } @@ -573,15 +628,23 @@ static int32_t initFillLinearInfo(STimeSliceOperatorInfo* pInfo, SSDataBlock* pB linearInfo.start.key = INT64_MIN; linearInfo.end.key = INT64_MIN; linearInfo.start.val = taosMemoryCalloc(1, pColInfo->info.bytes); + QUERY_CHECK_NULL(linearInfo.start.val, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + linearInfo.end.val = taosMemoryCalloc(1, pColInfo->info.bytes); + QUERY_CHECK_NULL(linearInfo.end.val, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); linearInfo.isStartSet = false; linearInfo.isEndSet = false; linearInfo.type = pColInfo->info.type; linearInfo.bytes = pColInfo->info.bytes; - taosArrayPush(pInfo->pLinearInfo, &linearInfo); + void* tmp = taosArrayPush(pInfo->pLinearInfo, &linearInfo); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } - return TSDB_CODE_SUCCESS; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static int32_t initGroupKeyKeeper(STimeSliceOperatorInfo* pInfo, SExprSupp* pExprSup) { @@ -630,62 +693,59 @@ static int32_t initKeeperInfo(STimeSliceOperatorInfo* pInfo, SSDataBlock* pBlock return TSDB_CODE_FAILED; } - return TSDB_CODE_SUCCESS; } -static int32_t resetPrevRowsKeeper(STimeSliceOperatorInfo* pInfo) { +static void resetPrevRowsKeeper(STimeSliceOperatorInfo* pInfo) { if (pInfo->pPrevRow == NULL) { - return TSDB_CODE_SUCCESS; + return; } for (int32_t i = 0; i < taosArrayGetSize(pInfo->pLinearInfo); ++i) { - SGroupKeys *pKey = taosArrayGet(pInfo->pPrevRow, i); + SGroupKeys* pKey = taosArrayGet(pInfo->pPrevRow, i); pKey->isNull = false; } pInfo->isPrevRowSet = false; - return TSDB_CODE_SUCCESS; + return; } -static int32_t resetNextRowsKeeper(STimeSliceOperatorInfo* pInfo) { +static void resetNextRowsKeeper(STimeSliceOperatorInfo* pInfo) { if (pInfo->pNextRow == NULL) { - return TSDB_CODE_SUCCESS; + return; } for (int32_t i = 0; i < taosArrayGetSize(pInfo->pLinearInfo); ++i) { - SGroupKeys *pKey = taosArrayGet(pInfo->pPrevRow, i); + SGroupKeys* pKey = taosArrayGet(pInfo->pPrevRow, i); pKey->isNull = false; } pInfo->isNextRowSet = false; - return TSDB_CODE_SUCCESS; + return; } -static int32_t resetFillLinearInfo(STimeSliceOperatorInfo* pInfo) { +static void resetFillLinearInfo(STimeSliceOperatorInfo* pInfo) { if (pInfo->pLinearInfo == NULL) { - return TSDB_CODE_SUCCESS; + return; } for (int32_t i = 0; i < taosArrayGetSize(pInfo->pLinearInfo); ++i) { - SFillLinearInfo *pLinearInfo = taosArrayGet(pInfo->pLinearInfo, i); + SFillLinearInfo* pLinearInfo = taosArrayGet(pInfo->pLinearInfo, i); pLinearInfo->start.key = INT64_MIN; pLinearInfo->end.key = INT64_MIN; pLinearInfo->isStartSet = false; pLinearInfo->isEndSet = false; } - return TSDB_CODE_SUCCESS; + return; } -static int32_t resetKeeperInfo(STimeSliceOperatorInfo* pInfo) { +static void resetKeeperInfo(STimeSliceOperatorInfo* pInfo) { resetPrevRowsKeeper(pInfo); resetNextRowsKeeper(pInfo); resetFillLinearInfo(pInfo); - - return TSDB_CODE_SUCCESS; } static bool checkThresholdReached(STimeSliceOperatorInfo* pSliceInfo, int32_t threshold) { @@ -717,13 +777,14 @@ static void saveBlockStatus(STimeSliceOperatorInfo* pSliceInfo, SSDataBlock* pBl // all data in remaining block processed pSliceInfo->pRemainRes = NULL; - } static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pSliceInfo, SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo, bool ignoreNull) { - SSDataBlock* pResBlock = pSliceInfo->pRes; - SInterval* pInterval = &pSliceInfo->interval; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SSDataBlock* pResBlock = pSliceInfo->pRes; + SInterval* pInterval = &pSliceInfo->interval; SColumnInfoData* pTsCol = taosArrayGet(pBlock->pDataBlock, pSliceInfo->tsCol.slotId); SColumnInfoData* pPkCol = NULL; @@ -746,7 +807,8 @@ static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pS } if (ts == pSliceInfo->current) { - addCurrentRowToResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i); + code = addCurrentRowToResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i); + QUERY_CHECK_CODE(code, lino, _end); doKeepPrevRows(pSliceInfo, pBlock, i); doKeepLinearInfo(pSliceInfo, pBlock, i); @@ -773,12 +835,12 @@ static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pS int64_t nextTs = *(int64_t*)colDataGetData(pTsCol, i + 1); if (nextTs > pSliceInfo->current) { while (pSliceInfo->current < nextTs && pSliceInfo->current <= pSliceInfo->win.ekey) { - if (!genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i, false) && + if (!genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i, false, pTaskInfo) && pSliceInfo->fillType == TSDB_FILL_LINEAR) { break; } else { - pSliceInfo->current = taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit, - pInterval->precision); + pSliceInfo->current = + taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit, pInterval->precision); } } @@ -801,7 +863,7 @@ static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pS doKeepLinearInfo(pSliceInfo, pBlock, i); while (pSliceInfo->current < ts && pSliceInfo->current <= pSliceInfo->win.ekey) { - if (!genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i, true) && + if (!genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i, true, pTaskInfo) && pSliceInfo->fillType == TSDB_FILL_LINEAR) { break; } else { @@ -812,7 +874,8 @@ static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pS // add current row if timestamp match if (ts == pSliceInfo->current && pSliceInfo->current <= pSliceInfo->win.ekey) { - addCurrentRowToResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i); + code = addCurrentRowToResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i); + QUERY_CHECK_CODE(code, lino, _end); pSliceInfo->current = taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit, pInterval->precision); @@ -832,6 +895,13 @@ static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pS // if reached here, meaning block processing finished naturally, // or interpolation reach window upper bound pSliceInfo->pRemainRes = NULL; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } } static void genInterpAfterDataBlock(STimeSliceOperatorInfo* pSliceInfo, SOperatorInfo* pOperator, int32_t index) { @@ -844,7 +914,7 @@ static void genInterpAfterDataBlock(STimeSliceOperatorInfo* pSliceInfo, SOperato } while (pSliceInfo->current <= pSliceInfo->win.ekey) { - genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, NULL, index, false); + (void)genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, NULL, index, false, pOperator->pTaskInfo); pSliceInfo->current = taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit, pInterval->precision); } @@ -855,7 +925,7 @@ static void copyPrevGroupKey(SExprSupp* pExprSup, SGroupKeys* pGroupKey, SSDataB SExprInfo* pExprInfo = &pExprSup->pExprInfo[j]; if (isGroupKeyFunc(pExprInfo)) { - int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId; + int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId; SColumnInfoData* pSrc = taosArrayGet(pSrcBlock->pDataBlock, srcSlot); if (colDataIsNull_s(pSrc, 0)) { @@ -901,16 +971,27 @@ static void doHandleTimeslice(SOperatorInfo* pOperator, SSDataBlock* pBlock) { if (pSliceInfo->scalarSup.pExprInfo != NULL) { SExprSupp* pExprSup = &pSliceInfo->scalarSup; - projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); + code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } // the pDataBlock are always the same one, no need to call this again - setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true); + code = setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } doTimesliceImpl(pOperator, pSliceInfo, pBlock, pTaskInfo, ignoreNull); copyPrevGroupKey(&pOperator->exprSupp, pSliceInfo->pPrevGroupKey, pBlock); } static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; if (pOperator->status == OP_EXEC_DONE) { return NULL; } @@ -924,7 +1005,8 @@ static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) { if (pSliceInfo->pNextGroupRes != NULL) { doHandleTimeslice(pOperator, pSliceInfo->pNextGroupRes); if (checkWindowBoundReached(pSliceInfo) || checkThresholdReached(pSliceInfo, pOperator->resultInfo.threshold)) { - doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _finished); if (pSliceInfo->pRemainRes == NULL) { pSliceInfo->pNextGroupRes = NULL; } @@ -959,7 +1041,8 @@ static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) { doHandleTimeslice(pOperator, pBlock); if (checkWindowBoundReached(pSliceInfo) || checkThresholdReached(pSliceInfo, pOperator->resultInfo.threshold)) { - doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _finished); if (pResBlock->info.rows != 0) { goto _finished; } @@ -971,7 +1054,8 @@ static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) { // except for fill(next), fill(linear) genInterpAfterDataBlock(pSliceInfo, pOperator, 0); - doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _finished); if (pOperator->status == OP_EXEC_DONE) { break; } @@ -989,6 +1073,11 @@ _finished: if (pResBlock->info.rows == 0) { pOperator->status = OP_EXEC_DONE; } + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return pResBlock->info.rows == 0 ? NULL : pResBlock; } @@ -996,23 +1085,24 @@ _finished: static int32_t extractPkColumnFromFuncs(SNodeList* pFuncs, bool* pHasPk, SColumn* pPkColumn) { SNode* pNode; FOREACH(pNode, pFuncs) { - if ((nodeType(pNode) == QUERY_NODE_TARGET) && - (nodeType(((STargetNode*)pNode)->pExpr) == QUERY_NODE_FUNCTION)) { - SFunctionNode* pFunc = (SFunctionNode*)((STargetNode*)pNode)->pExpr; - if (fmIsInterpFunc(pFunc->funcId) && pFunc->hasPk) { - SNode* pNode2 = (pFunc->pParameterList->pTail->pNode); - if ((nodeType(pNode2) == QUERY_NODE_COLUMN) && ((SColumnNode*)pNode2)->isPk) { - *pHasPk = true; - *pPkColumn = extractColumnFromColumnNode((SColumnNode*)pNode2); - break; - } + if ((nodeType(pNode) == QUERY_NODE_TARGET) && (nodeType(((STargetNode*)pNode)->pExpr) == QUERY_NODE_FUNCTION)) { + SFunctionNode* pFunc = (SFunctionNode*)((STargetNode*)pNode)->pExpr; + if (fmIsInterpFunc(pFunc->funcId) && pFunc->hasPk) { + SNode* pNode2 = (pFunc->pParameterList->pTail->pNode); + if ((nodeType(pNode2) == QUERY_NODE_COLUMN) && ((SColumnNode*)pNode2)->isPk) { + *pHasPk = true; + *pPkColumn = extractColumnFromColumnNode((SColumnNode*)pNode2); + break; } + } } } return TSDB_CODE_SUCCESS; } SOperatorInfo* createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; STimeSliceOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STimeSliceOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pOperator == NULL || pInfo == NULL) { @@ -1024,27 +1114,23 @@ SOperatorInfo* createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode int32_t numOfExprs = 0; SExprInfo* pExprInfo = createExprInfo(pInterpPhyNode->pFuncs, NULL, &numOfExprs); - int32_t code = initExprSupp(pSup, pExprInfo, numOfExprs, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + code = initExprSupp(pSup, pExprInfo, numOfExprs, &pTaskInfo->storageAPI.functionStore); + QUERY_CHECK_CODE(code, lino, _error); if (pInterpPhyNode->pExprs != NULL) { int32_t num = 0; SExprInfo* pScalarExprInfo = createExprInfo(pInterpPhyNode->pExprs, NULL, &num); code = initExprSupp(&pInfo->scalarSup, pScalarExprInfo, num, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); } code = filterInitFromNode((SNode*)pInterpPhyNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); pInfo->tsCol = extractColumnFromColumnNode((SColumnNode*)pInterpPhyNode->pTimeSeries); - extractPkColumnFromFuncs(pInterpPhyNode->pFuncs, &pInfo->hasPk, &pInfo->pkCol); + code = extractPkColumnFromFuncs(pInterpPhyNode->pFuncs, &pInfo->hasPk, &pInfo->pkCol); + QUERY_CHECK_CODE(code, lino, _error); + pInfo->fillType = convertFillType(pInterpPhyNode->fillMode); initResultSizeInfo(&pOperator->resultInfo, 4096); @@ -1080,17 +1166,22 @@ SOperatorInfo* createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode setOperatorInfo(pOperator, "TimeSliceOperator", QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC, false, OP_NOT_OPENED, pInfo, pTaskInfo); - pOperator->fpSet = - createOperatorFpSet(optrDummyOpenFn, doTimeslice, NULL, destroyTimeSliceOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); + pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTimeslice, NULL, destroyTimeSliceOperatorInfo, + optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); - blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _error); -// int32_t code = initKeeperInfo(pSliceInfo, pBlock, &pOperator->exprSupp); + // int32_t code = initKeeperInfo(pSliceInfo, pBlock, &pOperator->exprSupp); code = appendDownstream(pOperator, &downstream, 1); + QUERY_CHECK_CODE(code, lino, _error); return pOperator; _error: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } taosMemoryFree(pInfo); taosMemoryFree(pOperator); pTaskInfo->code = TSDB_CODE_OUT_OF_MEMORY; diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c index fb3176a2a8..e448cd8e3a 100644 --- a/source/libs/executor/src/timewindowoperator.c +++ b/source/libs/executor/src/timewindowoperator.c @@ -62,10 +62,10 @@ typedef struct SOpenWindowInfo { uint64_t groupId; } SOpenWindowInfo; -static int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo); +static int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo, SExecTaskInfo* pTaskInfo); static SResultRowPosition addToOpenWindowList(SResultRowInfo* pResultRowInfo, const SResultRow* pResult, - uint64_t groupId); + uint64_t groupId, SExecTaskInfo* pTaskInfo); static void doCloseWindow(SResultRowInfo* pResultRowInfo, const SIntervalAggOperatorInfo* pInfo, SResultRow* pResult); static int32_t setTimeWindowOutputBuf(SResultRowInfo* pResultRowInfo, STimeWindow* win, bool masterscan, @@ -707,7 +707,7 @@ static bool hashIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResul int32_t startPos = 0; int32_t numOfOutput = pSup->numOfExprs; - int64_t* tsCols = extractTsCol(pBlock, pInfo); + int64_t* tsCols = extractTsCol(pBlock, pInfo, pTaskInfo); uint64_t tableGroupId = pBlock->info.id.groupId; bool ascScan = (pInfo->binfo.inputTsOrder == TSDB_ORDER_ASC); TSKEY ts = getStartTsKey(&pBlock->info.window, tsCols); @@ -740,7 +740,7 @@ static bool hashIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResul // prev time window not interpolation yet. if (pInfo->timeWindowInterpo) { - SResultRowPosition pos = addToOpenWindowList(pResultRowInfo, pResult, tableGroupId); + SResultRowPosition pos = addToOpenWindowList(pResultRowInfo, pResult, tableGroupId, pTaskInfo); doInterpUnclosedTimeWindow(pOperatorInfo, numOfOutput, pResultRowInfo, pBlock, scanFlag, tsCols, &pos); // restore current time window @@ -811,26 +811,36 @@ void doCloseWindow(SResultRowInfo* pResultRowInfo, const SIntervalAggOperatorInf } } -SResultRowPosition addToOpenWindowList(SResultRowInfo* pResultRowInfo, const SResultRow* pResult, uint64_t groupId) { +SResultRowPosition addToOpenWindowList(SResultRowInfo* pResultRowInfo, const SResultRow* pResult, uint64_t groupId, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SOpenWindowInfo openWin = {0}; openWin.pos.pageId = pResult->pageId; openWin.pos.offset = pResult->offset; openWin.groupId = groupId; SListNode* pn = tdListGetTail(pResultRowInfo->openWindow); if (pn == NULL) { - tdListAppend(pResultRowInfo->openWindow, &openWin); + code = tdListAppend(pResultRowInfo->openWindow, &openWin); + QUERY_CHECK_CODE(code, lino, _end); return openWin.pos; } SOpenWindowInfo* px = (SOpenWindowInfo*)pn->data; if (px->pos.pageId != openWin.pos.pageId || px->pos.offset != openWin.pos.offset || px->groupId != openWin.groupId) { - tdListAppend(pResultRowInfo->openWindow, &openWin); + code = tdListAppend(pResultRowInfo->openWindow, &openWin); + QUERY_CHECK_CODE(code, lino, _end); } +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return openWin.pos; } -int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo) { +int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo, SExecTaskInfo* pTaskInfo) { TSKEY* tsCols = NULL; if (pBlock->pDataBlock != NULL && pBlock->info.dataLoad) { @@ -844,7 +854,12 @@ int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo } if (tsCols[0] != 0 && (pBlock->info.window.skey == 0 && pBlock->info.window.ekey == 0)) { - blockDataUpdateTsWindow(pBlock, pInfo->primaryTsIndex); + int32_t code = blockDataUpdateTsWindow(pBlock, pInfo->primaryTsIndex); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } } } @@ -856,6 +871,8 @@ static int32_t doOpenIntervalAgg(SOperatorInfo* pOperator) { return TSDB_CODE_SUCCESS; } + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SOperatorInfo* downstream = pOperator->pDownstream[0]; @@ -875,11 +892,13 @@ static int32_t doOpenIntervalAgg(SOperatorInfo* pOperator) { if (pInfo->scalarSupp.pExprInfo != NULL) { SExprSupp* pExprSup = &pInfo->scalarSupp; - projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); + code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); + QUERY_CHECK_CODE(code, lino, _end); } // the pDataBlock are always the same one, no need to call this again - setInputDataBlock(pSup, pBlock, pInfo->binfo.inputTsOrder, scanFlag, true); + code = setInputDataBlock(pSup, pBlock, pInfo->binfo.inputTsOrder, scanFlag, true); + QUERY_CHECK_CODE(code, lino, _end); if (hashIntervalAgg(pOperator, &pInfo->binfo.resultRowInfo, pBlock, scanFlag)) break; } @@ -887,7 +906,14 @@ static int32_t doOpenIntervalAgg(SOperatorInfo* pOperator) { OPTR_SET_OPENED(pOperator); pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0; - return TSDB_CODE_SUCCESS; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } + return code; } static void doStateWindowAggImpl(SOperatorInfo* pOperator, SStateWindowOperatorInfo* pInfo, SSDataBlock* pBlock) { @@ -979,6 +1005,8 @@ static int32_t openStateWindowAggOptr(SOperatorInfo* pOperator) { return TSDB_CODE_SUCCESS; } + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SStateWindowOperatorInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; @@ -994,8 +1022,11 @@ static int32_t openStateWindowAggOptr(SOperatorInfo* pOperator) { } pInfo->binfo.pRes->info.scanFlag = pBlock->info.scanFlag; - setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true); - blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId); + code = setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); + + code = blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId); + QUERY_CHECK_CODE(code, lino, _end); // there is an scalar expression that needs to be calculated right before apply the group aggregation. if (pInfo->scalarSup.pExprInfo != NULL) { @@ -1013,7 +1044,13 @@ static int32_t openStateWindowAggOptr(SOperatorInfo* pOperator) { initGroupedResultInfo(&pInfo->groupResInfo, pInfo->aggSup.pResultRowHashTable, TSDB_ORDER_ASC); pOperator->status = OP_RES_TO_RETURN; - return TSDB_CODE_SUCCESS; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } + return code; } static SSDataBlock* doStateWindowAgg(SOperatorInfo* pOperator) { @@ -1031,10 +1068,21 @@ static SSDataBlock* doStateWindowAgg(SOperatorInfo* pOperator) { return NULL; } - blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity); + int32_t code = blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } + while (1) { doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf); - doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } bool hasRemain = hasRemainResults(&pInfo->groupResInfo); if (!hasRemain) { @@ -1067,7 +1115,12 @@ static SSDataBlock* doBuildIntervalResult(SOperatorInfo* pOperator) { while (1) { doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf); - doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL); + int32_t code = doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } bool hasRemain = hasRemainResults(&pInfo->groupResInfo); if (!hasRemain) { @@ -1086,32 +1139,6 @@ static SSDataBlock* doBuildIntervalResult(SOperatorInfo* pOperator) { return (rows == 0) ? NULL : pBlock; } -static void doClearWindowImpl(SResultRowPosition* p1, SDiskbasedBuf* pResultBuf, SExprSupp* pSup, int32_t numOfOutput) { - SResultRow* pResult = getResultRowByPos(pResultBuf, p1, false); - if (NULL == pResult) { - return; - } - - SqlFunctionCtx* pCtx = pSup->pCtx; - for (int32_t i = 0; i < numOfOutput; ++i) { - pCtx[i].resultInfo = getResultEntryInfo(pResult, i, pSup->rowEntryInfoOffset); - struct SResultRowEntryInfo* pResInfo = pCtx[i].resultInfo; - if (fmIsWindowPseudoColumnFunc(pCtx[i].functionId)) { - continue; - } - pResInfo->initialized = false; - if (pCtx[i].functionId != -1) { - pCtx[i].fpSet.init(&pCtx[i], pResInfo); - } - } - SFilePage* bufPage = getBufPage(pResultBuf, p1->pageId); - if (NULL == bufPage) { - return; - } - setBufPageDirty(bufPage, true); - releaseBufPage(pResultBuf, bufPage); -} - static void destroyStateWindowOperatorInfo(void* param) { SStateWindowOperatorInfo* pInfo = (SStateWindowOperatorInfo*)param; cleanupBasicInfo(&pInfo->binfo); @@ -1135,7 +1162,7 @@ void destroyIntervalOperatorInfo(void* param) { cleanupAggSup(&pInfo->aggSup); cleanupExprSupp(&pInfo->scalarSupp); - tdListFree(pInfo->binfo.resultRowInfo.openWindow); + (void)tdListFree(pInfo->binfo.resultRowInfo.openWindow); taosArrayDestroy(pInfo->pInterpCols); pInfo->pInterpCols = NULL; @@ -1148,9 +1175,13 @@ void destroyIntervalOperatorInfo(void* param) { taosMemoryFreeClear(param); } -static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SIntervalAggOperatorInfo* pInfo) { +static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SIntervalAggOperatorInfo* pInfo, + SExecTaskInfo* pTaskInfo) { // the primary timestamp column - bool needed = false; + bool needed = false; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + void* tmp = NULL; for (int32_t i = 0; i < numOfCols; ++i) { SExprInfo* pExpr = pCtx[i].pExpr; @@ -1162,7 +1193,10 @@ static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SInt if (needed) { pInfo->pInterpCols = taosArrayInit(4, sizeof(SColumn)); + QUERY_CHECK_NULL(pInfo->pInterpCols, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + pInfo->pPrevValues = taosArrayInit(4, sizeof(SGroupKeys)); + QUERY_CHECK_NULL(pInfo->pPrevValues, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); { // ts column SColumn c = {0}; @@ -1170,14 +1204,18 @@ static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SInt c.slotId = pInfo->primaryTsIndex; c.type = TSDB_DATA_TYPE_TIMESTAMP; c.bytes = sizeof(int64_t); - taosArrayPush(pInfo->pInterpCols, &c); + tmp = taosArrayPush(pInfo->pInterpCols, &c); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); SGroupKeys key; key.bytes = c.bytes; key.type = c.type; key.isNull = true; // to denote no value is assigned yet key.pData = taosMemoryCalloc(1, c.bytes); - taosArrayPush(pInfo->pPrevValues, &key); + QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + tmp = taosArrayPush(pInfo->pPrevValues, &key); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } } @@ -1188,17 +1226,27 @@ static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SInt SFunctParam* pParam = &pExpr->base.pParam[0]; SColumn c = *pParam->pCol; - taosArrayPush(pInfo->pInterpCols, &c); + tmp = taosArrayPush(pInfo->pInterpCols, &c); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); SGroupKeys key = {0}; key.bytes = c.bytes; key.type = c.type; key.isNull = false; key.pData = taosMemoryCalloc(1, c.bytes); - taosArrayPush(pInfo->pPrevValues, &key); + QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + tmp = taosArrayPush(pInfo->pPrevValues, &key); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } } +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return needed; } @@ -1222,15 +1270,14 @@ SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPh size_t keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES; initResultSizeInfo(&pOperator->resultInfo, 512); - blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _error); int32_t num = 0; SExprInfo* pExprInfo = createExprInfo(pPhyNode->window.pFuncs, NULL, &num); code = initAggSup(pSup, &pInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str, pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); SInterval interval = {.interval = pPhyNode->interval, .sliding = pPhyNode->sliding, @@ -1279,7 +1326,7 @@ SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPh code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pInfo->win); QUERY_CHECK_CODE(code, lino, _error); - pInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, pInfo); + pInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, pInfo, pTaskInfo); if (pInfo->timeWindowInterpo) { pInfo->binfo.resultRowInfo.openWindow = tdListNew(sizeof(SOpenWindowInfo)); if (pInfo->binfo.resultRowInfo.openWindow == NULL) { @@ -1387,6 +1434,9 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) { return NULL; } + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SSessionAggOperatorInfo* pInfo = pOperator->info; SOptrBasicInfo* pBInfo = &pInfo->binfo; SExprSupp* pSup = &pOperator->exprSupp; @@ -1394,7 +1444,8 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) { if (pOperator->status == OP_RES_TO_RETURN) { while (1) { doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf); - doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); bool hasRemain = hasRemainResults(&pInfo->groupResInfo); if (!hasRemain) { @@ -1424,11 +1475,15 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) { pBInfo->pRes->info.scanFlag = pBlock->info.scanFlag; if (pInfo->scalarSupp.pExprInfo != NULL) { SExprSupp* pExprSup = &pInfo->scalarSupp; - projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); + code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); + QUERY_CHECK_CODE(code, lino, _end); } // the pDataBlock are always the same one, no need to call this again - setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true); - blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId); + code = setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); + + code = blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId); + QUERY_CHECK_CODE(code, lino, _end); doSessionWindowAggImpl(pOperator, pInfo, pBlock); } @@ -1439,10 +1494,12 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) { pOperator->status = OP_RES_TO_RETURN; initGroupedResultInfo(&pInfo->groupResInfo, pInfo->aggSup.pResultRowHashTable, TSDB_ORDER_ASC); - blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _end); while (1) { doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf); - doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); bool hasRemain = hasRemainResults(&pInfo->groupResInfo); if (!hasRemain) { @@ -1455,6 +1512,13 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) { } } pOperator->resultInfo.totalRows += pBInfo->pRes->info.rows; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return (pBInfo->pRes->info.rows == 0) ? NULL : pBInfo->pRes; } @@ -1581,7 +1645,7 @@ SOperatorInfo* createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionW initBasicInfo(&pInfo->binfo, pResBlock); code = initAggSup(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, numOfCols, keyBufSize, pTaskInfo->id.str, - pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); + pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); if (code != TSDB_CODE_SUCCESS) { goto _error; } @@ -1673,7 +1737,7 @@ static void doMergeAlignedIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultR SInterval* pInterval = &iaInfo->interval; int32_t startPos = 0; - int64_t* tsCols = extractTsCol(pBlock, iaInfo); + int64_t* tsCols = extractTsCol(pBlock, iaInfo, pTaskInfo); TSKEY ts = getStartTsKey(&pBlock->info.window, tsCols); @@ -1737,8 +1801,9 @@ static void cleanupAfterGroupResultGen(SMergeAlignedIntervalAggOperatorInfo* pMi } static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) { - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SMergeAlignedIntervalAggOperatorInfo* pMiaInfo = pOperator->info; SIntervalAggOperatorInfo* pIaInfo = pMiaInfo->intervalAggOperatorInfo; @@ -1765,7 +1830,8 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) { finalizeResultRows(pIaInfo->aggSup.pResultBuf, &pResultRowInfo->cur, pSup, pRes, pTaskInfo); resetResultRow(pMiaInfo->pResultRow, pIaInfo->aggSup.resultRowSize - sizeof(SResultRow)); cleanupAfterGroupResultGen(pMiaInfo, pRes); - doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); } setOperatorCompleted(pOperator); @@ -1786,7 +1852,8 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) { pMiaInfo->prefetchedBlock = pBlock; cleanupAfterGroupResultGen(pMiaInfo, pRes); - doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); break; } else { // continue @@ -1795,14 +1862,25 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) { } pRes->info.scanFlag = pBlock->info.scanFlag; - setInputDataBlock(pSup, pBlock, pIaInfo->binfo.inputTsOrder, pBlock->info.scanFlag, true); + code = setInputDataBlock(pSup, pBlock, pIaInfo->binfo.inputTsOrder, pBlock->info.scanFlag, true); + QUERY_CHECK_CODE(code, lino, _end); + doMergeAlignedIntervalAggImpl(pOperator, &pIaInfo->binfo.resultRowInfo, pBlock, pRes); - doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); + if (pRes->info.rows >= pOperator->resultInfo.capacity) { break; } } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } } static SSDataBlock* mergeAlignedIntervalAgg(SOperatorInfo* pOperator) { @@ -1865,9 +1943,7 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, pSup->hasWindowOrGroup = true; code = filterInitFromNode((SNode*)pNode->window.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); miaInfo->curTs = INT64_MIN; iaInfo->win = pTaskInfo->window; @@ -1885,22 +1961,21 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, code = initAggSup(&pOperator->exprSupp, &iaInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str, pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); SSDataBlock* pResBlock = createDataBlockFromDescNode(pNode->window.node.pOutputDataBlockDesc); initBasicInfo(&iaInfo->binfo, pResBlock); code = initExecTimeWindowInfo(&iaInfo->twAggSup.timeWindowData, &iaInfo->win); QUERY_CHECK_CODE(code, lino, _error); - iaInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, iaInfo); + iaInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, iaInfo, pTaskInfo); if (iaInfo->timeWindowInterpo) { iaInfo->binfo.resultRowInfo.openWindow = tdListNew(sizeof(SOpenWindowInfo)); } initResultRowInfo(&iaInfo->binfo.resultRowInfo); - blockDataEnsureCapacity(iaInfo->binfo.pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(iaInfo->binfo.pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _error); setOperatorInfo(pOperator, "TimeMergeAlignedIntervalAggOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL, false, OP_NOT_OPENED, miaInfo, pTaskInfo); @@ -1908,9 +1983,7 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); return pOperator; @@ -1940,7 +2013,7 @@ typedef struct SGroupTimeWindow { void destroyMergeIntervalOperatorInfo(void* param) { SMergeIntervalAggOperatorInfo* miaInfo = (SMergeIntervalAggOperatorInfo*)param; - tdListFree(miaInfo->groupIntervals); + (void)tdListFree(miaInfo->groupIntervals); destroyIntervalOperatorInfo(&miaInfo->intervalAggOperatorInfo); taosMemoryFreeClear(param); @@ -1953,7 +2026,11 @@ static int32_t outputPrevIntervalResult(SOperatorInfo* pOperatorInfo, uint64_t t bool ascScan = (iaInfo->binfo.inputTsOrder == TSDB_ORDER_ASC); SGroupTimeWindow groupTimeWindow = {.groupId = tableGroupId, .window = *newWin}; - tdListAppend(miaInfo->groupIntervals, &groupTimeWindow); + int32_t code = tdListAppend(miaInfo->groupIntervals, &groupTimeWindow); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } SListIter iter = {0}; tdListInitIter(miaInfo->groupIntervals, &iter, TD_LIST_FORWARD); @@ -1966,11 +2043,11 @@ static int32_t outputPrevIntervalResult(SOperatorInfo* pOperatorInfo, uint64_t t STimeWindow* prevWin = &prevGrpWin->window; if ((ascScan && newWin->skey > prevWin->ekey) || ((!ascScan) && newWin->skey < prevWin->ekey)) { - tdListPopNode(miaInfo->groupIntervals, listNode); + (void)tdListPopNode(miaInfo->groupIntervals, listNode); } } - return 0; + return TSDB_CODE_SUCCESS; } static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResultRowInfo, SSDataBlock* pBlock, @@ -1983,7 +2060,7 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo* int32_t startPos = 0; int32_t numOfOutput = pExprSup->numOfExprs; - int64_t* tsCols = extractTsCol(pBlock, iaInfo); + int64_t* tsCols = extractTsCol(pBlock, iaInfo, pTaskInfo); uint64_t tableGroupId = pBlock->info.id.groupId; bool ascScan = (iaInfo->binfo.inputTsOrder == TSDB_ORDER_ASC); TSKEY blockStartTs = getStartTsKey(&pBlock->info.window, tsCols); @@ -2006,7 +2083,7 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo* // prev time window not interpolation yet. if (iaInfo->timeWindowInterpo) { - SResultRowPosition pos = addToOpenWindowList(pResultRowInfo, pResult, tableGroupId); + SResultRowPosition pos = addToOpenWindowList(pResultRowInfo, pResult, tableGroupId, pTaskInfo); doInterpUnclosedTimeWindow(pOperatorInfo, numOfOutput, pResultRowInfo, pBlock, scanFlag, tsCols, &pos); // restore current time window @@ -2026,7 +2103,11 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo* doCloseWindow(pResultRowInfo, iaInfo, pResult); // output previous interval results after this interval (&win) is closed - outputPrevIntervalResult(pOperatorInfo, tableGroupId, pResultBlock, &win); + int32_t code = outputPrevIntervalResult(pOperatorInfo, tableGroupId, pResultBlock, &win); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY); + } STimeWindow nextWin = win; while (1) { @@ -2038,7 +2119,7 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo* } // null data, failed to allocate more memory buffer - int32_t code = + code = setTimeWindowOutputBuf(pResultRowInfo, &nextWin, (scanFlag == MAIN_SCAN), &pResult, tableGroupId, pExprSup->pCtx, numOfOutput, pExprSup->rowEntryInfoOffset, &iaInfo->aggSup, pTaskInfo); if (code != TSDB_CODE_SUCCESS || pResult == NULL) { @@ -2058,7 +2139,11 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo* doCloseWindow(pResultRowInfo, iaInfo, pResult); // output previous interval results after this interval (&nextWin) is closed - outputPrevIntervalResult(pOperatorInfo, tableGroupId, pResultBlock, &nextWin); + code = outputPrevIntervalResult(pOperatorInfo, tableGroupId, pResultBlock, &nextWin); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY); + } } if (iaInfo->timeWindowInterpo) { @@ -2067,6 +2152,8 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo* } static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SMergeIntervalAggOperatorInfo* miaInfo = pOperator->info; @@ -2079,7 +2166,8 @@ static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) { SSDataBlock* pRes = iaInfo->binfo.pRes; blockDataCleanup(pRes); - blockDataEnsureCapacity(pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _end); if (!miaInfo->inputBlocksFinished) { SOperatorInfo* downstream = pOperator->pDownstream[0]; @@ -2108,7 +2196,9 @@ static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) { } pRes->info.scanFlag = pBlock->info.scanFlag; - setInputDataBlock(pExpSupp, pBlock, iaInfo->binfo.inputTsOrder, pBlock->info.scanFlag, true); + code = setInputDataBlock(pExpSupp, pBlock, iaInfo->binfo.inputTsOrder, pBlock->info.scanFlag, true); + QUERY_CHECK_CODE(code, lino, _end); + doMergeIntervalAggImpl(pOperator, &iaInfo->binfo.resultRowInfo, pBlock, pBlock->info.scanFlag, pRes); if (pRes->info.rows >= pOperator->resultInfo.threshold) { @@ -2134,6 +2224,13 @@ static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) { size_t rows = pRes->info.rows; pOperator->resultInfo.totalRows += rows; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return (rows == 0) ? NULL : pRes; } @@ -2184,7 +2281,7 @@ SOperatorInfo* createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SMerge code = initExecTimeWindowInfo(&pIntervalInfo->twAggSup.timeWindowData, &pIntervalInfo->win); QUERY_CHECK_CODE(code, lino, _error); - pIntervalInfo->timeWindowInterpo = timeWindowinterpNeeded(pExprSupp->pCtx, num, pIntervalInfo); + pIntervalInfo->timeWindowInterpo = timeWindowinterpNeeded(pExprSupp->pCtx, num, pIntervalInfo, pTaskInfo); if (pIntervalInfo->timeWindowInterpo) { pIntervalInfo->binfo.resultRowInfo.openWindow = tdListNew(sizeof(SOpenWindowInfo)); if (pIntervalInfo->binfo.resultRowInfo.openWindow == NULL) { diff --git a/source/libs/executor/test/timewindowTest.cpp b/source/libs/executor/test/timewindowTest.cpp index 7ccbf0b10f..211dce606e 100644 --- a/source/libs/executor/test/timewindowTest.cpp +++ b/source/libs/executor/test/timewindowTest.cpp @@ -52,7 +52,7 @@ void printTimeWindow(STimeWindow* pWindow, int8_t precision, int64_t ts) { taosFormatUtcTime(bufs, tListLen(bufs), pWindow->skey, precision); taosFormatUtcTime(bufe, tListLen(bufe), pWindow->ekey, precision); - printf("%s [%s - %s]\n", buf, bufs, bufe); + (void)printf("%s [%s - %s]\n", buf, bufs, bufe); } } // namespace @@ -71,26 +71,26 @@ TEST(testCase, timewindow_gen) { printTimeWindow(&w, precision, key); getNextTimeWindow(&interval, &w, TSDB_ORDER_ASC); - printf("next\n"); + (void)printf("next\n"); printTimeWindow(&w, precision, key); - printf("---------------------------------------------------\n"); + (void)printf("---------------------------------------------------\n"); SInterval monthInterval = createInterval(1, 1, 0, 'n', 'n', 'd', TSDB_TIME_PRECISION_MILLI); getInitialStartTimeWindow(&monthInterval, key, &w, true); printTimeWindow(&w, precision, key); getNextTimeWindow(&monthInterval, &w, TSDB_ORDER_ASC); - printf("next\n"); + (void)printf("next\n"); printTimeWindow(&w, precision, key); - printf("----------------------------------------------------------\n"); + (void)printf("----------------------------------------------------------\n"); SInterval slidingInterval = createInterval(1, 10*86400*1000, 0, 'n', 'd', 'd', TSDB_TIME_PRECISION_MILLI); getInitialStartTimeWindow(&slidingInterval, key, &w, true); printTimeWindow(&w, precision, key); getNextTimeWindow(&slidingInterval, &w, TSDB_ORDER_ASC); - printf("next\n"); + (void)printf("next\n"); printTimeWindow(&w, precision, key); getNextTimeWindow(&slidingInterval, &w, TSDB_ORDER_ASC); @@ -114,13 +114,13 @@ TEST(testCase, timewindow_gen) { getNextTimeWindow(&slidingInterval, &w, TSDB_ORDER_ASC); printTimeWindow(&w, precision, key); - printf("-----------------calendar_interval_1n_sliding_1d-------\n"); + (void)printf("-----------------calendar_interval_1n_sliding_1d-------\n"); SInterval calendar_interval_1n = createInterval(1, 1*86400*1000, 0, 'n', 'd', 'd', TSDB_TIME_PRECISION_MILLI); int64_t k1 = 1664409600 * 1000L; getInitialStartTimeWindow(&calendar_interval_1n, k1, &w, true); printTimeWindow(&w, precision, k1); - printf("next\n"); + (void)printf("next\n"); getNextTimeWindow(&calendar_interval_1n, &w, TSDB_ORDER_ASC); printTimeWindow(&w, precision, key); @@ -134,14 +134,14 @@ TEST(testCase, timewindow_gen) { getNextTimeWindow(&calendar_interval_1n, &w, TSDB_ORDER_ASC); printTimeWindow(&w, precision, key); - printf("----------------interval_1d_clendar_sliding_1n---------\n"); + (void)printf("----------------interval_1d_clendar_sliding_1n---------\n"); SInterval interval_1d_calendar_sliding_1n = createInterval(1*86400*1000L, 1, 0, 'd', 'n', 'd', TSDB_TIME_PRECISION_MILLI); k1 = 1664409600 * 1000L; getInitialStartTimeWindow(&interval_1d_calendar_sliding_1n, k1, &w, true); printTimeWindow(&w, precision, k1); - printf("next time window:\n"); + (void)printf("next time window:\n"); getNextTimeWindow(&interval_1d_calendar_sliding_1n, &w, TSDB_ORDER_ASC); printTimeWindow(&w, precision, k1); @@ -151,7 +151,7 @@ TEST(testCase, timewindow_gen) { getNextTimeWindow(&interval_1d_calendar_sliding_1n, &w, TSDB_ORDER_ASC); printTimeWindow(&w, precision, k1); - printf("----------------interval_1d_sliding_1d_calendar_offset_1n---------\n"); + (void)printf("----------------interval_1d_sliding_1d_calendar_offset_1n---------\n"); SInterval offset_1n = createInterval(10*86400*1000L, 10*86400*1000L, 1, 'd', 'd', 'n', TSDB_TIME_PRECISION_MILLI); getInitialStartTimeWindow(&offset_1n, k1, &w, true); printTimeWindow(&w, precision, k1); @@ -175,14 +175,14 @@ TEST(testCase, timewindow_natural) { getInitialStartTimeWindow(&interval2, key1, &w1, true); printTimeWindow(&w1, precision, key1); STimeWindow w3 = getAlignQueryTimeWindow(&interval2, key1); - printf("%ld win %ld, %ld\n", key1, w3.skey, w3.ekey); + (void)printf("%ld win %ld, %ld\n", key1, w3.skey, w3.ekey); int64_t key2 = 1648758398208; STimeWindow w2 = {0}; getInitialStartTimeWindow(&interval2, key2, &w2, true); printTimeWindow(&w2, precision, key2); STimeWindow w4 = getAlignQueryTimeWindow(&interval2, key2); - printf("%ld win %ld, %ld\n", key2, w3.skey, w3.ekey); + (void)printf("%ld win %ld, %ld\n", key2, w3.skey, w3.ekey); ASSERT_EQ(w3.skey, w4.skey); ASSERT_EQ(w3.ekey, w4.ekey); @@ -199,7 +199,7 @@ TEST(testCase, timewindow_active) { int64_t key = (int64_t)1609430400*1000; // 2021-01-01 STimeWindow win = getActiveTimeWindow(NULL, &dumyInfo, key, &interval, TSDB_ORDER_ASC); printTimeWindow(&win, precision, key); - printf("%ld win %ld, %ld\n", key, win.skey, win.ekey); + (void)printf("%ld win %ld, %ld\n", key, win.skey, win.ekey); ASSERT_EQ(win.skey, 1325376000000); ASSERT_EQ(win.ekey, 1640908799999); }