From 13b75ba72a8d5a34781b4b45cbae43bff1dc5106 Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao> Date: Fri, 19 Jul 2024 16:15:37 +0800 Subject: [PATCH 01/11] adj operator result --- include/common/tdatablock.h | 2 +- include/util/tutil.h | 4 + source/common/src/tdatablock.c | 8 +- source/libs/executor/inc/executorInt.h | 13 +- source/libs/executor/src/groupoperator.c | 24 +- source/libs/executor/src/scanoperator.c | 1860 +++++++++++------ .../executor/src/streamcountwindowoperator.c | 94 +- .../executor/src/streameventwindowoperator.c | 100 +- source/libs/executor/src/streamfilloperator.c | 108 +- .../executor/src/streamtimewindowoperator.c | 487 ++--- source/libs/stream/src/streamSessionState.c | 86 +- source/libs/stream/src/streamState.c | 30 +- source/libs/stream/src/streamUpdate.c | 88 +- source/libs/stream/src/tstreamFileState.c | 58 +- source/util/src/tbloomfilter.c | 22 +- source/util/src/tscalablebf.c | 44 +- 16 files changed, 1850 insertions(+), 1178 deletions(-) diff --git a/include/common/tdatablock.h b/include/common/tdatablock.h index c271f118ae..89f6beaab4 100644 --- a/include/common/tdatablock.h +++ b/include/common/tdatablock.h @@ -247,7 +247,7 @@ int32_t doEnsureCapacity(SColumnInfoData* pColumn, const SDataBlockInfo* pBlockI size_t blockDataGetCapacityInRow(const SSDataBlock* pBlock, size_t pageSize, int32_t extraSize); int32_t blockDataTrimFirstRows(SSDataBlock* pBlock, size_t n); -int32_t blockDataKeepFirstNRows(SSDataBlock* pBlock, size_t n); +void blockDataKeepFirstNRows(SSDataBlock* pBlock, size_t n); int32_t assignOneDataBlock(SSDataBlock* dst, const SSDataBlock* src); int32_t copyDataBlock(SSDataBlock* pDst, const SSDataBlock* pSrc); diff --git a/include/util/tutil.h b/include/util/tutil.h index 2aa28ac1df..5af79dfc49 100644 --- a/include/util/tutil.h +++ b/include/util/tutil.h @@ -135,6 +135,8 @@ static FORCE_INLINE int32_t taosGetTbHashVal(const char *tbname, int32_t tblen, } \ } while (0) +#define QUERY_CHECK_CODE TSDB_CHECK_CODE + #define TSDB_CHECK_NULL(ptr, CODE, LINO, LABEL, ERRNO) \ if ((ptr) == NULL) { \ (CODE) = (ERRNO); \ @@ -142,6 +144,8 @@ static FORCE_INLINE int32_t taosGetTbHashVal(const char *tbname, int32_t tblen, goto LABEL; \ } +#define QUERY_CHECK_NULL TSDB_CHECK_NULL + #define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0])) #define VND_CHECK_CODE(CODE, LINO, LABEL) TSDB_CHECK_CODE(CODE, LINO, LABEL) diff --git a/source/common/src/tdatablock.c b/source/common/src/tdatablock.c index 43bac56f93..d12db23a43 100644 --- a/source/common/src/tdatablock.c +++ b/source/common/src/tdatablock.c @@ -1990,14 +1990,14 @@ static void colDataKeepFirstNRows(SColumnInfoData* pColInfoData, size_t n, size_ } } -int32_t blockDataKeepFirstNRows(SSDataBlock* pBlock, size_t n) { +void blockDataKeepFirstNRows(SSDataBlock* pBlock, size_t n) { if (n == 0) { blockDataEmpty(pBlock); - return TSDB_CODE_SUCCESS; + return ; } if (pBlock->info.rows <= n) { - return TSDB_CODE_SUCCESS; + return ; } else { size_t numOfCols = taosArrayGetSize(pBlock->pDataBlock); for (int32_t i = 0; i < numOfCols; ++i) { @@ -2007,7 +2007,7 @@ int32_t blockDataKeepFirstNRows(SSDataBlock* pBlock, size_t n) { pBlock->info.rows = n; } - return TSDB_CODE_SUCCESS; + return ; } int32_t tEncodeDataBlock(void** buf, const SSDataBlock* pBlock) { diff --git a/source/libs/executor/inc/executorInt.h b/source/libs/executor/inc/executorInt.h index c6266c1612..d8267c4579 100644 --- a/source/libs/executor/inc/executorInt.h +++ b/source/libs/executor/inc/executorInt.h @@ -862,10 +862,11 @@ int32_t doFilter(SSDataBlock* pBlock, SFilterInfo* pFilterInfo, SColMatchInfo* p int32_t addTagPseudoColumnData(SReadHandle* pHandle, const SExprInfo* pExpr, int32_t numOfExpr, SSDataBlock* pBlock, int32_t rows, SExecTaskInfo* pTask, STableMetaCacheInfo* pCache); -void appendOneRowToDataBlock(SSDataBlock* pBlock, STupleHandle* pTupleHandle); -void setTbNameColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId, const char* name); -void setVgIdColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId, int32_t vgId); -void setVgVerColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId, int64_t vgVer); +void appendOneRowToDataBlock(SSDataBlock* pBlock, STupleHandle* pTupleHandle); +int32_t setTbNameColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId, + const char* name); +int32_t setVgIdColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId, int32_t vgId); +int32_t setVgVerColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId, int64_t vgVer); int32_t setResultRowInitCtx(SResultRow* pResult, SqlFunctionCtx* pCtx, int32_t numOfOutput, int32_t* rowEntryInfoOffset); @@ -897,8 +898,8 @@ bool isOverdue(TSKEY ts, STimeWindowAggSupp* pSup); bool isCloseWindow(STimeWindow* pWin, STimeWindowAggSupp* pSup); bool isDeletedStreamWindow(STimeWindow* pWin, uint64_t groupId, void* pState, STimeWindowAggSupp* pTwSup, SStateStore* pStore); -void appendDataToSpecialBlock(SSDataBlock* pBlock, TSKEY* pStartTs, TSKEY* pEndTs, uint64_t* pUid, uint64_t* pGp, - void* pTbName); +int32_t appendDataToSpecialBlock(SSDataBlock* pBlock, TSKEY* pStartTs, TSKEY* pEndTs, uint64_t* pUid, uint64_t* pGp, + void* pTbName); uint64_t calGroupIdByData(SPartitionBySupporter* pParSup, SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t rowId); diff --git a/source/libs/executor/src/groupoperator.c b/source/libs/executor/src/groupoperator.c index cacb0cb20b..2382f10503 100644 --- a/source/libs/executor/src/groupoperator.c +++ b/source/libs/executor/src/groupoperator.c @@ -1166,7 +1166,7 @@ static SSDataBlock* buildStreamPartitionResult(SOperatorInfo* pOperator) { int32_t winCode = TSDB_CODE_SUCCESS; code = pAPI->stateStore.streamStateGetParName(pOperator->pTaskInfo->streamInfo.pState, pParInfo->groupId, &tbname, false, &winCode); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (winCode == TSDB_CODE_SUCCESS) { memcpy(pDest->info.parTbName, tbname, TSDB_TABLE_NAME_LEN); @@ -1199,7 +1199,7 @@ int32_t appendCreateTableRow(void* pState, SExprSupp* pTableSup, SExprSupp* pTag void* pValue = NULL; int32_t winCode = TSDB_CODE_SUCCESS; code = pAPI->streamStateGetParName(pState, groupId, &pValue, true, &winCode); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (winCode != TSDB_CODE_SUCCESS) { SSDataBlock* pTmpBlock = blockCopyOneRow(pSrcBlock, rowId); @@ -1209,7 +1209,7 @@ int32_t appendCreateTableRow(void* pState, SExprSupp* pTableSup, SExprSupp* pTag if (pTableSup->numOfExprs > 0) { code = projectApplyFunctions(pTableSup->pExprInfo, pDestBlock, pTmpBlock, pTableSup->pCtx, pTableSup->numOfExprs, NULL); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); SColumnInfoData* pTbCol = taosArrayGet(pDestBlock->pDataBlock, UD_TABLE_NAME_COLUMN_INDEX); memset(tbName, 0, TSDB_TABLE_NAME_LEN); @@ -1222,7 +1222,7 @@ int32_t appendCreateTableRow(void* pState, SExprSupp* pTableSup, SExprSupp* pTag len = TMIN(varDataLen(pData), TSDB_TABLE_NAME_LEN - 1); memcpy(tbName, varDataVal(pData), len); code = pAPI->streamStatePutParName(pState, groupId, tbName); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } memcpy(pTmpBlock->info.parTbName, tbName, len); pDestBlock->info.rows--; @@ -1234,7 +1234,7 @@ int32_t appendCreateTableRow(void* pState, SExprSupp* pTableSup, SExprSupp* pTag if (pTagSup->numOfExprs > 0) { code = projectApplyFunctions(pTagSup->pExprInfo, pDestBlock, pTmpBlock, pTagSup->pCtx, pTagSup->numOfExprs, NULL); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pDestBlock->info.rows--; } else { memcpy(pDestBlock->info.parTbName, pTmpBlock->info.parTbName, TSDB_TABLE_NAME_LEN); @@ -1242,7 +1242,7 @@ int32_t appendCreateTableRow(void* pState, SExprSupp* pTableSup, SExprSupp* pTag void* pGpIdCol = taosArrayGet(pDestBlock->pDataBlock, UD_GROUPID_COLUMN_INDEX); code = colDataSetVal(pGpIdCol, pDestBlock->info.rows, (const char*)&groupId, false); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pDestBlock->info.rows++; blockDataDestroy(pTmpBlock); } else { @@ -1269,14 +1269,14 @@ static int32_t buildStreamCreateTableResult(SOperatorInfo* pOperator) { } blockDataCleanup(pInfo->pCreateTbRes); code = blockDataEnsureCapacity(pInfo->pCreateTbRes, taosHashGetSize(pInfo->pPartitions)); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->pTbNameIte != NULL) { SPartitionDataInfo* pParInfo = (SPartitionDataInfo*)pInfo->pTbNameIte; int32_t rowId = *(int32_t*)taosArrayGet(pParInfo->rowIds, 0); code = appendCreateTableRow(pTask->streamInfo.pState, &pInfo->tbnameCalSup, &pInfo->tagCalSup, pParInfo->groupId, pSrc, rowId, pInfo->pCreateTbRes, &pTask->storageAPI.stateStore); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pInfo->pTbNameIte = taosHashIterate(pInfo->pPartitions, pInfo->pTbNameIte); } @@ -1318,7 +1318,7 @@ static SSDataBlock* doStreamHashPartition(SOperatorInfo* pOperator) { if (hasRemainTbName(pInfo)) { code = buildStreamCreateTableResult(pOperator); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->pCreateTbRes && pInfo->pCreateTbRes->info.rows > 0) { return pInfo->pCreateTbRes; } @@ -1373,7 +1373,7 @@ static SSDataBlock* doStreamHashPartition(SOperatorInfo* pOperator) { pInfo->parIte = taosHashIterate(pInfo->pPartitions, NULL); pInfo->pTbNameIte = taosHashIterate(pInfo->pPartitions, NULL); code = buildStreamCreateTableResult(pOperator); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->pCreateTbRes && pInfo->pCreateTbRes->info.rows > 0) { return pInfo->pCreateTbRes; } @@ -1569,10 +1569,10 @@ SOperatorInfo* createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStr setOperatorStreamStateFn(pOperator, streamOpReleaseState, streamOpReloadState); code = initParDownStream(downstream, &pInfo->partitionSup, &pInfo->scalarSup, &pInfo->tbnameCalSup); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); code = appendDownstream(pOperator, &downstream, 1); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); return pOperator; diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index 583dd7b41b..a878af8762 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -19,31 +19,31 @@ #include "functionMgt.h" #include "os.h" #include "querynodes.h" -#include "systable.h" #include "streamexecutorInt.h" +#include "systable.h" #include "tname.h" #include "tdatablock.h" #include "tmsg.h" +#include "operator.h" #include "query.h" +#include "querytask.h" #include "tcompare.h" #include "thash.h" #include "ttypes.h" -#include "operator.h" -#include "querytask.h" #include "storageapi.h" #include "wal.h" int32_t scanDebug = 0; -#define MULTI_READER_MAX_TABLE_NUM 5000 -#define SET_REVERSE_SCAN_FLAG(_info) ((_info)->scanFlag = REVERSE_SCAN) -#define SWITCH_ORDER(n) (((n) = ((n) == TSDB_ORDER_ASC) ? TSDB_ORDER_DESC : TSDB_ORDER_ASC)) -#define STREAM_SCAN_OP_NAME "StreamScanOperator" -#define STREAM_SCAN_OP_STATE_NAME "StreamScanFillHistoryState" -#define STREAM_SCAN_OP_CHECKPOINT_NAME "StreamScanOperator_Checkpoint" +#define MULTI_READER_MAX_TABLE_NUM 5000 +#define SET_REVERSE_SCAN_FLAG(_info) ((_info)->scanFlag = REVERSE_SCAN) +#define SWITCH_ORDER(n) (((n) = ((n) == TSDB_ORDER_ASC) ? TSDB_ORDER_DESC : TSDB_ORDER_ASC)) +#define STREAM_SCAN_OP_NAME "StreamScanOperator" +#define STREAM_SCAN_OP_STATE_NAME "StreamScanFillHistoryState" +#define STREAM_SCAN_OP_CHECKPOINT_NAME "StreamScanOperator_Checkpoint" typedef struct STableMergeScanExecInfo { SFileBlockLoadRecorder blockRecorder; @@ -168,20 +168,20 @@ static SResultRow* getTableGroupOutputBuf(SOperatorInfo* pOperator, uint64_t gro static int32_t insertTableToScanIgnoreList(STableScanInfo* pTableScanInfo, uint64_t uid) { if (NULL == pTableScanInfo->pIgnoreTables) { int32_t tableNum = taosArrayGetSize(pTableScanInfo->base.pTableListInfo->pTableList); - pTableScanInfo->pIgnoreTables = taosHashInit(tableNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK); + pTableScanInfo->pIgnoreTables = + taosHashInit(tableNum, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), true, HASH_NO_LOCK); if (NULL == pTableScanInfo->pIgnoreTables) { return TSDB_CODE_OUT_OF_MEMORY; } } - taosHashPut(pTableScanInfo->pIgnoreTables, &uid, sizeof(uid), &pTableScanInfo->scanTimes, sizeof(pTableScanInfo->scanTimes)); - - return TSDB_CODE_SUCCESS; + return taosHashPut(pTableScanInfo->pIgnoreTables, &uid, sizeof(uid), &pTableScanInfo->scanTimes, + sizeof(pTableScanInfo->scanTimes)); } static int32_t doDynamicPruneDataBlock(SOperatorInfo* pOperator, SDataBlockInfo* pBlockInfo, uint32_t* status) { STableScanInfo* pTableScanInfo = pOperator->info; - int32_t code = TSDB_CODE_SUCCESS; + int32_t code = TSDB_CODE_SUCCESS; if (pTableScanInfo->base.pdInfo.pExprSup == NULL) { return TSDB_CODE_SUCCESS; @@ -221,7 +221,7 @@ static int32_t doDynamicPruneDataBlock(SOperatorInfo* pOperator, SDataBlockInfo* } static int32_t doFilterByBlockSMA(SFilterInfo* pFilterInfo, SColumnDataAgg* pColsAgg, int32_t numOfCols, - int32_t numOfRows, bool *keep) { + int32_t numOfRows, bool* keep) { if (pColsAgg == NULL || pFilterInfo == NULL) { *keep = true; return TSDB_CODE_SUCCESS; @@ -235,7 +235,8 @@ static bool doLoadBlockSMA(STableScanBase* pTableScanInfo, SSDataBlock* pBlock, bool allColumnsHaveAgg = true; bool hasNullSMA = false; - int32_t code = pAPI->tsdReader.tsdReaderRetrieveBlockSMAInfo(pTableScanInfo->dataReader, pBlock, &allColumnsHaveAgg, &hasNullSMA); + int32_t code = pAPI->tsdReader.tsdReaderRetrieveBlockSMAInfo(pTableScanInfo->dataReader, pBlock, &allColumnsHaveAgg, + &hasNullSMA); if (code != TSDB_CODE_SUCCESS) { T_LONG_JMP(pTaskInfo->env, code); } @@ -274,7 +275,11 @@ bool applyLimitOffset(SLimitInfo* pLimitInfo, SSDataBlock* pBlock, SExecTaskInfo qDebug("current block ignore due to offset, current:%" PRId64 ", %s", pLimitInfo->remainOffset, id); return false; } else { - blockDataTrimFirstRows(pBlock, pLimitInfo->remainOffset); + int32_t code = blockDataTrimFirstRows(pBlock, pLimitInfo->remainOffset); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + } pLimitInfo->remainOffset = 0; } } @@ -295,6 +300,8 @@ bool applyLimitOffset(SLimitInfo* pLimitInfo, SSDataBlock* pBlock, SExecTaskInfo static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanBase* pTableScanInfo, SSDataBlock* pBlock, uint32_t* status) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; @@ -350,9 +357,10 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanBase* pTableSca if (pOperator->exprSupp.pFilterInfo != NULL && (!loadSMA)) { bool success = doLoadBlockSMA(pTableScanInfo, pBlock, pTaskInfo); if (success) { - size_t size = taosArrayGetSize(pBlock->pDataBlock); - bool keep = false; - int32_t code = doFilterByBlockSMA(pOperator->exprSupp.pFilterInfo, pBlock->pBlockAgg, size, pBlockInfo->rows, &keep); + size_t size = taosArrayGetSize(pBlock->pDataBlock); + bool keep = false; + int32_t code = + doFilterByBlockSMA(pOperator->exprSupp.pFilterInfo, pBlock->pBlockAgg, size, pBlockInfo->rows, &keep); if (TSDB_CODE_SUCCESS != code) { return code; } @@ -373,7 +381,9 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanBase* pTableSca taosMemoryFreeClear(pBlock->pBlockAgg); // try to filter data block according to current results - doDynamicPruneDataBlock(pOperator, pBlockInfo, status); + code = doDynamicPruneDataBlock(pOperator, pBlockInfo, status); + QUERY_CHECK_CODE(code, lino, _end); + if (*status == FUNC_DATA_REQUIRED_NOT_LOAD) { qDebug("%s data block skipped due to dynamic prune, brange:%" PRId64 "-%" PRId64 ", rows:%" PRId64, GET_TASKID(pTaskInfo), pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows); @@ -393,7 +403,7 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanBase* pTableSca pCost->loadBlocks += 1; SSDataBlock* p = NULL; - int32_t code = pAPI->tsdReader.tsdReaderRetrieveDataBlock(pTableScanInfo->dataReader, &p, NULL); + code = pAPI->tsdReader.tsdReaderRetrieveDataBlock(pTableScanInfo->dataReader, &p, NULL); if (p == NULL || code != TSDB_CODE_SUCCESS) { return code; } @@ -405,11 +415,11 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanBase* pTableSca pCost->totalRows -= pBlock->info.rows; if (pOperator->exprSupp.pFilterInfo != NULL) { - int32_t code = doFilter(pBlock, pOperator->exprSupp.pFilterInfo, &pTableScanInfo->matchInfo); - if (code != TSDB_CODE_SUCCESS) return code; + code = doFilter(pBlock, pOperator->exprSupp.pFilterInfo, &pTableScanInfo->matchInfo); + QUERY_CHECK_CODE(code, lino, _end); int64_t st = taosGetTimestampUs(); - double el = (taosGetTimestampUs() - st) / 1000.0; + double el = (taosGetTimestampUs() - st) / 1000.0; pTableScanInfo->readRecorder.filterTime += el; if (pBlock->info.rows == 0) { @@ -427,7 +437,12 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanBase* pTableSca } pCost->totalRows += pBlock->info.rows; - 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 void prepareForDescendingScan(STableScanBase* pTableScanInfo, SqlFunctionCtx* pCtx, int32_t numOfOutput) { @@ -489,7 +504,8 @@ static void doSetNullValue(SSDataBlock* pBlock, const SExprInfo* pExpr, int32_t int32_t addTagPseudoColumnData(SReadHandle* pHandle, const SExprInfo* pExpr, int32_t numOfExpr, SSDataBlock* pBlock, int32_t rows, SExecTaskInfo* pTask, STableMetaCacheInfo* pCache) { - int32_t code = 0; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; bool freeReader = false; LRUHandle* h = NULL; STableCachedVal val = {0}; @@ -575,7 +591,7 @@ int32_t addTagPseudoColumnData(SReadHandle* pHandle, const SExprInfo* pExpr, int STableCachedVal* pVal = taosLRUCacheValue(pCache->pTableMetaEntryCache, h); val = *pVal; - taosLRUCacheRelease(pCache->pTableMetaEntryCache, h, false); + (void)taosLRUCacheRelease(pCache->pTableMetaEntryCache, h, false); } qDebug("retrieve table meta from cache:%" PRIu64 ", hit:%" PRIu64 " miss:%" PRIu64 ", %s", pCache->metaFetch, @@ -595,11 +611,14 @@ int32_t addTagPseudoColumnData(SReadHandle* pHandle, const SExprInfo* pExpr, int if (fmIsScanPseudoColumnFunc(functionId)) { int32_t fType = pExpr1->pExpr->_function.functionType; if (fType == FUNCTION_TYPE_TBNAME) { - setTbNameColData(pBlock, pColInfoData, functionId, val.pName); + code = setTbNameColData(pBlock, pColInfoData, functionId, val.pName); + QUERY_CHECK_CODE(code, lino, _end); } else if (fType == FUNCTION_TYPE_VGID) { - setVgIdColData(pBlock, pColInfoData, functionId, pTask->id.vgId); + code = setVgIdColData(pBlock, pColInfoData, functionId, pTask->id.vgId); + QUERY_CHECK_CODE(code, lino, _end); } else if (fType == FUNCTION_TYPE_VGVER) { - setVgVerColData(pBlock, pColInfoData, functionId, pBlock->info.version); + code = setVgVerColData(pBlock, pColInfoData, functionId, pBlock->info.version); + QUERY_CHECK_CODE(code, lino, _end); } } else { // these are tags STagVal tagVal = {0}; @@ -629,7 +648,8 @@ int32_t addTagPseudoColumnData(SReadHandle* pHandle, const SExprInfo* pExpr, int } } else { // todo opt for json tag for (int32_t i = 0; i < pBlock->info.rows; ++i) { - colDataSetVal(pColInfoData, i, data, false); + code = colDataSetVal(pColInfoData, i, data, false); + QUERY_CHECK_CODE(code, lino, _end); } } } @@ -641,12 +661,20 @@ int32_t addTagPseudoColumnData(SReadHandle* pHandle, const SExprInfo* pExpr, int pHandle->api.metaReaderFn.clearReader(&mr); } - 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 setTbNameColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId, const char* name) { +int32_t setTbNameColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId, + const char* name) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; struct SScalarFuncExecFuncs fpSet = {0}; - fmGetScalarFuncExecFuncs(functionId, &fpSet); + code = fmGetScalarFuncExecFuncs(functionId, &fpSet); + QUERY_CHECK_CODE(code, lino, _end); size_t len = TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE; char buf[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; @@ -654,65 +682,102 @@ void setTbNameColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, SColumnInfoData infoData = createColumnInfoData(TSDB_DATA_TYPE_VARCHAR, len, 1); - colInfoDataEnsureCapacity(&infoData, 1, false); - colDataSetVal(&infoData, 0, buf, false); + code = colInfoDataEnsureCapacity(&infoData, 1, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = colDataSetVal(&infoData, 0, buf, false); + QUERY_CHECK_CODE(code, lino, _end); SScalarParam srcParam = {.numOfRows = pBlock->info.rows, .columnData = &infoData}; SScalarParam param = {.columnData = pColInfoData}; if (fpSet.process != NULL) { - fpSet.process(&srcParam, 1, ¶m); + code = fpSet.process(&srcParam, 1, ¶m); + QUERY_CHECK_CODE(code, lino, _end); } else { qError("failed to get the corresponding callback function, functionId:%d", functionId); } colDataDestroy(&infoData); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } -void setVgIdColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId, int32_t vgId) { +int32_t setVgIdColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId, int32_t vgId) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; struct SScalarFuncExecFuncs fpSet = {0}; - fmGetScalarFuncExecFuncs(functionId, &fpSet); + code = fmGetScalarFuncExecFuncs(functionId, &fpSet); + QUERY_CHECK_CODE(code, lino, _end); SColumnInfoData infoData = createColumnInfoData(pColInfoData->info.type, pColInfoData->info.bytes, 1); - colInfoDataEnsureCapacity(&infoData, 1, false); - colDataSetVal(&infoData, 0, (const char*)&vgId, false); + code = colInfoDataEnsureCapacity(&infoData, 1, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = colDataSetVal(&infoData, 0, (const char*)&vgId, false); + QUERY_CHECK_CODE(code, lino, _end); SScalarParam srcParam = {.numOfRows = pBlock->info.rows, .columnData = &infoData}; SScalarParam param = {.columnData = pColInfoData}; if (fpSet.process != NULL) { - fpSet.process(&srcParam, 1, ¶m); + code = fpSet.process(&srcParam, 1, ¶m); + QUERY_CHECK_CODE(code, lino, _end); } else { qError("failed to get the corresponding callback function, functionId:%d", functionId); } +_end: colDataDestroy(&infoData); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } -void setVgVerColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId, int64_t vgVer) { +int32_t setVgVerColData(const SSDataBlock* pBlock, SColumnInfoData* pColInfoData, int32_t functionId, int64_t vgVer) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; struct SScalarFuncExecFuncs fpSet = {0}; - fmGetScalarFuncExecFuncs(functionId, &fpSet); + code = fmGetScalarFuncExecFuncs(functionId, &fpSet); + QUERY_CHECK_CODE(code, lino, _end); SColumnInfoData infoData = createColumnInfoData(pColInfoData->info.type, pColInfoData->info.bytes, 1); - colInfoDataEnsureCapacity(&infoData, 1, false); - colDataSetVal(&infoData, 0, (const char*)&vgVer, false); + code = colInfoDataEnsureCapacity(&infoData, 1, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = colDataSetVal(&infoData, 0, (const char*)&vgVer, false); + QUERY_CHECK_CODE(code, lino, _end); SScalarParam srcParam = {.numOfRows = pBlock->info.rows, .columnData = &infoData}; SScalarParam param = {.columnData = pColInfoData}; if (fpSet.process != NULL) { - fpSet.process(&srcParam, 1, ¶m); + code = fpSet.process(&srcParam, 1, ¶m); + QUERY_CHECK_CODE(code, lino, _end); } else { qError("failed to get the corresponding callback function, functionId:%d", functionId); } +_end: colDataDestroy(&infoData); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } -static void initNextGroupScan(STableScanInfo* pInfo, STableKeyInfo** pKeyInfo, int32_t* size) { - tableListGetGroupList(pInfo->base.pTableListInfo, pInfo->currentGroupId, pKeyInfo, size); +static int32_t initNextGroupScan(STableScanInfo* pInfo, STableKeyInfo** pKeyInfo, int32_t* size) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + code = tableListGetGroupList(pInfo->base.pTableListInfo, pInfo->currentGroupId, pKeyInfo, size); + QUERY_CHECK_CODE(code, lino, _end); pInfo->tableStartIndex = TARRAY_ELEM_IDX(pInfo->base.pTableListInfo->pTableList, *pKeyInfo); pInfo->tableEndIndex = (pInfo->tableStartIndex + (*size) - 1); @@ -724,16 +789,22 @@ static void initNextGroupScan(STableScanInfo* pInfo, STableKeyInfo** pKeyInfo, i } else { pInfo->countState = TABLE_COUNT_STATE_SCAN; } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } void markGroupProcessed(STableScanInfo* pInfo, uint64_t groupId) { - if (pInfo->countState == TABLE_COUNT_STATE_END) { + if (pInfo->countState == TABLE_COUNT_STATE_END) { return; } if (pInfo->base.pTableListInfo->groupOffset) { pInfo->countState = TABLE_COUNT_STATE_PROCESSED; } else { - taosHashRemove(pInfo->base.pTableListInfo->remainGroups, &groupId, sizeof(groupId)); + (void)taosHashRemove(pInfo->base.pTableListInfo->remainGroups, &groupId, sizeof(groupId)); } } @@ -771,9 +842,9 @@ static SSDataBlock* doTableScanImpl(SOperatorInfo* pOperator) { SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; - SSDataBlock* pBlock = pTableScanInfo->pResBlock; - bool hasNext = false; - int32_t code = TSDB_CODE_SUCCESS; + SSDataBlock* pBlock = pTableScanInfo->pResBlock; + bool hasNext = false; + int32_t code = TSDB_CODE_SUCCESS; pBlock->info.dataLoad = false; int64_t st = taosGetTimestampUs(); @@ -835,9 +906,11 @@ static SSDataBlock* doTableScanImpl(SOperatorInfo* pOperator) { } static SSDataBlock* doGroupedTableScan(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; STableScanInfo* pTableScanInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - SStorageAPI* pAPI = &pTaskInfo->storageAPI; + SStorageAPI* pAPI = &pTaskInfo->storageAPI; // The read handle is not initialized yet, since no qualified tables exists if (pTableScanInfo->base.dataReader == NULL || pOperator->status == OP_EXEC_DONE) { @@ -862,7 +935,8 @@ static SSDataBlock* doGroupedTableScan(SOperatorInfo* pOperator) { qDebug("start to repeat ascending order scan data blocks due to query func required, %s", GET_TASKID(pTaskInfo)); // do prepare for the next round table scan operation - pAPI->tsdReader.tsdReaderResetStatus(pTableScanInfo->base.dataReader, &pTableScanInfo->base.cond); + code = pAPI->tsdReader.tsdReaderResetStatus(pTableScanInfo->base.dataReader, &pTableScanInfo->base.cond); + QUERY_CHECK_CODE(code, lino, _end); } } @@ -870,7 +944,8 @@ static SSDataBlock* doGroupedTableScan(SOperatorInfo* pOperator) { if (pTableScanInfo->scanTimes < total) { if (pTableScanInfo->base.cond.order == TSDB_ORDER_ASC) { prepareForDescendingScan(&pTableScanInfo->base, pOperator->exprSupp.pCtx, 0); - pAPI->tsdReader.tsdReaderResetStatus(pTableScanInfo->base.dataReader, &pTableScanInfo->base.cond); + code = pAPI->tsdReader.tsdReaderResetStatus(pTableScanInfo->base.dataReader, &pTableScanInfo->base.cond); + QUERY_CHECK_CODE(code, lino, _end); qDebug("%s start to descending order scan data blocks due to query func required", GET_TASKID(pTaskInfo)); } @@ -889,7 +964,8 @@ static SSDataBlock* doGroupedTableScan(SOperatorInfo* pOperator) { pTableScanInfo->base.scanFlag = MAIN_SCAN; qDebug("%s start to repeat descending order scan data blocks", GET_TASKID(pTaskInfo)); - pAPI->tsdReader.tsdReaderResetStatus(pTableScanInfo->base.dataReader, &pTableScanInfo->base.cond); + code = pAPI->tsdReader.tsdReaderResetStatus(pTableScanInfo->base.dataReader, &pTableScanInfo->base.cond); + QUERY_CHECK_CODE(code, lino, _end); } } } @@ -922,23 +998,29 @@ static SSDataBlock* doGroupedTableScan(SOperatorInfo* pOperator) { pTableScanInfo->countState = TABLE_COUNT_STATE_END; } +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + } return NULL; } static int32_t createTableListInfoFromParam(SOperatorInfo* pOperator) { - STableScanInfo* pInfo = pOperator->info; - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - int32_t code = 0; - STableListInfo* pListInfo = pInfo->base.pTableListInfo; + STableScanInfo* pInfo = pOperator->info; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + int32_t code = 0; + STableListInfo* pListInfo = pInfo->base.pTableListInfo; STableScanOperatorParam* pParam = (STableScanOperatorParam*)pOperator->pOperatorGetParam->value; - int32_t num = taosArrayGetSize(pParam->pUidList); + int32_t num = taosArrayGetSize(pParam->pUidList); if (num <= 0) { qError("empty table scan uid list"); return TSDB_CODE_INVALID_PARA; } - - qDebug("vgId:%d add total %d dynamic tables to scan, tableSeq:%d, exist num:%" PRId64 ", operator status:%d", - pTaskInfo->id.vgId, num, pParam->tableSeq, (int64_t)taosArrayGetSize(pListInfo->pTableList), pOperator->status); + + qDebug("vgId:%d add total %d dynamic tables to scan, tableSeq:%d, exist num:%" PRId64 ", operator status:%d", + pTaskInfo->id.vgId, num, pParam->tableSeq, (int64_t)taosArrayGetSize(pListInfo->pTableList), + pOperator->status); if (pParam->tableSeq) { pListInfo->oneTableForEachGroup = true; @@ -952,8 +1034,8 @@ static int32_t createTableListInfoFromParam(SOperatorInfo* pOperator) { pListInfo->numOfOuputGroups = 1; } - STableKeyInfo info = {.groupId = 0}; - int32_t tableIdx = 0; + STableKeyInfo info = {.groupId = 0}; + int32_t tableIdx = 0; for (int32_t i = 0; i < num; ++i) { uint64_t* pUid = taosArrayGet(pParam->pUidList, i); @@ -973,15 +1055,17 @@ static int32_t createTableListInfoFromParam(SOperatorInfo* pOperator) { tableIdx++; qDebug("add dynamic table scan uid:%" PRIu64 ", %s", info.uid, GET_TASKID(pTaskInfo)); } - + return code; } static SSDataBlock* startNextGroupScan(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; STableScanInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; - int32_t numOfTables = tableListGetSize(pInfo->base.pTableListInfo); + int32_t numOfTables = tableListGetSize(pInfo->base.pTableListInfo); if ((++pInfo->currentGroupId) >= tableListGetOutputGroups(pInfo->base.pTableListInfo)) { setOperatorCompleted(pOperator); if (pOperator->dynamicTask) { @@ -994,15 +1078,19 @@ static SSDataBlock* startNextGroupScan(SOperatorInfo* pOperator) { // reset value for the next group data output pOperator->status = OP_OPENED; resetLimitInfoForNextGroup(&pInfo->base.limitInfo); - + int32_t num = 0; STableKeyInfo* pList = NULL; - initNextGroupScan(pInfo, &pList, &num); + code = initNextGroupScan(pInfo, &pList, &num); + QUERY_CHECK_CODE(code, lino, _end); - pAPI->tsdReader.tsdSetQueryTableList(pInfo->base.dataReader, pList, num); - pAPI->tsdReader.tsdReaderResetStatus(pInfo->base.dataReader, &pInfo->base.cond); + code = pAPI->tsdReader.tsdSetQueryTableList(pInfo->base.dataReader, pList, num); + QUERY_CHECK_CODE(code, lino, _end); + + code = pAPI->tsdReader.tsdReaderResetStatus(pInfo->base.dataReader, &pInfo->base.cond); + QUERY_CHECK_CODE(code, lino, _end); pInfo->scanTimes = 0; - + SSDataBlock* result = doGroupedTableScan(pOperator); if (result != NULL) { if (pOperator->dynamicTask) { @@ -1010,16 +1098,24 @@ static SSDataBlock* startNextGroupScan(SOperatorInfo* pOperator) { } return result; } - + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + } return NULL; } static SSDataBlock* groupSeqTableScan(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; STableScanInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; int32_t num = 0; STableKeyInfo* pList = NULL; + SSDataBlock* result = NULL; if (pInfo->currentGroupId == -1) { if ((++pInfo->currentGroupId) >= tableListGetOutputGroups(pInfo->base.pTableListInfo)) { @@ -1028,16 +1124,16 @@ static SSDataBlock* groupSeqTableScan(SOperatorInfo* pOperator) { } taosRLockLatch(&pTaskInfo->lock); - initNextGroupScan(pInfo, &pList, &num); + code = initNextGroupScan(pInfo, &pList, &num); + QUERY_CHECK_CODE(code, lino, _end); + taosRUnLockLatch(&pTaskInfo->lock); ASSERT(pInfo->base.dataReader == NULL); - - int32_t code = pAPI->tsdReader.tsdReaderOpen(pInfo->base.readHandle.vnode, &pInfo->base.cond, pList, num, pInfo->pResBlock, - (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), &pInfo->pIgnoreTables); - if (code != TSDB_CODE_SUCCESS) { - T_LONG_JMP(pTaskInfo->env, code); - } + + 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); } @@ -1046,7 +1142,7 @@ static SSDataBlock* groupSeqTableScan(SOperatorInfo* pOperator) { } } - SSDataBlock* result = doGroupedTableScan(pOperator); + result = doGroupedTableScan(pOperator); if (result != NULL) { if (pOperator->dynamicTask) { result->info.id.groupId = result->info.id.uid; @@ -1061,17 +1157,24 @@ static SSDataBlock* groupSeqTableScan(SOperatorInfo* pOperator) { } } +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + } return result; } static SSDataBlock* doTableScan(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; STableScanInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; if (pOperator->pOperatorGetParam) { pOperator->dynamicTask = true; - int32_t code = createTableListInfoFromParam(pOperator); + code = createTableListInfoFromParam(pOperator); freeOperatorParam(pOperator->pOperatorGetParam, OP_GET_PARAM); pOperator->pOperatorGetParam = NULL; if (code != TSDB_CODE_SUCCESS) { @@ -1118,16 +1221,25 @@ static SSDataBlock* doTableScan(SOperatorInfo* pOperator) { tInfo = *(STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->currentTable); taosRUnLockLatch(&pTaskInfo->lock); - pAPI->tsdReader.tsdSetQueryTableList(pInfo->base.dataReader, &tInfo, 1); + code = pAPI->tsdReader.tsdSetQueryTableList(pInfo->base.dataReader, &tInfo, 1); + QUERY_CHECK_CODE(code, lino, _end); qDebug("set uid:%" PRIu64 " into scanner, total tables:%d, index:%d/%d %s", tInfo.uid, numOfTables, pInfo->currentTable, numOfTables, GET_TASKID(pTaskInfo)); - pAPI->tsdReader.tsdReaderResetStatus(pInfo->base.dataReader, &pInfo->base.cond); + code = pAPI->tsdReader.tsdReaderResetStatus(pInfo->base.dataReader, &pInfo->base.cond); + QUERY_CHECK_CODE(code, lino, _end); pInfo->scanTimes = 0; } } else { // scan table group by group sequentially return groupSeqTableScan(pOperator); } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + } + return NULL; } static int32_t getTableScannerExecInfo(struct SOperatorInfo* pOptr, void** pOptrExplain, uint32_t* len) { @@ -1149,7 +1261,7 @@ static void destroyTableScanBase(STableScanBase* pBase, TsdReader* pAPI) { taosArrayDestroy(pBase->matchInfo.pList); } - tableListDestroy(pBase->pTableListInfo); + (void)tableListDestroy(pBase->pTableListInfo); taosLRUCacheCleanup(pBase->metaCache.pTableMetaEntryCache); cleanupExprSupp(&pBase->pseudoSup); } @@ -1164,7 +1276,8 @@ static void destroyTableScanOperatorInfo(void* param) { SOperatorInfo* createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, SReadHandle* readHandle, STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo) { - int32_t code = 0; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; STableScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STableScanInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -1178,20 +1291,17 @@ SOperatorInfo* createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, int32_t numOfCols = 0; code = extractColMatchInfo(pScanNode->pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, &pInfo->base.matchInfo); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); initLimitInfo(pScanNode->node.pLimit, pScanNode->node.pSlimit, &pInfo->base.limitInfo); code = initQueryTableDataCond(&pInfo->base.cond, pTableScanNode, readHandle); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); if (pScanNode->pScanPseudoCols != NULL) { SExprSupp* pSup = &pInfo->base.pseudoSup; pSup->pExprInfo = createExprInfo(pScanNode->pScanPseudoCols, NULL, &pSup->numOfExprs); - pSup->pCtx = createSqlFunctionCtx(pSup->pExprInfo, pSup->numOfExprs, &pSup->rowEntryInfoOffset, &pTaskInfo->storageAPI.functionStore); + pSup->pCtx = createSqlFunctionCtx(pSup->pExprInfo, pSup->numOfExprs, &pSup->rowEntryInfoOffset, + &pTaskInfo->storageAPI.functionStore); } pInfo->scanInfo = (SScanInfo){.numOfAsc = pTableScanNode->scanSeq[0], .numOfDesc = pTableScanNode->scanSeq[1]}; @@ -1207,13 +1317,12 @@ SOperatorInfo* createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, pInfo->base.readerAPI = pTaskInfo->storageAPI.tsdReader; initResultSizeInfo(&pOperator->resultInfo, 4096); pInfo->pResBlock = createDataBlockFromDescNode(pDescNode); - prepareDataBlockBuf(pInfo->pResBlock, &pInfo->base.matchInfo); + code = prepareDataBlockBuf(pInfo->pResBlock, &pInfo->base.matchInfo); + QUERY_CHECK_CODE(code, lino, _error); code = filterInitFromNode((SNode*)pTableScanNode->scan.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } - + QUERY_CHECK_CODE(code, lino, _error); + pInfo->currentGroupId = -1; pInfo->tableEndIndex = -1; @@ -1230,7 +1339,7 @@ SOperatorInfo* createTableScanOperatorInfo(STableScanPhysiNode* pTableScanNode, pInfo->base.metaCache.pTableMetaEntryCache = taosLRUCacheInit(1024 * 128, -1, .5); if (pInfo->base.metaCache.pTableMetaEntryCache == NULL) { code = terrno; - goto _error; + QUERY_CHECK_CODE(code, lino, _error); } pInfo->filesetDelimited = pTableScanNode->filesetDelimited; @@ -1262,7 +1371,8 @@ SOperatorInfo* createTableSeqScanOperatorInfo(void* pReadHandle, SExecTaskInfo* setOperatorInfo(pOperator, "TableSeqScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_SEQ_SCAN, false, OP_NOT_OPENED, pInfo, pTaskInfo); - pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableScanImpl, NULL, NULL, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); + pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTableScanImpl, NULL, NULL, optrDefaultBufFn, NULL, + optrDefaultGetNextExtFn, NULL); return pOperator; } @@ -1297,7 +1407,8 @@ static bool isSlidingWindow(SStreamScanInfo* pInfo) { } static bool isCountSlidingWindow(SStreamScanInfo* pInfo) { - return pInfo->windowSup.pStreamAggSup && (pInfo->windowSup.pStreamAggSup->windowCount != pInfo->windowSup.pStreamAggSup->windowSliding); + return pInfo->windowSup.pStreamAggSup && + (pInfo->windowSup.pStreamAggSup->windowCount != pInfo->windowSup.pStreamAggSup->windowSliding); } static bool isCountWindow(SStreamScanInfo* pInfo) { @@ -1340,7 +1451,7 @@ static SSDataBlock* readPreVersionData(SOperatorInfo* pTableScanOp, uint64_t tbU SSDataBlock* pBlock = pTableScanInfo->pResBlock; STsdbReader* pReader = NULL; int32_t code = pAPI->tsdReader.tsdReaderOpen(pTableScanInfo->base.readHandle.vnode, &cond, &tblInfo, 1, pBlock, - (void**)&pReader, GET_TASKID(pTaskInfo), NULL); + (void**)&pReader, GET_TASKID(pTaskInfo), NULL); if (code != TSDB_CODE_SUCCESS) { terrno = code; T_LONG_JMP(pTaskInfo->env, code); @@ -1401,9 +1512,7 @@ bool comparePrimaryKey(SColumnInfoData* pCol, int32_t rowId, void* pVal) { return false; } -bool hasPrimaryKeyCol(SStreamScanInfo* pInfo) { - return pInfo->primaryKeyIndex != -1; -} +bool hasPrimaryKeyCol(SStreamScanInfo* pInfo) { return pInfo->primaryKeyIndex != -1; } static uint64_t getGroupIdByCol(SStreamScanInfo* pInfo, uint64_t uid, TSKEY ts, int64_t maxVersion, void* pVal) { SSDataBlock* pPreRes = readPreVersionData(pInfo->pTableScanOp, uid, ts, ts, maxVersion); @@ -1440,12 +1549,16 @@ static uint64_t getGroupIdByData(SStreamScanInfo* pInfo, uint64_t uid, TSKEY ts, return getGroupIdByUid(pInfo, uid); } -static bool prepareRangeScan(SStreamScanInfo* pInfo, SSDataBlock* pBlock, int32_t* pRowIndex) { +static void prepareRangeScan(SStreamScanInfo* pInfo, SSDataBlock* pBlock, int32_t* pRowIndex, bool* pRes) { if (pBlock->info.rows == 0) { - return false; + if (pRes) { + (*pRes) = false; + } } if ((*pRowIndex) == pBlock->info.rows) { - return false; + if (pRes) { + (*pRes) = false; + } } ASSERT(taosArrayGetSize(pBlock->pDataBlock) >= 3); @@ -1495,7 +1608,9 @@ static bool prepareRangeScan(SStreamScanInfo* pInfo, SSDataBlock* pBlock, int32_ resetTableScanInfo(pInfo->pTableScanOp->info, &win, pInfo->pUpdateInfo->maxDataVersion); } pInfo->pTableScanOp->status = OP_OPENED; - return true; + if (pRes) { + (*pRes) = true; + } } static STimeWindow getSlidingWindow(TSKEY* startTsCol, TSKEY* endTsCol, uint64_t* gpIdCol, SInterval* pInterval, @@ -1532,15 +1647,18 @@ static STimeWindow getSlidingWindow(TSKEY* startTsCol, TSKEY* endTsCol, uint64_t } } -static SSDataBlock* doRangeScan(SStreamScanInfo* pInfo, SSDataBlock* pSDB, int32_t tsColIndex, int32_t* pRowIndex) { +static int32_t doRangeScan(SStreamScanInfo* pInfo, SSDataBlock* pSDB, int32_t tsColIndex, int32_t* pRowIndex, + SSDataBlock** ppRes) { qDebug("do stream range scan. windows index:%d", *pRowIndex); - bool prepareRes = true; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + bool prepareRes = true; while (1) { SSDataBlock* pResult = NULL; pResult = doTableScan(pInfo->pTableScanOp); if (!pResult) { - prepareRes = prepareRangeScan(pInfo, pSDB, pRowIndex); + prepareRangeScan(pInfo, pSDB, pRowIndex, &prepareRes); // scan next window data pResult = doTableScan(pInfo->pTableScanOp); } @@ -1554,16 +1672,20 @@ static SSDataBlock* doRangeScan(SStreamScanInfo* pInfo, SSDataBlock* pSDB, int32 STableScanInfo* pTableScanInfo = pInfo->pTableScanOp->info; pTableScanInfo->base.readerAPI.tsdReaderClose(pTableScanInfo->base.dataReader); pTableScanInfo->base.dataReader = NULL; - return NULL; + (*ppRes) = NULL; + goto _end; } - doFilter(pResult, pInfo->pTableScanOp->exprSupp.pFilterInfo, NULL); + code = doFilter(pResult, pInfo->pTableScanOp->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); if (pResult->info.rows == 0) { continue; } if (pInfo->partitionSup.needCalc) { SSDataBlock* tmpBlock = createOneDataBlock(pResult, true); + QUERY_CHECK_NULL(tmpBlock, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + blockDataCleanup(pResult); for (int32_t i = 0; i < tmpBlock->info.rows; i++) { if (calGroupIdByData(&pInfo->partitionSup, pInfo->pPartScalarSup, tmpBlock, i) == pInfo->groupId) { @@ -1573,7 +1695,8 @@ static SSDataBlock* doRangeScan(SStreamScanInfo* pInfo, SSDataBlock* pSDB, int32 bool isNull = colDataIsNull(pSrcCol, tmpBlock->info.rows, i, NULL); char* pSrcData = NULL; if (!isNull) pSrcData = colDataGetData(pSrcCol, i); - colDataSetVal(pDestCol, pResult->info.rows, pSrcData, isNull); + code = colDataSetVal(pDestCol, pResult->info.rows, pSrcData, isNull); + QUERY_CHECK_CODE(code, lino, _end); } pResult->info.rows++; } @@ -1583,33 +1706,42 @@ static SSDataBlock* doRangeScan(SStreamScanInfo* pInfo, SSDataBlock* pSDB, int32 if (pResult->info.rows > 0) { pResult->info.calWin = pInfo->updateWin; - return pResult; + (*ppRes) = pResult; + goto _end; } } else if (pResult->info.id.groupId == pInfo->groupId) { pResult->info.calWin = pInfo->updateWin; - return pResult; + (*ppRes) = pResult; + goto _end; } } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } -static int32_t getPreSessionWindow(SStreamAggSupporter* pAggSup, TSKEY startTs, TSKEY endTs, uint64_t groupId, - SSessionKey* pKey) { +static void getPreSessionWindow(SStreamAggSupporter* pAggSup, TSKEY startTs, TSKEY endTs, uint64_t groupId, + SSessionKey* pKey) { pKey->win.skey = startTs; pKey->win.ekey = endTs; pKey->groupId = groupId; - void* pCur = pAggSup->stateStore.streamStateSessionSeekKeyCurrentPrev(pAggSup->pState, pKey); - int32_t code = pAggSup->stateStore.streamStateSessionGetKVByCur(pCur, pKey, NULL, 0); + void* pCur = pAggSup->stateStore.streamStateSessionSeekKeyCurrentPrev(pAggSup->pState, pKey); + int32_t code = pAggSup->stateStore.streamStateSessionGetKVByCur(pCur, pKey, NULL, 0); if (code != TSDB_CODE_SUCCESS) { SET_SESSION_WIN_KEY_INVALID(pKey); } taosMemoryFree(pCur); - return code; } -void appendOneRowToSpecialBlockImpl(SSDataBlock* pBlock, TSKEY* pStartTs, TSKEY* pEndTs, TSKEY* pCalStartTs, - TSKEY* pCalEndTs, uint64_t* pUid, uint64_t* pGp, void* pTbName, void* pPkData) { +int32_t appendOneRowToSpecialBlockImpl(SSDataBlock* pBlock, TSKEY* pStartTs, TSKEY* pEndTs, TSKEY* pCalStartTs, + TSKEY* pCalEndTs, uint64_t* pUid, uint64_t* pGp, void* pTbName, void* pPkData) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SColumnInfoData* pStartTsCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX); SColumnInfoData* pEndTsCol = taosArrayGet(pBlock->pDataBlock, END_TS_COLUMN_INDEX); SColumnInfoData* pUidCol = taosArrayGet(pBlock->pDataBlock, UID_COLUMN_INDEX); @@ -1617,42 +1749,63 @@ void appendOneRowToSpecialBlockImpl(SSDataBlock* pBlock, TSKEY* pStartTs, TSKEY* SColumnInfoData* pCalStartCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_START_TS_COLUMN_INDEX); SColumnInfoData* pCalEndCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_END_TS_COLUMN_INDEX); SColumnInfoData* pTableCol = taosArrayGet(pBlock->pDataBlock, TABLE_NAME_COLUMN_INDEX); - colDataSetVal(pStartTsCol, pBlock->info.rows, (const char*)pStartTs, false); - colDataSetVal(pEndTsCol, pBlock->info.rows, (const char*)pEndTs, false); - colDataSetVal(pUidCol, pBlock->info.rows, (const char*)pUid, false); - colDataSetVal(pGpCol, pBlock->info.rows, (const char*)pGp, false); - colDataSetVal(pCalStartCol, pBlock->info.rows, (const char*)pCalStartTs, false); - colDataSetVal(pCalEndCol, pBlock->info.rows, (const char*)pCalEndTs, false); - colDataSetVal(pTableCol, pBlock->info.rows, (const char*)pTbName, pTbName == NULL); + code = colDataSetVal(pStartTsCol, pBlock->info.rows, (const char*)pStartTs, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = colDataSetVal(pEndTsCol, pBlock->info.rows, (const char*)pEndTs, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = colDataSetVal(pUidCol, pBlock->info.rows, (const char*)pUid, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = colDataSetVal(pGpCol, pBlock->info.rows, (const char*)pGp, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = colDataSetVal(pCalStartCol, pBlock->info.rows, (const char*)pCalStartTs, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = colDataSetVal(pCalEndCol, pBlock->info.rows, (const char*)pCalEndTs, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = colDataSetVal(pTableCol, pBlock->info.rows, (const char*)pTbName, pTbName == NULL); + QUERY_CHECK_CODE(code, lino, _end); + if (taosArrayGetSize(pBlock->pDataBlock) > PRIMARY_KEY_COLUMN_INDEX) { SColumnInfoData* pPkCol = taosArrayGet(pBlock->pDataBlock, PRIMARY_KEY_COLUMN_INDEX); - colDataSetVal(pPkCol, pBlock->info.rows, (const char*)pPkData, pPkData == NULL); + code = colDataSetVal(pPkCol, pBlock->info.rows, (const char*)pPkData, pPkData == NULL); + QUERY_CHECK_CODE(code, lino, _end); } pBlock->info.rows++; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } -void appendPkToSpecialBlock(SSDataBlock* pBlock, TSKEY* pTsArray, SColumnInfoData* pPkCol, int32_t rowId, - uint64_t* pUid, uint64_t* pGp, void* pTbName) { +int32_t appendPkToSpecialBlock(SSDataBlock* pBlock, TSKEY* pTsArray, SColumnInfoData* pPkCol, int32_t rowId, + uint64_t* pUid, uint64_t* pGp, void* pTbName) { void* pVal = NULL; if (pPkCol) { pVal = colDataGetData(pPkCol, rowId); } - appendOneRowToSpecialBlockImpl(pBlock, pTsArray + rowId, pTsArray + rowId, pTsArray + rowId, pTsArray + rowId, pUid, - pGp, pTbName, pVal); + return appendOneRowToSpecialBlockImpl(pBlock, pTsArray + rowId, pTsArray + rowId, pTsArray + rowId, pTsArray + rowId, + pUid, pGp, pTbName, pVal); } -static void getPreVersionDataBlock(uint64_t uid, TSKEY startTs, TSKEY endTs, int64_t version, char* taskIdStr, - SStreamScanInfo* pInfo, SSDataBlock* pBlock) { +static int32_t getPreVersionDataBlock(uint64_t uid, TSKEY startTs, TSKEY endTs, int64_t version, char* taskIdStr, + SStreamScanInfo* pInfo, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SSDataBlock* pPreRes = readPreVersionData(pInfo->pTableScanOp, uid, startTs, endTs, version); printDataBlock(pPreRes, "pre res", taskIdStr); blockDataCleanup(pBlock); if (!pPreRes) { - return ; - } - int32_t code = blockDataEnsureCapacity(pBlock, pPreRes->info.rows); - if (code != TSDB_CODE_SUCCESS) { - return ; + goto _end; } + code = blockDataEnsureCapacity(pBlock, pPreRes->info.rows); + QUERY_CHECK_CODE(code, lino, _end); SColumnInfoData* pTsCol = (SColumnInfoData*)taosArrayGet(pPreRes->pDataBlock, pInfo->primaryTsIndex); SColumnInfoData* pPkCol = NULL; @@ -1661,12 +1814,22 @@ static void getPreVersionDataBlock(uint64_t uid, TSKEY startTs, TSKEY endTs, int } for (int32_t i = 0; i < pPreRes->info.rows; i++) { uint64_t groupId = calGroupIdByData(&pInfo->partitionSup, pInfo->pPartScalarSup, pPreRes, i); - appendPkToSpecialBlock(pBlock, (TSKEY*)pTsCol->pData, pPkCol, i, &uid, &groupId, NULL); + code = appendPkToSpecialBlock(pBlock, (TSKEY*)pTsCol->pData, pPkCol, i, &uid, &groupId, NULL); + QUERY_CHECK_CODE(code, lino, _end); } printDataBlock(pBlock, "new delete", taskIdStr); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } -static int32_t generateSessionScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSrcBlock, SSDataBlock* pDestBlock, EStreamType mode) { +static int32_t generateSessionScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSrcBlock, SSDataBlock* pDestBlock, + EStreamType mode) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pSrcBlock->info.rows == 0) { return TSDB_CODE_SUCCESS; } @@ -1685,18 +1848,18 @@ static int32_t generateSessionScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSr } int64_t ver = pSrcBlock->info.version - 1; - if (pInfo->partitionSup.needCalc && ( startData[0] != endData[0] || (hasPrimaryKeyCol(pInfo) && mode == STREAM_DELETE_DATA) )) { - getPreVersionDataBlock(uidCol[0], startData[0], endData[0], ver, GET_TASKID(pTaskInfo), pInfo, pSrcBlock); + if (pInfo->partitionSup.needCalc && + (startData[0] != endData[0] || (hasPrimaryKeyCol(pInfo) && mode == STREAM_DELETE_DATA))) { + code = getPreVersionDataBlock(uidCol[0], startData[0], endData[0], ver, GET_TASKID(pTaskInfo), pInfo, pSrcBlock); + QUERY_CHECK_CODE(code, lino, _end); startData = (TSKEY*)pStartTsCol->pData; endData = (TSKEY*)pEndTsCol->pData; uidCol = (uint64_t*)pUidCol->pData; pSrcGp = (uint64_t*)pGpCol->pData; } blockDataCleanup(pDestBlock); - int32_t code = blockDataEnsureCapacity(pDestBlock, pSrcBlock->info.rows); - if (code != TSDB_CODE_SUCCESS) { - return code; - } + code = blockDataEnsureCapacity(pDestBlock, pSrcBlock->info.rows); + QUERY_CHECK_CODE(code, lino, _end); SColumnInfoData* pDestStartCol = taosArrayGet(pDestBlock->pDataBlock, START_TS_COLUMN_INDEX); SColumnInfoData* pDestEndCol = taosArrayGet(pDestBlock->pDataBlock, END_TS_COLUMN_INDEX); @@ -1730,19 +1893,32 @@ static int32_t generateSessionScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSr qError("generate session scan range failed. rang start:%" PRIx64 ", end:%" PRIx64, startData[i], endData[i]); continue; } - colDataSetVal(pDestStartCol, i, (const char*)&startWin.win.skey, false); - colDataSetVal(pDestEndCol, i, (const char*)&endWin.win.ekey, false); + code = colDataSetVal(pDestStartCol, i, (const char*)&startWin.win.skey, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = colDataSetVal(pDestEndCol, i, (const char*)&endWin.win.ekey, false); + QUERY_CHECK_CODE(code, lino, _end); colDataSetNULL(pDestUidCol, i); - colDataSetVal(pDestGpCol, i, (const char*)&groupId, false); + code = colDataSetVal(pDestGpCol, i, (const char*)&groupId, false); + QUERY_CHECK_CODE(code, lino, _end); + colDataSetNULL(pDestCalStartTsCol, i); colDataSetNULL(pDestCalEndTsCol, i); pDestBlock->info.rows++; } - 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 generateCountScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSrcBlock, SSDataBlock* pDestBlock, EStreamType mode) { +static int32_t generateCountScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSrcBlock, SSDataBlock* pDestBlock, + EStreamType mode) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; blockDataCleanup(pDestBlock); if (pSrcBlock->info.rows == 0) { return TSDB_CODE_SUCCESS; @@ -1757,23 +1933,23 @@ static int32_t generateCountScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSrcB SColumnInfoData* pGpCol = taosArrayGet(pSrcBlock->pDataBlock, GROUPID_COLUMN_INDEX); uint64_t* pSrcGp = (uint64_t*)pGpCol->pData; SColumnInfoData* pSrcPkCol = NULL; - if (taosArrayGetSize(pSrcBlock->pDataBlock) > PRIMARY_KEY_COLUMN_INDEX ) { + if (taosArrayGetSize(pSrcBlock->pDataBlock) > PRIMARY_KEY_COLUMN_INDEX) { pSrcPkCol = taosArrayGet(pSrcBlock->pDataBlock, PRIMARY_KEY_COLUMN_INDEX); } int64_t ver = pSrcBlock->info.version - 1; - if (pInfo->partitionSup.needCalc && ( startData[0] != endData[0] || (hasPrimaryKeyCol(pInfo) && mode == STREAM_DELETE_DATA) )) { - getPreVersionDataBlock(uidCol[0], startData[0], endData[0], ver, GET_TASKID(pTaskInfo), pInfo, pSrcBlock); + if (pInfo->partitionSup.needCalc && + (startData[0] != endData[0] || (hasPrimaryKeyCol(pInfo) && mode == STREAM_DELETE_DATA))) { + code = getPreVersionDataBlock(uidCol[0], startData[0], endData[0], ver, GET_TASKID(pTaskInfo), pInfo, pSrcBlock); + QUERY_CHECK_CODE(code, lino, _end); startData = (TSKEY*)pStartTsCol->pData; endData = (TSKEY*)pEndTsCol->pData; uidCol = (uint64_t*)pUidCol->pData; pSrcGp = (uint64_t*)pGpCol->pData; } - int32_t code = blockDataEnsureCapacity(pDestBlock, pSrcBlock->info.rows); - if (code != TSDB_CODE_SUCCESS) { - return code; - } + code = blockDataEnsureCapacity(pDestBlock, pSrcBlock->info.rows); + QUERY_CHECK_CODE(code, lino, _end); SColumnInfoData* pDestStartCol = taosArrayGet(pDestBlock->pDataBlock, START_TS_COLUMN_INDEX); SColumnInfoData* pDestEndCol = taosArrayGet(pDestBlock->pDataBlock, END_TS_COLUMN_INDEX); @@ -1793,19 +1969,36 @@ static int32_t generateCountScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSrcB SSessionKey startWin = {.win.skey = startData[i], .win.ekey = endData[i], .groupId = groupId}; SSessionKey range = {0}; getCountWinRange(pInfo->windowSup.pStreamAggSup, &startWin, mode, &range); - colDataSetVal(pDestStartCol, i, (const char*)&range.win.skey, false); - colDataSetVal(pDestEndCol, i, (const char*)&range.win.ekey, false); + code = colDataSetVal(pDestStartCol, i, (const char*)&range.win.skey, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = colDataSetVal(pDestEndCol, i, (const char*)&range.win.ekey, false); + QUERY_CHECK_CODE(code, lino, _end); colDataSetNULL(pDestUidCol, i); - colDataSetVal(pDestGpCol, i, (const char*)&groupId, false); - colDataSetVal(pDestCalStartTsCol, i, (const char*)&range.win.skey, false); - colDataSetVal(pDestCalEndTsCol, i, (const char*)&range.win.ekey, false); + code = colDataSetVal(pDestGpCol, i, (const char*)&groupId, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = colDataSetVal(pDestCalStartTsCol, i, (const char*)&range.win.skey, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = colDataSetVal(pDestCalEndTsCol, i, (const char*)&range.win.ekey, false); + QUERY_CHECK_CODE(code, lino, _end); + pDestBlock->info.rows++; } - 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 generateIntervalScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSrcBlock, SSDataBlock* pDestBlock, EStreamType mode) { +static int32_t generateIntervalScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSrcBlock, SSDataBlock* pDestBlock, + EStreamType mode) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; blockDataCleanup(pDestBlock); if (pSrcBlock->info.rows == 0) { return TSDB_CODE_SUCCESS; @@ -1816,7 +2009,7 @@ static int32_t generateIntervalScanRange(SStreamScanInfo* pInfo, SSDataBlock* pS SColumnInfoData* pSrcUidCol = taosArrayGet(pSrcBlock->pDataBlock, UID_COLUMN_INDEX); SColumnInfoData* pSrcGpCol = taosArrayGet(pSrcBlock->pDataBlock, GROUPID_COLUMN_INDEX); SColumnInfoData* pSrcPkCol = NULL; - if (taosArrayGetSize(pSrcBlock->pDataBlock) > PRIMARY_KEY_COLUMN_INDEX ) { + if (taosArrayGetSize(pSrcBlock->pDataBlock) > PRIMARY_KEY_COLUMN_INDEX) { pSrcPkCol = taosArrayGet(pSrcBlock->pDataBlock, PRIMARY_KEY_COLUMN_INDEX); } @@ -1826,18 +2019,20 @@ static int32_t generateIntervalScanRange(SStreamScanInfo* pInfo, SSDataBlock* pS TSKEY* srcEndTsCol = (TSKEY*)pSrcEndTsCol->pData; int64_t ver = pSrcBlock->info.version - 1; - if (pInfo->partitionSup.needCalc && ( srcStartTsCol[0] != srcEndTsCol[0] || (hasPrimaryKeyCol(pInfo) && mode == STREAM_DELETE_DATA) )) { - getPreVersionDataBlock(srcUidData[0], srcStartTsCol[0], srcEndTsCol[0], ver, GET_TASKID(pTaskInfo), pInfo, pSrcBlock); + if (pInfo->partitionSup.needCalc && + (srcStartTsCol[0] != srcEndTsCol[0] || (hasPrimaryKeyCol(pInfo) && mode == STREAM_DELETE_DATA))) { + code = getPreVersionDataBlock(srcUidData[0], srcStartTsCol[0], srcEndTsCol[0], ver, GET_TASKID(pTaskInfo), pInfo, + pSrcBlock); + QUERY_CHECK_CODE(code, lino, _end); + srcStartTsCol = (TSKEY*)pSrcStartTsCol->pData; srcEndTsCol = (TSKEY*)pSrcEndTsCol->pData; srcUidData = (uint64_t*)pSrcUidCol->pData; } uint64_t* srcGp = (uint64_t*)pSrcGpCol->pData; - int32_t code = blockDataEnsureCapacity(pDestBlock, pSrcBlock->info.rows); - if (code != TSDB_CODE_SUCCESS) { - return code; - } + code = blockDataEnsureCapacity(pDestBlock, pSrcBlock->info.rows); + QUERY_CHECK_CODE(code, lino, _end); SColumnInfoData* pStartTsCol = taosArrayGet(pDestBlock->pDataBlock, START_TS_COLUMN_INDEX); SColumnInfoData* pEndTsCol = taosArrayGet(pDestBlock->pDataBlock, END_TS_COLUMN_INDEX); @@ -1856,18 +2051,35 @@ static int32_t generateIntervalScanRange(SStreamScanInfo* pInfo, SSDataBlock* pS groupId = getGroupIdByData(pInfo, srcUid, srcStartTsCol[i], ver, pVal); } TSKEY calStartTs = srcStartTsCol[i]; - colDataSetVal(pCalStartTsCol, pDestBlock->info.rows, (const char*)(&calStartTs), false); + code = colDataSetVal(pCalStartTsCol, pDestBlock->info.rows, (const char*)(&calStartTs), false); + QUERY_CHECK_CODE(code, lino, _end); + STimeWindow win = getSlidingWindow(srcStartTsCol, srcEndTsCol, srcGp, &pInfo->interval, &pSrcBlock->info, &i, pInfo->partitionSup.needCalc); TSKEY calEndTs = srcStartTsCol[i - 1]; - colDataSetVal(pCalEndTsCol, pDestBlock->info.rows, (const char*)(&calEndTs), false); - colDataSetVal(pDeUidCol, pDestBlock->info.rows, (const char*)(&srcUid), false); - colDataSetVal(pStartTsCol, pDestBlock->info.rows, (const char*)(&win.skey), false); - colDataSetVal(pEndTsCol, pDestBlock->info.rows, (const char*)(&win.ekey), false); - colDataSetVal(pGpCol, pDestBlock->info.rows, (const char*)(&groupId), false); + code = colDataSetVal(pCalEndTsCol, pDestBlock->info.rows, (const char*)(&calEndTs), false); + QUERY_CHECK_CODE(code, lino, _end); + + code = colDataSetVal(pDeUidCol, pDestBlock->info.rows, (const char*)(&srcUid), false); + QUERY_CHECK_CODE(code, lino, _end); + + code = colDataSetVal(pStartTsCol, pDestBlock->info.rows, (const char*)(&win.skey), false); + QUERY_CHECK_CODE(code, lino, _end); + + code = colDataSetVal(pEndTsCol, pDestBlock->info.rows, (const char*)(&win.ekey), false); + QUERY_CHECK_CODE(code, lino, _end); + + code = colDataSetVal(pGpCol, pDestBlock->info.rows, (const char*)(&groupId), false); + QUERY_CHECK_CODE(code, lino, _end); + pDestBlock->info.rows++; } - 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 calBlockTbName(SStreamScanInfo* pInfo, SSDataBlock* pBlock, int32_t rowId) { @@ -1880,7 +2092,7 @@ static int32_t calBlockTbName(SStreamScanInfo* pInfo, SSDataBlock* pBlock, int32 code = appendCreateTableRow(pInfo->pStreamScanOp->pTaskInfo->streamInfo.pState, &pInfo->tbnameCalSup, &pInfo->tagCalSup, pBlock->info.id.groupId, pBlock, rowId, pInfo->pCreateTbRes, &pInfo->stateStore); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } _end: @@ -1909,7 +2121,8 @@ static int32_t generatePartitionDelResBlock(SStreamScanInfo* pInfo, SSDataBlock* uint64_t srcUid = srcUidData[delI]; char tbname[VARSTR_HEADER_SIZE + TSDB_TABLE_NAME_LEN] = {0}; SSDataBlock* pPreRes = readPreVersionData(pInfo->pTableScanOp, srcUid, srcStartTsCol[delI], srcEndTsCol[delI], ver); - blockDataEnsureCapacity(pDestBlock, pDestBlock->info.rows + pPreRes->info.rows); + code = blockDataEnsureCapacity(pDestBlock, pDestBlock->info.rows + pPreRes->info.rows); + QUERY_CHECK_CODE(code, lino, _end); for (int32_t preJ = 0; preJ < pPreRes->info.rows; preJ++) { groupId = calGroupIdByData(&pInfo->partitionSup, pInfo->pPartScalarSup, pPreRes, preJ); if (pInfo->pPartTbnameSup) { @@ -1917,10 +2130,11 @@ static int32_t generatePartitionDelResBlock(SStreamScanInfo* pInfo, SSDataBlock* int32_t winCode = TSDB_CODE_SUCCESS; code = pInfo->stateStore.streamStateGetParName(pInfo->pStreamScanOp->pTaskInfo->streamInfo.pState, groupId, &parTbname, false, &winCode); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (winCode != TSDB_CODE_SUCCESS) { - calBlockTbName(pInfo, pPreRes, preJ); + code = calBlockTbName(pInfo, pPreRes, preJ); + QUERY_CHECK_CODE(code, lino, _end); memcpy(varDataVal(tbname), pPreRes->info.parTbName, strlen(pPreRes->info.parTbName)); } else { memcpy(varDataVal(tbname), parTbname, TSDB_TABLE_NAME_LEN); @@ -1928,8 +2142,9 @@ static int32_t generatePartitionDelResBlock(SStreamScanInfo* pInfo, SSDataBlock* varDataSetLen(tbname, strlen(varDataVal(tbname))); pInfo->stateStore.streamStateFreeVal(parTbname); } - appendDataToSpecialBlock(pDestBlock, srcStartTsCol + delI, srcEndTsCol + delI, srcUidData + delI, &groupId, - tbname[0] == 0 ? NULL : tbname); + code = appendDataToSpecialBlock(pDestBlock, srcStartTsCol + delI, srcEndTsCol + delI, srcUidData + delI, &groupId, + tbname[0] == 0 ? NULL : tbname); + QUERY_CHECK_CODE(code, lino, _end); } } @@ -1941,8 +2156,8 @@ _end: } static int32_t generateDeleteResultBlockImpl(SStreamScanInfo* pInfo, SSDataBlock* pSrcBlock, SSDataBlock* pDestBlock) { - int32_t code = TSDB_CODE_SUCCESS; -int32_t lino = 0; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SColumnInfoData* pSrcStartTsCol = (SColumnInfoData*)taosArrayGet(pSrcBlock->pDataBlock, START_TS_COLUMN_INDEX); SColumnInfoData* pSrcEndTsCol = (SColumnInfoData*)taosArrayGet(pSrcBlock->pDataBlock, END_TS_COLUMN_INDEX); SColumnInfoData* pSrcUidCol = taosArrayGet(pSrcBlock->pDataBlock, UID_COLUMN_INDEX); @@ -1950,7 +2165,7 @@ int32_t lino = 0; SColumnInfoData* pSrcGpCol = taosArrayGet(pSrcBlock->pDataBlock, GROUPID_COLUMN_INDEX); uint64_t* srcGp = (uint64_t*)pSrcGpCol->pData; SColumnInfoData* pSrcPkCol = NULL; - if (taosArrayGetSize(pSrcBlock->pDataBlock) > PRIMARY_KEY_COLUMN_INDEX ) { + if (taosArrayGetSize(pSrcBlock->pDataBlock) > PRIMARY_KEY_COLUMN_INDEX) { pSrcPkCol = taosArrayGet(pSrcBlock->pDataBlock, PRIMARY_KEY_COLUMN_INDEX); } @@ -1970,15 +2185,17 @@ int32_t lino = 0; groupId = getGroupIdByData(pInfo, srcUid, srcStartTsCol[i], ver, pVal); } if (pInfo->tbnameCalSup.pExprInfo) { - void* parTbname = NULL; + void* parTbname = NULL; int32_t winCode = TSDB_CODE_SUCCESS; - code = pInfo->stateStore.streamStateGetParName(pInfo->pStreamScanOp->pTaskInfo->streamInfo.pState, groupId, &parTbname, false, &winCode); - TSDB_CHECK_CODE(code, lino, _end); + code = pInfo->stateStore.streamStateGetParName(pInfo->pStreamScanOp->pTaskInfo->streamInfo.pState, groupId, + &parTbname, false, &winCode); + QUERY_CHECK_CODE(code, lino, _end); if (winCode != TSDB_CODE_SUCCESS) { SSDataBlock* pPreRes = readPreVersionData(pInfo->pTableScanOp, srcUid, srcStartTsCol[i], srcStartTsCol[i], ver); printDataBlock(pPreRes, "pre res", GET_TASKID(pInfo->pStreamScanOp->pTaskInfo)); - calBlockTbName(pInfo, pPreRes, 0); + code = calBlockTbName(pInfo, pPreRes, 0); + QUERY_CHECK_CODE(code, lino, _end); memcpy(varDataVal(tbname), pPreRes->info.parTbName, strlen(pPreRes->info.parTbName)); } else { memcpy(varDataVal(tbname), parTbname, TSDB_TABLE_NAME_LEN); @@ -1986,8 +2203,9 @@ int32_t lino = 0; varDataSetLen(tbname, strlen(varDataVal(tbname))); pInfo->stateStore.streamStateFreeVal(parTbname); } - appendDataToSpecialBlock(pDestBlock, srcStartTsCol + i, srcEndTsCol + i, srcUidData + i, &groupId, - tbname[0] == 0 ? NULL : tbname); + code = appendDataToSpecialBlock(pDestBlock, srcStartTsCol + i, srcEndTsCol + i, srcUidData + i, &groupId, + tbname[0] == 0 ? NULL : tbname); + QUERY_CHECK_CODE(code, lino, _end); } _end: @@ -2013,30 +2231,43 @@ static int32_t generateDeleteResultBlock(SStreamScanInfo* pInfo, SSDataBlock* pS return generateDeleteResultBlockImpl(pInfo, pSrcBlock, pDestBlock); } -static int32_t generateScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSrcBlock, SSDataBlock* pDestBlock, EStreamType type) { +static int32_t generateScanRange(SStreamScanInfo* pInfo, SSDataBlock* pSrcBlock, SSDataBlock* pDestBlock, + EStreamType type) { int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (isIntervalWindow(pInfo)) { code = generateIntervalScanRange(pInfo, pSrcBlock, pDestBlock, type); + QUERY_CHECK_CODE(code, lino, _end); } else if (isSessionWindow(pInfo) || isStateWindow(pInfo)) { code = generateSessionScanRange(pInfo, pSrcBlock, pDestBlock, type); + QUERY_CHECK_CODE(code, lino, _end); } else if (isCountWindow(pInfo)) { code = generateCountScanRange(pInfo, pSrcBlock, pDestBlock, type); + QUERY_CHECK_CODE(code, lino, _end); } else { code = generateDeleteResultBlock(pInfo, pSrcBlock, pDestBlock); + QUERY_CHECK_CODE(code, lino, _end); } pDestBlock->info.type = STREAM_CLEAR; pDestBlock->info.version = pSrcBlock->info.version; pDestBlock->info.dataLoad = 1; - blockDataUpdateTsWindow(pDestBlock, 0); + code = blockDataUpdateTsWindow(pDestBlock, 0); + QUERY_CHECK_CODE(code, lino, _end); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } return code; } -void appendDataToSpecialBlock(SSDataBlock* pBlock, TSKEY* pStartTs, TSKEY* pEndTs, uint64_t* pUid, uint64_t* pGp, - void* pTbName) { - appendOneRowToSpecialBlockImpl(pBlock, pStartTs, pEndTs, pStartTs, pEndTs, pUid, pGp, pTbName, NULL); +int32_t appendDataToSpecialBlock(SSDataBlock* pBlock, TSKEY* pStartTs, TSKEY* pEndTs, uint64_t* pUid, uint64_t* pGp, + void* pTbName) { + return appendOneRowToSpecialBlockImpl(pBlock, pStartTs, pEndTs, pStartTs, pEndTs, pUid, pGp, pTbName, NULL); } -bool checkExpiredData(SStateStore* pAPI, SUpdateInfo* pUpdateInfo, STimeWindowAggSupp* pTwSup, uint64_t tableId, TSKEY ts, void* pPkVal, int32_t len) { +bool checkExpiredData(SStateStore* pAPI, SUpdateInfo* pUpdateInfo, STimeWindowAggSupp* pTwSup, uint64_t tableId, + TSKEY ts, void* pPkVal, int32_t len) { bool isExpired = false; bool isInc = pAPI->isIncrementalTimeStamp(pUpdateInfo, tableId, ts, pPkVal, len); if (!isInc) { @@ -2045,20 +2276,23 @@ bool checkExpiredData(SStateStore* pAPI, SUpdateInfo* pUpdateInfo, STimeWindowAg return isExpired; } -static void checkUpdateData(SStreamScanInfo* pInfo, bool invertible, SSDataBlock* pBlock, bool out) { +static int32_t checkUpdateData(SStreamScanInfo* pInfo, bool invertible, SSDataBlock* pBlock, bool out) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (out) { blockDataCleanup(pInfo->pUpdateDataRes); - blockDataEnsureCapacity(pInfo->pUpdateDataRes, pBlock->info.rows * 2); + code = blockDataEnsureCapacity(pInfo->pUpdateDataRes, pBlock->info.rows * 2); + QUERY_CHECK_CODE(code, lino, _end); } SColumnInfoData* pColDataInfo = taosArrayGet(pBlock->pDataBlock, pInfo->primaryTsIndex); ASSERT(pColDataInfo->info.type == TSDB_DATA_TYPE_TIMESTAMP); - TSKEY* tsCol = (TSKEY*)pColDataInfo->pData; + TSKEY* tsCol = (TSKEY*)pColDataInfo->pData; SColumnInfoData* pPkColDataInfo = NULL; if (hasPrimaryKeyCol(pInfo)) { pPkColDataInfo = taosArrayGet(pBlock->pDataBlock, pInfo->primaryKeyIndex); } - bool tableInserted = pInfo->stateStore.updateInfoIsTableInserted(pInfo->pUpdateInfo, pBlock->info.id.uid); + bool tableInserted = pInfo->stateStore.updateInfoIsTableInserted(pInfo->pUpdateInfo, pBlock->info.id.uid); for (int32_t rowId = 0; rowId < pBlock->info.rows; rowId++) { SResultRowInfo dumyInfo; dumyInfo.cur.pageId = -1; @@ -2074,31 +2308,44 @@ static void checkUpdateData(SStreamScanInfo* pInfo, bool invertible, SSDataBlock isClosed = isCloseWindow(&win, &pInfo->twAggSup); } // must check update info first. - void* pPkVal = NULL; + void* pPkVal = NULL; int32_t pkLen = 0; if (hasPrimaryKeyCol(pInfo)) { pPkVal = colDataGetData(pPkColDataInfo, rowId); pkLen = colDataGetRowLength(pPkColDataInfo, rowId); } - bool update = pInfo->stateStore.updateInfoIsUpdated(pInfo->pUpdateInfo, pBlock->info.id.uid, tsCol[rowId], pPkVal, pkLen); - bool isDeleted = isClosed && isSignleIntervalWindow(pInfo) && - isDeletedStreamWindow(&win, pBlock->info.id.groupId, pInfo->pState, &pInfo->twAggSup, &pInfo->stateStore); + bool update = + pInfo->stateStore.updateInfoIsUpdated(pInfo->pUpdateInfo, pBlock->info.id.uid, tsCol[rowId], pPkVal, pkLen); + bool isDeleted = + isClosed && isSignleIntervalWindow(pInfo) && + isDeletedStreamWindow(&win, pBlock->info.id.groupId, pInfo->pState, &pInfo->twAggSup, &pInfo->stateStore); if ((update || isDeleted) && out) { qDebug("stream update check not pass, update %d, deleted Win %d", update, isDeleted); uint64_t gpId = 0; - appendPkToSpecialBlock(pInfo->pUpdateDataRes, tsCol, pPkColDataInfo, rowId, &pBlock->info.id.uid, &gpId, NULL); + code = appendPkToSpecialBlock(pInfo->pUpdateDataRes, tsCol, pPkColDataInfo, rowId, &pBlock->info.id.uid, &gpId, + NULL); + QUERY_CHECK_CODE(code, lino, _end); if (isDeleted && pInfo->partitionSup.needCalc) { gpId = calGroupIdByData(&pInfo->partitionSup, pInfo->pPartScalarSup, pBlock, rowId); - appendPkToSpecialBlock(pInfo->pUpdateDataRes, tsCol, pPkColDataInfo, rowId, &pBlock->info.id.uid, &gpId, NULL); + code = appendPkToSpecialBlock(pInfo->pUpdateDataRes, tsCol, pPkColDataInfo, rowId, &pBlock->info.id.uid, &gpId, + NULL); + QUERY_CHECK_CODE(code, lino, _end); } } } if (out && pInfo->pUpdateDataRes->info.rows > 0) { pInfo->pUpdateDataRes->info.version = pBlock->info.version; pInfo->pUpdateDataRes->info.dataLoad = 1; - blockDataUpdateTsWindow(pInfo->pUpdateDataRes, 0); + code = blockDataUpdateTsWindow(pInfo->pUpdateDataRes, 0); + QUERY_CHECK_CODE(code, lino, _end); pInfo->pUpdateDataRes->info.type = pInfo->partitionSup.needCalc ? STREAM_DELETE_DATA : STREAM_CLEAR; } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static void doBlockDataWindowFilter(SSDataBlock* pBlock, int32_t tsIndex, STimeWindow* pWindow, const char* id) { @@ -2140,8 +2387,8 @@ static void doBlockDataWindowFilter(SSDataBlock* pBlock, int32_t tsIndex, STimeW } } -static void doBlockDataPrimaryKeyFilter(SSDataBlock* pBlock, STqOffsetVal *offset) { - if(pBlock->info.window.skey != offset->ts || offset->primaryKey.type == 0){ +static void doBlockDataPrimaryKeyFilter(SSDataBlock* pBlock, STqOffsetVal* offset) { + if (pBlock->info.window.skey != offset->ts || offset->primaryKey.type == 0) { return; } bool* p = taosMemoryCalloc(pBlock->info.rows, sizeof(bool)); @@ -2150,20 +2397,20 @@ static void doBlockDataPrimaryKeyFilter(SSDataBlock* pBlock, STqOffsetVal *offse SColumnInfoData* pColTs = taosArrayGet(pBlock->pDataBlock, 0); SColumnInfoData* pColPk = taosArrayGet(pBlock->pDataBlock, 1); - qDebug("doBlockDataWindowFilter primary key, ts:%" PRId64 " %"PRId64, offset->ts, offset->primaryKey.val); + qDebug("doBlockDataWindowFilter primary key, ts:%" PRId64 " %" PRId64, offset->ts, offset->primaryKey.val); ASSERT(pColPk->info.type == offset->primaryKey.type); __compar_fn_t func = getComparFunc(pColPk->info.type, 0); for (int32_t i = 0; i < pBlock->info.rows; ++i) { int64_t* ts = (int64_t*)colDataGetData(pColTs, i); - void *data = colDataGetData(pColPk, i); - if(IS_VAR_DATA_TYPE(pColPk->info.type)){ - void *tmq = taosMemoryMalloc(offset->primaryKey.nData + VARSTR_HEADER_SIZE); + void* data = colDataGetData(pColPk, i); + if (IS_VAR_DATA_TYPE(pColPk->info.type)) { + void* tmq = taosMemoryMalloc(offset->primaryKey.nData + VARSTR_HEADER_SIZE); memcpy(varDataVal(tmq), offset->primaryKey.pData, offset->primaryKey.nData); varDataLen(tmq) = offset->primaryKey.nData; p[i] = (*ts > offset->ts) || (func(data, tmq) > 0); taosMemoryFree(tmq); - }else{ + } else { p[i] = (*ts > offset->ts) || (func(data, &offset->primaryKey.val) > 0); } @@ -2205,7 +2452,7 @@ static void rebuildDeleteBlockData(SSDataBlock* pBlock, STimeWindow* pWindow, co } } } else if (pWindow->ekey != INT64_MAX) { - for(int32_t i = 0; i < numOfRows; ++i) { + for (int32_t i = 0; i < numOfRows; ++i) { if (tsEndCol[i] > ekey) { tsEndCol[i] = ekey; } @@ -2220,7 +2467,8 @@ static void rebuildDeleteBlockData(SSDataBlock* pBlock, STimeWindow* pWindow, co if (hasUnqualified) { trimDataBlock(pBlock, pBlock->info.rows, p); - qDebug("%s re-build delete datablock, start key revised to:%"PRId64", rows:%"PRId64, id, skey, pBlock->info.rows); + qDebug("%s re-build delete datablock, start key revised to:%" PRId64 ", rows:%" PRId64, id, skey, + pBlock->info.rows); } else { qDebug("%s not update the delete block", id); } @@ -2228,24 +2476,28 @@ static void rebuildDeleteBlockData(SSDataBlock* pBlock, STimeWindow* pWindow, co taosMemoryFree(p); } -static int32_t colIdComparFn(const void* param1, const void * param2) { - int32_t p1 = *(int32_t*) param1; - int32_t p2 = *(int32_t*) param2; +static int32_t colIdComparFn(const void* param1, const void* param2) { + int32_t p1 = *(int32_t*)param1; + int32_t p2 = *(int32_t*)param2; if (p1 == p2) { return 0; } else { - return (p1 < p2)? -1:1; + return (p1 < p2) ? -1 : 1; } } -static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock, STimeWindow* pTimeWindow, bool filter) { +static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock, STimeWindow* pTimeWindow, + bool filter) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SDataBlockInfo* pBlockInfo = &pInfo->pRes->info; SOperatorInfo* pOperator = pInfo->pStreamScanOp; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; const char* id = GET_TASKID(pTaskInfo); - blockDataEnsureCapacity(pInfo->pRes, pBlock->info.rows); + code = blockDataEnsureCapacity(pInfo->pRes, pBlock->info.rows); + QUERY_CHECK_CODE(code, lino, _end); pBlockInfo->rows = pBlock->info.rows; pBlockInfo->id.uid = pBlock->info.id.uid; @@ -2256,6 +2508,7 @@ static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock pBlockInfo->id.groupId = tableListGetTableGroupId(pTableScanInfo->base.pTableListInfo, pBlock->info.id.uid); SArray* pColList = taosArrayInit(4, sizeof(int32_t)); + QUERY_CHECK_NULL(pColList, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); // todo extract method for (int32_t i = 0; i < taosArrayGetSize(pInfo->matchInfo.pList); ++i) { @@ -2269,9 +2522,12 @@ static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock SColumnInfoData* pResCol = bdGetColumnInfoData(pBlock, j); if (pResCol->info.colId == pColMatchInfo->colId) { SColumnInfoData* pDst = taosArrayGet(pInfo->pRes->pDataBlock, pColMatchInfo->dstSlotId); - colDataAssign(pDst, pResCol, pBlock->info.rows, &pInfo->pRes->info); + code = colDataAssign(pDst, pResCol, pBlock->info.rows, &pInfo->pRes->info); + QUERY_CHECK_CODE(code, lino, _end); + colExists = true; - taosArrayPush(pColList, &pColMatchInfo->dstSlotId); + void* tmp = taosArrayPush(pColList, &pColMatchInfo->dstSlotId); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); break; } } @@ -2280,16 +2536,17 @@ static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock if (!colExists) { SColumnInfoData* pDst = taosArrayGet(pInfo->pRes->pDataBlock, pColMatchInfo->dstSlotId); colDataSetNNULL(pDst, 0, pBlockInfo->rows); - taosArrayPush(pColList, &pColMatchInfo->dstSlotId); + void* tmp = taosArrayPush(pColList, &pColMatchInfo->dstSlotId); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } } // currently only the tbname pseudo column if (pInfo->numOfPseudoExpr > 0) { - int32_t code = addTagPseudoColumnData(&pInfo->readHandle, pInfo->pPseudoExpr, pInfo->numOfPseudoExpr, pInfo->pRes, - pBlockInfo->rows, pTaskInfo, &pTableScanInfo->base.metaCache); + int32_t tmpCode = addTagPseudoColumnData(&pInfo->readHandle, pInfo->pPseudoExpr, pInfo->numOfPseudoExpr, + pInfo->pRes, pBlockInfo->rows, pTaskInfo, &pTableScanInfo->base.metaCache); // ignore the table not exists error, since this table may have been dropped during the scan procedure. - if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_PAR_TABLE_NOT_EXIST) { + if (tmpCode != TSDB_CODE_SUCCESS && tmpCode != TSDB_CODE_PAR_TABLE_NOT_EXIST) { blockDataFreeRes((SSDataBlock*)pBlock); T_LONG_JMP(pTaskInfo->env, code); } @@ -2297,15 +2554,16 @@ static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock // reset the error code. terrno = 0; - for(int32_t i = 0; i < pInfo->numOfPseudoExpr; ++i) { - taosArrayPush(pColList, &pInfo->pPseudoExpr[i].base.resSchema.slotId); + for (int32_t i = 0; i < pInfo->numOfPseudoExpr; ++i) { + void* tmp = taosArrayPush(pColList, &pInfo->pPseudoExpr[i].base.resSchema.slotId); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } } taosArraySort(pColList, colIdComparFn); int32_t i = 0, j = 0; - while(i < taosArrayGetSize(pColList)) { + while (i < taosArrayGetSize(pColList)) { int32_t slot1 = *(int32_t*)taosArrayGet(pColList, i); if (slot1 > j) { SColumnInfoData* pDst = taosArrayGet(pInfo->pRes->pDataBlock, j); @@ -2317,7 +2575,7 @@ static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock } } - while(j < taosArrayGetSize(pInfo->pRes->pDataBlock)) { + while (j < taosArrayGetSize(pInfo->pRes->pDataBlock)) { SColumnInfoData* pDst = taosArrayGet(pInfo->pRes->pDataBlock, j); colDataSetNNULL(pDst, 0, pBlockInfo->rows); j += 1; @@ -2326,30 +2584,38 @@ static int32_t setBlockIntoRes(SStreamScanInfo* pInfo, const SSDataBlock* pBlock taosArrayDestroy(pColList); if (filter) { - doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); } // filter the block extracted from WAL files, according to the time window apply additional time window filter doBlockDataWindowFilter(pInfo->pRes, pInfo->primaryTsIndex, pTimeWindow, id); pInfo->pRes->info.dataLoad = 1; - blockDataUpdateTsWindow(pInfo->pRes, pInfo->primaryTsIndex); + code = blockDataUpdateTsWindow(pInfo->pRes, pInfo->primaryTsIndex); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->pRes->info.rows == 0) { return 0; } - calBlockTbName(pInfo, pInfo->pRes, 0); - return 0; + code = calBlockTbName(pInfo, pInfo->pRes, 0); + QUERY_CHECK_CODE(code, lino, _end); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } -static void processPrimaryKey(SSDataBlock* pBlock, bool hasPrimaryKey, STqOffsetVal *offset){ +static void processPrimaryKey(SSDataBlock* pBlock, bool hasPrimaryKey, STqOffsetVal* offset) { SValue val = {0}; - if (hasPrimaryKey){ + if (hasPrimaryKey) { doBlockDataPrimaryKeyFilter(pBlock, offset); SColumnInfoData* pColPk = taosArrayGet(pBlock->pDataBlock, 1); if (pBlock->info.rows < 1) { - return ; + return; } void* tmp = colDataGetData(pColPk, pBlock->info.rows - 1); val.type = pColPk->info.type; @@ -2365,6 +2631,8 @@ static void processPrimaryKey(SSDataBlock* pBlock, bool hasPrimaryKey, STqOffset } static SSDataBlock* doQueueScan(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; @@ -2407,11 +2675,11 @@ static SSDataBlock* doQueueScan(SOperatorInfo* pOperator) { } if (pTaskInfo->streamInfo.currentOffset.type == TMQ_OFFSET__LOG) { - while (1) { - bool hasResult = pAPI->tqReaderFn.tqReaderNextBlockInWal(pInfo->tqReader, id, pTaskInfo->streamInfo.sourceExcluded); + bool hasResult = + pAPI->tqReaderFn.tqReaderNextBlockInWal(pInfo->tqReader, id, pTaskInfo->streamInfo.sourceExcluded); - SSDataBlock* pRes = pAPI->tqReaderFn.tqGetResultBlock(pInfo->tqReader); + SSDataBlock* pRes = pAPI->tqReaderFn.tqGetResultBlock(pInfo->tqReader); struct SWalReader* pWalReader = pAPI->tqReaderFn.tqReaderGetWalReader(pInfo->tqReader); // curVersion move to next @@ -2425,7 +2693,8 @@ static SSDataBlock* doQueueScan(SOperatorInfo* pOperator) { pTaskInfo->streamInfo.currentOffset.version); blockDataCleanup(pInfo->pRes); STimeWindow defaultWindow = {.skey = INT64_MIN, .ekey = INT64_MAX}; - setBlockIntoRes(pInfo, pRes, &defaultWindow, true); + code = setBlockIntoRes(pInfo, pRes, &defaultWindow, true); + QUERY_CHECK_CODE(code, lino, _end); qDebug("doQueueScan after filter get data from log %" PRId64 " rows, version:%" PRId64, pInfo->pRes->info.rows, pTaskInfo->streamInfo.currentOffset.version); if (pInfo->pRes->info.rows > 0) { @@ -2440,12 +2709,21 @@ static SSDataBlock* doQueueScan(SOperatorInfo* pOperator) { qError("unexpected streamInfo prepare type: %d", pTaskInfo->streamInfo.currentOffset.type); return NULL; } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return NULL; } static int32_t filterDelBlockByUid(SSDataBlock* pDst, const SSDataBlock* pSrc, SStreamScanInfo* pInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; STqReader* pReader = pInfo->tqReader; int32_t rows = pSrc->info.rows; - blockDataEnsureCapacity(pDst, rows); + code = blockDataEnsureCapacity(pDst, rows); + QUERY_CHECK_CODE(code, lino, _end); SColumnInfoData* pSrcStartCol = taosArrayGet(pSrc->pDataBlock, START_TS_COLUMN_INDEX); uint64_t* startCol = (uint64_t*)pSrcStartCol->pData; @@ -2461,9 +2739,14 @@ static int32_t filterDelBlockByUid(SSDataBlock* pDst, const SSDataBlock* pSrc, S int32_t j = 0; for (int32_t i = 0; i < rows; i++) { if (pInfo->readerFn.tqReaderIsQueriedTable(pReader, uidCol[i])) { - colDataSetVal(pDstStartCol, j, (const char*)&startCol[i], false); - colDataSetVal(pDstEndCol, j, (const char*)&endCol[i], false); - colDataSetVal(pDstUidCol, j, (const char*)&uidCol[i], false); + code = colDataSetVal(pDstStartCol, j, (const char*)&startCol[i], false); + QUERY_CHECK_CODE(code, lino, _end); + + code = colDataSetVal(pDstEndCol, j, (const char*)&endCol[i], false); + QUERY_CHECK_CODE(code, lino, _end); + + code = colDataSetVal(pDstUidCol, j, (const char*)&uidCol[i], false); + QUERY_CHECK_CODE(code, lino, _end); colDataSetNULL(taosArrayGet(pDst->pDataBlock, GROUPID_COLUMN_INDEX), j); colDataSetNULL(taosArrayGet(pDst->pDataBlock, CALCULATE_START_TS_COLUMN_INDEX), j); @@ -2477,11 +2760,17 @@ static int32_t filterDelBlockByUid(SSDataBlock* pDst, const SSDataBlock* pSrc, S pDst->info.rows = j; pDst->info.capacity = cap; - return 0; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } // for partition by tag -static void setBlockGroupIdByUid(SStreamScanInfo* pInfo, SSDataBlock* pBlock) { +static int32_t setBlockGroupIdByUid(SStreamScanInfo* pInfo, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SColumnInfoData* pStartTsCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX); TSKEY* startTsCol = (TSKEY*)pStartTsCol->pData; SColumnInfoData* pGpCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX); @@ -2492,17 +2781,27 @@ static void setBlockGroupIdByUid(SStreamScanInfo* pInfo, SSDataBlock* pBlock) { if (!pInfo->partitionSup.needCalc) { for (int32_t i = 0; i < rows; i++) { uint64_t groupId = getGroupIdByUid(pInfo, uidCol[i]); - colDataSetVal(pGpCol, i, (const char*)&groupId, false); + code = colDataSetVal(pGpCol, i, (const char*)&groupId, 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 void doCheckUpdate(SStreamScanInfo* pInfo, TSKEY endKey, SSDataBlock* pBlock) { +static int32_t doCheckUpdate(SStreamScanInfo* pInfo, TSKEY endKey, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pInfo->pUpdateInfo) { pInfo->pUpdateInfo->maxDataVersion = TMAX(pInfo->pUpdateInfo->maxDataVersion, pBlock->info.version); } if (!pInfo->igCheckUpdate && pInfo->pUpdateInfo) { - checkUpdateData(pInfo, true, pBlock, true); + code = checkUpdateData(pInfo, true, pBlock, true); + QUERY_CHECK_CODE(code, lino, _end); pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, endKey); if (pInfo->pUpdateDataRes->info.rows > 0) { pInfo->updateResIndex = 0; @@ -2516,6 +2815,12 @@ static void doCheckUpdate(SStreamScanInfo* pInfo, TSKEY endKey, SSDataBlock* pBl } } } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } int32_t streamScanOperatorEncode(SStreamScanInfo* pInfo, void** pBuff, int32_t* pLen) { @@ -2523,19 +2828,20 @@ int32_t streamScanOperatorEncode(SStreamScanInfo* pInfo, void** pBuff, int32_t* int32_t lino = 0; int32_t len = 0; code = pInfo->stateStore.updateInfoSerialize(NULL, 0, pInfo->pUpdateInfo, &len); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); len += encodeSTimeWindowAggSupp(NULL, &pInfo->twAggSup); *pBuff = taosMemoryCalloc(1, len); if (!(*pBuff)) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } void* buf = *pBuff; - encodeSTimeWindowAggSupp(&buf, &pInfo->twAggSup); + (void)encodeSTimeWindowAggSupp(&buf, &pInfo->twAggSup); + int32_t tmp = 0; code = pInfo->stateStore.updateInfoSerialize(buf, len, pInfo->pUpdateInfo, &tmp); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); *pLen = len; @@ -2553,11 +2859,12 @@ void streamScanOperatorSaveCheckpoint(SStreamScanInfo* pInfo) { return; } if (needSaveStreamOperatorInfo(&pInfo->basic)) { - void* pBuf = NULL; + void* pBuf = NULL; int32_t len = 0; code = streamScanOperatorEncode(pInfo, &pBuf, &len); - TSDB_CHECK_CODE(code, lino, _end); - pInfo->stateStore.streamStateSaveInfo(pInfo->pState, STREAM_SCAN_OP_CHECKPOINT_NAME, strlen(STREAM_SCAN_OP_CHECKPOINT_NAME), pBuf, len); + QUERY_CHECK_CODE(code, lino, _end); + pInfo->stateStore.streamStateSaveInfo(pInfo->pState, STREAM_SCAN_OP_CHECKPOINT_NAME, + strlen(STREAM_SCAN_OP_CHECKPOINT_NAME), pBuf, len); taosMemoryFree(pBuf); saveStreamOperatorStateComplete(&pInfo->basic); } @@ -2580,7 +2887,7 @@ void streamScanOperatorDecode(void* pBuff, int32_t len, SStreamScanInfo* pInfo) return; } - void* pUpInfo = taosMemoryCalloc(1, sizeof(SUpdateInfo)); + void* pUpInfo = taosMemoryCalloc(1, sizeof(SUpdateInfo)); int32_t code = pInfo->stateStore.updateInfoDeserialize(buf, tlen, pUpInfo); if (code == TSDB_CODE_SUCCESS) { pInfo->stateStore.updateInfoDestroy(pInfo->pUpdateInfo); @@ -2600,8 +2907,8 @@ static bool isStreamWindow(SStreamScanInfo* pInfo) { static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) { // NOTE: this operator does never check if current status is done or not - int32_t code = TSDB_CODE_SUCCESS; - int32_t lino = 0; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; const char* id = GET_TASKID(pTaskInfo); @@ -2611,7 +2918,8 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) { qDebug("stream scan started, %s", id); - if (pStreamInfo->recoverStep == STREAM_RECOVER_STEP__PREPARE1 || pStreamInfo->recoverStep == STREAM_RECOVER_STEP__PREPARE2) { + if (pStreamInfo->recoverStep == STREAM_RECOVER_STEP__PREPARE1 || + pStreamInfo->recoverStep == STREAM_RECOVER_STEP__PREPARE2) { STableScanInfo* pTSInfo = pInfo->pTableScanOp->info; memcpy(&pTSInfo->base.cond, &pStreamInfo->tableCond, sizeof(SQueryTableDataCond)); @@ -2620,8 +2928,9 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) { pTSInfo->base.cond.endVersion = pStreamInfo->fillHistoryVer.maxVer; pTSInfo->base.cond.twindows = pStreamInfo->fillHistoryWindow; - qDebug("stream scan step1, verRange:%" PRId64 "-%" PRId64 " window:%"PRId64"-%"PRId64", %s", pTSInfo->base.cond.startVersion, - pTSInfo->base.cond.endVersion, pTSInfo->base.cond.twindows.skey, pTSInfo->base.cond.twindows.ekey, id); + qDebug("stream scan step1, verRange:%" PRId64 "-%" PRId64 " window:%" PRId64 "-%" PRId64 ", %s", + pTSInfo->base.cond.startVersion, pTSInfo->base.cond.endVersion, pTSInfo->base.cond.twindows.skey, + pTSInfo->base.cond.twindows.ekey, id); pStreamInfo->recoverStep = STREAM_RECOVER_STEP__SCAN1; pStreamInfo->recoverScanFinished = false; } else { @@ -2652,7 +2961,8 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) { switch (pInfo->scanMode) { case STREAM_SCAN_FROM_RES: { pInfo->scanMode = STREAM_SCAN_FROM_READERHANDLE; - printSpecDataBlock(pInfo->pRecoverRes, getStreamOpName(pOperator->operatorType), "recover", GET_TASKID(pTaskInfo)); + printSpecDataBlock(pInfo->pRecoverRes, getStreamOpName(pOperator->operatorType), "recover", + GET_TASKID(pTaskInfo)); return pInfo->pRecoverRes; } break; default: @@ -2661,20 +2971,25 @@ static SSDataBlock* doStreamScan(SOperatorInfo* pOperator) { pInfo->pRecoverRes = doTableScan(pInfo->pTableScanOp); if (pInfo->pRecoverRes != NULL) { - calBlockTbName(pInfo, pInfo->pRecoverRes, 0); + code = calBlockTbName(pInfo, pInfo->pRecoverRes, 0); + QUERY_CHECK_CODE(code, lino, _end); if (!pInfo->igCheckUpdate && pInfo->pUpdateInfo) { TSKEY maxTs = INT64_MIN; - pAPI->stateStore.updateInfoFillBlockData(pInfo->pUpdateInfo, pInfo->pRecoverRes, pInfo->primaryTsIndex, pInfo->primaryKeyIndex, &maxTs); + code = pAPI->stateStore.updateInfoFillBlockData(pInfo->pUpdateInfo, pInfo->pRecoverRes, pInfo->primaryTsIndex, + pInfo->primaryKeyIndex, &maxTs); + QUERY_CHECK_CODE(code, lino, _end); pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, maxTs); } if (pInfo->pCreateTbRes->info.rows > 0) { pInfo->scanMode = STREAM_SCAN_FROM_RES; - printSpecDataBlock(pInfo->pCreateTbRes, getStreamOpName(pOperator->operatorType), "recover", GET_TASKID(pTaskInfo)); + printSpecDataBlock(pInfo->pCreateTbRes, getStreamOpName(pOperator->operatorType), "recover", + GET_TASKID(pTaskInfo)); return pInfo->pCreateTbRes; } qDebug("stream recover scan get block, rows %" PRId64, pInfo->pRecoverRes->info.rows); - printSpecDataBlock(pInfo->pRecoverRes, getStreamOpName(pOperator->operatorType), "recover", GET_TASKID(pTaskInfo)); + printSpecDataBlock(pInfo->pRecoverRes, getStreamOpName(pOperator->operatorType), "recover", + GET_TASKID(pTaskInfo)); return pInfo->pRecoverRes; } pStreamInfo->recoverStep = STREAM_RECOVER_STEP__NONE; @@ -2699,8 +3014,8 @@ FETCH_NEXT_BLOCK: return NULL; } - int32_t current = pInfo->validBlockIndex++; - qDebug("process %d/%d input data blocks, %s", current, (int32_t) total, id); + int32_t current = pInfo->validBlockIndex++; + qDebug("process %d/%d input data blocks, %s", current, (int32_t)total, id); SPackedData* pPacked = taosArrayGet(pInfo->pBlockLists, current); SSDataBlock* pBlock = pPacked->pDataBlock; @@ -2720,7 +3035,8 @@ FETCH_NEXT_BLOCK: pInfo->pUpdateInfo->maxDataVersion = TMAX(pInfo->pUpdateInfo->maxDataVersion, pBlock->info.version); } - blockDataUpdateTsWindow(pBlock, 0); + code = blockDataUpdateTsWindow(pBlock, 0); + QUERY_CHECK_CODE(code, lino, _end); switch (pBlock->info.type) { case STREAM_NORMAL: case STREAM_GET_ALL: @@ -2730,9 +3046,10 @@ FETCH_NEXT_BLOCK: case STREAM_RETRIEVE: { pInfo->blockType = STREAM_INPUT__DATA_SUBMIT; pInfo->scanMode = STREAM_SCAN_FROM_DATAREADER_RETRIEVE; - copyDataBlock(pInfo->pUpdateRes, pBlock); + code = copyDataBlock(pInfo->pUpdateRes, pBlock); + QUERY_CHECK_CODE(code, lino, _end); pInfo->updateResIndex = 0; - prepareRangeScan(pInfo, pInfo->pUpdateRes, &pInfo->updateResIndex); + prepareRangeScan(pInfo, pInfo->pUpdateRes, &pInfo->updateResIndex, NULL); pAPI->stateStore.updateInfoAddCloseWindowSBF(pInfo->pUpdateInfo); } break; case STREAM_DELETE_DATA: { @@ -2740,14 +3057,17 @@ FETCH_NEXT_BLOCK: SSDataBlock* pDelBlock = NULL; if (pInfo->tqReader) { pDelBlock = createSpecialDataBlock(STREAM_DELETE_DATA); - filterDelBlockByUid(pDelBlock, pBlock, pInfo); + code = filterDelBlockByUid(pDelBlock, pBlock, pInfo); + QUERY_CHECK_CODE(code, lino, _end); } else { pDelBlock = pBlock; } - setBlockGroupIdByUid(pInfo, pDelBlock); + code = setBlockGroupIdByUid(pInfo, pDelBlock); + QUERY_CHECK_CODE(code, lino, _end); rebuildDeleteBlockData(pDelBlock, &pStreamInfo->fillHistoryWindow, id); - printSpecDataBlock(pDelBlock, getStreamOpName(pOperator->operatorType), "delete recv filtered", GET_TASKID(pTaskInfo)); + printSpecDataBlock(pDelBlock, getStreamOpName(pOperator->operatorType), "delete recv filtered", + GET_TASKID(pTaskInfo)); if (pDelBlock->info.rows == 0) { if (pInfo->tqReader) { blockDataDestroy(pDelBlock); @@ -2756,7 +3076,8 @@ FETCH_NEXT_BLOCK: } if (!isStreamWindow(pInfo)) { - generateDeleteResultBlock(pInfo, pDelBlock, pInfo->pDeleteDataRes); + code = generateDeleteResultBlock(pInfo, pDelBlock, pInfo->pDeleteDataRes); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->partitionSup.needCalc) { pInfo->pDeleteDataRes->info.type = STREAM_DELETE_DATA; } else { @@ -2765,7 +3086,8 @@ FETCH_NEXT_BLOCK: blockDataDestroy(pDelBlock); if (pInfo->pDeleteDataRes->info.rows > 0) { - printSpecDataBlock(pInfo->pDeleteDataRes, getStreamOpName(pOperator->operatorType), "delete result", GET_TASKID(pTaskInfo)); + printSpecDataBlock(pInfo->pDeleteDataRes, getStreamOpName(pOperator->operatorType), "delete result", + GET_TASKID(pTaskInfo)); setStreamOperatorState(&pInfo->basic, pInfo->pDeleteDataRes->info.type); return pInfo->pDeleteDataRes; } else { @@ -2774,16 +3096,19 @@ FETCH_NEXT_BLOCK: } else { pInfo->blockType = STREAM_INPUT__DATA_SUBMIT; pInfo->updateResIndex = 0; - generateScanRange(pInfo, pDelBlock, pInfo->pUpdateRes, STREAM_DELETE_DATA); - prepareRangeScan(pInfo, pInfo->pUpdateRes, &pInfo->updateResIndex); - copyDataBlock(pInfo->pDeleteDataRes, pInfo->pUpdateRes); + code = generateScanRange(pInfo, pDelBlock, pInfo->pUpdateRes, STREAM_DELETE_DATA); + QUERY_CHECK_CODE(code, lino, _end); + prepareRangeScan(pInfo, pInfo->pUpdateRes, &pInfo->updateResIndex, NULL); + code = copyDataBlock(pInfo->pDeleteDataRes, pInfo->pUpdateRes); + QUERY_CHECK_CODE(code, lino, _end); pInfo->pDeleteDataRes->info.type = STREAM_DELETE_DATA; if (pInfo->tqReader) { blockDataDestroy(pDelBlock); } if (pInfo->pDeleteDataRes->info.rows > 0) { pInfo->scanMode = STREAM_SCAN_FROM_DATAREADER_RANGE; - printSpecDataBlock(pInfo->pDeleteDataRes, getStreamOpName(pOperator->operatorType), "delete result", GET_TASKID(pTaskInfo)); + printSpecDataBlock(pInfo->pDeleteDataRes, getStreamOpName(pOperator->operatorType), "delete result", + GET_TASKID(pTaskInfo)); setStreamOperatorState(&pInfo->basic, pInfo->pDeleteDataRes->info.type); return pInfo->pDeleteDataRes; } else { @@ -2805,41 +3130,51 @@ FETCH_NEXT_BLOCK: switch (pInfo->scanMode) { case STREAM_SCAN_FROM_RES: { pInfo->scanMode = STREAM_SCAN_FROM_READERHANDLE; - doCheckUpdate(pInfo, pInfo->pRes->info.window.ekey, pInfo->pRes); + code = doCheckUpdate(pInfo, pInfo->pRes->info.window.ekey, pInfo->pRes); + QUERY_CHECK_CODE(code, lino, _end); setStreamOperatorState(&pInfo->basic, pInfo->pRes->info.type); - doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); pInfo->pRes->info.dataLoad = 1; - blockDataUpdateTsWindow(pInfo->pRes, pInfo->primaryTsIndex); + code = blockDataUpdateTsWindow(pInfo->pRes, pInfo->primaryTsIndex); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->pRes->info.rows > 0) { printDataBlock(pInfo->pRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo)); return pInfo->pRes; } } break; case STREAM_SCAN_FROM_DELETE_DATA: { - generateScanRange(pInfo, pInfo->pUpdateDataRes, pInfo->pUpdateRes, STREAM_PARTITION_DELETE_DATA); - prepareRangeScan(pInfo, pInfo->pUpdateRes, &pInfo->updateResIndex); + code = generateScanRange(pInfo, pInfo->pUpdateDataRes, pInfo->pUpdateRes, STREAM_PARTITION_DELETE_DATA); + QUERY_CHECK_CODE(code, lino, _end); + prepareRangeScan(pInfo, pInfo->pUpdateRes, &pInfo->updateResIndex, NULL); pInfo->scanMode = STREAM_SCAN_FROM_DATAREADER_RANGE; - copyDataBlock(pInfo->pDeleteDataRes, pInfo->pUpdateRes); + code = copyDataBlock(pInfo->pDeleteDataRes, pInfo->pUpdateRes); + QUERY_CHECK_CODE(code, lino, _end); pInfo->pDeleteDataRes->info.type = STREAM_DELETE_DATA; return pInfo->pDeleteDataRes; } break; case STREAM_SCAN_FROM_UPDATERES: { - generateScanRange(pInfo, pInfo->pUpdateDataRes, pInfo->pUpdateRes, STREAM_CLEAR); - prepareRangeScan(pInfo, pInfo->pUpdateRes, &pInfo->updateResIndex); + code = generateScanRange(pInfo, pInfo->pUpdateDataRes, pInfo->pUpdateRes, STREAM_CLEAR); + QUERY_CHECK_CODE(code, lino, _end); + prepareRangeScan(pInfo, pInfo->pUpdateRes, &pInfo->updateResIndex, NULL); pInfo->scanMode = STREAM_SCAN_FROM_DATAREADER_RANGE; return pInfo->pUpdateRes; } break; case STREAM_SCAN_FROM_DATAREADER_RANGE: case STREAM_SCAN_FROM_DATAREADER_RETRIEVE: { - SSDataBlock* pSDB = doRangeScan(pInfo, pInfo->pUpdateRes, pInfo->primaryTsIndex, &pInfo->updateResIndex); + SSDataBlock* pSDB = NULL; + code = doRangeScan(pInfo, pInfo->pUpdateRes, pInfo->primaryTsIndex, &pInfo->updateResIndex, &pSDB); + QUERY_CHECK_CODE(code, lino, _end); if (pSDB) { STableScanInfo* pTableScanInfo = pInfo->pTableScanOp->info; pSDB->info.type = pInfo->scanMode == STREAM_SCAN_FROM_DATAREADER_RANGE ? STREAM_NORMAL : STREAM_PULL_DATA; if (!pInfo->igCheckUpdate && pInfo->pUpdateInfo) { - checkUpdateData(pInfo, true, pSDB, false); + code = checkUpdateData(pInfo, true, pSDB, false); + QUERY_CHECK_CODE(code, lino, _end); } printSpecDataBlock(pSDB, getStreamOpName(pOperator->operatorType), "update", GET_TASKID(pTaskInfo)); - calBlockTbName(pInfo, pSDB, 0); + code = calBlockTbName(pInfo, pSDB, 0); + QUERY_CHECK_CODE(code, lino, _end); return pSDB; } blockDataCleanup(pInfo->pUpdateDataRes); @@ -2853,9 +3188,10 @@ FETCH_NEXT_BLOCK: pInfo->scanMode = STREAM_SCAN_FROM_DATAREADER_RANGE; pInfo->updateResIndex = 0; SStreamAggSupporter* pSup = pInfo->windowSup.pStreamAggSup; - copyDataBlock(pInfo->pUpdateRes, pSup->pScanBlock); + code = copyDataBlock(pInfo->pUpdateRes, pSup->pScanBlock); + QUERY_CHECK_CODE(code, lino, _end); blockDataCleanup(pSup->pScanBlock); - prepareRangeScan(pInfo, pInfo->pUpdateRes, &pInfo->updateResIndex); + prepareRangeScan(pInfo, pInfo->pUpdateRes, &pInfo->updateResIndex, NULL); pInfo->pUpdateRes->info.type = STREAM_DELETE_DATA; printSpecDataBlock(pInfo->pUpdateRes, getStreamOpName(pOperator->operatorType), "rebuild", GET_TASKID(pTaskInfo)); return pInfo->pUpdateRes; @@ -2879,8 +3215,10 @@ FETCH_NEXT_BLOCK: SPackedData* pSubmit = taosArrayGet(pInfo->pBlockLists, current); qDebug("set %d/%d as the input submit block, %s", current + 1, totalBlocks, id); - if (pAPI->tqReaderFn.tqReaderSetSubmitMsg(pInfo->tqReader, pSubmit->msgStr, pSubmit->msgLen, pSubmit->ver) < 0) { - qError("submit msg messed up when initializing stream submit block %p, current %d/%d, %s", pSubmit, current, totalBlocks, id); + if (pAPI->tqReaderFn.tqReaderSetSubmitMsg(pInfo->tqReader, pSubmit->msgStr, pSubmit->msgLen, pSubmit->ver) < + 0) { + qError("submit msg messed up when initializing stream submit block %p, current %d/%d, %s", pSubmit, current, + totalBlocks, id); continue; } } @@ -2890,7 +3228,7 @@ FETCH_NEXT_BLOCK: while (pAPI->tqReaderFn.tqNextBlockImpl(pInfo->tqReader, id)) { SSDataBlock* pRes = NULL; - int32_t code = pAPI->tqReaderFn.tqRetrieveBlock(pInfo->tqReader, &pRes, id); + code = pAPI->tqReaderFn.tqRetrieveBlock(pInfo->tqReader, &pRes, id); qDebug("retrieve data from submit completed code:%s rows:%" PRId64 " %s", tstrerror(code), pRes->info.rows, id); if (code != TSDB_CODE_SUCCESS || pRes->info.rows == 0) { @@ -2898,21 +3236,27 @@ FETCH_NEXT_BLOCK: continue; } - setBlockIntoRes(pInfo, pRes, &pStreamInfo->fillHistoryWindow, false); + code = setBlockIntoRes(pInfo, pRes, &pStreamInfo->fillHistoryWindow, false); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->pRes->info.rows == 0) { continue; } if (pInfo->pCreateTbRes->info.rows > 0) { pInfo->scanMode = STREAM_SCAN_FROM_RES; - qDebug("create table res exists, rows:%"PRId64" return from stream scan, %s", pInfo->pCreateTbRes->info.rows, id); + qDebug("create table res exists, rows:%" PRId64 " return from stream scan, %s", + pInfo->pCreateTbRes->info.rows, id); return pInfo->pCreateTbRes; } - doCheckUpdate(pInfo, pBlockInfo->window.ekey, pInfo->pRes); + code = doCheckUpdate(pInfo, pBlockInfo->window.ekey, pInfo->pRes); + QUERY_CHECK_CODE(code, lino, _end); setStreamOperatorState(&pInfo->basic, pInfo->pRes->info.type); - doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); - blockDataUpdateTsWindow(pInfo->pRes, pInfo->primaryTsIndex); + code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); + + code = blockDataUpdateTsWindow(pInfo->pRes, pInfo->primaryTsIndex); + QUERY_CHECK_CODE(code, lino, _end); int64_t numOfUpdateRes = pInfo->pUpdateDataRes->info.rows; qDebug("%s %" PRId64 " rows in datablock, update res:%" PRId64, id, pBlockInfo->rows, numOfUpdateRes); @@ -2932,7 +3276,7 @@ FETCH_NEXT_BLOCK: pInfo->numOfExec++; pOperator->resultInfo.totalRows += pBlockInfo->rows; - qDebug("stream scan completed, and return source rows:%" PRId64", %s", pBlockInfo->rows, id); + qDebug("stream scan completed, and return source rows:%" PRId64 ", %s", pBlockInfo->rows, id); if (pBlockInfo->rows > 0) { printDataBlock(pInfo->pRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo)); return pInfo->pRes; @@ -2949,8 +3293,8 @@ FETCH_NEXT_BLOCK: return NULL; } - int32_t current = pInfo->validBlockIndex++; - qDebug("process %d/%d input data blocks, %s", current, (int32_t) total, id); + int32_t current = pInfo->validBlockIndex++; + qDebug("process %d/%d input data blocks, %s", current, (int32_t)total, id); SPackedData* pData = taosArrayGet(pInfo->pBlockLists, current); SSDataBlock* pBlock = taosArrayGet(pData->pDataBlock, 0); @@ -2962,28 +3306,42 @@ FETCH_NEXT_BLOCK: return pInfo->pCheckpointRes; } +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } return NULL; } -static SArray* extractTableIdList(const STableListInfo* pTableListInfo) { +static int32_t extractTableIdList(const STableListInfo* pTableListInfo, SArray** ppArrayRes) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SArray* tableIdList = taosArrayInit(4, sizeof(uint64_t)); // Transfer the Array of STableKeyInfo into uid list. size_t size = tableListGetSize(pTableListInfo); for (int32_t i = 0; i < size; ++i) { STableKeyInfo* pkeyInfo = tableListGetInfo(pTableListInfo, i); - taosArrayPush(tableIdList, &pkeyInfo->uid); + void* tmp = taosArrayPush(tableIdList, &pkeyInfo->uid); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } - return tableIdList; + (*ppArrayRes) = tableIdList; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static SSDataBlock* doRawScan(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; SStreamRawScanInfo* pInfo = pOperator->info; - int32_t code = TSDB_CODE_SUCCESS; pTaskInfo->streamInfo.btMetaRsp.batchMetaReq = NULL; // use batchMetaReq != NULL to judge if data is meta pTaskInfo->streamInfo.btMetaRsp.batchMetaLen = NULL; @@ -3028,16 +3386,17 @@ static SSDataBlock* doRawScan(SOperatorInfo* pOperator) { tqOffsetResetToData(&offset, mtInfo.uid, INT64_MIN, val); qDebug("tmqsnap change get data uid:%" PRId64 "", mtInfo.uid); } - qStreamPrepareScan(pTaskInfo, &offset, pInfo->sContext->subType); + code = qStreamPrepareScan(pTaskInfo, &offset, pInfo->sContext->subType); + QUERY_CHECK_CODE(code, lino, _end); tDeleteSchemaWrapper(mtInfo.schema); return NULL; } else if (pTaskInfo->streamInfo.currentOffset.type == TMQ_OFFSET__SNAPSHOT_META) { SSnapContext* sContext = pInfo->sContext; - for(int32_t i = 0; i < tmqRowSize; i++) { - void* data = NULL; - int32_t dataLen = 0; - int16_t type = 0; - int64_t uid = 0; + for (int32_t i = 0; i < tmqRowSize; i++) { + void* data = NULL; + int32_t dataLen = 0; + int16_t type = 0; + int64_t uid = 0; if (pAPI->snapshotFn.getTableInfoFromSnapshot(sContext, &data, &dataLen, &type, &uid) < 0) { qError("tmqsnap getTableInfoFromSnapshot error"); taosMemoryFreeClear(data); @@ -3046,9 +3405,10 @@ static SSDataBlock* doRawScan(SOperatorInfo* pOperator) { if (!sContext->queryMeta) { // change to get data next poll request STqOffsetVal offset = {0}; - SValue val = {0}; + SValue val = {0}; tqOffsetResetToData(&offset, 0, INT64_MIN, val); - qStreamPrepareScan(pTaskInfo, &offset, pInfo->sContext->subType); + code = qStreamPrepareScan(pTaskInfo, &offset, pInfo->sContext->subType); + QUERY_CHECK_CODE(code, lino, _end); break; } else { tqOffsetResetToMeta(&pTaskInfo->streamInfo.currentOffset, uid); @@ -3058,7 +3418,10 @@ static SSDataBlock* doRawScan(SOperatorInfo* pOperator) { tmpMetaRsp.metaRsp = data; if (!pTaskInfo->streamInfo.btMetaRsp.batchMetaReq) { pTaskInfo->streamInfo.btMetaRsp.batchMetaReq = taosArrayInit(4, POINTER_BYTES); + QUERY_CHECK_NULL(pTaskInfo->streamInfo.btMetaRsp.batchMetaReq, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + pTaskInfo->streamInfo.btMetaRsp.batchMetaLen = taosArrayInit(4, sizeof(int32_t)); + QUERY_CHECK_NULL(pTaskInfo->streamInfo.btMetaRsp.batchMetaLen, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } int32_t code = TSDB_CODE_SUCCESS; uint32_t len = 0; @@ -3069,9 +3432,9 @@ static SSDataBlock* doRawScan(SOperatorInfo* pOperator) { break; } - int32_t tLen = sizeof(SMqRspHead) + len; - void* tBuf = taosMemoryCalloc(1, tLen); - void* metaBuff = POINTER_SHIFT(tBuf, sizeof(SMqRspHead)); + int32_t tLen = sizeof(SMqRspHead) + len; + void* tBuf = taosMemoryCalloc(1, tLen); + void* metaBuff = POINTER_SHIFT(tBuf, sizeof(SMqRspHead)); SEncoder encoder = {0}; tEncoderInit(&encoder, metaBuff, len); code = tEncodeMqMetaRsp(&encoder, &tmpMetaRsp); @@ -3083,20 +3446,29 @@ static SSDataBlock* doRawScan(SOperatorInfo* pOperator) { break; } taosMemoryFreeClear(data); - taosArrayPush(pTaskInfo->streamInfo.btMetaRsp.batchMetaReq, &tBuf); - taosArrayPush(pTaskInfo->streamInfo.btMetaRsp.batchMetaLen, &tLen); + void* tmp = taosArrayPush(pTaskInfo->streamInfo.btMetaRsp.batchMetaReq, &tBuf); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + tmp = taosArrayPush(pTaskInfo->streamInfo.btMetaRsp.batchMetaLen, &tLen); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } } return NULL; } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + } return NULL; } static void destroyRawScanOperatorInfo(void* param) { SStreamRawScanInfo* pRawScan = (SStreamRawScanInfo*)param; pRawScan->pAPI->tsdReader.tsdReaderClose(pRawScan->dataReader); - pRawScan->pAPI->snapshotFn.destroySnapshot(pRawScan->sContext); - tableListDestroy(pRawScan->pTableListInfo); + (void)pRawScan->pAPI->snapshotFn.destroySnapshot(pRawScan->sContext); + (void)tableListDestroy(pRawScan->pTableListInfo); taosMemoryFree(pRawScan); } @@ -3126,7 +3498,8 @@ SOperatorInfo* createRawScanOperatorInfo(SReadHandle* pHandle, SExecTaskInfo* pT setOperatorInfo(pOperator, "RawScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN, false, OP_NOT_OPENED, pInfo, pTaskInfo); - pOperator->fpSet = createOperatorFpSet(NULL, doRawScan, NULL, destroyRawScanOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); + pOperator->fpSet = createOperatorFpSet(NULL, doRawScan, NULL, destroyRawScanOperatorInfo, optrDefaultBufFn, NULL, + optrDefaultGetNextExtFn, NULL); return pOperator; _end: @@ -3170,10 +3543,10 @@ static void destroyStreamScanOperatorInfo(void* param) { } void streamScanReleaseState(SOperatorInfo* pOperator) { - int32_t code = TSDB_CODE_SUCCESS; - int32_t lino = 0; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SStreamScanInfo* pInfo = pOperator->info; - void* pBuff = NULL; + void* pBuff = NULL; if (!pInfo->pState) { return; } @@ -3182,19 +3555,20 @@ void streamScanReleaseState(SOperatorInfo* pOperator) { } int32_t len = 0; code = pInfo->stateStore.updateInfoSerialize(NULL, 0, pInfo->pUpdateInfo, &len); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pBuff = taosMemoryCalloc(1, len); if (!pBuff) { code = TSDB_CODE_OUT_OF_MEMORY; -TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } int32_t tmp = 0; code = pInfo->stateStore.updateInfoSerialize(pBuff, len, pInfo->pUpdateInfo, &tmp); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); - pInfo->stateStore.streamStateSaveInfo(pInfo->pState, STREAM_SCAN_OP_STATE_NAME, strlen(STREAM_SCAN_OP_STATE_NAME), pBuff, len); + pInfo->stateStore.streamStateSaveInfo(pInfo->pState, STREAM_SCAN_OP_STATE_NAME, strlen(STREAM_SCAN_OP_STATE_NAME), + pBuff, len); _end: if (code != TSDB_CODE_SUCCESS) { qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); @@ -3213,12 +3587,12 @@ void streamScanReloadState(SOperatorInfo* pOperator) { int32_t len = 0; code = pInfo->stateStore.streamStateGetInfo(pInfo->pState, STREAM_SCAN_OP_STATE_NAME, strlen(STREAM_SCAN_OP_STATE_NAME), &pBuff, &len); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); SUpdateInfo* pUpInfo = taosMemoryCalloc(1, sizeof(SUpdateInfo)); if (!pUpInfo) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } int32_t winCode = pInfo->stateStore.updateInfoDeserialize(pBuff, len, pUpInfo); @@ -3229,7 +3603,8 @@ void streamScanReloadState(SOperatorInfo* pOperator) { pInfo->pUpdateInfo = pUpInfo; } else { pInfo->stateStore.windowSBfDelete(pInfo->pUpdateInfo, 1); - pInfo->stateStore.windowSBfAdd(pInfo->pUpdateInfo, 1); + code = pInfo->stateStore.windowSBfAdd(pInfo->pUpdateInfo, 1); + QUERY_CHECK_CODE(code, lino, _end); ASSERT(pInfo->pUpdateInfo->minTS > pUpInfo->minTS); pInfo->pUpdateInfo->maxDataVersion = TMAX(pInfo->pUpdateInfo->maxDataVersion, pUpInfo->maxDataVersion); SHashObj* curMap = pInfo->pUpdateInfo->pMap; @@ -3237,7 +3612,9 @@ void streamScanReloadState(SOperatorInfo* pOperator) { while (pIte != NULL) { size_t keySize = 0; int64_t* pUid = taosHashGetKey(pIte, &keySize); - taosHashPut(pUpInfo->pMap, pUid, sizeof(int64_t), pIte, sizeof(TSKEY)); + code = taosHashPut(pUpInfo->pMap, pUid, sizeof(int64_t), pIte, sizeof(TSKEY)); + QUERY_CHECK_CODE(code, lino, _end); + pIte = taosHashIterate(curMap, pIte); } taosHashCleanup(curMap); @@ -3255,25 +3632,36 @@ _end: } } -void addPrimaryKeyCol(SSDataBlock* pBlock, uint8_t type, int32_t bytes) { +int32_t addPrimaryKeyCol(SSDataBlock* pBlock, uint8_t type, int32_t bytes) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; pBlock->info.rowSize += bytes; SColumnInfoData infoData = {0}; infoData.info.type = type; infoData.info.bytes = bytes; - taosArrayPush(pBlock->pDataBlock, &infoData); + void* tmp = taosArrayPush(pBlock->pDataBlock, &infoData); + 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; } SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhysiNode* pTableScanNode, SNode* pTagCond, STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SArray* pColIds = NULL; SStreamScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SStreamScanInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); SStorageAPI* pAPI = &pTaskInfo->storageAPI; - const char* idstr = pTaskInfo->id.str; + const char* idstr = pTaskInfo->id.str; if (pInfo == NULL || pOperator == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - tableListDestroy(pTableListInfo); + (void)tableListDestroy(pTableListInfo); goto _error; } @@ -3284,10 +3672,9 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys pInfo->pGroupTags = pTableScanNode->pGroupTags; int32_t numOfCols = 0; - int32_t code = - extractColMatchInfo(pScanPhyNode->pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo); + code = extractColMatchInfo(pScanPhyNode->pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo); if (code != TSDB_CODE_SUCCESS) { - tableListDestroy(pTableListInfo); + (void)tableListDestroy(pTableListInfo); goto _error; } @@ -3299,7 +3686,9 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys SColMatchItem* id = taosArrayGet(pInfo->matchInfo.pList, i); int16_t colId = id->colId; - taosArrayPush(pColIds, &colId); + void* tmp = taosArrayPush(pColIds, &colId); + QUERY_CHECK_NULL(tmp, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + if (id->colId == PRIMARYKEY_TIMESTAMP_COL_ID) { pInfo->primaryTsIndex = id->dstSlotId; } @@ -3314,14 +3703,14 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys SExprInfo* pSubTableExpr = taosMemoryCalloc(1, sizeof(SExprInfo)); if (pSubTableExpr == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - tableListDestroy(pTableListInfo); + (void)tableListDestroy(pTableListInfo); goto _error; } pInfo->tbnameCalSup.pExprInfo = pSubTableExpr; createExprFromOneNode(pSubTableExpr, pTableScanNode->pSubtable, 0); if (initExprSupp(&pInfo->tbnameCalSup, pSubTableExpr, 1, &pTaskInfo->storageAPI.functionStore) != 0) { - tableListDestroy(pTableListInfo); + (void)tableListDestroy(pTableListInfo); goto _error; } } @@ -3331,12 +3720,12 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys SExprInfo* pTagExpr = createExpr(pTableScanNode->pTags, &numOfTags); if (pTagExpr == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - tableListDestroy(pTableListInfo); + (void)tableListDestroy(pTableListInfo); goto _error; } if (initExprSupp(&pInfo->tagCalSup, pTagExpr, numOfTags, &pTaskInfo->storageAPI.functionStore) != 0) { terrno = TSDB_CODE_OUT_OF_MEMORY; - tableListDestroy(pTableListInfo); + (void)tableListDestroy(pTableListInfo); goto _error; } } @@ -3344,12 +3733,12 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys pInfo->pBlockLists = taosArrayInit(4, sizeof(SPackedData)); if (pInfo->pBlockLists == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - tableListDestroy(pTableListInfo); + (void)tableListDestroy(pTableListInfo); goto _error; } if (pHandle->vnode) { - SOperatorInfo* pTableScanOp = createTableScanOperatorInfo(pTableScanNode, pHandle, pTableListInfo, pTaskInfo); + SOperatorInfo* pTableScanOp = createTableScanOperatorInfo(pTableScanNode, pHandle, pTableListInfo, pTaskInfo); if (pTableScanOp == NULL) { qError("createTableScanOperatorInfo error, errorcode: %d", pTaskInfo->code); goto _error; @@ -3361,7 +3750,8 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys STableKeyInfo* pList = NULL; int32_t num = 0; - tableListGetGroupList(pTableListInfo, 0, &pList, &num); + code = tableListGetGroupList(pTableListInfo, 0, &pList, &num); + QUERY_CHECK_CODE(code, lino, _error); if (pHandle->initTableReader) { pTSInfo->scanMode = TABLE_SCAN__TABLE_ORDER; @@ -3380,17 +3770,22 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys pInfo->pUpdateInfo = NULL; pInfo->pTableScanOp = pTableScanOp; if (pInfo->pTableScanOp->pTaskInfo->streamInfo.pState) { - pAPI->stateStore.streamStateSetNumber(pInfo->pTableScanOp->pTaskInfo->streamInfo.pState, -1, pInfo->primaryTsIndex); + pAPI->stateStore.streamStateSetNumber(pInfo->pTableScanOp->pTaskInfo->streamInfo.pState, -1, + pInfo->primaryTsIndex); } pInfo->readHandle = *pHandle; pTaskInfo->streamInfo.snapshotVer = pHandle->version; pInfo->pCreateTbRes = buildCreateTableBlock(&pInfo->tbnameCalSup, &pInfo->tagCalSup); - blockDataEnsureCapacity(pInfo->pCreateTbRes, 8); + code = blockDataEnsureCapacity(pInfo->pCreateTbRes, 8); + QUERY_CHECK_CODE(code, lino, _error); // set the extract column id to streamHandle pAPI->tqReaderFn.tqReaderSetColIdList(pInfo->tqReader, pColIds); - SArray* tableIdList = extractTableIdList(((STableScanInfo*)(pInfo->pTableScanOp->info))->base.pTableListInfo); + SArray* tableIdList = NULL; + code = extractTableIdList(((STableScanInfo*)(pInfo->pTableScanOp->info))->base.pTableListInfo, &tableIdList); + QUERY_CHECK_CODE(code, lino, _error); + code = pAPI->tqReaderFn.tqReaderSetQueryTableList(pInfo->tqReader, tableIdList, idstr); if (code != 0) { taosArrayDestroy(tableIdList); @@ -3401,7 +3796,7 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys memcpy(&pTaskInfo->streamInfo.tableCond, &pTSInfo->base.cond, sizeof(SQueryTableDataCond)); } else { taosArrayDestroy(pColIds); - tableListDestroy(pTableListInfo); + (void)tableListDestroy(pTableListInfo); pColIds = NULL; } @@ -3426,7 +3821,9 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys pInfo->updateWin = (STimeWindow){.skey = INT64_MAX, .ekey = INT64_MAX}; pInfo->pUpdateDataRes = createSpecialDataBlock(STREAM_CLEAR); if (hasPrimaryKeyCol(pInfo)) { - addPrimaryKeyCol(pInfo->pUpdateDataRes, pkType.type, pkType.bytes); + code = addPrimaryKeyCol(pInfo->pUpdateDataRes, pkType.type, pkType.bytes); + QUERY_CHECK_CODE(code, lino, _error); + pInfo->pkColType = pkType.type; pInfo->pkColLen = pkType.bytes; } @@ -3444,7 +3841,8 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys if (pTaskInfo->streamInfo.pState) { void* buff = NULL; int32_t len = 0; - int32_t res = pAPI->stateStore.streamStateGetInfo(pTaskInfo->streamInfo.pState, STREAM_SCAN_OP_CHECKPOINT_NAME, strlen(STREAM_SCAN_OP_CHECKPOINT_NAME), &buff, &len); + int32_t res = pAPI->stateStore.streamStateGetInfo(pTaskInfo->streamInfo.pState, STREAM_SCAN_OP_CHECKPOINT_NAME, + strlen(STREAM_SCAN_OP_CHECKPOINT_NAME), &buff, &len); if (res == TSDB_CODE_SUCCESS) { streamScanOperatorDecode(buff, len, pInfo); taosMemoryFree(buff); @@ -3456,8 +3854,8 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock); __optr_fn_t nextFn = (pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM) ? doStreamScan : doQueueScan; - pOperator->fpSet = - createOperatorFpSet(optrDummyOpenFn, nextFn, NULL, destroyStreamScanOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); + pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, nextFn, NULL, destroyStreamScanOperatorInfo, optrDefaultBufFn, + NULL, optrDefaultGetNextExtFn, NULL); setOperatorStreamStateFn(pOperator, streamScanReleaseState, streamScanReloadState); return pOperator; @@ -3475,13 +3873,16 @@ _error: return NULL; } -static void doTagScanOneTable(SOperatorInfo* pOperator, const SSDataBlock* pRes, int32_t count, SMetaReader* mr, SStorageAPI* pAPI) { +static void doTagScanOneTable(SOperatorInfo* pOperator, const SSDataBlock* pRes, int32_t count, SMetaReader* mr, + SStorageAPI* pAPI) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - STagScanInfo* pInfo = pOperator->info; - SExprInfo* pExprInfo = &pOperator->exprSupp.pExprInfo[0]; + STagScanInfo* pInfo = pOperator->info; + SExprInfo* pExprInfo = &pOperator->exprSupp.pExprInfo[0]; STableKeyInfo* item = tableListGetInfo(pInfo->pTableListInfo, pInfo->curPos); - int32_t code = pAPI->metaReaderFn.getTableEntryByUid(mr, item->uid); + code = pAPI->metaReaderFn.getTableEntryByUid(mr, item->uid); tDecoderClear(&(*mr).coder); if (code != TSDB_CODE_SUCCESS) { qError("failed to get table meta, uid:0x%" PRIx64 ", code:%s, %s", item->uid, tstrerror(terrno), @@ -3497,11 +3898,14 @@ static void doTagScanOneTable(SOperatorInfo* pOperator, const SSDataBlock* pRes, // refactor later if (FUNCTION_TYPE_TBNAME == pExprInfo[j].pExpr->_function.functionType) { STR_TO_VARSTR(str, (*mr).me.name); - colDataSetVal(pDst, (count), str, false); + code = colDataSetVal(pDst, (count), str, false); + QUERY_CHECK_CODE(code, lino, _end); } else if (FUNCTION_TYPE_TBUID == pExprInfo[j].pExpr->_function.functionType) { - colDataSetVal(pDst, (count), (char*)&(*mr).me.uid, false); + code = colDataSetVal(pDst, (count), (char*)&(*mr).me.uid, false); + QUERY_CHECK_CODE(code, lino, _end); } else if (FUNCTION_TYPE_VGID == pExprInfo[j].pExpr->_function.functionType) { - colDataSetVal(pDst, (count), (char*)&pTaskInfo->id.vgId, false); + code = colDataSetVal(pDst, (count), (char*)&pTaskInfo->id.vgId, false); + QUERY_CHECK_CODE(code, lino, _end); } else { // it is a tag value STagVal val = {0}; val.cid = pExprInfo[j].base.pParam[0].pCol->colId; @@ -3513,8 +3917,9 @@ static void doTagScanOneTable(SOperatorInfo* pOperator, const SSDataBlock* pRes, } else { data = (char*)p; } - colDataSetVal(pDst, (count), data, - (data == NULL) || (pDst->info.type == TSDB_DATA_TYPE_JSON && tTagIsJsonNull(data))); + code = colDataSetVal(pDst, (count), data, + (data == NULL) || (pDst->info.type == TSDB_DATA_TYPE_JSON && tTagIsJsonNull(data))); + QUERY_CHECK_CODE(code, lino, _end); if (pDst->info.type != TSDB_DATA_TYPE_JSON && p != NULL && IS_VAR_DATA_TYPE(((const STagVal*)p)->type) && data != NULL) { @@ -3522,6 +3927,12 @@ static void doTagScanOneTable(SOperatorInfo* pOperator, const SSDataBlock* pRes, } } } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + } } static void tagScanFreeUidTag(void* p) { @@ -3556,6 +3967,8 @@ static int32_t tagScanCreateResultData(SDataType* pType, int32_t numOfRows, SSca } static EDealRes tagScanRewriteTagColumn(SNode** pNode, void* pContext) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SColumnNode* pSColumnNode = NULL; if (QUERY_NODE_COLUMN == nodeType((*pNode))) { pSColumnNode = *(SColumnNode**)pNode; @@ -3580,76 +3993,92 @@ static EDealRes tagScanRewriteTagColumn(SNode** pNode, void* pContext) { } STagScanFilterContext* pCtx = (STagScanFilterContext*)pContext; - void* data = taosHashGet(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId)); + void* data = taosHashGet(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId)); if (!data) { - taosHashPut(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode))); + code = taosHashPut(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode))); + QUERY_CHECK_CODE(code, lino, _end); pSColumnNode->slotId = pCtx->index++; SColumnInfo cInfo = {.colId = pSColumnNode->colId, .type = pSColumnNode->node.resType.type, .bytes = pSColumnNode->node.resType.bytes}; - taosArrayPush(pCtx->cInfoList, &cInfo); + void* tmp = taosArrayPush(pCtx->cInfoList, &cInfo); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } else { SColumnNode* col = *(SColumnNode**)data; pSColumnNode->slotId = col->slotId; } +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + return DEAL_RES_ERROR; + } return DEAL_RES_CONTINUE; } - -static int32_t tagScanFilterByTagCond(SArray* aUidTags, SNode* pTagCond, SArray* aFilterIdxs, void* pVnode, SStorageAPI* pAPI, STagScanInfo* pInfo) { - int32_t code = 0; +static int32_t tagScanFilterByTagCond(SArray* aUidTags, SNode* pTagCond, SArray* aFilterIdxs, void* pVnode, + SStorageAPI* pAPI, STagScanInfo* pInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; int32_t numOfTables = taosArrayGetSize(aUidTags); SSDataBlock* pResBlock = createTagValBlockForFilter(pInfo->filterCtx.cInfoList, numOfTables, aUidTags, pVnode, pAPI); + QUERY_CHECK_NULL(pResBlock, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); SArray* pBlockList = taosArrayInit(1, 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); + SDataType type = {.type = TSDB_DATA_TYPE_BOOL, .bytes = sizeof(bool)}; SScalarParam output = {0}; code = tagScanCreateResultData(&type, numOfTables, &output); - if (TSDB_CODE_SUCCESS != code) { - blockDataDestroy(pResBlock); - taosArrayDestroy(pBlockList); - return code; - } + QUERY_CHECK_CODE(code, lino, _end); code = scalarCalculate(pTagCond, pBlockList, &output); - if (TSDB_CODE_SUCCESS != code) { - blockDataDestroy(pResBlock); - taosArrayDestroy(pBlockList); - return code; - } + QUERY_CHECK_CODE(code, lino, _end); bool* result = (bool*)output.columnData->pData; - for (int32_t i = 0 ; i < numOfTables; ++i) { + for (int32_t i = 0; i < numOfTables; ++i) { if (result[i]) { - taosArrayPush(aFilterIdxs, &i); + void* tmp = taosArrayPush(aFilterIdxs, &i); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } } colDataDestroy(output.columnData); taosMemoryFreeClear(output.columnData); +_end: blockDataDestroy(pResBlock); taosArrayDestroy(pBlockList); - - return TSDB_CODE_SUCCESS; + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } -static void tagScanFillOneCellWithTag(SOperatorInfo* pOperator, const STUidTagInfo* pUidTagInfo, SExprInfo* pExprInfo, SColumnInfoData* pColInfo, int rowIndex, const SStorageAPI* pAPI, void* pVnode) { +static int32_t tagScanFillOneCellWithTag(SOperatorInfo* pOperator, const STUidTagInfo* pUidTagInfo, + SExprInfo* pExprInfo, SColumnInfoData* pColInfo, int rowIndex, + const SStorageAPI* pAPI, void* pVnode) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (QUERY_NODE_FUNCTION == pExprInfo->pExpr->nodeType) { if (FUNCTION_TYPE_TBNAME == pExprInfo->pExpr->_function.functionType) { // tbname char str[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(str, "ctbidx"); - colDataSetVal(pColInfo, rowIndex, str, false); + code = colDataSetVal(pColInfo, rowIndex, str, false); + QUERY_CHECK_CODE(code, lino, _end); } else if (FUNCTION_TYPE_TBUID == pExprInfo->pExpr->_function.functionType) { - colDataSetVal(pColInfo, rowIndex, (char*)&pUidTagInfo->uid, false); + code = colDataSetVal(pColInfo, rowIndex, (char*)&pUidTagInfo->uid, false); + QUERY_CHECK_CODE(code, lino, _end); } else if (FUNCTION_TYPE_VGID == pExprInfo->pExpr->_function.functionType) { - colDataSetVal(pColInfo, rowIndex, (char*)&pOperator->pTaskInfo->id.vgId, false); - } + code = colDataSetVal(pColInfo, rowIndex, (char*)&pOperator->pTaskInfo->id.vgId, false); + QUERY_CHECK_CODE(code, lino, _end); + } } else { STagVal tagVal = {0}; tagVal.cid = pExprInfo->base.pParam[0].pCol->colId; @@ -3661,32 +4090,45 @@ static void tagScanFillOneCellWithTag(SOperatorInfo* pOperator, const STUidTagIn if (p == NULL || (pColInfo->info.type == TSDB_DATA_TYPE_JSON && ((STag*)p)->nTag == 0)) { colDataSetNULL(pColInfo, rowIndex); } else if (pColInfo->info.type == TSDB_DATA_TYPE_JSON) { - colDataSetVal(pColInfo, rowIndex, p, false); + code = colDataSetVal(pColInfo, rowIndex, 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, rowIndex, tmp, false); + code = colDataSetVal(pColInfo, rowIndex, tmp, false); taosMemoryFree(tmp); + QUERY_CHECK_CODE(code, lino, _end); } else { - colDataSetVal(pColInfo, rowIndex, (const char*)&tagVal.i64, false); + code = colDataSetVal(pColInfo, rowIndex, (const char*)&tagVal.i64, 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 tagScanFillResultBlock(SOperatorInfo* pOperator, SSDataBlock* pRes, SArray* aUidTags, SArray* aFilterIdxs, bool ignoreFilterIdx, - SStorageAPI* pAPI) { +static int32_t tagScanFillResultBlock(SOperatorInfo* pOperator, SSDataBlock* pRes, SArray* aUidTags, + SArray* aFilterIdxs, bool ignoreFilterIdx, SStorageAPI* pAPI) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; STagScanInfo* pInfo = pOperator->info; SExprInfo* pExprInfo = &pOperator->exprSupp.pExprInfo[0]; if (!ignoreFilterIdx) { size_t szTables = taosArrayGetSize(aFilterIdxs); for (int i = 0; i < szTables; ++i) { - int32_t idx = *(int32_t*)taosArrayGet(aFilterIdxs, i); + int32_t idx = *(int32_t*)taosArrayGet(aFilterIdxs, i); STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, idx); for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) { SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId); - tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode); + code = tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode); } } } else { @@ -3695,19 +4137,26 @@ static int32_t tagScanFillResultBlock(SOperatorInfo* pOperator, SSDataBlock* pRe STUidTagInfo* pUidTagInfo = taosArrayGet(aUidTags, i); for (int32_t j = 0; j < pOperator->exprSupp.numOfExprs; ++j) { SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, pExprInfo[j].base.resSchema.slotId); - tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode); + code = tagScanFillOneCellWithTag(pOperator, pUidTagInfo, &pExprInfo[j], pDst, i, pAPI, pInfo->readHandle.vnode); } } } - return 0; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static SSDataBlock* doTagScanFromCtbIdx(SOperatorInfo* pOperator) { if (pOperator->status == OP_EXEC_DONE) { return NULL; } + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - SStorageAPI* pAPI = &pTaskInfo->storageAPI; + SStorageAPI* pAPI = &pTaskInfo->storageAPI; STagScanInfo* pInfo = pOperator->info; SSDataBlock* pRes = pInfo->pRes; @@ -3715,14 +4164,16 @@ static SSDataBlock* doTagScanFromCtbIdx(SOperatorInfo* pOperator) { if (pInfo->pCtbCursor == NULL) { pInfo->pCtbCursor = pAPI->metaFn.openCtbCursor(pInfo->readHandle.vnode, pInfo->suid, 1); + QUERY_CHECK_NULL(pInfo->pCtbCursor, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } else { - pAPI->metaFn.resumeCtbCursor(pInfo->pCtbCursor, 0); + code = pAPI->metaFn.resumeCtbCursor(pInfo->pCtbCursor, 0); + QUERY_CHECK_CODE(code, lino, _end); } SArray* aUidTags = pInfo->aUidTags; SArray* aFilterIdxs = pInfo->aFilterIdxs; int32_t count = 0; - bool ctbCursorFinished = false; + bool ctbCursorFinished = false; while (1) { taosArrayClearEx(aUidTags, tagScanFreeUidTag); taosArrayClear(aFilterIdxs); @@ -3738,7 +4189,8 @@ static SSDataBlock* doTagScanFromCtbIdx(SOperatorInfo* pOperator) { STUidTagInfo info = {.uid = uid, .pTagVal = pCur->pVal}; info.pTagVal = taosMemoryMalloc(pCur->vLen); memcpy(info.pTagVal, pCur->pVal, pCur->vLen); - taosArrayPush(aUidTags, &info); + void* tmp = taosArrayPush(aUidTags, &info); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); ++numTables; } @@ -3748,18 +4200,16 @@ static SSDataBlock* doTagScanFromCtbIdx(SOperatorInfo* pOperator) { bool ignoreFilterIdx = true; if (pInfo->pTagCond != NULL) { ignoreFilterIdx = false; - int32_t code = tagScanFilterByTagCond(aUidTags, pInfo->pTagCond, aFilterIdxs, pInfo->readHandle.vnode, pAPI, pInfo); - if (TSDB_CODE_SUCCESS != code) { - pOperator->pTaskInfo->code = code; - T_LONG_JMP(pOperator->pTaskInfo->env, code); - } + code = tagScanFilterByTagCond(aUidTags, pInfo->pTagCond, aFilterIdxs, pInfo->readHandle.vnode, pAPI, pInfo); + QUERY_CHECK_CODE(code, lino, _end); } else { ignoreFilterIdx = true; } - tagScanFillResultBlock(pOperator, pRes, aUidTags, aFilterIdxs, ignoreFilterIdx, pAPI); - - count = ignoreFilterIdx ? taosArrayGetSize(aUidTags): taosArrayGetSize(aFilterIdxs); + code = tagScanFillResultBlock(pOperator, pRes, aUidTags, aFilterIdxs, ignoreFilterIdx, pAPI); + QUERY_CHECK_CODE(code, lino, _end); + + count = ignoreFilterIdx ? taosArrayGetSize(aUidTags) : taosArrayGetSize(aFilterIdxs); if (count != 0) { break; @@ -3780,6 +4230,12 @@ static SSDataBlock* doTagScanFromCtbIdx(SOperatorInfo* pOperator) { if (bLimitReached) { setOperatorCompleted(pOperator); } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + } pOperator->resultInfo.totalRows += pRes->info.rows; return (pRes->info.rows == 0) ? NULL : pInfo->pRes; } @@ -3790,7 +4246,7 @@ static SSDataBlock* doTagScanFromMetaEntry(SOperatorInfo* pOperator) { } SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - SStorageAPI* pAPI = &pTaskInfo->storageAPI; + SStorageAPI* pAPI = &pTaskInfo->storageAPI; STagScanInfo* pInfo = pOperator->info; SExprInfo* pExprInfo = &pOperator->exprSupp.pExprInfo[0]; @@ -3850,10 +4306,13 @@ static void destroyTagScanOperatorInfo(void* param) { } SOperatorInfo* createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysiNode* pTagScanNode, - STableListInfo* pTableListInfo, SNode* pTagCond, SNode* pTagIndexCond, SExecTaskInfo* pTaskInfo) { + STableListInfo* pTableListInfo, SNode* pTagCond, SNode* pTagIndexCond, + SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SScanPhysiNode* pPhyNode = (SScanPhysiNode*)pTagScanNode; - STagScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STagScanInfo)); - SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); + STagScanInfo* pInfo = taosMemoryCalloc(1, sizeof(STagScanInfo)); + SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { goto _error; } @@ -3862,16 +4321,12 @@ SOperatorInfo* createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysi int32_t numOfExprs = 0; SExprInfo* pExprInfo = createExprInfo(pPhyNode->pScanPseudoCols, NULL, &numOfExprs); - int32_t code = initExprSupp(&pOperator->exprSupp, pExprInfo, numOfExprs, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + code = initExprSupp(&pOperator->exprSupp, pExprInfo, numOfExprs, &pTaskInfo->storageAPI.functionStore); + QUERY_CHECK_CODE(code, lino, _error); int32_t num = 0; code = extractColMatchInfo(pPhyNode->pScanPseudoCols, pDescNode, &num, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); pInfo->pTagCond = pTagCond; pInfo->pTagIndexCond = pTagIndexCond; @@ -3880,6 +4335,8 @@ SOperatorInfo* createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysi pInfo->pTableListInfo = pTableListInfo; pInfo->pRes = createDataBlockFromDescNode(pDescNode); + QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + pInfo->readHandle = *pReadHandle; pInfo->curPos = 0; @@ -3887,20 +4344,30 @@ SOperatorInfo* createTagScanOperatorInfo(SReadHandle* pReadHandle, STagScanPhysi setOperatorInfo(pOperator, "TagScanOperator", QUERY_NODE_PHYSICAL_PLAN_TAG_SCAN, false, OP_NOT_OPENED, pInfo, pTaskInfo); initResultSizeInfo(&pOperator->resultInfo, 4096); - blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _error); if (pTagScanNode->onlyMetaCtbIdx) { pInfo->aUidTags = taosArrayInit(pOperator->resultInfo.capacity, sizeof(STUidTagInfo)); + QUERY_CHECK_NULL(pInfo->aUidTags, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + pInfo->aFilterIdxs = taosArrayInit(pOperator->resultInfo.capacity, sizeof(int32_t)); - pInfo->filterCtx.colHash = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT), false, HASH_NO_LOCK); + QUERY_CHECK_NULL(pInfo->aFilterIdxs, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + + pInfo->filterCtx.colHash = + taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT), false, HASH_NO_LOCK); + QUERY_CHECK_NULL(pInfo->filterCtx.colHash, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + pInfo->filterCtx.cInfoList = taosArrayInit(4, sizeof(SColumnInfo)); + QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + if (pInfo->pTagCond != NULL) { nodesRewriteExprPostOrder(&pTagCond, tagScanRewriteTagColumn, (void*)&pInfo->filterCtx); } } __optr_fn_t tagScanNextFn = (pTagScanNode->onlyMetaCtbIdx) ? doTagScanFromCtbIdx : doTagScanFromMetaEntry; - pOperator->fpSet = - createOperatorFpSet(optrDummyOpenFn, tagScanNextFn, NULL, destroyTagScanOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); + pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, tagScanNextFn, NULL, destroyTagScanOperatorInfo, + optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); return pOperator; @@ -3914,8 +4381,8 @@ _error: // table merge scan operator static int32_t subTblRowCompareTsFn(const void* pLeft, const void* pRight, void* param) { - int32_t left = *(int32_t*)pLeft; - int32_t right = *(int32_t*)pRight; + int32_t left = *(int32_t*)pLeft; + int32_t right = *(int32_t*)pRight; STmsSubTablesMergeInfo* pInfo = (STmsSubTablesMergeInfo*)param; int32_t leftIdx = pInfo->aInputs[left].rowIdx; @@ -3929,7 +4396,7 @@ static int32_t subTblRowCompareTsFn(const void* pLeft, const void* pRight, void* int64_t leftTs = pInfo->aInputs[left].aTs[leftIdx]; int64_t rightTs = pInfo->aInputs[right].aTs[rightIdx]; - int32_t ret = leftTs>rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0); + int32_t ret = leftTs > rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0); if (pInfo->pTsOrderInfo->order == TSDB_ORDER_DESC) { ret = -1 * ret; } @@ -3937,8 +4404,8 @@ static int32_t subTblRowCompareTsFn(const void* pLeft, const void* pRight, void* } static int32_t subTblRowCompareTsPkFn(const void* pLeft, const void* pRight, void* param) { - int32_t left = *(int32_t*)pLeft; - int32_t right = *(int32_t*)pRight; + int32_t left = *(int32_t*)pLeft; + int32_t right = *(int32_t*)pRight; STmsSubTablesMergeInfo* pInfo = (STmsSubTablesMergeInfo*)param; int32_t leftIdx = pInfo->aInputs[left].rowIdx; @@ -3952,39 +4419,48 @@ static int32_t subTblRowCompareTsPkFn(const void* pLeft, const void* pRight, voi int64_t leftTs = pInfo->aInputs[left].aTs[leftIdx]; int64_t rightTs = pInfo->aInputs[right].aTs[rightIdx]; - int32_t ret = leftTs>rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0); + int32_t ret = leftTs > rightTs ? 1 : ((leftTs < rightTs) ? -1 : 0); if (pInfo->pTsOrderInfo->order == TSDB_ORDER_DESC) { ret = -1 * ret; } - if (ret == 0 && pInfo->pPkOrderInfo) { - ret = tsortComparBlockCell(pInfo->aInputs[left].pInputBlock, pInfo->aInputs[right].pInputBlock, - leftIdx, rightIdx, pInfo->pPkOrderInfo); + if (ret == 0 && pInfo->pPkOrderInfo) { + ret = tsortComparBlockCell(pInfo->aInputs[left].pInputBlock, pInfo->aInputs[right].pInputBlock, leftIdx, rightIdx, + pInfo->pPkOrderInfo); } return ret; } int32_t dumpQueryTableCond(const SQueryTableDataCond* src, SQueryTableDataCond* dst) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; memcpy((void*)dst, (void*)src, sizeof(SQueryTableDataCond)); dst->colList = taosMemoryCalloc(src->numOfCols, sizeof(SColumnInfo)); + QUERY_CHECK_NULL(dst->colList, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); for (int i = 0; i < src->numOfCols; i++) { dst->colList[i] = src->colList[i]; } - return 0; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } -static int32_t fetchNextSubTableBlockFromReader(SOperatorInfo* pOperator, STmsSubTableInput* pInput, bool* pSubTableHasBlock) { +static int32_t fetchNextSubTableBlockFromReader(SOperatorInfo* pOperator, STmsSubTableInput* pInput, + bool* pSubTableHasBlock) { int32_t code = 0; - STableMergeScanInfo* pInfo = pOperator->info; - SReadHandle* pHandle = &pInfo->base.readHandle; + STableMergeScanInfo* pInfo = pOperator->info; + SReadHandle* pHandle = &pInfo->base.readHandle; STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo; - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - const SStorageAPI* pAPI= &pTaskInfo->storageAPI; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + const SStorageAPI* pAPI = &pTaskInfo->storageAPI; blockDataCleanup(pInput->pReaderBlock); if (!pInput->bInMemReader) { code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, pInput->pKeyInfo, 1, pInput->pReaderBlock, - (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL); + (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL); if (code != 0) { T_LONG_JMP(pTaskInfo->env, code); } @@ -3993,7 +4469,7 @@ static int32_t fetchNextSubTableBlockFromReader(SOperatorInfo* pOperator, STmsSu pInfo->base.dataReader = pInput->pReader; while (true) { - bool hasNext = false; + bool hasNext = false; int32_t code = pAPI->tsdReader.tsdNextDataBlock(pInfo->base.dataReader, &hasNext); if (code != 0) { pAPI->tsdReader.tsdReaderReleaseDataBlock(pInfo->base.dataReader); @@ -4010,7 +4486,7 @@ static int32_t fetchNextSubTableBlockFromReader(SOperatorInfo* pOperator, STmsSu break; } - if (pInput->tblCond.order == TSDB_ORDER_ASC) { + if (pInput->tblCond.order == TSDB_ORDER_ASC) { pInput->tblCond.twindows.skey = pInput->pReaderBlock->info.window.ekey + 1; } else { pInput->tblCond.twindows.ekey = pInput->pReaderBlock->info.window.skey - 1; @@ -4035,7 +4511,8 @@ static int32_t fetchNextSubTableBlockFromReader(SOperatorInfo* pOperator, STmsSu } if (*pSubTableHasBlock) { - pInput->pReaderBlock->info.id.groupId = tableListGetTableGroupId(pInfo->base.pTableListInfo, pInput->pReaderBlock->info.id.uid); + pInput->pReaderBlock->info.id.groupId = + tableListGetTableGroupId(pInfo->base.pTableListInfo, pInput->pReaderBlock->info.id.uid); pOperator->resultInfo.totalRows += pInput->pReaderBlock->info.rows; } if (!pInput->bInMemReader || !*pSubTableHasBlock) { @@ -4063,7 +4540,7 @@ static void setGroupStartEndIndex(STableMergeScanInfo* pInfo) { static int32_t openSubTablesMergeSort(STmsSubTablesMergeInfo* pSubTblsInfo) { for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) { - STmsSubTableInput * pInput = pSubTblsInfo->aInputs + i; + STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i; if (pInput->rowIdx == -1) { continue; } @@ -4114,19 +4591,22 @@ static int32_t initSubTablesMergeInfo(STableMergeScanInfo* pInfo) { pInfo->pSubTablesMergeInfo = pSubTblsInfo; return TSDB_CODE_SUCCESS; -} +} static int32_t initSubTableInputs(SOperatorInfo* pOperator, STableMergeScanInfo* pInfo) { - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - SReadHandle* pHandle = &pInfo->base.readHandle; - SStorageAPI* pAPI = &pTaskInfo->storageAPI; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + SReadHandle* pHandle = &pInfo->base.readHandle; + SStorageAPI* pAPI = &pTaskInfo->storageAPI; STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo; for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) { - STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i; + STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i; pInput->type = SUB_TABLE_MEM_BLOCK; - dumpQueryTableCond(&pInfo->base.cond, &pInput->tblCond); + code = dumpQueryTableCond(&pInfo->base.cond, &pInput->tblCond); + QUERY_CHECK_CODE(code, lino, _end); pInput->pReaderBlock = createOneDataBlock(pInfo->pResBlock, false); pInput->pPageBlock = createOneDataBlock(pInfo->pResBlock, false); STableKeyInfo* keyInfo = tableListGetInfo(pInfo->base.pTableListInfo, i + pInfo->tableStartIndex); @@ -4137,15 +4617,17 @@ static int32_t initSubTableInputs(SOperatorInfo* pOperator, STableMergeScanInfo* } if (i + 1 < pSubTblsInfo->numInMemReaders) { - pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, keyInfo, 1, pInput->pReaderBlock, - (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL); + code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInput->tblCond, keyInfo, 1, pInput->pReaderBlock, + (void**)&pInput->pReader, GET_TASKID(pTaskInfo), NULL); + QUERY_CHECK_CODE(code, lino, _end); pInput->bInMemReader = true; } else { pInput->pReader = NULL; pInput->bInMemReader = false; } bool hasNext = true; - fetchNextSubTableBlockFromReader(pOperator, pInput, &hasNext); + code = fetchNextSubTableBlockFromReader(pOperator, pInput, &hasNext); + QUERY_CHECK_CODE(code, lino, _end); if (!hasNext) { pInput->rowIdx = -1; ++pSubTblsInfo->numSubTablesCompleted; @@ -4154,33 +4636,47 @@ static int32_t initSubTableInputs(SOperatorInfo* pOperator, STableMergeScanInfo* pInput->rowIdx = 0; pInput->pageIdx = -1; } - } - 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 adjustSubTableFromMemBlock(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) { +static void adjustSubTableFromMemBlock(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperatorInfo->pTaskInfo; STableMergeScanInfo* pInfo = pOperatorInfo->info; - STmsSubTableInput* pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree); - bool hasNext = true; - fetchNextSubTableBlockFromReader(pOperatorInfo, pInput, &hasNext); + STmsSubTableInput* pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree); + bool hasNext = true; + code = fetchNextSubTableBlockFromReader(pOperatorInfo, pInput, &hasNext); + QUERY_CHECK_CODE(code, lino, _end); + if (!hasNext) { pInput->rowIdx = -1; ++pSubTblsInfo->numSubTablesCompleted; } else { - pInput->rowIdx = 0; + pInput->rowIdx = 0; + } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); } - - return TSDB_CODE_SUCCESS; } static int32_t adjustSubTableForNextRow(SOperatorInfo* pOperatorInfo, STmsSubTablesMergeInfo* pSubTblsInfo) { STableMergeScanInfo* pInfo = pOperatorInfo->info; - STmsSubTableInput* pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree); + STmsSubTableInput* pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree); SSDataBlock* pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock; if (pInput->rowIdx < pInputBlock->info.rows - 1) { ++pInput->rowIdx; - } else if (pInput->rowIdx == pInputBlock->info.rows -1 ) { + } else if (pInput->rowIdx == pInputBlock->info.rows - 1) { if (pInput->type == SUB_TABLE_MEM_BLOCK) { adjustSubTableFromMemBlock(pOperatorInfo, pSubTblsInfo); } @@ -4197,8 +4693,10 @@ static int32_t adjustSubTableForNextRow(SOperatorInfo* pOperatorInfo, STmsSubTab } static int32_t appendChosenRowToDataBlock(STmsSubTablesMergeInfo* pSubTblsInfo, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; STmsSubTableInput* pInput = pSubTblsInfo->aInputs + tMergeTreeGetChosenIndex(pSubTblsInfo->pTree); - SSDataBlock* pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock; + SSDataBlock* pInputBlock = (pInput->type == SUB_TABLE_MEM_BLOCK) ? pInput->pReaderBlock : pInput->pPageBlock; for (int32_t i = 0; i < taosArrayGetSize(pBlock->pDataBlock); ++i) { SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, i); @@ -4207,23 +4705,32 @@ static int32_t appendChosenRowToDataBlock(STmsSubTablesMergeInfo* pSubTblsInfo, bool isNull = colDataIsNull(pSrcColInfo, pInputBlock->info.rows, pInput->rowIdx, NULL); if (isNull) { - colDataSetVal(pColInfo, pBlock->info.rows, NULL, true); + code = colDataSetVal(pColInfo, pBlock->info.rows, NULL, true); + QUERY_CHECK_CODE(code, lino, _end); } else { if (pSrcColInfo->pData != NULL) { char* pData = colDataGetData(pSrcColInfo, pInput->rowIdx); - colDataSetVal(pColInfo, pBlock->info.rows, pData, false); + code = colDataSetVal(pColInfo, pBlock->info.rows, pData, false); + QUERY_CHECK_CODE(code, lino, _end); } } } pBlock->info.dataLoad = 1; pBlock->info.scanFlag = pInputBlock->info.scanFlag; pBlock->info.rows += 1; - 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* getSubTablesSortedBlock(SOperatorInfo* pOperator, SSDataBlock* pResBlock, int32_t capacity) { - STableMergeScanInfo* pInfo = pOperator->info; - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + STableMergeScanInfo* pInfo = pOperator->info; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo; blockDataCleanup(pResBlock); @@ -4235,9 +4742,11 @@ static SSDataBlock* getSubTablesSortedBlock(SOperatorInfo* pOperator, SSDataBloc break; } - appendChosenRowToDataBlock(pSubTblsInfo, pResBlock); - adjustSubTableForNextRow(pOperator, pSubTblsInfo); - + code = appendChosenRowToDataBlock(pSubTblsInfo, pResBlock); + QUERY_CHECK_CODE(code, lino, _end); + code = adjustSubTableForNextRow(pOperator, pSubTblsInfo); + QUERY_CHECK_CODE(code, lino, _end); + if (pResBlock->info.rows >= capacity) { break; } @@ -4252,28 +4761,43 @@ static SSDataBlock* getSubTablesSortedBlock(SOperatorInfo* pOperator, SSDataBloc break; } } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + } return (pResBlock->info.rows > 0) ? pResBlock : NULL; } static int32_t startSubTablesTableMergeScan(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; STableMergeScanInfo* pInfo = pOperator->info; - initSubTablesMergeInfo(pInfo); + code = initSubTablesMergeInfo(pInfo); + QUERY_CHECK_CODE(code, lino, _end); - initSubTableInputs(pOperator, pInfo); - - openSubTablesMergeSort(pInfo->pSubTablesMergeInfo); + code = initSubTableInputs(pOperator, pInfo); + QUERY_CHECK_CODE(code, lino, _end); - return TSDB_CODE_SUCCESS; + code = openSubTablesMergeSort(pInfo->pSubTablesMergeInfo); + 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 stopSubTablesTableMergeScan(STableMergeScanInfo* pInfo) { +static void stopSubTablesTableMergeScan(STableMergeScanInfo* pInfo) { STmsSubTablesMergeInfo* pSubTblsInfo = pInfo->pSubTablesMergeInfo; if (pSubTblsInfo != NULL) { tMergeTreeDestroy(&pSubTblsInfo->pTree); for (int32_t i = 0; i < pSubTblsInfo->numSubTables; ++i) { - STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i; + STmsSubTableInput* pInput = pSubTblsInfo->aInputs + i; taosMemoryFree(pInput->tblCond.colList); blockDataDestroy(pInput->pReaderBlock); blockDataDestroy(pInput->pPageBlock); @@ -4288,9 +4812,8 @@ static int32_t stopSubTablesTableMergeScan(STableMergeScanInfo* pInfo) { taosMemoryFree(pSubTblsInfo); pInfo->pSubTablesMergeInfo = NULL; - //taosMemoryTrim(0); + // taosMemoryTrim(0); } - return TSDB_CODE_SUCCESS; } SSDataBlock* doTableMergeScanParaSubTables(SOperatorInfo* pOperator) { @@ -4301,6 +4824,7 @@ SSDataBlock* doTableMergeScanParaSubTables(SOperatorInfo* pOperator) { SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; STableMergeScanInfo* pInfo = pOperator->info; + int32_t lino = 0; int32_t code = pOperator->fpSet._openFn(pOperator); if (code != TSDB_CODE_SUCCESS) { T_LONG_JMP(pTaskInfo->env, code); @@ -4318,7 +4842,8 @@ SSDataBlock* doTableMergeScanParaSubTables(SOperatorInfo* pOperator) { } pInfo->tableStartIndex = 0; pInfo->groupId = ((STableKeyInfo*)tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex))->groupId; - startSubTablesTableMergeScan(pOperator); + code = startSubTablesTableMergeScan(pOperator); + QUERY_CHECK_CODE(code, lino, _end); } SSDataBlock* pBlock = NULL; @@ -4347,27 +4872,45 @@ SSDataBlock* doTableMergeScanParaSubTables(SOperatorInfo* pOperator) { pInfo->tableStartIndex = pInfo->tableEndIndex + 1; pInfo->groupId = tableListGetInfo(pInfo->base.pTableListInfo, pInfo->tableStartIndex)->groupId; - startSubTablesTableMergeScan(pOperator); + code = startSubTablesTableMergeScan(pOperator); + QUERY_CHECK_CODE(code, lino, _end); resetLimitInfoForNextGroup(&pInfo->limitInfo); } } - pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;; + pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + } return pBlock; } +static void tableMergeScanDoSkipTable(uint64_t uid, void* pTableMergeOpInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SOperatorInfo* pOperator = (SOperatorInfo*)pTableMergeOpInfo; + STableMergeScanInfo* pInfo = pOperator->info; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; -static void tableMergeScanDoSkipTable(uint64_t uid, void* pTableMergeScanInfo) { - STableMergeScanInfo* pInfo = pTableMergeScanInfo; if (pInfo->mSkipTables == NULL) { - pInfo->mSkipTables = taosHashInit(pInfo->tableEndIndex - pInfo->tableStartIndex + 1, - taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_NO_LOCK); + pInfo->mSkipTables = taosHashInit(pInfo->tableEndIndex - pInfo->tableStartIndex + 1, + taosGetDefaultHashFunction(TSDB_DATA_TYPE_UBIGINT), false, HASH_NO_LOCK); + QUERY_CHECK_NULL(pInfo->mSkipTables, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } int bSkip = 1; if (pInfo->mSkipTables != NULL) { - taosHashPut(pInfo->mSkipTables, &uid, sizeof(uid), &bSkip, sizeof(bSkip)); - } + code = taosHashPut(pInfo->mSkipTables, &uid, sizeof(uid), &bSkip, sizeof(bSkip)); + 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, pTaskInfo->code); + } } static void doGetBlockForTableMergeScan(SOperatorInfo* pOperator, bool* pFinished, bool* pSkipped) { @@ -4493,7 +5036,9 @@ static SSDataBlock* getBlockForTableMergeScan(void* param) { return NULL; } -SArray* generateSortByTsPkInfo(SArray* colMatchInfo, int32_t order) { +int32_t generateSortByTsPkInfo(SArray* colMatchInfo, int32_t order, SArray** ppSortArray) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SArray* pSortInfo = taosArrayInit(1, sizeof(SBlockOrderInfo)); SBlockOrderInfo biTs = {0}; SBlockOrderInfo biPk = {0}; @@ -4509,7 +5054,7 @@ SArray* generateSortByTsPkInfo(SArray* colMatchInfo, int32_t order) { biTs.nullFirst = (order == TSDB_ORDER_ASC); biTs.compFn = getKeyComparFunc(TSDB_DATA_TYPE_TIMESTAMP, order); } - //TODO: order by just ts + // TODO: order by just ts if (colInfo->isPk) { pkTargetSlotId = colInfo->dstSlotId; biPk.order = order; @@ -4519,12 +5064,20 @@ SArray* generateSortByTsPkInfo(SArray* colMatchInfo, int32_t order) { } } - taosArrayPush(pSortInfo, &biTs); + void* tmp = taosArrayPush(pSortInfo, &biTs); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); if (pkTargetSlotId != -1) { - taosArrayPush(pSortInfo, &biPk); + tmp = taosArrayPush(pSortInfo, &biPk); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } - return pSortInfo; + (*ppSortArray) = pSortInfo; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } void tableMergeScanTsdbNotifyCb(ETsdReaderNotifyType type, STsdReaderNotifyInfo* info, void* param) { @@ -4544,6 +5097,7 @@ int32_t startDurationForGroupTableMergeScan(SOperatorInfo* pOperator) { SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; int32_t numOfTable = pInfo->tableEndIndex - pInfo->tableStartIndex + 1; qDebug("%s table merge scan start duration ", GET_TASKID(pTaskInfo)); @@ -4554,40 +5108,46 @@ int32_t startDurationForGroupTableMergeScan(SOperatorInfo* pOperator) { int32_t numOfBufPage = pInfo->sortBufSize / pInfo->bufPageSize; pInfo->pSortHandle = tsortCreateSortHandle(pInfo->pSortInfo, SORT_BLOCK_TS_MERGE, pInfo->bufPageSize, numOfBufPage, - pInfo->pSortInputBlock, pTaskInfo->id.str, 0, 0, 0); + pInfo->pSortInputBlock, pTaskInfo->id.str, 0, 0, 0); if (pInfo->bSortRowId && numOfTable != 1) { int32_t memSize = 512 * 1024 * 1024; code = tsortSetSortByRowId(pInfo->pSortHandle, memSize); - if (code != TSDB_CODE_SUCCESS) { - return code; - } + QUERY_CHECK_CODE(code, lino, _end); } tsortSetMergeLimit(pInfo->pSortHandle, pInfo->mergeLimit); - tsortSetMergeLimitReachedFp(pInfo->pSortHandle, tableMergeScanDoSkipTable, pInfo); + tsortSetMergeLimitReachedFp(pInfo->pSortHandle, tableMergeScanDoSkipTable, pOperator); tsortSetAbortCheckFn(pInfo->pSortHandle, isTaskKilled, pOperator->pTaskInfo); - tsortSetFetchRawDataFp(pInfo->pSortHandle, getBlockForTableMergeScan, NULL, NULL); + code = tsortSetFetchRawDataFp(pInfo->pSortHandle, getBlockForTableMergeScan, NULL, NULL); + QUERY_CHECK_CODE(code, lino, _end); - STableMergeScanSortSourceParam *param = taosMemoryCalloc(1, sizeof(STableMergeScanSortSourceParam)); + STableMergeScanSortSourceParam* param = taosMemoryCalloc(1, sizeof(STableMergeScanSortSourceParam)); param->pOperator = pOperator; SSortSource* ps = taosMemoryCalloc(1, sizeof(SSortSource)); ps->param = param; ps->onlyRef = false; - tsortAddSource(pInfo->pSortHandle, ps); + code = tsortAddSource(pInfo->pSortHandle, ps); + QUERY_CHECK_CODE(code, lino, _end); if (numOfTable == 1) { tsortSetSingleTableMerge(pInfo->pSortHandle); } else { code = tsortOpen(pInfo->pSortHandle); + 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; } void stopDurationForGroupTableMergeScan(SOperatorInfo* pOperator) { STableMergeScanInfo* pInfo = pOperator->info; - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; qDebug("%s table merge scan stop duration ", GET_TASKID(pTaskInfo)); SSortExecInfo sortExecInfo = tsortGetSortExecInfo(pInfo->pSortHandle); @@ -4599,15 +5159,16 @@ void stopDurationForGroupTableMergeScan(SOperatorInfo* pOperator) { tsortDestroySortHandle(pInfo->pSortHandle); pInfo->pSortHandle = NULL; - } -int32_t startGroupTableMergeScan(SOperatorInfo* pOperator) { +void startGroupTableMergeScan(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; STableMergeScanInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - SReadHandle* pHandle = &pInfo->base.readHandle; - SStorageAPI* pAPI = &pTaskInfo->storageAPI; - qDebug("%s table merge scan start group %"PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId); + SReadHandle* pHandle = &pInfo->base.readHandle; + SStorageAPI* pAPI = &pTaskInfo->storageAPI; + qDebug("%s table merge scan start group %" PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId); { size_t numOfTables = tableListGetSize(pInfo->base.pTableListInfo); @@ -4624,25 +5185,27 @@ int32_t startGroupTableMergeScan(SOperatorInfo* pOperator) { int32_t tableStartIdx = pInfo->tableStartIndex; int32_t tableEndIdx = pInfo->tableEndIndex; - int32_t numOfTable = tableEndIdx - tableStartIdx + 1; + int32_t numOfTable = tableEndIdx - tableStartIdx + 1; STableKeyInfo* startKeyInfo = tableListGetInfo(pInfo->base.pTableListInfo, tableStartIdx); - pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInfo->base.cond, startKeyInfo, numOfTable, pInfo->pReaderBlock, - (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), &pInfo->mSkipTables); + code = pAPI->tsdReader.tsdReaderOpen(pHandle->vnode, &pInfo->base.cond, startKeyInfo, numOfTable, pInfo->pReaderBlock, + (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), &pInfo->mSkipTables); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->filesetDelimited) { pAPI->tsdReader.tsdSetFilesetDelimited(pInfo->base.dataReader); } pAPI->tsdReader.tsdSetSetNotifyCb(pInfo->base.dataReader, tableMergeScanTsdbNotifyCb, pInfo); - int32_t code = startDurationForGroupTableMergeScan(pOperator); + code = startDurationForGroupTableMergeScan(pOperator); + QUERY_CHECK_CODE(code, lino, _end); +_end: if (code != TSDB_CODE_SUCCESS) { - T_LONG_JMP(pTaskInfo->env, terrno); + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); } - - return TSDB_CODE_SUCCESS; } -int32_t stopGroupTableMergeScan(SOperatorInfo* pOperator) { +void stopGroupTableMergeScan(SOperatorInfo* pOperator) { STableMergeScanInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; @@ -4664,9 +5227,7 @@ int32_t stopGroupTableMergeScan(SOperatorInfo* pOperator) { resetLimitInfoForNextGroup(&pInfo->limitInfo); taosHashCleanup(pInfo->mSkipTables); pInfo->mSkipTables = NULL; - qDebug("%s table merge scan stop group %"PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId); - - return TSDB_CODE_SUCCESS; + qDebug("%s table merge scan stop group %" PRIu64, GET_TASKID(pTaskInfo), pInfo->groupId); } // all data produced by this function only belongs to one group @@ -4694,13 +5255,13 @@ SSDataBlock* getSortedTableMergeScanBlockData(SSortHandle* pHandle, SSDataBlock* terrno = TSDB_CODE_TSC_QUERY_CANCELLED; T_LONG_JMP(pOperator->pTaskInfo->env, terrno); } - + bool limitReached = applyLimitOffset(&pInfo->limitInfo, pResBlock, pTaskInfo); qDebug("%s get sorted row block, rows:%" PRId64 ", limit:%" PRId64, GET_TASKID(pTaskInfo), pResBlock->info.rows, - pInfo->limitInfo.numOfOutputRows); + pInfo->limitInfo.numOfOutputRows); if (pTupleHandle == NULL || limitReached || pResBlock->info.rows > 0) { break; - } + } } return (pResBlock->info.rows > 0) ? pResBlock : NULL; } @@ -4773,7 +5334,8 @@ SSDataBlock* doTableMergeScan(SOperatorInfo* pOperator) { } } - pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0;; + pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0; + ; return pBlock; } @@ -4843,6 +5405,7 @@ SOperatorInfo* createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanN int32_t numOfCols = 0; int32_t code = extractColMatchInfo(pTableScanNode->scan.pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, &pInfo->base.matchInfo); + int32_t lino = 0; if (code != TSDB_CODE_SUCCESS) { goto _error; } @@ -4856,7 +5419,8 @@ SOperatorInfo* createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanN if (pTableScanNode->scan.pScanPseudoCols != NULL) { SExprSupp* pSup = &pInfo->base.pseudoSup; pSup->pExprInfo = createExprInfo(pTableScanNode->scan.pScanPseudoCols, NULL, &pSup->numOfExprs); - pSup->pCtx = createSqlFunctionCtx(pSup->pExprInfo, pSup->numOfExprs, &pSup->rowEntryInfoOffset, &pTaskInfo->storageAPI.functionStore); + pSup->pCtx = createSqlFunctionCtx(pSup->pExprInfo, pSup->numOfExprs, &pSup->rowEntryInfoOffset, + &pTaskInfo->storageAPI.functionStore); } pInfo->scanInfo = (SScanInfo){.numOfAsc = pTableScanNode->scanSeq[0], .numOfDesc = pTableScanNode->scanSeq[1]}; @@ -4897,26 +5461,31 @@ SOperatorInfo* createTableMergeScanOperatorInfo(STableScanPhysiNode* pTableScanN initResultSizeInfo(&pOperator->resultInfo, 1024); pInfo->pResBlock = createDataBlockFromDescNode(pDescNode); - blockDataEnsureCapacity(pInfo->pResBlock, pOperator->resultInfo.capacity); + QUERY_CHECK_NULL(pInfo->pResBlock, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + code = blockDataEnsureCapacity(pInfo->pResBlock, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _error); if (!hasLimit && blockDataGetRowSize(pInfo->pResBlock) >= 256 && !pTableScanNode->smallDataTsSort) { pInfo->bSortRowId = true; } else { pInfo->bSortRowId = false; } - prepareDataBlockBuf(pInfo->pResBlock, &pInfo->base.matchInfo); + code = prepareDataBlockBuf(pInfo->pResBlock, &pInfo->base.matchInfo); + QUERY_CHECK_CODE(code, lino, _error); - pInfo->pSortInfo = generateSortByTsPkInfo(pInfo->base.matchInfo.pList, pInfo->base.cond.order); + code = generateSortByTsPkInfo(pInfo->base.matchInfo.pList, pInfo->base.cond.order, &pInfo->pSortInfo); + QUERY_CHECK_CODE(code, lino, _error); pInfo->pReaderBlock = createOneDataBlock(pInfo->pResBlock, false); + QUERY_CHECK_NULL(pInfo->pReaderBlock, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); pInfo->needCountEmptyTable = tsCountAlwaysReturnValue && pTableScanNode->needCountEmptyTable; int32_t rowSize = pInfo->pResBlock->info.rowSize; uint32_t nCols = taosArrayGetSize(pInfo->pResBlock->pDataBlock); - + pInfo->bufPageSize = getProperSortPageSize(rowSize, nCols); - //start one reader variable + // start one reader variable pInfo->pSortInputBlock = createOneDataBlock(pInfo->pResBlock, false); if (!tsExperimental) { @@ -4947,9 +5516,9 @@ _error: // TableCountScanOperator static SSDataBlock* doTableCountScan(SOperatorInfo* pOperator); static void destoryTableCountScanOperator(void* param); -static void buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, +static int32_t buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName, tb_uid_t stbUid, SStorageAPI* pAPI); -static void buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, +static int32_t buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName, SStorageAPI* pAPI); static void buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName); @@ -5059,6 +5628,7 @@ int32_t getTableCountScanSupp(SNodeList* groupTags, SName* tableName, SNodeList* SOperatorInfo* createTableCountScanOperatorInfo(SReadHandle* readHandle, STableCountScanPhysiNode* pTblCountScanNode, SExecTaskInfo* pTaskInfo) { int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SScanPhysiNode* pScanNode = &pTblCountScanNode->scan; STableCountScanOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STableCountScanOperatorInfo)); @@ -5073,11 +5643,15 @@ SOperatorInfo* createTableCountScanOperatorInfo(SReadHandle* readHandle, STableC SDataBlockDescNode* pDescNode = pScanNode->node.pOutputDataBlockDesc; initResultSizeInfo(&pOperator->resultInfo, 1); pInfo->pRes = createDataBlockFromDescNode(pDescNode); - blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_NULL(pInfo->pRes, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); - getTableCountScanSupp(pTblCountScanNode->pGroupTags, &pTblCountScanNode->scan.tableName, - pTblCountScanNode->scan.pScanCols, pTblCountScanNode->scan.pScanPseudoCols, &pInfo->supp, - pTaskInfo); + code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _error); + + code = getTableCountScanSupp(pTblCountScanNode->pGroupTags, &pTblCountScanNode->scan.tableName, + pTblCountScanNode->scan.pScanCols, pTblCountScanNode->scan.pScanPseudoCols, &pInfo->supp, + pTaskInfo); + QUERY_CHECK_CODE(code, lino, _error); setOperatorInfo(pOperator, "TableCountScanOperator", QUERY_NODE_PHYSICAL_PLAN_TABLE_COUNT_SCAN, false, OP_NOT_OPENED, pInfo, pTaskInfo); @@ -5094,8 +5668,10 @@ _error: return NULL; } -void fillTableCountScanDataBlock(STableCountScanSupp* pSupp, char* dbName, char* stbName, int64_t count, - SSDataBlock* pRes) { +int32_t fillTableCountScanDataBlock(STableCountScanSupp* pSupp, char* dbName, char* stbName, int64_t count, + SSDataBlock* pRes) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pSupp->dbNameSlotId != -1) { ASSERT(strlen(dbName)); SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->dbNameSlotId); @@ -5104,7 +5680,8 @@ void fillTableCountScanDataBlock(STableCountScanSupp* pSupp, char* dbName, char* tstrncpy(varDataVal(varDbName), dbName, TSDB_DB_NAME_LEN); varDataSetLen(varDbName, strlen(dbName)); - colDataSetVal(colInfoData, 0, varDbName, false); + code = colDataSetVal(colInfoData, 0, varDbName, false); + QUERY_CHECK_CODE(code, lino, _end); } if (pSupp->stbNameSlotId != -1) { @@ -5113,7 +5690,8 @@ void fillTableCountScanDataBlock(STableCountScanSupp* pSupp, char* dbName, char* char varStbName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; strncpy(varDataVal(varStbName), stbName, TSDB_TABLE_NAME_LEN); varDataSetLen(varStbName, strlen(stbName)); - colDataSetVal(colInfoData, 0, varStbName, false); + code = colDataSetVal(colInfoData, 0, varStbName, false); + QUERY_CHECK_CODE(code, lino, _end); } else { colDataSetNULL(colInfoData, 0); } @@ -5121,9 +5699,16 @@ void fillTableCountScanDataBlock(STableCountScanSupp* pSupp, char* dbName, char* if (pSupp->tbCountSlotId != -1) { SColumnInfoData* colInfoData = taosArrayGet(pRes->pDataBlock, pSupp->tbCountSlotId); - colDataSetVal(colInfoData, 0, (char*)&count, false); + code = colDataSetVal(colInfoData, 0, (char*)&count, false); + QUERY_CHECK_CODE(code, lino, _end); } pRes->info.rows = 1; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static SSDataBlock* buildSysDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo) { @@ -5147,12 +5732,24 @@ static SSDataBlock* buildSysDbTableCount(SOperatorInfo* pOperator, STableCountSc static void buildSysDbFilterTableCount(SOperatorInfo* pOperator, STableCountScanSupp* pSupp, SSDataBlock* pRes, size_t infodbTableNum, size_t perfdbTableNum) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; if (strcmp(pSupp->dbNameFilter, TSDB_INFORMATION_SCHEMA_DB) == 0) { - fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes); + code = fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes); + QUERY_CHECK_CODE(code, lino, _end); } else if (strcmp(pSupp->dbNameFilter, TSDB_PERFORMANCE_SCHEMA_DB) == 0) { - fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB, "", perfdbTableNum, pRes); + code = fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB, "", perfdbTableNum, pRes); + QUERY_CHECK_CODE(code, lino, _end); } else if (strlen(pSupp->dbNameFilter) == 0) { - fillTableCountScanDataBlock(pSupp, "", "", infodbTableNum + perfdbTableNum, pRes); + code = fillTableCountScanDataBlock(pSupp, "", "", infodbTableNum + perfdbTableNum, pRes); + 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, pTaskInfo->code); } setOperatorCompleted(pOperator); } @@ -5160,6 +5757,9 @@ static void buildSysDbFilterTableCount(SOperatorInfo* pOperator, STableCountScan static void buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, SSDataBlock* pRes, size_t infodbTableNum, size_t perfdbTableNum) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; if (pInfo->currGrpIdx == 0) { uint64_t groupId = 0; if (pSupp->groupByDbName) { @@ -5169,7 +5769,8 @@ static void buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountSca } pRes->info.id.groupId = groupId; - fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes); + code = fillTableCountScanDataBlock(pSupp, TSDB_INFORMATION_SCHEMA_DB, "", infodbTableNum, pRes); + QUERY_CHECK_CODE(code, lino, _end); } else if (pInfo->currGrpIdx == 1) { uint64_t groupId = 0; if (pSupp->groupByDbName) { @@ -5179,11 +5780,18 @@ static void buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountSca } pRes->info.id.groupId = groupId; - fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB, "", perfdbTableNum, pRes); + code = fillTableCountScanDataBlock(pSupp, TSDB_PERFORMANCE_SCHEMA_DB, "", perfdbTableNum, pRes); + QUERY_CHECK_CODE(code, lino, _end); } else { setOperatorCompleted(pOperator); } pInfo->currGrpIdx++; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + } } static SSDataBlock* doTableCountScan(SOperatorInfo* pOperator) { @@ -5205,45 +5813,59 @@ static SSDataBlock* doTableCountScan(SOperatorInfo* pOperator) { static SSDataBlock* buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, SSDataBlock* pRes) { - const char* db = NULL; - int32_t vgId = 0; - char dbName[TSDB_DB_NAME_LEN] = {0}; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + const char* db = NULL; + int32_t vgId = 0; + char dbName[TSDB_DB_NAME_LEN] = {0}; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - SStorageAPI* pAPI = &pTaskInfo->storageAPI; + SStorageAPI* pAPI = &pTaskInfo->storageAPI; // get dbname pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, &db, &vgId, NULL, NULL); SName sn = {0}; - tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); - tNameGetDbName(&sn, dbName); + code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + QUERY_CHECK_CODE(code, lino, _end); + code = tNameGetDbName(&sn, dbName); + QUERY_CHECK_CODE(code, lino, _end); if (pSupp->groupByDbName || pSupp->groupByStbName) { buildVnodeGroupedTableCount(pOperator, pInfo, pSupp, pRes, vgId, dbName); } else { buildVnodeFilteredTbCount(pOperator, pInfo, pSupp, pRes, dbName); } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + } return pRes->info.rows > 0 ? pRes : NULL; } static void buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, SSDataBlock* pRes, int32_t vgId, char* dbName) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - SStorageAPI* pAPI = &pTaskInfo->storageAPI; + SStorageAPI* pAPI = &pTaskInfo->storageAPI; if (pSupp->groupByStbName) { if (pInfo->stbUidList == NULL) { pInfo->stbUidList = taosArrayInit(16, sizeof(tb_uid_t)); - if (pAPI->metaFn.storeGetTableList(pInfo->readHandle.vnode, TSDB_SUPER_TABLE, pInfo->stbUidList) < 0) { - qError("vgId:%d, failed to get stb id list error: %s", vgId, terrstr()); - } + QUERY_CHECK_NULL(pInfo->stbUidList, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + code = pAPI->metaFn.storeGetTableList(pInfo->readHandle.vnode, TSDB_SUPER_TABLE, pInfo->stbUidList); + QUERY_CHECK_CODE(code, lino, _end); } if (pInfo->currGrpIdx < taosArrayGetSize(pInfo->stbUidList)) { tb_uid_t stbUid = *(tb_uid_t*)taosArrayGet(pInfo->stbUidList, pInfo->currGrpIdx); - buildVnodeGroupedStbTableCount(pInfo, pSupp, pRes, dbName, stbUid, pAPI); + code = buildVnodeGroupedStbTableCount(pInfo, pSupp, pRes, dbName, stbUid, pAPI); + QUERY_CHECK_CODE(code, lino, _end); pInfo->currGrpIdx++; } else if (pInfo->currGrpIdx == taosArrayGetSize(pInfo->stbUidList)) { - buildVnodeGroupedNtbTableCount(pInfo, pSupp, pRes, dbName, pAPI); + code = buildVnodeGroupedNtbTableCount(pInfo, pSupp, pRes, dbName, pAPI); + QUERY_CHECK_CODE(code, lino, _end); pInfo->currGrpIdx++; } else { @@ -5255,42 +5877,63 @@ static void buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountSca int64_t dbTableCount = 0; pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &dbTableCount, NULL); - fillTableCountScanDataBlock(pSupp, dbName, "", dbTableCount, pRes); + code = fillTableCountScanDataBlock(pSupp, dbName, "", dbTableCount, pRes); + QUERY_CHECK_CODE(code, lino, _end); setOperatorCompleted(pOperator); } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + } } static void buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, SSDataBlock* pRes, char* dbName) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - SStorageAPI* pAPI = &pTaskInfo->storageAPI; + SStorageAPI* pAPI = &pTaskInfo->storageAPI; if (strlen(pSupp->dbNameFilter) != 0) { if (strlen(pSupp->stbNameFilter) != 0) { uint64_t uid = 0; - pAPI->metaFn.getTableUidByName(pInfo->readHandle.vnode, pSupp->stbNameFilter, &uid); + code = pAPI->metaFn.getTableUidByName(pInfo->readHandle.vnode, pSupp->stbNameFilter, &uid); + QUERY_CHECK_CODE(code, lino, _end); int64_t numOfChildTables = 0; - pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, uid, &numOfChildTables, NULL); + code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, uid, &numOfChildTables, NULL); + QUERY_CHECK_CODE(code, lino, _end); - fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, numOfChildTables, pRes); + code = fillTableCountScanDataBlock(pSupp, dbName, pSupp->stbNameFilter, numOfChildTables, pRes); + QUERY_CHECK_CODE(code, lino, _end); } else { int64_t tbNumVnode = 0; pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &tbNumVnode, NULL); - fillTableCountScanDataBlock(pSupp, dbName, "", tbNumVnode, pRes); + code = fillTableCountScanDataBlock(pSupp, dbName, "", tbNumVnode, pRes); + QUERY_CHECK_CODE(code, lino, _end); } } else { int64_t tbNumVnode = 0; pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, &tbNumVnode, NULL); - fillTableCountScanDataBlock(pSupp, dbName, "", tbNumVnode, pRes); + code = fillTableCountScanDataBlock(pSupp, dbName, "", tbNumVnode, pRes); + QUERY_CHECK_CODE(code, lino, _end); } +_end: + if (code != TSDB_CODE_SUCCESS) { + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } setOperatorCompleted(pOperator); } -static void buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, - SSDataBlock* pRes, char* dbName, SStorageAPI* pAPI) { - char fullStbName[TSDB_TABLE_FNAME_LEN] = {0}; +static int32_t buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, + SSDataBlock* pRes, char* dbName, SStorageAPI* pAPI) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + char fullStbName[TSDB_TABLE_FNAME_LEN] = {0}; if (pSupp->groupByDbName) { snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, ""); } @@ -5302,28 +5945,45 @@ static void buildVnodeGroupedNtbTableCount(STableCountScanOperatorInfo* pInfo, S pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, NULL, NULL, NULL, &numOfTables); if (numOfTables != 0) { - fillTableCountScanDataBlock(pSupp, dbName, "", numOfTables, pRes); + code = fillTableCountScanDataBlock(pSupp, dbName, "", numOfTables, pRes); } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } -static void buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, - SSDataBlock* pRes, char* dbName, tb_uid_t stbUid, SStorageAPI* pAPI) { - char stbName[TSDB_TABLE_NAME_LEN] = {0}; - pAPI->metaFn.getTableNameByUid(pInfo->readHandle.vnode, stbUid, stbName); +static int32_t buildVnodeGroupedStbTableCount(STableCountScanOperatorInfo* pInfo, STableCountScanSupp* pSupp, + SSDataBlock* pRes, char* dbName, tb_uid_t stbUid, SStorageAPI* pAPI) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + char stbName[TSDB_TABLE_NAME_LEN] = {0}; + code = pAPI->metaFn.getTableNameByUid(pInfo->readHandle.vnode, stbUid, stbName); + QUERY_CHECK_CODE(code, lino, _end); char fullStbName[TSDB_TABLE_FNAME_LEN] = {0}; if (pSupp->groupByDbName) { - snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, varDataVal(stbName)); + (void)snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s.%s", dbName, varDataVal(stbName)); } else { - snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s", varDataVal(stbName)); + (void)snprintf(fullStbName, TSDB_TABLE_FNAME_LEN, "%s", varDataVal(stbName)); } uint64_t groupId = calcGroupId(fullStbName, strlen(fullStbName)); pRes->info.id.groupId = groupId; int64_t ctbNum = 0; - int32_t code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, stbUid, &ctbNum, NULL); - fillTableCountScanDataBlock(pSupp, dbName, varDataVal(stbName), ctbNum, pRes); + code = pAPI->metaFn.getNumOfChildTables(pInfo->readHandle.vnode, stbUid, &ctbNum, NULL); + QUERY_CHECK_CODE(code, lino, _end); + code = fillTableCountScanDataBlock(pSupp, dbName, varDataVal(stbName), ctbNum, pRes); + 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 void destoryTableCountScanOperator(void* param) { diff --git a/source/libs/executor/src/streamcountwindowoperator.c b/source/libs/executor/src/streamcountwindowoperator.c index 04310276a9..3471f02bf5 100644 --- a/source/libs/executor/src/streamcountwindowoperator.c +++ b/source/libs/executor/src/streamcountwindowoperator.c @@ -84,7 +84,7 @@ int32_t setCountOutputBuf(SStreamAggSupporter* pAggSup, TSKEY ts, uint64_t group if (pBuffInfo->winBuffOp == CREATE_NEW_WINDOW) { code = pAggSup->stateStore.streamStateCountWinAdd(pAggSup->pState, &pCurWin->winInfo.sessionWin, (void**)&pCurWin->winInfo.pStatePos, &size); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); winCode = TSDB_CODE_FAILED; } else if (pBuffInfo->winBuffOp == MOVE_NEXT_WINDOW) { @@ -95,7 +95,7 @@ int32_t setCountOutputBuf(SStreamAggSupporter* pAggSup, TSKEY ts, uint64_t group if (winCode == TSDB_CODE_FAILED) { code = pAggSup->stateStore.streamStateCountWinAdd(pAggSup->pState, &pCurWin->winInfo.sessionWin, (void**)&pCurWin->winInfo.pStatePos, &size); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } else { pBuffInfo->pCur = pAggSup->stateStore.streamStateCountSeekKeyPrev(pAggSup->pState, &pCurWin->winInfo.sessionWin, @@ -105,7 +105,7 @@ int32_t setCountOutputBuf(SStreamAggSupporter* pAggSup, TSKEY ts, uint64_t group if (winCode == TSDB_CODE_FAILED) { code = pAggSup->stateStore.streamStateCountWinAdd(pAggSup->pState, &pCurWin->winInfo.sessionWin, (void**)&pCurWin->winInfo.pStatePos, &size); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } if (ts < pCurWin->winInfo.sessionWin.win.ekey) { @@ -115,7 +115,7 @@ int32_t setCountOutputBuf(SStreamAggSupporter* pAggSup, TSKEY ts, uint64_t group code = pAggSup->stateStore.streamStateCountWinAddIfNotExist(pAggSup->pState, &pCurWin->winInfo.sessionWin, pAggSup->windowCount, (void**)&pCurWin->winInfo.pStatePos, &size, &winCode); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (winCode == TSDB_CODE_SUCCESS) { @@ -173,7 +173,7 @@ static int32_t updateCountWindowInfo(SStreamAggSupporter* pAggSup, SCountWindowI needDelState = true; if (pStDeleted && pWinInfo->winInfo.isOutput) { code = saveDeleteRes(pStDeleted, pWinInfo->winInfo.sessionWin); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } pWinInfo->winInfo.sessionWin.win.skey = pTs[start]; @@ -268,11 +268,11 @@ static void doStreamCountAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBl SColumnInfoData* pStartTsCol = taosArrayGet(pSDataBlock->pDataBlock, pInfo->primaryTsIndex); if (!pStartTsCol) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } TSKEY* startTsCols = (int64_t*)pStartTsCol->pData; code = blockDataEnsureCapacity(pAggSup->pScanBlock, rows * 2); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); SStreamStateCur* pCur = NULL; COUNT_TYPE slidingRows = 0; @@ -287,7 +287,7 @@ static void doStreamCountAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBl SCountWindowInfo curWin = {0}; buffInfo.rebuildWindow = false; code = setCountOutputBuf(pAggSup, startTsCols[i], groupId, &curWin, &buffInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (!inCountSlidingWindow(pAggSup, &curWin.winInfo.sessionWin.win, &pSDataBlock->info)) { buffInfo.winBuffOp = MOVE_NEXT_WINDOW; @@ -296,9 +296,9 @@ static void doStreamCountAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBl setSessionWinOutputInfo(pStUpdated, &curWin.winInfo); slidingRows = *curWin.pWindowCount; if (!buffInfo.rebuildWindow) { - code = updateCountWindowInfo(pAggSup, &curWin, startTsCols, i, rows, pAggSup->windowCount, pStUpdated, - pStDeleted, &buffInfo.rebuildWindow, &winRows); - TSDB_CHECK_CODE(code, lino, _end); + code = updateCountWindowInfo(pAggSup, &curWin, startTsCols, i, rows, pAggSup->windowCount, pStUpdated, pStDeleted, + &buffInfo.rebuildWindow, &winRows); + QUERY_CHECK_CODE(code, lino, _end); } if (buffInfo.rebuildWindow) { SSessionKey range = {0}; @@ -310,24 +310,26 @@ static void doStreamCountAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBl range.win.skey = TMIN(startTsCols[i], range.win.skey); range.win.ekey = TMAX(startTsCols[rows - 1], range.win.ekey); uint64_t uid = 0; - appendDataToSpecialBlock(pAggSup->pScanBlock, &range.win.skey, &range.win.ekey, &uid, &range.groupId, NULL); + code = + appendDataToSpecialBlock(pAggSup->pScanBlock, &range.win.skey, &range.win.ekey, &uid, &range.groupId, NULL); + QUERY_CHECK_CODE(code, lino, _end); break; } code = doOneWindowAggImpl(&pInfo->twAggSup.timeWindowData, &curWin.winInfo, &pResult, i, winRows, rows, numOfOutput, pOperator, 0); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = saveSessionOutputBuf(pAggSup, &curWin.winInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->destHasPrimaryKey && curWin.winInfo.isOutput && IS_NORMAL_COUNT_OP(pOperator)) { code = saveDeleteRes(pInfo->pPkDeleted, curWin.winInfo.sessionWin); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE && pStUpdated) { code = saveResult(curWin.winInfo, pStUpdated); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) { curWin.winInfo.pStatePos->beUpdated = true; @@ -335,7 +337,7 @@ static void doStreamCountAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBl getSessionHashKey(&curWin.winInfo.sessionWin, &key); code = tSimpleHashPut(pAggSup->pResultRows, &key, sizeof(SSessionKey), &curWin.winInfo, sizeof(SResultWindowInfo)); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (isSlidingCountWindow(pAggSup)) { @@ -425,7 +427,7 @@ int32_t doStreamCountDecodeOpState(void* buf, int32_t len, SOperatorInfo* pOpera SStreamCountAggOperatorInfo* pInfo = pOperator->info; if (!pInfo) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } // 4.checksum @@ -434,7 +436,7 @@ int32_t doStreamCountDecodeOpState(void* buf, int32_t len, SOperatorInfo* pOpera void* pCksum = POINTER_SHIFT(buf, dataLen); if (taosCheckChecksum(buf, dataLen, *(uint32_t*)pCksum) != TSDB_CODE_SUCCESS) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } @@ -447,12 +449,12 @@ int32_t doStreamCountDecodeOpState(void* buf, int32_t len, SOperatorInfo* pOpera buf = decodeSSessionKey(buf, &key); SBuffInfo buffInfo = {.rebuildWindow = false, .winBuffOp = NONE_WINDOW, .pCur = NULL}; code = setCountOutputBuf(&pInfo->streamAggSup, key.win.skey, key.groupId, &curWin, &buffInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); buf = decodeSResultWindowInfo(buf, &curWin.winInfo, pInfo->streamAggSup.resultRowSize); code = tSimpleHashPut(pInfo->streamAggSup.pResultRows, &key, sizeof(SSessionKey), &curWin.winInfo, sizeof(SResultWindowInfo)); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } // 2.twAggSup @@ -478,7 +480,7 @@ void doStreamCountSaveCheckpoint(SOperatorInfo* pOperator) { pBuf = taosMemoryCalloc(1, len); if (!pBuf) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } len = doStreamCountEncodeOpState(&pBuf, len, pOperator, true); pInfo->streamAggSup.stateStore.streamStateSaveInfo(pInfo->streamAggSup.pState, STREAM_COUNT_OP_CHECKPOINT_NAME, @@ -556,7 +558,7 @@ int32_t doDeleteCountWindows(SStreamAggSupporter* pAggSup, SSDataBlock* pBlock, doDeleteSessionWindow(pAggSup, &curWin); if (result) { code = saveDeleteInfo(result, curWin); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } } @@ -575,22 +577,22 @@ int32_t deleteCountWinState(SStreamAggSupporter* pAggSup, SSDataBlock* pBlock, S SArray* pWins = taosArrayInit(16, sizeof(SSessionKey)); if (!pWins) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (isSlidingCountWindow(pAggSup)) { code = doDeleteCountWindows(pAggSup, pBlock, pWins); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } else { code = doDeleteTimeWindows(pAggSup, pBlock, pWins); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } removeSessionResults(pAggSup, pMapUpdate, pWins); code = copyDeleteWindowInfo(pWins, pMapDelete); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (needAdd) { code = copyDeleteWindowInfo(pWins, pPkDelete); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } taosArrayDestroy(pWins); @@ -653,7 +655,7 @@ static SSDataBlock* doStreamCountAgg(SOperatorInfo* pOperator) { bool add = pInfo->destHasPrimaryKey && IS_NORMAL_COUNT_OP(pOperator); code = deleteCountWinState(&pInfo->streamAggSup, pBlock, pInfo->pStUpdated, pInfo->pStDeleted, pInfo->pPkDeleted, add); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } else if (pBlock->info.type == STREAM_CLEAR) { doResetCountWindows(&pInfo->streamAggSup, pBlock); @@ -661,7 +663,7 @@ static SSDataBlock* doStreamCountAgg(SOperatorInfo* pOperator) { } else if (pBlock->info.type == STREAM_GET_ALL) { pInfo->recvGetAll = true; code = getAllSessionWindow(pAggSup->pResultRows, pInfo->pStUpdated); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } else if (pBlock->info.type == STREAM_CREATE_CHILD_TABLE) { return pBlock; @@ -669,7 +671,7 @@ static SSDataBlock* doStreamCountAgg(SOperatorInfo* pOperator) { pAggSup->stateStore.streamStateCommit(pAggSup->pState); doStreamCountSaveCheckpoint(pOperator); code = copyDataBlock(pInfo->pCheckpointRes, pBlock); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } else { ASSERTS(pBlock->info.type == STREAM_NORMAL || pBlock->info.type == STREAM_INVALID, "invalid SSDataBlock type"); @@ -678,7 +680,7 @@ static SSDataBlock* doStreamCountAgg(SOperatorInfo* pOperator) { if (pInfo->scalarSupp.pExprInfo != NULL) { SExprSupp* pExprSup = &pInfo->scalarSupp; code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } // the pDataBlock are always the same one, no need to call this again setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); @@ -690,20 +692,20 @@ static SSDataBlock* doStreamCountAgg(SOperatorInfo* pOperator) { pOperator->status = OP_RES_TO_RETURN; code = closeSessionWindow(pAggSup->pResultRows, &pInfo->twAggSup, pInfo->pStUpdated); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = copyUpdateResult(&pInfo->pStUpdated, pInfo->pUpdated, sessionKeyCompareAsc); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); removeSessionDeleteResults(pInfo->pStDeleted, pInfo->pUpdated); initGroupResInfoFromArrayList(&pInfo->groupResInfo, pInfo->pUpdated); pInfo->pUpdated = NULL; code = blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->destHasPrimaryKey && IS_NORMAL_COUNT_OP(pOperator)) { code = copyDeleteSessionKey(pInfo->pPkDeleted, pInfo->pStDeleted); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } SSDataBlock* opRes = buildCountResult(pOperator); @@ -727,7 +729,7 @@ void streamCountReleaseState(SOperatorInfo* pOperator) { char* pBuff = taosMemoryCalloc(1, resSize); if (pBuff) { code = terrno; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } memcpy(pBuff, &pInfo->twAggSup.maxTs, sizeof(TSKEY)); qDebug("===stream=== count window operator relase state. "); @@ -755,7 +757,7 @@ void streamCountReloadState(SOperatorInfo* pOperator) { code = pAggSup->stateStore.streamStateGetInfo(pAggSup->pState, STREAM_COUNT_OP_STATE_NAME, strlen(STREAM_COUNT_OP_STATE_NAME), &pBuf, &size); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); TSKEY ts = *(TSKEY*)pBuf; pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, ts); @@ -783,7 +785,7 @@ SOperatorInfo* createStreamCountAggOperatorInfo(SOperatorInfo* downstream, SPhys SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } pOperator->pTaskInfo = pTaskInfo; @@ -793,14 +795,14 @@ SOperatorInfo* createStreamCountAggOperatorInfo(SOperatorInfo* downstream, SPhys int32_t numOfScalar = 0; SExprInfo* pScalarExprInfo = createExprInfo(pCountNode->window.pExprs, NULL, &numOfScalar); code = initExprSupp(&pInfo->scalarSupp, pScalarExprInfo, numOfScalar, &pTaskInfo->storageAPI.functionStore); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } SExprSupp* pExpSup = &pOperator->exprSupp; SExprInfo* pExprInfo = createExprInfo(pCountNode->window.pFuncs, NULL, &numOfCols); SSDataBlock* pResBlock = createDataBlockFromDescNode(pPhyNode->pOutputDataBlockDesc); code = initBasicInfoEx(&pInfo->binfo, pExpSup, pExprInfo, numOfCols, pResBlock, &pTaskInfo->storageAPI.functionStore); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); pInfo->twAggSup = (STimeWindowAggSupp){ .waterMark = pCountNode->window.watermark, @@ -814,7 +816,7 @@ SOperatorInfo* createStreamCountAggOperatorInfo(SOperatorInfo* downstream, SPhys code = initStreamAggSupporter(&pInfo->streamAggSup, pExpSup, numOfCols, 0, pTaskInfo->streamInfo.pState, sizeof(COUNT_TYPE), 0, &pTaskInfo->storageAPI.stateStore, pHandle, &pInfo->twAggSup, GET_TASKID(pTaskInfo), &pTaskInfo->storageAPI, pInfo->primaryTsIndex); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); pInfo->streamAggSup.windowCount = pCountNode->windowCount; pInfo->streamAggSup.windowSliding = pCountNode->windowSliding; @@ -834,7 +836,7 @@ SOperatorInfo* createStreamCountAggOperatorInfo(SOperatorInfo* downstream, SPhys pInfo->historyWins = taosArrayInit(4, sizeof(SSessionKey)); if (!pInfo->historyWins) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } pInfo->pCheckpointRes = createSpecialDataBlock(STREAM_CHECKPOINT); @@ -853,7 +855,7 @@ SOperatorInfo* createStreamCountAggOperatorInfo(SOperatorInfo* downstream, SPhys strlen(STREAM_COUNT_OP_CHECKPOINT_NAME), &buff, &len); if (res == TSDB_CODE_SUCCESS) { code = doStreamCountDecodeOpState(buff, len, pOperator, true); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); taosMemoryFree(buff); } pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamCountAgg, NULL, destroyStreamCountAggOperatorInfo, @@ -863,10 +865,10 @@ SOperatorInfo* createStreamCountAggOperatorInfo(SOperatorInfo* downstream, SPhys if (downstream) { code = initDownStream(downstream, &pInfo->streamAggSup, pOperator->operatorType, pInfo->primaryTsIndex, &pInfo->twAggSup, &pInfo->basic); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); code = appendDownstream(pOperator, &downstream, 1); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } return pOperator; diff --git a/source/libs/executor/src/streameventwindowoperator.c b/source/libs/executor/src/streameventwindowoperator.c index 2d6f9b1fc5..807cf5a4ba 100644 --- a/source/libs/executor/src/streameventwindowoperator.c +++ b/source/libs/executor/src/streameventwindowoperator.c @@ -154,7 +154,7 @@ int32_t setEventOutputBuf(SStreamAggSupporter* pAggSup, TSKEY* pTs, uint64_t gro SSessionKey winKey = {.win.skey = ts, .win.ekey = ts, .groupId = groupId}; code = pAggSup->stateStore.streamStateSessionAllocWinBuffByNextPosition(pAggSup->pState, pCur, &winKey, &pVal, &len); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); setEventWindowInfo(pAggSup, &winKey, pVal, pCurWin); pCurWin->pWinFlag->startFlag = start; @@ -213,7 +213,7 @@ int32_t updateEventWindowInfo(SStreamAggSupporter* pAggSup, SEventWindowInfo* pW if (pWin->skey > pTsData[i]) { if (pStDeleted && pWinInfo->winInfo.isOutput) { code = saveDeleteRes(pStDeleted, pWinInfo->winInfo.sessionWin); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } removeSessionResult(pAggSup, pStUpdated, pResultRows, &pWinInfo->winInfo.sessionWin); pWin->skey = pTsData[i]; @@ -278,7 +278,7 @@ static int32_t compactEventWindow(SOperatorInfo* pOperator, SEventWindowInfo* pC setEventWindowFlag(pAggSup, &nextWinInfo); code = compactTimeWindow(pSup, pAggSup, &pInfo->twAggSup, pTaskInfo, &pCurWin->winInfo, &nextWinInfo.winInfo, pStUpdated, pStDeleted, false); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pCurWin->pWinFlag->endFlag = nextWinInfo.pWinFlag->endFlag; } @@ -321,7 +321,7 @@ static void doStreamEventAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBl SColumnInfoData* pColDataInfo = taosArrayGet(pSDataBlock->pDataBlock, pInfo->primaryTsIndex); if (!pColDataInfo) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } tsCols = (int64_t*)pColDataInfo->pData; } else { @@ -337,7 +337,7 @@ static void doStreamEventAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBl } int32_t statusStart = 0; code = filterExecute(pInfo->pStartCondInfo, pSDataBlock, &pColStart, NULL, paramStart.numOfCols, &statusStart); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); SFilterColumnParam paramEnd = {.numOfCols = taosArrayGetSize(pSDataBlock->pDataBlock), .pDataBlock = pSDataBlock->pDataBlock}; @@ -349,11 +349,11 @@ static void doStreamEventAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBl int32_t statusEnd = 0; code = filterExecute(pInfo->pEndCondInfo, pSDataBlock, &pColEnd, NULL, paramEnd.numOfCols, &statusEnd); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); int32_t rows = pSDataBlock->info.rows; code = blockDataEnsureCapacity(pAggSup->pScanBlock, rows); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); for (int32_t i = 0; i < rows; i += winRows) { if (pInfo->ignoreExpiredData && checkExpiredData(&pInfo->streamAggSup.stateStore, pInfo->streamAggSup.pUpdateInfo, @@ -367,48 +367,50 @@ static void doStreamEventAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBl SSessionKey nextWinKey = {0}; code = setEventOutputBuf(pAggSup, tsCols, groupId, (bool*)pColStart->pData, (bool*)pColEnd->pData, i, rows, &curWin, &nextWinKey); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); setSessionWinOutputInfo(pSeUpdated, &curWin.winInfo); bool rebuild = false; code = updateEventWindowInfo(pAggSup, &curWin, &nextWinKey, tsCols, (bool*)pColStart->pData, (bool*)pColEnd->pData, rows, i, pAggSup->pResultRows, pSeUpdated, pStDeleted, &rebuild, &winRows); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); ASSERT(winRows >= 1); if (rebuild) { uint64_t uid = 0; - appendDataToSpecialBlock(pAggSup->pScanBlock, &curWin.winInfo.sessionWin.win.skey, - &curWin.winInfo.sessionWin.win.ekey, &uid, &groupId, NULL); + code = appendDataToSpecialBlock(pAggSup->pScanBlock, &curWin.winInfo.sessionWin.win.skey, + &curWin.winInfo.sessionWin.win.ekey, &uid, &groupId, NULL); + QUERY_CHECK_CODE(code, lino, _end); + code = tSimpleHashRemove(pSeUpdated, &curWin.winInfo.sessionWin, sizeof(SSessionKey)); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); doDeleteEventWindow(pAggSup, pSeUpdated, &curWin.winInfo.sessionWin); if (pInfo->destHasPrimaryKey && curWin.winInfo.isOutput && IS_NORMAL_EVENT_OP(pOperator) && !isWindowIncomplete(&curWin)) { code = saveDeleteRes(pInfo->pPkDeleted, curWin.winInfo.sessionWin); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } releaseOutputBuf(pAggSup->pState, curWin.winInfo.pStatePos, &pAPI->stateStore); SSessionKey tmpSeInfo = {0}; getSessionHashKey(&curWin.winInfo.sessionWin, &tmpSeInfo); code = tSimpleHashPut(pStDeleted, &tmpSeInfo, sizeof(SSessionKey), NULL, 0); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } code = doOneWindowAggImpl(&pInfo->twAggSup.timeWindowData, &curWin.winInfo, &pResult, i, winRows, rows, numOfOutput, pOperator, 0); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = compactEventWindow(pOperator, &curWin, pInfo->pSeUpdated, pInfo->pSeDeleted, false); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = saveSessionOutputBuf(pAggSup, &curWin.winInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->isHistoryOp) { code = saveResult(curWin.winInfo, pInfo->pAllUpdated); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (isWindowIncomplete(&curWin)) { @@ -418,12 +420,12 @@ static void doStreamEventAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBl if (pInfo->destHasPrimaryKey && curWin.winInfo.isOutput && IS_NORMAL_EVENT_OP(pOperator)) { code = saveDeleteRes(pInfo->pPkDeleted, curWin.winInfo.sessionWin); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE) { code = saveResult(curWin.winInfo, pSeUpdated); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) { @@ -432,7 +434,7 @@ static void doStreamEventAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBl getSessionHashKey(&curWin.winInfo.sessionWin, &key); code = tSimpleHashPut(pAggSup->pResultRows, &key, sizeof(SSessionKey), &curWin.winInfo, sizeof(SResultWindowInfo)); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } @@ -490,7 +492,7 @@ int32_t doStreamEventDecodeOpState(void* buf, int32_t len, SOperatorInfo* pOpera SStreamEventAggOperatorInfo* pInfo = pOperator->info; if (!pInfo) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } SStreamAggSupporter* pAggSup = &pInfo->streamAggSup; @@ -500,7 +502,7 @@ int32_t doStreamEventDecodeOpState(void* buf, int32_t len, SOperatorInfo* pOpera if (taosCheckChecksum(buf, dataLen, *(uint32_t*)pCksum) != TSDB_CODE_SUCCESS) { qError("stream event state is invalid"); code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } // 1.streamAggSup.pResultRows @@ -513,13 +515,13 @@ int32_t doStreamEventDecodeOpState(void* buf, int32_t len, SOperatorInfo* pOpera int32_t winCode = TSDB_CODE_SUCCESS; code = pAggSup->stateStore.streamStateSessionAddIfNotExist( pAggSup->pState, &winfo.sessionWin, pAggSup->gap, (void**)&winfo.pStatePos, &pAggSup->resultRowSize, &winCode); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); ASSERT(winCode == TSDB_CODE_SUCCESS); buf = decodeSResultWindowInfo(buf, &winfo, pInfo->streamAggSup.resultRowSize); code = tSimpleHashPut(pInfo->streamAggSup.pResultRows, &key, sizeof(SSessionKey), &winfo, sizeof(SResultWindowInfo)); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } // 2.twAggSup @@ -622,12 +624,12 @@ static SSDataBlock* doStreamEventAgg(SOperatorInfo* pOperator) { bool add = pInfo->destHasPrimaryKey && IS_NORMAL_EVENT_OP(pOperator); code = deleteSessionWinState(&pInfo->streamAggSup, pBlock, pInfo->pSeUpdated, pInfo->pSeDeleted, pInfo->pPkDeleted, add); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } else if (pBlock->info.type == STREAM_GET_ALL) { pInfo->recvGetAll = true; code = getAllSessionWindow(pInfo->streamAggSup.pResultRows, pInfo->pSeUpdated); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } else if (pBlock->info.type == STREAM_CREATE_CHILD_TABLE) { return pBlock; @@ -636,7 +638,7 @@ static SSDataBlock* doStreamEventAgg(SOperatorInfo* pOperator) { doStreamEventSaveCheckpoint(pOperator); pInfo->reCkBlock = true; code = copyDataBlock(pInfo->pCheckpointRes, pBlock); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } else { ASSERTS(pBlock->info.type == STREAM_NORMAL || pBlock->info.type == STREAM_INVALID, "invalid SSDataBlock type"); @@ -645,7 +647,7 @@ static SSDataBlock* doStreamEventAgg(SOperatorInfo* pOperator) { if (pInfo->scalarSupp.pExprInfo != NULL) { SExprSupp* pExprSup = &pInfo->scalarSupp; code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } // the pDataBlock are always the same one, no need to call this again setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); @@ -656,10 +658,10 @@ static SSDataBlock* doStreamEventAgg(SOperatorInfo* pOperator) { pOperator->status = OP_RES_TO_RETURN; code = closeSessionWindow(pInfo->streamAggSup.pResultRows, &pInfo->twAggSup, pInfo->pSeUpdated); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = copyUpdateResult(&pInfo->pSeUpdated, pInfo->pUpdated, sessionKeyCompareAsc); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); removeSessionDeleteResults(pInfo->pSeDeleted, pInfo->pUpdated); @@ -667,26 +669,26 @@ static SSDataBlock* doStreamEventAgg(SOperatorInfo* pOperator) { SArray* pHisWins = taosArrayInit(16, sizeof(SEventWindowInfo)); if (!pHisWins) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } code = copyUpdateResult(&pInfo->pAllUpdated, pHisWins, sessionKeyCompareAsc); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = getMaxTsWins(pHisWins, pInfo->historyWins); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); taosArrayDestroy(pHisWins); } if (pInfo->destHasPrimaryKey && IS_NORMAL_EVENT_OP(pOperator)) { code = copyDeleteSessionKey(pInfo->pPkDeleted, pInfo->pSeDeleted); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } initGroupResInfoFromArrayList(&pInfo->groupResInfo, pInfo->pUpdated); pInfo->pUpdated = NULL; code = blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); SSDataBlock* resBlock = buildEventResult(pOperator); if (resBlock != NULL) { @@ -733,7 +735,7 @@ void streamEventReloadState(SOperatorInfo* pOperator) { void* pBuf = NULL; code = pAggSup->stateStore.streamStateGetInfo(pAggSup->pState, STREAM_EVENT_OP_STATE_NAME, strlen(STREAM_EVENT_OP_STATE_NAME), &pBuf, &size); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); int32_t num = (size - sizeof(TSKEY)) / sizeof(SSessionKey); qDebug("===stream=== event window operator reload state. get result count:%d", num); @@ -757,7 +759,7 @@ void streamEventReloadState(SOperatorInfo* pOperator) { qDebug("===stream=== reload state. try process result %" PRId64 ", %" PRIu64 ", index:%d", pSeKeyBuf[i].win.skey, pSeKeyBuf[i].groupId, i); code = getSessionWindowInfoByKey(pAggSup, pSeKeyBuf + i, &curInfo.winInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); // event window has been deleted if (!IS_VALID_SESSION_WIN(curInfo.winInfo)) { @@ -766,18 +768,18 @@ void streamEventReloadState(SOperatorInfo* pOperator) { setEventWindowFlag(pAggSup, &curInfo); if (!curInfo.pWinFlag->startFlag || curInfo.pWinFlag->endFlag) { code = saveSessionOutputBuf(pAggSup, &curInfo.winInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } code = compactEventWindow(pOperator, &curInfo, pInfo->pSeUpdated, pInfo->pSeDeleted, false); qDebug("===stream=== reload state. save result %" PRId64 ", %" PRIu64, curInfo.winInfo.sessionWin.win.skey, curInfo.winInfo.sessionWin.groupId); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (IS_VALID_SESSION_WIN(curInfo.winInfo)) { code = saveSessionOutputBuf(pAggSup, &curInfo.winInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (!curInfo.pWinFlag->endFlag) { @@ -786,17 +788,17 @@ void streamEventReloadState(SOperatorInfo* pOperator) { if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE) { code = saveResult(curInfo.winInfo, pInfo->pSeUpdated); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } else if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) { if (!isCloseWindow(&curInfo.winInfo.sessionWin.win, &pInfo->twAggSup)) { code = saveDeleteRes(pInfo->pSeDeleted, curInfo.winInfo.sessionWin); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } SSessionKey key = {0}; getSessionHashKey(&curInfo.winInfo.sessionWin, &key); code = tSimpleHashPut(pAggSup->pResultRows, &key, sizeof(SSessionKey), &curInfo.winInfo, sizeof(SResultWindowInfo)); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } taosMemoryFree(pBuf); @@ -904,7 +906,7 @@ SOperatorInfo* createStreamEventAggOperatorInfo(SOperatorInfo* downstream, SPhys if (res == TSDB_CODE_SUCCESS) { code = doStreamEventDecodeOpState(buff, len, pOperator); taosMemoryFree(buff); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamEventAgg, NULL, destroyStreamEventOperatorInfo, @@ -912,16 +914,16 @@ SOperatorInfo* createStreamEventAggOperatorInfo(SOperatorInfo* downstream, SPhys setOperatorStreamStateFn(pOperator, streamEventReleaseState, streamEventReloadState); code = initDownStream(downstream, &pInfo->streamAggSup, pOperator->operatorType, pInfo->primaryTsIndex, &pInfo->twAggSup, &pInfo->basic); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); code = appendDownstream(pOperator, &downstream, 1); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); code = filterInitFromNode((SNode*)pEventNode->pStartCond, &pInfo->pStartCondInfo, 0); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); code = filterInitFromNode((SNode*)pEventNode->pEndCond, &pInfo->pEndCondInfo, 0); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); return pOperator; diff --git a/source/libs/executor/src/streamfilloperator.c b/source/libs/executor/src/streamfilloperator.c index 314a226b5d..a9cc270f7a 100644 --- a/source/libs/executor/src/streamfilloperator.c +++ b/source/libs/executor/src/streamfilloperator.c @@ -472,7 +472,7 @@ static int32_t checkResult(SStreamFillSupporter* pFillSup, TSKEY ts, uint64_t gr (*pRes) = false; } code = tSimpleHashPut(pFillSup->pResMap, &key, sizeof(SWinKey), NULL, 0); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); (*pRes) = true; _end: @@ -493,7 +493,7 @@ static int32_t buildFillResult(SResultRowData* pResRow, SStreamFillSupporter* pF uint64_t groupId = pBlock->info.id.groupId; bool ckRes = true; code = checkResult(pFillSup, ts, groupId, &ckRes); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pFillSup->hasDelete && !ckRes) { (*pRes) = true; @@ -512,7 +512,7 @@ static int32_t buildFillResult(SResultRowData* pResRow, SStreamFillSupporter* pF if (!filled) { SResultCellData* pCell = getResultCell(pResRow, slotId); code = setRowCell(pColData, pBlock->info.rows, pCell); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } pBlock->info.rows++; @@ -540,7 +540,7 @@ static void doStreamFillNormal(SStreamFillSupporter* pFillSup, SStreamFillInfo* if (inWinRange(&pFillSup->winRange, &st)) { bool res = true; code = buildFillResult(pFillInfo->pResRow, pFillSup, pFillInfo->current, pBlock, &res); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } pFillInfo->current = taosTimeAdd(pFillInfo->current, pFillSup->interval.sliding, pFillSup->interval.slidingUnit, pFillSup->interval.precision); @@ -561,7 +561,7 @@ static void doStreamFillLinear(SStreamFillSupporter* pFillSup, SStreamFillInfo* STimeWindow st = {.skey = pFillInfo->current, .ekey = pFillInfo->current}; bool ckRes = true; code = checkResult(pFillSup, pFillInfo->current, groupId, &ckRes); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if ((pFillSup->hasDelete && !ckRes) || !inWinRange(&pFillSup->winRange, &st)) { @@ -588,7 +588,7 @@ static void doStreamFillLinear(SStreamFillSupporter* pFillSup, SStreamFillInfo* bool filled = fillIfWindowPseudoColumn(&tmp, pFillCol, pColData, index); if (!filled) { code = setRowCell(pColData, index, pCell); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } else { if (IS_VAR_DATA_TYPE(type) || type == TSDB_DATA_TYPE_BOOL || pCell->isNull) { @@ -606,7 +606,7 @@ static void doStreamFillLinear(SStreamFillSupporter* pFillSup, SStreamFillInfo* cur.val = taosMemoryCalloc(1, pCell->bytes); taosGetLinearInterpolationVal(&cur, pCell->type, &start, pEnd, pCell->type); code = colDataSetVal(pColData, index, (const char*)cur.val, false); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); destroySPoint(&cur); } } @@ -636,13 +636,13 @@ static void doStreamFillRange(SStreamFillInfo* pFillInfo, SStreamFillSupporter* bool res = false; if (pFillInfo->needFill == false) { code = buildFillResult(&pFillSup->cur, pFillSup, pFillSup->cur.key, pRes, &res); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); return; } if (pFillInfo->pos == FILL_POS_START) { code = buildFillResult(&pFillSup->cur, pFillSup, pFillSup->cur.key, pRes, &res); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (res) { pFillInfo->pos = FILL_POS_INVALID; } @@ -654,7 +654,7 @@ static void doStreamFillRange(SStreamFillInfo* pFillInfo, SStreamFillSupporter* if (pFillInfo->pos == FILL_POS_MID) { code = buildFillResult(&pFillSup->cur, pFillSup, pFillSup->cur.key, pRes, &res); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (res) { pFillInfo->pos = FILL_POS_INVALID; } @@ -671,7 +671,7 @@ static void doStreamFillRange(SStreamFillInfo* pFillInfo, SStreamFillSupporter* } if (pFillInfo->pos == FILL_POS_END) { code = buildFillResult(&pFillSup->cur, pFillSup, pFillSup->cur.key, pRes, &res); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (res) { pFillInfo->pos = FILL_POS_INVALID; } @@ -731,14 +731,14 @@ static void doStreamFillImpl(SOperatorInfo* pOperator) { doFillResults(pOperator, pFillSup, pFillInfo, pBlock, tsCol, pInfo->srcRowIndex - 1, pRes); if (pInfo->pRes->info.rows == pInfo->pRes->info.capacity) { code = blockDataUpdateTsWindow(pRes, pInfo->primaryTsCol); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); return; } pInfo->srcRowIndex++; } doFillResults(pOperator, pFillSup, pFillInfo, pBlock, tsCol, pInfo->srcRowIndex - 1, pRes); code = blockDataUpdateTsWindow(pRes, pInfo->primaryTsCol); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); blockDataCleanup(pInfo->pSrcBlock); _end: @@ -761,14 +761,14 @@ static int32_t buildDeleteRange(SOperatorInfo* pOp, TSKEY start, TSKEY end, uint SColumnInfoData* pCalEndCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_END_TS_COLUMN_INDEX); SColumnInfoData* pTbNameCol = taosArrayGet(pBlock->pDataBlock, TABLE_NAME_COLUMN_INDEX); code = colDataSetVal(pStartCol, pBlock->info.rows, (const char*)&start, false); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = colDataSetVal(pEndCol, pBlock->info.rows, (const char*)&end, false); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); colDataSetNULL(pUidCol, pBlock->info.rows); code = colDataSetVal(pGroupCol, pBlock->info.rows, (const char*)&groupId, false); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); colDataSetNULL(pCalStartCol, pBlock->info.rows); colDataSetNULL(pCalEndCol, pBlock->info.rows); @@ -778,7 +778,7 @@ static int32_t buildDeleteRange(SOperatorInfo* pOp, TSKEY start, TSKEY end, uint void* tbname = NULL; int32_t winCode = TSDB_CODE_SUCCESS; code = pAPI->stateStore.streamStateGetParName(pOp->pTaskInfo->streamInfo.pState, groupId, &tbname, false, &winCode); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (winCode != TSDB_CODE_SUCCESS) { colDataSetNULL(pTableCol, pBlock->info.rows); } else { @@ -786,7 +786,7 @@ static int32_t buildDeleteRange(SOperatorInfo* pOp, TSKEY start, TSKEY end, uint char parTbName[VARSTR_HEADER_SIZE + TSDB_TABLE_NAME_LEN]; STR_WITH_MAXSIZE_TO_VARSTR(parTbName, tbname, sizeof(parTbName)); code = colDataSetVal(pTableCol, pBlock->info.rows, (const char*)parTbName, false); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pAPI->stateStore.streamStateFreeVal(tbname); } @@ -808,14 +808,14 @@ static int32_t buildDeleteResult(SOperatorInfo* pOperator, TSKEY startTs, TSKEY if (hasPrevWindow(pFillSup)) { TSKEY start = getNextWindowTs(pFillSup->prev.key, &pFillSup->interval); code = buildDeleteRange(pOperator, start, endTs, groupId, delRes); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } else if (hasNextWindow(pFillSup)) { TSKEY end = getPrevWindowTs(pFillSup->next.key, &pFillSup->interval); code = buildDeleteRange(pOperator, startTs, end, groupId, delRes); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } else { code = buildDeleteRange(pOperator, startTs, endTs, groupId, delRes); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } _end: @@ -836,7 +836,7 @@ static int32_t doDeleteFillResultImpl(SOperatorInfo* pOperator, TSKEY startTs, T pAPI->stateStore.streamStateFillDel(pOperator->pTaskInfo->streamInfo.pState, &key); if (!pInfo->pFillInfo->needFill) { code = buildDeleteResult(pOperator, startTs, endTs, groupId, pInfo->pDelRes); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } else { STimeRange tw = { .skey = startTs, @@ -846,7 +846,7 @@ static int32_t doDeleteFillResultImpl(SOperatorInfo* pOperator, TSKEY startTs, T void* tmp = taosArrayPush(pInfo->pFillInfo->delRanges, &tw); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } @@ -960,7 +960,7 @@ static int32_t doDeleteFillResult(SOperatorInfo* pOperator) { pAPI->stateStore.streamStateFreeCur(pCur); code = doDeleteFillResultImpl(pOperator, ts, endTs, groupId); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } pFillInfo->current = pFillInfo->end + 1; @@ -988,17 +988,17 @@ static int32_t doApplyStreamScalarCalculation(SOperatorInfo* pOperator, SSDataBl blockDataCleanup(pDstBlock); code = blockDataEnsureCapacity(pDstBlock, pSrcBlock->info.rows); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); setInputDataBlock(pSup, pSrcBlock, TSDB_ORDER_ASC, MAIN_SCAN, false); code = projectApplyFunctions(pSup->pExprInfo, pDstBlock, pSrcBlock, pSup->pCtx, pSup->numOfExprs, NULL); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pDstBlock->info.rows = 0; pSup = &pInfo->pFillSup->notFillExprSup; setInputDataBlock(pSup, pSrcBlock, TSDB_ORDER_ASC, MAIN_SCAN, false); code = projectApplyFunctions(pSup->pExprInfo, pDstBlock, pSrcBlock, pSup->pCtx, pSup->numOfExprs, NULL); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pDstBlock->info.id.groupId = pSrcBlock->info.id.groupId; @@ -1076,7 +1076,7 @@ static SSDataBlock* doStreamFill(SOperatorInfo* pOperator) { blockDataCleanup(pInfo->pDelRes); pInfo->pFillSup->hasDelete = true; code = doDeleteFillResult(pOperator); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->pDelRes->info.rows > 0) { printDataBlock(pInfo->pDelRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo)); @@ -1088,7 +1088,7 @@ static SSDataBlock* doStreamFill(SOperatorInfo* pOperator) { case STREAM_INVALID: case STREAM_PULL_DATA: { code = doApplyStreamScalarCalculation(pOperator, pBlock, pInfo->pSrcBlock); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); memcpy(pInfo->pSrcBlock->info.parTbName, pBlock->info.parTbName, TSDB_TABLE_NAME_LEN); pInfo->srcRowIndex = -1; @@ -1104,7 +1104,7 @@ static SSDataBlock* doStreamFill(SOperatorInfo* pOperator) { doStreamFillImpl(pOperator); code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, &pInfo->matchInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); memcpy(pInfo->pRes->info.parTbName, pInfo->pSrcBlock->info.parTbName, TSDB_TABLE_NAME_LEN); pOperator->resultInfo.totalRows += pInfo->pRes->info.rows; @@ -1161,7 +1161,7 @@ static SStreamFillSupporter* initStreamFillSup(SStreamFillPhysiNode* pPhyFillNod SStreamFillSupporter* pFillSup = taosMemoryCalloc(1, sizeof(SStreamFillSupporter)); if (!pFillSup) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } pFillSup->numOfFillCols = numOfFillCols; int32_t numOfNotFillCols = 0; @@ -1174,11 +1174,11 @@ static SStreamFillSupporter* initStreamFillSup(SStreamFillPhysiNode* pPhyFillNod pFillSup->pAPI = pAPI; code = initResultBuf(pFillSup); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); SExprInfo* noFillExpr = createExprInfo(pPhyFillNode->pNotFillExprs, NULL, &numOfNotFillCols); code = initExprSupp(&pFillSup->notFillExprSup, noFillExpr, numOfNotFillCols, &pAPI->functionStore); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY); pFillSup->pResMap = tSimpleHashInit(16, hashFn); @@ -1199,7 +1199,7 @@ SStreamFillInfo* initStreamFillInfo(SStreamFillSupporter* pFillSup, SSDataBlock* SStreamFillInfo* pFillInfo = taosMemoryCalloc(1, sizeof(SStreamFillInfo)); if (!pFillInfo) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } pFillInfo->start = INT64_MIN; @@ -1210,7 +1210,7 @@ SStreamFillInfo* initStreamFillInfo(SStreamFillSupporter* pFillSup, SSDataBlock* pFillInfo->pLinearInfo = taosMemoryCalloc(1, sizeof(SStreamFillLinearInfo)); if (!pFillInfo) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } pFillInfo->pLinearInfo->hasNext = false; @@ -1221,13 +1221,13 @@ SStreamFillInfo* initStreamFillInfo(SStreamFillSupporter* pFillSup, SSDataBlock* pFillInfo->pLinearInfo->pEndPoints = taosArrayInit(pFillSup->numOfAllCols, sizeof(SPoint)); if (!pFillInfo->pLinearInfo->pEndPoints) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } pFillInfo->pLinearInfo->pNextEndPoints = taosArrayInit(pFillSup->numOfAllCols, sizeof(SPoint)); if (!pFillInfo->pLinearInfo->pNextEndPoints) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } for (int32_t i = 0; i < pFillSup->numOfAllCols; i++) { @@ -1236,25 +1236,25 @@ SStreamFillInfo* initStreamFillInfo(SStreamFillSupporter* pFillSup, SSDataBlock* value.val = taosMemoryCalloc(1, pColData->info.bytes); if (!value.val) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } void* tmpRes = taosArrayPush(pFillInfo->pLinearInfo->pEndPoints, &value); if (!tmpRes) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } value.val = taosMemoryCalloc(1, pColData->info.bytes); if (!value.val) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } tmpRes = taosArrayPush(pFillInfo->pLinearInfo->pNextEndPoints, &value); if (!tmpRes) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } } @@ -1266,14 +1266,14 @@ SStreamFillInfo* initStreamFillInfo(SStreamFillSupporter* pFillSup, SSDataBlock* pFillInfo->pResRow = taosMemoryCalloc(1, sizeof(SResultRowData)); if (!pFillInfo->pResRow) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } pFillInfo->pResRow->key = INT64_MIN; pFillInfo->pResRow->pRowVal = taosMemoryCalloc(1, pFillSup->rowSize); if (!pFillInfo->pResRow->pRowVal) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } for (int32_t i = 0; i < pFillSup->numOfAllCols; ++i) { @@ -1288,7 +1288,7 @@ SStreamFillInfo* initStreamFillInfo(SStreamFillSupporter* pFillSup, SSDataBlock* pFillInfo->delRanges = taosArrayInit(16, sizeof(STimeRange)); if (!pFillInfo->delRanges) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } pFillInfo->delIndex = 0; @@ -1311,7 +1311,7 @@ SOperatorInfo* createStreamFillOperatorInfo(SOperatorInfo* downstream, SStreamFi SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } SInterval* pInterval = &((SStreamIntervalOperatorInfo*)downstream->info)->interval; @@ -1320,17 +1320,17 @@ SOperatorInfo* createStreamFillOperatorInfo(SOperatorInfo* downstream, SStreamFi pInfo->pFillSup = initStreamFillSup(pPhyFillNode, pInterval, pFillExprInfo, numOfFillCols, &pTaskInfo->storageAPI); if (!pInfo->pFillSup) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } initResultSizeInfo(&pOperator->resultInfo, 4096); pInfo->pRes = createDataBlockFromDescNode(pPhyFillNode->node.pOutputDataBlockDesc); pInfo->pSrcBlock = createDataBlockFromDescNode(pPhyFillNode->node.pOutputDataBlockDesc); code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); code = blockDataEnsureCapacity(pInfo->pSrcBlock, pOperator->resultInfo.capacity); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); pInfo->pFillInfo = initStreamFillInfo(pInfo->pFillSup, pInfo->pRes); if (!pInfo->pFillInfo) { @@ -1371,11 +1371,11 @@ SOperatorInfo* createStreamFillOperatorInfo(SOperatorInfo* downstream, SStreamFi pInfo->pDelRes = createSpecialDataBlock(STREAM_DELETE_RESULT); if (!pInfo->pDelRes) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } code = blockDataEnsureCapacity(pInfo->pDelRes, pOperator->resultInfo.capacity); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); pInfo->primaryTsCol = ((STargetNode*)pPhyFillNode->pWStartTs)->slotId; pInfo->primarySrcSlotId = ((SColumnNode*)((STargetNode*)pPhyFillNode->pWStartTs)->pExpr)->slotId; @@ -1383,13 +1383,13 @@ SOperatorInfo* createStreamFillOperatorInfo(SOperatorInfo* downstream, SStreamFi int32_t numOfOutputCols = 0; code = extractColMatchInfo(pPhyFillNode->pFillExprs, pPhyFillNode->node.pOutputDataBlockDesc, &numOfOutputCols, COL_MATCH_FROM_SLOT_ID, &pInfo->matchInfo); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); code = filterInitFromNode((SNode*)pPhyFillNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); code = initExprSupp(&pOperator->exprSupp, pFillExprInfo, numOfFillCols, &pTaskInfo->storageAPI.functionStore); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); pInfo->srcRowIndex = -1; setOperatorInfo(pOperator, "StreamFillOperator", QUERY_NODE_PHYSICAL_PLAN_STREAM_FILL, false, OP_NOT_OPENED, pInfo, @@ -1399,7 +1399,7 @@ SOperatorInfo* createStreamFillOperatorInfo(SOperatorInfo* downstream, SStreamFi setOperatorStreamStateFn(pOperator, streamOpReleaseState, streamOpReloadState); code = appendDownstream(pOperator, &downstream, 1); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); return pOperator; _error: diff --git a/source/libs/executor/src/streamtimewindowoperator.c b/source/libs/executor/src/streamtimewindowoperator.c index 50b20344d6..b2af12aab9 100644 --- a/source/libs/executor/src/streamtimewindowoperator.c +++ b/source/libs/executor/src/streamtimewindowoperator.c @@ -272,7 +272,7 @@ static int32_t doDeleteWindows(SOperatorInfo* pOperator, SInterval* pInterval, S qDebug("===stream===save invalid delete window:%" PRId64 ",groupId:%" PRId64 ",chId:%d", winRes.ts, winRes.groupId, childId); code = taosHashPut(pInvalidWins, &winRes, sizeof(SWinKey), NULL, 0); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } SArray* chArray = *(void**)chIds; @@ -289,7 +289,7 @@ static int32_t doDeleteWindows(SOperatorInfo* pOperator, SInterval* pInterval, S void* tmp = taosArrayPush(pUpWins, &winRes); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } if (pUpdatedMap) { @@ -367,7 +367,7 @@ static int32_t closeStreamIntervalWindow(SSHashObj* pHashMap, STimeWindowAggSupp if (pTwSup->calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) { code = saveWinResult(pWinKey, *(SRowBuffPos**)pIte, closeWins); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } int32_t tmpRes = tSimpleHashIterateRemove(pHashMap, pWinKey, sizeof(SWinKey), &pIte, &iter); qTrace("%s at line %d res:%d", __func__, __LINE__, tmpRes); @@ -399,7 +399,7 @@ static void doBuildDeleteResult(SStreamIntervalOperatorInfo* pInfo, SArray* pWin goto _end; } code = blockDataEnsureCapacity(pBlock, size - *index); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); uint64_t uid = 0; for (int32_t i = *index; i < size; i++) { @@ -407,15 +407,17 @@ static void doBuildDeleteResult(SStreamIntervalOperatorInfo* pInfo, SArray* pWin void* tbname = NULL; int32_t winCode = TSDB_CODE_SUCCESS; code = pInfo->stateStore.streamStateGetParName(pInfo->pState, pWin->groupId, &tbname, false, &winCode); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (winCode != TSDB_CODE_SUCCESS) { - appendDataToSpecialBlock(pBlock, &pWin->ts, &pWin->ts, &uid, &pWin->groupId, NULL); + code = appendDataToSpecialBlock(pBlock, &pWin->ts, &pWin->ts, &uid, &pWin->groupId, NULL); + QUERY_CHECK_CODE(code, lino, _end); } else { ASSERT(tbname); char parTbName[VARSTR_HEADER_SIZE + TSDB_TABLE_NAME_LEN]; STR_WITH_MAXSIZE_TO_VARSTR(parTbName, tbname, sizeof(parTbName)); - appendDataToSpecialBlock(pBlock, &pWin->ts, &pWin->ts, &uid, &pWin->groupId, parTbName); + code = appendDataToSpecialBlock(pBlock, &pWin->ts, &pWin->ts, &uid, &pWin->groupId, parTbName); + QUERY_CHECK_CODE(code, lino, _end); } pInfo->stateStore.streamStateFreeVal(tbname); (*index)++; @@ -529,7 +531,7 @@ int32_t initIntervalDownStream(SOperatorInfo* downstream, uint16_t type, SStream if (!pScanInfo->pUpdateInfo) { code = pAPI->updateInfoInitP(&pInfo->interval, pInfo->twAggSup.waterMark, pScanInfo->igCheckUpdate, pScanInfo->pkColType, pScanInfo->pkColLen, &pScanInfo->pUpdateInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } pScanInfo->interval = pInfo->interval; @@ -565,18 +567,18 @@ int32_t compactFunctions(SqlFunctionCtx* pDestCtx, SqlFunctionCtx* pSourceCtx, i SScalarParam out = {.columnData = &idata}; SScalarParam tw = {.numOfRows = 5, .columnData = pTimeWindowData}; code = pDestCtx[k].sfp.process(&tw, 1, &out); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pEntryInfo->numOfRes = 1; } else if (functionNeedToExecute(&pDestCtx[k]) && pDestCtx[k].fpSet.combine != NULL) { code = pDestCtx[k].fpSet.combine(&pDestCtx[k], &pSourceCtx[k]); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } else if (pDestCtx[k].fpSet.combine == NULL) { char* funName = fmGetFuncName(pDestCtx[k].functionId); qError("%s error, combine funcion for %s is not implemented", GET_TASKID(pTaskInfo), funName); taosMemoryFreeClear(funName); code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } @@ -601,7 +603,7 @@ int32_t setIntervalOutputBuf(void* pState, STimeWindow* win, SRowBuffPos** pResu int32_t size = pAggSup->resultRowSize; code = pStore->streamStateAddIfNotExist(pState, &key, (void**)&value, &size, pWinCode); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); *pResult = (SRowBuffPos*)value; SResultRow* res = (SResultRow*)((*pResult)->pRowBuff); @@ -609,7 +611,7 @@ int32_t setIntervalOutputBuf(void* pState, STimeWindow* win, SRowBuffPos** pResu // set time window for current result res->win = (*win); code = setResultRowInitCtx(res, pCtx, numOfOutput, rowEntryInfoOffset); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); _end: if (code != TSDB_CODE_SUCCESS) { @@ -646,11 +648,11 @@ int32_t addPullWindow(SHashObj* pMap, SWinKey* pWinRes, int32_t size) { void* tmp = taosArrayPush(childIds, &i); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } code = taosHashPut(pMap, pWinRes, sizeof(SWinKey), &childIds, sizeof(void*)); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); _end: if (code != TSDB_CODE_SUCCESS) { qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); @@ -682,7 +684,7 @@ static void doBuildPullDataBlock(SArray* array, int32_t* pIndex, SSDataBlock* pB goto _end; } code = blockDataEnsureCapacity(pBlock, size - (*pIndex)); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); SColumnInfoData* pStartTs = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX); SColumnInfoData* pEndTs = (SColumnInfoData*)taosArrayGet(pBlock->pDataBlock, END_TS_COLUMN_INDEX); @@ -692,19 +694,19 @@ static void doBuildPullDataBlock(SArray* array, int32_t* pIndex, SSDataBlock* pB for (; (*pIndex) < size; (*pIndex)++) { SPullWindowInfo* pWin = taosArrayGet(array, (*pIndex)); code = colDataSetVal(pStartTs, pBlock->info.rows, (const char*)&pWin->window.skey, false); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = colDataSetVal(pEndTs, pBlock->info.rows, (const char*)&pWin->window.ekey, false); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = colDataSetVal(pGroupId, pBlock->info.rows, (const char*)&pWin->groupId, false); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = colDataSetVal(pCalStartTs, pBlock->info.rows, (const char*)&pWin->calWin.skey, false); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = colDataSetVal(pCalEndTs, pBlock->info.rows, (const char*)&pWin->calWin.ekey, false); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pBlock->info.rows++; } @@ -713,7 +715,7 @@ static void doBuildPullDataBlock(SArray* array, int32_t* pIndex, SSDataBlock* pB taosArrayClear(array); } code = blockDataUpdateTsWindow(pBlock, 0); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); _end: if (code != TSDB_CODE_SUCCESS) { @@ -772,21 +774,21 @@ static int32_t processPullOver(SSDataBlock* pBlock, SHashObj* pMap, SHashObj* pF void* tmp = taosArrayPush(pInfo->pMidPullDatas, &winRes); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } else if (savePullWindow(&pull, pPullWins) == TSDB_CODE_SUCCESS) { void* tmp = taosArrayPush(pInfo->pDelWins, &winRes); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } code = addPullWindow(pMap, &winRes, numOfCh); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->destHasPrimaryKey) { code = tSimpleHashPut(pInfo->pDeletedMap, &winRes, sizeof(SWinKey), NULL, 0); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } qDebug("===stream===prepare final retrive for delete %" PRId64 ", size:%d", winRes.ts, numOfCh); } @@ -822,11 +824,11 @@ static int32_t addRetriveWindow(SArray* wins, SStreamIntervalOperatorInfo* pInfo // add pull data request if (savePullWindow(&pull, pInfo->pPullWins) == TSDB_CODE_SUCCESS) { code = addPullWindow(pInfo->pPullDataMap, winKey, pInfo->numOfChild); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->destHasPrimaryKey) { code = tSimpleHashPut(pInfo->pDeletedMap, winKey, sizeof(SWinKey), NULL, 0); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } qDebug("===stream===prepare retrive for delete %" PRId64 ", size:%d", winKey->ts, pInfo->numOfChild); } @@ -837,7 +839,7 @@ static int32_t addRetriveWindow(SArray* wins, SStreamIntervalOperatorInfo* pInfo if (index == -1) { qDebug("===stream===add final retrive %" PRId64, winKey->ts); code = taosHashPut(pInfo->pFinalPullDataMap, winKey, sizeof(SWinKey), NULL, 0); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } } @@ -876,7 +878,7 @@ void buildDataBlockFromGroupRes(SOperatorInfo* pOperator, void* pState, SSDataBl SRowBuffPos* pPos = *(SRowBuffPos**)taosArrayGet(pGroupResInfo->pRows, i); SResultRow* pRow = NULL; code = getOutputBuf(pState, pPos, &pRow, &pAPI->stateStore); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); uint64_t groupId = ((SWinKey*)pPos->pKey)->groupId; doUpdateNumOfRows(pCtx, pRow, numOfExprs, rowEntryOffset); // no results, continue to check the next one @@ -890,7 +892,7 @@ void buildDataBlockFromGroupRes(SOperatorInfo* pOperator, void* pState, SSDataBl int32_t winCode = TSDB_CODE_SUCCESS; code = pAPI->stateStore.streamStateGetParName(pTaskInfo->streamInfo.pState, pBlock->info.id.groupId, &tbname, false, &winCode); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (winCode != TSDB_CODE_SUCCESS) { pBlock->info.parTbName[0] = 0; } else { @@ -919,7 +921,7 @@ void buildDataBlockFromGroupRes(SOperatorInfo* pOperator, void* pState, SSDataBl int32_t tmpRes = pCtx[j].fpSet.finalize(&pCtx[j], pBlock); if (TAOS_FAILED(tmpRes)) { qError("%s build result data block error, code %s", GET_TASKID(pTaskInfo), tstrerror(tmpRes)); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } else if (strcmp(pCtx[j].pExpr->pExpr->_function.functionName, "_select_value") == 0) { // do nothing, todo refactor @@ -930,7 +932,7 @@ void buildDataBlockFromGroupRes(SOperatorInfo* pOperator, void* pState, SSDataBl char* in = GET_ROWCELL_INTERBUF(pCtx[j].resultInfo); for (int32_t k = 0; k < pRow->numOfRows; ++k) { code = colDataSetVal(pColInfoData, pBlock->info.rows + k, in, pCtx[j].resultInfo->isNullRes); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } } @@ -940,7 +942,7 @@ void buildDataBlockFromGroupRes(SOperatorInfo* pOperator, void* pState, SSDataBl pBlock->info.dataLoad = 1; code = blockDataUpdateTsWindow(pBlock, 0); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); _end: if (code != TSDB_CODE_SUCCESS) { @@ -1009,7 +1011,7 @@ static void doStreamIntervalAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDat qError("table uid %" PRIu64 " data block timestamp range may not be calculated! minKey %" PRId64 ",maxKey %" PRId64, pSDataBlock->info.id.uid, pSDataBlock->info.window.skey, pSDataBlock->info.window.ekey); code = blockDataUpdateTsWindow(pSDataBlock, pInfo->primaryTsIndex); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); // timestamp of the data is incorrect if (pSDataBlock->info.window.skey <= 0 || pSDataBlock->info.window.ekey <= 0) { @@ -1061,11 +1063,11 @@ static void doStreamIntervalAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDat // add pull data request if (savePullWindow(&pull, pInfo->pPullWins) == TSDB_CODE_SUCCESS) { code = addPullWindow(pInfo->pPullDataMap, &winRes, pInfo->numOfChild); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->destHasPrimaryKey) { code = tSimpleHashPut(pInfo->pDeletedMap, &winRes, sizeof(SWinKey), NULL, 0); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } } else { @@ -1094,7 +1096,7 @@ static void doStreamIntervalAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDat int32_t winCode = TSDB_CODE_SUCCESS; code = setIntervalOutputBuf(pInfo->pState, &nextWin, &pResPos, groupId, pSup->pCtx, numOfOutput, pSup->rowEntryInfoOffset, &pInfo->aggSup, &pInfo->stateStore, &winCode); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pResult = (SResultRow*)pResPos->pRowBuff; @@ -1112,18 +1114,18 @@ static void doStreamIntervalAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDat if (pInfo->destHasPrimaryKey && winCode == TSDB_CODE_SUCCESS && IS_NORMAL_INTERVAL_OP(pOperator)) { code = tSimpleHashPut(pDeletedMap, &key, sizeof(SWinKey), NULL, 0); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE && pUpdatedMap) { code = saveWinResult(&key, pResPos, pUpdatedMap); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) { pResPos->beUpdated = true; code = tSimpleHashPut(pInfo->aggSup.pResultRowHashTable, &key, sizeof(SWinKey), &pResPos, POINTER_BYTES); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } updateTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &nextWin, 1); @@ -1257,7 +1259,7 @@ int32_t decodeSPullWindowInfoArray(void* buf, SArray* pPullInfos, void** ppBuf) void* tmp = taosArrayPush(pPullInfos, &item); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } (*ppBuf) = buf; @@ -1332,7 +1334,7 @@ void doStreamIntervalDecodeOpState(void* buf, int32_t len, SOperatorInfo* pOpera SStreamIntervalOperatorInfo* pInfo = pOperator->info; if (!pInfo) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } // 6.checksum @@ -1340,7 +1342,7 @@ void doStreamIntervalDecodeOpState(void* buf, int32_t len, SOperatorInfo* pOpera void* pCksum = POINTER_SHIFT(buf, dataLen); if (taosCheckChecksum(buf, dataLen, *(uint32_t*)pCksum) != TSDB_CODE_SUCCESS) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } // 1.pResultRowHashTable @@ -1353,11 +1355,11 @@ void doStreamIntervalDecodeOpState(void* buf, int32_t len, SOperatorInfo* pOpera int32_t resSize = pInfo->aggSup.resultRowSize; int32_t winCode = TSDB_CODE_SUCCESS; code = pInfo->stateStore.streamStateAddIfNotExist(pInfo->pState, &key, (void**)&pPos, &resSize, &winCode); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); ASSERT(winCode == TSDB_CODE_SUCCESS); code = tSimpleHashPut(pInfo->aggSup.pResultRowHashTable, &key, sizeof(SWinKey), &pPos, POINTER_BYTES); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } // 2.twAggSup @@ -1371,7 +1373,7 @@ void doStreamIntervalDecodeOpState(void* buf, int32_t len, SOperatorInfo* pOpera SArray* pArray = taosArrayInit(0, sizeof(int32_t)); if (!pArray) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } buf = decodeSWinKey(buf, &key); @@ -1383,16 +1385,16 @@ void doStreamIntervalDecodeOpState(void* buf, int32_t len, SOperatorInfo* pOpera void* tmp = taosArrayPush(pArray, &chId); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } code = taosHashPut(pInfo->pPullDataMap, &key, sizeof(SWinKey), &pArray, POINTER_BYTES); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } // 4.pPullWins code = decodeSPullWindowInfoArray(buf, pInfo->pPullWins, &buf); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); // 5.dataVersion buf = taosDecodeFixedI64(buf, &pInfo->dataVersion); @@ -1427,7 +1429,7 @@ static int32_t copyIntervalDeleteKey(SSHashObj* pMap, SArray* pWins) { void* tmp = taosArrayPush(pWins, pKey); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } tSimpleHashClear(pMap); @@ -1484,7 +1486,7 @@ int32_t copyUpdateResult(SSHashObj** ppWinUpdated, SArray* pUpdated, __compar_fn void* tmp = taosArrayPush(pUpdated, pIte); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } taosArraySort(pUpdated, compar); @@ -1585,18 +1587,18 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) { SArray* delWins = taosArrayInit(8, sizeof(SWinKey)); SHashObj* finalMap = IS_FINAL_INTERVAL_OP(pOperator) ? pInfo->pFinalPullDataMap : NULL; code = doDeleteWindows(pOperator, &pInfo->interval, pBlock, delWins, pInfo->pUpdatedMap, finalMap); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (IS_FINAL_INTERVAL_OP(pOperator)) { int32_t chId = getChildIndex(pBlock); code = addRetriveWindow(delWins, pInfo, chId); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pBlock->info.type != STREAM_CLEAR) { void* tmp = taosArrayAddAll(pInfo->pDelWins, delWins); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } taosArrayDestroy(delWins); @@ -1606,7 +1608,7 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) { void* tmp = taosArrayAddAll(pInfo->pDelWins, delWins); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } taosArrayDestroy(delWins); @@ -1626,24 +1628,24 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) { } else if (pBlock->info.type == STREAM_GET_ALL && IS_FINAL_INTERVAL_OP(pOperator)) { pInfo->recvGetAll = true; code = getAllIntervalWindow(pInfo->aggSup.pResultRowHashTable, pInfo->pUpdatedMap); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } else if (pBlock->info.type == STREAM_RETRIEVE) { if (!IS_FINAL_INTERVAL_OP(pOperator)) { pInfo->recvRetrive = true; code = copyDataBlock(pInfo->pMidRetriveRes, pBlock); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pInfo->pMidRetriveRes->info.type = STREAM_MID_RETRIEVE; code = doDeleteWindows(pOperator, &pInfo->interval, pBlock, NULL, pInfo->pUpdatedMap, NULL); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); break; } continue; } else if (pBlock->info.type == STREAM_PULL_OVER && IS_FINAL_INTERVAL_OP(pOperator)) { code = processPullOver(pBlock, pInfo->pPullDataMap, pInfo->pFinalPullDataMap, &pInfo->interval, pInfo->pPullWins, pInfo->numOfChild, pOperator, NULL); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } else if (pBlock->info.type == STREAM_CREATE_CHILD_TABLE) { return pBlock; @@ -1651,7 +1653,7 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) { pAPI->stateStore.streamStateCommit(pInfo->pState); doStreamIntervalSaveCheckpoint(pOperator); code = copyDataBlock(pInfo->pCheckpointRes, pBlock); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } else if (IS_FINAL_INTERVAL_OP(pOperator) && pBlock->info.type == STREAM_MID_RETRIEVE) { @@ -1663,7 +1665,7 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) { if (pInfo->scalarSupp.pExprInfo != NULL) { SExprSupp* pExprSup = &pInfo->scalarSupp; code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); doStreamIntervalAggImpl(pOperator, pBlock, pBlock->info.id.groupId, pInfo->pUpdatedMap, pInfo->pDeletedMap); @@ -1678,22 +1680,22 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) { if (IS_FINAL_INTERVAL_OP(pOperator)) { code = closeStreamIntervalWindow(pInfo->aggSup.pResultRowHashTable, &pInfo->twAggSup, &pInfo->interval, pInfo->pPullDataMap, pInfo->pUpdatedMap, pInfo->pDelWins, pOperator); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->destHasPrimaryKey) { code = copyIntervalDeleteKey(pInfo->pDeletedMap, pInfo->pDelWins); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } pInfo->binfo.pRes->info.watermark = pInfo->twAggSup.maxTs; code = copyUpdateResult(&pInfo->pUpdatedMap, pInfo->pUpdated, winPosCmprImpl); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); initMultiResInfoFromArrayList(&pInfo->groupResInfo, pInfo->pUpdated); pInfo->pUpdated = NULL; code = blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); SSDataBlock* resBlock = buildIntervalResult(pOperator); if (resBlock != NULL) { @@ -1778,7 +1780,7 @@ void streamIntervalReloadState(SOperatorInfo* pOperator) { void* pBuf = NULL; code = pInfo->stateStore.streamStateGetInfo(pInfo->pState, STREAM_INTERVAL_OP_STATE_NAME, strlen(STREAM_INTERVAL_OP_STATE_NAME), &pBuf, &size); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); TSKEY ts = *(TSKEY*)pBuf; taosMemoryFree(pBuf); @@ -1807,7 +1809,7 @@ SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } pOperator->exprSupp.hasWindowOrGroup = true; @@ -1837,7 +1839,7 @@ SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, int32_t numOfScalar = 0; SExprInfo* pScalarExprInfo = createExprInfo(pIntervalPhyNode->window.pExprs, NULL, &numOfScalar); code = initExprSupp(&pInfo->scalarSupp, pScalarExprInfo, numOfScalar, &pTaskInfo->storageAPI.functionStore); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } int32_t numOfCols = 0; @@ -1855,7 +1857,7 @@ SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, pAPI->stateStore.streamStateSetNumber(pInfo->pState, -1, pInfo->primaryTsIndex); code = initAggSup(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, numOfCols, keyBufSize, pTaskInfo->id.str, pInfo->pState, &pTaskInfo->storageAPI.functionStore); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); initResultRowInfo(&pInfo->binfo.resultRowInfo); @@ -1916,10 +1918,10 @@ SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, if (pPhyNode->type == QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL || pPhyNode->type == QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL) { code = initIntervalDownStream(downstream, pPhyNode->type, pInfo); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } code = appendDownstream(pOperator, &downstream, 1); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); // for stream void* buff = NULL; @@ -2026,7 +2028,7 @@ int32_t initDownStream(SOperatorInfo* downstream, SStreamAggSupporter* pAggSup, code = pAggSup->stateStore.updateInfoInit(60000, TSDB_TIME_PRECISION_MILLI, pTwSup->waterMark, pScanInfo->igCheckUpdate, pScanInfo->pkColType, pScanInfo->pkColLen, &pScanInfo->pUpdateInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } pScanInfo->twAggSup = *pTwSup; pAggSup->pUpdateInfo = pScanInfo->pUpdateInfo; @@ -2125,7 +2127,7 @@ int32_t setSessionOutputBuf(SStreamAggSupporter* pAggSup, TSKEY startTs, TSKEY e int32_t winCode = TSDB_CODE_SUCCESS; code = pAggSup->stateStore.streamStateSessionAddIfNotExist(pAggSup->pState, &pCurWin->sessionWin, pAggSup->gap, (void**)&pCurWin->pStatePos, &size, &winCode); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (winCode == TSDB_CODE_SUCCESS && !inWinRange(&pAggSup->winRange, &pCurWin->sessionWin.win)) { winCode = TSDB_CODE_FAILED; @@ -2169,7 +2171,7 @@ int32_t saveDeleteInfo(SArray* pWins, SSessionKey key) { void* res = taosArrayPush(pWins, &key); if (!res) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } _end: @@ -2260,7 +2262,7 @@ int32_t updateSessionWindowInfo(SStreamAggSupporter* pAggSup, SResultWindowInfo* if (pWinInfo->sessionWin.win.skey > pStartTs[i]) { if (pStDeleted && pWinInfo->isOutput) { code = saveDeleteRes(pStDeleted, pWinInfo->sessionWin); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } removeSessionResult(pAggSup, pStUpdated, pResultRows, &pWinInfo->sessionWin); pWinInfo->sessionWin.win.skey = pStartTs[i]; @@ -2297,7 +2299,7 @@ int32_t doOneWindowAggImpl(SColumnInfoData* pTimeWindowData, SResultWindowInfo* SExprSupp* pSup = &pOperator->exprSupp; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; code = initSessionOutputBuf(pCurWin, pResult, pSup->pCtx, numOutput, pSup->rowEntryInfoOffset); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); updateTimeWindowInfo(pTimeWindowData, &pCurWin->sessionWin.win, winDelta); applyAggFunctionOnPartialTuples(pTaskInfo, pSup->pCtx, pTimeWindowData, startIndex, winRows, rows, numOutput); @@ -2350,11 +2352,11 @@ int32_t compactTimeWindow(SExprSupp* pSup, SStreamAggSupporter* pAggSup, STimeWi SResultRow* pCurResult = NULL; int32_t numOfOutput = pSup->numOfExprs; code = initSessionOutputBuf(pCurWin, &pCurResult, pSup->pCtx, numOfOutput, pSup->rowEntryInfoOffset); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); SResultRow* pWinResult = NULL; code = initSessionOutputBuf(pNextWin, &pWinResult, pAggSup->pDummyCtx, numOfOutput, pSup->rowEntryInfoOffset); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pCurWin->sessionWin.win.ekey = TMAX(pCurWin->sessionWin.win.ekey, pNextWin->sessionWin.win.ekey); memcpy(pCurWin->pStatePos->pKey, &pCurWin->sessionWin, sizeof(SSessionKey)); @@ -2365,7 +2367,7 @@ int32_t compactTimeWindow(SExprSupp* pSup, SStreamAggSupporter* pAggSup, STimeWi } updateTimeWindowInfo(&pTwAggSup->timeWindowData, &pCurWin->sessionWin.win, winDelta); code = compactFunctions(pSup->pCtx, pAggSup->pDummyCtx, numOfOutput, pTaskInfo, &pTwAggSup->timeWindowData); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); int32_t tmpRes = tSimpleHashRemove(pStUpdated, &pNextWin->sessionWin, sizeof(SSessionKey)); qTrace("%s at line %d res:%d", __func__, __LINE__, tmpRes); @@ -2374,7 +2376,7 @@ int32_t compactTimeWindow(SExprSupp* pSup, SStreamAggSupporter* pAggSup, STimeWi qDebug("===stream=== save delete window info %" PRId64 ", %" PRIu64, pNextWin->sessionWin.win.skey, pNextWin->sessionWin.groupId); code = saveDeleteRes(pStDeleted, pNextWin->sessionWin); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } removeSessionResult(pAggSup, pStUpdated, pAggSup->pResultRows, &pNextWin->sessionWin); doDeleteSessionWindow(pAggSup, &pNextWin->sessionWin); @@ -2411,7 +2413,7 @@ static int32_t compactSessionWindow(SOperatorInfo* pOperator, SResultWindowInfo* } code = compactTimeWindow(pSup, pAggSup, &pInfo->twAggSup, pTaskInfo, pCurWin, &winInfo, pStUpdated, pStDeleted, true); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); winNum++; } if (pWinNum) { @@ -2506,7 +2508,7 @@ static void doStreamSessionAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSData } SResultWindowInfo winInfo = {0}; code = setSessionOutputBuf(pAggSup, startTsCols[i], endTsCols[i], groupId, &winInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); // coverity scan error if (!winInfo.pStatePos) { @@ -2515,7 +2517,7 @@ static void doStreamSessionAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSData setSessionWinOutputInfo(pStUpdated, &winInfo); code = updateSessionWindowInfo(pAggSup, &winInfo, startTsCols, endTsCols, groupId, rows, i, pAggSup->gap, pAggSup->pResultRows, pStUpdated, pStDeleted, &winRows); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); int64_t winDelta = 0; if (addGap) { @@ -2523,28 +2525,28 @@ static void doStreamSessionAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSData } code = doOneWindowAggImpl(&pInfo->twAggSup.timeWindowData, &winInfo, &pResult, i, winRows, rows, numOfOutput, pOperator, winDelta); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = compactSessionWindow(pOperator, &winInfo, pStUpdated, pStDeleted, addGap, NULL); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = saveSessionOutputBuf(pAggSup, &winInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->destHasPrimaryKey && winInfo.isOutput && IS_NORMAL_SESSION_OP(pOperator)) { code = saveDeleteRes(pInfo->pPkDeleted, winInfo.sessionWin); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE && pStUpdated) { code = saveResult(winInfo, pStUpdated); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) { winInfo.pStatePos->beUpdated = true; SSessionKey key = {0}; getSessionHashKey(&winInfo.sessionWin, &key); code = tSimpleHashPut(pAggSup->pResultRows, &key, sizeof(SSessionKey), &winInfo, sizeof(SResultWindowInfo)); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } i += winRows; @@ -2575,7 +2577,7 @@ int32_t doDeleteTimeWindows(SStreamAggSupporter* pAggSup, SSDataBlock* pBlock, S doDeleteSessionWindow(pAggSup, &curWin); if (result) { code = saveDeleteInfo(result, curWin); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } } @@ -2619,7 +2621,7 @@ void doBuildDeleteDataBlock(SOperatorInfo* pOp, SSHashObj* pStDeleted, SSDataBlo return; } code = blockDataEnsureCapacity(pBlock, size); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); int32_t iter = 0; while (((*Ite) = tSimpleHashIterate(pStDeleted, *Ite, &iter)) != NULL) { @@ -2629,18 +2631,18 @@ void doBuildDeleteDataBlock(SOperatorInfo* pOp, SSHashObj* pStDeleted, SSDataBlo SSessionKey* res = tSimpleHashGetKey(*Ite, NULL); SColumnInfoData* pStartTsCol = taosArrayGet(pBlock->pDataBlock, START_TS_COLUMN_INDEX); code = colDataSetVal(pStartTsCol, pBlock->info.rows, (const char*)&res->win.skey, false); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); SColumnInfoData* pEndTsCol = taosArrayGet(pBlock->pDataBlock, END_TS_COLUMN_INDEX); code = colDataSetVal(pEndTsCol, pBlock->info.rows, (const char*)&res->win.skey, false); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); SColumnInfoData* pUidCol = taosArrayGet(pBlock->pDataBlock, UID_COLUMN_INDEX); colDataSetNULL(pUidCol, pBlock->info.rows); SColumnInfoData* pGpCol = taosArrayGet(pBlock->pDataBlock, GROUPID_COLUMN_INDEX); code = colDataSetVal(pGpCol, pBlock->info.rows, (const char*)&res->groupId, false); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); SColumnInfoData* pCalStCol = taosArrayGet(pBlock->pDataBlock, CALCULATE_START_TS_COLUMN_INDEX); colDataSetNULL(pCalStCol, pBlock->info.rows); @@ -2650,14 +2652,14 @@ void doBuildDeleteDataBlock(SOperatorInfo* pOp, SSHashObj* pStDeleted, SSDataBlo SColumnInfoData* pTableCol = taosArrayGet(pBlock->pDataBlock, TABLE_NAME_COLUMN_INDEX); if (!pTableCol) { - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } void* tbname = NULL; int32_t winCode = TSDB_CODE_SUCCESS; code = pAPI->stateStore.streamStateGetParName(pOp->pTaskInfo->streamInfo.pState, res->groupId, &tbname, false, &winCode); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (winCode != TSDB_CODE_SUCCESS) { colDataSetNULL(pTableCol, pBlock->info.rows); @@ -2665,7 +2667,7 @@ void doBuildDeleteDataBlock(SOperatorInfo* pOp, SSHashObj* pStDeleted, SSDataBlo char parTbName[VARSTR_HEADER_SIZE + TSDB_TABLE_NAME_LEN]; STR_WITH_MAXSIZE_TO_VARSTR(parTbName, tbname, sizeof(parTbName)); code = colDataSetVal(pTableCol, pBlock->info.rows, (const char*)parTbName, false); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pAPI->stateStore.streamStateFreeVal(tbname); } pBlock->info.rows += 1; @@ -2721,12 +2723,12 @@ static int32_t rebuildSessionWindow(SOperatorInfo* pOperator, SArray* pWinArray, if (winCode == TSDB_CODE_SUCCESS && inWinRange(&pWinKey->win, &childWin.sessionWin.win)) { if (num == 0) { code = setSessionOutputBuf(pAggSup, pWinKey->win.skey, pWinKey->win.ekey, pWinKey->groupId, &parentWin); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); parentWin.sessionWin = childWin.sessionWin; memcpy(parentWin.pStatePos->pKey, &parentWin.sessionWin, sizeof(SSessionKey)); code = initSessionOutputBuf(&parentWin, &pResult, pSup->pCtx, numOfOutput, pSup->rowEntryInfoOffset); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } num++; parentWin.sessionWin.win.skey = TMIN(parentWin.sessionWin.win.skey, childWin.sessionWin.win.skey); @@ -2736,14 +2738,14 @@ static int32_t rebuildSessionWindow(SOperatorInfo* pOperator, SArray* pWinArray, updateTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &parentWin.sessionWin.win, pAggSup->gap); code = initSessionOutputBuf(&childWin, &pChResult, pChild->exprSupp.pCtx, numOfOutput, pChild->exprSupp.rowEntryInfoOffset); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = compactFunctions(pSup->pCtx, pChild->exprSupp.pCtx, numOfOutput, pTaskInfo, &pInfo->twAggSup.timeWindowData); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = compactSessionWindow(pOperator, &parentWin, pStUpdated, NULL, true, NULL); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); releaseOutputBuf(pAggSup->pState, childWin.pStatePos, &pAggSup->stateStore); } else { @@ -2755,10 +2757,10 @@ static int32_t rebuildSessionWindow(SOperatorInfo* pOperator, SArray* pWinArray, } if (num > 0) { code = saveResult(parentWin, pStUpdated); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = saveSessionOutputBuf(pAggSup, &parentWin); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } @@ -2779,11 +2781,11 @@ int32_t closeSessionWindow(SSHashObj* pHashMap, STimeWindowAggSupp* pTwSup, SSHa if (isCloseWindow(&pWinInfo->sessionWin.win, pTwSup)) { if (pTwSup->calTrigger == STREAM_TRIGGER_WINDOW_CLOSE && pClosed) { code = saveResult(*pWinInfo, pClosed); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } SSessionKey* pKey = tSimpleHashGetKey(pIte, NULL); code = tSimpleHashIterateRemove(pHashMap, pKey, sizeof(SSessionKey), &pIte, &iter); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } _end: @@ -2803,7 +2805,7 @@ static int32_t closeChildSessionWindow(SArray* pChildren, TSKEY maxTs) { SStreamSessionAggOperatorInfo* pChInfo = pChildOp->info; pChInfo->twAggSup.maxTs = TMAX(pChInfo->twAggSup.maxTs, maxTs); code = closeSessionWindow(pChInfo->streamAggSup.pResultRows, &pChInfo->twAggSup, NULL); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } _end: if (code != TSDB_CODE_SUCCESS) { @@ -2824,7 +2826,7 @@ int32_t getAllSessionWindow(SSHashObj* pHashMap, SSHashObj* pStUpdated) { } pWinInfo->pStatePos->beUpdated = false; code = saveResult(*pWinInfo, pStUpdated); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } _end: @@ -2844,7 +2846,7 @@ int32_t copyDeleteWindowInfo(SArray* pResWins, SSHashObj* pStDeleted) { SSessionKey winInfo = {0}; getSessionHashKey(pWinKey, &winInfo); code = tSimpleHashPut(pStDeleted, &winInfo, sizeof(SSessionKey), NULL, 0); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } _end: @@ -2888,7 +2890,7 @@ int32_t buildSessionResultDataBlock(SOperatorInfo* pOperator, void* pState, SSDa int32_t winCode = TSDB_CODE_SUCCESS; code = pAPI->stateStore.streamStateGetParName((void*)pTaskInfo->streamInfo.pState, pBlock->info.id.groupId, &tbname, false, &winCode); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (winCode != TSDB_CODE_SUCCESS) { pBlock->info.parTbName[0] = 0; @@ -2904,7 +2906,7 @@ int32_t buildSessionResultDataBlock(SOperatorInfo* pOperator, void* pState, SSDa } code = pAPI->stateStore.streamStateGetByPos(pState, pPos, (void**)&pRow); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); doUpdateNumOfRows(pCtx, pRow, numOfExprs, rowEntryOffset); // no results, continue to check the next one @@ -2928,7 +2930,7 @@ int32_t buildSessionResultDataBlock(SOperatorInfo* pOperator, void* pState, SSDa int32_t tmpRes = pCtx[j].fpSet.finalize(&pCtx[j], pBlock); if (TAOS_FAILED(tmpRes)) { qError("%s build result data block error, code %s", GET_TASKID(pTaskInfo), tstrerror(tmpRes)); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } else if (strcmp(pCtx[j].pExpr->pExpr->_function.functionName, "_select_value") == 0) { // do nothing, todo refactor @@ -2939,7 +2941,7 @@ int32_t buildSessionResultDataBlock(SOperatorInfo* pOperator, void* pState, SSDa char* in = GET_ROWCELL_INTERBUF(pCtx[j].resultInfo); for (int32_t k = 0; k < pRow->numOfRows; ++k) { code = colDataSetVal(pColInfoData, pBlock->info.rows + k, in, pCtx[j].resultInfo->isNullRes); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } } @@ -2948,7 +2950,7 @@ int32_t buildSessionResultDataBlock(SOperatorInfo* pOperator, void* pState, SSDa pBlock->info.rows += pRow->numOfRows; } code = blockDataUpdateTsWindow(pBlock, 0); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); _end: if (code != TSDB_CODE_SUCCESS) { @@ -2973,7 +2975,7 @@ void doBuildSessionResult(SOperatorInfo* pOperator, void* pState, SGroupResInfo* // clear the existed group id pBlock->info.id.groupId = 0; code = buildSessionResultDataBlock(pOperator, pState, pBlock, &pOperator->exprSupp, pGroupResInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pBlock->info.rows == 0) { cleanupGroupResInfo(pGroupResInfo); @@ -3016,7 +3018,7 @@ int32_t getMaxTsWins(const SArray* pAllWins, SArray* pMaxWins) { void* tmp = taosArrayPush(pMaxWins, pSeKey); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (pSeKey->groupId == 0) { @@ -3030,7 +3032,7 @@ int32_t getMaxTsWins(const SArray* pAllWins, SArray* pMaxWins) { void* tmp = taosArrayPush(pMaxWins, pSeKey); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } preGpId = pSeKey->groupId; } @@ -3123,7 +3125,7 @@ int32_t doStreamSessionDecodeOpState(void* buf, int32_t len, SOperatorInfo* pOpe SStreamSessionAggOperatorInfo* pInfo = pOperator->info; if (!pInfo) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } SStreamAggSupporter* pAggSup = &pInfo->streamAggSup; @@ -3134,7 +3136,7 @@ int32_t doStreamSessionDecodeOpState(void* buf, int32_t len, SOperatorInfo* pOpe if (taosCheckChecksum(buf, dataLen, *(uint32_t*)pCksum) != TSDB_CODE_SUCCESS) { qError("stream session state is invalid"); code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } @@ -3148,13 +3150,13 @@ int32_t doStreamSessionDecodeOpState(void* buf, int32_t len, SOperatorInfo* pOpe int32_t winCode = TSDB_CODE_SUCCESS; code = pAggSup->stateStore.streamStateSessionAddIfNotExist( pAggSup->pState, &winfo.sessionWin, pAggSup->gap, (void**)&winfo.pStatePos, &pAggSup->resultRowSize, &winCode); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); ASSERT(winCode == TSDB_CODE_SUCCESS); buf = decodeSResultWindowInfo(buf, &winfo, pInfo->streamAggSup.resultRowSize); code = tSimpleHashPut(pInfo->streamAggSup.pResultRows, &key, sizeof(SSessionKey), &winfo, sizeof(SResultWindowInfo)); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } // 2.twAggSup @@ -3167,7 +3169,7 @@ int32_t doStreamSessionDecodeOpState(void* buf, int32_t len, SOperatorInfo* pOpe for (int32_t i = 0; i < size; i++) { SOperatorInfo* pChOp = taosArrayGetP(pInfo->pChildren, i); code = doStreamSessionDecodeOpState(buf, 0, pChOp, false, &buf); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } // 4.dataVersion @@ -3218,7 +3220,7 @@ int32_t copyDeleteSessionKey(SSHashObj* source, SSHashObj* dest) { while ((pIte = tSimpleHashIterate(source, pIte, &iter)) != NULL) { SSessionKey* pKey = tSimpleHashGetKey(pIte, &keyLen); code = saveDeleteRes(dest, *pKey); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } tSimpleHashClear(source); @@ -3282,7 +3284,7 @@ static SSDataBlock* doStreamSessionAgg(SOperatorInfo* pOperator) { SArray* pWins = taosArrayInit(16, sizeof(SSessionKey)); // gap must be 0 code = doDeleteTimeWindows(pAggSup, pBlock, pWins); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); removeSessionResults(pAggSup, pInfo->pStUpdated, pWins); if (IS_FINAL_SESSION_OP(pOperator)) { @@ -3291,24 +3293,24 @@ static SSDataBlock* doStreamSessionAgg(SOperatorInfo* pOperator) { SStreamSessionAggOperatorInfo* pChildInfo = pChildOp->info; // gap must be 0 code = doDeleteTimeWindows(&pChildInfo->streamAggSup, pBlock, NULL); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = rebuildSessionWindow(pOperator, pWins, pInfo->pStUpdated); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } code = copyDeleteWindowInfo(pWins, pInfo->pStDeleted); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->destHasPrimaryKey && IS_NORMAL_SESSION_OP(pOperator)) { code = copyDeleteWindowInfo(pWins, pInfo->pPkDeleted); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } taosArrayDestroy(pWins); continue; } else if (pBlock->info.type == STREAM_GET_ALL) { pInfo->recvGetAll = true; code = getAllSessionWindow(pAggSup->pResultRows, pInfo->pStUpdated); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } else if (pBlock->info.type == STREAM_CREATE_CHILD_TABLE) { return pBlock; @@ -3316,7 +3318,7 @@ static SSDataBlock* doStreamSessionAgg(SOperatorInfo* pOperator) { pAggSup->stateStore.streamStateCommit(pAggSup->pState); doStreamSessionSaveCheckpoint(pOperator); code = copyDataBlock(pInfo->pCheckpointRes, pBlock); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } else { @@ -3326,7 +3328,7 @@ static SSDataBlock* doStreamSessionAgg(SOperatorInfo* pOperator) { if (pInfo->scalarSupp.pExprInfo != NULL) { SExprSupp* pExprSup = &pInfo->scalarSupp; code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } // the pDataBlock are always the same one, no need to call this again setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); @@ -3342,12 +3344,12 @@ static SSDataBlock* doStreamSessionAgg(SOperatorInfo* pOperator) { if (!pChildOp) { qError("%s create stream child of final session error", GET_TASKID(pTaskInfo)); code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } void* tmp = taosArrayPush(pInfo->pChildren, &pChildOp); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } SOperatorInfo* pChildOp = taosArrayGetP(pInfo->pChildren, chIndex); @@ -3361,29 +3363,29 @@ static SSDataBlock* doStreamSessionAgg(SOperatorInfo* pOperator) { pOperator->status = OP_RES_TO_RETURN; code = closeSessionWindow(pAggSup->pResultRows, &pInfo->twAggSup, pInfo->pStUpdated); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = closeChildSessionWindow(pInfo->pChildren, pInfo->twAggSup.maxTs); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = copyUpdateResult(&pInfo->pStUpdated, pInfo->pUpdated, sessionKeyCompareAsc); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (!pInfo->destHasPrimaryKey) { removeSessionDeleteResults(pInfo->pStDeleted, pInfo->pUpdated); } if (pInfo->isHistoryOp) { code = getMaxTsWins(pInfo->pUpdated, pInfo->historyWins); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (pInfo->destHasPrimaryKey && IS_NORMAL_SESSION_OP(pOperator)) { code = copyDeleteSessionKey(pInfo->pPkDeleted, pInfo->pStDeleted); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } initGroupResInfoFromArrayList(&pInfo->groupResInfo, pInfo->pUpdated); pInfo->pUpdated = NULL; code = blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); SSDataBlock* opRes = buildSessionResult(pOperator); if (opRes) { @@ -3427,7 +3429,7 @@ int32_t getSessionWindowInfoByKey(SStreamAggSupporter* pAggSup, SSessionKey* pKe int32_t winCode = TSDB_CODE_SUCCESS; code = pAggSup->stateStore.streamStateSessionGet(pAggSup->pState, pKey, (void**)&pWinInfo->pStatePos, &rowSize, &winCode); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (winCode == TSDB_CODE_SUCCESS) { pWinInfo->sessionWin = *pKey; @@ -3470,7 +3472,7 @@ void streamSessionSemiReloadState(SOperatorInfo* pOperator) { void* pBuf = NULL; code = pAggSup->stateStore.streamStateGetInfo(pAggSup->pState, STREAM_SESSION_OP_STATE_NAME, strlen(STREAM_SESSION_OP_STATE_NAME), &pBuf, &size); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); int32_t num = (size - sizeof(TSKEY)) / sizeof(SSessionKey); SSessionKey* pSeKeyBuf = (SSessionKey*)pBuf; @@ -3478,13 +3480,13 @@ void streamSessionSemiReloadState(SOperatorInfo* pOperator) { for (int32_t i = 0; i < num; i++) { SResultWindowInfo winInfo = {0}; code = getSessionWindowInfoByKey(pAggSup, pSeKeyBuf + i, &winInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (!IS_VALID_SESSION_WIN(winInfo)) { continue; } compactSessionSemiWindow(pOperator, &winInfo); code = saveSessionOutputBuf(pAggSup, &winInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } TSKEY ts = *(TSKEY*)((char*)pBuf + size - sizeof(TSKEY)); taosMemoryFree(pBuf); @@ -3515,7 +3517,7 @@ void streamSessionReloadState(SOperatorInfo* pOperator) { code = pAggSup->stateStore.streamStateGetInfo(pAggSup->pState, STREAM_SESSION_OP_STATE_NAME, strlen(STREAM_SESSION_OP_STATE_NAME), &pBuf, &size); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); int32_t num = (size - sizeof(TSKEY)) / sizeof(SSessionKey); SSessionKey* pSeKeyBuf = (SSessionKey*)pBuf; @@ -3532,34 +3534,34 @@ void streamSessionReloadState(SOperatorInfo* pOperator) { for (int32_t i = 0; i < num; i++) { SResultWindowInfo winInfo = {0}; code = getSessionWindowInfoByKey(pAggSup, pSeKeyBuf + i, &winInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (!IS_VALID_SESSION_WIN(winInfo)) { continue; } int32_t winNum = 0; code = compactSessionWindow(pOperator, &winInfo, pInfo->pStUpdated, pInfo->pStDeleted, true, &winNum); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (winNum > 0) { qDebug("===stream=== reload state. save result %" PRId64 ", %" PRIu64, winInfo.sessionWin.win.skey, winInfo.sessionWin.groupId); if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE) { code = saveResult(winInfo, pInfo->pStUpdated); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } else if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) { if (!isCloseWindow(&winInfo.sessionWin.win, &pInfo->twAggSup)) { code = saveDeleteRes(pInfo->pStDeleted, winInfo.sessionWin); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } SSessionKey key = {0}; getSessionHashKey(&winInfo.sessionWin, &key); code = tSimpleHashPut(pAggSup->pResultRows, &key, sizeof(SSessionKey), &winInfo, sizeof(SResultWindowInfo)); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } code = saveSessionOutputBuf(pAggSup, &winInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } taosMemoryFree(pBuf); @@ -3668,7 +3670,7 @@ SOperatorInfo* createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPh if (res == TSDB_CODE_SUCCESS) { code = doStreamSessionDecodeOpState(buff, len, pOperator, true, NULL); taosMemoryFree(buff); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } } pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamSessionAgg, NULL, destroyStreamSessionAggOperatorInfo, @@ -3678,10 +3680,10 @@ SOperatorInfo* createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPh if (downstream) { code = initDownStream(downstream, &pInfo->streamAggSup, pOperator->operatorType, pInfo->primaryTsIndex, &pInfo->twAggSup, &pInfo->basic); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); code = appendDownstream(pOperator, &downstream, 1); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } return pOperator; @@ -3709,18 +3711,18 @@ int32_t deleteSessionWinState(SStreamAggSupporter* pAggSup, SSDataBlock* pBlock, SArray* pWins = taosArrayInit(16, sizeof(SSessionKey)); if (!pWins) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } code = doDeleteTimeWindows(pAggSup, pBlock, pWins); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); removeSessionResults(pAggSup, pMapUpdate, pWins); code = copyDeleteWindowInfo(pWins, pMapDelete); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (needAdd) { code = copyDeleteWindowInfo(pWins, pPkDelete); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } taosArrayDestroy(pWins); @@ -3793,12 +3795,12 @@ static SSDataBlock* doStreamSessionSemiAgg(SOperatorInfo* pOperator) { pBlock->info.type == STREAM_CLEAR) { // gap must be 0 code = deleteSessionWinState(pAggSup, pBlock, pInfo->pStUpdated, pInfo->pStDeleted, NULL, false); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pInfo->clearState = true; break; } else if (pBlock->info.type == STREAM_GET_ALL) { code = getAllSessionWindow(pInfo->streamAggSup.pResultRows, pInfo->pStUpdated); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } else if (pBlock->info.type == STREAM_CREATE_CHILD_TABLE) { return pBlock; @@ -3813,7 +3815,7 @@ static SSDataBlock* doStreamSessionSemiAgg(SOperatorInfo* pOperator) { if (pInfo->scalarSupp.pExprInfo != NULL) { SExprSupp* pExprSup = &pInfo->scalarSupp; code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } // the pDataBlock are always the same one, no need to call this again setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); @@ -3825,19 +3827,19 @@ static SSDataBlock* doStreamSessionSemiAgg(SOperatorInfo* pOperator) { pBInfo->pRes->info.watermark = pInfo->twAggSup.maxTs; code = copyUpdateResult(&pInfo->pStUpdated, pInfo->pUpdated, sessionKeyCompareAsc); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); removeSessionDeleteResults(pInfo->pStDeleted, pInfo->pUpdated); if (pInfo->isHistoryOp) { code = getMaxTsWins(pInfo->pUpdated, pInfo->historyWins); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } initGroupResInfoFromArrayList(&pInfo->groupResInfo, pInfo->pUpdated); pInfo->pUpdated = NULL; code = blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); SSDataBlock* opRes = buildSessionResult(pOperator); if (opRes) { @@ -3864,7 +3866,7 @@ SOperatorInfo* createStreamFinalSessionAggOperatorInfo(SOperatorInfo* downstream SOperatorInfo* pOperator = createStreamSessionAggOperatorInfo(downstream, pPhyNode, pTaskInfo, pHandle); if (pOperator == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } SStorageAPI* pAPI = &pTaskInfo->storageAPI; @@ -3886,7 +3888,7 @@ SOperatorInfo* createStreamFinalSessionAggOperatorInfo(SOperatorInfo* downstream SOperatorInfo* pChildOp = createStreamFinalSessionAggOperatorInfo(NULL, pPhyNode, pTaskInfo, 0, pHandle); if (pChildOp == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } SStreamSessionAggOperatorInfo* pChInfo = pChildOp->info; pChInfo->twAggSup.calTrigger = STREAM_TRIGGER_AT_ONCE; @@ -3894,7 +3896,7 @@ SOperatorInfo* createStreamFinalSessionAggOperatorInfo(SOperatorInfo* downstream void* tmp = taosArrayPush(pInfo->pChildren, &pChildOp); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } } @@ -3906,7 +3908,7 @@ SOperatorInfo* createStreamFinalSessionAggOperatorInfo(SOperatorInfo* downstream if (res == TSDB_CODE_SUCCESS) { code = doStreamSessionDecodeOpState(buff, len, pOperator, true, NULL); taosMemoryFree(buff); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } } @@ -3995,7 +3997,7 @@ int32_t getStateWindowInfoByKey(SStreamAggSupporter* pAggSup, SSessionKey* pKey, pCurWin->winInfo.sessionWin.win.skey = pKey->win.skey; pCurWin->winInfo.sessionWin.win.ekey = pKey->win.ekey; code = getSessionWindowInfoByKey(pAggSup, pKey, &pCurWin->winInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); ASSERT(IS_VALID_SESSION_WIN(pCurWin->winInfo)); pCurWin->pStateKey = @@ -4052,7 +4054,7 @@ int32_t setStateOutputBuf(SStreamAggSupporter* pAggSup, TSKEY ts, uint64_t group code = pAggSup->stateStore.streamStateStateAddIfNotExist(pAggSup->pState, &pCurWin->winInfo.sessionWin, pKeyData, pAggSup->stateKeySize, compareStateKey, (void**)&pCurWin->winInfo.pStatePos, &size, &winCode); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pCurWin->pStateKey = (SStateKeys*)((char*)pCurWin->winInfo.pStatePos->pRowBuff + (pAggSup->resultRowSize - pAggSup->stateKeySize)); @@ -4146,7 +4148,7 @@ int32_t updateStateWindowInfo(SStreamAggSupporter* pAggSup, SStateWindowInfo* pW if (pWinInfo->winInfo.sessionWin.win.skey > pTs[i]) { if (pSeDeleted && pWinInfo->winInfo.isOutput) { code = saveDeleteRes(pSeDeleted, pWinInfo->winInfo.sessionWin); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } removeSessionResult(pAggSup, pSeUpdated, pResultRows, &pWinInfo->winInfo.sessionWin); pWinInfo->winInfo.sessionWin.win.skey = pTs[i]; @@ -4191,7 +4193,7 @@ static void doStreamStateAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBl SColumnInfoData* pColDataInfo = taosArrayGet(pSDataBlock->pDataBlock, pInfo->primaryTsIndex); if (!pColDataInfo) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } tsCols = (int64_t*)pColDataInfo->pData; } else { @@ -4200,7 +4202,7 @@ static void doStreamStateAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBl int32_t rows = pSDataBlock->info.rows; code = blockDataEnsureCapacity(pAggSup->pScanBlock, rows); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); SColumnInfoData* pKeyColInfo = taosArrayGet(pSDataBlock->pDataBlock, pInfo->stateCol.slotId); for (int32_t i = 0; i < rows; i += winRows) { @@ -4216,21 +4218,22 @@ static void doStreamStateAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBl SStateWindowInfo curWin = {0}; SStateWindowInfo nextWin = {0}; code = setStateOutputBuf(pAggSup, tsCols[i], groupId, pKeyData, &curWin, &nextWin); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); releaseOutputBuf(pAggSup->pState, nextWin.winInfo.pStatePos, &pAPI->stateStore); setSessionWinOutputInfo(pSeUpdated, &curWin.winInfo); code = updateStateWindowInfo(pAggSup, &curWin, &nextWin, tsCols, groupId, pKeyColInfo, rows, i, &allEqual, pAggSup->pResultRows, pSeUpdated, pStDeleted, &winRows); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (!allEqual) { uint64_t uid = 0; - appendDataToSpecialBlock(pAggSup->pScanBlock, &curWin.winInfo.sessionWin.win.skey, - &curWin.winInfo.sessionWin.win.ekey, &uid, &groupId, NULL); + code = appendDataToSpecialBlock(pAggSup->pScanBlock, &curWin.winInfo.sessionWin.win.skey, + &curWin.winInfo.sessionWin.win.ekey, &uid, &groupId, NULL); + QUERY_CHECK_CODE(code, lino, _end); code = tSimpleHashRemove(pSeUpdated, &curWin.winInfo.sessionWin, sizeof(SSessionKey)); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); doDeleteSessionWindow(pAggSup, &curWin.winInfo.sessionWin); releaseOutputBuf(pAggSup->pState, curWin.winInfo.pStatePos, &pAPI->stateStore); @@ -4239,19 +4242,19 @@ static void doStreamStateAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBl code = doOneWindowAggImpl(&pInfo->twAggSup.timeWindowData, &curWin.winInfo, &pResult, i, winRows, rows, numOfOutput, pOperator, 0); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = saveSessionOutputBuf(pAggSup, &curWin.winInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->destHasPrimaryKey && curWin.winInfo.isOutput && IS_NORMAL_STATE_OP(pOperator)) { code = saveDeleteRes(pInfo->pPkDeleted, curWin.winInfo.sessionWin); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE) { code = saveResult(curWin.winInfo, pSeUpdated); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) { @@ -4260,7 +4263,7 @@ static void doStreamStateAggImpl(SOperatorInfo* pOperator, SSDataBlock* pSDataBl getSessionHashKey(&curWin.winInfo.sessionWin, &key); code = tSimpleHashPut(pAggSup->pResultRows, &key, sizeof(SSessionKey), &curWin.winInfo, sizeof(SResultWindowInfo)); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } @@ -4325,7 +4328,7 @@ int32_t doStreamStateDecodeOpState(void* buf, int32_t len, SOperatorInfo* pOpera SStreamAggSupporter* pAggSup = &pInfo->streamAggSup; if (!pInfo) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } // 5.checksum @@ -4335,7 +4338,7 @@ int32_t doStreamStateDecodeOpState(void* buf, int32_t len, SOperatorInfo* pOpera if (taosCheckChecksum(buf, dataLen, *(uint32_t*)pCksum) != TSDB_CODE_SUCCESS) { qError("stream state_window state is invalid"); code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } @@ -4350,12 +4353,12 @@ int32_t doStreamStateDecodeOpState(void* buf, int32_t len, SOperatorInfo* pOpera code = pAggSup->stateStore.streamStateStateAddIfNotExist( pAggSup->pState, &winfo.sessionWin, NULL, pAggSup->stateKeySize, compareStateKey, (void**)&winfo.pStatePos, &pAggSup->resultRowSize, &winCode); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); buf = decodeSResultWindowInfo(buf, &winfo, pInfo->streamAggSup.resultRowSize); code = tSimpleHashPut(pInfo->streamAggSup.pResultRows, &key, sizeof(SSessionKey), &winfo, sizeof(SResultWindowInfo)); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } // 2.twAggSup @@ -4368,7 +4371,7 @@ int32_t doStreamStateDecodeOpState(void* buf, int32_t len, SOperatorInfo* pOpera for (int32_t i = 0; i < size; i++) { SOperatorInfo* pChOp = taosArrayGetP(pInfo->pChildren, i); code = doStreamStateDecodeOpState(buf, 0, pChOp, false, &buf); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } // 4.dataVersion @@ -4472,12 +4475,12 @@ static SSDataBlock* doStreamStateAgg(SOperatorInfo* pOperator) { bool add = pInfo->destHasPrimaryKey && IS_NORMAL_STATE_OP(pOperator); code = deleteSessionWinState(&pInfo->streamAggSup, pBlock, pInfo->pSeUpdated, pInfo->pSeDeleted, pInfo->pPkDeleted, add); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } else if (pBlock->info.type == STREAM_GET_ALL) { pInfo->recvGetAll = true; code = getAllSessionWindow(pInfo->streamAggSup.pResultRows, pInfo->pSeUpdated); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } else if (pBlock->info.type == STREAM_CREATE_CHILD_TABLE) { return pBlock; @@ -4485,7 +4488,7 @@ static SSDataBlock* doStreamStateAgg(SOperatorInfo* pOperator) { pInfo->streamAggSup.stateStore.streamStateCommit(pInfo->streamAggSup.pState); doStreamStateSaveCheckpoint(pOperator); code = copyDataBlock(pInfo->pCheckpointRes, pBlock); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } else { @@ -4495,7 +4498,7 @@ static SSDataBlock* doStreamStateAgg(SOperatorInfo* pOperator) { if (pInfo->scalarSupp.pExprInfo != NULL) { SExprSupp* pExprSup = &pInfo->scalarSupp; code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } // the pDataBlock are always the same one, no need to call this again setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); @@ -4506,26 +4509,26 @@ static SSDataBlock* doStreamStateAgg(SOperatorInfo* pOperator) { pOperator->status = OP_RES_TO_RETURN; code = closeSessionWindow(pInfo->streamAggSup.pResultRows, &pInfo->twAggSup, pInfo->pSeUpdated); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = copyUpdateResult(&pInfo->pSeUpdated, pInfo->pUpdated, sessionKeyCompareAsc); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); removeSessionDeleteResults(pInfo->pSeDeleted, pInfo->pUpdated); if (pInfo->isHistoryOp) { code = getMaxTsWins(pInfo->pUpdated, pInfo->historyWins); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (pInfo->destHasPrimaryKey && IS_NORMAL_STATE_OP(pOperator)) { code = copyDeleteSessionKey(pInfo->pPkDeleted, pInfo->pSeDeleted); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } initGroupResInfoFromArrayList(&pInfo->groupResInfo, pInfo->pUpdated); pInfo->pUpdated = NULL; code = blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); SSDataBlock* resBlock = buildStateResult(pOperator); if (resBlock != NULL) { @@ -4580,7 +4583,7 @@ void streamStateReloadState(SOperatorInfo* pOperator) { void* pBuf = NULL; code = pAggSup->stateStore.streamStateGetInfo(pAggSup->pState, STREAM_STATE_OP_STATE_NAME, strlen(STREAM_STATE_OP_STATE_NAME), &pBuf, &size); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); int32_t num = (size - sizeof(TSKEY)) / sizeof(SSessionKey); qDebug("===stream=== reload state. get result count:%d", num); @@ -4605,7 +4608,7 @@ void streamStateReloadState(SOperatorInfo* pOperator) { qDebug("===stream=== reload state. try process result %" PRId64 ", %" PRIu64 ", index:%d", pSeKeyBuf[i].win.skey, pSeKeyBuf[i].groupId, i); code = getStateWindowInfoByKey(pAggSup, pSeKeyBuf + i, &curInfo, &nextInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); bool cpRes = compareWinStateKey(curInfo.pStateKey, nextInfo.pStateKey); qDebug("===stream=== reload state. next window info %" PRId64 ", %" PRIu64 ", compare:%d", @@ -4614,21 +4617,21 @@ void streamStateReloadState(SOperatorInfo* pOperator) { code = compactStateWindow(pOperator, &curInfo.winInfo, &nextInfo.winInfo, pInfo->pSeUpdated, pInfo->pSeDeleted); qDebug("===stream=== reload state. save result %" PRId64 ", %" PRIu64, curInfo.winInfo.sessionWin.win.skey, curInfo.winInfo.sessionWin.groupId); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE) { code = saveResult(curInfo.winInfo, pInfo->pSeUpdated); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } else if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) { if (!isCloseWindow(&curInfo.winInfo.sessionWin.win, &pInfo->twAggSup)) { code = saveDeleteRes(pInfo->pSeDeleted, curInfo.winInfo.sessionWin); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } SSessionKey key = {0}; getSessionHashKey(&curInfo.winInfo.sessionWin, &key); code = tSimpleHashPut(pAggSup->pResultRows, &key, sizeof(SSessionKey), &curInfo.winInfo, sizeof(SResultWindowInfo)); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } else if (IS_VALID_SESSION_WIN(nextInfo.winInfo)) { releaseOutputBuf(pAggSup->pState, nextInfo.winInfo.pStatePos, &pAggSup->pSessionAPI->stateStore); @@ -4636,7 +4639,7 @@ void streamStateReloadState(SOperatorInfo* pOperator) { if (IS_VALID_SESSION_WIN(curInfo.winInfo)) { code = saveSessionOutputBuf(pAggSup, &curInfo.winInfo); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } taosMemoryFree(pBuf); @@ -4665,7 +4668,7 @@ SOperatorInfo* createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhys SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } pInfo->stateCol = extractColumnFromColumnNode(pColNode); @@ -4674,7 +4677,7 @@ SOperatorInfo* createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhys int32_t numOfScalar = 0; SExprInfo* pScalarExprInfo = createExprInfo(pStateNode->window.pExprs, NULL, &numOfScalar); code = initExprSupp(&pInfo->scalarSupp, pScalarExprInfo, numOfScalar, &pTaskInfo->storageAPI.functionStore); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } pInfo->twAggSup = (STimeWindowAggSupp){ @@ -4701,7 +4704,7 @@ SOperatorInfo* createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhys code = initStreamAggSupporter(&pInfo->streamAggSup, pExpSup, numOfCols, 0, pTaskInfo->streamInfo.pState, keySize, type, &pTaskInfo->storageAPI.stateStore, pHandle, &pInfo->twAggSup, GET_TASKID(pTaskInfo), &pTaskInfo->storageAPI, pInfo->primaryTsIndex); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY); pInfo->pSeDeleted = tSimpleHashInit(64, hashFn); @@ -4716,7 +4719,7 @@ SOperatorInfo* createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhys pInfo->historyWins = taosArrayInit(4, sizeof(SSessionKey)); if (!pInfo->historyWins) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } if (pHandle) { pInfo->isHistoryOp = pHandle->fillHistory; @@ -4738,7 +4741,7 @@ SOperatorInfo* createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhys if (res == TSDB_CODE_SUCCESS) { code = doStreamStateDecodeOpState(buff, len, pOperator, true, NULL); taosMemoryFree(buff); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doStreamStateAgg, NULL, destroyStreamStateOperatorInfo, @@ -4746,10 +4749,10 @@ SOperatorInfo* createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhys setOperatorStreamStateFn(pOperator, streamStateReleaseState, streamStateReloadState); code = initDownStream(downstream, &pInfo->streamAggSup, pOperator->operatorType, pInfo->primaryTsIndex, &pInfo->twAggSup, &pInfo->basic); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); code = appendDownstream(pOperator, &downstream, 1); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); return pOperator; @@ -4835,12 +4838,12 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) { if (pBlock->info.type == STREAM_DELETE_DATA || pBlock->info.type == STREAM_DELETE_RESULT || pBlock->info.type == STREAM_CLEAR) { code = doDeleteWindows(pOperator, &pInfo->interval, pBlock, pInfo->pDelWins, pInfo->pUpdatedMap, NULL); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } else if (pBlock->info.type == STREAM_GET_ALL) { pInfo->recvGetAll = true; code = getAllIntervalWindow(pInfo->aggSup.pResultRowHashTable, pInfo->pUpdatedMap); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } else if (pBlock->info.type == STREAM_CREATE_CHILD_TABLE) { printDataBlock(pBlock, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo)); @@ -4850,7 +4853,7 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) { doStreamIntervalSaveCheckpoint(pOperator); pInfo->reCkBlock = true; code = copyDataBlock(pInfo->pCheckpointRes, pBlock); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } else { @@ -4865,7 +4868,7 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) { if (pInfo->scalarSupp.pExprInfo != NULL) { SExprSupp* pExprSup = &pInfo->scalarSupp; code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } // The timewindow that overlaps the timestamps of the input pBlock need to be recalculated and return to the @@ -4888,11 +4891,11 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) { } code = closeStreamIntervalWindow(pInfo->aggSup.pResultRowHashTable, &pInfo->twAggSup, &pInfo->interval, NULL, pInfo->pUpdatedMap, pInfo->pDelWins, pOperator); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->destHasPrimaryKey && IS_NORMAL_INTERVAL_OP(pOperator)) { code = copyIntervalDeleteKey(pInfo->pDeletedMap, pInfo->pDelWins); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } void* pIte = NULL; @@ -4901,7 +4904,7 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) { void* tmp = taosArrayPush(pInfo->pUpdated, pIte); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } taosArraySort(pInfo->pUpdated, winPosCmprImpl); @@ -4909,7 +4912,7 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) { initMultiResInfoFromArrayList(&pInfo->groupResInfo, pInfo->pUpdated); pInfo->pUpdated = NULL; code = blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); tSimpleHashCleanup(pInfo->pUpdatedMap); pInfo->pUpdatedMap = NULL; @@ -4932,7 +4935,7 @@ SOperatorInfo* createStreamIntervalOperatorInfo(SOperatorInfo* downstream, SPhys SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } SStreamIntervalPhysiNode* pIntervalPhyNode = (SStreamIntervalPhysiNode*)pPhyNode; int32_t numOfCols = 0; @@ -4979,13 +4982,13 @@ SOperatorInfo* createStreamIntervalOperatorInfo(SOperatorInfo* downstream, SPhys size_t keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES; code = initAggSup(pSup, &pInfo->aggSup, pExprInfo, numOfCols, keyBufSize, pTaskInfo->id.str, pInfo->pState, &pTaskInfo->storageAPI.functionStore); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); if (pIntervalPhyNode->window.pExprs != NULL) { int32_t numOfScalar = 0; SExprInfo* pScalarExprInfo = createExprInfo(pIntervalPhyNode->window.pExprs, NULL, &numOfScalar); code = initExprSupp(&pInfo->scalarSupp, pScalarExprInfo, numOfScalar, &pTaskInfo->storageAPI.functionStore); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } pInfo->invertible = false; @@ -5038,10 +5041,10 @@ SOperatorInfo* createStreamIntervalOperatorInfo(SOperatorInfo* downstream, SPhys } code = initIntervalDownStream(downstream, pPhyNode->type, pInfo); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); code = appendDownstream(pOperator, &downstream, 1); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); return pOperator; @@ -5107,18 +5110,18 @@ static void doStreamMidIntervalAggImpl(SOperatorInfo* pOperator, SSDataBlock* pS int32_t winCode = TSDB_CODE_SUCCESS; code = setIntervalOutputBuf(pInfo->pState, &nextWin, &pResPos, groupId, pSup->pCtx, numOfOutput, pSup->rowEntryInfoOffset, &pInfo->aggSup, &pInfo->stateStore, &winCode); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pResult = (SResultRow*)pResPos->pRowBuff; if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_AT_ONCE) { code = saveWinResult(&key, pResPos, pUpdatedMap); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (pInfo->twAggSup.calTrigger == STREAM_TRIGGER_WINDOW_CLOSE) { code = tSimpleHashPut(pInfo->aggSup.pResultRowHashTable, &key, sizeof(SWinKey), &pResPos, POINTER_BYTES); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } updateTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &nextWin, 1); @@ -5135,7 +5138,7 @@ static void doStreamMidIntervalAggImpl(SOperatorInfo* pOperator, SSDataBlock* pS ",maxKey %" PRId64, pSDataBlock->info.id.uid, pSDataBlock->info.window.skey, pSDataBlock->info.window.ekey); code = blockDataUpdateTsWindow(pSDataBlock, 0); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); // timestamp of the data is incorrect if (pSDataBlock->info.window.skey <= 0 || pSDataBlock->info.window.ekey <= 0) { @@ -5165,7 +5168,7 @@ static int32_t addMidRetriveWindow(SArray* wins, SHashObj* pMidPullMap, int32_t if (!chIds) { code = addPullWindow(pMidPullMap, winKey, numOfChild); qDebug("===stream===prepare mid operator retrive for delete %" PRId64 ", size:%d", winKey->ts, numOfChild); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } _end: @@ -5278,17 +5281,17 @@ static SSDataBlock* doStreamMidIntervalAgg(SOperatorInfo* pOperator) { SArray* delWins = taosArrayInit(8, sizeof(SWinKey)); if (!delWins) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } code = doDeleteWindows(pOperator, &pInfo->interval, pBlock, delWins, pInfo->pUpdatedMap, pInfo->pFinalPullDataMap); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); removeResults(delWins, pInfo->pUpdatedMap); void* tmp = taosArrayAddAll(pInfo->pDelWins, delWins); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } taosArrayDestroy(delWins); @@ -5310,11 +5313,11 @@ static SSDataBlock* doStreamMidIntervalAgg(SOperatorInfo* pOperator) { } else if (pBlock->info.type == STREAM_PULL_OVER) { code = processPullOver(pBlock, pInfo->pPullDataMap, pInfo->pFinalPullDataMap, &pInfo->interval, pInfo->pPullWins, pInfo->numOfChild, pOperator, &pInfo->recvPullover); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pInfo->recvPullover) { code = copyDataBlock(pInfo->pMidPulloverRes, pBlock); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pInfo->clearState = true; break; @@ -5324,25 +5327,25 @@ static SSDataBlock* doStreamMidIntervalAgg(SOperatorInfo* pOperator) { pAPI->stateStore.streamStateCommit(pInfo->pState); doStreamIntervalSaveCheckpoint(pOperator); code = copyDataBlock(pInfo->pCheckpointRes, pBlock); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); continue; } else if (pBlock->info.type == STREAM_MID_RETRIEVE) { SArray* delWins = taosArrayInit(8, sizeof(SWinKey)); if (!delWins) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } code = doDeleteWindows(pOperator, &pInfo->interval, pBlock, delWins, pInfo->pUpdatedMap, NULL); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = addMidRetriveWindow(delWins, pInfo->pPullDataMap, pInfo->numOfChild); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); taosArrayDestroy(delWins); pInfo->recvRetrive = true; code = copyDataBlock(pInfo->pMidRetriveRes, pBlock); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pInfo->pMidRetriveRes->info.type = STREAM_MID_RETRIEVE; pInfo->clearState = true; @@ -5354,7 +5357,7 @@ static SSDataBlock* doStreamMidIntervalAgg(SOperatorInfo* pOperator) { if (pInfo->scalarSupp.pExprInfo != NULL) { SExprSupp* pExprSup = &pInfo->scalarSupp; code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); doStreamMidIntervalAggImpl(pOperator, pBlock, pInfo->pUpdatedMap); @@ -5372,7 +5375,7 @@ static SSDataBlock* doStreamMidIntervalAgg(SOperatorInfo* pOperator) { void* tmp = taosArrayPush(pInfo->pUpdated, pIte); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } @@ -5383,7 +5386,7 @@ static SSDataBlock* doStreamMidIntervalAgg(SOperatorInfo* pOperator) { initMultiResInfoFromArrayList(&pInfo->groupResInfo, pInfo->pUpdated); pInfo->pUpdated = NULL; code = blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); SSDataBlock* resBlock = buildIntervalResult(pOperator); if (resBlock != NULL) { diff --git a/source/libs/stream/src/streamSessionState.c b/source/libs/stream/src/streamSessionState.c index c20f6b0577..66915b7cfa 100644 --- a/source/libs/stream/src/streamSessionState.c +++ b/source/libs/stream/src/streamSessionState.c @@ -88,14 +88,14 @@ static int32_t addNewSessionWindow(SStreamFileState* pFileState, SArray* pWinInf SRowBuffPos* pNewPos = getNewRowPosForWrite(pFileState); if (!pNewPos || !pNewPos->pRowBuff) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } memcpy(pNewPos->pKey, pKey, sizeof(SSessionKey)); void* tmp = taosArrayPush(pWinInfos, &pNewPos); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } (*ppPos) = pNewPos; @@ -113,14 +113,14 @@ static int32_t insertNewSessionWindow(SStreamFileState* pFileState, SArray* pWin SRowBuffPos* pNewPos = getNewRowPosForWrite(pFileState); if (!pNewPos || !pNewPos->pRowBuff) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } memcpy(pNewPos->pKey, pKey, sizeof(SSessionKey)); void* tmp = taosArrayInsert(pWinInfos, index, &pNewPos); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } *ppPos = pNewPos; @@ -138,7 +138,7 @@ SRowBuffPos* createSessionWinBuff(SStreamFileState* pFileState, SSessionKey* pKe SRowBuffPos* pNewPos = getNewRowPosForWrite(pFileState); if (!pNewPos || !pNewPos->pRowBuff) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } memcpy(pNewPos->pKey, pKey, sizeof(SSessionKey)); @@ -174,10 +174,10 @@ int32_t getSessionWinResultBuff(SStreamFileState* pFileState, SSessionKey* pKey, pWinStates = taosArrayInit(16, POINTER_BYTES); if (!pWinStates) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } code = tSimpleHashPut(pSessionBuff, &pKey->groupId, sizeof(uint64_t), &pWinStates, POINTER_BYTES); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } TSKEY startTs = pKey->win.skey; @@ -192,7 +192,7 @@ int32_t getSessionWinResultBuff(SStreamFileState* pFileState, SSessionKey* pKey, (*pVal) = createSessionWinBuff(pFileState, pKey, p, pVLen); if (!(*pVal)) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } (*pWinCode) = code_file; @@ -201,7 +201,7 @@ int32_t getSessionWinResultBuff(SStreamFileState* pFileState, SSessionKey* pKey, code = addNewSessionWindow(pFileState, pWinStates, pKey, (SRowBuffPos**)pVal); (*pWinCode) = TSDB_CODE_FAILED; taosMemoryFree(p); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } goto _end; } @@ -243,7 +243,7 @@ int32_t getSessionWinResultBuff(SStreamFileState* pFileState, SSessionKey* pKey, (*pVal) = createSessionWinBuff(pFileState, pKey, p, pVLen); if (!(*pVal)) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } (*pWinCode) = code_file; @@ -257,14 +257,14 @@ int32_t getSessionWinResultBuff(SStreamFileState* pFileState, SSessionKey* pKey, if (index == size - 1) { code = addNewSessionWindow(pFileState, pWinStates, pKey, (SRowBuffPos**)pVal); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); (*pWinCode) = TSDB_CODE_FAILED; goto _end; } code = insertNewSessionWindow(pFileState, pWinStates, pKey, index + 1, (SRowBuffPos**)pVal); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); (*pWinCode) = TSDB_CODE_FAILED; @@ -296,11 +296,11 @@ int32_t putSessionWinResultBuff(SStreamFileState* pFileState, SRowBuffPos* pPos) pWinStates = taosArrayInit(16, POINTER_BYTES); if (!pWinStates) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } code = tSimpleHashPut(pSessionBuff, &pKey->groupId, sizeof(uint64_t), &pWinStates, POINTER_BYTES); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } int32_t size = taosArrayGetSize(pWinStates); @@ -308,7 +308,7 @@ int32_t putSessionWinResultBuff(SStreamFileState* pFileState, SRowBuffPos* pPos) void* tmp = taosArrayPush(pWinStates, &pPos); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } goto _end; } @@ -319,13 +319,13 @@ int32_t putSessionWinResultBuff(SStreamFileState* pFileState, SRowBuffPos* pPos) void* tmp = taosArrayInsert(pWinStates, index, &pPos); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } else { void* tmp = taosArrayInsert(pWinStates, 0, &pPos); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } @@ -343,7 +343,7 @@ int32_t getSessionFlushedBuff(SStreamFileState* pFileState, SSessionKey* pKey, v SRowBuffPos* pNewPos = getNewRowPosForWrite(pFileState); if (!pNewPos || !pNewPos->pRowBuff) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } pNewPos->needFree = true; pNewPos->beFlushed = true; @@ -416,17 +416,17 @@ int32_t allocSessioncWinBuffByNextPosition(SStreamFileState* pFileState, SStream pWinStates = taosArrayInit(16, POINTER_BYTES); if (!pWinStates) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } code = tSimpleHashPut(pSessionBuff, &pWinKey->groupId, sizeof(uint64_t), &pWinStates, POINTER_BYTES); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } else { pWinStates = (SArray*)(*ppBuff); } if (!pCur) { code = addNewSessionWindow(pFileState, pWinStates, pWinKey, &pNewPos); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); goto _end; } @@ -435,12 +435,12 @@ int32_t allocSessioncWinBuffByNextPosition(SStreamFileState* pFileState, SStream if (pCur->buffIndex >= 0) { if (pCur->buffIndex >= size) { code = addNewSessionWindow(pFileState, pWinStates, pWinKey, &pNewPos); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); goto _end; } code = insertNewSessionWindow(pFileState, pWinStates, pWinKey, pCur->buffIndex, &pNewPos); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); goto _end; } else { @@ -452,14 +452,14 @@ int32_t allocSessioncWinBuffByNextPosition(SStreamFileState* pFileState, SStream int32_t winCode = TSDB_CODE_SUCCESS; code = getSessionWinResultBuff(pFileState, &pTmpKey, 0, (void**)&pNewPos, pVLen, &winCode); ASSERT(winCode == TSDB_CODE_FAILED); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); goto _end; } } pNewPos = getNewRowPosForWrite(pFileState); if (!pNewPos || !pNewPos->pRowBuff) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } memcpy(pNewPos->pKey, pWinKey, sizeof(SSessionKey)); @@ -793,11 +793,11 @@ int32_t getStateWinResultBuff(SStreamFileState* pFileState, SSessionKey* key, ch pWinStates = taosArrayInit(16, POINTER_BYTES); if (!pWinStates) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } code = tSimpleHashPut(pSessionBuff, &pWinKey->groupId, sizeof(uint64_t), &pWinStates, POINTER_BYTES); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } TSKEY startTs = pWinKey->win.skey; @@ -812,7 +812,7 @@ int32_t getStateWinResultBuff(SStreamFileState* pFileState, SSessionKey* key, ch (*pVal) = createSessionWinBuff(pFileState, pWinKey, p, pVLen); if (!(*pVal)) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } (*pWinCode) = code_file; @@ -822,7 +822,7 @@ int32_t getStateWinResultBuff(SStreamFileState* pFileState, SSessionKey* key, ch code = addNewSessionWindow(pFileState, pWinStates, key, (SRowBuffPos**)pVal); (*pWinCode) = TSDB_CODE_FAILED; taosMemoryFree(p); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } goto _end; } @@ -869,7 +869,7 @@ int32_t getStateWinResultBuff(SStreamFileState* pFileState, SSessionKey* key, ch (*pVal) = createSessionWinBuff(pFileState, pWinKey, p, pVLen); if (!(*pVal)) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } (*pWinCode) = code_file; @@ -884,13 +884,13 @@ int32_t getStateWinResultBuff(SStreamFileState* pFileState, SSessionKey* key, ch if (index == size - 1) { code = addNewSessionWindow(pFileState, pWinStates, key, (SRowBuffPos**)pVal); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); (*pWinCode) = TSDB_CODE_FAILED; goto _end; } code = insertNewSessionWindow(pFileState, pWinStates, key, index + 1, (SRowBuffPos**)pVal); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); (*pWinCode) = TSDB_CODE_FAILED; @@ -933,11 +933,11 @@ int32_t getCountWinResultBuff(SStreamFileState* pFileState, SSessionKey* pKey, C pWinStates = taosArrayInit(16, POINTER_BYTES); if (!pWinStates) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } code = tSimpleHashPut(pSessionBuff, &pWinKey->groupId, sizeof(uint64_t), &pWinStates, POINTER_BYTES); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } TSKEY startTs = pWinKey->win.skey; @@ -958,7 +958,7 @@ int32_t getCountWinResultBuff(SStreamFileState* pFileState, SSessionKey* pKey, C (*pVal) = createSessionWinBuff(pFileState, pWinKey, pRockVal, pVLen); if (!(*pVal)) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } goto _end; @@ -970,11 +970,11 @@ int32_t getCountWinResultBuff(SStreamFileState* pFileState, SSessionKey* pKey, C taosMemoryFree(pRockVal); if (!(*pVal)) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } else { code = addNewSessionWindow(pFileState, pWinStates, pWinKey, (SRowBuffPos**)pVal); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); (*pWinCount) = TSDB_CODE_FAILED; } @@ -1013,7 +1013,7 @@ int32_t getCountWinResultBuff(SStreamFileState* pFileState, SSessionKey* pKey, C (*pVal) = createSessionWinBuff(pFileState, pWinKey, pRockVal, pVLen); if (!(*pVal)) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } (*pWinCount) = code_file; @@ -1037,7 +1037,7 @@ int32_t getCountWinResultBuff(SStreamFileState* pFileState, SSessionKey* pKey, C } code = addNewSessionWindow(pFileState, pWinStates, pWinKey, (SRowBuffPos**)pVal); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); (*pWinCount) = TSDB_CODE_FAILED; @@ -1061,7 +1061,7 @@ int32_t createCountWinResultBuff(SStreamFileState* pFileState, SSessionKey* pKey } else { pWinStates = taosArrayInit(16, POINTER_BYTES); code = tSimpleHashPut(pSessionBuff, &pWinKey->groupId, sizeof(uint64_t), &pWinStates, POINTER_BYTES); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } TSKEY startTs = pWinKey->win.skey; @@ -1077,7 +1077,7 @@ int32_t createCountWinResultBuff(SStreamFileState* pFileState, SSessionKey* pKey (*pVal) = createSessionWinBuff(pFileState, pWinKey, p, pVLen); if (!(*pVal)) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } qDebug("===stream===0 get state win:%" PRId64 ",%" PRId64 " from disc, res %d", pWinKey->win.skey, @@ -1085,11 +1085,11 @@ int32_t createCountWinResultBuff(SStreamFileState* pFileState, SSessionKey* pKey } else { code = addNewSessionWindow(pFileState, pWinStates, pWinKey, (SRowBuffPos**)pVal); taosMemoryFree(p); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } else { code = addNewSessionWindow(pFileState, pWinStates, pWinKey, (SRowBuffPos**)pVal); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } _end: diff --git a/source/libs/stream/src/streamState.c b/source/libs/stream/src/streamState.c index 56a74e149d..c6ecaf9c2b 100644 --- a/source/libs/stream/src/streamState.c +++ b/source/libs/stream/src/streamState.c @@ -105,14 +105,14 @@ SStreamState* streamStateOpen(const char* path, void* pTask, int64_t streamId, i stDebug("open stream state %p, %s", pState, path); if (pState == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } pState->pTdbState = taosMemoryCalloc(1, sizeof(STdbState)); if (pState->pTdbState == NULL) { streamStateDestroy(pState, true); code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } SStreamTask* pStreamTask = pTask; @@ -121,7 +121,7 @@ SStreamState* streamStateOpen(const char* path, void* pTask, int64_t streamId, i sprintf(pState->pTdbState->idstr, "0x%" PRIx64 "-0x%x", pState->streamId, pState->taskId); code = streamTaskSetDb(pStreamTask->pMeta, pTask, pState->pTdbState->idstr); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); SStreamMeta* pMeta = pStreamTask->pMeta; pState->pTdbState->pOwner = pTask; @@ -130,7 +130,7 @@ SStreamState* streamStateOpen(const char* path, void* pTask, int64_t streamId, i pState->parNameMap = tSimpleHashInit(1024, hashFn); if (!pState->parNameMap) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } stInfo("open state %p on backend %p 0x%" PRIx64 "-%d succ", pState, pMeta->streamBackend, pState->streamId, pState->taskId); @@ -169,7 +169,7 @@ int32_t streamStateFuncPut(SStreamState* pState, const SWinKey* key, const void* void* pVal = NULL; int32_t len = getRowStateRowSize(pState->pFileState); code = getFunctionRowBuff(pState->pFileState, (void*)key, sizeof(SWinKey), &pVal, &len); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); char* buf = ((SRowBuffPos*)pVal)->pRowBuff; uint32_t rowSize = streamFileStateGetSelectRowSize(pState->pFileState); @@ -187,7 +187,7 @@ int32_t streamStateFuncGet(SStreamState* pState, const SWinKey* key, void** ppVa void* pVal = NULL; int32_t len = getRowStateRowSize(pState->pFileState); code = getFunctionRowBuff(pState->pFileState, (void*)key, sizeof(SWinKey), (void**)(&pVal), &len); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); char* buf = ((SRowBuffPos*)pVal)->pRowBuff; uint32_t rowSize = streamFileStateGetSelectRowSize(pState->pFileState); @@ -256,10 +256,10 @@ void streamStateSaveInfo(SStreamState* pState, void* pKey, int32_t keyLen, void* char* cfName = "default"; void* batch = streamStateCreateBatch(); code = streamStatePutBatch(pState, cfName, batch, pKey, pVal, vLen, 0); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = streamStatePutBatch_rocksdb(pState, batch); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); _end: if (code != TSDB_CODE_SUCCESS) { @@ -361,18 +361,18 @@ int32_t streamStateSessionPut(SStreamState* pState, const SSessionKey* key, void goto _end; } code = streamStateSessionPut_rocksdb(pState, key, pos->pRowBuff, vLen); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); streamStateReleaseBuf(pState, pos, true); code = putFreeBuff(pState->pFileState, pos); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); stDebug("===stream===save skey:%" PRId64 ", ekey:%" PRId64 ", groupId:%" PRIu64 ".code:%d", key->win.skey, key->win.ekey, key->groupId, code); } else { pos->beFlushed = false; code = putSessionWinResultBuff(pState->pFileState, value); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } @@ -453,10 +453,10 @@ int32_t streamStatePutParName(SStreamState* pState, int64_t groupId, const char if (tSimpleHashGet(pState->parNameMap, &groupId, sizeof(int64_t)) == NULL) { if (tSimpleHashGetSize(pState->parNameMap) < MAX_TABLE_NAME_NUM) { code = tSimpleHashPut(pState->parNameMap, &groupId, sizeof(int64_t), tbname, TSDB_TABLE_NAME_LEN); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } code = streamStatePutParName_rocksdb(pState, groupId, tbname); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } _end: @@ -477,14 +477,14 @@ int32_t streamStateGetParName(SStreamState* pState, int64_t groupId, void** pVal (*pWinCode) = streamStateGetParName_rocksdb(pState, groupId, pVal); if ((*pWinCode) == TSDB_CODE_SUCCESS && tSimpleHashGetSize(pState->parNameMap) < MAX_TABLE_NAME_NUM) { code = tSimpleHashPut(pState->parNameMap, &groupId, sizeof(int64_t), *pVal, TSDB_TABLE_NAME_LEN); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } goto _end; } *pVal = taosMemoryCalloc(1, TSDB_TABLE_NAME_LEN); if (!(*pVal)) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } memcpy(*pVal, pStr, TSDB_TABLE_NAME_LEN); diff --git a/source/libs/stream/src/streamUpdate.c b/source/libs/stream/src/streamUpdate.c index e395b3066b..ea3b923f98 100644 --- a/source/libs/stream/src/streamUpdate.c +++ b/source/libs/stream/src/streamUpdate.c @@ -78,11 +78,11 @@ int32_t windowSBfAdd(SUpdateInfo* pInfo, uint64_t count) { int64_t rows = adjustExpEntries(pInfo->interval * ROWS_PER_MILLISECOND); SScalableBf* tsSBF = NULL; code = tScalableBfInit(rows, DEFAULT_FALSE_POSITIVE, &tsSBF); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); void* res = taosArrayPush(pInfo->pTsSBFs, &tsSBF); if (!res) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } } @@ -152,7 +152,7 @@ int32_t updateInfoInit(int64_t interval, int32_t precision, int64_t watermark, b SUpdateInfo* pInfo = taosMemoryCalloc(1, sizeof(SUpdateInfo)); if (pInfo == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } pInfo->pTsBuckets = NULL; pInfo->pTsSBFs = NULL; @@ -170,16 +170,16 @@ int32_t updateInfoInit(int64_t interval, int32_t precision, int64_t watermark, b if (pInfo->pTsSBFs == NULL) { updateInfoDestroy(pInfo); code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } code = windowSBfAdd(pInfo, bfSize); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pInfo->pTsBuckets = taosArrayInit(DEFAULT_BUCKET_SIZE, sizeof(TSKEY)); if (pInfo->pTsBuckets == NULL) { updateInfoDestroy(pInfo); code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } TSKEY dumy = 0; @@ -187,7 +187,7 @@ int32_t updateInfoInit(int64_t interval, int32_t precision, int64_t watermark, b void* tmp = taosArrayPush(pInfo->pTsBuckets, &dumy); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } pInfo->numBuckets = DEFAULT_BUCKET_SIZE; @@ -197,7 +197,7 @@ int32_t updateInfoInit(int64_t interval, int32_t precision, int64_t watermark, b pInfo->pMap = taosHashInit(DEFAULT_MAP_CAPACITY, hashFn, true, HASH_NO_LOCK); if (!pInfo->pMap) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } pInfo->maxDataVersion = 0; pInfo->pkColLen = pkLen; @@ -205,12 +205,12 @@ int32_t updateInfoInit(int64_t interval, int32_t precision, int64_t watermark, b pInfo->pKeyBuff = taosMemoryCalloc(1, sizeof(TSKEY) + sizeof(int64_t) + pkLen); if (!pInfo->pKeyBuff) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } pInfo->pValueBuff = taosMemoryCalloc(1, sizeof(TSKEY) + pkLen); if (!pInfo->pValueBuff) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (pkLen != 0) { pInfo->comparePkRowFn = compareKeyTsAndPk; @@ -234,7 +234,7 @@ static int32_t getSBf(SUpdateInfo* pInfo, TSKEY ts, SScalableBf** ppSBf) { int32_t lino = 0; if (ts <= 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (pInfo->minTS < 0) { pInfo->minTS = (TSKEY)(ts / pInfo->interval * pInfo->interval); @@ -242,13 +242,13 @@ static int32_t getSBf(SUpdateInfo* pInfo, TSKEY ts, SScalableBf** ppSBf) { int64_t index = (int64_t)((ts - pInfo->minTS) / pInfo->interval); if (index < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (index >= pInfo->numSBFs) { uint64_t count = index + 1 - pInfo->numSBFs; windowSBfDelete(pInfo, count); code = windowSBfAdd(pInfo, count); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); index = pInfo->numSBFs - 1; } @@ -256,12 +256,12 @@ static int32_t getSBf(SUpdateInfo* pInfo, TSKEY ts, SScalableBf** ppSBf) { if (res == NULL) { int64_t rows = adjustExpEntries(pInfo->interval * ROWS_PER_MILLISECOND); code = tScalableBfInit(rows, DEFAULT_FALSE_POSITIVE, &res); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); void* tmp = taosArrayPush(pInfo->pTsSBFs, &res); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } (*ppSBf) = res; @@ -311,7 +311,7 @@ int32_t updateInfoFillBlockData(SUpdateInfo* pInfo, SSDataBlock* pBlock, int32_t } SScalableBf* pSBf = NULL; code = getSBf(pInfo, ts, &pSBf); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pSBf) { if (primaryKeyCol >= 0) { @@ -322,14 +322,14 @@ int32_t updateInfoFillBlockData(SUpdateInfo* pInfo, SSDataBlock* pBlock, int32_t // we don't care whether the data is updated or not int32_t winRes = 0; code = tScalableBfPut(pSBf, pInfo->pKeyBuff, buffLen, &winRes); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } void* pMaxTs = taosHashGet(pInfo->pMap, &tbUid, sizeof(int64_t)); if (pMaxTs == NULL || pInfo->comparePkRowFn(pMaxTs, &maxTs, pMaxPkVal, pInfo->comparePkCol) == -1) { int32_t valueLen = getValueBuff(maxTs, pMaxPkVal, maxLen, pInfo->pValueBuff); code = taosHashPut(pInfo->pMap, &tbUid, sizeof(int64_t), pInfo->pValueBuff, valueLen); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } (*pMaxResTs) = maxTs; @@ -354,7 +354,7 @@ bool updateInfoIsUpdated(SUpdateInfo* pInfo, uint64_t tableId, TSKEY ts, void* p // this window has been closed. if (pInfo->pCloseWinSBF) { code = tScalableBfPut(pInfo->pCloseWinSBF, pInfo->pKeyBuff, buffLen, &res); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (res == TSDB_CODE_SUCCESS) { return false; } else { @@ -366,14 +366,14 @@ bool updateInfoIsUpdated(SUpdateInfo* pInfo, uint64_t tableId, TSKEY ts, void* p SScalableBf* pSBf = NULL; code = getSBf(pInfo, ts, &pSBf); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); int32_t size = taosHashGetSize(pInfo->pMap); if ((!pMapMaxTs && size < DEFAULT_MAP_SIZE) || (pMapMaxTs && pInfo->comparePkRowFn(pMapMaxTs, &ts, pPkVal, pInfo->comparePkCol) == -1)) { int32_t valueLen = getValueBuff(ts, pPkVal, len, pInfo->pValueBuff); code = taosHashPut(pInfo->pMap, &tableId, sizeof(uint64_t), pInfo->pValueBuff, valueLen); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); // pSBf may be a null pointer if (pSBf) { @@ -385,7 +385,7 @@ bool updateInfoIsUpdated(SUpdateInfo* pInfo, uint64_t tableId, TSKEY ts, void* p // pSBf may be a null pointer if (pSBf) { code = tScalableBfPut(pSBf, pInfo->pKeyBuff, buffLen, &res); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (!pMapMaxTs && maxTs < ts) { @@ -458,67 +458,67 @@ int32_t updateInfoSerialize(void* buf, int32_t bufLen, const SUpdateInfo* pInfo, tEncoderInit(&encoder, buf, bufLen); if (tStartEncode(&encoder) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } int32_t size = taosArrayGetSize(pInfo->pTsBuckets); if (tEncodeI32(&encoder, size) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } for (int32_t i = 0; i < size; i++) { TSKEY* pTs = (TSKEY*)taosArrayGet(pInfo->pTsBuckets, i); if (tEncodeI64(&encoder, *pTs) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } if (tEncodeU64(&encoder, pInfo->numBuckets) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } int32_t sBfSize = taosArrayGetSize(pInfo->pTsSBFs); if (tEncodeI32(&encoder, sBfSize) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } for (int32_t i = 0; i < sBfSize; i++) { SScalableBf* pSBf = taosArrayGetP(pInfo->pTsSBFs, i); if (tScalableBfEncode(pSBf, &encoder) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } if (tEncodeU64(&encoder, pInfo->numSBFs) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (tEncodeI64(&encoder, pInfo->interval) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (tEncodeI64(&encoder, pInfo->watermark) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (tEncodeI64(&encoder, pInfo->minTS) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (tScalableBfEncode(pInfo->pCloseWinSBF, &encoder) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } int32_t mapSize = taosHashGetSize(pInfo->pMap); if (tEncodeI32(&encoder, mapSize) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } void* pIte = NULL; size_t keyLen = 0; @@ -526,27 +526,27 @@ int32_t updateInfoSerialize(void* buf, int32_t bufLen, const SUpdateInfo* pInfo, void* key = taosHashGetKey(pIte, &keyLen); if (tEncodeU64(&encoder, *(uint64_t*)key) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } int32_t valueSize = taosHashGetValueSize(pIte); if (tEncodeBinary(&encoder, (const uint8_t*)pIte, valueSize) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } if (tEncodeU64(&encoder, pInfo->maxDataVersion) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (tEncodeI32(&encoder, pInfo->pkColLen) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } if (tEncodeI8(&encoder, pInfo->pkColType) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } tEndEncode(&encoder); @@ -579,7 +579,7 @@ int32_t updateInfoDeserialize(void* buf, int32_t bufLen, SUpdateInfo* pInfo) { void* tmp = taosArrayPush(pInfo->pTsBuckets, &ts); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } } @@ -591,12 +591,12 @@ int32_t updateInfoDeserialize(void* buf, int32_t bufLen, SUpdateInfo* pInfo) { for (int32_t i = 0; i < sBfSize; i++) { SScalableBf* pSBf = NULL; code = tScalableBfDecode(&decoder, &pSBf); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); void* tmp = taosArrayPush(pInfo->pTsSBFs, &pSBf); if (!tmp) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } } @@ -622,7 +622,7 @@ int32_t updateInfoDeserialize(void* buf, int32_t bufLen, SUpdateInfo* pInfo) { if (tDecodeU64(&decoder, &uid) < 0) return -1; if (tDecodeBinary(&decoder, (uint8_t**)&pVal, &valSize) < 0) return -1; code = taosHashPut(pInfo->pMap, &uid, sizeof(uint64_t), pVal, valSize); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } ASSERT(mapSize == taosHashGetSize(pInfo->pMap)); if (tDecodeU64(&decoder, &pInfo->maxDataVersion) < 0) return -1; @@ -662,7 +662,7 @@ bool isIncrementalTimeStamp(SUpdateInfo* pInfo, uint64_t tableId, TSKEY ts, void } else { int32_t valueLen = getValueBuff(ts, pPkVal, len, pInfo->pValueBuff); code = taosHashPut(pInfo->pMap, &tableId, sizeof(uint64_t), pInfo->pValueBuff, valueLen); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } return res; diff --git a/source/libs/stream/src/tstreamFileState.c b/source/libs/stream/src/tstreamFileState.c index 2f656d9b41..b16e137dc9 100644 --- a/source/libs/stream/src/tstreamFileState.c +++ b/source/libs/stream/src/tstreamFileState.c @@ -261,7 +261,7 @@ int32_t putFreeBuff(SStreamFileState* pFileState, SRowBuffPos* pPos) { int32_t lino = 0; if (pPos->pRowBuff) { code = tdListAppend(pFileState->freeBuffs, &(pPos->pRowBuff)); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pPos->pRowBuff = NULL; } @@ -283,7 +283,7 @@ void clearExpiredRowBuff(SStreamFileState* pFileState, TSKEY ts, bool all) { SRowBuffPos* pPos = *(SRowBuffPos**)(pNode->data); if (all || (pFileState->getTs(pPos->pKey) < ts && !pPos->beUsed)) { code = putFreeBuff(pFileState, pPos); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (!all) { pFileState->stateBuffRemoveByPosFn(pFileState, pPos); @@ -312,7 +312,7 @@ int32_t clearFlushedRowBuff(SStreamFileState* pFileState, SStreamSnapshot* pFlus SRowBuffPos* pPos = *(SRowBuffPos**)pNode->data; if (isFlushedState(pFileState, pFileState->getTs(pPos->pKey), 0) && !pPos->beUsed) { code = tdListAppend(pFlushList, &pPos); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pFileState->flushMark = TMAX(pFileState->flushMark, pFileState->getTs(pPos->pKey)); pFileState->stateBuffRemoveByPosFn(pFileState, pPos); @@ -358,7 +358,7 @@ int32_t popUsedBuffs(SStreamFileState* pFileState, SStreamSnapshot* pFlushList, continue; } code = tdListAppend(pFlushList, &pPos); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pFileState->flushMark = TMAX(pFileState->flushMark, pFileState->getTs(pPos->pKey)); pFileState->stateBuffRemoveByPosFn(pFileState, pPos); @@ -385,21 +385,21 @@ int32_t flushRowBuff(SStreamFileState* pFileState) { SStreamSnapshot* pFlushList = tdListNew(POINTER_BYTES); if (!pFlushList) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } uint64_t num = (uint64_t)(pFileState->curRowCount * FLUSH_RATIO); num = TMAX(num, FLUSH_NUM); code = clearFlushedRowBuff(pFileState, pFlushList, num); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (isListEmpty(pFlushList)) { code = popUsedBuffs(pFileState, pFlushList, num, false); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (isListEmpty(pFlushList)) { code = popUsedBuffs(pFileState, pFlushList, num, true); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } @@ -411,7 +411,7 @@ int32_t flushRowBuff(SStreamFileState* pFileState) { while ((pNode = tdListNext(&fIter)) != NULL) { SRowBuffPos* pPos = *(SRowBuffPos**)pNode->data; code = putFreeBuff(pFileState, pPos); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } tdListFreeP(pFlushList, destroyRowBuffPosPtr); @@ -456,13 +456,13 @@ SRowBuffPos* getNewRowPos(SStreamFileState* pFileState) { SRowBuffPos* pPos = taosMemoryCalloc(1, sizeof(SRowBuffPos)); if (!pPos) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } pPos->pKey = taosMemoryCalloc(1, pFileState->keyLen); if (!pPos->pKey) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } void* pBuff = getFreeBuff(pFileState); @@ -481,13 +481,13 @@ SRowBuffPos* getNewRowPos(SStreamFileState* pFileState) { } code = clearRowBuff(pFileState); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); pPos->pRowBuff = getFreeBuff(pFileState); _end: code = tdListAppend(pFileState->usedBuffs, &pPos); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); _error: if (code != TSDB_CODE_SUCCESS) { @@ -505,7 +505,7 @@ SRowBuffPos* getNewRowPosForWrite(SStreamFileState* pFileState) { SRowBuffPos* newPos = getNewRowPos(pFileState); if (!newPos) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } newPos->beUsed = true; newPos->beFlushed = false; @@ -537,7 +537,7 @@ int32_t getRowBuff(SStreamFileState* pFileState, void* pKey, int32_t keyLen, voi SRowBuffPos* pNewPos = getNewRowPosForWrite(pFileState); if (!pNewPos || !pNewPos->pRowBuff) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } memcpy(pNewPos->pKey, pKey, keyLen); @@ -556,7 +556,7 @@ int32_t getRowBuff(SStreamFileState* pFileState, void* pKey, int32_t keyLen, voi } code = tSimpleHashPut(pFileState->rowStateBuff, pKey, keyLen, &pNewPos, POINTER_BYTES); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); if (pVal) { *pVLen = pFileState->rowSize; @@ -592,7 +592,7 @@ static int32_t recoverSessionRowBuff(SStreamFileState* pFileState, SRowBuffPos* int32_t len = 0; void* pBuff = NULL; code = pFileState->stateFileGetFn(pFileState, pPos->pKey, &pBuff, &len); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); memcpy(pPos->pRowBuff, pBuff, len); taosMemoryFree(pBuff); @@ -609,7 +609,7 @@ int32_t getRowBuffByPos(SStreamFileState* pFileState, SRowBuffPos* pPos, void** if (pPos->pRowBuff) { if (pPos->needFree) { code = recoverSessionRowBuff(pFileState, pPos); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } (*pVal) = pPos->pRowBuff; goto _end; @@ -621,19 +621,19 @@ int32_t getRowBuffByPos(SStreamFileState* pFileState, SRowBuffPos* pPos, void** pPos->pRowBuff = taosMemoryCalloc(1, pFileState->rowSize); if (!pPos->pRowBuff) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } pFileState->curRowCount++; } else { code = clearRowBuff(pFileState); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); pPos->pRowBuff = getFreeBuff(pFileState); } ASSERT(pPos->pRowBuff); } code = recoverSessionRowBuff(pFileState, pPos); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); (*pVal) = pPos->pRowBuff; if (!pPos->needFree) { @@ -680,13 +680,13 @@ void flushSnapshot(SStreamFileState* pFileState, SStreamSnapshot* pSnapshot, boo char* buf = taosMemoryCalloc(1, len); if (!buf) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } void* batch = streamStateCreateBatch(); if (!batch) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } while ((pNode = tdListNext(&iter)) != NULL && code == TSDB_CODE_SUCCESS) { @@ -701,14 +701,14 @@ void flushSnapshot(SStreamFileState* pFileState, SStreamSnapshot* pSnapshot, boo if (streamStateGetBatchSize(batch) >= BATCH_LIMIT) { code = streamStatePutBatch_rocksdb(pFileState->pFileStore, batch); streamStateClearBatch(batch); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } void* pSKey = pFileState->stateBuffCreateStateKeyFn(pPos, ((SStreamState*)pFileState->pFileStore)->number); code = streamStatePutBatchOptimize(pFileState->pFileStore, idx, batch, pSKey, pPos->pRowBuff, pFileState->rowSize, 0, buf); taosMemoryFreeClear(pSKey); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); // todo handle failure memset(buf, 0, len); } @@ -717,7 +717,7 @@ void flushSnapshot(SStreamFileState* pFileState, SStreamSnapshot* pSnapshot, boo int32_t numOfElems = streamStateGetBatchSize(batch); if (numOfElems > 0) { code = streamStatePutBatch_rocksdb(pFileState->pFileStore, batch); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } else { goto _end; } @@ -735,10 +735,10 @@ void flushSnapshot(SStreamFileState* pFileState, SStreamSnapshot* pSnapshot, boo qDebug("===stream===flushMark write:%" PRId64, pFileState->flushMark); code = streamStatePutBatch(pFileState->pFileStore, "default", batch, STREAM_STATE_INFO_NAME, valBuf, len, 0); taosMemoryFree(valBuf); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); code = streamStatePutBatch_rocksdb(pFileState->pFileStore, batch); - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } _end: @@ -858,7 +858,7 @@ void recoverSnapshot(SStreamFileState* pFileState, int64_t ckId) { SRowBuffPos* pNewPos = getNewRowPosForWrite(pFileState); if (!pNewPos || !pNewPos->pRowBuff) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } code = streamStateGetKVByCur_rocksdb(pCur, pNewPos->pKey, (const void**)&pVal, &vlen); diff --git a/source/util/src/tbloomfilter.c b/source/util/src/tbloomfilter.c index 1cf4ecf72e..cf9d5cd79c 100644 --- a/source/util/src/tbloomfilter.c +++ b/source/util/src/tbloomfilter.c @@ -40,12 +40,12 @@ int32_t tBloomFilterInit(uint64_t expectedEntries, double errorRate, SBloomFilte int32_t lino = 0; if (expectedEntries < 1 || errorRate <= 0 || errorRate >= 1.0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } SBloomFilter* pBF = taosMemoryCalloc(1, sizeof(SBloomFilter)); if (pBF == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } pBF->expectedEntries = expectedEntries; pBF->errorRate = errorRate; @@ -66,7 +66,7 @@ int32_t tBloomFilterInit(uint64_t expectedEntries, double errorRate, SBloomFilte if (pBF->buffer == NULL) { tBloomFilterDestroy(pBF); code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } (*ppBF) = pBF; @@ -150,40 +150,40 @@ int32_t tBloomFilterDecode(SDecoder* pDecoder, SBloomFilter** ppBF) { SBloomFilter* pBF = taosMemoryCalloc(1, sizeof(SBloomFilter)); if (!pBF) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } pBF->buffer = NULL; if (tDecodeU32(pDecoder, &pBF->hashFunctions) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } if (tDecodeU64(pDecoder, &pBF->expectedEntries) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } if (tDecodeU64(pDecoder, &pBF->numUnits) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } if (tDecodeU64(pDecoder, &pBF->numBits) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } if (tDecodeU64(pDecoder, &pBF->size) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } pBF->buffer = taosMemoryCalloc(pBF->numUnits, sizeof(uint64_t)); for (int32_t i = 0; i < pBF->numUnits; i++) { uint64_t* pUnits = (uint64_t*)pBF->buffer; if (tDecodeU64(pDecoder, pUnits + i) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } } if (tDecodeDouble(pDecoder, &pBF->errorRate) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } pBF->hashFn1 = HASH_FUNCTION_1; pBF->hashFn2 = HASH_FUNCTION_2; diff --git a/source/util/src/tscalablebf.c b/source/util/src/tscalablebf.c index 95f67d364a..5b018ba677 100644 --- a/source/util/src/tscalablebf.c +++ b/source/util/src/tscalablebf.c @@ -34,12 +34,12 @@ int32_t tScalableBfInit(uint64_t expectedEntries, double errorRate, SScalableBf* const uint32_t defaultSize = 8; if (expectedEntries < 1 || errorRate <= 0 || errorRate >= 1.0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } SScalableBf* pSBf = taosMemoryCalloc(1, sizeof(SScalableBf)); if (pSBf == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } pSBf->maxBloomFilters = DEFAULT_MAX_BLOOMFILTERS; pSBf->status = SBF_VALID; @@ -47,14 +47,14 @@ int32_t tScalableBfInit(uint64_t expectedEntries, double errorRate, SScalableBf* pSBf->bfArray = taosArrayInit(defaultSize, sizeof(void*)); if (!pSBf->bfArray) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } SBloomFilter* pNormalBf = NULL; code = tScalableBfAddFilter(pSBf, expectedEntries, errorRate * DEFAULT_TIGHTENING_RATIO, &pNormalBf); if (code != TSDB_CODE_SUCCESS) { tScalableBfDestroy(pSBf); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } pSBf->growth = DEFAULT_GROWTH; pSBf->hashFn1 = HASH_FUNCTION_1; @@ -72,20 +72,20 @@ int32_t tScalableBfPutNoCheck(SScalableBf* pSBf, const void* keyBuf, uint32_t le int32_t lino = 0; if (pSBf->status == SBF_INVALID) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } int32_t size = taosArrayGetSize(pSBf->bfArray); SBloomFilter* pNormalBf = taosArrayGetP(pSBf->bfArray, size - 1); if (!pNormalBf) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } if (tBloomFilterIsFull(pNormalBf)) { code = tScalableBfAddFilter(pSBf, pNormalBf->expectedEntries * pSBf->growth, pNormalBf->errorRate * DEFAULT_TIGHTENING_RATIO, &pNormalBf); if (code != TSDB_CODE_SUCCESS) { pSBf->status = SBF_INVALID; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } } return tBloomFilterPut(pNormalBf, keyBuf, len); @@ -102,7 +102,7 @@ int32_t tScalableBfPut(SScalableBf* pSBf, const void* keyBuf, uint32_t len, int3 int32_t lino = 0; if (pSBf->status == SBF_INVALID) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } uint64_t h1 = (uint64_t)pSBf->hashFn1(keyBuf, len); uint64_t h2 = (uint64_t)pSBf->hashFn2(keyBuf, len); @@ -121,7 +121,7 @@ int32_t tScalableBfPut(SScalableBf* pSBf, const void* keyBuf, uint32_t len, int3 pNormalBf->errorRate * DEFAULT_TIGHTENING_RATIO, &pNormalBf); if (code != TSDB_CODE_SUCCESS) { pSBf->status = SBF_INVALID; - TSDB_CHECK_CODE(code, lino, _end); + QUERY_CHECK_CODE(code, lino, _end); } } (*winRes) = tBloomFilterPutHash(pNormalBf, h1, h2); @@ -154,17 +154,17 @@ static int32_t tScalableBfAddFilter(SScalableBf* pSBf, uint64_t expectedEntries, int32_t lino = 0; if (taosArrayGetSize(pSBf->bfArray) >= pSBf->maxBloomFilters) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } SBloomFilter* pNormalBf = NULL; code = tBloomFilterInit(expectedEntries, errorRate, &pNormalBf); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); if (taosArrayPush(pSBf->bfArray, &pNormalBf) == NULL) { tBloomFilterDestroy(pNormalBf); code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } pSBf->numBits += pNormalBf->numBits; (*ppNormalBf) = pNormalBf; @@ -210,7 +210,7 @@ int32_t tScalableBfDecode(SDecoder* pDecoder, SScalableBf** ppSBf) { SScalableBf* pSBf = taosMemoryCalloc(1, sizeof(SScalableBf)); if (!pSBf) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } pSBf->hashFn1 = HASH_FUNCTION_1; pSBf->hashFn2 = HASH_FUNCTION_2; @@ -218,43 +218,43 @@ int32_t tScalableBfDecode(SDecoder* pDecoder, SScalableBf** ppSBf) { int32_t size = 0; if (tDecodeI32(pDecoder, &size) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } if (size == 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } pSBf->bfArray = taosArrayInit(size * 2, POINTER_BYTES); if (!pSBf->bfArray) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } for (int32_t i = 0; i < size; i++) { SBloomFilter* pBF = NULL; code = tBloomFilterDecode(pDecoder, &pBF); - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); void* tmpRes = taosArrayPush(pSBf->bfArray, &pBF); if (!tmpRes) { code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } } if (tDecodeU32(pDecoder, &pSBf->growth) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } if (tDecodeU64(pDecoder, &pSBf->numBits) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } if (tDecodeU32(pDecoder, &pSBf->maxBloomFilters) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } if (tDecodeI8(pDecoder, &pSBf->status) < 0) { code = TSDB_CODE_FAILED; - TSDB_CHECK_CODE(code, lino, _error); + QUERY_CHECK_CODE(code, lino, _error); } (*ppSBf) = pSBf; From a618667a5e63d29cf4330e38ccf87af416b98b2f Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao> Date: Fri, 19 Jul 2024 16:23:52 +0800 Subject: [PATCH 02/11] adj stream op result --- source/libs/executor/src/scanoperator.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index a878af8762..2c5f09e394 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -1553,11 +1553,13 @@ static void prepareRangeScan(SStreamScanInfo* pInfo, SSDataBlock* pBlock, int32_ if (pBlock->info.rows == 0) { if (pRes) { (*pRes) = false; + goto _end; } } if ((*pRowIndex) == pBlock->info.rows) { if (pRes) { (*pRes) = false; + goto _end; } } @@ -1611,6 +1613,9 @@ static void prepareRangeScan(SStreamScanInfo* pInfo, SSDataBlock* pBlock, int32_ if (pRes) { (*pRes) = true; } + +_end: + qTrace("%s success", __func__); } static STimeWindow getSlidingWindow(TSKEY* startTsCol, TSKEY* endTsCol, uint64_t* gpIdCol, SInterval* pInterval, From 60699c7895515d025a8314f67d38a5bd320bcb1a Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao> Date: Fri, 19 Jul 2024 17:53:56 +0800 Subject: [PATCH 03/11] adj operator result --- source/libs/executor/src/scanoperator.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index 2c5f09e394..207c81fcb9 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -1553,14 +1553,14 @@ static void prepareRangeScan(SStreamScanInfo* pInfo, SSDataBlock* pBlock, int32_ if (pBlock->info.rows == 0) { if (pRes) { (*pRes) = false; - goto _end; } + goto _end; } if ((*pRowIndex) == pBlock->info.rows) { if (pRes) { (*pRes) = false; - goto _end; } + goto _end; } ASSERT(taosArrayGetSize(pBlock->pDataBlock) >= 3); From 3f2abe8b00e1e1db50e71a454f3f0ad9ddb7eedc Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao> Date: Fri, 19 Jul 2024 18:36:03 +0800 Subject: [PATCH 04/11] adj operator result --- source/libs/stream/src/tstreamFileState.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/source/libs/stream/src/tstreamFileState.c b/source/libs/stream/src/tstreamFileState.c index b16e137dc9..5dacd4c80c 100644 --- a/source/libs/stream/src/tstreamFileState.c +++ b/source/libs/stream/src/tstreamFileState.c @@ -838,6 +838,7 @@ void recoverSesssion(SStreamFileState* pFileState, int64_t ckId) { void recoverSnapshot(SStreamFileState* pFileState, int64_t ckId) { int32_t code = TSDB_CODE_SUCCESS; int32_t lino = 0; + int32_t winCode = TSDB_CODE_SUCCESS; if (pFileState->maxTs != INT64_MIN) { int64_t mark = (INT64_MIN + pFileState->deleteMark >= pFileState->maxTs) ? INT64_MIN @@ -848,7 +849,7 @@ void recoverSnapshot(SStreamFileState* pFileState, int64_t ckId) { SStreamStateCur* pCur = streamStateSeekToLast_rocksdb(pFileState->pFileStore); int32_t recoverNum = TMIN(MIN_NUM_OF_RECOVER_ROW_BUFF, pFileState->maxRowCount); - while (code == TSDB_CODE_SUCCESS) { + while (winCode == TSDB_CODE_SUCCESS) { if (pFileState->curRowCount >= recoverNum) { break; } @@ -861,8 +862,8 @@ void recoverSnapshot(SStreamFileState* pFileState, int64_t ckId) { QUERY_CHECK_CODE(code, lino, _end); } - code = streamStateGetKVByCur_rocksdb(pCur, pNewPos->pKey, (const void**)&pVal, &vlen); - if (code != TSDB_CODE_SUCCESS || pFileState->getTs(pNewPos->pKey) < pFileState->flushMark) { + winCode = streamStateGetKVByCur_rocksdb(pCur, pNewPos->pKey, (const void**)&pVal, &vlen); + if (winCode != TSDB_CODE_SUCCESS || pFileState->getTs(pNewPos->pKey) < pFileState->flushMark) { destroyRowBuffPos(pNewPos); SListNode* pNode = tdListPopTail(pFileState->usedBuffs); taosMemoryFreeClear(pNode); From 6e70da62fb12e756fe89465a0202ef39c5b0bcde Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao> Date: Mon, 22 Jul 2024 12:51:25 +0800 Subject: [PATCH 05/11] adj operator res --- source/libs/executor/inc/executil.h | 2 +- source/libs/executor/inc/executorInt.h | 8 +- source/libs/executor/src/aggregateoperator.c | 41 ++- .../libs/executor/src/countwindowoperator.c | 66 ++-- .../libs/executor/src/eventwindowoperator.c | 46 +-- source/libs/executor/src/executil.c | 15 +- source/libs/executor/src/executor.c | 259 ++++++++++----- source/libs/executor/src/executorInt.c | 214 ++++++++----- source/libs/executor/src/filloperator.c | 109 +++++-- source/libs/executor/src/groupoperator.c | 301 ++++++++++++------ source/libs/executor/src/scanoperator.c | 5 +- .../executor/src/streamcountwindowoperator.c | 6 +- .../executor/src/streameventwindowoperator.c | 18 +- source/libs/executor/src/streamfilloperator.c | 6 +- .../executor/src/streamtimewindowoperator.c | 35 +- source/libs/executor/src/timewindowoperator.c | 52 +-- 16 files changed, 791 insertions(+), 392 deletions(-) diff --git a/source/libs/executor/inc/executil.h b/source/libs/executor/inc/executil.h index 55b803f6d4..27ea98afd5 100644 --- a/source/libs/executor/inc/executil.h +++ b/source/libs/executor/inc/executil.h @@ -179,7 +179,7 @@ SExprInfo* createExprInfo(SNodeList* pNodeList, SNodeList* pGroupKeys, int32_t* SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, int32_t** rowEntryInfoOffset, SFunctionStateStore* pStore); void relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray* pCols, bool outputEveryColumn); -void initExecTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pQueryWindow); +int32_t initExecTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pQueryWindow); SInterval extractIntervalInfo(const STableScanPhysiNode* pTableScanNode); SColumn extractColumnFromColumnNode(SColumnNode* pColNode); diff --git a/source/libs/executor/inc/executorInt.h b/source/libs/executor/inc/executorInt.h index d8267c4579..fec16f9ef4 100644 --- a/source/libs/executor/inc/executorInt.h +++ b/source/libs/executor/inc/executorInt.h @@ -834,9 +834,8 @@ void doBuildResultDatablock(struct SOperatorInfo* pOperator, SOptrBasicInfo* pbI /** * @brief copydata from hash table, instead of copying from SGroupResInfo's pRow */ -int32_t doCopyToSDataBlockByHash(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf, - SGroupResInfo* pGroupResInfo, SSHashObj* pHashmap, int32_t threshold, - bool ignoreGroup); +void doCopyToSDataBlockByHash(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf, + SGroupResInfo* pGroupResInfo, SSHashObj* pHashmap, int32_t threshold, bool ignoreGroup); bool hasLimitOffsetInfo(SLimitInfo* pLimitInfo); bool hasSlimitOffsetInfo(SLimitInfo* pLimitInfo); @@ -879,7 +878,8 @@ SResultRow* doSetResultOutBufByKey(SDiskbasedBuf* pResultBuf, SResultRowInfo* pR int32_t projectApplyFunctions(SExprInfo* pExpr, SSDataBlock* pResult, SSDataBlock* pSrcBlock, SqlFunctionCtx* pCtx, int32_t numOfOutput, SArray* pPseudoList); -void setInputDataBlock(SExprSupp* pExprSupp, SSDataBlock* pBlock, int32_t order, int32_t scanFlag, bool createDummyCol); +int32_t setInputDataBlock(SExprSupp* pExprSupp, SSDataBlock* pBlock, int32_t order, int32_t scanFlag, + bool createDummyCol); int32_t checkForQueryBuf(size_t numOfTables); diff --git a/source/libs/executor/src/aggregateoperator.c b/source/libs/executor/src/aggregateoperator.c index 5ff0601b7a..55cb8c8302 100644 --- a/source/libs/executor/src/aggregateoperator.c +++ b/source/libs/executor/src/aggregateoperator.c @@ -21,6 +21,7 @@ #include "tname.h" #include "executorInt.h" +#include "index.h" #include "operator.h" #include "query.h" #include "querytask.h" @@ -29,7 +30,6 @@ #include "tglobal.h" #include "thash.h" #include "ttypes.h" -#include "index.h" typedef struct { bool hasAgg; @@ -54,13 +54,13 @@ static void destroyAggOperatorInfo(void* param); static void setExecutionContext(SOperatorInfo* pOperator, int32_t numOfOutput, uint64_t groupId); static int32_t createDataBlockForEmptyInput(SOperatorInfo* pOperator, SSDataBlock** ppBlock); -static void destroyDataBlockForEmptyInput(bool blockAllocated, SSDataBlock** ppBlock); +static void destroyDataBlockForEmptyInput(bool blockAllocated, SSDataBlock** ppBlock); -static int32_t doAggregateImpl(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx); +static int32_t doAggregateImpl(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx); static SSDataBlock* getAggregateResult(SOperatorInfo* pOperator); static int32_t doInitAggInfoSup(SAggSupporter* pAggSup, SqlFunctionCtx* pCtx, int32_t numOfOutput, size_t keyBufSize, - const char* pKey); + const char* pKey); static int32_t addNewResultRowBuf(SResultRow* pWindowRes, SDiskbasedBuf* pResultBuf, uint32_t size); @@ -134,7 +134,7 @@ SOperatorInfo* createAggregateOperatorInfo(SOperatorInfo* downstream, SAggPhysiN return pOperator; - _error: +_error: if (pInfo != NULL) { destroyAggOperatorInfo(pInfo); } @@ -166,6 +166,8 @@ void destroyAggOperatorInfo(void* param) { * if false, fill results of ONE GROUP * */ static bool nextGroupedResult(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SAggOperatorInfo* pAggInfo = pOperator->info; @@ -175,7 +177,6 @@ static bool nextGroupedResult(SOperatorInfo* pOperator) { SOperatorInfo* downstream = pOperator->pDownstream[0]; int64_t st = taosGetTimestampUs(); - int32_t code = TSDB_CODE_SUCCESS; int32_t order = pAggInfo->binfo.inputTsOrder; SSDataBlock* pBlock = pAggInfo->pNewGroupBlock; @@ -183,11 +184,10 @@ static bool nextGroupedResult(SOperatorInfo* pOperator) { pAggInfo->pNewGroupBlock = NULL; tSimpleHashClear(pAggInfo->aggSup.pResultRowHashTable); setExecutionContext(pOperator, pOperator->exprSupp.numOfExprs, pBlock->info.id.groupId); - setInputDataBlock(pSup, pBlock, order, pBlock->info.scanFlag, true); + QUERY_CHECK_CODE(code, lino, _end); + code = setInputDataBlock(pSup, pBlock, order, pBlock->info.scanFlag, true); code = doAggregateImpl(pOperator, pSup->pCtx); - if (code != TSDB_CODE_SUCCESS) { - T_LONG_JMP(pTaskInfo->env, code); - } + QUERY_CHECK_CODE(code, lino, _end); } while (1) { bool blockAllocated = false; @@ -222,7 +222,9 @@ static bool nextGroupedResult(SOperatorInfo* pOperator) { } // the pDataBlock are always the same one, no need to call this again setExecutionContext(pOperator, pOperator->exprSupp.numOfExprs, pBlock->info.id.groupId); - setInputDataBlock(pSup, pBlock, order, pBlock->info.scanFlag, true); + code = setInputDataBlock(pSup, pBlock, order, pBlock->info.scanFlag, true); + QUERY_CHECK_CODE(code, lino, _end); + code = doAggregateImpl(pOperator, pSup->pCtx); if (code != 0) { destroyDataBlockForEmptyInput(blockAllocated, &pBlock); @@ -238,6 +240,13 @@ static bool nextGroupedResult(SOperatorInfo* pOperator) { } initGroupedResultInfo(&pAggInfo->groupResInfo, pAggInfo->aggSup.pResultRowHashTable, 0); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return pBlock != NULL; } @@ -250,7 +259,7 @@ SSDataBlock* getAggregateResult(SOperatorInfo* pOperator) { } SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - bool hasNewGroups = false; + bool hasNewGroups = false; do { hasNewGroups = nextGroupedResult(pOperator); blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); @@ -336,7 +345,6 @@ static int32_t createDataBlockForEmptyInput(SOperatorInfo* pOperator, SSDataBloc colInfo.info.type = TSDB_DATA_TYPE_NULL; colInfo.info.bytes = 1; - SExprInfo* pOneExpr = &pOperator->exprSupp.pExprInfo[i]; for (int32_t j = 0; j < pOneExpr->base.numOfParams; ++j) { SFunctParam* pFuncParam = &pOneExpr->base.pParam[j]; @@ -395,8 +403,9 @@ void doSetTableGroupOutputBuf(SOperatorInfo* pOperator, int32_t numOfOutput, uin SqlFunctionCtx* pCtx = pOperator->exprSupp.pCtx; int32_t* rowEntryInfoOffset = pOperator->exprSupp.rowEntryInfoOffset; - SResultRow* pResultRow = doSetResultOutBufByKey(pAggInfo->aggSup.pResultBuf, pResultRowInfo, (char*)&groupId, - sizeof(groupId), true, groupId, pTaskInfo, false, &pAggInfo->aggSup, true); + SResultRow* pResultRow = + doSetResultOutBufByKey(pAggInfo->aggSup.pResultBuf, pResultRowInfo, (char*)&groupId, sizeof(groupId), true, + groupId, pTaskInfo, false, &pAggInfo->aggSup, true); /* * not assign result buffer yet, add new result buffer * all group belong to one result set, and each group result has different group id so set the id to be one @@ -486,7 +495,7 @@ int32_t doInitAggInfoSup(SAggSupporter* pAggSup, SqlFunctionCtx* pCtx, int32_t n qError("failed to get buff page size, rowSize:%d", pAggSup->resultRowSize); return code; } - + if (!osTempSpaceAvailable()) { code = TSDB_CODE_NO_DISKSPACE; qError("Init stream agg supporter failed since %s, key:%s, tempDir:%s", tstrerror(code), pKey, tsTempDir); diff --git a/source/libs/executor/src/countwindowoperator.c b/source/libs/executor/src/countwindowoperator.c index 3a6c85532a..6e476c4ea0 100644 --- a/source/libs/executor/src/countwindowoperator.c +++ b/source/libs/executor/src/countwindowoperator.c @@ -25,13 +25,13 @@ #include "ttime.h" typedef struct SCountWindowResult { - int32_t winRows; - SResultRow row; + int32_t winRows; + SResultRow row; } SCountWindowResult; typedef struct SCountWindowSupp { - SArray* pWinStates; - int32_t stateIndex; + SArray* pWinStates; + int32_t stateIndex; } SCountWindowSupp; typedef struct SCountWindowOperatorInfo { @@ -61,13 +61,11 @@ void destroyCountWindowOperatorInfo(void* param) { taosMemoryFreeClear(param); } -static void clearWinStateBuff(SCountWindowResult* pBuff) { - pBuff->winRows = 0; -} +static void clearWinStateBuff(SCountWindowResult* pBuff) { pBuff->winRows = 0; } static SCountWindowResult* getCountWinStateInfo(SCountWindowSupp* pCountSup) { SCountWindowResult* pBuffInfo = taosArrayGet(pCountSup->pWinStates, pCountSup->stateIndex); - int32_t size = taosArrayGetSize(pCountSup->pWinStates); + int32_t size = taosArrayGetSize(pCountSup->pWinStates); // coverity scan ASSERTS(size > 0, "WinStates is empty"); if (size > 0) { @@ -76,7 +74,8 @@ static SCountWindowResult* getCountWinStateInfo(SCountWindowSupp* pCountSup) { return pBuffInfo; } -static SCountWindowResult* setCountWindowOutputBuff(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, SResultRow** pResult) { +static SCountWindowResult* setCountWindowOutputBuff(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, + SResultRow** pResult) { SCountWindowResult* pBuff = getCountWinStateInfo(pCountSup); (*pResult) = &pBuff->row; setResultRowInitCtx(*pResult, pExprSup->pCtx, pExprSup->numOfExprs, pExprSup->rowEntryInfoOffset); @@ -100,9 +99,9 @@ int32_t doCountWindowAggImpl(SOperatorInfo* pOperator, SSDataBlock* pBlock) { for (int32_t i = 0; i < pBlock->info.rows;) { SCountWindowResult* pBuffInfo = setCountWindowOutputBuff(pExprSup, &pInfo->countSup, &pInfo->pRow); - int32_t prevRows = pBuffInfo->winRows; - int32_t num = updateCountWindowInfo(i, pBlock->info.rows, pInfo->windowCount, &pBuffInfo->winRows); - int32_t step = num; + int32_t prevRows = pBuffInfo->winRows; + int32_t num = updateCountWindowInfo(i, pBlock->info.rows, pInfo->windowCount, &pBuffInfo->winRows); + int32_t step = num; if (prevRows == 0) { pInfo->pRow->win.skey = tsCols[i]; } @@ -136,12 +135,14 @@ int32_t doCountWindowAggImpl(SOperatorInfo* pOperator, SSDataBlock* pBlock) { return code; } -static void buildCountResult(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, SExecTaskInfo* pTaskInfo, SFilterInfo* pFilterInfo, SSDataBlock* pBlock) { +static void buildCountResult(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, SExecTaskInfo* pTaskInfo, + SFilterInfo* pFilterInfo, SSDataBlock* pBlock) { SResultRow* pResultRow = NULL; for (int32_t i = 0; i < taosArrayGetSize(pCountSup->pWinStates); i++) { SCountWindowResult* pBuff = setCountWindowOutputBuff(pExprSup, pCountSup, &pResultRow); if (pBuff->winRows == 0) { - continue;; + continue; + ; } doUpdateNumOfRows(pExprSup->pCtx, pResultRow, pExprSup->numOfExprs, pExprSup->rowEntryInfoOffset); copyResultrowToDataBlock(pExprSup->pExprInfo, pExprSup->numOfExprs, pResultRow, pExprSup->pCtx, pBlock, @@ -154,6 +155,8 @@ static void buildCountResult(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, S } static SSDataBlock* countWindowAggregate(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SCountWindowOperatorInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SExprSupp* pExprSup = &pOperator->exprSupp; @@ -170,8 +173,11 @@ static SSDataBlock* countWindowAggregate(SOperatorInfo* pOperator) { } pRes->info.scanFlag = pBlock->info.scanFlag; - setInputDataBlock(pExprSup, pBlock, order, MAIN_SCAN, true); - blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId); + code = setInputDataBlock(pExprSup, pBlock, order, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); + + code = blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId); + QUERY_CHECK_CODE(code, lino, _end); // there is an scalar expression that needs to be calculated right before apply the group aggregation. if (pInfo->scalarSup.pExprInfo != NULL) { @@ -196,11 +202,19 @@ static SSDataBlock* countWindowAggregate(SOperatorInfo* pOperator) { } buildCountResult(pExprSup, &pInfo->countSup, pTaskInfo, pOperator->exprSupp.pFilterInfo, pRes); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } return pRes->info.rows == 0 ? NULL : pRes; } SOperatorInfo* createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* physiNode, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SCountWindowOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SCountWindowOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -209,7 +223,6 @@ SOperatorInfo* createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo pOperator->exprSupp.hasWindowOrGroup = true; - int32_t code = TSDB_CODE_SUCCESS; SCountWinodwPhysiNode* pCountWindowNode = (SCountWinodwPhysiNode*)physiNode; pInfo->tsSlotId = ((SColumnNode*)pCountWindowNode->window.pTspk)->slotId; @@ -218,21 +231,17 @@ SOperatorInfo* createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo int32_t numOfScalarExpr = 0; SExprInfo* pScalarExprInfo = createExprInfo(pCountWindowNode->window.pExprs, NULL, &numOfScalarExpr); code = initExprSupp(&pInfo->scalarSup, pScalarExprInfo, numOfScalarExpr, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); } - size_t keyBufSize = 0; + size_t keyBufSize = 0; int32_t num = 0; SExprInfo* pExprInfo = createExprInfo(pCountWindowNode->window.pFuncs, NULL, &num); initResultSizeInfo(&pOperator->resultInfo, 4096); code = initAggSup(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str, pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); SSDataBlock* pResBlock = createDataBlockFromDescNode(pCountWindowNode->window.node.pOutputDataBlockDesc); blockDataEnsureCapacity(pResBlock, pOperator->resultInfo.capacity); @@ -243,7 +252,7 @@ SOperatorInfo* createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo pInfo->binfo.outputTsOrder = physiNode->outputTsOrder; pInfo->windowCount = pCountWindowNode->windowCount; pInfo->windowSliding = pCountWindowNode->windowSliding; - //sizeof(SCountWindowResult) + // sizeof(SCountWindowResult) int32_t itemSize = sizeof(int32_t) + pInfo->aggSup.resultRowSize; int32_t numOfItem = 1; if (pInfo->windowCount != pInfo->windowSliding) { @@ -257,11 +266,10 @@ SOperatorInfo* createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo pInfo->countSup.stateIndex = 0; code = filterInitFromNode((SNode*)pCountWindowNode->window.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + QUERY_CHECK_CODE(code, lino, _error); setOperatorInfo(pOperator, "CountWindowOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE_COUNT, true, OP_NOT_OPENED, pInfo, pTaskInfo); diff --git a/source/libs/executor/src/eventwindowoperator.c b/source/libs/executor/src/eventwindowoperator.c index b898ea576a..f15b05f817 100644 --- a/source/libs/executor/src/eventwindowoperator.c +++ b/source/libs/executor/src/eventwindowoperator.c @@ -60,6 +60,8 @@ static void doKeepTuple(SWindowRowsSup* pRowSup, int64_t ts, uint64_t groupId) { SOperatorInfo* createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNode* physiNode, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SEventWindowOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SEventWindowOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -71,29 +73,21 @@ SOperatorInfo* createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo SEventWinodwPhysiNode* pEventWindowNode = (SEventWinodwPhysiNode*)physiNode; int32_t tsSlotId = ((SColumnNode*)pEventWindowNode->window.pTspk)->slotId; - int32_t code = filterInitFromNode((SNode*)pEventWindowNode->pStartCond, &pInfo->pStartCondInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + code = filterInitFromNode((SNode*)pEventWindowNode->pStartCond, &pInfo->pStartCondInfo, 0); + QUERY_CHECK_CODE(code, lino, _error); code = filterInitFromNode((SNode*)pEventWindowNode->pEndCond, &pInfo->pEndCondInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); if (pEventWindowNode->window.pExprs != NULL) { int32_t numOfScalarExpr = 0; SExprInfo* pScalarExprInfo = createExprInfo(pEventWindowNode->window.pExprs, NULL, &numOfScalarExpr); code = initExprSupp(&pInfo->scalarSup, pScalarExprInfo, numOfScalarExpr, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); } code = filterInitFromNode((SNode*)pEventWindowNode->window.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); size_t keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES; @@ -103,12 +97,13 @@ SOperatorInfo* createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo code = initAggSup(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str, pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); SSDataBlock* pResBlock = createDataBlockFromDescNode(pEventWindowNode->window.node.pOutputDataBlockDesc); - blockDataEnsureCapacity(pResBlock, pOperator->resultInfo.capacity); + QUERY_CHECK_NULL(pResBlock, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + + code = blockDataEnsureCapacity(pResBlock, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _error); initBasicInfo(&pInfo->binfo, pResBlock); initResultRowInfo(&pInfo->binfo.resultRowInfo); @@ -118,7 +113,8 @@ SOperatorInfo* createEventwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo pInfo->twAggSup = (STimeWindowAggSupp){.waterMark = pEventWindowNode->window.watermark, .calTrigger = pEventWindowNode->window.triggerType}; - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + QUERY_CHECK_CODE(code, lino, _error); pInfo->tsSlotId = tsSlotId; @@ -173,6 +169,8 @@ void destroyEWindowOperatorInfo(void* param) { } static SSDataBlock* eventWindowAggregate(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SEventWindowOperatorInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; @@ -191,8 +189,11 @@ static SSDataBlock* eventWindowAggregate(SOperatorInfo* pOperator) { } pRes->info.scanFlag = pBlock->info.scanFlag; - setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true); - blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId); + code = setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); + + code = blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId); + QUERY_CHECK_CODE(code, lino, _end); // there is an scalar expression that needs to be calculated right before apply the group aggregation. if (pInfo->scalarSup.pExprInfo != NULL) { @@ -210,6 +211,11 @@ static SSDataBlock* eventWindowAggregate(SOperatorInfo* pOperator) { } } +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } return pRes->info.rows == 0 ? NULL : pRes; } diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c index c623e94a12..aa24e3a8b8 100644 --- a/source/libs/executor/src/executil.c +++ b/source/libs/executor/src/executil.c @@ -2021,18 +2021,27 @@ uint64_t tableListGetTableGroupId(const STableListInfo* pTableList, uint64_t tab // TODO handle the group offset info, fix it, the rule of group output will be broken by this function int32_t tableListAddTableInfo(STableListInfo* pTableList, uint64_t uid, uint64_t gid) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pTableList->map == NULL) { pTableList->map = taosHashInit(32, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_ENTRY_LOCK); + QUERY_CHECK_NULL(pTableList->map, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } STableKeyInfo keyInfo = {.uid = uid, .groupId = gid}; - taosArrayPush(pTableList->pTableList, &keyInfo); + void* tmp = taosArrayPush(pTableList->pTableList, &keyInfo); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); int32_t slot = (int32_t)taosArrayGetSize(pTableList->pTableList) - 1; - taosHashPut(pTableList->map, &uid, sizeof(uid), &slot, sizeof(slot)); + code = taosHashPut(pTableList->map, &uid, sizeof(uid), &slot, sizeof(slot)); + QUERY_CHECK_CODE(code, lino, _end); +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } qDebug("uid:%" PRIu64 ", groupId:%" PRIu64 " added into table list, slot:%d, total:%d", uid, gid, slot, slot + 1); - return TSDB_CODE_SUCCESS; + return code; } int32_t tableListGetGroupList(const STableListInfo* pTableList, int32_t ordinalGroupIndex, STableKeyInfo** pKeyInfo, diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c index 4aff0e69a3..c79f69129c 100644 --- a/source/libs/executor/src/executor.c +++ b/source/libs/executor/src/executor.c @@ -15,14 +15,14 @@ #include "executor.h" #include "executorInt.h" -#include "trpc.h" -#include "wal.h" #include "operator.h" #include "planner.h" #include "querytask.h" #include "tdatablock.h" #include "tref.h" +#include "trpc.h" #include "tudf.h" +#include "wal.h" #include "storageapi.h" @@ -31,15 +31,17 @@ int32_t exchangeObjRefPool = -1; static void cleanupRefPool() { int32_t ref = atomic_val_compare_exchange_32(&exchangeObjRefPool, exchangeObjRefPool, 0); - taosCloseRef(ref); + (void)taosCloseRef(ref); } static void initRefPool() { exchangeObjRefPool = taosOpenRef(1024, doDestroyExchangeOperatorInfo); - atexit(cleanupRefPool); + (void)atexit(cleanupRefPool); } static int32_t doSetSMABlock(SOperatorInfo* pOperator, void* input, size_t numOfBlocks, int32_t type, char* id) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) { if (pOperator->numOfDownstream == 0) { qError("failed to find stream scan operator to set the input data block, %s" PRIx64, id); @@ -60,33 +62,44 @@ static int32_t doSetSMABlock(SOperatorInfo* pOperator, void* input, size_t numOf if (type == STREAM_INPUT__MERGED_SUBMIT) { for (int32_t i = 0; i < numOfBlocks; i++) { SPackedData* pReq = POINTER_SHIFT(input, i * sizeof(SPackedData)); - taosArrayPush(pInfo->pBlockLists, pReq); + void* tmp = taosArrayPush(pInfo->pBlockLists, pReq); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } pInfo->blockType = STREAM_INPUT__DATA_SUBMIT; } else if (type == STREAM_INPUT__DATA_SUBMIT) { - taosArrayPush(pInfo->pBlockLists, &input); + void* tmp = taosArrayPush(pInfo->pBlockLists, &input); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); pInfo->blockType = STREAM_INPUT__DATA_SUBMIT; } else if (type == STREAM_INPUT__DATA_BLOCK) { for (int32_t i = 0; i < numOfBlocks; ++i) { SSDataBlock* pDataBlock = &((SSDataBlock*)input)[i]; - SPackedData tmp = {.pDataBlock = pDataBlock}; - taosArrayPush(pInfo->pBlockLists, &tmp); + SPackedData tmp = {.pDataBlock = pDataBlock}; + void* tmpItem = taosArrayPush(pInfo->pBlockLists, &tmp); + QUERY_CHECK_NULL(tmpItem, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } pInfo->blockType = STREAM_INPUT__DATA_BLOCK; } else if (type == STREAM_INPUT__CHECKPOINT) { SPackedData tmp = {.pDataBlock = input}; - taosArrayPush(pInfo->pBlockLists, &tmp); + void* tmpItem = taosArrayPush(pInfo->pBlockLists, &tmp); + QUERY_CHECK_NULL(tmpItem, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); pInfo->blockType = STREAM_INPUT__CHECKPOINT; } else if (type == STREAM_INPUT__REF_DATA_BLOCK) { - for (int32_t i = 0; i < numOfBlocks; ++i) { + for (int32_t i = 0; i < numOfBlocks; ++i) { SPackedData* pReq = POINTER_SHIFT(input, i * sizeof(SPackedData)); - taosArrayPush(pInfo->pBlockLists, pReq); + void* tmp = taosArrayPush(pInfo->pBlockLists, pReq); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } pInfo->blockType = STREAM_INPUT__DATA_BLOCK; } return TSDB_CODE_SUCCESS; } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + } + return code; } static int32_t doSetStreamOpOpen(SOperatorInfo* pOperator, char* id) { @@ -124,7 +137,10 @@ void resetTaskInfo(qTaskInfo_t tinfo) { clearStreamBlock(pTaskInfo->pRoot); } -static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t numOfBlocks, int32_t type, const char* id) { +static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t numOfBlocks, int32_t type, + const char* id) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pOperator->operatorType != QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) { if (pOperator->numOfDownstream == 0) { qError("failed to find stream scan operator to set the input data block, %s" PRIx64, id); @@ -147,24 +163,30 @@ static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t nu if (type == STREAM_INPUT__MERGED_SUBMIT) { for (int32_t i = 0; i < numOfBlocks; i++) { SPackedData* pReq = POINTER_SHIFT(input, i * sizeof(SPackedData)); - taosArrayPush(pInfo->pBlockLists, pReq); + void* tmp = taosArrayPush(pInfo->pBlockLists, pReq); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } pInfo->blockType = STREAM_INPUT__DATA_SUBMIT; } else if (type == STREAM_INPUT__DATA_SUBMIT) { - taosArrayPush(pInfo->pBlockLists, input); + void* tmp = taosArrayPush(pInfo->pBlockLists, input); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + pInfo->blockType = STREAM_INPUT__DATA_SUBMIT; } else if (type == STREAM_INPUT__DATA_BLOCK) { for (int32_t i = 0; i < numOfBlocks; ++i) { SSDataBlock* pDataBlock = &((SSDataBlock*)input)[i]; SPackedData tmp = {.pDataBlock = pDataBlock}; - taosArrayPush(pInfo->pBlockLists, &tmp); + void* tmpItem = taosArrayPush(pInfo->pBlockLists, &tmp); + QUERY_CHECK_NULL(tmpItem, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } pInfo->blockType = STREAM_INPUT__DATA_BLOCK; } else if (type == STREAM_INPUT__CHECKPOINT_TRIGGER) { SPackedData tmp = {.pDataBlock = input}; - taosArrayPush(pInfo->pBlockLists, &tmp); + void* tmpItem = taosArrayPush(pInfo->pBlockLists, &tmp); + QUERY_CHECK_NULL(tmpItem, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + pInfo->blockType = STREAM_INPUT__CHECKPOINT; } else { ASSERT(0); @@ -172,6 +194,12 @@ static int32_t doSetStreamBlock(SOperatorInfo* pOperator, void* input, size_t nu return TSDB_CODE_SUCCESS; } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } void doSetTaskId(SOperatorInfo* pOperator, SStorageAPI* pAPI) { @@ -330,16 +358,25 @@ qTaskInfo_t qCreateStreamExecTaskInfo(void* msg, SReadHandle* readers, int32_t v return NULL; } - qStreamInfoResetTimewindowFilter(pTaskInfo); + code = qStreamInfoResetTimewindowFilter(pTaskInfo); + if (code != TSDB_CODE_SUCCESS) { + nodesDestroyNode((SNode*)pPlan); + qDestroyTask(pTaskInfo); + terrno = code; + return NULL; + } return pTaskInfo; } -static SArray* filterUnqualifiedTables(const SStreamScanInfo* pScanInfo, const SArray* tableIdList, const char* idstr, - SStorageAPI* pAPI) { +static int32_t filterUnqualifiedTables(const SStreamScanInfo* pScanInfo, const SArray* tableIdList, const char* idstr, + SStorageAPI* pAPI, SArray** ppArrayRes) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SArray* qa = taosArrayInit(4, sizeof(tb_uid_t)); int32_t numOfUids = taosArrayGetSize(tableIdList); if (numOfUids == 0) { - return qa; + (*ppArrayRes) = qa; + goto _end; } STableScanInfo* pTableScanInfo = pScanInfo->pTableScanOp->info; @@ -395,11 +432,18 @@ static SArray* filterUnqualifiedTables(const SStreamScanInfo* pScanInfo, const S } // handle multiple partition - taosArrayPush(qa, id); + void* tmp = taosArrayPush(qa, id); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } pAPI->metaReaderFn.clearReader(&mr); - return qa; + (*ppArrayRes) = qa; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } int32_t qUpdateTableListForStreamScanner(qTaskInfo_t tinfo, const SArray* tableIdList, bool isAdd) { @@ -416,7 +460,12 @@ int32_t qUpdateTableListForStreamScanner(qTaskInfo_t tinfo, const SArray* tableI SStreamScanInfo* pScanInfo = pInfo->info; if (isAdd) { // add new table id - SArray* qa = filterUnqualifiedTables(pScanInfo, tableIdList, id, &pTaskInfo->storageAPI); + SArray* qa = NULL; + code = filterUnqualifiedTables(pScanInfo, tableIdList, id, &pTaskInfo->storageAPI, &qa); + if (code != TSDB_CODE_SUCCESS) { + taosArrayDestroy(qa); + return code; + } int32_t numOfQualifiedTables = taosArrayGetSize(qa); qDebug("%d qualified child tables added into stream scanner, %s", numOfQualifiedTables, id); code = pTaskInfo->storageAPI.tqReaderFn.tqReaderAddTables(pScanInfo->tqReader, qa); @@ -459,7 +508,13 @@ int32_t qUpdateTableListForStreamScanner(qTaskInfo_t tinfo, const SArray* tableI } } - tableListAddTableInfo(pTableListInfo, keyInfo.uid, keyInfo.groupId); + code = tableListAddTableInfo(pTableListInfo, keyInfo.uid, keyInfo.groupId); + if (code != TSDB_CODE_SUCCESS) { + taosMemoryFree(keyBuf); + taosArrayDestroy(qa); + taosWUnLockLatch(&pTaskInfo->lock); + return code; + } } taosWUnLockLatch(&pTaskInfo->lock); @@ -509,16 +564,14 @@ int32_t qGetQueryTableSchemaVersion(qTaskInfo_t tinfo, char* dbName, char* table return TSDB_CODE_SUCCESS; } -bool qIsDynamicExecTask(qTaskInfo_t tinfo) { - return ((SExecTaskInfo*)tinfo)->dynamicTask; -} +bool qIsDynamicExecTask(qTaskInfo_t tinfo) { return ((SExecTaskInfo*)tinfo)->dynamicTask; } void destroyOperatorParam(SOperatorParam* pParam) { if (NULL == pParam) { return; } - //TODO + // TODO } void qUpdateOperatorParam(qTaskInfo_t tinfo, void* pParam) { @@ -531,7 +584,7 @@ int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId, qTaskInfo_t* pTaskInfo, DataSinkHandle* handle, int8_t compressResult, char* sql, EOPTR_EXEC_MODEL model) { SExecTaskInfo** pTask = (SExecTaskInfo**)pTaskInfo; - taosThreadOnce(&initPoolOnce, initRefPool); + (void)taosThreadOnce(&initPoolOnce, initRefPool); qDebug("start to create task, TID:0x%" PRIx64 " QID:0x%" PRIx64 ", vgId:%d", taskId, pSubplan->id.queryId, vgId); @@ -543,7 +596,7 @@ int32_t qCreateExecTask(SReadHandle* readHandle, int32_t vgId, uint64_t taskId, if (handle) { SDataSinkMgtCfg cfg = {.maxDataBlockNum = 500, .maxDataBlockNumPerQuery = 50, .compress = compressResult}; - void* pSinkManager = NULL; + void* pSinkManager = NULL; code = dsDataSinkMgtInit(&cfg, &(*pTask)->storageAPI, &pSinkManager); if (code != TSDB_CODE_SUCCESS) { qError("failed to dsDataSinkMgtInit, code:%s, %s", tstrerror(code), (*pTask)->id.str); @@ -575,6 +628,8 @@ static void freeBlock(void* param) { } int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bool* hasMore, SLocalFetch* pLocal) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo; int64_t threadId = taosGetSelfPthreadId(); @@ -605,7 +660,7 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo int32_t ret = setjmp(pTaskInfo->env); if (ret != TSDB_CODE_SUCCESS) { pTaskInfo->code = ret; - cleanUpUdfs(); + (void)cleanUpUdfs(); qDebug("%s task abort due to error/cancel occurs, code:%s", GET_TASKID(pTaskInfo), tstrerror(pTaskInfo->code)); atomic_store_64(&pTaskInfo->owner, 0); @@ -627,10 +682,10 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo pRes = pTaskInfo->pRoot->fpSet.getNextFn(pTaskInfo->pRoot); } - if(pRes == NULL) { + if (pRes == NULL) { st = taosGetTimestampUs(); } - + int32_t rowsThreshold = pTaskInfo->pSubplan->rowsThreshold; if (!pTaskInfo->pSubplan->dynamicRowThreshold || 4096 <= pTaskInfo->pSubplan->rowsThreshold) { rowsThreshold = 4096; @@ -640,18 +695,21 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo SSDataBlock* p = NULL; if (blockIndex >= taosArrayGetSize(pTaskInfo->pResultBlockList)) { SSDataBlock* p1 = createOneDataBlock(pRes, true); - taosArrayPush(pTaskInfo->pResultBlockList, &p1); + void* tmp = taosArrayPush(pTaskInfo->pResultBlockList, &p1); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); p = p1; } else { p = *(SSDataBlock**)taosArrayGet(pTaskInfo->pResultBlockList, blockIndex); - copyDataBlock(p, pRes); + code = copyDataBlock(p, pRes); + QUERY_CHECK_CODE(code, lino, _end); } blockIndex += 1; current += p->info.rows; ASSERT(p->info.rows > 0 || p->info.type == STREAM_CHECKPOINT); - taosArrayPush(pResList, &p); + void* tmp = taosArrayPush(pResList, &p); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); if (current >= rowsThreshold) { break; @@ -671,7 +729,10 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo *useconds = pTaskInfo->cost.elapsedTime; } - cleanUpUdfs(); +_end: + + int32_t tmpRes = cleanUpUdfs(); + qTrace("%s at line %d res:%d", __func__, __LINE__, tmpRes); uint64_t total = pTaskInfo->pRoot->resultInfo.totalRows; qDebug("%s task suspended, %d rows in %d blocks returned, total:%" PRId64 " rows, in sinkNode:%d, elapsed:%.2f ms", @@ -730,7 +791,7 @@ int32_t qExecTask(qTaskInfo_t tinfo, SSDataBlock** pRes, uint64_t* useconds) { int32_t ret = setjmp(pTaskInfo->env); if (ret != TSDB_CODE_SUCCESS) { pTaskInfo->code = ret; - cleanUpUdfs(); + (void)cleanUpUdfs(); qDebug("%s task abort due to error/cancel occurs, code:%s", GET_TASKID(pTaskInfo), tstrerror(pTaskInfo->code)); atomic_store_64(&pTaskInfo->owner, 0); return pTaskInfo->code; @@ -748,7 +809,8 @@ int32_t qExecTask(qTaskInfo_t tinfo, SSDataBlock** pRes, uint64_t* useconds) { *useconds = pTaskInfo->cost.elapsedTime; } - cleanUpUdfs(); + int32_t tmpRes = cleanUpUdfs(); + qTrace("%s at line %d res:%d", __func__, __LINE__, tmpRes); int32_t current = (*pRes != NULL) ? (*pRes)->info.rows : 0; uint64_t total = pTaskInfo->pRoot->resultInfo.totalRows; @@ -762,9 +824,13 @@ int32_t qExecTask(qTaskInfo_t tinfo, SSDataBlock** pRes, uint64_t* useconds) { int32_t qAppendTaskStopInfo(SExecTaskInfo* pTaskInfo, SExchangeOpStopInfo* pInfo) { taosWLockLatch(&pTaskInfo->stopInfo.lock); - taosArrayPush(pTaskInfo->stopInfo.pStopInfo, pInfo); + void* tmp = taosArrayPush(pTaskInfo->stopInfo.pStopInfo, pInfo); taosWUnLockLatch(&pTaskInfo->stopInfo.lock); + if (tmp != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); + return TSDB_CODE_OUT_OF_MEMORY; + } return TSDB_CODE_SUCCESS; } @@ -798,8 +864,8 @@ void qStopTaskOperators(SExecTaskInfo* pTaskInfo) { SExchangeOpStopInfo* pStop = taosArrayGet(pTaskInfo->stopInfo.pStopInfo, i); SExchangeInfo* pExchangeInfo = taosAcquireRef(exchangeObjRefPool, pStop->refId); if (pExchangeInfo) { - tsem_post(&pExchangeInfo->ready); - taosReleaseRef(exchangeObjRefPool, pStop->refId); + (void)tsem_post(&pExchangeInfo->ready); + (void)taosReleaseRef(exchangeObjRefPool, pStop->refId); } } @@ -829,12 +895,12 @@ int32_t qKillTask(qTaskInfo_t tinfo, int32_t rspCode) { qDebug("%s sync killed execTask", GET_TASKID(pTaskInfo)); setTaskKilled(pTaskInfo, TSDB_CODE_TSC_QUERY_KILLED); - while(1) { + while (1) { taosWLockLatch(&pTaskInfo->lock); - if (qTaskIsExecuting(pTaskInfo)) { // let's wait for 100 ms and try again + if (qTaskIsExecuting(pTaskInfo)) { // let's wait for 100 ms and try again taosWUnLockLatch(&pTaskInfo->lock); taosMsleep(100); - } else { // not running now + } else { // not running now pTaskInfo->code = rspCode; taosWUnLockLatch(&pTaskInfo->lock); return TSDB_CODE_SUCCESS; @@ -907,7 +973,7 @@ int32_t qExtractStreamScanner(qTaskInfo_t tinfo, void** scanner) { } } -int32_t qStreamSourceScanParamForHistoryScanStep1(qTaskInfo_t tinfo, SVersionRange *pVerRange, STimeWindow* pWindow) { +int32_t qStreamSourceScanParamForHistoryScanStep1(qTaskInfo_t tinfo, SVersionRange* pVerRange, STimeWindow* pWindow) { SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo; ASSERT(pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM); @@ -917,14 +983,14 @@ int32_t qStreamSourceScanParamForHistoryScanStep1(qTaskInfo_t tinfo, SVersionRan pStreamInfo->fillHistoryWindow = *pWindow; pStreamInfo->recoverStep = STREAM_RECOVER_STEP__PREPARE1; - qDebug("%s step 1. set param for stream scanner for scan-history data, verRange:%" PRId64 " - %" PRId64 ", window:%" PRId64 - " - %" PRId64, + qDebug("%s step 1. set param for stream scanner for scan-history data, verRange:%" PRId64 " - %" PRId64 + ", window:%" PRId64 " - %" PRId64, GET_TASKID(pTaskInfo), pStreamInfo->fillHistoryVer.minVer, pStreamInfo->fillHistoryVer.maxVer, pWindow->skey, pWindow->ekey); return 0; } -int32_t qStreamSourceScanParamForHistoryScanStep2(qTaskInfo_t tinfo, SVersionRange *pVerRange, STimeWindow* pWindow) { +int32_t qStreamSourceScanParamForHistoryScanStep2(qTaskInfo_t tinfo, SVersionRange* pVerRange, STimeWindow* pWindow) { SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo; ASSERT(pTaskInfo->execModel == OPTR_EXEC_MODEL_STREAM); @@ -955,9 +1021,10 @@ int32_t qSetStreamOperatorOptionForScanHistory(qTaskInfo_t tinfo) { while (1) { int32_t type = pOperator->operatorType; if (type == QUERY_NODE_PHYSICAL_PLAN_STREAM_INTERVAL || type == QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_INTERVAL || - type == QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL || type == QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL) { + type == QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_INTERVAL || + type == QUERY_NODE_PHYSICAL_PLAN_STREAM_MID_INTERVAL) { SStreamIntervalOperatorInfo* pInfo = pOperator->info; - STimeWindowAggSupp* pSup = &pInfo->twAggSup; + STimeWindowAggSupp* pSup = &pInfo->twAggSup; ASSERT(pSup->calTrigger == STREAM_TRIGGER_AT_ONCE || pSup->calTrigger == STREAM_TRIGGER_WINDOW_CLOSE); ASSERT(pSup->calTriggerSaved == 0 && pSup->deleteMarkSaved == 0); @@ -974,7 +1041,7 @@ int32_t qSetStreamOperatorOptionForScanHistory(qTaskInfo_t tinfo) { type == QUERY_NODE_PHYSICAL_PLAN_STREAM_SEMI_SESSION || type == QUERY_NODE_PHYSICAL_PLAN_STREAM_FINAL_SESSION) { SStreamSessionAggOperatorInfo* pInfo = pOperator->info; - STimeWindowAggSupp* pSup = &pInfo->twAggSup; + STimeWindowAggSupp* pSup = &pInfo->twAggSup; ASSERT(pSup->calTrigger == STREAM_TRIGGER_AT_ONCE || pSup->calTrigger == STREAM_TRIGGER_WINDOW_CLOSE); ASSERT(pSup->calTriggerSaved == 0 && pSup->deleteMarkSaved == 0); @@ -989,7 +1056,7 @@ int32_t qSetStreamOperatorOptionForScanHistory(qTaskInfo_t tinfo) { pInfo->ignoreExpiredData = false; } else if (type == QUERY_NODE_PHYSICAL_PLAN_STREAM_STATE) { SStreamStateAggOperatorInfo* pInfo = pOperator->info; - STimeWindowAggSupp* pSup = &pInfo->twAggSup; + STimeWindowAggSupp* pSup = &pInfo->twAggSup; ASSERT(pSup->calTrigger == STREAM_TRIGGER_AT_ONCE || pSup->calTrigger == STREAM_TRIGGER_WINDOW_CLOSE); ASSERT(pSup->calTriggerSaved == 0 && pSup->deleteMarkSaved == 0); @@ -1004,7 +1071,7 @@ int32_t qSetStreamOperatorOptionForScanHistory(qTaskInfo_t tinfo) { pInfo->ignoreExpiredData = false; } else if (type == QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT) { SStreamEventAggOperatorInfo* pInfo = pOperator->info; - STimeWindowAggSupp* pSup = &pInfo->twAggSup; + STimeWindowAggSupp* pSup = &pInfo->twAggSup; ASSERT(pSup->calTrigger == STREAM_TRIGGER_AT_ONCE || pSup->calTrigger == STREAM_TRIGGER_WINDOW_CLOSE); ASSERT(pSup->calTriggerSaved == 0 && pSup->deleteMarkSaved == 0); @@ -1019,7 +1086,7 @@ int32_t qSetStreamOperatorOptionForScanHistory(qTaskInfo_t tinfo) { pInfo->ignoreExpiredData = false; } else if (type == QUERY_NODE_PHYSICAL_PLAN_STREAM_COUNT) { SStreamCountAggOperatorInfo* pInfo = pOperator->info; - STimeWindowAggSupp* pSup = &pInfo->twAggSup; + STimeWindowAggSupp* pSup = &pInfo->twAggSup; ASSERT(pSup->calTrigger == STREAM_TRIGGER_AT_ONCE || pSup->calTrigger == STREAM_TRIGGER_WINDOW_CLOSE); ASSERT(pSup->calTriggerSaved == 0 && pSup->deleteMarkSaved == 0); @@ -1137,20 +1204,21 @@ void qStreamSetSourceExcluded(qTaskInfo_t tinfo, int8_t sourceExcluded) { } int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subType) { + int32_t code = TSDB_CODE_SUCCESS; SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tinfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; SOperatorInfo* pOperator = pTaskInfo->pRoot; const char* id = GET_TASKID(pTaskInfo); - if(subType == TOPIC_SUB_TYPE__COLUMN && pOffset->type == TMQ_OFFSET__LOG){ + if (subType == TOPIC_SUB_TYPE__COLUMN && pOffset->type == TMQ_OFFSET__LOG) { pOperator = extractOperatorInTree(pOperator, QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN, id); if (pOperator == NULL) { return -1; } SStreamScanInfo* pInfo = pOperator->info; - SStoreTqReader* pReaderAPI = &pTaskInfo->storageAPI.tqReaderFn; - SWalReader* pWalReader = pReaderAPI->tqReaderGetWalReader(pInfo->tqReader); + SStoreTqReader* pReaderAPI = &pTaskInfo->storageAPI.tqReaderFn; + SWalReader* pWalReader = pReaderAPI->tqReaderGetWalReader(pInfo->tqReader); walReaderVerifyOffset(pWalReader, pOffset); } // if pOffset equal to current offset, means continue consume @@ -1229,9 +1297,9 @@ int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subT int64_t oldSkey = pScanBaseInfo->cond.twindows.skey; // let's start from the next ts that returned to consumer. - if(pTaskInfo->storageAPI.tqReaderFn.tqGetTablePrimaryKey(pInfo->tqReader)){ + if (pTaskInfo->storageAPI.tqReaderFn.tqGetTablePrimaryKey(pInfo->tqReader)) { pScanBaseInfo->cond.twindows.skey = ts; - }else{ + } else { pScanBaseInfo->cond.twindows.skey = ts + 1; } pScanInfo->scanTimes = 0; @@ -1249,8 +1317,17 @@ int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subT qDebug("tsdb reader created with offset(snapshot) uid:%" PRId64 " ts:%" PRId64 " table index:%d, total:%d, %s", uid, pScanBaseInfo->cond.twindows.skey, pScanInfo->currentTable, numOfTables, id); } else { - pTaskInfo->storageAPI.tsdReader.tsdSetQueryTableList(pScanBaseInfo->dataReader, &keyInfo, 1); - pTaskInfo->storageAPI.tsdReader.tsdReaderResetStatus(pScanBaseInfo->dataReader, &pScanBaseInfo->cond); + code = pTaskInfo->storageAPI.tsdReader.tsdSetQueryTableList(pScanBaseInfo->dataReader, &keyInfo, 1); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } + + code = pTaskInfo->storageAPI.tsdReader.tsdReaderResetStatus(pScanBaseInfo->dataReader, &pScanBaseInfo->cond); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } qDebug("tsdb reader offset seek snapshot to uid:%" PRId64 " ts %" PRId64 " table index:%d numOfTable:%d, %s", uid, pScanBaseInfo->cond.twindows.skey, pScanInfo->currentTable, numOfTables, id); } @@ -1289,20 +1366,32 @@ int32_t qStreamPrepareScan(qTaskInfo_t tinfo, STqOffsetVal* pOffset, int8_t subT } pAPI->snapshotFn.taosXSetTablePrimaryKey(sContext, mtInfo.uid); - initQueryTableDataCondForTmq(&pTaskInfo->streamInfo.tableCond, sContext, &mtInfo); - if(pAPI->snapshotFn.taosXGetTablePrimaryKey(sContext)){ + code = initQueryTableDataCondForTmq(&pTaskInfo->streamInfo.tableCond, sContext, &mtInfo); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } + if (pAPI->snapshotFn.taosXGetTablePrimaryKey(sContext)) { pTaskInfo->streamInfo.tableCond.twindows.skey = pOffset->ts; - }else{ + } else { pTaskInfo->streamInfo.tableCond.twindows.skey = pOffset->ts + 1; } - tableListAddTableInfo(pTableListInfo, mtInfo.uid, 0); + code = tableListAddTableInfo(pTableListInfo, mtInfo.uid, 0); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } STableKeyInfo* pList = tableListGetInfo(pTableListInfo, 0); int32_t size = tableListGetSize(pTableListInfo); - pTaskInfo->storageAPI.tsdReader.tsdReaderOpen(pInfo->vnode, &pTaskInfo->streamInfo.tableCond, pList, size, NULL, - (void**)&pInfo->dataReader, NULL, NULL); + code = pTaskInfo->storageAPI.tsdReader.tsdReaderOpen(pInfo->vnode, &pTaskInfo->streamInfo.tableCond, pList, size, + NULL, (void**)&pInfo->dataReader, NULL, NULL); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } cleanupQueryTableDataCond(&pTaskInfo->streamInfo.tableCond); strcpy(pTaskInfo->streamInfo.tbName, mtInfo.tbName); @@ -1353,12 +1442,14 @@ void qProcessRspMsg(void* parent, SRpcMsg* pMsg, SEpSet* pEpSet) { } } - pSendInfo->fp(pSendInfo->param, &buf, pMsg->code); + (void)pSendInfo->fp(pSendInfo->param, &buf, pMsg->code); rpcFreeCont(pMsg->pCont); destroySendMsgInfo(pSendInfo); } SArray* qGetQueriedTableListInfo(qTaskInfo_t tinfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = tinfo; SArray* plist = getTableListInfo(pTaskInfo); @@ -1366,30 +1457,50 @@ SArray* qGetQueriedTableListInfo(qTaskInfo_t tinfo) { STableListInfo* pTableListInfo = taosArrayGetP(plist, 0); SArray* pUidList = taosArrayInit(10, sizeof(uint64_t)); + QUERY_CHECK_NULL(pUidList, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); int32_t numOfTables = tableListGetSize(pTableListInfo); for (int32_t i = 0; i < numOfTables; ++i) { STableKeyInfo* pKeyInfo = tableListGetInfo(pTableListInfo, i); - taosArrayPush(pUidList, &pKeyInfo->uid); + void* tmp = taosArrayPush(pUidList, &pKeyInfo->uid); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } taosArrayDestroy(plist); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } return pUidList; } static void extractTableList(SArray* pList, const SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + if (pOperator->operatorType == QUERY_NODE_PHYSICAL_PLAN_STREAM_SCAN) { SStreamScanInfo* pScanInfo = pOperator->info; STableScanInfo* pTableScanInfo = pScanInfo->pTableScanOp->info; - taosArrayPush(pList, &pTableScanInfo->base.pTableListInfo); + void* tmp = taosArrayPush(pList, &pTableScanInfo->base.pTableListInfo); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } else if (pOperator->operatorType == QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN) { STableScanInfo* pScanInfo = pOperator->info; - taosArrayPush(pList, &pScanInfo->base.pTableListInfo); + void* tmp = taosArrayPush(pList, &pScanInfo->base.pTableListInfo); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } else { if (pOperator->pDownstream != NULL && pOperator->pDownstream[0] != NULL) { extractTableList(pList, pOperator->pDownstream[0]); } } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } SArray* getTableListInfo(const SExecTaskInfo* pTaskInfo) { @@ -1400,13 +1511,13 @@ SArray* getTableListInfo(const SExecTaskInfo* pTaskInfo) { } int32_t qStreamOperatorReleaseState(qTaskInfo_t tInfo) { - SExecTaskInfo* pTaskInfo = (SExecTaskInfo*) tInfo; + SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tInfo; pTaskInfo->pRoot->fpSet.releaseStreamStateFn(pTaskInfo->pRoot); return 0; } int32_t qStreamOperatorReloadState(qTaskInfo_t tInfo) { - SExecTaskInfo* pTaskInfo = (SExecTaskInfo*) tInfo; + SExecTaskInfo* pTaskInfo = (SExecTaskInfo*)tInfo; pTaskInfo->pRoot->fpSet.reloadStreamStateFn(pTaskInfo->pRoot); return 0; } diff --git a/source/libs/executor/src/executorInt.c b/source/libs/executor/src/executorInt.c index 0476a7981c..dd6067da34 100644 --- a/source/libs/executor/src/executorInt.c +++ b/source/libs/executor/src/executorInt.c @@ -72,14 +72,14 @@ static UNUSED_FUNC void* u_realloc(void* p, size_t __size) { #define realloc u_realloc #endif -static void setBlockSMAInfo(SqlFunctionCtx* pCtx, SExprInfo* pExpr, SSDataBlock* pBlock); +static int32_t setBlockSMAInfo(SqlFunctionCtx* pCtx, SExprInfo* pExpr, SSDataBlock* pBlock); static void initCtxOutputBuffer(SqlFunctionCtx* pCtx, int32_t size); static void doApplyScalarCalculation(SOperatorInfo* pOperator, SSDataBlock* pBlock, int32_t order, int32_t scanFlag); static int32_t doSetInputDataBlock(SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t order, int32_t scanFlag, bool createDummyCol); -static int32_t doCopyToSDataBlock(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf, +static void doCopyToSDataBlock(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf, SGroupResInfo* pGroupResInfo, int32_t threshold, bool ignoreGroup); SResultRow* getNewResultRow(SDiskbasedBuf* pResultBuf, int32_t* currentPageId, int32_t interBufSize) { @@ -192,8 +192,12 @@ SResultRow* doSetResultOutBufByKey(SDiskbasedBuf* pResultBuf, SResultRowInfo* pR // add a new result set for a new group SResultRowPosition pos = {.pageId = pResult->pageId, .offset = pResult->offset}; - tSimpleHashPut(pSup->pResultRowHashTable, pSup->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes), &pos, - sizeof(SResultRowPosition)); + int32_t code = tSimpleHashPut(pSup->pResultRowHashTable, pSup->keyBuf, GET_RES_WINDOW_KEY_LEN(bytes), &pos, + sizeof(SResultRowPosition)); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } // 2. set the new time window to be the new active time window @@ -209,11 +213,14 @@ SResultRow* doSetResultOutBufByKey(SDiskbasedBuf* pResultBuf, SResultRowInfo* pR } // query_range_start, query_range_end, window_duration, window_start, window_end -void initExecTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pQueryWindow) { +int32_t initExecTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pQueryWindow) { pColData->info.type = TSDB_DATA_TYPE_TIMESTAMP; pColData->info.bytes = sizeof(int64_t); - colInfoDataEnsureCapacity(pColData, 5, false); + int32_t code = colInfoDataEnsureCapacity(pColData, 5, false); + if (code != TSDB_CODE_SUCCESS) { + return code; + } colDataSetInt64(pColData, 0, &pQueryWindow->skey); colDataSetInt64(pColData, 1, &pQueryWindow->ekey); @@ -221,35 +228,46 @@ void initExecTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pQueryWindow colDataSetInt64(pColData, 2, &interval); // this value may be variable in case of 'n' and 'y'. colDataSetInt64(pColData, 3, &pQueryWindow->skey); colDataSetInt64(pColData, 4, &pQueryWindow->ekey); + return TSDB_CODE_SUCCESS; } -static void doSetInputDataBlockInfo(SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t order, int32_t scanFlag) { +static int32_t doSetInputDataBlockInfo(SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t order, int32_t scanFlag) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SqlFunctionCtx* pCtx = pExprSup->pCtx; for (int32_t i = 0; i < pExprSup->numOfExprs; ++i) { pCtx[i].order = order; pCtx[i].input.numOfRows = pBlock->info.rows; - setBlockSMAInfo(&pCtx[i], &pExprSup->pExprInfo[i], pBlock); + code = setBlockSMAInfo(&pCtx[i], &pExprSup->pExprInfo[i], pBlock); + QUERY_CHECK_CODE(code, lino, _end); pCtx[i].pSrcBlock = pBlock; pCtx[i].scanFlag = scanFlag; } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } -void setInputDataBlock(SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t order, int32_t scanFlag, bool createDummyCol) { +int32_t setInputDataBlock(SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t order, int32_t scanFlag, + bool createDummyCol) { if (pBlock->pBlockAgg != NULL) { - doSetInputDataBlockInfo(pExprSup, pBlock, order, scanFlag); + return doSetInputDataBlockInfo(pExprSup, pBlock, order, scanFlag); } else { - doSetInputDataBlock(pExprSup, pBlock, order, scanFlag, createDummyCol); + return doSetInputDataBlock(pExprSup, pBlock, order, scanFlag, createDummyCol); } } static int32_t doCreateConstantValColumnInfo(SInputColumnInfoData* pInput, SFunctParam* pFuncParam, int32_t paramIndex, int32_t numOfRows) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SColumnInfoData* pColInfo = NULL; if (pInput->pData[paramIndex] == NULL) { pColInfo = taosMemoryCalloc(1, sizeof(SColumnInfoData)); - if (pColInfo == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; - } + QUERY_CHECK_NULL(pColInfo, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); // Set the correct column info (data type and bytes) pColInfo->info.type = pFuncParam->param.nType; @@ -260,7 +278,8 @@ static int32_t doCreateConstantValColumnInfo(SInputColumnInfoData* pInput, SFunc pColInfo = pInput->pData[paramIndex]; } - colInfoDataEnsureCapacity(pColInfo, numOfRows, false); + code = colInfoDataEnsureCapacity(pColInfo, numOfRows, false); + QUERY_CHECK_CODE(code, lino, _end); int8_t type = pFuncParam->param.nType; if (type == TSDB_DATA_TYPE_BIGINT || type == TSDB_DATA_TYPE_UBIGINT) { @@ -277,12 +296,17 @@ static int32_t doCreateConstantValColumnInfo(SInputColumnInfoData* pInput, SFunc char* tmp = taosMemoryMalloc(pFuncParam->param.nLen + VARSTR_HEADER_SIZE); STR_WITH_SIZE_TO_VARSTR(tmp, pFuncParam->param.pz, pFuncParam->param.nLen); for (int32_t i = 0; i < numOfRows; ++i) { - colDataSetVal(pColInfo, i, tmp, false); + code = colDataSetVal(pColInfo, i, tmp, false); + QUERY_CHECK_CODE(code, lino, _end); } taosMemoryFree(tmp); } - return TSDB_CODE_SUCCESS; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static int32_t doSetInputDataBlock(SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t order, int32_t scanFlag, @@ -302,7 +326,7 @@ static int32_t doSetInputDataBlock(SExprSupp* pExprSup, SSDataBlock* pBlock, int pInput->colDataSMAIsSet = false; SExprInfo* pOneExpr = &pExprSup->pExprInfo[i]; - bool hasPk = pOneExpr->pExpr->nodeType == QUERY_NODE_FUNCTION && pOneExpr->pExpr->_function.pFunctNode->hasPk; + bool hasPk = pOneExpr->pExpr->nodeType == QUERY_NODE_FUNCTION && pOneExpr->pExpr->_function.pFunctNode->hasPk; pCtx[i].hasPrimaryKey = hasPk; int16_t tsParamIdx = (!hasPk) ? pOneExpr->base.numOfParams - 1 : pOneExpr->base.numOfParams - 2; @@ -320,13 +344,13 @@ static int32_t doSetInputDataBlock(SExprSupp* pExprSup, SSDataBlock* pBlock, int // NOTE: the last parameter is the primary timestamp column // todo: refactor this - + if (fmIsImplicitTsFunc(pCtx[i].functionId) && (j == tsParamIdx)) { pInput->pPTS = pInput->pData[j]; // in case of merge function, this is not always the ts column data. } if (hasPk && (j == pkParamIdx)) { pInput->pPrimaryKey = pInput->pData[j]; - } + } ASSERT(pInput->pData[j] != NULL); } else if (pFuncParam->type == FUNC_PARAM_TYPE_VALUE) { // todo avoid case: top(k, 12), 12 is the value parameter. @@ -419,7 +443,9 @@ static int32_t doCreateConstantValColumnSMAInfo(SInputColumnInfoData* pInput, SF return TSDB_CODE_SUCCESS; } -void setBlockSMAInfo(SqlFunctionCtx* pCtx, SExprInfo* pExprInfo, SSDataBlock* pBlock) { +int32_t setBlockSMAInfo(SqlFunctionCtx* pCtx, SExprInfo* pExprInfo, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; int32_t numOfRows = pBlock->info.rows; SInputColumnInfoData* pInput = &pCtx->input; @@ -443,12 +469,19 @@ void setBlockSMAInfo(SqlFunctionCtx* pCtx, SExprInfo* pExprInfo, SSDataBlock* pB // the data in the corresponding SColumnInfoData will not be used. pInput->pData[j] = taosArrayGet(pBlock->pDataBlock, slotId); } else if (pFuncParam->type == FUNC_PARAM_TYPE_VALUE) { - doCreateConstantValColumnSMAInfo(pInput, pFuncParam, pFuncParam->param.nType, j, pBlock->info.rows); + code = doCreateConstantValColumnSMAInfo(pInput, pFuncParam, pFuncParam->param.nType, j, pBlock->info.rows); + QUERY_CHECK_CODE(code, lino, _end); } } } else { pInput->colDataSMAIsSet = false; } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } ///////////////////////////////////////////////////////////////////////////////////////////// @@ -468,7 +501,8 @@ STimeWindow getAlignQueryTimeWindow(const SInterval* pInterval, int64_t key) { return win; } -int32_t setResultRowInitCtx(SResultRow* pResult, SqlFunctionCtx* pCtx, int32_t numOfOutput, int32_t* rowEntryInfoOffset) { +int32_t setResultRowInitCtx(SResultRow* pResult, SqlFunctionCtx* pCtx, int32_t numOfOutput, + int32_t* rowEntryInfoOffset) { bool init = false; for (int32_t i = 0; i < numOfOutput; ++i) { pCtx[i].resultInfo = getResultEntryInfo(pResult, i, rowEntryInfoOffset); @@ -488,7 +522,7 @@ int32_t setResultRowInitCtx(SResultRow* pResult, SqlFunctionCtx* pCtx, int32_t n if (!pResInfo->initialized) { if (pCtx[i].functionId != -1) { bool ini = pCtx[i].fpSet.init(&pCtx[i], pResInfo); - if (!ini && fmIsUserDefinedFunc(pCtx[i].functionId)){ + if (!ini && fmIsUserDefinedFunc(pCtx[i].functionId)) { pResInfo->initialized = false; return TSDB_CODE_UDF_FUNC_EXEC_FAILURE; } @@ -517,6 +551,8 @@ void clearResultRowInitFlag(SqlFunctionCtx* pCtx, int32_t numOfOutput) { } int32_t doFilter(SSDataBlock* pBlock, SFilterInfo* pFilterInfo, SColMatchInfo* pColMatchInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pFilterInfo == NULL || pBlock->info.rows == 0) { return TSDB_CODE_SUCCESS; } @@ -524,16 +560,12 @@ int32_t doFilter(SSDataBlock* pBlock, SFilterInfo* pFilterInfo, SColMatchInfo* p SFilterColumnParam param1 = {.numOfCols = taosArrayGetSize(pBlock->pDataBlock), .pDataBlock = pBlock->pDataBlock}; SColumnInfoData* p = NULL; - int32_t code = filterSetDataFromSlotId(pFilterInfo, ¶m1); - if (code != TSDB_CODE_SUCCESS) { - goto _err; - } + code = filterSetDataFromSlotId(pFilterInfo, ¶m1); + QUERY_CHECK_CODE(code, lino, _err); int32_t status = 0; code = filterExecute(pFilterInfo, pBlock, &p, NULL, param1.numOfCols, &status); - if (code != TSDB_CODE_SUCCESS) { - goto _err; - } + QUERY_CHECK_CODE(code, lino, _err); extractQualifiedTupleByFilterResult(pBlock, p, status); @@ -544,7 +576,8 @@ int32_t doFilter(SSDataBlock* pBlock, SFilterInfo* pFilterInfo, SColMatchInfo* p if (pInfo->colId == PRIMARYKEY_TIMESTAMP_COL_ID) { SColumnInfoData* pColData = taosArrayGet(pBlock->pDataBlock, pInfo->dstSlotId); if (pColData->info.type == TSDB_DATA_TYPE_TIMESTAMP) { - blockDataUpdateTsWindow(pBlock, pInfo->dstSlotId); + code = blockDataUpdateTsWindow(pBlock, pInfo->dstSlotId); + QUERY_CHECK_CODE(code, lino, _err); break; } } @@ -598,6 +631,8 @@ void doUpdateNumOfRows(SqlFunctionCtx* pCtx, SResultRow* pRow, int32_t numOfExpr void copyResultrowToDataBlock(SExprInfo* pExprInfo, int32_t numOfExprs, SResultRow* pRow, SqlFunctionCtx* pCtx, SSDataBlock* pBlock, const int32_t* rowEntryOffset, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; for (int32_t j = 0; j < numOfExprs; ++j) { int32_t slotId = pExprInfo[j].base.resSchema.slotId; @@ -611,8 +646,10 @@ void copyResultrowToDataBlock(SExprInfo* pExprInfo, int32_t numOfExprs, SResultR } } - blockDataEnsureCapacity(pBlock, pBlock->info.rows + pCtx[j].resultInfo->numOfRes); - int32_t code = pCtx[j].fpSet.finalize(&pCtx[j], pBlock); + code = blockDataEnsureCapacity(pBlock, pBlock->info.rows + pCtx[j].resultInfo->numOfRes); + QUERY_CHECK_CODE(code, lino, _end); + + code = pCtx[j].fpSet.finalize(&pCtx[j], pBlock); if (TAOS_FAILED(code)) { qError("%s build result data block error, code %s", GET_TASKID(pTaskInfo), tstrerror(code)); T_LONG_JMP(pTaskInfo->env, code); @@ -625,10 +662,17 @@ void copyResultrowToDataBlock(SExprInfo* pExprInfo, int32_t numOfExprs, SResultR SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, slotId); char* in = GET_ROWCELL_INTERBUF(pCtx[j].resultInfo); for (int32_t k = 0; k < pRow->numOfRows; ++k) { - colDataSetVal(pColInfoData, pBlock->info.rows + k, in, pCtx[j].resultInfo->isNullRes); + code = colDataSetVal(pColInfoData, pBlock->info.rows + k, in, pCtx[j].resultInfo->isNullRes); + QUERY_CHECK_CODE(code, lino, _end); } } } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } // todo refactor. SResultRow has direct pointer in miainfo @@ -671,9 +715,10 @@ int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPos return 0; } -int32_t doCopyToSDataBlockByHash(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf, - SGroupResInfo* pGroupResInfo, SSHashObj* pHashmap, int32_t threshold, - bool ignoreGroup) { +void doCopyToSDataBlockByHash(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf, + SGroupResInfo* pGroupResInfo, SSHashObj* pHashmap, int32_t threshold, bool ignoreGroup) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExprInfo* pExprInfo = pSup->pExprInfo; int32_t numOfExprs = pSup->numOfExprs; int32_t* rowEntryOffset = pSup->rowEntryInfoOffset; @@ -724,7 +769,8 @@ int32_t doCopyToSDataBlockByHash(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, if (pBlock->info.rows + pRow->numOfRows > pBlock->info.capacity) { uint32_t newSize = pBlock->info.rows + pRow->numOfRows + ((numOfRows - iter) > 1 ? 1 : 0); - blockDataEnsureCapacity(pBlock, newSize); + code = blockDataEnsureCapacity(pBlock, newSize); + QUERY_CHECK_CODE(code, lino, _end); qDebug("datablock capacity not sufficient, expand to required:%d, current capacity:%d, %s", newSize, pBlock->info.capacity, GET_TASKID(pTaskInfo)); // todo set the pOperator->resultInfo size @@ -744,14 +790,22 @@ int32_t doCopyToSDataBlockByHash(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, } qDebug("%s result generated, rows:%" PRId64 ", groupId:%" PRIu64, GET_TASKID(pTaskInfo), pBlock->info.rows, - pBlock->info.id.groupId); + pBlock->info.id.groupId); pBlock->info.dataLoad = 1; - blockDataUpdateTsWindow(pBlock, 0); - return 0; + code = blockDataUpdateTsWindow(pBlock, 0); + QUERY_CHECK_CODE(code, lino, _end); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } -int32_t doCopyToSDataBlock(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf, - SGroupResInfo* pGroupResInfo, int32_t threshold, bool ignoreGroup) { +void doCopyToSDataBlock(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf, + SGroupResInfo* pGroupResInfo, int32_t threshold, bool ignoreGroup) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExprInfo* pExprInfo = pSup->pExprInfo; int32_t numOfExprs = pSup->numOfExprs; int32_t* rowEntryOffset = pSup->rowEntryInfoOffset; @@ -792,7 +846,8 @@ int32_t doCopyToSDataBlock(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprS if (pBlock->info.rows + pRow->numOfRows > pBlock->info.capacity) { uint32_t newSize = pBlock->info.rows + pRow->numOfRows + ((numOfRows - i) > 1 ? 1 : 0); - blockDataEnsureCapacity(pBlock, newSize); + code = blockDataEnsureCapacity(pBlock, newSize); + QUERY_CHECK_CODE(code, lino, _end); qDebug("datablock capacity not sufficient, expand to required:%d, current capacity:%d, %s", newSize, pBlock->info.capacity, GET_TASKID(pTaskInfo)); // todo set the pOperator->resultInfo size @@ -811,8 +866,14 @@ int32_t doCopyToSDataBlock(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprS qDebug("%s result generated, rows:%" PRId64 ", groupId:%" PRIu64, GET_TASKID(pTaskInfo), pBlock->info.rows, pBlock->info.id.groupId); pBlock->info.dataLoad = 1; - blockDataUpdateTsWindow(pBlock, 0); - return 0; + code = blockDataUpdateTsWindow(pBlock, 0); + QUERY_CHECK_CODE(code, lino, _end); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } void doBuildResultDatablock(SOperatorInfo* pOperator, SOptrBasicInfo* pbInfo, SGroupResInfo* pGroupResInfo, @@ -909,9 +970,9 @@ void initBasicInfo(SOptrBasicInfo* pInfo, SSDataBlock* pBlock) { initResultRowInfo(&pInfo->resultRowInfo); } -static void* destroySqlFunctionCtx(SqlFunctionCtx* pCtx, SExprInfo* pExpr, int32_t numOfOutput) { +static void destroySqlFunctionCtx(SqlFunctionCtx* pCtx, SExprInfo* pExpr, int32_t numOfOutput) { if (pCtx == NULL) { - return NULL; + return; } for (int32_t i = 0; i < numOfOutput; ++i) { @@ -939,7 +1000,7 @@ static void* destroySqlFunctionCtx(SqlFunctionCtx* pCtx, SExprInfo* pExpr, int32 } taosMemoryFreeClear(pCtx); - return NULL; + return; } int32_t initExprSupp(SExprSupp* pSup, SExprInfo* pExprInfo, int32_t numOfExpr, SFunctionStateStore* pStore) { @@ -970,7 +1031,10 @@ void cleanupExprSupp(SExprSupp* pSupp) { taosMemoryFree(pSupp->rowEntryInfoOffset); } -void cleanupBasicInfo(SOptrBasicInfo* pInfo) { blockDataDestroy(pInfo->pRes); pInfo->pRes = NULL;} +void cleanupBasicInfo(SOptrBasicInfo* pInfo) { + blockDataDestroy(pInfo->pRes); + pInfo->pRes = NULL; +} bool groupbyTbname(SNodeList* pGroupList) { bool bytbname = false; @@ -1019,7 +1083,12 @@ int32_t createDataSinkParam(SDataSinkNode* pNode, void** pParam, SExecTaskInfo* for (int32_t i = 0; i < numOfTables; ++i) { STableKeyInfo* pTable = tableListGetInfo(pTableListInfo, i); - taosArrayPush(pDeleterParam->pUidList, &pTable->uid); + void* tmp = taosArrayPush(pDeleterParam->pUidList, &pTable->uid); + if (!tmp) { + taosArrayDestroy(pDeleterParam->pUidList); + taosMemoryFree(pDeleterParam); + return TSDB_CODE_OUT_OF_MEMORY; + } } *pParam = pDeleterParam; @@ -1056,7 +1125,7 @@ void freeOperatorParamImpl(SOperatorParam* pParam, SOperatorParamType type) { taosArrayDestroy(pParam->pChildren); taosMemoryFree(pParam->value); - + taosMemoryFree(pParam); } @@ -1077,25 +1146,15 @@ void freeExchangeGetOperatorParam(SOperatorParam* pParam) { freeOperatorParamImpl(pParam, OP_GET_PARAM); } -void freeExchangeNotifyOperatorParam(SOperatorParam* pParam) { - freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM); -} +void freeExchangeNotifyOperatorParam(SOperatorParam* pParam) { freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM); } -void freeGroupCacheGetOperatorParam(SOperatorParam* pParam) { - freeOperatorParamImpl(pParam, OP_GET_PARAM); -} +void freeGroupCacheGetOperatorParam(SOperatorParam* pParam) { freeOperatorParamImpl(pParam, OP_GET_PARAM); } -void freeGroupCacheNotifyOperatorParam(SOperatorParam* pParam) { - freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM); -} +void freeGroupCacheNotifyOperatorParam(SOperatorParam* pParam) { freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM); } -void freeMergeJoinGetOperatorParam(SOperatorParam* pParam) { - freeOperatorParamImpl(pParam, OP_GET_PARAM); -} +void freeMergeJoinGetOperatorParam(SOperatorParam* pParam) { freeOperatorParamImpl(pParam, OP_GET_PARAM); } -void freeMergeJoinNotifyOperatorParam(SOperatorParam* pParam) { - freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM); -} +void freeMergeJoinNotifyOperatorParam(SOperatorParam* pParam) { freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM); } void freeTableScanGetOperatorParam(SOperatorParam* pParam) { STableScanOperatorParam* pTableScanParam = (STableScanOperatorParam*)pParam->value; @@ -1103,16 +1162,13 @@ void freeTableScanGetOperatorParam(SOperatorParam* pParam) { freeOperatorParamImpl(pParam, OP_GET_PARAM); } -void freeTableScanNotifyOperatorParam(SOperatorParam* pParam) { - freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM); -} - +void freeTableScanNotifyOperatorParam(SOperatorParam* pParam) { freeOperatorParamImpl(pParam, OP_NOTIFY_PARAM); } void freeOperatorParam(SOperatorParam* pParam, SOperatorParamType type) { if (NULL == pParam) { return; } - + switch (pParam->opType) { case QUERY_NODE_PHYSICAL_PLAN_EXCHANGE: type == OP_GET_PARAM ? freeExchangeGetOperatorParam(pParam) : freeExchangeNotifyOperatorParam(pParam); @@ -1133,7 +1189,7 @@ void freeOperatorParam(SOperatorParam* pParam, SOperatorParamType type) { } void freeResetOperatorParams(struct SOperatorInfo* pOperator, SOperatorParamType type, bool allFree) { - SOperatorParam** ppParam = NULL; + SOperatorParam** ppParam = NULL; SOperatorParam*** pppDownstramParam = NULL; switch (type) { case OP_GET_PARAM: @@ -1166,22 +1222,22 @@ void freeResetOperatorParams(struct SOperatorInfo* pOperator, SOperatorParamType } } - -FORCE_INLINE SSDataBlock* getNextBlockFromDownstreamImpl(struct SOperatorInfo* pOperator, int32_t idx, bool clearParam) { +FORCE_INLINE SSDataBlock* getNextBlockFromDownstreamImpl(struct SOperatorInfo* pOperator, int32_t idx, + bool clearParam) { if (pOperator->pDownstreamGetParams && pOperator->pDownstreamGetParams[idx]) { qDebug("DynOp: op %s start to get block from downstream %s", pOperator->name, pOperator->pDownstream[idx]->name); - SSDataBlock* pBlock = pOperator->pDownstream[idx]->fpSet.getNextExtFn(pOperator->pDownstream[idx], pOperator->pDownstreamGetParams[idx]); + SSDataBlock* pBlock = pOperator->pDownstream[idx]->fpSet.getNextExtFn(pOperator->pDownstream[idx], + pOperator->pDownstreamGetParams[idx]); if (clearParam) { freeOperatorParam(pOperator->pDownstreamGetParams[idx], OP_GET_PARAM); pOperator->pDownstreamGetParams[idx] = NULL; } return pBlock; } - + return pOperator->pDownstream[idx]->fpSet.getNextFn(pOperator->pDownstream[idx]); } - bool compareVal(const char* v, const SStateKeys* pKey) { if (IS_VAR_DATA_TYPE(pKey->type)) { if (varDataLen(v) != varDataLen(pKey->pData)) { diff --git a/source/libs/executor/src/filloperator.c b/source/libs/executor/src/filloperator.c index ad1c6d67d4..cf31b5b7ad 100644 --- a/source/libs/executor/src/filloperator.c +++ b/source/libs/executor/src/filloperator.c @@ -26,11 +26,11 @@ #include "ttime.h" #include "function.h" +#include "operator.h" #include "querynodes.h" +#include "querytask.h" #include "tdatablock.h" #include "tfill.h" -#include "operator.h" -#include "querytask.h" typedef struct STimeRange { TSKEY skey; @@ -65,9 +65,9 @@ static void doHandleRemainBlockForNewGroupImpl(SOperatorInfo* pOperator, SFillOp pInfo->totalInputRows = pInfo->existNewGroupBlock->info.rows; SSDataBlock* pResBlock = pInfo->pFinalRes; -// int32_t order = TSDB_ORDER_ASC; + // int32_t order = TSDB_ORDER_ASC; int32_t scanFlag = MAIN_SCAN; -// getTableScanInfo(pOperator, &order, &scanFlag, false); + // getTableScanInfo(pOperator, &order, &scanFlag, false); taosResetFillInfo(pInfo->pFillInfo, getFillInfoStart(pInfo->pFillInfo)); blockDataCleanup(pInfo->pRes); @@ -75,7 +75,8 @@ static void doHandleRemainBlockForNewGroupImpl(SOperatorInfo* pOperator, SFillOp revisedFillStartKey(pInfo, pInfo->existNewGroupBlock, order); - int64_t ts = (order == TSDB_ORDER_ASC)? pInfo->existNewGroupBlock->info.window.ekey:pInfo->existNewGroupBlock->info.window.skey; + int64_t ts = (order == TSDB_ORDER_ASC) ? pInfo->existNewGroupBlock->info.window.ekey + : pInfo->existNewGroupBlock->info.window.skey; taosFillSetStartInfo(pInfo->pFillInfo, pInfo->pRes->info.rows, ts); taosFillSetInputDataBlock(pInfo->pFillInfo, pInfo->pRes); @@ -84,7 +85,12 @@ static void doHandleRemainBlockForNewGroupImpl(SOperatorInfo* pOperator, SFillOp } int32_t numOfResultRows = pResultInfo->capacity - pResBlock->info.rows; - taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows); + int32_t code = taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + T_LONG_JMP(pTaskInfo->env, code); + } pInfo->curGroupId = pInfo->existNewGroupBlock->info.id.groupId; pInfo->existNewGroupBlock = NULL; @@ -92,9 +98,14 @@ static void doHandleRemainBlockForNewGroupImpl(SOperatorInfo* pOperator, SFillOp static void doHandleRemainBlockFromNewGroup(SOperatorInfo* pOperator, SFillOperatorInfo* pInfo, SResultInfo* pResultInfo, int32_t order) { + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; if (taosFillHasMoreResults(pInfo->pFillInfo)) { int32_t numOfResultRows = pResultInfo->capacity - pInfo->pFinalRes->info.rows; - taosFillResultDataBlock(pInfo->pFillInfo, pInfo->pFinalRes, numOfResultRows); + int32_t code = taosFillResultDataBlock(pInfo->pFillInfo, pInfo->pFinalRes, numOfResultRows); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } pInfo->pRes->info.id.groupId = pInfo->curGroupId; return; } @@ -106,18 +117,32 @@ static void doHandleRemainBlockFromNewGroup(SOperatorInfo* pOperator, SFillOpera } void doApplyScalarCalculation(SOperatorInfo* pOperator, SSDataBlock* pBlock, int32_t order, int32_t scanFlag) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SFillOperatorInfo* pInfo = pOperator->info; SExprSupp* pSup = &pOperator->exprSupp; - setInputDataBlock(pSup, pBlock, order, scanFlag, false); - projectApplyFunctions(pSup->pExprInfo, pInfo->pRes, pBlock, pSup->pCtx, pSup->numOfExprs, NULL); + code = setInputDataBlock(pSup, pBlock, order, scanFlag, false); + QUERY_CHECK_CODE(code, lino, _end); + code = projectApplyFunctions(pSup->pExprInfo, pInfo->pRes, pBlock, pSup->pCtx, pSup->numOfExprs, NULL); + QUERY_CHECK_CODE(code, lino, _end); // reset the row value before applying the no-fill functions to the input data block, which is "pBlock" in this case. pInfo->pRes->info.rows = 0; SExprSupp* pNoFillSupp = &pInfo->noFillExprSupp; - setInputDataBlock(pNoFillSupp, pBlock, order, scanFlag, false); + code = setInputDataBlock(pNoFillSupp, pBlock, order, scanFlag, false); + QUERY_CHECK_CODE(code, lino, _end); - projectApplyFunctions(pNoFillSupp->pExprInfo, pInfo->pRes, pBlock, pNoFillSupp->pCtx, pNoFillSupp->numOfExprs, NULL); + code = projectApplyFunctions(pNoFillSupp->pExprInfo, pInfo->pRes, pBlock, pNoFillSupp->pCtx, pNoFillSupp->numOfExprs, + NULL); + QUERY_CHECK_CODE(code, lino, _end); pInfo->pRes->info.id.groupId = pBlock->info.id.groupId; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } static void fillResetPrevForNewGroup(SFillInfo* pFillInfo) { @@ -134,13 +159,13 @@ static void revisedFillStartKey(SFillOperatorInfo* pInfo, SSDataBlock* pBlock, i if (order == TSDB_ORDER_ASC) { int64_t skey = pBlock->info.window.skey; if (skey < pInfo->pFillInfo->start) { // the start key may be smaller than the - ASSERT( taosFillNotStarted(pInfo->pFillInfo)); + ASSERT(taosFillNotStarted(pInfo->pFillInfo)); taosFillUpdateStartTimestampInfo(pInfo->pFillInfo, skey); } else if (pInfo->pFillInfo->start < skey) { - int64_t t = skey; + int64_t t = skey; SInterval* pInterval = &pInfo->pFillInfo->interval; - while(1) { + while (1) { int64_t prev = taosTimeAdd(t, -pInterval->sliding, pInterval->slidingUnit, pInterval->precision); if (prev <= pInfo->pFillInfo->start) { t = prev; @@ -155,13 +180,13 @@ static void revisedFillStartKey(SFillOperatorInfo* pInfo, SSDataBlock* pBlock, i } else { int64_t ekey = pBlock->info.window.ekey; if (ekey > pInfo->pFillInfo->start) { - ASSERT( taosFillNotStarted(pInfo->pFillInfo)); + ASSERT(taosFillNotStarted(pInfo->pFillInfo)); taosFillUpdateStartTimestampInfo(pInfo->pFillInfo, ekey); } else if (ekey < pInfo->pFillInfo->start) { - int64_t t = ekey; + int64_t t = ekey; SInterval* pInterval = &pInfo->pFillInfo->interval; int64_t prev = t; - while(1) { + while (1) { int64_t next = taosTimeAdd(t, pInterval->sliding, pInterval->slidingUnit, pInterval->precision); if (next >= pInfo->pFillInfo->start) { prev = t; @@ -180,6 +205,8 @@ static void revisedFillStartKey(SFillOperatorInfo* pInfo, SSDataBlock* pBlock, i } static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SFillOperatorInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; @@ -219,11 +246,14 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) { } else { pResBlock->info.scanFlag = pBlock->info.scanFlag; pBlock->info.dataLoad = 1; - blockDataUpdateTsWindow(pBlock, pInfo->primarySrcSlotId); + code = blockDataUpdateTsWindow(pBlock, pInfo->primarySrcSlotId); + QUERY_CHECK_CODE(code, lino, _end); blockDataCleanup(pInfo->pRes); - blockDataEnsureCapacity(pInfo->pRes, pBlock->info.rows); - blockDataEnsureCapacity(pInfo->pFinalRes, pBlock->info.rows); + code = blockDataEnsureCapacity(pInfo->pRes, pBlock->info.rows); + QUERY_CHECK_CODE(code, lino, _end); + code = blockDataEnsureCapacity(pInfo->pFinalRes, pBlock->info.rows); + QUERY_CHECK_CODE(code, lino, _end); doApplyScalarCalculation(pOperator, pBlock, order, pBlock->info.scanFlag); if (pInfo->curGroupId == 0 || (pInfo->curGroupId == pInfo->pRes->info.id.groupId)) { @@ -234,7 +264,7 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) { pInfo->curGroupId = pInfo->pRes->info.id.groupId; // the first data block pInfo->totalInputRows += pInfo->pRes->info.rows; - int64_t ts = (order == TSDB_ORDER_ASC)? pBlock->info.window.ekey:pBlock->info.window.skey; + int64_t ts = (order == TSDB_ORDER_ASC) ? pBlock->info.window.ekey : pBlock->info.window.skey; taosFillSetStartInfo(pInfo->pFillInfo, pInfo->pRes->info.rows, ts); taosFillSetInputDataBlock(pInfo->pFillInfo, pInfo->pRes); } else if (pInfo->curGroupId != pBlock->info.id.groupId) { // the new group data block @@ -248,7 +278,8 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) { } int32_t numOfResultRows = pOperator->resultInfo.capacity - pResBlock->info.rows; - taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows); + code = taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows); + QUERY_CHECK_CODE(code, lino, _end); // current group has no more result to return if (pResBlock->info.rows > 0) { @@ -276,6 +307,13 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) { return NULL; } } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } + return NULL; } static SSDataBlock* doFill(SOperatorInfo* pOperator) { @@ -294,7 +332,11 @@ static SSDataBlock* doFill(SOperatorInfo* pOperator) { break; } - doFilter(fillResult, pOperator->exprSupp.pFilterInfo, &pInfo->matchInfo); + int32_t code = doFilter(fillResult, pOperator->exprSupp.pFilterInfo, &pInfo->matchInfo); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } if (fillResult->info.rows > 0) { break; } @@ -329,8 +371,8 @@ static int32_t initFillInfo(SFillOperatorInfo* pInfo, SExprInfo* pExpr, int32_t int64_t startKey = (order == TSDB_ORDER_ASC) ? win.skey : win.ekey; -// STimeWindow w = {0}; -// getInitialStartTimeWindow(pInterval, startKey, &w, order == TSDB_ORDER_ASC); + // STimeWindow w = {0}; + // getInitialStartTimeWindow(pInterval, startKey, &w, order == TSDB_ORDER_ASC); pInfo->pFillInfo = taosCreateFillInfo(startKey, numOfCols, numOfNotFillCols, capacity, pInterval, fillType, pColInfo, pInfo->primaryTsCol, order, id); @@ -409,7 +451,8 @@ SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* goto _error; } - code = initExprSupp(pNoFillSupp, pNoFillSupp->pExprInfo, pNoFillSupp->numOfExprs, &pTaskInfo->storageAPI.functionStore); + code = + initExprSupp(pNoFillSupp, pNoFillSupp->pExprInfo, pNoFillSupp->numOfExprs, &pTaskInfo->storageAPI.functionStore); if (code != TSDB_CODE_SUCCESS) { goto _error; } @@ -425,7 +468,10 @@ SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* SResultInfo* pResultInfo = &pOperator->resultInfo; initResultSizeInfo(&pOperator->resultInfo, 4096); - blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + if (code != TSDB_CODE_SUCCESS) { + goto _error; + } code = initExprSupp(&pOperator->exprSupp, pExprInfo, pInfo->numOfExpr, &pTaskInfo->storageAPI.functionStore); if (code != TSDB_CODE_SUCCESS) { goto _error; @@ -446,7 +492,10 @@ SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* } pInfo->pFinalRes = createOneDataBlock(pInfo->pRes, false); - blockDataEnsureCapacity(pInfo->pFinalRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pInfo->pFinalRes, pOperator->resultInfo.capacity); + if (code != TSDB_CODE_SUCCESS) { + goto _error; + } code = filterInitFromNode((SNode*)pPhyFillNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); if (code != TSDB_CODE_SUCCESS) { @@ -455,8 +504,8 @@ SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* setOperatorInfo(pOperator, "FillOperator", QUERY_NODE_PHYSICAL_PLAN_FILL, false, OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->exprSupp.numOfExprs = pInfo->numOfExpr; - pOperator->fpSet = - createOperatorFpSet(optrDummyOpenFn, doFill, NULL, destroyFillOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); + pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doFill, NULL, destroyFillOperatorInfo, optrDefaultBufFn, NULL, + optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); return pOperator; diff --git a/source/libs/executor/src/groupoperator.c b/source/libs/executor/src/groupoperator.c index 2382f10503..dbe844bc32 100644 --- a/source/libs/executor/src/groupoperator.c +++ b/source/libs/executor/src/groupoperator.c @@ -67,7 +67,7 @@ static void* getCurrentDataGroupInfo(const SPartitionOperatorInfo* pInfo, SDa static int32_t* setupColumnOffset(const SSDataBlock* pBlock, int32_t rowCapacity); static int32_t setGroupResultOutputBuf(SOperatorInfo* pOperator, SOptrBasicInfo* binfo, int32_t numOfCols, char* pData, int32_t bytes, uint64_t groupId, SDiskbasedBuf* pBuf, SAggSupporter* pAggSup); -static SArray* extractColumnInfo(SNodeList* pNodeList); +static int32_t extractColumnInfo(SNodeList* pNodeList, SArray** pArrayRes); static void freeGroupKey(void* param) { SGroupKeys* pKey = (SGroupKeys*)param; @@ -111,7 +111,10 @@ static int32_t initGroupOptrInfo(SArray** pGroupColVals, int32_t* keyLen, char** return TSDB_CODE_OUT_OF_MEMORY; } - taosArrayPush((*pGroupColVals), &key); + void* tmp = taosArrayPush((*pGroupColVals), &key); + if (!tmp) { + return TSDB_CODE_OUT_OF_MEMORY; + } } int32_t nullFlagSize = sizeof(int8_t) * numOfGroupCols; @@ -349,12 +352,16 @@ static void doHashGroupbyAgg(SOperatorInfo* pOperator, SSDataBlock* pBlock) { } static SSDataBlock* buildGroupResultDataBlock(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SGroupbyOperatorInfo* pInfo = pOperator->info; + SSDataBlock* pRes = pInfo->binfo.pRes; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - SSDataBlock* pRes = pInfo->binfo.pRes; while (1) { doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf); - doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); if (!hasRemainResults(&pInfo->groupResInfo)) { setOperatorCompleted(pOperator); @@ -367,6 +374,12 @@ static SSDataBlock* buildGroupResultDataBlock(SOperatorInfo* pOperator) { } pOperator->resultInfo.totalRows += pRes->info.rows; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } return (pRes->info.rows == 0) ? NULL : pRes; } @@ -412,6 +425,9 @@ void doBuildResultDatablockByHash(SOperatorInfo* pOperator, SOptrBasicInfo* pbIn } static SSDataBlock* buildGroupResultDataBlockByHash(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SGroupbyOperatorInfo* pInfo = pOperator->info; SSDataBlock* pRes = pInfo->binfo.pRes; @@ -419,7 +435,9 @@ static SSDataBlock* buildGroupResultDataBlockByHash(SOperatorInfo* pOperator) { while (1) { doBuildResultDatablockByHash(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf); - doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); + if (!hasRemainResultByHash(pOperator)) { setOperatorCompleted(pOperator); // clean hash after completed @@ -433,6 +451,12 @@ static SSDataBlock* buildGroupResultDataBlockByHash(SOperatorInfo* pOperator) { } pOperator->resultInfo.totalRows += pRes->info.rows; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } return (pRes->info.rows == 0) ? NULL : pRes; } @@ -441,6 +465,8 @@ static SSDataBlock* hashGroupbyAggregate(SOperatorInfo* pOperator) { return NULL; } + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SGroupbyOperatorInfo* pInfo = pOperator->info; @@ -462,15 +488,14 @@ static SSDataBlock* hashGroupbyAggregate(SOperatorInfo* pOperator) { pInfo->binfo.pRes->info.scanFlag = pBlock->info.scanFlag; // the pDataBlock are always the same one, no need to call this again - setInputDataBlock(&pOperator->exprSupp, pBlock, order, pBlock->info.scanFlag, true); + code = setInputDataBlock(&pOperator->exprSupp, pBlock, order, pBlock->info.scanFlag, true); + QUERY_CHECK_CODE(code, lino, _end); // there is an scalar expression that needs to be calculated right before apply the group aggregation. if (pInfo->scalarSup.pExprInfo != NULL) { - pTaskInfo->code = projectApplyFunctions(pInfo->scalarSup.pExprInfo, pBlock, pBlock, pInfo->scalarSup.pCtx, - pInfo->scalarSup.numOfExprs, NULL); - if (pTaskInfo->code != TSDB_CODE_SUCCESS) { - T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); - } + code = projectApplyFunctions(pInfo->scalarSup.pExprInfo, pBlock, pBlock, pInfo->scalarSup.pCtx, + pInfo->scalarSup.numOfExprs, NULL); + QUERY_CHECK_CODE(code, lino, _end); } doHashGroupbyAgg(pOperator, pBlock); @@ -491,11 +516,19 @@ static SSDataBlock* hashGroupbyAggregate(SOperatorInfo* pOperator) { pGroupResInfo->dataPos = NULL; pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return buildGroupResultDataBlockByHash(pOperator); } SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pAggNode, SExecTaskInfo* pTaskInfo) { int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SGroupbyOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SGroupbyOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -514,32 +547,28 @@ SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pScalarExprInfo = createExprInfo(pAggNode->pExprs, NULL, &numOfScalarExpr); } - pInfo->pGroupCols = extractColumnInfo(pAggNode->pGroupKeys); + pInfo->pGroupCols = NULL; + code = extractColumnInfo(pAggNode->pGroupKeys, &pInfo->pGroupCols); + QUERY_CHECK_CODE(code, lino, _error); + code = initExprSupp(&pInfo->scalarSup, pScalarExprInfo, numOfScalarExpr, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); initResultSizeInfo(&pOperator->resultInfo, 4096); - blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _error); code = initGroupOptrInfo(&pInfo->pGroupColVals, &pInfo->groupKeyLen, &pInfo->keyBuf, pInfo->pGroupCols); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); int32_t num = 0; SExprInfo* pExprInfo = createExprInfo(pAggNode->pAggFuncs, pAggNode->pGroupKeys, &num); code = initAggSup(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, num, pInfo->groupKeyLen, pTaskInfo->id.str, pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); code = filterInitFromNode((SNode*)pAggNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); initResultRowInfo(&pInfo->binfo.resultRowInfo); setOperatorInfo(pOperator, "GroupbyAggOperator", 0, true, OP_NOT_OPENED, pInfo, pTaskInfo); @@ -551,9 +580,7 @@ SOperatorInfo* createGroupOperatorInfo(SOperatorInfo* downstream, SAggPhysiNode* pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, hashGroupbyAggregate, NULL, destroyGroupOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); return pOperator; @@ -567,6 +594,8 @@ _error: } SSDataBlock* createBlockDataNotLoaded(const SOperatorInfo* pOperator, SSDataBlock* pDataBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pDataBlock == NULL) { return NULL; } @@ -595,27 +624,33 @@ SSDataBlock* createBlockDataNotLoaded(const SOperatorInfo* pOperator, SSDataBloc int32_t slotId = pExpr->base.pParam[0].pCol->slotId; SColumnInfoData* pSrc = taosArrayGet(pDataBlock->pDataBlock, slotId); SColumnInfoData colInfo = {.hasNull = true, .info = pSrc->info}; - blockDataAppendColInfo(pDstBlock, &colInfo); + code = blockDataAppendColInfo(pDstBlock, &colInfo); + QUERY_CHECK_CODE(code, lino, _end); SColumnInfoData* pDst = taosArrayGet(pDstBlock->pDataBlock, i); if (pDataBlock->pBlockAgg && pDataBlock->pBlockAgg[slotId].colId != -1) { pDstBlock->pBlockAgg[i] = pDataBlock->pBlockAgg[slotId]; } else { - int32_t code = doEnsureCapacity(pDst, &pDstBlock->info, pDataBlock->info.rows, false); - if (code != TSDB_CODE_SUCCESS) { - terrno = code; - blockDataDestroy(pDstBlock); - return NULL; - } + code = doEnsureCapacity(pDst, &pDstBlock->info, pDataBlock->info.rows, false); + QUERY_CHECK_CODE(code, lino, _end); - colDataAssign(pDst, pSrc, pDataBlock->info.rows, &pDataBlock->info); + code = colDataAssign(pDst, pSrc, pDataBlock->info.rows, &pDataBlock->info); + QUERY_CHECK_CODE(code, lino, _end); } } +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + blockDataDestroy(pDstBlock); + return NULL; + } return pDstBlock; } static void doHashPartition(SOperatorInfo* pOperator, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SPartitionOperatorInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; @@ -709,24 +744,37 @@ static void doHashPartition(SOperatorInfo* pOperator, SSDataBlock* pBlock) { } if (pGroupInfo->blockForNotLoaded == NULL) { pGroupInfo->blockForNotLoaded = taosArrayInit(0, sizeof(SSDataBlock*)); + QUERY_CHECK_NULL(pGroupInfo->blockForNotLoaded, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); pGroupInfo->offsetForNotLoaded = 0; } dataNotLoadBlock->info.id.groupId = pGroupInfo->groupId; dataNotLoadBlock->info.dataLoad = 0; - taosArrayPush(pGroupInfo->blockForNotLoaded, &dataNotLoadBlock); + void* tmp = taosArrayPush(pGroupInfo->blockForNotLoaded, &dataNotLoadBlock); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); break; } } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } void* getCurrentDataGroupInfo(const SPartitionOperatorInfo* pInfo, SDataGroupInfo** pGroupInfo, int32_t len) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SDataGroupInfo* p = taosHashGet(pInfo->pGroupSet, pInfo->keyBuf, len); void* pPage = NULL; if (p == NULL) { // it is a new group SDataGroupInfo gi = {0}; gi.pPageList = taosArrayInit(100, sizeof(int32_t)); - taosHashPut(pInfo->pGroupSet, pInfo->keyBuf, len, &gi, sizeof(SDataGroupInfo)); + QUERY_CHECK_NULL(gi.pPageList, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + code = taosHashPut(pInfo->pGroupSet, pInfo->keyBuf, len, &gi, sizeof(SDataGroupInfo)); + QUERY_CHECK_CODE(code, lino, _end); p = taosHashGet(pInfo->pGroupSet, pInfo->keyBuf, len); @@ -736,7 +784,9 @@ void* getCurrentDataGroupInfo(const SPartitionOperatorInfo* pInfo, SDataGroupInf return pPage; } - taosArrayPush(p->pPageList, &pageId); + void* tmp = taosArrayPush(p->pPageList, &pageId); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + *(int32_t*)pPage = 0; } else { int32_t* curId = taosArrayGetLast(p->pPageList); @@ -759,12 +809,21 @@ void* getCurrentDataGroupInfo(const SPartitionOperatorInfo* pInfo, SDataGroupInf return NULL; } - taosArrayPush(p->pPageList, &pageId); + void* tmp = taosArrayPush(p->pPageList, &pageId); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + memset(pPage, 0, getBufPageSize(pInfo->pBuf)); } } *pGroupInfo = p; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + return NULL; + } + return pPage; } @@ -832,6 +891,8 @@ static SSDataBlock* buildPartitionResultForNotLoadBlock(SDataGroupInfo* pGroupIn } static SSDataBlock* buildPartitionResult(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SPartitionOperatorInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; @@ -877,8 +938,11 @@ static SSDataBlock* buildPartitionResult(SOperatorInfo* pOperator) { return buildPartitionResult(pOperator); } - blockDataEnsureCapacity(pInfo->binfo.pRes, pInfo->rowCapacity); - blockDataFromBuf1(pInfo->binfo.pRes, page, pInfo->rowCapacity); + code = blockDataEnsureCapacity(pInfo->binfo.pRes, pInfo->rowCapacity); + QUERY_CHECK_CODE(code, lino, _end); + + code = blockDataFromBuf1(pInfo->binfo.pRes, page, pInfo->rowCapacity); + QUERY_CHECK_CODE(code, lino, _end); pInfo->pageIndex += 1; releaseBufPage(pInfo->pBuf, page); @@ -891,13 +955,21 @@ static SSDataBlock* buildPartitionResult(SOperatorInfo* pOperator) { if (pInfo->pOrderInfoArr) { pInfo->binfo.pRes->info.rows += pInfo->remainRows; - blockDataTrimFirstRows(pInfo->binfo.pRes, pInfo->orderedRows); + code = blockDataTrimFirstRows(pInfo->binfo.pRes, pInfo->orderedRows); + QUERY_CHECK_CODE(code, lino, _end); pInfo->orderedRows = blockDataGetSortedRows(pInfo->binfo.pRes, pInfo->pOrderInfoArr); pInfo->remainRows = pInfo->binfo.pRes->info.rows - pInfo->orderedRows; pInfo->binfo.pRes->info.rows = pInfo->orderedRows; } - blockDataUpdateTsWindow(pInfo->binfo.pRes, 0); + code = blockDataUpdateTsWindow(pInfo->binfo.pRes, 0); + QUERY_CHECK_CODE(code, lino, _end); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } pOperator->resultInfo.totalRows += pInfo->binfo.pRes->info.rows; return pInfo->binfo.pRes; @@ -908,8 +980,9 @@ static SSDataBlock* hashPartition(SOperatorInfo* pOperator) { return NULL; } - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SPartitionOperatorInfo* pInfo = pOperator->info; SSDataBlock* pRes = pInfo->binfo.pRes; @@ -948,7 +1021,8 @@ static SSDataBlock* hashPartition(SOperatorInfo* pOperator) { void* pGroupIter = taosHashIterate(pInfo->pGroupSet, NULL); while (pGroupIter != NULL) { SDataGroupInfo* pGroupInfo = pGroupIter; - taosArrayPush(groupArray, pGroupInfo); + void* tmp = taosArrayPush(groupArray, pGroupInfo); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); pGroupIter = taosHashIterate(pInfo->pGroupSet, pGroupIter); } @@ -960,7 +1034,15 @@ static SSDataBlock* hashPartition(SOperatorInfo* pOperator) { pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0; pOperator->status = OP_RES_TO_RETURN; - blockDataEnsureCapacity(pRes, 4096); + code = blockDataEnsureCapacity(pRes, 4096); + QUERY_CHECK_CODE(code, lino, _end); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } + return buildPartitionResult(pOperator); } @@ -1002,6 +1084,8 @@ static void destroyPartitionOperatorInfo(void* param) { SOperatorInfo* createPartitionOperatorInfo(SOperatorInfo* downstream, SPartitionPhysiNode* pPartNode, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SPartitionOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SPartitionOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -1022,7 +1106,8 @@ SOperatorInfo* createPartitionOperatorInfo(SOperatorInfo* downstream, SPartition pTaskInfo->code = terrno; goto _error; } - taosArrayPush(pInfo->pOrderInfoArr, &order); + void* tmp = taosArrayPush(pInfo->pOrderInfoArr, &order); + QUERY_CHECK_NULL(tmp, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); } if (pPartNode->pExprs != NULL) { @@ -1048,7 +1133,7 @@ SOperatorInfo* createPartitionOperatorInfo(SOperatorInfo* downstream, SPartition uint32_t defaultBufsz = 0; pInfo->binfo.pRes = createDataBlockFromDescNode(pPartNode->node.pOutputDataBlockDesc); - int32_t code = getBufferPgSize(pInfo->binfo.pRes->info.rowSize, &defaultPgsz, &defaultBufsz); + code = getBufferPgSize(pInfo->binfo.pRes->info.rowSize, &defaultPgsz, &defaultBufsz); if (code != TSDB_CODE_SUCCESS) { terrno = code; pTaskInfo->code = code; @@ -1101,6 +1186,7 @@ _error: if (pInfo != NULL) { destroyPartitionOperatorInfo(pInfo); } + pTaskInfo->code = code; taosMemoryFreeClear(pOperator); return NULL; } @@ -1156,7 +1242,8 @@ static SSDataBlock* buildStreamPartitionResult(SOperatorInfo* pOperator) { bool isNull = colDataIsNull(pSrcCol, pSrc->info.rows, rowIndex, NULL); char* pSrcData = NULL; if (!isNull) pSrcData = colDataGetData(pSrcCol, rowIndex); - colDataSetVal(pDestCol, pDest->info.rows, pSrcData, isNull); + code = colDataSetVal(pDestCol, pDest->info.rows, pSrcData, isNull); + QUERY_CHECK_CODE(code, lino, _end); } pDest->info.rows++; } @@ -1177,7 +1264,9 @@ static SSDataBlock* buildStreamPartitionResult(SOperatorInfo* pOperator) { pParInfo->rowIds = NULL; pDest->info.dataLoad = 1; - blockDataUpdateTsWindow(pDest, pInfo->tsColIndex); + code = blockDataUpdateTsWindow(pDest, pInfo->tsColIndex); + QUERY_CHECK_CODE(code, lino, _end); + pDest->info.id.groupId = pParInfo->groupId; pOperator->resultInfo.totalRows += pDest->info.rows; pInfo->parIte = taosHashIterate(pInfo->pPartitions, pInfo->parIte); @@ -1288,6 +1377,8 @@ _end: } static void doStreamHashPartitionImpl(SStreamPartitionOperatorInfo* pInfo, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; pInfo->pInputDataBlock = pBlock; for (int32_t i = 0; i < pBlock->info.rows; ++i) { recordNewGroupKeys(pInfo->partitionSup.pGroupCols, pInfo->partitionSup.pGroupColVals, pBlock, i); @@ -1295,15 +1386,25 @@ static void doStreamHashPartitionImpl(SStreamPartitionOperatorInfo* pInfo, SSDat SPartitionDataInfo* pParData = (SPartitionDataInfo*)taosHashGet(pInfo->pPartitions, pInfo->partitionSup.keyBuf, keyLen); if (pParData) { - taosArrayPush(pParData->rowIds, &i); + void* tmp = taosArrayPush(pParData->rowIds, &i); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } else { SPartitionDataInfo newParData = {0}; newParData.groupId = calcGroupId(pInfo->partitionSup.keyBuf, keyLen); newParData.rowIds = taosArrayInit(64, sizeof(int32_t)); - taosArrayPush(newParData.rowIds, &i); - taosHashPut(pInfo->pPartitions, pInfo->partitionSup.keyBuf, keyLen, &newParData, sizeof(SPartitionDataInfo)); + void* tmp = taosArrayPush(newParData.rowIds, &i); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + code = + taosHashPut(pInfo->pPartitions, pInfo->partitionSup.keyBuf, keyLen, &newParData, sizeof(SPartitionDataInfo)); + QUERY_CHECK_CODE(code, lino, _end); } } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } } static SSDataBlock* doStreamHashPartition(SOperatorInfo* pOperator) { @@ -1345,7 +1446,9 @@ static SSDataBlock* doStreamHashPartition(SOperatorInfo* pOperator) { pInfo->binfo.pRes->info.type = pBlock->info.type; break; case STREAM_DELETE_DATA: { - copyDataBlock(pInfo->pDelRes, pBlock); + code = copyDataBlock(pInfo->pDelRes, pBlock); + QUERY_CHECK_CODE(code, lino, _end); + pInfo->pDelRes->info.type = STREAM_DELETE_RESULT; printDataBlock(pInfo->pDelRes, getStreamOpName(pOperator->operatorType), GET_TASKID(pTaskInfo)); return pInfo->pDelRes; @@ -1362,8 +1465,9 @@ static SSDataBlock* doStreamHashPartition(SOperatorInfo* pOperator) { // there is an scalar expression that needs to be calculated right before apply the group aggregation. if (pInfo->scalarSup.pExprInfo != NULL) { - projectApplyFunctions(pInfo->scalarSup.pExprInfo, pBlock, pBlock, pInfo->scalarSup.pCtx, - pInfo->scalarSup.numOfExprs, NULL); + code = projectApplyFunctions(pInfo->scalarSup.pExprInfo, pBlock, pBlock, pInfo->scalarSup.pCtx, + pInfo->scalarSup.numOfExprs, NULL); + QUERY_CHECK_CODE(code, lino, _end); } taosHashClear(pInfo->pPartitions); doStreamHashPartitionImpl(pInfo, pBlock); @@ -1429,6 +1533,8 @@ int32_t initParDownStream(SOperatorInfo* downstream, SPartitionBySupporter* pPar } SSDataBlock* buildCreateTableBlock(SExprSupp* tbName, SExprSupp* tag) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SSDataBlock* pBlock = taosMemoryCalloc(1, sizeof(SSDataBlock)); pBlock->info.hasVarCol = false; pBlock->info.id.groupId = 0; @@ -1446,14 +1552,16 @@ SSDataBlock* buildCreateTableBlock(SExprSupp* tbName, SExprSupp* tag) { } pBlock->info.rowSize += infoData.info.bytes; // sub table name - taosArrayPush(pBlock->pDataBlock, &infoData); + void* tmp = taosArrayPush(pBlock->pDataBlock, &infoData); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); SColumnInfoData gpIdData = {0}; gpIdData.info.type = TSDB_DATA_TYPE_UBIGINT; gpIdData.info.bytes = 8; pBlock->info.rowSize += gpIdData.info.bytes; // group id - taosArrayPush(pBlock->pDataBlock, &gpIdData); + tmp = taosArrayPush(pBlock->pDataBlock, &gpIdData); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); for (int32_t i = 0; i < tag->numOfExprs; i++) { SColumnInfoData tagCol = {0}; @@ -1461,10 +1569,17 @@ SSDataBlock* buildCreateTableBlock(SExprSupp* tbName, SExprSupp* tag) { tagCol.info.bytes = tag->pExprInfo[i].base.resSchema.bytes; tagCol.info.precision = tag->pExprInfo[i].base.resSchema.precision; // tag info - taosArrayPush(pBlock->pDataBlock, &tagCol); + tmp = taosArrayPush(pBlock->pDataBlock, &tagCol); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); pBlock->info.rowSize += tagCol.info.bytes; } +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + blockDataDestroy(pBlock); + return NULL; + } return pBlock; } @@ -1490,42 +1605,33 @@ SOperatorInfo* createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStr int32_t num = 0; SExprInfo* pCalExprInfo = createExprInfo(pPartNode->part.pExprs, NULL, &num); code = initExprSupp(&pInfo->scalarSup, pCalExprInfo, num, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); } pInfo->tbnameCalSup.numOfExprs = 0; if (pPartNode->pSubtable != NULL) { SExprInfo* pSubTableExpr = taosMemoryCalloc(1, sizeof(SExprInfo)); - if (pSubTableExpr == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _error; - } + QUERY_CHECK_NULL(pSubTableExpr, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + pInfo->tbnameCalSup.pExprInfo = pSubTableExpr; createExprFromOneNode(pSubTableExpr, pPartNode->pSubtable, 0); code = initExprSupp(&pInfo->tbnameCalSup, pSubTableExpr, 1, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); } pInfo->tagCalSup.numOfExprs = 0; if (pPartNode->pTags != NULL) { int32_t numOfTags; SExprInfo* pTagExpr = createExpr(pPartNode->pTags, &numOfTags); - if (pTagExpr == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _error; - } - if (initExprSupp(&pInfo->tagCalSup, pTagExpr, numOfTags, &pTaskInfo->storageAPI.functionStore) != 0) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _error; - } + QUERY_CHECK_NULL(pTagExpr, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + + code = initExprSupp(&pInfo->tagCalSup, pTagExpr, numOfTags, &pTaskInfo->storageAPI.functionStore); + QUERY_CHECK_CODE(code, lino, _error); } if (pInfo->tbnameCalSup.numOfExprs != 0 || pInfo->tagCalSup.numOfExprs != 0) { pInfo->pCreateTbRes = buildCreateTableBlock(&pInfo->tbnameCalSup, &pInfo->tagCalSup); + QUERY_CHECK_NULL(pInfo->pCreateTbRes, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); } else { pInfo->pCreateTbRes = NULL; } @@ -1533,18 +1639,15 @@ SOperatorInfo* createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStr int32_t keyLen = 0; code = initGroupOptrInfo(&pInfo->partitionSup.pGroupColVals, &keyLen, &pInfo->partitionSup.keyBuf, pInfo->partitionSup.pGroupCols); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); + pInfo->partitionSup.needCalc = true; pInfo->binfo.pRes = createDataBlockFromDescNode(pPartNode->part.node.pOutputDataBlockDesc); - if (pInfo->binfo.pRes == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _error; - } + QUERY_CHECK_NULL(pInfo->binfo.pRes, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); - blockDataEnsureCapacity(pInfo->binfo.pRes, 4096); + code = blockDataEnsureCapacity(pInfo->binfo.pRes, 4096); + QUERY_CHECK_CODE(code, lino, _error); pInfo->parIte = NULL; pInfo->pTbNameIte = NULL; @@ -1555,6 +1658,7 @@ SOperatorInfo* createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStr taosHashSetFreeFp(pInfo->pPartitions, freePartItem); pInfo->tsColIndex = 0; pInfo->pDelRes = createSpecialDataBlock(STREAM_DELETE_RESULT); + QUERY_CHECK_NULL(pInfo->pDelRes, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); int32_t numOfCols = 0; SExprInfo* pExprInfo = createExprInfo(pPartNode->part.pTargets, NULL, &numOfCols); @@ -1584,12 +1688,15 @@ _error: return NULL; } -SArray* extractColumnInfo(SNodeList* pNodeList) { +int32_t extractColumnInfo(SNodeList* pNodeList, SArray** pArrayRes) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; size_t numOfCols = LIST_LENGTH(pNodeList); SArray* pList = taosArrayInit(numOfCols, sizeof(SColumn)); if (pList == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return NULL; + code = TSDB_CODE_OUT_OF_MEMORY; + (*pArrayRes) = NULL; + QUERY_CHECK_CODE(code, lino, _end); } for (int32_t i = 0; i < numOfCols; ++i) { @@ -1599,7 +1706,8 @@ SArray* extractColumnInfo(SNodeList* pNodeList) { SColumnNode* pColNode = (SColumnNode*)pNode->pExpr; SColumn c = extractColumnFromColumnNode(pColNode); - taosArrayPush(pList, &c); + void* tmp = taosArrayPush(pList, &c); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } else if (nodeType(pNode->pExpr) == QUERY_NODE_VALUE) { SValueNode* pValNode = (SValueNode*)pNode->pExpr; SColumn c = {0}; @@ -1610,9 +1718,16 @@ SArray* extractColumnInfo(SNodeList* pNodeList) { c.scale = pValNode->node.resType.scale; c.precision = pValNode->node.resType.precision; - taosArrayPush(pList, &c); + void* tmp = taosArrayPush(pList, &c); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } } - return pList; + (*pArrayRes) = pList; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index 207c81fcb9..520cba92a1 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -1131,9 +1131,8 @@ static SSDataBlock* groupSeqTableScan(SOperatorInfo* pOperator) { ASSERT(pInfo->base.dataReader == NULL); - code = pAPI->tsdReader.tsdReaderOpen(pInfo->base.readHandle.vnode, &pInfo->base.cond, pList, num, pInfo->pResBlock, + pAPI->tsdReader.tsdReaderOpen(pInfo->base.readHandle.vnode, &pInfo->base.cond, pList, num, pInfo->pResBlock, (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), &pInfo->pIgnoreTables); - QUERY_CHECK_CODE(code, lino, _end); if (pInfo->filesetDelimited) { pAPI->tsdReader.tsdSetFilesetDelimited(pInfo->base.dataReader); } @@ -3782,6 +3781,8 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys pInfo->readHandle = *pHandle; pTaskInfo->streamInfo.snapshotVer = pHandle->version; pInfo->pCreateTbRes = buildCreateTableBlock(&pInfo->tbnameCalSup, &pInfo->tagCalSup); + QUERY_CHECK_NULL(pInfo->pCreateTbRes, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + code = blockDataEnsureCapacity(pInfo->pCreateTbRes, 8); QUERY_CHECK_CODE(code, lino, _error); diff --git a/source/libs/executor/src/streamcountwindowoperator.c b/source/libs/executor/src/streamcountwindowoperator.c index 3471f02bf5..dd05581ff0 100644 --- a/source/libs/executor/src/streamcountwindowoperator.c +++ b/source/libs/executor/src/streamcountwindowoperator.c @@ -683,7 +683,8 @@ static SSDataBlock* doStreamCountAgg(SOperatorInfo* pOperator) { QUERY_CHECK_CODE(code, lino, _end); } // the pDataBlock are always the same one, no need to call this again - setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + code = setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); doStreamCountAggImpl(pOperator, pBlock, pInfo->pStUpdated, pInfo->pStDeleted); pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey); pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.watermark); @@ -821,7 +822,8 @@ SOperatorInfo* createStreamCountAggOperatorInfo(SOperatorInfo* downstream, SPhys pInfo->streamAggSup.windowCount = pCountNode->windowCount; pInfo->streamAggSup.windowSliding = pCountNode->windowSliding; - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + QUERY_CHECK_CODE(code, lino, _error); pInfo->binfo.pRes = pResBlock; _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY); diff --git a/source/libs/executor/src/streameventwindowoperator.c b/source/libs/executor/src/streameventwindowoperator.c index 807cf5a4ba..2cd36a7fb7 100644 --- a/source/libs/executor/src/streameventwindowoperator.c +++ b/source/libs/executor/src/streameventwindowoperator.c @@ -650,7 +650,8 @@ static SSDataBlock* doStreamEventAgg(SOperatorInfo* pOperator) { QUERY_CHECK_CODE(code, lino, _end); } // the pDataBlock are always the same one, no need to call this again - setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + code = setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); doStreamEventAggImpl(pOperator, pBlock, pInfo->pSeUpdated, pInfo->pSeDeleted); pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey); } @@ -846,24 +847,21 @@ SOperatorInfo* createStreamEventAggOperatorInfo(SOperatorInfo* downstream, SPhys .deleteMark = getDeleteMark(&pEventNode->window, 0), }; - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + QUERY_CHECK_CODE(code, lino, _error); SExprSupp* pExpSup = &pOperator->exprSupp; int32_t numOfCols = 0; SExprInfo* pExprInfo = createExprInfo(pEventNode->window.pFuncs, NULL, &numOfCols); SSDataBlock* pResBlock = createDataBlockFromDescNode(pPhyNode->pOutputDataBlockDesc); code = initBasicInfoEx(&pInfo->binfo, pExpSup, pExprInfo, numOfCols, pResBlock, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); pInfo->primaryTsIndex = tsSlotId; code = initStreamAggSupporter(&pInfo->streamAggSup, pExpSup, numOfCols, 0, pTaskInfo->streamInfo.pState, sizeof(bool) + sizeof(bool), 0, &pTaskInfo->storageAPI.stateStore, pHandle, &pInfo->twAggSup, GET_TASKID(pTaskInfo), &pTaskInfo->storageAPI, pInfo->primaryTsIndex); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); _hash_fn_t hashFn = taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY); pInfo->pSeDeleted = tSimpleHashInit(64, hashFn); @@ -885,14 +883,18 @@ SOperatorInfo* createStreamEventAggOperatorInfo(SOperatorInfo* downstream, SPhys if (pInfo->isHistoryOp) { pInfo->pAllUpdated = tSimpleHashInit(64, hashFn); + QUERY_CHECK_NULL(pInfo->pAllUpdated, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); } else { pInfo->pAllUpdated = NULL; } pInfo->pCheckpointRes = createSpecialDataBlock(STREAM_CHECKPOINT); + QUERY_CHECK_NULL(pInfo->pCheckpointRes, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + pInfo->reCkBlock = false; pInfo->recvGetAll = false; pInfo->pPkDeleted = tSimpleHashInit(64, hashFn); + QUERY_CHECK_NULL(pInfo->pPkDeleted, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); pInfo->destHasPrimaryKey = pEventNode->window.destHasPrimayKey; setOperatorInfo(pOperator, "StreamEventAggOperator", QUERY_NODE_PHYSICAL_PLAN_STREAM_EVENT, true, OP_NOT_OPENED, diff --git a/source/libs/executor/src/streamfilloperator.c b/source/libs/executor/src/streamfilloperator.c index a9cc270f7a..bd254c5e5a 100644 --- a/source/libs/executor/src/streamfilloperator.c +++ b/source/libs/executor/src/streamfilloperator.c @@ -990,13 +990,15 @@ static int32_t doApplyStreamScalarCalculation(SOperatorInfo* pOperator, SSDataBl code = blockDataEnsureCapacity(pDstBlock, pSrcBlock->info.rows); QUERY_CHECK_CODE(code, lino, _end); - setInputDataBlock(pSup, pSrcBlock, TSDB_ORDER_ASC, MAIN_SCAN, false); + code = setInputDataBlock(pSup, pSrcBlock, TSDB_ORDER_ASC, MAIN_SCAN, false); + QUERY_CHECK_CODE(code, lino, _end); code = projectApplyFunctions(pSup->pExprInfo, pDstBlock, pSrcBlock, pSup->pCtx, pSup->numOfExprs, NULL); QUERY_CHECK_CODE(code, lino, _end); pDstBlock->info.rows = 0; pSup = &pInfo->pFillSup->notFillExprSup; - setInputDataBlock(pSup, pSrcBlock, TSDB_ORDER_ASC, MAIN_SCAN, false); + code = setInputDataBlock(pSup, pSrcBlock, TSDB_ORDER_ASC, MAIN_SCAN, false); + QUERY_CHECK_CODE(code, lino, _end); code = projectApplyFunctions(pSup->pExprInfo, pDstBlock, pSrcBlock, pSup->pCtx, pSup->numOfExprs, NULL); QUERY_CHECK_CODE(code, lino, _end); diff --git a/source/libs/executor/src/streamtimewindowoperator.c b/source/libs/executor/src/streamtimewindowoperator.c index b2af12aab9..1135757950 100644 --- a/source/libs/executor/src/streamtimewindowoperator.c +++ b/source/libs/executor/src/streamtimewindowoperator.c @@ -1667,7 +1667,9 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) { code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); QUERY_CHECK_CODE(code, lino, _end); } - setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + code = setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); + doStreamIntervalAggImpl(pOperator, pBlock, pBlock->info.id.groupId, pInfo->pUpdatedMap, pInfo->pDeletedMap); pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey); pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.watermark); @@ -1859,7 +1861,8 @@ SOperatorInfo* createStreamFinalIntervalOperatorInfo(SOperatorInfo* downstream, pInfo->pState, &pTaskInfo->storageAPI.functionStore); QUERY_CHECK_CODE(code, lino, _error); - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + QUERY_CHECK_CODE(code, lino, _error); initResultRowInfo(&pInfo->binfo.resultRowInfo); pInfo->numOfChild = numOfChild; @@ -3331,7 +3334,9 @@ static SSDataBlock* doStreamSessionAgg(SOperatorInfo* pOperator) { QUERY_CHECK_CODE(code, lino, _end); } // the pDataBlock are always the same one, no need to call this again - setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + code = setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); + doStreamSessionAggImpl(pOperator, pBlock, pInfo->pStUpdated, pInfo->pStDeleted, IS_FINAL_SESSION_OP(pOperator), true); if (IS_FINAL_SESSION_OP(pOperator)) { @@ -3353,7 +3358,8 @@ static SSDataBlock* doStreamSessionAgg(SOperatorInfo* pOperator) { } } SOperatorInfo* pChildOp = taosArrayGetP(pInfo->pChildren, chIndex); - setInputDataBlock(&pChildOp->exprSupp, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + code = setInputDataBlock(&pChildOp->exprSupp, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); doStreamSessionAggImpl(pChildOp, pBlock, NULL, NULL, true, false); } pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey); @@ -3625,7 +3631,8 @@ SOperatorInfo* createStreamSessionAggOperatorInfo(SOperatorInfo* downstream, SPh goto _error; } - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + QUERY_CHECK_CODE(code, lino, _error); if (pSessionNode->window.pTsEnd) { pInfo->endTsIndex = ((SColumnNode*)pSessionNode->window.pTsEnd)->slotId; @@ -3818,7 +3825,8 @@ static SSDataBlock* doStreamSessionSemiAgg(SOperatorInfo* pOperator) { QUERY_CHECK_CODE(code, lino, _end); } // the pDataBlock are always the same one, no need to call this again - setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + code = setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); doStreamSessionAggImpl(pOperator, pBlock, pInfo->pStUpdated, NULL, false, false); maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey); } @@ -4501,7 +4509,8 @@ static SSDataBlock* doStreamStateAgg(SOperatorInfo* pOperator) { QUERY_CHECK_CODE(code, lino, _end); } // the pDataBlock are always the same one, no need to call this again - setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + code = setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); doStreamStateAggImpl(pOperator, pBlock, pInfo->pSeUpdated, pInfo->pSeDeleted); pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey); } @@ -4688,7 +4697,8 @@ SOperatorInfo* createStreamStateAggOperatorInfo(SOperatorInfo* downstream, SPhys .deleteMark = getDeleteMark(&pStateNode->window, 0), }; - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + QUERY_CHECK_CODE(code, lino, _error); SExprSupp* pExpSup = &pOperator->exprSupp; int32_t numOfCols = 0; @@ -4874,7 +4884,8 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) { // The timewindow that overlaps the timestamps of the input pBlock need to be recalculated and return to the // caller. Note that all the time window are not close till now. // the pDataBlock are always the same one, no need to call this again - setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + code = (pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); #ifdef BUILD_NO_CALL if (pInfo->invertible) { setInverFunction(pSup->pCtx, pOperator->exprSupp.numOfExprs, pBlock->info.type); @@ -4970,7 +4981,8 @@ SOperatorInfo* createStreamIntervalOperatorInfo(SOperatorInfo* downstream, SPhys pSup->hasWindowOrGroup = true; initBasicInfo(&pInfo->binfo, pResBlock); - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + QUERY_CHECK_CODE(code, lino, _error); pInfo->primaryTsIndex = ((SColumnNode*)pIntervalPhyNode->window.pTspk)->slotId; initResultSizeInfo(&pOperator->resultInfo, 4096); @@ -5359,7 +5371,8 @@ static SSDataBlock* doStreamMidIntervalAgg(SOperatorInfo* pOperator) { code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); QUERY_CHECK_CODE(code, lino, _end); } - setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + code = setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); doStreamMidIntervalAggImpl(pOperator, pBlock, pInfo->pUpdatedMap); pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.window.ekey); pInfo->twAggSup.maxTs = TMAX(pInfo->twAggSup.maxTs, pBlock->info.watermark); diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c index 41d398888e..fb3176a2a8 100644 --- a/source/libs/executor/src/timewindowoperator.c +++ b/source/libs/executor/src/timewindowoperator.c @@ -30,7 +30,7 @@ typedef struct SSessionAggOperatorInfo { SOptrBasicInfo binfo; SAggSupporter aggSup; - SExprSupp scalarSupp; // supporter for perform scalar function + SExprSupp scalarSupp; // supporter for perform scalar function SGroupResInfo groupResInfo; SWindowRowsSup winSup; bool reptScan; // next round scan @@ -518,8 +518,8 @@ static void doWindowBorderInterpolation(SIntervalAggOperatorInfo* pInfo, SSDataB // duplicated ts row does not involve in the interpolation of end value for current time window int32_t x = endRowIndex; - while(x > 0) { - if (tsCols[x] == tsCols[x-1]) { + while (x > 0) { + if (tsCols[x] == tsCols[x - 1]) { x -= 1; } else { endRowIndex = x; @@ -528,7 +528,8 @@ static void doWindowBorderInterpolation(SIntervalAggOperatorInfo* pInfo, SSDataB } TSKEY endKey = (pInfo->binfo.inputTsOrder == TSDB_ORDER_ASC) ? pBlock->info.window.ekey : pBlock->info.window.skey; - bool interp = setTimeWindowInterpolationEndTs(pInfo, pSup, endRowIndex, nextRowIndex, pBlock->pDataBlock, tsCols, endKey, win); + bool interp = setTimeWindowInterpolationEndTs(pInfo, pSup, endRowIndex, nextRowIndex, pBlock->pDataBlock, tsCols, + endKey, win); if (interp) { setResultRowInterpo(pResult, RESULT_ROW_END_INTERP); } @@ -1203,6 +1204,8 @@ static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SInt SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SIntervalAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SIntervalAggOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -1223,8 +1226,8 @@ SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPh int32_t num = 0; SExprInfo* pExprInfo = createExprInfo(pPhyNode->window.pFuncs, NULL, &num); - int32_t code = initAggSup(pSup, &pInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str, - pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); + code = initAggSup(pSup, &pInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str, pTaskInfo->streamInfo.pState, + &pTaskInfo->storageAPI.functionStore); if (code != TSDB_CODE_SUCCESS) { goto _error; } @@ -1274,7 +1277,8 @@ SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPh goto _error; } - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pInfo->win); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pInfo->win); + QUERY_CHECK_CODE(code, lino, _error); pInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, pInfo); if (pInfo->timeWindowInterpo) { pInfo->binfo.resultRowInfo.openWindow = tdListNew(sizeof(SOpenWindowInfo)); @@ -1421,7 +1425,7 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) { if (pInfo->scalarSupp.pExprInfo != NULL) { SExprSupp* pExprSup = &pInfo->scalarSupp; projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); - } + } // the pDataBlock are always the same one, no need to call this again setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true); blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId); @@ -1457,6 +1461,8 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) { // todo make this as an non-blocking operator SOperatorInfo* createStatewindowOperatorInfo(SOperatorInfo* downstream, SStateWinodwPhysiNode* pStateNode, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SStateWindowOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SStateWindowOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -1487,7 +1493,7 @@ SOperatorInfo* createStatewindowOperatorInfo(SOperatorInfo* downstream, SStateWi pInfo->binfo.inputTsOrder = pStateNode->window.node.inputTsOrder; pInfo->binfo.outputTsOrder = pStateNode->window.node.outputTsOrder; - int32_t code = filterInitFromNode((SNode*)pStateNode->window.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); + code = filterInitFromNode((SNode*)pStateNode->window.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); if (code != TSDB_CODE_SUCCESS) { goto _error; } @@ -1511,7 +1517,8 @@ SOperatorInfo* createStatewindowOperatorInfo(SOperatorInfo* downstream, SStateWi pInfo->twAggSup = (STimeWindowAggSupp){.waterMark = pStateNode->window.watermark, .calTrigger = pStateNode->window.triggerType}; - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + QUERY_CHECK_CODE(code, lino, _error); pInfo->tsSlotId = tsSlotId; @@ -1548,13 +1555,15 @@ void destroySWindowOperatorInfo(void* param) { cleanupAggSup(&pInfo->aggSup); cleanupExprSupp(&pInfo->scalarSupp); - + cleanupGroupResInfo(&pInfo->groupResInfo); taosMemoryFreeClear(param); } SOperatorInfo* createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionWinodwPhysiNode* pSessionNode, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SSessionAggOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(SSessionAggOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -1571,7 +1580,7 @@ SOperatorInfo* createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionW SSDataBlock* pResBlock = createDataBlockFromDescNode(pSessionNode->window.node.pOutputDataBlockDesc); initBasicInfo(&pInfo->binfo, pResBlock); - int32_t code = initAggSup(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, numOfCols, keyBufSize, pTaskInfo->id.str, + code = initAggSup(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, numOfCols, keyBufSize, pTaskInfo->id.str, pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); if (code != TSDB_CODE_SUCCESS) { goto _error; @@ -1582,7 +1591,8 @@ SOperatorInfo* createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionW pInfo->gap = pSessionNode->gap; initResultRowInfo(&pInfo->binfo.resultRowInfo); - initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pTaskInfo->window); + QUERY_CHECK_CODE(code, lino, _error); pInfo->tsSlotId = ((SColumnNode*)pSessionNode->window.pTspk)->slotId; pInfo->binfo.pRes = pResBlock; @@ -1830,6 +1840,8 @@ static SSDataBlock* mergeAlignedIntervalAgg(SOperatorInfo* pOperator) { SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SMergeAlignedIntervalPhysiNode* pNode, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SMergeAlignedIntervalAggOperatorInfo* miaInfo = taosMemoryCalloc(1, sizeof(SMergeAlignedIntervalAggOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (miaInfo == NULL || pOperator == NULL) { @@ -1852,7 +1864,7 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SExprSupp* pSup = &pOperator->exprSupp; pSup->hasWindowOrGroup = true; - int32_t code = filterInitFromNode((SNode*)pNode->window.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); + code = filterInitFromNode((SNode*)pNode->window.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); if (code != TSDB_CODE_SUCCESS) { goto _error; } @@ -1879,7 +1891,8 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, SSDataBlock* pResBlock = createDataBlockFromDescNode(pNode->window.node.pOutputDataBlockDesc); initBasicInfo(&iaInfo->binfo, pResBlock); - initExecTimeWindowInfo(&iaInfo->twAggSup.timeWindowData, &iaInfo->win); + code = initExecTimeWindowInfo(&iaInfo->twAggSup.timeWindowData, &iaInfo->win); + QUERY_CHECK_CODE(code, lino, _error); iaInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, iaInfo); if (iaInfo->timeWindowInterpo) { @@ -2126,6 +2139,8 @@ static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) { SOperatorInfo* createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SMergeIntervalPhysiNode* pIntervalPhyNode, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SMergeIntervalAggOperatorInfo* pMergeIntervalInfo = taosMemoryCalloc(1, sizeof(SMergeIntervalAggOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pMergeIntervalInfo == NULL || pOperator == NULL) { @@ -2158,15 +2173,16 @@ SOperatorInfo* createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SMerge size_t keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES; initResultSizeInfo(&pOperator->resultInfo, 4096); - int32_t code = initAggSup(pExprSupp, &pIntervalInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str, - pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); + code = initAggSup(pExprSupp, &pIntervalInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str, + pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); if (code != TSDB_CODE_SUCCESS) { goto _error; } SSDataBlock* pResBlock = createDataBlockFromDescNode(pIntervalPhyNode->window.node.pOutputDataBlockDesc); initBasicInfo(&pIntervalInfo->binfo, pResBlock); - initExecTimeWindowInfo(&pIntervalInfo->twAggSup.timeWindowData, &pIntervalInfo->win); + code = initExecTimeWindowInfo(&pIntervalInfo->twAggSup.timeWindowData, &pIntervalInfo->win); + QUERY_CHECK_CODE(code, lino, _error); pIntervalInfo->timeWindowInterpo = timeWindowinterpNeeded(pExprSupp->pCtx, num, pIntervalInfo); if (pIntervalInfo->timeWindowInterpo) { From fd6c1ecf3720f2e8da08732bf4b5c7abb4f9c8da Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao> Date: Mon, 22 Jul 2024 13:05:39 +0800 Subject: [PATCH 06/11] adj operator res --- source/libs/stream/src/streamUpdate.c | 4 ++-- source/util/src/tscalablebf.c | 5 +++-- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/source/libs/stream/src/streamUpdate.c b/source/libs/stream/src/streamUpdate.c index ea3b923f98..76b0d6a561 100644 --- a/source/libs/stream/src/streamUpdate.c +++ b/source/libs/stream/src/streamUpdate.c @@ -241,8 +241,8 @@ static int32_t getSBf(SUpdateInfo* pInfo, TSKEY ts, SScalableBf** ppSBf) { } int64_t index = (int64_t)((ts - pInfo->minTS) / pInfo->interval); if (index < 0) { - code = TSDB_CODE_FAILED; - QUERY_CHECK_CODE(code, lino, _end); + (*ppSBf) = NULL; + goto _end; } if (index >= pInfo->numSBFs) { uint64_t count = index + 1 - pInfo->numSBFs; diff --git a/source/util/src/tscalablebf.c b/source/util/src/tscalablebf.c index 5b018ba677..72a97fee45 100644 --- a/source/util/src/tscalablebf.c +++ b/source/util/src/tscalablebf.c @@ -221,8 +221,9 @@ int32_t tScalableBfDecode(SDecoder* pDecoder, SScalableBf** ppSBf) { QUERY_CHECK_CODE(code, lino, _error); } if (size == 0) { - code = TSDB_CODE_FAILED; - QUERY_CHECK_CODE(code, lino, _error); + (*ppSBf) = NULL; + tScalableBfDestroy(pSBf); + goto _error; } pSBf->bfArray = taosArrayInit(size * 2, POINTER_BYTES); if (!pSBf->bfArray) { From 951283fc4408e0c8d492a2f3d2433c912f42485c Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao> Date: Mon, 22 Jul 2024 13:15:24 +0800 Subject: [PATCH 07/11] adj operator res --- source/libs/executor/src/executor.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c index c79f69129c..c7259c464d 100644 --- a/source/libs/executor/src/executor.c +++ b/source/libs/executor/src/executor.c @@ -731,8 +731,7 @@ int32_t qExecTaskOpt(qTaskInfo_t tinfo, SArray* pResList, uint64_t* useconds, bo _end: - int32_t tmpRes = cleanUpUdfs(); - qTrace("%s at line %d res:%d", __func__, __LINE__, tmpRes); + (void)cleanUpUdfs(); uint64_t total = pTaskInfo->pRoot->resultInfo.totalRows; qDebug("%s task suspended, %d rows in %d blocks returned, total:%" PRId64 " rows, in sinkNode:%d, elapsed:%.2f ms", From b43dcf2a26817acfb62dc81370bf256ba63d334e Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao> Date: Mon, 22 Jul 2024 13:38:30 +0800 Subject: [PATCH 08/11] adj operator res --- source/libs/executor/src/streamtimewindowoperator.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/libs/executor/src/streamtimewindowoperator.c b/source/libs/executor/src/streamtimewindowoperator.c index 1135757950..d340efbb1b 100644 --- a/source/libs/executor/src/streamtimewindowoperator.c +++ b/source/libs/executor/src/streamtimewindowoperator.c @@ -4884,7 +4884,7 @@ static SSDataBlock* doStreamIntervalAgg(SOperatorInfo* pOperator) { // The timewindow that overlaps the timestamps of the input pBlock need to be recalculated and return to the // caller. Note that all the time window are not close till now. // the pDataBlock are always the same one, no need to call this again - code = (pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); + code = setInputDataBlock(pSup, pBlock, TSDB_ORDER_ASC, MAIN_SCAN, true); QUERY_CHECK_CODE(code, lino, _end); #ifdef BUILD_NO_CALL if (pInfo->invertible) { From e3a89571ff82dcfac1a9dfa26f3d85ca55a9ceb3 Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao> Date: Mon, 22 Jul 2024 13:40:35 +0800 Subject: [PATCH 09/11] adj operator res --- source/libs/executor/src/countwindowoperator.c | 1 - 1 file changed, 1 deletion(-) diff --git a/source/libs/executor/src/countwindowoperator.c b/source/libs/executor/src/countwindowoperator.c index 6e476c4ea0..55f73b9417 100644 --- a/source/libs/executor/src/countwindowoperator.c +++ b/source/libs/executor/src/countwindowoperator.c @@ -142,7 +142,6 @@ static void buildCountResult(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, S SCountWindowResult* pBuff = setCountWindowOutputBuff(pExprSup, pCountSup, &pResultRow); if (pBuff->winRows == 0) { continue; - ; } doUpdateNumOfRows(pExprSup->pCtx, pResultRow, pExprSup->numOfExprs, pExprSup->rowEntryInfoOffset); copyResultrowToDataBlock(pExprSup->pExprInfo, pExprSup->numOfExprs, pResultRow, pExprSup->pCtx, pBlock, From 3660b6cede223a335d9cff8306f56ef71ecb94b5 Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao> Date: Mon, 22 Jul 2024 13:55:00 +0800 Subject: [PATCH 10/11] adj operator res --- source/libs/executor/src/executor.c | 2 +- source/libs/executor/src/executorInt.c | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c index c7259c464d..8cf44602f9 100644 --- a/source/libs/executor/src/executor.c +++ b/source/libs/executor/src/executor.c @@ -826,7 +826,7 @@ int32_t qAppendTaskStopInfo(SExecTaskInfo* pTaskInfo, SExchangeOpStopInfo* pInfo void* tmp = taosArrayPush(pTaskInfo->stopInfo.pStopInfo, pInfo); taosWUnLockLatch(&pTaskInfo->stopInfo.lock); - if (tmp != TSDB_CODE_SUCCESS) { + if (!tmp) { qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); return TSDB_CODE_OUT_OF_MEMORY; } diff --git a/source/libs/executor/src/executorInt.c b/source/libs/executor/src/executorInt.c index dd6067da34..3b356f0ab4 100644 --- a/source/libs/executor/src/executorInt.c +++ b/source/libs/executor/src/executorInt.c @@ -649,10 +649,10 @@ void copyResultrowToDataBlock(SExprInfo* pExprInfo, int32_t numOfExprs, SResultR code = blockDataEnsureCapacity(pBlock, pBlock->info.rows + pCtx[j].resultInfo->numOfRes); QUERY_CHECK_CODE(code, lino, _end); - code = pCtx[j].fpSet.finalize(&pCtx[j], pBlock); - if (TAOS_FAILED(code)) { - qError("%s build result data block error, code %s", GET_TASKID(pTaskInfo), tstrerror(code)); - T_LONG_JMP(pTaskInfo->env, code); + int32_t winCode = pCtx[j].fpSet.finalize(&pCtx[j], pBlock); + if (TAOS_FAILED(winCode)) { + qError("%s build result data block error, code %s", GET_TASKID(pTaskInfo), tstrerror(winCode)); + T_LONG_JMP(pTaskInfo->env, winCode); } } else if (strcmp(pCtx[j].pExpr->pExpr->_function.functionName, "_select_value") == 0) { // do nothing From d02617aaf6c62b7110f34d9fc4f3ada702bb0d34 Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao> Date: Mon, 22 Jul 2024 14:42:50 +0800 Subject: [PATCH 11/11] adj operator result --- source/libs/executor/inc/tfill.h | 4 ++-- source/libs/executor/src/filloperator.c | 16 +++------------- source/libs/executor/src/tfill.c | 4 +--- 3 files changed, 6 insertions(+), 18 deletions(-) diff --git a/source/libs/executor/inc/tfill.h b/source/libs/executor/inc/tfill.h index 79837480d7..82d422302c 100644 --- a/source/libs/executor/inc/tfill.h +++ b/source/libs/executor/inc/tfill.h @@ -131,11 +131,11 @@ SFillInfo* taosCreateFillInfo(TSKEY skey, int32_t numOfFillCols, int32_t numOfNo int32_t order, const char* id); void* taosDestroyFillInfo(struct SFillInfo* pFillInfo); -int64_t taosFillResultDataBlock(struct SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity); +void taosFillResultDataBlock(struct SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity); int64_t getFillInfoStart(struct SFillInfo* pFillInfo); bool fillIfWindowPseudoColumn(SFillInfo* pFillInfo, SFillColInfo* pCol, SColumnInfoData* pDstColInfoData, - int32_t rowIndex); + int32_t rowIndex); #ifdef __cplusplus } #endif diff --git a/source/libs/executor/src/filloperator.c b/source/libs/executor/src/filloperator.c index cf31b5b7ad..79e2d4b7c9 100644 --- a/source/libs/executor/src/filloperator.c +++ b/source/libs/executor/src/filloperator.c @@ -85,12 +85,7 @@ static void doHandleRemainBlockForNewGroupImpl(SOperatorInfo* pOperator, SFillOp } int32_t numOfResultRows = pResultInfo->capacity - pResBlock->info.rows; - int32_t code = taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows); - if (code != TSDB_CODE_SUCCESS) { - qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - T_LONG_JMP(pTaskInfo->env, code); - } + taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows); pInfo->curGroupId = pInfo->existNewGroupBlock->info.id.groupId; pInfo->existNewGroupBlock = NULL; @@ -101,11 +96,7 @@ static void doHandleRemainBlockFromNewGroup(SOperatorInfo* pOperator, SFillOpera SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; if (taosFillHasMoreResults(pInfo->pFillInfo)) { int32_t numOfResultRows = pResultInfo->capacity - pInfo->pFinalRes->info.rows; - 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); - } + taosFillResultDataBlock(pInfo->pFillInfo, pInfo->pFinalRes, numOfResultRows); pInfo->pRes->info.id.groupId = pInfo->curGroupId; return; } @@ -278,8 +269,7 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) { } int32_t numOfResultRows = pOperator->resultInfo.capacity - pResBlock->info.rows; - code = taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows); - QUERY_CHECK_CODE(code, lino, _end); + taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows); // current group has no more result to return if (pResBlock->info.rows > 0) { diff --git a/source/libs/executor/src/tfill.c b/source/libs/executor/src/tfill.c index 2be8024aa8..5a8697d7b8 100644 --- a/source/libs/executor/src/tfill.c +++ b/source/libs/executor/src/tfill.c @@ -617,7 +617,7 @@ void taosGetLinearInterpolationVal(SPoint* point, int32_t outputType, SPoint* po SET_TYPED_DATA(point->val, outputType, r); } -int64_t taosFillResultDataBlock(SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity) { +void taosFillResultDataBlock(SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity) { int32_t remain = taosNumOfRemainRows(pFillInfo); int64_t numOfRes = getNumOfResultsAfterFillGap(pFillInfo, pFillInfo->end, capacity); @@ -635,8 +635,6 @@ int64_t taosFillResultDataBlock(SFillInfo* pFillInfo, SSDataBlock* p, int32_t ca ", current : % d, total : % d, %s", pFillInfo, pFillInfo->numOfRows, pFillInfo->index, pFillInfo->start, pFillInfo->end, pFillInfo->currentKey, pFillInfo->numOfCurrent, pFillInfo->numOfTotal, pFillInfo->id); - - return numOfRes; } int64_t getFillInfoStart(struct SFillInfo* pFillInfo) { return pFillInfo->start; }