From ffe2973ade468cef70cab78350ae6a9eaf8d92a5 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Fri, 19 Jul 2024 13:19:01 +0800 Subject: [PATCH 01/15] refactor return code --- source/dnode/vnode/src/inc/tsdb.h | 3 +- .../dnode/vnode/src/tsdb/tsdbReaderWriter.c | 8 +- source/dnode/vnode/src/tsdb/tsdbSnapInfo.c | 199 ++++++++++-------- source/dnode/vnode/src/tsdb/tsdbUtil.c | 83 +++++--- source/libs/sync/src/syncUtil.c | 16 +- 5 files changed, 175 insertions(+), 134 deletions(-) diff --git a/source/dnode/vnode/src/inc/tsdb.h b/source/dnode/vnode/src/inc/tsdb.h index 3d26104722..d496853cd5 100644 --- a/source/dnode/vnode/src/inc/tsdb.h +++ b/source/dnode/vnode/src/inc/tsdb.h @@ -226,7 +226,7 @@ void tMapDataGetItemByIdx(SMapData *pMapData, int32_t idx, void *pItem, int32 int32_t tMapDataSearch(SMapData *pMapData, void *pSearchItem, int32_t (*tGetItemFn)(uint8_t *, void *), int32_t (*tItemCmprFn)(const void *, const void *), void *pItem); int32_t tPutMapData(uint8_t *p, SMapData *pMapData); -int32_t tGetMapData(uint8_t *p, SMapData *pMapData); +int32_t tGetMapData(uint8_t *p, SMapData *pMapData, int32_t *decodedSize); int32_t tMapDataToArray(SMapData *pMapData, int32_t itemSize, int32_t (*tGetItemFn)(uint8_t *, void *), SArray **ppArray); // other @@ -706,7 +706,6 @@ typedef TARRAY2(STsdbFSetPartition *) STsdbFSetPartList; STsdbFSetPartList *tsdbFSetPartListCreate(); void tsdbFSetPartListDestroy(STsdbFSetPartList **ppList); -int32_t tSerializeTsdbFSetPartList(void *buf, int32_t bufLen, STsdbFSetPartList *pList); int32_t tDeserializeTsdbFSetPartList(void *buf, int32_t bufLen, STsdbFSetPartList *pList); int32_t tsdbFSetPartListToRangeDiff(STsdbFSetPartList *pList, TFileSetRangeArray **ppRanges); diff --git a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c index 932bf2d92c..dfc7dd8c7c 100644 --- a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c +++ b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c @@ -803,11 +803,9 @@ int32_t tsdbReadDataBlk(SDataFReader *pReader, SBlockIdx *pBlockIdx, SMapData *m if (code) goto _err; // decode - int64_t n = tGetMapData(pReader->aBuf[0], mDataBlk); - if (n < 0) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; - } + int32_t n; + code = tGetMapData(pReader->aBuf[0], mDataBlk, &n); + if (code) goto _err; ASSERT(n == size); return code; diff --git a/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c b/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c index bc7bf5449e..f515cd5352 100644 --- a/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c +++ b/source/dnode/vnode/src/tsdb/tsdbSnapInfo.c @@ -81,7 +81,7 @@ static int32_t tsdbFTypeToFRangeType(tsdb_ftype_t ftype) { static int32_t tsdbTFileSetToFSetPartition(STFileSet* fset, STsdbFSetPartition** ppSP) { STsdbFSetPartition* p = tsdbFSetPartitionCreate(); if (p == NULL) { - goto _err; + return terrno; } p->fid = fset->fid; @@ -134,10 +134,6 @@ static int32_t tsdbTFileSetToFSetPartition(STFileSet* fset, STsdbFSetPartition** } ppSP[0] = p; return 0; - -_err: - tsdbFSetPartitionClear(&p); - return -1; } // fset partition list @@ -160,9 +156,11 @@ void tsdbFSetPartListDestroy(STsdbFSetPartList** ppList) { } int32_t tsdbFSetPartListToRangeDiff(STsdbFSetPartList* pList, TFileSetRangeArray** ppRanges) { + int32_t code = 0; + TFileSetRangeArray* pDiff = taosMemoryCalloc(1, sizeof(TFileSetRangeArray)); if (pDiff == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; goto _err; } TARRAY2_INIT(pDiff); @@ -171,7 +169,7 @@ int32_t tsdbFSetPartListToRangeDiff(STsdbFSetPartList* pList, TFileSetRangeArray TARRAY2_FOREACH(pList, part) { STFileSetRange* r = taosMemoryCalloc(1, sizeof(STFileSetRange)); if (r == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; goto _err; } int64_t maxVerValid = -1; @@ -202,7 +200,7 @@ _err: if (pDiff) { tsdbTFileSetRangeArrayDestroy(&pDiff); } - return -1; + return code; } // serialization @@ -235,96 +233,103 @@ int32_t tTsdbFSetPartListDataLenCalc(STsdbFSetPartList* pList) { return datLen; } -int32_t tSerializeTsdbFSetPartList(void* buf, int32_t bufLen, STsdbFSetPartList* pList) { +static int32_t tSerializeTsdbFSetPartList(void* buf, int32_t bufLen, STsdbFSetPartList* pList, int32_t* encodeSize) { SEncoder encoder = {0}; + int8_t reserved8 = 0; + int16_t reserved16 = 0; + int64_t reserved64 = 0; + int8_t msgVer = TSDB_SNAP_MSG_VER; + int32_t len = TARRAY2_SIZE(pList); + int32_t code = 0; + tEncoderInit(&encoder, buf, bufLen); - - int8_t reserved8 = 0; - int16_t reserved16 = 0; - int64_t reserved64 = 0; - - int8_t msgVer = TSDB_SNAP_MSG_VER; - int32_t len = TARRAY2_SIZE(pList); - - if (tStartEncode(&encoder) < 0) goto _err; - if (tEncodeI8(&encoder, msgVer) < 0) goto _err; - if (tEncodeI32(&encoder, len) < 0) goto _err; + if ((code = tStartEncode(&encoder))) goto _exit; + if ((code = tEncodeI8(&encoder, msgVer))) goto _exit; + if ((code = tEncodeI32(&encoder, len))) goto _exit; for (int32_t u = 0; u < len; u++) { STsdbFSetPartition* p = TARRAY2_GET(pList, u); - if (tEncodeI64(&encoder, p->fid) < 0) goto _err; - if (tEncodeI8(&encoder, p->stat) < 0) goto _err; - if (tEncodeI8(&encoder, reserved8) < 0) goto _err; - if (tEncodeI16(&encoder, reserved16) < 0) goto _err; + if ((code = tEncodeI64(&encoder, p->fid))) goto _exit; + if ((code = tEncodeI8(&encoder, p->stat))) goto _exit; + if ((code = tEncodeI8(&encoder, reserved8))) goto _exit; + if ((code = tEncodeI16(&encoder, reserved16))) goto _exit; int32_t typMax = TSDB_FSET_RANGE_TYP_MAX; - if (tEncodeI32(&encoder, typMax) < 0) goto _err; + if ((code = tEncodeI32(&encoder, typMax))) goto _exit; for (int32_t i = 0; i < typMax; i++) { SVerRangeList* iList = &p->verRanges[i]; int32_t iLen = TARRAY2_SIZE(iList); - if (tEncodeI32(&encoder, iLen) < 0) goto _err; + if ((code = tEncodeI32(&encoder, iLen))) goto _exit; for (int32_t j = 0; j < iLen; j++) { SVersionRange r = TARRAY2_GET(iList, j); - if (tEncodeI64(&encoder, r.minVer) < 0) goto _err; - if (tEncodeI64(&encoder, r.maxVer) < 0) goto _err; - if (tEncodeI64(&encoder, reserved64) < 0) goto _err; + if ((code = tEncodeI64(&encoder, r.minVer))) goto _exit; + if ((code = tEncodeI64(&encoder, r.maxVer))) goto _exit; + if ((code = tEncodeI64(&encoder, reserved64))) goto _exit; } } } tEndEncode(&encoder); - int32_t tlen = encoder.pos; - tEncoderClear(&encoder); - return tlen; -_err: + if (encodeSize) { + encodeSize[0] = encoder.pos; + } + +_exit: tEncoderClear(&encoder); - return -1; + return code; } int32_t tDeserializeTsdbFSetPartList(void* buf, int32_t bufLen, STsdbFSetPartList* pList) { SDecoder decoder = {0}; - tDecoderInit(&decoder, buf, bufLen); - - int8_t reserved8 = 0; - int16_t reserved16 = 0; - int64_t reserved64 = 0; + int8_t reserved8 = 0; + int16_t reserved16 = 0; + int64_t reserved64 = 0; + int32_t code = 0; STsdbFSetPartition* p = NULL; + tDecoderInit(&decoder, buf, bufLen); int8_t msgVer = 0; int32_t len = 0; - if (tStartDecode(&decoder) < 0) goto _err; - if (tDecodeI8(&decoder, &msgVer) < 0) goto _err; - if (msgVer != TSDB_SNAP_MSG_VER) goto _err; - if (tDecodeI32(&decoder, &len) < 0) goto _err; + if ((code = tStartDecode(&decoder))) goto _err; + if ((code = tDecodeI8(&decoder, &msgVer))) goto _err; + if (msgVer != TSDB_SNAP_MSG_VER) { + code = TSDB_CODE_INVALID_MSG; + goto _err; + } + if ((code = tDecodeI32(&decoder, &len))) goto _err; for (int32_t u = 0; u < len; u++) { p = tsdbFSetPartitionCreate(); - if (p == NULL) goto _err; - if (tDecodeI64(&decoder, &p->fid) < 0) goto _err; - if (tDecodeI8(&decoder, &p->stat) < 0) goto _err; - if (tDecodeI8(&decoder, &reserved8) < 0) goto _err; - if (tDecodeI16(&decoder, &reserved16) < 0) goto _err; + if (p == NULL) { + code = terrno; + goto _err; + } + + if ((code = tDecodeI64(&decoder, &p->fid))) goto _err; + if ((code = tDecodeI8(&decoder, &p->stat))) goto _err; + if ((code = tDecodeI8(&decoder, &reserved8))) goto _err; + if ((code = tDecodeI16(&decoder, &reserved16))) goto _err; int32_t typMax = 0; - if (tDecodeI32(&decoder, &typMax) < 0) goto _err; + if ((code = tDecodeI32(&decoder, &typMax))) goto _err; for (int32_t i = 0; i < typMax; i++) { SVerRangeList* iList = &p->verRanges[i]; int32_t iLen = 0; - if (tDecodeI32(&decoder, &iLen) < 0) goto _err; + if ((code = tDecodeI32(&decoder, &iLen))) goto _err; for (int32_t j = 0; j < iLen; j++) { SVersionRange r = {0}; - if (tDecodeI64(&decoder, &r.minVer) < 0) goto _err; - if (tDecodeI64(&decoder, &r.maxVer) < 0) goto _err; - if (tDecodeI64(&decoder, &reserved64) < 0) goto _err; - if (TARRAY2_APPEND(iList, r)) goto _err; + if ((code = tDecodeI64(&decoder, &r.minVer))) goto _err; + if ((code = tDecodeI64(&decoder, &r.maxVer))) goto _err; + if ((code = tDecodeI64(&decoder, &reserved64))) goto _err; + if ((code = TARRAY2_APPEND(iList, r))) goto _err; } } - if (TARRAY2_APPEND(pList, p)) goto _err; + if ((code = TARRAY2_APPEND(pList, p))) goto _err; p = NULL; } @@ -337,7 +342,7 @@ _err: tsdbFSetPartitionClear(&p); } tDecoderClear(&decoder); - return -1; + return code; } // fs state @@ -352,8 +357,9 @@ static STsdbFSetPartList* tsdbSnapGetFSetPartList(STFileSystem* fs) { STFileSet* fset; TARRAY2_FOREACH(fs->fSetArr, fset) { STsdbFSetPartition* pItem = NULL; - if (tsdbTFileSetToFSetPartition(fset, &pItem) < 0) { - code = -1; + code = tsdbTFileSetToFSetPartition(fset, &pItem); + if (code) { + terrno = code; break; } ASSERT(pItem != NULL); @@ -404,7 +410,9 @@ static int32_t tsdbPartitionInfoInit(SVnode* pVnode, STsdbPartitionInfo* pInfo) for (int32_t j = 0; j < pInfo->tsdbMaxCnt; ++j) { STsdb* pTsdb = SMA_RSMA_GET_TSDB(pVnode, j); pInfo->pLists[j] = tsdbSnapGetFSetPartList(pTsdb->pFS); - if (pInfo->pLists[j] == NULL) return -1; + if (pInfo->pLists[j] == NULL) { + return terrno; + } } return 0; } @@ -432,9 +440,10 @@ static int32_t tsdbPartitionInfoSerialize(STsdbPartitionInfo* pInfo, uint8_t* bu SSyncTLV* pSubHead = (void*)((char*)buf + offset); int32_t valOffset = offset + sizeof(*pSubHead); ASSERT(pSubHead->val == (char*)buf + valOffset); - if ((tlen = tSerializeTsdbFSetPartList(pSubHead->val, bufLen - valOffset, pInfo->pLists[j])) < 0) { + int32_t code = tSerializeTsdbFSetPartList(pSubHead->val, bufLen - valOffset, pInfo->pLists[j], &tlen); + if (code) { tsdbError("vgId:%d, failed to serialize fset partition list of tsdb %d since %s", pInfo->vgId, j, terrstr()); - return -1; + return code; } pSubHead->typ = pInfo->subTyps[j]; pSubHead->len = tlen; @@ -460,17 +469,18 @@ static int32_t tTsdbRepOptsDataLenCalc(STsdbRepOpts* pInfo) { } int32_t tSerializeTsdbRepOpts(void* buf, int32_t bufLen, STsdbRepOpts* pOpts) { + int32_t code = 0; SEncoder encoder = {0}; + int64_t reserved64 = 0; + int8_t msgVer = TSDB_SNAP_MSG_VER; + tEncoderInit(&encoder, buf, bufLen); - int64_t reserved64 = 0; - int8_t msgVer = TSDB_SNAP_MSG_VER; - - if (tStartEncode(&encoder) < 0) goto _err; - if (tEncodeI8(&encoder, msgVer) < 0) goto _err; + if ((code = tStartEncode(&encoder))) goto _err; + if ((code = tEncodeI8(&encoder, msgVer))) goto _err; int16_t format = pOpts->format; - if (tEncodeI16(&encoder, format) < 0) goto _err; - if (tEncodeI64(&encoder, reserved64) < 0) goto _err; + if ((code = tEncodeI16(&encoder, format))) goto _err; + if ((code = tEncodeI64(&encoder, reserved64))) goto _err; tEndEncode(&encoder); int32_t tlen = encoder.pos; @@ -479,23 +489,24 @@ int32_t tSerializeTsdbRepOpts(void* buf, int32_t bufLen, STsdbRepOpts* pOpts) { _err: tEncoderClear(&encoder); - return -1; + return code; } int32_t tDeserializeTsdbRepOpts(void* buf, int32_t bufLen, STsdbRepOpts* pOpts) { + int32_t code; SDecoder decoder = {0}; + int64_t reserved64 = 0; + int8_t msgVer = 0; + tDecoderInit(&decoder, buf, bufLen); - int64_t reserved64 = 0; - int8_t msgVer = 0; - - if (tStartDecode(&decoder) < 0) goto _err; - if (tDecodeI8(&decoder, &msgVer) < 0) goto _err; + if ((code = tStartDecode(&decoder))) goto _err; + if ((code = tDecodeI8(&decoder, &msgVer))) goto _err; if (msgVer != TSDB_SNAP_MSG_VER) goto _err; int16_t format = 0; - if (tDecodeI16(&decoder, &format) < 0) goto _err; + if ((code = tDecodeI16(&decoder, &format))) goto _err; pOpts->format = format; - if (tDecodeI64(&decoder, &reserved64) < 0) goto _err; + if ((code = tDecodeI64(&decoder, &reserved64))) goto _err; tEndDecode(&decoder); tDecoderClear(&decoder); @@ -503,7 +514,7 @@ int32_t tDeserializeTsdbRepOpts(void* buf, int32_t bufLen, STsdbRepOpts* pOpts) _err: tDecoderClear(&decoder); - return -1; + return code; } static int32_t tsdbRepOptsEstSize(STsdbRepOpts* pOpts) { @@ -518,7 +529,7 @@ static int32_t tsdbRepOptsSerialize(STsdbRepOpts* pOpts, void* buf, int32_t bufL int32_t offset = 0; int32_t tlen = 0; if ((tlen = tSerializeTsdbRepOpts(pSubHead->val, bufLen, pOpts)) < 0) { - return -1; + return tlen; } pSubHead->typ = SNAP_DATA_RAW; pSubHead->len = tlen; @@ -528,8 +539,10 @@ static int32_t tsdbRepOptsSerialize(STsdbRepOpts* pOpts, void* buf, int32_t bufL // snap info static int32_t tsdbSnapPrepDealWithSnapInfo(SVnode* pVnode, SSnapshot* pSnap, STsdbRepOpts* pInfo) { - if (!pSnap->data) return 0; - int32_t code = -1; + if (!pSnap->data) { + return 0; + } + int32_t code = 0; SSyncTLV* pHead = (void*)pSnap->data; int32_t offset = 0; @@ -546,30 +559,30 @@ static int32_t tsdbSnapPrepDealWithSnapInfo(SVnode* pVnode, SSnapshot* pSnap, ST case SNAP_DATA_RSMA2: { } break; case SNAP_DATA_RAW: { - if (tDeserializeTsdbRepOpts(buf, bufLen, pInfo) < 0) { - terrno = TSDB_CODE_INVALID_DATA_FMT; + code = tDeserializeTsdbRepOpts(buf, bufLen, pInfo); + if (code < 0) { tsdbError("vgId:%d, failed to deserialize tsdb rep opts since %s", TD_VID(pVnode), terrstr()); - goto _out; + return code; } } break; default: + code = TSDB_CODE_INVALID_MSG; tsdbError("vgId:%d, unexpected subfield type of snap info. typ:%d", TD_VID(pVnode), pField->typ); - goto _out; + return code; } } - code = 0; -_out: return code; } int32_t tsdbSnapPrepDescription(SVnode* pVnode, SSnapshot* pSnap) { ASSERT(pSnap->type == TDMT_SYNC_PREP_SNAPSHOT || pSnap->type == TDMT_SYNC_PREP_SNAPSHOT_REPLY); STsdbPartitionInfo partitionInfo = {0}; - int code = -1; + int code = 0; STsdbPartitionInfo* pInfo = &partitionInfo; - if (tsdbPartitionInfoInit(pVnode, pInfo) != 0) { + code = tsdbPartitionInfoInit(pVnode, pInfo); + if (code) { goto _out; } @@ -577,7 +590,7 @@ int32_t tsdbSnapPrepDescription(SVnode* pVnode, SSnapshot* pSnap) { STsdbRepOpts opts = {.format = TSDB_SNAP_REP_FMT_RAW}; if (pSnap->type == TDMT_SYNC_PREP_SNAPSHOT_REPLY) { STsdbRepOpts leaderOpts = {0}; - if (tsdbSnapPrepDealWithSnapInfo(pVnode, pSnap, &leaderOpts) < 0) { + if ((code = tsdbSnapPrepDealWithSnapInfo(pVnode, pSnap, &leaderOpts)) < 0) { tsdbError("vgId:%d, failed to deal with snap info for reply since %s", TD_VID(pVnode), terrstr()); goto _out; } @@ -589,7 +602,7 @@ int32_t tsdbSnapPrepDescription(SVnode* pVnode, SSnapshot* pSnap) { int32_t bufLen = headLen; bufLen += tsdbPartitionInfoEstSize(pInfo); bufLen += tsdbRepOptsEstSize(&opts); - if (syncSnapInfoDataRealloc(pSnap, bufLen) != 0) { + if ((code = syncSnapInfoDataRealloc(pSnap, bufLen)) != 0) { tsdbError("vgId:%d, failed to realloc memory for data of snap info. bytes:%d", TD_VID(pVnode), bufLen); goto _out; } @@ -599,7 +612,8 @@ int32_t tsdbSnapPrepDescription(SVnode* pVnode, SSnapshot* pSnap) { int32_t offset = headLen; int32_t tlen = 0; - if ((tlen = tsdbPartitionInfoSerialize(pInfo, buf + offset, bufLen - offset)) < 0) { + if ((tlen = tsdbPartitionInfoSerialize(pInfo, (uint8_t*)(buf + offset), bufLen - offset)) < 0) { + code = tlen; tsdbError("vgId:%d, failed to serialize tsdb partition info since %s", TD_VID(pVnode), terrstr()); goto _out; } @@ -607,6 +621,7 @@ int32_t tsdbSnapPrepDescription(SVnode* pVnode, SSnapshot* pSnap) { ASSERT(offset <= bufLen); if ((tlen = tsdbRepOptsSerialize(&opts, buf + offset, bufLen - offset)) < 0) { + code = tlen; tsdbError("vgId:%d, failed to serialize tsdb rep opts since %s", TD_VID(pVnode), terrstr()); goto _out; } @@ -620,7 +635,7 @@ int32_t tsdbSnapPrepDescription(SVnode* pVnode, SSnapshot* pSnap) { tsdbInfo("vgId:%d, tsdb snap info prepared. type:%s, val length:%d", TD_VID(pVnode), TMSG_INFO(pHead->typ), pHead->len); - code = 0; + _out: tsdbPartitionInfoClear(pInfo); return code; diff --git a/source/dnode/vnode/src/tsdb/tsdbUtil.c b/source/dnode/vnode/src/tsdb/tsdbUtil.c index 58075cf0ac..66db7baab9 100644 --- a/source/dnode/vnode/src/tsdb/tsdbUtil.c +++ b/source/dnode/vnode/src/tsdb/tsdbUtil.c @@ -152,7 +152,7 @@ int32_t tPutMapData(uint8_t *p, SMapData *pMapData) { } #endif -int32_t tGetMapData(uint8_t *p, SMapData *pMapData) { +int32_t tGetMapData(uint8_t *p, SMapData *pMapData, int32_t *decodedSize) { int32_t n = 0; int32_t offset; @@ -160,7 +160,9 @@ int32_t tGetMapData(uint8_t *p, SMapData *pMapData) { n += tGetI32v(p + n, &pMapData->nItem); if (pMapData->nItem) { - if (tRealloc((uint8_t **)&pMapData->aOffset, sizeof(int32_t) * pMapData->nItem)) return -1; + if (tRealloc((uint8_t **)&pMapData->aOffset, sizeof(int32_t) * pMapData->nItem)) { + return TSDB_CODE_OUT_OF_MEMORY; + } int32_t lOffset = 0; for (int32_t iItem = 0; iItem < pMapData->nItem; iItem++) { @@ -170,12 +172,18 @@ int32_t tGetMapData(uint8_t *p, SMapData *pMapData) { } n += tGetI32v(p + n, &pMapData->nData); - if (tRealloc(&pMapData->pData, pMapData->nData)) return -1; + if (tRealloc(&pMapData->pData, pMapData->nData)) { + return TSDB_CODE_OUT_OF_MEMORY; + } memcpy(pMapData->pData, p + n, pMapData->nData); n += pMapData->nData; } - return n; + if (decodedSize) { + *decodedSize = n; + } + + return 0; } #ifdef BUILD_NO_CALL @@ -680,20 +688,17 @@ int32_t tsdbRowCompareWithoutVersion(const void *p1, const void *p2) { // STSDBRowIter ====================================================== int32_t tsdbRowIterOpen(STSDBRowIter *pIter, TSDBROW *pRow, STSchema *pTSchema) { - int32_t code = 0; - pIter->pRow = pRow; if (pRow->type == TSDBROW_ROW_FMT) { - code = tRowIterOpen(pRow->pTSRow, pTSchema, &pIter->pIter); - if (code) goto _exit; + int32_t code = tRowIterOpen(pRow->pTSRow, pTSchema, &pIter->pIter); + if (code) return code; } else if (pRow->type == TSDBROW_COL_FMT) { pIter->iColData = 0; } else { ASSERT(0); } -_exit: - return code; + return 0; } void tsdbRowClose(STSDBRowIter *pIter) { @@ -760,7 +765,9 @@ int32_t tsdbRowMergerAdd(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema) --iCol; continue; } else if (pTSchema->columns[jCol].colId > pTColumn->colId) { - taosArrayPush(pMerger->pArray, &COL_VAL_NONE(pTColumn->colId, pTColumn->type)); + if (taosArrayPush(pMerger->pArray, &COL_VAL_NONE(pTColumn->colId, pTColumn->type)) == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } continue; } @@ -780,14 +787,15 @@ int32_t tsdbRowMergerAdd(SRowMerger *pMerger, TSDBROW *pRow, STSchema *pTSchema) } if (taosArrayPush(pMerger->pArray, pColVal) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - return code; + return TSDB_CODE_OUT_OF_MEMORY; } } for (; iCol < pMerger->pTSchema->numOfCols; ++iCol) { pTColumn = &pMerger->pTSchema->columns[iCol]; - taosArrayPush(pMerger->pArray, &COL_VAL_NONE(pTColumn->colId, pTColumn->type)); + if (taosArrayPush(pMerger->pArray, &COL_VAL_NONE(pTColumn->colId, pTColumn->type)) == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } } pMerger->version = key.version; @@ -962,8 +970,7 @@ _exit: */ // delete skyline ====================================================== -static int32_t tsdbMergeSkyline(SArray *pSkyline1, SArray *pSkyline2, SArray *pSkyline) { - int32_t code = 0; +static void tsdbMergeSkyline(SArray *pSkyline1, SArray *pSkyline2, SArray *pSkyline) { int32_t i1 = 0; int32_t n1 = taosArrayGetSize(pSkyline1); int32_t i2 = 0; @@ -1017,7 +1024,6 @@ static int32_t tsdbMergeSkyline(SArray *pSkyline1, SArray *pSkyline2, SArray *pS } pSkyline->size = TARRAY_ELEM_IDX(pSkyline, pItem); - return code; } int32_t tsdbBuildDeleteSkylineImpl(SArray *aSkyline, int32_t sidx, int32_t eidx, SArray *pSkyline) { @@ -1029,8 +1035,13 @@ int32_t tsdbBuildDeleteSkylineImpl(SArray *aSkyline, int32_t sidx, int32_t eidx, if (sidx == eidx) { TSDBKEY *pItem1 = taosArrayGet(aSkyline, sidx * 2); TSDBKEY *pItem2 = taosArrayGet(aSkyline, sidx * 2 + 1); - taosArrayPush(pSkyline, &pItem1); - taosArrayPush(pSkyline, &pItem2); + if (taosArrayPush(pSkyline, &pItem1) == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + if (taosArrayPush(pSkyline, &pItem2) == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } } else { SArray *pSkyline1 = NULL; SArray *pSkyline2 = NULL; @@ -1049,7 +1060,7 @@ int32_t tsdbBuildDeleteSkylineImpl(SArray *aSkyline, int32_t sidx, int32_t eidx, code = tsdbBuildDeleteSkylineImpl(aSkyline, midx + 1, eidx, pSkyline2); if (code) goto _clear; - code = tsdbMergeSkyline(pSkyline1, pSkyline2, pSkyline); + tsdbMergeSkyline(pSkyline1, pSkyline2, pSkyline); _clear: taosArrayDestroy(pSkyline1); @@ -1064,13 +1075,28 @@ int32_t tsdbBuildDeleteSkyline(SArray *aDelData, int32_t sidx, int32_t eidx, SAr int32_t code = 0; int32_t dataNum = eidx - sidx + 1; SArray *aTmpSkyline = taosArrayInit(dataNum * 2, sizeof(TSDBKEY)); - SArray *pSkyline = taosArrayInit(dataNum * 2, POINTER_BYTES); + if (aTmpSkyline == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + + SArray *pSkyline = taosArrayInit(dataNum * 2, POINTER_BYTES); + if (pSkyline == NULL) { + taosArrayDestroy(aTmpSkyline); + return TSDB_CODE_OUT_OF_MEMORY; + } taosArrayClear(aSkyline); for (int32_t i = sidx; i <= eidx; ++i) { pDelData = (SDelData *)taosArrayGet(aDelData, i); - taosArrayPush(aTmpSkyline, &(TSDBKEY){.ts = pDelData->sKey, .version = pDelData->version}); - taosArrayPush(aTmpSkyline, &(TSDBKEY){.ts = pDelData->eKey, .version = 0}); + if (taosArrayPush(aTmpSkyline, &(TSDBKEY){.ts = pDelData->sKey, .version = pDelData->version}) == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _clear; + } + + if (taosArrayPush(aTmpSkyline, &(TSDBKEY){.ts = pDelData->eKey, .version = 0}) == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _clear; + } } code = tsdbBuildDeleteSkylineImpl(aTmpSkyline, sidx, eidx, pSkyline); @@ -1079,7 +1105,10 @@ int32_t tsdbBuildDeleteSkyline(SArray *aDelData, int32_t sidx, int32_t eidx, SAr int32_t skylineNum = taosArrayGetSize(pSkyline); for (int32_t i = 0; i < skylineNum; ++i) { TSDBKEY *p = taosArrayGetP(pSkyline, i); - taosArrayPush(aSkyline, p); + if (taosArrayPush(aSkyline, p) == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _clear; + } } _clear: @@ -1519,8 +1548,8 @@ int32_t tBlockDataDecompress(SBufferReader *br, SBlockData *blockData, SBuffer * SBlockCol blockCol; code = tGetBlockCol(&br2, &blockCol, hdr.fmtVer, hdr.cmprAlg); - if (blockCol.alg == 0) blockCol.alg = hdr.cmprAlg; TSDB_CHECK_CODE(code, lino, _exit); + if (blockCol.alg == 0) blockCol.alg = hdr.cmprAlg; code = tBlockDataDecompressColData(&hdr, &blockCol, br, blockData, assist); TSDB_CHECK_CODE(code, lino, _exit); } @@ -1812,7 +1841,9 @@ int32_t tsdbGetColCmprAlgFromSet(SHashObj *set, int16_t colId, uint32_t *alg) { if (set == NULL) return -1; uint32_t *ret = taosHashGet(set, &colId, sizeof(colId)); - if (ret == NULL) return -1; + if (ret == NULL) { + return TSDB_CODE_NOT_FOUND; + } *alg = *ret; return 0; diff --git a/source/libs/sync/src/syncUtil.c b/source/libs/sync/src/syncUtil.c index 93a06ddf30..66b7938440 100644 --- a/source/libs/sync/src/syncUtil.c +++ b/source/libs/sync/src/syncUtil.c @@ -43,17 +43,16 @@ void syncUtilNodeInfo2EpSet(const SNodeInfo* pInfo, SEpSet* pEpSet) { bool syncUtilNodeInfo2RaftId(const SNodeInfo* pInfo, SyncGroupId vgId, SRaftId* raftId) { uint32_t ipv4 = 0xFFFFFFFF; - sDebug("vgId:%d, start to resolve sync addr fqdn in %d seconds, " - "dnode:%d cluster:%" PRId64 " fqdn:%s port:%u ", - vgId, tsResolveFQDNRetryTime, - pInfo->nodeId, pInfo->clusterId, pInfo->nodeFqdn, pInfo->nodePort); - for(int i = 0; i < tsResolveFQDNRetryTime; i++){ + sDebug( + "vgId:%d, start to resolve sync addr fqdn in %d seconds, " + "dnode:%d cluster:%" PRId64 " fqdn:%s port:%u ", + vgId, tsResolveFQDNRetryTime, pInfo->nodeId, pInfo->clusterId, pInfo->nodeFqdn, pInfo->nodePort); + for (int i = 0; i < tsResolveFQDNRetryTime; i++) { ipv4 = taosGetIpv4FromFqdn(pInfo->nodeFqdn); if (ipv4 == 0xFFFFFFFF || ipv4 == 1) { sError("failed to resolve ipv4 addr, fqdn:%s, wait one second", pInfo->nodeFqdn); taosSsleep(1); - } - else{ + } else { break; } } @@ -501,8 +500,7 @@ void syncLogSendRequestVoteReply(SSyncNode* pSyncNode, const SyncRequestVoteRepl int32_t syncSnapInfoDataRealloc(SSnapshot* pSnap, int32_t size) { void* data = taosMemoryRealloc(pSnap->data, size); if (data == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return -1; + return terrno = TSDB_CODE_OUT_OF_MEMORY; } pSnap->data = data; return 0; From 5734fe8778f8e7070c1cba44ccccb0af4d5ceb26 Mon Sep 17 00:00:00 2001 From: Hongze Cheng Date: Fri, 19 Jul 2024 16:07:09 +0800 Subject: [PATCH 02/15] fix compile error --- source/dnode/vnode/src/tsdb/tsdbReaderWriter.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c index 16bacf90b3..28abed1ce7 100644 --- a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c +++ b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c @@ -759,7 +759,7 @@ int32_t tsdbReadDataBlk(SDataFReader *pReader, SBlockIdx *pBlockIdx, SMapData *m // decode int32_t n; code = tGetMapData(pReader->aBuf[0], mDataBlk, &n); - if (code) goto _err; + if (code) goto _exit; ASSERT(n == size); _exit: From 862a40afa01a5ed814e9c308e2c1a98c7d0bd274 Mon Sep 17 00:00:00 2001 From: wangmm0220 Date: Mon, 22 Jul 2024 17:30:49 +0800 Subject: [PATCH 03/15] fix:[TD-31017]process return value in mnode for tmq --- include/common/tmsg.h | 15 +- include/util/tdef.h | 3 +- source/client/src/clientTmq.c | 18 +- source/common/src/tmsg.c | 14 +- source/dnode/mnode/impl/inc/mndConsumer.h | 22 +- source/dnode/mnode/impl/inc/mndDef.h | 7 +- source/dnode/mnode/impl/inc/mndSubscribe.h | 5 +- source/dnode/mnode/impl/inc/mndTopic.h | 5 +- source/dnode/mnode/impl/src/mndConsumer.c | 507 ++++++-------- source/dnode/mnode/impl/src/mndDb.c | 3 - source/dnode/mnode/impl/src/mndDef.c | 74 +- source/dnode/mnode/impl/src/mndScheduler.c | 49 +- source/dnode/mnode/impl/src/mndSubscribe.c | 760 ++++++++++----------- source/dnode/mnode/impl/src/mndTopic.c | 462 +++++-------- source/dnode/mnode/impl/src/mndUser.c | 18 +- source/dnode/mnode/impl/src/mndVgroup.c | 9 - 16 files changed, 892 insertions(+), 1079 deletions(-) diff --git a/include/common/tmsg.h b/include/common/tmsg.h index a5dea8a44e..e9cde9e99b 100644 --- a/include/common/tmsg.h +++ b/include/common/tmsg.h @@ -2828,19 +2828,24 @@ static FORCE_INLINE int32_t tSerializeSCMSubscribeReq(void** buf, const SCMSubsc return tlen; } -static FORCE_INLINE void* tDeserializeSCMSubscribeReq(void* buf, SCMSubscribeReq* pReq) { +static FORCE_INLINE int32_t tDeserializeSCMSubscribeReq(void* buf, SCMSubscribeReq* pReq) { buf = taosDecodeFixedI64(buf, &pReq->consumerId); buf = taosDecodeStringTo(buf, pReq->cgroup); buf = taosDecodeStringTo(buf, pReq->clientId); - int32_t topicNum; + int32_t topicNum = 0; buf = taosDecodeFixedI32(buf, &topicNum); pReq->topicNames = taosArrayInit(topicNum, sizeof(void*)); + if (pReq->topicNames == NULL){ + return TSDB_CODE_OUT_OF_MEMORY; + } for (int32_t i = 0; i < topicNum; i++) { - char* name; + char* name = NULL; buf = taosDecodeString(buf, &name); - taosArrayPush(pReq->topicNames, &name); + if (taosArrayPush(pReq->topicNames, &name) == NULL){ + return TSDB_CODE_OUT_OF_MEMORY; + } } buf = taosDecodeFixedI8(buf, &pReq->withTbName); @@ -2849,7 +2854,7 @@ static FORCE_INLINE void* tDeserializeSCMSubscribeReq(void* buf, SCMSubscribeReq buf = taosDecodeFixedI8(buf, &pReq->resetOffsetCfg); buf = taosDecodeFixedI8(buf, &pReq->enableReplay); buf = taosDecodeFixedI8(buf, &pReq->enableBatchMeta); - return buf; + return 0; } typedef struct { diff --git a/include/util/tdef.h b/include/util/tdef.h index 9c2858ed30..53bb8a493c 100644 --- a/include/util/tdef.h +++ b/include/util/tdef.h @@ -556,7 +556,8 @@ typedef struct { char name[TSDB_LOG_VAR_LEN]; } SLogVar; -#define TMQ_SEPARATOR ':' +#define TMQ_SEPARATOR ":" +#define TMQ_SEPARATOR_CHAR ':' enum { SND_WORKER_TYPE__SHARED = 1, diff --git a/source/client/src/clientTmq.c b/source/client/src/clientTmq.c index c363686343..09fbed4ba4 100644 --- a/source/client/src/clientTmq.c +++ b/source/client/src/clientTmq.c @@ -456,11 +456,7 @@ static int32_t doSendCommitMsg(tmq_t* tmq, int32_t vgId, SEpSet* epSet, STqOffse pOffset.consumerId = tmq->consumerId; pOffset.offset.val = *offset; - int32_t groupLen = strlen(tmq->groupId); - memcpy(pOffset.offset.subKey, tmq->groupId, groupLen); - pOffset.offset.subKey[groupLen] = TMQ_SEPARATOR; - strcpy(pOffset.offset.subKey + groupLen + 1, pTopicName); - + (void)snprintf(pOffset.offset.subKey, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", tmq->groupId, TMQ_SEPARATOR, pTopicName); int32_t len = 0; int32_t code = 0; tEncodeSize(tEncodeMqVgOffset, &pOffset, len, code); @@ -1667,11 +1663,7 @@ static bool doUpdateLocalEp(tmq_t* tmq, int32_t epoch, const SMqAskEpRsp* pRsp) } void tmqBuildConsumeReqImpl(SMqPollReq* pReq, tmq_t* tmq, int64_t timeout, SMqClientTopic* pTopic, SMqClientVg* pVg) { - int32_t groupLen = strlen(tmq->groupId); - memcpy(pReq->subKey, tmq->groupId, groupLen); - pReq->subKey[groupLen] = TMQ_SEPARATOR; - strcpy(pReq->subKey + groupLen + 1, pTopic->topicName); - + (void)snprintf(pReq->subKey, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", tmq->groupId, TMQ_SEPARATOR, pTopic->topicName); pReq->withTbName = tmq->withTbName; pReq->consumerId = tmq->consumerId; pReq->timeout = timeout; @@ -2902,11 +2894,7 @@ int64_t getCommittedFromServer(tmq_t* tmq, char* tname, int32_t vgId, SEpSet* ep SMqVgOffset pOffset = {0}; pOffset.consumerId = tmq->consumerId; - - int32_t groupLen = strlen(tmq->groupId); - memcpy(pOffset.offset.subKey, tmq->groupId, groupLen); - pOffset.offset.subKey[groupLen] = TMQ_SEPARATOR; - strcpy(pOffset.offset.subKey + groupLen + 1, tname); + (void)snprintf(pOffset.offset.subKey, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", tmq->groupId, TMQ_SEPARATOR, tname); int32_t len = 0; tEncodeSize(tEncodeMqVgOffset, &pOffset, len, code); diff --git a/source/common/src/tmsg.c b/source/common/src/tmsg.c index 9efff055bf..a15afa64db 100644 --- a/source/common/src/tmsg.c +++ b/source/common/src/tmsg.c @@ -9197,23 +9197,23 @@ int32_t tDecodeSTqOffsetVal(SDecoder *pDecoder, STqOffsetVal *pOffsetVal) { int32_t tFormatOffset(char *buf, int32_t maxLen, const STqOffsetVal *pVal) { if (pVal->type == TMQ_OFFSET__RESET_NONE) { - snprintf(buf, maxLen, "none"); + (void)snprintf(buf, maxLen, "none"); } else if (pVal->type == TMQ_OFFSET__RESET_EARLIEST) { - snprintf(buf, maxLen, "earliest"); + (void)snprintf(buf, maxLen, "earliest"); } else if (pVal->type == TMQ_OFFSET__RESET_LATEST) { - snprintf(buf, maxLen, "latest"); + (void)snprintf(buf, maxLen, "latest"); } else if (pVal->type == TMQ_OFFSET__LOG) { - snprintf(buf, maxLen, "wal:%" PRId64, pVal->version); + (void)snprintf(buf, maxLen, "wal:%" PRId64, pVal->version); } else if (pVal->type == TMQ_OFFSET__SNAPSHOT_DATA || pVal->type == TMQ_OFFSET__SNAPSHOT_META) { if (IS_VAR_DATA_TYPE(pVal->primaryKey.type)) { char *tmp = taosMemoryCalloc(1, pVal->primaryKey.nData + 1); if (tmp == NULL) return TSDB_CODE_OUT_OF_MEMORY; - memcpy(tmp, pVal->primaryKey.pData, pVal->primaryKey.nData); - snprintf(buf, maxLen, "tsdb:%" PRId64 "|%" PRId64 ",pk type:%d,val:%s", pVal->uid, pVal->ts, + (void)memcpy(tmp, pVal->primaryKey.pData, pVal->primaryKey.nData); + (void)snprintf(buf, maxLen, "tsdb:%" PRId64 "|%" PRId64 ",pk type:%d,val:%s", pVal->uid, pVal->ts, pVal->primaryKey.type, tmp); taosMemoryFree(tmp); } else { - snprintf(buf, maxLen, "tsdb:%" PRId64 "|%" PRId64 ",pk type:%d,val:%" PRId64, pVal->uid, pVal->ts, + (void)snprintf(buf, maxLen, "tsdb:%" PRId64 "|%" PRId64 ",pk type:%d,val:%" PRId64, pVal->uid, pVal->ts, pVal->primaryKey.type, pVal->primaryKey.val); } } else { diff --git a/source/dnode/mnode/impl/inc/mndConsumer.h b/source/dnode/mnode/impl/inc/mndConsumer.h index 5184ad0eca..e1a790867e 100644 --- a/source/dnode/mnode/impl/inc/mndConsumer.h +++ b/source/dnode/mnode/impl/inc/mndConsumer.h @@ -30,10 +30,10 @@ enum { int32_t mndInitConsumer(SMnode *pMnode); void mndCleanupConsumer(SMnode *pMnode); -void mndSendConsumerMsg(SMnode *pMnode, int64_t consumerId, uint16_t msgType, SRpcHandleInfo* info); +int32_t mndSendConsumerMsg(SMnode *pMnode, int64_t consumerId, uint16_t msgType, SRpcHandleInfo* info); -SMqConsumerObj *mndAcquireConsumer(SMnode *pMnode, int64_t consumerId); -void mndReleaseConsumer(SMnode *pMnode, SMqConsumerObj *pConsumer); +int32_t mndAcquireConsumer(SMnode *pMnode, int64_t consumerId, SMqConsumerObj** pConsumer); +void mndReleaseConsumer(SMnode *pMnode, SMqConsumerObj *pConsumer); SSdbRaw *mndConsumerActionEncode(SMqConsumerObj *pConsumer); SSdbRow *mndConsumerActionDecode(SSdbRaw *pRaw); @@ -43,6 +43,22 @@ int32_t mndSetConsumerDropLogs(STrans *pTrans, SMqConsumerObj *pConsumer); const char *mndConsumerStatusName(int status); +#define MND_TMQ_NULL_CHECK(c) \ + do { \ + if (c == NULL) { \ + code = TSDB_CODE_OUT_OF_MEMORY; \ + goto END; \ + } \ + } while (0) + +#define MND_TMQ_RETURN_CHECK(c) \ + do { \ + code = c; \ + if (code != 0) { \ + goto END; \ + } \ + } while (0) + #ifdef __cplusplus } #endif diff --git a/source/dnode/mnode/impl/inc/mndDef.h b/source/dnode/mnode/impl/inc/mndDef.h index 089c4a10b3..5319cc88eb 100644 --- a/source/dnode/mnode/impl/inc/mndDef.h +++ b/source/dnode/mnode/impl/inc/mndDef.h @@ -622,7 +622,8 @@ typedef struct { int32_t resetOffsetCfg; } SMqConsumerObj; -SMqConsumerObj *tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t updateType, char *topic, SCMSubscribeReq *subscribe); +int32_t tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t updateType, + char *topic, SCMSubscribeReq *subscribe, SMqConsumerObj** ppConsumer); void tClearSMqConsumerObj(SMqConsumerObj* pConsumer); void tDeleteSMqConsumerObj(SMqConsumerObj* pConsumer); int32_t tEncodeSMqConsumerObj(void** buf, const SMqConsumerObj* pConsumer); @@ -665,8 +666,8 @@ typedef struct { char* qmsg; // SubPlanToString } SMqSubscribeObj; -SMqSubscribeObj* tNewSubscribeObj(const char key[TSDB_SUBSCRIBE_KEY_LEN]); -SMqSubscribeObj* tCloneSubscribeObj(const SMqSubscribeObj* pSub); +int32_t tNewSubscribeObj(const char *key, SMqSubscribeObj **ppSub); +int32_t tCloneSubscribeObj(const SMqSubscribeObj* pSub, SMqSubscribeObj **ppSub); void tDeleteSubscribeObj(SMqSubscribeObj* pSub); int32_t tEncodeSubscribeObj(void** buf, const SMqSubscribeObj* pSub); void* tDecodeSubscribeObj(const void* buf, SMqSubscribeObj* pSub, int8_t sver); diff --git a/source/dnode/mnode/impl/inc/mndSubscribe.h b/source/dnode/mnode/impl/inc/mndSubscribe.h index eb9902a75c..614c14c7d2 100644 --- a/source/dnode/mnode/impl/inc/mndSubscribe.h +++ b/source/dnode/mnode/impl/inc/mndSubscribe.h @@ -26,12 +26,9 @@ int32_t mndInitSubscribe(SMnode *pMnode); void mndCleanupSubscribe(SMnode *pMnode); int32_t mndGetGroupNumByTopic(SMnode *pMnode, const char *topicName); -SMqSubscribeObj *mndAcquireSubscribe(SMnode *pMnode, const char *CGroup, const char *topicName); -SMqSubscribeObj *mndAcquireSubscribeByKey(SMnode *pMnode, const char *key); +int32_t mndAcquireSubscribeByKey(SMnode *pMnode, const char *key, SMqSubscribeObj** pSub); void mndReleaseSubscribe(SMnode *pMnode, SMqSubscribeObj *pSub); -void mndMakeSubscribeKey(char *key, const char *cgroup, const char *topicName); - int32_t mndDropSubByTopic(SMnode *pMnode, STrans *pTrans, const char *topic); int32_t mndSetDropSubCommitLogs(SMnode *pMnode, STrans *pTrans, SMqSubscribeObj *pSub); diff --git a/source/dnode/mnode/impl/inc/mndTopic.h b/source/dnode/mnode/impl/inc/mndTopic.h index b2b86775ab..dc6c137455 100644 --- a/source/dnode/mnode/impl/inc/mndTopic.h +++ b/source/dnode/mnode/impl/inc/mndTopic.h @@ -25,13 +25,12 @@ extern "C" { int32_t mndInitTopic(SMnode *pMnode); void mndCleanupTopic(SMnode *pMnode); -SMqTopicObj *mndAcquireTopic(SMnode *pMnode, const char *topicName); +int32_t mndAcquireTopic(SMnode *pMnode, const char *topicName, SMqTopicObj **pTopic); void mndReleaseTopic(SMnode *pMnode, SMqTopicObj *pTopic); int32_t mndDropTopicByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb); bool mndTopicExistsForDb(SMnode *pMnode, SDbObj *pDb); -const char *mndTopicGetShowName(const char topic[TSDB_TOPIC_FNAME_LEN]); +void mndTopicGetShowName(const char* fullTopic, char* topic); -int32_t mndSetTopicCommitLogs(SMnode *pMnode, STrans *pTrans, SMqTopicObj *pTopic); int32_t mndGetNumOfTopics(SMnode *pMnode, char *dbName, int32_t *pNumOfTopics); #ifdef __cplusplus diff --git a/source/dnode/mnode/impl/src/mndConsumer.c b/source/dnode/mnode/impl/src/mndConsumer.c index 7788bf005a..532a224732 100644 --- a/source/dnode/mnode/impl/src/mndConsumer.c +++ b/source/dnode/mnode/impl/src/mndConsumer.c @@ -40,7 +40,6 @@ static int32_t mndProcessSubscribeReq(SRpcMsg *pMsg); static int32_t mndProcessAskEpReq(SRpcMsg *pMsg); static int32_t mndProcessMqHbReq(SRpcMsg *pMsg); static int32_t mndProcessConsumerClearMsg(SRpcMsg *pMsg); -static int32_t mndProcessConsumerRecoverMsg(SRpcMsg *pMsg); int32_t mndInitConsumer(SMnode *pMnode) { SSdbTable table = { @@ -57,7 +56,6 @@ int32_t mndInitConsumer(SMnode *pMnode) { mndSetMsgHandle(pMnode, TDMT_MND_TMQ_HB, mndProcessMqHbReq); mndSetMsgHandle(pMnode, TDMT_MND_TMQ_ASK_EP, mndProcessAskEpReq); // mndSetMsgHandle(pMnode, TDMT_MND_TMQ_TIMER, mndProcessMqTimerMsg); - mndSetMsgHandle(pMnode, TDMT_MND_TMQ_CONSUMER_RECOVER, mndProcessConsumerRecoverMsg); mndSetMsgHandle(pMnode, TDMT_MND_TMQ_LOST_CONSUMER_CLEAR, mndProcessConsumerClearMsg); mndAddShowRetrieveHandle(pMnode, TSDB_MGMT_TABLE_CONSUMERS, mndRetrieveConsumer); @@ -68,13 +66,10 @@ int32_t mndInitConsumer(SMnode *pMnode) { void mndCleanupConsumer(SMnode *pMnode) {} -void mndSendConsumerMsg(SMnode *pMnode, int64_t consumerId, uint16_t msgType, SRpcHandleInfo *info) { - void *msg = rpcMallocCont(sizeof(int64_t)); - if (msg == NULL) { - mError("consumer:0x%" PRIx64 " failed to clear consumer due to out of memory. alloc size:%d", consumerId, - (int32_t)sizeof(int64_t)); - return; - } +int32_t mndSendConsumerMsg(SMnode *pMnode, int64_t consumerId, uint16_t msgType, SRpcHandleInfo *info) { + int32_t code = 0; + void *msg = rpcMallocCont(sizeof(int64_t)); + MND_TMQ_NULL_CHECK(msg); *(int64_t*)msg = consumerId; SRpcMsg rpcMsg = { @@ -85,108 +80,51 @@ void mndSendConsumerMsg(SMnode *pMnode, int64_t consumerId, uint16_t msgType, SR }; mInfo("mndSendConsumerMsg type:%d consumer:0x%" PRIx64, msgType, consumerId); - int32_t code = tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg); - if (code != 0){ - mError("consumer:%"PRId64" send consumer msg:%d error:%d", consumerId, msgType, code); - } + MND_TMQ_RETURN_CHECK(tmsgPutToQueue(&pMnode->msgCb, WRITE_QUEUE, &rpcMsg)); + return code; + +END: + taosMemoryFree(msg); + return code; } static int32_t validateTopics(const SArray *pTopicList, SMnode *pMnode, const char *pUser, bool enableReplay) { SMqTopicObj *pTopic = NULL; int32_t code = 0; - int32_t lino = 0; int32_t numOfTopics = taosArrayGetSize(pTopicList); for (int32_t i = 0; i < numOfTopics; i++) { char *pOneTopic = taosArrayGetP(pTopicList, i); - pTopic = mndAcquireTopic(pMnode, pOneTopic); - if (pTopic == NULL) { // terrno has been set by callee function - code = TSDB_CODE_MND_RETURN_VALUE_NULL; - if (terrno != 0) code = terrno; - goto FAILED; - } - - TAOS_CHECK_GOTO(mndCheckTopicPrivilege(pMnode, pUser, MND_OPER_SUBSCRIBE, pTopic), &lino, FAILED); - - TAOS_CHECK_GOTO(grantCheckExpire(TSDB_GRANT_SUBSCRIPTION), &lino, FAILED); + MND_TMQ_RETURN_CHECK(mndAcquireTopic(pMnode, pOneTopic, &pTopic)); + MND_TMQ_RETURN_CHECK(mndCheckTopicPrivilege(pMnode, pUser, MND_OPER_SUBSCRIBE, pTopic)); + MND_TMQ_RETURN_CHECK(grantCheckExpire(TSDB_GRANT_SUBSCRIPTION)); if (enableReplay) { if (pTopic->subType != TOPIC_SUB_TYPE__COLUMN) { code = TSDB_CODE_TMQ_REPLAY_NOT_SUPPORT; - goto FAILED; + goto END; } else if (pTopic->ntbUid == 0 && pTopic->ctbStbUid == 0) { SDbObj *pDb = mndAcquireDb(pMnode, pTopic->db); if (pDb == NULL) { code = TSDB_CODE_MND_RETURN_VALUE_NULL; - if (terrno != 0) code = terrno; - goto FAILED; + goto END; } if (pDb->cfg.numOfVgroups != 1) { mndReleaseDb(pMnode, pDb); code = TSDB_CODE_TMQ_REPLAY_NEED_ONE_VGROUP; - goto FAILED; + goto END; } mndReleaseDb(pMnode, pDb); } } - mndReleaseTopic(pMnode, pTopic); } - return 0; -FAILED: - mndReleaseTopic(pMnode, pTopic); - TAOS_RETURN(code); -} -static int32_t mndProcessConsumerRecoverMsg(SRpcMsg *pMsg) { - int32_t code = 0; - int32_t lino = 0; - SMnode *pMnode = pMsg->info.node; - SMqConsumerRecoverMsg *pRecoverMsg = pMsg->pCont; - SMqConsumerObj *pConsumerNew = NULL; - STrans *pTrans = NULL; - SMqConsumerObj *pConsumer = mndAcquireConsumer(pMnode, pRecoverMsg->consumerId); - if (pConsumer == NULL) { - mError("cannot find consumer %" PRId64 " when processing consumer recover msg", pRecoverMsg->consumerId); - code = TSDB_CODE_MND_RETURN_VALUE_NULL; - if (terrno != 0) code = terrno; - goto END; - } - - mInfo("receive consumer recover msg, consumer:0x%" PRIx64 " status:%d(%s)", pRecoverMsg->consumerId, - pConsumer->status, mndConsumerStatusName(pConsumer->status)); - - if (pConsumer->status != MQ_CONSUMER_STATUS_LOST) { - code = TSDB_CODE_MND_CONSUMER_NOT_READY; - goto END; - } - - pConsumerNew = tNewSMqConsumerObj(pConsumer->consumerId, pConsumer->cgroup, CONSUMER_UPDATE_REC, NULL, NULL); - if (pConsumerNew == NULL){ - code = TSDB_CODE_MND_RETURN_VALUE_NULL; - if (terrno != 0) code = terrno; - goto END; - } - - pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_NOTHING, pMsg, "recover-csm"); - if (pTrans == NULL) { - code = TSDB_CODE_MND_RETURN_VALUE_NULL; - if (terrno != 0) code = terrno; - goto END; - } - - TAOS_CHECK_GOTO(validateTopics(pConsumer->assignedTopics, pMnode, pMsg->info.conn.user, false), &lino, END); - - TAOS_CHECK_GOTO(mndSetConsumerCommitLogs(pTrans, pConsumerNew), &lino, END); - - code = mndTransPrepare(pMnode, pTrans); END: - mndReleaseConsumer(pMnode, pConsumer); - tDeleteSMqConsumerObj(pConsumerNew); - mndTransDrop(pTrans); - TAOS_RETURN(code); + mndReleaseTopic(pMnode, pTopic); + return code; } static int32_t mndProcessConsumerClearMsg(SRpcMsg *pMsg) { @@ -196,55 +134,39 @@ static int32_t mndProcessConsumerClearMsg(SRpcMsg *pMsg) { SMqConsumerClearMsg *pClearMsg = pMsg->pCont; SMqConsumerObj *pConsumerNew = NULL; STrans *pTrans = NULL; + SMqConsumerObj *pConsumer = NULL; - SMqConsumerObj *pConsumer = mndAcquireConsumer(pMnode, pClearMsg->consumerId); - if (pConsumer == NULL) { - mError("consumer:0x%" PRIx64 " failed to be found to clear it", pClearMsg->consumerId); - TAOS_RETURN(code); - } - + MND_TMQ_RETURN_CHECK(mndAcquireConsumer(pMnode, pClearMsg->consumerId, &pConsumer)); mInfo("consumer:0x%" PRIx64 " needs to be cleared, status %s", pClearMsg->consumerId, mndConsumerStatusName(pConsumer->status)); - pConsumerNew = tNewSMqConsumerObj(pConsumer->consumerId, pConsumer->cgroup, -1, NULL, NULL); - if (pConsumerNew == NULL){ - code = TSDB_CODE_MND_RETURN_VALUE_NULL; - if (terrno != 0) code = terrno; - goto END; - } - + MND_TMQ_RETURN_CHECK(tNewSMqConsumerObj(pConsumer->consumerId, pConsumer->cgroup, -1, NULL, NULL, &pConsumerNew)); pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_NOTHING, pMsg, "clear-csm"); - if (pTrans == NULL) { - code = TSDB_CODE_MND_RETURN_VALUE_NULL; - if (terrno != 0) code = terrno; - goto END; - } - - // this is the drop action, not the update action - TAOS_CHECK_GOTO(mndSetConsumerDropLogs(pTrans, pConsumerNew), &lino, END); - + MND_TMQ_NULL_CHECK(pTrans); + MND_TMQ_RETURN_CHECK(mndSetConsumerDropLogs(pTrans, pConsumerNew)); code = mndTransPrepare(pMnode, pTrans); END: mndReleaseConsumer(pMnode, pConsumer); tDeleteSMqConsumerObj(pConsumerNew); mndTransDrop(pTrans); - TAOS_RETURN(code); + return code; } static int32_t checkPrivilege(SMnode *pMnode, SMqConsumerObj *pConsumer, SMqHbRsp *rsp, char *user) { + int32_t code = 0; rsp->topicPrivileges = taosArrayInit(taosArrayGetSize(pConsumer->currentTopics), sizeof(STopicPrivilege)); - if (rsp->topicPrivileges == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; - } + MND_TMQ_NULL_CHECK(rsp->topicPrivileges); for (int32_t i = 0; i < taosArrayGetSize(pConsumer->currentTopics); i++) { char *topic = taosArrayGetP(pConsumer->currentTopics, i); - SMqTopicObj *pTopic = mndAcquireTopic(pMnode, topic); - if (pTopic == NULL) { // terrno has been set by callee function + SMqTopicObj *pTopic = NULL; + code = mndAcquireTopic(pMnode, topic, &pTopic); + if (code != TDB_CODE_SUCCESS) { continue; } STopicPrivilege *data = taosArrayReserve(rsp->topicPrivileges, 1); - strcpy(data->topic, topic); + MND_TMQ_NULL_CHECK(data); + (void)strcpy(data->topic, topic); if (mndCheckTopicPrivilege(pMnode, user, MND_OPER_SUBSCRIBE, pTopic) != 0 || grantCheckExpire(TSDB_GRANT_SUBSCRIPTION) < 0) { data->noPrivilege = 1; @@ -253,22 +175,30 @@ static int32_t checkPrivilege(SMnode *pMnode, SMqConsumerObj *pConsumer, SMqHbRs } mndReleaseTopic(pMnode, pTopic); } - return 0; +END: + return code; } static void storeOffsetRows(SMnode *pMnode, SMqHbReq *req, SMqConsumerObj *pConsumer){ for (int i = 0; i < taosArrayGetSize(req->topics); i++) { TopicOffsetRows *data = taosArrayGet(req->topics, i); + if (data == NULL){ + continue; + } mInfo("heartbeat report offset rows.%s:%s", pConsumer->cgroup, data->topicName); - SMqSubscribeObj *pSub = mndAcquireSubscribe(pMnode, pConsumer->cgroup, data->topicName); - if (pSub == NULL) { + SMqSubscribeObj *pSub = NULL; + char key[TSDB_SUBSCRIBE_KEY_LEN] = {0}; + (void)snprintf(key, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", pConsumer->cgroup, TMQ_SEPARATOR, data->topicName); + int32_t code = mndAcquireSubscribeByKey(pMnode, key, &pSub); + if (code != 0) { + mError("failed to acquire subscribe by key:%s, code:%d", key, code); continue; } taosWLockLatch(&pSub->lock); SMqConsumerEp *pConsumerEp = taosHashGet(pSub->consumerHash, &pConsumer->consumerId, sizeof(int64_t)); if (pConsumerEp) { - taosArrayDestroy(pConsumerEp->offsetRows); + (void)taosArrayDestroy(pConsumerEp->offsetRows); pConsumerEp->offsetRows = data->offsetRows; data->offsetRows = NULL; } @@ -303,36 +233,24 @@ static int32_t mndProcessMqHbReq(SRpcMsg *pMsg) { SMqHbReq req = {0}; SMqHbRsp rsp = {0}; SMqConsumerObj *pConsumer = NULL; - - TAOS_CHECK_GOTO(tDeserializeSMqHbReq(pMsg->pCont, pMsg->contLen, &req), NULL, end); - + MND_TMQ_RETURN_CHECK(tDeserializeSMqHbReq(pMsg->pCont, pMsg->contLen, &req)); int64_t consumerId = req.consumerId; - pConsumer = mndAcquireConsumer(pMnode, consumerId); - if (pConsumer == NULL) { - mError("consumer:0x%" PRIx64 " not exist", consumerId); - code = TSDB_CODE_MND_CONSUMER_NOT_EXIST; - goto end; - } - - TAOS_CHECK_GOTO(checkPrivilege(pMnode, pConsumer, &rsp, pMsg->info.conn.user), NULL, end); - + MND_TMQ_RETURN_CHECK(mndAcquireConsumer(pMnode, consumerId, &pConsumer)); + MND_TMQ_RETURN_CHECK(checkPrivilege(pMnode, pConsumer, &rsp, pMsg->info.conn.user)); atomic_store_32(&pConsumer->hbStatus, 0); - int32_t status = atomic_load_32(&pConsumer->status); - if (status == MQ_CONSUMER_STATUS_LOST) { mInfo("try to recover consumer:0x%" PRIx64, consumerId); - mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_CONSUMER_RECOVER, &pMsg->info); + MND_TMQ_RETURN_CHECK(mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_CONSUMER_RECOVER, &pMsg->info)); } - storeOffsetRows(pMnode, &req, pConsumer); code = buildMqHbRsp(pMsg, &rsp); -end: +END: tDestroySMqHbRsp(&rsp); mndReleaseConsumer(pMnode, pConsumer); tDestroySMqHbReq(&req); - TAOS_RETURN(code); + return code; } static int32_t addEpSetInfo(SMnode *pMnode, SMqConsumerObj *pConsumer, int32_t epoch, SMqAskEpRsp *rsp){ @@ -349,19 +267,22 @@ static int32_t addEpSetInfo(SMnode *pMnode, SMqConsumerObj *pConsumer, int32_t e // handle all topics subscribed by this consumer for (int32_t i = 0; i < numOfTopics; i++) { char *topic = taosArrayGetP(pConsumer->currentTopics, i); - SMqSubscribeObj *pSub = mndAcquireSubscribe(pMnode, pConsumer->cgroup, topic); - // txn guarantees pSub is created - if (pSub == NULL) { + SMqSubscribeObj *pSub = NULL; + char key[TSDB_SUBSCRIBE_KEY_LEN] = {0}; + (void)snprintf(key, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", pConsumer->cgroup, TMQ_SEPARATOR, topic); + int32_t code = mndAcquireSubscribeByKey(pMnode, key, &pSub); + if (code != 0) { continue; } taosRLockLatch(&pSub->lock); SMqSubTopicEp topicEp = {0}; - strcpy(topicEp.topic, topic); + (void)strcpy(topicEp.topic, topic); // 2.1 fetch topic schema - SMqTopicObj *pTopic = mndAcquireTopic(pMnode, topic); - if (pTopic == NULL) { + SMqTopicObj *pTopic = NULL; + code = mndAcquireTopic(pMnode, topic, &pTopic); + if (code != TDB_CODE_SUCCESS) { taosRUnLockLatch(&pSub->lock); mndReleaseSubscribe(pMnode, pSub); continue; @@ -371,16 +292,27 @@ static int32_t addEpSetInfo(SMnode *pMnode, SMqConsumerObj *pConsumer, int32_t e topicEp.schema.nCols = pTopic->schema.nCols; if (topicEp.schema.nCols) { topicEp.schema.pSchema = taosMemoryCalloc(topicEp.schema.nCols, sizeof(SSchema)); - memcpy(topicEp.schema.pSchema, pTopic->schema.pSchema, topicEp.schema.nCols * sizeof(SSchema)); + if (topicEp.schema.pSchema == NULL) { + taosRUnLockLatch(&pTopic->lock); + taosRUnLockLatch(&pSub->lock); + mndReleaseSubscribe(pMnode, pSub); + mndReleaseTopic(pMnode, pTopic); + return TSDB_CODE_OUT_OF_MEMORY; + } + (void)memcpy(topicEp.schema.pSchema, pTopic->schema.pSchema, topicEp.schema.nCols * sizeof(SSchema)); } taosRUnLockLatch(&pTopic->lock); mndReleaseTopic(pMnode, pTopic); // 2.2 iterate all vg assigned to the consumer of that topic SMqConsumerEp *pConsumerEp = taosHashGet(pSub->consumerHash, &pConsumer->consumerId, sizeof(int64_t)); - int32_t vgNum = taosArrayGetSize(pConsumerEp->vgs); - - // this customer assigned vgroups + if (pConsumerEp == NULL) { + taosRUnLockLatch(&pConsumer->lock); + taosRUnLockLatch(&pSub->lock); + mndReleaseSubscribe(pMnode, pSub); + return TSDB_CODE_OUT_OF_MEMORY; + } + int32_t vgNum = taosArrayGetSize(pConsumerEp->vgs); topicEp.vgs = taosArrayInit(vgNum, sizeof(SMqSubVgEp)); if (topicEp.vgs == NULL) { taosRUnLockLatch(&pConsumer->lock); @@ -391,9 +323,9 @@ static int32_t addEpSetInfo(SMnode *pMnode, SMqConsumerObj *pConsumer, int32_t e for (int32_t j = 0; j < vgNum; j++) { SMqVgEp *pVgEp = taosArrayGetP(pConsumerEp->vgs, j); - // char offsetKey[TSDB_PARTITION_KEY_LEN]; - // mndMakePartitionKey(offsetKey, pConsumer->cgroup, topic, pVgEp->vgId); - + if (pVgEp == NULL) { + continue; + } if (epoch == -1) { SVgObj *pVgroup = mndAcquireVgroup(pMnode, pVgEp->vgId); if (pVgroup) { @@ -401,17 +333,10 @@ static int32_t addEpSetInfo(SMnode *pMnode, SMqConsumerObj *pConsumer, int32_t e mndReleaseVgroup(pMnode, pVgroup); } } - // 2.2.1 build vg ep - SMqSubVgEp vgEp = { - .epSet = pVgEp->epSet, - .vgId = pVgEp->vgId, - .offset = -1, - }; - - taosArrayPush(topicEp.vgs, &vgEp); + SMqSubVgEp vgEp = {.epSet = pVgEp->epSet, .vgId = pVgEp->vgId, .offset = -1}; + (void)taosArrayPush(topicEp.vgs, &vgEp); } - taosArrayPush(rsp->topics, &topicEp); - + (void)taosArrayPush(rsp->topics, &topicEp); taosRUnLockLatch(&pSub->lock); mndReleaseSubscribe(pMnode, pSub); } @@ -437,12 +362,16 @@ static int32_t buildAskEpRsp(SRpcMsg *pMsg, SMqAskEpRsp *rsp, int32_t serverEpoc pHead->walever = 0; void *abuf = POINTER_SHIFT(buf, sizeof(SMqRspHead)); - tEncodeSMqAskEpRsp(&abuf, rsp); + code = tEncodeSMqAskEpRsp(&abuf, rsp); + if (code != 0) { + rpcFreeCont(buf); + return code; + } // send rsp pMsg->info.rsp = buf; pMsg->info.rspLen = tlen; - TAOS_RETURN(code); + return code; } static int32_t mndProcessAskEpReq(SRpcMsg *pMsg) { @@ -450,33 +379,22 @@ static int32_t mndProcessAskEpReq(SRpcMsg *pMsg) { SMqAskEpReq req = {0}; SMqAskEpRsp rsp = {0}; int32_t code = 0; + SMqConsumerObj *pConsumer = NULL; - TAOS_CHECK_RETURN(tDeserializeSMqAskEpReq(pMsg->pCont, pMsg->contLen, &req)); - + MND_TMQ_RETURN_CHECK(tDeserializeSMqAskEpReq(pMsg->pCont, pMsg->contLen, &req)); int64_t consumerId = req.consumerId; - - SMqConsumerObj *pConsumer = mndAcquireConsumer(pMnode, consumerId); - if (pConsumer == NULL) { - mError("consumer:0x%" PRIx64 " group:%s not exists in sdb", consumerId, req.cgroup); - return TSDB_CODE_MND_CONSUMER_NOT_EXIST; - } - + MND_TMQ_RETURN_CHECK(mndAcquireConsumer(pMnode, consumerId, &pConsumer)); if (strncmp(req.cgroup, pConsumer->cgroup, tListLen(pConsumer->cgroup)) != 0) { mError("consumer:0x%" PRIx64 " group:%s not consistent with data in sdb, saved cgroup:%s", consumerId, req.cgroup, pConsumer->cgroup); code = TSDB_CODE_MND_CONSUMER_NOT_EXIST; goto END; } - atomic_store_32(&pConsumer->hbStatus, 0); - - // 1. check consumer status int32_t status = atomic_load_32(&pConsumer->status); - if (status == MQ_CONSUMER_STATUS_LOST) { - mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_CONSUMER_RECOVER, &pMsg->info); + MND_TMQ_RETURN_CHECK(mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_CONSUMER_RECOVER, &pMsg->info)); } - if (status != MQ_CONSUMER_STATUS_READY) { mInfo("consumer:0x%" PRIx64 " not ready, status: %s", consumerId, mndConsumerStatusName(status)); code = TSDB_CODE_MND_CONSUMER_NOT_READY; @@ -490,10 +408,7 @@ static int32_t mndProcessAskEpReq(SRpcMsg *pMsg) { if (epoch != serverEpoch) { mInfo("process ask ep, consumer:0x%" PRIx64 "(epoch %d) update with server epoch %d", consumerId, epoch, serverEpoch); - code = addEpSetInfo(pMnode, pConsumer, epoch, &rsp); - if(code != 0){ - goto END; - } + MND_TMQ_RETURN_CHECK(addEpSetInfo(pMnode, pConsumer, epoch, &rsp)); } code = buildAskEpRsp(pMsg, &rsp, serverEpoch, consumerId); @@ -507,27 +422,29 @@ END: int32_t mndSetConsumerDropLogs(STrans *pTrans, SMqConsumerObj *pConsumer) { int32_t code = 0; SSdbRaw *pCommitRaw = mndConsumerActionEncode(pConsumer); - if (pCommitRaw == NULL) { - code = TSDB_CODE_MND_RETURN_VALUE_NULL; - if (terrno != 0) code = terrno; - TAOS_RETURN(code); + MND_TMQ_NULL_CHECK(pCommitRaw); + code = mndTransAppendCommitlog(pTrans, pCommitRaw); + if (code != 0) { + sdbFreeRaw(pCommitRaw); + goto END; } - TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw)); - TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED)); - TAOS_RETURN(code); + MND_TMQ_RETURN_CHECK(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED)); +END: + return code; } int32_t mndSetConsumerCommitLogs(STrans *pTrans, SMqConsumerObj *pConsumer) { int32_t code = 0; SSdbRaw *pCommitRaw = mndConsumerActionEncode(pConsumer); - if (pCommitRaw == NULL) { - code = TSDB_CODE_MND_RETURN_VALUE_NULL; - if (terrno != 0) code = terrno; - TAOS_RETURN(code); + MND_TMQ_NULL_CHECK(pCommitRaw); + code = mndTransAppendCommitlog(pTrans, pCommitRaw); + if (code != 0) { + sdbFreeRaw(pCommitRaw); + goto END; } - TAOS_CHECK_RETURN(mndTransAppendCommitlog(pTrans, pCommitRaw)); - TAOS_CHECK_RETURN(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY)); - TAOS_RETURN(code); + MND_TMQ_RETURN_CHECK(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY)); +END: + return code; } static void freeItem(void *param) { @@ -538,29 +455,35 @@ static void freeItem(void *param) { } static int32_t getTopicAddDelete(SMqConsumerObj *pExistedConsumer, SMqConsumerObj *pConsumerNew){ + int32_t code = 0; pConsumerNew->rebNewTopics = taosArrayInit(0, sizeof(void *)); + MND_TMQ_NULL_CHECK(pConsumerNew->rebNewTopics); pConsumerNew->rebRemovedTopics = taosArrayInit(0, sizeof(void *)); - if(pConsumerNew->rebNewTopics == NULL || pConsumerNew->rebRemovedTopics == NULL){ - return TSDB_CODE_OUT_OF_MEMORY; - } + MND_TMQ_NULL_CHECK(pConsumerNew->rebRemovedTopics); + int32_t newTopicNum = taosArrayGetSize(pConsumerNew->assignedTopics); int32_t oldTopicNum = taosArrayGetSize(pExistedConsumer->currentTopics); - int32_t i = 0, j = 0; while (i < oldTopicNum || j < newTopicNum) { if (i >= oldTopicNum) { - char *newTopicCopy = taosStrdup(taosArrayGetP(pConsumerNew->assignedTopics, j)); - taosArrayPush(pConsumerNew->rebNewTopics, &newTopicCopy); + void* tmp = taosArrayGetP(pConsumerNew->assignedTopics, j); + MND_TMQ_NULL_CHECK(tmp); + char *newTopicCopy = taosStrdup(tmp); + MND_TMQ_NULL_CHECK(taosArrayPush(pConsumerNew->rebNewTopics, &newTopicCopy)); j++; continue; } else if (j >= newTopicNum) { - char *oldTopicCopy = taosStrdup(taosArrayGetP(pExistedConsumer->currentTopics, i)); - taosArrayPush(pConsumerNew->rebRemovedTopics, &oldTopicCopy); + void* tmp = taosArrayGetP(pExistedConsumer->currentTopics, i); + MND_TMQ_NULL_CHECK(tmp); + char *oldTopicCopy = taosStrdup(tmp); + MND_TMQ_NULL_CHECK(taosArrayPush(pConsumerNew->rebRemovedTopics, &oldTopicCopy)); i++; continue; } else { char *oldTopic = taosArrayGetP(pExistedConsumer->currentTopics, i); + MND_TMQ_NULL_CHECK(oldTopic); char *newTopic = taosArrayGetP(pConsumerNew->assignedTopics, j); + MND_TMQ_NULL_CHECK(newTopic); int comp = strcmp(oldTopic, newTopic); if (comp == 0) { i++; @@ -568,22 +491,22 @@ static int32_t getTopicAddDelete(SMqConsumerObj *pExistedConsumer, SMqConsumerOb continue; } else if (comp < 0) { char *oldTopicCopy = taosStrdup(oldTopic); - taosArrayPush(pConsumerNew->rebRemovedTopics, &oldTopicCopy); + MND_TMQ_NULL_CHECK(taosArrayPush(pConsumerNew->rebRemovedTopics, &oldTopicCopy)); i++; continue; } else { char *newTopicCopy = taosStrdup(newTopic); - taosArrayPush(pConsumerNew->rebNewTopics, &newTopicCopy); + MND_TMQ_NULL_CHECK(taosArrayPush(pConsumerNew->rebNewTopics, &newTopicCopy)); j++; continue; } } } - return 0; +END: + return code; } static int32_t checkAndSortTopic(SMnode *pMnode, SArray *pTopicList){ - int32_t code = 0; taosArraySort(pTopicList, taosArrayCompareString); taosArrayRemoveDuplicate(pTopicList, taosArrayCompareString, freeItem); @@ -594,24 +517,21 @@ static int32_t checkAndSortTopic(SMnode *pMnode, SArray *pTopicList){ return TSDB_CODE_TMQ_GROUP_OUT_OF_RANGE; } } - TAOS_RETURN(code); + return 0; } -static SMqConsumerObj* buildSubConsumer(SMnode *pMnode, SCMSubscribeReq *subscribe){ +static int32_t buildSubConsumer(SMnode *pMnode, SCMSubscribeReq *subscribe, SMqConsumerObj** ppConsumer){ int64_t consumerId = subscribe->consumerId; char *cgroup = subscribe->cgroup; SMqConsumerObj *pConsumerNew = NULL; SMqConsumerObj *pExistedConsumer = NULL; - pExistedConsumer = mndAcquireConsumer(pMnode, consumerId); - if (pExistedConsumer == NULL) { + int32_t code = mndAcquireConsumer(pMnode, consumerId, &pExistedConsumer); + if (code != 0) { mInfo("receive subscribe request from new consumer:0x%" PRIx64 ",cgroup:%s, numOfTopics:%d", consumerId, subscribe->cgroup, (int32_t)taosArrayGetSize(subscribe->topicNames)); - pConsumerNew = tNewSMqConsumerObj(consumerId, cgroup, CONSUMER_INSERT_SUB, NULL, subscribe); - if (pConsumerNew == NULL) { - goto _over; - } + MND_TMQ_RETURN_CHECK(tNewSMqConsumerObj(consumerId, cgroup, CONSUMER_INSERT_SUB, NULL, subscribe, &pConsumerNew)); } else { int32_t status = atomic_load_32(&pExistedConsumer->status); @@ -621,82 +541,53 @@ static SMqConsumerObj* buildSubConsumer(SMnode *pMnode, SCMSubscribeReq *subscri (int32_t)taosArrayGetSize(subscribe->topicNames)); if (status != MQ_CONSUMER_STATUS_READY) { - terrno = TSDB_CODE_MND_CONSUMER_NOT_READY; - goto _over; - } - pConsumerNew = tNewSMqConsumerObj(consumerId, cgroup, CONSUMER_UPDATE_SUB, NULL, subscribe); - if (pConsumerNew == NULL) { - goto _over; - } - - int32_t code = getTopicAddDelete(pExistedConsumer, pConsumerNew); - if (code != 0){ - terrno = code; - goto _over; + code = TSDB_CODE_MND_CONSUMER_NOT_READY; + goto END; } + MND_TMQ_RETURN_CHECK(tNewSMqConsumerObj(consumerId, cgroup, CONSUMER_UPDATE_SUB, NULL, subscribe, &pConsumerNew)); + MND_TMQ_RETURN_CHECK(getTopicAddDelete(pExistedConsumer, pConsumerNew)); } mndReleaseConsumer(pMnode, pExistedConsumer); - return pConsumerNew; + if (ppConsumer){ + *ppConsumer = pConsumerNew; + } + return code; -_over: +END: mndReleaseConsumer(pMnode, pExistedConsumer); tDeleteSMqConsumerObj(pConsumerNew); - return NULL; + return code; } int32_t mndProcessSubscribeReq(SRpcMsg *pMsg) { SMnode *pMnode = pMsg->info.node; char *msgStr = pMsg->pCont; int32_t code = 0; - - SCMSubscribeReq subscribe = {0}; - tDeserializeSCMSubscribeReq(msgStr, &subscribe); - SMqConsumerObj *pConsumerNew = NULL; STrans *pTrans = NULL; + SCMSubscribeReq subscribe = {0}; + MND_TMQ_RETURN_CHECK(tDeserializeSCMSubscribeReq(msgStr, &subscribe)); if(taosArrayGetSize(subscribe.topicNames) == 0){ - SMqConsumerObj *pConsumerTmp = mndAcquireConsumer(pMnode, subscribe.consumerId); - if(pConsumerTmp == NULL){ - goto _over; - } + SMqConsumerObj *pConsumerTmp = NULL; + MND_TMQ_RETURN_CHECK(mndAcquireConsumer(pMnode, subscribe.consumerId, &pConsumerTmp)); mndReleaseConsumer(pMnode, pConsumerTmp); } - - code = checkAndSortTopic(pMnode, subscribe.topicNames); - if(code != TSDB_CODE_SUCCESS){ - goto _over; - } - + MND_TMQ_RETURN_CHECK(checkAndSortTopic(pMnode, subscribe.topicNames)); pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_NOTHING, pMsg, "subscribe"); - if (pTrans == NULL) { - code = TSDB_CODE_MND_RETURN_VALUE_NULL; - if (terrno != 0) code = terrno; - goto _over; - } + MND_TMQ_NULL_CHECK(pTrans); - code = validateTopics(subscribe.topicNames, pMnode, pMsg->info.conn.user, subscribe.enableReplay); - if (code != TSDB_CODE_SUCCESS) { - goto _over; - } - - pConsumerNew = buildSubConsumer(pMnode, &subscribe); - if(pConsumerNew == NULL){ - code = TSDB_CODE_MND_RETURN_VALUE_NULL; - if (terrno != 0) code = terrno; - goto _over; - } - - TAOS_CHECK_GOTO(mndSetConsumerCommitLogs(pTrans, pConsumerNew), NULL, _over); - - TAOS_CHECK_GOTO(mndTransPrepare(pMnode, pTrans), NULL, _over); + MND_TMQ_RETURN_CHECK(validateTopics(subscribe.topicNames, pMnode, pMsg->info.conn.user, subscribe.enableReplay)); + MND_TMQ_RETURN_CHECK(buildSubConsumer(pMnode, &subscribe, &pConsumerNew)); + MND_TMQ_RETURN_CHECK(mndSetConsumerCommitLogs(pTrans, pConsumerNew)); + MND_TMQ_RETURN_CHECK(mndTransPrepare(pMnode, pTrans)); code = TSDB_CODE_ACTION_IN_PROGRESS; -_over: +END: mndTransDrop(pTrans); tDeleteSMqConsumerObj(pConsumerNew); taosArrayDestroyP(subscribe.topicNames, (FDelete)taosMemoryFree); - TAOS_RETURN(code); + return code; } SSdbRaw *mndConsumerActionEncode(SMqConsumerObj *pConsumer) { @@ -838,8 +729,7 @@ static bool existInCurrentTopicList(const SMqConsumerObj *pConsumer, const char int32_t size = taosArrayGetSize(pConsumer->currentTopics); for (int32_t i = 0; i < size; i++) { char *topic = taosArrayGetP(pConsumer->currentTopics, i); - - if (strcmp(topic, pTopic) == 0) { + if (topic && strcmp(topic, pTopic) == 0) { existing = true; break; } @@ -865,32 +755,45 @@ static int32_t mndConsumerActionUpdate(SSdb *pSdb, SMqConsumerObj *pOldConsumer, } else if (pNewConsumer->updateType == CONSUMER_UPDATE_REC) { int32_t sz = taosArrayGetSize(pOldConsumer->assignedTopics); for (int32_t i = 0; i < sz; i++) { - char *topic = taosStrdup(taosArrayGetP(pOldConsumer->assignedTopics, i)); - taosArrayPush(pOldConsumer->rebNewTopics, &topic); + void * tmp = taosArrayGetP(pOldConsumer->assignedTopics, i); + if (tmp == NULL){ + return TSDB_CODE_TMQ_INVALID_MSG; + } + char *topic = taosStrdup(tmp); + if (taosArrayPush(pOldConsumer->rebNewTopics, &topic) == NULL) { + taosMemoryFree(topic); + return TSDB_CODE_TMQ_INVALID_MSG; + } } pOldConsumer->status = MQ_CONSUMER_STATUS_REBALANCE; mInfo("consumer:0x%" PRIx64 " recover update", pOldConsumer->consumerId); } else if (pNewConsumer->updateType == CONSUMER_UPDATE_REB) { - atomic_add_fetch_32(&pOldConsumer->epoch, 1); - + (void)atomic_add_fetch_32(&pOldConsumer->epoch, 1); pOldConsumer->rebalanceTime = taosGetTimestampMs(); mInfo("[rebalance] consumer:0x%" PRIx64 " rebalance update, only rebalance time", pOldConsumer->consumerId); } else if (pNewConsumer->updateType == CONSUMER_ADD_REB) { - char *pNewTopic = taosStrdup(taosArrayGetP(pNewConsumer->rebNewTopics, 0)); + void *tmp = taosArrayGetP(pNewConsumer->rebNewTopics, 0); + if (tmp == NULL){ + return TSDB_CODE_TMQ_INVALID_MSG; + } + char *pNewTopic = taosStrdup(tmp); removeFromTopicList(pOldConsumer->rebNewTopics, pNewTopic, pOldConsumer->consumerId, "new"); bool existing = existInCurrentTopicList(pOldConsumer, pNewTopic); if (existing) { mError("[rebalance] consumer:0x%" PRIx64 " add new topic:%s should not in currentTopics", pOldConsumer->consumerId, pNewTopic); taosMemoryFree(pNewTopic); } else { - taosArrayPush(pOldConsumer->currentTopics, &pNewTopic); + if (taosArrayPush(pOldConsumer->currentTopics, &pNewTopic) == NULL) { + taosMemoryFree(pNewTopic); + return TSDB_CODE_TMQ_INVALID_MSG; + } taosArraySort(pOldConsumer->currentTopics, taosArrayCompareString); } int32_t status = pOldConsumer->status; updateConsumerStatus(pOldConsumer); pOldConsumer->rebalanceTime = taosGetTimestampMs(); - atomic_add_fetch_32(&pOldConsumer->epoch, 1); + (void)atomic_add_fetch_32(&pOldConsumer->epoch, 1); mInfo("[rebalance] consumer:0x%" PRIx64 " rebalance update add, state (%d)%s -> (%d)%s, new epoch:%d, reb-time:%" PRId64 ", current topics:%d, newTopics:%d, removeTopics:%d", @@ -901,13 +804,16 @@ static int32_t mndConsumerActionUpdate(SSdb *pSdb, SMqConsumerObj *pOldConsumer, } else if (pNewConsumer->updateType == CONSUMER_REMOVE_REB) { char *topic = taosArrayGetP(pNewConsumer->rebRemovedTopics, 0); + if (topic == NULL){ + return TSDB_CODE_TMQ_INVALID_MSG; + } removeFromTopicList(pOldConsumer->rebRemovedTopics, topic, pOldConsumer->consumerId, "remove"); removeFromTopicList(pOldConsumer->currentTopics, topic, pOldConsumer->consumerId, "current"); int32_t status = pOldConsumer->status; updateConsumerStatus(pOldConsumer); pOldConsumer->rebalanceTime = taosGetTimestampMs(); - atomic_add_fetch_32(&pOldConsumer->epoch, 1); + (void)atomic_add_fetch_32(&pOldConsumer->epoch, 1); mInfo("[rebalance]consumer:0x%" PRIx64 " rebalance update remove, state (%d)%s -> (%d)%s, new epoch:%d, reb-time:%" PRId64 ", current topics:%d, newTopics:%d, removeTopics:%d", @@ -921,13 +827,13 @@ static int32_t mndConsumerActionUpdate(SSdb *pSdb, SMqConsumerObj *pOldConsumer, return 0; } -SMqConsumerObj *mndAcquireConsumer(SMnode *pMnode, int64_t consumerId) { +int32_t mndAcquireConsumer(SMnode *pMnode, int64_t consumerId, SMqConsumerObj** pConsumer) { SSdb *pSdb = pMnode->pSdb; - SMqConsumerObj *pConsumer = sdbAcquire(pSdb, SDB_CONSUMER, &consumerId); - if (pConsumer == NULL) { - terrno = TSDB_CODE_MND_CONSUMER_NOT_EXIST; + *pConsumer = sdbAcquire(pSdb, SDB_CONSUMER, &consumerId); + if (*pConsumer == NULL) { + return TSDB_CODE_MND_CONSUMER_NOT_EXIST; } - return pConsumer; + return 0; } void mndReleaseConsumer(SMnode *pMnode, SMqConsumerObj *pConsumer) { @@ -940,6 +846,7 @@ static int32_t mndRetrieveConsumer(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock * SSdb *pSdb = pMnode->pSdb; int32_t numOfRows = 0; SMqConsumerObj *pConsumer = NULL; + int32_t code = 0; while (numOfRows < rowsCapacity) { pShow->pIter = sdbFetch(pSdb, SDB_CONSUMER, pShow->pIter, (void **)&pConsumer); @@ -964,34 +871,37 @@ static int32_t mndRetrieveConsumer(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock * } if (numOfRows + topicSz > rowsCapacity) { - blockDataEnsureCapacity(pBlock, numOfRows + topicSz); + MND_TMQ_RETURN_CHECK(blockDataEnsureCapacity(pBlock, numOfRows + topicSz)); } for (int32_t i = 0; i < topicSz; i++) { - SColumnInfoData *pColInfo; + SColumnInfoData *pColInfo = NULL; int32_t cols = 0; // consumer id char consumerIdHex[32] = {0}; - sprintf(varDataVal(consumerIdHex), "0x%" PRIx64, pConsumer->consumerId); + (void)sprintf(varDataVal(consumerIdHex), "0x%" PRIx64, pConsumer->consumerId); varDataSetLen(consumerIdHex, strlen(varDataVal(consumerIdHex))); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)consumerIdHex, false); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)consumerIdHex, false)); // consumer group char cgroup[TSDB_CGROUP_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(cgroup, pConsumer->cgroup); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)cgroup, false); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)cgroup, false)); // client id char clientId[256 + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(clientId, pConsumer->clientId); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)clientId, false); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)clientId, false)); // status char status[20 + VARSTR_HEADER_SIZE] = {0}; @@ -999,46 +909,48 @@ static int32_t mndRetrieveConsumer(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock * STR_TO_VARSTR(status, pStatusName); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)status, false); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)status, false)); // one subscribed topic pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); + MND_TMQ_NULL_CHECK(pColInfo); if (hasTopic) { char topic[TSDB_TOPIC_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; - const char *topicName = mndTopicGetShowName(taosArrayGetP(pConsumer->assignedTopics, i)); - STR_TO_VARSTR(topic, topicName); - colDataSetVal(pColInfo, numOfRows, (const char *)topic, false); + mndTopicGetShowName(taosArrayGetP(pConsumer->assignedTopics, i), topic + VARSTR_HEADER_SIZE); + *(VarDataLenT *)(topic) = strlen(topic + VARSTR_HEADER_SIZE); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)topic, false)); } else { - colDataSetVal(pColInfo, numOfRows, NULL, true); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, NULL, true)); } - // end point - /*pColInfo = taosArrayGet(pBlock->pDataBlock, cols++);*/ - /*colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->ep, true);*/ - // up time pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->createTime, false); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->createTime, false)); // subscribe time pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->subscribeTime, false); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->subscribeTime, false)); // rebalance time pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->rebalanceTime, pConsumer->rebalanceTime == 0); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)&pConsumer->rebalanceTime, pConsumer->rebalanceTime == 0)); char buf[TSDB_OFFSET_LEN] = {0}; STqOffsetVal pVal = {.type = pConsumer->resetOffsetCfg}; - tFormatOffset(buf, TSDB_OFFSET_LEN, &pVal); + MND_TMQ_RETURN_CHECK(tFormatOffset(buf, TSDB_OFFSET_LEN, &pVal)); char parasStr[64 + TSDB_OFFSET_LEN + VARSTR_HEADER_SIZE] = {0}; - sprintf(varDataVal(parasStr), "tbname:%d,commit:%d,interval:%dms,reset:%s", pConsumer->withTbName, + (void)sprintf(varDataVal(parasStr), "tbname:%d,commit:%d,interval:%dms,reset:%s", pConsumer->withTbName, pConsumer->autoCommit, pConsumer->autoCommitInterval, buf); varDataSetLen(parasStr, strlen(varDataVal(parasStr))); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)parasStr, false); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)parasStr, false)); numOfRows++; } @@ -1051,6 +963,9 @@ static int32_t mndRetrieveConsumer(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock * pShow->numOfRows += numOfRows; return numOfRows; + +END: + return code; } static void mndCancelGetNextConsumer(SMnode *pMnode, void *pIter) { diff --git a/source/dnode/mnode/impl/src/mndDb.c b/source/dnode/mnode/impl/src/mndDb.c index 8432855c6f..3e94411e52 100644 --- a/source/dnode/mnode/impl/src/mndDb.c +++ b/source/dnode/mnode/impl/src/mndDb.c @@ -1525,9 +1525,6 @@ static int32_t mndDropDb(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb) { if (mndSetDropDbPrepareLogs(pMnode, pTrans, pDb) != 0) goto _OVER; if (mndSetDropDbCommitLogs(pMnode, pTrans, pDb) != 0) goto _OVER; - /*if (mndDropOffsetByDB(pMnode, pTrans, pDb) != 0) goto _OVER;*/ - /*if (mndDropSubByDB(pMnode, pTrans, pDb) != 0) goto _OVER;*/ - /*if (mndDropTopicByDB(pMnode, pTrans, pDb) != 0) goto _OVER;*/ if (mndDropStreamByDb(pMnode, pTrans, pDb) != 0) goto _OVER; #ifdef TD_ENTERPRISE if (mndDropViewByDb(pMnode, pTrans, pDb) != 0) goto _OVER; diff --git a/source/dnode/mnode/impl/src/mndDef.c b/source/dnode/mnode/impl/src/mndDef.c index 9dc5f920ad..3aa0b5a01d 100644 --- a/source/dnode/mnode/impl/src/mndDef.c +++ b/source/dnode/mnode/impl/src/mndDef.c @@ -255,15 +255,17 @@ void *tDecodeSMqVgEp(const void *buf, SMqVgEp *pVgEp, int8_t sver) { static void *topicNameDup(void *p) { return taosStrdup((char *)p); } -SMqConsumerObj *tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t updateType, char *topic, SCMSubscribeReq *subscribe) { +int32_t tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t updateType, + char *topic, SCMSubscribeReq *subscribe, SMqConsumerObj** ppConsumer) { + int32_t code = 0; SMqConsumerObj *pConsumer = taosMemoryCalloc(1, sizeof(SMqConsumerObj)); if (pConsumer == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return NULL; + code = TSDB_CODE_OUT_OF_MEMORY; + goto END; } pConsumer->consumerId = consumerId; - memcpy(pConsumer->cgroup, cgroup, TSDB_CGROUP_LEN); + (void)memcpy(pConsumer->cgroup, cgroup, TSDB_CGROUP_LEN); pConsumer->epoch = 0; pConsumer->status = MQ_CONSUMER_STATUS_REBALANCE; @@ -276,20 +278,26 @@ SMqConsumerObj *tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t upda if (updateType == CONSUMER_ADD_REB){ pConsumer->rebNewTopics = taosArrayInit(0, sizeof(void *)); if(pConsumer->rebNewTopics == NULL){ - terrno = TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; goto END; } char* topicTmp = taosStrdup(topic); - taosArrayPush(pConsumer->rebNewTopics, &topicTmp); + if (taosArrayPush(pConsumer->rebNewTopics, &topicTmp) == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto END; + } }else if (updateType == CONSUMER_REMOVE_REB) { pConsumer->rebRemovedTopics = taosArrayInit(0, sizeof(void *)); if(pConsumer->rebRemovedTopics == NULL){ - terrno = TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; goto END; } char* topicTmp = taosStrdup(topic); - taosArrayPush(pConsumer->rebRemovedTopics, &topicTmp); + if (taosArrayPush(pConsumer->rebRemovedTopics, &topicTmp) == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto END; + } }else if (updateType == CONSUMER_INSERT_SUB){ tstrncpy(pConsumer->clientId, subscribe->clientId, tListLen(pConsumer->clientId)); pConsumer->withTbName = subscribe->withTbName; @@ -297,10 +305,9 @@ SMqConsumerObj *tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t upda pConsumer->autoCommitInterval = subscribe->autoCommitInterval; pConsumer->resetOffsetCfg = subscribe->resetOffsetCfg; - pConsumer->rebNewTopics = taosArrayDup(subscribe->topicNames, topicNameDup); if (pConsumer->rebNewTopics == NULL){ - terrno = TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; goto END; } pConsumer->assignedTopics = subscribe->topicNames; @@ -310,11 +317,12 @@ SMqConsumerObj *tNewSMqConsumerObj(int64_t consumerId, char *cgroup, int8_t upda subscribe->topicNames = NULL; } - return pConsumer; + *ppConsumer = pConsumer; + return 0; END: tDeleteSMqConsumerObj(pConsumer); - return NULL; + return code; } void tClearSMqConsumerObj(SMqConsumerObj *pConsumer) { @@ -530,27 +538,36 @@ void *tDecodeSMqConsumerEp(const void *buf, SMqConsumerEp *pConsumerEp, int8_t s return (void *)buf; } -SMqSubscribeObj *tNewSubscribeObj(const char *key) { +int32_t tNewSubscribeObj(const char *key, SMqSubscribeObj **ppSub) { + int32_t code = 0; SMqSubscribeObj *pSubObj = taosMemoryCalloc(1, sizeof(SMqSubscribeObj)); - if (pSubObj == NULL) { - return NULL; - } + MND_TMQ_NULL_CHECK(pSubObj); - memcpy(pSubObj->key, key, TSDB_SUBSCRIBE_KEY_LEN); + (void)memcpy(pSubObj->key, key, TSDB_SUBSCRIBE_KEY_LEN); taosInitRWLatch(&pSubObj->lock); pSubObj->vgNum = 0; pSubObj->consumerHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK); - - // TODO set hash free fp - /*taosHashSetFreeFp(pSubObj->consumerHash, tDeleteSMqConsumerEp);*/ + MND_TMQ_NULL_CHECK(pSubObj->consumerHash); pSubObj->unassignedVgs = taosArrayInit(0, POINTER_BYTES); - return pSubObj; + MND_TMQ_NULL_CHECK(pSubObj->unassignedVgs); + if (ppSub){ + *ppSub = pSubObj; + } + return code; + +END: + taosMemoryFree(pSubObj); + return code; } -SMqSubscribeObj *tCloneSubscribeObj(const SMqSubscribeObj *pSub) { +int32_t tCloneSubscribeObj(const SMqSubscribeObj *pSub, SMqSubscribeObj **ppSub) { + int32_t code = 0; SMqSubscribeObj *pSubNew = taosMemoryMalloc(sizeof(SMqSubscribeObj)); - if (pSubNew == NULL) return NULL; - memcpy(pSubNew->key, pSub->key, TSDB_SUBSCRIBE_KEY_LEN); + if (pSubNew == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto END; + } + (void)memcpy(pSubNew->key, pSub->key, TSDB_SUBSCRIBE_KEY_LEN); taosInitRWLatch(&pSubNew->lock); pSubNew->dbUid = pSub->dbUid; @@ -560,8 +577,7 @@ SMqSubscribeObj *tCloneSubscribeObj(const SMqSubscribeObj *pSub) { pSubNew->vgNum = pSub->vgNum; pSubNew->consumerHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_ENTRY_LOCK); - // TODO set hash free fp - /*taosHashSetFreeFp(pSubNew->consumerHash, tDeleteSMqConsumerEp);*/ + void *pIter = NULL; SMqConsumerEp *pConsumerEp = NULL; while (1) { @@ -576,9 +592,11 @@ SMqSubscribeObj *tCloneSubscribeObj(const SMqSubscribeObj *pSub) { } pSubNew->unassignedVgs = taosArrayDup(pSub->unassignedVgs, (__array_item_dup_fn_t)tCloneSMqVgEp); pSubNew->offsetRows = taosArrayDup(pSub->offsetRows, NULL); - memcpy(pSubNew->dbName, pSub->dbName, TSDB_DB_FNAME_LEN); + (void)memcpy(pSubNew->dbName, pSub->dbName, TSDB_DB_FNAME_LEN); pSubNew->qmsg = taosStrdup(pSub->qmsg); - return pSubNew; + +END: + return code; } void tDeleteSubscribeObj(SMqSubscribeObj *pSub) { diff --git a/source/dnode/mnode/impl/src/mndScheduler.c b/source/dnode/mnode/impl/src/mndScheduler.c index db8c08e2e3..484d7bba28 100644 --- a/source/dnode/mnode/impl/src/mndScheduler.c +++ b/source/dnode/mnode/impl/src/mndScheduler.c @@ -759,25 +759,27 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib SVgObj* pVgroup = NULL; SQueryPlan* pPlan = NULL; SSubplan* pSubplan = NULL; + int32_t code = 0; if (pTopic->subType == TOPIC_SUB_TYPE__COLUMN) { pPlan = qStringToQueryPlan(pTopic->physicalPlan); if (pPlan == NULL) { - terrno = TSDB_CODE_QRY_INVALID_INPUT; - return -1; + return TSDB_CODE_QRY_INVALID_INPUT; } } else if (pTopic->subType == TOPIC_SUB_TYPE__TABLE && pTopic->ast != NULL) { SNode* pAst = NULL; - if (nodesStringToNode(pTopic->ast, &pAst) != 0) { + code = nodesStringToNode(pTopic->ast, &pAst); + if (code != 0) { mError("topic:%s, failed to create since %s", pTopic->name, terrstr()); - return -1; + return code; } SPlanContext cxt = {.pAstRoot = pAst, .topicQuery = true}; - if (qCreateQueryPlan(&cxt, &pPlan, NULL) != 0) { + code = qCreateQueryPlan(&cxt, &pPlan, NULL); + if (code != 0) { mError("failed to create topic:%s since %s", pTopic->name, terrstr()); nodesDestroyNode(pAst); - return -1; + return code; } nodesDestroyNode(pAst); } @@ -785,18 +787,19 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib if (pPlan) { int32_t levelNum = LIST_LENGTH(pPlan->pSubplans); if (levelNum != 1) { - qDestroyQueryPlan(pPlan); - terrno = TSDB_CODE_MND_INVALID_TOPIC_QUERY; - return -1; + code = TSDB_CODE_MND_INVALID_TOPIC_QUERY; + goto END; } SNodeListNode* pNodeListNode = (SNodeListNode*)nodesListGetNode(pPlan->pSubplans, 0); - + if (pNodeListNode == NULL){ + code = TSDB_CODE_OUT_OF_MEMORY; + goto END; + } int32_t opNum = LIST_LENGTH(pNodeListNode->pNodeList); if (opNum != 1) { - qDestroyQueryPlan(pPlan); - terrno = TSDB_CODE_MND_INVALID_TOPIC_QUERY; - return -1; + code = TSDB_CODE_MND_INVALID_TOPIC_QUERY; + goto END; } pSubplan = (SSubplan*)nodesListGetNode(pNodeListNode->pNodeList, 0); @@ -817,12 +820,18 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib pSub->vgNum++; SMqVgEp* pVgEp = taosMemoryMalloc(sizeof(SMqVgEp)); + if (pVgEp == NULL){ + code = TSDB_CODE_OUT_OF_MEMORY; + goto END; + } pVgEp->epSet = mndGetVgroupEpset(pMnode, pVgroup); pVgEp->vgId = pVgroup->vgId; - taosArrayPush(pSub->unassignedVgs, &pVgEp); - + if (taosArrayPush(pSub->unassignedVgs, &pVgEp) == NULL){ + code = TSDB_CODE_OUT_OF_MEMORY; + taosMemoryFree(pVgEp); + goto END; + } mInfo("init subscription %s for topic:%s assign vgId:%d", pSub->key, pTopic->name, pVgEp->vgId); - sdbRelease(pSdb, pVgroup); } @@ -830,14 +839,14 @@ int32_t mndSchedInitSubEp(SMnode* pMnode, const SMqTopicObj* pTopic, SMqSubscrib int32_t msgLen; if (qSubPlanToString(pSubplan, &pSub->qmsg, &msgLen) < 0) { - qDestroyQueryPlan(pPlan); - terrno = TSDB_CODE_QRY_INVALID_INPUT; - return -1; + code = TSDB_CODE_QRY_INVALID_INPUT; + goto END; } } else { pSub->qmsg = taosStrdup(""); } +END: qDestroyQueryPlan(pPlan); - return 0; + return code; } diff --git a/source/dnode/mnode/impl/src/mndSubscribe.c b/source/dnode/mnode/impl/src/mndSubscribe.c index e2bedc258a..731e25175f 100644 --- a/source/dnode/mnode/impl/src/mndSubscribe.c +++ b/source/dnode/mnode/impl/src/mndSubscribe.c @@ -41,14 +41,21 @@ static int32_t mndProcessRebalanceReq(SRpcMsg *pMsg); static int32_t mndProcessDropCgroupReq(SRpcMsg *pMsg); static int32_t mndRetrieveSubscribe(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows); static void mndCancelGetNextSubscribe(SMnode *pMnode, void *pIter); -static void mndCheckConsumer(SRpcMsg *pMsg, SHashObj *hash); +static int32_t mndCheckConsumer(SRpcMsg *pMsg, SHashObj *hash); static int32_t mndSetSubCommitLogs(STrans *pTrans, SMqSubscribeObj *pSub) { + int32_t code = 0; SSdbRaw *pCommitRaw = mndSubActionEncode(pSub); - if (pCommitRaw == NULL) return -1; - if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1; - if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) return -1; - return 0; + MND_TMQ_NULL_CHECK(pCommitRaw); + code = mndTransAppendCommitlog(pTrans, pCommitRaw); + if (code != 0) { + sdbFreeRaw(pCommitRaw); + goto END; + } + code = sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY); + +END: + return code; } int32_t mndInitSubscribe(SMnode *pMnode) { @@ -74,41 +81,37 @@ int32_t mndInitSubscribe(SMnode *pMnode) { return sdbSetTable(pMnode->pSdb, table); } -static SMqSubscribeObj *mndCreateSubscription(SMnode *pMnode, const SMqTopicObj *pTopic, const char *subKey) { - SMqSubscribeObj *pSub = tNewSubscribeObj(subKey); - if (pSub == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return NULL; - } +static int32_t mndCreateSubscription(SMnode *pMnode, const SMqTopicObj *pTopic, const char *subKey, SMqSubscribeObj** pSub) { + int32_t code = 0; + MND_TMQ_RETURN_CHECK(tNewSubscribeObj(subKey, pSub)); + (*pSub)->dbUid = pTopic->dbUid; + (*pSub)->stbUid = pTopic->stbUid; + (*pSub)->subType = pTopic->subType; + (*pSub)->withMeta = pTopic->withMeta; - pSub->dbUid = pTopic->dbUid; - pSub->stbUid = pTopic->stbUid; - pSub->subType = pTopic->subType; - pSub->withMeta = pTopic->withMeta; + MND_TMQ_RETURN_CHECK(mndSchedInitSubEp(pMnode, pTopic, *pSub)); + return code; - if (mndSchedInitSubEp(pMnode, pTopic, pSub) < 0) { - tDeleteSubscribeObj(pSub); - taosMemoryFree(pSub); - return NULL; - } - - return pSub; +END: + tDeleteSubscribeObj(*pSub); + taosMemoryFree(*pSub); + return code; } static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, SMqSubscribeObj *pSub, const SMqRebOutputVg *pRebVg, SSubplan *pPlan) { SMqRebVgReq req = {0}; + int32_t code = 0; + SEncoder encoder = {0}; + req.oldConsumerId = pRebVg->oldConsumerId; req.newConsumerId = pRebVg->newConsumerId; req.vgId = pRebVg->pVgEp->vgId; if (pPlan) { pPlan->execNode.epSet = pRebVg->pVgEp->epSet; pPlan->execNode.nodeId = pRebVg->pVgEp->vgId; - int32_t msgLen; - if (qSubPlanToString(pPlan, &req.qmsg, &msgLen) < 0) { - terrno = TSDB_CODE_QRY_INVALID_INPUT; - return -1; - } + int32_t msgLen = 0; + MND_TMQ_RETURN_CHECK(qSubPlanToString(pPlan, &req.qmsg, &msgLen)); } else { req.qmsg = taosStrdup(""); } @@ -118,62 +121,47 @@ static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, SMqSubscribeObj tstrncpy(req.subKey, pSub->key, TSDB_SUBSCRIBE_KEY_LEN); int32_t tlen = 0; - int32_t ret = 0; - tEncodeSize(tEncodeSMqRebVgReq, &req, tlen, ret); - if (ret < 0) { - taosMemoryFree(req.qmsg); - return -1; + tEncodeSize(tEncodeSMqRebVgReq, &req, tlen, code); + if (code < 0) { + goto END; } tlen += sizeof(SMsgHead); void *buf = taosMemoryMalloc(tlen); - if (buf == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - taosMemoryFree(req.qmsg); - return -1; - } - + MND_TMQ_NULL_CHECK(buf); SMsgHead *pMsgHead = (SMsgHead *)buf; - pMsgHead->contLen = htonl(tlen); pMsgHead->vgId = htonl(pRebVg->pVgEp->vgId); - SEncoder encoder = {0}; tEncoderInit(&encoder, POINTER_SHIFT(buf, sizeof(SMsgHead)), tlen); - if (tEncodeSMqRebVgReq(&encoder, &req) < 0) { - taosMemoryFreeClear(buf); - tEncoderClear(&encoder); - taosMemoryFree(req.qmsg); - return -1; - } - tEncoderClear(&encoder); + MND_TMQ_RETURN_CHECK(tEncodeSMqRebVgReq(&encoder, &req)); *pBuf = buf; *pLen = tlen; +END: + tEncoderClear(&encoder); taosMemoryFree(req.qmsg); - return 0; + return code; } static int32_t mndPersistSubChangeVgReq(SMnode *pMnode, STrans *pTrans, SMqSubscribeObj *pSub, const SMqRebOutputVg *pRebVg, SSubplan *pPlan) { + int32_t code = 0; + void *buf = NULL; + if (pRebVg->oldConsumerId == pRebVg->newConsumerId) { if (pRebVg->oldConsumerId == -1) return 0; // drop stream, no consumer, while split vnode,all consumerId is -1 - terrno = TSDB_CODE_MND_INVALID_SUB_OPTION; - return -1; - } - - void *buf; - int32_t tlen; - if (mndBuildSubChangeReq(&buf, &tlen, pSub, pRebVg, pPlan) < 0) { - return -1; + code = TSDB_CODE_MND_INVALID_SUB_OPTION; + goto END; } + int32_t tlen = 0; + MND_TMQ_RETURN_CHECK(mndBuildSubChangeReq(&buf, &tlen, pSub, pRebVg, pPlan)); int32_t vgId = pRebVg->pVgEp->vgId; SVgObj *pVgObj = mndAcquireVgroup(pMnode, vgId); if (pVgObj == NULL) { - taosMemoryFree(buf); - terrno = TSDB_CODE_MND_VGROUP_NOT_EXIST; - return -1; + code = TSDB_CODE_MND_VGROUP_NOT_EXIST; + goto END; } STransAction action = {0}; @@ -183,71 +171,87 @@ static int32_t mndPersistSubChangeVgReq(SMnode *pMnode, STrans *pTrans, SMqSubsc action.msgType = TDMT_VND_TMQ_SUBSCRIBE; mndReleaseVgroup(pMnode, pVgObj); - if (mndTransAppendRedoAction(pTrans, &action) != 0) { - taosMemoryFree(buf); - return -1; - } - return 0; + MND_TMQ_RETURN_CHECK(mndTransAppendRedoAction(pTrans, &action)); + return code; + +END: + taosMemoryFree(buf); + return code; } -static int32_t mndSplitSubscribeKey(const char *key, char *topic, char *cgroup, bool fullName) { +static void mndSplitSubscribeKey(const char *key, char *topic, char *cgroup, bool fullName) { int32_t i = 0; - while (key[i] != TMQ_SEPARATOR) { + while (key[i] != TMQ_SEPARATOR_CHAR) { i++; } - memcpy(cgroup, key, i); + (void)memcpy(cgroup, key, i); cgroup[i] = 0; if (fullName) { - strcpy(topic, &key[i + 1]); + (void)strcpy(topic, &key[i + 1]); } else { while (key[i] != '.') { i++; } - strcpy(topic, &key[i + 1]); + (void)strcpy(topic, &key[i + 1]); } - return 0; } -static SMqRebInfo *mndGetOrCreateRebSub(SHashObj *pHash, const char *key) { - SMqRebInfo *pRebInfo = taosHashGet(pHash, key, strlen(key) + 1); +static int32_t mndGetOrCreateRebSub(SHashObj *pHash, const char *key, SMqRebInfo **pReb) { + int32_t code = 0; + SMqRebInfo* pRebInfo = taosHashGet(pHash, key, strlen(key) + 1); if (pRebInfo == NULL) { pRebInfo = tNewSMqRebSubscribe(key); if (pRebInfo == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - return NULL; + code = TSDB_CODE_OUT_OF_MEMORY; + goto END; + } + code = taosHashPut(pHash, key, strlen(key) + 1, pRebInfo, sizeof(SMqRebInfo)); + taosMemoryFreeClear(pRebInfo); + if (code != 0) { + goto END; } - taosHashPut(pHash, key, strlen(key) + 1, pRebInfo, sizeof(SMqRebInfo)); - taosMemoryFree(pRebInfo); pRebInfo = taosHashGet(pHash, key, strlen(key) + 1); + MND_TMQ_NULL_CHECK(pRebInfo); } - return pRebInfo; + if (pReb){ + *pReb = pRebInfo; + } + +END: + return code; } -static void pushVgDataToHash(SArray *vgs, SHashObj *pHash, int64_t consumerId, char *key) { - SMqVgEp *pVgEp = *(SMqVgEp **)taosArrayPop(vgs); - SMqRebOutputVg outputVg = {consumerId, -1, pVgEp}; - taosHashPut(pHash, &pVgEp->vgId, sizeof(int32_t), &outputVg, sizeof(SMqRebOutputVg)); - mInfo("[rebalance] sub:%s mq rebalance remove vgId:%d from consumer:0x%" PRIx64, key, pVgEp->vgId, consumerId); +static int32_t pushVgDataToHash(SArray *vgs, SHashObj *pHash, int64_t consumerId, char *key) { + int32_t code = 0; + SMqVgEp **pVgEp = (SMqVgEp **)taosArrayPop(vgs); + MND_TMQ_NULL_CHECK(pVgEp); + SMqRebOutputVg outputVg = {consumerId, -1, *pVgEp}; + MND_TMQ_RETURN_CHECK(taosHashPut(pHash, &(*pVgEp)->vgId, sizeof(int32_t), &outputVg, sizeof(SMqRebOutputVg))); + mInfo("[rebalance] sub:%s mq rebalance remove vgId:%d from consumer:0x%" PRIx64, key, (*pVgEp)->vgId, consumerId); +END: + return code; } -static void processRemovedConsumers(SMqRebOutputObj *pOutput, SHashObj *pHash, const SMqRebInputObj *pInput) { +static int32_t processRemovedConsumers(SMqRebOutputObj *pOutput, SHashObj *pHash, const SMqRebInputObj *pInput) { + int32_t code = 0; int32_t numOfRemoved = taosArrayGetSize(pInput->pRebInfo->removedConsumers); int32_t actualRemoved = 0; for (int32_t i = 0; i < numOfRemoved; i++) { - uint64_t consumerId = *(uint64_t *)taosArrayGet(pInput->pRebInfo->removedConsumers, i); - SMqConsumerEp *pConsumerEp = taosHashGet(pOutput->pSub->consumerHash, &consumerId, sizeof(int64_t)); + int64_t* consumerId = (int64_t *)taosArrayGet(pInput->pRebInfo->removedConsumers, i); + MND_TMQ_NULL_CHECK(consumerId); + SMqConsumerEp *pConsumerEp = taosHashGet(pOutput->pSub->consumerHash, consumerId, sizeof(int64_t)); if (pConsumerEp == NULL) { continue; } int32_t consumerVgNum = taosArrayGetSize(pConsumerEp->vgs); for (int32_t j = 0; j < consumerVgNum; j++) { - pushVgDataToHash(pConsumerEp->vgs, pHash, consumerId, pOutput->pSub->key); + MND_TMQ_RETURN_CHECK(pushVgDataToHash(pConsumerEp->vgs, pHash, *consumerId, pOutput->pSub->key)); } - taosArrayDestroy(pConsumerEp->vgs); - taosHashRemove(pOutput->pSub->consumerHash, &consumerId, sizeof(int64_t)); - taosArrayPush(pOutput->removedConsumers, &consumerId); + (void)taosArrayDestroy(pConsumerEp->vgs); + MND_TMQ_RETURN_CHECK(taosHashRemove(pOutput->pSub->consumerHash, consumerId, sizeof(int64_t))); + MND_TMQ_NULL_CHECK(taosArrayPush(pOutput->removedConsumers, consumerId)); actualRemoved++; } @@ -257,45 +261,42 @@ static void processRemovedConsumers(SMqRebOutputObj *pOutput, SHashObj *pHash, c } else { mInfo("[rebalance] sub:%s removed %d consumers", pOutput->pSub->key, numOfRemoved); } +END: + return code; } -static void processNewConsumers(SMqRebOutputObj *pOutput, const SMqRebInputObj *pInput) { +static int32_t processNewConsumers(SMqRebOutputObj *pOutput, const SMqRebInputObj *pInput) { + int32_t code = 0; int32_t numOfNewConsumers = taosArrayGetSize(pInput->pRebInfo->newConsumers); for (int32_t i = 0; i < numOfNewConsumers; i++) { - int64_t consumerId = *(int64_t *)taosArrayGet(pInput->pRebInfo->newConsumers, i); - + int64_t* consumerId = (int64_t *)taosArrayGet(pInput->pRebInfo->newConsumers, i); + MND_TMQ_NULL_CHECK(consumerId); SMqConsumerEp newConsumerEp = {0}; - newConsumerEp.consumerId = consumerId; + newConsumerEp.consumerId = *consumerId; newConsumerEp.vgs = taosArrayInit(0, sizeof(void *)); - - taosHashPut(pOutput->pSub->consumerHash, &consumerId, sizeof(int64_t), &newConsumerEp, sizeof(SMqConsumerEp)); - taosArrayPush(pOutput->newConsumers, &consumerId); - mInfo("[rebalance] sub:%s mq rebalance add new consumer:0x%" PRIx64, pOutput->pSub->key, consumerId); + MND_TMQ_NULL_CHECK(newConsumerEp.vgs); + MND_TMQ_RETURN_CHECK(taosHashPut(pOutput->pSub->consumerHash, consumerId, sizeof(int64_t), &newConsumerEp, sizeof(SMqConsumerEp))); + MND_TMQ_NULL_CHECK(taosArrayPush(pOutput->newConsumers, consumerId)); + mInfo("[rebalance] sub:%s mq rebalance add new consumer:0x%" PRIx64, pOutput->pSub->key, *consumerId); } +END: + return code; } -static void processUnassignedVgroups(SMqRebOutputObj *pOutput, SHashObj *pHash) { +static int32_t processUnassignedVgroups(SMqRebOutputObj *pOutput, SHashObj *pHash) { + int32_t code = 0; int32_t numOfVgroups = taosArrayGetSize(pOutput->pSub->unassignedVgs); for (int32_t i = 0; i < numOfVgroups; i++) { - pushVgDataToHash(pOutput->pSub->unassignedVgs, pHash, -1, pOutput->pSub->key); + MND_TMQ_RETURN_CHECK(pushVgDataToHash(pOutput->pSub->unassignedVgs, pHash, -1, pOutput->pSub->key)); } +END: + return code; } -// static void putNoTransferToOutput(SMqRebOutputObj *pOutput, SMqConsumerEp *pConsumerEp){ -// for(int i = 0; i < taosArrayGetSize(pConsumerEp->vgs); i++){ -// SMqVgEp *pVgEp = (SMqVgEp *)taosArrayGetP(pConsumerEp->vgs, i); -// SMqRebOutputVg outputVg = { -// .oldConsumerId = pConsumerEp->consumerId, -// .newConsumerId = pConsumerEp->consumerId, -// .pVgEp = pVgEp, -// }; -// taosArrayPush(pOutput->rebVgs, &outputVg); -// } -// } - -static void processModifiedConsumers(SMqRebOutputObj *pOutput, SHashObj *pHash, int32_t minVgCnt, +static int32_t processModifiedConsumers(SMqRebOutputObj *pOutput, SHashObj *pHash, int32_t minVgCnt, int32_t remainderVgCnt) { + int32_t code = 0; int32_t cnt = 0; void *pIter = NULL; @@ -308,28 +309,31 @@ static void processModifiedConsumers(SMqRebOutputObj *pOutput, SHashObj *pHash, SMqConsumerEp *pConsumerEp = (SMqConsumerEp *)pIter; int32_t consumerVgNum = taosArrayGetSize(pConsumerEp->vgs); - taosArrayPush(pOutput->modifyConsumers, &pConsumerEp->consumerId); + MND_TMQ_NULL_CHECK(taosArrayPush(pOutput->modifyConsumers, &pConsumerEp->consumerId)); if (consumerVgNum > minVgCnt) { if (cnt < remainderVgCnt) { while (taosArrayGetSize(pConsumerEp->vgs) > minVgCnt + 1) { // pop until equal minVg + 1 - pushVgDataToHash(pConsumerEp->vgs, pHash, pConsumerEp->consumerId, pOutput->pSub->key); + MND_TMQ_RETURN_CHECK(pushVgDataToHash(pConsumerEp->vgs, pHash, pConsumerEp->consumerId, pOutput->pSub->key)); } cnt++; } else { while (taosArrayGetSize(pConsumerEp->vgs) > minVgCnt) { - pushVgDataToHash(pConsumerEp->vgs, pHash, pConsumerEp->consumerId, pOutput->pSub->key); + MND_TMQ_RETURN_CHECK(pushVgDataToHash(pConsumerEp->vgs, pHash, pConsumerEp->consumerId, pOutput->pSub->key)); } } } - // putNoTransferToOutput(pOutput, pConsumerEp); } +END: + return code; } static int32_t processRemoveAddVgs(SMnode *pMnode, SMqRebOutputObj *pOutput) { + int32_t code = 0; int32_t totalVgNum = 0; SVgObj *pVgroup = NULL; void *pIter = NULL; SArray *newVgs = taosArrayInit(0, POINTER_BYTES); + MND_TMQ_NULL_CHECK(newVgs); while (1) { pIter = sdbFetch(pMnode->pSdb, SDB_VGROUP, pIter, (void **)&pVgroup); if (pIter == NULL) { @@ -343,9 +347,10 @@ static int32_t processRemoveAddVgs(SMnode *pMnode, SMqRebOutputObj *pOutput) { totalVgNum++; SMqVgEp *pVgEp = taosMemoryMalloc(sizeof(SMqVgEp)); + MND_TMQ_NULL_CHECK(pVgEp); pVgEp->epSet = mndGetVgroupEpset(pMnode, pVgroup); pVgEp->vgId = pVgroup->vgId; - taosArrayPush(newVgs, &pVgEp); + MND_TMQ_NULL_CHECK(taosArrayPush(newVgs, &pVgEp)); sdbRelease(pMnode->pSdb, pVgroup); } @@ -354,13 +359,14 @@ static int32_t processRemoveAddVgs(SMnode *pMnode, SMqRebOutputObj *pOutput) { pIter = taosHashIterate(pOutput->pSub->consumerHash, pIter); if (pIter == NULL) break; SMqConsumerEp *pConsumerEp = (SMqConsumerEp *)pIter; - int32_t j = 0; while (j < taosArrayGetSize(pConsumerEp->vgs)) { SMqVgEp *pVgEp = taosArrayGetP(pConsumerEp->vgs, j); + MND_TMQ_NULL_CHECK(pVgEp); bool find = false; for (int32_t k = 0; k < taosArrayGetSize(newVgs); k++) { SMqVgEp *pnewVgEp = taosArrayGetP(newVgs, k); + MND_TMQ_NULL_CHECK(pnewVgEp); if (pVgEp->vgId == pnewVgEp->vgId) { tDeleteSMqVgEp(pnewVgEp); taosArrayRemove(newVgs, k); @@ -379,23 +385,29 @@ static int32_t processRemoveAddVgs(SMnode *pMnode, SMqRebOutputObj *pOutput) { } if (taosArrayGetSize(pOutput->pSub->unassignedVgs) == 0 && taosArrayGetSize(newVgs) != 0) { - taosArrayAddAll(pOutput->pSub->unassignedVgs, newVgs); + MND_TMQ_NULL_CHECK(taosArrayAddAll(pOutput->pSub->unassignedVgs, newVgs)); mInfo("[rebalance] processRemoveAddVgs add new vg num:%d", (int)taosArrayGetSize(newVgs)); - taosArrayDestroy(newVgs); + (void)taosArrayDestroy(newVgs); } else { - taosArrayDestroyP(newVgs, (FDelete)tDeleteSMqVgEp); + (void)taosArrayDestroyP(newVgs, (FDelete)tDeleteSMqVgEp); } return totalVgNum; +END: + return code; } -static void processSubOffsetRows(SMnode *pMnode, const SMqRebInputObj *pInput, SMqRebOutputObj *pOutput) { - SMqSubscribeObj *pSub = mndAcquireSubscribeByKey(pMnode, pInput->pRebInfo->key); // put all offset rows - if (pSub == NULL) { - return; - } +static int32_t processSubOffsetRows(SMnode *pMnode, const SMqRebInputObj *pInput, SMqRebOutputObj *pOutput) { + int32_t code = 0; + SMqSubscribeObj *pSub = NULL; + MND_TMQ_RETURN_CHECK(mndAcquireSubscribeByKey(pMnode, pInput->pRebInfo->key, &pSub)); // put all offset rows taosRLockLatch(&pSub->lock); if (pOutput->pSub->offsetRows == NULL) { pOutput->pSub->offsetRows = taosArrayInit(4, sizeof(OffsetRows)); + if(pOutput->pSub->offsetRows == NULL) { + taosRUnLockLatch(&pSub->lock); + code = TSDB_CODE_OUT_OF_MEMORY; + goto END; + } } void *pIter = NULL; while (1) { @@ -406,9 +418,11 @@ static void processSubOffsetRows(SMnode *pMnode, const SMqRebInputObj *pInput, S for (int j = 0; j < taosArrayGetSize(pConsumerEp->offsetRows); j++) { OffsetRows *d1 = taosArrayGet(pConsumerEp->offsetRows, j); + MND_TMQ_NULL_CHECK(d1); bool jump = false; for (int i = 0; pConsumerEpNew && i < taosArrayGetSize(pConsumerEpNew->vgs); i++) { SMqVgEp *pVgEp = taosArrayGetP(pConsumerEpNew->vgs, i); + MND_TMQ_NULL_CHECK(pVgEp); if (pVgEp->vgId == d1->vgId) { jump = true; mInfo("pSub->offsetRows jump, because consumer id:0x%" PRIx64 " and vgId:%d not change", @@ -420,6 +434,7 @@ static void processSubOffsetRows(SMnode *pMnode, const SMqRebInputObj *pInput, S bool find = false; for (int i = 0; i < taosArrayGetSize(pOutput->pSub->offsetRows); i++) { OffsetRows *d2 = taosArrayGet(pOutput->pSub->offsetRows, i); + MND_TMQ_NULL_CHECK(d2); if (d1->vgId == d2->vgId) { d2->rows += d1->rows; d2->offset = d1->offset; @@ -430,18 +445,22 @@ static void processSubOffsetRows(SMnode *pMnode, const SMqRebInputObj *pInput, S } } if (!find) { - taosArrayPush(pOutput->pSub->offsetRows, d1); + MND_TMQ_NULL_CHECK(taosArrayPush(pOutput->pSub->offsetRows, d1)); } } } taosRUnLockLatch(&pSub->lock); mndReleaseSubscribe(pMnode, pSub); + +END: + return code; } static void printRebalanceLog(SMqRebOutputObj *pOutput) { mInfo("sub:%s mq rebalance calculation completed, re-balanced vg", pOutput->pSub->key); for (int32_t i = 0; i < taosArrayGetSize(pOutput->rebVgs); i++) { SMqRebOutputVg *pOutputRebVg = taosArrayGet(pOutput->rebVgs, i); + if (pOutputRebVg == NULL) continue; mInfo("sub:%s mq rebalance vgId:%d, moved from consumer:0x%" PRIx64 ", to consumer:0x%" PRIx64, pOutput->pSub->key, pOutputRebVg->pVgEp->vgId, pOutputRebVg->oldConsumerId, pOutputRebVg->newConsumerId); } @@ -456,6 +475,7 @@ static void printRebalanceLog(SMqRebOutputObj *pOutput) { pConsumerEp->consumerId, sz); for (int32_t i = 0; i < sz; i++) { SMqVgEp *pVgEp = taosArrayGetP(pConsumerEp->vgs, i); + if (pVgEp == NULL) continue; mInfo("sub:%s mq rebalance final cfg: vg %d to consumer:0x%" PRIx64, pOutput->pSub->key, pVgEp->vgId, pConsumerEp->consumerId); } @@ -480,10 +500,11 @@ static void calcVgroupsCnt(const SMqRebInputObj *pInput, int32_t totalVgNum, con pSubKey, totalVgNum, pInput->oldConsumerNum, numOfAdded, numOfRemoved, *minVgCnt, *remainderVgCnt); } -static void assignVgroups(SMqRebOutputObj *pOutput, SHashObj *pHash, int32_t minVgCnt) { +static int32_t assignVgroups(SMqRebOutputObj *pOutput, SHashObj *pHash, int32_t minVgCnt) { SMqRebOutputVg *pRebVg = NULL; void *pAssignIter = NULL; void *pIter = NULL; + int32_t code = 0; while (1) { pIter = taosHashIterate(pOutput->pSub->consumerHash, pIter); @@ -500,7 +521,7 @@ static void assignVgroups(SMqRebOutputObj *pOutput, SHashObj *pHash, int32_t min pRebVg = (SMqRebOutputVg *)pAssignIter; pRebVg->newConsumerId = pConsumerEp->consumerId; - taosArrayPush(pConsumerEp->vgs, &pRebVg->pVgEp); + MND_TMQ_NULL_CHECK(taosArrayPush(pConsumerEp->vgs, &pRebVg->pVgEp)); mInfo("[rebalance] mq rebalance: add vgId:%d to consumer:0x%" PRIx64 " for average", pRebVg->pVgEp->vgId, pConsumerEp->consumerId); } @@ -521,7 +542,7 @@ static void assignVgroups(SMqRebOutputObj *pOutput, SHashObj *pHash, int32_t min pRebVg = (SMqRebOutputVg *)pAssignIter; pRebVg->newConsumerId = pConsumerEp->consumerId; - taosArrayPush(pConsumerEp->vgs, &pRebVg->pVgEp); + MND_TMQ_NULL_CHECK(taosArrayPush(pConsumerEp->vgs, &pRebVg->pVgEp)); mInfo("[rebalance] mq rebalance: add vgId:%d to consumer:0x%" PRIx64 " for average + 1", pRebVg->pVgEp->vgId, pConsumerEp->consumerId); } @@ -530,6 +551,8 @@ static void assignVgroups(SMqRebOutputObj *pOutput, SHashObj *pHash, int32_t min taosHashCancelIterate(pOutput->pSub->consumerHash, pIter); if (pAssignIter != NULL) { mError("[rebalance]sub:%s assign iter is not NULL, never should reach here", pOutput->pSub->key); + code = TSDB_CODE_PAR_INTERNAL_ERROR; + goto END; } while (1) { pAssignIter = taosHashIterate(pHash, pAssignIter); @@ -538,30 +561,39 @@ static void assignVgroups(SMqRebOutputObj *pOutput, SHashObj *pHash, int32_t min } SMqRebOutputVg *pRebOutput = (SMqRebOutputVg *)pAssignIter; - taosArrayPush(pOutput->rebVgs, pRebOutput); + MND_TMQ_NULL_CHECK(taosArrayPush(pOutput->rebVgs, pRebOutput)); if (taosHashGetSize(pOutput->pSub->consumerHash) == 0) { // if all consumer is removed - taosArrayPush(pOutput->pSub->unassignedVgs, &pRebOutput->pVgEp); // put all vg into unassigned + MND_TMQ_NULL_CHECK(taosArrayPush(pOutput->pSub->unassignedVgs, &pRebOutput->pVgEp)); // put all vg into unassigned } } + +END: + return code; } -static void mndDoRebalance(SMnode *pMnode, const SMqRebInputObj *pInput, SMqRebOutputObj *pOutput) { +static int32_t mndDoRebalance(SMnode *pMnode, const SMqRebInputObj *pInput, SMqRebOutputObj *pOutput) { int32_t totalVgNum = processRemoveAddVgs(pMnode, pOutput); + if (totalVgNum < 0){ + return totalVgNum; + } const char *pSubKey = pOutput->pSub->key; int32_t minVgCnt = 0; int32_t remainderVgCnt = 0; - - SHashObj *pHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK); - - processRemovedConsumers(pOutput, pHash, pInput); - processUnassignedVgroups(pOutput, pHash); + int32_t code = 0; + SHashObj *pHash = taosHashInit(64, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT), false, HASH_NO_LOCK); + MND_TMQ_NULL_CHECK(pHash); + MND_TMQ_RETURN_CHECK(processRemovedConsumers(pOutput, pHash, pInput)); + MND_TMQ_RETURN_CHECK(processUnassignedVgroups(pOutput, pHash)); calcVgroupsCnt(pInput, totalVgNum, pSubKey, &minVgCnt, &remainderVgCnt); - processModifiedConsumers(pOutput, pHash, minVgCnt, remainderVgCnt); - processNewConsumers(pOutput, pInput); - assignVgroups(pOutput, pHash, minVgCnt); - processSubOffsetRows(pMnode, pInput, pOutput); + MND_TMQ_RETURN_CHECK(processModifiedConsumers(pOutput, pHash, minVgCnt, remainderVgCnt)); + MND_TMQ_RETURN_CHECK(processNewConsumers(pOutput, pInput)); + MND_TMQ_RETURN_CHECK(assignVgroups(pOutput, pHash, minVgCnt)); + MND_TMQ_RETURN_CHECK(processSubOffsetRows(pMnode, pInput, pOutput)); printRebalanceLog(pOutput); taosHashCleanup(pHash); + +END: + return code; } static int32_t presistConsumerByType(STrans *pTrans, SArray *consumers, int8_t type, char *cgroup, char *topic) { @@ -569,18 +601,10 @@ static int32_t presistConsumerByType(STrans *pTrans, SArray *consumers, int8_t t SMqConsumerObj *pConsumerNew = NULL; int32_t consumerNum = taosArrayGetSize(consumers); for (int32_t i = 0; i < consumerNum; i++) { - int64_t consumerId = *(int64_t *)taosArrayGet(consumers, i); - pConsumerNew = tNewSMqConsumerObj(consumerId, cgroup, type, topic, NULL); - if (pConsumerNew == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto END; - } - - code = mndSetConsumerCommitLogs(pTrans, pConsumerNew); - if (code != 0) { - goto END; - } - + int64_t* consumerId = (int64_t *)taosArrayGet(consumers, i); + MND_TMQ_NULL_CHECK(consumerId); + MND_TMQ_RETURN_CHECK(tNewSMqConsumerObj(*consumerId, cgroup, type, topic, NULL, &pConsumerNew)); + MND_TMQ_RETURN_CHECK(mndSetConsumerCommitLogs(pTrans, pConsumerNew)); tDeleteSMqConsumerObj(pConsumerNew); } pConsumerNew = NULL; @@ -591,17 +615,12 @@ END: } static int32_t mndPresistConsumer(STrans *pTrans, const SMqRebOutputObj *pOutput, char *cgroup, char *topic) { - int32_t code = presistConsumerByType(pTrans, pOutput->modifyConsumers, CONSUMER_UPDATE_REB, cgroup, NULL); - if (code != 0) { - return code; - } - - code = presistConsumerByType(pTrans, pOutput->newConsumers, CONSUMER_ADD_REB, cgroup, topic); - if (code != 0) { - return code; - } - - return presistConsumerByType(pTrans, pOutput->removedConsumers, CONSUMER_REMOVE_REB, cgroup, topic); + int32_t code = 0; + MND_TMQ_RETURN_CHECK(presistConsumerByType(pTrans, pOutput->modifyConsumers, CONSUMER_UPDATE_REB, cgroup, NULL)); + MND_TMQ_RETURN_CHECK(presistConsumerByType(pTrans, pOutput->newConsumers, CONSUMER_ADD_REB, cgroup, topic)); + MND_TMQ_RETURN_CHECK(presistConsumerByType(pTrans, pOutput->removedConsumers, CONSUMER_REMOVE_REB, cgroup, topic)); +END: + return code; } static int32_t mndPersistRebResult(SMnode *pMnode, SRpcMsg *pMsg, const SMqRebOutputObj *pOutput) { @@ -610,11 +629,7 @@ static int32_t mndPersistRebResult(SMnode *pMnode, SRpcMsg *pMsg, const SMqRebOu STrans *pTrans = NULL; if (strcmp(pOutput->pSub->qmsg, "") != 0) { - code = qStringToSubplan(pOutput->pSub->qmsg, &pPlan); - if (code != 0) { - terrno = code; - goto END; - } + MND_TMQ_RETURN_CHECK(qStringToSubplan(pOutput->pSub->qmsg, &pPlan)); } char topic[TSDB_TOPIC_FNAME_LEN] = {0}; @@ -628,39 +643,28 @@ static int32_t mndPersistRebResult(SMnode *pMnode, SRpcMsg *pMsg, const SMqRebOu } mndTransSetDbName(pTrans, pOutput->pSub->dbName, cgroup); - code = mndTransCheckConflict(pMnode, pTrans); - if (code != 0) { - goto END; - } + MND_TMQ_RETURN_CHECK(mndTransCheckConflict(pMnode, pTrans)); // 1. redo action: action to all vg const SArray *rebVgs = pOutput->rebVgs; int32_t vgNum = taosArrayGetSize(rebVgs); for (int32_t i = 0; i < vgNum; i++) { SMqRebOutputVg *pRebVg = taosArrayGet(rebVgs, i); - code = mndPersistSubChangeVgReq(pMnode, pTrans, pOutput->pSub, pRebVg, pPlan); - if (code != 0) { - goto END; - } + MND_TMQ_NULL_CHECK(pRebVg); + MND_TMQ_RETURN_CHECK(mndPersistSubChangeVgReq(pMnode, pTrans, pOutput->pSub, pRebVg, pPlan)); } // 2. commit log: subscribe and vg assignment - code = mndSetSubCommitLogs(pTrans, pOutput->pSub); - if (code != 0) { - goto END; - } + MND_TMQ_RETURN_CHECK(mndSetSubCommitLogs(pTrans, pOutput->pSub)); // 3. commit log: consumer to update status and epoch - code = mndPresistConsumer(pTrans, pOutput, cgroup, topic); - if (code != 0) { - goto END; - } + MND_TMQ_RETURN_CHECK(mndPresistConsumer(pTrans, pOutput, cgroup, topic)); // 4. set cb mndTransSetCb(pTrans, TRANS_START_FUNC_MQ_REB, TRANS_STOP_FUNC_MQ_REB, NULL, 0); // 5. execution - code = mndTransPrepare(pMnode, pTrans); + MND_TMQ_RETURN_CHECK(mndTransPrepare(pMnode, pTrans)); END: nodesDestroyNode((SNode *)pPlan); @@ -670,46 +674,63 @@ END: static void freeRebalanceItem(void *param) { SMqRebInfo *pInfo = param; - taosArrayDestroy(pInfo->newConsumers); - taosArrayDestroy(pInfo->removedConsumers); + (void)taosArrayDestroy(pInfo->newConsumers); + (void)taosArrayDestroy(pInfo->removedConsumers); } // type = 0 remove type = 1 add -static void buildRebInfo(SHashObj *rebSubHash, SArray *topicList, int8_t type, char *group, int64_t consumerId) { +static int32_t buildRebInfo(SHashObj *rebSubHash, SArray *topicList, int8_t type, char *group, int64_t consumerId) { + int32_t code = 0; int32_t topicNum = taosArrayGetSize(topicList); for (int32_t i = 0; i < topicNum; i++) { - char key[TSDB_SUBSCRIBE_KEY_LEN]; char *removedTopic = taosArrayGetP(topicList, i); - mndMakeSubscribeKey(key, group, removedTopic); - SMqRebInfo *pRebSub = mndGetOrCreateRebSub(rebSubHash, key); + MND_TMQ_NULL_CHECK(removedTopic); + char key[TSDB_SUBSCRIBE_KEY_LEN] = {0}; + (void)snprintf(key, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", group, TMQ_SEPARATOR, removedTopic); + SMqRebInfo *pRebSub = NULL; + MND_TMQ_RETURN_CHECK(mndGetOrCreateRebSub(rebSubHash, key, &pRebSub)); if (type == 0) - taosArrayPush(pRebSub->removedConsumers, &consumerId); + MND_TMQ_NULL_CHECK(taosArrayPush(pRebSub->removedConsumers, &consumerId)); else if (type == 1) - taosArrayPush(pRebSub->newConsumers, &consumerId); + MND_TMQ_NULL_CHECK(taosArrayPush(pRebSub->newConsumers, &consumerId)); } + +END: + return code; } static void checkForVgroupSplit(SMnode *pMnode, SMqConsumerObj *pConsumer, SHashObj *rebSubHash) { int32_t newTopicNum = taosArrayGetSize(pConsumer->currentTopics); for (int32_t i = 0; i < newTopicNum; i++) { char *topic = taosArrayGetP(pConsumer->currentTopics, i); - SMqSubscribeObj *pSub = mndAcquireSubscribe(pMnode, pConsumer->cgroup, topic); - if (pSub == NULL) { + if (topic == NULL){ + continue; + } + SMqSubscribeObj *pSub = NULL; + char key[TSDB_SUBSCRIBE_KEY_LEN] = {0}; + (void)snprintf(key, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", pConsumer->cgroup, TMQ_SEPARATOR, topic); + int32_t code = mndAcquireSubscribeByKey(pMnode, key, &pSub); + if (code != 0) { continue; } taosRLockLatch(&pSub->lock); // iterate all vg assigned to the consumer of that topic SMqConsumerEp *pConsumerEp = taosHashGet(pSub->consumerHash, &pConsumer->consumerId, sizeof(int64_t)); - int32_t vgNum = taosArrayGetSize(pConsumerEp->vgs); - + if (pConsumerEp == NULL){ + taosRUnLockLatch(&pSub->lock); + mndReleaseSubscribe(pMnode, pSub); + continue; + } + int32_t vgNum = taosArrayGetSize(pConsumerEp->vgs); for (int32_t j = 0; j < vgNum; j++) { SMqVgEp *pVgEp = taosArrayGetP(pConsumerEp->vgs, j); + if (pVgEp == NULL) { + continue; + } SVgObj *pVgroup = mndAcquireVgroup(pMnode, pVgEp->vgId); if (!pVgroup) { - char key[TSDB_SUBSCRIBE_KEY_LEN]; - mndMakeSubscribeKey(key, pConsumer->cgroup, topic); - mndGetOrCreateRebSub(rebSubHash, key); + (void)mndGetOrCreateRebSub(rebSubHash, key, NULL); mInfo("vnode splitted, vgId:%d rebalance will be triggered", pVgEp->vgId); } mndReleaseVgroup(pMnode, pVgroup); @@ -719,11 +740,12 @@ static void checkForVgroupSplit(SMnode *pMnode, SMqConsumerObj *pConsumer, SHash } } -static void mndCheckConsumer(SRpcMsg *pMsg, SHashObj *rebSubHash) { +static int32_t mndCheckConsumer(SRpcMsg *pMsg, SHashObj *rebSubHash) { SMnode *pMnode = pMsg->info.node; SSdb *pSdb = pMnode->pSdb; SMqConsumerObj *pConsumer = NULL; void *pIter = NULL; + int32_t code = 0; // iterate all consumers, find all modification while (1) { @@ -742,27 +764,29 @@ static void mndCheckConsumer(SRpcMsg *pMsg, SHashObj *rebSubHash) { if (status == MQ_CONSUMER_STATUS_READY) { if (taosArrayGetSize(pConsumer->assignedTopics) == 0) { // unsubscribe or close - mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_LOST_CONSUMER_CLEAR, &pMsg->info); + MND_TMQ_RETURN_CHECK(mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_LOST_CONSUMER_CLEAR, &pMsg->info)); } else if (hbStatus > MND_CONSUMER_LOST_HB_CNT) { taosRLockLatch(&pConsumer->lock); - buildRebInfo(rebSubHash, pConsumer->currentTopics, 0, pConsumer->cgroup, pConsumer->consumerId); + MND_TMQ_RETURN_CHECK(buildRebInfo(rebSubHash, pConsumer->currentTopics, 0, pConsumer->cgroup, pConsumer->consumerId)); taosRUnLockLatch(&pConsumer->lock); } else { checkForVgroupSplit(pMnode, pConsumer, rebSubHash); } } else if (status == MQ_CONSUMER_STATUS_LOST) { if (hbStatus > MND_CONSUMER_LOST_CLEAR_THRESHOLD) { // clear consumer if lost a day - mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_LOST_CONSUMER_CLEAR, &pMsg->info); + MND_TMQ_RETURN_CHECK(mndSendConsumerMsg(pMnode, pConsumer->consumerId, TDMT_MND_TMQ_LOST_CONSUMER_CLEAR, &pMsg->info)); } } else { taosRLockLatch(&pConsumer->lock); - buildRebInfo(rebSubHash, pConsumer->rebNewTopics, 1, pConsumer->cgroup, pConsumer->consumerId); - buildRebInfo(rebSubHash, pConsumer->rebRemovedTopics, 0, pConsumer->cgroup, pConsumer->consumerId); + MND_TMQ_RETURN_CHECK(buildRebInfo(rebSubHash, pConsumer->rebNewTopics, 1, pConsumer->cgroup, pConsumer->consumerId)); + MND_TMQ_RETURN_CHECK(buildRebInfo(rebSubHash, pConsumer->rebRemovedTopics, 0, pConsumer->cgroup, pConsumer->consumerId)); taosRUnLockLatch(&pConsumer->lock); } mndReleaseConsumer(pMnode, pConsumer); } +END: + return code; } bool mndRebTryStart() { @@ -781,31 +805,35 @@ void mndRebCntDec() { } static void clearRebOutput(SMqRebOutputObj *rebOutput) { - taosArrayDestroy(rebOutput->newConsumers); - taosArrayDestroy(rebOutput->modifyConsumers); - taosArrayDestroy(rebOutput->removedConsumers); - taosArrayDestroy(rebOutput->rebVgs); + (void)taosArrayDestroy(rebOutput->newConsumers); + (void)taosArrayDestroy(rebOutput->modifyConsumers); + (void)taosArrayDestroy(rebOutput->removedConsumers); + (void)taosArrayDestroy(rebOutput->rebVgs); tDeleteSubscribeObj(rebOutput->pSub); taosMemoryFree(rebOutput->pSub); } static int32_t initRebOutput(SMqRebOutputObj *rebOutput) { + int32_t code = 0; rebOutput->newConsumers = taosArrayInit(0, sizeof(int64_t)); + MND_TMQ_NULL_CHECK(rebOutput->newConsumers); rebOutput->removedConsumers = taosArrayInit(0, sizeof(int64_t)); + MND_TMQ_NULL_CHECK(rebOutput->removedConsumers); rebOutput->modifyConsumers = taosArrayInit(0, sizeof(int64_t)); + MND_TMQ_NULL_CHECK(rebOutput->modifyConsumers); rebOutput->rebVgs = taosArrayInit(0, sizeof(SMqRebOutputVg)); + MND_TMQ_NULL_CHECK(rebOutput->rebVgs); + return code; - if (rebOutput->newConsumers == NULL || rebOutput->removedConsumers == NULL || rebOutput->modifyConsumers == NULL || - rebOutput->rebVgs == NULL) { - clearRebOutput(rebOutput); - return TSDB_CODE_OUT_OF_MEMORY; - } - return 0; +END: + clearRebOutput(rebOutput); + return code; } // This function only works when there are dirty consumers -static void checkConsumer(SMnode *pMnode, SMqSubscribeObj *pSub) { - void *pIter = NULL; +static int32_t checkConsumer(SMnode *pMnode, SMqSubscribeObj *pSub) { + int32_t code = 0; + void *pIter = NULL; while (1) { pIter = taosHashIterate(pSub->consumerHash, pIter); if (pIter == NULL) { @@ -813,83 +841,89 @@ static void checkConsumer(SMnode *pMnode, SMqSubscribeObj *pSub) { } SMqConsumerEp *pConsumerEp = (SMqConsumerEp *)pIter; - SMqConsumerObj *pConsumer = mndAcquireConsumer(pMnode, pConsumerEp->consumerId); - if (pConsumer != NULL) { + SMqConsumerObj *pConsumer = NULL; + code = mndAcquireConsumer(pMnode, pConsumerEp->consumerId, &pConsumer); + if (code == 0) { mndReleaseConsumer(pMnode, pConsumer); continue; } mError("consumer:0x%" PRIx64 " not exists in sdb for exception", pConsumerEp->consumerId); - taosArrayAddAll(pSub->unassignedVgs, pConsumerEp->vgs); + MND_TMQ_NULL_CHECK(taosArrayAddAll(pSub->unassignedVgs, pConsumerEp->vgs)); - taosArrayDestroy(pConsumerEp->vgs); - taosHashRemove(pSub->consumerHash, &pConsumerEp->consumerId, sizeof(int64_t)); + (void)taosArrayDestroy(pConsumerEp->vgs); + MND_TMQ_RETURN_CHECK(taosHashRemove(pSub->consumerHash, &pConsumerEp->consumerId, sizeof(int64_t))); } +END: + return code; } static int32_t buildRebOutput(SMnode *pMnode, SMqRebInputObj *rebInput, SMqRebOutputObj *rebOutput) { + int32_t code = 0; const char *key = rebInput->pRebInfo->key; - SMqSubscribeObj *pSub = mndAcquireSubscribeByKey(pMnode, key); + SMqSubscribeObj *pSub = NULL; + MND_TMQ_RETURN_CHECK(mndAcquireSubscribeByKey(pMnode, key, &pSub)); if (pSub == NULL) { // split sub key and extract topic - char topic[TSDB_TOPIC_FNAME_LEN]; - char cgroup[TSDB_CGROUP_LEN]; + char topic[TSDB_TOPIC_FNAME_LEN] = {0}; + char cgroup[TSDB_CGROUP_LEN] = {0}; mndSplitSubscribeKey(key, topic, cgroup, true); - - SMqTopicObj *pTopic = mndAcquireTopic(pMnode, topic); - if (pTopic == NULL) { - mError("[rebalance] mq rebalance %s ignored since topic %s doesn't exist", key, topic); - return -1; - } - + SMqTopicObj *pTopic = NULL; + MND_TMQ_RETURN_CHECK(mndAcquireTopic(pMnode, topic, &pTopic)); taosRLockLatch(&pTopic->lock); rebInput->oldConsumerNum = 0; - rebOutput->pSub = mndCreateSubscription(pMnode, pTopic, key); - - if (rebOutput->pSub == NULL) { + code = mndCreateSubscription(pMnode, pTopic, key, &rebOutput->pSub); + if (code != 0) { mError("[rebalance] mq rebalance %s failed create sub since %s, ignore", key, terrstr()); taosRUnLockLatch(&pTopic->lock); mndReleaseTopic(pMnode, pTopic); - return -1; + return code; } - memcpy(rebOutput->pSub->dbName, pTopic->db, TSDB_DB_FNAME_LEN); + (void)memcpy(rebOutput->pSub->dbName, pTopic->db, TSDB_DB_FNAME_LEN); taosRUnLockLatch(&pTopic->lock); mndReleaseTopic(pMnode, pTopic); mInfo("[rebalance] sub topic:%s has no consumers sub yet", key); } else { taosRLockLatch(&pSub->lock); - rebOutput->pSub = tCloneSubscribeObj(pSub); - checkConsumer(pMnode, rebOutput->pSub); + code = tCloneSubscribeObj(pSub, &rebOutput->pSub); + if(code != 0){ + taosRUnLockLatch(&pSub->lock); + goto END; + } + code =checkConsumer(pMnode, rebOutput->pSub); + if(code != 0){ + taosRUnLockLatch(&pSub->lock); + goto END; + } rebInput->oldConsumerNum = taosHashGetSize(rebOutput->pSub->consumerHash); taosRUnLockLatch(&pSub->lock); mInfo("[rebalance] sub topic:%s has %d consumers sub till now", key, rebInput->oldConsumerNum); mndReleaseSubscribe(pMnode, pSub); } - return 0; + +END: + return code; } static int32_t mndProcessRebalanceReq(SRpcMsg *pMsg) { int code = 0; void *pIter = NULL; SMnode *pMnode = pMsg->info.node; - mDebug("[rebalance] start to process mq timer") - - if (!mndRebTryStart()) { - mInfo("[rebalance] mq rebalance already in progress, do nothing") return code; + mDebug("[rebalance] start to process mq timer"); + if (!mndRebTryStart()) { + mInfo("[rebalance] mq rebalance already in progress, do nothing"); + return code; } SHashObj *rebSubHash = taosHashInit(64, MurmurHash3_32, true, HASH_NO_LOCK); - if (rebSubHash == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto END; - } + MND_TMQ_NULL_CHECK(rebSubHash); taosHashSetFreeFp(rebSubHash, freeRebalanceItem); - mndCheckConsumer(pMsg, rebSubHash); + MND_TMQ_RETURN_CHECK(mndCheckConsumer(pMsg, rebSubHash)); if (taosHashGetSize(rebSubHash) > 0) { mInfo("[rebalance] mq rebalance start, total required re-balanced trans:%d", taosHashGetSize(rebSubHash)) } @@ -902,21 +936,25 @@ static int32_t mndProcessRebalanceReq(SRpcMsg *pMsg) { SMqRebInputObj rebInput = {0}; SMqRebOutputObj rebOutput = {0}; - code = initRebOutput(&rebOutput); - if (code != 0) { - goto END; - } - + MND_TMQ_RETURN_CHECK(initRebOutput(&rebOutput)); rebInput.pRebInfo = (SMqRebInfo *)pIter; - - if (buildRebOutput(pMnode, &rebInput, &rebOutput) != 0) { - continue; + code = buildRebOutput(pMnode, &rebInput, &rebOutput); + if (code != 0) { + mError("mq rebalance buildRebOutput, msg:%s", tstrerror(code)) } - mndDoRebalance(pMnode, &rebInput, &rebOutput); + if (code == 0){ + code = mndDoRebalance(pMnode, &rebInput, &rebOutput); + if (code != 0) { + mError("mq rebalance do rebalance error, msg:%s", tstrerror(code)) + } + } - if (mndPersistRebResult(pMnode, pMsg, &rebOutput) != 0) { - mError("mq rebalance persist output error, possibly vnode splitted or dropped,msg:%s", terrstr()) + if (code == 0){ + code = mndPersistRebResult(pMnode, pMsg, &rebOutput); + if (code != 0) { + mError("mq rebalance persist output error, possibly vnode splitted or dropped,msg:%s", tstrerror(code)) + } } clearRebOutput(&rebOutput); @@ -937,7 +975,7 @@ END: static int32_t sendDeleteSubToVnode(SMnode *pMnode, SMqSubscribeObj *pSub, STrans *pTrans) { void *pIter = NULL; SVgObj *pVgObj = NULL; - int32_t ret = 0; + int32_t code = 0; while (1) { pIter = sdbFetch(pMnode->pSdb, SDB_VGROUP, pIter, (void **)&pVgObj); if (pIter == NULL) { @@ -949,40 +987,33 @@ static int32_t sendDeleteSubToVnode(SMnode *pMnode, SMqSubscribeObj *pSub, STran continue; } SMqVDeleteReq *pReq = taosMemoryCalloc(1, sizeof(SMqVDeleteReq)); - if (pReq == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - ret = -1; - goto END; - } + MND_TMQ_NULL_CHECK(pReq); pReq->head.vgId = htonl(pVgObj->vgId); pReq->vgId = pVgObj->vgId; pReq->consumerId = -1; - memcpy(pReq->subKey, pSub->key, TSDB_SUBSCRIBE_KEY_LEN); + (void)memcpy(pReq->subKey, pSub->key, TSDB_SUBSCRIBE_KEY_LEN); STransAction action = {0}; action.epSet = mndGetVgroupEpset(pMnode, pVgObj); - ; action.pCont = pReq; action.contLen = sizeof(SMqVDeleteReq); action.msgType = TDMT_VND_TMQ_DELETE_SUB; action.acceptableCode = TSDB_CODE_MND_VGROUP_NOT_EXIST; sdbRelease(pMnode->pSdb, pVgObj); - if (mndTransAppendRedoAction(pTrans, &action) != 0) { - ret = -1; - goto END; - } + MND_TMQ_RETURN_CHECK(mndTransAppendRedoAction(pTrans, &action)); } + END: sdbRelease(pMnode->pSdb, pVgObj); sdbCancelFetch(pMnode->pSdb, pIter); - return ret; + return code; } static int32_t mndDropConsumerByGroup(SMnode *pMnode, STrans *pTrans, char *cgroup, char *topic) { void *pIter = NULL; SMqConsumerObj *pConsumer = NULL; - int ret = 0; + int code = 0; while (1) { pIter = sdbFetch(pMnode->pSdb, SDB_CONSUMER, pIter, (void **)&pConsumer); if (pIter == NULL) { @@ -997,12 +1028,8 @@ static int32_t mndDropConsumerByGroup(SMnode *pMnode, STrans *pTrans, char *cgro int32_t sz = taosArrayGetSize(pConsumer->assignedTopics); for (int32_t i = 0; i < sz; i++) { char *name = taosArrayGetP(pConsumer->assignedTopics, i); - if (strcmp(topic, name) == 0) { - int32_t code = mndSetConsumerDropLogs(pTrans, pConsumer); - if (code != 0) { - ret = code; - goto END; - } + if (name && strcmp(topic, name) == 0) { + MND_TMQ_RETURN_CHECK(mndSetConsumerDropLogs(pTrans, pConsumer)); } } @@ -1012,7 +1039,7 @@ static int32_t mndDropConsumerByGroup(SMnode *pMnode, STrans *pTrans, char *cgro END: sdbRelease(pMnode->pSdb, pConsumer); sdbCancelFetch(pMnode->pSdb, pIter); - return ret; + return code; } static int32_t mndProcessDropCgroupReq(SRpcMsg *pMsg) { @@ -1020,68 +1047,41 @@ static int32_t mndProcessDropCgroupReq(SRpcMsg *pMsg) { SMDropCgroupReq dropReq = {0}; STrans *pTrans = NULL; int32_t code = TSDB_CODE_ACTION_IN_PROGRESS; + SMqSubscribeObj *pSub = NULL; - if (tDeserializeSMDropCgroupReq(pMsg->pCont, pMsg->contLen, &dropReq) != 0) { - terrno = TSDB_CODE_INVALID_MSG; - return -1; - } - - SMqSubscribeObj *pSub = mndAcquireSubscribe(pMnode, dropReq.cgroup, dropReq.topic); - if (pSub == NULL) { + MND_TMQ_RETURN_CHECK(tDeserializeSMDropCgroupReq(pMsg->pCont, pMsg->contLen, &dropReq)); + char key[TSDB_SUBSCRIBE_KEY_LEN] = {0}; + (void)snprintf(key, TSDB_SUBSCRIBE_KEY_LEN, "%s%s%s", dropReq.cgroup, TMQ_SEPARATOR, dropReq.topic); + code = mndAcquireSubscribeByKey(pMnode, key, &pSub); + if (code != 0) { if (dropReq.igNotExists) { mInfo("cgroup:%s on topic:%s, not exist, ignore not exist is set", dropReq.cgroup, dropReq.topic); return 0; } else { - terrno = TSDB_CODE_MND_SUBSCRIBE_NOT_EXIST; + code = TSDB_CODE_MND_SUBSCRIBE_NOT_EXIST; mError("topic:%s, cgroup:%s, failed to drop since %s", dropReq.topic, dropReq.cgroup, terrstr()); - return -1; + return code; } } taosWLockLatch(&pSub->lock); if (taosHashGetSize(pSub->consumerHash) != 0) { - terrno = TSDB_CODE_MND_CGROUP_USED; + code = TSDB_CODE_MND_CGROUP_USED; mError("cgroup:%s on topic:%s, failed to drop since %s", dropReq.cgroup, dropReq.topic, terrstr()); - code = -1; - goto end; + goto END; } pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_DB_INSIDE, pMsg, "drop-cgroup"); - if (pTrans == NULL) { - mError("cgroup: %s on topic:%s, failed to drop since %s", dropReq.cgroup, dropReq.topic, terrstr()); - code = -1; - goto end; - } - + MND_TMQ_NULL_CHECK(pTrans); mInfo("trans:%d, used to drop cgroup:%s on topic %s", pTrans->id, dropReq.cgroup, dropReq.topic); mndTransSetDbName(pTrans, pSub->dbName, dropReq.cgroup); - code = mndTransCheckConflict(pMnode, pTrans); - if (code != 0) { - goto end; - } + MND_TMQ_RETURN_CHECK(mndTransCheckConflict(pMnode, pTrans)); + MND_TMQ_RETURN_CHECK(mndDropConsumerByGroup(pMnode, pTrans, dropReq.cgroup, dropReq.topic)); + MND_TMQ_RETURN_CHECK(sendDeleteSubToVnode(pMnode, pSub, pTrans)); + MND_TMQ_RETURN_CHECK(mndSetDropSubCommitLogs(pMnode, pTrans, pSub)); + MND_TMQ_RETURN_CHECK(mndTransPrepare(pMnode, pTrans)); - code = mndDropConsumerByGroup(pMnode, pTrans, dropReq.cgroup, dropReq.topic); - if (code != 0) { - goto end; - } - - code = sendDeleteSubToVnode(pMnode, pSub, pTrans); - if (code != 0) { - goto end; - } - - code = mndSetDropSubCommitLogs(pMnode, pTrans, pSub); - if (code != 0) { - mError("cgroup %s on topic:%s, failed to drop since %s", dropReq.cgroup, dropReq.topic, terrstr()); - goto end; - } - - code = mndTransPrepare(pMnode, pTrans); - if (code != 0) { - goto end; - } - -end: +END: taosWUnLockLatch(&pSub->lock); mndReleaseSubscribe(pMnode, pSub); mndTransDrop(pTrans); @@ -1229,31 +1229,13 @@ static int32_t mndSubActionUpdate(SSdb *pSdb, SMqSubscribeObj *pOldSub, SMqSubsc return 0; } -void mndMakeSubscribeKey(char *key, const char *cgroup, const char *topicName) { - int32_t tlen = strlen(cgroup); - memcpy(key, cgroup, tlen); - key[tlen] = TMQ_SEPARATOR; - strcpy(key + tlen + 1, topicName); -} - -SMqSubscribeObj *mndAcquireSubscribe(SMnode *pMnode, const char *cgroup, const char *topicName) { - SSdb *pSdb = pMnode->pSdb; - char key[TSDB_SUBSCRIBE_KEY_LEN]; - mndMakeSubscribeKey(key, cgroup, topicName); - SMqSubscribeObj *pSub = sdbAcquire(pSdb, SDB_SUBSCRIBE, key); - if (pSub == NULL) { - terrno = TSDB_CODE_MND_SUBSCRIBE_NOT_EXIST; - } - return pSub; -} - -SMqSubscribeObj *mndAcquireSubscribeByKey(SMnode *pMnode, const char *key) { +int32_t mndAcquireSubscribeByKey(SMnode *pMnode, const char *key, SMqSubscribeObj** pSub) { SSdb *pSdb = pMnode->pSdb; - SMqSubscribeObj *pSub = sdbAcquire(pSdb, SDB_SUBSCRIBE, key); - if (pSub == NULL) { - terrno = TSDB_CODE_MND_SUBSCRIBE_NOT_EXIST; + *pSub = sdbAcquire(pSdb, SDB_SUBSCRIBE, key); + if (*pSub == NULL) { + return TSDB_CODE_MND_SUBSCRIBE_NOT_EXIST; } - return pSub; + return 0; } int32_t mndGetGroupNumByTopic(SMnode *pMnode, const char *topicName) { @@ -1286,20 +1268,18 @@ void mndReleaseSubscribe(SMnode *pMnode, SMqSubscribeObj *pSub) { sdbRelease(pSdb, pSub); } -static int32_t mndSetDropSubRedoLogs(SMnode *pMnode, STrans *pTrans, SMqSubscribeObj *pSub) { - SSdbRaw *pRedoRaw = mndSubActionEncode(pSub); - if (pRedoRaw == NULL) return -1; - if (mndTransAppendRedolog(pTrans, pRedoRaw) != 0) return -1; - if (sdbSetRawStatus(pRedoRaw, SDB_STATUS_DROPPED) != 0) return -1; - return 0; -} - int32_t mndSetDropSubCommitLogs(SMnode *pMnode, STrans *pTrans, SMqSubscribeObj *pSub) { + int32_t code = 0; SSdbRaw *pCommitRaw = mndSubActionEncode(pSub); - if (pCommitRaw == NULL) return -1; - if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1; - if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED) != 0) return -1; - return 0; + MND_TMQ_NULL_CHECK(pCommitRaw); + code = mndTransAppendCommitlog(pTrans, pCommitRaw); + if (code != 0){ + sdbFreeRaw(pCommitRaw); + goto END; + } + code = sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED); +END: + return code; } int32_t mndDropSubByTopic(SMnode *pMnode, STrans *pTrans, const char *topicName) { @@ -1325,15 +1305,8 @@ int32_t mndDropSubByTopic(SMnode *pMnode, STrans *pTrans, const char *topicName) goto END; } - code = sendDeleteSubToVnode(pMnode, pSub, pTrans); - if (code != 0) { - goto END; - } - - code = mndSetDropSubCommitLogs(pMnode, pTrans, pSub); - if (code != 0) { - goto END; - } + MND_TMQ_RETURN_CHECK(sendDeleteSubToVnode(pMnode, pSub, pTrans)); + MND_TMQ_RETURN_CHECK(mndSetDropSubCommitLogs(pMnode, pTrans, pSub)); } END: @@ -1345,22 +1318,27 @@ END: static int32_t buildResult(SSDataBlock *pBlock, int32_t *numOfRows, int64_t consumerId, const char *topic, const char *cgroup, SArray *vgs, SArray *offsetRows) { + int32_t code = 0; int32_t sz = taosArrayGetSize(vgs); for (int32_t j = 0; j < sz; j++) { SMqVgEp *pVgEp = taosArrayGetP(vgs, j); + MND_TMQ_NULL_CHECK(pVgEp); - SColumnInfoData *pColInfo; + SColumnInfoData *pColInfo = NULL; int32_t cols = 0; pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, *numOfRows, (const char *)topic, false); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, *numOfRows, (const char *)topic, false)); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, *numOfRows, (const char *)cgroup, false); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, *numOfRows, (const char *)cgroup, false)); // vg id pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, *numOfRows, (const char *)&pVgEp->vgId, false); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, *numOfRows, (const char *)&pVgEp->vgId, false)); // consumer id char consumerIdHex[32] = {0}; @@ -1368,7 +1346,8 @@ static int32_t buildResult(SSDataBlock *pBlock, int32_t *numOfRows, int64_t cons varDataSetLen(consumerIdHex, strlen(varDataVal(consumerIdHex))); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, *numOfRows, (const char *)consumerIdHex, consumerId == -1); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, *numOfRows, (const char *)consumerIdHex, consumerId == -1)); mInfo("mnd show subscriptions: topic %s, consumer:0x%" PRIx64 " cgroup %s vgid %d", varDataVal(topic), consumerId, varDataVal(cgroup), pVgEp->vgId); @@ -1377,6 +1356,7 @@ static int32_t buildResult(SSDataBlock *pBlock, int32_t *numOfRows, int64_t cons OffsetRows *data = NULL; for (int i = 0; i < taosArrayGetSize(offsetRows); i++) { OffsetRows *tmp = taosArrayGet(offsetRows, i); + MND_TMQ_NULL_CHECK(tmp); if (tmp->vgId != pVgEp->vgId) { mError("mnd show subscriptions: do not find vgId:%d, %d in offsetRows", tmp->vgId, pVgEp->vgId); continue; @@ -1386,23 +1366,29 @@ static int32_t buildResult(SSDataBlock *pBlock, int32_t *numOfRows, int64_t cons if (data) { // vg id char buf[TSDB_OFFSET_LEN * 2 + VARSTR_HEADER_SIZE] = {0}; - tFormatOffset(varDataVal(buf), TSDB_OFFSET_LEN, &data->offset); - sprintf(varDataVal(buf) + strlen(varDataVal(buf)), "/%" PRId64, data->ever); + MND_TMQ_RETURN_CHECK(tFormatOffset(varDataVal(buf), TSDB_OFFSET_LEN, &data->offset)); + (void)sprintf(varDataVal(buf) + strlen(varDataVal(buf)), "/%" PRId64, data->ever); varDataSetLen(buf, strlen(varDataVal(buf))); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, *numOfRows, (const char *)buf, false); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, *numOfRows, (const char *)buf, false)); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, *numOfRows, (const char *)&data->rows, false); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, *numOfRows, (const char *)&data->rows, false)); } else { pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); + MND_TMQ_NULL_CHECK(pColInfo); colDataSetNULL(pColInfo, *numOfRows); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); + MND_TMQ_NULL_CHECK(pColInfo); colDataSetNULL(pColInfo, *numOfRows); mError("mnd show subscriptions: do not find vgId:%d in offsetRows", pVgEp->vgId); } (*numOfRows)++; } return 0; +END: + return code; } int32_t mndRetrieveSubscribe(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) { @@ -1410,6 +1396,7 @@ int32_t mndRetrieveSubscribe(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock SSdb *pSdb = pMnode->pSdb; int32_t numOfRows = 0; SMqSubscribeObj *pSub = NULL; + int32_t code = 0; mInfo("mnd show subscriptions begin"); @@ -1422,7 +1409,7 @@ int32_t mndRetrieveSubscribe(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock taosRLockLatch(&pSub->lock); if (numOfRows + pSub->vgNum > rowsCapacity) { - blockDataEnsureCapacity(pBlock, numOfRows + pSub->vgNum); + MND_TMQ_RETURN_CHECK(blockDataEnsureCapacity(pBlock, numOfRows + pSub->vgNum)) ; } // topic and cgroup @@ -1439,11 +1426,11 @@ int32_t mndRetrieveSubscribe(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock if (pIter == NULL) break; pConsumerEp = (SMqConsumerEp *)pIter; - buildResult(pBlock, &numOfRows, pConsumerEp->consumerId, topic, cgroup, pConsumerEp->vgs, - pConsumerEp->offsetRows); + MND_TMQ_RETURN_CHECK(buildResult(pBlock, &numOfRows, pConsumerEp->consumerId, topic, cgroup, pConsumerEp->vgs, + pConsumerEp->offsetRows)); } - buildResult(pBlock, &numOfRows, -1, topic, cgroup, pSub->unassignedVgs, pSub->offsetRows); + MND_TMQ_RETURN_CHECK(buildResult(pBlock, &numOfRows, -1, topic, cgroup, pSub->unassignedVgs, pSub->offsetRows)); pBlock->info.rows = numOfRows; @@ -1455,6 +1442,9 @@ int32_t mndRetrieveSubscribe(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock pShow->numOfRows += numOfRows; return numOfRows; + +END: + return code; } void mndCancelGetNextSubscribe(SMnode *pMnode, void *pIter) { diff --git a/source/dnode/mnode/impl/src/mndTopic.c b/source/dnode/mnode/impl/src/mndTopic.c index bcb38a3902..959a3ef008 100644 --- a/source/dnode/mnode/impl/src/mndTopic.c +++ b/source/dnode/mnode/impl/src/mndTopic.c @@ -44,8 +44,6 @@ static int32_t mndProcessDropTopicReq(SRpcMsg *pReq); static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rows); static void mndCancelGetNextTopic(SMnode *pMnode, void *pIter); -static int32_t mndSetDropTopicCommitLogs(SMnode *pMnode, STrans *pTrans, SMqTopicObj *pTopic); - int32_t mndInitTopic(SMnode *pMnode) { SSdbTable table = { .sdbType = SDB_TOPIC, @@ -70,9 +68,16 @@ int32_t mndInitTopic(SMnode *pMnode) { void mndCleanupTopic(SMnode *pMnode) {} -const char *mndTopicGetShowName(const char topic[TSDB_TOPIC_FNAME_LEN]) { - // - return strchr(topic, '.') + 1; +void mndTopicGetShowName(const char* fullTopic, char* topic) { + if (fullTopic == NULL) { + return; + } + char* tmp = strchr(fullTopic, '.'); + if (tmp == NULL) { + tstrncpy(topic, fullTopic, TSDB_TOPIC_FNAME_LEN); + }else { + tstrncpy(topic, tmp+1, TSDB_TOPIC_FNAME_LEN); + } } SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) { @@ -289,25 +294,25 @@ static int32_t mndTopicActionDelete(SSdb *pSdb, SMqTopicObj *pTopic) { taosMemoryFreeClear(pTopic->ast); taosMemoryFreeClear(pTopic->physicalPlan); if (pTopic->schema.nCols) taosMemoryFreeClear(pTopic->schema.pSchema); - taosArrayDestroy(pTopic->ntbColIds); + (void)taosArrayDestroy(pTopic->ntbColIds); return 0; } static int32_t mndTopicActionUpdate(SSdb *pSdb, SMqTopicObj *pOldTopic, SMqTopicObj *pNewTopic) { mTrace("topic:%s perform update action", pOldTopic->name); - atomic_exchange_64(&pOldTopic->updateTime, pNewTopic->updateTime); - atomic_exchange_32(&pOldTopic->version, pNewTopic->version); + (void)atomic_exchange_64(&pOldTopic->updateTime, pNewTopic->updateTime); + (void)atomic_exchange_32(&pOldTopic->version, pNewTopic->version); return 0; } -SMqTopicObj *mndAcquireTopic(SMnode *pMnode, const char *topicName) { +int32_t mndAcquireTopic(SMnode *pMnode, const char *topicName, SMqTopicObj **pTopic) { SSdb *pSdb = pMnode->pSdb; - SMqTopicObj *pTopic = sdbAcquire(pSdb, SDB_TOPIC, topicName); - if (pTopic == NULL && terrno == TSDB_CODE_SDB_OBJ_NOT_THERE) { - terrno = TSDB_CODE_MND_TOPIC_NOT_EXIST; + *pTopic = sdbAcquire(pSdb, SDB_TOPIC, topicName); + if (*pTopic == NULL) { + return TSDB_CODE_MND_TOPIC_NOT_EXIST; } - return pTopic; + return TDB_CODE_SUCCESS; } void mndReleaseTopic(SMnode *pMnode, SMqTopicObj *pTopic) { @@ -316,25 +321,23 @@ void mndReleaseTopic(SMnode *pMnode, SMqTopicObj *pTopic) { } static int32_t mndCheckCreateTopicReq(SCMCreateTopicReq *pCreate) { - terrno = TSDB_CODE_MND_INVALID_TOPIC; - - if (pCreate->sql == NULL) return -1; + if (pCreate->sql == NULL) return TSDB_CODE_MND_INVALID_TOPIC; if (pCreate->subType == TOPIC_SUB_TYPE__COLUMN) { - if (pCreate->ast == NULL || pCreate->ast[0] == 0) return -1; + if (pCreate->ast == NULL || pCreate->ast[0] == 0) return TSDB_CODE_MND_INVALID_TOPIC; } else if (pCreate->subType == TOPIC_SUB_TYPE__TABLE) { - if (pCreate->subStbName[0] == 0) return -1; + if (pCreate->subStbName[0] == 0) return TSDB_CODE_MND_INVALID_TOPIC; } else if (pCreate->subType == TOPIC_SUB_TYPE__DB) { - if (pCreate->subDbName[0] == 0) return -1; + if (pCreate->subDbName[0] == 0) return TSDB_CODE_MND_INVALID_TOPIC; } - terrno = TSDB_CODE_SUCCESS; return 0; } static int32_t extractTopicTbInfo(SNode *pAst, SMqTopicObj *pTopic) { SNodeList *pNodeList = NULL; - nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList); + int32_t code = 0; + MND_TMQ_RETURN_CHECK(nodesCollectColumns((SSelectStmt *)pAst, SQL_CLAUSE_FROM, NULL, COLLECT_COL_TYPE_ALL, &pNodeList)); int64_t suid = ((SRealTableNode *)((SSelectStmt *)pAst)->pFromTable)->pMeta->suid; int8_t tableType = ((SRealTableNode *)((SSelectStmt *)pAst)->pFromTable)->pMeta->tableType; if (tableType == TSDB_CHILD_TABLE) { @@ -345,17 +348,19 @@ static int32_t extractTopicTbInfo(SNode *pAst, SMqTopicObj *pTopic) { SColumnNode *pCol = (SColumnNode *)pNode; if (pCol->tableType == TSDB_NORMAL_TABLE) { pTopic->ntbUid = pCol->tableId; - taosArrayPush(pTopic->ntbColIds, &pCol->colId); + MND_TMQ_NULL_CHECK(taosArrayPush(pTopic->ntbColIds, &pCol->colId)); } } } nodesDestroyList(pNodeList); - return 0; + +END: + return code; } static int32_t sendCheckInfoToVnode(STrans *pTrans, SMnode *pMnode, SMqTopicObj *topicObj){ - STqCheckInfo info; - memcpy(info.topic, topicObj->name, TSDB_TOPIC_FNAME_LEN); + STqCheckInfo info = {0}; + (void)memcpy(info.topic, topicObj->name, TSDB_TOPIC_FNAME_LEN); info.ntbUid = topicObj->ntbUid; info.colIdList = topicObj->ntbColIds; // broadcast forbid alter info @@ -363,7 +368,7 @@ static int32_t sendCheckInfoToVnode(STrans *pTrans, SMnode *pMnode, SMqTopicObj SSdb *pSdb = pMnode->pSdb; SVgObj *pVgroup = NULL; int32_t code = 0; - void *buf = NULL; + void *buf = NULL; while (1) { // iterate vg @@ -378,16 +383,17 @@ static int32_t sendCheckInfoToVnode(STrans *pTrans, SMnode *pMnode, SMqTopicObj int32_t len; tEncodeSize(tEncodeSTqCheckInfo, &info, len, code); if (code != 0) { - terrno = TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; goto END; } buf = taosMemoryCalloc(1, sizeof(SMsgHead) + len); + MND_TMQ_NULL_CHECK(buf); void *abuf = POINTER_SHIFT(buf, sizeof(SMsgHead)); - SEncoder encoder; + SEncoder encoder = {0}; tEncoderInit(&encoder, abuf, len); code = tEncodeSTqCheckInfo(&encoder, &info); if (code < 0) { - terrno = TSDB_CODE_OUT_OF_MEMORY; + tEncoderClear(&encoder); goto END; } tEncoderClear(&encoder); @@ -398,10 +404,7 @@ static int32_t sendCheckInfoToVnode(STrans *pTrans, SMnode *pMnode, SMqTopicObj action.pCont = buf; action.contLen = sizeof(SMsgHead) + len; action.msgType = TDMT_VND_TMQ_ADD_CHECKINFO; - code = mndTransAppendRedoAction(pTrans, &action); - if (code != 0) { - goto END; - } + MND_TMQ_RETURN_CHECK(mndTransAppendRedoAction(pTrans, &action)); sdbRelease(pSdb, pVgroup); buf = NULL; } @@ -417,33 +420,22 @@ static int32_t mndCreateTopic(SMnode *pMnode, SRpcMsg *pReq, SCMCreateTopicReq * const char *userName) { mInfo("start to create topic:%s", pCreate->name); STrans *pTrans = NULL; - int32_t code = -1; + int32_t code = 0; SNode *pAst = NULL; SQueryPlan *pPlan = NULL; SMqTopicObj topicObj = {0}; pTrans = mndTransCreate(pMnode, TRN_POLICY_ROLLBACK, TRN_CONFLICT_DB, pReq, "create-topic"); - if (pTrans == NULL) { - mError("topic:%s, failed to create since %s", pCreate->name, terrstr()); - code = -1; - goto _OUT; - } - + MND_TMQ_NULL_CHECK(pTrans); mndTransSetDbName(pTrans, pDb->name, NULL); - code = mndTransCheckConflict(pMnode, pTrans); - if (code != 0) { - goto _OUT; - } + MND_TMQ_RETURN_CHECK(mndTransCheckConflict(pMnode, pTrans)); mInfo("trans:%d to create topic:%s", pTrans->id, pCreate->name); tstrncpy(topicObj.name, pCreate->name, TSDB_TOPIC_FNAME_LEN); tstrncpy(topicObj.db, pDb->name, TSDB_DB_FNAME_LEN); tstrncpy(topicObj.createUser, userName, TSDB_USER_LEN); - code = mndCheckTopicPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_TOPIC, &topicObj); - if (code != 0) { - goto _OUT; - } + MND_TMQ_RETURN_CHECK(mndCheckTopicPrivilege(pMnode, pReq->info.conn.user, MND_OPER_CREATE_TOPIC, &topicObj)); topicObj.createTime = taosGetTimestampMs(); topicObj.updateTime = topicObj.createTime; @@ -458,56 +450,25 @@ static int32_t mndCreateTopic(SMnode *pMnode, SRpcMsg *pReq, SCMCreateTopicReq * if (pCreate->subType == TOPIC_SUB_TYPE__COLUMN) { topicObj.ast = taosStrdup(pCreate->ast); topicObj.astLen = strlen(pCreate->ast) + 1; - qDebugL("topic:%s ast %s", topicObj.name, topicObj.ast); - - code = nodesStringToNode(pCreate->ast, &pAst); - if (code != 0) { - mError("topic:%s, failed to create since %s", pCreate->name, terrstr()); - goto _OUT; - } - + MND_TMQ_RETURN_CHECK(nodesStringToNode(pCreate->ast, &pAst)); SPlanContext cxt = {.pAstRoot = pAst, .topicQuery = true}; - code = qCreateQueryPlan(&cxt, &pPlan, NULL); - if (code != 0) { - mError("failed to create topic:%s since %s", pCreate->name, terrstr()); - goto _OUT; - } + MND_TMQ_RETURN_CHECK(qCreateQueryPlan(&cxt, &pPlan, NULL)); topicObj.ntbColIds = taosArrayInit(0, sizeof(int16_t)); - if (topicObj.ntbColIds == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; - code = terrno; - goto _OUT; - } - - extractTopicTbInfo(pAst, &topicObj); - + MND_TMQ_NULL_CHECK(topicObj.ntbColIds); + MND_TMQ_RETURN_CHECK(extractTopicTbInfo(pAst, &topicObj)); if (topicObj.ntbUid == 0) { - taosArrayDestroy(topicObj.ntbColIds); + (void)taosArrayDestroy(topicObj.ntbColIds); topicObj.ntbColIds = NULL; } - code = qExtractResultSchema(pAst, &topicObj.schema.nCols, &topicObj.schema.pSchema); - if (code != 0) { - mError("topic:%s, failed to create since %s", pCreate->name, terrstr()); - goto _OUT; - } - - code = nodesNodeToString((SNode *)pPlan, false, &topicObj.physicalPlan, NULL); - if (code != 0) { - mError("topic:%s, failed to create since %s", pCreate->name, terrstr()); - goto _OUT; - } + MND_TMQ_RETURN_CHECK(qExtractResultSchema(pAst, &topicObj.schema.nCols, &topicObj.schema.pSchema)); + MND_TMQ_RETURN_CHECK(nodesNodeToString((SNode *)pPlan, false, &topicObj.physicalPlan, NULL)); } else if (pCreate->subType == TOPIC_SUB_TYPE__TABLE) { SStbObj *pStb = mndAcquireStb(pMnode, pCreate->subStbName); - if (pStb == NULL) { - terrno = TSDB_CODE_MND_STB_NOT_EXIST; - code = terrno; - goto _OUT; - } - - strcpy(topicObj.stbName, pCreate->subStbName); + MND_TMQ_NULL_CHECK(pStb); + tstrncpy(topicObj.stbName, pCreate->subStbName, TSDB_TABLE_FNAME_LEN); topicObj.stbUid = pStb->uid; mndReleaseStb(pMnode, pStb); if(pCreate->ast != NULL){ @@ -518,34 +479,25 @@ static int32_t mndCreateTopic(SMnode *pMnode, SRpcMsg *pReq, SCMCreateTopicReq * } SSdbRaw *pCommitRaw = mndTopicActionEncode(&topicObj); - if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) { - mError("trans:%d, failed to append commit log since %s", pTrans->id, terrstr()); - code = -1; - goto _OUT; + MND_TMQ_NULL_CHECK(pCommitRaw); + code = mndTransAppendCommitlog(pTrans, pCommitRaw); + if(code != 0) { + sdbFreeRaw(pCommitRaw); + goto END; } - (void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY); - + MND_TMQ_RETURN_CHECK(sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY)); if (topicObj.ntbUid != 0) { - code = sendCheckInfoToVnode(pTrans, pMnode, &topicObj); - if (code != 0){ - goto _OUT; - } + MND_TMQ_RETURN_CHECK(sendCheckInfoToVnode(pTrans, pMnode, &topicObj)); } - - if (mndTransPrepare(pMnode, pTrans) != 0) { - mError("trans:%d, failed to prepare since %s", pTrans->id, terrstr()); - code = -1; - goto _OUT; - } - + MND_TMQ_RETURN_CHECK(mndTransPrepare(pMnode, pTrans)); code = TSDB_CODE_ACTION_IN_PROGRESS; -_OUT: +END: taosMemoryFreeClear(topicObj.physicalPlan); taosMemoryFreeClear(topicObj.sql); taosMemoryFreeClear(topicObj.ast); - taosArrayDestroy(topicObj.ntbColIds); + (void)taosArrayDestroy(topicObj.ntbColIds); if (topicObj.schema.nCols) { taosMemoryFreeClear(topicObj.schema.pSchema); } @@ -557,75 +509,64 @@ _OUT: static int32_t mndProcessCreateTopicReq(SRpcMsg *pReq) { SMnode *pMnode = pReq->info.node; - int32_t code = -1; + int32_t code = TDB_CODE_SUCCESS; SMqTopicObj *pTopic = NULL; SDbObj *pDb = NULL; SCMCreateTopicReq createTopicReq = {0}; if (tDeserializeSCMCreateTopicReq(pReq->pCont, pReq->contLen, &createTopicReq) != 0) { - terrno = TSDB_CODE_INVALID_MSG; - goto _OVER; + code = TSDB_CODE_INVALID_MSG; + goto END; } mInfo("topic:%s start to create, sql:%s", createTopicReq.name, createTopicReq.sql); - if (mndCheckCreateTopicReq(&createTopicReq) != 0) { - mError("topic:%s failed to create since %s", createTopicReq.name, terrstr()); - goto _OVER; - } + MND_TMQ_RETURN_CHECK(mndCheckCreateTopicReq(&createTopicReq)); - pTopic = mndAcquireTopic(pMnode, createTopicReq.name); - if (pTopic != NULL) { + code = mndAcquireTopic(pMnode, createTopicReq.name, &pTopic); + if (code == TDB_CODE_SUCCESS) { if (createTopicReq.igExists) { mInfo("topic:%s already exist, ignore exist is set", createTopicReq.name); - code = 0; - goto _OVER; + goto END; } else { - terrno = TSDB_CODE_MND_TOPIC_ALREADY_EXIST; - goto _OVER; + code = TSDB_CODE_MND_TOPIC_ALREADY_EXIST; + goto END; } - } else if (terrno != TSDB_CODE_MND_TOPIC_NOT_EXIST) { - goto _OVER; + } else if (code != TSDB_CODE_MND_TOPIC_NOT_EXIST) { + goto END; } pDb = mndAcquireDb(pMnode, createTopicReq.subDbName); - if (pDb == NULL) { - terrno = TSDB_CODE_MND_DB_NOT_SELECTED; - goto _OVER; - } + MND_TMQ_NULL_CHECK(pDb); if (pDb->cfg.walRetentionPeriod == 0) { - terrno = TSDB_CODE_MND_DB_RETENTION_PERIOD_ZERO; + code = TSDB_CODE_MND_DB_RETENTION_PERIOD_ZERO; mError("db:%s, not allowed to create topic when WAL_RETENTION_PERIOD is zero", pDb->name); - goto _OVER; + goto END; } if (sdbGetSize(pMnode->pSdb, SDB_TOPIC) >= tmqMaxTopicNum){ - terrno = TSDB_CODE_TMQ_TOPIC_OUT_OF_RANGE; + code = TSDB_CODE_TMQ_TOPIC_OUT_OF_RANGE; mError("topic num out of range"); - goto _OVER; - } - - if ((terrno = grantCheck(TSDB_GRANT_SUBSCRIPTION)) < 0) { - goto _OVER; + goto END; } + MND_TMQ_RETURN_CHECK(grantCheck(TSDB_GRANT_SUBSCRIPTION)); code = mndCreateTopic(pMnode, pReq, &createTopicReq, pDb, pReq->info.conn.user); if (code == 0) { code = TSDB_CODE_ACTION_IN_PROGRESS; } - SName dbname = {0}; - tNameFromString(&dbname, createTopicReq.subDbName, T_NAME_ACCT | T_NAME_DB); + { + SName dbname = {0}; + (void)tNameFromString(&dbname, createTopicReq.subDbName, T_NAME_ACCT | T_NAME_DB); // ignore error + SName topicName = {0}; + (void)tNameFromString(&topicName, createTopicReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); // ignore error + auditRecord(pReq, pMnode->clusterId, "createTopic", dbname.dbname, topicName.dbname, + createTopicReq.sql, strlen(createTopicReq.sql)); + } - SName topicName = {0}; - tNameFromString(&topicName, createTopicReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); - //reuse this function for topic - - auditRecord(pReq, pMnode->clusterId, "createTopic", dbname.dbname, topicName.dbname, - createTopicReq.sql, strlen(createTopicReq.sql)); - -_OVER: +END: if (code != 0 && code != TSDB_CODE_ACTION_IN_PROGRESS) { mError("failed to create topic:%s since %s", createTopicReq.name, terrstr()); } @@ -638,22 +579,20 @@ _OVER: } static int32_t mndDropTopic(SMnode *pMnode, STrans *pTrans, SRpcMsg *pReq, SMqTopicObj *pTopic) { - int32_t code = -1; - if (mndUserRemoveTopic(pMnode, pTrans, pTopic->name) != 0) { - goto _OVER; + int32_t code = 0; + SSdbRaw *pCommitRaw = NULL; + MND_TMQ_RETURN_CHECK(mndUserRemoveTopic(pMnode, pTrans, pTopic->name)); + pCommitRaw = mndTopicActionEncode(pTopic); + MND_TMQ_NULL_CHECK(pCommitRaw); + code = mndTransAppendCommitlog(pTrans, pCommitRaw); + if(code != 0) { + sdbFreeRaw(pCommitRaw); + goto END; } + MND_TMQ_RETURN_CHECK(sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED)); + MND_TMQ_RETURN_CHECK(mndTransPrepare(pMnode, pTrans)); - SSdbRaw *pCommitRaw = mndTopicActionEncode(pTopic); - if (pCommitRaw == NULL || mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) goto _OVER; - (void)sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED); - - if (mndTransPrepare(pMnode, pTrans) != 0) { - goto _OVER; - } - - code = 0; - -_OVER: +END: return code; } @@ -661,7 +600,7 @@ static bool checkTopic(SArray *topics, char *topicName){ int32_t sz = taosArrayGetSize(topics); for (int32_t i = 0; i < sz; i++) { char *name = taosArrayGetP(topics, i); - if (strcmp(name, topicName) == 0) { + if (name && strcmp(name, topicName) == 0) { return true; } } @@ -682,29 +621,26 @@ static int32_t mndDropConsumerByTopic(SMnode *pMnode, STrans *pTrans, char *topi bool found = checkTopic(pConsumer->assignedTopics, topicName); if (found){ if (pConsumer->status == MQ_CONSUMER_STATUS_LOST) { - code = mndSetConsumerDropLogs(pTrans, pConsumer); - if (code != 0) { - goto end; - } + MND_TMQ_RETURN_CHECK(mndSetConsumerDropLogs(pTrans, pConsumer)); sdbRelease(pSdb, pConsumer); continue; } mError("topic:%s, failed to drop since subscribed by consumer:0x%" PRIx64 ", in consumer group %s", topicName, pConsumer->consumerId, pConsumer->cgroup); code = TSDB_CODE_MND_TOPIC_SUBSCRIBED; - goto end; + goto END; } if (checkTopic(pConsumer->rebNewTopics, topicName) || checkTopic(pConsumer->rebRemovedTopics, topicName)) { code = TSDB_CODE_MND_TOPIC_SUBSCRIBED; mError("topic:%s, failed to drop since subscribed by consumer:%" PRId64 ", in consumer group %s (reb new)", topicName, pConsumer->consumerId, pConsumer->cgroup); - goto end; + goto END; } sdbRelease(pSdb, pConsumer); } -end: +END: sdbRelease(pSdb, pConsumer); sdbCancelFetch(pSdb, pIter); return code; @@ -726,13 +662,10 @@ static int32_t mndDropCheckInfoByTopic(SMnode *pMnode, STrans *pTrans, SMqTopicO } buf = taosMemoryCalloc(1, sizeof(SMsgHead) + TSDB_TOPIC_FNAME_LEN); - if (buf == NULL){ - code = TSDB_CODE_OUT_OF_MEMORY; - goto end; - } + MND_TMQ_NULL_CHECK(buf); void *abuf = POINTER_SHIFT(buf, sizeof(SMsgHead)); ((SMsgHead *)buf)->vgId = htonl(pVgroup->vgId); - memcpy(abuf, pTopic->name, TSDB_TOPIC_FNAME_LEN); + (void)memcpy(abuf, pTopic->name, TSDB_TOPIC_FNAME_LEN); STransAction action = {0}; action.epSet = mndGetVgroupEpset(pMnode, pVgroup); @@ -742,12 +675,12 @@ static int32_t mndDropCheckInfoByTopic(SMnode *pMnode, STrans *pTrans, SMqTopicO code = mndTransAppendRedoAction(pTrans, &action); if (code != 0) { taosMemoryFree(buf); - goto end; + goto END; } sdbRelease(pSdb, pVgroup); } -end: +END: sdbRelease(pSdb, pVgroup); sdbCancelFetch(pSdb, pIter); return code; @@ -761,70 +694,40 @@ static int32_t mndProcessDropTopicReq(SRpcMsg *pReq) { STrans *pTrans = NULL; if (tDeserializeSMDropTopicReq(pReq->pCont, pReq->contLen, &dropReq) != 0) { - terrno = TSDB_CODE_INVALID_MSG; - return -1; + return TSDB_CODE_INVALID_MSG; } - pTopic = mndAcquireTopic(pMnode, dropReq.name); - if (pTopic == NULL) { + code = mndAcquireTopic(pMnode, dropReq.name, &pTopic); + if (code != 0) { if (dropReq.igNotExists) { mInfo("topic:%s, not exist, ignore not exist is set", dropReq.name); tFreeSMDropTopicReq(&dropReq); return 0; } else { - terrno = TSDB_CODE_MND_TOPIC_NOT_EXIST; mError("topic:%s, failed to drop since %s", dropReq.name, terrstr()); tFreeSMDropTopicReq(&dropReq); - return -1; + return code; } } pTrans = mndTransCreate(pMnode, TRN_POLICY_RETRY, TRN_CONFLICT_DB, pReq, "drop-topic"); - if (pTrans == NULL) { - mError("topic:%s, failed to drop since %s", pTopic->name, terrstr()); - code = -1; - goto end; - } + MND_TMQ_NULL_CHECK(pTrans); mndTransSetDbName(pTrans, pTopic->db, NULL); - code = mndTransCheckConflict(pMnode, pTrans); - if (code != 0) { - goto end; - } - + MND_TMQ_RETURN_CHECK(mndTransCheckConflict(pMnode, pTrans)); mInfo("trans:%d, used to drop topic:%s", pTrans->id, pTopic->name); - - code = mndCheckTopicPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_TOPIC, pTopic); - if (code != 0) { - goto end; - } - - code = mndCheckDbPrivilegeByName(pMnode, pReq->info.conn.user, MND_OPER_READ_DB, pTopic->db); - if (code != 0) { - goto end; - } - - code = mndDropConsumerByTopic(pMnode, pTrans, dropReq.name); - if (code != 0) { - goto end; - } - - code = mndDropSubByTopic(pMnode, pTrans, dropReq.name); - if (code < 0) { - mError("topic:%s, failed to drop since %s", pTopic->name, terrstr()); - goto end; - } + MND_TMQ_RETURN_CHECK(mndCheckTopicPrivilege(pMnode, pReq->info.conn.user, MND_OPER_DROP_TOPIC, pTopic)); + MND_TMQ_RETURN_CHECK(mndCheckDbPrivilegeByName(pMnode, pReq->info.conn.user, MND_OPER_READ_DB, pTopic->db)); + MND_TMQ_RETURN_CHECK(mndDropConsumerByTopic(pMnode, pTrans, dropReq.name)); + MND_TMQ_RETURN_CHECK(mndDropSubByTopic(pMnode, pTrans, dropReq.name)); if (pTopic->ntbUid != 0) { - code = mndDropCheckInfoByTopic(pMnode, pTrans, pTopic); - if (code != 0) { - goto end; - } + MND_TMQ_RETURN_CHECK(mndDropCheckInfoByTopic(pMnode, pTrans, pTopic)); } code = mndDropTopic(pMnode, pTrans, pReq, pTopic); -end: +END: mndReleaseTopic(pMnode, pTopic); mndTransDrop(pTrans); if (code != 0) { @@ -834,8 +737,7 @@ end: } SName name = {0}; - tNameFromString(&name, dropReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); - + (void)tNameFromString(&name, dropReq.name, T_NAME_ACCT | T_NAME_DB | T_NAME_TABLE); // ignore error auditRecord(pReq, pMnode->clusterId, "dropTopic", name.dbname, name.tname, dropReq.sql, dropReq.sqlLen); tFreeSMDropTopicReq(&dropReq); @@ -849,8 +751,7 @@ int32_t mndGetNumOfTopics(SMnode *pMnode, char *dbName, int32_t *pNumOfTopics) { SSdb *pSdb = pMnode->pSdb; SDbObj *pDb = mndAcquireDb(pMnode, dbName); if (pDb == NULL) { - terrno = TSDB_CODE_MND_DB_NOT_SELECTED; - return -1; + return TSDB_CODE_MND_DB_NOT_SELECTED; } int32_t numOfTopics = 0; @@ -875,18 +776,24 @@ int32_t mndGetNumOfTopics(SMnode *pMnode, char *dbName, int32_t *pNumOfTopics) { } static void schemaToJson(SSchema *schema, int32_t nCols, char *schemaJson){ - char* string = NULL; + char* string = NULL; + int32_t code = 0; cJSON* columns = cJSON_CreateArray(); - if (columns == NULL) { - return; - } + MND_TMQ_NULL_CHECK(columns); for (int i = 0; i < nCols; i++) { cJSON* column = cJSON_CreateObject(); + MND_TMQ_NULL_CHECK(column); SSchema* s = schema + i; cJSON* cname = cJSON_CreateString(s->name); - cJSON_AddItemToObject(column, "name", cname); + MND_TMQ_NULL_CHECK(cname); + if (!cJSON_AddItemToObject(column, "name", cname)) { + return; + } cJSON* ctype = cJSON_CreateString(tDataTypes[s->type].name); - cJSON_AddItemToObject(column, "type", ctype); + MND_TMQ_NULL_CHECK(ctype); + if (!cJSON_AddItemToObject(column, "type", ctype)) { + return; + } int32_t length = 0; if (s->type == TSDB_DATA_TYPE_BINARY || s->type == TSDB_DATA_TYPE_VARBINARY || s->type == TSDB_DATA_TYPE_GEOMETRY) { @@ -897,8 +804,13 @@ static void schemaToJson(SSchema *schema, int32_t nCols, char *schemaJson){ length = s->bytes; } cJSON* cbytes = cJSON_CreateNumber(length); - cJSON_AddItemToObject(column, "length", cbytes); - cJSON_AddItemToArray(columns, column); + MND_TMQ_NULL_CHECK(cbytes); + if (!cJSON_AddItemToObject(column, "length", cbytes)){ + return; + } + if (!cJSON_AddItemToArray(columns, column)){ + return; + } } string = cJSON_PrintUnformatted(columns); cJSON_Delete(columns); @@ -910,6 +822,9 @@ static void schemaToJson(SSchema *schema, int32_t nCols, char *schemaJson){ mError("mndRetrieveTopic build schema error json:%p, json len:%zu", string, len); } taosMemoryFree(string); + +END: + return; } static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBlock, int32_t rowsCapacity) { @@ -917,13 +832,16 @@ static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl SSdb *pSdb = pMnode->pSdb; int32_t numOfRows = 0; SMqTopicObj *pTopic = NULL; + int32_t code = 0; + char *sql = NULL; + char *schemaJson = NULL; while (numOfRows < rowsCapacity) { pShow->pIter = sdbFetch(pSdb, SDB_TOPIC, pShow->pIter, (void **)&pTopic); if (pShow->pIter == NULL) break; - SColumnInfoData *pColInfo; - SName n; + SColumnInfoData *pColInfo= NULL; + SName n = {0}; int32_t cols = 0; char topicName[TSDB_TOPIC_NAME_LEN + VARSTR_HEADER_SIZE + 5] = {0}; @@ -931,28 +849,34 @@ static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl STR_TO_VARSTR(topicName, pName); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)topicName, false); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)topicName, false)); char dbName[TSDB_DB_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; - tNameFromString(&n, pTopic->db, T_NAME_ACCT | T_NAME_DB); - tNameGetDbName(&n, varDataVal(dbName)); + MND_TMQ_RETURN_CHECK(tNameFromString(&n, pTopic->db, T_NAME_ACCT | T_NAME_DB)); + MND_TMQ_RETURN_CHECK(tNameGetDbName(&n, varDataVal(dbName))); varDataSetLen(dbName, strlen(varDataVal(dbName))); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)dbName, false); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)dbName, false)); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)&pTopic->createTime, false); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)&pTopic->createTime, false)); - char *sql = taosMemoryMalloc(strlen(pTopic->sql) + VARSTR_HEADER_SIZE); + sql = taosMemoryMalloc(strlen(pTopic->sql) + VARSTR_HEADER_SIZE); + MND_TMQ_NULL_CHECK(sql); STR_TO_VARSTR(sql, pTopic->sql); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)sql, false); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)sql, false)); - taosMemoryFree(sql); + taosMemoryFreeClear(sql); - char *schemaJson = taosMemoryMalloc(TSDB_SHOW_SCHEMA_JSON_LEN + VARSTR_HEADER_SIZE); + schemaJson = taosMemoryMalloc(TSDB_SHOW_SCHEMA_JSON_LEN + VARSTR_HEADER_SIZE); + MND_TMQ_NULL_CHECK(schemaJson); if(pTopic->subType == TOPIC_SUB_TYPE__COLUMN){ schemaToJson(pTopic->schema.pSchema, pTopic->schema.nCols, schemaJson); }else if(pTopic->subType == TOPIC_SUB_TYPE__TABLE){ @@ -969,8 +893,9 @@ static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl } pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)schemaJson, false); - taosMemoryFree(schemaJson); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)schemaJson, false)); + taosMemoryFreeClear(schemaJson); char mete[4 + VARSTR_HEADER_SIZE] = {0}; if(pTopic->withMeta){ @@ -980,7 +905,8 @@ static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl } pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)mete, false); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)mete, false)); char type[8 + VARSTR_HEADER_SIZE] = {0}; if(pTopic->subType == TOPIC_SUB_TYPE__COLUMN){ @@ -992,7 +918,8 @@ static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl } pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); - colDataSetVal(pColInfo, numOfRows, (const char *)type, false); + MND_TMQ_NULL_CHECK(pColInfo); + MND_TMQ_RETURN_CHECK(colDataSetVal(pColInfo, numOfRows, (const char *)type, false)); numOfRows++; sdbRelease(pSdb, pTopic); @@ -1000,24 +927,11 @@ static int32_t mndRetrieveTopic(SRpcMsg *pReq, SShowObj *pShow, SSDataBlock *pBl pShow->numOfRows += numOfRows; return numOfRows; -} -int32_t mndSetTopicCommitLogs(SMnode *pMnode, STrans *pTrans, SMqTopicObj *pTopic) { - SSdbRaw *pCommitRaw = mndTopicActionEncode(pTopic); - if (pCommitRaw == NULL) return -1; - if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1; - if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_READY) != 0) return -1; - - return 0; -} - -static int32_t mndSetDropTopicCommitLogs(SMnode *pMnode, STrans *pTrans, SMqTopicObj *pTopic) { - SSdbRaw *pCommitRaw = mndTopicActionEncode(pTopic); - if (pCommitRaw == NULL) return -1; - if (mndTransAppendCommitlog(pTrans, pCommitRaw) != 0) return -1; - if (sdbSetRawStatus(pCommitRaw, SDB_STATUS_DROPPED) != 0) return -1; - - return 0; +END: + taosMemoryFreeClear(schemaJson); + taosMemoryFreeClear(sql); + return code; } static void mndCancelGetNextTopic(SMnode *pMnode, void *pIter) { @@ -1047,33 +961,3 @@ bool mndTopicExistsForDb(SMnode *pMnode, SDbObj *pDb) { return false; } - -#if 0 -int32_t mndDropTopicByDB(SMnode *pMnode, STrans *pTrans, SDbObj *pDb) { - int32_t code = 0; - SSdb *pSdb = pMnode->pSdb; - - void *pIter = NULL; - SMqTopicObj *pTopic = NULL; - while (1) { - pIter = sdbFetch(pSdb, SDB_TOPIC, pIter, (void **)&pTopic); - if (pIter == NULL) break; - - if (pTopic->dbUid != pDb->uid) { - sdbRelease(pSdb, pTopic); - continue; - } - - if (mndSetDropTopicCommitLogs(pMnode, pTrans, pTopic) < 0) { - sdbRelease(pSdb, pTopic); - sdbCancelFetch(pSdb, pIter); - code = -1; - break; - } - - sdbRelease(pSdb, pTopic); - } - - return code; -} -#endif diff --git a/source/dnode/mnode/impl/src/mndUser.c b/source/dnode/mnode/impl/src/mndUser.c index fd5267e471..cd0cd97026 100644 --- a/source/dnode/mnode/impl/src/mndUser.c +++ b/source/dnode/mnode/impl/src/mndUser.c @@ -1357,7 +1357,7 @@ SHashObj *mndDupUseDbHash(SHashObj *pOld) { } int32_t mndUserDupObj(SUserObj *pUser, SUserObj *pNew) { - memcpy(pNew, pUser, sizeof(SUserObj)); + (void)memcpy(pNew, pUser, sizeof(SUserObj)); pNew->authVersion++; pNew->updateTime = taosGetTimestampMs(); @@ -1377,7 +1377,7 @@ int32_t mndUserDupObj(SUserObj *pUser, SUserObj *pNew) { taosRUnLockLatch(&pUser->lock); if (pNew->readDbs == NULL || pNew->writeDbs == NULL || pNew->topics == NULL) { - return -1; + return TSDB_CODE_INVALID_PARA; } return 0; } @@ -1983,10 +1983,11 @@ static int32_t mndProcessAlterUserPrivilegesReq(SAlterUserReq *pAlterReq, SMnode if (ALTER_USER_ADD_SUBSCRIBE_TOPIC_PRIV(pAlterReq->alterType, pAlterReq->privileges)) { int32_t len = strlen(pAlterReq->objname) + 1; - SMqTopicObj *pTopic = mndAcquireTopic(pMnode, pAlterReq->objname); - if (pTopic == NULL) { + SMqTopicObj *pTopic = NULL; + int32_t code = mndAcquireTopic(pMnode, pAlterReq->objname, &pTopic); + if (code != 0) { mndReleaseTopic(pMnode, pTopic); - return -1; + return code; } taosHashPut(pNewUser->topics, pTopic->name, len, pTopic->name, TSDB_TOPIC_FNAME_LEN); mndReleaseTopic(pMnode, pTopic); @@ -1994,10 +1995,11 @@ static int32_t mndProcessAlterUserPrivilegesReq(SAlterUserReq *pAlterReq, SMnode if (ALTER_USER_DEL_SUBSCRIBE_TOPIC_PRIV(pAlterReq->alterType, pAlterReq->privileges)) { int32_t len = strlen(pAlterReq->objname) + 1; - SMqTopicObj *pTopic = mndAcquireTopic(pMnode, pAlterReq->objname); - if (pTopic == NULL) { + SMqTopicObj *pTopic = NULL; + int32_t code = mndAcquireTopic(pMnode, pAlterReq->objname, &pTopic); + if (code != 0) { mndReleaseTopic(pMnode, pTopic); - return -1; + return code; } taosHashRemove(pNewUser->topics, pAlterReq->objname, len); mndReleaseTopic(pMnode, pTopic); diff --git a/source/dnode/mnode/impl/src/mndVgroup.c b/source/dnode/mnode/impl/src/mndVgroup.c index 0422bfabff..d100f84d5a 100644 --- a/source/dnode/mnode/impl/src/mndVgroup.c +++ b/source/dnode/mnode/impl/src/mndVgroup.c @@ -2725,15 +2725,6 @@ int32_t mndSplitVgroup(SMnode *pMnode, SRpcMsg *pReq, SDbObj *pDb, SVgObj *pVgro SDbObj dbObj = {0}; SArray *pArray = mndBuildDnodesArray(pMnode, 0); - // int32_t numOfTopics = 0; - // if (mndGetNumOfTopics(pMnode, pDb->name, &numOfTopics) != 0) { - // goto _OVER; - // } - // if (numOfTopics > 0) { - // terrno = TSDB_CODE_MND_TOPIC_MUST_BE_DELETED; - // goto _OVER; - // } - int32_t numOfStreams = 0; if (mndGetNumOfStreams(pMnode, pDb->name, &numOfStreams) != 0) { goto _OVER; From 7b39915027a3e653e48cf1bf54bdff51de373792 Mon Sep 17 00:00:00 2001 From: wangmm0220 Date: Mon, 22 Jul 2024 17:43:26 +0800 Subject: [PATCH 04/15] fix:[TD-31017]process return value in mnode for tmq --- source/dnode/mnode/impl/src/mndConsumer.c | 4 +++- source/dnode/mnode/impl/src/mndSubscribe.c | 6 ++++-- source/dnode/mnode/impl/src/mndTopic.c | 6 ++++-- 3 files changed, 11 insertions(+), 5 deletions(-) diff --git a/source/dnode/mnode/impl/src/mndConsumer.c b/source/dnode/mnode/impl/src/mndConsumer.c index 532a224732..cea664f64d 100644 --- a/source/dnode/mnode/impl/src/mndConsumer.c +++ b/source/dnode/mnode/impl/src/mndConsumer.c @@ -604,7 +604,9 @@ SSdbRaw *mndConsumerActionEncode(SMqConsumerObj *pConsumer) { if (buf == NULL) goto CM_ENCODE_OVER; void *abuf = buf; - tEncodeSMqConsumerObj(&abuf, pConsumer); + if(tEncodeSMqConsumerObj(&abuf, pConsumer) < 0){ + goto CM_ENCODE_OVER; + } int32_t dataPos = 0; SDB_SET_INT32(pRaw, dataPos, tlen, CM_ENCODE_OVER); diff --git a/source/dnode/mnode/impl/src/mndSubscribe.c b/source/dnode/mnode/impl/src/mndSubscribe.c index 731e25175f..ec915eb9d8 100644 --- a/source/dnode/mnode/impl/src/mndSubscribe.c +++ b/source/dnode/mnode/impl/src/mndSubscribe.c @@ -1109,7 +1109,9 @@ static SSdbRaw *mndSubActionEncode(SMqSubscribeObj *pSub) { if (buf == NULL) goto SUB_ENCODE_OVER; void *abuf = buf; - tEncodeSubscribeObj(&abuf, pSub); + if (tEncodeSubscribeObj(&abuf, pSub) < 0){ + goto SUB_ENCODE_OVER; + } int32_t dataPos = 0; SDB_SET_INT32(pRaw, dataPos, tlen, SUB_ENCODE_OVER); @@ -1342,7 +1344,7 @@ static int32_t buildResult(SSDataBlock *pBlock, int32_t *numOfRows, int64_t cons // consumer id char consumerIdHex[32] = {0}; - sprintf(varDataVal(consumerIdHex), "0x%" PRIx64, consumerId); + (void)sprintf(varDataVal(consumerIdHex), "0x%" PRIx64, consumerId); varDataSetLen(consumerIdHex, strlen(varDataVal(consumerIdHex))); pColInfo = taosArrayGet(pBlock->pDataBlock, cols++); diff --git a/source/dnode/mnode/impl/src/mndTopic.c b/source/dnode/mnode/impl/src/mndTopic.c index 959a3ef008..2fb0870ed6 100644 --- a/source/dnode/mnode/impl/src/mndTopic.c +++ b/source/dnode/mnode/impl/src/mndTopic.c @@ -134,7 +134,9 @@ SSdbRaw *mndTopicActionEncode(SMqTopicObj *pTopic) { goto TOPIC_ENCODE_OVER; } void *aswBuf = swBuf; - taosEncodeSSchemaWrapper(&aswBuf, &pTopic->schema); + if(taosEncodeSSchemaWrapper(&aswBuf, &pTopic->schema) < 0){ + goto TOPIC_ENCODE_OVER; + } SDB_SET_BINARY(pRaw, dataPos, swBuf, schemaLen, TOPIC_ENCODE_OVER); } @@ -264,7 +266,7 @@ SSdbRow *mndTopicActionDecode(SSdbRaw *pRaw) { } int16_t colId; SDB_GET_INT16(pRaw, dataPos, &colId, TOPIC_DECODE_OVER); - taosArrayPush(pTopic->ntbColIds, &colId); + (void)taosArrayPush(pTopic->ntbColIds, &colId); } SDB_GET_INT64(pRaw, dataPos, &pTopic->ctbStbUid, TOPIC_DECODE_OVER); From 7718d5e042162b4c93f795cf3a600cff523fe666 Mon Sep 17 00:00:00 2001 From: dapan1121 Date: Mon, 22 Jul 2024 18:47:41 +0800 Subject: [PATCH 05/15] fix: os return code --- include/os/os.h | 1 + include/os/osTime.h | 8 ++++---- source/os/src/osDir.c | 6 +++--- source/os/src/osMemory.c | 39 +++++++++++++++++++++++++++++++-------- source/os/src/osRand.c | 2 +- source/os/src/osTime.c | 26 ++++++++++++++++++++------ 6 files changed, 60 insertions(+), 22 deletions(-) diff --git a/include/os/os.h b/include/os/os.h index ac1a750b78..1749687d97 100644 --- a/include/os/os.h +++ b/include/os/os.h @@ -97,6 +97,7 @@ extern "C" { #include #endif + #include "osThread.h" #include "osAtomic.h" diff --git a/include/os/osTime.h b/include/os/osTime.h index 87df3a2650..c367416175 100644 --- a/include/os/osTime.h +++ b/include/os/osTime.h @@ -65,28 +65,28 @@ int32_t taosGetTimestampSec(); //@return timestamp in millisecond static FORCE_INLINE int64_t taosGetTimestampMs() { struct timeval systemTime; - taosGetTimeOfDay(&systemTime); + (void)taosGetTimeOfDay(&systemTime); return (int64_t)systemTime.tv_sec * 1000LL + (int64_t)systemTime.tv_usec / 1000; } //@return timestamp in microsecond static FORCE_INLINE int64_t taosGetTimestampUs() { struct timeval systemTime; - taosGetTimeOfDay(&systemTime); + (void)taosGetTimeOfDay(&systemTime); return (int64_t)systemTime.tv_sec * 1000000LL + (int64_t)systemTime.tv_usec; } //@return timestamp in nanosecond static FORCE_INLINE int64_t taosGetTimestampNs() { struct timespec systemTime = {0}; - taosClockGetTime(CLOCK_REALTIME, &systemTime); + (void)taosClockGetTime(CLOCK_REALTIME, &systemTime); return (int64_t)systemTime.tv_sec * 1000000000LL + (int64_t)systemTime.tv_nsec; } //@return timestamp of monotonic clock in millisecond static FORCE_INLINE int64_t taosGetMonoTimestampMs() { struct timespec systemTime = {0}; - taosClockGetTime(CLOCK_MONOTONIC, &systemTime); + (void)taosClockGetTime(CLOCK_MONOTONIC, &systemTime); return (int64_t)systemTime.tv_sec * 1000LL + (int64_t)systemTime.tv_nsec / 1000000; } diff --git a/source/os/src/osDir.c b/source/os/src/osDir.c index 667c3c146a..4348629467 100644 --- a/source/os/src/osDir.c +++ b/source/os/src/osDir.c @@ -44,7 +44,7 @@ int wordexp(char *words, wordexp_t *pwordexp, int flags) { pwordexp->we_wordc = 1; pwordexp->we_wordv[0] = pwordexp->wordPos; - memset(pwordexp->wordPos, 0, 1025); + (void)memset(pwordexp->wordPos, 0, 1025); if (_fullpath(pwordexp->wordPos, words, 1024) == NULL) { pwordexp->we_wordv[0] = words; printf("failed to parse relative path:%s to abs path\n", words); @@ -100,7 +100,7 @@ void taosRemoveDir(const char *dirname) { if (strcmp(taosGetDirEntryName(de), ".") == 0 || strcmp(taosGetDirEntryName(de), "..") == 0) continue; char filename[1024] = {0}; - snprintf(filename, sizeof(filename), "%s%s%s", dirname, TD_DIRSEP, taosGetDirEntryName(de)); + (void)snprintf(filename, sizeof(filename), "%s%s%s", dirname, TD_DIRSEP, taosGetDirEntryName(de)); if (taosDirEntryIsDir(de)) { taosRemoveDir(filename); } else { @@ -110,7 +110,7 @@ void taosRemoveDir(const char *dirname) { } taosCloseDir(&pDir); - rmdir(dirname); + (void)rmdir(dirname); // printf("dir:%s is removed\n", dirname); return; diff --git a/source/os/src/osMemory.c b/source/os/src/osMemory.c index d130ebe469..3e49808dad 100644 --- a/source/os/src/osMemory.c +++ b/source/os/src/osMemory.c @@ -186,7 +186,7 @@ static void print_line(Dwarf_Debug dbg, Dwarf_Line line, Dwarf_Addr pc) { dwarf_linesrc(line, &linesrc, NULL); dwarf_lineno(line, &lineno, NULL); } - printf("BackTrace %08" PRId64 " %s:%" DW_PR_DUu "\n", taosGetSelfPthreadId(), linesrc, lineno); + (void)printf("BackTrace %08" PRId64 " %s:%" DW_PR_DUu "\n", taosGetSelfPthreadId(), linesrc, lineno); if (line) dwarf_dealloc(dbg, linesrc, DW_DLA_STRING); } void taosPrintBackTrace() { @@ -266,7 +266,11 @@ void *taosMemoryMalloc(int64_t size) { return (char *)tmp + sizeof(TdMemoryInfo); #else - return malloc(size); + void* p = malloc(size); + if (NULL == p) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + } + return p; #endif } @@ -283,7 +287,11 @@ void *taosMemoryCalloc(int64_t num, int64_t size) { return (char *)tmp + sizeof(TdMemoryInfo); #else - return calloc(num, size); + void* p = calloc(num, size); + if (NULL == p) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + } + return p; #endif } @@ -309,7 +317,11 @@ void *taosMemoryRealloc(void *ptr, int64_t size) { return (char *)tmp + sizeof(TdMemoryInfo); #else - return realloc(ptr, size); + void* p = realloc(ptr, size); + if (size > 0 && NULL == p) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + } + return p; #endif } @@ -330,7 +342,12 @@ char *taosStrdup(const char *ptr) { return (char *)tmp + sizeof(TdMemoryInfo); #else - return tstrdup(ptr); + char* p = tstrdup(ptr); + if (ptr != NULL && NULL == p) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + } + return p; + #endif } @@ -357,8 +374,7 @@ int64_t taosMemorySize(void *ptr) { TdMemoryInfoPtr pTdMemoryInfo = (TdMemoryInfoPtr)((char *)ptr - sizeof(TdMemoryInfo)); ASSERT(pTdMemoryInfo->symbol == TD_MEMORY_SYMBOL); if (pTdMemoryInfo->symbol != TD_MEMORY_SYMBOL) { - +return NULL; - + + return NULL; } return pTdMemoryInfo->memorySize; @@ -378,7 +394,7 @@ void taosMemoryTrim(int32_t size) { // do nothing return; #else - malloc_trim(size); + (void)malloc_trim(size); #endif } @@ -388,6 +404,13 @@ void *taosMemoryMallocAlign(uint32_t alignment, int64_t size) { #else #if defined(LINUX) void *p = memalign(alignment, size); + if (NULL == p) { + if (ENOMEM == errno) { + terrno = TSDB_CODE_OUT_OF_MEMORY; + } else { + terrno = TAOS_SYSTEM_ERROR(errno); + } + } return p; #else return taosMemoryMalloc(size); diff --git a/source/os/src/osRand.c b/source/os/src/osRand.c index 0e58b7a8ec..da4e8dfb9d 100644 --- a/source/os/src/osRand.c +++ b/source/os/src/osRand.c @@ -69,7 +69,7 @@ uint32_t taosSafeRand(void) { if (len < 0) { seed = (int)taosGetTimestampSec(); } - taosCloseFile(&pFile); + (void)taosCloseFile(&pFile); } return (uint32_t)seed; diff --git a/source/os/src/osTime.c b/source/os/src/osTime.c index 9cad1dd6ef..c650ac989d 100644 --- a/source/os/src/osTime.c +++ b/source/os/src/osTime.c @@ -345,6 +345,7 @@ char *taosStrpTime(const char *buf, const char *fmt, struct tm *tm) { } int32_t taosGetTimeOfDay(struct timeval *tv) { + int32_t code = 0; #ifdef WINDOWS LARGE_INTEGER t; FILETIME f; @@ -359,11 +360,18 @@ int32_t taosGetTimeOfDay(struct timeval *tv) { tv->tv_usec = (t.QuadPart % 10000000) / 10; return 0; #else - return gettimeofday(tv, NULL); + code = gettimeofday(tv, NULL); + return (-1 == code) ? (terrno = TAOS_SYSTEM_ERROR(errno)) : 0; #endif } -time_t taosTime(time_t *t) { return time(t); } +time_t taosTime(time_t *t) { + time_t r = time(t); + if (r == (time_t)-1) { + terrno = TAOS_SYSTEM_ERROR(errno); + } + return r; +} /* * mktime64 - Converts date to seconds. @@ -458,7 +466,11 @@ time_t taosMktime(struct tm *timep) { timep->tm_sec, tz); #endif #else - return mktime(timep); + time_t r = mktime(timep); + if (r == (time_t)-1) { + terrno = TAOS_SYSTEM_ERROR(errno); + } + return r; #endif } @@ -470,7 +482,7 @@ struct tm *taosLocalTime(const time_t *timep, struct tm *result, char *buf) { if (result == NULL) { res = localtime(timep); if (res == NULL && buf != NULL) { - sprintf(buf, "NaN"); + (void)sprintf(buf, "NaN"); } return res; } @@ -528,7 +540,7 @@ struct tm *taosLocalTime(const time_t *timep, struct tm *result, char *buf) { #else res = localtime_r(timep, result); if (res == NULL && buf != NULL) { - sprintf(buf, "NaN"); + (void)sprintf(buf, "NaN"); } #endif return result; @@ -642,6 +654,7 @@ struct tm *taosLocalTimeNolock(struct tm *result, const time_t *timep, int dst) int32_t taosGetTimestampSec() { return (int32_t)time(NULL); } int32_t taosClockGetTime(int clock_id, struct timespec *pTS) { + int32_t code = 0; #ifdef WINDOWS LARGE_INTEGER t; FILETIME f; @@ -656,6 +669,7 @@ int32_t taosClockGetTime(int clock_id, struct timespec *pTS) { pTS->tv_nsec = (t.QuadPart % 10000000) * 100; return (0); #else - return clock_gettime(clock_id, pTS); + code = clock_gettime(clock_id, pTS); + return (-1 == code) ? (terrno = TAOS_SYSTEM_ERROR(errno)) : 0; #endif } From 1d35ea137a56e7ad5931030e9a2e8b17c80fe2b7 Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao> Date: Tue, 23 Jul 2024 10:50:16 +0800 Subject: [PATCH 06/15] adj query operator result --- source/libs/executor/inc/executil.h | 31 +- source/libs/executor/inc/executorInt.h | 2 +- source/libs/executor/inc/tfill.h | 6 +- source/libs/executor/src/aggregateoperator.c | 46 +- source/libs/executor/src/cachescanoperator.c | 90 ++- .../libs/executor/src/countwindowoperator.c | 49 +- .../libs/executor/src/eventwindowoperator.c | 32 +- source/libs/executor/src/exchangeoperator.c | 159 +++-- source/libs/executor/src/executil.c | 394 ++++++++--- source/libs/executor/src/executorInt.c | 5 +- source/libs/executor/src/filloperator.c | 33 +- source/libs/executor/src/groupoperator.c | 4 +- source/libs/executor/src/scanoperator.c | 40 +- source/libs/executor/src/sysscanoperator.c | 614 +++++++++++++----- source/libs/executor/src/tfill.c | 197 ++++-- source/libs/executor/src/timesliceoperator.c | 287 +++++--- source/libs/executor/src/timewindowoperator.c | 283 +++++--- source/libs/executor/test/timewindowTest.cpp | 28 +- 18 files changed, 1630 insertions(+), 670 deletions(-) diff --git a/source/libs/executor/inc/executil.h b/source/libs/executor/inc/executil.h index 27ea98afd5..7b27b41177 100644 --- a/source/libs/executor/inc/executil.h +++ b/source/libs/executor/inc/executil.h @@ -106,9 +106,9 @@ typedef struct STableListInfo { int32_t numOfOuputGroups; // the data block will be generated one by one int32_t* groupOffset; // keep the offset value for each group in the tableList SArray* pTableList; - SHashObj* map; // speedup acquire the tableQueryInfo by table uid - SHashObj* remainGroups; // remaining group has not yet processed the empty group - STableListIdInfo idInfo; // this maybe the super table or ordinary table + SHashObj* map; // speedup acquire the tableQueryInfo by table uid + SHashObj* remainGroups; // remaining group has not yet processed the empty group + STableListIdInfo idInfo; // this maybe the super table or ordinary table } STableListInfo; struct SqlFunctionCtx; @@ -118,7 +118,7 @@ int32_t createScanTableListInfo(SScanPhysiNode* pScanNode, SNodeList* pGroupTags SExecTaskInfo* pTaskInfo); STableListInfo* tableListCreate(); -void* tableListDestroy(STableListInfo* pTableListInfo); +void tableListDestroy(STableListInfo* pTableListInfo); void tableListClear(STableListInfo* pTableListInfo); int32_t tableListGetOutputGroups(const STableListInfo* pTableList); bool oneTableForEachGroup(const STableListInfo* pTableList); @@ -130,7 +130,7 @@ uint64_t tableListGetSize(const STableListInfo* pTableList); uint64_t tableListGetSuid(const STableListInfo* pTableList); STableKeyInfo* tableListGetInfo(const STableListInfo* pTableList, int32_t index); int32_t tableListFind(const STableListInfo* pTableList, uint64_t uid, int32_t startIndex); -void tableListGetSourceTableInfo(const STableListInfo* pTableList, uint64_t* psuid, uint64_t* uid, int32_t* type); +void tableListGetSourceTableInfo(const STableListInfo* pTableList, uint64_t* psuid, uint64_t* uid, int32_t* type); size_t getResultRowSize(struct SqlFunctionCtx* pCtx, int32_t numOfOutput); void initResultRowInfo(SResultRowInfo* pResultRowInfo); @@ -165,7 +165,8 @@ SSDataBlock* createDataBlockFromDescNode(SDataBlockDescNode* pNode); int32_t prepareDataBlockBuf(SSDataBlock* pDataBlock, SColMatchInfo* pMatchInfo); EDealRes doTranslateTagExpr(SNode** pNode, void* pContext); -int32_t getGroupIdFromTagsVal(void* pVnode, uint64_t uid, SNodeList* pGroupNode, char* keyBuf, uint64_t* pGroupId, SStorageAPI* pAPI); +int32_t getGroupIdFromTagsVal(void* pVnode, uint64_t uid, SNodeList* pGroupNode, char* keyBuf, uint64_t* pGroupId, + SStorageAPI* pAPI); size_t getTableTagsBufLen(const SNodeList* pGroups); SArray* createSortInfo(SNodeList* pNodeList); @@ -173,18 +174,20 @@ SArray* makeColumnArrayFromList(SNodeList* pNodeList); int32_t extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNodeList, int32_t* numOfOutputCols, int32_t type, SColMatchInfo* pMatchInfo); -void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId); -void createExprFromTargetNode(SExprInfo* pExp, STargetNode* pTargetNode); +int32_t createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId); +int32_t createExprFromTargetNode(SExprInfo* pExp, STargetNode* pTargetNode); SExprInfo* createExprInfo(SNodeList* pNodeList, SNodeList* pGroupKeys, int32_t* numOfExprs); -SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, int32_t** rowEntryInfoOffset, SFunctionStateStore* pStore); -void relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray* pCols, bool outputEveryColumn); +SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, int32_t** rowEntryInfoOffset, + SFunctionStateStore* pStore); +int32_t relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray* pCols, bool outputEveryColumn); int32_t initExecTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pQueryWindow); SInterval extractIntervalInfo(const STableScanPhysiNode* pTableScanNode); SColumn extractColumnFromColumnNode(SColumnNode* pColNode); -int32_t initQueryTableDataCond(SQueryTableDataCond* pCond, const STableScanPhysiNode* pTableScanNode, const SReadHandle* readHandle); +int32_t initQueryTableDataCond(SQueryTableDataCond* pCond, const STableScanPhysiNode* pTableScanNode, + const SReadHandle* readHandle); void cleanupQueryTableDataCond(SQueryTableDataCond* pCond); int32_t convertFillType(int32_t mode); @@ -198,7 +201,7 @@ void getNextTimeWindow(const SInterval* pInterval, STimeWindow* tw, int32_t orde void getInitialStartTimeWindow(SInterval* pInterval, TSKEY ts, STimeWindow* w, bool ascQuery); TSKEY getStartTsKey(STimeWindow* win, const TSKEY* tsCols); -void updateTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pWin, int64_t delta); +void updateTimeWindowInfo(SColumnInfoData* pColData, STimeWindow* pWin, int64_t delta); SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, SArray* pUidTagList, void* pVnode, SStorageAPI* pStorageAPI); @@ -212,9 +215,9 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S int32_t buildKeys(char* keyBuf, const SArray* pSortGroupCols, const SSDataBlock* pBlock, int32_t rowIndex); int32_t compKeys(const SArray* pSortGroupCols, const char* oldkeyBuf, int32_t oldKeysLen, const SSDataBlock* pDataBlock, - int32_t rowIndex); + int32_t rowIndex); -uint64_t calcGroupId(char *pData, int32_t len); +uint64_t calcGroupId(char* pData, int32_t len); SNodeList* makeColsNodeArrFromSortKeys(SNodeList* pSortKeys); diff --git a/source/libs/executor/inc/executorInt.h b/source/libs/executor/inc/executorInt.h index fec16f9ef4..31fdc5b291 100644 --- a/source/libs/executor/inc/executorInt.h +++ b/source/libs/executor/inc/executorInt.h @@ -903,7 +903,7 @@ int32_t appendDataToSpecialBlock(SSDataBlock* pBlock, TSKEY* pStartTs, TSKEY* pE uint64_t calGroupIdByData(SPartitionBySupporter* pParSup, SExprSupp* pExprSup, SSDataBlock* pBlock, int32_t rowId); -int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, SExprSupp* pSup, +void finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, SExprSupp* pSup, SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo); bool groupbyTbname(SNodeList* pGroupList); diff --git a/source/libs/executor/inc/tfill.h b/source/libs/executor/inc/tfill.h index 82d422302c..cd003ebd15 100644 --- a/source/libs/executor/inc/tfill.h +++ b/source/libs/executor/inc/tfill.h @@ -20,6 +20,7 @@ extern "C" { #endif +#include "executil.h" #include "os.h" #include "taosdef.h" #include "tcommon.h" @@ -77,6 +78,7 @@ typedef struct SFillInfo { SFillColInfo* pFillCol; // column info for fill operations SFillTagColInfo* pTags; // tags value for filling gap const char* id; + SExecTaskInfo* pTaskInfo; } SFillInfo; typedef struct SResultCellData { @@ -128,10 +130,10 @@ bool taosFillHasMoreResults(struct SFillInfo* pFillInfo); SFillInfo* taosCreateFillInfo(TSKEY skey, int32_t numOfFillCols, int32_t numOfNotFillCols, int32_t capacity, SInterval* pInterval, int32_t fillType, struct SFillColInfo* pCol, int32_t slotId, - int32_t order, const char* id); + int32_t order, const char* id, SExecTaskInfo* pTaskInfo); void* taosDestroyFillInfo(struct SFillInfo* pFillInfo); -void taosFillResultDataBlock(struct SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity); +int32_t taosFillResultDataBlock(struct SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity); int64_t getFillInfoStart(struct SFillInfo* pFillInfo); bool fillIfWindowPseudoColumn(SFillInfo* pFillInfo, SFillColInfo* pCol, SColumnInfoData* pDstColInfoData, diff --git a/source/libs/executor/src/aggregateoperator.c b/source/libs/executor/src/aggregateoperator.c index 55cb8c8302..1e86b90d3b 100644 --- a/source/libs/executor/src/aggregateoperator.c +++ b/source/libs/executor/src/aggregateoperator.c @@ -194,7 +194,9 @@ static bool nextGroupedResult(SOperatorInfo* pOperator) { pBlock = getNextBlockFromDownstream(pOperator, 0); if (pBlock == NULL) { if (!pAggInfo->hasValidBlock) { - createDataBlockForEmptyInput(pOperator, &pBlock); + code = createDataBlockForEmptyInput(pOperator, &pBlock); + QUERY_CHECK_CODE(code, lino, _end); + if (pBlock == NULL) { break; } @@ -240,7 +242,7 @@ static bool nextGroupedResult(SOperatorInfo* pOperator) { } initGroupedResultInfo(&pAggInfo->groupResInfo, pAggInfo->aggSup.pResultRowHashTable, 0); - + _end: if (code != TSDB_CODE_SUCCESS) { qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); @@ -251,6 +253,8 @@ _end: } SSDataBlock* getAggregateResult(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SAggOperatorInfo* pAggInfo = pOperator->info; SOptrBasicInfo* pInfo = &pAggInfo->binfo; @@ -262,11 +266,13 @@ SSDataBlock* getAggregateResult(SOperatorInfo* pOperator) { bool hasNewGroups = false; do { hasNewGroups = nextGroupedResult(pOperator); - blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _end); while (1) { doBuildResultDatablock(pOperator, pInfo, &pAggInfo->groupResInfo, pAggInfo->aggSup.pResultBuf); - doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); if (!hasRemainResults(&pAggInfo->groupResInfo)) { if (!hasNewGroups) setOperatorCompleted(pOperator); @@ -282,6 +288,12 @@ SSDataBlock* getAggregateResult(SOperatorInfo* pOperator) { size_t rows = blockDataGetNumOfRows(pInfo->pRes); pOperator->resultInfo.totalRows += rows; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } + return (rows == 0) ? NULL : pInfo->pRes; } @@ -312,6 +324,8 @@ int32_t doAggregateImpl(SOperatorInfo* pOperator, SqlFunctionCtx* pCtx) { } static int32_t createDataBlockForEmptyInput(SOperatorInfo* pOperator, SSDataBlock** ppBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (!tsCountAlwaysReturnValue) { return TSDB_CODE_SUCCESS; } @@ -352,9 +366,12 @@ static int32_t createDataBlockForEmptyInput(SOperatorInfo* pOperator, SSDataBloc int32_t slotId = pFuncParam->pCol->slotId; int32_t numOfCols = taosArrayGetSize(pBlock->pDataBlock); if (slotId >= numOfCols) { - taosArrayEnsureCap(pBlock->pDataBlock, slotId + 1); + code = taosArrayEnsureCap(pBlock->pDataBlock, slotId + 1); + QUERY_CHECK_CODE(code, lino, _end); + for (int32_t k = numOfCols; k < slotId + 1; ++k) { - taosArrayPush(pBlock->pDataBlock, &colInfo); + void* tmp = taosArrayPush(pBlock->pDataBlock, &colInfo); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } } } else if (pFuncParam->type == FUNC_PARAM_TYPE_VALUE) { @@ -363,14 +380,20 @@ static int32_t createDataBlockForEmptyInput(SOperatorInfo* pOperator, SSDataBloc } } - blockDataEnsureCapacity(pBlock, pBlock->info.rows); + code = blockDataEnsureCapacity(pBlock, pBlock->info.rows); + QUERY_CHECK_CODE(code, lino, _end); + for (int32_t i = 0; i < blockDataGetNumOfCols(pBlock); ++i) { SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, i); colDataSetNULL(pColInfoData, 0); } *ppBlock = pBlock; - return TSDB_CODE_SUCCESS; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + } + return code; } void destroyDataBlockForEmptyInput(bool blockAllocated, SSDataBlock** ppBlock) { @@ -571,7 +594,12 @@ void applyAggFunctionOnPartialTuples(SExecTaskInfo* taskInfo, SqlFunctionCtx* pC SScalarParam out = {.columnData = &idata}; SScalarParam tw = {.numOfRows = 5, .columnData = pTimeWindowData}; - pCtx[k].sfp.process(&tw, 1, &out); + int32_t code = pCtx[k].sfp.process(&tw, 1, &out); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + taskInfo->code = code; + T_LONG_JMP(taskInfo->env, code); + } pEntryInfo->numOfRes = 1; } else { int32_t code = TSDB_CODE_SUCCESS; diff --git a/source/libs/executor/src/cachescanoperator.c b/source/libs/executor/src/cachescanoperator.c index ad7d089da9..8559a44348 100644 --- a/source/libs/executor/src/cachescanoperator.c +++ b/source/libs/executor/src/cachescanoperator.c @@ -13,8 +13,8 @@ * along with this program. If not, see . */ -#include "os.h" #include "function.h" +#include "os.h" #include "tname.h" #include "tdatablock.h" @@ -63,7 +63,7 @@ static void setColIdForCacheReadBlock(SSDataBlock* pBlock, SLastRowScanPhysiNode int32_t idx = 0; FOREACH(pNode, pScan->pTargets) { if (nodeType(pNode) == QUERY_NODE_COLUMN) { - SColumnNode* pCol = (SColumnNode*)pNode; + SColumnNode* pCol = (SColumnNode*)pNode; SColumnInfoData* pColInfo = taosArrayGet(pBlock->pDataBlock, idx); pColInfo->info.colId = pCol->colId; } @@ -87,6 +87,7 @@ static void setColIdForCacheReadBlock(SSDataBlock* pBlock, SLastRowScanPhysiNode SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SReadHandle* readHandle, STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo) { int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; int32_t numOfCols = 0; SNodeList* pScanCols = pScanNode->scan.pScanCols; SCacheRowsScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SCacheRowsScanInfo)); @@ -105,9 +106,7 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe pInfo->pRes = createDataBlockFromDescNode(pDescNode); code = extractColMatchInfo(pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); // todo: the pk information should comes from the physical plan // pk info may not in pScanCols, so extract primary key from pInfo->matchInfo may failed @@ -121,7 +120,7 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe pInfo->pkCol.pk = 1; } } else { - for(int32_t i = 0; i < taosArrayGetSize(pInfo->matchInfo.pList); ++i) { + for (int32_t i = 0; i < taosArrayGetSize(pInfo->matchInfo.pList); ++i) { SColMatchItem* pItem = taosArrayGet(pInfo->matchInfo.pList, i); if (pItem->isPk) { pInfo->numOfPks += 1; @@ -134,23 +133,24 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe SArray* pCidList = taosArrayInit(numOfCols, sizeof(int16_t)); pInfo->pFuncTypeList = taosArrayInit(taosArrayGetSize(pScanNode->pFuncTypes), sizeof(int32_t)); - taosArrayAddAll(pInfo->pFuncTypeList, pScanNode->pFuncTypes); + void* tmp = taosArrayAddAll(pInfo->pFuncTypeList, pScanNode->pFuncTypes); + QUERY_CHECK_NULL(tmp, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); for (int i = 0; i < TARRAY_SIZE(pInfo->matchInfo.pList); ++i) { SColMatchItem* pColInfo = taosArrayGet(pInfo->matchInfo.pList, i); - taosArrayPush(pCidList, &pColInfo->colId); + void* tmp = taosArrayPush(pCidList, &pColInfo->colId); + QUERY_CHECK_NULL(tmp, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); if (pInfo->pFuncTypeList != NULL && taosArrayGetSize(pInfo->pFuncTypeList) > i) { pColInfo->funcType = *(int32_t*)taosArrayGet(pInfo->pFuncTypeList, i); } } pInfo->pCidList = pCidList; - removeRedundantTsCol(pScanNode, &pInfo->matchInfo); + code = removeRedundantTsCol(pScanNode, &pInfo->matchInfo); + QUERY_CHECK_CODE(code, lino, _error); code = extractCacheScanSlotId(pInfo->matchInfo.pList, pTaskInfo, &pInfo->pSlotIds, &pInfo->pDstSlotIds); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); int32_t totalTables = tableListGetSize(pTableListInfo); int32_t capacity = 0; @@ -166,17 +166,16 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe uint64_t suid = tableListGetSuid(pTableListInfo); code = pInfo->readHandle.api.cacheFn.openReader(pInfo->readHandle.vnode, pInfo->retrieveType, pList, totalTables, taosArrayGetSize(pInfo->matchInfo.pList), pCidList, pInfo->pSlotIds, - suid, &pInfo->pLastrowReader, pTaskInfo->id.str, pScanNode->pFuncTypes, - &pInfo->pkCol, pInfo->numOfPks); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + suid, &pInfo->pLastrowReader, pTaskInfo->id.str, + pScanNode->pFuncTypes, &pInfo->pkCol, pInfo->numOfPks); + QUERY_CHECK_CODE(code, lino, _error); capacity = TMIN(totalTables, 4096); pInfo->pBufferedRes = createOneDataBlock(pInfo->pRes, false); setColIdForCacheReadBlock(pInfo->pBufferedRes, pScanNode); - blockDataEnsureCapacity(pInfo->pBufferedRes, capacity); + code = blockDataEnsureCapacity(pInfo->pBufferedRes, capacity); + QUERY_CHECK_CODE(code, lino, _error); } else { // by tags pInfo->retrieveType = CACHESCAN_RETRIEVE_TYPE_SINGLE | SCAN_ROW_TYPE(pScanNode->ignoreNull); capacity = 1; // only one row output @@ -184,26 +183,31 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe } initResultSizeInfo(&pOperator->resultInfo, capacity); - blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _error); if (pScanNode->scan.pScanPseudoCols != NULL) { SExprSupp* p = &pInfo->pseudoExprSup; p->pExprInfo = createExprInfo(pScanNode->scan.pScanPseudoCols, NULL, &p->numOfExprs); - p->pCtx = createSqlFunctionCtx(p->pExprInfo, p->numOfExprs, &p->rowEntryInfoOffset, &pTaskInfo->storageAPI.functionStore); + p->pCtx = + createSqlFunctionCtx(p->pExprInfo, p->numOfExprs, &p->rowEntryInfoOffset, &pTaskInfo->storageAPI.functionStore); } setOperatorInfo(pOperator, "CachedRowScanOperator", QUERY_NODE_PHYSICAL_PLAN_LAST_ROW_SCAN, false, OP_NOT_OPENED, pInfo, pTaskInfo); pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pRes->pDataBlock); - pOperator->fpSet = - createOperatorFpSet(optrDummyOpenFn, doScanCache, NULL, destroyCacheScanOperator, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); + pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doScanCache, NULL, destroyCacheScanOperator, optrDefaultBufFn, + NULL, optrDefaultGetNextExtFn, NULL); pOperator->cost.openCost = 0; return pOperator; _error: pTaskInfo->code = code; + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + } destroyCacheScanOperator(pInfo); taosMemoryFree(pOperator); return NULL; @@ -258,7 +262,7 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) { if (pInfo->indexOfBufferedRes < pBufRes->info.rows) { for (int32_t i = 0; i < taosArrayGetSize(pBufRes->pDataBlock); ++i) { SColumnInfoData* pCol = taosArrayGet(pRes->pDataBlock, i); - int32_t slotId = pCol->info.slotId; + int32_t slotId = pCol->info.slotId; SColumnInfoData* pSrc = taosArrayGet(pBufRes->pDataBlock, slotId); SColumnInfoData* pDst = taosArrayGet(pRes->pDataBlock, slotId); @@ -267,8 +271,12 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) { colDataSetNULL(pDst, 0); } else { if (pSrc->pData) { - char* p = colDataGetData(pSrc, pInfo->indexOfBufferedRes); - colDataSetVal(pDst, 0, p, false); + char* p = colDataGetData(pSrc, pInfo->indexOfBufferedRes); + int32_t code = colDataSetVal(pDst, 0, p, false); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } } } @@ -320,7 +328,11 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) { continue; } } else { - pReaderFn->reuseReader(pInfo->pLastrowReader, pList, num); + code = pReaderFn->reuseReader(pInfo->pLastrowReader, pList, num); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } taosArrayClear(pInfo->pUidList); @@ -352,10 +364,10 @@ SSDataBlock* doScanCache(SOperatorInfo* pOperator) { } } - //pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader); + // pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader); return pInfo->pRes; } else { - //pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader); + // pInfo->pLastrowReader = tsdbCacherowsReaderClose(pInfo->pLastrowReader); } } @@ -400,12 +412,12 @@ int32_t extractCacheScanSlotId(const SArray* pColMatchInfo, SExecTaskInfo* pTask return TSDB_CODE_OUT_OF_MEMORY; } - SSchemaInfo* pSchemaInfo = taosArrayGetLast(pTaskInfo->schemaInfos); + SSchemaInfo* pSchemaInfo = taosArrayGetLast(pTaskInfo->schemaInfos); SSchemaWrapper* pWrapper = pSchemaInfo->sw; for (int32_t i = 0; i < numOfCols; ++i) { SColMatchItem* pColMatch = taosArrayGet(pColMatchInfo, i); - bool found = false; + bool found = false; for (int32_t j = 0; j < pWrapper->nCols; ++j) { /* if (pColMatch->colId == pWrapper->pSchema[j].colId && pColMatch->colId == PRIMARYKEY_TIMESTAMP_COL_ID) { (*pSlotIds)[pColMatch->dstSlotId] = -1; @@ -429,12 +441,15 @@ int32_t extractCacheScanSlotId(const SArray* pColMatchInfo, SExecTaskInfo* pTask } int32_t removeRedundantTsCol(SLastRowScanPhysiNode* pScanNode, SColMatchInfo* pColMatchInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (!pScanNode->ignoreNull) { // retrieve cached last value return TSDB_CODE_SUCCESS; } size_t size = taosArrayGetSize(pColMatchInfo->pList); SArray* pMatchInfo = taosArrayInit(size, sizeof(SColMatchItem)); + QUERY_CHECK_NULL(pMatchInfo, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); for (int32_t i = 0; i < size; ++i) { SColMatchItem* pColInfo = taosArrayGet(pColMatchInfo->pList, i); @@ -444,13 +459,20 @@ int32_t removeRedundantTsCol(SLastRowScanPhysiNode* pScanNode, SColMatchInfo* pC SSlotDescNode* pDesc = (SSlotDescNode*)nodesListGetNode(pList, slotId); if (pDesc->dataType.type != TSDB_DATA_TYPE_TIMESTAMP) { - taosArrayPush(pMatchInfo, pColInfo); - } else if (FUNCTION_TYPE_CACHE_LAST_ROW == pColInfo->funcType){ - taosArrayPush(pMatchInfo, pColInfo); + void* tmp = taosArrayPush(pMatchInfo, pColInfo); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + } else if (FUNCTION_TYPE_CACHE_LAST_ROW == pColInfo->funcType) { + void* tmp = taosArrayPush(pMatchInfo, pColInfo); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } } taosArrayDestroy(pColMatchInfo->pList); pColMatchInfo->pList = pMatchInfo; - return TSDB_CODE_SUCCESS; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } diff --git a/source/libs/executor/src/countwindowoperator.c b/source/libs/executor/src/countwindowoperator.c index 55f73b9417..58d289efe4 100644 --- a/source/libs/executor/src/countwindowoperator.c +++ b/source/libs/executor/src/countwindowoperator.c @@ -74,12 +74,15 @@ static SCountWindowResult* getCountWinStateInfo(SCountWindowSupp* pCountSup) { return pBuffInfo; } -static SCountWindowResult* setCountWindowOutputBuff(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, - SResultRow** pResult) { +static int32_t setCountWindowOutputBuff(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, SResultRow** pResult, + SCountWindowResult** ppResBuff) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SCountWindowResult* pBuff = getCountWinStateInfo(pCountSup); (*pResult) = &pBuff->row; - setResultRowInitCtx(*pResult, pExprSup->pCtx, pExprSup->numOfExprs, pExprSup->rowEntryInfoOffset); - return pBuff; + code = setResultRowInitCtx(*pResult, pExprSup->pCtx, pExprSup->numOfExprs, pExprSup->rowEntryInfoOffset); + (*ppResBuff) = pBuff; + return code; } static int32_t updateCountWindowInfo(int32_t start, int32_t blockRows, int32_t countWinRows, int32_t* pCurrentRows) { @@ -88,20 +91,26 @@ static int32_t updateCountWindowInfo(int32_t start, int32_t blockRows, int32_t c return rows; } -int32_t doCountWindowAggImpl(SOperatorInfo* pOperator, SSDataBlock* pBlock) { +void doCountWindowAggImpl(SOperatorInfo* pOperator, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SExprSupp* pExprSup = &pOperator->exprSupp; SCountWindowOperatorInfo* pInfo = pOperator->info; SSDataBlock* pRes = pInfo->binfo.pRes; SColumnInfoData* pColInfoData = taosArrayGet(pBlock->pDataBlock, pInfo->tsSlotId); TSKEY* tsCols = (TSKEY*)pColInfoData->pData; - int32_t code = TSDB_CODE_SUCCESS; for (int32_t i = 0; i < pBlock->info.rows;) { - SCountWindowResult* pBuffInfo = setCountWindowOutputBuff(pExprSup, &pInfo->countSup, &pInfo->pRow); - int32_t prevRows = pBuffInfo->winRows; - int32_t num = updateCountWindowInfo(i, pBlock->info.rows, pInfo->windowCount, &pBuffInfo->winRows); - int32_t step = num; + SCountWindowResult* pBuffInfo = NULL; + code = setCountWindowOutputBuff(pExprSup, &pInfo->countSup, &pInfo->pRow, &pBuffInfo); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } + int32_t prevRows = pBuffInfo->winRows; + int32_t num = updateCountWindowInfo(i, pBlock->info.rows, pInfo->windowCount, &pBuffInfo->winRows); + int32_t step = num; if (prevRows == 0) { pInfo->pRow->win.skey = tsCols[i]; } @@ -131,15 +140,17 @@ int32_t doCountWindowAggImpl(SOperatorInfo* pOperator, SSDataBlock* pBlock) { } i += step; } - - return code; } static void buildCountResult(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, SExecTaskInfo* pTaskInfo, SFilterInfo* pFilterInfo, SSDataBlock* pBlock) { SResultRow* pResultRow = NULL; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; for (int32_t i = 0; i < taosArrayGetSize(pCountSup->pWinStates); i++) { - SCountWindowResult* pBuff = setCountWindowOutputBuff(pExprSup, pCountSup, &pResultRow); + SCountWindowResult* pBuff = NULL; + code = setCountWindowOutputBuff(pExprSup, pCountSup, &pResultRow, &pBuff); + QUERY_CHECK_CODE(code, lino, _end); if (pBuff->winRows == 0) { continue; } @@ -150,7 +161,14 @@ static void buildCountResult(SExprSupp* pExprSup, SCountWindowSupp* pCountSup, S clearWinStateBuff(pBuff); clearResultRowInitFlag(pExprSup->pCtx, pExprSup->numOfExprs); } - doFilter(pBlock, pFilterInfo, NULL); + code = doFilter(pBlock, pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } static SSDataBlock* countWindowAggregate(SOperatorInfo* pOperator) { @@ -243,7 +261,8 @@ SOperatorInfo* createCountwindowOperatorInfo(SOperatorInfo* downstream, SPhysiNo QUERY_CHECK_CODE(code, lino, _error); SSDataBlock* pResBlock = createDataBlockFromDescNode(pCountWindowNode->window.node.pOutputDataBlockDesc); - blockDataEnsureCapacity(pResBlock, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pResBlock, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _error); initBasicInfo(&pInfo->binfo, pResBlock); initResultRowInfo(&pInfo->binfo.resultRowInfo); diff --git a/source/libs/executor/src/eventwindowoperator.c b/source/libs/executor/src/eventwindowoperator.c index f15b05f817..75153e3a08 100644 --- a/source/libs/executor/src/eventwindowoperator.c +++ b/source/libs/executor/src/eventwindowoperator.c @@ -204,8 +204,12 @@ static SSDataBlock* eventWindowAggregate(SOperatorInfo* pOperator) { } } - eventWindowAggImpl(pOperator, pInfo, pBlock); - doFilter(pRes, pSup->pFilterInfo, NULL); + code = eventWindowAggImpl(pOperator, pInfo, pBlock); + QUERY_CHECK_CODE(code, lino, _end); + + code = doFilter(pRes, pSup->pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); + if (pRes->info.rows >= pOperator->resultInfo.threshold) { return pRes; } @@ -253,6 +257,8 @@ static void doEventWindowAggImpl(SEventWindowOperatorInfo* pInfo, SExprSupp* pSu } int32_t eventWindowAggImpl(SOperatorInfo* pOperator, SEventWindowOperatorInfo* pInfo, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SExprSupp* pSup = &pOperator->exprSupp; SSDataBlock* pRes = pInfo->binfo.pRes; @@ -274,22 +280,20 @@ int32_t eventWindowAggImpl(SOperatorInfo* pOperator, SEventWindowOperatorInfo* p SFilterColumnParam param1 = {.numOfCols = taosArrayGetSize(pBlock->pDataBlock), .pDataBlock = pBlock->pDataBlock}; - int32_t code = filterSetDataFromSlotId(pInfo->pStartCondInfo, ¶m1); - if (code != TSDB_CODE_SUCCESS) { - return code; - } + code = filterSetDataFromSlotId(pInfo->pStartCondInfo, ¶m1); + QUERY_CHECK_CODE(code, lino, _return); int32_t status1 = 0; - filterExecute(pInfo->pStartCondInfo, pBlock, &ps, NULL, param1.numOfCols, &status1); + code = filterExecute(pInfo->pStartCondInfo, pBlock, &ps, NULL, param1.numOfCols, &status1); + QUERY_CHECK_CODE(code, lino, _return); SFilterColumnParam param2 = {.numOfCols = taosArrayGetSize(pBlock->pDataBlock), .pDataBlock = pBlock->pDataBlock}; code = filterSetDataFromSlotId(pInfo->pEndCondInfo, ¶m2); - if (code != TSDB_CODE_SUCCESS) { - goto _return; - } + QUERY_CHECK_CODE(code, lino, _return); int32_t status2 = 0; - filterExecute(pInfo->pEndCondInfo, pBlock, &pe, NULL, param2.numOfCols, &status2); + code = filterExecute(pInfo->pEndCondInfo, pBlock, &pe, NULL, param2.numOfCols, &status2); + QUERY_CHECK_CODE(code, lino, _return); int32_t startIndex = pInfo->inWindow ? 0 : -1; while (rowIndex < pBlock->info.rows) { @@ -307,7 +311,8 @@ int32_t eventWindowAggImpl(SOperatorInfo* pOperator, SEventWindowOperatorInfo* p // check buffer size if (pRes->info.rows + pInfo->pRow->numOfRows >= pRes->info.capacity) { int32_t newSize = pRes->info.rows + pInfo->pRow->numOfRows; - blockDataEnsureCapacity(pRes, newSize); + code = blockDataEnsureCapacity(pRes, newSize); + QUERY_CHECK_CODE(code, lino, _return); } copyResultrowToDataBlock(pSup->pExprInfo, pSup->numOfExprs, pInfo->pRow, pSup->pCtx, pRes, @@ -344,6 +349,9 @@ int32_t eventWindowAggImpl(SOperatorInfo* pOperator, SEventWindowOperatorInfo* p _return: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + } colDataDestroy(ps); taosMemoryFree(ps); colDataDestroy(pe); diff --git a/source/libs/executor/src/exchangeoperator.c b/source/libs/executor/src/exchangeoperator.c index a6a273cce8..87b5b3c4ec 100644 --- a/source/libs/executor/src/exchangeoperator.c +++ b/source/libs/executor/src/exchangeoperator.c @@ -45,10 +45,10 @@ typedef struct SSourceDataInfo { int32_t decompBufSize; } SSourceDataInfo; -static void destroyExchangeOperatorInfo(void* param); -static void freeBlock(void* pParam); -static void freeSourceDataInfo(void* param); -static void* setAllSourcesCompleted(SOperatorInfo* pOperator); +static void destroyExchangeOperatorInfo(void* param); +static void freeBlock(void* pParam); +static void freeSourceDataInfo(void* param); +static void setAllSourcesCompleted(SOperatorInfo* pOperator); static int32_t loadRemoteDataCallback(void* param, SDataBuf* pMsg, int32_t code); static int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTaskInfo, int32_t sourceIndex); @@ -171,6 +171,7 @@ _error: } static SSDataBlock* doLoadRemoteDataImpl(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; SExchangeInfo* pExchangeInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; @@ -192,11 +193,22 @@ static SSDataBlock* doLoadRemoteDataImpl(SOperatorInfo* pOperator) { } if (p != NULL) { - taosArrayPush(pExchangeInfo->pRecycledBlocks, &p); + void* tmp = taosArrayPush(pExchangeInfo->pRecycledBlocks, &p); + if (!tmp) { + code = TSDB_CODE_OUT_OF_MEMORY; + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return p; } else { if (pExchangeInfo->seqLoadData) { - seqLoadRemoteData(pOperator); + code = seqLoadRemoteData(pOperator); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } } else { concurrentlyLoadRemoteDataImpl(pOperator, pExchangeInfo, pTaskInfo); } @@ -206,7 +218,13 @@ static SSDataBlock* doLoadRemoteDataImpl(SOperatorInfo* pOperator) { } else { p = taosArrayGetP(pExchangeInfo->pResultBlockList, 0); taosArrayRemove(pExchangeInfo->pResultBlockList, 0); - taosArrayPush(pExchangeInfo->pRecycledBlocks, &p); + void* tmp = taosArrayPush(pExchangeInfo->pRecycledBlocks, &p); + if (!tmp) { + code = TSDB_CODE_OUT_OF_MEMORY; + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return p; } } @@ -231,7 +249,11 @@ static SSDataBlock* loadRemoteData(SOperatorInfo* pOperator) { return NULL; } - doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL); + pTaskInfo->code = doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL); + if (pTaskInfo->code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(pTaskInfo->code)); + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + } if (blockDataGetNumOfRows(pBlock) == 0) { continue; } @@ -293,21 +315,32 @@ static int32_t initExchangeOperator(SExchangePhysiNode* pExNode, SExchangeInfo* pInfo->pSources = taosArrayInit(numOfSources, sizeof(SDownstreamSourceNode)); if (pInfo->pSources == NULL) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); return TSDB_CODE_OUT_OF_MEMORY; } if (pExNode->node.dynamicOp) { pInfo->pHashSources = tSimpleHashInit(numOfSources * 2, taosGetDefaultHashFunction(TSDB_DATA_TYPE_INT)); if (NULL == pInfo->pHashSources) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); return TSDB_CODE_OUT_OF_MEMORY; } } for (int32_t i = 0; i < numOfSources; ++i) { SDownstreamSourceNode* pNode = (SDownstreamSourceNode*)nodesListGetNode((SNodeList*)pExNode->pSrcEndPoints, i); - taosArrayPush(pInfo->pSources, pNode); + void* tmp = taosArrayPush(pInfo->pSources, pNode); + if (!tmp) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); + return TSDB_CODE_OUT_OF_MEMORY; + } SExchangeSrcIndex idx = {.srcIdx = i, .inUseIdx = -1}; - tSimpleHashPut(pInfo->pHashSources, &pNode->addr.nodeId, sizeof(pNode->addr.nodeId), &idx, sizeof(idx)); + int32_t code = + tSimpleHashPut(pInfo->pHashSources, &pNode->addr.nodeId, sizeof(pNode->addr.nodeId), &idx, sizeof(idx)); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } } initLimitInfo(pExNode->node.pLimit, pExNode->node.pSlimit, &pInfo->limitInfo); @@ -317,6 +350,8 @@ static int32_t initExchangeOperator(SExchangePhysiNode* pExNode, SExchangeInfo* } SOperatorInfo* createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode* pExNode, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExchangeInfo* pInfo = taosMemoryCalloc(1, sizeof(SExchangeInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -324,18 +359,19 @@ SOperatorInfo* createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode } pInfo->dynamicOp = pExNode->node.dynamicOp; - int32_t code = initExchangeOperator(pExNode, pInfo, GET_TASKID(pTaskInfo)); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + code = initExchangeOperator(pExNode, pInfo, GET_TASKID(pTaskInfo)); + QUERY_CHECK_CODE(code, lino, _error); + + code = tsem_init(&pInfo->ready, 0, 0); + QUERY_CHECK_CODE(code, lino, _error); - tsem_init(&pInfo->ready, 0, 0); pInfo->pDummyBlock = createDataBlockFromDescNode(pExNode->node.pOutputDataBlockDesc); pInfo->pResultBlockList = taosArrayInit(64, POINTER_BYTES); pInfo->pRecycledBlocks = taosArrayInit(64, POINTER_BYTES); SExchangeOpStopInfo stopInfo = {QUERY_NODE_PHYSICAL_PLAN_EXCHANGE, pInfo->self}; - qAppendTaskStopInfo(pTaskInfo, &stopInfo); + code = qAppendTaskStopInfo(pTaskInfo, &stopInfo); + QUERY_CHECK_CODE(code, lino, _error); pInfo->seqLoadData = pExNode->seqRecvData; pInfo->pTransporter = pTransporter; @@ -345,15 +381,17 @@ SOperatorInfo* createExchangeOperatorInfo(void* pTransporter, SExchangePhysiNode pOperator->exprSupp.numOfExprs = taosArrayGetSize(pInfo->pDummyBlock->pDataBlock); code = filterInitFromNode((SNode*)pExNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); pOperator->fpSet = createOperatorFpSet(prepareLoadRemoteData, loadRemoteData, NULL, destroyExchangeOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); return pOperator; _error: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + } if (pInfo != NULL) { doDestroyExchangeOperatorInfo(pInfo); } @@ -365,7 +403,7 @@ _error: void destroyExchangeOperatorInfo(void* param) { SExchangeInfo* pExInfo = (SExchangeInfo*)param; - taosRemoveRef(exchangeObjRefPool, pExInfo->self); + (void)taosRemoveRef(exchangeObjRefPool, pExInfo->self); } void freeBlock(void* pParam) { @@ -393,7 +431,7 @@ void doDestroyExchangeOperatorInfo(void* param) { blockDataDestroy(pExInfo->pDummyBlock); tSimpleHashCleanup(pExInfo->pHashSources); - tsem_destroy(&pExInfo->ready); + (void)tsem_destroy(&pExInfo->ready); taosMemoryFreeClear(pExInfo->pTaskId); taosMemoryFreeClear(param); @@ -445,7 +483,7 @@ int32_t loadRemoteDataCallback(void* param, SDataBuf* pMsg, int32_t code) { qError("failed to invoke post when fetch rsp is ready, code:%s, %p", tstrerror(code), pExchangeInfo); } - taosReleaseRef(exchangeObjRefPool, pWrapper->exchangeId); + (void)taosReleaseRef(exchangeObjRefPool, pWrapper->exchangeId); return code; } @@ -478,6 +516,8 @@ int32_t buildTableScanOperatorParam(SOperatorParam** ppRes, SArray* pUidList, in } int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTaskInfo, int32_t sourceIndex) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SSourceDataInfo* pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, sourceIndex); if (EX_SOURCE_DATA_NOT_READY != pDataInfo->status) { return TSDB_CODE_SUCCESS; @@ -489,6 +529,7 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas size_t totalSources = taosArrayGetSize(pExchangeInfo->pSources); SFetchRspHandleWrapper* pWrapper = taosMemoryCalloc(1, sizeof(SFetchRspHandleWrapper)); + QUERY_CHECK_NULL(pWrapper, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); pWrapper->exchangeId = pExchangeInfo->self; pWrapper->sourceIndex = sourceIndex; @@ -497,7 +538,8 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas int32_t code = (*pTaskInfo->localFetch.fp)(pTaskInfo->localFetch.handle, pSource->schedId, pTaskInfo->id.queryId, pSource->taskId, 0, pSource->execId, &pBuf.pData, pTaskInfo->localFetch.explainRes); - loadRemoteDataCallback(pWrapper, &pBuf, code); + code = loadRemoteDataCallback(pWrapper, &pBuf, code); + QUERY_CHECK_CODE(code, lino, _end); taosMemoryFree(pWrapper); } else { SResFetchReq req = {0}; @@ -566,11 +608,15 @@ int32_t doSendFetchDataRequest(SExchangeInfo* pExchangeInfo, SExecTaskInfo* pTas pMsgSendInfo->fp = loadRemoteDataCallback; int64_t transporterId = 0; - int32_t code = - asyncSendMsgToServer(pExchangeInfo->pTransporter, &pSource->addr.epSet, &transporterId, pMsgSendInfo); + code = asyncSendMsgToServer(pExchangeInfo->pTransporter, &pSource->addr.epSet, &transporterId, pMsgSendInfo); + QUERY_CHECK_CODE(code, lino, _end); } - return TSDB_CODE_SUCCESS; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } void updateLoadRemoteInfo(SLoadRemoteDataInfo* pInfo, int64_t numOfRows, int32_t dataLen, int64_t startTs, @@ -582,6 +628,8 @@ void updateLoadRemoteInfo(SLoadRemoteDataInfo* pInfo, int64_t numOfRows, int32_t } int32_t extractDataBlockFromFetchRsp(SSDataBlock* pRes, char* pData, SArray* pColList, char** pNextStart) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pColList == NULL) { // data from other sources blockDataCleanup(pRes); *pNextStart = (char*)blockDecode(pRes, pData); @@ -604,24 +652,32 @@ int32_t extractDataBlockFromFetchRsp(SSDataBlock* pRes, char* pData, SArray* pCo SSDataBlock* pBlock = createDataBlock(); for (int32_t i = 0; i < numOfCols; ++i) { SColumnInfoData idata = createColumnInfoData(pSchema[i].type, pSchema[i].bytes, pSchema[i].colId); - blockDataAppendColInfo(pBlock, &idata); + code = blockDataAppendColInfo(pBlock, &idata); + QUERY_CHECK_CODE(code, lino, _end); } - (void) blockDecode(pBlock, pStart); - blockDataEnsureCapacity(pRes, pBlock->info.rows); + (void)blockDecode(pBlock, pStart); + code = blockDataEnsureCapacity(pRes, pBlock->info.rows); + QUERY_CHECK_CODE(code, lino, _end); // data from mnode pRes->info.dataLoad = 1; pRes->info.rows = pBlock->info.rows; pRes->info.scanFlag = MAIN_SCAN; - relocateColumnData(pRes, pColList, pBlock->pDataBlock, false); + code = relocateColumnData(pRes, pColList, pBlock->pDataBlock, false); + QUERY_CHECK_CODE(code, lino, _end); + blockDataDestroy(pBlock); } - return TSDB_CODE_SUCCESS; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } -void* setAllSourcesCompleted(SOperatorInfo* pOperator) { +void setAllSourcesCompleted(SOperatorInfo* pOperator) { SExchangeInfo* pExchangeInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; @@ -632,7 +688,6 @@ void* setAllSourcesCompleted(SOperatorInfo* pOperator) { pLoadInfo->totalElapsed / 1000.0); setOperatorCompleted(pOperator); - return NULL; } int32_t getCompletedSources(const SArray* pArray) { @@ -679,21 +734,24 @@ int32_t prepareConcurrentlyLoad(SOperatorInfo* pOperator) { } int32_t doExtractResultBlocks(SExchangeInfo* pExchangeInfo, SSourceDataInfo* pDataInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SRetrieveTableRsp* pRetrieveRsp = pDataInfo->pRsp; - char* pNextStart = pRetrieveRsp->data; - char* pStart = pNextStart; + char* pNextStart = pRetrieveRsp->data; + char* pStart = pNextStart; int32_t index = 0; - int32_t code = 0; if (pRetrieveRsp->compressed) { // decompress the data if (pDataInfo->decompBuf == NULL) { pDataInfo->decompBuf = taosMemoryMalloc(pRetrieveRsp->payloadLen); + QUERY_CHECK_NULL(pDataInfo->decompBuf, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); pDataInfo->decompBufSize = pRetrieveRsp->payloadLen; } else { if (pDataInfo->decompBufSize < pRetrieveRsp->payloadLen) { char* p = taosMemoryRealloc(pDataInfo->decompBuf, pRetrieveRsp->payloadLen); + QUERY_CHECK_NULL(p, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); if (p != NULL) { pDataInfo->decompBuf = p; pDataInfo->decompBufSize = pRetrieveRsp->payloadLen; @@ -702,7 +760,6 @@ int32_t doExtractResultBlocks(SExchangeInfo* pExchangeInfo, SSourceDataInfo* pDa } } - while (index++ < pRetrieveRsp->numOfBlocks) { SSDataBlock* pb = NULL; pStart = pNextStart; @@ -712,12 +769,13 @@ int32_t doExtractResultBlocks(SExchangeInfo* pExchangeInfo, SSourceDataInfo* pDa blockDataCleanup(pb); } else { pb = createOneDataBlock(pExchangeInfo->pDummyBlock, false); + QUERY_CHECK_NULL(pb, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } - int32_t compLen = *(int32_t*) pStart; + int32_t compLen = *(int32_t*)pStart; pStart += sizeof(int32_t); - int32_t rawLen = *(int32_t*) pStart; + int32_t rawLen = *(int32_t*)pStart; pStart += sizeof(int32_t); ASSERT(compLen <= rawLen && compLen != 0); @@ -734,9 +792,14 @@ int32_t doExtractResultBlocks(SExchangeInfo* pExchangeInfo, SSourceDataInfo* pDa return code; } - taosArrayPush(pExchangeInfo->pResultBlockList, &pb); + void* tmp = taosArrayPush(pExchangeInfo->pResultBlockList, &pb); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } return code; } @@ -757,7 +820,13 @@ int32_t seqLoadRemoteData(SOperatorInfo* pOperator) { SSourceDataInfo* pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, pExchangeInfo->current); pDataInfo->status = EX_SOURCE_DATA_NOT_READY; - doSendFetchDataRequest(pExchangeInfo, pTaskInfo, pExchangeInfo->current); + code = doSendFetchDataRequest(pExchangeInfo, pTaskInfo, pExchangeInfo->current); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + } + code = exchangeWait(pOperator, pExchangeInfo); if (code != TSDB_CODE_SUCCESS || isTaskKilled(pTaskInfo)) { T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); @@ -838,7 +907,11 @@ int32_t addSingleExchangeSource(SOperatorInfo* pOperator, SExchangeOperatorBasic dataInfo.srcOpType = pBasicParam->srcOpType; dataInfo.tableSeq = pBasicParam->tableSeq; - taosArrayPush(pExchangeInfo->pSourceDataInfo, &dataInfo); + void* tmp = taosArrayPush(pExchangeInfo->pSourceDataInfo, &dataInfo); + if (!tmp) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); + return TSDB_CODE_OUT_OF_MEMORY; + } pIdx->inUseIdx = taosArrayGetSize(pExchangeInfo->pSourceDataInfo) - 1; } else { SSourceDataInfo* pDataInfo = taosArrayGet(pExchangeInfo->pSourceDataInfo, pIdx->inUseIdx); @@ -984,7 +1057,7 @@ static int32_t exchangeWait(SOperatorInfo* pOperator, SExchangeInfo* pExchangeIn return pTask->code; } } - tsem_wait(&pExchangeInfo->ready); + (void)tsem_wait(&pExchangeInfo->ready); if (pTask->pWorkerCb) { code = pTask->pWorkerCb->afterRecoverFromBlocking(pTask->pWorkerCb->pPool); if (code != TSDB_CODE_SUCCESS) { diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c index 698ace3e4e..2c1d3983cd 100644 --- a/source/libs/executor/src/executil.c +++ b/source/libs/executor/src/executil.c @@ -143,7 +143,7 @@ void initGroupedResultInfo(SGroupResInfo* pGroupResInfo, SSHashObj* pHashmap, in // todo move away and record this during create window while ((pData = tSimpleHashIterate(pHashmap, pData, &iter)) != NULL) { - /*void* key = */ tSimpleHashGetKey(pData, &keyLen); + /*void* key = */ (void)tSimpleHashGetKey(pData, &keyLen); bufLen += keyLen + sizeof(SResultRowPosition); } @@ -222,7 +222,13 @@ SArray* createSortInfo(SNodeList* pNodeList) { SColumnNode* pColNode = (SColumnNode*)pSortKey->pExpr; bi.slotId = pColNode->slotId; - taosArrayPush(pList, &bi); + void* tmp = taosArrayPush(pList, &bi); + if (!tmp) { + taosArrayDestroy(pList); + pList = NULL; + terrno = TSDB_CODE_OUT_OF_MEMORY; + break; + } } return pList; @@ -245,7 +251,14 @@ SSDataBlock* createDataBlockFromDescNode(SDataBlockDescNode* pNode) { idata.info.scale = pDescNode->dataType.scale; idata.info.precision = pDescNode->dataType.precision; - blockDataAppendColInfo(pBlock, &idata); + int32_t code = blockDataAppendColInfo(pBlock, &idata); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + blockDataDestroy(pBlock); + pBlock = NULL; + terrno = code; + break; + } } return pBlock; @@ -288,7 +301,7 @@ int32_t prepareDataBlockBuf(SSDataBlock* pDataBlock, SColMatchInfo* pMatchInfo) EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) { SMetaReader* mr = (SMetaReader*)pContext; - bool isTagCol = false, isTbname = false; + bool isTagCol = false, isTbname = false; if (nodeType(*pNode) == QUERY_NODE_COLUMN) { SColumnNode* pCol = (SColumnNode*)*pNode; if (pCol->colType == COLUMN_TYPE_TBNAME) @@ -297,8 +310,7 @@ EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) { isTagCol = true; } else if (nodeType(*pNode) == QUERY_NODE_FUNCTION) { SFunctionNode* pFunc = (SFunctionNode*)*pNode; - if (pFunc->funcType == FUNCTION_TYPE_TBNAME) - isTbname = true; + if (pFunc->funcType == FUNCTION_TYPE_TBNAME) isTbname = true; } if (isTagCol) { SColumnNode* pSColumnNode = *(SColumnNode**)pNode; @@ -325,7 +337,10 @@ EDealRes doTranslateTagExpr(SNode** pNode, void* pContext) { memcpy(varDataVal(res->datum.p), tagVal.pData, tagVal.nData); varDataSetLen(res->datum.p, tagVal.nData); } else { - nodesSetValueNodeValue(res, &(tagVal.i64)); + int32_t code = nodesSetValueNodeValue(res, &(tagVal.i64)); + if (code != TSDB_CODE_SUCCESS) { + return DEAL_RES_ERROR; + } } nodesDestroyNode(*pNode); *pNode = (SNode*)res; @@ -411,7 +426,11 @@ static EDealRes getColumn(SNode** pNode, void* pContext) { tagFilterAssist* pData = (tagFilterAssist*)pContext; void* data = taosHashGet(pData->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId)); if (!data) { - taosHashPut(pData->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode))); + int32_t code = + taosHashPut(pData->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode))); + if (code != TSDB_CODE_SUCCESS) { + return DEAL_RES_ERROR; + } pSColumnNode->slotId = pData->index++; SColumnInfo cInfo = {.colId = pSColumnNode->colId, .type = pSColumnNode->node.resType.type, @@ -420,7 +439,10 @@ static EDealRes getColumn(SNode** pNode, void* pContext) { #if TAG_FILTER_DEBUG qDebug("tagfilter build column info, slotId:%d, colId:%d, type:%d", pSColumnNode->slotId, cInfo.colId, cInfo.type); #endif - taosArrayPush(pData->cInfoList, &cInfo); + void* tmp = taosArrayPush(pData->cInfoList, &cInfo); + if(!tmp) { + return DEAL_RES_ERROR; + } } else { SColumnNode* col = *(SColumnNode**)data; pSColumnNode->slotId = col->slotId; @@ -468,28 +490,38 @@ void freeItem(void* p) { } } -static void genTagFilterDigest(const SNode* pTagCond, T_MD5_CTX* pContext) { +static int32_t genTagFilterDigest(const SNode* pTagCond, T_MD5_CTX* pContext) { if (pTagCond == NULL) { - return; + return TSDB_CODE_SUCCESS; } char* payload = NULL; int32_t len = 0; - nodesNodeToMsg(pTagCond, &payload, &len); + int32_t code = nodesNodeToMsg(pTagCond, &payload, &len); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } tMD5Init(pContext); tMD5Update(pContext, (uint8_t*)payload, (uint32_t)len); tMD5Final(pContext); taosMemoryFree(payload); + return TSDB_CODE_SUCCESS; } -static void genTbGroupDigest(const SNode* pGroup, uint8_t* filterDigest, T_MD5_CTX* pContext) { +static int32_t genTbGroupDigest(const SNode* pGroup, uint8_t* filterDigest, T_MD5_CTX* pContext) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; char* payload = NULL; int32_t len = 0; - nodesNodeToMsg(pGroup, &payload, &len); + code = nodesNodeToMsg(pGroup, &payload, &len); + QUERY_CHECK_CODE(code, lino, _end); + if (filterDigest[0]) { payload = taosMemoryRealloc(payload, len + tListLen(pContext->digest)); + QUERY_CHECK_NULL(payload, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); memcpy(payload + len, filterDigest + 1, tListLen(pContext->digest)); len += tListLen(pContext->digest); } @@ -498,12 +530,18 @@ static void genTbGroupDigest(const SNode* pGroup, uint8_t* filterDigest, T_MD5_C tMD5Update(pContext, (uint8_t*)payload, (uint32_t)len); tMD5Final(pContext); +_end: taosMemoryFree(payload); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInfo* pTableListInfo, uint8_t* digest, SStorageAPI* pAPI, bool initRemainGroups) { int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SArray* pBlockList = NULL; SSDataBlock* pResBlock = NULL; void* keyBuf = NULL; @@ -540,11 +578,15 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf if (tsTagFilterCache) { SNodeListNode* listNode = (SNodeListNode*)nodesMakeNode(QUERY_NODE_NODE_LIST); listNode->pNodeList = group; - genTbGroupDigest((SNode*)listNode, digest, &context); + code = genTbGroupDigest((SNode*)listNode, digest, &context); + QUERY_CHECK_CODE(code, lino, end); + nodesFree(listNode); - pAPI->metaFn.metaGetCachedTbGroup(pVnode, pTableListInfo->idInfo.suid, context.digest, tListLen(context.digest), - &tableList); + code = pAPI->metaFn.metaGetCachedTbGroup(pVnode, pTableListInfo->idInfo.suid, context.digest, + tListLen(context.digest), &tableList); + QUERY_CHECK_CODE(code, lino, end); + if (tableList) { taosArrayDestroy(pTableListInfo->pTableList); pTableListInfo->pTableList = tableList; @@ -555,10 +597,13 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf } pUidTagList = taosArrayInit(8, sizeof(STUidTagInfo)); + QUERY_CHECK_NULL(pUidTagList, code, lino, end, TSDB_CODE_OUT_OF_MEMORY); + for (int32_t i = 0; i < rows; ++i) { STableKeyInfo* pkeyInfo = taosArrayGet(pTableListInfo->pTableList, i); STUidTagInfo info = {.uid = pkeyInfo->uid}; - taosArrayPush(pUidTagList, &info); + void* tmp = taosArrayPush(pUidTagList, &info); + QUERY_CHECK_NULL(tmp, code, lino, end, TSDB_CODE_OUT_OF_MEMORY); } code = pAPI->metaFn.getTableTags(pVnode, pTableListInfo->idInfo.suid, pUidTagList); @@ -577,9 +622,14 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf // qDebug("generate tag block rows:%d, cost:%ld us", rows, st1-st); pBlockList = taosArrayInit(2, POINTER_BYTES); - taosArrayPush(pBlockList, &pResBlock); + QUERY_CHECK_NULL(pBlockList, code, lino, end, TSDB_CODE_OUT_OF_MEMORY); + + void* tmp = taosArrayPush(pBlockList, &pResBlock); + QUERY_CHECK_NULL(tmp, code, lino, end, TSDB_CODE_OUT_OF_MEMORY); groupData = taosArrayInit(2, POINTER_BYTES); + QUERY_CHECK_NULL(groupData, code, lino, end, TSDB_CODE_OUT_OF_MEMORY); + FOREACH(pNode, group) { SScalarParam output = {0}; @@ -617,7 +667,8 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf goto end; } - taosArrayPush(groupData, &output.columnData); + void* tmp = taosArrayPush(groupData, &output.columnData); + QUERY_CHECK_NULL(tmp, code, lino, end, TSDB_CODE_OUT_OF_MEMORY); } int32_t keyLen = 0; @@ -688,15 +739,18 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf info->groupId = calcGroupId(keyBuf, len); if (initRemainGroups) { // groupId ~ table uid - taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId), &(info->uid), - sizeof(info->uid)); + code = taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId), &(info->uid), + sizeof(info->uid)); + QUERY_CHECK_CODE(code, lino, end); } } if (tsTagFilterCache) { tableList = taosArrayDup(pTableListInfo->pTableList, NULL); - pAPI->metaFn.metaPutTbGroupToCache(pVnode, pTableListInfo->idInfo.suid, context.digest, tListLen(context.digest), - tableList, taosArrayGetSize(tableList) * sizeof(STableKeyInfo)); + code = pAPI->metaFn.metaPutTbGroupToCache(pVnode, pTableListInfo->idInfo.suid, context.digest, + tListLen(context.digest), tableList, + taosArrayGetSize(tableList) * sizeof(STableKeyInfo)); + QUERY_CHECK_CODE(code, lino, end); } // int64_t st2 = taosGetTimestampUs(); @@ -726,10 +780,14 @@ static int32_t nameComparFn(const void* p1, const void* p2) { } static SArray* getTableNameList(const SNodeListNode* pList) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; int32_t len = LIST_LENGTH(pList->pNodeList); SListCell* cell = pList->pNodeList->pHead; SArray* pTbList = taosArrayInit(len, POINTER_BYTES); + QUERY_CHECK_NULL(pTbList, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + for (int i = 0; i < pList->pNodeList->length; i++) { SValueNode* valueNode = (SValueNode*)cell->pNode; if (!IS_VAR_DATA_TYPE(valueNode->node.resType.type)) { @@ -739,7 +797,8 @@ static SArray* getTableNameList(const SNodeListNode* pList) { } char* name = varDataVal(valueNode->datum.p); - taosArrayPush(pTbList, &name); + void* tmp = taosArrayPush(pTbList, &name); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); cell = cell->pNext; } @@ -750,7 +809,8 @@ static SArray* getTableNameList(const SNodeListNode* pList) { // remove the duplicates SArray* pNewList = taosArrayInit(taosArrayGetSize(pTbList), sizeof(void*)); - taosArrayPush(pNewList, taosArrayGet(pTbList, 0)); + void* tmp = taosArrayPush(pNewList, taosArrayGet(pTbList, 0)); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); for (int32_t i = 1; i < numOfTables; ++i) { char** name = taosArrayGetLast(pNewList); @@ -759,10 +819,16 @@ static SArray* getTableNameList(const SNodeListNode* pList) { continue; } - taosArrayPush(pNewList, nameInOldList); + tmp = taosArrayPush(pNewList, nameInOldList); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } +_end: taosArrayDestroy(pTbList); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + return NULL; + } return pNewList; } @@ -868,9 +934,18 @@ static int32_t optimizeTbnameInCondImpl(void* pVnode, SArray* pExistedUidList, S size_t numOfExisted = taosArrayGetSize(pExistedUidList); // len > 0 means there already have uids if (numOfExisted > 0) { uHash = taosHashInit(numOfExisted / 0.7, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK); + if (!uHash) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); + return TSDB_CODE_OUT_OF_MEMORY; + } + for (int i = 0; i < numOfExisted; i++) { STUidTagInfo* pTInfo = taosArrayGet(pExistedUidList, i); - taosHashPut(uHash, &pTInfo->uid, sizeof(uint64_t), &i, sizeof(i)); + int32_t code = taosHashPut(uHash, &pTInfo->uid, sizeof(uint64_t), &i, sizeof(i)); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } } } @@ -883,7 +958,10 @@ static int32_t optimizeTbnameInCondImpl(void* pVnode, SArray* pExistedUidList, S if (pStoreAPI->metaFn.getTableTypeByName(pVnode, name, &tbType) == 0 && tbType == TSDB_CHILD_TABLE) { if (NULL == uHash || taosHashGet(uHash, &uid, sizeof(uid)) == NULL) { STUidTagInfo s = {.uid = uid, .name = name, .pTagVal = NULL}; - taosArrayPush(pExistedUidList, &s); + void* tmp = taosArrayPush(pExistedUidList, &s); + if (!tmp) { + return TSDB_CODE_OUT_OF_MEMORY; + } } } else { taosArrayDestroy(pTbList); @@ -906,6 +984,8 @@ static int32_t optimizeTbnameInCondImpl(void* pVnode, SArray* pExistedUidList, S SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, SArray* pUidTagList, void* pVnode, SStorageAPI* pStorageAPI) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SSDataBlock* pResBlock = createDataBlock(); if (pResBlock == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; @@ -915,10 +995,11 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S for (int32_t i = 0; i < taosArrayGetSize(pColList); ++i) { SColumnInfoData colInfo = {0}; colInfo.info = *(SColumnInfo*)taosArrayGet(pColList, i); - blockDataAppendColInfo(pResBlock, &colInfo); + code = blockDataAppendColInfo(pResBlock, &colInfo); + QUERY_CHECK_CODE(code, lino, _end); } - int32_t code = blockDataEnsureCapacity(pResBlock, numOfTables); + code = blockDataEnsureCapacity(pResBlock, numOfTables); if (code != TSDB_CODE_SUCCESS) { terrno = code; taosMemoryFree(pResBlock); @@ -940,10 +1021,12 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S if (p1->name != NULL) { STR_TO_VARSTR(str, p1->name); } else { // name is not retrieved during filter - pStorageAPI->metaFn.getTableNameByUid(pVnode, p1->uid, str); + code = pStorageAPI->metaFn.getTableNameByUid(pVnode, p1->uid, str); + QUERY_CHECK_CODE(code, lino, _end); } - colDataSetVal(pColInfo, i, str, false); + code = colDataSetVal(pColInfo, i, str, false); + QUERY_CHECK_CODE(code, lino, _end); #if TAG_FILTER_DEBUG qDebug("tagfilter uid:%ld, tbname:%s", *uid, str + 2); #endif @@ -958,18 +1041,22 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S if (p == NULL || (pColInfo->info.type == TSDB_DATA_TYPE_JSON && ((STag*)p)->nTag == 0)) { colDataSetNULL(pColInfo, i); } else if (pColInfo->info.type == TSDB_DATA_TYPE_JSON) { - colDataSetVal(pColInfo, i, p, false); + code = colDataSetVal(pColInfo, i, p, false); + QUERY_CHECK_CODE(code, lino, _end); } else if (IS_VAR_DATA_TYPE(pColInfo->info.type)) { char* tmp = taosMemoryMalloc(tagVal.nData + VARSTR_HEADER_SIZE + 1); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); varDataSetLen(tmp, tagVal.nData); memcpy(tmp + VARSTR_HEADER_SIZE, tagVal.pData, tagVal.nData); - colDataSetVal(pColInfo, i, tmp, false); + code = colDataSetVal(pColInfo, i, tmp, false); + QUERY_CHECK_CODE(code, lino, _end); #if TAG_FILTER_DEBUG qDebug("tagfilter varch:%s", tmp + 2); #endif taosMemoryFree(tmp); } else { - colDataSetVal(pColInfo, i, (const char*)&tagVal.i64, false); + code = colDataSetVal(pColInfo, i, (const char*)&tagVal.i64, false); + QUERY_CHECK_CODE(code, lino, _end); #if TAG_FILTER_DEBUG if (pColInfo->info.type == TSDB_DATA_TYPE_INT) { qDebug("tagfilter int:%d", *(int*)(&tagVal.i64)); @@ -983,6 +1070,12 @@ SSDataBlock* createTagValBlockForFilter(SArray* pColList, int32_t numOfTables, S } } +_end: + if (code != TSDB_CODE_SUCCESS) { + taosMemoryFree(pResBlock); + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + return NULL; + } return pResBlock; } @@ -1004,7 +1097,10 @@ static int32_t doSetQualifiedUid(STableListInfo* pListInfo, SArray* pUidList, co } if (addUid) { - taosArrayPush(pUidList, &uid); + void* tmp = taosArrayPush(pUidList, &uid); + if (tmp == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } } } } @@ -1012,17 +1108,23 @@ static int32_t doSetQualifiedUid(STableListInfo* pListInfo, SArray* pUidList, co return TSDB_CODE_SUCCESS; } -static void copyExistedUids(SArray* pUidTagList, const SArray* pUidList) { +static int32_t copyExistedUids(SArray* pUidTagList, const SArray* pUidList) { + int32_t code = TSDB_CODE_SUCCESS; int32_t numOfExisted = taosArrayGetSize(pUidList); if (numOfExisted == 0) { - return; + return code; } for (int32_t i = 0; i < numOfExisted; ++i) { uint64_t* uid = taosArrayGet(pUidList, i); STUidTagInfo info = {.uid = *uid}; - taosArrayPush(pUidTagList, &info); + void* tmp = taosArrayPush(pUidTagList, &info); + if (!tmp) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); + return code; + } } + return code; } static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SNode* pTagCond, void* pVnode, @@ -1034,6 +1136,7 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN terrno = TSDB_CODE_SUCCESS; + int32_t lino = 0; int32_t code = TSDB_CODE_SUCCESS; SArray* pBlockList = NULL; SSDataBlock* pResBlock = NULL; @@ -1059,7 +1162,10 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN // int64_t stt = taosGetTimestampUs(); pUidTagList = taosArrayInit(10, sizeof(STUidTagInfo)); - copyExistedUids(pUidTagList, pUidList); + QUERY_CHECK_NULL(pUidTagList, code, lino, end, TSDB_CODE_OUT_OF_MEMORY); + + code = copyExistedUids(pUidTagList, pUidList); + QUERY_CHECK_CODE(code, lino, end); FilterCondType condType = checkTagCond(pTagCond); @@ -1068,10 +1174,13 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN taosArrayClear(pUidList); int32_t numOfRows = taosArrayGetSize(pUidTagList); - taosArrayEnsureCap(pUidList, numOfRows); + code = taosArrayEnsureCap(pUidList, numOfRows); + QUERY_CHECK_CODE(code, lino, end); + for (int32_t i = 0; i < numOfRows; ++i) { STUidTagInfo* pInfo = taosArrayGet(pUidTagList, i); - taosArrayPush(pUidList, &pInfo->uid); + void* tmp = taosArrayPush(pUidList, &pInfo->uid); + QUERY_CHECK_NULL(tmp, code, lino, end, TSDB_CODE_OUT_OF_MEMORY); } terrno = 0; } else { @@ -1101,7 +1210,10 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN // int64_t st1 = taosGetTimestampUs(); // qDebug("generate tag block rows:%d, cost:%ld us", rows, st1-st); pBlockList = taosArrayInit(2, POINTER_BYTES); - taosArrayPush(pBlockList, &pResBlock); + QUERY_CHECK_NULL(pBlockList, code, lino, end, TSDB_CODE_OUT_OF_MEMORY); + + void* tmp = taosArrayPush(pBlockList, &pResBlock); + QUERY_CHECK_NULL(tmp, code, lino, end, TSDB_CODE_OUT_OF_MEMORY); code = createResultData(&type, numOfTables, &output); if (code != TSDB_CODE_SUCCESS) { @@ -1124,6 +1236,9 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN *listAdded = true; end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } taosHashCleanup(ctx.colHash); taosArrayDestroy(ctx.cInfoList); blockDataDestroy(pResBlock); @@ -1138,6 +1253,7 @@ end: int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, SNode* pTagIndexCond, STableListInfo* pListInfo, uint8_t* digest, const char* idstr, SStorageAPI* pStorageAPI) { int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; size_t numOfTables = 0; bool listAdded = false; @@ -1145,12 +1261,14 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S pListInfo->idInfo.tableType = pScanNode->tableType; SArray* pUidList = taosArrayInit(8, sizeof(uint64_t)); + QUERY_CHECK_NULL(pUidList, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); SIdxFltStatus status = SFLT_NOT_INDEX; if (pScanNode->tableType != TSDB_SUPER_TABLE) { pListInfo->idInfo.uid = pScanNode->uid; if (pStorageAPI->metaFn.isTableExisted(pVnode, pScanNode->uid)) { - taosArrayPush(pUidList, &pScanNode->uid); + void* tmp = taosArrayPush(pUidList, &pScanNode->uid); + QUERY_CHECK_NULL(tmp, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); } code = doFilterByTagCond(pListInfo, pUidList, pTagCond, pVnode, status, pStorageAPI, false, &listAdded); if (code != TSDB_CODE_SUCCESS) { @@ -1161,11 +1279,14 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S if (tsTagFilterCache) { // try to retrieve the result from meta cache - genTagFilterDigest(pTagCond, &context); + code = genTagFilterDigest(pTagCond, &context); + QUERY_CHECK_CODE(code, lino, _error); bool acquired = false; - pStorageAPI->metaFn.getCachedTableList(pVnode, pScanNode->suid, context.digest, tListLen(context.digest), - pUidList, &acquired); + code = pStorageAPI->metaFn.getCachedTableList(pVnode, pScanNode->suid, context.digest, tListLen(context.digest), + pUidList, &acquired); + QUERY_CHECK_CODE(code, lino, _error); + if (acquired) { digest[0] = 1; memcpy(digest + 1, context.digest, tListLen(context.digest)); @@ -1175,7 +1296,8 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S } if (!pTagCond) { // no tag filter condition exists, let's fetch all tables of this super table - pStorageAPI->metaFn.getChildTableList(pVnode, pScanNode->suid, pUidList); + code = pStorageAPI->metaFn.getChildTableList(pVnode, pScanNode->suid, pUidList); + QUERY_CHECK_CODE(code, lino, _error); } else { // failed to find the result in the cache, let try to calculate the results if (pTagIndexCond) { @@ -1207,14 +1329,17 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S if (tsTagFilterCache) { size_t size = numOfTables * sizeof(uint64_t) + sizeof(int32_t); char* pPayload = taosMemoryMalloc(size); + QUERY_CHECK_NULL(pPayload, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); *(int32_t*)pPayload = numOfTables; if (numOfTables > 0) { memcpy(pPayload + sizeof(int32_t), taosArrayGet(pUidList, 0), numOfTables * sizeof(uint64_t)); } - pStorageAPI->metaFn.putCachedTableList(pVnode, pScanNode->suid, context.digest, tListLen(context.digest), - pPayload, size, 1); + code = pStorageAPI->metaFn.putCachedTableList(pVnode, pScanNode->suid, context.digest, tListLen(context.digest), + pPayload, size, 1); + QUERY_CHECK_CODE(code, lino, _error); + digest[0] = 1; memcpy(digest + 1, context.digest, tListLen(context.digest)); } @@ -1236,7 +1361,11 @@ _end: } } +_error: taosArrayDestroy(pUidList); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } return code; } @@ -1360,7 +1489,12 @@ SArray* makeColumnArrayFromList(SNodeList* pNodeList) { c.precision = pColNode->node.resType.precision; c.scale = pColNode->node.resType.scale; - taosArrayPush(pList, &c); + void* tmp = taosArrayPush(pList, &c); + if (!tmp) { + taosArrayDestroy(pList); + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); + return NULL; + } } return pList; @@ -1369,7 +1503,8 @@ SArray* makeColumnArrayFromList(SNodeList* pNodeList) { int32_t extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNodeList, int32_t* numOfOutputCols, int32_t type, SColMatchInfo* pMatchInfo) { size_t numOfCols = LIST_LENGTH(pNodeList); - int32_t code = 0; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; pMatchInfo->matchType = type; @@ -1390,7 +1525,8 @@ int32_t extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNod c.dstSlotId = pNode->slotId; c.isPk = pColNode->isPk; c.dataType = pColNode->node.resType; - taosArrayPush(pList, &c); + void* tmp = taosArrayPush(pList, &c); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } } @@ -1424,6 +1560,11 @@ int32_t extractColMatchInfo(SNodeList* pNodeList, SDataBlockDescNode* pOutputNod } pMatchInfo->pList = pList; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } return code; } @@ -1458,8 +1599,12 @@ static SColumn* createColumn(int32_t blockId, int32_t slotId, int32_t colId, SDa return pCol; } -void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) { +int32_t createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; pExp->pExpr = taosMemoryCalloc(1, sizeof(tExprNode)); + QUERY_CHECK_NULL(pExp->pExpr, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + pExp->pExpr->_function.num = 1; pExp->pExpr->_function.functionId = -1; @@ -1470,6 +1615,8 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) { SColumnNode* pColNode = (SColumnNode*)pNode; pExp->base.pParam = taosMemoryCalloc(1, sizeof(SFunctParam)); + QUERY_CHECK_NULL(pExp->base.pParam, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + pExp->base.numOfParams = 1; SDataType* pType = &pColNode->node.resType; @@ -1483,6 +1630,8 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) { SValueNode* pValNode = (SValueNode*)pNode; pExp->base.pParam = taosMemoryCalloc(1, sizeof(SFunctParam)); + QUERY_CHECK_NULL(pExp->base.pParam, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + pExp->base.numOfParams = 1; SDataType* pType = &pValNode->node.resType; @@ -1518,7 +1667,8 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) { if (NULL == res) { // todo handle error } else { res->node.resType = (SDataType){.bytes = sizeof(int64_t), .type = TSDB_DATA_TYPE_BIGINT}; - nodesListAppend(pFuncNode->pParameterList, (SNode*)res); + code = nodesListAppend(pFuncNode->pParameterList, (SNode*)res); + QUERY_CHECK_CODE(code, lino, _end); } } #endif @@ -1567,10 +1717,16 @@ void createExprFromOneNode(SExprInfo* pExp, SNode* pNode, int16_t slotId) { } else { ASSERT(0); } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } -void createExprFromTargetNode(SExprInfo* pExp, STargetNode* pTargetNode) { - createExprFromOneNode(pExp, pTargetNode->pExpr, pTargetNode->slotId); +int32_t createExprFromTargetNode(SExprInfo* pExp, STargetNode* pTargetNode) { + return createExprFromOneNode(pExp, pTargetNode->pExpr, pTargetNode->slotId); } SExprInfo* createExpr(SNodeList* pNodeList, int32_t* numOfExprs) { @@ -1579,7 +1735,12 @@ SExprInfo* createExpr(SNodeList* pNodeList, int32_t* numOfExprs) { for (int32_t i = 0; i < (*numOfExprs); ++i) { SExprInfo* pExp = &pExprs[i]; - createExprFromOneNode(pExp, nodesListGetNode(pNodeList, i), i + UD_TAG_COLUMN_INDEX); + int32_t code = createExprFromOneNode(pExp, nodesListGetNode(pNodeList, i), i + UD_TAG_COLUMN_INDEX); + if (code != TSDB_CODE_SUCCESS) { + taosMemoryFreeClear(pExprs); + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return NULL; + } } return pExprs; @@ -1608,7 +1769,12 @@ SExprInfo* createExprInfo(SNodeList* pNodeList, SNodeList* pGroupKeys, int32_t* } SExprInfo* pExp = &pExprs[i]; - createExprFromTargetNode(pExp, pTargetNode); + int32_t code = createExprFromTargetNode(pExp, pTargetNode); + if (code != TSDB_CODE_SUCCESS) { + taosMemoryFreeClear(pExprs); + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return NULL; + } } return pExprs; @@ -1636,7 +1802,11 @@ static int32_t setSelectValueColumnInfo(SqlFunctionCtx* pCtx, int32_t numOfOutpu p = NULL; break; } else { - taosHashPut(pSelectFuncs, pName, strlen(pName), &num, sizeof(num)); + int32_t code = taosHashPut(pSelectFuncs, pName, strlen(pName), &num, sizeof(num)); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } p = &pCtx[i]; } } @@ -1655,6 +1825,8 @@ static int32_t setSelectValueColumnInfo(SqlFunctionCtx* pCtx, int32_t numOfOutpu SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, int32_t** rowEntryInfoOffset, SFunctionStateStore* pStore) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SqlFunctionCtx* pFuncCtx = (SqlFunctionCtx*)taosMemoryCalloc(numOfOutput, sizeof(SqlFunctionCtx)); if (pFuncCtx == NULL) { return NULL; @@ -1684,17 +1856,29 @@ SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, if (fmIsAggFunc(pCtx->functionId) || fmIsIndefiniteRowsFunc(pCtx->functionId)) { bool isUdaf = fmIsUserDefinedFunc(pCtx->functionId); if (!isUdaf) { - fmGetFuncExecFuncs(pCtx->functionId, &pCtx->fpSet); + code = fmGetFuncExecFuncs(pCtx->functionId, &pCtx->fpSet); + QUERY_CHECK_CODE(code, lino, _end); } else { char* udfName = pExpr->pExpr->_function.pFunctNode->functionName; pCtx->udfName = taosStrdup(udfName); - fmGetUdafExecFuncs(pCtx->functionId, &pCtx->fpSet); + code = fmGetUdafExecFuncs(pCtx->functionId, &pCtx->fpSet); + QUERY_CHECK_CODE(code, lino, _end); + } + bool tmp = pCtx->fpSet.getEnv(pExpr->pExpr->_function.pFunctNode, &env); + if (!tmp) { + code = TSDB_CODE_OUT_OF_MEMORY; + QUERY_CHECK_CODE(code, lino, _end); } - pCtx->fpSet.getEnv(pExpr->pExpr->_function.pFunctNode, &env); } else { - fmGetScalarFuncExecFuncs(pCtx->functionId, &pCtx->sfp); + code = fmGetScalarFuncExecFuncs(pCtx->functionId, &pCtx->sfp); + QUERY_CHECK_CODE(code, lino, _end); + if (pCtx->sfp.getEnv != NULL) { - pCtx->sfp.getEnv(pExpr->pExpr->_function.pFunctNode, &env); + bool tmp = pCtx->sfp.getEnv(pExpr->pExpr->_function.pFunctNode, &env); + if (!tmp) { + code = TSDB_CODE_OUT_OF_MEMORY; + QUERY_CHECK_CODE(code, lino, _end); + } } } pCtx->resDataInfo.interBufSize = env.calcMemSize; @@ -1706,7 +1890,9 @@ SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, pCtx->input.numOfInputCols = pFunct->numOfParams; pCtx->input.pData = taosMemoryCalloc(pFunct->numOfParams, POINTER_BYTES); + QUERY_CHECK_NULL(pCtx->input.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); pCtx->input.pColumnDataAgg = taosMemoryCalloc(pFunct->numOfParams, POINTER_BYTES); + QUERY_CHECK_NULL(pCtx->input.pColumnDataAgg, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); pCtx->pTsOutput = NULL; pCtx->resDataInfo.bytes = pFunct->resSchema.bytes; @@ -1726,14 +1912,27 @@ SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, pFuncCtx[i - 1].resDataInfo.interBufSize); } - setSelectValueColumnInfo(pFuncCtx, numOfOutput); + code = setSelectValueColumnInfo(pFuncCtx, numOfOutput); + QUERY_CHECK_CODE(code, lino, _end); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + for (int32_t i = 0; i < numOfOutput; ++i) { + taosMemoryFree(pFuncCtx[i].input.pData); + taosMemoryFree(pFuncCtx[i].input.pColumnDataAgg); + } + taosMemoryFreeClear(pFuncCtx); + return NULL; + } return pFuncCtx; } // NOTE: sources columns are more than the destination SSDatablock columns. // doFilter in table scan needs every column even its output is false -void relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray* pCols, bool outputEveryColumn) { - size_t numOfSrcCols = taosArrayGetSize(pCols); +int32_t relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray* pCols, bool outputEveryColumn) { + int32_t code = TSDB_CODE_SUCCESS; + size_t numOfSrcCols = taosArrayGetSize(pCols); int32_t i = 0, j = 0; while (i < numOfSrcCols && j < taosArrayGetSize(pColMatchInfo)) { @@ -1742,7 +1941,11 @@ void relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray if (p->info.colId == pmInfo->colId) { SColumnInfoData* pDst = taosArrayGet(pBlock->pDataBlock, pmInfo->dstSlotId); - colDataAssign(pDst, p, pBlock->info.rows, &pBlock->info); + code = colDataAssign(pDst, p, pBlock->info.rows, &pBlock->info); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } i++; j++; } else if (p->info.colId < pmInfo->colId) { @@ -1751,6 +1954,7 @@ void relocateColumnData(SSDataBlock* pBlock, const SArray* pColMatchInfo, SArray ASSERT(0); } } + return code; } SInterval extractIntervalInfo(const STableScanPhysiNode* pTableScanNode) { @@ -2022,15 +2226,15 @@ uint64_t tableListGetTableGroupId(const STableListInfo* pTableList, uint64_t tab // TODO handle the group offset info, fix it, the rule of group output will be broken by this function int32_t tableListAddTableInfo(STableListInfo* pTableList, uint64_t uid, uint64_t gid) { - int32_t code = TSDB_CODE_SUCCESS; - int32_t lino = 0; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pTableList->map == NULL) { pTableList->map = taosHashInit(32, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_ENTRY_LOCK); QUERY_CHECK_NULL(pTableList->map, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } STableKeyInfo keyInfo = {.uid = uid, .groupId = gid}; - void* tmp = taosArrayPush(pTableList->pTableList, &keyInfo); + void* tmp = taosArrayPush(pTableList->pTableList, &keyInfo); QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); int32_t slot = (int32_t)taosArrayGetSize(pTableList->pTableList) - 1; @@ -2108,9 +2312,9 @@ _error: return NULL; } -void* tableListDestroy(STableListInfo* pTableListInfo) { +void tableListDestroy(STableListInfo* pTableListInfo) { if (pTableListInfo == NULL) { - return NULL; + return; } taosArrayDestroy(pTableListInfo->pTableList); @@ -2122,7 +2326,6 @@ void* tableListDestroy(STableListInfo* pTableListInfo) { pTableListInfo->pTableList = NULL; pTableListInfo->map = NULL; taosMemoryFree(pTableListInfo); - return NULL; } void tableListClear(STableListInfo* pTableListInfo) { @@ -2159,12 +2362,20 @@ static int32_t sortTableGroup(STableListInfo* pTableListInfo) { uint64_t gid = pInfo->groupId; int32_t start = 0; - taosArrayPush(pList, &start); + void* tmp = taosArrayPush(pList, &start); + if (!tmp) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); + return TSDB_CODE_OUT_OF_MEMORY; + } for (int32_t i = 1; i < size; ++i) { pInfo = taosArrayGet(pTableListInfo->pTableList, i); if (pInfo->groupId != gid) { - taosArrayPush(pList, &i); + tmp = taosArrayPush(pList, &i); + if (!tmp) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(TSDB_CODE_OUT_OF_MEMORY)); + return TSDB_CODE_OUT_OF_MEMORY; + } gid = pInfo->groupId; } } @@ -2191,19 +2402,24 @@ int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle* return code; } if (group == NULL || groupByTbname) { - if (tsCountAlwaysReturnValue && QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN == nodeType(pScanNode) && ((STableScanPhysiNode*)pScanNode)->needCountEmptyTable) { + if (tsCountAlwaysReturnValue && QUERY_NODE_PHYSICAL_PLAN_TABLE_SCAN == nodeType(pScanNode) && + ((STableScanPhysiNode*)pScanNode)->needCountEmptyTable) { pTableListInfo->remainGroups = taosHashInit(numOfTables, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK); if (pTableListInfo->remainGroups == NULL) { return TSDB_CODE_OUT_OF_MEMORY; } - + for (int i = 0; i < numOfTables; i++) { STableKeyInfo* info = taosArrayGet(pTableListInfo->pTableList, i); info->groupId = groupByTbname ? info->uid : 0; - - taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId), &(info->uid), - sizeof(info->uid)); + + code = taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId), &(info->uid), + sizeof(info->uid)); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } } } else { for (int32_t i = 0; i < numOfTables; i++) { @@ -2251,7 +2467,11 @@ int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle* size_t size = taosArrayGetSize(pTableListInfo->pTableList); for (int32_t i = 0; i < size; ++i) { STableKeyInfo* p = taosArrayGet(pTableListInfo->pTableList, i); - taosHashPut(pTableListInfo->map, &p->uid, sizeof(uint64_t), &i, sizeof(int32_t)); + code = taosHashPut(pTableListInfo->map, &p->uid, sizeof(uint64_t), &i, sizeof(int32_t)); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } } return code; @@ -2457,7 +2677,11 @@ SNodeList* makeColsNodeArrFromSortKeys(SNodeList* pSortKeys) { SNodeList* ret = NULL; FOREACH(node, pSortKeys) { SOrderByExprNode* pSortKey = (SOrderByExprNode*)node; - nodesListMakeAppend(&ret, pSortKey->pExpr); + int32_t code = nodesListMakeAppend(&ret, pSortKey->pExpr); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return NULL; + } } return ret; } diff --git a/source/libs/executor/src/executorInt.c b/source/libs/executor/src/executorInt.c index a3e3501114..08103da96c 100644 --- a/source/libs/executor/src/executorInt.c +++ b/source/libs/executor/src/executorInt.c @@ -677,7 +677,7 @@ _end: } // todo refactor. SResultRow has direct pointer in miainfo -int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, SExprSupp* pSup, +void finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPosition, SExprSupp* pSup, SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo) { SFilePage* page = getBufPage(pBuf, resultRowPosition->pageId); if (page == NULL) { @@ -694,7 +694,7 @@ int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPos doUpdateNumOfRows(pCtx, pRow, pSup->numOfExprs, rowEntryOffset); if (pRow->numOfRows == 0) { releaseBufPage(pBuf, page); - return 0; + return ; } int32_t size = pBlock->info.capacity; @@ -713,7 +713,6 @@ int32_t finalizeResultRows(SDiskbasedBuf* pBuf, SResultRowPosition* resultRowPos releaseBufPage(pBuf, page); pBlock->info.rows += pRow->numOfRows; - return 0; } void doCopyToSDataBlockByHash(SExecTaskInfo* pTaskInfo, SSDataBlock* pBlock, SExprSupp* pSup, SDiskbasedBuf* pBuf, diff --git a/source/libs/executor/src/filloperator.c b/source/libs/executor/src/filloperator.c index 79e2d4b7c9..66655090bc 100644 --- a/source/libs/executor/src/filloperator.c +++ b/source/libs/executor/src/filloperator.c @@ -63,7 +63,8 @@ static void fillResetPrevForNewGroup(SFillInfo* pFillInfo); static void doHandleRemainBlockForNewGroupImpl(SOperatorInfo* pOperator, SFillOperatorInfo* pInfo, SResultInfo* pResultInfo, int32_t order) { pInfo->totalInputRows = pInfo->existNewGroupBlock->info.rows; - SSDataBlock* pResBlock = pInfo->pFinalRes; + SSDataBlock* pResBlock = pInfo->pFinalRes; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; // int32_t order = TSDB_ORDER_ASC; int32_t scanFlag = MAIN_SCAN; @@ -85,7 +86,11 @@ static void doHandleRemainBlockForNewGroupImpl(SOperatorInfo* pOperator, SFillOp } int32_t numOfResultRows = pResultInfo->capacity - pResBlock->info.rows; - taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows); + int32_t code = taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } pInfo->curGroupId = pInfo->existNewGroupBlock->info.id.groupId; pInfo->existNewGroupBlock = NULL; @@ -96,7 +101,11 @@ static void doHandleRemainBlockFromNewGroup(SOperatorInfo* pOperator, SFillOpera SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; if (taosFillHasMoreResults(pInfo->pFillInfo)) { int32_t numOfResultRows = pResultInfo->capacity - pInfo->pFinalRes->info.rows; - taosFillResultDataBlock(pInfo->pFillInfo, pInfo->pFinalRes, numOfResultRows); + int32_t code = taosFillResultDataBlock(pInfo->pFillInfo, pInfo->pFinalRes, numOfResultRows); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } pInfo->pRes->info.id.groupId = pInfo->curGroupId; return; } @@ -269,7 +278,8 @@ static SSDataBlock* doFillImpl(SOperatorInfo* pOperator) { } int32_t numOfResultRows = pOperator->resultInfo.capacity - pResBlock->info.rows; - taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows); + code = taosFillResultDataBlock(pInfo->pFillInfo, pResBlock, numOfResultRows); + QUERY_CHECK_CODE(code, lino, _end); // current group has no more result to return if (pResBlock->info.rows > 0) { @@ -356,7 +366,8 @@ void destroyFillOperatorInfo(void* param) { static int32_t initFillInfo(SFillOperatorInfo* pInfo, SExprInfo* pExpr, int32_t numOfCols, SExprInfo* pNotFillExpr, int32_t numOfNotFillCols, SNodeListNode* pValNode, STimeWindow win, int32_t capacity, - const char* id, SInterval* pInterval, int32_t fillType, int32_t order) { + const char* id, SInterval* pInterval, int32_t fillType, int32_t order, + SExecTaskInfo* pTaskInfo) { SFillColInfo* pColInfo = createFillColInfo(pExpr, numOfCols, pNotFillExpr, numOfNotFillCols, pValNode); int64_t startKey = (order == TSDB_ORDER_ASC) ? win.skey : win.ekey; @@ -364,7 +375,7 @@ static int32_t initFillInfo(SFillOperatorInfo* pInfo, SExprInfo* pExpr, int32_t // STimeWindow w = {0}; // getInitialStartTimeWindow(pInterval, startKey, &w, order == TSDB_ORDER_ASC); pInfo->pFillInfo = taosCreateFillInfo(startKey, numOfCols, numOfNotFillCols, capacity, pInterval, fillType, pColInfo, - pInfo->primaryTsCol, order, id); + pInfo->primaryTsCol, order, id, pTaskInfo); if (order == TSDB_ORDER_ASC) { pInfo->win.skey = win.skey; @@ -414,7 +425,13 @@ static int32_t createPrimaryTsExprIfNeeded(SFillOperatorInfo* pInfo, SFillPhysiN return TSDB_CODE_OUT_OF_MEMORY; } - createExprFromTargetNode(&pExpr[pExprSupp->numOfExprs], (STargetNode*)pPhyFillNode->pWStartTs); + int32_t code = createExprFromTargetNode(&pExpr[pExprSupp->numOfExprs], (STargetNode*)pPhyFillNode->pWStartTs); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + taosMemoryFreeClear(pExpr); + return code; + } + pExprSupp->numOfExprs += 1; pExprSupp->pExprInfo = pExpr; } @@ -476,7 +493,7 @@ SOperatorInfo* createFillOperatorInfo(SOperatorInfo* downstream, SFillPhysiNode* code = initFillInfo(pInfo, pExprInfo, pInfo->numOfExpr, pNoFillSupp->pExprInfo, pNoFillSupp->numOfExprs, (SNodeListNode*)pPhyFillNode->pValues, pPhyFillNode->timeRange, pResultInfo->capacity, - pTaskInfo->id.str, pInterval, type, order); + pTaskInfo->id.str, pInterval, type, order, pTaskInfo); if (code != TSDB_CODE_SUCCESS) { goto _error; } diff --git a/source/libs/executor/src/groupoperator.c b/source/libs/executor/src/groupoperator.c index dbe844bc32..2e660ef1bc 100644 --- a/source/libs/executor/src/groupoperator.c +++ b/source/libs/executor/src/groupoperator.c @@ -1614,7 +1614,9 @@ SOperatorInfo* createStreamPartitionOperatorInfo(SOperatorInfo* downstream, SStr QUERY_CHECK_NULL(pSubTableExpr, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); pInfo->tbnameCalSup.pExprInfo = pSubTableExpr; - createExprFromOneNode(pSubTableExpr, pPartNode->pSubtable, 0); + code = createExprFromOneNode(pSubTableExpr, pPartNode->pSubtable, 0); + QUERY_CHECK_CODE(code, lino, _error); + code = initExprSupp(&pInfo->tbnameCalSup, pSubTableExpr, 1, &pTaskInfo->storageAPI.functionStore); QUERY_CHECK_CODE(code, lino, _error); } diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index 520cba92a1..103378c3ef 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -359,11 +359,10 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanBase* pTableSca if (success) { size_t size = taosArrayGetSize(pBlock->pDataBlock); bool keep = false; - int32_t code = + code = doFilterByBlockSMA(pOperator->exprSupp.pFilterInfo, pBlock->pBlockAgg, size, pBlockInfo->rows, &keep); - if (TSDB_CODE_SUCCESS != code) { - return code; - } + QUERY_CHECK_CODE(code, lino, _end); + if (!keep) { qDebug("%s data block filter out by block SMA, brange:%" PRId64 "-%" PRId64 ", rows:%" PRId64, GET_TASKID(pTaskInfo), pBlockInfo->window.skey, pBlockInfo->window.ekey, pBlockInfo->rows); @@ -1125,14 +1124,16 @@ static SSDataBlock* groupSeqTableScan(SOperatorInfo* pOperator) { taosRLockLatch(&pTaskInfo->lock); code = initNextGroupScan(pInfo, &pList, &num); - QUERY_CHECK_CODE(code, lino, _end); taosRUnLockLatch(&pTaskInfo->lock); + QUERY_CHECK_CODE(code, lino, _end); ASSERT(pInfo->base.dataReader == NULL); - pAPI->tsdReader.tsdReaderOpen(pInfo->base.readHandle.vnode, &pInfo->base.cond, pList, num, pInfo->pResBlock, + code = pAPI->tsdReader.tsdReaderOpen(pInfo->base.readHandle.vnode, &pInfo->base.cond, pList, num, pInfo->pResBlock, (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), &pInfo->pIgnoreTables); + QUERY_CHECK_CODE(code, lino, _end); + if (pInfo->filesetDelimited) { pAPI->tsdReader.tsdSetFilesetDelimited(pInfo->base.dataReader); } @@ -1260,7 +1261,7 @@ static void destroyTableScanBase(STableScanBase* pBase, TsdReader* pAPI) { taosArrayDestroy(pBase->matchInfo.pList); } - (void)tableListDestroy(pBase->pTableListInfo); + tableListDestroy(pBase->pTableListInfo); taosLRUCacheCleanup(pBase->metaCache.pTableMetaEntryCache); cleanupExprSupp(&pBase->pseudoSup); } @@ -3472,7 +3473,7 @@ static void destroyRawScanOperatorInfo(void* param) { SStreamRawScanInfo* pRawScan = (SStreamRawScanInfo*)param; pRawScan->pAPI->tsdReader.tsdReaderClose(pRawScan->dataReader); (void)pRawScan->pAPI->snapshotFn.destroySnapshot(pRawScan->sContext); - (void)tableListDestroy(pRawScan->pTableListInfo); + tableListDestroy(pRawScan->pTableListInfo); taosMemoryFree(pRawScan); } @@ -3665,7 +3666,7 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys if (pInfo == NULL || pOperator == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - (void)tableListDestroy(pTableListInfo); + tableListDestroy(pTableListInfo); goto _error; } @@ -3678,7 +3679,7 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys int32_t numOfCols = 0; code = extractColMatchInfo(pScanPhyNode->pScanCols, pDescNode, &numOfCols, COL_MATCH_FROM_COL_ID, &pInfo->matchInfo); if (code != TSDB_CODE_SUCCESS) { - (void)tableListDestroy(pTableListInfo); + tableListDestroy(pTableListInfo); goto _error; } @@ -3707,14 +3708,16 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys SExprInfo* pSubTableExpr = taosMemoryCalloc(1, sizeof(SExprInfo)); if (pSubTableExpr == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - (void)tableListDestroy(pTableListInfo); + tableListDestroy(pTableListInfo); goto _error; } pInfo->tbnameCalSup.pExprInfo = pSubTableExpr; - createExprFromOneNode(pSubTableExpr, pTableScanNode->pSubtable, 0); + code = createExprFromOneNode(pSubTableExpr, pTableScanNode->pSubtable, 0); + QUERY_CHECK_CODE(code, lino, _error); + if (initExprSupp(&pInfo->tbnameCalSup, pSubTableExpr, 1, &pTaskInfo->storageAPI.functionStore) != 0) { - (void)tableListDestroy(pTableListInfo); + tableListDestroy(pTableListInfo); goto _error; } } @@ -3724,12 +3727,12 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys SExprInfo* pTagExpr = createExpr(pTableScanNode->pTags, &numOfTags); if (pTagExpr == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - (void)tableListDestroy(pTableListInfo); + tableListDestroy(pTableListInfo); goto _error; } if (initExprSupp(&pInfo->tagCalSup, pTagExpr, numOfTags, &pTaskInfo->storageAPI.functionStore) != 0) { terrno = TSDB_CODE_OUT_OF_MEMORY; - (void)tableListDestroy(pTableListInfo); + tableListDestroy(pTableListInfo); goto _error; } } @@ -3737,7 +3740,7 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys pInfo->pBlockLists = taosArrayInit(4, sizeof(SPackedData)); if (pInfo->pBlockLists == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - (void)tableListDestroy(pTableListInfo); + tableListDestroy(pTableListInfo); goto _error; } @@ -3802,7 +3805,7 @@ SOperatorInfo* createStreamScanOperatorInfo(SReadHandle* pHandle, STableScanPhys memcpy(&pTaskInfo->streamInfo.tableCond, &pTSInfo->base.cond, sizeof(SQueryTableDataCond)); } else { taosArrayDestroy(pColIds); - (void)tableListDestroy(pTableListInfo); + tableListDestroy(pTableListInfo); pColIds = NULL; } @@ -4307,7 +4310,7 @@ static void destroyTagScanOperatorInfo(void* param) { blockDataDestroy(pInfo->pRes); pInfo->pRes = NULL; taosArrayDestroy(pInfo->matchInfo.pList); - pInfo->pTableListInfo = tableListDestroy(pInfo->pTableListInfo); + tableListDestroy(pInfo->pTableListInfo); taosMemoryFreeClear(param); } @@ -5341,7 +5344,6 @@ SSDataBlock* doTableMergeScan(SOperatorInfo* pOperator) { } pOperator->cost.totalCost += (taosGetTimestampUs() - st) / 1000.0; - ; return pBlock; } diff --git a/source/libs/executor/src/sysscanoperator.c b/source/libs/executor/src/sysscanoperator.c index dd6c653a8a..1b09c47f05 100644 --- a/source/libs/executor/src/sysscanoperator.c +++ b/source/libs/executor/src/sysscanoperator.c @@ -14,9 +14,9 @@ */ #include "executorInt.h" -#include "geosWrapper.h" #include "filter.h" #include "functionMgt.h" +#include "geosWrapper.h" #include "querynodes.h" #include "systable.h" #include "tname.h" @@ -129,7 +129,7 @@ const SSTabFltFuncDef filterDict[] = { #define SYSTAB_FILTER_DICT_SIZE (sizeof(filterDict) / sizeof(filterDict[0])) static int32_t buildDbTableInfoBlock(bool sysInfo, const SSDataBlock* p, const SSysTableMeta* pSysDbTableMeta, - size_t size, const char* dbName); + size_t size, const char* dbName, int64_t* pRows); static char* SYSTABLE_IDX_COLUMN[] = {"table_name", "db_name", "create_time", "columns", "ttl", "stable_name", "vgroup_id', 'uid", "type"}; @@ -151,7 +151,7 @@ static int32_t sysTableUserColsFillOneTableCols(const SSysTableScanInfo* pInfo, char* tableType); static void relocateAndFilterSysTagsScanResult(SSysTableScanInfo* pInfo, int32_t numOfRows, SSDataBlock* dataBlock, - SFilterInfo* pFilterInfo); + SFilterInfo* pFilterInfo, SExecTaskInfo* pTaskInfo); int32_t sysFilte__DbName(void* arg, SNode* pNode, SArray* result) { SSTabFltArg* pArg = arg; @@ -162,9 +162,17 @@ int32_t sysFilte__DbName(void* arg, SNode* pNode, SArray* result) { SName sn = {0}; char dbname[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; - tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + int32_t code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } - tNameGetDbName(&sn, varDataVal(dbname)); + code = tNameGetDbName(&sn, varDataVal(dbname)); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } varDataSetLen(dbname, strlen(varDataVal(dbname))); SOperatorNode* pOper = (SOperatorNode*)pNode; @@ -481,11 +489,18 @@ static SSDataBlock* doOptimizeTableNameFilter(SOperatorInfo* pOperator, SSDataBl STR_TO_VARSTR(typeName, "NORMAL_TABLE"); } - sysTableUserColsFillOneTableCols(pInfo, dbname, &numOfRows, dataBlock, tableName, schemaRow, typeName); + code = sysTableUserColsFillOneTableCols(pInfo, dbname, &numOfRows, dataBlock, tableName, schemaRow, typeName); + if (code != TSDB_CODE_SUCCESS) { + pAPI->metaReaderFn.clearReader(&smrTable); + pInfo->loadInfo.totalRows = 0; + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } pAPI->metaReaderFn.clearReader(&smrTable); if (numOfRows > 0) { - relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo); + relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo, pTaskInfo); numOfRows = 0; } @@ -498,19 +513,30 @@ static SSDataBlock* doOptimizeTableNameFilter(SOperatorInfo* pOperator, SSDataBl } int32_t doExtractDbName(char* dbname, SSysTableScanInfo* pInfo, SStorageAPI* pAPI) { - SName sn = {0}; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SName sn = {0}; const char* db = NULL; int32_t vgId = 0; pAPI->metaFn.getBasicInfo(pInfo->readHandle.vnode, &db, &vgId, NULL, NULL); - tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + QUERY_CHECK_CODE(code, lino, _end); + + code = tNameGetDbName(&sn, varDataVal(dbname)); + QUERY_CHECK_CODE(code, lino, _end); - tNameGetDbName(&sn, varDataVal(dbname)); varDataSetLen(dbname, strlen(varDataVal(dbname))); - return TSDB_CODE_SUCCESS; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; SSysTableScanInfo* pInfo = pOperator->info; @@ -526,8 +552,11 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { blockDataCleanup(pInfo->pRes); pDataBlock = buildInfoSchemaTableMetaBlock(TSDB_INS_TABLE_COLS); - blockDataEnsureCapacity(pDataBlock, pOperator->resultInfo.capacity); - doExtractDbName(dbname, pInfo, pAPI); + code = blockDataEnsureCapacity(pDataBlock, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _end); + + code = doExtractDbName(dbname, pInfo, pAPI); + QUERY_CHECK_CODE(code, lino, _end); // optimize when sql like where table_name='tablename' and xxx. if (pInfo->req.filterTb[0]) { @@ -555,7 +584,6 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { return NULL; } - while (((ret = pAPI->metaFn.cursorNext(pInfo->pCur, TSDB_TABLE_MAX)) == 0)) { char typeName[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; char tableName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; @@ -567,7 +595,8 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { void* schema = taosHashGet(pInfo->pSchema, &pInfo->pCur->mr.me.uid, sizeof(int64_t)); if (schema == NULL) { SSchemaWrapper* schemaWrapper = tCloneSSchemaWrapper(&pInfo->pCur->mr.me.stbEntry.schemaRow); - taosHashPut(pInfo->pSchema, &pInfo->pCur->mr.me.uid, sizeof(int64_t), &schemaWrapper, POINTER_BYTES); + code = taosHashPut(pInfo->pSchema, &pInfo->pCur->mr.me.uid, sizeof(int64_t), &schemaWrapper, POINTER_BYTES); + QUERY_CHECK_CODE(code, lino, _end); } continue; } else if (pInfo->pCur->mr.me.type == TSDB_CHILD_TABLE) { @@ -582,10 +611,11 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { } else { SMetaReader smrSuperTable = {0}; pAPI->metaReaderFn.initReader(&smrSuperTable, pInfo->readHandle.vnode, META_READER_NOLOCK, &pAPI->metaFn); - int code = pAPI->metaReaderFn.getTableEntryByUid(&smrSuperTable, suid); + code = pAPI->metaReaderFn.getTableEntryByUid(&smrSuperTable, suid); if (code != TSDB_CODE_SUCCESS) { // terrno has been set by pAPI->metaReaderFn.getTableEntryByName, therefore, return directly - qError("sysTableScanUserCols get meta by suid:%" PRId64 " error, code:%d, %s", suid, code, GET_TASKID(pTaskInfo)); + qError("sysTableScanUserCols get meta by suid:%" PRId64 " error, code:%d, %s", suid, code, + GET_TASKID(pTaskInfo)); pAPI->metaReaderFn.clearReader(&smrSuperTable); blockDataDestroy(pDataBlock); @@ -593,7 +623,9 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { return NULL; } SSchemaWrapper* schemaWrapper = tCloneSSchemaWrapper(&smrSuperTable.me.stbEntry.schemaRow); - taosHashPut(pInfo->pSchema, &suid, sizeof(int64_t), &schemaWrapper, POINTER_BYTES); + code = taosHashPut(pInfo->pSchema, &suid, sizeof(int64_t), &schemaWrapper, POINTER_BYTES); + QUERY_CHECK_CODE(code, lino, _end); + schemaRow = schemaWrapper; pAPI->metaReaderFn.clearReader(&smrSuperTable); } @@ -608,7 +640,7 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { } if ((numOfRows + schemaRow->nCols) > pOperator->resultInfo.capacity) { - relocateAndFilterSysTagsScanResult(pInfo, numOfRows, pDataBlock, pOperator->exprSupp.pFilterInfo); + relocateAndFilterSysTagsScanResult(pInfo, numOfRows, pDataBlock, pOperator->exprSupp.pFilterInfo, pTaskInfo); numOfRows = 0; if (pInfo->pRes->info.rows > 0) { @@ -616,13 +648,14 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { break; } } else { - sysTableUserColsFillOneTableCols(pInfo, dbname, &numOfRows, pDataBlock, tableName, schemaRow, typeName); + code = sysTableUserColsFillOneTableCols(pInfo, dbname, &numOfRows, pDataBlock, tableName, schemaRow, typeName); + QUERY_CHECK_CODE(code, lino, _end); } } if (numOfRows > 0) { pAPI->metaFn.pauseTableMetaCursor(pInfo->pCur); - relocateAndFilterSysTagsScanResult(pInfo, numOfRows, pDataBlock, pOperator->exprSupp.pFilterInfo); + relocateAndFilterSysTagsScanResult(pInfo, numOfRows, pDataBlock, pOperator->exprSupp.pFilterInfo, pTaskInfo); numOfRows = 0; } @@ -635,10 +668,19 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { pInfo->loadInfo.totalRows += pInfo->pRes->info.rows; qDebug("get cols success, rows:%" PRIu64 " %s", pInfo->loadInfo.totalRows, GET_TASKID(pTaskInfo)); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes; } static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; @@ -651,7 +693,8 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) { int32_t numOfRows = 0; SSDataBlock* dataBlock = buildInfoSchemaTableMetaBlock(TSDB_INS_TABLE_TAGS); - blockDataEnsureCapacity(dataBlock, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(dataBlock, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _end); const char* db = NULL; int32_t vgId = 0; @@ -659,9 +702,12 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) { SName sn = {0}; char dbname[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; - tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + QUERY_CHECK_CODE(code, lino, _end); + + code = tNameGetDbName(&sn, varDataVal(dbname)); + QUERY_CHECK_CODE(code, lino, _end); - tNameGetDbName(&sn, varDataVal(dbname)); varDataSetLen(dbname, strlen(varDataVal(dbname))); char condTableName[TSDB_TABLE_NAME_LEN] = {0}; @@ -699,12 +745,14 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) { return NULL; } - sysTableUserTagsFillOneTableTags(pInfo, &smrSuperTable, &smrChildTable, dbname, tableName, &numOfRows, dataBlock); + code = sysTableUserTagsFillOneTableTags(pInfo, &smrSuperTable, &smrChildTable, dbname, tableName, &numOfRows, dataBlock); + QUERY_CHECK_CODE(code, lino, _end); + pAPI->metaReaderFn.clearReader(&smrSuperTable); pAPI->metaReaderFn.clearReader(&smrChildTable); if (numOfRows > 0) { - relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo); + relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo, pTaskInfo); numOfRows = 0; } blockDataDestroy(dataBlock); @@ -731,7 +779,7 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) { SMetaReader smrSuperTable = {0}; pAPI->metaReaderFn.initReader(&smrSuperTable, pInfo->readHandle.vnode, META_READER_NOLOCK, &pAPI->metaFn); uint64_t suid = pInfo->pCur->mr.me.ctbEntry.suid; - int32_t code = pAPI->metaReaderFn.getTableEntryByUid(&smrSuperTable, suid); + code = pAPI->metaReaderFn.getTableEntryByUid(&smrSuperTable, suid); if (code != TSDB_CODE_SUCCESS) { qError("failed to get super table meta, uid:0x%" PRIx64 ", code:%s, %s", suid, tstrerror(terrno), GET_TASKID(pTaskInfo)); @@ -742,7 +790,7 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) { } if ((smrSuperTable.me.stbEntry.schemaTag.nCols + numOfRows) > pOperator->resultInfo.capacity) { - relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo); + relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo, pTaskInfo); numOfRows = 0; if (pInfo->pRes->info.rows > 0) { @@ -751,15 +799,16 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) { break; } } else { - sysTableUserTagsFillOneTableTags(pInfo, &smrSuperTable, &pInfo->pCur->mr, dbname, tableName, &numOfRows, - dataBlock); + code = sysTableUserTagsFillOneTableTags(pInfo, &smrSuperTable, &pInfo->pCur->mr, dbname, tableName, &numOfRows, + dataBlock); + QUERY_CHECK_CODE(code, lino, _end); } pAPI->metaReaderFn.clearReader(&smrSuperTable); } if (numOfRows > 0) { pAPI->metaFn.pauseTableMetaCursor(pInfo->pCur); - relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo); + relocateAndFilterSysTagsScanResult(pInfo, numOfRows, dataBlock, pOperator->exprSupp.pFilterInfo, pTaskInfo); numOfRows = 0; } @@ -771,17 +820,39 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) { } pInfo->loadInfo.totalRows += pInfo->pRes->info.rows; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pAPI->metaFn.closeTableMetaCursor(pInfo->pCur); + pInfo->pCur = NULL; + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes; } void relocateAndFilterSysTagsScanResult(SSysTableScanInfo* pInfo, int32_t numOfRows, SSDataBlock* dataBlock, - SFilterInfo* pFilterInfo) { + SFilterInfo* pFilterInfo, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; dataBlock->info.rows = numOfRows; pInfo->pRes->info.rows = numOfRows; - relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, dataBlock->pDataBlock, false); - doFilter(pInfo->pRes, pFilterInfo, NULL); + code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, dataBlock->pDataBlock, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = doFilter(pInfo->pRes, pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); + blockDataCleanup(dataBlock); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } } int32_t convertTagDataToStr(char* str, int type, void* buf, int32_t bufSize, int32_t* len) { @@ -894,7 +965,9 @@ static int32_t sysTableGetGeomText(char* iGeom, int32_t nGeom, char** output, in static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo, SMetaReader* smrSuperTable, SMetaReader* smrChildTable, const char* dbname, const char* tableName, int32_t* pNumOfRows, const SSDataBlock* dataBlock) { - char stableName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + char stableName[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(stableName, (*smrSuperTable).me.name); int32_t numOfRows = *pNumOfRows; @@ -905,21 +978,25 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo, // table name pColInfoData = taosArrayGet(dataBlock->pDataBlock, 0); - colDataSetVal(pColInfoData, numOfRows, tableName, false); + code = colDataSetVal(pColInfoData, numOfRows, tableName, false); + QUERY_CHECK_CODE(code, lino, _end); // database name pColInfoData = taosArrayGet(dataBlock->pDataBlock, 1); - colDataSetVal(pColInfoData, numOfRows, dbname, false); + code = colDataSetVal(pColInfoData, numOfRows, dbname, false); + QUERY_CHECK_CODE(code, lino, _end); // super table name pColInfoData = taosArrayGet(dataBlock->pDataBlock, 2); - colDataSetVal(pColInfoData, numOfRows, stableName, false); + code = colDataSetVal(pColInfoData, numOfRows, stableName, false); + QUERY_CHECK_CODE(code, lino, _end); // tag name char tagName[TSDB_COL_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(tagName, (*smrSuperTable).me.stbEntry.schemaTag.pSchema[i].name); pColInfoData = taosArrayGet(dataBlock->pDataBlock, 3); - colDataSetVal(pColInfoData, numOfRows, tagName, false); + code = colDataSetVal(pColInfoData, numOfRows, tagName, false); + QUERY_CHECK_CODE(code, lino, _end); // tag type int8_t tagType = (*smrSuperTable).me.stbEntry.schemaTag.pSchema[i].type; @@ -935,7 +1012,8 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo, (int32_t)((*smrSuperTable).me.stbEntry.schemaTag.pSchema[i].bytes - VARSTR_HEADER_SIZE)); } varDataSetLen(tagTypeStr, tagTypeLen); - colDataSetVal(pColInfoData, numOfRows, (char*)tagTypeStr, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)tagTypeStr, false); + QUERY_CHECK_CODE(code, lino, _end); STagVal tagVal = {0}; tagVal.cid = (*smrSuperTable).me.stbEntry.schemaTag.pSchema[i].colId; @@ -948,7 +1026,8 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo, bool exist = tTagGet((STag*)smrChildTable->me.ctbEntry.pTags, &tagVal); if (exist) { if (tagType == TSDB_DATA_TYPE_GEOMETRY) { - sysTableGetGeomText(tagVal.pData, tagVal.nData, &tagData, &tagLen); + code = sysTableGetGeomText(tagVal.pData, tagVal.nData, &tagData, &tagLen); + QUERY_CHECK_CODE(code, lino, _end); } else if (tagType == TSDB_DATA_TYPE_VARBINARY) { if (taosAscii2Hex(tagVal.pData, tagVal.nData, (void**)&tagData, &tagLen) < 0) { qError("varbinary for systable failed since %s", tstrerror(TSDB_CODE_OUT_OF_MEMORY)); @@ -969,6 +1048,7 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo, char* tagJson = NULL; parseTagDatatoJson(tagData, &tagJson); tagVarChar = taosMemoryMalloc(strlen(tagJson) + VARSTR_HEADER_SIZE); + QUERY_CHECK_NULL(tagVarChar, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); memcpy(varDataVal(tagVarChar), tagJson, strlen(tagJson)); varDataSetLen(tagVarChar, strlen(tagJson)); taosMemoryFree(tagJson); @@ -976,6 +1056,7 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo, int32_t bufSize = IS_VAR_DATA_TYPE(tagType) ? (tagLen + VARSTR_HEADER_SIZE) : (3 + DBL_MANT_DIG - DBL_MIN_EXP + VARSTR_HEADER_SIZE); tagVarChar = taosMemoryCalloc(1, bufSize + 1); + QUERY_CHECK_NULL(tagVarChar, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); int32_t len = -1; if (tagLen > 0) convertTagDataToStr(varDataVal(tagVarChar), tagType, tagData, tagLen, &len); @@ -985,8 +1066,10 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo, } } pColInfoData = taosArrayGet(dataBlock->pDataBlock, 5); - colDataSetVal(pColInfoData, numOfRows, tagVarChar, - (tagData == NULL) || (tagType == TSDB_DATA_TYPE_JSON && tTagIsJsonNull(tagData))); + code = colDataSetVal(pColInfoData, numOfRows, tagVarChar, + (tagData == NULL) || (tagType == TSDB_DATA_TYPE_JSON && tTagIsJsonNull(tagData))); + QUERY_CHECK_CODE(code, lino, _end); + if (tagType == TSDB_DATA_TYPE_GEOMETRY || tagType == TSDB_DATA_TYPE_VARBINARY) taosMemoryFreeClear(tagData); taosMemoryFree(tagVarChar); ++numOfRows; @@ -994,12 +1077,18 @@ static int32_t sysTableUserTagsFillOneTableTags(const SSysTableScanInfo* pInfo, *pNumOfRows = numOfRows; - return TSDB_CODE_SUCCESS; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static int32_t sysTableUserColsFillOneTableCols(const SSysTableScanInfo* pInfo, const char* dbname, int32_t* pNumOfRows, const SSDataBlock* dataBlock, char* tName, SSchemaWrapper* schemaRow, char* tableType) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (schemaRow == NULL) { qError("sysTableUserColsFillOneTableCols schemaRow is NULL"); return TSDB_CODE_SUCCESS; @@ -1012,20 +1101,24 @@ static int32_t sysTableUserColsFillOneTableCols(const SSysTableScanInfo* pInfo, // table name pColInfoData = taosArrayGet(dataBlock->pDataBlock, 0); - colDataSetVal(pColInfoData, numOfRows, tName, false); + code = colDataSetVal(pColInfoData, numOfRows, tName, false); + QUERY_CHECK_CODE(code, lino, _end); // database name pColInfoData = taosArrayGet(dataBlock->pDataBlock, 1); - colDataSetVal(pColInfoData, numOfRows, dbname, false); + code = colDataSetVal(pColInfoData, numOfRows, dbname, false); + QUERY_CHECK_CODE(code, lino, _end); pColInfoData = taosArrayGet(dataBlock->pDataBlock, 2); - colDataSetVal(pColInfoData, numOfRows, tableType, false); + code = colDataSetVal(pColInfoData, numOfRows, tableType, false); + QUERY_CHECK_CODE(code, lino, _end); // col name char colName[TSDB_COL_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(colName, schemaRow->pSchema[i].name); pColInfoData = taosArrayGet(dataBlock->pDataBlock, 3); - colDataSetVal(pColInfoData, numOfRows, colName, false); + code = colDataSetVal(pColInfoData, numOfRows, colName, false); + QUERY_CHECK_CODE(code, lino, _end); // col type int8_t colType = schemaRow->pSchema[i].type; @@ -1040,10 +1133,12 @@ static int32_t sysTableUserColsFillOneTableCols(const SSysTableScanInfo* pInfo, (int32_t)((schemaRow->pSchema[i].bytes - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE)); } varDataSetLen(colTypeStr, colTypeLen); - colDataSetVal(pColInfoData, numOfRows, (char*)colTypeStr, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)colTypeStr, false); + QUERY_CHECK_CODE(code, lino, _end); pColInfoData = taosArrayGet(dataBlock->pDataBlock, 5); - colDataSetVal(pColInfoData, numOfRows, (const char*)&schemaRow->pSchema[i].bytes, false); + code = colDataSetVal(pColInfoData, numOfRows, (const char*)&schemaRow->pSchema[i].bytes, false); + QUERY_CHECK_CODE(code, lino, _end); for (int32_t j = 6; j <= 8; ++j) { pColInfoData = taosArrayGet(dataBlock->pDataBlock, j); @@ -1054,7 +1149,11 @@ static int32_t sysTableUserColsFillOneTableCols(const SSysTableScanInfo* pInfo, *pNumOfRows = numOfRows; - return TSDB_CODE_SUCCESS; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static SSDataBlock* buildInfoSchemaTableMetaBlock(char* tableName) { @@ -1074,14 +1173,23 @@ static SSDataBlock* buildInfoSchemaTableMetaBlock(char* tableName) { for (int32_t i = 0; i < pMeta[index].colNum; ++i) { SColumnInfoData colInfoData = createColumnInfoData(pMeta[index].schema[i].type, pMeta[index].schema[i].bytes, i + 1); - blockDataAppendColInfo(pBlock, &colInfoData); + int32_t code = blockDataAppendColInfo(pBlock, &colInfoData); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + blockDataDestroy(pBlock); + pBlock = NULL; + terrno = code; + break; + } } return pBlock; } int32_t buildDbTableInfoBlock(bool sysInfo, const SSDataBlock* p, const SSysTableMeta* pSysDbTableMeta, size_t size, - const char* dbName) { + const char* dbName, int64_t* pRows) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; char n[TSDB_TABLE_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; int32_t numOfRows = p->info.rows; @@ -1091,19 +1199,21 @@ int32_t buildDbTableInfoBlock(bool sysInfo, const SSDataBlock* p, const SSysTabl continue; } - if(strcmp(pm->name, TSDB_INS_TABLE_USERS_FULL) == 0){ + if (strcmp(pm->name, TSDB_INS_TABLE_USERS_FULL) == 0) { continue; } SColumnInfoData* pColInfoData = taosArrayGet(p->pDataBlock, 0); STR_TO_VARSTR(n, pm->name); - colDataSetVal(pColInfoData, numOfRows, n, false); + code = colDataSetVal(pColInfoData, numOfRows, n, false); + QUERY_CHECK_CODE(code, lino, _end); // database name STR_TO_VARSTR(n, dbName); pColInfoData = taosArrayGet(p->pDataBlock, 1); - colDataSetVal(pColInfoData, numOfRows, n, false); + code = colDataSetVal(pColInfoData, numOfRows, n, false); + QUERY_CHECK_CODE(code, lino, _end); // create time pColInfoData = taosArrayGet(p->pDataBlock, 2); @@ -1111,7 +1221,8 @@ int32_t buildDbTableInfoBlock(bool sysInfo, const SSDataBlock* p, const SSysTabl // number of columns pColInfoData = taosArrayGet(p->pDataBlock, 3); - colDataSetVal(pColInfoData, numOfRows, (char*)&pm->colNum, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&pm->colNum, false); + QUERY_CHECK_CODE(code, lino, _end); for (int32_t j = 4; j <= 8; ++j) { pColInfoData = taosArrayGet(p->pDataBlock, j); @@ -1121,41 +1232,61 @@ int32_t buildDbTableInfoBlock(bool sysInfo, const SSDataBlock* p, const SSysTabl STR_TO_VARSTR(n, "SYSTEM_TABLE"); pColInfoData = taosArrayGet(p->pDataBlock, 9); - colDataSetVal(pColInfoData, numOfRows, n, false); + code = colDataSetVal(pColInfoData, numOfRows, n, false); + QUERY_CHECK_CODE(code, lino, _end); numOfRows += 1; } - return numOfRows; + *pRows = numOfRows; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } int32_t buildSysDbTableInfo(const SSysTableScanInfo* pInfo, int32_t capacity) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SSDataBlock* p = buildInfoSchemaTableMetaBlock(TSDB_INS_TABLE_TABLES); - blockDataEnsureCapacity(p, capacity); + QUERY_CHECK_NULL(p, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + code = blockDataEnsureCapacity(p, capacity); + QUERY_CHECK_CODE(code, lino, _end); size_t size = 0; const SSysTableMeta* pSysDbTableMeta = NULL; getInfosDbMeta(&pSysDbTableMeta, &size); - p->info.rows = buildDbTableInfoBlock(pInfo->sysInfo, p, pSysDbTableMeta, size, TSDB_INFORMATION_SCHEMA_DB); + code = buildDbTableInfoBlock(pInfo->sysInfo, p, pSysDbTableMeta, size, TSDB_INFORMATION_SCHEMA_DB, &p->info.rows); + QUERY_CHECK_CODE(code, lino, _end); getPerfDbMeta(&pSysDbTableMeta, &size); - p->info.rows = buildDbTableInfoBlock(pInfo->sysInfo, p, pSysDbTableMeta, size, TSDB_PERFORMANCE_SCHEMA_DB); + code = buildDbTableInfoBlock(pInfo->sysInfo, p, pSysDbTableMeta, size, TSDB_PERFORMANCE_SCHEMA_DB, &p->info.rows); + QUERY_CHECK_CODE(code, lino, _end); pInfo->pRes->info.rows = p->info.rows; - relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); + code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); + QUERY_CHECK_CODE(code, lino, _end); + blockDataDestroy(p); - return pInfo->pRes->info.rows; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) { - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - SStorageAPI* pAPI = &pTaskInfo->storageAPI; - + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + SStorageAPI* pAPI = &pTaskInfo->storageAPI; SSysTableScanInfo* pInfo = pOperator->info; - - SSysTableIndex* pIdx = pInfo->pIdx; + SSysTableIndex* pIdx = pInfo->pIdx; blockDataCleanup(pInfo->pRes); int32_t numOfRows = 0; @@ -1167,13 +1298,17 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) { SName sn = {0}; char dbname[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; - tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + QUERY_CHECK_CODE(code, lino, _end); + + code = tNameGetDbName(&sn, varDataVal(dbname)); + QUERY_CHECK_CODE(code, lino, _end); - tNameGetDbName(&sn, varDataVal(dbname)); varDataSetLen(dbname, strlen(varDataVal(dbname))); SSDataBlock* p = buildInfoSchemaTableMetaBlock(TSDB_INS_TABLE_TABLES); - blockDataEnsureCapacity(p, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(p, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _end); char n[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; int32_t i = pIdx->lastIdx; @@ -1191,28 +1326,32 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) { // table name SColumnInfoData* pColInfoData = taosArrayGet(p->pDataBlock, 0); - colDataSetVal(pColInfoData, numOfRows, n, false); + code = colDataSetVal(pColInfoData, numOfRows, n, false); + QUERY_CHECK_CODE(code, lino, _end); // database name pColInfoData = taosArrayGet(p->pDataBlock, 1); - colDataSetVal(pColInfoData, numOfRows, dbname, false); + code = colDataSetVal(pColInfoData, numOfRows, dbname, false); + QUERY_CHECK_CODE(code, lino, _end); // vgId pColInfoData = taosArrayGet(p->pDataBlock, 6); - colDataSetVal(pColInfoData, numOfRows, (char*)&vgId, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&vgId, false); + QUERY_CHECK_CODE(code, lino, _end); int32_t tableType = mr.me.type; if (tableType == TSDB_CHILD_TABLE) { // create time int64_t ts = mr.me.ctbEntry.btime; pColInfoData = taosArrayGet(p->pDataBlock, 2); - colDataSetVal(pColInfoData, numOfRows, (char*)&ts, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&ts, false); + QUERY_CHECK_CODE(code, lino, _end); SMetaReader mr1 = {0}; pAPI->metaReaderFn.initReader(&mr1, pInfo->readHandle.vnode, META_READER_NOLOCK, &pAPI->metaFn); int64_t suid = mr.me.ctbEntry.suid; - int32_t code = pAPI->metaReaderFn.getTableEntryByUid(&mr1, suid); + code = pAPI->metaReaderFn.getTableEntryByUid(&mr1, suid); if (code != TSDB_CODE_SUCCESS) { qError("failed to get super table meta, cname:%s, suid:0x%" PRIx64 ", code:%s, %s", pInfo->pCur->mr.me.name, suid, tstrerror(terrno), GET_TASKID(pTaskInfo)); @@ -1221,12 +1360,14 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) { T_LONG_JMP(pTaskInfo->env, terrno); } pColInfoData = taosArrayGet(p->pDataBlock, 3); - colDataSetVal(pColInfoData, numOfRows, (char*)&mr1.me.stbEntry.schemaRow.nCols, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr1.me.stbEntry.schemaRow.nCols, false); + QUERY_CHECK_CODE(code, lino, _end); // super table name STR_TO_VARSTR(n, mr1.me.name); pColInfoData = taosArrayGet(p->pDataBlock, 4); - colDataSetVal(pColInfoData, numOfRows, n, false); + code = colDataSetVal(pColInfoData, numOfRows, n, false); + QUERY_CHECK_CODE(code, lino, _end); pAPI->metaReaderFn.clearReader(&mr1); // table comment @@ -1234,33 +1375,39 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) { if (mr.me.ctbEntry.commentLen > 0) { char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(comment, mr.me.ctbEntry.comment); - colDataSetVal(pColInfoData, numOfRows, comment, false); + code = colDataSetVal(pColInfoData, numOfRows, comment, false); + QUERY_CHECK_CODE(code, lino, _end); } else if (mr.me.ctbEntry.commentLen == 0) { char comment[VARSTR_HEADER_SIZE + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(comment, ""); - colDataSetVal(pColInfoData, numOfRows, comment, false); + code = colDataSetVal(pColInfoData, numOfRows, comment, false); + QUERY_CHECK_CODE(code, lino, _end); } else { colDataSetNULL(pColInfoData, numOfRows); } // uid pColInfoData = taosArrayGet(p->pDataBlock, 5); - colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.uid, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.uid, false); + QUERY_CHECK_CODE(code, lino, _end); // ttl pColInfoData = taosArrayGet(p->pDataBlock, 7); - colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.ctbEntry.ttlDays, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.ctbEntry.ttlDays, false); + QUERY_CHECK_CODE(code, lino, _end); STR_TO_VARSTR(n, "CHILD_TABLE"); } else if (tableType == TSDB_NORMAL_TABLE) { // create time pColInfoData = taosArrayGet(p->pDataBlock, 2); - colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.btime, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.btime, false); + QUERY_CHECK_CODE(code, lino, _end); // number of columns pColInfoData = taosArrayGet(p->pDataBlock, 3); - colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.schemaRow.nCols, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.schemaRow.nCols, false); + QUERY_CHECK_CODE(code, lino, _end); // super table name pColInfoData = taosArrayGet(p->pDataBlock, 4); @@ -1271,22 +1418,26 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) { if (mr.me.ntbEntry.commentLen > 0) { char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(comment, mr.me.ntbEntry.comment); - colDataSetVal(pColInfoData, numOfRows, comment, false); + code = colDataSetVal(pColInfoData, numOfRows, comment, false); + QUERY_CHECK_CODE(code, lino, _end); } else if (mr.me.ntbEntry.commentLen == 0) { char comment[VARSTR_HEADER_SIZE + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(comment, ""); - colDataSetVal(pColInfoData, numOfRows, comment, false); + code = colDataSetVal(pColInfoData, numOfRows, comment, false); + QUERY_CHECK_CODE(code, lino, _end); } else { colDataSetNULL(pColInfoData, numOfRows); } // uid pColInfoData = taosArrayGet(p->pDataBlock, 5); - colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.uid, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.uid, false); + QUERY_CHECK_CODE(code, lino, _end); // ttl pColInfoData = taosArrayGet(p->pDataBlock, 7); - colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.ntbEntry.ttlDays, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.ntbEntry.ttlDays, false); + QUERY_CHECK_CODE(code, lino, _end); STR_TO_VARSTR(n, "NORMAL_TABLE"); // impl later @@ -1295,14 +1446,18 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) { pAPI->metaReaderFn.clearReader(&mr); pColInfoData = taosArrayGet(p->pDataBlock, 9); - colDataSetVal(pColInfoData, numOfRows, n, false); + code = colDataSetVal(pColInfoData, numOfRows, n, false); + QUERY_CHECK_CODE(code, lino, _end); if (++numOfRows >= pOperator->resultInfo.capacity) { p->info.rows = numOfRows; pInfo->pRes->info.rows = numOfRows; - relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); - doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); blockDataCleanup(p); numOfRows = 0; @@ -1317,8 +1472,11 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) { p->info.rows = numOfRows; pInfo->pRes->info.rows = numOfRows; - relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); - doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); blockDataCleanup(p); numOfRows = 0; @@ -1333,10 +1491,19 @@ static SSDataBlock* sysTableBuildUserTablesByUids(SOperatorInfo* pOperator) { blockDataDestroy(p); pInfo->loadInfo.totalRows += pInfo->pRes->info.rows; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes; } static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SStorageAPI* pAPI = &pTaskInfo->storageAPI; int8_t firstMetaCursor = 0; @@ -1359,13 +1526,19 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) { SName sn = {0}; char dbname[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; - tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); + QUERY_CHECK_CODE(code, lino, _end); + + code = tNameGetDbName(&sn, varDataVal(dbname)); + QUERY_CHECK_CODE(code, lino, _end); - tNameGetDbName(&sn, varDataVal(dbname)); varDataSetLen(dbname, strlen(varDataVal(dbname))); SSDataBlock* p = buildInfoSchemaTableMetaBlock(TSDB_INS_TABLE_TABLES); - blockDataEnsureCapacity(p, pOperator->resultInfo.capacity); + QUERY_CHECK_NULL(p, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + code = blockDataEnsureCapacity(p, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _end); char n[TSDB_TABLE_NAME_LEN + VARSTR_HEADER_SIZE] = {0}; @@ -1375,28 +1548,32 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) { // table name SColumnInfoData* pColInfoData = taosArrayGet(p->pDataBlock, 0); - colDataSetVal(pColInfoData, numOfRows, n, false); + code = colDataSetVal(pColInfoData, numOfRows, n, false); + QUERY_CHECK_CODE(code, lino, _end); // database name pColInfoData = taosArrayGet(p->pDataBlock, 1); - colDataSetVal(pColInfoData, numOfRows, dbname, false); + code = colDataSetVal(pColInfoData, numOfRows, dbname, false); + QUERY_CHECK_CODE(code, lino, _end); // vgId pColInfoData = taosArrayGet(p->pDataBlock, 6); - colDataSetVal(pColInfoData, numOfRows, (char*)&vgId, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&vgId, false); + QUERY_CHECK_CODE(code, lino, _end); int32_t tableType = pInfo->pCur->mr.me.type; if (tableType == TSDB_CHILD_TABLE) { // create time int64_t ts = pInfo->pCur->mr.me.ctbEntry.btime; pColInfoData = taosArrayGet(p->pDataBlock, 2); - colDataSetVal(pColInfoData, numOfRows, (char*)&ts, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&ts, false); + QUERY_CHECK_CODE(code, lino, _end); SMetaReader mr = {0}; pAPI->metaReaderFn.initReader(&mr, pInfo->readHandle.vnode, META_READER_NOLOCK, &pAPI->metaFn); uint64_t suid = pInfo->pCur->mr.me.ctbEntry.suid; - int32_t code = pAPI->metaReaderFn.getTableEntryByUid(&mr, suid); + code = pAPI->metaReaderFn.getTableEntryByUid(&mr, suid); if (code != TSDB_CODE_SUCCESS) { qError("failed to get super table meta, cname:%s, suid:0x%" PRIx64 ", code:%s, %s", pInfo->pCur->mr.me.name, suid, tstrerror(terrno), GET_TASKID(pTaskInfo)); @@ -1413,12 +1590,14 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) { // number of columns pColInfoData = taosArrayGet(p->pDataBlock, 3); - colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.stbEntry.schemaRow.nCols, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&mr.me.stbEntry.schemaRow.nCols, false); + QUERY_CHECK_CODE(code, lino, _end); // super table name STR_TO_VARSTR(n, mr.me.name); pColInfoData = taosArrayGet(p->pDataBlock, 4); - colDataSetVal(pColInfoData, numOfRows, n, false); + code = colDataSetVal(pColInfoData, numOfRows, n, false); + QUERY_CHECK_CODE(code, lino, _end); pAPI->metaReaderFn.clearReader(&mr); // table comment @@ -1426,32 +1605,38 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) { if (pInfo->pCur->mr.me.ctbEntry.commentLen > 0) { char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(comment, pInfo->pCur->mr.me.ctbEntry.comment); - colDataSetVal(pColInfoData, numOfRows, comment, false); + code = colDataSetVal(pColInfoData, numOfRows, comment, false); + QUERY_CHECK_CODE(code, lino, _end); } else if (pInfo->pCur->mr.me.ctbEntry.commentLen == 0) { char comment[VARSTR_HEADER_SIZE + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(comment, ""); - colDataSetVal(pColInfoData, numOfRows, comment, false); + code = colDataSetVal(pColInfoData, numOfRows, comment, false); + QUERY_CHECK_CODE(code, lino, _end); } else { colDataSetNULL(pColInfoData, numOfRows); } // uid pColInfoData = taosArrayGet(p->pDataBlock, 5); - colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.uid, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.uid, false); + QUERY_CHECK_CODE(code, lino, _end); // ttl pColInfoData = taosArrayGet(p->pDataBlock, 7); - colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ctbEntry.ttlDays, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ctbEntry.ttlDays, false); + QUERY_CHECK_CODE(code, lino, _end); STR_TO_VARSTR(n, "CHILD_TABLE"); } else if (tableType == TSDB_NORMAL_TABLE) { // create time pColInfoData = taosArrayGet(p->pDataBlock, 2); - colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.btime, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.btime, false); + QUERY_CHECK_CODE(code, lino, _end); // number of columns pColInfoData = taosArrayGet(p->pDataBlock, 3); - colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.schemaRow.nCols, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.schemaRow.nCols, false); + QUERY_CHECK_CODE(code, lino, _end); // super table name pColInfoData = taosArrayGet(p->pDataBlock, 4); @@ -1462,35 +1647,43 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) { if (pInfo->pCur->mr.me.ntbEntry.commentLen > 0) { char comment[TSDB_TB_COMMENT_LEN + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(comment, pInfo->pCur->mr.me.ntbEntry.comment); - colDataSetVal(pColInfoData, numOfRows, comment, false); + code = colDataSetVal(pColInfoData, numOfRows, comment, false); + QUERY_CHECK_CODE(code, lino, _end); } else if (pInfo->pCur->mr.me.ntbEntry.commentLen == 0) { char comment[VARSTR_HEADER_SIZE + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(comment, ""); - colDataSetVal(pColInfoData, numOfRows, comment, false); + code = colDataSetVal(pColInfoData, numOfRows, comment, false); + QUERY_CHECK_CODE(code, lino, _end); } else { colDataSetNULL(pColInfoData, numOfRows); } // uid pColInfoData = taosArrayGet(p->pDataBlock, 5); - colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.uid, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.uid, false); + QUERY_CHECK_CODE(code, lino, _end); // ttl pColInfoData = taosArrayGet(p->pDataBlock, 7); - colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.ttlDays, false); + code = colDataSetVal(pColInfoData, numOfRows, (char*)&pInfo->pCur->mr.me.ntbEntry.ttlDays, false); + QUERY_CHECK_CODE(code, lino, _end); STR_TO_VARSTR(n, "NORMAL_TABLE"); } pColInfoData = taosArrayGet(p->pDataBlock, 9); - colDataSetVal(pColInfoData, numOfRows, n, false); + code = colDataSetVal(pColInfoData, numOfRows, n, false); + QUERY_CHECK_CODE(code, lino, _end); if (++numOfRows >= pOperator->resultInfo.capacity) { p->info.rows = numOfRows; pInfo->pRes->info.rows = numOfRows; - relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); - doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); blockDataCleanup(p); numOfRows = 0; @@ -1507,8 +1700,11 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) { p->info.rows = numOfRows; pInfo->pRes->info.rows = numOfRows; - relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); - doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = relocateColumnData(pInfo->pRes, pInfo->matchInfo.pList, p->pDataBlock, false); + QUERY_CHECK_CODE(code, lino, _end); + + code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); blockDataCleanup(p); numOfRows = 0; @@ -1524,10 +1720,19 @@ static SSDataBlock* sysTableBuildUserTables(SOperatorInfo* pOperator) { } pInfo->loadInfo.totalRows += pInfo->pRes->info.rows; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return (pInfo->pRes->info.rows == 0) ? NULL : pInfo->pRes; } static SSDataBlock* sysTableScanUserTables(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SSysTableScanInfo* pInfo = pOperator->info; @@ -1538,8 +1743,11 @@ static SSDataBlock* sysTableScanUserTables(SOperatorInfo* pOperator) { // the retrieve is executed on the mnode, so return tables that belongs to the information schema database. if (pInfo->readHandle.mnd != NULL) { - buildSysDbTableInfo(pInfo, pOperator->resultInfo.capacity); - doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = buildSysDbTableInfo(pInfo, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _end); + + code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); pInfo->loadInfo.totalRows += pInfo->pRes->info.rows; setOperatorCompleted(pOperator); @@ -1573,6 +1781,13 @@ static SSDataBlock* sysTableScanUserTables(SOperatorInfo* pOperator) { return sysTableBuildUserTables(pOperator); } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return NULL; } @@ -1657,7 +1872,6 @@ static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator) { char dbName[TSDB_DB_NAME_LEN] = {0}; while (1) { - if (isTaskKilled(pOperator->pTaskInfo)) { setOperatorCompleted(pOperator); return NULL; @@ -1675,7 +1889,7 @@ static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator) { } else if (strncasecmp(name, TSDB_INS_TABLE_COLS, TSDB_TABLE_FNAME_LEN) == 0) { getDBNameFromCondition(pInfo->pCondition, dbName); if (dbName[0]) sprintf(pInfo->req.db, "%d.%s", pInfo->accountId, dbName); - sysTableIsCondOnOneTable(pInfo->pCondition, pInfo->req.filterTb); + (void)sysTableIsCondOnOneTable(pInfo->pCondition, pInfo->req.filterTb); } SSDataBlock* pBlock = NULL; @@ -1686,7 +1900,7 @@ static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator) { } else if (strncasecmp(name, TSDB_INS_TABLE_COLS, TSDB_TABLE_FNAME_LEN) == 0 && pInfo->readHandle.mnd == NULL) { pBlock = sysTableScanUserCols(pOperator); } else if (strncasecmp(name, TSDB_INS_TABLE_STABLES, TSDB_TABLE_FNAME_LEN) == 0 && pInfo->showRewrite && - IS_SYS_DBNAME(dbName)) { + IS_SYS_DBNAME(dbName)) { pBlock = sysTableScanUserSTables(pOperator); } else { // load the meta from mnode of the given epset pBlock = sysTableScanFromMNode(pOperator, pInfo, name, pTaskInfo); @@ -1711,6 +1925,9 @@ static SSDataBlock* doSysTableScan(SOperatorInfo* pOperator) { static void sysTableScanFillTbName(SOperatorInfo* pOperator, const SSysTableScanInfo* pInfo, const char* name, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; if (pBlock == NULL) { return; } @@ -1720,14 +1937,25 @@ static void sysTableScanFillTbName(SOperatorInfo* pOperator, const SSysTableScan char varTbName[TSDB_TABLE_FNAME_LEN - 1 + VARSTR_HEADER_SIZE] = {0}; STR_TO_VARSTR(varTbName, name); - colDataSetNItems(pColumnInfoData, 0, varTbName, pBlock->info.rows, true); + code = colDataSetNItems(pColumnInfoData, 0, varTbName, pBlock->info.rows, true); + QUERY_CHECK_CODE(code, lino, _end); } - doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } } static SSDataBlock* sysTableScanFromMNode(SOperatorInfo* pOperator, SSysTableScanInfo* pInfo, const char* name, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pOperator->status == OP_EXEC_DONE) { return NULL; } @@ -1739,7 +1967,7 @@ static SSDataBlock* sysTableScanFromMNode(SOperatorInfo* pOperator, SSysTableSca int32_t contLen = tSerializeSRetrieveTableReq(NULL, 0, &pInfo->req); char* buf1 = taosMemoryCalloc(1, contLen); - tSerializeSRetrieveTableReq(buf1, contLen, &pInfo->req); + (void)tSerializeSRetrieveTableReq(buf1, contLen, &pInfo->req); // send the fetch remote task result reques SMsgSendInfo* pMsgSendInfo = taosMemoryCalloc(1, sizeof(SMsgSendInfo)); @@ -1760,9 +1988,14 @@ static SSDataBlock* sysTableScanFromMNode(SOperatorInfo* pOperator, SSysTableSca pMsgSendInfo->requestId = pTaskInfo->id.queryId; int64_t transporterId = 0; - int32_t code = - asyncSendMsgToServer(pInfo->readHandle.pMsgCb->clientRpc, &pInfo->epSet, &transporterId, pMsgSendInfo); - tsem_wait(&pInfo->ready); + code = asyncSendMsgToServer(pInfo->readHandle.pMsgCb->clientRpc, &pInfo->epSet, &transporterId, pMsgSendInfo); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } + + (void)tsem_wait(&pInfo->ready); if (pTaskInfo->code) { qError("%s load meta data from mnode failed, totalRows:%" PRIu64 ", code:%s", GET_TASKID(pTaskInfo), @@ -1785,11 +2018,23 @@ static SSDataBlock* sysTableScanFromMNode(SOperatorInfo* pOperator, SSysTableSca } char* pStart = pRsp->data; - extractDataBlockFromFetchRsp(pInfo->pRes, pRsp->data, pInfo->matchInfo.pList, &pStart); + code = extractDataBlockFromFetchRsp(pInfo->pRes, pRsp->data, pInfo->matchInfo.pList, &pStart); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + taosMemoryFreeClear(pRsp); + T_LONG_JMP(pTaskInfo->env, code); + } updateLoadRemoteInfo(&pInfo->loadInfo, pRsp->numOfRows, pRsp->compLen, startTs, pOperator); // todo log the filter info - doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + taosMemoryFreeClear(pRsp); + T_LONG_JMP(pTaskInfo->env, code); + } taosMemoryFree(pRsp); if (pInfo->pRes->info.rows > 0) { return pInfo->pRes; @@ -1802,6 +2047,7 @@ static SSDataBlock* sysTableScanFromMNode(SOperatorInfo* pOperator, SSysTableSca SOperatorInfo* createSysTableScanOperatorInfo(void* readHandle, SSystemTableScanPhysiNode* pScanPhyNode, const char* pUser, SExecTaskInfo* pTaskInfo) { int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SSysTableScanInfo* pInfo = taosMemoryCalloc(1, sizeof(SSysTableScanInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -1828,13 +2074,12 @@ SOperatorInfo* createSysTableScanOperatorInfo(void* readHandle, SSystemTableScan pInfo->pRes = createDataBlockFromDescNode(pDescNode); pInfo->pCondition = pScanNode->node.pConditions; code = filterInitFromNode(pScanNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); initLimitInfo(pScanPhyNode->scan.node.pLimit, pScanPhyNode->scan.node.pSlimit, &pInfo->limitInfo); initResultSizeInfo(&pOperator->resultInfo, 4096); - blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _error); tNameAssign(&pInfo->name, &pScanNode->tableName); const char* name = tNameGetTableName(&pInfo->name); @@ -1843,7 +2088,10 @@ SOperatorInfo* createSysTableScanOperatorInfo(void* readHandle, SSystemTableScan strncasecmp(name, TSDB_INS_TABLE_TAGS, TSDB_TABLE_FNAME_LEN) == 0) { pInfo->readHandle = *(SReadHandle*)readHandle; } else { - tsem_init(&pInfo->ready, 0, 0); + if (tsem_init(&pInfo->ready, 0, 0) != TSDB_CODE_SUCCESS) { + code = TSDB_CODE_FAILED; + goto _error; + } pInfo->epSet = pScanPhyNode->mgmtEpSet; pInfo->readHandle = *(SReadHandle*)readHandle; } @@ -1859,6 +2107,9 @@ _error: if (pInfo != NULL) { destroySysScanOperator(pInfo); } + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } taosMemoryFreeClear(pOperator); pTaskInfo->code = code; return NULL; @@ -1886,7 +2137,7 @@ void extractTbnameSlotId(SSysTableScanInfo* pInfo, const SScanPhysiNode* pScanNo void destroySysScanOperator(void* param) { SSysTableScanInfo* pInfo = (SSysTableScanInfo*)param; - tsem_destroy(&pInfo->ready); + (void)tsem_destroy(&pInfo->ready); blockDataDestroy(pInfo->pRes); const char* name = tNameGetTableName(&pInfo->name); @@ -1938,7 +2189,7 @@ int32_t loadSysTableCallback(void* param, SDataBuf* pMsg, int32_t code) { } } - tsem_post(&pScanResInfo->ready); + (void)tsem_post(&pScanResInfo->ready); return TSDB_CODE_SUCCESS; } @@ -2082,12 +2333,15 @@ static FORCE_INLINE int optSysBinarySearch(SArray* arr, int s, int e, uint64_t k return s; } -void optSysIntersection(SArray* in, SArray* out) { +int32_t optSysIntersection(SArray* in, SArray* out) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; int32_t sz = (int32_t)taosArrayGetSize(in); if (sz <= 0) { - return; + goto _end; } MergeIndex* mi = taosMemoryCalloc(sz, sizeof(MergeIndex)); + QUERY_CHECK_NULL(mi, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); for (int i = 0; i < sz; i++) { SArray* t = taosArrayGetP(in, i); mi[i].len = (int32_t)taosArrayGetSize(t); @@ -2110,10 +2364,20 @@ void optSysIntersection(SArray* in, SArray* out) { } } if (has == true) { - taosArrayPush(out, &tgt); + void* tmp = taosArrayPush(out, &tgt); + if (!tmp) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _end; + } } } + +_end: taosMemoryFreeClear(mi); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static int tableUidCompare(const void* a, const void* b) { @@ -2131,8 +2395,7 @@ static int32_t optSysMergeRslt(SArray* mRslt, SArray* rslt) { SArray* arslt = taosArrayGetP(mRslt, i); taosArraySort(arslt, tableUidCompare); } - optSysIntersection(mRslt, rslt); - return 0; + return optSysIntersection(mRslt, rslt); } static int32_t optSysSpecialColumn(SNode* cond) { @@ -2147,7 +2410,7 @@ static int32_t optSysSpecialColumn(SNode* cond) { } static int32_t optSysTabFilte(void* arg, SNode* cond, SArray* result) { - int ret = -1; + int ret = TSDB_CODE_FAILED; if (nodeType(cond) == QUERY_NODE_OPERATOR) { ret = optSysTabFilteImpl(arg, cond, result); if (ret == 0) { @@ -2185,7 +2448,10 @@ static int32_t optSysTabFilte(void* arg, SNode* cond, SArray* result) { // has index hasIdx = true; if (optSysSpecialColumn(cell->pNode) == 0) { - taosArrayPush(mRslt, &aRslt); + void* tmp = taosArrayPush(mRslt, &aRslt); + if (!tmp) { + return TSDB_CODE_FAILED; + } } else { // db_name/vgroup not result taosArrayDestroy(aRslt); @@ -2202,7 +2468,10 @@ static int32_t optSysTabFilte(void* arg, SNode* cond, SArray* result) { cell = cell->pNext; } if (hasRslt && hasIdx) { - optSysMergeRslt(mRslt, result); + int32_t code = optSysMergeRslt(mRslt, result); + if (code != TSDB_CODE_SUCCESS) { + return code; + } } for (int i = 0; i < taosArrayGetSize(mRslt); i++) { @@ -2273,6 +2542,8 @@ static int32_t doGetTableRowSize(SReadHandle* pHandle, uint64_t uid, int32_t* ro } static SSDataBlock* doBlockInfoScan(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pOperator->status == OP_EXEC_DONE) { return NULL; } @@ -2282,13 +2553,13 @@ static SSDataBlock* doBlockInfoScan(SOperatorInfo* pOperator) { SStorageAPI* pAPI = &pTaskInfo->storageAPI; STableBlockDistInfo blockDistInfo = {.minRows = INT_MAX, .maxRows = INT_MIN}; - int32_t code = doGetTableRowSize(&pBlockScanInfo->readHandle, pBlockScanInfo->uid, (int32_t*)&blockDistInfo.rowSize, - GET_TASKID(pTaskInfo)); - if (code != TSDB_CODE_SUCCESS) { - T_LONG_JMP(pTaskInfo->env, code); - } + code = doGetTableRowSize(&pBlockScanInfo->readHandle, pBlockScanInfo->uid, (int32_t*)&blockDistInfo.rowSize, + GET_TASKID(pTaskInfo)); + QUERY_CHECK_CODE(code, lino, _end); + + code = pAPI->tsdReader.tsdReaderGetDataBlockDistInfo(pBlockScanInfo->pHandle, &blockDistInfo); + QUERY_CHECK_CODE(code, lino, _end); - pAPI->tsdReader.tsdReaderGetDataBlockDistInfo(pBlockScanInfo->pHandle, &blockDistInfo); blockDistInfo.numOfInmemRows = (int32_t)pAPI->tsdReader.tsdReaderGetNumOfInMemRows(pBlockScanInfo->pHandle); SSDataBlock* pBlock = pBlockScanInfo->pResBlock; @@ -2298,10 +2569,15 @@ static SSDataBlock* doBlockInfoScan(SOperatorInfo* pOperator) { int32_t len = tSerializeBlockDistInfo(NULL, 0, &blockDistInfo); char* p = taosMemoryCalloc(1, len + VARSTR_HEADER_SIZE); - tSerializeBlockDistInfo(varDataVal(p), len, &blockDistInfo); + QUERY_CHECK_NULL(p, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + code = tSerializeBlockDistInfo(varDataVal(p), len, &blockDistInfo); + QUERY_CHECK_CODE(code, lino, _end); varDataSetLen(p, len); - colDataSetVal(pColInfo, 0, p, false); + code = colDataSetVal(pColInfo, 0, p, false); + QUERY_CHECK_CODE(code, lino, _end); + taosMemoryFree(p); // make the valgrind happy that all memory buffer has been initialized already. @@ -2313,6 +2589,13 @@ static SSDataBlock* doBlockInfoScan(SOperatorInfo* pOperator) { pBlock->info.rows = 1; pOperator->status = OP_EXEC_DONE; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return pBlock; } @@ -2354,6 +2637,8 @@ static int32_t initTableblockDistQueryCond(uint64_t uid, SQueryTableDataCond* pC SOperatorInfo* createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDistScanPhysiNode* pBlockScanNode, STableListInfo* pTableListInfo, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SBlockDistInfo* pInfo = taosMemoryCalloc(1, sizeof(SBlockDistInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pInfo == NULL || pOperator == NULL) { @@ -2362,14 +2647,13 @@ SOperatorInfo* createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDi } pInfo->pResBlock = createDataBlockFromDescNode(pBlockScanNode->node.pOutputDataBlockDesc); - blockDataEnsureCapacity(pInfo->pResBlock, 1); + code = blockDataEnsureCapacity(pInfo->pResBlock, 1); + QUERY_CHECK_CODE(code, lino, _error); { SQueryTableDataCond cond = {0}; - int32_t code = initTableblockDistQueryCond(pBlockScanNode->suid, &cond); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + code = initTableblockDistQueryCond(pBlockScanNode->suid, &cond); + QUERY_CHECK_CODE(code, lino, _error); pInfo->pTableListInfo = pTableListInfo; size_t num = tableListGetSize(pTableListInfo); @@ -2378,9 +2662,7 @@ SOperatorInfo* createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDi code = readHandle->api.tsdReader.tsdReaderOpen(readHandle->vnode, &cond, pList, num, pInfo->pResBlock, (void**)&pInfo->pHandle, pTaskInfo->id.str, NULL); cleanupQueryTableDataCond(&cond); - if (code != 0) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); } pInfo->readHandle = *readHandle; @@ -2388,10 +2670,8 @@ SOperatorInfo* createDataBlockInfoScanOperator(SReadHandle* readHandle, SBlockDi int32_t numOfCols = 0; SExprInfo* pExprInfo = createExprInfo(pBlockScanNode->pScanPseudoCols, NULL, &numOfCols); - int32_t code = initExprSupp(&pOperator->exprSupp, pExprInfo, numOfCols, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + code = initExprSupp(&pOperator->exprSupp, pExprInfo, numOfCols, &pTaskInfo->storageAPI.functionStore); + QUERY_CHECK_CODE(code, lino, _error); setOperatorInfo(pOperator, "DataBlockDistScanOperator", QUERY_NODE_PHYSICAL_PLAN_BLOCK_DIST_SCAN, false, OP_NOT_OPENED, pInfo, pTaskInfo); diff --git a/source/libs/executor/src/tfill.c b/source/libs/executor/src/tfill.c index 5a8697d7b8..3a024bc22d 100644 --- a/source/libs/executor/src/tfill.c +++ b/source/libs/executor/src/tfill.c @@ -28,6 +28,7 @@ #include "executorInt.h" #include "function.h" #include "querynodes.h" +#include "querytask.h" #include "tdatablock.h" #include "tfill.h" @@ -35,7 +36,7 @@ #define DO_INTERPOLATION(_v1, _v2, _k1, _k2, _k) \ ((_v1) + ((_v2) - (_v1)) * (((double)(_k)) - ((double)(_k1))) / (((double)(_k2)) - ((double)(_k1)))) -static void doSetVal(SColumnInfoData* pDstColInfoData, int32_t rowIndex, const SGroupKeys* pKey); +static int32_t doSetVal(SColumnInfoData* pDstColInfoData, int32_t rowIndex, const SGroupKeys* pKey); static void setNotFillColumn(SFillInfo* pFillInfo, SColumnInfoData* pDstColInfo, int32_t rowIndex, int32_t colIdx) { SRowVal* p = NULL; @@ -46,7 +47,11 @@ static void setNotFillColumn(SFillInfo* pFillInfo, SColumnInfoData* pDstColInfo, } SGroupKeys* pKey = taosArrayGet(p->pRowVal, colIdx); - doSetVal(pDstColInfo, rowIndex, pKey); + int32_t code = doSetVal(pDstColInfo, rowIndex, pKey); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pFillInfo->pTaskInfo->env, code); + } } static void setNullRow(SSDataBlock* pBlock, SFillInfo* pFillInfo, int32_t rowIndex) { @@ -65,39 +70,55 @@ static void setNullRow(SSDataBlock* pBlock, SFillInfo* pFillInfo, int32_t rowInd } } -static void doSetUserSpecifiedValue(SColumnInfoData* pDst, SVariant* pVar, int32_t rowIndex, int64_t currentKey) { - bool isNull = (TSDB_DATA_TYPE_NULL == pVar->nType) ? true : false; +static int32_t doSetUserSpecifiedValue(SColumnInfoData* pDst, SVariant* pVar, int32_t rowIndex, int64_t currentKey) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + bool isNull = (TSDB_DATA_TYPE_NULL == pVar->nType) ? true : false; if (pDst->info.type == TSDB_DATA_TYPE_FLOAT) { float v = 0; GET_TYPED_DATA(v, float, pVar->nType, &pVar->f); - colDataSetVal(pDst, rowIndex, (char*)&v, isNull); + code = colDataSetVal(pDst, rowIndex, (char*)&v, isNull); + QUERY_CHECK_CODE(code, lino, _end); } else if (pDst->info.type == TSDB_DATA_TYPE_DOUBLE) { double v = 0; GET_TYPED_DATA(v, double, pVar->nType, &pVar->d); - colDataSetVal(pDst, rowIndex, (char*)&v, isNull); + code = colDataSetVal(pDst, rowIndex, (char*)&v, isNull); + QUERY_CHECK_CODE(code, lino, _end); } else if (IS_SIGNED_NUMERIC_TYPE(pDst->info.type) || pDst->info.type == TSDB_DATA_TYPE_BOOL) { int64_t v = 0; GET_TYPED_DATA(v, int64_t, pVar->nType, &pVar->i); - colDataSetVal(pDst, rowIndex, (char*)&v, isNull); + code = colDataSetVal(pDst, rowIndex, (char*)&v, isNull); + QUERY_CHECK_CODE(code, lino, _end); } else if (IS_UNSIGNED_NUMERIC_TYPE(pDst->info.type)) { uint64_t v = 0; GET_TYPED_DATA(v, uint64_t, pVar->nType, &pVar->u); - colDataSetVal(pDst, rowIndex, (char*)&v, isNull); + code = colDataSetVal(pDst, rowIndex, (char*)&v, isNull); + QUERY_CHECK_CODE(code, lino, _end); } else if (pDst->info.type == TSDB_DATA_TYPE_TIMESTAMP) { int64_t v = 0; GET_TYPED_DATA(v, int64_t, pVar->nType, &pVar->u); - colDataSetVal(pDst, rowIndex, (const char*)&v, isNull); + code = colDataSetVal(pDst, rowIndex, (const char*)&v, isNull); + QUERY_CHECK_CODE(code, lino, _end); } else if (pDst->info.type == TSDB_DATA_TYPE_NCHAR || pDst->info.type == TSDB_DATA_TYPE_VARCHAR || pDst->info.type == TSDB_DATA_TYPE_VARBINARY) { - colDataSetVal(pDst, rowIndex, pVar->pz, isNull); + code = colDataSetVal(pDst, rowIndex, pVar->pz, isNull); + QUERY_CHECK_CODE(code, lino, _end); } else { // others data colDataSetNULL(pDst, rowIndex); } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } // fill windows pseudo column, _wstart, _wend, _wduration and return true, otherwise return false bool fillIfWindowPseudoColumn(SFillInfo* pFillInfo, SFillColInfo* pCol, SColumnInfoData* pDstColInfoData, int32_t rowIndex) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (!pCol->notFillCol) { return false; } @@ -106,26 +127,37 @@ bool fillIfWindowPseudoColumn(SFillInfo* pFillInfo, SFillColInfo* pCol, SColumnI return false; } if (pCol->pExpr->base.pParam[0].pCol->colType == COLUMN_TYPE_WINDOW_START) { - colDataSetVal(pDstColInfoData, rowIndex, (const char*)&pFillInfo->currentKey, false); + code = colDataSetVal(pDstColInfoData, rowIndex, (const char*)&pFillInfo->currentKey, false); + QUERY_CHECK_CODE(code, lino, _end); return true; } else if (pCol->pExpr->base.pParam[0].pCol->colType == COLUMN_TYPE_WINDOW_END) { // TODO: include endpoint SInterval* pInterval = &pFillInfo->interval; int64_t windowEnd = taosTimeAdd(pFillInfo->currentKey, pInterval->interval, pInterval->intervalUnit, pInterval->precision); - colDataSetVal(pDstColInfoData, rowIndex, (const char*)&windowEnd, false); + code = colDataSetVal(pDstColInfoData, rowIndex, (const char*)&windowEnd, false); + QUERY_CHECK_CODE(code, lino, _end); return true; } else if (pCol->pExpr->base.pParam[0].pCol->colType == COLUMN_TYPE_WINDOW_DURATION) { // TODO: include endpoint - colDataSetVal(pDstColInfoData, rowIndex, (const char*)&pFillInfo->interval.sliding, false); + code = colDataSetVal(pDstColInfoData, rowIndex, (const char*)&pFillInfo->interval.sliding, false); + QUERY_CHECK_CODE(code, lino, _end); return true; } } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pFillInfo->pTaskInfo->env, code); + } return false; } static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock* pSrcBlock, int64_t ts, bool outOfBound) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SPoint point1, point2, point; int32_t step = GET_FORWARD_DIRECTION_FACTOR(pFillInfo->order); @@ -171,7 +203,7 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock* setNotFillColumn(pFillInfo, pDstCol, index, i); } } else { - SRowVal* pRVal = FILL_IS_ASC_FILL(pFillInfo) ? &pFillInfo->prev : &pFillInfo->next; + SRowVal* pRVal = FILL_IS_ASC_FILL(pFillInfo) ? &pFillInfo->prev : &pFillInfo->next; SGroupKeys* pKey = taosArrayGet(pRVal->pRowVal, i); if (IS_VAR_DATA_TYPE(type) || type == TSDB_DATA_TYPE_BOOL || pKey->isNull) { colDataSetNULL(pDstCol, index); @@ -193,7 +225,8 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock* point = (SPoint){.key = pFillInfo->currentKey, .val = &out}; taosGetLinearInterpolationVal(&point, type, &point1, &point2, type); - colDataSetVal(pDstCol, index, (const char*)&out, false); + code = colDataSetVal(pDstCol, index, (const char*)&out, false); + QUERY_CHECK_CODE(code, lino, _end); } } } @@ -213,7 +246,8 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock* } } else { SVariant* pVar = &pFillInfo->pFillCol[i].fillVal; - doSetUserSpecifiedValue(pDst, pVar, index, pFillInfo->currentKey); + code = doSetUserSpecifiedValue(pDst, pVar, index, pFillInfo->currentKey); + QUERY_CHECK_CODE(code, lino, _end); } } } @@ -224,19 +258,36 @@ static void doFillOneRow(SFillInfo* pFillInfo, SSDataBlock* pBlock, SSDataBlock* taosTimeAdd(pFillInfo->currentKey, pInterval->sliding * step, pInterval->slidingUnit, pInterval->precision); pBlock->info.rows += 1; pFillInfo->numOfCurrent++; -} -void doSetVal(SColumnInfoData* pDstCol, int32_t rowIndex, const SGroupKeys* pKey) { - if (pKey->isNull) { - colDataSetNULL(pDstCol, rowIndex); - } else { - colDataSetVal(pDstCol, rowIndex, pKey->pData, false); +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + T_LONG_JMP(pFillInfo->pTaskInfo->env, code); } } -static void initBeforeAfterDataBuf(SFillInfo* pFillInfo) { +int32_t doSetVal(SColumnInfoData* pDstCol, int32_t rowIndex, const SGroupKeys* pKey) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + if (pKey->isNull) { + colDataSetNULL(pDstCol, rowIndex); + } else { + code = colDataSetVal(pDstCol, rowIndex, pKey->pData, false); + QUERY_CHECK_CODE(code, lino, _end); + } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; +} + +static int32_t initBeforeAfterDataBuf(SFillInfo* pFillInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (taosArrayGetSize(pFillInfo->next.pRowVal) > 0) { - return; + goto _end; } for (int i = 0; i < pFillInfo->numOfCols; i++) { @@ -245,15 +296,26 @@ static void initBeforeAfterDataBuf(SFillInfo* pFillInfo) { SGroupKeys key = {0}; SResSchema* pSchema = &pCol->pExpr->base.resSchema; key.pData = taosMemoryMalloc(pSchema->bytes); + QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); key.isNull = true; key.bytes = pSchema->bytes; key.type = pSchema->type; - taosArrayPush(pFillInfo->next.pRowVal, &key); + void* tmp = taosArrayPush(pFillInfo->next.pRowVal, &key); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); key.pData = taosMemoryMalloc(pSchema->bytes); - taosArrayPush(pFillInfo->prev.pRowVal, &key); + QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + tmp = taosArrayPush(pFillInfo->prev.pRowVal, &key); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static void saveColData(SArray* rowBuf, int32_t columnIndex, const char* src, bool isNull); @@ -264,7 +326,7 @@ static void copyCurrentRowIntoBuf(SFillInfo* pFillInfo, int32_t rowIndex, SRowVa for (int32_t i = 0; i < pFillInfo->numOfCols; ++i) { int32_t type = pFillInfo->pFillCol[i].pExpr->pExpr->nodeType; - if ( type == QUERY_NODE_COLUMN || type == QUERY_NODE_OPERATOR || type == QUERY_NODE_FUNCTION) { + if (type == QUERY_NODE_COLUMN || type == QUERY_NODE_OPERATOR || type == QUERY_NODE_FUNCTION) { if (!pFillInfo->pFillCol[i].notFillCol && pFillInfo->type != TSDB_FILL_NEXT) { continue; } @@ -288,7 +350,8 @@ static void copyCurrentRowIntoBuf(SFillInfo* pFillInfo, int32_t rowIndex, SRowVa static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t outputRows) { pFillInfo->numOfCurrent = 0; - + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SColumnInfoData* pTsCol = taosArrayGet(pFillInfo->pSrcBlock->pDataBlock, pFillInfo->srcTsSlotId); int32_t step = GET_FORWARD_DIRECTION_FACTOR(pFillInfo->order); @@ -321,7 +384,7 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t // output buffer is full, abort if (pFillInfo->numOfCurrent == outputRows) { pFillInfo->numOfTotal += pFillInfo->numOfCurrent; - return outputRows; + goto _end; } } else { ASSERT(pFillInfo->currentKey == ts); @@ -348,7 +411,8 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t char* src = colDataGetData(pSrc, pFillInfo->index); if (!colDataIsNull_s(pSrc, pFillInfo->index)) { - colDataSetVal(pDst, index, src, false); + code = colDataSetVal(pDst, index, src, false); + QUERY_CHECK_CODE(code, lino, _end); SRowVal* pRVal = FILL_IS_ASC_FILL(pFillInfo) ? &pFillInfo->prev : &pFillInfo->next; saveColData(pRVal->pRowVal, i, src, false); if (pFillInfo->srcTsSlotId == dstSlotId) { @@ -356,15 +420,19 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t } } else { // the value is null if (pDst->info.type == TSDB_DATA_TYPE_TIMESTAMP) { - colDataSetVal(pDst, index, (const char*)&pFillInfo->currentKey, false); + code = colDataSetVal(pDst, index, (const char*)&pFillInfo->currentKey, false); + QUERY_CHECK_CODE(code, lino, _end); } else { // i > 0 and data is null , do interpolation if (pFillInfo->type == TSDB_FILL_PREV) { SArray* p = FILL_IS_ASC_FILL(pFillInfo) ? pFillInfo->prev.pRowVal : pFillInfo->next.pRowVal; SGroupKeys* pKey = taosArrayGet(p, i); - doSetVal(pDst, index, pKey); + code = doSetVal(pDst, index, pKey); + QUERY_CHECK_CODE(code, lino, _end); } else if (pFillInfo->type == TSDB_FILL_LINEAR) { bool isNull = colDataIsNull_s(pSrc, pFillInfo->index); - colDataSetVal(pDst, index, src, isNull); + code = colDataSetVal(pDst, index, src, isNull); + QUERY_CHECK_CODE(code, lino, _end); + SArray* p = FILL_IS_ASC_FILL(pFillInfo) ? pFillInfo->prev.pRowVal : pFillInfo->next.pRowVal; saveColData(p, i, src, isNull); // todo: } else if (pFillInfo->type == TSDB_FILL_NULL || pFillInfo->type == TSDB_FILL_NULL_F) { @@ -372,10 +440,12 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t } else if (pFillInfo->type == TSDB_FILL_NEXT) { SArray* p = FILL_IS_ASC_FILL(pFillInfo) ? pFillInfo->next.pRowVal : pFillInfo->prev.pRowVal; SGroupKeys* pKey = taosArrayGet(p, i); - doSetVal(pDst, index, pKey); + code = doSetVal(pDst, index, pKey); + QUERY_CHECK_CODE(code, lino, _end); } else { SVariant* pVar = &pFillInfo->pFillCol[i].fillVal; - doSetUserSpecifiedValue(pDst, pVar, index, pFillInfo->currentKey); + code = doSetUserSpecifiedValue(pDst, pVar, index, pFillInfo->currentKey); + QUERY_CHECK_CODE(code, lino, _end); } } } @@ -393,11 +463,15 @@ static int32_t fillResultImpl(SFillInfo* pFillInfo, SSDataBlock* pBlock, int32_t if (pFillInfo->index >= pFillInfo->numOfRows || pFillInfo->numOfCurrent >= outputRows) { pFillInfo->numOfTotal += pFillInfo->numOfCurrent; - return pFillInfo->numOfCurrent; + goto _end; } } - return pFillInfo->numOfCurrent; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static void saveColData(SArray* rowBuf, int32_t columnIndex, const char* src, bool isNull) { @@ -414,7 +488,7 @@ static void saveColData(SArray* rowBuf, int32_t columnIndex, const char* src, bo } } -static int64_t appendFilledResult(SFillInfo* pFillInfo, SSDataBlock* pBlock, int64_t resultCapacity) { +static void appendFilledResult(SFillInfo* pFillInfo, SSDataBlock* pBlock, int64_t resultCapacity) { /* * These data are generated according to fill strategy, since the current timestamp is out of the time window of * real result set. Note that we need to keep the direct previous result rows, to generated the filled data. @@ -427,7 +501,6 @@ static int64_t appendFilledResult(SFillInfo* pFillInfo, SSDataBlock* pBlock, int pFillInfo->numOfTotal += pFillInfo->numOfCurrent; ASSERT(pFillInfo->numOfCurrent == resultCapacity); - return resultCapacity; } static int32_t taosNumOfRemainRows(SFillInfo* pFillInfo) { @@ -440,7 +513,9 @@ static int32_t taosNumOfRemainRows(SFillInfo* pFillInfo) { struct SFillInfo* taosCreateFillInfo(TSKEY skey, int32_t numOfFillCols, int32_t numOfNotFillCols, int32_t capacity, SInterval* pInterval, int32_t fillType, struct SFillColInfo* pCol, - int32_t primaryTsSlotId, int32_t order, const char* id) { + int32_t primaryTsSlotId, int32_t order, const char* id, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (fillType == TSDB_FILL_NONE) { return NULL; } @@ -473,9 +548,23 @@ struct SFillInfo* taosCreateFillInfo(TSKEY skey, int32_t numOfFillCols, int32_t pFillInfo->interval = *pInterval; pFillInfo->next.pRowVal = taosArrayInit(pFillInfo->numOfCols, sizeof(SGroupKeys)); - pFillInfo->prev.pRowVal = taosArrayInit(pFillInfo->numOfCols, sizeof(SGroupKeys)); + QUERY_CHECK_NULL(pFillInfo->next.pRowVal, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); - initBeforeAfterDataBuf(pFillInfo); + pFillInfo->prev.pRowVal = taosArrayInit(pFillInfo->numOfCols, sizeof(SGroupKeys)); + QUERY_CHECK_NULL(pFillInfo->prev.pRowVal, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + code = initBeforeAfterDataBuf(pFillInfo); + QUERY_CHECK_CODE(code, lino, _end); + + pFillInfo->pTaskInfo = pTaskInfo; + +_end: + if (code != TSDB_CODE_SUCCESS) { + taosArrayDestroy(pFillInfo->next.pRowVal); + taosArrayDestroy(pFillInfo->prev.pRowVal); + terrno = TSDB_CODE_OUT_OF_MEMORY; + return NULL; + } return pFillInfo; } @@ -559,7 +648,7 @@ void taosFillUpdateStartTimestampInfo(SFillInfo* pFillInfo, int64_t ts) { pFillInfo->currentKey = ts; } -bool taosFillNotStarted(const SFillInfo* pFillInfo) {return pFillInfo->start == pFillInfo->currentKey;} +bool taosFillNotStarted(const SFillInfo* pFillInfo) { return pFillInfo->start == pFillInfo->currentKey; } bool taosFillHasMoreResults(SFillInfo* pFillInfo) { int32_t remain = taosNumOfRemainRows(pFillInfo); @@ -577,16 +666,17 @@ bool taosFillHasMoreResults(SFillInfo* pFillInfo) { } int64_t getNumOfResultsAfterFillGap(SFillInfo* pFillInfo, TSKEY ekey, int32_t maxNumOfRows) { - int32_t numOfRows = taosNumOfRemainRows(pFillInfo); + int32_t numOfRows = taosNumOfRemainRows(pFillInfo); TSKEY ekey1 = ekey; int64_t numOfRes = -1; if (numOfRows > 0) { // still fill gap within current data block, not generating data after the result set. - SColumnInfoData* pCol = taosArrayGet(pFillInfo->pSrcBlock->pDataBlock, pFillInfo->srcTsSlotId); - int64_t* tsList = (int64_t*)pCol->pData; - TSKEY lastKey = tsList[pFillInfo->numOfRows - 1]; - numOfRes = taosTimeCountIntervalForFill(lastKey, pFillInfo->currentKey, pFillInfo->interval.sliding, + SColumnInfoData* pCol = taosArrayGet(pFillInfo->pSrcBlock->pDataBlock, pFillInfo->srcTsSlotId); + int64_t* tsList = (int64_t*)pCol->pData; + TSKEY lastKey = tsList[pFillInfo->numOfRows - 1]; + numOfRes = + taosTimeCountIntervalForFill(lastKey, pFillInfo->currentKey, pFillInfo->interval.sliding, pFillInfo->interval.slidingUnit, pFillInfo->interval.precision, pFillInfo->order); ASSERT(numOfRes >= numOfRows); } else { // reach the end of data @@ -595,7 +685,8 @@ int64_t getNumOfResultsAfterFillGap(SFillInfo* pFillInfo, TSKEY ekey, int32_t ma return 0; } - numOfRes = taosTimeCountIntervalForFill(ekey1, pFillInfo->currentKey, pFillInfo->interval.sliding, + numOfRes = + taosTimeCountIntervalForFill(ekey1, pFillInfo->currentKey, pFillInfo->interval.sliding, pFillInfo->interval.slidingUnit, pFillInfo->interval.precision, pFillInfo->order); } @@ -603,7 +694,7 @@ int64_t getNumOfResultsAfterFillGap(SFillInfo* pFillInfo, TSKEY ekey, int32_t ma } void taosGetLinearInterpolationVal(SPoint* point, int32_t outputType, SPoint* point1, SPoint* point2, - int32_t inputType) { + int32_t inputType) { double v1 = -1, v2 = -1; GET_TYPED_DATA(v1, double, inputType, point1->val); GET_TYPED_DATA(v2, double, inputType, point2->val); @@ -617,7 +708,8 @@ void taosGetLinearInterpolationVal(SPoint* point, int32_t outputType, SPoint* po SET_TYPED_DATA(point->val, outputType, r); } -void taosFillResultDataBlock(SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity) { +int32_t taosFillResultDataBlock(SFillInfo* pFillInfo, SSDataBlock* p, int32_t capacity) { + int32_t code = TSDB_CODE_SUCCESS; int32_t remain = taosNumOfRemainRows(pFillInfo); int64_t numOfRes = getNumOfResultsAfterFillGap(pFillInfo, pFillInfo->end, capacity); @@ -627,7 +719,7 @@ void taosFillResultDataBlock(SFillInfo* pFillInfo, SSDataBlock* p, int32_t capac if (remain == 0) { appendFilledResult(pFillInfo, p, numOfRes); } else { - fillResultImpl(pFillInfo, p, (int32_t)numOfRes); + code = fillResultImpl(pFillInfo, p, (int32_t)numOfRes); ASSERT(numOfRes == pFillInfo->numOfCurrent); } @@ -635,6 +727,7 @@ void taosFillResultDataBlock(SFillInfo* pFillInfo, SSDataBlock* p, int32_t capac ", current : % d, total : % d, %s", pFillInfo, pFillInfo->numOfRows, pFillInfo->index, pFillInfo->start, pFillInfo->end, pFillInfo->currentKey, pFillInfo->numOfCurrent, pFillInfo->numOfTotal, pFillInfo->id); + return code; } int64_t getFillInfoStart(struct SFillInfo* pFillInfo) { return pFillInfo->start; } diff --git a/source/libs/executor/src/timesliceoperator.c b/source/libs/executor/src/timesliceoperator.c index e5a1bd0701..c2e7b16dea 100644 --- a/source/libs/executor/src/timesliceoperator.c +++ b/source/libs/executor/src/timesliceoperator.c @@ -44,8 +44,8 @@ typedef struct STimeSliceOperatorInfo { uint64_t groupId; SGroupKeys* pPrevGroupKey; SSDataBlock* pNextGroupRes; - SSDataBlock* pRemainRes; // save block unfinished processing - int32_t remainIndex; // the remaining index in the block to be processed + SSDataBlock* pRemainRes; // save block unfinished processing + int32_t remainIndex; // the remaining index in the block to be processed bool hasPk; SColumn pkCol; } STimeSliceOperatorInfo; @@ -163,18 +163,22 @@ static FORCE_INLINE int32_t timeSliceEnsureBlockCapacity(STimeSliceOperatorInfo* uint32_t winNum = (pSliceInfo->win.ekey - pSliceInfo->win.skey) / pSliceInfo->interval.interval; uint32_t newRowsNum = pBlock->info.rows + TMIN(winNum / 4 + 1, 1048576); - blockDataEnsureCapacity(pBlock, newRowsNum); + int32_t code = blockDataEnsureCapacity(pBlock, newRowsNum); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } return TSDB_CODE_SUCCESS; } static bool isIrowtsPseudoColumn(SExprInfo* pExprInfo) { - char *name = pExprInfo->pExpr->_function.functionName; + char* name = pExprInfo->pExpr->_function.functionName; return (IS_TIMESTAMP_TYPE(pExprInfo->base.resSchema.type) && strcasecmp(name, "_irowts") == 0); } static bool isIsfilledPseudoColumn(SExprInfo* pExprInfo) { - char *name = pExprInfo->pExpr->_function.functionName; + char* name = pExprInfo->pExpr->_function.functionName; return (IS_BOOLEAN_TYPE(pExprInfo->base.resSchema.type) && strcasecmp(name, "_isfilled") == 0); } @@ -202,7 +206,7 @@ static bool checkDuplicateTimestamps(STimeSliceOperatorInfo* pSliceInfo, SColumn return false; } - SRowKey cur = {.ts = currentTs, .numOfPKs = (pPkCol != NULL)? 1:0}; + SRowKey cur = {.ts = currentTs, .numOfPKs = (pPkCol != NULL) ? 1 : 0}; if (pPkCol != NULL) { cur.pks[0].type = pPkCol->info.type; if (IS_VAR_DATA_TYPE(pPkCol->info.type)) { @@ -244,7 +248,7 @@ static bool getIgoreNullRes(SExprSupp* pExprSup) { if (isInterpFunc(pExprInfo)) { for (int32_t j = 0; j < pExprInfo->base.numOfParams; ++j) { - SFunctParam *pFuncParam = &pExprInfo->base.pParam[j]; + SFunctParam* pFuncParam = &pExprInfo->base.pParam[j]; if (pFuncParam->type == FUNC_PARAM_TYPE_VALUE) { return pFuncParam->param.i ? true : false; } @@ -264,7 +268,7 @@ static bool checkNullRow(SExprSupp* pExprSup, SSDataBlock* pSrcBlock, int32_t in SExprInfo* pExprInfo = &pExprSup->pExprInfo[j]; if (isInterpFunc(pExprInfo)) { - int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId; + int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId; SColumnInfoData* pSrc = taosArrayGet(pSrcBlock->pDataBlock, srcSlot); if (colDataIsNull_s(pSrc, index)) { @@ -276,34 +280,37 @@ static bool checkNullRow(SExprSupp* pExprSup, SSDataBlock* pSrcBlock, int32_t in return false; } - static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp* pExprSup, SSDataBlock* pResBlock, - SSDataBlock* pSrcBlock, int32_t index, bool beforeTs) { + SSDataBlock* pSrcBlock, int32_t index, bool beforeTs, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; int32_t rows = pResBlock->info.rows; - timeSliceEnsureBlockCapacity(pSliceInfo, pResBlock); + code = timeSliceEnsureBlockCapacity(pSliceInfo, pResBlock); + QUERY_CHECK_CODE(code, lino, _end); // todo set the correct primary timestamp column - // output the result int32_t fillColIndex = 0; - bool hasInterp = true; + bool hasInterp = true; for (int32_t j = 0; j < pExprSup->numOfExprs; ++j) { SExprInfo* pExprInfo = &pExprSup->pExprInfo[j]; - int32_t dstSlot = pExprInfo->base.resSchema.slotId; + int32_t dstSlot = pExprInfo->base.resSchema.slotId; SColumnInfoData* pDst = taosArrayGet(pResBlock->pDataBlock, dstSlot); if (isIrowtsPseudoColumn(pExprInfo)) { - colDataSetVal(pDst, rows, (char*)&pSliceInfo->current, false); + code = colDataSetVal(pDst, rows, (char*)&pSliceInfo->current, false); + QUERY_CHECK_CODE(code, lino, _end); continue; } else if (isIsfilledPseudoColumn(pExprInfo)) { bool isFilled = true; - colDataSetVal(pDst, pResBlock->info.rows, (char*)&isFilled, false); + code = colDataSetVal(pDst, pResBlock->info.rows, (char*)&isFilled, false); + QUERY_CHECK_CODE(code, lino, _end); continue; } else if (!isInterpFunc(pExprInfo)) { if (isGroupKeyFunc(pExprInfo) || isSelectGroupConstValueFunc(pExprInfo)) { if (pSrcBlock != NULL) { - int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId; + int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId; SColumnInfoData* pSrc = taosArrayGet(pSrcBlock->pDataBlock, srcSlot); if (colDataIsNull_s(pSrc, index)) { @@ -312,12 +319,14 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp } char* v = colDataGetData(pSrc, index); - colDataSetVal(pDst, pResBlock->info.rows, v, false); + code = colDataSetVal(pDst, pResBlock->info.rows, v, false); + QUERY_CHECK_CODE(code, lino, _end); } else if(!isSelectGroupConstValueFunc(pExprInfo)){ // use stored group key SGroupKeys* pkey = pSliceInfo->pPrevGroupKey; if (pkey->isNull == false) { - colDataSetVal(pDst, rows, pkey->pData, false); + code = colDataSetVal(pDst, rows, pkey->pData, false); + QUERY_CHECK_CODE(code, lino, _end); } else { colDataSetNULL(pDst, rows); } @@ -354,7 +363,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp } else { v = taosStr2Float(varDataVal(pVar->pz), NULL); } - colDataSetVal(pDst, rows, (char*)&v, isNull); + code = colDataSetVal(pDst, rows, (char*)&v, isNull); + QUERY_CHECK_CODE(code, lino, _end); } else if (pDst->info.type == TSDB_DATA_TYPE_DOUBLE) { double v = 0; if (!IS_VAR_DATA_TYPE(pVar->nType)) { @@ -362,7 +372,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp } else { v = taosStr2Double(varDataVal(pVar->pz), NULL); } - colDataSetVal(pDst, rows, (char*)&v, isNull); + code = colDataSetVal(pDst, rows, (char*)&v, isNull); + QUERY_CHECK_CODE(code, lino, _end); } else if (IS_SIGNED_NUMERIC_TYPE(pDst->info.type)) { int64_t v = 0; if (!IS_VAR_DATA_TYPE(pVar->nType)) { @@ -370,7 +381,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp } else { v = taosStr2Int64(varDataVal(pVar->pz), NULL, 10); } - colDataSetVal(pDst, rows, (char*)&v, isNull); + code = colDataSetVal(pDst, rows, (char*)&v, isNull); + QUERY_CHECK_CODE(code, lino, _end); } else if (IS_UNSIGNED_NUMERIC_TYPE(pDst->info.type)) { uint64_t v = 0; if (!IS_VAR_DATA_TYPE(pVar->nType)) { @@ -378,7 +390,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp } else { v = taosStr2UInt64(varDataVal(pVar->pz), NULL, 10); } - colDataSetVal(pDst, rows, (char*)&v, isNull); + code = colDataSetVal(pDst, rows, (char*)&v, isNull); + QUERY_CHECK_CODE(code, lino, _end); } else if (IS_BOOLEAN_TYPE(pDst->info.type)) { bool v = false; if (!IS_VAR_DATA_TYPE(pVar->nType)) { @@ -386,7 +399,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp } else { v = taosStr2Int8(varDataVal(pVar->pz), NULL, 10); } - colDataSetVal(pDst, rows, (char*)&v, isNull); + code = colDataSetVal(pDst, rows, (char*)&v, isNull); + QUERY_CHECK_CODE(code, lino, _end); } ++fillColIndex; @@ -421,8 +435,10 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp } current.val = taosMemoryCalloc(pLinearInfo->bytes, 1); + QUERY_CHECK_NULL(current.val, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); taosGetLinearInterpolationVal(¤t, pLinearInfo->type, &start, &end, pLinearInfo->type); - colDataSetVal(pDst, rows, (char*)current.val, false); + code = colDataSetVal(pDst, rows, (char*)current.val, false); + QUERY_CHECK_CODE(code, lino, _end); taosMemoryFree(current.val); break; @@ -435,7 +451,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp SGroupKeys* pkey = taosArrayGet(pSliceInfo->pPrevRow, srcSlot); if (pkey->isNull == false) { - colDataSetVal(pDst, rows, pkey->pData, false); + code = colDataSetVal(pDst, rows, pkey->pData, false); + QUERY_CHECK_CODE(code, lino, _end); } else { colDataSetNULL(pDst, rows); } @@ -450,7 +467,8 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp SGroupKeys* pkey = taosArrayGet(pSliceInfo->pNextRow, srcSlot); if (pkey->isNull == false) { - colDataSetVal(pDst, rows, pkey->pData, false); + code = colDataSetVal(pDst, rows, pkey->pData, false); + QUERY_CHECK_CODE(code, lino, _end); } else { colDataSetNULL(pDst, rows); } @@ -467,12 +485,21 @@ static bool genInterpolationResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp pResBlock->info.rows += 1; } +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return hasInterp; } -static void addCurrentRowToResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp* pExprSup, SSDataBlock* pResBlock, - SSDataBlock* pSrcBlock, int32_t index) { - timeSliceEnsureBlockCapacity(pSliceInfo, pResBlock); +static int32_t addCurrentRowToResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp* pExprSup, SSDataBlock* pResBlock, + SSDataBlock* pSrcBlock, int32_t index) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + code = timeSliceEnsureBlockCapacity(pSliceInfo, pResBlock); + QUERY_CHECK_CODE(code, lino, _end); for (int32_t j = 0; j < pExprSup->numOfExprs; ++j) { SExprInfo* pExprInfo = &pExprSup->pExprInfo[j]; @@ -480,12 +507,14 @@ static void addCurrentRowToResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp* SColumnInfoData* pDst = taosArrayGet(pResBlock->pDataBlock, dstSlot); if (isIrowtsPseudoColumn(pExprInfo)) { - colDataSetVal(pDst, pResBlock->info.rows, (char*)&pSliceInfo->current, false); + code = colDataSetVal(pDst, pResBlock->info.rows, (char*)&pSliceInfo->current, false); + QUERY_CHECK_CODE(code, lino, _end); } else if (isIsfilledPseudoColumn(pExprInfo)) { bool isFilled = false; - colDataSetVal(pDst, pResBlock->info.rows, (char*)&isFilled, false); + code = colDataSetVal(pDst, pResBlock->info.rows, (char*)&isFilled, false); + QUERY_CHECK_CODE(code, lino, _end); } else { - int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId; + int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId; SColumnInfoData* pSrc = taosArrayGet(pSrcBlock->pDataBlock, srcSlot); if (colDataIsNull_s(pSrc, index)) { @@ -494,15 +523,23 @@ static void addCurrentRowToResult(STimeSliceOperatorInfo* pSliceInfo, SExprSupp* } char* v = colDataGetData(pSrc, index); - colDataSetVal(pDst, pResBlock->info.rows, v, false); + code = colDataSetVal(pDst, pResBlock->info.rows, v, false); + QUERY_CHECK_CODE(code, lino, _end); } } pResBlock->info.rows += 1; - return; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static int32_t initPrevRowsKeeper(STimeSliceOperatorInfo* pInfo, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pInfo->pPrevRow != NULL) { return TSDB_CODE_SUCCESS; } @@ -521,14 +558,23 @@ static int32_t initPrevRowsKeeper(STimeSliceOperatorInfo* pInfo, SSDataBlock* pB key.type = pColInfo->info.type; key.isNull = false; key.pData = taosMemoryCalloc(1, pColInfo->info.bytes); - taosArrayPush(pInfo->pPrevRow, &key); + QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + void* tmp = taosArrayPush(pInfo->pPrevRow, &key); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } pInfo->isPrevRowSet = false; - return TSDB_CODE_SUCCESS; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static int32_t initNextRowsKeeper(STimeSliceOperatorInfo* pInfo, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pInfo->pNextRow != NULL) { return TSDB_CODE_SUCCESS; } @@ -547,15 +593,24 @@ static int32_t initNextRowsKeeper(STimeSliceOperatorInfo* pInfo, SSDataBlock* pB key.type = pColInfo->info.type; key.isNull = false; key.pData = taosMemoryCalloc(1, pColInfo->info.bytes); - taosArrayPush(pInfo->pNextRow, &key); + QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + void* tmp = taosArrayPush(pInfo->pNextRow, &key); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } pInfo->isNextRowSet = false; - return TSDB_CODE_SUCCESS; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static int32_t initFillLinearInfo(STimeSliceOperatorInfo* pInfo, SSDataBlock* pBlock) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; if (pInfo->pLinearInfo != NULL) { return TSDB_CODE_SUCCESS; } @@ -573,15 +628,23 @@ static int32_t initFillLinearInfo(STimeSliceOperatorInfo* pInfo, SSDataBlock* pB linearInfo.start.key = INT64_MIN; linearInfo.end.key = INT64_MIN; linearInfo.start.val = taosMemoryCalloc(1, pColInfo->info.bytes); + QUERY_CHECK_NULL(linearInfo.start.val, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + linearInfo.end.val = taosMemoryCalloc(1, pColInfo->info.bytes); + QUERY_CHECK_NULL(linearInfo.end.val, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); linearInfo.isStartSet = false; linearInfo.isEndSet = false; linearInfo.type = pColInfo->info.type; linearInfo.bytes = pColInfo->info.bytes; - taosArrayPush(pInfo->pLinearInfo, &linearInfo); + void* tmp = taosArrayPush(pInfo->pLinearInfo, &linearInfo); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } - return TSDB_CODE_SUCCESS; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } + return code; } static int32_t initGroupKeyKeeper(STimeSliceOperatorInfo* pInfo, SExprSupp* pExprSup) { @@ -630,62 +693,59 @@ static int32_t initKeeperInfo(STimeSliceOperatorInfo* pInfo, SSDataBlock* pBlock return TSDB_CODE_FAILED; } - return TSDB_CODE_SUCCESS; } -static int32_t resetPrevRowsKeeper(STimeSliceOperatorInfo* pInfo) { +static void resetPrevRowsKeeper(STimeSliceOperatorInfo* pInfo) { if (pInfo->pPrevRow == NULL) { - return TSDB_CODE_SUCCESS; + return; } for (int32_t i = 0; i < taosArrayGetSize(pInfo->pLinearInfo); ++i) { - SGroupKeys *pKey = taosArrayGet(pInfo->pPrevRow, i); + SGroupKeys* pKey = taosArrayGet(pInfo->pPrevRow, i); pKey->isNull = false; } pInfo->isPrevRowSet = false; - return TSDB_CODE_SUCCESS; + return; } -static int32_t resetNextRowsKeeper(STimeSliceOperatorInfo* pInfo) { +static void resetNextRowsKeeper(STimeSliceOperatorInfo* pInfo) { if (pInfo->pNextRow == NULL) { - return TSDB_CODE_SUCCESS; + return; } for (int32_t i = 0; i < taosArrayGetSize(pInfo->pLinearInfo); ++i) { - SGroupKeys *pKey = taosArrayGet(pInfo->pPrevRow, i); + SGroupKeys* pKey = taosArrayGet(pInfo->pPrevRow, i); pKey->isNull = false; } pInfo->isNextRowSet = false; - return TSDB_CODE_SUCCESS; + return; } -static int32_t resetFillLinearInfo(STimeSliceOperatorInfo* pInfo) { +static void resetFillLinearInfo(STimeSliceOperatorInfo* pInfo) { if (pInfo->pLinearInfo == NULL) { - return TSDB_CODE_SUCCESS; + return; } for (int32_t i = 0; i < taosArrayGetSize(pInfo->pLinearInfo); ++i) { - SFillLinearInfo *pLinearInfo = taosArrayGet(pInfo->pLinearInfo, i); + SFillLinearInfo* pLinearInfo = taosArrayGet(pInfo->pLinearInfo, i); pLinearInfo->start.key = INT64_MIN; pLinearInfo->end.key = INT64_MIN; pLinearInfo->isStartSet = false; pLinearInfo->isEndSet = false; } - return TSDB_CODE_SUCCESS; + return; } -static int32_t resetKeeperInfo(STimeSliceOperatorInfo* pInfo) { +static void resetKeeperInfo(STimeSliceOperatorInfo* pInfo) { resetPrevRowsKeeper(pInfo); resetNextRowsKeeper(pInfo); resetFillLinearInfo(pInfo); - - return TSDB_CODE_SUCCESS; } static bool checkThresholdReached(STimeSliceOperatorInfo* pSliceInfo, int32_t threshold) { @@ -717,13 +777,14 @@ static void saveBlockStatus(STimeSliceOperatorInfo* pSliceInfo, SSDataBlock* pBl // all data in remaining block processed pSliceInfo->pRemainRes = NULL; - } static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pSliceInfo, SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo, bool ignoreNull) { - SSDataBlock* pResBlock = pSliceInfo->pRes; - SInterval* pInterval = &pSliceInfo->interval; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SSDataBlock* pResBlock = pSliceInfo->pRes; + SInterval* pInterval = &pSliceInfo->interval; SColumnInfoData* pTsCol = taosArrayGet(pBlock->pDataBlock, pSliceInfo->tsCol.slotId); SColumnInfoData* pPkCol = NULL; @@ -746,7 +807,8 @@ static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pS } if (ts == pSliceInfo->current) { - addCurrentRowToResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i); + code = addCurrentRowToResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i); + QUERY_CHECK_CODE(code, lino, _end); doKeepPrevRows(pSliceInfo, pBlock, i); doKeepLinearInfo(pSliceInfo, pBlock, i); @@ -773,12 +835,12 @@ static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pS int64_t nextTs = *(int64_t*)colDataGetData(pTsCol, i + 1); if (nextTs > pSliceInfo->current) { while (pSliceInfo->current < nextTs && pSliceInfo->current <= pSliceInfo->win.ekey) { - if (!genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i, false) && + if (!genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i, false, pTaskInfo) && pSliceInfo->fillType == TSDB_FILL_LINEAR) { break; } else { - pSliceInfo->current = taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit, - pInterval->precision); + pSliceInfo->current = + taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit, pInterval->precision); } } @@ -801,7 +863,7 @@ static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pS doKeepLinearInfo(pSliceInfo, pBlock, i); while (pSliceInfo->current < ts && pSliceInfo->current <= pSliceInfo->win.ekey) { - if (!genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i, true) && + if (!genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i, true, pTaskInfo) && pSliceInfo->fillType == TSDB_FILL_LINEAR) { break; } else { @@ -812,7 +874,8 @@ static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pS // add current row if timestamp match if (ts == pSliceInfo->current && pSliceInfo->current <= pSliceInfo->win.ekey) { - addCurrentRowToResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i); + code = addCurrentRowToResult(pSliceInfo, &pOperator->exprSupp, pResBlock, pBlock, i); + QUERY_CHECK_CODE(code, lino, _end); pSliceInfo->current = taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit, pInterval->precision); @@ -832,6 +895,13 @@ static void doTimesliceImpl(SOperatorInfo* pOperator, STimeSliceOperatorInfo* pS // if reached here, meaning block processing finished naturally, // or interpolation reach window upper bound pSliceInfo->pRemainRes = NULL; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } } static void genInterpAfterDataBlock(STimeSliceOperatorInfo* pSliceInfo, SOperatorInfo* pOperator, int32_t index) { @@ -844,7 +914,7 @@ static void genInterpAfterDataBlock(STimeSliceOperatorInfo* pSliceInfo, SOperato } while (pSliceInfo->current <= pSliceInfo->win.ekey) { - genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, NULL, index, false); + (void)genInterpolationResult(pSliceInfo, &pOperator->exprSupp, pResBlock, NULL, index, false, pOperator->pTaskInfo); pSliceInfo->current = taosTimeAdd(pSliceInfo->current, pInterval->interval, pInterval->intervalUnit, pInterval->precision); } @@ -855,7 +925,7 @@ static void copyPrevGroupKey(SExprSupp* pExprSup, SGroupKeys* pGroupKey, SSDataB SExprInfo* pExprInfo = &pExprSup->pExprInfo[j]; if (isGroupKeyFunc(pExprInfo)) { - int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId; + int32_t srcSlot = pExprInfo->base.pParam[0].pCol->slotId; SColumnInfoData* pSrc = taosArrayGet(pSrcBlock->pDataBlock, srcSlot); if (colDataIsNull_s(pSrc, 0)) { @@ -901,16 +971,27 @@ static void doHandleTimeslice(SOperatorInfo* pOperator, SSDataBlock* pBlock) { if (pSliceInfo->scalarSup.pExprInfo != NULL) { SExprSupp* pExprSup = &pSliceInfo->scalarSup; - projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); + code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } } // the pDataBlock are always the same one, no need to call this again - setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true); + code = setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } doTimesliceImpl(pOperator, pSliceInfo, pBlock, pTaskInfo, ignoreNull); copyPrevGroupKey(&pOperator->exprSupp, pSliceInfo->pPrevGroupKey, pBlock); } static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; if (pOperator->status == OP_EXEC_DONE) { return NULL; } @@ -924,7 +1005,8 @@ static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) { if (pSliceInfo->pNextGroupRes != NULL) { doHandleTimeslice(pOperator, pSliceInfo->pNextGroupRes); if (checkWindowBoundReached(pSliceInfo) || checkThresholdReached(pSliceInfo, pOperator->resultInfo.threshold)) { - doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _finished); if (pSliceInfo->pRemainRes == NULL) { pSliceInfo->pNextGroupRes = NULL; } @@ -959,7 +1041,8 @@ static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) { doHandleTimeslice(pOperator, pBlock); if (checkWindowBoundReached(pSliceInfo) || checkThresholdReached(pSliceInfo, pOperator->resultInfo.threshold)) { - doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _finished); if (pResBlock->info.rows != 0) { goto _finished; } @@ -971,7 +1054,8 @@ static SSDataBlock* doTimeslice(SOperatorInfo* pOperator) { // except for fill(next), fill(linear) genInterpAfterDataBlock(pSliceInfo, pOperator, 0); - doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pResBlock, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _finished); if (pOperator->status == OP_EXEC_DONE) { break; } @@ -989,6 +1073,11 @@ _finished: if (pResBlock->info.rows == 0) { pOperator->status = OP_EXEC_DONE; } + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return pResBlock->info.rows == 0 ? NULL : pResBlock; } @@ -996,23 +1085,24 @@ _finished: static int32_t extractPkColumnFromFuncs(SNodeList* pFuncs, bool* pHasPk, SColumn* pPkColumn) { SNode* pNode; FOREACH(pNode, pFuncs) { - if ((nodeType(pNode) == QUERY_NODE_TARGET) && - (nodeType(((STargetNode*)pNode)->pExpr) == QUERY_NODE_FUNCTION)) { - SFunctionNode* pFunc = (SFunctionNode*)((STargetNode*)pNode)->pExpr; - if (fmIsInterpFunc(pFunc->funcId) && pFunc->hasPk) { - SNode* pNode2 = (pFunc->pParameterList->pTail->pNode); - if ((nodeType(pNode2) == QUERY_NODE_COLUMN) && ((SColumnNode*)pNode2)->isPk) { - *pHasPk = true; - *pPkColumn = extractColumnFromColumnNode((SColumnNode*)pNode2); - break; - } + if ((nodeType(pNode) == QUERY_NODE_TARGET) && (nodeType(((STargetNode*)pNode)->pExpr) == QUERY_NODE_FUNCTION)) { + SFunctionNode* pFunc = (SFunctionNode*)((STargetNode*)pNode)->pExpr; + if (fmIsInterpFunc(pFunc->funcId) && pFunc->hasPk) { + SNode* pNode2 = (pFunc->pParameterList->pTail->pNode); + if ((nodeType(pNode2) == QUERY_NODE_COLUMN) && ((SColumnNode*)pNode2)->isPk) { + *pHasPk = true; + *pPkColumn = extractColumnFromColumnNode((SColumnNode*)pNode2); + break; } + } } } return TSDB_CODE_SUCCESS; } SOperatorInfo* createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode* pPhyNode, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; STimeSliceOperatorInfo* pInfo = taosMemoryCalloc(1, sizeof(STimeSliceOperatorInfo)); SOperatorInfo* pOperator = taosMemoryCalloc(1, sizeof(SOperatorInfo)); if (pOperator == NULL || pInfo == NULL) { @@ -1024,27 +1114,23 @@ SOperatorInfo* createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode int32_t numOfExprs = 0; SExprInfo* pExprInfo = createExprInfo(pInterpPhyNode->pFuncs, NULL, &numOfExprs); - int32_t code = initExprSupp(pSup, pExprInfo, numOfExprs, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + code = initExprSupp(pSup, pExprInfo, numOfExprs, &pTaskInfo->storageAPI.functionStore); + QUERY_CHECK_CODE(code, lino, _error); if (pInterpPhyNode->pExprs != NULL) { int32_t num = 0; SExprInfo* pScalarExprInfo = createExprInfo(pInterpPhyNode->pExprs, NULL, &num); code = initExprSupp(&pInfo->scalarSup, pScalarExprInfo, num, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); } code = filterInitFromNode((SNode*)pInterpPhyNode->node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); pInfo->tsCol = extractColumnFromColumnNode((SColumnNode*)pInterpPhyNode->pTimeSeries); - extractPkColumnFromFuncs(pInterpPhyNode->pFuncs, &pInfo->hasPk, &pInfo->pkCol); + code = extractPkColumnFromFuncs(pInterpPhyNode->pFuncs, &pInfo->hasPk, &pInfo->pkCol); + QUERY_CHECK_CODE(code, lino, _error); + pInfo->fillType = convertFillType(pInterpPhyNode->fillMode); initResultSizeInfo(&pOperator->resultInfo, 4096); @@ -1080,17 +1166,22 @@ SOperatorInfo* createTimeSliceOperatorInfo(SOperatorInfo* downstream, SPhysiNode setOperatorInfo(pOperator, "TimeSliceOperator", QUERY_NODE_PHYSICAL_PLAN_INTERP_FUNC, false, OP_NOT_OPENED, pInfo, pTaskInfo); - pOperator->fpSet = - createOperatorFpSet(optrDummyOpenFn, doTimeslice, NULL, destroyTimeSliceOperatorInfo, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); + pOperator->fpSet = createOperatorFpSet(optrDummyOpenFn, doTimeslice, NULL, destroyTimeSliceOperatorInfo, + optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); - blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pInfo->pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _error); -// int32_t code = initKeeperInfo(pSliceInfo, pBlock, &pOperator->exprSupp); + // int32_t code = initKeeperInfo(pSliceInfo, pBlock, &pOperator->exprSupp); code = appendDownstream(pOperator, &downstream, 1); + QUERY_CHECK_CODE(code, lino, _error); return pOperator; _error: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } taosMemoryFree(pInfo); taosMemoryFree(pOperator); pTaskInfo->code = TSDB_CODE_OUT_OF_MEMORY; diff --git a/source/libs/executor/src/timewindowoperator.c b/source/libs/executor/src/timewindowoperator.c index fb3176a2a8..e448cd8e3a 100644 --- a/source/libs/executor/src/timewindowoperator.c +++ b/source/libs/executor/src/timewindowoperator.c @@ -62,10 +62,10 @@ typedef struct SOpenWindowInfo { uint64_t groupId; } SOpenWindowInfo; -static int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo); +static int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo, SExecTaskInfo* pTaskInfo); static SResultRowPosition addToOpenWindowList(SResultRowInfo* pResultRowInfo, const SResultRow* pResult, - uint64_t groupId); + uint64_t groupId, SExecTaskInfo* pTaskInfo); static void doCloseWindow(SResultRowInfo* pResultRowInfo, const SIntervalAggOperatorInfo* pInfo, SResultRow* pResult); static int32_t setTimeWindowOutputBuf(SResultRowInfo* pResultRowInfo, STimeWindow* win, bool masterscan, @@ -707,7 +707,7 @@ static bool hashIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResul int32_t startPos = 0; int32_t numOfOutput = pSup->numOfExprs; - int64_t* tsCols = extractTsCol(pBlock, pInfo); + int64_t* tsCols = extractTsCol(pBlock, pInfo, pTaskInfo); uint64_t tableGroupId = pBlock->info.id.groupId; bool ascScan = (pInfo->binfo.inputTsOrder == TSDB_ORDER_ASC); TSKEY ts = getStartTsKey(&pBlock->info.window, tsCols); @@ -740,7 +740,7 @@ static bool hashIntervalAgg(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResul // prev time window not interpolation yet. if (pInfo->timeWindowInterpo) { - SResultRowPosition pos = addToOpenWindowList(pResultRowInfo, pResult, tableGroupId); + SResultRowPosition pos = addToOpenWindowList(pResultRowInfo, pResult, tableGroupId, pTaskInfo); doInterpUnclosedTimeWindow(pOperatorInfo, numOfOutput, pResultRowInfo, pBlock, scanFlag, tsCols, &pos); // restore current time window @@ -811,26 +811,36 @@ void doCloseWindow(SResultRowInfo* pResultRowInfo, const SIntervalAggOperatorInf } } -SResultRowPosition addToOpenWindowList(SResultRowInfo* pResultRowInfo, const SResultRow* pResult, uint64_t groupId) { +SResultRowPosition addToOpenWindowList(SResultRowInfo* pResultRowInfo, const SResultRow* pResult, uint64_t groupId, SExecTaskInfo* pTaskInfo) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SOpenWindowInfo openWin = {0}; openWin.pos.pageId = pResult->pageId; openWin.pos.offset = pResult->offset; openWin.groupId = groupId; SListNode* pn = tdListGetTail(pResultRowInfo->openWindow); if (pn == NULL) { - tdListAppend(pResultRowInfo->openWindow, &openWin); + code = tdListAppend(pResultRowInfo->openWindow, &openWin); + QUERY_CHECK_CODE(code, lino, _end); return openWin.pos; } SOpenWindowInfo* px = (SOpenWindowInfo*)pn->data; if (px->pos.pageId != openWin.pos.pageId || px->pos.offset != openWin.pos.offset || px->groupId != openWin.groupId) { - tdListAppend(pResultRowInfo->openWindow, &openWin); + code = tdListAppend(pResultRowInfo->openWindow, &openWin); + QUERY_CHECK_CODE(code, lino, _end); } +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return openWin.pos; } -int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo) { +int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo, SExecTaskInfo* pTaskInfo) { TSKEY* tsCols = NULL; if (pBlock->pDataBlock != NULL && pBlock->info.dataLoad) { @@ -844,7 +854,12 @@ int64_t* extractTsCol(SSDataBlock* pBlock, const SIntervalAggOperatorInfo* pInfo } if (tsCols[0] != 0 && (pBlock->info.window.skey == 0 && pBlock->info.window.ekey == 0)) { - blockDataUpdateTsWindow(pBlock, pInfo->primaryTsIndex); + int32_t code = blockDataUpdateTsWindow(pBlock, pInfo->primaryTsIndex); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } } } @@ -856,6 +871,8 @@ static int32_t doOpenIntervalAgg(SOperatorInfo* pOperator) { return TSDB_CODE_SUCCESS; } + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SOperatorInfo* downstream = pOperator->pDownstream[0]; @@ -875,11 +892,13 @@ static int32_t doOpenIntervalAgg(SOperatorInfo* pOperator) { if (pInfo->scalarSupp.pExprInfo != NULL) { SExprSupp* pExprSup = &pInfo->scalarSupp; - projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); + code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); + QUERY_CHECK_CODE(code, lino, _end); } // the pDataBlock are always the same one, no need to call this again - setInputDataBlock(pSup, pBlock, pInfo->binfo.inputTsOrder, scanFlag, true); + code = setInputDataBlock(pSup, pBlock, pInfo->binfo.inputTsOrder, scanFlag, true); + QUERY_CHECK_CODE(code, lino, _end); if (hashIntervalAgg(pOperator, &pInfo->binfo.resultRowInfo, pBlock, scanFlag)) break; } @@ -887,7 +906,14 @@ static int32_t doOpenIntervalAgg(SOperatorInfo* pOperator) { OPTR_SET_OPENED(pOperator); pOperator->cost.openCost = (taosGetTimestampUs() - st) / 1000.0; - return TSDB_CODE_SUCCESS; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } + return code; } static void doStateWindowAggImpl(SOperatorInfo* pOperator, SStateWindowOperatorInfo* pInfo, SSDataBlock* pBlock) { @@ -979,6 +1005,8 @@ static int32_t openStateWindowAggOptr(SOperatorInfo* pOperator) { return TSDB_CODE_SUCCESS; } + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SStateWindowOperatorInfo* pInfo = pOperator->info; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; @@ -994,8 +1022,11 @@ static int32_t openStateWindowAggOptr(SOperatorInfo* pOperator) { } pInfo->binfo.pRes->info.scanFlag = pBlock->info.scanFlag; - setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true); - blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId); + code = setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); + + code = blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId); + QUERY_CHECK_CODE(code, lino, _end); // there is an scalar expression that needs to be calculated right before apply the group aggregation. if (pInfo->scalarSup.pExprInfo != NULL) { @@ -1013,7 +1044,13 @@ static int32_t openStateWindowAggOptr(SOperatorInfo* pOperator) { initGroupedResultInfo(&pInfo->groupResInfo, pInfo->aggSup.pResultRowHashTable, TSDB_ORDER_ASC); pOperator->status = OP_RES_TO_RETURN; - return TSDB_CODE_SUCCESS; +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } + return code; } static SSDataBlock* doStateWindowAgg(SOperatorInfo* pOperator) { @@ -1031,10 +1068,21 @@ static SSDataBlock* doStateWindowAgg(SOperatorInfo* pOperator) { return NULL; } - blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity); + int32_t code = blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } + while (1) { doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf); - doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } bool hasRemain = hasRemainResults(&pInfo->groupResInfo); if (!hasRemain) { @@ -1067,7 +1115,12 @@ static SSDataBlock* doBuildIntervalResult(SOperatorInfo* pOperator) { while (1) { doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf); - doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL); + int32_t code = doFilter(pBlock, pOperator->exprSupp.pFilterInfo, NULL); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } bool hasRemain = hasRemainResults(&pInfo->groupResInfo); if (!hasRemain) { @@ -1086,32 +1139,6 @@ static SSDataBlock* doBuildIntervalResult(SOperatorInfo* pOperator) { return (rows == 0) ? NULL : pBlock; } -static void doClearWindowImpl(SResultRowPosition* p1, SDiskbasedBuf* pResultBuf, SExprSupp* pSup, int32_t numOfOutput) { - SResultRow* pResult = getResultRowByPos(pResultBuf, p1, false); - if (NULL == pResult) { - return; - } - - SqlFunctionCtx* pCtx = pSup->pCtx; - for (int32_t i = 0; i < numOfOutput; ++i) { - pCtx[i].resultInfo = getResultEntryInfo(pResult, i, pSup->rowEntryInfoOffset); - struct SResultRowEntryInfo* pResInfo = pCtx[i].resultInfo; - if (fmIsWindowPseudoColumnFunc(pCtx[i].functionId)) { - continue; - } - pResInfo->initialized = false; - if (pCtx[i].functionId != -1) { - pCtx[i].fpSet.init(&pCtx[i], pResInfo); - } - } - SFilePage* bufPage = getBufPage(pResultBuf, p1->pageId); - if (NULL == bufPage) { - return; - } - setBufPageDirty(bufPage, true); - releaseBufPage(pResultBuf, bufPage); -} - static void destroyStateWindowOperatorInfo(void* param) { SStateWindowOperatorInfo* pInfo = (SStateWindowOperatorInfo*)param; cleanupBasicInfo(&pInfo->binfo); @@ -1135,7 +1162,7 @@ void destroyIntervalOperatorInfo(void* param) { cleanupAggSup(&pInfo->aggSup); cleanupExprSupp(&pInfo->scalarSupp); - tdListFree(pInfo->binfo.resultRowInfo.openWindow); + (void)tdListFree(pInfo->binfo.resultRowInfo.openWindow); taosArrayDestroy(pInfo->pInterpCols); pInfo->pInterpCols = NULL; @@ -1148,9 +1175,13 @@ void destroyIntervalOperatorInfo(void* param) { taosMemoryFreeClear(param); } -static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SIntervalAggOperatorInfo* pInfo) { +static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SIntervalAggOperatorInfo* pInfo, + SExecTaskInfo* pTaskInfo) { // the primary timestamp column - bool needed = false; + bool needed = false; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + void* tmp = NULL; for (int32_t i = 0; i < numOfCols; ++i) { SExprInfo* pExpr = pCtx[i].pExpr; @@ -1162,7 +1193,10 @@ static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SInt if (needed) { pInfo->pInterpCols = taosArrayInit(4, sizeof(SColumn)); + QUERY_CHECK_NULL(pInfo->pInterpCols, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + pInfo->pPrevValues = taosArrayInit(4, sizeof(SGroupKeys)); + QUERY_CHECK_NULL(pInfo->pPrevValues, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); { // ts column SColumn c = {0}; @@ -1170,14 +1204,18 @@ static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SInt c.slotId = pInfo->primaryTsIndex; c.type = TSDB_DATA_TYPE_TIMESTAMP; c.bytes = sizeof(int64_t); - taosArrayPush(pInfo->pInterpCols, &c); + tmp = taosArrayPush(pInfo->pInterpCols, &c); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); SGroupKeys key; key.bytes = c.bytes; key.type = c.type; key.isNull = true; // to denote no value is assigned yet key.pData = taosMemoryCalloc(1, c.bytes); - taosArrayPush(pInfo->pPrevValues, &key); + QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + tmp = taosArrayPush(pInfo->pPrevValues, &key); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } } @@ -1188,17 +1226,27 @@ static bool timeWindowinterpNeeded(SqlFunctionCtx* pCtx, int32_t numOfCols, SInt SFunctParam* pParam = &pExpr->base.pParam[0]; SColumn c = *pParam->pCol; - taosArrayPush(pInfo->pInterpCols, &c); + tmp = taosArrayPush(pInfo->pInterpCols, &c); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); SGroupKeys key = {0}; key.bytes = c.bytes; key.type = c.type; key.isNull = false; key.pData = taosMemoryCalloc(1, c.bytes); - taosArrayPush(pInfo->pPrevValues, &key); + QUERY_CHECK_NULL(key.pData, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); + + tmp = taosArrayPush(pInfo->pPrevValues, &key); + QUERY_CHECK_NULL(tmp, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); } } +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return needed; } @@ -1222,15 +1270,14 @@ SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPh size_t keyBufSize = sizeof(int64_t) + sizeof(int64_t) + POINTER_BYTES; initResultSizeInfo(&pOperator->resultInfo, 512); - blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pInfo->binfo.pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _error); int32_t num = 0; SExprInfo* pExprInfo = createExprInfo(pPhyNode->window.pFuncs, NULL, &num); code = initAggSup(pSup, &pInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str, pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); SInterval interval = {.interval = pPhyNode->interval, .sliding = pPhyNode->sliding, @@ -1279,7 +1326,7 @@ SOperatorInfo* createIntervalOperatorInfo(SOperatorInfo* downstream, SIntervalPh code = initExecTimeWindowInfo(&pInfo->twAggSup.timeWindowData, &pInfo->win); QUERY_CHECK_CODE(code, lino, _error); - pInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, pInfo); + pInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, pInfo, pTaskInfo); if (pInfo->timeWindowInterpo) { pInfo->binfo.resultRowInfo.openWindow = tdListNew(sizeof(SOpenWindowInfo)); if (pInfo->binfo.resultRowInfo.openWindow == NULL) { @@ -1387,6 +1434,9 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) { return NULL; } + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SSessionAggOperatorInfo* pInfo = pOperator->info; SOptrBasicInfo* pBInfo = &pInfo->binfo; SExprSupp* pSup = &pOperator->exprSupp; @@ -1394,7 +1444,8 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) { if (pOperator->status == OP_RES_TO_RETURN) { while (1) { doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf); - doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); bool hasRemain = hasRemainResults(&pInfo->groupResInfo); if (!hasRemain) { @@ -1424,11 +1475,15 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) { pBInfo->pRes->info.scanFlag = pBlock->info.scanFlag; if (pInfo->scalarSupp.pExprInfo != NULL) { SExprSupp* pExprSup = &pInfo->scalarSupp; - projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); + code = projectApplyFunctions(pExprSup->pExprInfo, pBlock, pBlock, pExprSup->pCtx, pExprSup->numOfExprs, NULL); + QUERY_CHECK_CODE(code, lino, _end); } // the pDataBlock are always the same one, no need to call this again - setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true); - blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId); + code = setInputDataBlock(pSup, pBlock, order, MAIN_SCAN, true); + QUERY_CHECK_CODE(code, lino, _end); + + code = blockDataUpdateTsWindow(pBlock, pInfo->tsSlotId); + QUERY_CHECK_CODE(code, lino, _end); doSessionWindowAggImpl(pOperator, pInfo, pBlock); } @@ -1439,10 +1494,12 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) { pOperator->status = OP_RES_TO_RETURN; initGroupedResultInfo(&pInfo->groupResInfo, pInfo->aggSup.pResultRowHashTable, TSDB_ORDER_ASC); - blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pBInfo->pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _end); while (1) { doBuildResultDatablock(pOperator, &pInfo->binfo, &pInfo->groupResInfo, pInfo->aggSup.pResultBuf); - doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pBInfo->pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); bool hasRemain = hasRemainResults(&pInfo->groupResInfo); if (!hasRemain) { @@ -1455,6 +1512,13 @@ static SSDataBlock* doSessionWindowAgg(SOperatorInfo* pOperator) { } } pOperator->resultInfo.totalRows += pBInfo->pRes->info.rows; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return (pBInfo->pRes->info.rows == 0) ? NULL : pBInfo->pRes; } @@ -1581,7 +1645,7 @@ SOperatorInfo* createSessionAggOperatorInfo(SOperatorInfo* downstream, SSessionW initBasicInfo(&pInfo->binfo, pResBlock); code = initAggSup(&pOperator->exprSupp, &pInfo->aggSup, pExprInfo, numOfCols, keyBufSize, pTaskInfo->id.str, - pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); + pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); if (code != TSDB_CODE_SUCCESS) { goto _error; } @@ -1673,7 +1737,7 @@ static void doMergeAlignedIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultR SInterval* pInterval = &iaInfo->interval; int32_t startPos = 0; - int64_t* tsCols = extractTsCol(pBlock, iaInfo); + int64_t* tsCols = extractTsCol(pBlock, iaInfo, pTaskInfo); TSKEY ts = getStartTsKey(&pBlock->info.window, tsCols); @@ -1737,8 +1801,9 @@ static void cleanupAfterGroupResultGen(SMergeAlignedIntervalAggOperatorInfo* pMi } static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) { - SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; - + SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SMergeAlignedIntervalAggOperatorInfo* pMiaInfo = pOperator->info; SIntervalAggOperatorInfo* pIaInfo = pMiaInfo->intervalAggOperatorInfo; @@ -1765,7 +1830,8 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) { finalizeResultRows(pIaInfo->aggSup.pResultBuf, &pResultRowInfo->cur, pSup, pRes, pTaskInfo); resetResultRow(pMiaInfo->pResultRow, pIaInfo->aggSup.resultRowSize - sizeof(SResultRow)); cleanupAfterGroupResultGen(pMiaInfo, pRes); - doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); } setOperatorCompleted(pOperator); @@ -1786,7 +1852,8 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) { pMiaInfo->prefetchedBlock = pBlock; cleanupAfterGroupResultGen(pMiaInfo, pRes); - doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); break; } else { // continue @@ -1795,14 +1862,25 @@ static void doMergeAlignedIntervalAgg(SOperatorInfo* pOperator) { } pRes->info.scanFlag = pBlock->info.scanFlag; - setInputDataBlock(pSup, pBlock, pIaInfo->binfo.inputTsOrder, pBlock->info.scanFlag, true); + code = setInputDataBlock(pSup, pBlock, pIaInfo->binfo.inputTsOrder, pBlock->info.scanFlag, true); + QUERY_CHECK_CODE(code, lino, _end); + doMergeAlignedIntervalAggImpl(pOperator, &pIaInfo->binfo.resultRowInfo, pBlock, pRes); - doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + code = doFilter(pRes, pOperator->exprSupp.pFilterInfo, NULL); + QUERY_CHECK_CODE(code, lino, _end); + if (pRes->info.rows >= pOperator->resultInfo.capacity) { break; } } + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } } static SSDataBlock* mergeAlignedIntervalAgg(SOperatorInfo* pOperator) { @@ -1865,9 +1943,7 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, pSup->hasWindowOrGroup = true; code = filterInitFromNode((SNode*)pNode->window.node.pConditions, &pOperator->exprSupp.pFilterInfo, 0); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); miaInfo->curTs = INT64_MIN; iaInfo->win = pTaskInfo->window; @@ -1885,22 +1961,21 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, code = initAggSup(&pOperator->exprSupp, &iaInfo->aggSup, pExprInfo, num, keyBufSize, pTaskInfo->id.str, pTaskInfo->streamInfo.pState, &pTaskInfo->storageAPI.functionStore); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); SSDataBlock* pResBlock = createDataBlockFromDescNode(pNode->window.node.pOutputDataBlockDesc); initBasicInfo(&iaInfo->binfo, pResBlock); code = initExecTimeWindowInfo(&iaInfo->twAggSup.timeWindowData, &iaInfo->win); QUERY_CHECK_CODE(code, lino, _error); - iaInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, iaInfo); + iaInfo->timeWindowInterpo = timeWindowinterpNeeded(pSup->pCtx, num, iaInfo, pTaskInfo); if (iaInfo->timeWindowInterpo) { iaInfo->binfo.resultRowInfo.openWindow = tdListNew(sizeof(SOpenWindowInfo)); } initResultRowInfo(&iaInfo->binfo.resultRowInfo); - blockDataEnsureCapacity(iaInfo->binfo.pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(iaInfo->binfo.pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _error); setOperatorInfo(pOperator, "TimeMergeAlignedIntervalAggOperator", QUERY_NODE_PHYSICAL_PLAN_MERGE_ALIGNED_INTERVAL, false, OP_NOT_OPENED, miaInfo, pTaskInfo); @@ -1908,9 +1983,7 @@ SOperatorInfo* createMergeAlignedIntervalOperatorInfo(SOperatorInfo* downstream, optrDefaultBufFn, NULL, optrDefaultGetNextExtFn, NULL); code = appendDownstream(pOperator, &downstream, 1); - if (code != TSDB_CODE_SUCCESS) { - goto _error; - } + QUERY_CHECK_CODE(code, lino, _error); return pOperator; @@ -1940,7 +2013,7 @@ typedef struct SGroupTimeWindow { void destroyMergeIntervalOperatorInfo(void* param) { SMergeIntervalAggOperatorInfo* miaInfo = (SMergeIntervalAggOperatorInfo*)param; - tdListFree(miaInfo->groupIntervals); + (void)tdListFree(miaInfo->groupIntervals); destroyIntervalOperatorInfo(&miaInfo->intervalAggOperatorInfo); taosMemoryFreeClear(param); @@ -1953,7 +2026,11 @@ static int32_t outputPrevIntervalResult(SOperatorInfo* pOperatorInfo, uint64_t t bool ascScan = (iaInfo->binfo.inputTsOrder == TSDB_ORDER_ASC); SGroupTimeWindow groupTimeWindow = {.groupId = tableGroupId, .window = *newWin}; - tdListAppend(miaInfo->groupIntervals, &groupTimeWindow); + int32_t code = tdListAppend(miaInfo->groupIntervals, &groupTimeWindow); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } SListIter iter = {0}; tdListInitIter(miaInfo->groupIntervals, &iter, TD_LIST_FORWARD); @@ -1966,11 +2043,11 @@ static int32_t outputPrevIntervalResult(SOperatorInfo* pOperatorInfo, uint64_t t STimeWindow* prevWin = &prevGrpWin->window; if ((ascScan && newWin->skey > prevWin->ekey) || ((!ascScan) && newWin->skey < prevWin->ekey)) { - tdListPopNode(miaInfo->groupIntervals, listNode); + (void)tdListPopNode(miaInfo->groupIntervals, listNode); } } - return 0; + return TSDB_CODE_SUCCESS; } static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo* pResultRowInfo, SSDataBlock* pBlock, @@ -1983,7 +2060,7 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo* int32_t startPos = 0; int32_t numOfOutput = pExprSup->numOfExprs; - int64_t* tsCols = extractTsCol(pBlock, iaInfo); + int64_t* tsCols = extractTsCol(pBlock, iaInfo, pTaskInfo); uint64_t tableGroupId = pBlock->info.id.groupId; bool ascScan = (iaInfo->binfo.inputTsOrder == TSDB_ORDER_ASC); TSKEY blockStartTs = getStartTsKey(&pBlock->info.window, tsCols); @@ -2006,7 +2083,7 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo* // prev time window not interpolation yet. if (iaInfo->timeWindowInterpo) { - SResultRowPosition pos = addToOpenWindowList(pResultRowInfo, pResult, tableGroupId); + SResultRowPosition pos = addToOpenWindowList(pResultRowInfo, pResult, tableGroupId, pTaskInfo); doInterpUnclosedTimeWindow(pOperatorInfo, numOfOutput, pResultRowInfo, pBlock, scanFlag, tsCols, &pos); // restore current time window @@ -2026,7 +2103,11 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo* doCloseWindow(pResultRowInfo, iaInfo, pResult); // output previous interval results after this interval (&win) is closed - outputPrevIntervalResult(pOperatorInfo, tableGroupId, pResultBlock, &win); + int32_t code = outputPrevIntervalResult(pOperatorInfo, tableGroupId, pResultBlock, &win); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY); + } STimeWindow nextWin = win; while (1) { @@ -2038,7 +2119,7 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo* } // null data, failed to allocate more memory buffer - int32_t code = + code = setTimeWindowOutputBuf(pResultRowInfo, &nextWin, (scanFlag == MAIN_SCAN), &pResult, tableGroupId, pExprSup->pCtx, numOfOutput, pExprSup->rowEntryInfoOffset, &iaInfo->aggSup, pTaskInfo); if (code != TSDB_CODE_SUCCESS || pResult == NULL) { @@ -2058,7 +2139,11 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo* doCloseWindow(pResultRowInfo, iaInfo, pResult); // output previous interval results after this interval (&nextWin) is closed - outputPrevIntervalResult(pOperatorInfo, tableGroupId, pResultBlock, &nextWin); + code = outputPrevIntervalResult(pOperatorInfo, tableGroupId, pResultBlock, &nextWin); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, TSDB_CODE_OUT_OF_MEMORY); + } } if (iaInfo->timeWindowInterpo) { @@ -2067,6 +2152,8 @@ static void doMergeIntervalAggImpl(SOperatorInfo* pOperatorInfo, SResultRowInfo* } static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) { + int32_t code = TSDB_CODE_SUCCESS; + int32_t lino = 0; SExecTaskInfo* pTaskInfo = pOperator->pTaskInfo; SMergeIntervalAggOperatorInfo* miaInfo = pOperator->info; @@ -2079,7 +2166,8 @@ static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) { SSDataBlock* pRes = iaInfo->binfo.pRes; blockDataCleanup(pRes); - blockDataEnsureCapacity(pRes, pOperator->resultInfo.capacity); + code = blockDataEnsureCapacity(pRes, pOperator->resultInfo.capacity); + QUERY_CHECK_CODE(code, lino, _end); if (!miaInfo->inputBlocksFinished) { SOperatorInfo* downstream = pOperator->pDownstream[0]; @@ -2108,7 +2196,9 @@ static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) { } pRes->info.scanFlag = pBlock->info.scanFlag; - setInputDataBlock(pExpSupp, pBlock, iaInfo->binfo.inputTsOrder, pBlock->info.scanFlag, true); + code = setInputDataBlock(pExpSupp, pBlock, iaInfo->binfo.inputTsOrder, pBlock->info.scanFlag, true); + QUERY_CHECK_CODE(code, lino, _end); + doMergeIntervalAggImpl(pOperator, &iaInfo->binfo.resultRowInfo, pBlock, pBlock->info.scanFlag, pRes); if (pRes->info.rows >= pOperator->resultInfo.threshold) { @@ -2134,6 +2224,13 @@ static SSDataBlock* doMergeIntervalAgg(SOperatorInfo* pOperator) { size_t rows = pRes->info.rows; pOperator->resultInfo.totalRows += rows; + +_end: + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); + } return (rows == 0) ? NULL : pRes; } @@ -2184,7 +2281,7 @@ SOperatorInfo* createMergeIntervalOperatorInfo(SOperatorInfo* downstream, SMerge code = initExecTimeWindowInfo(&pIntervalInfo->twAggSup.timeWindowData, &pIntervalInfo->win); QUERY_CHECK_CODE(code, lino, _error); - pIntervalInfo->timeWindowInterpo = timeWindowinterpNeeded(pExprSupp->pCtx, num, pIntervalInfo); + pIntervalInfo->timeWindowInterpo = timeWindowinterpNeeded(pExprSupp->pCtx, num, pIntervalInfo, pTaskInfo); if (pIntervalInfo->timeWindowInterpo) { pIntervalInfo->binfo.resultRowInfo.openWindow = tdListNew(sizeof(SOpenWindowInfo)); if (pIntervalInfo->binfo.resultRowInfo.openWindow == NULL) { diff --git a/source/libs/executor/test/timewindowTest.cpp b/source/libs/executor/test/timewindowTest.cpp index 7ccbf0b10f..211dce606e 100644 --- a/source/libs/executor/test/timewindowTest.cpp +++ b/source/libs/executor/test/timewindowTest.cpp @@ -52,7 +52,7 @@ void printTimeWindow(STimeWindow* pWindow, int8_t precision, int64_t ts) { taosFormatUtcTime(bufs, tListLen(bufs), pWindow->skey, precision); taosFormatUtcTime(bufe, tListLen(bufe), pWindow->ekey, precision); - printf("%s [%s - %s]\n", buf, bufs, bufe); + (void)printf("%s [%s - %s]\n", buf, bufs, bufe); } } // namespace @@ -71,26 +71,26 @@ TEST(testCase, timewindow_gen) { printTimeWindow(&w, precision, key); getNextTimeWindow(&interval, &w, TSDB_ORDER_ASC); - printf("next\n"); + (void)printf("next\n"); printTimeWindow(&w, precision, key); - printf("---------------------------------------------------\n"); + (void)printf("---------------------------------------------------\n"); SInterval monthInterval = createInterval(1, 1, 0, 'n', 'n', 'd', TSDB_TIME_PRECISION_MILLI); getInitialStartTimeWindow(&monthInterval, key, &w, true); printTimeWindow(&w, precision, key); getNextTimeWindow(&monthInterval, &w, TSDB_ORDER_ASC); - printf("next\n"); + (void)printf("next\n"); printTimeWindow(&w, precision, key); - printf("----------------------------------------------------------\n"); + (void)printf("----------------------------------------------------------\n"); SInterval slidingInterval = createInterval(1, 10*86400*1000, 0, 'n', 'd', 'd', TSDB_TIME_PRECISION_MILLI); getInitialStartTimeWindow(&slidingInterval, key, &w, true); printTimeWindow(&w, precision, key); getNextTimeWindow(&slidingInterval, &w, TSDB_ORDER_ASC); - printf("next\n"); + (void)printf("next\n"); printTimeWindow(&w, precision, key); getNextTimeWindow(&slidingInterval, &w, TSDB_ORDER_ASC); @@ -114,13 +114,13 @@ TEST(testCase, timewindow_gen) { getNextTimeWindow(&slidingInterval, &w, TSDB_ORDER_ASC); printTimeWindow(&w, precision, key); - printf("-----------------calendar_interval_1n_sliding_1d-------\n"); + (void)printf("-----------------calendar_interval_1n_sliding_1d-------\n"); SInterval calendar_interval_1n = createInterval(1, 1*86400*1000, 0, 'n', 'd', 'd', TSDB_TIME_PRECISION_MILLI); int64_t k1 = 1664409600 * 1000L; getInitialStartTimeWindow(&calendar_interval_1n, k1, &w, true); printTimeWindow(&w, precision, k1); - printf("next\n"); + (void)printf("next\n"); getNextTimeWindow(&calendar_interval_1n, &w, TSDB_ORDER_ASC); printTimeWindow(&w, precision, key); @@ -134,14 +134,14 @@ TEST(testCase, timewindow_gen) { getNextTimeWindow(&calendar_interval_1n, &w, TSDB_ORDER_ASC); printTimeWindow(&w, precision, key); - printf("----------------interval_1d_clendar_sliding_1n---------\n"); + (void)printf("----------------interval_1d_clendar_sliding_1n---------\n"); SInterval interval_1d_calendar_sliding_1n = createInterval(1*86400*1000L, 1, 0, 'd', 'n', 'd', TSDB_TIME_PRECISION_MILLI); k1 = 1664409600 * 1000L; getInitialStartTimeWindow(&interval_1d_calendar_sliding_1n, k1, &w, true); printTimeWindow(&w, precision, k1); - printf("next time window:\n"); + (void)printf("next time window:\n"); getNextTimeWindow(&interval_1d_calendar_sliding_1n, &w, TSDB_ORDER_ASC); printTimeWindow(&w, precision, k1); @@ -151,7 +151,7 @@ TEST(testCase, timewindow_gen) { getNextTimeWindow(&interval_1d_calendar_sliding_1n, &w, TSDB_ORDER_ASC); printTimeWindow(&w, precision, k1); - printf("----------------interval_1d_sliding_1d_calendar_offset_1n---------\n"); + (void)printf("----------------interval_1d_sliding_1d_calendar_offset_1n---------\n"); SInterval offset_1n = createInterval(10*86400*1000L, 10*86400*1000L, 1, 'd', 'd', 'n', TSDB_TIME_PRECISION_MILLI); getInitialStartTimeWindow(&offset_1n, k1, &w, true); printTimeWindow(&w, precision, k1); @@ -175,14 +175,14 @@ TEST(testCase, timewindow_natural) { getInitialStartTimeWindow(&interval2, key1, &w1, true); printTimeWindow(&w1, precision, key1); STimeWindow w3 = getAlignQueryTimeWindow(&interval2, key1); - printf("%ld win %ld, %ld\n", key1, w3.skey, w3.ekey); + (void)printf("%ld win %ld, %ld\n", key1, w3.skey, w3.ekey); int64_t key2 = 1648758398208; STimeWindow w2 = {0}; getInitialStartTimeWindow(&interval2, key2, &w2, true); printTimeWindow(&w2, precision, key2); STimeWindow w4 = getAlignQueryTimeWindow(&interval2, key2); - printf("%ld win %ld, %ld\n", key2, w3.skey, w3.ekey); + (void)printf("%ld win %ld, %ld\n", key2, w3.skey, w3.ekey); ASSERT_EQ(w3.skey, w4.skey); ASSERT_EQ(w3.ekey, w4.ekey); @@ -199,7 +199,7 @@ TEST(testCase, timewindow_active) { int64_t key = (int64_t)1609430400*1000; // 2021-01-01 STimeWindow win = getActiveTimeWindow(NULL, &dumyInfo, key, &interval, TSDB_ORDER_ASC); printTimeWindow(&win, precision, key); - printf("%ld win %ld, %ld\n", key, win.skey, win.ekey); + (void)printf("%ld win %ld, %ld\n", key, win.skey, win.ekey); ASSERT_EQ(win.skey, 1325376000000); ASSERT_EQ(win.ekey, 1640908799999); } From 2522e9d3b8753274fd6d5f522a0663c963e71d3c Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao> Date: Tue, 23 Jul 2024 11:33:00 +0800 Subject: [PATCH 07/15] adj query operator result --- source/libs/executor/src/exchangeoperator.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/libs/executor/src/exchangeoperator.c b/source/libs/executor/src/exchangeoperator.c index 87b5b3c4ec..421fc562a4 100644 --- a/source/libs/executor/src/exchangeoperator.c +++ b/source/libs/executor/src/exchangeoperator.c @@ -337,7 +337,7 @@ static int32_t initExchangeOperator(SExchangePhysiNode* pExNode, SExchangeInfo* SExchangeSrcIndex idx = {.srcIdx = i, .inUseIdx = -1}; int32_t code = tSimpleHashPut(pInfo->pHashSources, &pNode->addr.nodeId, sizeof(pNode->addr.nodeId), &idx, sizeof(idx)); - if (code != TSDB_CODE_SUCCESS) { + if (pInfo->pHashSources && code != TSDB_CODE_SUCCESS) { qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); return code; } From 432731b7767428e3679d6a5bb1aaa967512f3829 Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao> Date: Tue, 23 Jul 2024 14:19:04 +0800 Subject: [PATCH 08/15] fix ci issue --- source/libs/executor/src/cachescanoperator.c | 10 ++++-- .../libs/executor/src/eventwindowoperator.c | 2 +- source/libs/executor/src/executil.c | 26 ++++++++++------ source/libs/executor/src/executor.c | 2 +- source/libs/executor/src/groupoperator.c | 10 ++++-- source/libs/executor/src/scanoperator.c | 31 +++++++++++++------ .../executor/src/streamtimewindowoperator.c | 6 ++-- source/libs/executor/src/sysscanoperator.c | 20 +++++++----- 8 files changed, 72 insertions(+), 35 deletions(-) diff --git a/source/libs/executor/src/cachescanoperator.c b/source/libs/executor/src/cachescanoperator.c index 8559a44348..c153012817 100644 --- a/source/libs/executor/src/cachescanoperator.c +++ b/source/libs/executor/src/cachescanoperator.c @@ -132,9 +132,15 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe } SArray* pCidList = taosArrayInit(numOfCols, sizeof(int16_t)); + QUERY_CHECK_NULL(pCidList, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + pInfo->pFuncTypeList = taosArrayInit(taosArrayGetSize(pScanNode->pFuncTypes), sizeof(int32_t)); + QUERY_CHECK_NULL(pInfo->pFuncTypeList, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + void* tmp = taosArrayAddAll(pInfo->pFuncTypeList, pScanNode->pFuncTypes); - QUERY_CHECK_NULL(tmp, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + if (!tmp && taosArrayGetSize(pScanNode->pFuncTypes) > 0) { + QUERY_CHECK_NULL(tmp, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); + } for (int i = 0; i < TARRAY_SIZE(pInfo->matchInfo.pList); ++i) { SColMatchItem* pColInfo = taosArrayGet(pInfo->matchInfo.pList, i); @@ -206,7 +212,7 @@ SOperatorInfo* createCacherowsScanOperator(SLastRowScanPhysiNode* pScanNode, SRe _error: pTaskInfo->code = code; if (code != TSDB_CODE_SUCCESS) { - qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); } destroyCacheScanOperator(pInfo); taosMemoryFree(pOperator); diff --git a/source/libs/executor/src/eventwindowoperator.c b/source/libs/executor/src/eventwindowoperator.c index 75153e3a08..1988dff44f 100644 --- a/source/libs/executor/src/eventwindowoperator.c +++ b/source/libs/executor/src/eventwindowoperator.c @@ -350,7 +350,7 @@ int32_t eventWindowAggImpl(SOperatorInfo* pOperator, SEventWindowOperatorInfo* p _return: if (code != TSDB_CODE_SUCCESS) { - qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); } colDataDestroy(ps); taosMemoryFree(ps); diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c index 2c1d3983cd..f2de61f625 100644 --- a/source/libs/executor/src/executil.c +++ b/source/libs/executor/src/executil.c @@ -428,7 +428,7 @@ static EDealRes getColumn(SNode** pNode, void* pContext) { if (!data) { int32_t code = taosHashPut(pData->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode))); - if (code != TSDB_CODE_SUCCESS) { + if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { return DEAL_RES_ERROR; } pSColumnNode->slotId = pData->index++; @@ -440,7 +440,7 @@ static EDealRes getColumn(SNode** pNode, void* pContext) { qDebug("tagfilter build column info, slotId:%d, colId:%d, type:%d", pSColumnNode->slotId, cInfo.colId, cInfo.type); #endif void* tmp = taosArrayPush(pData->cInfoList, &cInfo); - if(!tmp) { + if (!tmp) { return DEAL_RES_ERROR; } } else { @@ -741,7 +741,10 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf // groupId ~ table uid code = taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId), &(info->uid), sizeof(info->uid)); - QUERY_CHECK_CODE(code, lino, end); + if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { + lino = __LINE__; + goto end; + } } } @@ -942,7 +945,7 @@ static int32_t optimizeTbnameInCondImpl(void* pVnode, SArray* pExistedUidList, S for (int i = 0; i < numOfExisted; i++) { STUidTagInfo* pTInfo = taosArrayGet(pExistedUidList, i); int32_t code = taosHashPut(uHash, &pTInfo->uid, sizeof(uint64_t), &i, sizeof(i)); - if (code != TSDB_CODE_SUCCESS) { + if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); return code; } @@ -1793,8 +1796,8 @@ static int32_t setSelectValueColumnInfo(SqlFunctionCtx* pCtx, int32_t numOfOutpu SHashObj* pSelectFuncs = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, HASH_ENTRY_LOCK); for (int32_t i = 0; i < numOfOutput; ++i) { const char* pName = pCtx[i].pExpr->pExpr->_function.functionName; - if ((strcmp(pName, "_select_value") == 0) || (strcmp(pName, "_group_key") == 0) - || (strcmp(pName, "_group_const_value") == 0)) { + if ((strcmp(pName, "_select_value") == 0) || (strcmp(pName, "_group_key") == 0) || + (strcmp(pName, "_group_const_value") == 0)) { pValCtx[num++] = &pCtx[i]; } else if (fmIsSelectFunc(pCtx[i].functionId)) { void* data = taosHashGet(pSelectFuncs, pName, strlen(pName)); @@ -1803,7 +1806,7 @@ static int32_t setSelectValueColumnInfo(SqlFunctionCtx* pCtx, int32_t numOfOutpu break; } else { int32_t code = taosHashPut(pSelectFuncs, pName, strlen(pName), &num, sizeof(num)); - if (code != TSDB_CODE_SUCCESS) { + if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); return code; } @@ -2239,7 +2242,10 @@ int32_t tableListAddTableInfo(STableListInfo* pTableList, uint64_t uid, uint64_t int32_t slot = (int32_t)taosArrayGetSize(pTableList->pTableList) - 1; code = taosHashPut(pTableList->map, &uid, sizeof(uid), &slot, sizeof(slot)); - QUERY_CHECK_CODE(code, lino, _end); + if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { + lino = __LINE__; + goto _end; + } _end: if (code != TSDB_CODE_SUCCESS) { @@ -2416,7 +2422,7 @@ int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle* code = taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId), &(info->uid), sizeof(info->uid)); - if (code != TSDB_CODE_SUCCESS) { + if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); return code; } @@ -2468,7 +2474,7 @@ int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle* for (int32_t i = 0; i < size; ++i) { STableKeyInfo* p = taosArrayGet(pTableListInfo->pTableList, i); code = taosHashPut(pTableListInfo->map, &p->uid, sizeof(uint64_t), &i, sizeof(int32_t)); - if (code != TSDB_CODE_SUCCESS) { + if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); return code; } diff --git a/source/libs/executor/src/executor.c b/source/libs/executor/src/executor.c index 8cf44602f9..960269d18e 100644 --- a/source/libs/executor/src/executor.c +++ b/source/libs/executor/src/executor.c @@ -97,7 +97,7 @@ static int32_t doSetSMABlock(SOperatorInfo* pOperator, void* input, size_t numOf _end: if (code != TSDB_CODE_SUCCESS) { - qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); } return code; } diff --git a/source/libs/executor/src/groupoperator.c b/source/libs/executor/src/groupoperator.c index 2e660ef1bc..1d39f20757 100644 --- a/source/libs/executor/src/groupoperator.c +++ b/source/libs/executor/src/groupoperator.c @@ -774,7 +774,10 @@ void* getCurrentDataGroupInfo(const SPartitionOperatorInfo* pInfo, SDataGroupInf 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); + if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { + lino = __LINE__; + goto _end; + } p = taosHashGet(pInfo->pGroupSet, pInfo->keyBuf, len); @@ -1397,7 +1400,10 @@ static void doStreamHashPartitionImpl(SStreamPartitionOperatorInfo* pInfo, SSDat code = taosHashPut(pInfo->pPartitions, pInfo->partitionSup.keyBuf, keyLen, &newParData, sizeof(SPartitionDataInfo)); - QUERY_CHECK_CODE(code, lino, _end); + if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { + lino = __LINE__; + goto _end; + } } } diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index 103378c3ef..3260be63ed 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -175,8 +175,13 @@ static int32_t insertTableToScanIgnoreList(STableScanInfo* pTableScanInfo, uint6 } } - return taosHashPut(pTableScanInfo->pIgnoreTables, &uid, sizeof(uid), &pTableScanInfo->scanTimes, - sizeof(pTableScanInfo->scanTimes)); + int32_t code = taosHashPut(pTableScanInfo->pIgnoreTables, &uid, sizeof(uid), &pTableScanInfo->scanTimes, + sizeof(pTableScanInfo->scanTimes)); + if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + return code; + } + return TSDB_CODE_SUCCESS; } static int32_t doDynamicPruneDataBlock(SOperatorInfo* pOperator, SDataBlockInfo* pBlockInfo, uint32_t* status) { @@ -357,10 +362,9 @@ 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; - code = - doFilterByBlockSMA(pOperator->exprSupp.pFilterInfo, pBlock->pBlockAgg, size, pBlockInfo->rows, &keep); + size_t size = taosArrayGetSize(pBlock->pDataBlock); + bool keep = false; + code = doFilterByBlockSMA(pOperator->exprSupp.pFilterInfo, pBlock->pBlockAgg, size, pBlockInfo->rows, &keep); QUERY_CHECK_CODE(code, lino, _end); if (!keep) { @@ -3618,7 +3622,10 @@ void streamScanReloadState(SOperatorInfo* pOperator) { size_t keySize = 0; int64_t* pUid = taosHashGetKey(pIte, &keySize); code = taosHashPut(pUpInfo->pMap, pUid, sizeof(int64_t), pIte, sizeof(TSKEY)); - QUERY_CHECK_CODE(code, lino, _end); + if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { + lino = __LINE__; + goto _end; + } pIte = taosHashIterate(curMap, pIte); } @@ -4005,7 +4012,10 @@ static EDealRes tagScanRewriteTagColumn(SNode** pNode, void* pContext) { void* data = taosHashGet(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId)); if (!data) { code = taosHashPut(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode))); - QUERY_CHECK_CODE(code, lino, _end); + if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { + lino = __LINE__; + goto _end; + } pSColumnNode->slotId = pCtx->index++; SColumnInfo cInfo = {.colId = pSColumnNode->colId, .type = pSColumnNode->node.resType.type, @@ -4912,7 +4922,10 @@ static void tableMergeScanDoSkipTable(uint64_t uid, void* pTableMergeOpInfo) { int bSkip = 1; if (pInfo->mSkipTables != NULL) { code = taosHashPut(pInfo->mSkipTables, &uid, sizeof(uid), &bSkip, sizeof(bSkip)); - QUERY_CHECK_CODE(code, lino, _end); + if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { + lino = __LINE__; + goto _end; + } } _end: diff --git a/source/libs/executor/src/streamtimewindowoperator.c b/source/libs/executor/src/streamtimewindowoperator.c index c47f99cca3..85cbe8f519 100644 --- a/source/libs/executor/src/streamtimewindowoperator.c +++ b/source/libs/executor/src/streamtimewindowoperator.c @@ -1600,7 +1600,7 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) { if (pBlock->info.type != STREAM_CLEAR) { void* tmp = taosArrayAddAll(pInfo->pDelWins, delWins); - if (!tmp) { + if (!tmp && taosArrayGetSize(delWins) > 0) { code = TSDB_CODE_OUT_OF_MEMORY; QUERY_CHECK_CODE(code, lino, _end); } @@ -1610,7 +1610,7 @@ static SSDataBlock* doStreamFinalIntervalAgg(SOperatorInfo* pOperator) { } removeResults(delWins, pInfo->pUpdatedMap); void* tmp = taosArrayAddAll(pInfo->pDelWins, delWins); - if (!tmp) { + if (!tmp && taosArrayGetSize(delWins) > 0) { code = TSDB_CODE_OUT_OF_MEMORY; QUERY_CHECK_CODE(code, lino, _end); } @@ -5313,7 +5313,7 @@ static SSDataBlock* doStreamMidIntervalAgg(SOperatorInfo* pOperator) { removeResults(delWins, pInfo->pUpdatedMap); void* tmp = taosArrayAddAll(pInfo->pDelWins, delWins); - if (!tmp) { + if (!tmp && taosArrayGetSize(delWins) > 0) { code = TSDB_CODE_OUT_OF_MEMORY; QUERY_CHECK_CODE(code, lino, _end); } diff --git a/source/libs/executor/src/sysscanoperator.c b/source/libs/executor/src/sysscanoperator.c index 1b09c47f05..6528ad1b9d 100644 --- a/source/libs/executor/src/sysscanoperator.c +++ b/source/libs/executor/src/sysscanoperator.c @@ -160,8 +160,8 @@ int32_t sysFilte__DbName(void* arg, SNode* pNode, SArray* result) { const char* db = NULL; pArg->pAPI->metaFn.getBasicInfo(pVnode, &db, NULL, NULL, NULL); - SName sn = {0}; - char dbname[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; + SName sn = {0}; + char dbname[TSDB_DB_FNAME_LEN + VARSTR_HEADER_SIZE] = {0}; int32_t code = tNameFromString(&sn, db, T_NAME_ACCT | T_NAME_DB); if (code != TSDB_CODE_SUCCESS) { qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); @@ -596,7 +596,10 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { if (schema == NULL) { SSchemaWrapper* schemaWrapper = tCloneSSchemaWrapper(&pInfo->pCur->mr.me.stbEntry.schemaRow); code = taosHashPut(pInfo->pSchema, &pInfo->pCur->mr.me.uid, sizeof(int64_t), &schemaWrapper, POINTER_BYTES); - QUERY_CHECK_CODE(code, lino, _end); + if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { + lino = __LINE__; + goto _end; + } } continue; } else if (pInfo->pCur->mr.me.type == TSDB_CHILD_TABLE) { @@ -624,7 +627,10 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { } SSchemaWrapper* schemaWrapper = tCloneSSchemaWrapper(&smrSuperTable.me.stbEntry.schemaRow); code = taosHashPut(pInfo->pSchema, &suid, sizeof(int64_t), &schemaWrapper, POINTER_BYTES); - QUERY_CHECK_CODE(code, lino, _end); + if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { + lino = __LINE__; + goto _end; + } schemaRow = schemaWrapper; pAPI->metaReaderFn.clearReader(&smrSuperTable); @@ -745,7 +751,8 @@ static SSDataBlock* sysTableScanUserTags(SOperatorInfo* pOperator) { return NULL; } - code = sysTableUserTagsFillOneTableTags(pInfo, &smrSuperTable, &smrChildTable, dbname, tableName, &numOfRows, dataBlock); + code = sysTableUserTagsFillOneTableTags(pInfo, &smrSuperTable, &smrChildTable, dbname, tableName, &numOfRows, + dataBlock); QUERY_CHECK_CODE(code, lino, _end); pAPI->metaReaderFn.clearReader(&smrSuperTable); @@ -2571,8 +2578,7 @@ static SSDataBlock* doBlockInfoScan(SOperatorInfo* pOperator) { char* p = taosMemoryCalloc(1, len + VARSTR_HEADER_SIZE); QUERY_CHECK_NULL(p, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); - code = tSerializeBlockDistInfo(varDataVal(p), len, &blockDistInfo); - QUERY_CHECK_CODE(code, lino, _end); + (void)tSerializeBlockDistInfo(varDataVal(p), len, &blockDistInfo); varDataSetLen(p, len); code = colDataSetVal(pColInfo, 0, p, false); From 9e8d94a69a10812ac870a19e96c2e9204b643d8e Mon Sep 17 00:00:00 2001 From: dapan1121 Date: Tue, 23 Jul 2024 15:03:24 +0800 Subject: [PATCH 09/15] fix: add function return code validation --- include/os/osEnv.h | 4 +- include/os/osTimezone.h | 2 +- source/client/src/clientMonitor.c | 3 +- source/common/src/tglobal.c | 1 - source/dnode/mgmt/node_mgmt/src/dmEnv.c | 2 - source/dnode/mgmt/node_mgmt/src/dmNodes.c | 1 - source/dnode/mgmt/node_util/src/dmFile.c | 1 - source/dnode/mnode/impl/src/mndMain.c | 1 - source/libs/tdb/src/db/tdbDb.c | 2 +- source/libs/wal/src/walMgmt.c | 2 +- source/os/src/osDir.c | 106 ++++++++++++++-------- source/os/src/osEnv.c | 39 ++++---- source/os/src/osFile.c | 70 +++++++++----- source/os/src/osSleep.c | 8 +- source/os/src/osTimer.c | 31 ++++--- source/os/src/osTimezone.c | 49 ++++++---- source/util/src/tconfig.c | 3 +- 17 files changed, 197 insertions(+), 128 deletions(-) diff --git a/include/os/osEnv.h b/include/os/osEnv.h index 4f4a58d4e8..5f7cdf44dc 100644 --- a/include/os/osEnv.h +++ b/include/os/osEnv.h @@ -54,7 +54,7 @@ extern SDiskSpace tsDataSpace; extern SDiskSpace tsLogSpace; extern SDiskSpace tsTempSpace; -void osDefaultInit(); +int32_t osDefaultInit(); void osUpdate(); void osCleanup(); @@ -66,7 +66,7 @@ bool osLogSpaceSufficient(); bool osDataSpaceSufficient(); bool osTempSpaceSufficient(); -void osSetTimezone(const char *timezone); +int32_t osSetTimezone(const char *timezone); void osSetSystemLocale(const char *inLocale, const char *inCharSet); void osSetProcPath(int32_t argc, char **argv); diff --git a/include/os/osTimezone.h b/include/os/osTimezone.h index ce573d320b..fab42e8e11 100644 --- a/include/os/osTimezone.h +++ b/include/os/osTimezone.h @@ -55,7 +55,7 @@ enum TdTimezone { }; void taosGetSystemTimezone(char *outTimezone, enum TdTimezone *tsTimezone); -void taosSetSystemTimezone(const char *inTimezone, char *outTimezone, int8_t *outDaylight, enum TdTimezone *tsTimezone); +int32_t taosSetSystemTimezone(const char *inTimezone, char *outTimezone, int8_t *outDaylight, enum TdTimezone *tsTimezone); #ifdef __cplusplus } diff --git a/source/client/src/clientMonitor.c b/source/client/src/clientMonitor.c index b8b57160fe..e3b073dbc8 100644 --- a/source/client/src/clientMonitor.c +++ b/source/client/src/clientMonitor.c @@ -801,9 +801,8 @@ int32_t monitorInit() { } if (taosMulModeMkDir(tmpSlowLogPath, 0777, true) != 0) { - terrno = TAOS_SYSTEM_ERROR(errno); tscError("failed to create dir:%s since %s", tmpSlowLogPath, terrstr()); - return -1; + return terrno; } if (tsem2_init(&monitorSem, 0, 0) != 0) { diff --git a/source/common/src/tglobal.c b/source/common/src/tglobal.c index 7538b504e3..c4905de898 100644 --- a/source/common/src/tglobal.c +++ b/source/common/src/tglobal.c @@ -1306,7 +1306,6 @@ int32_t taosCreateLog(const char *logname, int32_t logFileNum, const char *cfgDi taosSetAllDebugFlag(pCfg, cfgGetItem(pCfg, "debugFlag")->i32); if (taosMulModeMkDir(tsLogDir, 0777, true) != 0) { - terrno = TAOS_SYSTEM_ERROR(errno); printf("failed to create dir:%s since %s", tsLogDir, terrstr()); cfgCleanup(pCfg); return -1; diff --git a/source/dnode/mgmt/node_mgmt/src/dmEnv.c b/source/dnode/mgmt/node_mgmt/src/dmEnv.c index f636629b3a..98a8bccf0d 100644 --- a/source/dnode/mgmt/node_mgmt/src/dmEnv.c +++ b/source/dnode/mgmt/node_mgmt/src/dmEnv.c @@ -244,7 +244,6 @@ static int32_t dmProcessCreateNodeReq(EDndNodeType ntype, SRpcMsg *pMsg) { pWrapper = &pDnode->wrappers[ntype]; if (taosMkDir(pWrapper->path) != 0) { dmReleaseWrapper(pWrapper); - terrno = TAOS_SYSTEM_ERROR(errno); dError("failed to create dir:%s since %s", pWrapper->path, terrstr()); return -1; } @@ -314,7 +313,6 @@ static int32_t dmProcessAlterNodeTypeReq(EDndNodeType ntype, SRpcMsg *pMsg) { pWrapper = &pDnode->wrappers[ntype]; if (taosMkDir(pWrapper->path) != 0) { taosThreadMutexUnlock(&pDnode->mutex); - terrno = TAOS_SYSTEM_ERROR(errno); dError("failed to create dir:%s since %s", pWrapper->path, terrstr()); return -1; } diff --git a/source/dnode/mgmt/node_mgmt/src/dmNodes.c b/source/dnode/mgmt/node_mgmt/src/dmNodes.c index a8bf5be3e2..f25bc03a4d 100644 --- a/source/dnode/mgmt/node_mgmt/src/dmNodes.c +++ b/source/dnode/mgmt/node_mgmt/src/dmNodes.c @@ -20,7 +20,6 @@ int32_t dmOpenNode(SMgmtWrapper *pWrapper) { SDnode *pDnode = pWrapper->pDnode; if (taosMkDir(pWrapper->path) != 0) { - terrno = TAOS_SYSTEM_ERROR(errno); dError("node:%s, failed to create dir:%s since %s", pWrapper->name, pWrapper->path, terrstr()); return -1; } diff --git a/source/dnode/mgmt/node_util/src/dmFile.c b/source/dnode/mgmt/node_util/src/dmFile.c index 752abb83a2..d86c345ce3 100644 --- a/source/dnode/mgmt/node_util/src/dmFile.c +++ b/source/dnode/mgmt/node_util/src/dmFile.c @@ -328,7 +328,6 @@ int32_t dmUpdateEncryptKey(char *key, bool toLogFile) { terrno = 0; if (taosMkDir(folder) != 0) { - terrno = TAOS_SYSTEM_ERROR(errno); encryptError("failed to create dir:%s since %s", folder, terrstr()); goto _OVER; } diff --git a/source/dnode/mnode/impl/src/mndMain.c b/source/dnode/mnode/impl/src/mndMain.c index 723e3701a1..680cc7ab28 100644 --- a/source/dnode/mnode/impl/src/mndMain.c +++ b/source/dnode/mnode/impl/src/mndMain.c @@ -454,7 +454,6 @@ static int32_t mndCreateDir(SMnode *pMnode, const char *path) { } if (taosMkDir(pMnode->path) != 0) { - terrno = TAOS_SYSTEM_ERROR(errno); return -1; } diff --git a/source/libs/tdb/src/db/tdbDb.c b/source/libs/tdb/src/db/tdbDb.c index 9a1d89eeac..1ac6c727ca 100644 --- a/source/libs/tdb/src/db/tdbDb.c +++ b/source/libs/tdb/src/db/tdbDb.c @@ -70,7 +70,7 @@ int32_t tdbOpen(const char *dbname, int32_t szPage, int32_t pages, TDB **ppDb, i ret = taosMulModeMkDir(dbname, 0755, false); if (ret < 0) { - return -1; + return terrno; } #ifdef USE_MAINDB diff --git a/source/libs/wal/src/walMgmt.c b/source/libs/wal/src/walMgmt.c index 3dbaed1bc7..88992ada2a 100644 --- a/source/libs/wal/src/walMgmt.c +++ b/source/libs/wal/src/walMgmt.c @@ -103,7 +103,7 @@ SWal *walOpen(const char *path, SWalCfg *pCfg) { tstrncpy(pWal->path, path, sizeof(pWal->path)); if (taosMkDir(pWal->path) != 0) { - wError("vgId:%d, path:%s, failed to create directory since %s", pWal->cfg.vgId, pWal->path, strerror(errno)); + wError("vgId:%d, path:%s, failed to create directory since %s", pWal->cfg.vgId, pWal->path, tstrerror(terrno)); goto _err; } diff --git a/source/os/src/osDir.c b/source/os/src/osDir.c index 4348629467..c04add2f42 100644 --- a/source/os/src/osDir.c +++ b/source/os/src/osDir.c @@ -109,7 +109,7 @@ void taosRemoveDir(const char *dirname) { } } - taosCloseDir(&pDir); + (void)taosCloseDir(&pDir); (void)rmdir(dirname); // printf("dir:%s is removed\n", dirname); @@ -127,8 +127,13 @@ int32_t taosMkDir(const char *dirname) { #else int32_t code = mkdir(dirname, 0755); #endif - if (code < 0 && errno == EEXIST) { - return 0; + if (-1 == code) { + if (errno == EEXIST) { + return 0; + } else { + terrno = TAOS_SYSTEM_ERROR(errno); + code = terrno; + } } return code; @@ -143,7 +148,7 @@ int32_t taosMulMkDir(const char *dirname) { taosRealPath(dirname, temp, sizeof(temp)); if (temp[1] == ':') pos += 3; #else - strcpy(temp, dirname); + (void)strcpy(temp, dirname); #endif if (taosDirExist(temp)) return code; @@ -165,7 +170,7 @@ int32_t taosMulMkDir(const char *dirname) { code = mkdir(temp, 0755); #endif if (code < 0 && errno != EEXIST) { - // terrno = TAOS_SYSTEM_ERROR(errno); + terrno = TAOS_SYSTEM_ERROR(errno); return code; } *pos = TD_DIRSEP[0]; @@ -181,7 +186,7 @@ int32_t taosMulMkDir(const char *dirname) { code = mkdir(temp, 0755); #endif if (code < 0 && errno != EEXIST) { - // terrno = TAOS_SYSTEM_ERROR(errno); + terrno = TAOS_SYSTEM_ERROR(errno); return code; } } @@ -194,7 +199,10 @@ int32_t taosMulMkDir(const char *dirname) { } int32_t taosMulModeMkDir(const char *dirname, int mode, bool checkAccess) { - if (dirname == NULL || strlen(dirname) >= TDDIRMAXLEN) return -1; + if (dirname == NULL || strlen(dirname) >= TDDIRMAXLEN) { + terrno = TSDB_CODE_INVALID_PARA; + return terrno; + } char temp[TDDIRMAXLEN]; char *pos = temp; int32_t code = 0; @@ -202,14 +210,18 @@ int32_t taosMulModeMkDir(const char *dirname, int mode, bool checkAccess) { taosRealPath(dirname, temp, sizeof(temp)); if (temp[1] == ':') pos += 3; #else - strcpy(temp, dirname); + (void)strcpy(temp, dirname); #endif if (taosDirExist(temp)) { if (checkAccess && taosCheckAccessFile(temp, TD_FILE_ACCESS_EXIST_OK | TD_FILE_ACCESS_READ_OK | TD_FILE_ACCESS_WRITE_OK)) { return 0; } - return chmod(temp, mode); + code = chmod(temp, mode); + if (-1 == code) { + terrno = TAOS_SYSTEM_ERROR(errno); + return terrno; + } } if (strncmp(temp, TD_DIRSEP, 1) == 0) { @@ -229,8 +241,8 @@ int32_t taosMulModeMkDir(const char *dirname, int mode, bool checkAccess) { code = mkdir(temp, mode); #endif if (code < 0 && errno != EEXIST) { - // terrno = TAOS_SYSTEM_ERROR(errno); - return code; + terrno = TAOS_SYSTEM_ERROR(errno); + return terrno; } *pos = TD_DIRSEP[0]; } @@ -245,8 +257,8 @@ int32_t taosMulModeMkDir(const char *dirname, int mode, bool checkAccess) { code = mkdir(temp, mode); #endif if (code < 0 && errno != EEXIST) { - // terrno = TAOS_SYSTEM_ERROR(errno); - return code; + terrno = TAOS_SYSTEM_ERROR(errno); + return terrno; } } @@ -254,10 +266,14 @@ int32_t taosMulModeMkDir(const char *dirname, int mode, bool checkAccess) { if (checkAccess && taosCheckAccessFile(temp, TD_FILE_ACCESS_EXIST_OK | TD_FILE_ACCESS_READ_OK | TD_FILE_ACCESS_WRITE_OK)) { return 0; } - return chmod(temp, mode); } - return chmod(temp, mode); + code = chmod(temp, mode); + if (-1 == code) { + terrno = TAOS_SYSTEM_ERROR(errno); + return terrno; + } + return code; } void taosRemoveOldFiles(const char *dirname, int32_t keepDays) { @@ -271,7 +287,7 @@ void taosRemoveOldFiles(const char *dirname, int32_t keepDays) { if (strcmp(taosGetDirEntryName(de), ".") == 0 || strcmp(taosGetDirEntryName(de), "..") == 0) continue; char filename[1024]; - snprintf(filename, sizeof(filename), "%s/%s", dirname, taosGetDirEntryName(de)); + (void)snprintf(filename, sizeof(filename), "%s/%s", dirname, taosGetDirEntryName(de)); if (taosDirEntryIsDir(de)) { continue; } else { @@ -299,34 +315,25 @@ void taosRemoveOldFiles(const char *dirname, int32_t keepDays) { } } - taosCloseDir(&pDir); - rmdir(dirname); + (void)taosCloseDir(&pDir); + (void)rmdir(dirname); } int32_t taosExpandDir(const char *dirname, char *outname, int32_t maxlen) { wordexp_t full_path; - switch (wordexp(dirname, &full_path, 0)) { + int32_t code = wordexp(dirname, &full_path, 0); + switch (code) { case 0: break; case WRDE_NOSPACE: wordfree(&full_path); - // printf("failed to expand path:%s since Out of memory\n", dirname); - return -1; - case WRDE_BADCHAR: - // printf("failed to expand path:%s since illegal occurrence of newline or one of |, &, ;, <, >, (, ), {, }\n", - // dirname); - return -1; - case WRDE_SYNTAX: - // printf("failed to expand path:%s since Shell syntax error, such as unbalanced parentheses or unmatched - // quotes\n", dirname); - return -1; + // FALL THROUGH default: - // printf("failed to expand path:%s since %s\n", dirname, strerror(errno)); - return -1; + return code; } if (full_path.we_wordv != NULL && full_path.we_wordv[0] != NULL) { - strncpy(outname, full_path.we_wordv[0], maxlen); + (void)strncpy(outname, full_path.we_wordv[0], maxlen); } wordfree(&full_path); @@ -343,21 +350,23 @@ int32_t taosRealPath(char *dirname, char *realPath, int32_t maxlen) { #endif if (strlen(tmp) < maxlen) { if (realPath == NULL) { - strncpy(dirname, tmp, maxlen); + (void)strncpy(dirname, tmp, maxlen); } else { - strncpy(realPath, tmp, maxlen); + (void)strncpy(realPath, tmp, maxlen); } return 0; } } - return -1; + terrno = TAOS_SYSTEM_ERROR(errno); + + return terrno; } bool taosIsDir(const char *dirname) { TdDirPtr pDir = taosOpenDir(dirname); if (pDir != NULL) { - taosCloseDir(&pDir); + (void)taosCloseDir(&pDir); return true; } return false; @@ -410,6 +419,7 @@ char *taosDirEntryBaseName(char *name) { TdDirPtr taosOpenDir(const char *dirname) { if (dirname == NULL) { + terrno = TSDB_CODE_INVALID_PARA; return NULL; } @@ -436,12 +446,17 @@ TdDirPtr taosOpenDir(const char *dirname) { dirPtr->pDir = pDir; return dirPtr; #else - return (TdDirPtr)opendir(dirname); + TdDirPtr ptr = (TdDirPtr)opendir(dirname); + if (NULL == ptr) { + terrno = TAOS_SYSTEM_ERROR(errno); + } + return ptr; #endif } TdDirEntryPtr taosReadDir(TdDirPtr pDir) { if (pDir == NULL) { + terrno = TSDB_CODE_INVALID_PARA; return NULL; } #ifdef WINDOWS @@ -456,7 +471,13 @@ TdDirEntryPtr taosReadDir(TdDirPtr pDir) { return NULL; } #else - return (TdDirEntryPtr)readdir((DIR *)pDir); + errno = 0; + terrno = 0; + TdDirEntryPtr p = (TdDirEntryPtr)readdir((DIR *)pDir); + if (NULL == p && errno) { + terrno = TAOS_SYSTEM_ERROR(errno); + } + return p; #endif } @@ -484,7 +505,8 @@ char *taosGetDirEntryName(TdDirEntryPtr pDirEntry) { int32_t taosCloseDir(TdDirPtr *ppDir) { if (ppDir == NULL || *ppDir == NULL) { - return -1; + terrno = TSDB_CODE_INVALID_PARA; + return terrno; } #ifdef WINDOWS FindClose((*ppDir)->hFind); @@ -497,8 +519,12 @@ int32_t taosCloseDir(TdDirPtr *ppDir) { *ppDir = NULL; return 0; #else - closedir((DIR *)*ppDir); + int32_t code = closedir((DIR *)*ppDir); *ppDir = NULL; + if (-1 == code) { + terrno = TAOS_SYSTEM_ERROR(errno); + return terrno; + } return 0; #endif } diff --git a/source/os/src/osEnv.c b/source/os/src/osEnv.c index 948040ac76..72f0a41710 100644 --- a/source/os/src/osEnv.c +++ b/source/os/src/osEnv.c @@ -45,11 +45,16 @@ char tsAVX2Supported = 0; char tsFMASupported = 0; char tsAVX512Supported = 0; -void osDefaultInit() { +int32_t osDefaultInit() { + int32_t code = TSDB_CODE_SUCCESS; + taosSeedRand(taosSafeRand()); taosGetSystemLocale(tsLocale, tsCharset); taosGetSystemTimezone(tsTimezoneStr, &tsTimezone); - taosSetSystemTimezone(tsTimezoneStr, tsTimezoneStr, &tsDaylight, &tsTimezone); + code = taosSetSystemTimezone(tsTimezoneStr, tsTimezoneStr, &tsDaylight, &tsTimezone); + if (code) { + return code; + } taosGetSystemInfo(); // deadlock in query @@ -65,33 +70,35 @@ void osDefaultInit() { tmpDir = getenv("temp"); } if (tmpDir != NULL) { - strcpy(tsTempDir, tmpDir); + (void)strcpy(tsTempDir, tmpDir); } - strcpy(tsOsName, "Windows"); + (void)strcpy(tsOsName, "Windows"); #elif defined(_TD_DARWIN_64) - strcpy(tsOsName, "Darwin"); + (void)strcpy(tsOsName, "Darwin"); #else - strcpy(tsOsName, "Linux"); + (void)strcpy(tsOsName, "Linux"); #endif if (configDir[0] == 0) { - strcpy(configDir, TD_CFG_DIR_PATH); + (void)strcpy(configDir, TD_CFG_DIR_PATH); } - strcpy(tsDataDir, TD_DATA_DIR_PATH); - strcpy(tsLogDir, TD_LOG_DIR_PATH); + (void)strcpy(tsDataDir, TD_DATA_DIR_PATH); + (void)strcpy(tsLogDir, TD_LOG_DIR_PATH); if(strlen(tsTempDir) == 0){ - strcpy(tsTempDir, TD_TMP_DIR_PATH); + (void)strcpy(tsTempDir, TD_TMP_DIR_PATH); } + + return code; } void osUpdate() { if (tsLogDir[0] != 0) { - taosGetDiskSize(tsLogDir, &tsLogSpace.size); + (void)taosGetDiskSize(tsLogDir, &tsLogSpace.size); } if (tsDataDir[0] != 0) { - taosGetDiskSize(tsDataDir, &tsDataSpace.size); + (void)taosGetDiskSize(tsDataDir, &tsDataSpace.size); } if (tsTempDir[0] != 0) { - taosGetDiskSize(tsTempDir, &tsTempSpace.size); + (void)taosGetDiskSize(tsTempDir, &tsTempSpace.size); } } @@ -109,11 +116,11 @@ bool osDataSpaceSufficient() { return tsDataSpace.size.avail > tsDataSpace.reser bool osTempSpaceSufficient() { return tsTempSpace.size.avail > tsTempSpace.reserved; } -void osSetTimezone(const char *tz) { taosSetSystemTimezone(tz, tsTimezoneStr, &tsDaylight, &tsTimezone); } +int32_t osSetTimezone(const char *tz) { return taosSetSystemTimezone(tz, tsTimezoneStr, &tsDaylight, &tsTimezone); } void osSetSystemLocale(const char *inLocale, const char *inCharSet) { - memcpy(tsLocale, inLocale, strlen(inLocale) + 1); - memcpy(tsCharset, inCharSet, strlen(inCharSet) + 1); + (void)memcpy(tsLocale, inLocale, strlen(inLocale) + 1); + (void)memcpy(tsCharset, inCharSet, strlen(inCharSet) + 1); } void osSetProcPath(int32_t argc, char **argv) { tsProcPath = argv[0]; } diff --git a/source/os/src/osFile.c b/source/os/src/osFile.c index f63339bcfc..0581df573a 100644 --- a/source/os/src/osFile.c +++ b/source/os/src/osFile.c @@ -90,24 +90,24 @@ void taosGetTmpfilePath(const char *inputTmpDir, const char *fileNamePrefix, cha char tmpPath[PATH_MAX]; int32_t len = strlen(inputTmpDir); - memcpy(tmpPath, inputTmpDir, len); + (void)memcpy(tmpPath, inputTmpDir, len); static uint64_t seqId = 0; if (tmpPath[len - 1] != '/') { tmpPath[len++] = '/'; } - strcpy(tmpPath + len, TD_TMP_FILE_PREFIX); + (void)strcpy(tmpPath + len, TD_TMP_FILE_PREFIX); if (strlen(tmpPath) + strlen(fileNamePrefix) + strlen("-%d-%s") < PATH_MAX) { - strcat(tmpPath, fileNamePrefix); - strcat(tmpPath, "-%d-%s"); + (void)strcat(tmpPath, fileNamePrefix); + (void)strcat(tmpPath, "-%d-%s"); } char rand[32] = {0}; - sprintf(rand, "%" PRIu64, atomic_add_fetch_64(&seqId, 1)); + (void)sprintf(rand, "%" PRIu64, atomic_add_fetch_64(&seqId, 1)); - snprintf(dstPath, PATH_MAX, tmpPath, getpid(), rand); + (void)snprintf(dstPath, PATH_MAX, tmpPath, getpid(), rand); #endif } @@ -123,6 +123,7 @@ int64_t taosCopyFile(const char *from, const char *to) { char buffer[4096]; int64_t size = 0; int64_t bytes; + int32_t code = TSDB_CODE_SUCCESS; // fidfrom = open(from, O_RDONLY); TdFilePtr pFileFrom = taosOpenFile(from, TD_FILE_READ); @@ -143,7 +144,7 @@ int64_t taosCopyFile(const char *from, const char *to) { if (bytes < sizeof(buffer)) break; } - int code = taosFsyncFile(pFileTo); + code = taosFsyncFile(pFileTo); taosCloseFile(&pFileFrom); taosCloseFile(&pFileTo); @@ -154,10 +155,12 @@ int64_t taosCopyFile(const char *from, const char *to) { return size; _err: + if (pFileFrom != NULL) taosCloseFile(&pFileFrom); if (pFileTo != NULL) taosCloseFile(&pFileTo); /* coverity[+retval] */ taosRemoveFile(to); + return -1; #endif } @@ -301,11 +304,15 @@ FILE *taosOpenFileForStream(const char *path, int32_t tdFileOptions) { } else { mode = (tdFileOptions & TD_FILE_TEXT) ? "rt+" : "rb+"; } - ASSERT(!(tdFileOptions & TD_FILE_EXCL)); if (tdFileOptions & TD_FILE_EXCL) { + terrno = TSDB_CODE_INVALID_PARA; return NULL; } - return fopen(path, mode); + FILE* f = fopen(path, mode); + if (NULL == f) { + terrno = TAOS_SYSTEM_ERROR(errno); + } + return f; } #ifdef WINDOWS @@ -653,6 +660,9 @@ int taosOpenFileNotStream(const char *path, int32_t tdFileOptions) { access |= (tdFileOptions & TD_FILE_CLOEXEC) ? O_CLOEXEC : 0; int fd = open(path, access, S_IRWXU | S_IRWXG | S_IRWXO); + if (-1 == fd) { + terrno = TAOS_SYSTEM_ERROR(errno); + } return fd; } @@ -1060,14 +1070,14 @@ TdFilePtr taosOpenFile(const char *path, int32_t tdFileOptions) { #ifdef WINDOWS if (hFile != NULL) CloseHandle(hFile); #else - if (fd >= 0) close(fd); + if (fd >= 0) (void)close(fd); #endif - if (fp != NULL) fclose(fp); + if (fp != NULL) (void)fclose(fp); return NULL; } #if FILE_WITH_LOCK - taosThreadRwlockInit(&(pFile->rwlock), NULL); + (void)taosThreadRwlockInit(&(pFile->rwlock), NULL); #endif pFile->fp = fp; pFile->refId = 0; @@ -1082,9 +1092,15 @@ TdFilePtr taosOpenFile(const char *path, int32_t tdFileOptions) { // Remove it instantly, so when the program exits normally/abnormally, the file // will be automatically remove by OS. if (tdFileOptions & TD_FILE_AUTO_DEL) { - unlink(path); + if (-1 == unlink(path)) { + terrno = TAOS_SYSTEM_ERROR(errno); + (void)close(fd); + taosMemoryFree(pFile); + return NULL; + } } #endif + return pFile; } @@ -1094,11 +1110,11 @@ int32_t taosCloseFile(TdFilePtr *ppFile) { return 0; } #if FILE_WITH_LOCK - taosThreadRwlockWrlock(&((*ppFile)->rwlock)); + (void)taosThreadRwlockWrlock(&((*ppFile)->rwlock)); #endif if ((*ppFile)->fp != NULL) { - fflush((*ppFile)->fp); - fclose((*ppFile)->fp); + (void)fflush((*ppFile)->fp); + (void)fclose((*ppFile)->fp); (*ppFile)->fp = NULL; } #ifdef WINDOWS @@ -1113,16 +1129,20 @@ int32_t taosCloseFile(TdFilePtr *ppFile) { // warning: never fsync silently in base lib /*fsync((*ppFile)->fd);*/ code = close((*ppFile)->fd); + if (-1 == code) { + terrno = TAOS_SYSTEM_ERROR(errno); + } (*ppFile)->fd = -1; #endif } (*ppFile)->refId = 0; #if FILE_WITH_LOCK - taosThreadRwlockUnlock(&((*ppFile)->rwlock)); - taosThreadRwlockDestroy(&((*ppFile)->rwlock)); + (void)taosThreadRwlockUnlock(&((*ppFile)->rwlock)); + (void)taosThreadRwlockDestroy(&((*ppFile)->rwlock)); #endif taosMemoryFree(*ppFile); *ppFile = NULL; + return code; } @@ -1155,20 +1175,28 @@ int64_t taosPReadFile(TdFilePtr pFile, void *buf, int64_t count, int64_t offset) } #else #if FILE_WITH_LOCK - taosThreadRwlockRdlock(&(pFile->rwlock)); + (void)taosThreadRwlockRdlock(&(pFile->rwlock)); #endif ASSERT(pFile->fd >= 0); // Please check if you have closed the file. if (pFile->fd < 0) { #if FILE_WITH_LOCK - taosThreadRwlockUnlock(&(pFile->rwlock)); + (void)taosThreadRwlockUnlock(&(pFile->rwlock)); #endif + terrno = TSDB_CODE_INVALID_PARA; return -1; } + int32_t code = 0; int64_t ret = pread(pFile->fd, buf, count, offset); + if (-1 == ret) { + code = TAOS_SYSTEM_ERROR(errno); + } #endif #if FILE_WITH_LOCK - taosThreadRwlockUnlock(&(pFile->rwlock)); + (void)taosThreadRwlockUnlock(&(pFile->rwlock)); #endif + + terrno = code; + return ret; } diff --git a/source/os/src/osSleep.c b/source/os/src/osSleep.c index f6cc7d608d..f72805b15d 100644 --- a/source/os/src/osSleep.c +++ b/source/os/src/osSleep.c @@ -26,7 +26,9 @@ void taosSsleep(int32_t s) { #ifdef WINDOWS Sleep(1000 * s); #else - sleep(s); + while (s > 0) { + s = sleep(s); + } #endif } @@ -35,7 +37,7 @@ void taosMsleep(int32_t ms) { #ifdef WINDOWS Sleep(ms); #else - usleep(ms * 1000); + (void)usleep(ms * 1000); #endif } @@ -51,6 +53,6 @@ void taosUsleep(int32_t us) { WaitForSingleObject(timer, INFINITE); CloseHandle(timer); #else - usleep(us); + (void)usleep(us); #endif } diff --git a/source/os/src/osTimer.c b/source/os/src/osTimer.c index 36d364382a..6e5d9844a9 100644 --- a/source/os/src/osTimer.c +++ b/source/os/src/osTimer.c @@ -80,7 +80,7 @@ void taos_block_sigalrm(void) { static void taosDeleteTimer(void *tharg) { timer_t *pTimer = tharg; - timer_delete(*pTimer); + (void)timer_delete(*pTimer); } static TdThread timerThread; @@ -90,9 +90,9 @@ static volatile bool stopTimer = false; static void *taosProcessAlarmSignal(void *tharg) { // Block the signal sigset_t sigset; - sigemptyset(&sigset); - sigaddset(&sigset, SIGALRM); - sigprocmask(SIG_BLOCK, &sigset, NULL); + (void)sigemptyset(&sigset); + (void)sigaddset(&sigset, SIGALRM); + (void)sigprocmask(SIG_BLOCK, &sigset, NULL); void (*callback)(int) = tharg; struct sigevent sevent = {{0}}; @@ -110,7 +110,8 @@ static void *taosProcessAlarmSignal(void *tharg) { sevent.sigev_signo = SIGALRM; if (timer_create(CLOCK_REALTIME, &sevent, &timerId) == -1) { - // printf("Failed to create timer"); + terrno = TAOS_SYSTEM_ERROR(errno); + return NULL; } taosThreadCleanupPush(taosDeleteTimer, &timerId); @@ -122,15 +123,17 @@ static void *taosProcessAlarmSignal(void *tharg) { ts.it_interval.tv_sec = 0; ts.it_interval.tv_nsec = 1000000 * MSECONDS_PER_TICK; - if (timer_settime(timerId, 0, &ts, NULL)) { - // printf("Failed to init timer"); + if (-1 == timer_settime(timerId, 0, &ts, NULL)) { + terrno = TAOS_SYSTEM_ERROR(errno); break; } int signo; + int32_t code = 0; while (!stopTimer) { - if (sigwait(&sigset, &signo)) { - // printf("Failed to wait signal: number %d", signo); + code = sigwait(&sigset, &signo); + if (code) { + terrno = TAOS_SYSTEM_ERROR(code); continue; } /* //printf("Signal handling: number %d ......\n", signo); */ @@ -178,14 +181,12 @@ int taosInitTimer(void (*callback)(int), int ms) { #else stopTimer = false; TdThreadAttr tattr; - taosThreadAttrInit(&tattr); + (void)taosThreadAttrInit(&tattr); int code = taosThreadCreate(&timerThread, &tattr, taosProcessAlarmSignal, callback); - taosThreadAttrDestroy(&tattr); + (void)taosThreadAttrDestroy(&tattr); if (code != 0) { // printf("failed to create timer thread"); - return -1; - } else { - // printf("timer thread:0x%08" PRIx64 " is created", taosGetPthreadId(timerThread)); + return TAOS_SYSTEM_ERROR(code); } return 0; @@ -210,7 +211,7 @@ void taosUninitTimer() { stopTimer = true; // printf("join timer thread:0x%08" PRIx64, taosGetPthreadId(timerThread)); - taosThreadJoin(timerThread, NULL); + (void)taosThreadJoin(timerThread, NULL); #endif } diff --git a/source/os/src/osTimezone.c b/source/os/src/osTimezone.c index 72f7dda41c..8780fb2bc2 100644 --- a/source/os/src/osTimezone.c +++ b/source/os/src/osTimezone.c @@ -742,12 +742,20 @@ char *tz_win[554][2] = {{"Asia/Shanghai", "China Standard Time"}, static int isdst_now = 0; -void taosSetSystemTimezone(const char *inTimezoneStr, char *outTimezoneStr, int8_t *outDaylight, +int32_t taosSetSystemTimezone(const char *inTimezoneStr, char *outTimezoneStr, int8_t *outDaylight, enum TdTimezone *tsTimezone) { - if (inTimezoneStr == NULL || inTimezoneStr[0] == 0) return; + if (inTimezoneStr == NULL || inTimezoneStr[0] == 0) { + terrno = TSDB_CODE_INVALID_PARA; + return terrno; + } + int32_t code = TSDB_CODE_SUCCESS; size_t len = strlen(inTimezoneStr); - char *buf = taosMemoryCalloc(len + 1, 1); + if (len >= TD_TIMEZONE_LEN) { + terrno = TSDB_CODE_INVALID_PARA; + return terrno; + } + char buf[TD_TIMEZONE_LEN] = {0}; for (int32_t i = 0; i < len; i++) { if (inTimezoneStr[i] == ' ' || inTimezoneStr[i] == '(') { buf[i] = 0; @@ -813,17 +821,22 @@ void taosSetSystemTimezone(const char *inTimezoneStr, char *outTimezoneStr, int8 *outDaylight = isdst_now; #else - setenv("TZ", buf, 1); + code = setenv("TZ", buf, 1); + if (-1 == code) { + terrno = TAOS_SYSTEM_ERROR(errno); + return terrno; + } + tzset(); int32_t tz = (int32_t)((-timezone * MILLISECOND_PER_SECOND) / MILLISECOND_PER_HOUR); *tsTimezone = tz; tz += isdst_now; - sprintf(outTimezoneStr, "%s (%s, %s%02d00)", buf, tzname[isdst_now], tz >= 0 ? "+" : "-", abs(tz)); + (void)sprintf(outTimezoneStr, "%s (%s, %s%02d00)", buf, tzname[isdst_now], tz >= 0 ? "+" : "-", abs(tz)); *outDaylight = isdst_now; #endif - taosMemoryFree(buf); + return code; } void taosGetSystemTimezone(char *outTimezoneStr, enum TdTimezone *tsTimezone) { @@ -914,7 +927,7 @@ void taosGetSystemTimezone(char *outTimezoneStr, enum TdTimezone *tsTimezone) { { int n = readlink("/etc/localtime", buf, sizeof(buf)-1); if (n < 0) { - printf("read /etc/localtime error, reason:%s", strerror(errno)); + (void)printf("read /etc/localtime error, reason:%s", strerror(errno)); if (taosCheckExistFile("/etc/timezone")) { /* @@ -924,7 +937,7 @@ void taosGetSystemTimezone(char *outTimezoneStr, enum TdTimezone *tsTimezone) { */ time_t tx1 = taosGetTimestampSec(); struct tm tm1; - taosLocalTime(&tx1, &tm1, NULL); + (void)taosLocalTime(&tx1, &tm1, NULL); /* load time zone string from /etc/timezone */ // FILE *f = fopen("/etc/timezone", "r"); errno = 0; @@ -933,12 +946,12 @@ void taosGetSystemTimezone(char *outTimezoneStr, enum TdTimezone *tsTimezone) { if (pFile != NULL) { int len = taosReadFile(pFile, buf, 64); if (len < 64 && taosGetErrorFile(pFile)) { - taosCloseFile(&pFile); - printf("read /etc/timezone error, reason:%s", strerror(errno)); + (void)taosCloseFile(&pFile); + (void)printf("read /etc/timezone error, reason:%s", strerror(errno)); return; } - taosCloseFile(&pFile); + (void)taosCloseFile(&pFile); buf[sizeof(buf) - 1] = 0; char *lineEnd = strstr(buf, "\n"); @@ -948,7 +961,7 @@ void taosGetSystemTimezone(char *outTimezoneStr, enum TdTimezone *tsTimezone) { // for CentOS system, /etc/timezone does not exist. Ignore the TZ environment variables if (strlen(buf) > 0) { - setenv("TZ", buf, 1); + (void)setenv("TZ", buf, 1); } } // get and set default timezone @@ -970,10 +983,10 @@ void taosGetSystemTimezone(char *outTimezoneStr, enum TdTimezone *tsTimezone) { * Asia/Shanghai (CST, +0800) * Europe/London (BST, +0100) */ - snprintf(outTimezoneStr, TD_TIMEZONE_LEN, "%s (%s, %s%02d00)", buf, tzname[daylight], tz >= 0 ? "+" : "-", + (void)snprintf(outTimezoneStr, TD_TIMEZONE_LEN, "%s (%s, %s%02d00)", buf, tzname[daylight], tz >= 0 ? "+" : "-", abs(tz)); } else { - printf("There is not /etc/timezone.\n"); + (void)printf("There is not /etc/timezone.\n"); } return; } @@ -981,7 +994,7 @@ void taosGetSystemTimezone(char *outTimezoneStr, enum TdTimezone *tsTimezone) { char *zi = strstr(buf, "zoneinfo"); if (!zi) { - printf("parsing /etc/localtime failed"); + (void)printf("parsing /etc/localtime failed"); return; } tz = zi + strlen("zoneinfo") + 1; @@ -1000,7 +1013,7 @@ void taosGetSystemTimezone(char *outTimezoneStr, enum TdTimezone *tsTimezone) { // return; // } - setenv("TZ", tz, 1); + (void)setenv("TZ", tz, 1); tzset(); } @@ -1011,7 +1024,7 @@ void taosGetSystemTimezone(char *outTimezoneStr, enum TdTimezone *tsTimezone) { */ time_t tx1 = taosGetTimestampSec(); struct tm tm1; - taosLocalTime(&tx1, &tm1, NULL); + (void)taosLocalTime(&tx1, &tm1, NULL); isdst_now = tm1.tm_isdst; /* @@ -1020,7 +1033,7 @@ void taosGetSystemTimezone(char *outTimezoneStr, enum TdTimezone *tsTimezone) { * Asia/Shanghai (CST, +0800) * Europe/London (BST, +0100) */ - snprintf(outTimezoneStr, TD_TIMEZONE_LEN, "%s (%s, %+03ld00)", tz, tm1.tm_isdst ? tzname[daylight] : tzname[0], + (void)snprintf(outTimezoneStr, TD_TIMEZONE_LEN, "%s (%s, %+03ld00)", tz, tm1.tm_isdst ? tzname[daylight] : tzname[0], -timezone / 3600); #endif } diff --git a/source/util/src/tconfig.c b/source/util/src/tconfig.c index 3ab0f83238..268b0b8497 100644 --- a/source/util/src/tconfig.c +++ b/source/util/src/tconfig.c @@ -136,8 +136,7 @@ static int32_t cfgCheckAndSetConf(SConfigItem *pItem, const char *conf) { static int32_t cfgCheckAndSetDir(SConfigItem *pItem, const char *inputDir) { char fullDir[PATH_MAX] = {0}; if (taosExpandDir(inputDir, fullDir, PATH_MAX) != 0) { - terrno = TAOS_SYSTEM_ERROR(errno); - uError("failed to expand dir:%s since %s", inputDir, terrstr()); + uError("failed to expand dir:%s", inputDir); return -1; } From 02346072fce735ce9e2f6c40a4b9e4f9bf2c6e41 Mon Sep 17 00:00:00 2001 From: wangmm0220 Date: Tue, 23 Jul 2024 16:02:07 +0800 Subject: [PATCH 10/15] fix:[TD-31017]process return value in mnode for tmq --- source/dnode/mnode/impl/src/mndConsumer.c | 5 ++--- source/dnode/mnode/impl/src/mndDef.c | 4 +++- source/dnode/mnode/impl/src/mndSubscribe.c | 13 +++++++------ 3 files changed, 12 insertions(+), 10 deletions(-) diff --git a/source/dnode/mnode/impl/src/mndConsumer.c b/source/dnode/mnode/impl/src/mndConsumer.c index cea664f64d..1b77a0ad6a 100644 --- a/source/dnode/mnode/impl/src/mndConsumer.c +++ b/source/dnode/mnode/impl/src/mndConsumer.c @@ -362,10 +362,9 @@ static int32_t buildAskEpRsp(SRpcMsg *pMsg, SMqAskEpRsp *rsp, int32_t serverEpoc pHead->walever = 0; void *abuf = POINTER_SHIFT(buf, sizeof(SMqRspHead)); - code = tEncodeSMqAskEpRsp(&abuf, rsp); - if (code != 0) { + if (tEncodeSMqAskEpRsp(&abuf, rsp) < 0) { rpcFreeCont(buf); - return code; + return TSDB_CODE_TSC_INTERNAL_ERROR; } // send rsp diff --git a/source/dnode/mnode/impl/src/mndDef.c b/source/dnode/mnode/impl/src/mndDef.c index 3aa0b5a01d..e90962ca5e 100644 --- a/source/dnode/mnode/impl/src/mndDef.c +++ b/source/dnode/mnode/impl/src/mndDef.c @@ -594,7 +594,9 @@ int32_t tCloneSubscribeObj(const SMqSubscribeObj *pSub, SMqSubscribeObj **ppSub) pSubNew->offsetRows = taosArrayDup(pSub->offsetRows, NULL); (void)memcpy(pSubNew->dbName, pSub->dbName, TSDB_DB_FNAME_LEN); pSubNew->qmsg = taosStrdup(pSub->qmsg); - + if (ppSub) { + *ppSub = pSubNew; + } END: return code; } diff --git a/source/dnode/mnode/impl/src/mndSubscribe.c b/source/dnode/mnode/impl/src/mndSubscribe.c index ec915eb9d8..a08e94e24f 100644 --- a/source/dnode/mnode/impl/src/mndSubscribe.c +++ b/source/dnode/mnode/impl/src/mndSubscribe.c @@ -397,9 +397,11 @@ END: } static int32_t processSubOffsetRows(SMnode *pMnode, const SMqRebInputObj *pInput, SMqRebOutputObj *pOutput) { - int32_t code = 0; SMqSubscribeObj *pSub = NULL; - MND_TMQ_RETURN_CHECK(mndAcquireSubscribeByKey(pMnode, pInput->pRebInfo->key, &pSub)); // put all offset rows + int32_t code = mndAcquireSubscribeByKey(pMnode, pInput->pRebInfo->key, &pSub); // put all offset rows + if( code != 0){ + return 0; + } taosRLockLatch(&pSub->lock); if (pOutput->pSub->offsetRows == NULL) { pOutput->pSub->offsetRows = taosArrayInit(4, sizeof(OffsetRows)); @@ -858,12 +860,11 @@ END: } static int32_t buildRebOutput(SMnode *pMnode, SMqRebInputObj *rebInput, SMqRebOutputObj *rebOutput) { - int32_t code = 0; const char *key = rebInput->pRebInfo->key; SMqSubscribeObj *pSub = NULL; - MND_TMQ_RETURN_CHECK(mndAcquireSubscribeByKey(pMnode, key, &pSub)); + int32_t code = mndAcquireSubscribeByKey(pMnode, key, &pSub); - if (pSub == NULL) { + if (code != 0) { // split sub key and extract topic char topic[TSDB_TOPIC_FNAME_LEN] = {0}; char cgroup[TSDB_CGROUP_LEN] = {0}; @@ -893,7 +894,7 @@ static int32_t buildRebOutput(SMnode *pMnode, SMqRebInputObj *rebInput, SMqRebOu taosRUnLockLatch(&pSub->lock); goto END; } - code =checkConsumer(pMnode, rebOutput->pSub); + code = checkConsumer(pMnode, rebOutput->pSub); if(code != 0){ taosRUnLockLatch(&pSub->lock); goto END; From d2af00c139e3c69b56d3a7e2bb7b9e830f473a71 Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao> Date: Tue, 23 Jul 2024 16:34:28 +0800 Subject: [PATCH 11/15] fix ci issue --- source/libs/executor/src/executil.c | 3 +- source/libs/executor/src/scanoperator.c | 64 +++++++++++++++++-------- 2 files changed, 44 insertions(+), 23 deletions(-) diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c index f2de61f625..686b4c6d6b 100644 --- a/source/libs/executor/src/executil.c +++ b/source/libs/executor/src/executil.c @@ -1873,8 +1873,7 @@ SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, QUERY_CHECK_CODE(code, lino, _end); } } else { - code = fmGetScalarFuncExecFuncs(pCtx->functionId, &pCtx->sfp); - QUERY_CHECK_CODE(code, lino, _end); + (void)fmGetScalarFuncExecFuncs(pCtx->functionId, &pCtx->sfp); if (pCtx->sfp.getEnv != NULL) { bool tmp = pCtx->sfp.getEnv(pExpr->pExpr->_function.pFunctNode, &env); diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index 3260be63ed..35c8dc358d 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -283,7 +283,8 @@ bool applyLimitOffset(SLimitInfo* pLimitInfo, SSDataBlock* pBlock, SExecTaskInfo 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); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); } pLimitInfo->remainOffset = 0; } @@ -1004,7 +1005,8 @@ static SSDataBlock* doGroupedTableScan(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); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); } return NULL; } @@ -1105,7 +1107,8 @@ static SSDataBlock* startNextGroupScan(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); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); } return NULL; } @@ -1134,9 +1137,13 @@ 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, - (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), &pInfo->pIgnoreTables); - QUERY_CHECK_CODE(code, lino, _end); + 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) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); + T_LONG_JMP(pTaskInfo->env, code); + } if (pInfo->filesetDelimited) { pAPI->tsdReader.tsdSetFilesetDelimited(pInfo->base.dataReader); @@ -1164,7 +1171,8 @@ 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); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); } return result; } @@ -1241,7 +1249,8 @@ static SSDataBlock* doTableScan(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); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); } return NULL; } @@ -3468,7 +3477,8 @@ static SSDataBlock* doRawScan(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); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); } return NULL; } @@ -3947,7 +3957,8 @@ 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); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); } } @@ -4253,7 +4264,8 @@ static SSDataBlock* doTagScanFromCtbIdx(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); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); } pOperator->resultInfo.totalRows += pRes->info.rows; return (pRes->info.rows == 0) ? NULL : pInfo->pRes; @@ -4684,7 +4696,8 @@ static void adjustSubTableFromMemBlock(SOperatorInfo* pOperatorInfo, STmsSubTabl _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); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); } } @@ -4784,7 +4797,8 @@ static SSDataBlock* getSubTablesSortedBlock(SOperatorInfo* pOperator, SSDataBloc _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); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); } return (pResBlock->info.rows > 0) ? pResBlock : NULL; } @@ -4902,7 +4916,8 @@ SSDataBlock* doTableMergeScanParaSubTables(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); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); } return pBlock; } @@ -4931,7 +4946,8 @@ static void tableMergeScanDoSkipTable(uint64_t uid, void* pTableMergeOpInfo) { _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); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); } } @@ -5223,7 +5239,8 @@ void startGroupTableMergeScan(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); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); } } @@ -5770,7 +5787,8 @@ static void buildSysDbFilterTableCount(SOperatorInfo* pOperator, STableCountScan _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); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); } setOperatorCompleted(pOperator); } @@ -5811,7 +5829,8 @@ static void buildSysDbGroupedTableCount(SOperatorInfo* pOperator, STableCountSca _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); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); } } @@ -5859,7 +5878,8 @@ static SSDataBlock* buildVnodeDbTableCount(SOperatorInfo* pOperator, STableCount _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); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); } return pRes->info.rows > 0 ? pRes : NULL; } @@ -5906,7 +5926,8 @@ static void buildVnodeGroupedTableCount(SOperatorInfo* pOperator, STableCountSca _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); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); } } @@ -5944,7 +5965,8 @@ static void buildVnodeFilteredTbCount(SOperatorInfo* pOperator, STableCountScanO _end: if (code != TSDB_CODE_SUCCESS) { - T_LONG_JMP(pTaskInfo->env, pTaskInfo->code); + pTaskInfo->code = code; + T_LONG_JMP(pTaskInfo->env, code); qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); } setOperatorCompleted(pOperator); From bf76f5a483c10e939c52c9cdd4fc6d27ce70ff2a Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao> Date: Tue, 23 Jul 2024 18:32:03 +0800 Subject: [PATCH 12/15] fix ci issue --- source/libs/executor/src/executil.c | 80 +++++++++++----------- source/libs/executor/src/groupoperator.c | 12 ++-- source/libs/executor/src/scanoperator.c | 33 +++++---- source/libs/executor/src/sysscanoperator.c | 12 ++-- 4 files changed, 69 insertions(+), 68 deletions(-) diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c index 686b4c6d6b..4d4dd3663f 100644 --- a/source/libs/executor/src/executil.c +++ b/source/libs/executor/src/executil.c @@ -426,9 +426,9 @@ static EDealRes getColumn(SNode** pNode, void* pContext) { tagFilterAssist* pData = (tagFilterAssist*)pContext; void* data = taosHashGet(pData->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId)); if (!data) { - int32_t code = + int32_t tempRes = taosHashPut(pData->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode))); - if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { + if (tempRes != TSDB_CODE_SUCCESS && tempRes != TSDB_CODE_DUP_KEY) { return DEAL_RES_ERROR; } pSColumnNode->slotId = pData->index++; @@ -741,10 +741,10 @@ int32_t getColInfoResultForGroupby(void* pVnode, SNodeList* group, STableListInf // groupId ~ table uid code = taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId), &(info->uid), sizeof(info->uid)); - if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { - lino = __LINE__; - goto end; + if (code == TSDB_CODE_DUP_KEY) { + code = TSDB_CODE_SUCCESS; } + QUERY_CHECK_CODE(code, lino, end); } } @@ -767,6 +767,9 @@ end: taosArrayDestroy(pBlockList); taosArrayDestroyEx(pUidTagList, freeItem); taosArrayDestroyP(groupData, releaseColInfoData); + if (code != TSDB_CODE_SUCCESS) { + qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + } return code; } @@ -944,10 +947,10 @@ static int32_t optimizeTbnameInCondImpl(void* pVnode, SArray* pExistedUidList, S for (int i = 0; i < numOfExisted; i++) { STUidTagInfo* pTInfo = taosArrayGet(pExistedUidList, i); - int32_t code = taosHashPut(uHash, &pTInfo->uid, sizeof(uint64_t), &i, sizeof(i)); - if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { - qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); - return code; + int32_t tempRes = taosHashPut(uHash, &pTInfo->uid, sizeof(uint64_t), &i, sizeof(i)); + if (tempRes != TSDB_CODE_SUCCESS && tempRes != TSDB_CODE_DUP_KEY) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(tempRes)); + return tempRes; } } } @@ -1150,13 +1153,15 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN ctx.colHash = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_SMALLINT), false, HASH_NO_LOCK); if (ctx.colHash == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - goto end; + code = TSDB_CODE_OUT_OF_MEMORY; + QUERY_CHECK_CODE(code, lino, end); } ctx.cInfoList = taosArrayInit(4, sizeof(SColumnInfo)); if (ctx.cInfoList == NULL) { terrno = TSDB_CODE_OUT_OF_MEMORY; - goto end; + code = TSDB_CODE_OUT_OF_MEMORY; + QUERY_CHECK_CODE(code, lino, end); } nodesRewriteExprPostOrder(&pTagCond, getColumn, (void*)&ctx); @@ -1195,7 +1200,7 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN if (code != TSDB_CODE_SUCCESS) { qError("failed to get table tags from meta, reason:%s, suid:%" PRIu64, tstrerror(code), pListInfo->idInfo.suid); terrno = code; - goto end; + QUERY_CHECK_CODE(code, lino, end); } } @@ -1207,7 +1212,7 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN pResBlock = createTagValBlockForFilter(ctx.cInfoList, numOfTables, pUidTagList, pVnode, pAPI); if (pResBlock == NULL) { code = terrno; - goto end; + QUERY_CHECK_CODE(code, lino, end); } // int64_t st1 = taosGetTimestampUs(); @@ -1221,20 +1226,20 @@ static int32_t doFilterByTagCond(STableListInfo* pListInfo, SArray* pUidList, SN code = createResultData(&type, numOfTables, &output); if (code != TSDB_CODE_SUCCESS) { terrno = code; - goto end; + QUERY_CHECK_CODE(code, lino, end); } code = scalarCalculate(pTagCond, pBlockList, &output); if (code != TSDB_CODE_SUCCESS) { qError("failed to calculate scalar, reason:%s", tstrerror(code)); terrno = code; - goto end; + QUERY_CHECK_CODE(code, lino, end); } code = doSetQualifiedUid(pListInfo, pUidList, pUidTagList, (bool*)output.columnData->pData, addUid); if (code != TSDB_CODE_SUCCESS) { terrno = code; - goto end; + QUERY_CHECK_CODE(code, lino, end); } *listAdded = true; @@ -1274,9 +1279,7 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S QUERY_CHECK_NULL(tmp, code, lino, _error, TSDB_CODE_OUT_OF_MEMORY); } code = doFilterByTagCond(pListInfo, pUidList, pTagCond, pVnode, status, pStorageAPI, false, &listAdded); - if (code != TSDB_CODE_SUCCESS) { - goto _end; - } + QUERY_CHECK_CODE(code, lino, _end); } else { T_MD5_CTX context = {0}; @@ -1322,9 +1325,7 @@ int32_t getTableList(void* pVnode, SScanPhysiNode* pScanNode, SNode* pTagCond, S } code = doFilterByTagCond(pListInfo, pUidList, pTagCond, pVnode, status, pStorageAPI, tsTagFilterCache, &listAdded); - if (code != TSDB_CODE_SUCCESS) { - goto _end; - } + QUERY_CHECK_CODE(code, lino, _end); // let's add the filter results into meta-cache numOfTables = taosArrayGetSize(pUidList); @@ -1805,10 +1806,10 @@ static int32_t setSelectValueColumnInfo(SqlFunctionCtx* pCtx, int32_t numOfOutpu p = NULL; break; } else { - int32_t code = taosHashPut(pSelectFuncs, pName, strlen(pName), &num, sizeof(num)); - if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { - qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); - return code; + int32_t tempRes = taosHashPut(pSelectFuncs, pName, strlen(pName), &num, sizeof(num)); + if (tempRes != TSDB_CODE_SUCCESS && tempRes != TSDB_CODE_DUP_KEY) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(tempRes)); + return tempRes; } p = &pCtx[i]; } @@ -1873,7 +1874,8 @@ SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, QUERY_CHECK_CODE(code, lino, _end); } } else { - (void)fmGetScalarFuncExecFuncs(pCtx->functionId, &pCtx->sfp); + code = fmGetScalarFuncExecFuncs(pCtx->functionId, &pCtx->sfp); + QUERY_CHECK_CODE(code, lino, _end); if (pCtx->sfp.getEnv != NULL) { bool tmp = pCtx->sfp.getEnv(pExpr->pExpr->_function.pFunctNode, &env); @@ -2241,10 +2243,10 @@ int32_t tableListAddTableInfo(STableListInfo* pTableList, uint64_t uid, uint64_t int32_t slot = (int32_t)taosArrayGetSize(pTableList->pTableList) - 1; code = taosHashPut(pTableList->map, &uid, sizeof(uid), &slot, sizeof(slot)); - if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { - lino = __LINE__; - goto _end; + if (code == TSDB_CODE_DUP_KEY) { + code = TSDB_CODE_SUCCESS; } + QUERY_CHECK_CODE(code, lino, _end); _end: if (code != TSDB_CODE_SUCCESS) { @@ -2419,11 +2421,11 @@ int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle* STableKeyInfo* info = taosArrayGet(pTableListInfo->pTableList, i); info->groupId = groupByTbname ? info->uid : 0; - code = taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId), &(info->uid), - sizeof(info->uid)); - if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { - qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); - return code; + int32_t tempRes = taosHashPut(pTableListInfo->remainGroups, &(info->groupId), sizeof(info->groupId), + &(info->uid), sizeof(info->uid)); + if (tempRes != TSDB_CODE_SUCCESS && tempRes != TSDB_CODE_DUP_KEY) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(tempRes)); + return tempRes; } } } else { @@ -2472,10 +2474,10 @@ int32_t buildGroupIdMapForAllTables(STableListInfo* pTableListInfo, SReadHandle* size_t size = taosArrayGetSize(pTableListInfo->pTableList); for (int32_t i = 0; i < size; ++i) { STableKeyInfo* p = taosArrayGet(pTableListInfo->pTableList, i); - code = taosHashPut(pTableListInfo->map, &p->uid, sizeof(uint64_t), &i, sizeof(int32_t)); - if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { - qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); - return code; + int32_t tempRes = taosHashPut(pTableListInfo->map, &p->uid, sizeof(uint64_t), &i, sizeof(int32_t)); + if (tempRes != TSDB_CODE_SUCCESS && tempRes != TSDB_CODE_DUP_KEY) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(tempRes)); + return tempRes; } } diff --git a/source/libs/executor/src/groupoperator.c b/source/libs/executor/src/groupoperator.c index 1d39f20757..1af5ef0238 100644 --- a/source/libs/executor/src/groupoperator.c +++ b/source/libs/executor/src/groupoperator.c @@ -774,10 +774,10 @@ void* getCurrentDataGroupInfo(const SPartitionOperatorInfo* pInfo, SDataGroupInf QUERY_CHECK_NULL(gi.pPageList, code, lino, _end, TSDB_CODE_OUT_OF_MEMORY); code = taosHashPut(pInfo->pGroupSet, pInfo->keyBuf, len, &gi, sizeof(SDataGroupInfo)); - if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { - lino = __LINE__; - goto _end; + if (code == TSDB_CODE_DUP_KEY) { + code = TSDB_CODE_SUCCESS; } + QUERY_CHECK_CODE(code, lino, _end); p = taosHashGet(pInfo->pGroupSet, pInfo->keyBuf, len); @@ -1400,10 +1400,10 @@ static void doStreamHashPartitionImpl(SStreamPartitionOperatorInfo* pInfo, SSDat code = taosHashPut(pInfo->pPartitions, pInfo->partitionSup.keyBuf, keyLen, &newParData, sizeof(SPartitionDataInfo)); - if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { - lino = __LINE__; - goto _end; + if (code == TSDB_CODE_DUP_KEY) { + code = TSDB_CODE_SUCCESS; } + QUERY_CHECK_CODE(code, lino, _end); } } diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index 35c8dc358d..a2e5d8103f 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -175,11 +175,11 @@ static int32_t insertTableToScanIgnoreList(STableScanInfo* pTableScanInfo, uint6 } } - int32_t code = taosHashPut(pTableScanInfo->pIgnoreTables, &uid, sizeof(uid), &pTableScanInfo->scanTimes, - sizeof(pTableScanInfo->scanTimes)); - if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { - qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); - return code; + int32_t tempRes = taosHashPut(pTableScanInfo->pIgnoreTables, &uid, sizeof(uid), &pTableScanInfo->scanTimes, + sizeof(pTableScanInfo->scanTimes)); + if (tempRes != TSDB_CODE_SUCCESS && tempRes != TSDB_CODE_DUP_KEY) { + qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(tempRes)); + return tempRes; } return TSDB_CODE_SUCCESS; } @@ -1137,9 +1137,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, - (void**)&pInfo->base.dataReader, GET_TASKID(pTaskInfo), &pInfo->pIgnoreTables); + 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) { qError("%s failed at line %d since %s", __func__, __LINE__, tstrerror(code)); T_LONG_JMP(pTaskInfo->env, code); @@ -3632,10 +3631,10 @@ void streamScanReloadState(SOperatorInfo* pOperator) { size_t keySize = 0; int64_t* pUid = taosHashGetKey(pIte, &keySize); code = taosHashPut(pUpInfo->pMap, pUid, sizeof(int64_t), pIte, sizeof(TSKEY)); - if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { - lino = __LINE__; - goto _end; + if (code == TSDB_CODE_DUP_KEY) { + code = TSDB_CODE_SUCCESS; } + QUERY_CHECK_CODE(code, lino, _end); pIte = taosHashIterate(curMap, pIte); } @@ -4023,10 +4022,10 @@ static EDealRes tagScanRewriteTagColumn(SNode** pNode, void* pContext) { void* data = taosHashGet(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId)); if (!data) { code = taosHashPut(pCtx->colHash, &pSColumnNode->colId, sizeof(pSColumnNode->colId), pNode, sizeof((*pNode))); - if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { - lino = __LINE__; - goto _end; + if (code == TSDB_CODE_DUP_KEY) { + code = TSDB_CODE_SUCCESS; } + QUERY_CHECK_CODE(code, lino, _end); pSColumnNode->slotId = pCtx->index++; SColumnInfo cInfo = {.colId = pSColumnNode->colId, .type = pSColumnNode->node.resType.type, @@ -4937,10 +4936,10 @@ static void tableMergeScanDoSkipTable(uint64_t uid, void* pTableMergeOpInfo) { int bSkip = 1; if (pInfo->mSkipTables != NULL) { code = taosHashPut(pInfo->mSkipTables, &uid, sizeof(uid), &bSkip, sizeof(bSkip)); - if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { - lino = __LINE__; - goto _end; + if (code == TSDB_CODE_DUP_KEY) { + code = TSDB_CODE_SUCCESS; } + QUERY_CHECK_CODE(code, lino, _end); } _end: diff --git a/source/libs/executor/src/sysscanoperator.c b/source/libs/executor/src/sysscanoperator.c index 6528ad1b9d..4b247f871c 100644 --- a/source/libs/executor/src/sysscanoperator.c +++ b/source/libs/executor/src/sysscanoperator.c @@ -596,10 +596,10 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { if (schema == NULL) { SSchemaWrapper* schemaWrapper = tCloneSSchemaWrapper(&pInfo->pCur->mr.me.stbEntry.schemaRow); code = taosHashPut(pInfo->pSchema, &pInfo->pCur->mr.me.uid, sizeof(int64_t), &schemaWrapper, POINTER_BYTES); - if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { - lino = __LINE__; - goto _end; + if (code == TSDB_CODE_DUP_KEY) { + code = TSDB_CODE_SUCCESS; } + QUERY_CHECK_CODE(code, lino, _end); } continue; } else if (pInfo->pCur->mr.me.type == TSDB_CHILD_TABLE) { @@ -627,10 +627,10 @@ static SSDataBlock* sysTableScanUserCols(SOperatorInfo* pOperator) { } SSchemaWrapper* schemaWrapper = tCloneSSchemaWrapper(&smrSuperTable.me.stbEntry.schemaRow); code = taosHashPut(pInfo->pSchema, &suid, sizeof(int64_t), &schemaWrapper, POINTER_BYTES); - if (code != TSDB_CODE_SUCCESS && code != TSDB_CODE_DUP_KEY) { - lino = __LINE__; - goto _end; + if (code == TSDB_CODE_DUP_KEY) { + code = TSDB_CODE_SUCCESS; } + QUERY_CHECK_CODE(code, lino, _end); schemaRow = schemaWrapper; pAPI->metaReaderFn.clearReader(&smrSuperTable); From 9735c069c85f670d458966e53b6abe799dc6326d Mon Sep 17 00:00:00 2001 From: dapan1121 Date: Tue, 23 Jul 2024 18:47:20 +0800 Subject: [PATCH 13/15] fix: windows compile issue --- source/os/src/osFile.c | 100 +++++++++++++++++++++++++++++------------ 1 file changed, 72 insertions(+), 28 deletions(-) diff --git a/source/os/src/osFile.c b/source/os/src/osFile.c index 0581df573a..167c141569 100644 --- a/source/os/src/osFile.c +++ b/source/os/src/osFile.c @@ -127,40 +127,56 @@ int64_t taosCopyFile(const char *from, const char *to) { // fidfrom = open(from, O_RDONLY); TdFilePtr pFileFrom = taosOpenFile(from, TD_FILE_READ); - if (pFileFrom == NULL) goto _err; + if (pFileFrom == NULL) { + code = terrno; + goto _err; + } // fidto = open(to, O_WRONLY | O_CREAT | O_EXCL, 0755); TdFilePtr pFileTo = taosOpenFile(to, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_EXCL); - if (pFileTo == NULL) goto _err; + if (pFileTo == NULL) { + code = terrno; + goto _err; + } while (true) { bytes = taosReadFile(pFileFrom, buffer, sizeof(buffer)); - if (bytes < 0) goto _err; + if (bytes < 0) { + code = terrno; + goto _err; + } + if (bytes == 0) break; size += bytes; - if (taosWriteFile(pFileTo, (void *)buffer, bytes) < bytes) goto _err; + if (taosWriteFile(pFileTo, (void *)buffer, bytes) < bytes) { + code = terrno; + goto _err; + } if (bytes < sizeof(buffer)) break; } code = taosFsyncFile(pFileTo); - taosCloseFile(&pFileFrom); - taosCloseFile(&pFileTo); + (void)taosCloseFile(&pFileFrom); + (void)taosCloseFile(&pFileTo); if (code != 0) { + terrno = code; return -1; } + return size; _err: - if (pFileFrom != NULL) taosCloseFile(&pFileFrom); - if (pFileTo != NULL) taosCloseFile(&pFileTo); + if (pFileFrom != NULL) (void)taosCloseFile(&pFileFrom); + if (pFileTo != NULL) (void)taosCloseFile(&pFileTo); /* coverity[+retval] */ - taosRemoveFile(to); - + (void)taosRemoveFile(to); + + terrno = code; return -1; #endif } @@ -168,24 +184,31 @@ _err: TdFilePtr taosCreateFile(const char *path, int32_t tdFileOptions) { TdFilePtr fp = taosOpenFile(path, tdFileOptions); if (!fp) { - if (errno == ENOENT) { + if (terrno == TAOS_SYSTEM_ERROR(ENOENT)) { // Try to create directory recursively - char *s = taosStrdup(path); + char s[PATH_MAX]; + tstrncpy(s, path, sizeof(s)); if (taosMulMkDir(taosDirName(s)) != 0) { - taosMemoryFree(s); return NULL; } - taosMemoryFree(s); fp = taosOpenFile(path, tdFileOptions); if (!fp) { return NULL; } } } + return fp; } -int32_t taosRemoveFile(const char *path) { return remove(path); } +int32_t taosRemoveFile(const char *path) { + int32_t code = remove(path); + if (-1 == code) { + terrno = TAOS_SYSTEM_ERROR(errno); + return terrno; + } + return code; +} int32_t taosRenameFile(const char *oldName, const char *newName) { #ifdef WINDOWS @@ -217,8 +240,9 @@ int32_t taosRenameFile(const char *oldName, const char *newName) { return finished ? 0 : -1; #else int32_t code = rename(oldName, newName); - if (code < 0) { - printf("failed to rename file %s to %s, reason:%s\n", oldName, newName, strerror(errno)); + if (-1 == code) { + terrno = TAOS_SYSTEM_ERROR(errno); + return terrno; } return code; @@ -233,8 +257,9 @@ int32_t taosStatFile(const char *path, int64_t *size, int32_t *mtime, int32_t *a struct stat fileStat; int32_t code = stat(path, &fileStat); #endif - if (code < 0) { - return code; + if (-1 == code) { + terrno = TAOS_SYSTEM_ERROR(errno); + return terrno; } if (size != NULL) { @@ -272,13 +297,15 @@ int32_t taosDevInoFile(TdFilePtr pFile, int64_t *stDev, int64_t *stIno) { #else if (pFile == NULL || pFile->fd < 0) { - return -1; + terrno = TSDB_CODE_INVALID_PARA; + return terrno; } + struct stat fileStat; int32_t code = fstat(pFile->fd, &fileStat); - if (code < 0) { - printf("taosFStatFile run fstat fail."); - return code; + if (-1 == code) { + terrno = TAOS_SYSTEM_ERROR(errno); + return terrno; } if (stDev != NULL) { @@ -1150,6 +1177,8 @@ int64_t taosPReadFile(TdFilePtr pFile, void *buf, int64_t count, int64_t offset) if (pFile == NULL) { return 0; } + + int32_t code = 0; #ifdef WINDOWS #if FILE_WITH_LOCK @@ -1185,7 +1214,6 @@ int64_t taosPReadFile(TdFilePtr pFile, void *buf, int64_t count, int64_t offset) terrno = TSDB_CODE_INVALID_PARA; return -1; } - int32_t code = 0; int64_t ret = pread(pFile->fd, buf, count, offset); if (-1 == ret) { code = TAOS_SYSTEM_ERROR(errno); @@ -1205,20 +1233,36 @@ int32_t taosFsyncFile(TdFilePtr pFile) { return 0; } + int32_t code = 0; // this implementation is WRONG // fflush is not a replacement of fsync - if (pFile->fp != NULL) return fflush(pFile->fp); + if (pFile->fp != NULL) { + code = fflush(pFile->fp); + if (0 != code) { + terrno = TAOS_SYSTEM_ERROR(errno); + return terrno; + } + + return code; + } + #ifdef WINDOWS if (pFile->hFile != NULL) { if (pFile->tdFileOptions & TD_FILE_WRITE_THROUGH) { return 0; } return !FlushFileBuffers(pFile->hFile); + } #else if (pFile->fd >= 0) { - return fsync(pFile->fd); -#endif + code = fsync(pFile->fd); + if (-1 == code) { + terrno = TAOS_SYSTEM_ERROR(errno); + return terrno; + } } +#endif + return 0; } @@ -1471,4 +1515,4 @@ int taosSetAutoDelFile(char* path) { #else return unlink(path); #endif -} \ No newline at end of file +} From 9a0f0d8829ea2e9cd7dec5c41cf62df622313ef4 Mon Sep 17 00:00:00 2001 From: 54liuyao <54liuyao> Date: Tue, 23 Jul 2024 19:31:43 +0800 Subject: [PATCH 14/15] fix udf ci error --- source/libs/executor/src/executil.c | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/source/libs/executor/src/executil.c b/source/libs/executor/src/executil.c index 4d4dd3663f..5db27478fc 100644 --- a/source/libs/executor/src/executil.c +++ b/source/libs/executor/src/executil.c @@ -1080,6 +1080,7 @@ _end: if (code != TSDB_CODE_SUCCESS) { taosMemoryFree(pResBlock); qError("%s failed at line %d since %s", __func__, lino, tstrerror(code)); + terrno = code; return NULL; } return pResBlock; @@ -1857,8 +1858,8 @@ SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, pCtx->isPseudoFunc = fmIsWindowPseudoColumnFunc(pCtx->functionId); pCtx->isNotNullFunc = fmIsNotNullOutputFunc(pCtx->functionId); + bool isUdaf = fmIsUserDefinedFunc(pCtx->functionId); if (fmIsAggFunc(pCtx->functionId) || fmIsIndefiniteRowsFunc(pCtx->functionId)) { - bool isUdaf = fmIsUserDefinedFunc(pCtx->functionId); if (!isUdaf) { code = fmGetFuncExecFuncs(pCtx->functionId, &pCtx->fpSet); QUERY_CHECK_CODE(code, lino, _end); @@ -1875,6 +1876,9 @@ SqlFunctionCtx* createSqlFunctionCtx(SExprInfo* pExprInfo, int32_t numOfOutput, } } else { code = fmGetScalarFuncExecFuncs(pCtx->functionId, &pCtx->sfp); + if (code != TSDB_CODE_SUCCESS && isUdaf) { + code = TSDB_CODE_SUCCESS; + } QUERY_CHECK_CODE(code, lino, _end); if (pCtx->sfp.getEnv != NULL) { From 04f51842e4164712d5f782ccfa2cbc061a3ca435 Mon Sep 17 00:00:00 2001 From: wangmm0220 Date: Tue, 23 Jul 2024 23:56:35 +0800 Subject: [PATCH 15/15] fix:[TD-31017]process return value in mnd for tmq --- source/dnode/mnode/impl/src/mndSubscribe.c | 2 -- 1 file changed, 2 deletions(-) diff --git a/source/dnode/mnode/impl/src/mndSubscribe.c b/source/dnode/mnode/impl/src/mndSubscribe.c index dcf407009b..a110d442cf 100644 --- a/source/dnode/mnode/impl/src/mndSubscribe.c +++ b/source/dnode/mnode/impl/src/mndSubscribe.c @@ -100,7 +100,6 @@ END: static int32_t mndBuildSubChangeReq(void **pBuf, int32_t *pLen, SMqSubscribeObj *pSub, const SMqRebOutputVg *pRebVg, SSubplan *pPlan) { - int32_t code = 0; SMqRebVgReq req = {0}; int32_t code = 0; SEncoder encoder = {0}; @@ -862,7 +861,6 @@ END: } static int32_t buildRebOutput(SMnode *pMnode, SMqRebInputObj *rebInput, SMqRebOutputObj *rebOutput) { - int32_t code = 0; const char *key = rebInput->pRebInfo->key; SMqSubscribeObj *pSub = NULL; int32_t code = mndAcquireSubscribeByKey(pMnode, key, &pSub);