diff --git a/include/common/tdatablock.h b/include/common/tdatablock.h index ec998e9365..c271f118ae 100644 --- a/include/common/tdatablock.h +++ b/include/common/tdatablock.h @@ -253,7 +253,7 @@ int32_t assignOneDataBlock(SSDataBlock* dst, const SSDataBlock* src); int32_t copyDataBlock(SSDataBlock* pDst, const SSDataBlock* pSrc); SSDataBlock* createDataBlock(); -void* blockDataDestroy(SSDataBlock* pBlock); +void blockDataDestroy(SSDataBlock* pBlock); void blockDataFreeRes(SSDataBlock* pBlock); SSDataBlock* createOneDataBlock(const SSDataBlock* pDataBlock, bool copyData); SSDataBlock* createSpecialDataBlock(EStreamType type); diff --git a/include/libs/scalar/filter.h b/include/libs/scalar/filter.h index 750179ee3b..a98bf29afb 100644 --- a/include/libs/scalar/filter.h +++ b/include/libs/scalar/filter.h @@ -58,12 +58,13 @@ extern int32_t filterGetTimeRange(SNode *pNode, STimeWindow *win, bool *isStrict extern int32_t filterConverNcharColumns(SFilterInfo *pFilterInfo, int32_t rows, bool *gotNchar); extern int32_t filterFreeNcharColumns(SFilterInfo *pFilterInfo); extern void filterFreeInfo(SFilterInfo *info); -extern bool filterRangeExecute(SFilterInfo *info, SColumnDataAgg *pColsAgg, int32_t numOfCols, int32_t numOfRows); +extern int32_t filterRangeExecute(SFilterInfo *info, SColumnDataAgg *pDataStatis, int32_t numOfCols, int32_t numOfRows, + bool *keep); /* condition split interface */ int32_t filterPartitionCond(SNode **pCondition, SNode **pPrimaryKeyCond, SNode **pTagIndexCond, SNode **pTagCond, SNode **pOtherCond); -bool filterIsMultiTableColsCond(SNode *pCond); +int32_t filterIsMultiTableColsCond(SNode *pCond, bool *res); EConditionType filterClassifyCondition(SNode *pNode); #ifdef __cplusplus diff --git a/include/libs/stream/tstream.h b/include/libs/stream/tstream.h index 5327428f5b..dff212b15c 100644 --- a/include/libs/stream/tstream.h +++ b/include/libs/stream/tstream.h @@ -629,7 +629,7 @@ int32_t streamSetupScheduleTrigger(SStreamTask* pTask); int32_t streamProcessDispatchMsg(SStreamTask* pTask, SStreamDispatchReq* pReq, SRpcMsg* pMsg); int32_t streamProcessDispatchRsp(SStreamTask* pTask, SStreamDispatchRsp* pRsp, int32_t code); -int32_t streamTaskGetUpstreamTaskEpInfo(SStreamTask* pTask, int32_t taskId, SStreamUpstreamEpInfo** pEpInfo); +void streamTaskGetUpstreamTaskEpInfo(SStreamTask* pTask, int32_t taskId, SStreamUpstreamEpInfo** pEpInfo); #if 0 SEpSet* streamTaskGetDownstreamEpInfo(SStreamTask* pTask, int32_t taskId); #endif @@ -659,10 +659,10 @@ int8_t streamTaskSetSchedStatusInactive(SStreamTask* pTask); int32_t streamTaskClearHTaskAttr(SStreamTask* pTask, int32_t clearRelHalt); int32_t streamExecTask(SStreamTask* pTask); -int32_t streamResumeTask(SStreamTask* pTask); +void streamResumeTask(SStreamTask* pTask); int32_t streamTrySchedExec(SStreamTask* pTask); int32_t streamTaskSchedTask(SMsgCb* pMsgCb, int32_t vgId, int64_t streamId, int32_t taskId, int32_t execType); -int32_t streamTaskResumeInFuture(SStreamTask* pTask); +void streamTaskResumeInFuture(SStreamTask* pTask); void streamTaskClearSchedIdleInfo(SStreamTask* pTask); void streamTaskSetIdleInfo(SStreamTask* pTask, int32_t idleTime); @@ -675,8 +675,8 @@ int32_t streamTaskSendCheckRsp(const SStreamMeta* pMeta, int32_t vgId, SStreamTa int32_t streamTaskProcessCheckRsp(SStreamTask* pTask, const SStreamTaskCheckRsp* pRsp); // check downstream status -int32_t streamTaskStartMonitorCheckRsp(SStreamTask* pTask); -int32_t streamTaskStopMonitorCheckRsp(STaskCheckInfo* pInfo, const char* id); +void streamTaskStartMonitorCheckRsp(SStreamTask* pTask); +void streamTaskStopMonitorCheckRsp(STaskCheckInfo* pInfo, const char* id); void streamTaskCleanupCheckInfo(STaskCheckInfo* pInfo); // fill-history task diff --git a/include/util/taoserror.h b/include/util/taoserror.h index 6e001f303e..9c760a465a 100644 --- a/include/util/taoserror.h +++ b/include/util/taoserror.h @@ -597,6 +597,7 @@ int32_t taosGetErrSize(); #define TSDB_CODE_QRY_GEO_NOT_SUPPORT_ERROR TAOS_DEF_ERROR_CODE(0, 0x0731) #define TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR TAOS_DEF_ERROR_CODE(0, 0x0732) #define TSDB_CODE_QRY_INVALID_JOIN_CONDITION TAOS_DEF_ERROR_CODE(0, 0x0733) +#define TSDB_CODE_QRY_FILTER_NOT_SUPPORT_TYPE TAOS_DEF_ERROR_CODE(0, 0x0734) // grant #define TSDB_CODE_GRANT_EXPIRED TAOS_DEF_ERROR_CODE(0, 0x0800) diff --git a/source/common/src/tdatablock.c b/source/common/src/tdatablock.c index 965246326a..43bac56f93 100644 --- a/source/common/src/tdatablock.c +++ b/source/common/src/tdatablock.c @@ -1523,9 +1523,9 @@ void blockDataFreeRes(SSDataBlock* pBlock) { memset(&pBlock->info, 0, sizeof(SDataBlockInfo)); } -void* blockDataDestroy(SSDataBlock* pBlock) { +void blockDataDestroy(SSDataBlock* pBlock) { if (pBlock == NULL) { - return NULL; + return; } if (IS_VAR_DATA_TYPE(pBlock->info.pks[0].type)) { @@ -1535,7 +1535,6 @@ void* blockDataDestroy(SSDataBlock* pBlock) { blockDataFreeRes(pBlock); taosMemoryFreeClear(pBlock); - return NULL; } // todo remove it @@ -2468,19 +2467,18 @@ char* buildCtbNameByGroupId(const char* stbFullName, uint64_t groupId) { int32_t buildCtbNameByGroupIdImpl(const char* stbFullName, uint64_t groupId, char* cname) { if (stbFullName[0] == 0) { - terrno = TSDB_CODE_INVALID_PARA; - return TSDB_CODE_FAILED; + return TSDB_CODE_INVALID_PARA; } SArray* tags = taosArrayInit(0, sizeof(SSmlKv)); if (tags == NULL) { - return TSDB_CODE_FAILED; + return TSDB_CODE_OUT_OF_MEMORY; } if (cname == NULL) { terrno = TSDB_CODE_INVALID_PARA; taosArrayDestroy(tags); - return TSDB_CODE_FAILED; + return terrno; } int8_t type = TSDB_DATA_TYPE_UBIGINT; diff --git a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c index 0669956fb8..fe65c7239d 100644 --- a/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c +++ b/source/dnode/mgmt/mgmt_vnode/src/vmHandle.c @@ -377,14 +377,14 @@ int32_t vmProcessCreateVnodeReq(SVnodeMgmt *pMgmt, SRpcMsg *pMsg) { goto _OVER; } - taosThreadMutexLock(&pMgmt->createLock); + //taosThreadMutexLock(&pMgmt->createLock); code = vmWriteVnodeListToFile(pMgmt); if (code != 0) { code = terrno != 0 ? terrno : code; - taosThreadMutexUnlock(&pMgmt->createLock); + //taosThreadMutexUnlock(&pMgmt->createLock); goto _OVER; } - taosThreadMutexUnlock(&pMgmt->createLock); + //taosThreadMutexUnlock(&pMgmt->createLock); _OVER: if (code != 0) { @@ -988,7 +988,7 @@ SArray *vmGetMsgHandles() { if (dmSetMgmtHandle(pArray, TDMT_VND_COMPACT, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER; if (dmSetMgmtHandle(pArray, TDMT_VND_TRIM, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER; if (dmSetMgmtHandle(pArray, TDMT_VND_S3MIGRATE, vmPutMsgToWriteQueue, 0) == NULL) goto _OVER; - if (dmSetMgmtHandle(pArray, TDMT_DND_CREATE_VNODE, vmPutMsgToMultiMgmtQueue, 0) == NULL) goto _OVER; + if (dmSetMgmtHandle(pArray, TDMT_DND_CREATE_VNODE, vmPutMsgToMgmtQueue, 0) == NULL) goto _OVER; if (dmSetMgmtHandle(pArray, TDMT_DND_DROP_VNODE, vmPutMsgToMgmtQueue, 0) == NULL) goto _OVER; if (dmSetMgmtHandle(pArray, TDMT_DND_ALTER_VNODE_TYPE, vmPutMsgToMgmtQueue, 0) == NULL) goto _OVER; if (dmSetMgmtHandle(pArray, TDMT_DND_CHECK_VNODE_LEARNER_CATCHUP, vmPutMsgToMgmtQueue, 0) == NULL) goto _OVER; diff --git a/source/dnode/vnode/src/tsdb/tsdbFS.c b/source/dnode/vnode/src/tsdb/tsdbFS.c index a796f5121c..b262912f9b 100644 --- a/source/dnode/vnode/src/tsdb/tsdbFS.c +++ b/source/dnode/vnode/src/tsdb/tsdbFS.c @@ -90,12 +90,14 @@ _exit: } static int32_t tsdbSaveFSToFile(STsdbFS *pFS, const char *fname) { - int32_t code = 0; - int32_t lino = 0; + int32_t code = 0; + int32_t lino = 0; + TdFilePtr pFD = NULL; + uint8_t *pData = NULL; // encode to binary - int32_t size = tsdbFSToBinary(NULL, pFS) + sizeof(TSCKSUM); - uint8_t *pData = taosMemoryMalloc(size); + int32_t size = tsdbFSToBinary(NULL, pFS) + sizeof(TSCKSUM); + pData = taosMemoryMalloc(size); if (pData == NULL) { code = TSDB_CODE_OUT_OF_MEMORY; TSDB_CHECK_CODE(code, lino, _exit); @@ -104,32 +106,26 @@ static int32_t tsdbSaveFSToFile(STsdbFS *pFS, const char *fname) { taosCalcChecksumAppend(0, pData, size); // save to file - TdFilePtr pFD = taosOpenFile(fname, TD_FILE_WRITE | TD_FILE_CREATE | TD_FILE_TRUNC | TD_FILE_WRITE_THROUGH); + pFD = taosOpenFile(fname, TD_FILE_WRITE | TD_FILE_CREATE | TD_FILE_TRUNC | TD_FILE_WRITE_THROUGH); if (pFD == NULL) { - code = TAOS_SYSTEM_ERROR(errno); - TSDB_CHECK_CODE(code, lino, _exit); + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(errno), lino, _exit); } int64_t n = taosWriteFile(pFD, pData, size); if (n < 0) { - code = TAOS_SYSTEM_ERROR(errno); - taosCloseFile(&pFD); - TSDB_CHECK_CODE(code, lino, _exit); + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(errno), lino, _exit); } if (taosFsyncFile(pFD) < 0) { - code = TAOS_SYSTEM_ERROR(errno); - taosCloseFile(&pFD); - TSDB_CHECK_CODE(code, lino, _exit); + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(errno), lino, _exit); } - taosCloseFile(&pFD); - _exit: - if (pData) taosMemoryFree(pData); if (code) { tsdbError("%s failed at line %d since %s, fname:%s", __func__, lino, tstrerror(code), fname); } + taosMemoryFree(pData); + taosCloseFile(&pFD); return code; } @@ -180,11 +176,6 @@ static int32_t tsdbScanAndTryFixFS(STsdb *pTsdb) { code = TAOS_SYSTEM_ERROR(errno); TSDB_CHECK_CODE(code, lino, _exit); } - - // if (size != tsdbLogicToFileSize(pTsdb->fs.pDelFile->size, pTsdb->pVnode->config.tsdbPageSize)) { - // code = TSDB_CODE_FILE_CORRUPTED; - // TSDB_CHECK_CODE(code, lino, _exit); - // } } // SArray @@ -327,17 +318,15 @@ static int32_t load_fs(const char *fname, STsdbFS *pFS) { TSDB_CHECK_CODE(code, lino, _exit); } - taosCloseFile(&pFD); - - // decode binary code = tsdbBinaryToFS(pData, size, pFS); TSDB_CHECK_CODE(code, lino, _exit); _exit: - if (pData) taosMemoryFree(pData); if (code) { tsdbError("%s failed at line %d since %s, fname:%s", __func__, lino, tstrerror(code), fname); } + taosMemoryFree(pData); + taosCloseFile(&pFD); return code; } @@ -383,7 +372,11 @@ static int32_t tsdbNewFileSet(STsdb *pTsdb, SDFileSet *pSetTo, SDFileSet *pSetFr int32_t code = 0; int32_t lino = 0; - *pSetTo = (SDFileSet){.diskId = pSetFrom->diskId, .fid = pSetFrom->fid, .nSttF = 0}; + *pSetTo = (SDFileSet){ + .diskId = pSetFrom->diskId, + .fid = pSetFrom->fid, + .nSttF = 0, + }; // head pSetTo->pHeadF = (SHeadFile *)taosMemoryMalloc(sizeof(SHeadFile)); diff --git a/source/dnode/vnode/src/tsdb/tsdbFS2.c b/source/dnode/vnode/src/tsdb/tsdbFS2.c index 9b8a979d01..0b329d23b9 100644 --- a/source/dnode/vnode/src/tsdb/tsdbFS2.c +++ b/source/dnode/vnode/src/tsdb/tsdbFS2.c @@ -41,7 +41,9 @@ static const char *gCurrentFname[] = { static int32_t create_fs(STsdb *pTsdb, STFileSystem **fs) { fs[0] = taosMemoryCalloc(1, sizeof(*fs[0])); - if (fs[0] == NULL) return TSDB_CODE_OUT_OF_MEMORY; + if (fs[0] == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } fs[0]->tsdb = pTsdb; tsem_init(&fs[0]->canEdit, 0, 1); @@ -75,69 +77,75 @@ int32_t current_fname(STsdb *pTsdb, char *fname, EFCurrentT ftype) { } static int32_t save_json(const cJSON *json, const char *fname) { - int32_t code = 0; + int32_t code = 0; + int32_t lino; + char *data = NULL; + TdFilePtr fp = NULL; - char *data = cJSON_PrintUnformatted(json); - if (data == NULL) return TSDB_CODE_OUT_OF_MEMORY; + data = cJSON_PrintUnformatted(json); + if (data == NULL) { + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); + } - TdFilePtr fp = taosOpenFile(fname, TD_FILE_WRITE | TD_FILE_CREATE | TD_FILE_TRUNC | TD_FILE_WRITE_THROUGH); + fp = taosOpenFile(fname, TD_FILE_WRITE | TD_FILE_CREATE | TD_FILE_TRUNC | TD_FILE_WRITE_THROUGH); if (fp == NULL) { - code = TAOS_SYSTEM_ERROR(code); - goto _exit; + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(code), lino, _exit); } if (taosWriteFile(fp, data, strlen(data)) < 0) { - code = TAOS_SYSTEM_ERROR(code); - goto _exit; + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(code), lino, _exit); } if (taosFsyncFile(fp) < 0) { - code = TAOS_SYSTEM_ERROR(code); - goto _exit; + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(code), lino, _exit); } - taosCloseFile(&fp); - _exit: + if (code) { + tsdbError("%s failed at %s:%d since %s", __func__, fname, __LINE__, tstrerror(code)); + } taosMemoryFree(data); + taosCloseFile(&fp); return code; } static int32_t load_json(const char *fname, cJSON **json) { int32_t code = 0; + int32_t lino; char *data = NULL; TdFilePtr fp = taosOpenFile(fname, TD_FILE_READ); - if (fp == NULL) return TAOS_SYSTEM_ERROR(code); + if (fp == NULL) { + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(errno), lino, _exit); + } int64_t size; if (taosFStatFile(fp, &size, NULL) < 0) { - code = TAOS_SYSTEM_ERROR(code); - goto _exit; + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(code), lino, _exit); } data = taosMemoryMalloc(size + 1); if (data == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _exit; + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } if (taosReadFile(fp, data, size) < 0) { - code = TAOS_SYSTEM_ERROR(code); - goto _exit; + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(code), lino, _exit); } data[size] = '\0'; json[0] = cJSON_Parse(data); if (json[0] == NULL) { - code = TSDB_CODE_FILE_CORRUPTED; - goto _exit; + TSDB_CHECK_CODE(code = TSDB_CODE_FILE_CORRUPTED, lino, _exit); } _exit: + if (code) { + tsdbError("%s failed at %s:%d since %s", __func__, fname, __LINE__, tstrerror(code)); + json[0] = NULL; + } taosCloseFile(&fp); - if (data) taosMemoryFree(data); - if (code) json[0] = NULL; + taosMemoryFree(data); return code; } @@ -146,26 +154,25 @@ int32_t save_fs(const TFileSetArray *arr, const char *fname) { int32_t lino = 0; cJSON *json = cJSON_CreateObject(); - if (!json) return TSDB_CODE_OUT_OF_MEMORY; + if (json == NULL) { + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); + } // fmtv if (cJSON_AddNumberToObject(json, "fmtv", 1) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _exit); + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } // fset cJSON *ajson = cJSON_AddArrayToObject(json, "fset"); if (!ajson) { - code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _exit); + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } const STFileSet *fset; TARRAY2_FOREACH(arr, fset) { cJSON *item = cJSON_CreateObject(); if (!item) { - code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _exit); + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } cJSON_AddItemToArray(ajson, item); @@ -226,14 +233,17 @@ static int32_t load_fs(STsdb *pTsdb, const char *fname, TFileSetArray *arr) { _exit: if (code) { - tsdbError("%s failed at line %d since %s, fname:%s", __func__, lino, tstrerror(code), fname); + tsdbError("%s failed at %sP%d since %s, fname:%s", __func__, __FILE__, lino, tstrerror(code), fname); + } + if (json) { + cJSON_Delete(json); } - if (json) cJSON_Delete(json); return code; } static int32_t apply_commit(STFileSystem *fs) { int32_t code = 0; + int32_t lino; TFileSetArray *fsetArray1 = fs->fSetArr; TFileSetArray *fsetArray2 = fs->fSetArrTmp; int32_t i1 = 0, i2 = 0; @@ -250,15 +260,15 @@ static int32_t apply_commit(STFileSystem *fs) { } else if (fset1->fid > fset2->fid) { // create new file set with fid of fset2->fid code = tsdbTFileSetInitCopy(fs->tsdb, fset2, &fset1); - if (code) return code; + TSDB_CHECK_CODE(code, lino, _exit); code = TARRAY2_SORT_INSERT(fsetArray1, fset1, tsdbTFileSetCmprFn); - if (code) return code; + TSDB_CHECK_CODE(code, lino, _exit); i1++; i2++; } else { // edit code = tsdbTFileSetApplyEdit(fs->tsdb, fset2, fset1); - if (code) return code; + TSDB_CHECK_CODE(code, lino, _exit); i1++; i2++; } @@ -269,15 +279,19 @@ static int32_t apply_commit(STFileSystem *fs) { } else { // create new file set with fid of fset2->fid code = tsdbTFileSetInitCopy(fs->tsdb, fset2, &fset1); - if (code) return code; + TSDB_CHECK_CODE(code, lino, _exit); code = TARRAY2_SORT_INSERT(fsetArray1, fset1, tsdbTFileSetCmprFn); - if (code) return code; + TSDB_CHECK_CODE(code, lino, _exit); i1++; i2++; } } - return 0; +_exit: + if (code) { + TSDB_ERROR_LOG(TD_VID(fs->tsdb->pVnode), lino, code); + } + return code; } static int32_t commit_edit(STFileSystem *fs) { @@ -303,7 +317,8 @@ static int32_t commit_edit(STFileSystem *fs) { _exit: if (code) { - tsdbError("vgId:%d %s failed at line %d since %s", TD_VID(fs->tsdb->pVnode), __func__, lino, tstrerror(code)); + tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(fs->tsdb->pVnode), __func__, __FILE__, lino, + tstrerror(code)); } else { tsdbInfo("vgId:%d %s success, etype:%d", TD_VID(fs->tsdb->pVnode), __func__, fs->etype); } @@ -335,7 +350,8 @@ static int32_t abort_edit(STFileSystem *fs) { _exit: if (code) { - tsdbError("vgId:%d %s failed since %s", TD_VID(fs->tsdb->pVnode), __func__, tstrerror(code)); + tsdbError("vgId:%d %s failed at %s:%d since %s", TD_VID(fs->tsdb->pVnode), __func__, __FILE__, lino, + tstrerror(code)); } else { tsdbInfo("vgId:%d %s success, etype:%d", TD_VID(fs->tsdb->pVnode), __func__, fs->etype); } @@ -360,13 +376,6 @@ static int32_t tsdbFSDoScanAndFixFile(STFileSystem *fs, const STFileObj *fobj) { } found = true; - /* - const char *object_name = taosDirEntryBaseName((char *)fobj->fname); - long s3_size = s3Size(object_name); - if (s3_size > 0) { - return 0; - } - */ } if (!found) { @@ -376,16 +385,6 @@ static int32_t tsdbFSDoScanAndFixFile(STFileSystem *fs, const STFileObj *fobj) { } } - { // TODO: check file size - // int64_t fsize; - // if (taosStatFile(fobj->fname, &fsize, NULL, NULL) < 0) { - // code = TAOS_SYSTEM_ERROR(terrno); - // tsdbError("vgId:%d %s failed since file:%s stat failed, reason:%s", TD_VID(fs->tsdb->pVnode), __func__, - // fobj->fname, tstrerror(code)); - // return code; - // } - } - return 0; } @@ -408,6 +407,7 @@ static int32_t tsdbFSAddEntryToFileObjHash(STFileHash *hash, const char *fname) static int32_t tsdbFSCreateFileObjHash(STFileSystem *fs, STFileHash *hash) { int32_t code = 0; + int32_t lino; char fname[TSDB_FILENAME_LEN]; // init hash table @@ -415,14 +415,13 @@ static int32_t tsdbFSCreateFileObjHash(STFileSystem *fs, STFileHash *hash) { hash->numBucket = 4096; hash->buckets = taosMemoryCalloc(hash->numBucket, sizeof(STFileHashEntry *)); if (hash->buckets == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - return code; + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } // vnode.json current_fname(fs->tsdb, fname, TSDB_FCURRENT); code = tsdbFSAddEntryToFileObjHash(hash, fname); - if (code) goto _exit; + TSDB_CHECK_CODE(code, lino, _exit); // other STFileSet *fset = NULL; @@ -431,7 +430,7 @@ static int32_t tsdbFSCreateFileObjHash(STFileSystem *fs, STFileHash *hash) { for (int32_t i = 0; i < TSDB_FTYPE_MAX; i++) { if (fset->farr[i] != NULL) { code = tsdbFSAddEntryToFileObjHash(hash, fset->farr[i]->fname); - if (code) goto _exit; + TSDB_CHECK_CODE(code, lino, _exit); } } @@ -441,13 +440,14 @@ static int32_t tsdbFSCreateFileObjHash(STFileSystem *fs, STFileHash *hash) { STFileObj *fobj; TARRAY2_FOREACH(lvl->fobjArr, fobj) { code = tsdbFSAddEntryToFileObjHash(hash, fobj->fname); - if (code) goto _exit; + TSDB_CHECK_CODE(code, lino, _exit); } } } _exit: if (code) { + TSDB_ERROR_LOG(TD_VID(fs->tsdb->pVnode), lino, code); tsdbFSDestroyFileObjHash(hash); } return code; diff --git a/source/dnode/vnode/src/tsdb/tsdbFSetRAW.c b/source/dnode/vnode/src/tsdb/tsdbFSetRAW.c index b180f9d099..1adca31347 100644 --- a/source/dnode/vnode/src/tsdb/tsdbFSetRAW.c +++ b/source/dnode/vnode/src/tsdb/tsdbFSetRAW.c @@ -35,7 +35,9 @@ int32_t tsdbFSetRAWWriterOpen(SFSetRAWWriterConfig *config, SFSetRAWWriter **wri int32_t lino = 0; writer[0] = taosMemoryCalloc(1, sizeof(SFSetRAWWriter)); - if (writer[0] == NULL) return TSDB_CODE_OUT_OF_MEMORY; + if (writer[0] == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } writer[0]->config[0] = config[0]; diff --git a/source/dnode/vnode/src/tsdb/tsdbFSetRW.c b/source/dnode/vnode/src/tsdb/tsdbFSetRW.c index f6ca515d1e..77d8998aa7 100644 --- a/source/dnode/vnode/src/tsdb/tsdbFSetRW.c +++ b/source/dnode/vnode/src/tsdb/tsdbFSetRW.c @@ -44,9 +44,10 @@ static int32_t tsdbFSetWriteTableDataBegin(SFSetWriter *writer, const TABLEID *t writer->ctx->tbid->uid = tbid->uid; code = tsdbUpdateSkmTb(writer->config->tsdb, writer->ctx->tbid, writer->skmTb); + TSDB_CHECK_CODE(code , lino, _exit); code = metaGetColCmpr(writer->config->tsdb->pVnode->pMeta, tbid->suid ? tbid->suid : tbid->uid, &writer->pColCmprObj); - // TSDB_CHECK_CODE(code, lino, _exit); + // TODO: TSDB_CHECK_CODE(code, lino, _exit); writer->blockDataIdx = 0; for (int32_t i = 0; i < ARRAY_SIZE(writer->blockData); i++) { @@ -136,7 +137,9 @@ int32_t tsdbFSetWriterOpen(SFSetWriterConfig *config, SFSetWriter **writer) { int32_t lino = 0; writer[0] = taosMemoryCalloc(1, sizeof(*writer[0])); - if (writer[0] == NULL) return TSDB_CODE_OUT_OF_MEMORY; + if (writer[0] == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } writer[0]->config[0] = config[0]; diff --git a/source/dnode/vnode/src/tsdb/tsdbRead2.c b/source/dnode/vnode/src/tsdb/tsdbRead2.c index 2474666e93..23e396b6a4 100644 --- a/source/dnode/vnode/src/tsdb/tsdbRead2.c +++ b/source/dnode/vnode/src/tsdb/tsdbRead2.c @@ -4648,7 +4648,8 @@ void tsdbReaderClose2(STsdbReader* pReader) { } if (pReader->resBlockInfo.freeBlock) { - pReader->resBlockInfo.pResBlock = blockDataDestroy(pReader->resBlockInfo.pResBlock); + blockDataDestroy(pReader->resBlockInfo.pResBlock); + pReader->resBlockInfo.pResBlock = NULL; } taosMemoryFree(pSupInfo->colId); diff --git a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c index dfc7dd8c7c..16bacf90b3 100644 --- a/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c +++ b/source/dnode/vnode/src/tsdb/tsdbReaderWriter.c @@ -16,10 +16,12 @@ #include "cos.h" #include "crypt.h" #include "tsdb.h" +#include "tsdbDef.h" #include "vnd.h" static int32_t tsdbOpenFileImpl(STsdbFD *pFD) { int32_t code = 0; + int32_t lino; const char *path = pFD->path; int32_t szPage = pFD->szPage; int32_t flag = pFD->flag; @@ -38,70 +40,27 @@ static int32_t tsdbOpenFileImpl(STsdbFD *pFD) { char *dot = strrchr(lc_path, '.'); if (!dot) { tsdbError("unexpected path: %s", lc_path); - code = TAOS_SYSTEM_ERROR(ENOENT); - goto _exit; + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(ENOENT), lino, _exit); } snprintf(dot + 1, TSDB_FQDN_LEN - (dot + 1 - lc_path), "%d.data", pFD->lcn); pFD->pFD = taosOpenFile(lc_path, flag); if (pFD->pFD == NULL) { - code = TAOS_SYSTEM_ERROR(errno); - // taosMemoryFree(pFD); - goto _exit; + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(errno), lino, _exit); } if (taosStatFile(lc_path, &lc_size, NULL, NULL) < 0) { - code = TAOS_SYSTEM_ERROR(errno); - // taosCloseFile(&pFD->pFD); - // taosMemoryFree(pFD); - goto _exit; + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(errno), lino, _exit); } } else { tsdbInfo("no file: %s", path); - code = TAOS_SYSTEM_ERROR(errno); - // taosMemoryFree(pFD); - goto _exit; + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(errno), lino, _exit); } pFD->s3File = 1; - /* - const char *object_name = taosDirEntryBaseName((char *)path); - long s3_size = 0; - if (tsS3Enabled) { - long size = s3Size(object_name); - if (size < 0) { - code = terrno = TSDB_CODE_FAILED_TO_CONNECT_S3; - goto _exit; - } - - s3_size = size; - } - - if (tsS3Enabled && !strncmp(path + strlen(path) - 5, ".data", 5) && s3_size > 0) { -#ifndef S3_BLOCK_CACHE - s3EvictCache(path, s3_size); - s3Get(object_name, path); - - pFD->pFD = taosOpenFile(path, flag); - if (pFD->pFD == NULL) { - code = TAOS_SYSTEM_ERROR(ENOENT); - // taosMemoryFree(pFD); - goto _exit; - } -#else - pFD->pFD = (TdFilePtr)&pFD->s3File; - int32_t vid = 0; - sscanf(object_name, "v%df%dver%" PRId64 ".data", &vid, &pFD->fid, &pFD->cid); - pFD->objName = object_name; - // pFD->szFile = s3_size; -#endif - */ } pFD->pBuf = taosMemoryCalloc(1, szPage); if (pFD->pBuf == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - // taosCloseFile(&pFD->pFD); - // taosMemoryFree(pFD); - goto _exit; + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } if (lc_size > 0) { @@ -114,11 +73,7 @@ static int32_t tsdbOpenFileImpl(STsdbFD *pFD) { // not check file size when reading data files. if (flag != TD_FILE_READ /* && !pFD->s3File*/) { if (!lc_size && taosStatFile(path, &pFD->szFile, NULL, NULL) < 0) { - code = TAOS_SYSTEM_ERROR(errno); - // taosMemoryFree(pFD->pBuf); - // taosCloseFile(&pFD->pFD); - // taosMemoryFree(pFD); - goto _exit; + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(errno), lino, _exit); } } @@ -126,12 +81,16 @@ static int32_t tsdbOpenFileImpl(STsdbFD *pFD) { pFD->szFile = pFD->szFile / szPage; _exit: + if (code) { + TSDB_ERROR_LOG(TD_VID(pFD->pTsdb->pVnode), lino, code); + } return code; } // =============== PAGE-WISE FILE =============== int32_t tsdbOpenFile(const char *path, STsdb *pTsdb, int32_t flag, STsdbFD **ppFD, int32_t lcn) { int32_t code = 0; + int32_t lino; STsdbFD *pFD = NULL; int32_t szPage = pTsdb->pVnode->config.tsdbPageSize; @@ -139,8 +98,7 @@ int32_t tsdbOpenFile(const char *path, STsdb *pTsdb, int32_t flag, STsdbFD **ppF pFD = (STsdbFD *)taosMemoryCalloc(1, sizeof(*pFD) + strlen(path) + 1); if (pFD == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _exit; + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } pFD->path = (char *)&pFD[1]; @@ -155,6 +113,9 @@ int32_t tsdbOpenFile(const char *path, STsdb *pTsdb, int32_t flag, STsdbFD **ppF *ppFD = pFD; _exit: + if (code) { + TSDB_ERROR_LOG(TD_VID(pTsdb->pVnode), lino, code); + } return code; } @@ -172,12 +133,11 @@ void tsdbCloseFile(STsdbFD **ppFD) { static int32_t tsdbWriteFilePage(STsdbFD *pFD, int32_t encryptAlgorithm, char *encryptKey) { int32_t code = 0; + int32_t lino; if (!pFD->pFD) { code = tsdbOpenFileImpl(pFD); - if (code) { - goto _exit; - } + TSDB_CHECK_CODE(code, lino, _exit); } if (pFD->pgno > 0) { @@ -193,8 +153,7 @@ static int32_t tsdbWriteFilePage(STsdbFD *pFD, int32_t encryptAlgorithm, char *e int64_t n = taosLSeekFile(pFD->pFD, offset, SEEK_SET); if (n < 0) { - code = TAOS_SYSTEM_ERROR(errno); - goto _exit; + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(errno), lino, _exit); } taosCalcChecksumAppend(0, pFD->pBuf, pFD->szPage); @@ -223,8 +182,7 @@ static int32_t tsdbWriteFilePage(STsdbFD *pFD, int32_t encryptAlgorithm, char *e n = taosWriteFile(pFD->pFD, pFD->pBuf, pFD->szPage); if (n < 0) { - code = TAOS_SYSTEM_ERROR(errno); - goto _exit; + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(errno), lino, _exit); } if (pFD->szFile < pFD->pgno) { @@ -234,18 +192,20 @@ static int32_t tsdbWriteFilePage(STsdbFD *pFD, int32_t encryptAlgorithm, char *e pFD->pgno = 0; _exit: + if (code) { + TSDB_ERROR_LOG(TD_VID(pFD->pTsdb->pVnode), lino, code); + } return code; } static int32_t tsdbReadFilePage(STsdbFD *pFD, int64_t pgno, int32_t encryptAlgorithm, char *encryptKey) { int32_t code = 0; + int32_t lino; // ASSERT(pgno <= pFD->szFile); if (!pFD->pFD) { code = tsdbOpenFileImpl(pFD); - if (code) { - goto _exit; - } + TSDB_CHECK_CODE(code, lino, _exit); } int64_t offset = PAGE_OFFSET(pgno, pFD->szPage); @@ -257,43 +217,19 @@ static int32_t tsdbReadFilePage(STsdbFD *pFD, int64_t pgno, int32_t encryptAlgor offset -= chunkoffset; } ASSERT(offset >= 0); - /* - if (pFD->s3File) { - LRUHandle *handle = NULL; - pFD->blkno = (pgno + tsS3BlockSize - 1) / tsS3BlockSize; - code = tsdbCacheGetBlockS3(pFD->pTsdb->bCache, pFD, &handle); - if (code != TSDB_CODE_SUCCESS || handle == NULL) { - tsdbCacheRelease(pFD->pTsdb->bCache, handle); - if (code == TSDB_CODE_SUCCESS && !handle) { - code = TSDB_CODE_OUT_OF_MEMORY; - } - goto _exit; - } - - uint8_t *pBlock = (uint8_t *)taosLRUCacheValue(pFD->pTsdb->bCache, handle); - - int64_t blk_offset = (pFD->blkno - 1) * tsS3BlockSize * pFD->szPage; - memcpy(pFD->pBuf, pBlock + (offset - blk_offset), pFD->szPage); - - tsdbCacheRelease(pFD->pTsdb->bCache, handle); - } else { - */ // seek int64_t n = taosLSeekFile(pFD->pFD, offset, SEEK_SET); if (n < 0) { - code = TAOS_SYSTEM_ERROR(errno); - goto _exit; + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(errno), lino, _exit); } // read n = taosReadFile(pFD->pFD, pFD->pBuf, pFD->szPage); if (n < 0) { - code = TAOS_SYSTEM_ERROR(errno); - goto _exit; + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(errno), lino, _exit); } else if (n < pFD->szPage) { - code = TSDB_CODE_FILE_CORRUPTED; - goto _exit; + TSDB_CHECK_CODE(code = TSDB_CODE_FILE_CORRUPTED, lino, _exit); } //} @@ -322,19 +258,22 @@ static int32_t tsdbReadFilePage(STsdbFD *pFD, int64_t pgno, int32_t encryptAlgor // check if (pgno > 1 && !taosCheckChecksumWhole(pFD->pBuf, pFD->szPage)) { - code = TSDB_CODE_FILE_CORRUPTED; - goto _exit; + TSDB_CHECK_CODE(code = TSDB_CODE_FILE_CORRUPTED, lino, _exit); } pFD->pgno = pgno; _exit: + if (code) { + TSDB_ERROR_LOG(TD_VID(pFD->pTsdb->pVnode), lino, code); + } return code; } int32_t tsdbWriteFile(STsdbFD *pFD, int64_t offset, const uint8_t *pBuf, int64_t size, int32_t encryptAlgorithm, char *encryptKey) { int32_t code = 0; + int32_t lino; int64_t fOffset = LOGIC_TO_FILE_OFFSET(offset, pFD->szPage); int64_t pgno = OFFSET_PGNO(fOffset, pFD->szPage); int64_t bOffset = fOffset % pFD->szPage; @@ -343,11 +282,11 @@ int32_t tsdbWriteFile(STsdbFD *pFD, int64_t offset, const uint8_t *pBuf, int64_t do { if (pFD->pgno != pgno) { code = tsdbWriteFilePage(pFD, encryptAlgorithm, encryptKey); - if (code) goto _exit; + TSDB_CHECK_CODE(code, lino, _exit); if (pgno <= pFD->szFile) { code = tsdbReadFilePage(pFD, pgno, encryptAlgorithm, encryptKey); - if (code) goto _exit; + TSDB_CHECK_CODE(code, lino, _exit); } else { pFD->pgno = pgno; } @@ -362,12 +301,16 @@ int32_t tsdbWriteFile(STsdbFD *pFD, int64_t offset, const uint8_t *pBuf, int64_t } while (n < size); _exit: + if (code) { + TSDB_ERROR_LOG(TD_VID(pFD->pTsdb->pVnode), lino, code); + } return code; } static int32_t tsdbReadFileImp(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int64_t size, int32_t encryptAlgorithm, char *encryptKey) { int32_t code = 0; + int32_t lino; int64_t n = 0; int64_t fOffset = LOGIC_TO_FILE_OFFSET(offset, pFD->szPage); int64_t pgno = OFFSET_PGNO(fOffset, pFD->szPage); @@ -380,7 +323,7 @@ static int32_t tsdbReadFileImp(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int6 while (n < size) { if (pFD->pgno != pgno) { code = tsdbReadFilePage(pFD, pgno, encryptAlgorithm, encryptKey); - if (code) goto _exit; + TSDB_CHECK_CODE(code, lino, _exit); } int64_t nRead = TMIN(szPgCont - bOffset, size - n); @@ -392,15 +335,20 @@ static int32_t tsdbReadFileImp(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int6 } _exit: + if (code) { + TSDB_ERROR_LOG(TD_VID(pFD->pTsdb->pVnode), lino, code); + } return code; } static int32_t tsdbReadFileBlock(STsdbFD *pFD, int64_t offset, int64_t size, bool check, uint8_t **ppBlock) { int32_t code = 0; + int32_t lino; SVnodeCfg *pCfg = &pFD->pTsdb->pVnode->config; int64_t chunksize = (int64_t)pCfg->tsdbPageSize * pCfg->s3ChunkSize; int64_t cOffset = offset % chunksize; int64_t n = 0; + char *buf = NULL; char *object_name = taosDirEntryBaseName(pFD->path); char object_name_prefix[TSDB_FILENAME_LEN]; @@ -410,11 +358,13 @@ static int32_t tsdbReadFileBlock(STsdbFD *pFD, int64_t offset, int64_t size, boo char *dot = strrchr(object_name_prefix, '.'); if (!dot) { tsdbError("unexpected path: %s", object_name_prefix); - code = TAOS_SYSTEM_ERROR(ENOENT); - goto _exit; + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(ENOENT), lino, _exit); } - char *buf = taosMemoryCalloc(1, size); + buf = taosMemoryCalloc(1, size); + if (buf == NULL) { + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); + } for (int32_t chunkno = offset / chunksize + 1; n < size; ++chunkno) { int64_t nRead = TMIN(chunksize - cOffset, size - n); @@ -423,20 +373,14 @@ static int32_t tsdbReadFileBlock(STsdbFD *pFD, int64_t offset, int64_t size, boo // read last chunk int64_t ret = taosLSeekFile(pFD->pFD, chunksize * (chunkno - pFD->lcn) + cOffset, SEEK_SET); if (ret < 0) { - code = TAOS_SYSTEM_ERROR(errno); - taosMemoryFree(buf); - goto _exit; + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(errno), lino, _exit); } ret = taosReadFile(pFD->pFD, buf + n, nRead); if (ret < 0) { - code = TAOS_SYSTEM_ERROR(errno); - taosMemoryFree(buf); - goto _exit; + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(errno), lino, _exit); } else if (ret < nRead) { - code = TSDB_CODE_FILE_CORRUPTED; - taosMemoryFree(buf); - goto _exit; + TSDB_CHECK_CODE(code = TSDB_CODE_FILE_CORRUPTED, lino, _exit); } } else { uint8_t *pBlock = NULL; @@ -444,10 +388,7 @@ static int32_t tsdbReadFileBlock(STsdbFD *pFD, int64_t offset, int64_t size, boo snprintf(dot + 1, TSDB_FQDN_LEN - (dot + 1 - object_name_prefix), "%d.data", chunkno); code = s3GetObjectBlock(object_name_prefix, cOffset, nRead, check, &pBlock); - if (code != TSDB_CODE_SUCCESS) { - taosMemoryFree(buf); - goto _exit; - } + TSDB_CHECK_CODE(code, lino, _exit); memcpy(buf + n, pBlock, nRead); taosMemoryFree(pBlock); @@ -457,14 +398,19 @@ static int32_t tsdbReadFileBlock(STsdbFD *pFD, int64_t offset, int64_t size, boo cOffset = 0; } - *ppBlock = buf; - _exit: + if (code) { + TSDB_ERROR_LOG(TD_VID(pFD->pTsdb->pVnode), lino, code); + taosMemoryFree(buf); + } else { + *ppBlock = (uint8_t *)buf; + } return code; } static int32_t tsdbReadFileS3(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int64_t size, int64_t szHint) { int32_t code = 0; + int32_t lino; int64_t n = 0; int32_t szPgCont = PAGE_CONTENT_SIZE(pFD->szPage); int64_t fOffset = LOGIC_TO_FILE_OFFSET(offset, pFD->szPage); @@ -486,7 +432,7 @@ static int32_t tsdbReadFileS3(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int64 if (handle) { tsdbCacheRelease(pFD->pTsdb->pgCache, handle); } - goto _exit; + TSDB_CHECK_CODE(code, lino, _exit); } if (!handle) { @@ -499,8 +445,7 @@ static int32_t tsdbReadFileS3(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int64 // check if (pgno > 1 && !taosCheckChecksumWhole(pFD->pBuf, pFD->szPage)) { - code = TSDB_CODE_FILE_CORRUPTED; - goto _exit; + TSDB_CHECK_CODE(code = TSDB_CODE_FILE_CORRUPTED, lino, _exit); } pFD->pgno = pgno; @@ -525,16 +470,9 @@ static int32_t tsdbReadFileS3(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int64 } int64_t retrieve_size = (pgnoEnd - pgno + 1) * pFD->szPage; - /* - code = s3GetObjectBlock(pFD->objName, retrieve_offset, retrieve_size, 1, &pBlock); - if (code != TSDB_CODE_SUCCESS) { - goto _exit; - } - */ + code = tsdbReadFileBlock(pFD, retrieve_offset, retrieve_size, 1, &pBlock); - if (code != TSDB_CODE_SUCCESS) { - goto _exit; - } + TSDB_CHECK_CODE(code, lino, _exit); // 3, Store Pages in Cache int nPage = pgnoEnd - pgno + 1; for (int i = 0; i < nPage; ++i) { @@ -550,8 +488,7 @@ static int32_t tsdbReadFileS3(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int64 // check if (pgno > 1 && !taosCheckChecksumWhole(pFD->pBuf, pFD->szPage)) { - code = TSDB_CODE_FILE_CORRUPTED; - goto _exit; + TSDB_CHECK_CODE(code = TSDB_CODE_FILE_CORRUPTED, lino, _exit); } pFD->pgno = pgno; @@ -568,59 +505,72 @@ static int32_t tsdbReadFileS3(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int64 } _exit: + if (code) { + TSDB_ERROR_LOG(TD_VID(pFD->pTsdb->pVnode), lino, code); + } return code; } int32_t tsdbReadFile(STsdbFD *pFD, int64_t offset, uint8_t *pBuf, int64_t size, int64_t szHint, int32_t encryptAlgorithm, char *encryptKey) { int32_t code = 0; + int32_t lino; + if (!pFD->pFD) { code = tsdbOpenFileImpl(pFD); - if (code) { - goto _exit; - } + TSDB_CHECK_CODE(code, lino, _exit); } if (pFD->s3File && pFD->lcn > 1 /* && tsS3BlockSize < 0*/) { - return tsdbReadFileS3(pFD, offset, pBuf, size, szHint); + code = tsdbReadFileS3(pFD, offset, pBuf, size, szHint); + TSDB_CHECK_CODE(code, lino, _exit); } else { - return tsdbReadFileImp(pFD, offset, pBuf, size, encryptAlgorithm, encryptKey); + code = tsdbReadFileImp(pFD, offset, pBuf, size, encryptAlgorithm, encryptKey); + TSDB_CHECK_CODE(code, lino, _exit); } _exit: + if (code) { + TSDB_ERROR_LOG(TD_VID(pFD->pTsdb->pVnode), lino, code); + } return code; } int32_t tsdbReadFileToBuffer(STsdbFD *pFD, int64_t offset, int64_t size, SBuffer *buffer, int64_t szHint, int32_t encryptAlgorithm, char *encryptKey) { int32_t code; + int32_t lino; code = tBufferEnsureCapacity(buffer, buffer->size + size); - if (code) return code; + TSDB_CHECK_CODE(code, lino, _exit); + code = tsdbReadFile(pFD, offset, (uint8_t *)tBufferGetDataEnd(buffer), size, szHint, encryptAlgorithm, encryptKey); - if (code) return code; + TSDB_CHECK_CODE(code, lino, _exit); + buffer->size += size; +_exit: + if (code) { + TSDB_ERROR_LOG(TD_VID(pFD->pTsdb->pVnode), lino, code); + } return code; } int32_t tsdbFsyncFile(STsdbFD *pFD, int32_t encryptAlgorithm, char *encryptKey) { int32_t code = 0; - /* - if (pFD->s3File) { - tsdbWarn("%s file: %s", __func__, pFD->path); - return code; - } - */ + int32_t lino; + code = tsdbWriteFilePage(pFD, encryptAlgorithm, encryptKey); - if (code) goto _exit; + TSDB_CHECK_CODE(code, lino, _exit); if (taosFsyncFile(pFD->pFD) < 0) { - code = TAOS_SYSTEM_ERROR(errno); - goto _exit; + TSDB_CHECK_CODE(code = TAOS_SYSTEM_ERROR(errno), lino, _exit); } _exit: + if (code) { + TSDB_ERROR_LOG(TD_VID(pFD->pTsdb->pVnode), lino, code); + } return code; } @@ -635,8 +585,7 @@ int32_t tsdbDataFReaderOpen(SDataFReader **ppReader, STsdb *pTsdb, SDFileSet *pS // alloc pReader = (SDataFReader *)taosMemoryCalloc(1, sizeof(*pReader)); if (pReader == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - TSDB_CHECK_CODE(code, lino, _exit); + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } pReader->pTsdb = pTsdb; pReader->pSet = pSet; @@ -711,22 +660,25 @@ int32_t tsdbDataFReaderClose(SDataFReader **ppReader) { int32_t tsdbReadBlockIdx(SDataFReader *pReader, SArray *aBlockIdx) { int32_t code = 0; + int32_t lino; SHeadFile *pHeadFile = pReader->pSet->pHeadF; int64_t offset = pHeadFile->offset; int64_t size = pHeadFile->size - offset; taosArrayClear(aBlockIdx); - if (size == 0) return code; + if (size == 0) { + return code; + } // alloc code = tRealloc(&pReader->aBuf[0], size); - if (code) goto _err; + TSDB_CHECK_CODE(code, lino, _exit); // read int32_t encryptAlgorithm = pReader->pTsdb->pVnode->config.tsdbCfg.encryptAlgorithm; char *encryptKey = pReader->pTsdb->pVnode->config.tsdbCfg.encryptKey; code = tsdbReadFile(pReader->pHeadFD, offset, pReader->aBuf[0], size, 0, encryptAlgorithm, encryptKey); - if (code) goto _err; + TSDB_CHECK_CODE(code, lino, _exit); // decode int64_t n = 0; @@ -735,37 +687,39 @@ int32_t tsdbReadBlockIdx(SDataFReader *pReader, SArray *aBlockIdx) { n += tGetBlockIdx(pReader->aBuf[0] + n, &blockIdx); if (taosArrayPush(aBlockIdx, &blockIdx) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } } ASSERT(n == size); - return code; - -_err: - tsdbError("vgId:%d, read block idx failed since %s", TD_VID(pReader->pTsdb->pVnode), tstrerror(code)); +_exit: + if (code) { + TSDB_ERROR_LOG(TD_VID(pReader->pTsdb->pVnode), lino, code); + } return code; } int32_t tsdbReadSttBlk(SDataFReader *pReader, int32_t iStt, SArray *aSttBlk) { int32_t code = 0; + int32_t lino; SSttFile *pSttFile = pReader->pSet->aSttF[iStt]; int64_t offset = pSttFile->offset; int64_t size = pSttFile->size - offset; taosArrayClear(aSttBlk); - if (size == 0) return code; + if (size == 0) { + return 0; + } // alloc code = tRealloc(&pReader->aBuf[0], size); - if (code) goto _err; + TSDB_CHECK_CODE(code, lino, _exit); // read int32_t encryptAlgorithm = pReader->pTsdb->pVnode->config.tsdbCfg.encryptAlgorithm; char *encryptKey = pReader->pTsdb->pVnode->config.tsdbCfg.encryptKey; code = tsdbReadFile(pReader->aSttFD[iStt], offset, pReader->aBuf[0], size, 0, encryptAlgorithm, encryptKey); - if (code) goto _err; + TSDB_CHECK_CODE(code, lino, _exit); // decode int64_t n = 0; @@ -774,33 +728,33 @@ int32_t tsdbReadSttBlk(SDataFReader *pReader, int32_t iStt, SArray *aSttBlk) { n += tGetSttBlk(pReader->aBuf[0] + n, &sttBlk); if (taosArrayPush(aSttBlk, &sttBlk) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } } ASSERT(n == size); - return code; - -_err: - tsdbError("vgId:%d, read stt blk failed since %s", TD_VID(pReader->pTsdb->pVnode), tstrerror(code)); +_exit: + if (code) { + TSDB_ERROR_LOG(TD_VID(pReader->pTsdb->pVnode), lino, code); + } return code; } int32_t tsdbReadDataBlk(SDataFReader *pReader, SBlockIdx *pBlockIdx, SMapData *mDataBlk) { int32_t code = 0; + int32_t lino; int64_t offset = pBlockIdx->offset; int64_t size = pBlockIdx->size; // alloc code = tRealloc(&pReader->aBuf[0], size); - if (code) goto _err; + TSDB_CHECK_CODE(code, lino, _exit); // read int32_t encryptAlgorithm = pReader->pTsdb->pVnode->config.tsdbCfg.encryptAlgorithm; char *encryptKey = pReader->pTsdb->pVnode->config.tsdbCfg.encryptKey; code = tsdbReadFile(pReader->pHeadFD, offset, pReader->aBuf[0], size, 0, encryptAlgorithm, encryptKey); - if (code) goto _err; + TSDB_CHECK_CODE(code, lino, _exit); // decode int32_t n; @@ -808,10 +762,10 @@ int32_t tsdbReadDataBlk(SDataFReader *pReader, SBlockIdx *pBlockIdx, SMapData *m if (code) goto _err; ASSERT(n == size); - return code; - -_err: - tsdbError("vgId:%d, read block failed since %s", TD_VID(pReader->pTsdb->pVnode), tstrerror(code)); +_exit: + if (code) { + TSDB_ERROR_LOG(TD_VID(pReader->pTsdb->pVnode), lino, code); + } return code; } @@ -832,8 +786,7 @@ int32_t tsdbDelFReaderOpen(SDelFReader **ppReader, SDelFile *pFile, STsdb *pTsdb // alloc pDelFReader = (SDelFReader *)taosMemoryCalloc(1, sizeof(*pDelFReader)); if (pDelFReader == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _exit; + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } // open impl @@ -842,15 +795,13 @@ int32_t tsdbDelFReaderOpen(SDelFReader **ppReader, SDelFile *pFile, STsdb *pTsdb tsdbDelFileName(pTsdb, pFile, fname); code = tsdbOpenFile(fname, pTsdb, TD_FILE_READ, &pDelFReader->pReadH, 0); - if (code) { - taosMemoryFree(pDelFReader); - goto _exit; - } + TSDB_CHECK_CODE(code, lino, _exit); _exit: if (code) { *ppReader = NULL; - tsdbError("vgId:%d, %s failed at %d since %s", TD_VID(pTsdb->pVnode), __func__, lino, tstrerror(code)); + TSDB_ERROR_LOG(TD_VID(pTsdb->pVnode), lino, code); + taosMemoryFree(pDelFReader); } else { *ppReader = pDelFReader; } @@ -879,6 +830,7 @@ int32_t tsdbReadDelData(SDelFReader *pReader, SDelIdx *pDelIdx, SArray *aDelData int32_t tsdbReadDelDatav1(SDelFReader *pReader, SDelIdx *pDelIdx, SArray *aDelData, int64_t maxVer) { int32_t code = 0; + int32_t lino; int64_t offset = pDelIdx->offset; int64_t size = pDelIdx->size; int64_t n; @@ -887,13 +839,13 @@ int32_t tsdbReadDelDatav1(SDelFReader *pReader, SDelIdx *pDelIdx, SArray *aDelDa // alloc code = tRealloc(&pReader->aBuf[0], size); - if (code) goto _err; + TSDB_CHECK_CODE(code, lino, _exit); // read int32_t encryptAlgorithm = pReader->pTsdb->pVnode->config.tsdbCfg.encryptAlgorithm; char *encryptKey = pReader->pTsdb->pVnode->config.tsdbCfg.encryptKey; code = tsdbReadFile(pReader->pReadH, offset, pReader->aBuf[0], size, 0, encryptAlgorithm, encryptKey); - if (code) goto _err; + TSDB_CHECK_CODE(code, lino, _exit); // // decode n = 0; @@ -905,22 +857,22 @@ int32_t tsdbReadDelDatav1(SDelFReader *pReader, SDelIdx *pDelIdx, SArray *aDelDa continue; } if (taosArrayPush(aDelData, &delData) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } } ASSERT(n == size); - return code; - -_err: - tsdbError("vgId:%d, read del data failed since %s", TD_VID(pReader->pTsdb->pVnode), tstrerror(code)); +_exit: + if (code) { + TSDB_ERROR_LOG(TD_VID(pReader->pTsdb->pVnode), lino, code); + } return code; } int32_t tsdbReadDelIdx(SDelFReader *pReader, SArray *aDelIdx) { int32_t code = 0; + int32_t lino; int32_t n; int64_t offset = pReader->fDel.offset; int64_t size = pReader->fDel.size - offset; @@ -929,13 +881,13 @@ int32_t tsdbReadDelIdx(SDelFReader *pReader, SArray *aDelIdx) { // alloc code = tRealloc(&pReader->aBuf[0], size); - if (code) goto _err; + TSDB_CHECK_CODE(code, lino, _exit); // read int32_t encryptAlgorithm = pReader->pTsdb->pVnode->config.tsdbCfg.encryptAlgorithm; char *encryptKey = pReader->pTsdb->pVnode->config.tsdbCfg.encryptKey; code = tsdbReadFile(pReader->pReadH, offset, pReader->aBuf[0], size, 0, encryptAlgorithm, encryptKey); - if (code) goto _err; + TSDB_CHECK_CODE(code, lino, _exit); // decode n = 0; @@ -945,16 +897,15 @@ int32_t tsdbReadDelIdx(SDelFReader *pReader, SArray *aDelIdx) { n += tGetDelIdx(pReader->aBuf[0] + n, &delIdx); if (taosArrayPush(aDelIdx, &delIdx) == NULL) { - code = TSDB_CODE_OUT_OF_MEMORY; - goto _err; + TSDB_CHECK_CODE(code = TSDB_CODE_OUT_OF_MEMORY, lino, _exit); } } ASSERT(n == size); - return code; - -_err: - tsdbError("vgId:%d, read del idx failed since %s", TD_VID(pReader->pTsdb->pVnode), tstrerror(code)); +_exit: + if (code) { + TSDB_ERROR_LOG(TD_VID(pReader->pTsdb->pVnode), lino, code); + } return code; } diff --git a/source/libs/executor/src/exchangeoperator.c b/source/libs/executor/src/exchangeoperator.c index 059e1f2663..a6a273cce8 100644 --- a/source/libs/executor/src/exchangeoperator.c +++ b/source/libs/executor/src/exchangeoperator.c @@ -607,7 +607,7 @@ int32_t extractDataBlockFromFetchRsp(SSDataBlock* pRes, char* pData, SArray* pCo blockDataAppendColInfo(pBlock, &idata); } - blockDecode(pBlock, pStart); + (void) blockDecode(pBlock, pStart); blockDataEnsureCapacity(pRes, pBlock->info.rows); // data from mnode diff --git a/source/libs/executor/src/executorInt.c b/source/libs/executor/src/executorInt.c index fad2b263b2..0476a7981c 100644 --- a/source/libs/executor/src/executorInt.c +++ b/source/libs/executor/src/executorInt.c @@ -970,7 +970,7 @@ void cleanupExprSupp(SExprSupp* pSupp) { taosMemoryFree(pSupp->rowEntryInfoOffset); } -void cleanupBasicInfo(SOptrBasicInfo* pInfo) { pInfo->pRes = blockDataDestroy(pInfo->pRes); } +void cleanupBasicInfo(SOptrBasicInfo* pInfo) { blockDataDestroy(pInfo->pRes); pInfo->pRes = NULL;} bool groupbyTbname(SNodeList* pGroupList) { bool bytbname = false; diff --git a/source/libs/executor/src/filloperator.c b/source/libs/executor/src/filloperator.c index e1aa75d828..ad1c6d67d4 100644 --- a/source/libs/executor/src/filloperator.c +++ b/source/libs/executor/src/filloperator.c @@ -310,8 +310,10 @@ static SSDataBlock* doFill(SOperatorInfo* pOperator) { void destroyFillOperatorInfo(void* param) { SFillOperatorInfo* pInfo = (SFillOperatorInfo*)param; pInfo->pFillInfo = taosDestroyFillInfo(pInfo->pFillInfo); - pInfo->pRes = blockDataDestroy(pInfo->pRes); - pInfo->pFinalRes = blockDataDestroy(pInfo->pFinalRes); + blockDataDestroy(pInfo->pRes); + pInfo->pRes = NULL; + blockDataDestroy(pInfo->pFinalRes); + pInfo->pFinalRes = NULL; cleanupExprSupp(&pInfo->noFillExprSupp); diff --git a/source/libs/executor/src/hashjoinoperator.c b/source/libs/executor/src/hashjoinoperator.c index 2fe2ccc56f..adc1055a6b 100755 --- a/source/libs/executor/src/hashjoinoperator.c +++ b/source/libs/executor/src/hashjoinoperator.c @@ -1065,7 +1065,8 @@ static void destroyHashJoinOperator(void* param) { hJoinFreeTableInfo(&pJoinOperator->tbs[0]); hJoinFreeTableInfo(&pJoinOperator->tbs[1]); - pJoinOperator->finBlk = blockDataDestroy(pJoinOperator->finBlk); + blockDataDestroy(pJoinOperator->finBlk); + pJoinOperator->finBlk = NULL; taosMemoryFreeClear(pJoinOperator->pResColMap); taosArrayDestroyEx(pJoinOperator->pRowBufs, hJoinFreeBufPage); diff --git a/source/libs/executor/src/mergejoin.c b/source/libs/executor/src/mergejoin.c index 5f0a2eadfb..50ce604a7c 100755 --- a/source/libs/executor/src/mergejoin.c +++ b/source/libs/executor/src/mergejoin.c @@ -3304,9 +3304,11 @@ void mJoinDestroyWindowCtx(SMJoinOperatorInfo* pJoin) { SMJoinWindowCtx* pCtx = &pJoin->ctx.windowCtx; mWinJoinResetWindowCache(pCtx, &pCtx->cache); - - pCtx->finBlk = blockDataDestroy(pCtx->finBlk); - pCtx->cache.outBlk = blockDataDestroy(pCtx->cache.outBlk); + + blockDataDestroy(pCtx->finBlk); + pCtx->finBlk = NULL; + blockDataDestroy(pCtx->cache.outBlk); + pCtx->cache.outBlk = NULL; taosArrayDestroy(pCtx->cache.grps); } @@ -3378,9 +3380,11 @@ int32_t mJoinInitWindowCtx(SMJoinOperatorInfo* pJoin, SSortMergeJoinPhysiNode* p void mJoinDestroyMergeCtx(SMJoinOperatorInfo* pJoin) { SMJoinMergeCtx* pCtx = &pJoin->ctx.mergeCtx; + blockDataDestroy(pCtx->finBlk); + blockDataDestroy(pCtx->midBlk); - pCtx->finBlk = blockDataDestroy(pCtx->finBlk); - pCtx->midBlk = blockDataDestroy(pCtx->midBlk); + pCtx->finBlk = NULL; + pCtx->midBlk = NULL; } diff --git a/source/libs/executor/src/mergeoperator.c b/source/libs/executor/src/mergeoperator.c index 993e8c72fd..2816bae03c 100755 --- a/source/libs/executor/src/mergeoperator.c +++ b/source/libs/executor/src/mergeoperator.c @@ -232,8 +232,11 @@ int32_t getSortMergeExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplain, u void destroySortMergeOperatorInfo(void* param) { SSortMergeInfo* pSortMergeInfo = param; - pSortMergeInfo->pInputBlock = blockDataDestroy(pSortMergeInfo->pInputBlock); - pSortMergeInfo->pIntermediateBlock = blockDataDestroy(pSortMergeInfo->pIntermediateBlock); + blockDataDestroy(pSortMergeInfo->pInputBlock); + pSortMergeInfo->pInputBlock = NULL; + + blockDataDestroy(pSortMergeInfo->pIntermediateBlock); + pSortMergeInfo->pIntermediateBlock = NULL; taosArrayDestroy(pSortMergeInfo->matchInfo.pList); @@ -429,7 +432,8 @@ SSDataBlock* doMultiwayMerge(SOperatorInfo* pOperator) { void destroyMultiwayMergeOperatorInfo(void* param) { SMultiwayMergeOperatorInfo* pInfo = (SMultiwayMergeOperatorInfo*)param; - pInfo->binfo.pRes = blockDataDestroy(pInfo->binfo.pRes); + blockDataDestroy(pInfo->binfo.pRes); + pInfo->binfo.pRes = NULL; if (NULL != gMultiwayMergeFps[pInfo->type].closeFn) { (*gMultiwayMergeFps[pInfo->type].closeFn)(&pInfo->sortMergeInfo); diff --git a/source/libs/executor/src/scanoperator.c b/source/libs/executor/src/scanoperator.c index 678d8d569e..39b1cce600 100644 --- a/source/libs/executor/src/scanoperator.c +++ b/source/libs/executor/src/scanoperator.c @@ -220,14 +220,14 @@ static int32_t doDynamicPruneDataBlock(SOperatorInfo* pOperator, SDataBlockInfo* return code; } -static bool doFilterByBlockSMA(SFilterInfo* pFilterInfo, SColumnDataAgg* pColsAgg, int32_t numOfCols, - int32_t numOfRows) { +static int32_t doFilterByBlockSMA(SFilterInfo* pFilterInfo, SColumnDataAgg* pColsAgg, int32_t numOfCols, + int32_t numOfRows, bool *keep) { if (pColsAgg == NULL || pFilterInfo == NULL) { - return true; + *keep = true; + return TSDB_CODE_SUCCESS; } - bool keep = filterRangeExecute(pFilterInfo, pColsAgg, numOfCols, numOfRows); - return keep; + return filterRangeExecute(pFilterInfo, pColsAgg, numOfCols, numOfRows, keep); } static bool doLoadBlockSMA(STableScanBase* pTableScanInfo, SSDataBlock* pBlock, SExecTaskInfo* pTaskInfo) { @@ -351,7 +351,11 @@ static int32_t loadDataBlock(SOperatorInfo* pOperator, STableScanBase* pTableSca bool success = doLoadBlockSMA(pTableScanInfo, pBlock, pTaskInfo); if (success) { size_t size = taosArrayGetSize(pBlock->pDataBlock); - bool keep = doFilterByBlockSMA(pOperator->exprSupp.pFilterInfo, pBlock->pBlockAgg, size, pBlockInfo->rows); + bool keep = false; + int32_t code = doFilterByBlockSMA(pOperator->exprSupp.pFilterInfo, pBlock->pBlockAgg, size, pBlockInfo->rows, &keep); + if (TSDB_CODE_SUCCESS != code) { + return code; + } 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); @@ -3785,7 +3789,8 @@ static void destroyTagScanOperatorInfo(void* param) { taosArrayDestroy(pInfo->aFilterIdxs); taosArrayDestroyEx(pInfo->aUidTags, tagScanFreeUidTag); - pInfo->pRes = blockDataDestroy(pInfo->pRes); + blockDataDestroy(pInfo->pRes); + pInfo->pRes = NULL; taosArrayDestroy(pInfo->matchInfo.pList); pInfo->pTableListInfo = tableListDestroy(pInfo->pTableListInfo); taosMemoryFreeClear(param); @@ -4738,15 +4743,19 @@ void destroyTableMergeScanOperatorInfo(void* param) { pTableScanInfo->pSortHandle = NULL; taosHashCleanup(pTableScanInfo->mSkipTables); pTableScanInfo->mSkipTables = NULL; - pTableScanInfo->pSortInputBlock = blockDataDestroy(pTableScanInfo->pSortInputBlock); + blockDataDestroy(pTableScanInfo->pSortInputBlock); + pTableScanInfo->pSortInputBlock = NULL; // end one reader variable cleanupQueryTableDataCond(&pTableScanInfo->base.cond); destroyTableScanBase(&pTableScanInfo->base, &pTableScanInfo->base.readerAPI); - pTableScanInfo->pResBlock = blockDataDestroy(pTableScanInfo->pResBlock); + blockDataDestroy(pTableScanInfo->pResBlock); + pTableScanInfo->pResBlock = NULL; + // remove it from the task->result list - pTableScanInfo->pReaderBlock = blockDataDestroy(pTableScanInfo->pReaderBlock); + blockDataDestroy(pTableScanInfo->pReaderBlock); + pTableScanInfo->pReaderBlock = NULL; taosArrayDestroy(pTableScanInfo->pSortInfo); stopSubTablesTableMergeScan(pTableScanInfo); diff --git a/source/libs/executor/src/sortoperator.c b/source/libs/executor/src/sortoperator.c index 507dbe7ee2..82eebf5310 100644 --- a/source/libs/executor/src/sortoperator.c +++ b/source/libs/executor/src/sortoperator.c @@ -368,7 +368,8 @@ SSDataBlock* doSort(SOperatorInfo* pOperator) { void destroySortOperatorInfo(void* param) { SSortOperatorInfo* pInfo = (SSortOperatorInfo*)param; - pInfo->binfo.pRes = blockDataDestroy(pInfo->binfo.pRes); + blockDataDestroy(pInfo->binfo.pRes); + pInfo->binfo.pRes = NULL; tsortDestroySortHandle(pInfo->pSortHandle); taosArrayDestroy(pInfo->pSortInfo); @@ -611,7 +612,8 @@ int32_t getGroupSortExplainExecInfo(SOperatorInfo* pOptr, void** pOptrExplain, u void destroyGroupSortOperatorInfo(void* param) { SGroupSortOperatorInfo* pInfo = (SGroupSortOperatorInfo*)param; - pInfo->binfo.pRes = blockDataDestroy(pInfo->binfo.pRes); + blockDataDestroy(pInfo->binfo.pRes); + pInfo->binfo.pRes = NULL; taosArrayDestroy(pInfo->pSortInfo); taosArrayDestroy(pInfo->matchInfo.pList); diff --git a/source/libs/executor/src/streamfilloperator.c b/source/libs/executor/src/streamfilloperator.c index 5f188c2c8a..384c763063 100644 --- a/source/libs/executor/src/streamfilloperator.c +++ b/source/libs/executor/src/streamfilloperator.c @@ -126,9 +126,12 @@ static void destroyStreamFillOperatorInfo(void* param) { SStreamFillOperatorInfo* pInfo = (SStreamFillOperatorInfo*)param; pInfo->pFillInfo = destroyStreamFillInfo(pInfo->pFillInfo); pInfo->pFillSup = destroyStreamFillSupporter(pInfo->pFillSup); - pInfo->pRes = blockDataDestroy(pInfo->pRes); - pInfo->pSrcBlock = blockDataDestroy(pInfo->pSrcBlock); - pInfo->pDelRes = blockDataDestroy(pInfo->pDelRes); + blockDataDestroy(pInfo->pRes); + pInfo->pRes = NULL; + blockDataDestroy(pInfo->pSrcBlock); + pInfo->pSrcBlock = NULL; + blockDataDestroy(pInfo->pDelRes); + pInfo->pDelRes = NULL; taosArrayDestroy(pInfo->matchInfo.pList); pInfo->matchInfo.pList = NULL; taosMemoryFree(pInfo); diff --git a/source/libs/executor/src/timesliceoperator.c b/source/libs/executor/src/timesliceoperator.c index cda22fa320..cdcc702629 100644 --- a/source/libs/executor/src/timesliceoperator.c +++ b/source/libs/executor/src/timesliceoperator.c @@ -1087,7 +1087,8 @@ _error: void destroyTimeSliceOperatorInfo(void* param) { STimeSliceOperatorInfo* pInfo = (STimeSliceOperatorInfo*)param; - pInfo->pRes = blockDataDestroy(pInfo->pRes); + blockDataDestroy(pInfo->pRes); + pInfo->pRes = NULL; for (int32_t i = 0; i < taosArrayGetSize(pInfo->pPrevRow); ++i) { SGroupKeys* pKey = taosArrayGet(pInfo->pPrevRow, i); diff --git a/source/libs/executor/src/tsort.c b/source/libs/executor/src/tsort.c index d9bcc954a4..6d88eaef99 100644 --- a/source/libs/executor/src/tsort.c +++ b/source/libs/executor/src/tsort.c @@ -555,7 +555,8 @@ static int32_t adjustMergeTreeForNextTuple(SSortSource* pSource, SMultiwayMergeT (*numOfCompleted) += 1; pSource->src.rowIndex = -1; pSource->pageIndex = -1; - pSource->src.pBlock = blockDataDestroy(pSource->src.pBlock); + blockDataDestroy(pSource->src.pBlock); + pSource->src.pBlock = NULL; } else { if (pSource->pageIndex % 512 == 0) { qDebug("begin source %p page %d", pSource, pSource->pageIndex); diff --git a/source/libs/geometry/src/geomFunc.c b/source/libs/geometry/src/geomFunc.c index 2ac1761737..6e32aaf1a6 100644 --- a/source/libs/geometry/src/geomFunc.c +++ b/source/libs/geometry/src/geomFunc.c @@ -143,12 +143,24 @@ int32_t executeMakePointFunc(SColumnInfoData *pInputData[], int32_t iLeft, int32 getDoubleValueFn[1]= getVectorDoubleValueFn(pInputData[1]->info.type); unsigned char *output = NULL; - code = doMakePointFunc(getDoubleValueFn[0](pInputData[0]->pData, iLeft), getDoubleValueFn[1](pInputData[1]->pData, iRight), &output); - if (code != TSDB_CODE_SUCCESS) { + double leftRes = 0; + double rightRes = 0; + code = getDoubleValueFn[0](pInputData[0]->pData, iLeft, &leftRes); + if (TSDB_CODE_SUCCESS != code) { + goto _exit; + } + code = getDoubleValueFn[1](pInputData[1]->pData, iRight, &rightRes); + if (TSDB_CODE_SUCCESS != code) { + goto _exit; + } + code = doMakePointFunc(leftRes, rightRes, &output); + if (TSDB_CODE_SUCCESS != code) { + goto _exit; + } + code = colDataSetVal(pOutputData, TMAX(iLeft, iRight), output, (output == NULL)); + if (TSDB_CODE_SUCCESS != code) { goto _exit; } - - colDataSetVal(pOutputData, TMAX(iLeft, iRight), output, (output == NULL)); _exit: if (output) { diff --git a/source/libs/planner/src/planOptimizer.c b/source/libs/planner/src/planOptimizer.c index 05ee27f6de..b1db171875 100644 --- a/source/libs/planner/src/planOptimizer.c +++ b/source/libs/planner/src/planOptimizer.c @@ -5045,7 +5045,13 @@ static int32_t hashJoinOptSplitPrimFromLogicCond(SNode **pCondition, SNode **pPr SNodeList *pPrimaryKeyConds = NULL; SNode *pCond = NULL; WHERE_EACH(pCond, pLogicCond->pParameterList) { - if (filterIsMultiTableColsCond(pCond) || COND_TYPE_PRIMARY_KEY != filterClassifyCondition(pCond)) { + bool result = false; + code = filterIsMultiTableColsCond(pCond, &result); + if (TSDB_CODE_SUCCESS != code) { + break; + } + + if (result || COND_TYPE_PRIMARY_KEY != filterClassifyCondition(pCond)) { WHERE_NEXT; continue; } @@ -5089,7 +5095,12 @@ int32_t hashJoinOptSplitPrimCond(SNode **pCondition, SNode **pPrimaryKeyCond) { } bool needOutput = false; - if (filterIsMultiTableColsCond(*pCondition)) { + bool result = false; + int32_t code = filterIsMultiTableColsCond(*pCondition, &result); + if (TSDB_CODE_SUCCESS != code) { + return code; + } + if (result) { return TSDB_CODE_SUCCESS; } diff --git a/source/libs/scalar/inc/filterInt.h b/source/libs/scalar/inc/filterInt.h index 4296abb588..a645c43f86 100644 --- a/source/libs/scalar/inc/filterInt.h +++ b/source/libs/scalar/inc/filterInt.h @@ -98,7 +98,7 @@ typedef struct SFilterRange { typedef bool (*rangeCompFunc)(const void *, const void *, const void *, const void *, __compar_fn_t); typedef int32_t (*filter_desc_compare_func)(const void *, const void *); -typedef bool (*filter_exec_func)(void *, int32_t, SColumnInfoData *, SColumnDataAgg *, int16_t, int32_t *); +typedef int32_t (*filter_exec_func)(void *, int32_t, SColumnInfoData *, SColumnDataAgg *, int16_t, int32_t *, bool *); typedef int32_t (*filer_get_col_from_name)(void *, int32_t, char *, void **); typedef struct SFilterDataInfo { @@ -363,7 +363,8 @@ struct SFilterInfo { } while (0) #define INSERT_RANGE(ctx, r, ra) \ do { \ - SFilterRangeNode *n = filterNewRange(ctx, ra); \ + SFilterRangeNode *n = NULL; \ + FLT_ERR_RET(filterNewRange(ctx, ra, &n)); \ n->prev = (r)->prev; \ if ((r)->prev) { \ (r)->prev->next = n; \ @@ -375,7 +376,8 @@ struct SFilterInfo { } while (0) #define APPEND_RANGE(ctx, r, ra) \ do { \ - SFilterRangeNode *n = filterNewRange(ctx, ra); \ + SFilterRangeNode *n = NULL; \ + FLT_ERR_RET(filterNewRange(ctx, ra, &n)); \ n->prev = (r); \ if (r) { \ (r)->next = n; \ @@ -458,11 +460,13 @@ struct SFilterInfo { #define FILTER_UNIT_GET_R(i, idx) ((i)->unitRes[idx]) #define FILTER_UNIT_SET_R(i, idx, v) (i)->unitRes[idx] = (v) -#define FILTER_PUSH_UNIT(colInfo, u) \ - do { \ - (colInfo).type = RANGE_TYPE_UNIT; \ - (colInfo).dataType = FILTER_UNIT_DATA_TYPE(u); \ - taosArrayPush((SArray *)((colInfo).info), &u); \ +#define FILTER_PUSH_UNIT(colInfo, u) \ + do { \ + (colInfo).type = RANGE_TYPE_UNIT; \ + (colInfo).dataType = FILTER_UNIT_DATA_TYPE(u); \ + if (taosArrayPush((SArray *)((colInfo).info), &u) == NULL) { \ + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); \ + } \ } while (0) #define FILTER_PUSH_VAR_HASH(colInfo, ha) \ do { \ @@ -494,7 +498,7 @@ struct SFilterInfo { #define FILTER_EMPTY_RES(i) FILTER_GET_FLAG((i)->status, FI_STATUS_EMPTY) extern bool filterDoCompare(__compar_fn_t func, uint8_t optr, void *left, void *right); -extern __compar_fn_t filterGetCompFunc(int32_t type, int32_t optr); +extern int32_t filterGetCompFunc(__compar_fn_t *func, int32_t type, int32_t optr); extern __compar_fn_t filterGetCompFuncEx(int32_t lType, int32_t rType, int32_t optr); #ifdef __cplusplus diff --git a/source/libs/scalar/inc/sclInt.h b/source/libs/scalar/inc/sclInt.h index 8278da0ed0..836cf7d69a 100644 --- a/source/libs/scalar/inc/sclInt.h +++ b/source/libs/scalar/inc/sclInt.h @@ -95,11 +95,11 @@ int32_t sclConvertToTsValueNode(int8_t precision, SValueNode* valueNode); #define GET_PARAM_PRECISON(_c) ((_c)->columnData->info.precision) void sclFreeParam(SScalarParam* param); -void doVectorCompare(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut, int32_t startIndex, int32_t numOfRows, +int32_t doVectorCompare(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut, int32_t startIndex, int32_t numOfRows, int32_t _ord, int32_t optr); -void vectorCompareImpl(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut, int32_t startIndex, int32_t numOfRows, - int32_t _ord, int32_t optr); -void vectorCompare(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut, int32_t _ord, int32_t optr); +int32_t vectorCompareImpl(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut, int32_t startIndex, int32_t numOfRows, + int32_t _ord, int32_t optr); +int32_t vectorCompare(SScalarParam* pLeft, SScalarParam* pRight, SScalarParam *pOut, int32_t _ord, int32_t optr); #ifdef __cplusplus } diff --git a/source/libs/scalar/inc/sclvector.h b/source/libs/scalar/inc/sclvector.h index e633b39223..c2eb13dc75 100644 --- a/source/libs/scalar/inc/sclvector.h +++ b/source/libs/scalar/inc/sclvector.h @@ -29,43 +29,54 @@ typedef struct SSclVectorConvCtx { int16_t outType; } SSclVectorConvCtx; -typedef double (*_getDoubleValue_fn_t)(void *src, int32_t index); +typedef int32_t (*_getDoubleValue_fn_t)(void *src, int32_t index, double *out); -static FORCE_INLINE double getVectorDoubleValue_TINYINT(void *src, int32_t index) { - return (double)*((int8_t *)src + index); +static FORCE_INLINE int32_t getVectorDoubleValue_TINYINT(void *src, int32_t index, double *out) { + *out = (double)*((int8_t *)src + index); + return TSDB_CODE_SUCCESS; } -static FORCE_INLINE double getVectorDoubleValue_UTINYINT(void *src, int32_t index) { - return (double)*((uint8_t *)src + index); +static FORCE_INLINE int32_t getVectorDoubleValue_UTINYINT(void *src, int32_t index, double *out) { + *out = (double)*((uint8_t *)src + index); + return TSDB_CODE_SUCCESS; } -static FORCE_INLINE double getVectorDoubleValue_SMALLINT(void *src, int32_t index) { - return (double)*((int16_t *)src + index); +static FORCE_INLINE int32_t getVectorDoubleValue_SMALLINT(void *src, int32_t index, double *out) { + *out = (double)*((int16_t *)src + index); + return TSDB_CODE_SUCCESS; } -static FORCE_INLINE double getVectorDoubleValue_USMALLINT(void *src, int32_t index) { - return (double)*((uint16_t *)src + index); +static FORCE_INLINE int32_t getVectorDoubleValue_USMALLINT(void *src, int32_t index, double *out) { + *out = (double)*((uint16_t *)src + index); + return TSDB_CODE_SUCCESS; } -static FORCE_INLINE double getVectorDoubleValue_INT(void *src, int32_t index) { - return (double)*((int32_t *)src + index); +static FORCE_INLINE int32_t getVectorDoubleValue_INT(void *src, int32_t index, double *out) { + *out = (double)*((int32_t *)src + index); + return TSDB_CODE_SUCCESS; } -static FORCE_INLINE double getVectorDoubleValue_UINT(void *src, int32_t index) { - return (double)*((uint32_t *)src + index); +static FORCE_INLINE int32_t getVectorDoubleValue_UINT(void *src, int32_t index, double *out) { + *out = (double)*((uint32_t *)src + index); + return TSDB_CODE_SUCCESS; } -static FORCE_INLINE double getVectorDoubleValue_BIGINT(void *src, int32_t index) { - return (double)*((int64_t *)src + index); +static FORCE_INLINE int32_t getVectorDoubleValue_BIGINT(void *src, int32_t index, double *out) { + *out = (double)*((int64_t *)src + index); + return TSDB_CODE_SUCCESS; } -static FORCE_INLINE double getVectorDoubleValue_UBIGINT(void *src, int32_t index) { - return (double)*((uint64_t *)src + index); +static FORCE_INLINE int32_t getVectorDoubleValue_UBIGINT(void *src, int32_t index, double *out) { + *out = (double)*((uint64_t *)src + index); + return TSDB_CODE_SUCCESS; } -static FORCE_INLINE double getVectorDoubleValue_FLOAT(void *src, int32_t index) { - return (double)*((float *)src + index); +static FORCE_INLINE int32_t getVectorDoubleValue_FLOAT(void *src, int32_t index, double *out) { + *out = (double)*((float *)src + index); + return TSDB_CODE_SUCCESS; } -static FORCE_INLINE double getVectorDoubleValue_DOUBLE(void *src, int32_t index) { - return (double)*((double *)src + index); +static FORCE_INLINE int32_t getVectorDoubleValue_DOUBLE(void *src, int32_t index, double *out) { + *out = (double)*((double *)src + index); + return TSDB_CODE_SUCCESS; } -static FORCE_INLINE double getVectorDoubleValue_BOOL(void *src, int32_t index) { - return (double)*((bool *)src + index); +static FORCE_INLINE int32_t getVectorDoubleValue_BOOL(void *src, int32_t index, double *out) { + *out = (double)*((bool *)src + index); + return TSDB_CODE_SUCCESS; } -double getVectorDoubleValue_JSON(void *src, int32_t index); +int32_t getVectorDoubleValue_JSON(void *src, int32_t index, double *out); static FORCE_INLINE _getDoubleValue_fn_t getVectorDoubleValueFn(int32_t srcType) { _getDoubleValue_fn_t p = NULL; @@ -103,8 +114,8 @@ static FORCE_INLINE _getDoubleValue_fn_t getVectorDoubleValueFn(int32_t srcType) return p; } -typedef void (*_bufConverteFunc)(char *buf, SScalarParam *pOut, int32_t outType, int32_t *overflow); -typedef void (*_bin_scalar_fn_t)(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *output, int32_t order); +typedef int32_t (*_bufConverteFunc)(char *buf, SScalarParam *pOut, int32_t outType, int32_t *overflow); +typedef int32_t (*_bin_scalar_fn_t)(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *output, int32_t order); _bin_scalar_fn_t getBinScalarOperatorFn(int32_t binOperator); #ifdef __cplusplus diff --git a/source/libs/scalar/src/filter.c b/source/libs/scalar/src/filter.c index 72e38c7a0d..105243608e 100644 --- a/source/libs/scalar/src/filter.c +++ b/source/libs/scalar/src/filter.c @@ -177,34 +177,40 @@ __compar_fn_t gUint64SignCompare[] = {compareUint64Int8, compareUint64Int16, co compareUint64Int64, compareUint64Float, compareUint64Double}; __compar_fn_t gUint64UsignCompare[] = {compareUint64Uint8, compareUint64Uint16, compareUint64Uint32, compareUint64Val}; -int8_t filterGetCompFuncIdx(int32_t type, int32_t optr, bool scalarMode) { - int8_t comparFn = 0; - +int32_t filterGetCompFuncIdx(int32_t type, int32_t optr, int8_t *comparFn, bool scalarMode) { + int32_t code = TSDB_CODE_SUCCESS; if (optr == OP_TYPE_IN && (type != TSDB_DATA_TYPE_BINARY && type != TSDB_DATA_TYPE_VARBINARY && type != TSDB_DATA_TYPE_NCHAR && type != TSDB_DATA_TYPE_GEOMETRY)) { switch (type) { case TSDB_DATA_TYPE_BOOL: case TSDB_DATA_TYPE_TINYINT: case TSDB_DATA_TYPE_UTINYINT: - return 15; + *comparFn = 15; + break; case TSDB_DATA_TYPE_SMALLINT: case TSDB_DATA_TYPE_USMALLINT: - return 16; + *comparFn = 16; + break; case TSDB_DATA_TYPE_INT: case TSDB_DATA_TYPE_UINT: case TSDB_DATA_TYPE_FLOAT: - return 17; + *comparFn = 17; + break; case TSDB_DATA_TYPE_BIGINT: case TSDB_DATA_TYPE_UBIGINT: case TSDB_DATA_TYPE_DOUBLE: case TSDB_DATA_TYPE_TIMESTAMP: - return 18; + *comparFn = 18; + break; case TSDB_DATA_TYPE_JSON: - terrno = TSDB_CODE_QRY_JSON_IN_ERROR; - return 0; + *comparFn = 0; + code = TSDB_CODE_QRY_JSON_IN_ERROR; + break; default: - return 0; + *comparFn = 0; + break; } + return code; } if (optr == OP_TYPE_NOT_IN && (type != TSDB_DATA_TYPE_BINARY && type != TSDB_DATA_TYPE_VARBINARY && type != TSDB_DATA_TYPE_NCHAR && type != TSDB_DATA_TYPE_GEOMETRY)) { @@ -212,25 +218,32 @@ int8_t filterGetCompFuncIdx(int32_t type, int32_t optr, bool scalarMode) { case TSDB_DATA_TYPE_BOOL: case TSDB_DATA_TYPE_TINYINT: case TSDB_DATA_TYPE_UTINYINT: - return 21; + *comparFn = 21; + break; case TSDB_DATA_TYPE_SMALLINT: case TSDB_DATA_TYPE_USMALLINT: - return 22; + *comparFn = 22; + break; case TSDB_DATA_TYPE_INT: case TSDB_DATA_TYPE_UINT: case TSDB_DATA_TYPE_FLOAT: - return 23; + *comparFn = 23; + break; case TSDB_DATA_TYPE_BIGINT: case TSDB_DATA_TYPE_UBIGINT: case TSDB_DATA_TYPE_DOUBLE: case TSDB_DATA_TYPE_TIMESTAMP: - return 24; + *comparFn = 24; + break; case TSDB_DATA_TYPE_JSON: - terrno = TSDB_CODE_QRY_JSON_IN_ERROR; - return 0; + *comparFn = 0; + code = TSDB_CODE_QRY_JSON_IN_ERROR; + break; default: - return 0; + *comparFn = 0; + break; } + return code; } // if (optr == OP_TYPE_JSON_CONTAINS && type == TSDB_DATA_TYPE_JSON) { @@ -240,49 +253,49 @@ int8_t filterGetCompFuncIdx(int32_t type, int32_t optr, bool scalarMode) { switch (type) { case TSDB_DATA_TYPE_BOOL: case TSDB_DATA_TYPE_TINYINT: - comparFn = 1; + *comparFn = 1; break; case TSDB_DATA_TYPE_SMALLINT: - comparFn = 2; + *comparFn = 2; break; case TSDB_DATA_TYPE_INT: - comparFn = 0; + *comparFn = 0; break; case TSDB_DATA_TYPE_BIGINT: case TSDB_DATA_TYPE_TIMESTAMP: - comparFn = 3; + *comparFn = 3; break; case TSDB_DATA_TYPE_FLOAT: - comparFn = 4; + *comparFn = 4; break; case TSDB_DATA_TYPE_DOUBLE: - comparFn = 5; + *comparFn = 5; break; case TSDB_DATA_TYPE_VARBINARY:{ if (optr == OP_TYPE_IN) { - comparFn = 8; + *comparFn = 8; } else if (optr == OP_TYPE_NOT_IN) { - comparFn = 25; + *comparFn = 25; } else { /* normal relational comparFn */ - comparFn = 30; + *comparFn = 30; } break; } case TSDB_DATA_TYPE_BINARY: { if (optr == OP_TYPE_MATCH) { - comparFn = 19; + *comparFn = 19; } else if (optr == OP_TYPE_NMATCH) { - comparFn = 20; + *comparFn = 20; } else if (optr == OP_TYPE_LIKE) { /* wildcard query using like operator */ - comparFn = 7; + *comparFn = 7; } else if (optr == OP_TYPE_NOT_LIKE) { /* wildcard query using like operator */ - comparFn = 26; + *comparFn = 26; } else if (optr == OP_TYPE_IN) { - comparFn = 8; + *comparFn = 8; } else if (optr == OP_TYPE_NOT_IN) { - comparFn = 25; + *comparFn = 25; } else { /* normal relational comparFn */ - comparFn = 6; + *comparFn = 6; } break; @@ -290,19 +303,19 @@ int8_t filterGetCompFuncIdx(int32_t type, int32_t optr, bool scalarMode) { case TSDB_DATA_TYPE_NCHAR: { if (optr == OP_TYPE_MATCH) { - comparFn = scalarMode ? 28 : 19; + *comparFn = scalarMode ? 28 : 19; } else if (optr == OP_TYPE_NMATCH) { - comparFn = scalarMode ? 29 : 20; + *comparFn = scalarMode ? 29 : 20; } else if (optr == OP_TYPE_LIKE) { - comparFn = 9; + *comparFn = 9; } else if (optr == OP_TYPE_NOT_LIKE) { - comparFn = 27; + *comparFn = 27; } else if (optr == OP_TYPE_IN) { - comparFn = 8; + *comparFn = 8; } else if (optr == OP_TYPE_NOT_IN) { - comparFn = 25; + *comparFn = 25; } else { - comparFn = 10; + *comparFn = 10; } break; } @@ -310,40 +323,45 @@ int8_t filterGetCompFuncIdx(int32_t type, int32_t optr, bool scalarMode) { case TSDB_DATA_TYPE_GEOMETRY: { if (optr == OP_TYPE_EQUAL || optr == OP_TYPE_NOT_EQUAL || optr == OP_TYPE_IS_NULL || optr == OP_TYPE_IS_NOT_NULL) { - comparFn = 30; + *comparFn = 30; } else if (optr == OP_TYPE_IN) { - comparFn = 8; + *comparFn = 8; } else if (optr == OP_TYPE_NOT_IN) { - comparFn = 25; + *comparFn = 25; } else { - terrno = TSDB_CODE_QRY_GEO_NOT_SUPPORT_ERROR; - return 0; + *comparFn = 0; + code = TSDB_CODE_QRY_GEO_NOT_SUPPORT_ERROR; } break; } case TSDB_DATA_TYPE_UTINYINT: - comparFn = 11; + *comparFn = 11; break; case TSDB_DATA_TYPE_USMALLINT: - comparFn = 12; + *comparFn = 12; break; case TSDB_DATA_TYPE_UINT: - comparFn = 13; + *comparFn = 13; break; case TSDB_DATA_TYPE_UBIGINT: - comparFn = 14; + *comparFn = 14; break; default: - comparFn = 0; + *comparFn = 0; break; } - return comparFn; + return code; } -__compar_fn_t filterGetCompFunc(int32_t type, int32_t optr) { return gDataCompare[filterGetCompFuncIdx(type, optr, true)]; } +int32_t filterGetCompFunc(__compar_fn_t *func, int32_t type, int32_t optr) { + int8_t compFuncIdx = 0; + int32_t code = filterGetCompFuncIdx(type, optr, &compFuncIdx, true); + *func = gDataCompare[compFuncIdx]; + return code; +} __compar_fn_t filterGetCompFuncEx(int32_t lType, int32_t rType, int32_t optr) { if (TSDB_DATA_TYPE_NULL == rType || TSDB_DATA_TYPE_JSON == rType) { @@ -447,49 +465,62 @@ static FORCE_INLINE int32_t filterCompareGroupCtx(const void *pLeft, const void int32_t filterInitUnitsFields(SFilterInfo *info) { info->unitSize = FILTER_DEFAULT_UNIT_SIZE; info->units = taosMemoryCalloc(info->unitSize, sizeof(SFilterUnit)); + if (info->units == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } info->fields[FLD_TYPE_COLUMN].num = 0; info->fields[FLD_TYPE_COLUMN].size = FILTER_DEFAULT_FIELD_SIZE; info->fields[FLD_TYPE_COLUMN].fields = taosMemoryCalloc(info->fields[FLD_TYPE_COLUMN].size, sizeof(SFilterField)); + if (info->fields[FLD_TYPE_COLUMN].fields == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } info->fields[FLD_TYPE_VALUE].num = 0; info->fields[FLD_TYPE_VALUE].size = FILTER_DEFAULT_FIELD_SIZE; info->fields[FLD_TYPE_VALUE].fields = taosMemoryCalloc(info->fields[FLD_TYPE_VALUE].size, sizeof(SFilterField)); + if (info->fields[FLD_TYPE_VALUE].fields == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } return TSDB_CODE_SUCCESS; } -static FORCE_INLINE SFilterRangeNode *filterNewRange(SFilterRangeCtx *ctx, SFilterRange *ra) { - SFilterRangeNode *r = NULL; +static FORCE_INLINE int32_t filterNewRange(SFilterRangeCtx *ctx, SFilterRange *ra, SFilterRangeNode **r) { if (ctx->rf) { - r = ctx->rf; + *r = ctx->rf; ctx->rf = ctx->rf->next; - r->prev = NULL; - r->next = NULL; + (*r)->prev = NULL; + (*r)->next = NULL; } else { - r = taosMemoryCalloc(1, sizeof(SFilterRangeNode)); + *r = taosMemoryCalloc(1, sizeof(SFilterRangeNode)); + if (*r == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } } - FILTER_COPY_RA(&r->ra, ra); + FILTER_COPY_RA(&(*r)->ra, ra); - return r; + return TSDB_CODE_SUCCESS; } -void *filterInitRangeCtx(int32_t type, int32_t options) { +int32_t filterInitRangeCtx(int32_t type, int32_t options, SFilterRangeCtx **ctx) { if (type > TSDB_DATA_TYPE_UBIGINT || type < TSDB_DATA_TYPE_BOOL || type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_VARBINARY || type == TSDB_DATA_TYPE_NCHAR || type == TSDB_DATA_TYPE_GEOMETRY) { qError("not supported range type:%d", type); - return NULL; + return TSDB_CODE_QRY_FILTER_NOT_SUPPORT_TYPE; } - SFilterRangeCtx *ctx = taosMemoryCalloc(1, sizeof(SFilterRangeCtx)); + *ctx = taosMemoryCalloc(1, sizeof(SFilterRangeCtx)); + if (*ctx == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + (*ctx)->type = type; + (*ctx)->options = options; + (*ctx)->pCompareFunc = getComparFunc(type, 0); - ctx->type = type; - ctx->options = options; - ctx->pCompareFunc = getComparFunc(type, 0); - - return ctx; + return TSDB_CODE_SUCCESS; } int32_t filterResetRangeCtx(SFilterRangeCtx *ctx) { @@ -517,7 +548,7 @@ int32_t filterResetRangeCtx(SFilterRangeCtx *ctx) { } int32_t filterReuseRangeCtx(SFilterRangeCtx *ctx, int32_t type, int32_t options) { - filterResetRangeCtx(ctx); + FLT_ERR_RET(filterResetRangeCtx(ctx)); ctx->type = type; ctx->options = options; @@ -697,11 +728,11 @@ int32_t filterAddRangeImpl(void *h, SFilterRange *ra, int32_t optr) { if (ctx->rs && ctx->rs->next == NULL) { bool notnull; - filterConvertRange(ctx, &ctx->rs->ra, ¬null); + FLT_ERR_RET(filterConvertRange(ctx, &ctx->rs->ra, ¬null)); if (notnull) { bool all = false; FREE_FROM_RANGE(ctx, ctx->rs); - filterAddRangeOptr(h, OP_TYPE_IS_NOT_NULL, optr, NULL, &all); + FLT_ERR_RET(filterAddRangeOptr(h, OP_TYPE_IS_NOT_NULL, optr, NULL, &all)); if (all) { FILTER_SET_FLAG(ctx->status, MR_ST_ALL); } @@ -741,7 +772,7 @@ int32_t filterAddRangeCtx(void *dst, void *src, int32_t optr) { SFilterRangeNode *r = sctx->rs; while (r) { - filterAddRange(dctx, &r->ra, optr); + FLT_ERR_RET(filterAddRange(dctx, &r->ra, optr)); r = r->next; } @@ -810,7 +841,7 @@ int32_t filterFinishRange(void *h) { } int32_t filterGetRangeNum(void *h, int32_t *num) { - filterFinishRange(h); + FLT_ERR_RET(filterFinishRange(h)); SFilterRangeCtx *ctx = (SFilterRangeCtx *)h; @@ -827,7 +858,7 @@ int32_t filterGetRangeNum(void *h, int32_t *num) { } int32_t filterGetRangeRes(void *h, SFilterRange *ra) { - filterFinishRange(h); + FLT_ERR_RET(filterFinishRange(h)); SFilterRangeCtx *ctx = (SFilterRangeCtx *)h; uint32_t num = 0; @@ -857,24 +888,24 @@ int32_t filterSourceRangeFromCtx(SFilterRangeCtx *ctx, void *sctx, int32_t optr, SFilterRangeCtx *src = (SFilterRangeCtx *)sctx; if (src->isnull) { - filterAddRangeOptr(ctx, OP_TYPE_IS_NULL, optr, empty, all); + FLT_ERR_RET(filterAddRangeOptr(ctx, OP_TYPE_IS_NULL, optr, empty, all)); if (FILTER_GET_FLAG(ctx->status, MR_ST_ALL)) { *all = true; } } if (src->notnull) { - filterAddRangeOptr(ctx, OP_TYPE_IS_NOT_NULL, optr, empty, all); + FLT_ERR_RET(filterAddRangeOptr(ctx, OP_TYPE_IS_NOT_NULL, optr, empty, all)); if (FILTER_GET_FLAG(ctx->status, MR_ST_ALL)) { *all = true; } } if (src->isrange) { - filterAddRangeOptr(ctx, 0, optr, empty, all); + FLT_ERR_RET(filterAddRangeOptr(ctx, 0, optr, empty, all)); if (!(optr == LOGIC_COND_TYPE_OR && ctx->notnull)) { - filterAddRangeCtx(ctx, src, optr); + FLT_ERR_RET(filterAddRangeCtx(ctx, src, optr)); } if (FILTER_GET_FLAG(ctx->status, MR_ST_ALL)) { @@ -917,12 +948,18 @@ int32_t filterDetachCnfGroup(SFilterGroup *gp1, SFilterGroup *gp2, SArray *group gp.unitNum = gp1->unitNum + gp2->unitNum; gp.unitIdxs = taosMemoryCalloc(gp.unitNum, sizeof(*gp.unitIdxs)); - memcpy(gp.unitIdxs, gp1->unitIdxs, gp1->unitNum * sizeof(*gp.unitIdxs)); - memcpy(gp.unitIdxs + gp1->unitNum, gp2->unitIdxs, gp2->unitNum * sizeof(*gp.unitIdxs)); + if (NULL == gp.unitIdxs) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + (void)memcpy(gp.unitIdxs, gp1->unitIdxs, gp1->unitNum * sizeof(*gp.unitIdxs)); + (void)memcpy(gp.unitIdxs + gp1->unitNum, gp2->unitIdxs, gp2->unitNum * sizeof(*gp.unitIdxs)); gp.unitFlags = NULL; - taosArrayPush(group, &gp); + if (NULL == taosArrayPush(group, &gp)) { + taosMemoryFreeClear(gp.unitIdxs); + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } return TSDB_CODE_SUCCESS; } @@ -939,7 +976,9 @@ int32_t filterDetachCnfGroups(SArray *group, SArray *left, SArray *right) { SFilterGroup *gp = NULL; while ((gp = (SFilterGroup *)taosArrayPop(right)) != NULL) { - taosArrayPush(group, gp); + if (NULL == taosArrayPush(group, gp)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } } return TSDB_CODE_SUCCESS; @@ -948,7 +987,9 @@ int32_t filterDetachCnfGroups(SArray *group, SArray *left, SArray *right) { if (taosArrayGetSize(right) <= 0) { SFilterGroup *gp = NULL; while ((gp = (SFilterGroup *)taosArrayPop(left)) != NULL) { - taosArrayPush(group, gp); + if (NULL == taosArrayPush(group, gp)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } } return TSDB_CODE_SUCCESS; @@ -960,7 +1001,7 @@ int32_t filterDetachCnfGroups(SArray *group, SArray *left, SArray *right) { for (int32_t r = 0; r < rightSize; ++r) { SFilterGroup *gp2 = taosArrayGet(right, r); - filterDetachCnfGroup(gp1, gp2, group); + FLT_ERR_RET(filterDetachCnfGroup(gp1, gp2, group)); } } @@ -1018,6 +1059,9 @@ int32_t filterAddField(SFilterInfo *info, void *desc, void **data, int32_t type, info->fields[type].size += FILTER_DEFAULT_FIELD_SIZE; info->fields[type].fields = taosMemoryRealloc(info->fields[type].fields, info->fields[type].size * sizeof(SFilterField)); + if (info->fields[type].fields == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } } info->fields[type].fields[idx].flag = type; @@ -1034,10 +1078,17 @@ int32_t filterAddField(SFilterInfo *info, void *desc, void **data, int32_t type, if (info->pctx.valHash == NULL) { info->pctx.valHash = taosHashInit(FILTER_DEFAULT_GROUP_SIZE * FILTER_DEFAULT_VALUE_SIZE, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), false, false); + if (NULL == info->pctx.valHash) { + fltError("taosHashInit failed, size:%d", FILTER_DEFAULT_GROUP_SIZE * FILTER_DEFAULT_VALUE_SIZE); + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } } SFilterDataInfo dInfo = {idx, *data}; - taosHashPut(info->pctx.valHash, *data, dataLen, &dInfo, sizeof(dInfo)); + if (taosHashPut(info->pctx.valHash, *data, dataLen, &dInfo, sizeof(dInfo))) { + fltError("taosHashPut to set failed"); + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } if (srcFlag) { FILTER_SET_FLAG(*srcFlag, FLD_DATA_NO_FREE); } @@ -1057,7 +1108,7 @@ int32_t filterAddField(SFilterInfo *info, void *desc, void **data, int32_t type, } static FORCE_INLINE int32_t filterAddColFieldFromField(SFilterInfo *info, SFilterField *field, SFilterFieldId *fid) { - filterAddField(info, field->desc, &field->data, FILTER_GET_TYPE(field->flag), fid, 0, false, NULL); + FLT_ERR_RET(filterAddField(info, field->desc, &field->data, FILTER_GET_TYPE(field->flag), fid, 0, false, NULL)); FILTER_SET_FLAG(field->flag, FLD_DATA_NO_FREE); @@ -1086,7 +1137,7 @@ int32_t filterAddFieldFromNode(SFilterInfo *info, SNode *node, SFilterFieldId *f v = node; } - filterAddField(info, v, NULL, type, fid, 0, true, NULL); + FLT_ERR_RET(filterAddField(info, v, NULL, type, fid, 0, true, NULL)); _return: return TSDB_CODE_SUCCESS; @@ -1098,6 +1149,10 @@ int32_t filterAddUnitImpl(SFilterInfo *info, uint8_t optr, SFilterFieldId *left, if (info->pctx.unitHash == NULL) { info->pctx.unitHash = taosHashInit(FILTER_DEFAULT_GROUP_SIZE * FILTER_DEFAULT_UNIT_SIZE, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, false); + if (NULL == info->pctx.unitHash) { + fltError("taosHashInit failed, size:%d", FILTER_DEFAULT_GROUP_SIZE * FILTER_DEFAULT_UNIT_SIZE); + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } } else { char v[14] = {0}; FLT_PACKAGE_UNIT_HASH_KEY(&v, optr, optr2, left->idx, (right ? right->idx : -1), (right2 ? right2->idx : -1)); @@ -1118,7 +1173,7 @@ int32_t filterAddUnitImpl(SFilterInfo *info, uint8_t optr, SFilterFieldId *left, return TSDB_CODE_OUT_OF_MEMORY; } info->units = (SFilterUnit *)tmp; - memset(info->units + psize, 0, sizeof(*info->units) * FILTER_DEFAULT_UNIT_SIZE); + (void)memset(info->units + psize, 0, sizeof(*info->units) * FILTER_DEFAULT_UNIT_SIZE); } SFilterUnit *u = &info->units[info->unitNum]; @@ -1155,7 +1210,11 @@ int32_t filterAddUnitImpl(SFilterInfo *info, uint8_t optr, SFilterFieldId *left, if (FILTER_GET_FLAG(info->options, FLT_OPTION_NEED_UNIQE)) { char v[14] = {0}; FLT_PACKAGE_UNIT_HASH_KEY(&v, optr, optr2, left->idx, (right ? right->idx : -1), (right2 ? right2->idx : -1)); - taosHashPut(info->pctx.unitHash, v, sizeof(v), uidx, sizeof(*uidx)); + if (taosHashPut(info->pctx.unitHash, v, sizeof(v), uidx, sizeof(*uidx))) { + fltError("taosHashPut to set failed"); + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + } ++info->unitNum; @@ -1187,7 +1246,7 @@ int32_t fltAddGroupUnitFromNode(SFilterInfo *info, SNode *tree, SArray *group) { SOperatorNode *node = (SOperatorNode *)tree; int32_t ret = TSDB_CODE_SUCCESS; SFilterFieldId left = {0}, right = {0}; - filterAddFieldFromNode(info, node->pLeft, &left); + FLT_ERR_RET(filterAddFieldFromNode(info, node->pLeft, &left)); uint8_t type = FILTER_GET_COL_FIELD_TYPE(FILTER_GET_FIELD(info, left)); int32_t len = 0; uint32_t uidx = 0; @@ -1198,6 +1257,9 @@ int32_t fltAddGroupUnitFromNode(SFilterInfo *info, SNode *tree, SArray *group) { SListCell *cell = listNode->pNodeList->pHead; SScalarParam out = {.columnData = taosMemoryCalloc(1, sizeof(SColumnInfoData))}; + if (out.columnData == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } out.columnData->info.type = type; out.columnData->info.bytes = tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes; // reserved space for simple_copy @@ -1206,9 +1268,9 @@ int32_t fltAddGroupUnitFromNode(SFilterInfo *info, SNode *tree, SArray *group) { if (valueNode->node.resType.type != type) { int32_t overflow = 0; code = sclConvertValueToSclParam(valueNode, &out, &overflow); - if (code) { + if (TSDB_CODE_SUCCESS != code) { // fltError("convert from %d to %d failed", in.type, out.type); - FLT_ERR_RET(code); + break; } if (overflow) { @@ -1218,35 +1280,52 @@ int32_t fltAddGroupUnitFromNode(SFilterInfo *info, SNode *tree, SArray *group) { len = tDataTypes[type].bytes; - filterAddField(info, NULL, (void **)&out.columnData->pData, FLD_TYPE_VALUE, &right, len, true, NULL); + code = filterAddField(info, NULL, (void **)&out.columnData->pData, FLD_TYPE_VALUE, &right, len, true, NULL); + if (TSDB_CODE_SUCCESS != code) { + break; + } out.columnData->pData = NULL; } else { void *data = taosMemoryCalloc(1, tDataTypes[TSDB_DATA_TYPE_BIGINT].bytes); // reserved space for simple_copy if (NULL == data) { - FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + code = TSDB_CODE_OUT_OF_MEMORY; + break; + } + (void)memcpy(data, nodesGetValueFromNode(valueNode), tDataTypes[type].bytes); + code = filterAddField(info, NULL, (void **)&data, FLD_TYPE_VALUE, &right, len, true, NULL); + if (TSDB_CODE_SUCCESS != code) { + break; } - memcpy(data, nodesGetValueFromNode(valueNode), tDataTypes[type].bytes); - filterAddField(info, NULL, (void **)&data, FLD_TYPE_VALUE, &right, len, true, NULL); } - filterAddUnit(info, OP_TYPE_EQUAL, &left, &right, &uidx); - + code = filterAddUnit(info, OP_TYPE_EQUAL, &left, &right, &uidx); + if (TSDB_CODE_SUCCESS != code) { + break; + } SFilterGroup fgroup = {0}; - filterAddUnitToGroup(&fgroup, uidx); - - taosArrayPush(group, &fgroup); + code = filterAddUnitToGroup(&fgroup, uidx); + if (TSDB_CODE_SUCCESS != code) { + break; + } + if (NULL == taosArrayPush(group, &fgroup)) { + code = TSDB_CODE_OUT_OF_MEMORY; + break; + } cell = cell->pNext; } colDataDestroy(out.columnData); taosMemoryFree(out.columnData); + FLT_ERR_RET(code); } else { - filterAddFieldFromNode(info, node->pRight, &right); + FLT_ERR_RET(filterAddFieldFromNode(info, node->pRight, &right)); FLT_ERR_RET(filterAddUnit(info, node->opType, &left, &right, &uidx)); SFilterGroup fgroup = {0}; - filterAddUnitToGroup(&fgroup, uidx); + FLT_ERR_RET(filterAddUnitToGroup(&fgroup, uidx)); - taosArrayPush(group, &fgroup); + if (NULL == taosArrayPush(group, &fgroup)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } } return TSDB_CODE_SUCCESS; @@ -1257,7 +1336,7 @@ int32_t filterAddUnitFromUnit(SFilterInfo *dst, SFilterInfo *src, SFilterUnit *u uint8_t type = FILTER_UNIT_DATA_TYPE(u); uint16_t flag = 0; - filterAddField(dst, FILTER_UNIT_COL_DESC(src, u), NULL, FLD_TYPE_COLUMN, &left, 0, false, NULL); + FLT_ERR_RET(filterAddField(dst, FILTER_UNIT_COL_DESC(src, u), NULL, FLD_TYPE_COLUMN, &left, 0, false, NULL)); SFilterField *t = FILTER_UNIT_LEFT_FIELD(src, u); if (u->right.type == FLD_TYPE_VALUE) { @@ -1266,16 +1345,16 @@ int32_t filterAddUnitFromUnit(SFilterInfo *dst, SFilterInfo *src, SFilterUnit *u if (IS_VAR_DATA_TYPE(type)) { if (FILTER_UNIT_OPTR(u) == OP_TYPE_IN) { - filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, POINTER_BYTES, false, - &rField->flag); // POINTER_BYTES should be sizeof(SHashObj), but POINTER_BYTES is also right. + FLT_ERR_RET(filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, POINTER_BYTES, false, &rField->flag)); + // POINTER_BYTES should be sizeof(SHashObj), but POINTER_BYTES is also right. t = FILTER_GET_FIELD(dst, right); FILTER_SET_FLAG(t->flag, FLD_DATA_IS_HASH); } else { - filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, varDataTLen(data), false, &rField->flag); + FLT_ERR_RET(filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, varDataTLen(data), false, &rField->flag)); } } else { - filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, tDataTypes[type].bytes, false, &rField->flag); + FLT_ERR_RET(filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, tDataTypes[type].bytes, false, &rField->flag)); } } else { pright = NULL; @@ -1299,22 +1378,22 @@ int32_t filterAddGroupUnitFromCtx(SFilterInfo *dst, SFilterInfo *src, SFilterRan SFilterField *col = FILTER_GET_COL_FIELD(src, cidx); - filterAddColFieldFromField(dst, col, &left); + FLT_ERR_RET(filterAddColFieldFromField(dst, col, &left)); int32_t type = FILTER_GET_COL_FIELD_TYPE(FILTER_GET_FIELD(dst, left)); if (optr == LOGIC_COND_TYPE_AND) { if (ctx->isnull) { ASSERT(ctx->notnull == false && ctx->isrange == false); - filterAddUnit(dst, OP_TYPE_IS_NULL, &left, NULL, &uidx); - filterAddUnitToGroup(g, uidx); + FLT_ERR_RET(filterAddUnit(dst, OP_TYPE_IS_NULL, &left, NULL, &uidx)); + FLT_ERR_RET(filterAddUnitToGroup(g, uidx)); return TSDB_CODE_SUCCESS; } if (ctx->notnull) { ASSERT(ctx->isnull == false && ctx->isrange == false); - filterAddUnit(dst, OP_TYPE_IS_NOT_NULL, &left, NULL, &uidx); - filterAddUnitToGroup(g, uidx); + FLT_ERR_RET(filterAddUnit(dst, OP_TYPE_IS_NOT_NULL, &left, NULL, &uidx)); + FLT_ERR_RET(filterAddUnitToGroup(g, uidx)); return TSDB_CODE_SUCCESS; } @@ -1333,44 +1412,59 @@ int32_t filterAddGroupUnitFromCtx(SFilterInfo *dst, SFilterInfo *src, SFilterRan __compar_fn_t func = getComparFunc(type, 0); if (func(&ra->s, &ra->e) == 0) { void *data = taosMemoryMalloc(sizeof(int64_t)); + if (data == NULL) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SIMPLE_COPY_VALUES(data, &ra->s); - filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, tDataTypes[type].bytes, true, NULL); - filterAddUnit(dst, OP_TYPE_EQUAL, &left, &right, &uidx); - filterAddUnitToGroup(g, uidx); + FLT_ERR_RET(filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, tDataTypes[type].bytes, true, NULL)); + FLT_ERR_RET(filterAddUnit(dst, OP_TYPE_EQUAL, &left, &right, &uidx)); + FLT_ERR_RET(filterAddUnitToGroup(g, uidx)); return TSDB_CODE_SUCCESS; } else { void *data = taosMemoryMalloc(sizeof(int64_t)); + if (data == NULL) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SIMPLE_COPY_VALUES(data, &ra->s); - filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, tDataTypes[type].bytes, true, NULL); + FLT_ERR_RET(filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, tDataTypes[type].bytes, true, NULL)); void *data2 = taosMemoryMalloc(sizeof(int64_t)); + if (data2 == NULL) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SIMPLE_COPY_VALUES(data2, &ra->e); - filterAddField(dst, NULL, &data2, FLD_TYPE_VALUE, &right2, tDataTypes[type].bytes, true, NULL); + FLT_ERR_RET(filterAddField(dst, NULL, &data2, FLD_TYPE_VALUE, &right2, tDataTypes[type].bytes, true, NULL)); - filterAddUnitImpl( + FLT_ERR_RET(filterAddUnitImpl( dst, FILTER_GET_FLAG(ra->sflag, RANGE_FLG_EXCLUDE) ? OP_TYPE_GREATER_THAN : OP_TYPE_GREATER_EQUAL, &left, &right, FILTER_GET_FLAG(ra->eflag, RANGE_FLG_EXCLUDE) ? OP_TYPE_LOWER_THAN : OP_TYPE_LOWER_EQUAL, &right2, - &uidx); - filterAddUnitToGroup(g, uidx); + &uidx)); + FLT_ERR_RET(filterAddUnitToGroup(g, uidx)); return TSDB_CODE_SUCCESS; } } if (!FILTER_GET_FLAG(ra->sflag, RANGE_FLG_NULL)) { void *data = taosMemoryMalloc(sizeof(int64_t)); + if (data == NULL) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SIMPLE_COPY_VALUES(data, &ra->s); - filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, tDataTypes[type].bytes, true, NULL); - filterAddUnit(dst, FILTER_GET_FLAG(ra->sflag, RANGE_FLG_EXCLUDE) ? OP_TYPE_GREATER_THAN : OP_TYPE_GREATER_EQUAL, - &left, &right, &uidx); - filterAddUnitToGroup(g, uidx); + FLT_ERR_RET(filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, tDataTypes[type].bytes, true, NULL)); + FLT_ERR_RET(filterAddUnit(dst, FILTER_GET_FLAG(ra->sflag, RANGE_FLG_EXCLUDE) ? OP_TYPE_GREATER_THAN : OP_TYPE_GREATER_EQUAL, + &left, &right, &uidx)); + FLT_ERR_RET(filterAddUnitToGroup(g, uidx)); } if (!FILTER_GET_FLAG(ra->eflag, RANGE_FLG_NULL)) { void *data = taosMemoryMalloc(sizeof(int64_t)); + if (data == NULL) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SIMPLE_COPY_VALUES(data, &ra->e); - filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, tDataTypes[type].bytes, true, NULL); - filterAddUnit(dst, FILTER_GET_FLAG(ra->eflag, RANGE_FLG_EXCLUDE) ? OP_TYPE_LOWER_THAN : OP_TYPE_LOWER_EQUAL, - &left, &right, &uidx); - filterAddUnitToGroup(g, uidx); + FLT_ERR_RET(filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, tDataTypes[type].bytes, true, NULL)); + FLT_ERR_RET(filterAddUnit(dst, FILTER_GET_FLAG(ra->eflag, RANGE_FLG_EXCLUDE) ? OP_TYPE_LOWER_THAN : OP_TYPE_LOWER_EQUAL, + &left, &right, &uidx)); + FLT_ERR_RET(filterAddUnitToGroup(g, uidx)); } return TSDB_CODE_SUCCESS; @@ -1384,18 +1478,22 @@ int32_t filterAddGroupUnitFromCtx(SFilterInfo *dst, SFilterInfo *src, SFilterRan ASSERT(ctx->isnull || ctx->notnull || ctx->isrange); if (ctx->isnull) { - filterAddUnit(dst, OP_TYPE_IS_NULL, &left, NULL, &uidx); - filterAddUnitToGroup(g, uidx); - taosArrayPush(res, g); + FLT_ERR_RET(filterAddUnit(dst, OP_TYPE_IS_NULL, &left, NULL, &uidx)); + FLT_ERR_RET(filterAddUnitToGroup(g, uidx)); + if (NULL == taosArrayPush(res,g)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } } if (ctx->notnull) { ASSERT(!ctx->isrange); - memset(g, 0, sizeof(*g)); + (void)memset(g, 0, sizeof(*g)); - filterAddUnit(dst, OP_TYPE_IS_NOT_NULL, &left, NULL, &uidx); - filterAddUnitToGroup(g, uidx); - taosArrayPush(res, g); + FLT_ERR_RET(filterAddUnit(dst, OP_TYPE_IS_NOT_NULL, &left, NULL, &uidx)); + FLT_ERR_RET(filterAddUnitToGroup(g, uidx)); + if (NULL == taosArrayPush(res,g)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } } if (!ctx->isrange) { @@ -1407,32 +1505,43 @@ int32_t filterAddGroupUnitFromCtx(SFilterInfo *dst, SFilterInfo *src, SFilterRan SFilterRangeNode *r = ctx->rs; while (r) { - memset(g, 0, sizeof(*g)); + (void)memset(g, 0, sizeof(*g)); if ((!FILTER_GET_FLAG(r->ra.sflag, RANGE_FLG_NULL)) && (!FILTER_GET_FLAG(r->ra.eflag, RANGE_FLG_NULL))) { __compar_fn_t func = getComparFunc(type, 0); if (func(&r->ra.s, &r->ra.e) == 0) { void *data = taosMemoryMalloc(sizeof(int64_t)); + if (data == NULL) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SIMPLE_COPY_VALUES(data, &r->ra.s); - filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, tDataTypes[type].bytes, true, NULL); - filterAddUnit(dst, OP_TYPE_EQUAL, &left, &right, &uidx); - filterAddUnitToGroup(g, uidx); + FLT_ERR_RET(filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, tDataTypes[type].bytes, true, NULL)); + FLT_ERR_RET(filterAddUnit(dst, OP_TYPE_EQUAL, &left, &right, &uidx)); + FLT_ERR_RET(filterAddUnitToGroup(g, uidx)); } else { void *data = taosMemoryMalloc(sizeof(int64_t)); + if (data == NULL) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SIMPLE_COPY_VALUES(data, &r->ra.s); - filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, tDataTypes[type].bytes, true, NULL); + FLT_ERR_RET(filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, tDataTypes[type].bytes, true, NULL)); void *data2 = taosMemoryMalloc(sizeof(int64_t)); + if (data2 == NULL) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SIMPLE_COPY_VALUES(data2, &r->ra.e); - filterAddField(dst, NULL, &data2, FLD_TYPE_VALUE, &right2, tDataTypes[type].bytes, true, NULL); + FLT_ERR_RET(filterAddField(dst, NULL, &data2, FLD_TYPE_VALUE, &right2, tDataTypes[type].bytes, true, NULL)); - filterAddUnitImpl( - dst, FILTER_GET_FLAG(r->ra.sflag, RANGE_FLG_EXCLUDE) ? OP_TYPE_GREATER_THAN : OP_TYPE_GREATER_EQUAL, &left, - &right, FILTER_GET_FLAG(r->ra.eflag, RANGE_FLG_EXCLUDE) ? OP_TYPE_LOWER_THAN : OP_TYPE_LOWER_EQUAL, &right2, - &uidx); - filterAddUnitToGroup(g, uidx); + FLT_ERR_RET(filterAddUnitImpl( + dst, FILTER_GET_FLAG(r->ra.sflag, RANGE_FLG_EXCLUDE) ? OP_TYPE_GREATER_THAN : OP_TYPE_GREATER_EQUAL, &left, + &right, FILTER_GET_FLAG(r->ra.eflag, RANGE_FLG_EXCLUDE) ? OP_TYPE_LOWER_THAN : OP_TYPE_LOWER_EQUAL, &right2, + &uidx)); + FLT_ERR_RET(filterAddUnitToGroup(g, uidx)); } - taosArrayPush(res, g); + if (NULL == taosArrayPush(res,g)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } r = r->next; @@ -1441,25 +1550,33 @@ int32_t filterAddGroupUnitFromCtx(SFilterInfo *dst, SFilterInfo *src, SFilterRan if (!FILTER_GET_FLAG(r->ra.sflag, RANGE_FLG_NULL)) { void *data = taosMemoryMalloc(sizeof(int64_t)); + if (data == NULL) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SIMPLE_COPY_VALUES(data, &r->ra.s); - filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, tDataTypes[type].bytes, true, NULL); - filterAddUnit(dst, FILTER_GET_FLAG(r->ra.sflag, RANGE_FLG_EXCLUDE) ? OP_TYPE_GREATER_THAN : OP_TYPE_GREATER_EQUAL, - &left, &right, &uidx); - filterAddUnitToGroup(g, uidx); + FLT_ERR_RET(filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, tDataTypes[type].bytes, true, NULL)); + FLT_ERR_RET(filterAddUnit(dst, FILTER_GET_FLAG(r->ra.sflag, RANGE_FLG_EXCLUDE) ? OP_TYPE_GREATER_THAN : OP_TYPE_GREATER_EQUAL, + &left, &right, &uidx)); + FLT_ERR_RET(filterAddUnitToGroup(g, uidx)); } if (!FILTER_GET_FLAG(r->ra.eflag, RANGE_FLG_NULL)) { void *data = taosMemoryMalloc(sizeof(int64_t)); + if (data == NULL) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SIMPLE_COPY_VALUES(data, &r->ra.e); - filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, tDataTypes[type].bytes, true, NULL); - filterAddUnit(dst, FILTER_GET_FLAG(r->ra.eflag, RANGE_FLG_EXCLUDE) ? OP_TYPE_LOWER_THAN : OP_TYPE_LOWER_EQUAL, - &left, &right, &uidx); - filterAddUnitToGroup(g, uidx); + FLT_ERR_RET(filterAddField(dst, NULL, &data, FLD_TYPE_VALUE, &right, tDataTypes[type].bytes, true, NULL)); + FLT_ERR_RET(filterAddUnit(dst, FILTER_GET_FLAG(r->ra.eflag, RANGE_FLG_EXCLUDE) ? OP_TYPE_LOWER_THAN : OP_TYPE_LOWER_EQUAL, + &left, &right, &uidx)); + FLT_ERR_RET(filterAddUnitToGroup(g, uidx)); } ASSERT(g->unitNum > 0); - taosArrayPush(res, g); + if (NULL == taosArrayPush(res,g)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } r = r->next; } @@ -1493,7 +1610,13 @@ EDealRes fltTreeToGroup(SNode *pNode, void *pContext) { SListCell *cell = node->pParameterList->pHead; for (int32_t i = 0; i < node->pParameterList->length; ++i) { newGroup = taosArrayInit(4, sizeof(SFilterGroup)); + if (NULL == newGroup) { + FLT_ERR_RET(terrno); + } resGroup = taosArrayInit(4, sizeof(SFilterGroup)); + if (NULL == resGroup) { + FLT_ERR_RET(terrno); + } SFltBuildGroupCtx tctx = {.info = ctx->info, .group = newGroup}; nodesWalkExpr(cell->pNode, fltTreeToGroup, (void *)&tctx); @@ -1511,7 +1634,7 @@ EDealRes fltTreeToGroup(SNode *pNode, void *pContext) { cell = cell->pNext; } - taosArrayAddAll(ctx->group, preGroup); + (void)taosArrayAddAll(ctx->group, preGroup); taosArrayDestroy(preGroup); @@ -1614,7 +1737,7 @@ int32_t fltConverToStr(char *str, int type, void *buf, int32_t bufSize, int32_t } *str = '"'; - memcpy(str + 1, buf, bufSize); + (void)memcpy(str + 1, buf, bufSize); *(str + bufSize + 1) = '"'; n = bufSize + 2; break; @@ -1645,11 +1768,11 @@ int32_t fltConverToStr(char *str, int type, void *buf, int32_t bufSize, int32_t return TSDB_CODE_SUCCESS; } -void filterDumpInfoToString(SFilterInfo *info, const char *msg, int32_t options) { +int32_t filterDumpInfoToString(SFilterInfo *info, const char *msg, int32_t options) { if (qDebugFlag & DEBUG_DEBUG) { if (info == NULL) { fltDebug("%s - FilterInfo: EMPTY", msg); - return; + return TSDB_CODE_SUCCESS; } if (options == 0) { @@ -1700,14 +1823,16 @@ void filterDumpInfoToString(SFilterInfo *info, const char *msg, int32_t options) tlen = varDataLen(data); data += VARSTR_HEADER_SIZE; } - if (data) fltConverToStr(str + len, type, data, tlen > 32 ? 32 : tlen, &tlen); + if (data) { + FLT_ERR_RET(fltConverToStr(str + len, type, data, tlen > 32 ? 32 : tlen, &tlen)); + } } else { - strcat(str, "NULL"); + (void)strcat(str, "NULL"); } - strcat(str, "]"); + (void)strcat(str, "]"); if (unit->compare.optr2) { - strcat(str, " && "); + (void)strcat(str, " && "); if (unit->compare.optr2 <= OP_TYPE_JSON_CONTAINS) { sprintf(str + strlen(str), "[%d][%d] %s [", refNode->dataBlockId, refNode->slotId, operatorTypeStr(unit->compare.optr2)); @@ -1720,11 +1845,11 @@ void filterDumpInfoToString(SFilterInfo *info, const char *msg, int32_t options) tlen = varDataLen(data); data += VARSTR_HEADER_SIZE; } - fltConverToStr(str + strlen(str), type, data, tlen > 32 ? 32 : tlen, &tlen); + FLT_ERR_RET(fltConverToStr(str + strlen(str), type, data, tlen > 32 ? 32 : tlen, &tlen)); } else { - strcat(str, "NULL"); + (void)strcat(str, "NULL"); } - strcat(str, "]"); + (void)strcat(str, "]"); } qDebug("%s", str); // TODO @@ -1741,7 +1866,7 @@ void filterDumpInfoToString(SFilterInfo *info, const char *msg, int32_t options) } } - return; + return TSDB_CODE_SUCCESS; } if (options == 1) { @@ -1758,18 +1883,18 @@ void filterDumpInfoToString(SFilterInfo *info, const char *msg, int32_t options) while (r) { char str[256] = {0}; if (FILTER_GET_FLAG(r->ra.sflag, RANGE_FLG_NULL)) { - strcat(str, "(NULL)"); + (void)strcat(str, "(NULL)"); } else { FILTER_GET_FLAG(r->ra.sflag, RANGE_FLG_EXCLUDE) ? strcat(str, "(") : strcat(str, "["); - fltConverToStr(str + strlen(str), ctx->type, &r->ra.s, tlen > 32 ? 32 : tlen, &tlen); + FLT_ERR_RET(fltConverToStr(str + strlen(str), ctx->type, &r->ra.s, tlen > 32 ? 32 : tlen, &tlen)); FILTER_GET_FLAG(r->ra.sflag, RANGE_FLG_EXCLUDE) ? strcat(str, ")") : strcat(str, "]"); } - strcat(str, " - "); + (void)strcat(str, " - "); if (FILTER_GET_FLAG(r->ra.eflag, RANGE_FLG_NULL)) { - strcat(str, "(NULL)"); + (void)strcat(str, "(NULL)"); } else { FILTER_GET_FLAG(r->ra.eflag, RANGE_FLG_EXCLUDE) ? strcat(str, "(") : strcat(str, "["); - fltConverToStr(str + strlen(str), ctx->type, &r->ra.e, tlen > 32 ? 32 : tlen, &tlen); + FLT_ERR_RET(fltConverToStr(str + strlen(str), ctx->type, &r->ra.e, tlen > 32 ? 32 : tlen, &tlen)); FILTER_GET_FLAG(r->ra.eflag, RANGE_FLG_EXCLUDE) ? strcat(str, ")") : strcat(str, "]"); } qDebug("range: %s", str); @@ -1779,17 +1904,17 @@ void filterDumpInfoToString(SFilterInfo *info, const char *msg, int32_t options) } } - return; + return TSDB_CODE_SUCCESS; } qDebug("%s - Block Filter info:", msg); if (FILTER_GET_FLAG(info->blkFlag, FI_STATUS_BLK_ALL)) { qDebug("Flag:%s", "ALL"); - return; + return TSDB_CODE_SUCCESS; } else if (FILTER_GET_FLAG(info->blkFlag, FI_STATUS_BLK_EMPTY)) { qDebug("Flag:%s", "EMPTY"); - return; + return TSDB_CODE_SUCCESS; } else if (FILTER_GET_FLAG(info->blkFlag, FI_STATUS_BLK_ACTIVE)) { qDebug("Flag:%s", "ACTIVE"); } @@ -1804,6 +1929,7 @@ void filterDumpInfoToString(SFilterInfo *info, const char *msg, int32_t options) } } } + return TSDB_CODE_SUCCESS; } void filterFreeColInfo(void *data) { @@ -1816,7 +1942,7 @@ void filterFreeColInfo(void *data) { if (info->type == RANGE_TYPE_VAR_HASH) { // TODO } else if (info->type == RANGE_TYPE_MR_CTX) { - filterFreeRangeCtx(info->info); + (void)filterFreeRangeCtx(info->info); // No need to handle the return value. } else if (info->type == RANGE_TYPE_UNIT) { taosArrayDestroy((SArray *)info->info); } @@ -1831,7 +1957,7 @@ void filterFreeColCtx(void *data) { SFilterColCtx *ctx = (SFilterColCtx *)data; if (ctx->ctx) { - filterFreeRangeCtx(ctx->ctx); + (void)filterFreeRangeCtx(ctx->ctx); // No need to handle the return value. } } @@ -1913,7 +2039,7 @@ void filterFreeInfo(SFilterInfo *info) { taosMemoryFreeClear(info->unitFlags); for (uint32_t i = 0; i < info->colRangeNum; ++i) { - filterFreeRangeCtx(info->colRange[i]); + (void)filterFreeRangeCtx(info->colRange[i]); // No need to handle the return value. } taosMemoryFreeClear(info->colRange); @@ -1987,9 +2113,15 @@ int32_t fltInitValFieldData(SFilterInfo *info) { if (dType->type == type) { size_t bufBytes = TMAX(dType->bytes, sizeof(int64_t)); fi->data = taosMemoryCalloc(1, bufBytes); + if (fi->data == NULL) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } assignVal(fi->data, nodesGetValueFromNode(var), dType->bytes, type); } else { SScalarParam out = {.columnData = taosMemoryCalloc(1, sizeof(SColumnInfoData))}; + if (out.columnData == NULL) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } out.columnData->info.type = type; out.columnData->info.precision = precision; if (!IS_VAR_DATA_TYPE(type)) { @@ -2008,9 +2140,12 @@ int32_t fltInitValFieldData(SFilterInfo *info) { size_t bufBytes = IS_VAR_DATA_TYPE(type) ? varDataTLen(out.columnData->pData) : TMAX(out.columnData->info.bytes, sizeof(int64_t)); fi->data = taosMemoryCalloc(1, bufBytes); + if (fi->data== NULL) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } size_t valBytes = IS_VAR_DATA_TYPE(type) ? varDataTLen(out.columnData->pData) : out.columnData->info.bytes; - memcpy(fi->data, out.columnData->pData, valBytes); + (void)memcpy(fi->data, out.columnData->pData, valBytes); colDataDestroy(out.columnData); taosMemoryFree(out.columnData); @@ -2025,7 +2160,7 @@ int32_t fltInitValFieldData(SFilterInfo *info) { return TSDB_CODE_APP_ERROR; } varDataSetLen(newValData, len); - varDataCopy(fi->data, newValData); + (void)varDataCopy(fi->data, newValData); } } @@ -2127,7 +2262,7 @@ int32_t filterAddUnitRange(SFilterInfo *info, SFilterUnit *u, SFilterRangeCtx *c return TSDB_CODE_APP_ERROR; } - filterAddRange(ctx, &ra, optr); + FLT_ERR_RET(filterAddRange(ctx, &ra, optr)); return TSDB_CODE_SUCCESS; } @@ -2166,17 +2301,19 @@ int32_t filterMergeUnits(SFilterInfo *info, SFilterGroupCtx *gRes, uint32_t colI SArray *colArray = (SArray *)gRes->colInfo[colIdx].info; int32_t size = (int32_t)taosArrayGetSize(colArray); int32_t type = gRes->colInfo[colIdx].dataType; - SFilterRangeCtx *ctx = filterInitRangeCtx(type, 0); + int32_t code = TSDB_CODE_SUCCESS; + SFilterRangeCtx *ctx = NULL; + FLT_ERR_JRET(filterInitRangeCtx(type, 0, &ctx)); for (uint32_t i = 0; i < size; ++i) { SFilterUnit *u = taosArrayGetP(colArray, i); uint8_t optr = FILTER_UNIT_OPTR(u); - filterAddRangeOptr(ctx, optr, LOGIC_COND_TYPE_AND, empty, NULL); + FLT_ERR_RET(filterAddRangeOptr(ctx, optr, LOGIC_COND_TYPE_AND, empty, NULL)); FLT_CHK_JMP(*empty); if (!FILTER_NO_MERGE_OPTR(optr)) { - filterAddUnitRange(info, u, ctx, LOGIC_COND_TYPE_AND); + FLT_ERR_JRET(filterAddUnitRange(info, u, ctx, LOGIC_COND_TYPE_AND)); FLT_CHK_JMP(MR_EMPTY_RES(ctx)); } if (FILTER_UNIT_OPTR(u) == OP_TYPE_EQUAL && !FILTER_NO_MERGE_DATA_TYPE(FILTER_UNIT_DATA_TYPE(u))) { @@ -2195,22 +2332,31 @@ _return: *empty = true; - filterFreeRangeCtx(ctx); + (void)filterFreeRangeCtx(ctx); // No need to handle the return value. return TSDB_CODE_SUCCESS; } int32_t filterMergeGroupUnits(SFilterInfo *info, SFilterGroupCtx **gRes, int32_t *gResNum) { bool empty = false; - uint32_t *colIdx = taosMemoryMalloc(info->fields[FLD_TYPE_COLUMN].num * sizeof(uint32_t)); + int32_t code = TSDB_CODE_SUCCESS; uint32_t colIdxi = 0; uint32_t gResIdx = 0; - + uint32_t *colIdx = taosMemoryMalloc(info->fields[FLD_TYPE_COLUMN].num * sizeof(uint32_t)); + if (colIdx == NULL) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } for (uint32_t i = 0; i < info->groupNum; ++i) { SFilterGroup *g = info->groups + i; gRes[gResIdx] = taosMemoryCalloc(1, sizeof(SFilterGroupCtx)); + if (gRes[gResIdx] == NULL) { + FLT_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } gRes[gResIdx]->colInfo = taosMemoryCalloc(info->fields[FLD_TYPE_COLUMN].num, sizeof(SFilterColInfo)); + if (gRes[gResIdx]->colInfo == NULL) { + FLT_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } colIdxi = 0; empty = false; @@ -2220,6 +2366,9 @@ int32_t filterMergeGroupUnits(SFilterInfo *info, SFilterGroupCtx **gRes, int32_t if (gRes[gResIdx]->colInfo[cidx].info == NULL) { gRes[gResIdx]->colInfo[cidx].info = (SArray *)taosArrayInit(4, POINTER_BYTES); + if (gRes[gResIdx]->colInfo[cidx].info == NULL) { + FLT_ERR_JRET(terrno); + } colIdx[colIdxi++] = cidx; ++gRes[gResIdx]->colNum; } else { @@ -2242,7 +2391,7 @@ int32_t filterMergeGroupUnits(SFilterInfo *info, SFilterGroupCtx **gRes, int32_t continue; } - filterMergeUnits(info, gRes[gResIdx], colIdx[l], &empty); + FLT_ERR_JRET(filterMergeUnits(info, gRes[gResIdx], colIdx[l], &empty)); if (empty) { break; @@ -2262,15 +2411,15 @@ int32_t filterMergeGroupUnits(SFilterInfo *info, SFilterGroupCtx **gRes, int32_t ++gResIdx; } - taosMemoryFreeClear(colIdx); - *gResNum = gResIdx; if (gResIdx == 0) { FILTER_SET_FLAG(info->status, FI_STATUS_EMPTY); } - return TSDB_CODE_SUCCESS; +_return: + taosMemoryFreeClear(colIdx); + FLT_RET(code); } bool filterIsSameUnits(SFilterColInfo *pCol1, SFilterColInfo *pCol2) { @@ -2371,16 +2520,16 @@ int32_t filterMergeTwoGroupsImpl(SFilterInfo *info, SFilterRangeCtx **ctx, int32 int32_t type = FILTER_GET_COL_FIELD_TYPE(fi); if ((*ctx) == NULL) { - *ctx = filterInitRangeCtx(type, 0); + FLT_ERR_RET(filterInitRangeCtx(type, 0, ctx)); } else { - filterReuseRangeCtx(*ctx, type, 0); + FLT_ERR_RET(filterReuseRangeCtx(*ctx, type, 0)); } ASSERT(gRes2->colInfo[cidx].type == RANGE_TYPE_MR_CTX); ASSERT(gRes1->colInfo[cidx].type == RANGE_TYPE_MR_CTX); - filterCopyRangeCtx(*ctx, gRes2->colInfo[cidx].info); - filterSourceRangeFromCtx(*ctx, gRes1->colInfo[cidx].info, optr, empty, all); + FLT_ERR_RET(filterCopyRangeCtx(*ctx, gRes2->colInfo[cidx].info)); + FLT_ERR_RET(filterSourceRangeFromCtx(*ctx, gRes1->colInfo[cidx].info, optr, empty, all)); return TSDB_CODE_SUCCESS; } @@ -2401,7 +2550,11 @@ int32_t filterMergeTwoGroups(SFilterInfo *info, SFilterGroupCtx **gRes1, SFilter uint32_t equal1 = 0, equal2 = 0, merNum = 0; SFilterRangeCtx *ctx = NULL; SFilterColCtx colCtx = {0}; + int32_t code = TSDB_CODE_SUCCESS; SArray *colCtxs = taosArrayInit((*gRes2)->colNum, sizeof(SFilterColCtx)); + if (colCtxs == NULL) { + FLT_ERR_JRET(terrno); + } for (; m < (*gRes1)->colNum; ++m) { idx1 = (*gRes1)->colIdx[m]; @@ -2417,7 +2570,7 @@ int32_t filterMergeTwoGroups(SFilterInfo *info, SFilterGroupCtx **gRes1, SFilter ++merNum; - filterMergeTwoGroupsImpl(info, &ctx, LOGIC_COND_TYPE_OR, idx1, *gRes1, *gRes2, NULL, all); + FLT_ERR_JRET(filterMergeTwoGroupsImpl(info, &ctx, LOGIC_COND_TYPE_OR, idx1, *gRes1, *gRes2, NULL, all)); FLT_CHK_JMP(*all); @@ -2426,15 +2579,17 @@ int32_t filterMergeTwoGroups(SFilterInfo *info, SFilterGroupCtx **gRes1, SFilter ++equal1; colCtx.colIdx = idx1; colCtx.ctx = ctx; - taosArrayPush(colCtxs, &colCtx); + if (NULL == taosArrayPush(colCtxs, &colCtx)) { + FLT_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } break; } else { - filterCompareRangeCtx(ctx, (*gRes1)->colInfo[idx1].info, &equal); + FLT_ERR_JRET(filterCompareRangeCtx(ctx, (*gRes1)->colInfo[idx1].info, &equal)); if (equal) { ++equal1; } - filterCompareRangeCtx(ctx, (*gRes2)->colInfo[idx2].info, &equal); + FLT_ERR_JRET(filterCompareRangeCtx(ctx, (*gRes2)->colInfo[idx2].info, &equal)); if (equal) { ++equal2; } @@ -2443,10 +2598,12 @@ int32_t filterMergeTwoGroups(SFilterInfo *info, SFilterGroupCtx **gRes1, SFilter colCtx.colIdx = idx1; colCtx.ctx = ctx; ctx = NULL; - taosArrayPush(colCtxs, &colCtx); + if (NULL == taosArrayPush(colCtxs, &colCtx)) { + FLT_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } } } else { - filterCompareRangeCtx(ctx, (*gRes1)->colInfo[idx1].info, &equal); + FLT_ERR_JRET(filterCompareRangeCtx(ctx, (*gRes1)->colInfo[idx1].info, &equal)); if (equal) { ++equal1; } @@ -2455,7 +2612,9 @@ int32_t filterMergeTwoGroups(SFilterInfo *info, SFilterGroupCtx **gRes1, SFilter colCtx.colIdx = idx1; colCtx.ctx = ctx; ctx = NULL; - taosArrayPush(colCtxs, &colCtx); + if (NULL == taosArrayPush(colCtxs, &colCtx)) { + FLT_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } } ++n; @@ -2498,7 +2657,7 @@ _return: } } - filterFreeRangeCtx(ctx); + (void)filterFreeRangeCtx(ctx); // No need to handle the return value. return TSDB_CODE_SUCCESS; } @@ -2510,6 +2669,7 @@ int32_t filterMergeGroups(SFilterInfo *info, SFilterGroupCtx **gRes, int32_t *gR taosSort(gRes, *gResNum, POINTER_BYTES, filterCompareGroupCtx); + int32_t code = TSDB_CODE_SUCCESS; int32_t pEnd = 0, cStart = 0, cEnd = 0; uint32_t pColNum = 0, cColNum = 0; int32_t movedNum = 0; @@ -2529,13 +2689,13 @@ int32_t filterMergeGroups(SFilterInfo *info, SFilterGroupCtx **gRes, int32_t *gR for (int32_t m = 0; m <= pEnd; ++m) { for (int32_t n = cStart; n <= cEnd; ++n) { ASSERT(m < n); - filterMergeTwoGroups(info, &gRes[m], &gRes[n], &all); + FLT_ERR_JRET(filterMergeTwoGroups(info, &gRes[m], &gRes[n], &all)); FLT_CHK_JMP(all); if (gRes[n] == NULL) { if (n < ((*gResNum) - 1)) { - memmove(&gRes[n], &gRes[n + 1], (*gResNum - n - 1) * POINTER_BYTES); + (void)memmove(&gRes[n], &gRes[n + 1], (*gResNum - n - 1) * POINTER_BYTES); } --cEnd; @@ -2550,13 +2710,13 @@ int32_t filterMergeGroups(SFilterInfo *info, SFilterGroupCtx **gRes, int32_t *gR for (int32_t m = cStart; m < cEnd; ++m) { for (int32_t n = m + 1; n <= cEnd; ++n) { ASSERT(m < n); - filterMergeTwoGroups(info, &gRes[m], &gRes[n], &all); + FLT_ERR_JRET(filterMergeTwoGroups(info, &gRes[m], &gRes[n], &all)); FLT_CHK_JMP(all); if (gRes[n] == NULL) { if (n < ((*gResNum) - 1)) { - memmove(&gRes[n], &gRes[n + 1], (*gResNum - n - 1) * POINTER_BYTES); + (void)memmove(&gRes[n], &gRes[n + 1], (*gResNum - n - 1) * POINTER_BYTES); } --cEnd; @@ -2596,11 +2756,17 @@ int32_t filterConvertGroupFromArray(SFilterInfo *info, SArray *group) { if (info->groupNum > 0) { info->groups = taosMemoryCalloc(info->groupNum, sizeof(*info->groups)); + if (info->groups == NULL) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } } for (size_t i = 0; i < groupSize; ++i) { SFilterGroup *pg = taosArrayGet(group, i); pg->unitFlags = taosMemoryCalloc(pg->unitNum, sizeof(*pg->unitFlags)); + if (pg->unitFlags == NULL) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } info->groups[i] = *pg; } @@ -2617,13 +2783,17 @@ int32_t filterRewrite(SFilterInfo *info, SFilterGroupCtx **gRes, int32_t gResNum FILTER_SET_FLAG(oinfo.status, FI_STATUS_CLONED); - SArray *group = taosArrayInit(FILTER_DEFAULT_GROUP_SIZE, sizeof(SFilterGroup)); SFilterGroupCtx *res = NULL; SFilterColInfo *colInfo = NULL; int32_t optr = 0; uint32_t uidx = 0; + uint32_t code = TSDB_CODE_SUCCESS; + SArray *group = taosArrayInit(FILTER_DEFAULT_GROUP_SIZE, sizeof(SFilterGroup)); + if (group == NULL) { + FLT_ERR_JRET(terrno); + } - memset(info, 0, sizeof(*info)); + (void)memset(info, 0, sizeof(*info)); info->colRangeNum = oinfo.colRangeNum; info->colRange = oinfo.colRange; @@ -2632,7 +2802,7 @@ int32_t filterRewrite(SFilterInfo *info, SFilterGroupCtx **gRes, int32_t gResNum FILTER_SET_FLAG(info->options, FLT_OPTION_NEED_UNIQE); - filterInitUnitsFields(info); + FLT_ERR_JRET(filterInitUnitsFields(info)); for (int32_t i = 0; i < gResNum; ++i) { res = gRes[i]; @@ -2650,8 +2820,8 @@ int32_t filterRewrite(SFilterInfo *info, SFilterGroupCtx **gRes, int32_t gResNum for (int32_t n = 0; n < usize; ++n) { SFilterUnit *u = (SFilterUnit *)taosArrayGetP((SArray *)colInfo->info, n); - filterAddUnitFromUnit(info, &oinfo, u, &uidx); - filterAddUnitToGroup(&ng, uidx); + FLT_ERR_JRET(filterAddUnitFromUnit(info, &oinfo, u, &uidx)); + FLT_ERR_JRET(filterAddUnitToGroup(&ng, uidx)); } continue; @@ -2659,29 +2829,35 @@ int32_t filterRewrite(SFilterInfo *info, SFilterGroupCtx **gRes, int32_t gResNum ASSERT(colInfo->type == RANGE_TYPE_MR_CTX); - filterAddGroupUnitFromCtx(info, &oinfo, colInfo->info, res->colIdx[m], &ng, optr, group); + FLT_ERR_JRET(filterAddGroupUnitFromCtx(info, &oinfo, colInfo->info, res->colIdx[m], &ng, optr, group)); } if (ng.unitNum > 0) { - taosArrayPush(group, &ng); + if (NULL == taosArrayPush(group, &ng)) { + FLT_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } } } - filterConvertGroupFromArray(info, group); +_return: + FLT_ERR_RET(filterConvertGroupFromArray(info, group)); taosArrayDestroy(group); filterFreeInfo(&oinfo); - return TSDB_CODE_SUCCESS; + FLT_RET(code); } int32_t filterGenerateColRange(SFilterInfo *info, SFilterGroupCtx **gRes, int32_t gResNum) { uint32_t *idxs = NULL; uint32_t colNum = 0; SFilterGroupCtx *res = NULL; + int32_t code = TSDB_CODE_SUCCESS; uint32_t *idxNum = taosMemoryCalloc(info->fields[FLD_TYPE_COLUMN].num, sizeof(*idxNum)); - + if (idxNum == NULL) { + FLT_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } for (int32_t i = 0; i < gResNum; ++i) { for (uint32_t m = 0; m < gRes[i]->colNum; ++m) { SFilterColInfo *colInfo = &gRes[i]->colInfo[gRes[i]->colIdx[m]]; @@ -2702,6 +2878,9 @@ int32_t filterGenerateColRange(SFilterInfo *info, SFilterGroupCtx **gRes, int32_ if (idxs == NULL) { idxs = taosMemoryCalloc(info->fields[FLD_TYPE_COLUMN].num, sizeof(*idxs)); + if (idxs == NULL) { + FLT_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } } idxs[colNum++] = i; @@ -2711,6 +2890,9 @@ int32_t filterGenerateColRange(SFilterInfo *info, SFilterGroupCtx **gRes, int32_ info->colRangeNum = colNum; info->colRange = taosMemoryCalloc(colNum, POINTER_BYTES); + if (info->colRange == NULL) { + FLT_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } for (int32_t i = 0; i < gResNum; ++i) { res = gRes[i]; @@ -2726,7 +2908,7 @@ int32_t filterGenerateColRange(SFilterInfo *info, SFilterGroupCtx **gRes, int32_ SFilterColInfo *colInfo = &res->colInfo[res->colIdx[n]]; if (info->colRange[m] == NULL) { - info->colRange[m] = filterInitRangeCtx(colInfo->dataType, 0); + FLT_ERR_JRET(filterInitRangeCtx(colInfo->dataType, 0, &(info->colRange[m]))); SFilterField *fi = FILTER_GET_COL_FIELD(info, res->colIdx[n]); info->colRange[m]->colId = FILTER_GET_COL_FIELD_ID(fi); } @@ -2734,14 +2916,13 @@ int32_t filterGenerateColRange(SFilterInfo *info, SFilterGroupCtx **gRes, int32_ ASSERT(colInfo->type == RANGE_TYPE_MR_CTX); bool all = false; - filterSourceRangeFromCtx(info->colRange[m], colInfo->info, LOGIC_COND_TYPE_OR, NULL, &all); + FLT_ERR_JRET(filterSourceRangeFromCtx(info->colRange[m], colInfo->info, LOGIC_COND_TYPE_OR, NULL, &all)); if (all) { - filterFreeRangeCtx(info->colRange[m]); + (void)filterFreeRangeCtx(info->colRange[m]); // No need to handle the return value. info->colRange[m] = NULL; - if (m < (info->colRangeNum - 1)) { - memmove(&info->colRange[m], &info->colRange[m + 1], (info->colRangeNum - m - 1) * POINTER_BYTES); - memmove(&idxs[m], &idxs[m + 1], (info->colRangeNum - m - 1) * sizeof(*idxs)); + (void)memmove(&info->colRange[m], &info->colRange[m + 1], (info->colRangeNum - m - 1) * POINTER_BYTES); + (void)memmove(&idxs[m], &idxs[m + 1], (info->colRangeNum - m - 1) * sizeof(*idxs)); } --info->colRangeNum; @@ -2777,15 +2958,17 @@ int32_t filterPostProcessRange(SFilterInfo *info) { } int32_t filterGenerateComInfo(SFilterInfo *info) { - terrno = 0; info->cunits = taosMemoryMalloc(info->unitNum * sizeof(*info->cunits)); info->blkUnitRes = taosMemoryMalloc(sizeof(*info->blkUnitRes) * info->unitNum); info->blkUnits = taosMemoryMalloc(sizeof(*info->blkUnits) * (info->unitNum + 1) * info->groupNum); + if (NULL == info->cunits || NULL == info->blkUnitRes || NULL == info->blkUnits) { + return TSDB_CODE_OUT_OF_MEMORY; + } for (uint32_t i = 0; i < info->unitNum; ++i) { SFilterUnit *unit = &info->units[i]; - info->cunits[i].func = filterGetCompFuncIdx(FILTER_UNIT_DATA_TYPE(unit), unit->compare.optr, false); // set terrno if err + FLT_ERR_RET(filterGetCompFuncIdx(FILTER_UNIT_DATA_TYPE(unit), unit->compare.optr, &info->cunits[i].func, false)); info->cunits[i].rfunc = filterGetRangeCompFuncFromOptrs(unit->compare.optr, unit->compare.optr2); info->cunits[i].optr = FILTER_UNIT_OPTR(unit); info->cunits[i].colData = NULL; @@ -2806,7 +2989,7 @@ int32_t filterGenerateComInfo(SFilterInfo *info) { info->cunits[i].dataType = FILTER_UNIT_DATA_TYPE(unit); } - return terrno; + return TSDB_CODE_SUCCESS; } int32_t filterUpdateComUnits(SFilterInfo *info) { @@ -2823,7 +3006,7 @@ int32_t filterUpdateComUnits(SFilterInfo *info) { int32_t filterRmUnitByRange(SFilterInfo *info, SColumnDataAgg *pDataStatis, int32_t numOfCols, int32_t numOfRows) { int32_t rmUnit = 0; - memset(info->blkUnitRes, 0, sizeof(*info->blkUnitRes) * info->unitNum); + (void)memset(info->blkUnitRes, 0, sizeof(*info->blkUnitRes) * info->unitNum); for (uint32_t k = 0; k < info->unitNum; ++k) { int32_t index = -1; @@ -3003,7 +3186,7 @@ int32_t filterRmUnitByRange(SFilterInfo *info, SColumnDataAgg *pDataStatis, int3 _return: - filterDumpInfoToString(info, "Block Filter", 2); + FLT_ERR_RET(filterDumpInfoToString(info, "Block Filter", 2)); return TSDB_CODE_SUCCESS; } @@ -3071,11 +3254,13 @@ bool filterExecuteBasedOnStatisImpl(void *pinfo, int32_t numOfRows, SColumnInfoD } int32_t filterExecuteBasedOnStatis(SFilterInfo *info, int32_t numOfRows, SColumnInfoData *p, SColumnDataAgg *statis, - int16_t numOfCols, bool *all) { + int16_t numOfCols, bool *all, int32_t *result) { + int32_t code = TSDB_CODE_SUCCESS; + *result = 0; if (statis && numOfRows >= FILTER_RM_UNIT_MIN_ROWS) { info->blkFlag = 0; - filterRmUnitByRange(info, statis, numOfCols, numOfRows); + FLT_ERR_JRET(filterRmUnitByRange(info, statis, numOfCols, numOfRows)); if (info->blkFlag) { if (FILTER_GET_FLAG(info->blkFlag, FI_STATUS_BLK_ALL)) { @@ -3093,32 +3278,37 @@ int32_t filterExecuteBasedOnStatis(SFilterInfo *info, int32_t numOfRows, SColumn } } - return 1; + *result = 1; + FLT_RET(TSDB_CODE_SUCCESS); _return: info->blkFlag = 0; - return TSDB_CODE_SUCCESS; + result = 0; + FLT_RET(code); } -static FORCE_INLINE bool filterExecuteImplAll(void *info, int32_t numOfRows, SColumnInfoData *p, SColumnDataAgg *statis, - int16_t numOfCols, int32_t *numOfQualified) { - return true; +static FORCE_INLINE int32_t filterExecuteImplAll(void *info, int32_t numOfRows, SColumnInfoData *p, SColumnDataAgg *statis, + int16_t numOfCols, int32_t *numOfQualified, bool *all) { + *all = true; + FLT_RET(TSDB_CODE_SUCCESS); } -static FORCE_INLINE bool filterExecuteImplEmpty(void *info, int32_t numOfRows, SColumnInfoData *p, - SColumnDataAgg *statis, int16_t numOfCols, int32_t *numOfQualified) { - return false; +static FORCE_INLINE int32_t filterExecuteImplEmpty(void *info, int32_t numOfRows, SColumnInfoData *p, + SColumnDataAgg *statis, int16_t numOfCols, int32_t *numOfQualified, bool *all) { + *all = false; + FLT_RET(TSDB_CODE_SUCCESS); } -static FORCE_INLINE bool filterExecuteImplIsNull(void *pinfo, int32_t numOfRows, SColumnInfoData *pRes, - SColumnDataAgg *statis, int16_t numOfCols, int32_t *numOfQualified) { +static FORCE_INLINE int32_t filterExecuteImplIsNull(void *pinfo, int32_t numOfRows, SColumnInfoData *pRes, + SColumnDataAgg *statis, int16_t numOfCols, int32_t *numOfQualified, bool *all) { SFilterInfo *info = (SFilterInfo *)pinfo; - bool all = true; + int8_t *p = (int8_t *)pRes->pData; + int32_t result = 0; - int8_t *p = (int8_t *)pRes->pData; - - if (filterExecuteBasedOnStatis(info, numOfRows, pRes, statis, numOfCols, &all) == 0) { - return all; + *all = true; + FLT_ERR_RET(filterExecuteBasedOnStatis(info, numOfRows, pRes, statis, numOfCols, all, &result)); + if (result == 0) { + FLT_RET(TSDB_CODE_SUCCESS); } for (int32_t i = 0; i < numOfRows; ++i) { @@ -3126,22 +3316,24 @@ static FORCE_INLINE bool filterExecuteImplIsNull(void *pinfo, int32_t numOfRows, p[i] = colDataIsNull((SColumnInfoData *)info->cunits[uidx].colData, 0, i, NULL); if (p[i] == 0) { - all = false; + *all = false; } else { (*numOfQualified) += 1; } } - return all; + FLT_RET(TSDB_CODE_SUCCESS); } -static FORCE_INLINE bool filterExecuteImplNotNull(void *pinfo, int32_t numOfRows, SColumnInfoData *pRes, - SColumnDataAgg *statis, int16_t numOfCols, int32_t *numOfQualified) { +static FORCE_INLINE int32_t filterExecuteImplNotNull(void *pinfo, int32_t numOfRows, SColumnInfoData *pRes, + SColumnDataAgg *statis, int16_t numOfCols, int32_t *numOfQualified, bool *all) { SFilterInfo *info = (SFilterInfo *)pinfo; - bool all = true; + int32_t result = 0; - if (filterExecuteBasedOnStatis(info, numOfRows, pRes, statis, numOfCols, &all) == 0) { - return all; + *all = true; + FLT_ERR_RET(filterExecuteBasedOnStatis(info, numOfRows, pRes, statis, numOfCols, all, &result)); + if (result == 0) { + FLT_RET(TSDB_CODE_SUCCESS); } int8_t *p = (int8_t *)pRes->pData; @@ -3151,27 +3343,29 @@ static FORCE_INLINE bool filterExecuteImplNotNull(void *pinfo, int32_t numOfRows p[i] = !colDataIsNull((SColumnInfoData *)info->cunits[uidx].colData, 0, i, NULL); if (p[i] == 0) { - all = false; + *all = false; } else { (*numOfQualified) += 1; } } - return all; + FLT_RET(TSDB_CODE_SUCCESS); } -bool filterExecuteImplRange(void *pinfo, int32_t numOfRows, SColumnInfoData *pRes, SColumnDataAgg *statis, - int16_t numOfCols, int32_t *numOfQualified) { +int32_t filterExecuteImplRange(void *pinfo, int32_t numOfRows, SColumnInfoData *pRes, SColumnDataAgg *statis, + int16_t numOfCols, int32_t *numOfQualified, bool *all) { SFilterInfo *info = (SFilterInfo *)pinfo; - bool all = true; uint16_t dataSize = info->cunits[0].dataSize; rangeCompFunc rfunc = gRangeCompare[info->cunits[0].rfunc]; void *valData = info->cunits[0].valData; void *valData2 = info->cunits[0].valData2; __compar_fn_t func = gDataCompare[info->cunits[0].func]; + int32_t result = 0; - if (filterExecuteBasedOnStatis(info, numOfRows, pRes, statis, numOfCols, &all) == 0) { - return all; + *all = true; + FLT_ERR_RET(filterExecuteBasedOnStatis(info, numOfRows, pRes, statis, numOfCols, all, &result)); + if (result == 0) { + FLT_RET(TSDB_CODE_SUCCESS); } int8_t *p = (int8_t *)pRes->pData; @@ -3180,7 +3374,7 @@ bool filterExecuteImplRange(void *pinfo, int32_t numOfRows, SColumnInfoData *pRe SColumnInfoData *pData = info->cunits[0].colData; if (colDataIsNull_s(pData, i)) { - all = false; + *all = false; p[i] = 0; continue; } @@ -3189,22 +3383,24 @@ bool filterExecuteImplRange(void *pinfo, int32_t numOfRows, SColumnInfoData *pRe p[i] = (*rfunc)(colData, colData, valData, valData2, func); if (p[i] == 0) { - all = false; + *all = false; } else { (*numOfQualified)++; } } - return all; + FLT_RET(TSDB_CODE_SUCCESS); } -bool filterExecuteImplMisc(void *pinfo, int32_t numOfRows, SColumnInfoData *pRes, SColumnDataAgg *statis, - int16_t numOfCols, int32_t *numOfQualified) { +int32_t filterExecuteImplMisc(void *pinfo, int32_t numOfRows, SColumnInfoData *pRes, SColumnDataAgg *statis, + int16_t numOfCols, int32_t *numOfQualified, bool *all) { SFilterInfo *info = (SFilterInfo *)pinfo; - bool all = true; + int32_t result = 0; - if (filterExecuteBasedOnStatis(info, numOfRows, pRes, statis, numOfCols, &all) == 0) { - return all; + *all = true; + FLT_ERR_RET(filterExecuteBasedOnStatis(info, numOfRows, pRes, statis, numOfCols, all, &result)); + if (result == 0) { + FLT_RET(TSDB_CODE_SUCCESS); } int8_t *p = (int8_t *)pRes->pData; @@ -3213,7 +3409,7 @@ bool filterExecuteImplMisc(void *pinfo, int32_t numOfRows, SColumnInfoData *pRes uint32_t uidx = info->groups[0].unitIdxs[0]; if (colDataIsNull_s((SColumnInfoData *)info->cunits[uidx].colData, i)) { p[i] = 0; - all = false; + *all = false; continue; } @@ -3222,9 +3418,14 @@ bool filterExecuteImplMisc(void *pinfo, int32_t numOfRows, SColumnInfoData *pRes if (info->cunits[uidx].dataType == TSDB_DATA_TYPE_NCHAR && (info->cunits[uidx].optr == OP_TYPE_MATCH || info->cunits[uidx].optr == OP_TYPE_NMATCH)) { char *newColData = taosMemoryCalloc(info->cunits[uidx].dataSize * TSDB_NCHAR_SIZE + VARSTR_HEADER_SIZE, 1); + if (newColData == NULL) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } int32_t len = taosUcs4ToMbs((TdUcs4 *)varDataVal(colData), varDataLen(colData), varDataVal(newColData)); if (len < 0) { qError("castConvert1 taosUcs4ToMbs error"); + taosMemoryFreeClear(newColData); + FLT_ERR_RET(TSDB_CODE_APP_ERROR); } else { varDataSetLen(newColData, len); p[i] = filterDoCompare(gDataCompare[info->cunits[uidx].func], info->cunits[uidx].optr, newColData, @@ -3237,22 +3438,24 @@ bool filterExecuteImplMisc(void *pinfo, int32_t numOfRows, SColumnInfoData *pRes } if (p[i] == 0) { - all = false; + *all = false; } else { (*numOfQualified) += 1; } } - return all; + FLT_RET(TSDB_CODE_SUCCESS); } -bool filterExecuteImpl(void *pinfo, int32_t numOfRows, SColumnInfoData *pRes, SColumnDataAgg *statis, int16_t numOfCols, - int32_t *numOfQualified) { +int32_t filterExecuteImpl(void *pinfo, int32_t numOfRows, SColumnInfoData *pRes, SColumnDataAgg *statis, int16_t numOfCols, + int32_t *numOfQualified, bool *all) { SFilterInfo *info = (SFilterInfo *)pinfo; - bool all = true; + int32_t result = 0; - if (filterExecuteBasedOnStatis(info, numOfRows, pRes, statis, numOfCols, &all) == 0) { - return all; + *all = true; + FLT_ERR_RET(filterExecuteBasedOnStatis(info, numOfRows, pRes, statis, numOfCols, all, &result)); + if (result == 0) { + FLT_RET(TSDB_CODE_SUCCESS); } int8_t *p = (int8_t *)pRes->pData; @@ -3290,9 +3493,14 @@ bool filterExecuteImpl(void *pinfo, int32_t numOfRows, SColumnInfoData *pRes, SC if (cunit->dataType == TSDB_DATA_TYPE_NCHAR && (cunit->optr == OP_TYPE_MATCH || cunit->optr == OP_TYPE_NMATCH)) { char *newColData = taosMemoryCalloc(cunit->dataSize * TSDB_NCHAR_SIZE + VARSTR_HEADER_SIZE, 1); + if (newColData == NULL) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } int32_t len = taosUcs4ToMbs((TdUcs4 *)varDataVal(colData), varDataLen(colData), varDataVal(newColData)); if (len < 0) { qError("castConvert1 taosUcs4ToMbs error"); + taosMemoryFreeClear(newColData); + FLT_ERR_RET(TSDB_CODE_APP_ERROR); } else { varDataSetLen(newColData, len); p[i] = filterDoCompare(gDataCompare[cunit->func], cunit->optr, newColData, cunit->valData); @@ -3318,13 +3526,13 @@ bool filterExecuteImpl(void *pinfo, int32_t numOfRows, SColumnInfoData *pRes, SC } if (p[i] == 0) { - all = false; + *all = false; } else { (*numOfQualified) += 1; } } - return all; + FLT_RET(TSDB_CODE_SUCCESS); } int32_t filterSetExecFunc(SFilterInfo *info) { @@ -3364,12 +3572,15 @@ int32_t filterSetExecFunc(SFilterInfo *info) { int32_t filterPreprocess(SFilterInfo *info) { int32_t code = TSDB_CODE_SUCCESS; - SFilterGroupCtx **gRes = taosMemoryCalloc(info->groupNum, sizeof(SFilterGroupCtx *)); int32_t gResNum = 0; + SFilterGroupCtx **gRes = taosMemoryCalloc(info->groupNum, sizeof(SFilterGroupCtx *)); + if (gRes == NULL) { + FLT_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } - filterMergeGroupUnits(info, gRes, &gResNum); + FLT_ERR_JRET(filterMergeGroupUnits(info, gRes, &gResNum)); - filterMergeGroups(info, gRes, &gResNum); + FLT_ERR_JRET(filterMergeGroups(info, gRes, &gResNum)); if (FILTER_GET_FLAG(info->status, FI_STATUS_ALL)) { fltInfo("Final - FilterInfo: [ALL]"); @@ -3381,19 +3592,19 @@ int32_t filterPreprocess(SFilterInfo *info) { goto _return; } - filterGenerateColRange(info, gRes, gResNum); + FLT_ERR_JRET(filterGenerateColRange(info, gRes, gResNum)); - filterDumpInfoToString(info, "Final", 1); + FLT_ERR_JRET(filterDumpInfoToString(info, "Final", 1)); - filterPostProcessRange(info); + FLT_ERR_JRET(filterPostProcessRange(info)); - filterRewrite(info, gRes, gResNum); + FLT_ERR_JRET(filterRewrite(info, gRes, gResNum)); FLT_ERR_JRET(filterGenerateComInfo(info)); _return: - filterSetExecFunc(info); + FLT_ERR_RET(filterSetExecFunc(info)); for (int32_t i = 0; i < gResNum; ++i) { filterFreeGroupCtx(gRes[i]); @@ -3413,13 +3624,13 @@ int32_t fltSetColFieldDataImpl(SFilterInfo *info, void *param, filer_get_col_fro SFilterField *fi = &info->fields[FLD_TYPE_COLUMN].fields[i]; if (fromColId) { - (*fp)(param, FILTER_GET_COL_FIELD_ID(fi), &fi->data); + FLT_ERR_RET((*fp)(param, FILTER_GET_COL_FIELD_ID(fi), &fi->data)); } else { - (*fp)(param, FILTER_GET_COL_FIELD_SLOT_ID(fi), &fi->data); + FLT_ERR_RET((*fp)(param, FILTER_GET_COL_FIELD_SLOT_ID(fi), &fi->data)); } } - filterUpdateComUnits(info); + FLT_ERR_RET(filterUpdateComUnits(info)); return TSDB_CODE_SUCCESS; } @@ -3428,20 +3639,23 @@ int32_t fltInitFromNode(SNode *tree, SFilterInfo *info, uint32_t options) { int32_t code = TSDB_CODE_SUCCESS; SArray *group = taosArrayInit(FILTER_DEFAULT_GROUP_SIZE, sizeof(SFilterGroup)); + if (group == NULL) { + FLT_ERR_JRET(terrno); + } - filterInitUnitsFields(info); + FLT_ERR_JRET(filterInitUnitsFields(info)); SFltBuildGroupCtx tctx = {.info = info, .group = group}; nodesWalkExpr(tree, fltTreeToGroup, (void *)&tctx); FLT_ERR_JRET(tctx.code); - filterConvertGroupFromArray(info, group); + FLT_ERR_JRET(filterConvertGroupFromArray(info, group)); taosArrayDestroy(group); FLT_ERR_JRET(fltInitValFieldData(info)); if (!FILTER_GET_FLAG(info->options, FLT_OPTION_NO_REWRITE)) { - filterDumpInfoToString(info, "Before preprocess", 0); + FLT_ERR_JRET(filterDumpInfoToString(info, "Before preprocess", 0)); FLT_ERR_JRET(filterPreprocess(info)); @@ -3453,9 +3667,14 @@ int32_t fltInitFromNode(SNode *tree, SFilterInfo *info, uint32_t options) { } info->unitRes = taosMemoryMalloc(info->unitNum * sizeof(*info->unitRes)); + if (info->unitRes == NULL) { + FLT_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } info->unitFlags = taosMemoryMalloc(info->unitNum * sizeof(*info->unitFlags)); - - filterDumpInfoToString(info, "Final", 0); + if (info->unitFlags == NULL) { + FLT_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } + FLT_ERR_JRET(filterDumpInfoToString(info, "Final", 0)); return code; _return: @@ -3597,26 +3816,34 @@ int32_t fltSclMergeSort(SArray *pts1, SArray *pts2, SArray *result) { SFltSclPoint *pt2 = taosArrayGet(pts2, j); bool less = fltSclLessPoint(pt1, pt2); if (less) { - taosArrayPush(result, pt1); + if (NULL == taosArrayPush(result, pt1)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } ++i; } else { - taosArrayPush(result, pt2); + if (NULL == taosArrayPush(result, pt2)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } ++j; } } if (i < len1) { for (; i < len1; ++i) { SFltSclPoint *pt1 = taosArrayGet(pts1, i); - taosArrayPush(result, pt1); + if (NULL == taosArrayPush(result, pt1)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } } } if (j < len2) { for (; j < len2; ++j) { SFltSclPoint *pt2 = taosArrayGet(pts2, j); - taosArrayPush(result, pt2); + if (NULL == taosArrayPush(result, pt2)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } } } - return 0; + return TSDB_CODE_SUCCESS; } int32_t fltSclMerge(SArray *pts1, SArray *pts2, bool isUnion, SArray *merged) { @@ -3624,7 +3851,10 @@ int32_t fltSclMerge(SArray *pts1, SArray *pts2, bool isUnion, SArray *merged) { size_t len2 = taosArrayGetSize(pts2); // first merge sort pts1 and pts2 SArray *all = taosArrayInit(len1 + len2, sizeof(SFltSclPoint)); - fltSclMergeSort(pts1, pts2, all); + if (all == NULL) { + FLT_ERR_RET(terrno); + } + FLT_ERR_RET(fltSclMergeSort(pts1, pts2, all)); int32_t countRequired = (isUnion) ? 1 : 2; int32_t count = 0; for (int32_t i = 0; i < taosArrayGetSize(all); ++i) { @@ -3632,17 +3862,21 @@ int32_t fltSclMerge(SArray *pts1, SArray *pts2, bool isUnion, SArray *merged) { if (pt->start) { ++count; if (count == countRequired) { - taosArrayPush(merged, pt); + if (NULL == taosArrayPush(merged, pt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } } } else { if (count == countRequired) { - taosArrayPush(merged, pt); + if (NULL == taosArrayPush(merged, pt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } } --count; } } taosArrayDestroy(all); - return 0; + return TSDB_CODE_SUCCESS; } int32_t fltSclIntersect(SArray *pts1, SArray *pts2, SArray *merged) { return fltSclMerge(pts1, pts2, false, merged); } @@ -3655,17 +3889,27 @@ typedef struct { EOperatorType type; } SFltSclOperator; -SFltSclColumnRange *fltSclGetOrCreateColumnRange(SColumnNode *colNode, SArray *colRangeList) { + +int32_t fltSclGetOrCreateColumnRange(SColumnNode *colNode, SArray *colRangeList, SFltSclColumnRange **colRange) { for (int32_t i = 0; i < taosArrayGetSize(colRangeList); ++i) { - SFltSclColumnRange *colRange = taosArrayGet(colRangeList, i); - if (nodesEqualNode((SNode *)colRange->colNode, (SNode *)colNode)) { - return colRange; + *colRange = taosArrayGet(colRangeList, i); + if (nodesEqualNode((SNode *)(*colRange)->colNode, (SNode *)colNode)) { + return TSDB_CODE_SUCCESS; } } + // TODO(smj):wait for nodesCloneNode change it's return value, use terrno for now. + terrno = TSDB_CODE_SUCCESS; SColumnNode *pColumnNode = (SColumnNode *)nodesCloneNode((SNode *)colNode); + FLT_ERR_RET(terrno); SFltSclColumnRange newColRange = {.colNode = pColumnNode, .points = taosArrayInit(4, sizeof(SFltSclPoint))}; - taosArrayPush(colRangeList, &newColRange); - return taosArrayGetLast(colRangeList); + if (NULL == newColRange.points) { + FLT_ERR_RET(terrno); + } + if (NULL == taosArrayPush(colRangeList, &newColRange)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + *colRange = taosArrayGetLast(colRangeList); + return TSDB_CODE_SUCCESS; } int32_t fltSclBuildDatumFromValueNode(SFltSclDatum *datum, SValueNode *valNode) { @@ -3760,29 +4004,42 @@ int32_t fltSclBuildRangeFromBlockSma(SFltSclColumnRange *colRange, SColumnDataAg SFltSclDatum datum = {.kind = FLT_SCL_DATUM_KIND_NULL}; SFltSclPoint startPt = {.start = true, .excl = false, .val = datum}; SFltSclPoint endPt = {.start = false, .excl = false, .val = datum}; - taosArrayPush(points, &startPt); - taosArrayPush(points, &endPt); + if (NULL == taosArrayPush(points, &startPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + if (NULL == taosArrayPush(points, &endPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } return TSDB_CODE_SUCCESS; } if (pAgg->numOfNull > 0) { SFltSclDatum nullDatum = {.kind = FLT_SCL_DATUM_KIND_NULL}; SFltSclPoint startPt = {.start = true, .excl = false, .val = nullDatum}; SFltSclPoint endPt = {.start = false, .excl = false, .val = nullDatum}; - taosArrayPush(points, &startPt); - taosArrayPush(points, &endPt); + if (NULL == taosArrayPush(points, &startPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + if (NULL == taosArrayPush(points, &endPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } } SFltSclDatum min = {0}; - fltSclBuildDatumFromBlockSmaValue(&min, colRange->colNode->node.resType.type, pAgg->min); + FLT_ERR_RET(fltSclBuildDatumFromBlockSmaValue(&min, colRange->colNode->node.resType.type, pAgg->min)); SFltSclPoint minPt = {.excl = false, .start = true, .val = min}; SFltSclDatum max = {0}; - fltSclBuildDatumFromBlockSmaValue(&max, colRange->colNode->node.resType.type, pAgg->max); + FLT_ERR_RET(fltSclBuildDatumFromBlockSmaValue(&max, colRange->colNode->node.resType.type, pAgg->max)); SFltSclPoint maxPt = {.excl = false, .start = false, .val = max}; - taosArrayPush(points, &minPt); - taosArrayPush(points, &maxPt); + if (NULL == taosArrayPush(points, &minPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + if (NULL == taosArrayPush(points, &maxPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } return TSDB_CODE_SUCCESS; } -bool filterRangeExecute(SFilterInfo *info, SColumnDataAgg *pDataStatis, int32_t numOfCols, int32_t numOfRows) { +int32_t filterRangeExecute(SFilterInfo *info, SColumnDataAgg *pDataStatis, int32_t numOfCols, int32_t numOfRows, + bool *keep) { if (info->scalarMode) { SArray *colRanges = info->sclCtx.fltSclRange; for (int32_t i = 0; i < taosArrayGetSize(colRanges); ++i) { @@ -3798,12 +4055,18 @@ bool filterRangeExecute(SFilterInfo *info, SColumnDataAgg *pDataStatis, int32_t if (foundCol) { SColumnDataAgg *pAgg = &pDataStatis[j]; SArray *points = taosArrayInit(2, sizeof(SFltSclPoint)); - fltSclBuildRangeFromBlockSma(colRange, pAgg, numOfRows, points); + if (NULL == points) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + FLT_ERR_RET(fltSclBuildRangeFromBlockSma(colRange, pAgg, numOfRows, points)); qDebug("column data agg: nulls %d, rows %d, max %" PRId64 " min %" PRId64, pAgg->numOfNull, numOfRows, pAgg->max, pAgg->min); SArray *merged = taosArrayInit(8, sizeof(SFltSclPoint)); - fltSclIntersect(points, colRange->points, merged); + if (NULL == merged) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + FLT_ERR_RET(fltSclIntersect(points, colRange->points, merged)); bool isIntersect = taosArrayGetSize(merged) != 0; qDebug("filter range execute, scalar mode, column range found. colId: %d colName: %s has overlap: %d", colRange->colNode->colId, colRange->colNode->colName, isIntersect); @@ -3811,19 +4074,23 @@ bool filterRangeExecute(SFilterInfo *info, SColumnDataAgg *pDataStatis, int32_t taosArrayDestroy(merged); taosArrayDestroy(points); if (!isIntersect) { - return false; + *keep = false; + FLT_RET(TSDB_CODE_SUCCESS); } } } - return true; + *keep = true; + FLT_RET(TSDB_CODE_SUCCESS); } if (FILTER_EMPTY_RES(info)) { - return false; + *keep = false; + FLT_RET(TSDB_CODE_SUCCESS); } if (FILTER_ALL_RES(info)) { - return true; + *keep = true; + FLT_RET(TSDB_CODE_SUCCESS); } bool ret = true; @@ -3895,17 +4162,19 @@ bool filterRangeExecute(SFilterInfo *info, SColumnDataAgg *pDataStatis, int32_t } if (!ret) { - return ret; + *keep = ret; + FLT_RET(TSDB_CODE_SUCCESS); } } - return ret; + *keep = ret; + FLT_RET(TSDB_CODE_SUCCESS); } int32_t filterGetTimeRangeImpl(SFilterInfo *info, STimeWindow *win, bool *isStrict) { SFilterRange ra = {0}; - SFilterRangeCtx *prev = filterInitRangeCtx(TSDB_DATA_TYPE_TIMESTAMP, FLT_OPTION_TIMESTAMP); - SFilterRangeCtx *tmpc = filterInitRangeCtx(TSDB_DATA_TYPE_TIMESTAMP, FLT_OPTION_TIMESTAMP); + SFilterRangeCtx *prev = NULL; + SFilterRangeCtx *tmpc = NULL; SFilterRangeCtx *cur = NULL; int32_t num = 0; int32_t optr = 0; @@ -3913,6 +4182,8 @@ int32_t filterGetTimeRangeImpl(SFilterInfo *info, STimeWindow *win, bool *isStri bool empty = false, all = false; uint32_t emptyGroups = 0; + FLT_ERR_JRET(filterInitRangeCtx(TSDB_DATA_TYPE_TIMESTAMP, FLT_OPTION_TIMESTAMP, &prev)); + FLT_ERR_JRET(filterInitRangeCtx(TSDB_DATA_TYPE_TIMESTAMP, FLT_OPTION_TIMESTAMP, &tmpc)); for (uint32_t i = 0; i < info->groupNum; ++i) { SFilterGroup *group = &info->groups[i]; if (group->unitNum > 1) { @@ -3930,7 +4201,7 @@ int32_t filterGetTimeRangeImpl(SFilterInfo *info, STimeWindow *win, bool *isStri uint8_t raOptr = FILTER_UNIT_OPTR(unit); - filterAddRangeOptr(cur, raOptr, LOGIC_COND_TYPE_AND, &empty, NULL); + FLT_ERR_JRET(filterAddRangeOptr(cur, raOptr, LOGIC_COND_TYPE_AND, &empty, NULL)); if (empty) { emptyGroups++; } @@ -3939,7 +4210,7 @@ int32_t filterGetTimeRangeImpl(SFilterInfo *info, STimeWindow *win, bool *isStri continue; } - filterAddUnitRange(info, unit, cur, optr); + FLT_ERR_JRET(filterAddUnitRange(info, unit, cur, optr)); } if (empty) { @@ -3952,8 +4223,8 @@ int32_t filterGetTimeRangeImpl(SFilterInfo *info, STimeWindow *win, bool *isStri } if (group->unitNum > 1) { - filterSourceRangeFromCtx(prev, cur, LOGIC_COND_TYPE_OR, &empty, &all); - filterResetRangeCtx(cur); + FLT_ERR_JRET(filterSourceRangeFromCtx(prev, cur, LOGIC_COND_TYPE_OR, &empty, &all)); + FLT_ERR_JRET(filterResetRangeCtx(cur)); if (all) { break; } @@ -3965,7 +4236,7 @@ int32_t filterGetTimeRangeImpl(SFilterInfo *info, STimeWindow *win, bool *isStri if (prev->notnull) { *win = TSWINDOW_INITIALIZER; } else { - filterGetRangeNum(prev, &num); + FLT_ERR_JRET(filterGetRangeNum(prev, &num)); FLT_CHK_JMP(num < 1); @@ -3975,7 +4246,7 @@ int32_t filterGetTimeRangeImpl(SFilterInfo *info, STimeWindow *win, bool *isStri } SFilterRange tra; - filterGetRangeRes(prev, &tra); + FLT_ERR_JRET(filterGetRangeRes(prev, &tra)); win->skey = tra.s; win->ekey = tra.e; if (FILTER_GET_FLAG(tra.sflag, RANGE_FLG_EXCLUDE)) { @@ -3986,8 +4257,8 @@ int32_t filterGetTimeRangeImpl(SFilterInfo *info, STimeWindow *win, bool *isStri } } - filterFreeRangeCtx(prev); - filterFreeRangeCtx(tmpc); + (void)filterFreeRangeCtx(prev); // No need to handle the return value. + (void)filterFreeRangeCtx(tmpc); // No need to handle the return value. qDebug("qFilter time range:[%" PRId64 "]-[%" PRId64 "]", win->skey, win->ekey); return TSDB_CODE_SUCCESS; @@ -3996,8 +4267,8 @@ _return: *win = TSWINDOW_DESC_INITIALIZER; - filterFreeRangeCtx(prev); - filterFreeRangeCtx(tmpc); + (void)filterFreeRangeCtx(prev); // No need to handle the return value. + (void)filterFreeRangeCtx(tmpc); // No need to handle the return value. qDebug("qFilter time range:[%" PRId64 "]-[%" PRId64 "]", win->skey, win->ekey); @@ -4009,9 +4280,9 @@ static int32_t fltSclGetTimeStampDatum(SFltSclPoint *point, SFltSclDatum *d) { d->kind = FLT_SCL_DATUM_KIND_INT64; if (point->val.kind == FLT_SCL_DATUM_KIND_MAX) { - getDataMax(point->val.type.type, &(d->i)); + (void)getDataMax(point->val.type.type, &(d->i)); // No need to handle the return value. } else if (point->val.kind == FLT_SCL_DATUM_KIND_MIN) { - getDataMin(point->val.type.type, &(d->i)); + (void)getDataMin(point->val.type.type, &(d->i)); // No need to handle the return value. } else if (point->val.kind == FLT_SCL_DATUM_KIND_INT64) { if (point->excl) { if (point->start) { @@ -4044,6 +4315,7 @@ static int32_t fltSclGetTimeStampDatum(SFltSclPoint *point, SFltSclDatum *d) { } } else { qError("not supported type %d when get datum from point", d->type.type); + return TSDB_CODE_FAILED; } return TSDB_CODE_SUCCESS; } @@ -4054,7 +4326,7 @@ int32_t filterGetTimeRange(SNode *pNode, STimeWindow *win, bool *isStrict) { *isStrict = true; - FLT_ERR_RET(filterInitFromNode(pNode, &info, FLT_OPTION_NO_REWRITE | FLT_OPTION_TIMESTAMP)); + FLT_ERR_JRET(filterInitFromNode(pNode, &info, FLT_OPTION_NO_REWRITE | FLT_OPTION_TIMESTAMP)); if (info->scalarMode) { SArray *colRanges = info->sclCtx.fltSclRange; @@ -4067,8 +4339,8 @@ int32_t filterGetTimeRange(SNode *pNode, STimeWindow *win, bool *isStrict) { SFltSclPoint *endPt = taosArrayGet(points, 1); SFltSclDatum start; SFltSclDatum end; - fltSclGetTimeStampDatum(startPt, &start); - fltSclGetTimeStampDatum(endPt, &end); + FLT_ERR_JRET(fltSclGetTimeStampDatum(startPt, &start)); + FLT_ERR_JRET(fltSclGetTimeStampDatum(endPt, &end)); win->skey = start.i; win->ekey = end.i; *isStrict = true; @@ -4105,6 +4377,9 @@ int32_t filterConverNcharColumns(SFilterInfo *info, int32_t rows, bool *gotNchar nfi.desc = fi->desc; int32_t bytes = FILTER_GET_COL_FIELD_SIZE(fi); nfi.data = taosMemoryMalloc(rows * bytes); + if (nfi.data == NULL) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } int32_t bufSize = bytes - VARSTR_HEADER_SIZE; for (int32_t j = 0; j < rows; ++j) { char *src = FILTER_GET_COL_FIELD_DATA(fi, j); @@ -4117,7 +4392,7 @@ int32_t filterConverNcharColumns(SFilterInfo *info, int32_t rows, bool *gotNchar if (k == varSrcLen) { /* NULL */ varDataLen(dst) = (VarDataLenT)varSrcLen; - varDataCopy(dst, src); + (void)varDataCopy(dst, src); continue; } bool ret = taosMbsToUcs4(varDataVal(src), varDataLen(src), (TdUcs4 *)varDataVal(dst), bufSize, &len); @@ -4135,7 +4410,7 @@ int32_t filterConverNcharColumns(SFilterInfo *info, int32_t rows, bool *gotNchar } if (*gotNchar) { - filterUpdateComUnits(info); + FLT_ERR_RET(filterUpdateComUnits(info)); } return TSDB_CODE_SUCCESS; @@ -4409,69 +4684,97 @@ int32_t fltSclBuildRangePoints(SFltSclOperator *oper, SArray *points) { switch (oper->type) { case OP_TYPE_GREATER_THAN: { SFltSclDatum start; - fltSclBuildDatumFromValueNode(&start, oper->valNode); + FLT_ERR_RET(fltSclBuildDatumFromValueNode(&start, oper->valNode)); SFltSclPoint startPt = {.start = true, .excl = true, .val = start}; SFltSclDatum end = {.kind = FLT_SCL_DATUM_KIND_MAX, .type = oper->colNode->node.resType}; SFltSclPoint endPt = {.start = false, .excl = false, .val = end}; - taosArrayPush(points, &startPt); - taosArrayPush(points, &endPt); + if (NULL == taosArrayPush(points, &startPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + if (NULL == taosArrayPush(points, &endPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } break; } case OP_TYPE_GREATER_EQUAL: { SFltSclDatum start; - fltSclBuildDatumFromValueNode(&start, oper->valNode); + FLT_ERR_RET(fltSclBuildDatumFromValueNode(&start, oper->valNode)); SFltSclPoint startPt = {.start = true, .excl = false, .val = start}; SFltSclDatum end = {.kind = FLT_SCL_DATUM_KIND_MAX, .type = oper->colNode->node.resType}; SFltSclPoint endPt = {.start = false, .excl = false, .val = end}; - taosArrayPush(points, &startPt); - taosArrayPush(points, &endPt); + if (NULL == taosArrayPush(points, &startPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + if (NULL == taosArrayPush(points, &endPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } break; } case OP_TYPE_LOWER_THAN: { SFltSclDatum end; - fltSclBuildDatumFromValueNode(&end, oper->valNode); + FLT_ERR_RET(fltSclBuildDatumFromValueNode(&end, oper->valNode)); SFltSclPoint endPt = {.start = false, .excl = true, .val = end}; SFltSclDatum start = {.kind = FLT_SCL_DATUM_KIND_MIN, .type = oper->colNode->node.resType}; SFltSclPoint startPt = {.start = true, .excl = false, .val = start}; - taosArrayPush(points, &startPt); - taosArrayPush(points, &endPt); + if (NULL == taosArrayPush(points, &startPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + if (NULL == taosArrayPush(points, &endPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } break; } case OP_TYPE_LOWER_EQUAL: { SFltSclDatum end; - fltSclBuildDatumFromValueNode(&end, oper->valNode); + FLT_ERR_RET(fltSclBuildDatumFromValueNode(&end, oper->valNode)); SFltSclPoint endPt = {.start = false, .excl = false, .val = end}; SFltSclDatum start = {.kind = FLT_SCL_DATUM_KIND_MIN, .type = oper->colNode->node.resType}; SFltSclPoint startPt = {.start = true, .excl = false, .val = start}; - taosArrayPush(points, &startPt); - taosArrayPush(points, &endPt); + if (NULL == taosArrayPush(points, &startPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + if (NULL == taosArrayPush(points, &endPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } break; } case OP_TYPE_EQUAL: { SFltSclDatum valDatum; - fltSclBuildDatumFromValueNode(&valDatum, oper->valNode); + FLT_ERR_RET(fltSclBuildDatumFromValueNode(&valDatum, oper->valNode)); SFltSclPoint startPt = {.start = true, .excl = false, .val = valDatum}; SFltSclPoint endPt = {.start = false, .excl = false, .val = valDatum}; - taosArrayPush(points, &startPt); - taosArrayPush(points, &endPt); + if (NULL == taosArrayPush(points, &startPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + if (NULL == taosArrayPush(points, &endPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } break; } case OP_TYPE_NOT_EQUAL: { SFltSclDatum valDatum; - fltSclBuildDatumFromValueNode(&valDatum, oper->valNode); + FLT_ERR_RET(fltSclBuildDatumFromValueNode(&valDatum, oper->valNode)); { SFltSclDatum start = {.kind = FLT_SCL_DATUM_KIND_MIN, .type = oper->colNode->node.resType}; SFltSclPoint startPt = {.start = true, .excl = false, .val = start}; SFltSclPoint endPt = {.start = false, .excl = true, .val = valDatum}; - taosArrayPush(points, &startPt); - taosArrayPush(points, &endPt); + if (NULL == taosArrayPush(points, &startPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + if (NULL == taosArrayPush(points, &endPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } } { SFltSclPoint startPt = {.start = true, .excl = true, .val = valDatum}; SFltSclDatum end = {.kind = FLT_SCL_DATUM_KIND_MAX, .type = oper->colNode->node.resType}; SFltSclPoint endPt = {.start = false, .excl = false, .val = end}; - taosArrayPush(points, &startPt); - taosArrayPush(points, &endPt); + if (NULL == taosArrayPush(points, &startPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + if (NULL == taosArrayPush(points, &endPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } } break; } @@ -4479,8 +4782,12 @@ int32_t fltSclBuildRangePoints(SFltSclOperator *oper, SArray *points) { SFltSclDatum nullDatum = {.kind = FLT_SCL_DATUM_KIND_NULL}; SFltSclPoint startPt = {.start = true, .excl = false, .val = nullDatum}; SFltSclPoint endPt = {.start = false, .excl = false, .val = nullDatum}; - taosArrayPush(points, &startPt); - taosArrayPush(points, &endPt); + if (NULL == taosArrayPush(points, &startPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + if (NULL == taosArrayPush(points, &endPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } break; } case OP_TYPE_IS_NOT_NULL: { @@ -4488,8 +4795,12 @@ int32_t fltSclBuildRangePoints(SFltSclOperator *oper, SArray *points) { SFltSclPoint startPt = {.start = true, .excl = false, .val = minDatum}; SFltSclDatum maxDatum = {.kind = FLT_SCL_DATUM_KIND_MAX, .type = oper->colNode->node.resType}; SFltSclPoint endPt = {.start = false, .excl = false, .val = maxDatum}; - taosArrayPush(points, &startPt); - taosArrayPush(points, &endPt); + if (NULL == taosArrayPush(points, &startPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + if (NULL == taosArrayPush(points, &endPt)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } break; } default: { @@ -4505,12 +4816,19 @@ int32_t fltSclProcessCNF(SArray *sclOpListCNF, SArray *colRangeList) { size_t sz = taosArrayGetSize(sclOpListCNF); for (int32_t i = 0; i < sz; ++i) { SFltSclOperator *sclOper = taosArrayGet(sclOpListCNF, i); - SFltSclColumnRange *colRange = fltSclGetOrCreateColumnRange(sclOper->colNode, colRangeList); + SFltSclColumnRange *colRange = NULL; + FLT_ERR_RET(fltSclGetOrCreateColumnRange(sclOper->colNode, colRangeList, &colRange)); SArray *points = taosArrayInit(4, sizeof(SFltSclPoint)); - fltSclBuildRangePoints(sclOper, points); + if (NULL == points) { + FLT_ERR_RET(terrno); + } + FLT_ERR_RET(fltSclBuildRangePoints(sclOper, points)); if (taosArrayGetSize(colRange->points) != 0) { SArray *merged = taosArrayInit(4, sizeof(SFltSclPoint)); - int32_t code = fltSclIntersect(colRange->points, points, merged); + if (NULL == merged) { + FLT_ERR_RET(terrno); + } + FLT_ERR_RET(fltSclIntersect(colRange->points, points, merged)); taosArrayDestroy(colRange->points); taosArrayDestroy(points); colRange->points = merged; @@ -4556,7 +4874,15 @@ static int32_t fltSclCollectOperatorFromNode(SNode *pNode, SArray *sclOpList) { SFltSclOperator sclOp = {.colNode = (SColumnNode *)nodesCloneNode(pOper->pLeft), .valNode = (SValueNode *)nodesCloneNode(pOper->pRight), .type = pOper->opType}; - taosArrayPush(sclOpList, &sclOp); + if (NULL == sclOp.colNode) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + if (NULL == sclOp.valNode) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + if (NULL == taosArrayPush(sclOpList, &sclOp)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } } return TSDB_CODE_SUCCESS; @@ -4577,24 +4903,32 @@ static int32_t fltSclCollectOperatorsFromLogicCond(SNode *pNode, SArray *sclOpLi return TSDB_CODE_SUCCESS; } } - FOREACH(pExpr, pLogicCond->pParameterList) { fltSclCollectOperatorFromNode(pExpr, sclOpList); } + FOREACH(pExpr, pLogicCond->pParameterList) { + FLT_ERR_RET(fltSclCollectOperatorFromNode(pExpr, sclOpList)); + } return TSDB_CODE_SUCCESS; } static int32_t fltSclCollectOperators(SNode *pNode, SArray *sclOpList) { if (nodeType(pNode) == QUERY_NODE_OPERATOR) { - fltSclCollectOperatorFromNode(pNode, sclOpList); + FLT_ERR_RET(fltSclCollectOperatorFromNode(pNode, sclOpList)); } else if (nodeType(pNode) == QUERY_NODE_LOGIC_CONDITION) { - fltSclCollectOperatorsFromLogicCond(pNode, sclOpList); + FLT_ERR_RET(fltSclCollectOperatorsFromLogicCond(pNode, sclOpList)); } return TSDB_CODE_SUCCESS; } int32_t fltOptimizeNodes(SFilterInfo *pInfo, SNode **pNode, SFltTreeStat *pStat) { SArray *sclOpList = taosArrayInit(16, sizeof(SFltSclOperator)); - fltSclCollectOperators(*pNode, sclOpList); + if (NULL == sclOpList) { + FLT_ERR_RET(terrno); + } + FLT_ERR_RET(fltSclCollectOperators(*pNode, sclOpList)); SArray *colRangeList = taosArrayInit(16, sizeof(SFltSclColumnRange)); - fltSclProcessCNF(sclOpList, colRangeList); + if (NULL == colRangeList) { + FLT_ERR_RET(terrno); + } + FLT_ERR_RET(fltSclProcessCNF(sclOpList, colRangeList)); pInfo->sclCtx.fltSclRange = colRangeList; for (int32_t i = 0; i < taosArrayGetSize(sclOpList); ++i) { @@ -4716,7 +5050,12 @@ int32_t filterExecute(SFilterInfo *info, SSDataBlock *pSrc, SColumnInfoData **p, if (info->scalarMode) { SArray *pList = taosArrayInit(1, POINTER_BYTES); - taosArrayPush(pList, &pSrc); + if (NULL == pList) { + FLT_ERR_RET(terrno); + } + if (NULL == taosArrayPush(pList, &pSrc)) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } code = scalarCalculate(info->sclCtx.node, pList, &output); taosArrayDestroy(pList); @@ -4743,7 +5082,8 @@ int32_t filterExecute(SFilterInfo *info, SSDataBlock *pSrc, SColumnInfoData **p, return TSDB_CODE_APP_ERROR; } - bool keepAll = (*info->func)(info, pSrc->info.rows, *p, statis, numOfCols, &output.numOfQualified); + bool keepAll = false; + FLT_ERR_RET((info->func)(info, pSrc->info.rows, *p, statis, numOfCols, &output.numOfQualified, &keepAll)); // todo this should be return during filter procedure if (keepAll) { @@ -4813,7 +5153,7 @@ EConditionType filterClassifyCondition(SNode *pNode) { : (cxt.hasTagIndexCol ? COND_TYPE_TAG_INDEX : COND_TYPE_TAG))); } -bool filterIsMultiTableColsCond(SNode *pCond) { +int32_t filterIsMultiTableColsCond(SNode *pCond, bool *res) { SNodeList *pCondCols = nodesMakeList(); int32_t code = nodesCollectColumnsFromNode(pCond, NULL, COLLECT_COL_TYPE_ALL, &pCondCols); if (code == TSDB_CODE_SUCCESS) { @@ -4824,13 +5164,15 @@ bool filterIsMultiTableColsCond(SNode *pCond) { if (strcmp(((SColumnNode *)pColNode)->dbName, pFirstCol->dbName) != 0 || strcmp(((SColumnNode *)pColNode)->tableAlias, pFirstCol->tableAlias) != 0) { nodesDestroyList(pCondCols); - return true; + *res = true; + return TSDB_CODE_SUCCESS; } } } nodesDestroyList(pCondCols); } - return false; + *res = false; + return code; } static int32_t partitionLogicCond(SNode **pCondition, SNode **pPrimaryKeyCond, SNode **pTagIndexCond, SNode **pTagCond, @@ -4845,7 +5187,12 @@ static int32_t partitionLogicCond(SNode **pCondition, SNode **pPrimaryKeyCond, S SNodeList *pOtherConds = NULL; SNode *pCond = NULL; FOREACH(pCond, pLogicCond->pParameterList) { - if (filterIsMultiTableColsCond(pCond)) { + bool result = false; + code = filterIsMultiTableColsCond(pCond, &result); + if (TSDB_CODE_SUCCESS != code) { + break; + } + if (result) { if (NULL != pOtherCond) { code = nodesListMakeAppend(&pOtherConds, nodesCloneNode(pCond)); } @@ -4936,7 +5283,9 @@ int32_t filterPartitionCond(SNode **pCondition, SNode **pPrimaryKeyCond, SNode * } bool needOutput = false; - if (filterIsMultiTableColsCond(*pCondition)) { + bool result = false; + FLT_ERR_RET(filterIsMultiTableColsCond(*pCondition, &result)); + if (result) { if (NULL != pOtherCond) { *pOtherCond = *pCondition; needOutput = true; diff --git a/source/libs/scalar/src/scalar.c b/source/libs/scalar/src/scalar.c index 8f9ea4d36c..346bbb2811 100644 --- a/source/libs/scalar/src/scalar.c +++ b/source/libs/scalar/src/scalar.c @@ -72,9 +72,16 @@ int32_t sclConvertValueToSclParam(SValueNode *pValueNode, SScalarParam *out, int return code; } - colDataSetVal(in.columnData, 0, nodesGetValueFromNode(pValueNode), false); + code = colDataSetVal(in.columnData, 0, nodesGetValueFromNode(pValueNode), false); + if (code != TSDB_CODE_SUCCESS) { + return code; + } + + code = colInfoDataEnsureCapacity(out->columnData, 1, true); + if (code != TSDB_CODE_SUCCESS) { + return code; + } - colInfoDataEnsureCapacity(out->columnData, 1, true); code = vectorConvertSingleColImpl(&in, out, overflow, -1, -1); sclFreeParam(&in); @@ -84,6 +91,7 @@ int32_t sclConvertValueToSclParam(SValueNode *pValueNode, SScalarParam *out, int int32_t sclExtendResRows(SScalarParam *pDst, SScalarParam *pSrc, SArray *pBlockList) { SSDataBlock *pb = taosArrayGetP(pBlockList, 0); SScalarParam *pLeft = taosMemoryCalloc(1, sizeof(SScalarParam)); + int32_t code = TSDB_CODE_SUCCESS; if (NULL == pLeft) { sclError("calloc %d failed", (int32_t)sizeof(SScalarParam)); SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); @@ -92,15 +100,16 @@ int32_t sclExtendResRows(SScalarParam *pDst, SScalarParam *pSrc, SArray *pBlockL pLeft->numOfRows = pb->info.rows; if (pDst->numOfRows < pb->info.rows) { - colInfoDataEnsureCapacity(pDst->columnData, pb->info.rows, true); + SCL_ERR_JRET(colInfoDataEnsureCapacity(pDst->columnData, pb->info.rows, true)); } _bin_scalar_fn_t OperatorFn = getBinScalarOperatorFn(OP_TYPE_ASSIGN); - OperatorFn(pLeft, pSrc, pDst, TSDB_ORDER_ASC); + SCL_ERR_JRET(OperatorFn(pLeft, pSrc, pDst, TSDB_ORDER_ASC)); +_return: taosMemoryFree(pLeft); - return TSDB_CODE_SUCCESS; + SCL_RET(code); } int32_t scalarGenerateSetFromList(void **data, void *pNode, uint32_t type) { @@ -116,7 +125,9 @@ int32_t scalarGenerateSetFromList(void **data, void *pNode, uint32_t type) { SNodeListNode *nodeList = (SNodeListNode *)pNode; SListCell *cell = nodeList->pNodeList->pHead; SScalarParam out = {.columnData = taosMemoryCalloc(1, sizeof(SColumnInfoData))}; - + if (out.columnData == NULL) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } int32_t len = 0; void *buf = NULL; @@ -228,7 +239,7 @@ int32_t sclCopyValueNodeValue(SValueNode *pNode, void **res) { SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); } - memcpy(*res, nodesGetValueFromNode(pNode), pNode->node.resType.bytes); + (void)memcpy(*res, nodesGetValueFromNode(pNode), pNode->node.resType.bytes); return TSDB_CODE_SUCCESS; } @@ -343,7 +354,7 @@ int32_t sclInitParam(SNode *node, SScalarParam *param, SScalarCtx *ctx, int32_t if (TSDB_DATA_TYPE_NULL == valueNode->node.resType.type || valueNode->isNull) { colDataSetNULL(param->columnData, 0); } else { - colDataSetVal(param->columnData, 0, nodesGetValueFromNode(valueNode), false); + SCL_ERR_RET(colDataSetVal(param->columnData, 0, nodesGetValueFromNode(valueNode), false)); } break; } @@ -502,23 +513,27 @@ _return: SCL_RET(code); } -int32_t sclGetNodeType(SNode *pNode, SScalarCtx *ctx) { +int32_t sclGetNodeType(SNode *pNode, SScalarCtx *ctx, int32_t *type) { if (NULL == pNode) { - return -1; + *type = -1; + return TSDB_CODE_SUCCESS; } switch ((int)nodeType(pNode)) { case QUERY_NODE_VALUE: { SValueNode *valueNode = (SValueNode *)pNode; - return valueNode->node.resType.type; + *type = valueNode->node.resType.type; + return TSDB_CODE_SUCCESS; } case QUERY_NODE_NODE_LIST: { SNodeListNode *nodeList = (SNodeListNode *)pNode; - return nodeList->node.resType.type; + *type = nodeList->node.resType.type; + return TSDB_CODE_SUCCESS; } case QUERY_NODE_COLUMN: { SColumnNode *colNode = (SColumnNode *)pNode; - return colNode->node.resType.type; + *type = colNode->node.resType.type; + return TSDB_CODE_SUCCESS; } case QUERY_NODE_FUNCTION: case QUERY_NODE_OPERATOR: @@ -526,19 +541,22 @@ int32_t sclGetNodeType(SNode *pNode, SScalarCtx *ctx) { SScalarParam *res = (SScalarParam *)taosHashGet(ctx->pRes, &pNode, POINTER_BYTES); if (NULL == res) { sclError("no result for node, type:%d, node:%p", nodeType(pNode), pNode); - return -1; + SCL_ERR_RET(TSDB_CODE_QRY_INVALID_INPUT); } - return res->columnData->info.type; + *type = (int32_t)(res->columnData->info.type); + return TSDB_CODE_SUCCESS; } } - return -1; + *type = -1; + return TSDB_CODE_SUCCESS; } -void sclSetOperatorValueType(SOperatorNode *node, SScalarCtx *ctx) { +int32_t sclSetOperatorValueType(SOperatorNode *node, SScalarCtx *ctx) { ctx->type.opResType = node->node.resType.type; - ctx->type.selfType = sclGetNodeType(node->pLeft, ctx); - ctx->type.peerType = sclGetNodeType(node->pRight, ctx); + SCL_ERR_RET(sclGetNodeType(node->pLeft, ctx, &(ctx->type.selfType))); + SCL_ERR_RET(sclGetNodeType(node->pRight, ctx, &(ctx->type.peerType))); + SCL_RET(TSDB_CODE_SUCCESS); } int32_t sclInitOperatorParams(SScalarParam **pParams, SOperatorNode *node, SScalarCtx *ctx, int32_t *rowNum) { @@ -555,7 +573,7 @@ int32_t sclInitOperatorParams(SScalarParam **pParams, SOperatorNode *node, SScal SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); } - sclSetOperatorValueType(node, ctx); + SCL_ERR_JRET(sclSetOperatorValueType(node, ctx)); SCL_ERR_JRET(sclInitParam(node->pLeft, ¶mList[0], ctx, rowNum)); if (paramNum > 1) { @@ -603,13 +621,13 @@ int32_t sclWalkCaseWhenList(SScalarCtx *ctx, SNodeList *pList, struct SListCell SCL_ERR_RET(sclGetNodeRes(pWhenThen->pWhen, ctx, &pWhen)); SCL_ERR_RET(sclGetNodeRes(pWhenThen->pThen, ctx, &pThen)); - vectorCompareImpl(pCase, pWhen, pComp, rowIdx, 1, TSDB_ORDER_ASC, OP_TYPE_EQUAL); + SCL_ERR_JRET(vectorCompareImpl(pCase, pWhen, pComp, rowIdx, 1, TSDB_ORDER_ASC, OP_TYPE_EQUAL)); bool *equal = (bool *)colDataGetData(pComp->columnData, rowIdx); if (*equal) { bool isNull = colDataIsNull_s(pThen->columnData, (pThen->numOfRows > 1 ? rowIdx : 0)); char *pData = isNull ? NULL : colDataGetData(pThen->columnData, (pThen->numOfRows > 1 ? rowIdx : 0)); - colDataSetVal(output->columnData, rowIdx, pData, isNull); + SCL_ERR_JRET(colDataSetVal(output->columnData, rowIdx, pData, isNull)); if (0 == rowIdx && 1 == pCase->numOfRows && 1 == pWhen->numOfRows && 1 == pThen->numOfRows && totalRows > 1) { SCL_ERR_JRET(sclExtendResRows(output, output, ctx->pBlockList)); @@ -623,7 +641,7 @@ int32_t sclWalkCaseWhenList(SScalarCtx *ctx, SNodeList *pList, struct SListCell if (pElse) { bool isNull = colDataIsNull_s(pElse->columnData, (pElse->numOfRows > 1 ? rowIdx : 0)); char *pData = isNull ? NULL : colDataGetData(pElse->columnData, (pElse->numOfRows > 1 ? rowIdx : 0)); - colDataSetVal(output->columnData, rowIdx, pData, isNull); + SCL_ERR_JRET(colDataSetVal(output->columnData, rowIdx, pData, isNull)); if (0 == rowIdx && 1 == pCase->numOfRows && 1 == pElse->numOfRows && totalRows > 1) { SCL_ERR_JRET(sclExtendResRows(output, output, ctx->pBlockList)); @@ -633,7 +651,7 @@ int32_t sclWalkCaseWhenList(SScalarCtx *ctx, SNodeList *pList, struct SListCell goto _return; } - colDataSetVal(output->columnData, rowIdx, NULL, true); + SCL_ERR_JRET(colDataSetVal(output->columnData, rowIdx, NULL, true)); if (0 == rowIdx && 1 == pCase->numOfRows && totalRows > 1) { SCL_ERR_JRET(sclExtendResRows(output, output, ctx->pBlockList)); @@ -672,7 +690,7 @@ int32_t sclWalkWhenList(SScalarCtx *ctx, SNodeList *pList, struct SListCell *pCe if (*whenValue) { bool isNull = colDataIsNull_s(pThen->columnData, (pThen->numOfRows > 1 ? rowIdx : 0)); char *pData = isNull ? NULL : colDataGetData(pThen->columnData, (pThen->numOfRows > 1 ? rowIdx : 0)); - colDataSetVal(output->columnData, rowIdx, pData, isNull); + SCL_ERR_JRET(colDataSetVal(output->columnData, rowIdx, pData, isNull)); if (preSingle && 0 == rowIdx && 1 == pWhen->numOfRows && 1 == pThen->numOfRows && totalRows > 1) { SCL_ERR_JRET(sclExtendResRows(output, output, ctx->pBlockList)); @@ -691,7 +709,7 @@ int32_t sclWalkWhenList(SScalarCtx *ctx, SNodeList *pList, struct SListCell *pCe if (pElse) { bool isNull = colDataIsNull_s(pElse->columnData, (pElse->numOfRows > 1 ? rowIdx : 0)); char *pData = isNull ? NULL : colDataGetData(pElse->columnData, (pElse->numOfRows > 1 ? rowIdx : 0)); - colDataSetVal(output->columnData, rowIdx, pData, isNull); + SCL_ERR_JRET(colDataSetVal(output->columnData, rowIdx, pData, isNull)); if (preSingle && 0 == rowIdx && 1 == pElse->numOfRows && totalRows > 1) { SCL_ERR_JRET(sclExtendResRows(output, output, ctx->pBlockList)); @@ -701,7 +719,7 @@ int32_t sclWalkWhenList(SScalarCtx *ctx, SNodeList *pList, struct SListCell *pCe goto _return; } - colDataSetVal(output->columnData, rowIdx, NULL, true); + SCL_ERR_JRET(colDataSetVal(output->columnData, rowIdx, NULL, true)); if (preSingle && 0 == rowIdx && totalRows > 1) { SCL_ERR_JRET(sclExtendResRows(output, output, ctx->pBlockList)); @@ -827,7 +845,7 @@ int32_t sclExecLogic(SLogicConditionNode *node, SScalarCtx *ctx, SScalarParam *o } if (complete) { - colDataSetVal(output->columnData, i, (char *)&value, false); + SCL_ERR_JRET(colDataSetVal(output->columnData, i, (char *)&value, false)); if (value) { numOfQualified++; } @@ -876,9 +894,8 @@ int32_t sclExecOperator(SOperatorNode *node, SScalarCtx *ctx, SScalarParam *outp SScalarParam *pRight = paramNum > 1 ? ¶ms[1] : NULL; terrno = TSDB_CODE_SUCCESS; - OperatorFn(pLeft, pRight, output, TSDB_ORDER_ASC); - code = terrno; - + SCL_ERR_JRET(OperatorFn(pLeft, pRight, output, TSDB_ORDER_ASC)); + SCL_ERR_JRET(terrno); _return: sclFreeParamList(params, paramNum); @@ -928,13 +945,14 @@ int32_t sclExecCaseWhen(SCaseWhenNode *node, SScalarCtx *ctx, SScalarParam *outp } if (pCase) { - vectorCompare(pCase, pWhen, &comp, TSDB_ORDER_ASC, OP_TYPE_EQUAL); + SCL_ERR_JRET(vectorCompare(pCase, pWhen, &comp, TSDB_ORDER_ASC, OP_TYPE_EQUAL)); for (int32_t i = 0; i < rowNum; ++i) { bool *equal = (bool *)colDataGetData(comp.columnData, (comp.numOfRows > 1 ? i : 0)); if (*equal) { - colDataSetVal(output->columnData, i, colDataGetData(pThen->columnData, (pThen->numOfRows > 1 ? i : 0)), - colDataIsNull_s(pThen->columnData, (pThen->numOfRows > 1 ? i : 0))); + SCL_ERR_JRET(colDataSetVal(output->columnData, i, + colDataGetData(pThen->columnData, (pThen->numOfRows > 1 ? i : 0)), + colDataIsNull_s(pThen->columnData, (pThen->numOfRows > 1 ? i : 0)))); if (0 == i && 1 == pCase->numOfRows && 1 == pWhen->numOfRows && 1 == pThen->numOfRows && rowNum > 1) { SCL_ERR_JRET(sclExtendResRows(output, output, ctx->pBlockList)); break; @@ -951,8 +969,9 @@ int32_t sclExecCaseWhen(SCaseWhenNode *node, SScalarCtx *ctx, SScalarParam *outp for (int32_t i = 0; i < rowNum; ++i) { bool *whenValue = (bool *)colDataGetData(pWhen->columnData, (pWhen->numOfRows > 1 ? i : 0)); if (*whenValue) { - colDataSetVal(output->columnData, i, colDataGetData(pThen->columnData, (pThen->numOfRows > 1 ? i : 0)), - colDataIsNull_s(pThen->columnData, (pThen->numOfRows > 1 ? i : 0))); + SCL_ERR_JRET(colDataSetVal(output->columnData, i, + colDataGetData(pThen->columnData, (pThen->numOfRows > 1 ? i : 0)), + colDataIsNull_s(pThen->columnData, (pThen->numOfRows > 1 ? i : 0)))); if (0 == i && 1 == pWhen->numOfRows && 1 == pThen->numOfRows && rowNum > 1) { SCL_ERR_JRET(sclExtendResRows(output, output, ctx->pBlockList)); break; @@ -1063,42 +1082,34 @@ static uint8_t sclGetOpValueNodeTsPrecision(SNode *pLeft, SNode *pRight) { return 0; } -int32_t sclConvertOpValueNodeTs(SOperatorNode *node, SScalarCtx *ctx) { - int32_t code = 0; +int32_t sclConvertOpValueNodeTs(SOperatorNode *node) { if (node->pLeft && SCL_IS_VAR_VALUE_NODE(node->pLeft)) { if (node->pRight && (TSDB_DATA_TYPE_TIMESTAMP == ((SExprNode *)node->pRight)->resType.type)) { - SCL_ERR_JRET( + SCL_ERR_RET( sclConvertToTsValueNode(sclGetOpValueNodeTsPrecision(node->pLeft, node->pRight), (SValueNode *)node->pLeft)); } } else if (node->pRight && SCL_IS_NOTNULL_CONST_NODE(node->pRight)) { if (node->pLeft && (TSDB_DATA_TYPE_TIMESTAMP == ((SExprNode *)node->pLeft)->resType.type)) { if (SCL_IS_VAR_VALUE_NODE(node->pRight)) { - SCL_ERR_JRET(sclConvertToTsValueNode(sclGetOpValueNodeTsPrecision(node->pLeft, node->pRight), + SCL_ERR_RET(sclConvertToTsValueNode(sclGetOpValueNodeTsPrecision(node->pLeft, node->pRight), (SValueNode *)node->pRight)); } else if (QUERY_NODE_NODE_LIST == node->pRight->type) { SNode *pNode; FOREACH(pNode, ((SNodeListNode *)node->pRight)->pNodeList) { if (SCL_IS_VAR_VALUE_NODE(pNode)) { - SCL_ERR_JRET( + SCL_ERR_RET( sclConvertToTsValueNode(sclGetOpValueNodeTsPrecision(node->pLeft, pNode), (SValueNode *)pNode)); } } } } } - return TSDB_CODE_SUCCESS; - -_return: - - ctx->code = code; - return DEAL_RES_ERROR; } -int32_t sclConvertCaseWhenValueNodeTs(SCaseWhenNode *node, SScalarCtx *ctx) { - int32_t code = 0; +int32_t sclConvertCaseWhenValueNodeTs(SCaseWhenNode *node) { if (NULL == node->pCase) { return TSDB_CODE_SUCCESS; } @@ -1108,7 +1119,7 @@ int32_t sclConvertCaseWhenValueNodeTs(SCaseWhenNode *node, SScalarCtx *ctx) { FOREACH(pNode, node->pWhenThenList) { SExprNode *pExpr = (SExprNode *)((SWhenThenNode *)pNode)->pWhen; if (TSDB_DATA_TYPE_TIMESTAMP == pExpr->resType.type) { - SCL_ERR_JRET(sclConvertToTsValueNode(pExpr->resType.precision, (SValueNode *)node->pCase)); + SCL_ERR_RET(sclConvertToTsValueNode(pExpr->resType.precision, (SValueNode *)node->pCase)); break; } } @@ -1116,18 +1127,13 @@ int32_t sclConvertCaseWhenValueNodeTs(SCaseWhenNode *node, SScalarCtx *ctx) { SNode *pNode; FOREACH(pNode, node->pWhenThenList) { if (SCL_IS_VAR_VALUE_NODE(((SWhenThenNode *)pNode)->pWhen)) { - SCL_ERR_JRET(sclConvertToTsValueNode(((SExprNode *)node->pCase)->resType.precision, + SCL_ERR_RET(sclConvertToTsValueNode(((SExprNode *)node->pCase)->resType.precision, (SValueNode *)((SWhenThenNode *)pNode)->pWhen)); } } } return TSDB_CODE_SUCCESS; - -_return: - - ctx->code = code; - return DEAL_RES_ERROR; } EDealRes sclRewriteNonConstOperator(SNode **pNode, SScalarCtx *ctx) { @@ -1213,7 +1219,7 @@ EDealRes sclRewriteFunction(SNode **pNode, SScalarCtx *ctx) { res->translate = true; - strcpy(res->node.aliasName, node->node.aliasName); + (void)strcpy(res->node.aliasName, node->node.aliasName); res->node.resType.type = output.columnData->info.type; res->node.resType.bytes = output.columnData->info.bytes; res->node.resType.scale = output.columnData->info.scale; @@ -1225,14 +1231,33 @@ EDealRes sclRewriteFunction(SNode **pNode, SScalarCtx *ctx) { if (type == TSDB_DATA_TYPE_JSON) { int32_t len = getJsonValueLen(output.columnData->pData); res->datum.p = taosMemoryCalloc(len, 1); - memcpy(res->datum.p, output.columnData->pData, len); + if (NULL == res->datum.p) { + sclError("calloc %d failed", len); + sclFreeParam(&output); + nodesDestroyNode((SNode *)res); + ctx->code = TSDB_CODE_OUT_OF_MEMORY; + return DEAL_RES_ERROR; + } + (void)memcpy(res->datum.p, output.columnData->pData, len); } else if (IS_VAR_DATA_TYPE(type)) { // res->datum.p = taosMemoryCalloc(res->node.resType.bytes + VARSTR_HEADER_SIZE + 1, 1); res->datum.p = taosMemoryCalloc(varDataTLen(output.columnData->pData) + 1, 1); + if (NULL == res->datum.p) { + sclError("calloc %d failed", (int)(varDataTLen(output.columnData->pData) + 1)); + sclFreeParam(&output); + nodesDestroyNode((SNode *)res); + ctx->code = TSDB_CODE_OUT_OF_MEMORY; + return DEAL_RES_ERROR; + } res->node.resType.bytes = varDataTLen(output.columnData->pData); - memcpy(res->datum.p, output.columnData->pData, varDataTLen(output.columnData->pData)); + (void)memcpy(res->datum.p, output.columnData->pData, varDataTLen(output.columnData->pData)); } else { - nodesSetValueNodeValue(res, output.columnData->pData); + ctx->code = nodesSetValueNodeValue(res, output.columnData->pData); + if (ctx->code) { + sclFreeParam(&output); + nodesDestroyNode((SNode *)res); + return DEAL_RES_ERROR; + } } } @@ -1269,13 +1294,17 @@ EDealRes sclRewriteLogic(SNode **pNode, SScalarCtx *ctx) { res->node.resType = node->node.resType; res->translate = true; - strcpy(res->node.aliasName, node->node.aliasName); + (void)strcpy(res->node.aliasName, node->node.aliasName); int32_t type = output.columnData->info.type; if (IS_VAR_DATA_TYPE(type)) { res->datum.p = output.columnData->pData; output.columnData->pData = NULL; } else { - nodesSetValueNodeValue(res, output.columnData->pData); + ctx->code = nodesSetValueNodeValue(res, output.columnData->pData); + if (ctx->code) { + sclFreeParam(&output); + return DEAL_RES_ERROR; + } } nodesDestroyNode(*pNode); @@ -1288,7 +1317,10 @@ EDealRes sclRewriteLogic(SNode **pNode, SScalarCtx *ctx) { EDealRes sclRewriteOperator(SNode **pNode, SScalarCtx *ctx) { SOperatorNode *node = (SOperatorNode *)*pNode; - SCL_ERR_RET(sclConvertOpValueNodeTs(node, ctx)); + ctx->code = sclConvertOpValueNodeTs(node); + if (ctx->code) { + return DEAL_RES_ERROR; + } if ((!SCL_IS_CONST_NODE(node->pLeft)) || (!SCL_IS_CONST_NODE(node->pRight))) { return sclRewriteNonConstOperator(pNode, ctx); @@ -1311,7 +1343,7 @@ EDealRes sclRewriteOperator(SNode **pNode, SScalarCtx *ctx) { res->translate = true; - strcpy(res->node.aliasName, node->node.aliasName); + (void)strcpy(res->node.aliasName, node->node.aliasName); res->node.resType = node->node.resType; if (colDataIsNull_s(output.columnData, 0)) { res->isNull = true; @@ -1322,7 +1354,11 @@ EDealRes sclRewriteOperator(SNode **pNode, SScalarCtx *ctx) { res->datum.p = output.columnData->pData; output.columnData->pData = NULL; } else { - nodesSetValueNodeValue(res, output.columnData->pData); + ctx->code = nodesSetValueNodeValue(res, output.columnData->pData); + if (ctx->code) { + sclFreeParam(&output); + return DEAL_RES_ERROR; + } } } @@ -1336,7 +1372,10 @@ EDealRes sclRewriteOperator(SNode **pNode, SScalarCtx *ctx) { EDealRes sclRewriteCaseWhen(SNode **pNode, SScalarCtx *ctx) { SCaseWhenNode *node = (SCaseWhenNode *)*pNode; - SCL_ERR_RET(sclConvertCaseWhenValueNodeTs(node, ctx)); + ctx->code = sclConvertCaseWhenValueNodeTs(node); + if (ctx->code) { + return DEAL_RES_ERROR; + } if ((!SCL_IS_CONST_NODE(node->pCase)) || (!SCL_IS_CONST_NODE(node->pElse))) { return DEAL_RES_CONTINUE; @@ -1367,7 +1406,7 @@ EDealRes sclRewriteCaseWhen(SNode **pNode, SScalarCtx *ctx) { res->translate = true; - strcpy(res->node.aliasName, node->node.aliasName); + (void)strcpy(res->node.aliasName, node->node.aliasName); res->node.resType = node->node.resType; if (colDataIsNull_s(output.columnData, 0)) { res->isNull = true; @@ -1376,9 +1415,21 @@ EDealRes sclRewriteCaseWhen(SNode **pNode, SScalarCtx *ctx) { int32_t type = output.columnData->info.type; if (IS_VAR_DATA_TYPE(type)) { // todo refactor res->datum.p = taosMemoryCalloc(varDataTLen(output.columnData->pData) + 1, sizeof(char)); // add \0 to the end for print json value - memcpy(res->datum.p, output.columnData->pData, varDataTLen(output.columnData->pData)); + if (NULL == res->datum.p) { + sclError("calloc %d failed", (int)(varDataTLen(output.columnData->pData) + 1)); + sclFreeParam(&output); + nodesDestroyNode((SNode *)res); + ctx->code = TSDB_CODE_OUT_OF_MEMORY; + return DEAL_RES_ERROR; + } + (void)memcpy(res->datum.p, output.columnData->pData, varDataTLen(output.columnData->pData)); } else { - nodesSetValueNodeValue(res, output.columnData->pData); + ctx->code = nodesSetValueNodeValue(res, output.columnData->pData); + if (ctx->code) { + sclFreeParam(&output); + nodesDestroyNode((SNode *)res); + return DEAL_RES_ERROR; + } } } @@ -1513,11 +1564,14 @@ EDealRes sclWalkTarget(SNode *pNode, SScalarCtx *ctx) { return DEAL_RES_ERROR; } - colDataAssign(col, res->columnData, res->numOfRows, NULL); + ctx->code = colDataAssign(col, res->columnData, res->numOfRows, NULL); + if (ctx->code) { + return DEAL_RES_ERROR; + } block->info.rows = res->numOfRows; sclFreeParam(res); - taosHashRemove(ctx->pRes, (void *)&target->pExpr, POINTER_BYTES); + (void)taosHashRemove(ctx->pRes, (void *)&target->pExpr, POINTER_BYTES); return DEAL_RES_CONTINUE; } @@ -1733,14 +1787,14 @@ int32_t scalarCalculate(SNode *pNode, SArray *pBlockList, SScalarParam *pDst) { if (1 == res->numOfRows && pb->info.rows > 0) { SCL_ERR_JRET(sclExtendResRows(pDst, res, pBlockList)); } else { - colInfoDataEnsureCapacity(pDst->columnData, res->numOfRows, true); - colDataAssign(pDst->columnData, res->columnData, res->numOfRows, NULL); + SCL_ERR_JRET(colInfoDataEnsureCapacity(pDst->columnData, res->numOfRows, true)); + SCL_ERR_JRET(colDataAssign(pDst->columnData, res->columnData, res->numOfRows, NULL)); pDst->numOfRows = res->numOfRows; pDst->numOfQualified = res->numOfQualified; } sclFreeParam(res); - taosHashRemove(ctx.pRes, (void *)&pNode, POINTER_BYTES); + (void)taosHashRemove(ctx.pRes, (void *)&pNode, POINTER_BYTES); } _return: diff --git a/source/libs/scalar/src/sclfunc.c b/source/libs/scalar/src/sclfunc.c index 282e935dd8..5baaa57b1d 100644 --- a/source/libs/scalar/src/sclfunc.c +++ b/source/libs/scalar/src/sclfunc.c @@ -124,7 +124,7 @@ int32_t absFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutpu } default: { - colDataAssign(pOutputData, pInputData, pInput->numOfRows, NULL); + SCL_ERR_RET(colDataAssign(pOutputData, pInputData, pInput->numOfRows, NULL)); } } @@ -147,7 +147,9 @@ static int32_t doScalarFunctionUnique(SScalarParam *pInput, int32_t inputNum, SS colDataSetNULL(pOutputData, i); continue; } - double result = valFn(getValueFn(pInputData->pData, i)); + double tmp = 0; + SCL_ERR_RET(getValueFn(pInputData->pData, i, &tmp)); + double result = valFn(tmp); if (isinf(result) || isnan(result)) { colDataSetNULL(pOutputData, i); } else { @@ -182,7 +184,11 @@ static int32_t doScalarFunctionUnique2(SScalarParam *pInput, int32_t inputNum, S colDataSetNULL(pOutputData, i); continue; } - result = valFn(getValueFn[0](pInputData[0]->pData, i), getValueFn[1](pInputData[1]->pData, i)); + double val1 = 0; + double val2 = 0; + SCL_ERR_RET(getValueFn[0](pInputData[0]->pData, i, &val1)); + SCL_ERR_RET(getValueFn[1](pInputData[1]->pData, i, &val2)); + result = valFn(val1, val2); if (isinf(result) || isnan(result)) { colDataSetNULL(pOutputData, i); } else { @@ -198,8 +204,11 @@ static int32_t doScalarFunctionUnique2(SScalarParam *pInput, int32_t inputNum, S colDataSetNULL(pOutputData, i); continue; } - - result = valFn(getValueFn[0](pInputData[0]->pData, 0), getValueFn[1](pInputData[1]->pData, i)); + double val1 = 0; + double val2 = 0; + SCL_ERR_RET(getValueFn[0](pInputData[0]->pData, 0, &val1)); + SCL_ERR_RET(getValueFn[1](pInputData[1]->pData, i, &val2)); + result = valFn(val1, val2); if (isinf(result) || isnan(result)) { colDataSetNULL(pOutputData, i); continue; @@ -217,8 +226,11 @@ static int32_t doScalarFunctionUnique2(SScalarParam *pInput, int32_t inputNum, S colDataSetNULL(pOutputData, i); continue; } - - result = valFn(getValueFn[0](pInputData[0]->pData, i), getValueFn[1](pInputData[1]->pData, 0)); + double val1 = 0; + double val2 = 0; + SCL_ERR_RET(getValueFn[0](pInputData[0]->pData, i, &val1)); + SCL_ERR_RET(getValueFn[1](pInputData[1]->pData, 0, &val2)); + result = valFn(val1, val2); if (isinf(result) || isnan(result)) { colDataSetNULL(pOutputData, i); continue; @@ -277,7 +289,7 @@ static int32_t doScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarP } default: { - colDataAssign(pOutputData, pInputData, pInput->numOfRows, NULL); + SCL_ERR_RET(colDataAssign(pOutputData, pInputData, pInput->numOfRows, NULL)); } } @@ -380,6 +392,9 @@ static int32_t doLengthFunction(SScalarParam *pInput, int32_t inputNum, SScalarP static int32_t concatCopyHelper(const char *input, char *output, bool hasNchar, int32_t type, VarDataLenT *dataLen) { if (hasNchar && type == TSDB_DATA_TYPE_VARCHAR) { TdUcs4 *newBuf = taosMemoryCalloc((varDataLen(input) + 1) * TSDB_NCHAR_SIZE, 1); + if (NULL == newBuf) { + return TSDB_CODE_OUT_OF_MEMORY; + } int32_t len = varDataLen(input); bool ret = taosMbsToUcs4(varDataVal(input), len, newBuf, (varDataLen(input) + 1) * TSDB_NCHAR_SIZE, &len); if (!ret) { @@ -410,12 +425,19 @@ static int32_t getNumOfNullEntries(SColumnInfoData *pColumnInfoData, int32_t num } int32_t concatFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { - int32_t ret = TSDB_CODE_SUCCESS; + int32_t code = TSDB_CODE_SUCCESS; SColumnInfoData **pInputData = taosMemoryCalloc(inputNum, sizeof(SColumnInfoData *)); SColumnInfoData *pOutputData = pOutput->columnData; char **input = taosMemoryCalloc(inputNum, POINTER_BYTES); char *outputBuf = NULL; + if (NULL == pInputData) { + SCL_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } + if (NULL == input) { + SCL_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } + int32_t inputLen = 0; int32_t numOfRows = 0; bool hasNchar = (GET_PARAM_TYPE(pOutput) == TSDB_DATA_TYPE_NCHAR) ? true : false; @@ -441,6 +463,9 @@ int32_t concatFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu int32_t outputLen = inputLen + numOfRows * VARSTR_HEADER_SIZE; outputBuf = taosMemoryCalloc(outputLen, 1); + if (NULL == outputBuf) { + SCL_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } char *output = outputBuf; for (int32_t k = 0; k < numOfRows; ++k) { @@ -462,33 +487,37 @@ int32_t concatFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu int32_t rowIdx = (pInput[i].numOfRows == 1) ? 0 : k; input[i] = colDataGetData(pInputData[i], rowIdx); - ret = concatCopyHelper(input[i], output, hasNchar, GET_PARAM_TYPE(&pInput[i]), &dataLen); - if (ret != TSDB_CODE_SUCCESS) { - goto DONE; - } + SCL_ERR_JRET(concatCopyHelper(input[i], output, hasNchar, GET_PARAM_TYPE(&pInput[i]), &dataLen)); } varDataSetLen(output, dataLen); - colDataSetVal(pOutputData, k, output, false); + SCL_ERR_JRET(colDataSetVal(pOutputData, k, output, false)); output += varDataTLen(output); } pOutput->numOfRows = numOfRows; -DONE: +_return: taosMemoryFree(input); taosMemoryFree(outputBuf); taosMemoryFree(pInputData); - return ret; + SCL_RET(code); } int32_t concatWsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { - int32_t ret = TSDB_CODE_SUCCESS; + int32_t code = TSDB_CODE_SUCCESS; SColumnInfoData **pInputData = taosMemoryCalloc(inputNum, sizeof(SColumnInfoData *)); SColumnInfoData *pOutputData = pOutput->columnData; char **input = taosMemoryCalloc(inputNum, POINTER_BYTES); char *outputBuf = NULL; + if (NULL == pInputData) { + SCL_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } + if (NULL == input) { + SCL_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } + int32_t inputLen = 0; int32_t numOfRows = 0; bool hasNchar = (GET_PARAM_TYPE(pOutput) == TSDB_DATA_TYPE_NCHAR) ? true : false; @@ -518,6 +547,10 @@ int32_t concatWsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *p int32_t outputLen = inputLen + numOfRows * VARSTR_HEADER_SIZE; outputBuf = taosMemoryCalloc(outputLen, 1); + if (NULL == outputBuf) { + SCL_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } + char *output = outputBuf; for (int32_t k = 0; k < numOfRows; ++k) { @@ -537,18 +570,12 @@ int32_t concatWsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *p int32_t rowIdx = (pInput[i].numOfRows == 1) ? 0 : k; input[i] = colDataGetData(pInputData[i], rowIdx); - ret = concatCopyHelper(input[i], output, hasNchar, GET_PARAM_TYPE(&pInput[i]), &dataLen); - if (ret != TSDB_CODE_SUCCESS) { - goto DONE; - } + SCL_ERR_JRET(concatCopyHelper(input[i], output, hasNchar, GET_PARAM_TYPE(&pInput[i]), &dataLen)); if (i < inputNum - 1) { // insert the separator char *sep = (pInput[0].numOfRows == 1) ? colDataGetData(pInputData[0], 0) : colDataGetData(pInputData[0], k); - ret = concatCopyHelper(sep, output, hasNchar, GET_PARAM_TYPE(&pInput[0]), &dataLen); - if (ret != TSDB_CODE_SUCCESS) { - goto DONE; - } + SCL_ERR_JRET(concatCopyHelper(sep, output, hasNchar, GET_PARAM_TYPE(&pInput[0]), &dataLen)); } } @@ -557,19 +584,19 @@ int32_t concatWsFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *p memset(output, 0, dataLen); } else { varDataSetLen(output, dataLen); - colDataSetVal(pOutputData, k, output, false); + SCL_ERR_JRET(colDataSetVal(pOutputData, k, output, false)); output += varDataTLen(output); } } pOutput->numOfRows = numOfRows; -DONE: +_return: taosMemoryFree(input); taosMemoryFree(outputBuf); taosMemoryFree(pInputData); - return ret; + return code; } static int32_t doCaseConvFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput, _conv_fn convFn) { @@ -580,6 +607,10 @@ static int32_t doCaseConvFunction(SScalarParam *pInput, int32_t inputNum, SScala int32_t outputLen = pInputData->varmeta.length; char *outputBuf = taosMemoryCalloc(outputLen, 1); + if (outputBuf == NULL) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + char *output = outputBuf; for (int32_t i = 0; i < pInput->numOfRows; ++i) { @@ -600,7 +631,11 @@ static int32_t doCaseConvFunction(SScalarParam *pInput, int32_t inputNum, SScala } } varDataSetLen(output, len); - colDataSetVal(pOutputData, i, output, false); + int32_t code = colDataSetVal(pOutputData, i, output, false); + if (TSDB_CODE_SUCCESS != code) { + taosMemoryFree(outputBuf); + SCL_ERR_RET(code); + } output += varDataTLen(output); } @@ -618,6 +653,10 @@ static int32_t doTrimFunction(SScalarParam *pInput, int32_t inputNum, SScalarPar int32_t outputLen = pInputData->varmeta.length; char *outputBuf = taosMemoryCalloc(outputLen, 1); + if (outputBuf == NULL) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + char *output = outputBuf; for (int32_t i = 0; i < pInput->numOfRows; ++i) { @@ -631,7 +670,11 @@ static int32_t doTrimFunction(SScalarParam *pInput, int32_t inputNum, SScalarPar int32_t charLen = (type == TSDB_DATA_TYPE_VARCHAR) ? len : len / TSDB_NCHAR_SIZE; trimFn(input, output, type, charLen); - colDataSetVal(pOutputData, i, output, false); + int32_t code = colDataSetVal(pOutputData, i, output, false); + if (TSDB_CODE_SUCCESS != code) { + taosMemoryFree(outputBuf); + SCL_ERR_RET(code); + } output += varDataTLen(output); } @@ -688,7 +731,11 @@ int32_t substrFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu varDataSetLen(output, 0); } - colDataSetVal(pOutputData, i, output, false); + int32_t code = colDataSetVal(pOutputData, i, output, false); + if (TSDB_CODE_SUCCESS != code) { + taosMemoryFree(outputBuf); + SCL_ERR_RET(code); + } } pOutput->numOfRows = pInput->numOfRows; @@ -715,12 +762,21 @@ int32_t md5Function(SScalarParam* pInput, int32_t inputNum, SScalarParam* pOutpu if (bufLen < varDataLen(input) + VARSTR_HEADER_SIZE) { bufLen = varDataLen(input) + VARSTR_HEADER_SIZE; pOutputBuf = taosMemoryRealloc(pOutputBuf, bufLen); + if (!pOutputBuf) { + qError("md5 function alloc memory failed"); + return TSDB_CODE_OUT_OF_MEMORY; + } } char *output = pOutputBuf; memcpy(varDataVal(output), varDataVal(input), varDataLen(input)); int32_t len = taosCreateMD5Hash(varDataVal(output), varDataLen(input)); varDataSetLen(output, len); - colDataSetVal(pOutputData, i, output, false); + int32_t code = colDataSetVal(pOutputData, i, output, false); + if (TSDB_CODE_SUCCESS != code) { + taosMemoryFree(pOutputBuf); + SCL_ERR_RET(code); + } + } pOutput->numOfRows = pInput->numOfRows; taosMemoryFree(pOutputBuf); @@ -1062,7 +1118,10 @@ int32_t castFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutp } } - colDataSetVal(pOutput->columnData, i, output, false); + code = colDataSetVal(pOutput->columnData, i, output, false); + if (TSDB_CODE_SUCCESS != code) { + goto _end; + } } pOutput->numOfRows = pInput->numOfRows; @@ -1167,7 +1226,7 @@ _end: memmove(buf + VARSTR_HEADER_SIZE, buf, len); varDataSetLen(buf, len); - colDataSetVal(pOutput->columnData, i, buf, false); + SCL_ERR_RET(colDataSetVal(pOutput->columnData, i, buf, false)); } pOutput->numOfRows = pInput->numOfRows; @@ -1193,7 +1252,7 @@ int32_t toUnixtimestampFunction(SScalarParam *pInput, int32_t inputNum, SScalarP if (ret != TSDB_CODE_SUCCESS) { colDataSetNULL(pOutput->columnData, i); } else { - colDataSetVal(pOutput->columnData, i, (char *)&timeVal, false); + SCL_ERR_RET(colDataSetVal(pOutput->columnData, i, (char *)&timeVal, false)); } } @@ -1206,12 +1265,21 @@ int32_t toJsonFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu int32_t type = GET_PARAM_TYPE(pInput); char tmp[TSDB_MAX_JSON_TAG_LEN] = {0}; + int32_t code = TSDB_CODE_SUCCESS; for (int32_t i = 0; i < pInput[0].numOfRows; ++i) { SArray *pTagVals = taosArrayInit(8, sizeof(STagVal)); + if (NULL == pTagVals) { + return TSDB_CODE_OUT_OF_MEMORY; + } STag *pTag = NULL; if (colDataIsNull_s(pInput[0].columnData, i)) { - tTagNew(pTagVals, 1, true, &pTag); + code = tTagNew(pTagVals, 1, true, &pTag); + if (TSDB_CODE_SUCCESS != code) { + tTagFree(pTag); + taosArrayDestroy(pTagVals); + SCL_ERR_RET(code); + } } else { char *input = pInput[0].columnData->pData + pInput[0].columnData->varmeta.offset[i]; if (varDataLen(input) > (TSDB_MAX_JSON_TAG_LEN - VARSTR_HEADER_SIZE) / TSDB_NCHAR_SIZE) { @@ -1221,13 +1289,21 @@ int32_t toJsonFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOu memcpy(tmp, varDataVal(input), varDataLen(input)); tmp[varDataLen(input)] = 0; if (parseJsontoTagData(tmp, pTagVals, &pTag, NULL)) { - tTagNew(pTagVals, 1, true, &pTag); + code = tTagNew(pTagVals, 1, true, &pTag); + if (TSDB_CODE_SUCCESS != code) { + tTagFree(pTag); + taosArrayDestroy(pTagVals); + SCL_ERR_RET(code); + } } } - colDataSetVal(pOutput->columnData, i, (const char *)pTag, false); + code = colDataSetVal(pOutput->columnData, i, (const char *)pTag, false); tTagFree(pTag); taosArrayDestroy(pTagVals); + if (TSDB_CODE_SUCCESS != code ) { + SCL_ERR_RET(code); + } } pOutput->numOfRows = pInput->numOfRows; @@ -1242,6 +1318,9 @@ int32_t toTimestampFunction(SScalarParam* pInput, int32_t inputNum, SScalarParam int32_t len, code = TSDB_CODE_SUCCESS; SArray *formats = NULL; + if (tsStr == NULL || format == NULL) { + SCL_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } for (int32_t i = 0; i < pInput[0].numOfRows; ++i) { if (colDataIsNull_s(pInput[1].columnData, i) || colDataIsNull_s(pInput[0].columnData, i)) { colDataSetNULL(pOutput->columnData, i); @@ -1251,11 +1330,11 @@ int32_t toTimestampFunction(SScalarParam* pInput, int32_t inputNum, SScalarParam char *tsData = colDataGetData(pInput[0].columnData, i); char *formatData = colDataGetData(pInput[1].columnData, pInput[1].numOfRows > 1 ? i : 0); len = TMIN(TS_FORMAT_MAX_LEN - 1, varDataLen(tsData)); - strncpy(tsStr, varDataVal(tsData), len); + (void)strncpy(tsStr, varDataVal(tsData), len); // No need to handle the return value. tsStr[len] = '\0'; len = TMIN(TS_FORMAT_MAX_LEN - 1, varDataLen(formatData)); if (pInput[1].numOfRows > 1 || i == 0) { - strncpy(format, varDataVal(formatData), len); + (void)strncpy(format, varDataVal(formatData), len); // No need to handle the return value. format[len] = '\0'; if (formats) { taosArrayDestroy(formats); @@ -1267,10 +1346,12 @@ int32_t toTimestampFunction(SScalarParam* pInput, int32_t inputNum, SScalarParam code = taosChar2Ts(format, &formats, tsStr, &ts, precision, errMsg, 128); if (code) { qError("func to_timestamp failed %s", errMsg); - break; + SCL_ERR_JRET(code); } - colDataSetVal(pOutput->columnData, i, (char *)&ts, false); + SCL_ERR_JRET(colDataSetVal(pOutput->columnData, i, (char *)&ts, false)); } + +_return: if (formats) taosArrayDestroy(formats); taosMemoryFree(tsStr); taosMemoryFree(format); @@ -1283,6 +1364,10 @@ int32_t toCharFunction(SScalarParam* pInput, int32_t inputNum, SScalarParam* pOu int32_t len; SArray *formats = NULL; int32_t code = 0; + + if (format == NULL || out == NULL) { + SCL_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } for (int32_t i = 0; i < pInput[0].numOfRows; ++i) { if (colDataIsNull_s(pInput[1].columnData, i) || colDataIsNull_s(pInput[0].columnData, i)) { colDataSetNULL(pOutput->columnData, i); @@ -1293,7 +1378,7 @@ int32_t toCharFunction(SScalarParam* pInput, int32_t inputNum, SScalarParam* pOu char *formatData = colDataGetData(pInput[1].columnData, pInput[1].numOfRows > 1 ? i : 0); len = TMIN(TS_FORMAT_MAX_LEN - 1, varDataLen(formatData)); if (pInput[1].numOfRows > 1 || i == 0) { - strncpy(format, varDataVal(formatData), len); + (void)strncpy(format, varDataVal(formatData), len); format[len] = '\0'; if (formats) { taosArrayDestroy(formats); @@ -1301,11 +1386,12 @@ int32_t toCharFunction(SScalarParam* pInput, int32_t inputNum, SScalarParam* pOu } } int32_t precision = pInput[0].columnData->info.precision; - code = taosTs2Char(format, &formats, *(int64_t *)ts, precision, varDataVal(out), TS_FORMAT_MAX_LEN); - if (code) break; + SCL_ERR_JRET(taosTs2Char(format, &formats, *(int64_t *)ts, precision, varDataVal(out), TS_FORMAT_MAX_LEN)); varDataSetLen(out, strlen(varDataVal(out))); - colDataSetVal(pOutput->columnData, i, out, false); + SCL_ERR_JRET(colDataSetVal(pOutput->columnData, i, out, false)); } + +_return: if (formats) taosArrayDestroy(formats); taosMemoryFree(format); taosMemoryFree(out); @@ -1341,7 +1427,7 @@ int32_t timeTruncateFunction(SScalarParam *pInput, int32_t inputNum, SScalarPara } GET_TYPED_DATA(timePrec, int64_t, GET_PARAM_TYPE(&pInput[timePrecIdx]), pInput[timePrecIdx].columnData->pData); - memcpy(timezone, varDataVal(pInput[timeZoneIdx].columnData->pData), varDataLen(pInput[timeZoneIdx].columnData->pData)); + (void)memcpy(timezone, varDataVal(pInput[timeZoneIdx].columnData->pData), varDataLen(pInput[timeZoneIdx].columnData->pData)); for (int32_t i = 0; i < pInput[0].numOfRows; ++i) { if (colDataIsNull_s(pInput[0].columnData, i)) { @@ -1373,7 +1459,7 @@ int32_t timeTruncateFunction(SScalarParam *pInput, int32_t inputNum, SScalarPara } else { timeVal = timeVal / timeUnit * timeUnit; } - colDataSetVal(pOutput->columnData, i, (char *)&timeVal, false); + SCL_ERR_RET(colDataSetVal(pOutput->columnData, i, (char *)&timeVal, false)); } pOutput->numOfRows = pInput->numOfRows; @@ -1507,7 +1593,7 @@ int32_t timeDiffFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *p } } - colDataSetVal(pOutput->columnData, i, (char *)&result, false); + SCL_ERR_RET(colDataSetVal(pOutput->columnData, i, (char *)&result, false)); } pOutput->numOfRows = numOfRows; @@ -1541,10 +1627,10 @@ int32_t todayFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOut int32_t timezoneFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { char output[TD_TIMEZONE_LEN + VARSTR_HEADER_SIZE] = {0}; - memcpy(varDataVal(output), tsTimezoneStr, TD_TIMEZONE_LEN); + (void)memcpy(varDataVal(output), tsTimezoneStr, TD_TIMEZONE_LEN); varDataSetLen(output, strlen(tsTimezoneStr)); for (int32_t i = 0; i < pInput->numOfRows; ++i) { - colDataSetVal(pOutput->columnData, i, output, false); + SCL_ERR_RET(colDataSetVal(pOutput->columnData, i, output, false)); } pOutput->numOfRows = pInput->numOfRows; return TSDB_CODE_SUCCESS; @@ -2259,16 +2345,16 @@ int32_t leastSQRScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarPa char interceptBuf[64] = {0}; int n = snprintf(slopBuf, 64, "%.6lf", matrix02); if (n > LEASTSQUARES_DOUBLE_ITEM_LENGTH) { - snprintf(slopBuf, 64, "%." DOUBLE_PRECISION_DIGITS, matrix02); + (void)snprintf(slopBuf, 64, "%." DOUBLE_PRECISION_DIGITS, matrix02); } n = snprintf(interceptBuf, 64, "%.6lf", matrix12); if (n > LEASTSQUARES_DOUBLE_ITEM_LENGTH) { - snprintf(interceptBuf, 64, "%." DOUBLE_PRECISION_DIGITS, matrix12); + (void) snprintf(interceptBuf, 64, "%." DOUBLE_PRECISION_DIGITS, matrix12); } size_t len = snprintf(varDataVal(buf), sizeof(buf) - VARSTR_HEADER_SIZE, "{slop:%s, intercept:%s}", slopBuf, interceptBuf); varDataSetLen(buf, len); - colDataSetVal(pOutputData, 0, buf, false); + SCL_ERR_RET(colDataSetVal(pOutputData, 0, buf, false)); } pOutput->numOfRows = 1; @@ -2295,7 +2381,7 @@ int32_t percentileScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalar if (hasNull) { colDataSetNULL(pOutputData, 0); } else { - colDataSetVal(pOutputData, 0, (char *)&val, false); + SCL_ERR_RET(colDataSetVal(pOutputData, 0, (char *)&val, false)); } pOutput->numOfRows = 1; @@ -2341,7 +2427,7 @@ int32_t spreadScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarPara colDataSetNULL(pOutputData, 0); } else { double result = max - min; - colDataSetVal(pOutputData, 0, (char *)&result, false); + SCL_ERR_RET(colDataSetVal(pOutputData, 0, (char *)&result, false)); } pOutput->numOfRows = 1; @@ -2544,7 +2630,7 @@ int32_t stateCountScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalar } else { count = 0; } - colDataSetVal(pOutputData, i, (char *)&out, false); + SCL_ERR_RET(colDataSetVal(pOutputData, i, (char *)&out, false)); } pOutput->numOfRows = pInput->numOfRows; @@ -2568,7 +2654,7 @@ int32_t stateDurationScalarFunction(SScalarParam *pInput, int32_t inputNum, SSca if (ret) { out = 0; } - colDataSetVal(pOutputData, i, (char *)&out, false); + SCL_ERR_RET(colDataSetVal(pOutputData, i, (char *)&out, false)); } pOutput->numOfRows = pInput->numOfRows; @@ -2599,7 +2685,7 @@ typedef struct SHistoFuncBin { double percentage; } SHistoFuncBin; -static bool getHistogramBinDesc(SHistoFuncBin **bins, int32_t *binNum, char *binDescStr, int8_t binType, +static int32_t getHistogramBinDesc(SHistoFuncBin **bins, int32_t *binNum, char *binDescStr, int8_t binType, bool normalized) { cJSON *binDesc = cJSON_Parse(binDescStr); int32_t numOfBins; @@ -2609,7 +2695,7 @@ static bool getHistogramBinDesc(SHistoFuncBin **bins, int32_t *binNum, char *bin int32_t startIndex; if (numOfParams != 4) { cJSON_Delete(binDesc); - return false; + SCL_ERR_RET(TSDB_CODE_FAILED); } cJSON *start = cJSON_GetObjectItem(binDesc, "start"); @@ -2620,18 +2706,18 @@ static bool getHistogramBinDesc(SHistoFuncBin **bins, int32_t *binNum, char *bin if (!cJSON_IsNumber(start) || !cJSON_IsNumber(count) || !cJSON_IsBool(infinity)) { cJSON_Delete(binDesc); - return false; + SCL_RET(TSDB_CODE_SUCCESS); } if (count->valueint <= 0 || count->valueint > 1000) { // limit count to 1000 cJSON_Delete(binDesc); - return false; + SCL_ERR_RET(TSDB_CODE_FAILED); } if (isinf(start->valuedouble) || (width != NULL && isinf(width->valuedouble)) || (factor != NULL && isinf(factor->valuedouble)) || (count != NULL && isinf(count->valuedouble))) { cJSON_Delete(binDesc); - return false; + SCL_ERR_RET(TSDB_CODE_FAILED); } int32_t counter = (int32_t)count->valueint; @@ -2644,19 +2730,23 @@ static bool getHistogramBinDesc(SHistoFuncBin **bins, int32_t *binNum, char *bin } intervals = taosMemoryCalloc(numOfBins, sizeof(double)); + if (NULL == intervals) { + cJSON_Delete(binDesc); + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } if (cJSON_IsNumber(width) && factor == NULL && binType == LINEAR_BIN) { // linear bin process if (width->valuedouble == 0) { taosMemoryFree(intervals); cJSON_Delete(binDesc); - return false; + SCL_ERR_RET(TSDB_CODE_FAILED); } for (int i = 0; i < counter + 1; ++i) { intervals[startIndex] = start->valuedouble + i * width->valuedouble; if (isinf(intervals[startIndex])) { taosMemoryFree(intervals); cJSON_Delete(binDesc); - return false; + SCL_ERR_RET(TSDB_CODE_FAILED); } startIndex++; } @@ -2665,26 +2755,26 @@ static bool getHistogramBinDesc(SHistoFuncBin **bins, int32_t *binNum, char *bin if (start->valuedouble == 0) { taosMemoryFree(intervals); cJSON_Delete(binDesc); - return false; + SCL_ERR_RET(TSDB_CODE_FAILED); } if (factor->valuedouble < 0 || factor->valuedouble == 0 || factor->valuedouble == 1) { taosMemoryFree(intervals); cJSON_Delete(binDesc); - return false; + SCL_ERR_RET(TSDB_CODE_FAILED); } for (int i = 0; i < counter + 1; ++i) { intervals[startIndex] = start->valuedouble * pow(factor->valuedouble, i * 1.0); if (isinf(intervals[startIndex])) { taosMemoryFree(intervals); cJSON_Delete(binDesc); - return false; + SCL_ERR_RET(TSDB_CODE_FAILED); } startIndex++; } } else { taosMemoryFree(intervals); cJSON_Delete(binDesc); - return false; + SCL_ERR_RET(TSDB_CODE_FAILED); } if (infinity->valueint == true) { @@ -2692,7 +2782,7 @@ static bool getHistogramBinDesc(SHistoFuncBin **bins, int32_t *binNum, char *bin intervals[numOfBins - 1] = INFINITY; // in case of desc bin orders, -inf/inf should be swapped if (numOfBins < 4) { - return false; + SCL_ERR_RET(TSDB_CODE_FAILED); } if (intervals[1] > intervals[numOfBins - 2]) { TSWAP(intervals[0], intervals[numOfBins - 1]); @@ -2701,15 +2791,19 @@ static bool getHistogramBinDesc(SHistoFuncBin **bins, int32_t *binNum, char *bin } else if (cJSON_IsArray(binDesc)) { /* user input bins */ if (binType != USER_INPUT_BIN) { cJSON_Delete(binDesc); - return false; + SCL_ERR_RET(TSDB_CODE_FAILED); } numOfBins = cJSON_GetArraySize(binDesc); intervals = taosMemoryCalloc(numOfBins, sizeof(double)); + if (NULL == intervals) { + cJSON_Delete(binDesc); + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } cJSON *bin = binDesc->child; if (bin == NULL) { taosMemoryFree(intervals); cJSON_Delete(binDesc); - return false; + SCL_ERR_RET(TSDB_CODE_FAILED); } int i = 0; while (bin) { @@ -2717,23 +2811,26 @@ static bool getHistogramBinDesc(SHistoFuncBin **bins, int32_t *binNum, char *bin if (!cJSON_IsNumber(bin)) { taosMemoryFree(intervals); cJSON_Delete(binDesc); - return false; + SCL_ERR_RET(TSDB_CODE_FAILED); } if (i != 0 && intervals[i] <= intervals[i - 1]) { taosMemoryFree(intervals); cJSON_Delete(binDesc); - return false; + SCL_ERR_RET(TSDB_CODE_FAILED); } bin = bin->next; i++; } } else { cJSON_Delete(binDesc); - return false; + SCL_RET(TSDB_CODE_FAILED); } *binNum = numOfBins - 1; *bins = taosMemoryCalloc(numOfBins, sizeof(SHistoFuncBin)); + if (NULL == bins) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } for (int32_t i = 0; i < *binNum; ++i) { (*bins)[i].lower = intervals[i] < intervals[i + 1] ? intervals[i] : intervals[i + 1]; (*bins)[i].upper = intervals[i + 1] > intervals[i] ? intervals[i + 1] : intervals[i]; @@ -2743,7 +2840,7 @@ static bool getHistogramBinDesc(SHistoFuncBin **bins, int32_t *binNum, char *bin taosMemoryFree(intervals); cJSON_Delete(binDesc); - return true; + SCL_RET(TSDB_CODE_SUCCESS); } int32_t histogramScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarParam *pOutput) { @@ -2762,9 +2859,10 @@ int32_t histogramScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarP int64_t normalized = *(int64_t *)(pInput[3].columnData->pData); int32_t type = GET_PARAM_TYPE(pInput); - if (!getHistogramBinDesc(&bins, &numOfBins, binDesc, binType, (bool)normalized)) { + int32_t code = getHistogramBinDesc(&bins, &numOfBins, binDesc, binType, (bool)normalized); + if (TSDB_CODE_SUCCESS != code) { taosMemoryFree(binDesc); - return TSDB_CODE_FAILED; + return code; } taosMemoryFree(binDesc); @@ -2796,7 +2894,7 @@ int32_t histogramScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarP } } - colInfoDataEnsureCapacity(pOutputData, numOfBins, false); + SCL_ERR_JRET(colInfoDataEnsureCapacity(pOutputData, numOfBins, false)); for (int32_t k = 0; k < numOfBins; ++k) { int32_t len; @@ -2809,11 +2907,12 @@ int32_t histogramScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarP bins[k].upper, bins[k].percentage); } varDataSetLen(buf, len); - colDataSetVal(pOutputData, k, buf, false); + SCL_ERR_JRET(colDataSetVal(pOutputData, k, buf, false)); } - - taosMemoryFree(bins); pOutput->numOfRows = numOfBins; + +_return: + taosMemoryFree(bins); return TSDB_CODE_SUCCESS; } @@ -2830,7 +2929,7 @@ int32_t selectScalarFunction(SScalarParam *pInput, int32_t inputNum, SScalarPara } char *data = colDataGetData(pInputData, i); - colDataSetVal(pOutputData, i, data, false); + SCL_ERR_RET(colDataSetVal(pOutputData, i, data, false)); } pOutput->numOfRows = 1; diff --git a/source/libs/scalar/src/sclvector.c b/source/libs/scalar/src/sclvector.c index 16c06c2452..f841ec6618 100644 --- a/source/libs/scalar/src/sclvector.c +++ b/source/libs/scalar/src/sclvector.c @@ -96,11 +96,16 @@ void convertNumberToNumber(const void *inData, void *outData, int8_t inType, int } } -void convertNcharToDouble(const void *inData, void *outData) { - char *tmp = taosMemoryMalloc(varDataTLen(inData)); +int32_t convertNcharToDouble(const void *inData, void *outData) { + int32_t code = TSDB_CODE_SUCCESS; + char *tmp = taosMemoryMalloc(varDataTLen(inData)); + if (NULL == tmp) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } int len = taosUcs4ToMbs((TdUcs4 *)varDataVal(inData), varDataLen(inData), tmp); if (len < 0) { sclError("castConvert taosUcs4ToMbs error 1"); + SCL_ERR_JRET(TSDB_CODE_FAILED); } tmp[len] = 0; @@ -108,50 +113,89 @@ void convertNcharToDouble(const void *inData, void *outData) { double value = taosStr2Double(tmp, NULL); *((double *)outData) = value; + +_return: taosMemoryFreeClear(tmp); + SCL_RET(code); } -void convertBinaryToDouble(const void *inData, void *outData) { +int32_t convertBinaryToDouble(const void *inData, void *outData) { char *tmp = taosMemoryCalloc(1, varDataTLen(inData)); if (tmp == NULL) { *((double *)outData) = 0.; - return; + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); } - memcpy(tmp, varDataVal(inData), varDataLen(inData)); + (void)memcpy(tmp, varDataVal(inData), varDataLen(inData)); double ret = taosStr2Double(tmp, NULL); taosMemoryFree(tmp); *((double *)outData) = ret; + SCL_RET(TSDB_CODE_SUCCESS); } -typedef int64_t (*_getBigintValue_fn_t)(void *src, int32_t index); +typedef int32_t (*_getBigintValue_fn_t)(void *src, int32_t index, int64_t *res); -int64_t getVectorBigintValue_TINYINT(void *src, int32_t index) { return (int64_t) * ((int8_t *)src + index); } -int64_t getVectorBigintValue_UTINYINT(void *src, int32_t index) { return (int64_t) * ((uint8_t *)src + index); } -int64_t getVectorBigintValue_SMALLINT(void *src, int32_t index) { return (int64_t) * ((int16_t *)src + index); } -int64_t getVectorBigintValue_USMALLINT(void *src, int32_t index) { return (int64_t) * ((uint16_t *)src + index); } -int64_t getVectorBigintValue_INT(void *src, int32_t index) { return (int64_t) * ((int32_t *)src + index); } -int64_t getVectorBigintValue_UINT(void *src, int32_t index) { return (int64_t) * ((uint32_t *)src + index); } -int64_t getVectorBigintValue_BIGINT(void *src, int32_t index) { return (int64_t) * ((int64_t *)src + index); } -int64_t getVectorBigintValue_UBIGINT(void *src, int32_t index) { return (int64_t) * ((uint64_t *)src + index); } -int64_t getVectorBigintValue_FLOAT(void *src, int32_t index) { return (int64_t) * ((float *)src + index); } -int64_t getVectorBigintValue_DOUBLE(void *src, int32_t index) { return (int64_t) * ((double *)src + index); } -int64_t getVectorBigintValue_BOOL(void *src, int32_t index) { return (int64_t) * ((bool *)src + index); } +int32_t getVectorBigintValue_TINYINT(void *src, int32_t index, int64_t *res) { + *res = (int64_t) * ((int8_t *)src + index); + SCL_RET(TSDB_CODE_SUCCESS); +} +int32_t getVectorBigintValue_UTINYINT(void *src, int32_t index, int64_t *res) { + *res = (int64_t) * ((uint8_t *)src + index); + SCL_RET(TSDB_CODE_SUCCESS); +} +int32_t getVectorBigintValue_SMALLINT(void *src, int32_t index, int64_t *res) { + *res = (int64_t) * ((int16_t *)src + index); + SCL_RET(TSDB_CODE_SUCCESS); +} +int32_t getVectorBigintValue_USMALLINT(void *src, int32_t index, int64_t *res) { + *res = (int64_t) * ((uint16_t *)src + index); + SCL_RET(TSDB_CODE_SUCCESS); +} +int32_t getVectorBigintValue_INT(void *src, int32_t index, int64_t *res) { + *res = (int64_t) * ((int32_t *)src + index); + SCL_RET(TSDB_CODE_SUCCESS); +} +int32_t getVectorBigintValue_UINT(void *src, int32_t index, int64_t *res) { + *res = (int64_t) * ((uint32_t *)src + index); + SCL_RET(TSDB_CODE_SUCCESS); +} +int32_t getVectorBigintValue_BIGINT(void *src, int32_t index, int64_t *res) { + *res = (int64_t) * ((int64_t *)src + index); + SCL_RET(TSDB_CODE_SUCCESS); +} +int32_t getVectorBigintValue_UBIGINT(void *src, int32_t index, int64_t *res) { + *res = (int64_t) * ((uint64_t *)src + index); + SCL_RET(TSDB_CODE_SUCCESS); +} +int32_t getVectorBigintValue_FLOAT(void *src, int32_t index, int64_t *res) { + *res = (int64_t) * ((float *)src + index); + SCL_RET(TSDB_CODE_SUCCESS); +} +int32_t getVectorBigintValue_DOUBLE(void *src, int32_t index, int64_t *res) { + *res = (int64_t) * ((double *)src + index); + SCL_RET(TSDB_CODE_SUCCESS); +} +int32_t getVectorBigintValue_BOOL(void *src, int32_t index, int64_t *res) { + *res = (int64_t) * ((bool *)src + index); + SCL_RET(TSDB_CODE_SUCCESS); +} -int64_t getVectorBigintValue_JSON(void *src, int32_t index) { +int32_t getVectorBigintValue_JSON(void *src, int32_t index, int64_t *res) { ASSERT(!colDataIsNull_var(((SColumnInfoData *)src), index)); char *data = colDataGetVarData((SColumnInfoData *)src, index); double out = 0; if (*data == TSDB_DATA_TYPE_NULL) { - return 0; + *res = 0; + SCL_RET(TSDB_CODE_SUCCESS); } else if (*data == TSDB_DATA_TYPE_NCHAR) { // json inner type can not be BINARY - convertNcharToDouble(data + CHAR_BYTES, &out); + SCL_ERR_RET(convertNcharToDouble(data + CHAR_BYTES, &out)); } else if (tTagIsJson(data)) { - terrno = TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR; - return 0; + *res = 0; + SCL_ERR_RET(TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR); } else { convertNumberToNumber(data + CHAR_BYTES, &out, *data, TSDB_DATA_TYPE_DOUBLE); } - return (int64_t)out; + *res = (int64_t)out; + SCL_RET(TSDB_CODE_SUCCESS); } _getBigintValue_fn_t getVectorBigintValueFn(int32_t srcType) { @@ -190,31 +234,29 @@ _getBigintValue_fn_t getVectorBigintValueFn(int32_t srcType) { return p; } -static FORCE_INLINE void varToTimestamp(char *buf, SScalarParam *pOut, int32_t rowIndex, int32_t *overflow) { - terrno = TSDB_CODE_SUCCESS; - +static FORCE_INLINE int32_t varToTimestamp(char *buf, SScalarParam *pOut, int32_t rowIndex, int32_t *overflow) { int64_t value = 0; + int32_t code = TSDB_CODE_SUCCESS; if (taosParseTime(buf, &value, strlen(buf), pOut->columnData->info.precision, tsDaylight) != TSDB_CODE_SUCCESS) { value = 0; - terrno = TSDB_CODE_SCALAR_CONVERT_ERROR; + code = TSDB_CODE_SCALAR_CONVERT_ERROR; } colDataSetInt64(pOut->columnData, rowIndex, &value); + SCL_RET(code); } -static FORCE_INLINE void varToSigned(char *buf, SScalarParam *pOut, int32_t rowIndex, int32_t *overflow) { - terrno = TSDB_CODE_SUCCESS; - +static FORCE_INLINE int32_t varToSigned(char *buf, SScalarParam *pOut, int32_t rowIndex, int32_t *overflow) { if (overflow) { int64_t minValue = tDataTypes[pOut->columnData->info.type].minValue; int64_t maxValue = tDataTypes[pOut->columnData->info.type].maxValue; int64_t value = (int64_t)taosStr2Int64(buf, NULL, 10); if (value > maxValue) { *overflow = 1; - return; + SCL_RET(TSDB_CODE_SUCCESS); } else if (value < minValue) { *overflow = -1; - return; + SCL_RET(TSDB_CODE_SUCCESS); } else { *overflow = 0; } @@ -243,21 +285,20 @@ static FORCE_INLINE void varToSigned(char *buf, SScalarParam *pOut, int32_t rowI break; } } + SCL_RET(TSDB_CODE_SUCCESS); } -static FORCE_INLINE void varToUnsigned(char *buf, SScalarParam *pOut, int32_t rowIndex, int32_t *overflow) { - terrno = TSDB_CODE_SUCCESS; - +static FORCE_INLINE int32_t varToUnsigned(char *buf, SScalarParam *pOut, int32_t rowIndex, int32_t *overflow) { if (overflow) { uint64_t minValue = (uint64_t)tDataTypes[pOut->columnData->info.type].minValue; uint64_t maxValue = (uint64_t)tDataTypes[pOut->columnData->info.type].maxValue; uint64_t value = (uint64_t)taosStr2UInt64(buf, NULL, 10); if (value > maxValue) { *overflow = 1; - return; + SCL_RET(TSDB_CODE_SUCCESS); } else if (value < minValue) { *overflow = -1; - return; + SCL_RET(TSDB_CODE_SUCCESS); } else { *overflow = 0; } @@ -285,150 +326,156 @@ static FORCE_INLINE void varToUnsigned(char *buf, SScalarParam *pOut, int32_t ro break; } } + SCL_RET(TSDB_CODE_SUCCESS); } -static FORCE_INLINE void varToFloat(char *buf, SScalarParam *pOut, int32_t rowIndex, int32_t *overflow) { - terrno = TSDB_CODE_SUCCESS; - +static FORCE_INLINE int32_t varToFloat(char *buf, SScalarParam *pOut, int32_t rowIndex, int32_t *overflow) { if (TSDB_DATA_TYPE_FLOAT == pOut->columnData->info.type) { float value = taosStr2Float(buf, NULL); colDataSetFloat(pOut->columnData, rowIndex, &value); - return; + SCL_RET(TSDB_CODE_SUCCESS); } double value = taosStr2Double(buf, NULL); colDataSetDouble(pOut->columnData, rowIndex, &value); + SCL_RET(TSDB_CODE_SUCCESS); } -static FORCE_INLINE void varToBool(char *buf, SScalarParam *pOut, int32_t rowIndex, int32_t *overflow) { - terrno = TSDB_CODE_SUCCESS; - +static FORCE_INLINE int32_t varToBool(char *buf, SScalarParam *pOut, int32_t rowIndex, int32_t *overflow) { int64_t value = taosStr2Int64(buf, NULL, 10); bool v = (value != 0) ? true : false; colDataSetInt8(pOut->columnData, rowIndex, (int8_t *)&v); + SCL_RET(TSDB_CODE_SUCCESS); } // todo remove this malloc -static FORCE_INLINE void varToVarbinary(char *buf, SScalarParam *pOut, int32_t rowIndex, int32_t *overflow) { - terrno = TSDB_CODE_SUCCESS; - +static FORCE_INLINE int32_t varToVarbinary(char *buf, SScalarParam *pOut, int32_t rowIndex, int32_t *overflow) { if(isHex(varDataVal(buf), varDataLen(buf))){ if(!isValidateHex(varDataVal(buf), varDataLen(buf))){ - terrno = TSDB_CODE_PAR_INVALID_VARBINARY; - return; + SCL_ERR_RET(TSDB_CODE_PAR_INVALID_VARBINARY); } void* data = NULL; uint32_t size = 0; if(taosHex2Ascii(varDataVal(buf), varDataLen(buf), &data, &size) < 0){ - terrno = TSDB_CODE_OUT_OF_MEMORY; - return; + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); } int32_t inputLen = size + VARSTR_HEADER_SIZE; char *t = taosMemoryCalloc(1, inputLen); if (t == NULL) { sclError("Out of memory"); - terrno = TSDB_CODE_OUT_OF_MEMORY; taosMemoryFree(data); - return; + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); } varDataSetLen(t, size); - memcpy(varDataVal(t), data, size); - colDataSetVal(pOut->columnData, rowIndex, t, false); + (void)memcpy(varDataVal(t), data, size); + int32_t code = colDataSetVal(pOut->columnData, rowIndex, t, false); taosMemoryFree(t); taosMemoryFree(data); + SCL_ERR_RET(code); }else{ int32_t inputLen = varDataTLen(buf); char *t = taosMemoryCalloc(1, inputLen); if (t == NULL) { sclError("Out of memory"); - terrno = TSDB_CODE_OUT_OF_MEMORY; - return; + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); } - memcpy(t, buf, inputLen); - colDataSetVal(pOut->columnData, rowIndex, t, false); + (void)memcpy(t, buf, inputLen); + int32_t code = colDataSetVal(pOut->columnData, rowIndex, t, false); taosMemoryFree(t); + SCL_ERR_RET(code); } + SCL_RET(TSDB_CODE_SUCCESS); } -static FORCE_INLINE void varToNchar(char *buf, SScalarParam *pOut, int32_t rowIndex, int32_t *overflow) { - terrno = TSDB_CODE_SUCCESS; - +static FORCE_INLINE int32_t varToNchar(char *buf, SScalarParam *pOut, int32_t rowIndex, int32_t *overflow) { int32_t len = 0; int32_t inputLen = varDataLen(buf); int32_t outputMaxLen = (inputLen + 1) * TSDB_NCHAR_SIZE + VARSTR_HEADER_SIZE; + int32_t code = TSDB_CODE_SUCCESS; char *t = taosMemoryCalloc(1, outputMaxLen); + if (NULL == t) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } int32_t ret = taosMbsToUcs4(varDataVal(buf), inputLen, (TdUcs4 *)varDataVal(t), outputMaxLen - VARSTR_HEADER_SIZE, &len); if (!ret) { sclError("failed to convert to NCHAR"); - terrno = TSDB_CODE_SCALAR_CONVERT_ERROR; + SCL_ERR_JRET(TSDB_CODE_SCALAR_CONVERT_ERROR); } varDataSetLen(t, len); - colDataSetVal(pOut->columnData, rowIndex, t, false); + SCL_ERR_JRET(colDataSetVal(pOut->columnData, rowIndex, t, false)); + +_return: taosMemoryFree(t); + SCL_RET(code); } -static FORCE_INLINE void ncharToVar(char *buf, SScalarParam *pOut, int32_t rowIndex, int32_t *overflow) { - terrno = TSDB_CODE_SUCCESS; - +static FORCE_INLINE int32_t ncharToVar(char *buf, SScalarParam *pOut, int32_t rowIndex, int32_t *overflow) { + int32_t code =TSDB_CODE_SUCCESS; int32_t inputLen = varDataLen(buf); char *t = taosMemoryCalloc(1, inputLen + VARSTR_HEADER_SIZE); + if (NULL == t) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } int32_t len = taosUcs4ToMbs((TdUcs4 *)varDataVal(buf), varDataLen(buf), varDataVal(t)); if (len < 0) { - terrno = TSDB_CODE_SCALAR_CONVERT_ERROR; - taosMemoryFree(t); - return; + SCL_ERR_JRET(TSDB_CODE_SCALAR_CONVERT_ERROR); } varDataSetLen(t, len); - colDataSetVal(pOut->columnData, rowIndex, t, false); + SCL_ERR_JRET(colDataSetVal(pOut->columnData, rowIndex, t, false)); + +_return: taosMemoryFree(t); + SCL_RET(code); } -static FORCE_INLINE void varToGeometry(char *buf, SScalarParam *pOut, int32_t rowIndex, int32_t *overflow) { +static FORCE_INLINE int32_t varToGeometry(char *buf, SScalarParam *pOut, int32_t rowIndex, int32_t *overflow) { //[ToDo] support to parse WKB as well as WKT - terrno = TSDB_CODE_SUCCESS; - + int32_t code = TSDB_CODE_SUCCESS; size_t len = 0; unsigned char *t = NULL; char *output = NULL; if (initCtxGeomFromText()) { sclError("failed to init geometry ctx, %s", getThreadLocalGeosCtx()->errMsg); - terrno = TSDB_CODE_APP_ERROR; - goto _err; + SCL_ERR_JRET(TSDB_CODE_APP_ERROR); } if (doGeomFromText(buf, &t, &len)) { sclInfo("failed to convert text to geometry, %s", getThreadLocalGeosCtx()->errMsg); - terrno = TSDB_CODE_SCALAR_CONVERT_ERROR; - goto _err; + SCL_ERR_JRET(TSDB_CODE_SCALAR_CONVERT_ERROR); } output = taosMemoryCalloc(1, len + VARSTR_HEADER_SIZE); - memcpy(output + VARSTR_HEADER_SIZE, t, len); + if (NULL == output) { + SCL_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); + } + (void)memcpy(output + VARSTR_HEADER_SIZE, t, len); varDataSetLen(output, len); - colDataSetVal(pOut->columnData, rowIndex, output, false); + SCL_ERR_JRET(colDataSetVal(pOut->columnData, rowIndex, output, false)); taosMemoryFree(output); geosFreeBuffer(t); - return; + SCL_RET(TSDB_CODE_SUCCESS); -_err: +_return: + taosMemoryFree(output); + geosFreeBuffer(t); ASSERT(t == NULL && len == 0); VarDataLenT dummyHeader = 0; - colDataSetVal(pOut->columnData, rowIndex, (const char *)&dummyHeader, false); + SCL_ERR_RET(colDataSetVal(pOut->columnData, rowIndex, (const char *)&dummyHeader, false)); + SCL_RET(code); } // TODO opt performance, tmp is not needed. int32_t vectorConvertFromVarData(SSclVectorConvCtx *pCtx, int32_t *overflow) { - terrno = TSDB_CODE_SUCCESS; - + int32_t code = TSDB_CODE_SUCCESS; bool vton = false; _bufConverteFunc func = NULL; @@ -457,8 +504,7 @@ int32_t vectorConvertFromVarData(SSclVectorConvCtx *pCtx, int32_t *overflow) { vton = true; } else { sclError("invalid convert outType:%d, inType:%d", pCtx->outType, pCtx->inType); - terrno = TSDB_CODE_APP_ERROR; - return terrno; + SCL_ERR_RET(TSDB_CODE_APP_ERROR); } pCtx->pOut->numOfRows = pCtx->pIn->numOfRows; @@ -477,8 +523,7 @@ int32_t vectorConvertFromVarData(SSclVectorConvCtx *pCtx, int32_t *overflow) { data += CHAR_BYTES; convertType = TSDB_DATA_TYPE_NCHAR; } else if (tTagIsJson(data) || *data == TSDB_DATA_TYPE_NULL) { - terrno = TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR; - goto _err; + SCL_ERR_JRET(TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR); } else { convertNumberToNumber(data + CHAR_BYTES, colDataGetNumData(pCtx->pOut->columnData, i), *data, pCtx->outType); continue; @@ -490,103 +535,99 @@ int32_t vectorConvertFromVarData(SSclVectorConvCtx *pCtx, int32_t *overflow) { tmp = taosMemoryMalloc(bufSize); if (tmp == NULL) { sclError("out of memory in vectorConvertFromVarData"); - terrno = TSDB_CODE_OUT_OF_MEMORY; - goto _err; + SCL_ERR_JRET(TSDB_CODE_OUT_OF_MEMORY); } } if (vton) { - memcpy(tmp, data, varDataTLen(data)); + (void)memcpy(tmp, data, varDataTLen(data)); } else { if (TSDB_DATA_TYPE_VARCHAR == convertType || TSDB_DATA_TYPE_GEOMETRY == convertType) { - memcpy(tmp, varDataVal(data), varDataLen(data)); + (void)memcpy(tmp, varDataVal(data), varDataLen(data)); tmp[varDataLen(data)] = 0; } else if (TSDB_DATA_TYPE_NCHAR == convertType) { // we need to convert it to native char string, and then perform the string to numeric data if (varDataLen(data) > bufSize) { sclError("castConvert convert buffer size too small"); - terrno = TSDB_CODE_APP_ERROR; - goto _err; + SCL_ERR_JRET(TSDB_CODE_APP_ERROR); } int len = taosUcs4ToMbs((TdUcs4 *)varDataVal(data), varDataLen(data), tmp); if (len < 0) { sclError("castConvert taosUcs4ToMbs error 1"); - terrno = TSDB_CODE_SCALAR_CONVERT_ERROR; - goto _err; + SCL_ERR_JRET(TSDB_CODE_SCALAR_CONVERT_ERROR); } tmp[len] = 0; } } - (*func)(tmp, pCtx->pOut, i, overflow); - if (terrno != TSDB_CODE_SUCCESS) { - goto _err; - } + SCL_ERR_JRET((*func)(tmp, pCtx->pOut, i, overflow)); } -_err: +_return: if (tmp != NULL) { taosMemoryFreeClear(tmp); } - return terrno; + SCL_RET(code); } -double getVectorDoubleValue_JSON(void *src, int32_t index) { +int32_t getVectorDoubleValue_JSON(void *src, int32_t index, double *out) { char *data = colDataGetVarData((SColumnInfoData *)src, index); - double out = 0; + *out = 0; if (*data == TSDB_DATA_TYPE_NULL) { - return out; + SCL_RET(TSDB_CODE_SUCCESS); } else if (*data == TSDB_DATA_TYPE_NCHAR) { // json inner type can not be BINARY - convertNcharToDouble(data + CHAR_BYTES, &out); + SCL_ERR_RET(convertNcharToDouble(data + CHAR_BYTES, out)); } else if (tTagIsJson(data)) { - terrno = TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR; - return 0; + SCL_ERR_RET(TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR); } else { - convertNumberToNumber(data + CHAR_BYTES, &out, *data, TSDB_DATA_TYPE_DOUBLE); + convertNumberToNumber(data + CHAR_BYTES, out, *data, TSDB_DATA_TYPE_DOUBLE); } - return out; + SCL_RET(TSDB_CODE_SUCCESS); } -void *ncharTobinary(void *buf) { // todo need to remove , if tobinary is nchar +int32_t ncharTobinary(void *buf, void **out) { // todo need to remove , if tobinary is nchar int32_t inputLen = varDataTLen(buf); - void *t = taosMemoryCalloc(1, inputLen); - int32_t len = taosUcs4ToMbs((TdUcs4 *)varDataVal(buf), varDataLen(buf), varDataVal(t)); + *out = taosMemoryCalloc(1, inputLen); + int32_t len = taosUcs4ToMbs((TdUcs4 *)varDataVal(buf), varDataLen(buf), varDataVal(*out)); if (len < 0) { sclError("charset:%s to %s. val:%s convert ncharTobinary failed.", DEFAULT_UNICODE_ENCODEC, tsCharset, (char *)varDataVal(buf)); - taosMemoryFree(t); - return NULL; + taosMemoryFree(*out); + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); } - varDataSetLen(t, len); - return t; + varDataSetLen(*out, len); + SCL_RET(TSDB_CODE_SUCCESS); } -bool convertJsonValue(__compar_fn_t *fp, int32_t optr, int8_t typeLeft, int8_t typeRight, char **pLeftData, +int32_t convertJsonValue(__compar_fn_t *fp, int32_t optr, int8_t typeLeft, int8_t typeRight, char **pLeftData, char **pRightData, void *pLeftOut, void *pRightOut, bool *isNull, bool *freeLeft, - bool *freeRight) { + bool *freeRight, bool *result) { + *result = false; if (optr == OP_TYPE_JSON_CONTAINS) { - return true; + *result = true; + return TSDB_CODE_SUCCESS; } if (typeLeft != TSDB_DATA_TYPE_JSON && typeRight != TSDB_DATA_TYPE_JSON) { - return true; + *result = true; + return TSDB_CODE_SUCCESS; } if (typeLeft == TSDB_DATA_TYPE_JSON) { if (tTagIsJson(*pLeftData)) { - terrno = TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR; - return false; + *result = false; + return TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR; } typeLeft = **pLeftData; (*pLeftData)++; } if (typeRight == TSDB_DATA_TYPE_JSON) { if (tTagIsJson(*pRightData)) { - terrno = TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR; - return false; + *result = false; + return TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR; } typeRight = **pRightData; (*pRightData)++; @@ -595,7 +636,8 @@ bool convertJsonValue(__compar_fn_t *fp, int32_t optr, int8_t typeLeft, int8_t t if (optr == OP_TYPE_LIKE || optr == OP_TYPE_NOT_LIKE || optr == OP_TYPE_MATCH || optr == OP_TYPE_NMATCH) { if (typeLeft != TSDB_DATA_TYPE_NCHAR && typeLeft != TSDB_DATA_TYPE_BINARY && typeLeft != TSDB_DATA_TYPE_GEOMETRY && typeLeft != TSDB_DATA_TYPE_VARBINARY) { - return false; + *result = false; + return TSDB_CODE_SUCCESS; } } @@ -605,27 +647,31 @@ bool convertJsonValue(__compar_fn_t *fp, int32_t optr, int8_t typeLeft, int8_t t (IS_VAR_DATA_TYPE(typeLeft) && !IS_VAR_DATA_TYPE(typeRight)) || (IS_VAR_DATA_TYPE(typeRight) && !IS_VAR_DATA_TYPE(typeLeft)) || ((typeLeft == TSDB_DATA_TYPE_BOOL) && (typeRight != TSDB_DATA_TYPE_BOOL)) || - ((typeRight == TSDB_DATA_TYPE_BOOL) && (typeLeft != TSDB_DATA_TYPE_BOOL))) - return false; + ((typeRight == TSDB_DATA_TYPE_BOOL) && (typeLeft != TSDB_DATA_TYPE_BOOL))) { + *result = false; + return TSDB_CODE_SUCCESS; + } if (typeLeft == TSDB_DATA_TYPE_NULL || typeRight == TSDB_DATA_TYPE_NULL) { *isNull = true; - return true; + *result = true; + return TSDB_CODE_SUCCESS; } - int8_t type = vectorGetConvertType(typeLeft, typeRight); + int8_t type = (int8_t)vectorGetConvertType(typeLeft, typeRight); if (type == 0) { - *fp = filterGetCompFunc(typeLeft, optr); - return true; + *result = true; + SCL_RET(filterGetCompFunc(fp, typeLeft, optr)); } - *fp = filterGetCompFunc(type, optr); + SCL_ERR_RET(filterGetCompFunc(fp, type, optr)); if (IS_NUMERIC_TYPE(type)) { if (typeLeft == TSDB_DATA_TYPE_NCHAR || typeLeft == TSDB_DATA_TYPE_VARCHAR || typeLeft == TSDB_DATA_TYPE_GEOMETRY) { - return false; + *result = false; + return TSDB_CODE_SUCCESS; } else if (typeLeft != type) { convertNumberToNumber(*pLeftData, pLeftOut, typeLeft, type); *pLeftData = pLeftOut; @@ -634,7 +680,8 @@ bool convertJsonValue(__compar_fn_t *fp, int32_t optr, int8_t typeLeft, int8_t t if (typeRight == TSDB_DATA_TYPE_NCHAR || typeRight == TSDB_DATA_TYPE_VARCHAR || typeRight == TSDB_DATA_TYPE_GEOMETRY) { - return false; + *result = false; + return TSDB_CODE_SUCCESS; } else if (typeRight != type) { convertNumberToNumber(*pRightData, pRightOut, typeRight, type); *pRightData = pRightOut; @@ -642,18 +689,24 @@ bool convertJsonValue(__compar_fn_t *fp, int32_t optr, int8_t typeLeft, int8_t t } else if (type == TSDB_DATA_TYPE_BINARY || type == TSDB_DATA_TYPE_GEOMETRY) { if (typeLeft == TSDB_DATA_TYPE_NCHAR) { - *pLeftData = ncharTobinary(*pLeftData); + char *tmpLeft = NULL; + SCL_ERR_RET(ncharTobinary(*pLeftData, (void *)&tmpLeft)); + *pLeftData = tmpLeft; *freeLeft = true; } if (typeRight == TSDB_DATA_TYPE_NCHAR) { - *pRightData = ncharTobinary(*pRightData); + char *tmpRight = NULL; + SCL_ERR_RET(ncharTobinary(*pRightData, (void *)&tmpRight)); + *pRightData = tmpRight; *freeRight = true; } } else { - return false; + *result = false; + return TSDB_CODE_SUCCESS; } - return true; + *result = true; + return TSDB_CODE_SUCCESS; } int32_t vectorConvertToVarData(SSclVectorConvCtx *pCtx) { @@ -674,9 +727,9 @@ int32_t vectorConvertToVarData(SSclVectorConvCtx *pCtx) { int32_t len = sprintf(varDataVal(tmp), "%" PRId64, value); varDataLen(tmp) = len; if (pCtx->outType == TSDB_DATA_TYPE_NCHAR) { - varToNchar(tmp, pCtx->pOut, i, NULL); + SCL_ERR_RET(varToNchar(tmp, pCtx->pOut, i, NULL)); } else { - colDataSetVal(pOutputCol, i, (char *)tmp, false); + SCL_ERR_RET(colDataSetVal(pOutputCol, i, (char *)tmp, false)); } } } else if (IS_UNSIGNED_NUMERIC_TYPE(pCtx->inType)) { @@ -691,9 +744,9 @@ int32_t vectorConvertToVarData(SSclVectorConvCtx *pCtx) { int32_t len = sprintf(varDataVal(tmp), "%" PRIu64, value); varDataLen(tmp) = len; if (pCtx->outType == TSDB_DATA_TYPE_NCHAR) { - varToNchar(tmp, pCtx->pOut, i, NULL); + SCL_ERR_RET(varToNchar(tmp, pCtx->pOut, i, NULL)); } else { - colDataSetVal(pOutputCol, i, (char *)tmp, false); + SCL_ERR_RET(colDataSetVal(pOutputCol, i, (char *)tmp, false)); } } } else if (IS_FLOAT_TYPE(pCtx->inType)) { @@ -708,9 +761,9 @@ int32_t vectorConvertToVarData(SSclVectorConvCtx *pCtx) { int32_t len = sprintf(varDataVal(tmp), "%lf", value); varDataLen(tmp) = len; if (pCtx->outType == TSDB_DATA_TYPE_NCHAR) { - varToNchar(tmp, pCtx->pOut, i, NULL); + SCL_ERR_RET(varToNchar(tmp, pCtx->pOut, i, NULL)); } else { - colDataSetVal(pOutputCol, i, (char *)tmp, false); + SCL_ERR_RET(colDataSetVal(pOutputCol, i, (char *)tmp, false)); } } } else { @@ -1075,7 +1128,7 @@ enum { }; // TODO not correct for descending order scan -static void vectorMathAddHelper(SColumnInfoData *pLeftCol, SColumnInfoData *pRightCol, SColumnInfoData *pOutputCol, +static int32_t vectorMathAddHelper(SColumnInfoData *pLeftCol, SColumnInfoData *pRightCol, SColumnInfoData *pOutputCol, int32_t numOfRows, int32_t step, int32_t i) { _getDoubleValue_fn_t getVectorDoubleValueFnLeft = getVectorDoubleValueFn(pLeftCol->info.type); _getDoubleValue_fn_t getVectorDoubleValueFnRight = getVectorDoubleValueFn(pRightCol->info.type); @@ -1090,12 +1143,17 @@ static void vectorMathAddHelper(SColumnInfoData *pLeftCol, SColumnInfoData *pRig colDataSetNULL(pOutputCol, i); continue; // TODO set null or ignore } - *output = getVectorDoubleValueFnLeft(LEFT_COL, i) + getVectorDoubleValueFnRight(RIGHT_COL, 0); + double leftRes = 0; + double rightRes = 0; + SCL_ERR_RET(getVectorDoubleValueFnLeft(LEFT_COL, i, &leftRes)); + SCL_ERR_RET(getVectorDoubleValueFnRight(RIGHT_COL, 0, &rightRes)); + *output = leftRes + rightRes; } } + SCL_RET(TSDB_CODE_SUCCESS); } -static void vectorMathTsAddHelper(SColumnInfoData *pLeftCol, SColumnInfoData *pRightCol, SColumnInfoData *pOutputCol, +static int32_t vectorMathTsAddHelper(SColumnInfoData *pLeftCol, SColumnInfoData *pRightCol, SColumnInfoData *pOutputCol, int32_t numOfRows, int32_t step, int32_t i) { _getBigintValue_fn_t getVectorBigintValueFnLeft = getVectorBigintValueFn(pLeftCol->info.type); _getBigintValue_fn_t getVectorBigintValueFnRight = getVectorBigintValueFn(pRightCol->info.type); @@ -1110,32 +1168,38 @@ static void vectorMathTsAddHelper(SColumnInfoData *pLeftCol, SColumnInfoData *pR colDataSetNULL(pOutputCol, i); continue; // TODO set null or ignore } + int64_t leftRes = 0; + int64_t rightRes = 0; + SCL_ERR_RET(getVectorBigintValueFnLeft(pLeftCol->pData, i, &leftRes)); + SCL_ERR_RET(getVectorBigintValueFnRight(pRightCol->pData, 0, &rightRes)); *output = - taosTimeAdd(getVectorBigintValueFnLeft(pLeftCol->pData, i), getVectorBigintValueFnRight(pRightCol->pData, 0), - pRightCol->info.scale, pRightCol->info.precision); + taosTimeAdd(leftRes, rightRes, pRightCol->info.scale, pRightCol->info.precision); } } + SCL_RET(TSDB_CODE_SUCCESS); } -static SColumnInfoData *vectorConvertVarToDouble(SScalarParam *pInput, int32_t *converted) { +static int32_t vectorConvertVarToDouble(SScalarParam *pInput, int32_t *converted, SColumnInfoData **pOutputCol) { SScalarParam output = {0}; SColumnInfoData *pCol = pInput->columnData; if (IS_VAR_DATA_TYPE(pCol->info.type) && pCol->info.type != TSDB_DATA_TYPE_JSON && pCol->info.type != TSDB_DATA_TYPE_VARBINARY) { int32_t code = vectorConvertSingleCol(pInput, &output, TSDB_DATA_TYPE_DOUBLE, -1, -1); if (code != TSDB_CODE_SUCCESS) { - terrno = code; - return NULL; + *pOutputCol = NULL; + SCL_ERR_RET(code); } *converted = VECTOR_DO_CONVERT; - return output.columnData; + *pOutputCol = output.columnData; + SCL_RET(code); } *converted = VECTOR_UN_CONVERT; - return pInput->columnData; + *pOutputCol = pInput->columnData; + SCL_RET(TSDB_CODE_SUCCESS); } static void doReleaseVec(SColumnInfoData *pCol, int32_t type) { @@ -1145,7 +1209,7 @@ static void doReleaseVec(SColumnInfoData *pCol, int32_t type) { } } -void vectorMathAdd(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { +int32_t vectorMathAdd(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { SColumnInfoData *pOutputCol = pOut->columnData; int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : TMAX(pLeft->numOfRows, pRight->numOfRows) - 1; @@ -1153,9 +1217,12 @@ void vectorMathAdd(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut pOut->numOfRows = TMAX(pLeft->numOfRows, pRight->numOfRows); + int32_t code = TSDB_CODE_SUCCESS; int32_t leftConvert = 0, rightConvert = 0; - SColumnInfoData *pLeftCol = vectorConvertVarToDouble(pLeft, &leftConvert); - SColumnInfoData *pRightCol = vectorConvertVarToDouble(pRight, &rightConvert); + SColumnInfoData *pLeftCol = NULL; + SColumnInfoData *pRightCol = NULL; + SCL_ERR_JRET(vectorConvertVarToDouble(pLeft, &leftConvert, &pLeftCol)); + SCL_ERR_JRET(vectorConvertVarToDouble(pRight, &rightConvert, &pRightCol)); if ((GET_PARAM_TYPE(pLeft) == TSDB_DATA_TYPE_TIMESTAMP && IS_INTEGER_TYPE(GET_PARAM_TYPE(pRight))) || (GET_PARAM_TYPE(pRight) == TSDB_DATA_TYPE_TIMESTAMP && IS_INTEGER_TYPE(GET_PARAM_TYPE(pLeft))) || @@ -1168,21 +1235,25 @@ void vectorMathAdd(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut if (pLeft->numOfRows == 1 && pRight->numOfRows == 1) { if (GET_PARAM_TYPE(pLeft) == TSDB_DATA_TYPE_TIMESTAMP) { - vectorMathTsAddHelper(pLeftCol, pRightCol, pOutputCol, pRight->numOfRows, step, i); + SCL_ERR_JRET(vectorMathTsAddHelper(pLeftCol, pRightCol, pOutputCol, pRight->numOfRows, step, i)); } else { - vectorMathTsAddHelper(pRightCol, pLeftCol, pOutputCol, pRight->numOfRows, step, i); + SCL_ERR_JRET(vectorMathTsAddHelper(pRightCol, pLeftCol, pOutputCol, pRight->numOfRows, step, i)); } } else if (pLeft->numOfRows == 1) { - vectorMathTsAddHelper(pRightCol, pLeftCol, pOutputCol, pRight->numOfRows, step, i); + SCL_ERR_JRET(vectorMathTsAddHelper(pRightCol, pLeftCol, pOutputCol, pRight->numOfRows, step, i)); } else if (pRight->numOfRows == 1) { - vectorMathTsAddHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, i); + SCL_ERR_JRET(vectorMathTsAddHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, i)); } else if (pLeft->numOfRows == pRight->numOfRows) { for (; i < pRight->numOfRows && i >= 0; i += step, output += 1) { if (IS_NULL) { colDataSetNULL(pOutputCol, i); continue; // TODO set null or ignore } - *output = getVectorBigintValueFnLeft(pLeftCol->pData, i) + getVectorBigintValueFnRight(pRightCol->pData, i); + int64_t leftRes = 0; + int64_t rightRes = 0; + SCL_ERR_JRET(getVectorBigintValueFnLeft(pLeftCol->pData, i, &leftRes)); + SCL_ERR_JRET(getVectorBigintValueFnRight(pRightCol->pData, i, &rightRes)); + *output = leftRes + rightRes; } } } else { @@ -1196,21 +1267,27 @@ void vectorMathAdd(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut colDataSetNULL(pOutputCol, i); continue; // TODO set null or ignore } - *output = getVectorDoubleValueFnLeft(LEFT_COL, i) + getVectorDoubleValueFnRight(RIGHT_COL, i); + double leftRes = 0; + double rightRes = 0; + SCL_ERR_JRET(getVectorDoubleValueFnLeft(LEFT_COL, i, &leftRes)); + SCL_ERR_JRET(getVectorDoubleValueFnRight(RIGHT_COL, i, &rightRes)); + *output = leftRes + rightRes; } } else if (pLeft->numOfRows == 1) { - vectorMathAddHelper(pRightCol, pLeftCol, pOutputCol, pRight->numOfRows, step, i); + SCL_ERR_JRET(vectorMathAddHelper(pRightCol, pLeftCol, pOutputCol, pRight->numOfRows, step, i)); } else if (pRight->numOfRows == 1) { - vectorMathAddHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, i); + SCL_ERR_JRET(vectorMathAddHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, i)); } } +_return: doReleaseVec(pLeftCol, leftConvert); doReleaseVec(pRightCol, rightConvert); + SCL_RET(code); } // TODO not correct for descending order scan -static void vectorMathSubHelper(SColumnInfoData *pLeftCol, SColumnInfoData *pRightCol, SColumnInfoData *pOutputCol, +static int32_t vectorMathSubHelper(SColumnInfoData *pLeftCol, SColumnInfoData *pRightCol, SColumnInfoData *pOutputCol, int32_t numOfRows, int32_t step, int32_t factor, int32_t i) { _getDoubleValue_fn_t getVectorDoubleValueFnLeft = getVectorDoubleValueFn(pLeftCol->info.type); _getDoubleValue_fn_t getVectorDoubleValueFnRight = getVectorDoubleValueFn(pRightCol->info.type); @@ -1225,12 +1302,17 @@ static void vectorMathSubHelper(SColumnInfoData *pLeftCol, SColumnInfoData *pRig colDataSetNULL(pOutputCol, i); continue; // TODO set null or ignore } - *output = (getVectorDoubleValueFnLeft(LEFT_COL, i) - getVectorDoubleValueFnRight(RIGHT_COL, 0)) * factor; + double leftRes = 0; + double rightRes = 0; + SCL_ERR_RET(getVectorDoubleValueFnLeft(LEFT_COL, i, &leftRes)); + SCL_ERR_RET(getVectorDoubleValueFnRight(RIGHT_COL, 0, &rightRes)); + *output = (leftRes - rightRes) * factor; } } + SCL_RET(TSDB_CODE_SUCCESS); } -static void vectorMathTsSubHelper(SColumnInfoData *pLeftCol, SColumnInfoData *pRightCol, SColumnInfoData *pOutputCol, +static int32_t vectorMathTsSubHelper(SColumnInfoData *pLeftCol, SColumnInfoData *pRightCol, SColumnInfoData *pOutputCol, int32_t numOfRows, int32_t step, int32_t factor, int32_t i) { _getBigintValue_fn_t getVectorBigintValueFnLeft = getVectorBigintValueFn(pLeftCol->info.type); _getBigintValue_fn_t getVectorBigintValueFnRight = getVectorBigintValueFn(pRightCol->info.type); @@ -1245,24 +1327,31 @@ static void vectorMathTsSubHelper(SColumnInfoData *pLeftCol, SColumnInfoData *pR colDataSetNULL(pOutputCol, i); continue; // TODO set null or ignore } + int64_t leftRes = 0; + int64_t rightRes = 0; + SCL_ERR_RET(getVectorBigintValueFnLeft(pLeftCol->pData, i, &leftRes)); + SCL_ERR_RET(getVectorBigintValueFnRight(pRightCol->pData, 0, &rightRes)); *output = - taosTimeAdd(getVectorBigintValueFnLeft(pLeftCol->pData, i), -getVectorBigintValueFnRight(pRightCol->pData, 0), - pRightCol->info.scale, pRightCol->info.precision); + taosTimeAdd(leftRes, -rightRes, pRightCol->info.scale, pRightCol->info.precision); } } + SCL_RET(TSDB_CODE_SUCCESS); } -void vectorMathSub(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { +int32_t vectorMathSub(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { SColumnInfoData *pOutputCol = pOut->columnData; pOut->numOfRows = TMAX(pLeft->numOfRows, pRight->numOfRows); + int32_t code = TSDB_CODE_SUCCESS; int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : TMAX(pLeft->numOfRows, pRight->numOfRows) - 1; int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1; int32_t leftConvert = 0, rightConvert = 0; - SColumnInfoData *pLeftCol = vectorConvertVarToDouble(pLeft, &leftConvert); - SColumnInfoData *pRightCol = vectorConvertVarToDouble(pRight, &rightConvert); + SColumnInfoData *pLeftCol = NULL; + SColumnInfoData *pRightCol = NULL; + SCL_ERR_JRET(vectorConvertVarToDouble(pLeft, &leftConvert, &pLeftCol)); + SCL_ERR_JRET(vectorConvertVarToDouble(pRight, &rightConvert, &pRightCol)); if ((GET_PARAM_TYPE(pLeft) == TSDB_DATA_TYPE_TIMESTAMP && GET_PARAM_TYPE(pRight) == TSDB_DATA_TYPE_BIGINT) || (GET_PARAM_TYPE(pRight) == TSDB_DATA_TYPE_TIMESTAMP && @@ -1272,18 +1361,22 @@ void vectorMathSub(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut _getBigintValue_fn_t getVectorBigintValueFnRight = getVectorBigintValueFn(pRightCol->info.type); if (pLeft->numOfRows == 1 && pRight->numOfRows == 1) { - vectorMathTsSubHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, 1, i); + SCL_ERR_JRET(vectorMathTsSubHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, 1, i)); } else if (pLeft->numOfRows == 1) { - vectorMathTsSubHelper(pRightCol, pLeftCol, pOutputCol, pRight->numOfRows, step, -1, i); + SCL_ERR_JRET(vectorMathTsSubHelper(pRightCol, pLeftCol, pOutputCol, pRight->numOfRows, step, -1, i)); } else if (pRight->numOfRows == 1) { - vectorMathTsSubHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, 1, i); + SCL_ERR_JRET(vectorMathTsSubHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, 1, i)); } else if (pLeft->numOfRows == pRight->numOfRows) { for (; i < pRight->numOfRows && i >= 0; i += step, output += 1) { if (IS_NULL) { colDataSetNULL(pOutputCol, i); continue; // TODO set null or ignore } - *output = getVectorBigintValueFnLeft(pLeftCol->pData, i) - getVectorBigintValueFnRight(pRightCol->pData, i); + int64_t leftRes = 0; + int64_t rightRes = 0; + SCL_ERR_JRET(getVectorBigintValueFnLeft(pLeftCol->pData, i, &leftRes)); + SCL_ERR_JRET(getVectorBigintValueFnRight(pRightCol->pData, i, &rightRes)); + *output = leftRes - rightRes; } } } else { @@ -1297,21 +1390,27 @@ void vectorMathSub(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut colDataSetNULL(pOutputCol, i); continue; // TODO set null or ignore } - *output = getVectorDoubleValueFnLeft(LEFT_COL, i) - getVectorDoubleValueFnRight(RIGHT_COL, i); + double leftRes = 0; + double rightRes = 0; + SCL_ERR_JRET(getVectorDoubleValueFnLeft(LEFT_COL, i, &leftRes)); + SCL_ERR_JRET(getVectorDoubleValueFnRight(RIGHT_COL, i, &rightRes)); + *output = leftRes - rightRes; } } else if (pLeft->numOfRows == 1) { - vectorMathSubHelper(pRightCol, pLeftCol, pOutputCol, pRight->numOfRows, step, -1, i); + SCL_ERR_JRET(vectorMathSubHelper(pRightCol, pLeftCol, pOutputCol, pRight->numOfRows, step, -1, i)); } else if (pRight->numOfRows == 1) { - vectorMathSubHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, 1, i); + SCL_ERR_JRET(vectorMathSubHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, 1, i)); } } +_return: doReleaseVec(pLeftCol, leftConvert); doReleaseVec(pRightCol, rightConvert); + SCL_RET(code); } // TODO not correct for descending order scan -static void vectorMathMultiplyHelper(SColumnInfoData *pLeftCol, SColumnInfoData *pRightCol, SColumnInfoData *pOutputCol, +static int32_t vectorMathMultiplyHelper(SColumnInfoData *pLeftCol, SColumnInfoData *pRightCol, SColumnInfoData *pOutputCol, int32_t numOfRows, int32_t step, int32_t i) { _getDoubleValue_fn_t getVectorDoubleValueFnLeft = getVectorDoubleValueFn(pLeftCol->info.type); _getDoubleValue_fn_t getVectorDoubleValueFnRight = getVectorDoubleValueFn(pRightCol->info.type); @@ -1326,21 +1425,29 @@ static void vectorMathMultiplyHelper(SColumnInfoData *pLeftCol, SColumnInfoData colDataSetNULL(pOutputCol, i); continue; // TODO set null or ignore } - *output = getVectorDoubleValueFnLeft(LEFT_COL, i) * getVectorDoubleValueFnRight(RIGHT_COL, 0); + double leftRes = 0; + double rightRes = 0; + SCL_ERR_RET(getVectorDoubleValueFnLeft(LEFT_COL, i, &leftRes)); + SCL_ERR_RET(getVectorDoubleValueFnRight(RIGHT_COL, 0, &rightRes)); + *output = leftRes * rightRes; } } + SCL_RET(TSDB_CODE_SUCCESS); } -void vectorMathMultiply(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { +int32_t vectorMathMultiply(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { SColumnInfoData *pOutputCol = pOut->columnData; pOut->numOfRows = TMAX(pLeft->numOfRows, pRight->numOfRows); + int32_t code = TSDB_CODE_SUCCESS; int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : TMAX(pLeft->numOfRows, pRight->numOfRows) - 1; int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1; int32_t leftConvert = 0, rightConvert = 0; - SColumnInfoData *pLeftCol = vectorConvertVarToDouble(pLeft, &leftConvert); - SColumnInfoData *pRightCol = vectorConvertVarToDouble(pRight, &rightConvert); + SColumnInfoData *pLeftCol = NULL; + SColumnInfoData *pRightCol = NULL; + SCL_ERR_JRET(vectorConvertVarToDouble(pLeft, &leftConvert, &pLeftCol)); + SCL_ERR_JRET(vectorConvertVarToDouble(pRight, &rightConvert, &pRightCol)); _getDoubleValue_fn_t getVectorDoubleValueFnLeft = getVectorDoubleValueFn(pLeftCol->info.type); _getDoubleValue_fn_t getVectorDoubleValueFnRight = getVectorDoubleValueFn(pRightCol->info.type); @@ -1352,28 +1459,37 @@ void vectorMathMultiply(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam colDataSetNULL(pOutputCol, i); continue; // TODO set null or ignore } - *output = getVectorDoubleValueFnLeft(LEFT_COL, i) * getVectorDoubleValueFnRight(RIGHT_COL, i); + double leftRes = 0; + double rightRes = 0; + SCL_ERR_JRET(getVectorDoubleValueFnLeft(LEFT_COL, i, &leftRes)); + SCL_ERR_JRET(getVectorDoubleValueFnRight(RIGHT_COL, i, &rightRes)); + *output = leftRes * rightRes; } } else if (pLeft->numOfRows == 1) { - vectorMathMultiplyHelper(pRightCol, pLeftCol, pOutputCol, pRight->numOfRows, step, i); + SCL_ERR_JRET(vectorMathMultiplyHelper(pRightCol, pLeftCol, pOutputCol, pRight->numOfRows, step, i)); } else if (pRight->numOfRows == 1) { - vectorMathMultiplyHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, i); + SCL_ERR_JRET(vectorMathMultiplyHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, i)); } +_return: doReleaseVec(pLeftCol, leftConvert); doReleaseVec(pRightCol, rightConvert); + SCL_RET(code); } -void vectorMathDivide(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { +int32_t vectorMathDivide(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { SColumnInfoData *pOutputCol = pOut->columnData; pOut->numOfRows = TMAX(pLeft->numOfRows, pRight->numOfRows); + int32_t code = TSDB_CODE_SUCCESS; int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : TMAX(pLeft->numOfRows, pRight->numOfRows) - 1; int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1; int32_t leftConvert = 0, rightConvert = 0; - SColumnInfoData *pLeftCol = vectorConvertVarToDouble(pLeft, &leftConvert); - SColumnInfoData *pRightCol = vectorConvertVarToDouble(pRight, &rightConvert); + SColumnInfoData *pLeftCol = NULL; + SColumnInfoData *pRightCol = NULL; + SCL_ERR_JRET(vectorConvertVarToDouble(pLeft, &leftConvert, &pLeftCol)); + SCL_ERR_JRET(vectorConvertVarToDouble(pRight, &rightConvert, &pRightCol)); _getDoubleValue_fn_t getVectorDoubleValueFnLeft = getVectorDoubleValueFn(pLeftCol->info.type); _getDoubleValue_fn_t getVectorDoubleValueFnRight = getVectorDoubleValueFn(pRightCol->info.type); @@ -1381,53 +1497,81 @@ void vectorMathDivide(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *p double *output = (double *)pOutputCol->pData; if (pLeft->numOfRows == pRight->numOfRows) { for (; i < pRight->numOfRows && i >= 0; i += step, output += 1) { - if (IS_NULL || (getVectorDoubleValueFnRight(RIGHT_COL, i) == 0)) { // divide by 0 check + if (IS_NULL) { // divide by 0 check colDataSetNULL(pOutputCol, i); continue; } - *output = getVectorDoubleValueFnLeft(LEFT_COL, i) / getVectorDoubleValueFnRight(RIGHT_COL, i); + double rightRes = 0; + SCL_ERR_JRET((getVectorDoubleValueFnRight(RIGHT_COL, i, &rightRes))); + if (rightRes == 0) { + colDataSetNULL(pOutputCol, i); + continue; + } + double leftRes = 0; + SCL_ERR_JRET(getVectorDoubleValueFnLeft(LEFT_COL, i, &leftRes)); + *output = leftRes / rightRes; } } else if (pLeft->numOfRows == 1) { if (IS_HELPER_NULL(pLeftCol, 0)) { // Set pLeft->numOfRows NULL value colDataSetNNULL(pOutputCol, 0, pRight->numOfRows); } else { for (; i >= 0 && i < pRight->numOfRows; i += step, output += 1) { - if (IS_HELPER_NULL(pRightCol, i) || (getVectorDoubleValueFnRight(RIGHT_COL, i) == 0)) { // divide by 0 check + if (IS_HELPER_NULL(pRightCol, i)) { // divide by 0 check colDataSetNULL(pOutputCol, i); continue; } - *output = getVectorDoubleValueFnLeft(LEFT_COL, 0) / getVectorDoubleValueFnRight(RIGHT_COL, i); + double rightRes = 0; + SCL_ERR_JRET((getVectorDoubleValueFnRight(RIGHT_COL, i, &rightRes))); + if (rightRes == 0) { + colDataSetNULL(pOutputCol, i); + continue; + } + double leftRes = 0; + SCL_ERR_JRET(getVectorDoubleValueFnLeft(LEFT_COL, 0, &leftRes)); + *output = leftRes / rightRes; } } } else if (pRight->numOfRows == 1) { - if (IS_HELPER_NULL(pRightCol, 0) || - (getVectorDoubleValueFnRight(RIGHT_COL, 0) == 0)) { // Set pLeft->numOfRows NULL value (divde by 0 check) + if (IS_HELPER_NULL(pRightCol, 0)) { // Set pLeft->numOfRows NULL value (divde by 0 check) colDataSetNNULL(pOutputCol, 0, pLeft->numOfRows); } else { - for (; i >= 0 && i < pLeft->numOfRows; i += step, output += 1) { - if (IS_HELPER_NULL(pLeftCol, i)) { - colDataSetNULL(pOutputCol, i); - continue; + double rightRes = 0; + SCL_ERR_JRET((getVectorDoubleValueFnRight(RIGHT_COL, 0, &rightRes))); + if (rightRes == 0) { + colDataSetNNULL(pOutputCol, 0, pLeft->numOfRows); + } else { + for (; i >= 0 && i < pLeft->numOfRows; i += step, output += 1) { + if (IS_HELPER_NULL(pLeftCol, i)) { + colDataSetNULL(pOutputCol, i); + continue; + } + double leftRes = 0; + SCL_ERR_JRET(getVectorDoubleValueFnLeft(LEFT_COL, i, &leftRes)); + *output = leftRes / rightRes; } - *output = getVectorDoubleValueFnLeft(LEFT_COL, i) / getVectorDoubleValueFnRight(RIGHT_COL, 0); } } } +_return: doReleaseVec(pLeftCol, leftConvert); doReleaseVec(pRightCol, rightConvert); + SCL_RET(code); } -void vectorMathRemainder(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { +int32_t vectorMathRemainder(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { SColumnInfoData *pOutputCol = pOut->columnData; pOut->numOfRows = TMAX(pLeft->numOfRows, pRight->numOfRows); + int32_t code = TSDB_CODE_SUCCESS; int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : TMAX(pLeft->numOfRows, pRight->numOfRows) - 1; int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1; int32_t leftConvert = 0, rightConvert = 0; - SColumnInfoData *pLeftCol = vectorConvertVarToDouble(pLeft, &leftConvert); - SColumnInfoData *pRightCol = vectorConvertVarToDouble(pRight, &rightConvert); + SColumnInfoData *pLeftCol = NULL; + SColumnInfoData *pRightCol = NULL; + SCL_ERR_JRET(vectorConvertVarToDouble(pLeft, &leftConvert, &pLeftCol)); + SCL_ERR_JRET(vectorConvertVarToDouble(pRight, &rightConvert, &pRightCol)); _getDoubleValue_fn_t getVectorDoubleValueFnLeft = getVectorDoubleValueFn(pLeftCol->info.type); _getDoubleValue_fn_t getVectorDoubleValueFnRight = getVectorDoubleValueFn(pRightCol->info.type); @@ -1441,8 +1585,10 @@ void vectorMathRemainder(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam continue; } - double lx = getVectorDoubleValueFnLeft(LEFT_COL, i); - double rx = getVectorDoubleValueFnRight(RIGHT_COL, i); + double lx = 0; + double rx = 0; + SCL_ERR_JRET(getVectorDoubleValueFnLeft(LEFT_COL, i, &lx)); + SCL_ERR_JRET(getVectorDoubleValueFnRight(RIGHT_COL, i, &rx)); if (isnan(lx) || isinf(lx) || isnan(rx) || isinf(rx) || FLT_EQUAL(rx, 0)) { colDataSetNULL(pOutputCol, i); continue; @@ -1451,7 +1597,8 @@ void vectorMathRemainder(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *output = lx - ((int64_t)(lx / rx)) * rx; } } else if (pLeft->numOfRows == 1) { - double lx = getVectorDoubleValueFnLeft(LEFT_COL, 0); + double lx = 0; + SCL_ERR_JRET(getVectorDoubleValueFnLeft(LEFT_COL, 0, &lx)); if (IS_HELPER_NULL(pLeftCol, 0)) { // Set pLeft->numOfRows NULL value colDataSetNNULL(pOutputCol, 0, pRight->numOfRows); } else { @@ -1461,7 +1608,8 @@ void vectorMathRemainder(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam continue; } - double rx = getVectorDoubleValueFnRight(RIGHT_COL, i); + double rx = 0; + SCL_ERR_JRET(getVectorDoubleValueFnRight(RIGHT_COL, i, &rx)); if (isnan(rx) || isinf(rx) || FLT_EQUAL(rx, 0)) { colDataSetNULL(pOutputCol, i); continue; @@ -1471,7 +1619,8 @@ void vectorMathRemainder(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam } } } else if (pRight->numOfRows == 1) { - double rx = getVectorDoubleValueFnRight(RIGHT_COL, 0); + double rx = 0; + SCL_ERR_JRET(getVectorDoubleValueFnRight(RIGHT_COL, 0, &rx)); if (IS_HELPER_NULL(pRightCol, 0) || FLT_EQUAL(rx, 0)) { // Set pLeft->numOfRows NULL value colDataSetNNULL(pOutputCol, 0, pLeft->numOfRows); } else { @@ -1481,7 +1630,8 @@ void vectorMathRemainder(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam continue; } - double lx = getVectorDoubleValueFnLeft(LEFT_COL, i); + double lx = 0; + SCL_ERR_JRET(getVectorDoubleValueFnLeft(LEFT_COL, i, &lx)); if (isnan(lx) || isinf(lx)) { colDataSetNULL(pOutputCol, i); continue; @@ -1492,20 +1642,24 @@ void vectorMathRemainder(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam } } +_return: doReleaseVec(pLeftCol, leftConvert); doReleaseVec(pRightCol, rightConvert); + SCL_RET(code); } -void vectorMathMinus(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { +int32_t vectorMathMinus(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { SColumnInfoData *pOutputCol = pOut->columnData; pOut->numOfRows = pLeft->numOfRows; + int32_t code = TSDB_CODE_SUCCESS; int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : (pLeft->numOfRows - 1); int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1; int32_t leftConvert = 0; - SColumnInfoData *pLeftCol = vectorConvertVarToDouble(pLeft, &leftConvert); + SColumnInfoData *pLeftCol = NULL; + SCL_ERR_JRET(vectorConvertVarToDouble(pLeft, &leftConvert, &pLeftCol)); _getDoubleValue_fn_t getVectorDoubleValueFnLeft = getVectorDoubleValueFn(pLeftCol->info.type); @@ -1515,14 +1669,17 @@ void vectorMathMinus(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pO colDataSetNULL(pOutputCol, i); continue; } - double result = getVectorDoubleValueFnLeft(LEFT_COL, i); + double result = 0; + SCL_ERR_JRET(getVectorDoubleValueFnLeft(LEFT_COL, i, &result)); *output = (result == 0) ? 0 : -result; } +_return: doReleaseVec(pLeftCol, leftConvert); + SCL_RET(code); } -void vectorAssign(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { +int32_t vectorAssign(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { SColumnInfoData *pOutputCol = pOut->columnData; pOut->numOfRows = pLeft->numOfRows; @@ -1531,16 +1688,17 @@ void vectorAssign(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, } else { char *d = colDataGetData(pRight->columnData, 0); for (int32_t i = 0; i < pOut->numOfRows; ++i) { - colDataSetVal(pOutputCol, i, d, false); + SCL_ERR_RET(colDataSetVal(pOutputCol, i, d, false)); } } ASSERT(pRight->numOfQualified == 1 || pRight->numOfQualified == 0); pOut->numOfQualified = pRight->numOfQualified * pOut->numOfRows; + return TSDB_CODE_SUCCESS; } -static void vectorBitAndHelper(SColumnInfoData *pLeftCol, SColumnInfoData *pRightCol, SColumnInfoData *pOutputCol, - int32_t numOfRows, int32_t step, int32_t i) { +static int32_t vectorBitAndHelper(SColumnInfoData *pLeftCol, SColumnInfoData *pRightCol, SColumnInfoData *pOutputCol, + int32_t numOfRows, int32_t step, int32_t i) { _getBigintValue_fn_t getVectorBigintValueFnLeft = getVectorBigintValueFn(pLeftCol->info.type); _getBigintValue_fn_t getVectorBigintValueFnRight = getVectorBigintValueFn(pRightCol->info.type); @@ -1554,21 +1712,29 @@ static void vectorBitAndHelper(SColumnInfoData *pLeftCol, SColumnInfoData *pRigh colDataSetNULL(pOutputCol, i); continue; // TODO set null or ignore } - *output = getVectorBigintValueFnLeft(LEFT_COL, i) & getVectorBigintValueFnRight(RIGHT_COL, 0); + int64_t leftRes = 0; + int64_t rightRes = 0; + SCL_ERR_RET(getVectorBigintValueFnLeft(LEFT_COL, i, &leftRes)); + SCL_ERR_RET(getVectorBigintValueFnRight(RIGHT_COL, 0, &rightRes)); + *output = leftRes & rightRes; } } + SCL_RET(TSDB_CODE_SUCCESS); } -void vectorBitAnd(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { +int32_t vectorBitAnd(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { SColumnInfoData *pOutputCol = pOut->columnData; pOut->numOfRows = TMAX(pLeft->numOfRows, pRight->numOfRows); + int32_t code = TSDB_CODE_SUCCESS; int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : TMAX(pLeft->numOfRows, pRight->numOfRows) - 1; int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1; int32_t leftConvert = 0, rightConvert = 0; - SColumnInfoData *pLeftCol = vectorConvertVarToDouble(pLeft, &leftConvert); - SColumnInfoData *pRightCol = vectorConvertVarToDouble(pRight, &rightConvert); + SColumnInfoData *pLeftCol = NULL; + SColumnInfoData *pRightCol = NULL; + SCL_ERR_JRET(vectorConvertVarToDouble(pLeft, &leftConvert, &pLeftCol)); + SCL_ERR_JRET(vectorConvertVarToDouble(pRight, &rightConvert, &pRightCol)); _getBigintValue_fn_t getVectorBigintValueFnLeft = getVectorBigintValueFn(pLeftCol->info.type); _getBigintValue_fn_t getVectorBigintValueFnRight = getVectorBigintValueFn(pRightCol->info.type); @@ -1580,20 +1746,26 @@ void vectorBitAnd(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, colDataSetNULL(pOutputCol, i); continue; // TODO set null or ignore } - *output = getVectorBigintValueFnLeft(LEFT_COL, i) & getVectorBigintValueFnRight(RIGHT_COL, i); + int64_t leftRes = 0; + int64_t rightRes = 0; + SCL_ERR_JRET(getVectorBigintValueFnLeft(LEFT_COL, i, &leftRes)); + SCL_ERR_JRET(getVectorBigintValueFnRight(RIGHT_COL, i, &rightRes)); + *output = leftRes & rightRes; } } else if (pLeft->numOfRows == 1) { - vectorBitAndHelper(pRightCol, pLeftCol, pOutputCol, pRight->numOfRows, step, i); + SCL_ERR_JRET(vectorBitAndHelper(pRightCol, pLeftCol, pOutputCol, pRight->numOfRows, step, i)); } else if (pRight->numOfRows == 1) { - vectorBitAndHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, i); + SCL_ERR_JRET(vectorBitAndHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, i)); } +_return: doReleaseVec(pLeftCol, leftConvert); doReleaseVec(pRightCol, rightConvert); + SCL_RET(code); } -static void vectorBitOrHelper(SColumnInfoData *pLeftCol, SColumnInfoData *pRightCol, SColumnInfoData *pOutputCol, - int32_t numOfRows, int32_t step, int32_t i) { +static int32_t vectorBitOrHelper(SColumnInfoData *pLeftCol, SColumnInfoData *pRightCol, SColumnInfoData *pOutputCol, + int32_t numOfRows, int32_t step, int32_t i) { _getBigintValue_fn_t getVectorBigintValueFnLeft = getVectorBigintValueFn(pLeftCol->info.type); _getBigintValue_fn_t getVectorBigintValueFnRight = getVectorBigintValueFn(pRightCol->info.type); @@ -1602,27 +1774,34 @@ static void vectorBitOrHelper(SColumnInfoData *pLeftCol, SColumnInfoData *pRight if (IS_HELPER_NULL(pRightCol, 0)) { // Set pLeft->numOfRows NULL value colDataSetNNULL(pOutputCol, 0, numOfRows); } else { - int64_t rx = getVectorBigintValueFnRight(RIGHT_COL, 0); + int64_t rx = 0; + SCL_ERR_RET(getVectorBigintValueFnRight(RIGHT_COL, 0, &rx)); for (; i >= 0 && i < numOfRows; i += step, output += 1) { if (IS_HELPER_NULL(pLeftCol, i)) { colDataSetNULL(pOutputCol, i); continue; // TODO set null or ignore } - *output = getVectorBigintValueFnLeft(LEFT_COL, i) | rx; + int64_t lx = 0; + SCL_ERR_RET(getVectorBigintValueFnLeft(LEFT_COL, i, &lx)); + *output = lx | rx; } } + SCL_RET(TSDB_CODE_SUCCESS); } -void vectorBitOr(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { +int32_t vectorBitOr(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { SColumnInfoData *pOutputCol = pOut->columnData; pOut->numOfRows = TMAX(pLeft->numOfRows, pRight->numOfRows); + int32_t code = TSDB_CODE_SUCCESS; int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : TMAX(pLeft->numOfRows, pRight->numOfRows) - 1; int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1; int32_t leftConvert = 0, rightConvert = 0; - SColumnInfoData *pLeftCol = vectorConvertVarToDouble(pLeft, &leftConvert); - SColumnInfoData *pRightCol = vectorConvertVarToDouble(pRight, &rightConvert); + SColumnInfoData *pLeftCol = NULL; + SColumnInfoData *pRightCol = NULL; + SCL_ERR_JRET(vectorConvertVarToDouble(pLeft, &leftConvert, &pLeftCol)); + SCL_ERR_JRET(vectorConvertVarToDouble(pRight, &rightConvert, &pRightCol)); _getBigintValue_fn_t getVectorBigintValueFnLeft = getVectorBigintValueFn(pLeftCol->info.type); _getBigintValue_fn_t getVectorBigintValueFnRight = getVectorBigintValueFn(pRightCol->info.type); @@ -1634,23 +1813,28 @@ void vectorBitOr(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, colDataSetNULL(pOutputCol, i); continue; // TODO set null or ignore } - *output = getVectorBigintValueFnLeft(LEFT_COL, i) | getVectorBigintValueFnRight(RIGHT_COL, i); + int64_t leftRes = 0; + int64_t rightRes = 0; + SCL_ERR_JRET(getVectorBigintValueFnLeft(LEFT_COL, i, &leftRes)); + SCL_ERR_JRET(getVectorBigintValueFnRight(RIGHT_COL, i, &rightRes)); + *output = leftRes | rightRes; } } else if (pLeft->numOfRows == 1) { - vectorBitOrHelper(pRightCol, pLeftCol, pOutputCol, pRight->numOfRows, step, i); + SCL_ERR_JRET(vectorBitOrHelper(pRightCol, pLeftCol, pOutputCol, pRight->numOfRows, step, i)); } else if (pRight->numOfRows == 1) { - vectorBitOrHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, i); + SCL_ERR_JRET(vectorBitOrHelper(pLeftCol, pRightCol, pOutputCol, pLeft->numOfRows, step, i)); } +_return: doReleaseVec(pLeftCol, leftConvert); doReleaseVec(pRightCol, rightConvert); + SCL_RET(code); } int32_t doVectorCompareImpl(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t startIndex, - int32_t numOfRows, int32_t step, __compar_fn_t fp, int32_t optr) { - int32_t num = 0; + int32_t numOfRows, int32_t step, __compar_fn_t fp, int32_t optr, int32_t *num) { bool *pRes = (bool *)pOut->columnData->pData; - + int32_t code = TSDB_CODE_SUCCESS; if (IS_MATHABLE_TYPE(GET_PARAM_TYPE(pLeft)) && IS_MATHABLE_TYPE(GET_PARAM_TYPE(pRight))) { if (!(pLeft->columnData->hasNull || pRight->columnData->hasNull)) { for (int32_t i = startIndex; i < numOfRows && i >= 0; i += step) { @@ -1662,7 +1846,7 @@ int32_t doVectorCompareImpl(SScalarParam *pLeft, SScalarParam *pRight, SScalarPa pRes[i] = filterDoCompare(fp, optr, pLeftData, pRightData); if (pRes[i]) { - ++num; + ++(*num); } } } else { @@ -1679,7 +1863,7 @@ int32_t doVectorCompareImpl(SScalarParam *pLeft, SScalarParam *pRight, SScalarPa char *pRightData = colDataGetData(pRight->columnData, rightIndex); pRes[i] = filterDoCompare(fp, optr, pLeftData, pRightData); if (pRes[i]) { - ++num; + ++(*num); } } } @@ -1702,9 +1886,11 @@ int32_t doVectorCompareImpl(SScalarParam *pLeft, SScalarParam *pRight, SScalarPa bool freeLeft = false; bool freeRight = false; bool isJsonnull = false; + bool result = false; + + SCL_ERR_RET(convertJsonValue(&fp, optr, GET_PARAM_TYPE(pLeft), GET_PARAM_TYPE(pRight), &pLeftData, &pRightData, + &leftOut, &rightOut, &isJsonnull, &freeLeft, &freeRight, &result)); - bool result = convertJsonValue(&fp, optr, GET_PARAM_TYPE(pLeft), GET_PARAM_TYPE(pRight), &pLeftData, &pRightData, - &leftOut, &rightOut, &isJsonnull, &freeLeft, &freeRight); if (isJsonnull) { ASSERT(0); } @@ -1718,7 +1904,7 @@ int32_t doVectorCompareImpl(SScalarParam *pLeft, SScalarParam *pRight, SScalarPa bool res = filterDoCompare(fp, optr, pLeftData, pRightData); colDataSetInt8(pOut->columnData, i, (int8_t *)&res); if (res) { - ++num; + ++(*num); } } @@ -1732,10 +1918,10 @@ int32_t doVectorCompareImpl(SScalarParam *pLeft, SScalarParam *pRight, SScalarPa } } - return num; + return code; } -void doVectorCompare(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t startIndex, +int32_t doVectorCompare(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t startIndex, int32_t numOfRows, int32_t _ord, int32_t optr) { int32_t i = 0; int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1; @@ -1743,9 +1929,8 @@ void doVectorCompare(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pO int32_t rType = GET_PARAM_TYPE(pRight); __compar_fn_t fp = NULL; int32_t compRows = 0; - if (lType == rType) { - fp = filterGetCompFunc(lType, optr); + SCL_ERR_RET(filterGetCompFunc(&fp, lType, optr)); } else { fp = filterGetCompFuncEx(lType, rType, optr); } @@ -1775,87 +1960,88 @@ void doVectorCompare(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pO } } } else { // normal compare - pOut->numOfQualified = doVectorCompareImpl(pLeft, pRight, pOut, i, compRows, step, fp, optr); + SCL_ERR_RET(doVectorCompareImpl(pLeft, pRight, pOut, i, compRows, step, fp, optr, &(pOut->numOfQualified))); } + return TSDB_CODE_SUCCESS; } -void vectorCompareImpl(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t startIndex, - int32_t numOfRows, int32_t _ord, int32_t optr) { +int32_t vectorCompareImpl(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t startIndex, + int32_t numOfRows, int32_t _ord, int32_t optr) { SScalarParam pLeftOut = {0}; SScalarParam pRightOut = {0}; SScalarParam *param1 = NULL; SScalarParam *param2 = NULL; - + int32_t code = TSDB_CODE_SUCCESS; if (noConvertBeforeCompare(GET_PARAM_TYPE(pLeft), GET_PARAM_TYPE(pRight), optr)) { param1 = pLeft; param2 = pRight; } else { - if (vectorConvertCols(pLeft, pRight, &pLeftOut, &pRightOut, startIndex, numOfRows)) { - return; - } + SCL_ERR_JRET(vectorConvertCols(pLeft, pRight, &pLeftOut, &pRightOut, startIndex, numOfRows)); param1 = (pLeftOut.columnData != NULL) ? &pLeftOut : pLeft; param2 = (pRightOut.columnData != NULL) ? &pRightOut : pRight; } - doVectorCompare(param1, param2, pOut, startIndex, numOfRows, _ord, optr); + SCL_ERR_JRET(doVectorCompare(param1, param2, pOut, startIndex, numOfRows, _ord, optr)); +_return: sclFreeParam(&pLeftOut); sclFreeParam(&pRightOut); + SCL_RET(code); } -void vectorCompare(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord, int32_t optr) { - vectorCompareImpl(pLeft, pRight, pOut, -1, -1, _ord, optr); +int32_t vectorCompare(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord, int32_t optr) { + SCL_RET(vectorCompareImpl(pLeft, pRight, pOut, -1, -1, _ord, optr)); } -void vectorGreater(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { - vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_GREATER_THAN); +int32_t vectorGreater(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { + SCL_RET(vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_GREATER_THAN)); } -void vectorGreaterEqual(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { - vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_GREATER_EQUAL); +int32_t vectorGreaterEqual(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { + SCL_RET(vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_GREATER_EQUAL)); } -void vectorLower(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { - vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_LOWER_THAN); +int32_t vectorLower(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { + SCL_RET(vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_LOWER_THAN)); } -void vectorLowerEqual(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { - vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_LOWER_EQUAL); +int32_t vectorLowerEqual(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { + SCL_RET(vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_LOWER_EQUAL)); } -void vectorEqual(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { - vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_EQUAL); +int32_t vectorEqual(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { + SCL_RET(vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_EQUAL)); } -void vectorNotEqual(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { - vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_NOT_EQUAL); +int32_t vectorNotEqual(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { + SCL_RET(vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_NOT_EQUAL)); } -void vectorIn(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { - vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_IN); +int32_t vectorIn(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { + SCL_RET(vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_IN)); } -void vectorNotIn(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { - vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_NOT_IN); +int32_t vectorNotIn(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { + SCL_RET(vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_NOT_IN)); } -void vectorLike(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { - vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_LIKE); +int32_t vectorLike(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { + SCL_RET(vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_LIKE)); } -void vectorNotLike(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { - vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_NOT_LIKE); +int32_t vectorNotLike(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { + SCL_RET(vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_NOT_LIKE)); } -void vectorMatch(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { - vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_MATCH); +int32_t vectorMatch(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { + SCL_RET(vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_MATCH)); } -void vectorNotMatch(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { - vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_NMATCH); +int32_t vectorNotMatch(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { + SCL_RET(vectorCompare(pLeft, pRight, pOut, _ord, OP_TYPE_NMATCH)); } -void vectorIsNull(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { +int32_t vectorIsNull(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { for (int32_t i = 0; i < pLeft->numOfRows; ++i) { int8_t v = IS_HELPER_NULL(pLeft->columnData, i) ? 1 : 0; if (v) { @@ -1865,9 +2051,10 @@ void vectorIsNull(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, colDataClearNull_f(pOut->columnData->nullbitmap, i); } pOut->numOfRows = pLeft->numOfRows; + return TSDB_CODE_SUCCESS; } -void vectorNotNull(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { +int32_t vectorNotNull(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { for (int32_t i = 0; i < pLeft->numOfRows; ++i) { int8_t v = IS_HELPER_NULL(pLeft->columnData, i) ? 0 : 1; if (v) { @@ -1877,10 +2064,11 @@ void vectorNotNull(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut colDataClearNull_f(pOut->columnData->nullbitmap, i); } pOut->numOfRows = pLeft->numOfRows; + return TSDB_CODE_SUCCESS; } -void vectorIsTrue(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { - vectorConvertSingleColImpl(pLeft, pOut, NULL, -1, -1); +int32_t vectorIsTrue(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { + SCL_ERR_RET(vectorConvertSingleColImpl(pLeft, pOut, NULL, -1, -1)); for (int32_t i = 0; i < pOut->numOfRows; ++i) { if (colDataIsNull_s(pOut->columnData, i)) { int8_t v = 0; @@ -1896,28 +2084,29 @@ void vectorIsTrue(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, } } pOut->columnData->hasNull = false; + return TSDB_CODE_SUCCESS; } -STagVal getJsonValue(char *json, char *key, bool *isExist) { - STagVal val = {.pKey = key}; +int32_t getJsonValue(char *json, char *key, bool *isExist, STagVal *val) { + val->pKey = key; if (json == NULL || tTagIsJson((const STag *)json) == false) { - terrno = TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR; if (isExist) { *isExist = false; } - return val; + SCL_ERR_RET(TSDB_CODE_QRY_JSON_NOT_SUPPORT_ERROR); } - bool find = tTagGet(((const STag *)json), &val); // json value is null and not exist is different + bool find = tTagGet(((const STag *)json), val); // json value is null and not exist is different if (isExist) { *isExist = find; } - return val; + SCL_RET(TSDB_CODE_SUCCESS); } -void vectorJsonContains(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { +int32_t vectorJsonContains(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { SColumnInfoData *pOutputCol = pOut->columnData; + int32_t code = TSDB_CODE_SUCCESS; int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : TMAX(pLeft->numOfRows, pRight->numOfRows) - 1; int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1; @@ -1925,25 +2114,33 @@ void vectorJsonContains(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam char *pRightData = colDataGetVarData(pRight->columnData, 0); char *jsonKey = taosMemoryCalloc(1, varDataLen(pRightData) + 1); - memcpy(jsonKey, varDataVal(pRightData), varDataLen(pRightData)); + if (NULL == jsonKey) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + (void)memcpy(jsonKey, varDataVal(pRightData), varDataLen(pRightData)); for (; i >= 0 && i < pLeft->numOfRows; i += step) { bool isExist = false; if (!colDataIsNull_var(pLeft->columnData, i)) { char *pLeftData = colDataGetVarData(pLeft->columnData, i); - getJsonValue(pLeftData, jsonKey, &isExist); + STagVal value; + SCL_ERR_JRET(getJsonValue(pLeftData, jsonKey, &isExist, &value)); } if (isExist) { ++pOut->numOfQualified; } - colDataSetVal(pOutputCol, i, (const char *)(&isExist), false); + SCL_ERR_JRET(colDataSetVal(pOutputCol, i, (const char *)(&isExist), false)); } + +_return: taosMemoryFree(jsonKey); + SCL_RET(code); } -void vectorJsonArrow(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { +int32_t vectorJsonArrow(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pOut, int32_t _ord) { SColumnInfoData *pOutputCol = pOut->columnData; + int32_t code = TSDB_CODE_SUCCESS; int32_t i = ((_ord) == TSDB_ORDER_ASC) ? 0 : TMAX(pLeft->numOfRows, pRight->numOfRows) - 1; int32_t step = ((_ord) == TSDB_ORDER_ASC) ? 1 : -1; @@ -1951,7 +2148,10 @@ void vectorJsonArrow(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pO char *pRightData = colDataGetVarData(pRight->columnData, 0); char *jsonKey = taosMemoryCalloc(1, varDataLen(pRightData) + 1); - memcpy(jsonKey, varDataVal(pRightData), varDataLen(pRightData)); + if (NULL == jsonKey) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + (void)memcpy(jsonKey, varDataVal(pRightData), varDataLen(pRightData)); for (; i >= 0 && i < pLeft->numOfRows; i += step) { if (colDataIsNull_var(pLeft->columnData, i)) { colDataSetNull_var(pOutputCol, i); @@ -1960,14 +2160,19 @@ void vectorJsonArrow(SScalarParam *pLeft, SScalarParam *pRight, SScalarParam *pO } char *pLeftData = colDataGetVarData(pLeft->columnData, i); bool isExist = false; - STagVal value = getJsonValue(pLeftData, jsonKey, &isExist); + STagVal value; + SCL_ERR_JRET(getJsonValue(pLeftData, jsonKey, &isExist, &value)); char *data = isExist ? tTagValToData(&value, true) : NULL; - colDataSetVal(pOutputCol, i, data, data == NULL); + code = colDataSetVal(pOutputCol, i, data, data == NULL); if (isExist && IS_VAR_DATA_TYPE(value.type) && data) { taosMemoryFree(data); } + SCL_ERR_JRET(code); } + +_return: taosMemoryFree(jsonKey); + SCL_RET(code); } _bin_scalar_fn_t getBinScalarOperatorFn(int32_t binFunctionId) { diff --git a/source/libs/scalar/test/filter/filterTests.cpp b/source/libs/scalar/test/filter/filterTests.cpp index cd3d681f58..26f9024f3e 100644 --- a/source/libs/scalar/test/filter/filterTests.cpp +++ b/source/libs/scalar/test/filter/filterTests.cpp @@ -55,21 +55,27 @@ void flttInitLogFile() { tsAsyncLog = 0; qDebugFlag = 159; - strcpy(tsLogDir, TD_LOG_DIR_PATH); + (void)strcpy(tsLogDir, TD_LOG_DIR_PATH); if (taosInitLog(defaultLogFileNamePrefix, maxLogFileNum) < 0) { printf("failed to open log file in directory:%s\n", tsLogDir); } } -void flttMakeValueNode(SNode **pNode, int32_t dataType, void *value) { +int32_t flttMakeValueNode(SNode **pNode, int32_t dataType, void *value) { SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_VALUE); + if (NULL == node) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SValueNode *vnode = (SValueNode *)node; vnode->node.resType.type = dataType; if (IS_VAR_DATA_TYPE(dataType)) { vnode->datum.p = (char *)taosMemoryMalloc(varDataTLen(value)); - varDataCopy(vnode->datum.p, value); + if (NULL == vnode->datum.p) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + (void)varDataCopy(vnode->datum.p, value); vnode->node.resType.bytes = varDataLen(value); } else { vnode->node.resType.bytes = tDataTypes[dataType].bytes; @@ -77,13 +83,17 @@ void flttMakeValueNode(SNode **pNode, int32_t dataType, void *value) { } *pNode = (SNode *)vnode; + FLT_RET(TSDB_CODE_SUCCESS); } -void flttMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType, int32_t dataBytes, int32_t rowNum, +int32_t flttMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType, int32_t dataBytes, int32_t rowNum, void *value) { static uint64_t dbidx = 0; SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_COLUMN); + if (NULL == node) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SColumnNode *rnode = (SColumnNode *)node; rnode->node.resType.type = dataType; rnode->node.resType.bytes = dataBytes; @@ -96,23 +106,27 @@ void flttMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType, in rnode->colId = 3; *pNode = (SNode *)rnode; - return; + FLT_RET(TSDB_CODE_SUCCESS); } if (NULL == *block) { SSDataBlock *res = createDataBlock(); for (int32_t i = 0; i < 2; ++i) { SColumnInfoData idata = createColumnInfoData(TSDB_DATA_TYPE_NULL, 10, 1 + i); - blockDataAppendColInfo(res, &idata); + FLT_ERR_RET(blockDataAppendColInfo(res, &idata)); } SColumnInfoData idata = createColumnInfoData(dataType, dataBytes, 3); - blockDataAppendColInfo(res, &idata); - blockDataEnsureCapacity(res, rowNum); + FLT_ERR_RET(blockDataAppendColInfo(res, &idata)); + FLT_ERR_RET(blockDataEnsureCapacity(res, rowNum)); SColumnInfoData *pColumn = (SColumnInfoData *)taosArrayGetLast(res->pDataBlock); + if (NULL == pColumn) { + fltError("fail to get the last task, num:%d", (int32_t)taosArrayGetSize(res->pDataBlock)); + FLT_ERR_RET(TSDB_CODE_QRY_SYS_ERROR); + } for (int32_t i = 0; i < rowNum; ++i) { - colDataSetVal(pColumn, i, (const char *)value, false); + FLT_ERR_RET(colDataSetVal(pColumn, i, (const char *)value, false)); if (IS_VAR_DATA_TYPE(dataType)) { value = (char *)value + varDataTLen(value); } else { @@ -130,13 +144,16 @@ void flttMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType, in int32_t idx = taosArrayGetSize(res->pDataBlock); SColumnInfoData idata = createColumnInfoData(dataType, dataBytes, 1 + idx); - blockDataAppendColInfo(res, &idata); - blockDataEnsureCapacity(res, rowNum); + FLT_ERR_RET(blockDataAppendColInfo(res, &idata)); + FLT_ERR_RET(blockDataEnsureCapacity(res, rowNum)); SColumnInfoData *pColumn = (SColumnInfoData *)taosArrayGetLast(res->pDataBlock); - + if (NULL == pColumn) { + fltError("fail to get the last task, num:%d", (int32_t)taosArrayGetSize(res->pDataBlock)); + FLT_ERR_RET(TSDB_CODE_QRY_SYS_ERROR); + } for (int32_t i = 0; i < rowNum; ++i) { - colDataSetVal(pColumn, i, (const char *)value, false); + FLT_ERR_RET(colDataSetVal(pColumn, i, (const char *)value, false)); if (IS_VAR_DATA_TYPE(dataType)) { value = (char *)value + varDataTLen(value); } else { @@ -149,10 +166,14 @@ void flttMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType, in } *pNode = (SNode *)rnode; + FLT_RET(TSDB_CODE_SUCCESS); } -void flttMakeOpNode(SNode **pNode, EOperatorType opType, int32_t resType, SNode *pLeft, SNode *pRight) { +int32_t flttMakeOpNode(SNode **pNode, EOperatorType opType, int32_t resType, SNode *pLeft, SNode *pRight) { SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_OPERATOR); + if (NULL == node) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SOperatorNode *onode = (SOperatorNode *)node; onode->node.resType.type = resType; onode->node.resType.bytes = tDataTypes[resType].bytes; @@ -162,10 +183,14 @@ void flttMakeOpNode(SNode **pNode, EOperatorType opType, int32_t resType, SNode onode->pRight = pRight; *pNode = (SNode *)onode; + FLT_RET(TSDB_CODE_SUCCESS); } -void flttMakeLogicNode(SNode **pNode, ELogicConditionType opType, SNode **nodeList, int32_t nodeNum) { +int32_t flttMakeLogicNode(SNode **pNode, ELogicConditionType opType, SNode **nodeList, int32_t nodeNum) { SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); + if (NULL == node) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SLogicConditionNode *onode = (SLogicConditionNode *)node; onode->condType = opType; onode->node.resType.type = TSDB_DATA_TYPE_BOOL; @@ -173,14 +198,18 @@ void flttMakeLogicNode(SNode **pNode, ELogicConditionType opType, SNode **nodeLi onode->pParameterList = nodesMakeList(); for (int32_t i = 0; i < nodeNum; ++i) { - nodesListAppend(onode->pParameterList, nodeList[i]); + FLT_ERR_RET(nodesListAppend(onode->pParameterList, nodeList[i])); } *pNode = (SNode *)onode; + FLT_RET(TSDB_CODE_SUCCESS); } -void flttMakeLogicNodeFromList(SNode **pNode, ELogicConditionType opType, SNodeList *nodeList) { +int32_t flttMakeLogicNodeFromList(SNode **pNode, ELogicConditionType opType, SNodeList *nodeList) { SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); + if (NULL == node) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SLogicConditionNode *onode = (SLogicConditionNode *)node; onode->condType = opType; onode->node.resType.type = TSDB_DATA_TYPE_BOOL; @@ -189,15 +218,20 @@ void flttMakeLogicNodeFromList(SNode **pNode, ELogicConditionType opType, SNodeL onode->pParameterList = nodeList; *pNode = (SNode *)onode; + FLT_RET(TSDB_CODE_SUCCESS); } -void flttMakeListNode(SNode **pNode, SNodeList *list, int32_t resType) { +int32_t flttMakeListNode(SNode **pNode, SNodeList *list, int32_t resType) { SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_NODE_LIST); + if (NULL == node) { + FLT_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SNodeListNode *lnode = (SNodeListNode *)node; lnode->node.resType.type = resType; lnode->pNodeList = list; *pNode = (SNode *)lnode; + FLT_RET(TSDB_CODE_SUCCESS); } void initScalarParam(SScalarParam *pParam) { @@ -213,17 +247,21 @@ TEST(timerangeTest, greater) { SScalarParam res; initScalarParam(&res); + int32_t code = TSDB_CODE_SUCCESS; int64_t tsmall = 222, tbig = 333; - flttMakeColumnNode(&pcol, NULL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 0, NULL); - flttMakeValueNode(&pval, TSDB_DATA_TYPE_TIMESTAMP, &tsmall); - flttMakeOpNode(&opNode1, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pcol, pval); + code = flttMakeColumnNode(&pcol, NULL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 0, NULL); + ASSERT_EQ(code, 0); + code = flttMakeValueNode(&pval, TSDB_DATA_TYPE_TIMESTAMP, &tsmall); + ASSERT_EQ(code, 0); + code = flttMakeOpNode(&opNode1, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pcol, pval); + ASSERT_EQ(code, 0); // SFilterInfo *filter = NULL; // int32_t code = filterInitFromNode(opNode1, &filter, FLT_OPTION_NO_REWRITE|FLT_OPTION_TIMESTAMP); // ASSERT_EQ(code, 0); STimeWindow win = {0}; bool isStrict = false; - int32_t code = filterGetTimeRange(opNode1, &win, &isStrict); + code = filterGetTimeRange(opNode1, &win, &isStrict); ASSERT_EQ(code, 0); ASSERT_EQ(isStrict, true); ASSERT_EQ(win.skey, tsmall + 1); @@ -237,25 +275,33 @@ TEST(timerangeTest, greater_and_lower) { bool eRes[5] = {false, false, true, true, true}; SScalarParam res; initScalarParam(&res); + int32_t code = TSDB_CODE_SUCCESS; int64_t tsmall = 222, tbig = 333; - flttMakeColumnNode(&pcol, NULL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 0, NULL); - flttMakeValueNode(&pval, TSDB_DATA_TYPE_TIMESTAMP, &tsmall); - flttMakeOpNode(&opNode1, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pcol, pval); - flttMakeColumnNode(&pcol, NULL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 0, NULL); - flttMakeValueNode(&pval, TSDB_DATA_TYPE_TIMESTAMP, &tbig); - flttMakeOpNode(&opNode2, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pcol, pval); + code = flttMakeColumnNode(&pcol, NULL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 0, NULL); + ASSERT_EQ(code, 0); + code = flttMakeValueNode(&pval, TSDB_DATA_TYPE_TIMESTAMP, &tsmall); + ASSERT_EQ(code, 0); + code = flttMakeOpNode(&opNode1, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pcol, pval); + ASSERT_EQ(code, 0); + code = flttMakeColumnNode(&pcol, NULL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 0, NULL); + ASSERT_EQ(code, 0); + code = flttMakeValueNode(&pval, TSDB_DATA_TYPE_TIMESTAMP, &tbig); + ASSERT_EQ(code, 0); + code = flttMakeOpNode(&opNode2, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pcol, pval); + ASSERT_EQ(code, 0); SNode *list[2] = {0}; list[0] = opNode1; list[1] = opNode2; - flttMakeLogicNode(&logicNode, LOGIC_COND_TYPE_AND, list, 2); + code = flttMakeLogicNode(&logicNode, LOGIC_COND_TYPE_AND, list, 2); + ASSERT_EQ(code, 0); // SFilterInfo *filter = NULL; // int32_t code = filterInitFromNode(logicNode, &filter, FLT_OPTION_NO_REWRITE|FLT_OPTION_TIMESTAMP); // ASSERT_EQ(code, 0); STimeWindow win = {0}; bool isStrict = false; - int32_t code = filterGetTimeRange(logicNode, &win, &isStrict); + code = filterGetTimeRange(logicNode, &win, &isStrict); ASSERT_EQ(isStrict, true); ASSERT_EQ(code, 0); ASSERT_EQ(win.skey, tsmall + 1); @@ -269,25 +315,33 @@ TEST(timerangeTest, greater_equal_and_lower_equal) { bool eRes[5] = {false, false, true, true, true}; SScalarParam res; initScalarParam(&res); + int32_t code = TSDB_CODE_SUCCESS; int64_t tsmall = 222, tbig = 333; - flttMakeColumnNode(&pcol, NULL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 0, NULL); - flttMakeValueNode(&pval, TSDB_DATA_TYPE_TIMESTAMP, &tsmall); - flttMakeOpNode(&opNode1, OP_TYPE_GREATER_EQUAL, TSDB_DATA_TYPE_BOOL, pcol, pval); - flttMakeColumnNode(&pcol, NULL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 0, NULL); - flttMakeValueNode(&pval, TSDB_DATA_TYPE_TIMESTAMP, &tbig); - flttMakeOpNode(&opNode2, OP_TYPE_LOWER_EQUAL, TSDB_DATA_TYPE_BOOL, pcol, pval); + code = flttMakeColumnNode(&pcol, NULL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 0, NULL); + ASSERT_EQ(code, 0); + code = flttMakeValueNode(&pval, TSDB_DATA_TYPE_TIMESTAMP, &tsmall); + ASSERT_EQ(code, 0); + code = flttMakeOpNode(&opNode1, OP_TYPE_GREATER_EQUAL, TSDB_DATA_TYPE_BOOL, pcol, pval); + ASSERT_EQ(code, 0); + code = flttMakeColumnNode(&pcol, NULL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 0, NULL); + ASSERT_EQ(code, 0); + code = flttMakeValueNode(&pval, TSDB_DATA_TYPE_TIMESTAMP, &tbig); + ASSERT_EQ(code, 0); + code = flttMakeOpNode(&opNode2, OP_TYPE_LOWER_EQUAL, TSDB_DATA_TYPE_BOOL, pcol, pval); + ASSERT_EQ(code, 0); SNode *list[2] = {0}; list[0] = opNode1; list[1] = opNode2; - flttMakeLogicNode(&logicNode, LOGIC_COND_TYPE_AND, list, 2); + code = flttMakeLogicNode(&logicNode, LOGIC_COND_TYPE_AND, list, 2); + ASSERT_EQ(code, 0); // SFilterInfo *filter = NULL; // int32_t code = filterInitFromNode(logicNode, &filter, FLT_OPTION_NO_REWRITE|FLT_OPTION_TIMESTAMP); // ASSERT_EQ(code, 0); STimeWindow win = {0}; bool isStrict = false; - int32_t code = filterGetTimeRange(logicNode, &win, &isStrict); + code = filterGetTimeRange(logicNode, &win, &isStrict); ASSERT_EQ(isStrict, true); ASSERT_EQ(code, 0); ASSERT_EQ(win.skey, tsmall); @@ -301,42 +355,58 @@ TEST(timerangeTest, greater_and_lower_not_strict) { bool eRes[5] = {false, false, true, true, true}; SScalarParam res; initScalarParam(&res); + int32_t code = TSDB_CODE_SUCCESS; int64_t tsmall1 = 222, tbig1 = 333; int64_t tsmall2 = 444, tbig2 = 555; SNode *list[2] = {0}; - flttMakeColumnNode(&pcol, NULL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 0, NULL); - flttMakeValueNode(&pval, TSDB_DATA_TYPE_TIMESTAMP, &tsmall1); - flttMakeOpNode(&opNode1, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pcol, pval); - flttMakeColumnNode(&pcol, NULL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 0, NULL); - flttMakeValueNode(&pval, TSDB_DATA_TYPE_TIMESTAMP, &tbig1); - flttMakeOpNode(&opNode2, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pcol, pval); + code = flttMakeColumnNode(&pcol, NULL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 0, NULL); + ASSERT_EQ(code, 0); + code = flttMakeValueNode(&pval, TSDB_DATA_TYPE_TIMESTAMP, &tsmall1); + ASSERT_EQ(code, 0); + code = flttMakeOpNode(&opNode1, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pcol, pval); + ASSERT_EQ(code, 0); + code = flttMakeColumnNode(&pcol, NULL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 0, NULL); + ASSERT_EQ(code, 0); + code = flttMakeValueNode(&pval, TSDB_DATA_TYPE_TIMESTAMP, &tbig1); + ASSERT_EQ(code, 0); + code = flttMakeOpNode(&opNode2, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pcol, pval); + ASSERT_EQ(code, 0); list[0] = opNode1; list[1] = opNode2; - flttMakeLogicNode(&logicNode1, LOGIC_COND_TYPE_AND, list, 2); + code = flttMakeLogicNode(&logicNode1, LOGIC_COND_TYPE_AND, list, 2); + ASSERT_EQ(code, 0); - flttMakeColumnNode(&pcol, NULL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 0, NULL); - flttMakeValueNode(&pval, TSDB_DATA_TYPE_TIMESTAMP, &tsmall2); - flttMakeOpNode(&opNode1, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pcol, pval); - flttMakeColumnNode(&pcol, NULL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 0, NULL); - flttMakeValueNode(&pval, TSDB_DATA_TYPE_TIMESTAMP, &tbig2); - flttMakeOpNode(&opNode2, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pcol, pval); + code = flttMakeColumnNode(&pcol, NULL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 0, NULL); + ASSERT_EQ(code, 0); + code = flttMakeValueNode(&pval, TSDB_DATA_TYPE_TIMESTAMP, &tsmall2); + ASSERT_EQ(code, 0); + code = flttMakeOpNode(&opNode1, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pcol, pval); + ASSERT_EQ(code, 0); + code = flttMakeColumnNode(&pcol, NULL, TSDB_DATA_TYPE_TIMESTAMP, sizeof(int64_t), 0, NULL); + ASSERT_EQ(code, 0); + code = flttMakeValueNode(&pval, TSDB_DATA_TYPE_TIMESTAMP, &tbig2); + ASSERT_EQ(code, 0); + code = flttMakeOpNode(&opNode2, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pcol, pval); + ASSERT_EQ(code, 0); list[0] = opNode1; list[1] = opNode2; - flttMakeLogicNode(&logicNode2, LOGIC_COND_TYPE_AND, list, 2); + code = flttMakeLogicNode(&logicNode2, LOGIC_COND_TYPE_AND, list, 2); + ASSERT_EQ(code, 0); list[0] = logicNode1; list[1] = logicNode2; - flttMakeLogicNode(&logicNode1, LOGIC_COND_TYPE_OR, list, 2); + code = flttMakeLogicNode(&logicNode1, LOGIC_COND_TYPE_OR, list, 2); + ASSERT_EQ(code, 0); // SFilterInfo *filter = NULL; // int32_t code = filterInitFromNode(logicNode, &filter, FLT_OPTION_NO_REWRITE|FLT_OPTION_TIMESTAMP); // ASSERT_EQ(code, 0); STimeWindow win = {0}; bool isStrict = false; - int32_t code = filterGetTimeRange(logicNode1, &win, &isStrict); + code = filterGetTimeRange(logicNode1, &win, &isStrict); ASSERT_EQ(isStrict, false); ASSERT_EQ(code, 0); ASSERT_EQ(win.skey, tsmall1 + 1); diff --git a/source/libs/scalar/test/scalar/scalarTests.cpp b/source/libs/scalar/test/scalar/scalarTests.cpp index dd88344962..41be682a65 100644 --- a/source/libs/scalar/test/scalar/scalarTests.cpp +++ b/source/libs/scalar/test/scalar/scalarTests.cpp @@ -36,6 +36,7 @@ #include "nodes.h" #include "parUtil.h" #include "scalar.h" +#include "sclInt.h" #include "stub.h" #include "taos.h" #include "tdatablock.h" @@ -72,7 +73,7 @@ SColumnInfo createColumnInfo(int32_t colId, int32_t type, int32_t bytes) { int64_t scltLeftV = 21, scltRightV = 10; double scltLeftVd = 21.0, scltRightVd = 10.0; -void scltFreeDataBlock(void *block) { blockDataDestroy(*(SSDataBlock **)block); } +void scltFreeDataBlock(void *block) { (void)blockDataDestroy(*(SSDataBlock **)block); } void scltInitLogFile() { const char *defaultLogFileNamePrefix = "taoslog"; @@ -80,30 +81,41 @@ void scltInitLogFile() { tsAsyncLog = 0; qDebugFlag = 159; - strcpy(tsLogDir, TD_LOG_DIR_PATH); + (void)strcpy(tsLogDir, TD_LOG_DIR_PATH); if (taosInitLog(defaultLogFileNamePrefix, maxLogFileNum) < 0) { printf("failed to open log file in directory:%s\n", tsLogDir); } } -void scltAppendReservedSlot(SArray *pBlockList, int16_t *dataBlockId, int16_t *slotId, bool newBlock, int32_t rows, - SColumnInfo *colInfo) { +int32_t scltAppendReservedSlot(SArray *pBlockList, int16_t *dataBlockId, int16_t *slotId, bool newBlock, int32_t rows, + SColumnInfo *colInfo) { if (newBlock) { SSDataBlock *res = createDataBlock(); + if (NULL == res || NULL == res->pDataBlock) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SColumnInfoData idata = {0}; idata.info = *colInfo; - colInfoDataEnsureCapacity(&idata, rows, true); + int32_t code = colInfoDataEnsureCapacity(&idata, rows, true); + if (code != TSDB_CODE_SUCCESS) { + taosMemoryFree(&idata); + SCL_ERR_RET(code); + } - blockDataAppendColInfo(res, &idata); + code = blockDataAppendColInfo(res, &idata); + if (code != TSDB_CODE_SUCCESS) { + blockDataFreeRes(res); + SCL_ERR_RET(code); + } res->info.capacity = rows; res->info.rows = rows; SColumnInfoData *p = static_cast(taosArrayGet(res->pDataBlock, 0)); ASSERT(p->pData != NULL && p->nullbitmap != NULL); - taosArrayPush(pBlockList, &res); + (void)taosArrayPush(pBlockList, &res); *dataBlockId = taosArrayGetSize(pBlockList) - 1; res->info.id.blockId = *dataBlockId; *slotId = 0; @@ -111,34 +123,55 @@ void scltAppendReservedSlot(SArray *pBlockList, int16_t *dataBlockId, int16_t *s SSDataBlock *res = *(SSDataBlock **)taosArrayGetLast(pBlockList); SColumnInfoData idata = {0}; idata.info = *colInfo; - colInfoDataEnsureCapacity(&idata, rows, true); - blockDataAppendColInfo(res, &idata); + int32_t code = colInfoDataEnsureCapacity(&idata, rows, true); + if (code != TSDB_CODE_SUCCESS) { + taosMemoryFree(&idata); + SCL_ERR_RET(code); + } + + code = blockDataAppendColInfo(res, &idata); + if (code != TSDB_CODE_SUCCESS) { + blockDataFreeRes(res); + SCL_ERR_RET(code); + } *dataBlockId = taosArrayGetSize(pBlockList) - 1; *slotId = taosArrayGetSize(res->pDataBlock) - 1; } + SCL_RET(TSDB_CODE_SUCCESS); + } -void scltMakeValueNode(SNode **pNode, int32_t dataType, void *value) { +int32_t scltMakeValueNode(SNode **pNode, int32_t dataType, void *value) { SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_VALUE); + if (NULL == node) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SValueNode *vnode = (SValueNode *)node; vnode->node.resType.type = dataType; if (IS_VAR_DATA_TYPE(dataType)) { vnode->datum.p = (char *)taosMemoryMalloc(varDataTLen(value)); - varDataCopy(vnode->datum.p, value); + if (NULL == vnode->datum.p) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } + (void)varDataCopy(vnode->datum.p, value); vnode->node.resType.bytes = varDataTLen(value); } else { vnode->node.resType.bytes = tDataTypes[dataType].bytes; - assignVal((char *)nodesGetValueFromNode(vnode), (const char *)value, 0, dataType); + (void)assignVal((char *)nodesGetValueFromNode(vnode), (const char *)value, 0, dataType); } *pNode = (SNode *)vnode; + SCL_RET(TSDB_CODE_SUCCESS); } -void scltMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType, int32_t dataBytes, int32_t rowNum, - void *value) { +int32_t scltMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType, int32_t dataBytes, int32_t rowNum, + void *value) { SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_COLUMN); + if (NULL == node) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SColumnNode *rnode = (SColumnNode *)node; rnode->node.resType.type = dataType; rnode->node.resType.bytes = dataBytes; @@ -146,26 +179,43 @@ void scltMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType, in if (NULL == block) { *pNode = (SNode *)rnode; - return; + SCL_RET(TSDB_CODE_SUCCESS); } + int32_t code = TSDB_CODE_SUCCESS; if (NULL == *block) { SSDataBlock *res = createDataBlock(); for (int32_t i = 0; i < 2; ++i) { SColumnInfoData idata = createColumnInfoData(TSDB_DATA_TYPE_INT, 10, i + 1); - colInfoDataEnsureCapacity(&idata, rowNum, true); - blockDataAppendColInfo(res, &idata); + code = colInfoDataEnsureCapacity(&idata, rowNum, true); + if (code != TSDB_CODE_SUCCESS) { + taosMemoryFree(&idata); + SCL_ERR_RET(code); + } + code = blockDataAppendColInfo(res, &idata); + if (code != TSDB_CODE_SUCCESS) { + blockDataFreeRes(res); + SCL_ERR_RET(code); + } } SColumnInfoData idata = createColumnInfoData(dataType, dataBytes, 3); - colInfoDataEnsureCapacity(&idata, rowNum, true); - blockDataAppendColInfo(res, &idata); + code = colInfoDataEnsureCapacity(&idata, rowNum, true); + if (code != TSDB_CODE_SUCCESS) { + taosMemoryFree(&idata); + SCL_ERR_RET(code); + } + code = blockDataAppendColInfo(res, &idata); + if (code != TSDB_CODE_SUCCESS) { + blockDataFreeRes(res); + SCL_ERR_RET(code); + } res->info.capacity = rowNum; res->info.rows = rowNum; SColumnInfoData *pColumn = (SColumnInfoData *)taosArrayGetLast(res->pDataBlock); for (int32_t i = 0; i < rowNum; ++i) { - colDataSetVal(pColumn, i, (const char *)value, false); + SCL_ERR_RET(colDataSetVal(pColumn, i, (const char *)value, false)); if (IS_VAR_DATA_TYPE(dataType)) { value = (char *)value + varDataTLen(value); } else { @@ -182,15 +232,23 @@ void scltMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType, in int32_t idx = taosArrayGetSize(res->pDataBlock); SColumnInfoData idata = createColumnInfoData(dataType, dataBytes, 1 + idx); - colInfoDataEnsureCapacity(&idata, rowNum, true); + code = colInfoDataEnsureCapacity(&idata, rowNum, true); + if (code != TSDB_CODE_SUCCESS) { + taosMemoryFree(&idata); + SCL_ERR_RET(code); + } res->info.capacity = rowNum; - blockDataAppendColInfo(res, &idata); + code = blockDataAppendColInfo(res, &idata); + if (code != TSDB_CODE_SUCCESS) { + blockDataFreeRes(res); + SCL_ERR_RET(code); + } SColumnInfoData *pColumn = (SColumnInfoData *)taosArrayGetLast(res->pDataBlock); for (int32_t i = 0; i < rowNum; ++i) { - colDataSetVal(pColumn, i, (const char *)value, false); + SCL_ERR_RET(colDataSetVal(pColumn, i, (const char *)value, false)); if (IS_VAR_DATA_TYPE(dataType)) { value = (char *)value + varDataTLen(value); } else { @@ -203,11 +261,15 @@ void scltMakeColumnNode(SNode **pNode, SSDataBlock **block, int32_t dataType, in } *pNode = (SNode *)rnode; + SCL_RET(code); } -void scltMakeOpNode2(SNode **pNode, EOperatorType opType, int32_t resType, SNode *pLeft, SNode *pRight, +int32_t scltMakeOpNode2(SNode **pNode, EOperatorType opType, int32_t resType, SNode *pLeft, SNode *pRight, bool isReverse) { SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_OPERATOR); + if (NULL == node) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SOperatorNode *onode = (SOperatorNode *)node; onode->node.resType.type = resType; onode->node.resType.bytes = tDataTypes[resType].bytes; @@ -222,10 +284,14 @@ void scltMakeOpNode2(SNode **pNode, EOperatorType opType, int32_t resType, SNode } *pNode = (SNode *)onode; + SCL_RET(TSDB_CODE_SUCCESS); } -void scltMakeOpNode(SNode **pNode, EOperatorType opType, int32_t resType, SNode *pLeft, SNode *pRight) { +int32_t scltMakeOpNode(SNode **pNode, EOperatorType opType, int32_t resType, SNode *pLeft, SNode *pRight) { SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_OPERATOR); + if (NULL == node) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SOperatorNode *onode = (SOperatorNode *)node; onode->node.resType.type = resType; onode->node.resType.bytes = tDataTypes[resType].bytes; @@ -235,19 +301,27 @@ void scltMakeOpNode(SNode **pNode, EOperatorType opType, int32_t resType, SNode onode->pRight = pRight; *pNode = (SNode *)onode; + SCL_RET(TSDB_CODE_SUCCESS); } -void scltMakeListNode(SNode **pNode, SNodeList *list, int32_t resType) { +int32_t scltMakeListNode(SNode **pNode, SNodeList *list, int32_t resType) { SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_NODE_LIST); + if (NULL == node) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SNodeListNode *lnode = (SNodeListNode *)node; lnode->node.resType.type = resType; lnode->pNodeList = list; *pNode = (SNode *)lnode; + SCL_RET(TSDB_CODE_SUCCESS); } -void scltMakeLogicNode(SNode **pNode, ELogicConditionType opType, SNode **nodeList, int32_t nodeNum) { +int32_t scltMakeLogicNode(SNode **pNode, ELogicConditionType opType, SNode **nodeList, int32_t nodeNum) { SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_LOGIC_CONDITION); + if (NULL == node) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } SLogicConditionNode *onode = (SLogicConditionNode *)node; onode->condType = opType; onode->node.resType.type = TSDB_DATA_TYPE_BOOL; @@ -255,31 +329,40 @@ void scltMakeLogicNode(SNode **pNode, ELogicConditionType opType, SNode **nodeLi onode->pParameterList = nodesMakeList(); for (int32_t i = 0; i < nodeNum; ++i) { - nodesListAppend(onode->pParameterList, nodeList[i]); + SCL_ERR_RET(nodesListAppend(onode->pParameterList, nodeList[i])); } *pNode = (SNode *)onode; + SCL_RET(TSDB_CODE_SUCCESS); } -void scltMakeTargetNode(SNode **pNode, int16_t dataBlockId, int16_t slotId, SNode *snode) { +int32_t scltMakeTargetNode(SNode **pNode, int16_t dataBlockId, int16_t slotId, SNode *snode) { SNode *node = (SNode *)nodesMakeNode(QUERY_NODE_TARGET); + if (NULL == node) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } STargetNode *onode = (STargetNode *)node; onode->pExpr = snode; onode->dataBlockId = dataBlockId; onode->slotId = slotId; *pNode = (SNode *)onode; + SCL_RET(TSDB_CODE_SUCCESS); } } // namespace TEST(constantTest, bigint_add_bigint) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_BIGINT, &scltLeftV); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BIGINT, &scltRightV); - scltMakeOpNode(&opNode, OP_TYPE_ADD, TSDB_DATA_TYPE_DOUBLE, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_BIGINT, &scltLeftV); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BIGINT, &scltRightV); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_ADD, TSDB_DATA_TYPE_DOUBLE, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -290,12 +373,16 @@ TEST(constantTest, bigint_add_bigint) { TEST(constantTest, double_sub_bigint) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_DOUBLE, &scltLeftVd); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BIGINT, &scltRightV); - scltMakeOpNode(&opNode, OP_TYPE_SUB, TSDB_DATA_TYPE_DOUBLE, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_DOUBLE, &scltLeftVd); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BIGINT, &scltRightV); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_SUB, TSDB_DATA_TYPE_DOUBLE, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -306,12 +393,16 @@ TEST(constantTest, double_sub_bigint) { TEST(constantTest, tinyint_and_smallint) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_TINYINT, &scltLeftV); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &scltRightV); - scltMakeOpNode(&opNode, OP_TYPE_BIT_AND, TSDB_DATA_TYPE_BIGINT, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_TINYINT, &scltLeftV); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &scltRightV); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_BIT_AND, TSDB_DATA_TYPE_BIGINT, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -322,12 +413,16 @@ TEST(constantTest, tinyint_and_smallint) { TEST(constantTest, bigint_or_double) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_BIGINT, &scltLeftV); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_DOUBLE, &scltRightVd); - scltMakeOpNode(&opNode, OP_TYPE_BIT_OR, TSDB_DATA_TYPE_BIGINT, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_BIGINT, &scltLeftV); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_DOUBLE, &scltRightVd); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_BIT_OR, TSDB_DATA_TYPE_BIGINT, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -339,14 +434,18 @@ TEST(constantTest, bigint_or_double) { TEST(constantTest, int_or_binary) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; char binaryStr[64] = {0}; - sprintf(&binaryStr[2], "%d", scltRightV); + int32_t code = TSDB_CODE_SUCCESS; + (void)sprintf(&binaryStr[2], "%d", scltRightV); varDataSetLen(binaryStr, strlen(&binaryStr[2])); - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &scltLeftV); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, binaryStr); - scltMakeOpNode(&opNode, OP_TYPE_BIT_OR, TSDB_DATA_TYPE_BIGINT, pLeft, pRight); + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &scltLeftV); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, binaryStr); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_BIT_OR, TSDB_DATA_TYPE_BIGINT, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -357,12 +456,16 @@ TEST(constantTest, int_or_binary) { TEST(constantTest, int_greater_double) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &scltLeftV); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_DOUBLE, &scltRightVd); - scltMakeOpNode(&opNode, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &scltLeftV); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_DOUBLE, &scltRightVd); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -374,14 +477,18 @@ TEST(constantTest, int_greater_double) { TEST(constantTest, int_greater_equal_binary) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; char binaryStr[64] = {0}; - sprintf(&binaryStr[2], "%d", scltRightV); + int32_t code = TSDB_CODE_SUCCESS; + (void)sprintf(&binaryStr[2], "%d", scltRightV); varDataSetLen(binaryStr, strlen(&binaryStr[2])); - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &scltLeftV); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, binaryStr); - scltMakeOpNode(&opNode, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &scltLeftV); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, binaryStr); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -392,12 +499,16 @@ TEST(constantTest, int_greater_equal_binary) { TEST(constantTest, tinyint_lower_ubigint) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_TINYINT, &scltLeftV); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_UBIGINT, &scltRightV); - scltMakeOpNode(&opNode, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_TINYINT, &scltLeftV); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_UBIGINT, &scltRightV); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -410,12 +521,16 @@ TEST(constantTest, usmallint_lower_equal_ubigint) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; int32_t leftv = 1; int64_t rightv = 1; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_USMALLINT, &leftv); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_UBIGINT, &rightv); - scltMakeOpNode(&opNode, OP_TYPE_LOWER_EQUAL, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_USMALLINT, &leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_UBIGINT, &rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_LOWER_EQUAL, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -428,12 +543,16 @@ TEST(constantTest, int_equal_smallint1) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; int32_t leftv = 1; int16_t rightv = 1; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv); - scltMakeOpNode(&opNode, OP_TYPE_EQUAL, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_EQUAL, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -445,12 +564,16 @@ TEST(constantTest, int_equal_smallint1) { TEST(constantTest, int_equal_smallint2) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; int32_t leftv = 0, rightv = 1; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv); - scltMakeOpNode(&opNode, OP_TYPE_EQUAL, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_EQUAL, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -462,12 +585,16 @@ TEST(constantTest, int_equal_smallint2) { TEST(constantTest, int_not_equal_smallint1) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; int32_t leftv = 1, rightv = 1; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv); - scltMakeOpNode(&opNode, OP_TYPE_NOT_EQUAL, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_NOT_EQUAL, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -479,12 +606,16 @@ TEST(constantTest, int_not_equal_smallint1) { TEST(constantTest, int_not_equal_smallint2) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; int32_t leftv = 0, rightv = 1; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv); - scltMakeOpNode(&opNode, OP_TYPE_NOT_EQUAL, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_NOT_EQUAL, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -498,19 +629,30 @@ TEST(constantTest, int_in_smallint1) { SNode *pLeft = NULL, *pRight = NULL, *listNode = NULL, *res = NULL, *opNode = NULL; int32_t leftv = 1, rightv1 = 1, rightv2 = 2, rightv3 = 3; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SNodeList *list = nodesMakeList(); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1); - nodesListAppend(list, pRight); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv2); - nodesListAppend(list, pRight); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv3); - nodesListAppend(list, pRight); - scltMakeListNode(&listNode, list, TSDB_DATA_TYPE_INT); - scltMakeOpNode(&opNode, OP_TYPE_IN, TSDB_DATA_TYPE_BOOL, pLeft, listNode); + ASSERT_NE(list, nullptr); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = nodesListAppend(list, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = nodesListAppend(list, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv3); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = nodesListAppend(list, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeListNode(&listNode, list, TSDB_DATA_TYPE_INT); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_IN, TSDB_DATA_TYPE_BOOL, pLeft, listNode); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -524,19 +666,30 @@ TEST(constantTest, int_in_smallint2) { SNode *pLeft = NULL, *pRight = NULL, *listNode = NULL, *res = NULL, *opNode = NULL; int32_t leftv = 4, rightv1 = 1, rightv2 = 2, rightv3 = 3; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SNodeList *list = nodesMakeList(); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1); - nodesListAppend(list, pRight); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv2); - nodesListAppend(list, pRight); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv3); - nodesListAppend(list, pRight); - scltMakeListNode(&listNode, list, TSDB_DATA_TYPE_INT); - scltMakeOpNode(&opNode, OP_TYPE_IN, TSDB_DATA_TYPE_BOOL, pLeft, listNode); + ASSERT_NE(list, nullptr); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = nodesListAppend(list, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = nodesListAppend(list, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv3); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = nodesListAppend(list, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeListNode(&listNode, list, TSDB_DATA_TYPE_INT); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_IN, TSDB_DATA_TYPE_BOOL, pLeft, listNode); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -548,19 +701,30 @@ TEST(constantTest, int_in_smallint2) { TEST(constantTest, int_not_in_smallint1) { SNode *pLeft = NULL, *pRight = NULL, *listNode = NULL, *res = NULL, *opNode = NULL; int32_t leftv = 1, rightv1 = 1, rightv2 = 2, rightv3 = 3; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SNodeList *list = nodesMakeList(); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1); - nodesListAppend(list, pRight); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv2); - nodesListAppend(list, pRight); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv3); - nodesListAppend(list, pRight); - scltMakeListNode(&listNode, list, TSDB_DATA_TYPE_INT); - scltMakeOpNode(&opNode, OP_TYPE_NOT_IN, TSDB_DATA_TYPE_BOOL, pLeft, listNode); + ASSERT_NE(list, nullptr); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = nodesListAppend(list, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = nodesListAppend(list, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv3); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = nodesListAppend(list, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeListNode(&listNode, list, TSDB_DATA_TYPE_INT); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_NOT_IN, TSDB_DATA_TYPE_BOOL, pLeft, listNode); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -574,19 +738,30 @@ TEST(constantTest, int_not_in_smallint2) { SNode *pLeft = NULL, *pRight = NULL, *listNode = NULL, *res = NULL, *opNode = NULL; int32_t leftv = 4, rightv1 = 1, rightv2 = 2, rightv3 = 3; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SNodeList *list = nodesMakeList(); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1); - nodesListAppend(list, pRight); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv2); - nodesListAppend(list, pRight); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv3); - nodesListAppend(list, pRight); - scltMakeListNode(&listNode, list, TSDB_DATA_TYPE_INT); - scltMakeOpNode(&opNode, OP_TYPE_NOT_IN, TSDB_DATA_TYPE_BOOL, pLeft, listNode); + ASSERT_NE(list, nullptr); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv1); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = nodesListAppend(list, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = nodesListAppend(list, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_SMALLINT, &rightv3); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = nodesListAppend(list, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeListNode(&listNode, list, TSDB_DATA_TYPE_INT); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_NOT_IN, TSDB_DATA_TYPE_BOOL, pLeft, listNode); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -598,16 +773,20 @@ TEST(constantTest, int_not_in_smallint2) { TEST(constantTest, binary_like_binary1) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; char leftv[64] = {0}, rightv[64] = {0}; - sprintf(&leftv[2], "%s", "abc"); + int32_t code = TSDB_CODE_SUCCESS; + (void)sprintf(&leftv[2], "%s", "abc"); varDataSetLen(leftv, strlen(&leftv[2])); - sprintf(&rightv[2], "%s", "a_c"); + (void)sprintf(&rightv[2], "%s", "a_c"); varDataSetLen(rightv, strlen(&rightv[2])); - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_BINARY, leftv); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv); - scltMakeOpNode(&opNode, OP_TYPE_LIKE, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_BINARY, leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_LIKE, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -619,16 +798,20 @@ TEST(constantTest, binary_like_binary1) { TEST(constantTest, binary_like_binary2) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; char leftv[64] = {0}, rightv[64] = {0}; - sprintf(&leftv[2], "%s", "abc"); + int32_t code = TSDB_CODE_SUCCESS; + (void)sprintf(&leftv[2], "%s", "abc"); varDataSetLen(leftv, strlen(&leftv[2])); - sprintf(&rightv[2], "%s", "ac"); + (void)sprintf(&rightv[2], "%s", "ac"); varDataSetLen(rightv, strlen(&rightv[2])); - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_BINARY, leftv); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv); - scltMakeOpNode(&opNode, OP_TYPE_LIKE, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_BINARY, leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_LIKE, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -640,16 +823,20 @@ TEST(constantTest, binary_like_binary2) { TEST(constantTest, binary_not_like_binary1) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; char leftv[64] = {0}, rightv[64] = {0}; - sprintf(&leftv[2], "%s", "abc"); + int32_t code = TSDB_CODE_SUCCESS; + (void)sprintf(&leftv[2], "%s", "abc"); varDataSetLen(leftv, strlen(&leftv[2])); - sprintf(&rightv[2], "%s", "a%c"); + (void)sprintf(&rightv[2], "%s", "a%c"); varDataSetLen(rightv, strlen(&rightv[2])); - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_BINARY, leftv); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv); - scltMakeOpNode(&opNode, OP_TYPE_NOT_LIKE, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_BINARY, leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_NOT_LIKE, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -661,16 +848,20 @@ TEST(constantTest, binary_not_like_binary1) { TEST(constantTest, binary_not_like_binary2) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; char leftv[64] = {0}, rightv[64] = {0}; - sprintf(&leftv[2], "%s", "abc"); + int32_t code = TSDB_CODE_SUCCESS; + (void)sprintf(&leftv[2], "%s", "abc"); varDataSetLen(leftv, strlen(&leftv[2])); - sprintf(&rightv[2], "%s", "ac"); + (void)sprintf(&rightv[2], "%s", "ac"); varDataSetLen(rightv, strlen(&rightv[2])); - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_BINARY, leftv); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv); - scltMakeOpNode(&opNode, OP_TYPE_NOT_LIKE, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_BINARY, leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_NOT_LIKE, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -682,16 +873,20 @@ TEST(constantTest, binary_not_like_binary2) { TEST(constantTest, binary_match_binary1) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; char leftv[64] = {0}, rightv[64] = {0}; - sprintf(&leftv[2], "%s", "abc"); + int32_t code = TSDB_CODE_SUCCESS; + (void)sprintf(&leftv[2], "%s", "abc"); varDataSetLen(leftv, strlen(&leftv[2])); - sprintf(&rightv[2], "%s", ".*"); + (void)sprintf(&rightv[2], "%s", ".*"); varDataSetLen(rightv, strlen(&rightv[2])); - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_BINARY, leftv); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv); - scltMakeOpNode(&opNode, OP_TYPE_MATCH, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_BINARY, leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_MATCH, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -703,16 +898,20 @@ TEST(constantTest, binary_match_binary1) { TEST(constantTest, binary_match_binary2) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; char leftv[64] = {0}, rightv[64] = {0}; - sprintf(&leftv[2], "%s", "abc"); + int32_t code = TSDB_CODE_SUCCESS; + (void)sprintf(&leftv[2], "%s", "abc"); varDataSetLen(leftv, strlen(&leftv[2])); - sprintf(&rightv[2], "%s", "abc.+"); + (void)sprintf(&rightv[2], "%s", "abc.+"); varDataSetLen(rightv, strlen(&rightv[2])); - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_BINARY, leftv); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv); - scltMakeOpNode(&opNode, OP_TYPE_MATCH, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_BINARY, leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_MATCH, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -724,16 +923,20 @@ TEST(constantTest, binary_match_binary2) { TEST(constantTest, binary_not_match_binary1) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; char leftv[64] = {0}, rightv[64] = {0}; - sprintf(&leftv[2], "%s", "abc"); + int32_t code = TSDB_CODE_SUCCESS; + (void)sprintf(&leftv[2], "%s", "abc"); varDataSetLen(leftv, strlen(&leftv[2])); - sprintf(&rightv[2], "%s", "a[1-9]c"); + (void)sprintf(&rightv[2], "%s", "a[1-9]c"); varDataSetLen(rightv, strlen(&rightv[2])); - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_BINARY, leftv); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv); - scltMakeOpNode(&opNode, OP_TYPE_NMATCH, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_BINARY, leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_NMATCH, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -745,16 +948,20 @@ TEST(constantTest, binary_not_match_binary1) { TEST(constantTest, binary_not_match_binary2) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; char leftv[64] = {0}, rightv[64] = {0}; - sprintf(&leftv[2], "%s", "abc"); + int32_t code = TSDB_CODE_SUCCESS; + (void)sprintf(&leftv[2], "%s", "abc"); varDataSetLen(leftv, strlen(&leftv[2])); - sprintf(&rightv[2], "%s", "a[ab]c"); + (void)sprintf(&rightv[2], "%s", "a[ab]c"); varDataSetLen(rightv, strlen(&rightv[2])); - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_BINARY, leftv); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv); - scltMakeOpNode(&opNode, OP_TYPE_NMATCH, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_BINARY, leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_NMATCH, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -766,11 +973,14 @@ TEST(constantTest, binary_not_match_binary2) { TEST(constantTest, int_is_null1) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; int32_t leftv = 1, rightv = 1; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); - scltMakeOpNode(&opNode, OP_TYPE_IS_NULL, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_IS_NULL, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -782,11 +992,14 @@ TEST(constantTest, int_is_null1) { TEST(constantTest, int_is_null2) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; int32_t leftv = TSDB_DATA_INT_NULL, rightv = 1; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_NULL, &leftv); - scltMakeOpNode(&opNode, OP_TYPE_IS_NULL, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_NULL, &leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_IS_NULL, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -798,11 +1011,14 @@ TEST(constantTest, int_is_null2) { TEST(constantTest, int_is_not_null1) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; int32_t leftv = 1, rightv = 1; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); - scltMakeOpNode(&opNode, OP_TYPE_IS_NOT_NULL, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_IS_NOT_NULL, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -814,11 +1030,14 @@ TEST(constantTest, int_is_not_null1) { TEST(constantTest, int_is_not_null2) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; int32_t leftv = 1, rightv = 1; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_NULL, &leftv); - scltMakeOpNode(&opNode, OP_TYPE_IS_NOT_NULL, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_NULL, &leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_IS_NOT_NULL, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -830,13 +1049,18 @@ TEST(constantTest, int_is_not_null2) { TEST(constantTest, int_add_int_is_true1) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; int32_t leftv = 1, rightv = 1; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_INT, &rightv); - scltMakeOpNode(&opNode, OP_TYPE_ADD, TSDB_DATA_TYPE_DOUBLE, pLeft, pRight); - scltMakeOpNode(&opNode, OP_TYPE_IS_TRUE, TSDB_DATA_TYPE_BOOL, opNode, NULL); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_INT, &rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_ADD, TSDB_DATA_TYPE_DOUBLE, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_IS_TRUE, TSDB_DATA_TYPE_BOOL, opNode, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -848,13 +1072,18 @@ TEST(constantTest, int_add_int_is_true1) { TEST(constantTest, int_add_int_is_true2) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; int32_t leftv = 1, rightv = -1; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_INT, &rightv); - scltMakeOpNode(&opNode, OP_TYPE_ADD, TSDB_DATA_TYPE_DOUBLE, pLeft, pRight); - scltMakeOpNode(&opNode, OP_TYPE_IS_TRUE, TSDB_DATA_TYPE_BOOL, opNode, NULL); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_INT, &rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_ADD, TSDB_DATA_TYPE_DOUBLE, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_IS_TRUE, TSDB_DATA_TYPE_BOOL, opNode, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -866,13 +1095,18 @@ TEST(constantTest, int_add_int_is_true2) { TEST(constantTest, int_greater_int_is_true1) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; int32_t leftv = 1, rightv = 1; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_INT, &rightv); - scltMakeOpNode(&opNode, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pLeft, pRight); - scltMakeOpNode(&opNode, OP_TYPE_IS_TRUE, TSDB_DATA_TYPE_BOOL, opNode, NULL); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_INT, &rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_IS_TRUE, TSDB_DATA_TYPE_BOOL, opNode, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -884,13 +1118,18 @@ TEST(constantTest, int_greater_int_is_true1) { TEST(constantTest, int_greater_int_is_true2) { SNode *pLeft = NULL, *pRight = NULL, *opNode = NULL, *res = NULL; int32_t leftv = 1, rightv = 0; - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_INT, &rightv); - scltMakeOpNode(&opNode, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pLeft, pRight); - scltMakeOpNode(&opNode, OP_TYPE_IS_TRUE, TSDB_DATA_TYPE_BOOL, opNode, NULL); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_INT, &rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_IS_TRUE, TSDB_DATA_TYPE_BOOL, opNode, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(opNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(opNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -906,18 +1145,26 @@ TEST(constantTest, greater_and_lower) { bool eRes[5] = {false, false, true, true, true}; int64_t v1 = 333, v2 = 222, v3 = -10, v4 = 20; SNode *list[2] = {0}; - scltMakeValueNode(&pval1, TSDB_DATA_TYPE_BIGINT, &v1); - scltMakeValueNode(&pval2, TSDB_DATA_TYPE_BIGINT, &v2); - scltMakeOpNode(&opNode1, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pval1, pval2); - scltMakeValueNode(&pval1, TSDB_DATA_TYPE_BIGINT, &v3); - scltMakeValueNode(&pval2, TSDB_DATA_TYPE_BIGINT, &v4); - scltMakeOpNode(&opNode2, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pval1, pval2); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pval1, TSDB_DATA_TYPE_BIGINT, &v1); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pval2, TSDB_DATA_TYPE_BIGINT, &v2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode1, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pval1, pval2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pval1, TSDB_DATA_TYPE_BIGINT, &v3); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pval2, TSDB_DATA_TYPE_BIGINT, &v4); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode2, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pval1, pval2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); list[0] = opNode1; list[1] = opNode2; - scltMakeLogicNode(&logicNode, LOGIC_COND_TYPE_AND, list, 2); + code = scltMakeLogicNode(&logicNode, LOGIC_COND_TYPE_AND, list, 2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(logicNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(logicNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -933,18 +1180,26 @@ TEST(constantTest, column_and_value1) { bool eRes[5] = {false, false, true, true, true}; int64_t v1 = 333, v2 = 222, v3 = -10, v4 = 20; SNode *list[2] = {0}; - scltMakeValueNode(&pval1, TSDB_DATA_TYPE_BIGINT, &v1); - scltMakeValueNode(&pval2, TSDB_DATA_TYPE_BIGINT, &v2); - scltMakeOpNode(&opNode1, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pval1, pval2); - scltMakeValueNode(&pval1, TSDB_DATA_TYPE_BIGINT, &v3); - scltMakeColumnNode(&pval2, NULL, TSDB_DATA_TYPE_BIGINT, sizeof(int64_t), 0, NULL); - scltMakeOpNode(&opNode2, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pval1, pval2); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pval1, TSDB_DATA_TYPE_BIGINT, &v1); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pval2, TSDB_DATA_TYPE_BIGINT, &v2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode1, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pval1, pval2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pval1, TSDB_DATA_TYPE_BIGINT, &v3); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeColumnNode(&pval2, NULL, TSDB_DATA_TYPE_BIGINT, sizeof(int64_t), 0, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode2, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pval1, pval2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); list[0] = opNode1; list[1] = opNode2; - scltMakeLogicNode(&logicNode, LOGIC_COND_TYPE_AND, list, 2); + code = scltMakeLogicNode(&logicNode, LOGIC_COND_TYPE_AND, list, 2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(logicNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(logicNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_LOGIC_CONDITION); SLogicConditionNode *v = (SLogicConditionNode *)res; @@ -960,18 +1215,26 @@ TEST(constantTest, column_and_value2) { bool eRes[5] = {false, false, true, true, true}; int64_t v1 = 333, v2 = 222, v3 = -10, v4 = 20; SNode *list[2] = {0}; - scltMakeValueNode(&pval1, TSDB_DATA_TYPE_BIGINT, &v1); - scltMakeValueNode(&pval2, TSDB_DATA_TYPE_BIGINT, &v2); - scltMakeOpNode(&opNode1, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pval1, pval2); - scltMakeValueNode(&pval1, TSDB_DATA_TYPE_BIGINT, &v3); - scltMakeColumnNode(&pval2, NULL, TSDB_DATA_TYPE_BIGINT, sizeof(int64_t), 0, NULL); - scltMakeOpNode(&opNode2, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pval1, pval2); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pval1, TSDB_DATA_TYPE_BIGINT, &v1); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pval2, TSDB_DATA_TYPE_BIGINT, &v2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode1, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pval1, pval2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pval1, TSDB_DATA_TYPE_BIGINT, &v3); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeColumnNode(&pval2, NULL, TSDB_DATA_TYPE_BIGINT, sizeof(int64_t), 0, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode2, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pval1, pval2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); list[0] = opNode1; list[1] = opNode2; - scltMakeLogicNode(&logicNode, LOGIC_COND_TYPE_AND, list, 2); + code = scltMakeLogicNode(&logicNode, LOGIC_COND_TYPE_AND, list, 2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(logicNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(logicNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -987,18 +1250,26 @@ TEST(constantTest, column_and_value3) { bool eRes[5] = {false, false, true, true, true}; int64_t v1 = 333, v2 = 222, v3 = -10, v4 = 20; SNode *list[2] = {0}; - scltMakeValueNode(&pval1, TSDB_DATA_TYPE_BIGINT, &v1); - scltMakeValueNode(&pval2, TSDB_DATA_TYPE_BIGINT, &v2); - scltMakeOpNode(&opNode1, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pval1, pval2); - scltMakeValueNode(&pval1, TSDB_DATA_TYPE_BIGINT, &v3); - scltMakeColumnNode(&pval2, NULL, TSDB_DATA_TYPE_BIGINT, sizeof(int64_t), 0, NULL); - scltMakeOpNode(&opNode2, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pval1, pval2); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pval1, TSDB_DATA_TYPE_BIGINT, &v1); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pval2, TSDB_DATA_TYPE_BIGINT, &v2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode1, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pval1, pval2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pval1, TSDB_DATA_TYPE_BIGINT, &v3); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeColumnNode(&pval2, NULL, TSDB_DATA_TYPE_BIGINT, sizeof(int64_t), 0, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode2, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pval1, pval2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); list[0] = opNode1; list[1] = opNode2; - scltMakeLogicNode(&logicNode, LOGIC_COND_TYPE_OR, list, 2); + code = scltMakeLogicNode(&logicNode, LOGIC_COND_TYPE_OR, list, 2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(logicNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(logicNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_VALUE); SValueNode *v = (SValueNode *)res; @@ -1014,18 +1285,25 @@ TEST(constantTest, column_and_value4) { bool eRes[5] = {false, false, true, true, true}; int64_t v1 = 333, v2 = 222, v3 = -10, v4 = 20; SNode *list[2] = {0}; - scltMakeValueNode(&pval1, TSDB_DATA_TYPE_BIGINT, &v1); - scltMakeValueNode(&pval2, TSDB_DATA_TYPE_BIGINT, &v2); - scltMakeOpNode(&opNode1, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pval1, pval2); - scltMakeValueNode(&pval1, TSDB_DATA_TYPE_BIGINT, &v3); - scltMakeColumnNode(&pval2, NULL, TSDB_DATA_TYPE_BIGINT, sizeof(int64_t), 0, NULL); - scltMakeOpNode(&opNode2, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pval1, pval2); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pval1, TSDB_DATA_TYPE_BIGINT, &v1); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pval2, TSDB_DATA_TYPE_BIGINT, &v2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode1, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pval1, pval2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pval1, TSDB_DATA_TYPE_BIGINT, &v3); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeColumnNode(&pval2, NULL, TSDB_DATA_TYPE_BIGINT, sizeof(int64_t), 0, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode2, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pval1, pval2); list[0] = opNode1; list[1] = opNode2; - scltMakeLogicNode(&logicNode, LOGIC_COND_TYPE_OR, list, 2); + code = scltMakeLogicNode(&logicNode, LOGIC_COND_TYPE_OR, list, 2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculateConstants(logicNode, &res); - ASSERT_EQ(code, 0); + code = scalarCalculateConstants(logicNode, &res); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); ASSERT_TRUE(res); ASSERT_EQ(nodeType(res), QUERY_NODE_LOGIC_CONDITION); SLogicConditionNode *v = (SLogicConditionNode *)res; @@ -1034,19 +1312,21 @@ TEST(constantTest, column_and_value4) { nodesDestroyNode(res); } -void makeJsonArrow(SSDataBlock **src, SNode **opNode, void *json, char *key) { +int32_t makeJsonArrow(SSDataBlock **src, SNode **opNode, void *json, char *key) { char keyVar[32] = {0}; - memcpy(varDataVal(keyVar), key, strlen(key)); + (void)memcpy(varDataVal(keyVar), key, strlen(key)); varDataLen(keyVar) = strlen(key); SNode *pLeft = NULL, *pRight = NULL; - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, keyVar); - scltMakeColumnNode(&pLeft, src, TSDB_DATA_TYPE_JSON, ((STag *)json)->len, 1, json); - scltMakeOpNode(opNode, OP_TYPE_JSON_GET_VALUE, TSDB_DATA_TYPE_JSON, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + SCL_ERR_RET(scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, keyVar)); + SCL_ERR_RET(scltMakeColumnNode(&pLeft, src, TSDB_DATA_TYPE_JSON, ((STag *)json)->len, 1, json)); + SCL_ERR_RET(scltMakeOpNode(opNode, OP_TYPE_JSON_GET_VALUE, TSDB_DATA_TYPE_JSON, pLeft, pRight)); + SCL_RET(code); } -void makeOperator(SNode **opNode, SArray *blockList, EOperatorType opType, int32_t rightType, void *rightData, - bool isReverse) { +int32_t makeOperator(SNode **opNode, SArray *blockList, EOperatorType opType, int32_t rightType, void *rightData, + bool isReverse) { int32_t resType = TSDB_DATA_TYPE_NULL; if (opType == OP_TYPE_ADD || opType == OP_TYPE_SUB || opType == OP_TYPE_MULTI || opType == OP_TYPE_DIV || opType == OP_TYPE_REM || opType == OP_TYPE_MINUS) { @@ -1062,58 +1342,73 @@ void makeOperator(SNode **opNode, SArray *blockList, EOperatorType opType, int32 } SNode *right = NULL; - scltMakeValueNode(&right, rightType, rightData); - scltMakeOpNode2(opNode, opType, resType, *opNode, right, isReverse); + int32_t code = TSDB_CODE_SUCCESS; + SCL_ERR_RET(scltMakeValueNode(&right, rightType, rightData)); + SCL_ERR_RET(scltMakeOpNode2(opNode, opType, resType, *opNode, right, isReverse)); SColumnInfo colInfo = createColumnInfo(1, resType, tDataTypes[resType].bytes); int16_t dataBlockId = 0, slotId = 0; - scltAppendReservedSlot(blockList, &dataBlockId, &slotId, true, 1, &colInfo); - scltMakeTargetNode(opNode, dataBlockId, slotId, *opNode); + SCL_ERR_RET(scltAppendReservedSlot(blockList, &dataBlockId, &slotId, true, 1, &colInfo)); + SCL_ERR_RET(scltMakeTargetNode(opNode, dataBlockId, slotId, *opNode)); + SCL_RET(code); } -void makeCalculate(void *json, void *key, int32_t rightType, void *rightData, double exceptValue, EOperatorType opType, - bool isReverse) { +int32_t makeCalculate(void *json, void *key, int32_t rightType, void *rightData, double exceptValue, + EOperatorType opType, bool isReverse) { SArray *blockList = taosArrayInit(2, POINTER_BYTES); SSDataBlock *src = NULL; SNode *opNode = NULL; - makeJsonArrow(&src, &opNode, json, (char *)key); - taosArrayPush(blockList, &src); + SCL_ERR_RET(makeJsonArrow(&src, &opNode, json, (char *)key)); + (void)taosArrayPush(blockList, &src); - makeOperator(&opNode, blockList, opType, rightType, rightData, isReverse); + SCL_ERR_RET(makeOperator(&opNode, blockList, opType, rightType, rightData, isReverse)); - int32_t code = scalarCalculate(opNode, blockList, NULL); - ASSERT_EQ(code, 0); + SCL_ERR_RET(scalarCalculate(opNode, blockList, NULL)); SSDataBlock *res = *(SSDataBlock **)taosArrayGetLast(blockList); - ASSERT_EQ(res->info.rows, 1); + if (res->info.rows != 1) { + (void)printf("expect 1 row, but got %d\n", res->info.rows); + SCL_ERR_RET(TSDB_CODE_FAILED); + } SColumnInfoData *column = (SColumnInfoData *)taosArrayGetLast(res->pDataBlock); if (colDataIsNull_f(column->nullbitmap, 0)) { - ASSERT_EQ(DBL_MAX, exceptValue); - printf("result:NULL\n"); + if (DBL_MAX != exceptValue) { + (void)printf("expect value = DBL_MAX, but got %d\n", exceptValue); + SCL_ERR_RET(TSDB_CODE_FAILED); + } + (void)printf("result:NULL\n"); } else if (opType == OP_TYPE_ADD || opType == OP_TYPE_SUB || opType == OP_TYPE_MULTI || opType == OP_TYPE_DIV || opType == OP_TYPE_REM || opType == OP_TYPE_MINUS) { - printf("op:%s,1result:%f,except:%f\n", operatorTypeStr(opType), *((double *)colDataGetData(column, 0)), - exceptValue); - ASSERT_TRUE(fabs(*((double *)colDataGetData(column, 0)) - exceptValue) < 0.0001); + (void)printf("op:%s,1result:%f,except:%f\n", operatorTypeStr(opType), *((double *)colDataGetData(column, 0)), + exceptValue); + if (fabs(*((double *)colDataGetData(column, 0)) - exceptValue) >= 0.0001) { + (void)printf("expect value %d, but got %d\n", *((double *)colDataGetData(column, 0)), exceptValue); + SCL_ERR_RET(TSDB_CODE_FAILED); + } } else if (opType == OP_TYPE_BIT_AND || opType == OP_TYPE_BIT_OR) { - printf("op:%s,2result:%" PRId64 ",except:%f\n", operatorTypeStr(opType), *((int64_t *)colDataGetData(column, 0)), - exceptValue); - ASSERT_EQ(*((int64_t *)colDataGetData(column, 0)), exceptValue); + (void)printf("op:%s,2result:%" PRId64 ",except:%f\n", operatorTypeStr(opType), + *((int64_t *)colDataGetData(column, 0)), exceptValue); + if (*((int64_t *)colDataGetData(column, 0)) != exceptValue) { + (void)printf("expect value %d, but got %d\n", *((int64_t *)colDataGetData(column, 0)), exceptValue); + SCL_ERR_RET(TSDB_CODE_FAILED); + } } else if (opType == OP_TYPE_GREATER_THAN || opType == OP_TYPE_GREATER_EQUAL || opType == OP_TYPE_LOWER_THAN || opType == OP_TYPE_LOWER_EQUAL || opType == OP_TYPE_EQUAL || opType == OP_TYPE_NOT_EQUAL || opType == OP_TYPE_IS_NULL || opType == OP_TYPE_IS_NOT_NULL || opType == OP_TYPE_IS_TRUE || opType == OP_TYPE_LIKE || opType == OP_TYPE_NOT_LIKE || opType == OP_TYPE_MATCH || opType == OP_TYPE_NMATCH) { - printf("op:%s,3result:%d,except:%f\n", operatorTypeStr(opType), *((bool *)colDataGetData(column, 0)), exceptValue); + (void)printf("op:%s,3result:%d,except:%f\n", operatorTypeStr(opType), *((bool *)colDataGetData(column, 0)), + exceptValue); assert(*(bool *)colDataGetData(column, 0) == exceptValue); // ASSERT_EQ((int) *((bool *)colDataGetData(column, 0)), (int)exceptValue); } taosArrayDestroyEx(blockList, scltFreeDataBlock); nodesDestroyNode(opNode); + SCL_RET(TSDB_CODE_SUCCESS); } TEST(columnTest, json_column_arith_op) { @@ -1123,10 +1418,12 @@ TEST(columnTest, json_column_arith_op) { "\"8hel\"}"; char rightv[256] = {0}; - memcpy(rightv, rightvTmp, strlen(rightvTmp)); + (void)memcpy(rightv, rightvTmp, strlen(rightvTmp)); SArray *tags = taosArrayInit(1, sizeof(STagVal)); + ASSERT_NE(tags, nullptr); STag *row = NULL; - parseJsontoTagData(rightv, tags, &row, NULL); + int32_t code = parseJsontoTagData(rightv, tags, &row, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); const int32_t len = 8; EOperatorType op[len] = {OP_TYPE_ADD, OP_TYPE_SUB, OP_TYPE_MULTI, OP_TYPE_DIV, @@ -1138,10 +1435,12 @@ TEST(columnTest, json_column_arith_op) { double eRes00[len] = {5.0, -4, 8.0, 2.0, 1.0, -4, 4 & -4, 4 | 9}; double eRes01[len] = {5.0, 4, 8.0, 0.5, 3, 0, 4 & -4, 4 | 9}; for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes00[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes00[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes01[i], op[i], true); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes01[i], op[i], true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } printf("--------------------json string- 0 op {1, 8, 2, 2, 3, 0, -4, 9}--------------------\n"); @@ -1150,10 +1449,12 @@ TEST(columnTest, json_column_arith_op) { double eRes10[len] = {1.0, -8, 0, 0, 0, 0, 0, 9}; double eRes11[len] = {1.0, 8, 0, DBL_MAX, DBL_MAX, 0, 0, 9}; for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes10[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes10[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes11[i], op[i], true); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes11[i], op[i], true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } printf("---------------------json null- null op {1, 8, 2, 2, 3, 0, -4, 9}-------------------\n"); @@ -1162,10 +1463,12 @@ TEST(columnTest, json_column_arith_op) { double eRes20[len] = {DBL_MAX, DBL_MAX, DBL_MAX, DBL_MAX, DBL_MAX, DBL_MAX, DBL_MAX, DBL_MAX}; double eRes21[len] = {DBL_MAX, DBL_MAX, DBL_MAX, DBL_MAX, DBL_MAX, 0, DBL_MAX, DBL_MAX}; for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes20[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes20[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes21[i], op[i], true); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes21[i], op[i], true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } printf("---------------------json bool- true op {1, 8, 2, 2, 3, 0, -4, 9}-------------------\n"); @@ -1174,10 +1477,12 @@ TEST(columnTest, json_column_arith_op) { double eRes30[len] = {2.0, -7, 2, 0.5, 1, -1, 1 & -4, 1 | 9}; double eRes31[len] = {2.0, 7, 2, 2, 0, 0, 1 & -4, 1 | 9}; for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes30[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes30[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes31[i], op[i], true); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes31[i], op[i], true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } printf("----------------------json double-- 5.44 op {1, 8, 2, 2, 3, 0, -4, 9}------------------\n"); @@ -1186,10 +1491,12 @@ TEST(columnTest, json_column_arith_op) { double eRes40[len] = {6.44, -2.56, 10.88, 2.72, 2.44, -5.44, 5 & -4, 5 | 9}; double eRes41[len] = {6.44, 2.56, 10.88, 0.3676470588235294, 3, 0, 5 & -4, 5 | 9}; for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes40[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes40[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes41[i], op[i], true); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes41[i], op[i], true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } printf("----------------------json int-- -10 op {1, 8, 2, 2, 3, 0, -4, 9}------------------\n"); @@ -1198,10 +1505,12 @@ TEST(columnTest, json_column_arith_op) { double eRes50[len] = {-9, -18, -20, -5, -10 % 3, 10, -10 & -4, -10 | 9}; double eRes51[len] = {-9, 18, -20, -0.2, 3 % -10, 0, -10 & -4, -10 | 9}; for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes50[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes50[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes51[i], op[i], true); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes51[i], op[i], true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } printf("----------------------json double-- -9.8 op {1, 8, 2, 2, 3, 0, -4, 9}------------------\n"); @@ -1210,10 +1519,12 @@ TEST(columnTest, json_column_arith_op) { double eRes60[len] = {-8.8, -17.8, -19.6, -4.9, -0.8, 9.8, -9 & -4, -9 | 9}; double eRes61[len] = {-8.8, 17.8, -19.6, -0.2040816326530612, 3, 0, -9 & -4, -9 | 9}; for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes60[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes60[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes61[i], op[i], true); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes61[i], op[i], true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } printf("----------------------json bool-- 0 op {1, 8, 2, 2, 3, 0, -4, 9}------------------\n"); @@ -1222,10 +1533,12 @@ TEST(columnTest, json_column_arith_op) { double eRes70[len] = {1.0, -8, 0, 0, 0, 0, 0, 9}; double eRes71[len] = {1.0, 8, 0, DBL_MAX, DBL_MAX, 0, 0, 9}; for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes70[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes70[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes71[i], op[i], true); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes71[i], op[i], true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } printf("----------------------json string-- 8 op {1, 8, 2, 2, 3, 0, -4, 9}------------------\n"); @@ -1234,10 +1547,12 @@ TEST(columnTest, json_column_arith_op) { double eRes80[len] = {9, 0, 16, 4, 8 % 3, -8, 8 & -4, 8 | 9}; double eRes81[len] = {9, 0, 16, 0.25, 3 % 8, 0, 8 & -4, 8 | 9}; for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes80[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes80[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes81[i], op[i], true); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes81[i], op[i], true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } printf("---------------------json not exist-- NULL op {1, 8, 2, 2, 3, 0, -4, 9}------------------\n"); @@ -1246,10 +1561,12 @@ TEST(columnTest, json_column_arith_op) { double eRes90[len] = {DBL_MAX, DBL_MAX, DBL_MAX, DBL_MAX, DBL_MAX, DBL_MAX, DBL_MAX, DBL_MAX}; double eRes91[len] = {DBL_MAX, DBL_MAX, DBL_MAX, DBL_MAX, DBL_MAX, 0, DBL_MAX, DBL_MAX}; for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes90[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes90[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes91[i], op[i], true); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes91[i], op[i], true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } taosArrayDestroy(tags); @@ -1273,10 +1590,13 @@ TEST(columnTest, json_column_logic_op) { "6hello\"}"; char rightv[256] = {0}; - memcpy(rightv, rightvTmp, strlen(rightvTmp)); + int32_t code = TSDB_CODE_SUCCESS; + (void)memcpy(rightv, rightvTmp, strlen(rightvTmp)); SArray *tags = taosArrayInit(1, sizeof(STagVal)); + ASSERT_NE(tags, nullptr); STag *row = NULL; - parseJsontoTagData(rightv, tags, &row, NULL); + code = parseJsontoTagData(rightv, tags, &row, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); const int32_t len0 = 6; const int32_t len = 9; @@ -1288,20 +1608,22 @@ TEST(columnTest, json_column_logic_op) { int32_t input[len] = {1, 8, 2, 2, 3, 0, 0, 0, 0}; char *inputNchar[len1] = {"hell_", "hel%", "hell", "llll"}; - printf("--------------------json int---4 {1, 8, 2, 2, 3, 0, 0, 0, 0}------------------\n"); char *key = "k1"; bool eRes[len + len1] = {true, false, false, false, false, true, false, true, true, false, false, false, false}; for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } bool eRes_0[len0] = {false, true, true, true, false, true}; for (int i = 0; i < len0; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes_0[i], op[i], true); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes_0[i], op[i], true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } for (int i = len; i < len + len1; i++) { void *rightData = prepareNchar(inputNchar[i - len]); - makeCalculate(row, key, TSDB_DATA_TYPE_NCHAR, rightData, eRes[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_NCHAR, rightData, eRes[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); taosMemoryFree(rightData); } @@ -1310,16 +1632,19 @@ TEST(columnTest, json_column_logic_op) { key = "k2"; bool eRes1[len + len1] = {false, false, false, false, false, false, false, true, false, true, false, true, true}; for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes1[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes1[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } bool eRes_1[len0] = {false, false, false, false, false, false}; for (int i = 0; i < len0; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes_1[i], op[i], true); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes_1[i], op[i], true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } for (int i = len; i < len + len1; i++) { void *rightData = prepareNchar(inputNchar[i - len]); - makeCalculate(row, key, TSDB_DATA_TYPE_NCHAR, rightData, eRes1[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_NCHAR, rightData, eRes1[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); taosMemoryFree(rightData); } @@ -1328,16 +1653,19 @@ TEST(columnTest, json_column_logic_op) { key = "k3"; // (null is true) return NULL, so use DBL_MAX represent NULL bool eRes2[len + len1] = {false, false, false, false, false, false, true, false, false, false, false, false, false}; for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes2[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes2[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } bool eRes_2[len0] = {false, false, false, false, false, false}; for (int i = 0; i < len0; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes_2[i], op[i], true); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes_2[i], op[i], true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } for (int i = len; i < len + len1; i++) { void *rightData = prepareNchar(inputNchar[i - len]); - makeCalculate(row, key, TSDB_DATA_TYPE_NCHAR, rightData, eRes2[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_NCHAR, rightData, eRes2[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); taosMemoryFree(rightData); } @@ -1346,16 +1674,19 @@ TEST(columnTest, json_column_logic_op) { key = "k4"; bool eRes3[len + len1] = {false, false, false, false, false, false, false, true, true, false, false, false, false}; for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes3[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes3[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } bool eRes_3[len0] = {false, false, false, false, false, false}; for (int i = 0; i < len0; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes_3[i], op[i], true); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes_3[i], op[i], true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } for (int i = len; i < len + len1; i++) { void *rightData = prepareNchar(inputNchar[i - len]); - makeCalculate(row, key, TSDB_DATA_TYPE_NCHAR, rightData, eRes3[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_NCHAR, rightData, eRes3[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); taosMemoryFree(rightData); } @@ -1364,16 +1695,19 @@ TEST(columnTest, json_column_logic_op) { key = "k5"; bool eRes4[len + len1] = {true, false, false, false, false, true, false, true, true, false, false, false, false}; for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes4[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes4[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } bool eRes_4[len0] = {false, true, true, true, false, true}; for (int i = 0; i < len0; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes_4[i], op[i], true); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes_4[i], op[i], true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } for (int i = len; i < len + len1; i++) { void *rightData = prepareNchar(inputNchar[i - len]); - makeCalculate(row, key, TSDB_DATA_TYPE_NCHAR, rightData, eRes4[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_NCHAR, rightData, eRes4[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); taosMemoryFree(rightData); } @@ -1382,16 +1716,19 @@ TEST(columnTest, json_column_logic_op) { key = "k6"; bool eRes5[len + len1] = {false, false, true, true, false, true, false, true, true, false, false, false, false}; for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes5[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes5[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } bool eRes_5[len0] = {true, true, false, false, false, true}; for (int i = 0; i < len0; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes_5[i], op[i], true); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes_5[i], op[i], true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } for (int i = len; i < len + len1; i++) { void *rightData = prepareNchar(inputNchar[i - len]); - makeCalculate(row, key, TSDB_DATA_TYPE_NCHAR, rightData, eRes5[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_NCHAR, rightData, eRes5[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); taosMemoryFree(rightData); } @@ -1400,16 +1737,19 @@ TEST(columnTest, json_column_logic_op) { key = "k7"; bool eRes6[len + len1] = {false, false, true, true, false, true, false, true, true, false, false, false, false}; for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes6[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes6[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } bool eRes_6[len0] = {true, true, false, false, false, true}; for (int i = 0; i < len0; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes_6[i], op[i], true); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes_6[i], op[i], true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } for (int i = len; i < len + len1; i++) { void *rightData = prepareNchar(inputNchar[i - len]); - makeCalculate(row, key, TSDB_DATA_TYPE_NCHAR, rightData, eRes6[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_NCHAR, rightData, eRes6[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); taosMemoryFree(rightData); } @@ -1418,16 +1758,19 @@ TEST(columnTest, json_column_logic_op) { key = "k8"; bool eRes7[len + len1] = {false, false, false, false, false, false, false, true, false, false, false, false, false}; for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes7[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes7[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } bool eRes_7[len0] = {false, false, false, false, false, false}; for (int i = 0; i < len0; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes_7[i], op[i], true); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes_7[i], op[i], true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } for (int i = len; i < len + len1; i++) { void *rightData = prepareNchar(inputNchar[i - len]); - makeCalculate(row, key, TSDB_DATA_TYPE_NCHAR, rightData, eRes7[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_NCHAR, rightData, eRes7[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); taosMemoryFree(rightData); } @@ -1436,11 +1779,13 @@ TEST(columnTest, json_column_logic_op) { key = "k9"; bool eRes8[len + len1] = {false, false, false, false, false, false, false, true, true, false, true, true, true}; for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes8[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes8[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } bool eRes_8[len0] = {false, false, false, false, false, false}; for (int i = 0; i < len0; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes_8[i], op[i], true); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes_8[i], op[i], true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } for (int i = len; i < len + len1; i++) { @@ -1448,7 +1793,8 @@ TEST(columnTest, json_column_logic_op) { if (i == 11) { printf("abc\n"); } - makeCalculate(row, key, TSDB_DATA_TYPE_NCHAR, rightData, eRes8[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_NCHAR, rightData, eRes8[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); taosMemoryFree(rightData); } @@ -1457,16 +1803,19 @@ TEST(columnTest, json_column_logic_op) { key = "k10"; // (NULL is true) return NULL, so use DBL_MAX represent NULL bool eRes9[len + len1] = {false, false, false, false, false, false, true, false, false, false, false, false, false}; for (int i = 0; i < len; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes9[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes9[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } bool eRes_9[len0] = {false, false, false, false, false, false}; for (int i = 0; i < len0; i++) { - makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes_9[i], op[i], true); + code = makeCalculate(row, key, TSDB_DATA_TYPE_INT, &input[i], eRes_9[i], op[i], true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } for (int i = len; i < len + len1; i++) { void *rightData = prepareNchar(inputNchar[i - len]); - makeCalculate(row, key, TSDB_DATA_TYPE_NCHAR, rightData, eRes9[i], op[i], false); + code = makeCalculate(row, key, TSDB_DATA_TYPE_NCHAR, rightData, eRes9[i], op[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); taosMemoryFree(rightData); } @@ -1483,19 +1832,26 @@ TEST(columnTest, smallint_value_add_int_column) { double eRes[5] = {1.0, -4, -3, 24, 101}; SSDataBlock *src = NULL; int32_t rowNum = sizeof(rightv) / sizeof(rightv[0]); - scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); - scltMakeColumnNode(&pRight, &src, TSDB_DATA_TYPE_SMALLINT, sizeof(int16_t), rowNum, rightv); - scltMakeOpNode(&opNode, OP_TYPE_ADD, TSDB_DATA_TYPE_DOUBLE, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeValueNode(&pLeft, TSDB_DATA_TYPE_INT, &leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeColumnNode(&pRight, &src, TSDB_DATA_TYPE_SMALLINT, sizeof(int16_t), rowNum, rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_ADD, TSDB_DATA_TYPE_DOUBLE, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SArray *blockList = taosArrayInit(2, POINTER_BYTES); - taosArrayPush(blockList, &src); + ASSERT_NE(blockList, nullptr); + ASSERT_NE(taosArrayPush(blockList, &src), nullptr); SColumnInfo colInfo = createColumnInfo(1, TSDB_DATA_TYPE_DOUBLE, sizeof(double)); int16_t dataBlockId = 0, slotId = 0; - scltAppendReservedSlot(blockList, &dataBlockId, &slotId, true, rowNum, &colInfo); - scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + code = scltAppendReservedSlot(blockList, &dataBlockId, &slotId, true, rowNum, &colInfo); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculate(opNode, blockList, NULL); - ASSERT_EQ(code, 0); + code = scalarCalculate(opNode, blockList, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SSDataBlock *res = *(SSDataBlock **)taosArrayGetLast(blockList); ASSERT_EQ(res->info.rows, rowNum); @@ -1522,20 +1878,24 @@ TEST(columnTest, bigint_column_multi_binary_column) { double eRes[5] = {0, 2, 6, 12, 20}; SSDataBlock *src = NULL; int32_t rowNum = sizeof(rightv) / sizeof(rightv[0]); - scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_BIGINT, sizeof(int64_t), rowNum, leftv); - scltMakeColumnNode(&pRight, &src, TSDB_DATA_TYPE_BINARY, 5, rowNum, rightv); - scltMakeOpNode(&opNode, OP_TYPE_MULTI, TSDB_DATA_TYPE_DOUBLE, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_BIGINT, sizeof(int64_t), rowNum, leftv); + code = scltMakeColumnNode(&pRight, &src, TSDB_DATA_TYPE_BINARY, 5, rowNum, rightv); + code = scltMakeOpNode(&opNode, OP_TYPE_MULTI, TSDB_DATA_TYPE_DOUBLE, pLeft, pRight); SArray *blockList = taosArrayInit(1, POINTER_BYTES); - taosArrayPush(blockList, &src); + ASSERT_NE(blockList, nullptr); + (void)taosArrayPush(blockList, &src); SColumnInfo colInfo = createColumnInfo(1, TSDB_DATA_TYPE_DOUBLE, sizeof(double)); int16_t dataBlockId = 0, slotId = 0; - scltAppendReservedSlot(blockList, &dataBlockId, &slotId, false, rowNum, &colInfo); - scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + code = scltAppendReservedSlot(blockList, &dataBlockId, &slotId, false, rowNum, &colInfo); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculate(opNode, blockList, NULL); - ASSERT_EQ(code, 0); + code = scalarCalculate(opNode, blockList, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SSDataBlock *res = *(SSDataBlock **)taosArrayGetLast(blockList); ASSERT_EQ(res->info.rows, rowNum); @@ -1561,19 +1921,26 @@ TEST(columnTest, smallint_column_and_binary_column) { int64_t eRes[5] = {0, 0, 2, 0, 4}; SSDataBlock *src = NULL; int32_t rowNum = sizeof(rightv) / sizeof(rightv[0]); - scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_SMALLINT, sizeof(int16_t), rowNum, leftv); - scltMakeColumnNode(&pRight, &src, TSDB_DATA_TYPE_BINARY, 5, rowNum, rightv); - scltMakeOpNode(&opNode, OP_TYPE_BIT_AND, TSDB_DATA_TYPE_BIGINT, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_SMALLINT, sizeof(int16_t), rowNum, leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeColumnNode(&pRight, &src, TSDB_DATA_TYPE_BINARY, 5, rowNum, rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_BIT_AND, TSDB_DATA_TYPE_BIGINT, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SArray *blockList = taosArrayInit(1, POINTER_BYTES); - taosArrayPush(blockList, &src); + ASSERT_NE(blockList, nullptr); + ASSERT_NE(taosArrayPush(blockList, &src), nullptr); SColumnInfo colInfo = createColumnInfo(1, TSDB_DATA_TYPE_BIGINT, sizeof(int64_t)); int16_t dataBlockId = 0, slotId = 0; - scltAppendReservedSlot(blockList, &dataBlockId, &slotId, false, rowNum, &colInfo); - scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + code = scltAppendReservedSlot(blockList, &dataBlockId, &slotId, false, rowNum, &colInfo); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculate(opNode, blockList, NULL); - ASSERT_EQ(code, 0); + code = scalarCalculate(opNode, blockList, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SSDataBlock *res = *(SSDataBlock **)taosArrayGetLast(blockList); ASSERT_EQ(res->info.rows, rowNum); @@ -1594,19 +1961,26 @@ TEST(columnTest, smallint_column_or_float_column) { int64_t eRes[5] = {3, 3, 7, 5, 7}; SSDataBlock *src = NULL; int32_t rowNum = sizeof(rightv) / sizeof(rightv[0]); - scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_SMALLINT, sizeof(int16_t), rowNum, leftv); - scltMakeColumnNode(&pRight, &src, TSDB_DATA_TYPE_FLOAT, sizeof(float), rowNum, rightv); - scltMakeOpNode(&opNode, OP_TYPE_BIT_OR, TSDB_DATA_TYPE_BIGINT, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_SMALLINT, sizeof(int16_t), rowNum, leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeColumnNode(&pRight, &src, TSDB_DATA_TYPE_FLOAT, sizeof(float), rowNum, rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_BIT_OR, TSDB_DATA_TYPE_BIGINT, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SArray *blockList = taosArrayInit(1, POINTER_BYTES); - taosArrayPush(blockList, &src); + ASSERT_NE(blockList, nullptr); + ASSERT_NE(taosArrayPush(blockList, &src), nullptr); SColumnInfo colInfo = createColumnInfo(1, TSDB_DATA_TYPE_BIGINT, sizeof(int64_t)); int16_t dataBlockId = 0, slotId = 0; - scltAppendReservedSlot(blockList, &dataBlockId, &slotId, true, rowNum, &colInfo); - scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + code = scltAppendReservedSlot(blockList, &dataBlockId, &slotId, true, rowNum, &colInfo); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculate(opNode, blockList, NULL); - ASSERT_EQ(code, 0); + code = scalarCalculate(opNode, blockList, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SSDataBlock *res = *(SSDataBlock **)taosArrayGetLast(blockList); ASSERT_EQ(res->info.rows, rowNum); @@ -1627,19 +2001,26 @@ TEST(columnTest, smallint_column_or_double_value) { int64_t eRes[5] = {11, 10, 11, 14, 15}; SSDataBlock *src = NULL; int32_t rowNum = sizeof(leftv) / sizeof(leftv[0]); - scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_SMALLINT, sizeof(int16_t), rowNum, leftv); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_DOUBLE, &rightv); - scltMakeOpNode(&opNode, OP_TYPE_BIT_OR, TSDB_DATA_TYPE_BIGINT, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_SMALLINT, sizeof(int16_t), rowNum, leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_DOUBLE, &rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_BIT_OR, TSDB_DATA_TYPE_BIGINT, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SArray *blockList = taosArrayInit(1, POINTER_BYTES); - taosArrayPush(blockList, &src); + ASSERT_NE(blockList, nullptr); + ASSERT_NE(taosArrayPush(blockList, &src), nullptr); SColumnInfo colInfo = createColumnInfo(1, TSDB_DATA_TYPE_BIGINT, sizeof(int64_t)); int16_t dataBlockId = 0, slotId = 0; - scltAppendReservedSlot(blockList, &dataBlockId, &slotId, true, rowNum, &colInfo); - scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + code = scltAppendReservedSlot(blockList, &dataBlockId, &slotId, true, rowNum, &colInfo); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculate(opNode, blockList, NULL); - ASSERT_EQ(code, 0); + code = scalarCalculate(opNode, blockList, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SSDataBlock *res = *(SSDataBlock **)taosArrayGetLast(blockList); ASSERT_EQ(res->info.rows, rowNum); @@ -1660,19 +2041,26 @@ TEST(columnTest, smallint_column_greater_double_value) { bool eRes[5] = {false, false, true, true, true}; SSDataBlock *src = NULL; int32_t rowNum = sizeof(leftv) / sizeof(leftv[0]); - scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_SMALLINT, sizeof(int16_t), rowNum, leftv); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_DOUBLE, &rightv); - scltMakeOpNode(&opNode, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_SMALLINT, sizeof(int16_t), rowNum, leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_DOUBLE, &rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SArray *blockList = taosArrayInit(1, POINTER_BYTES); - taosArrayPush(blockList, &src); + ASSERT_NE(blockList, nullptr); + ASSERT_NE(taosArrayPush(blockList, &src), nullptr); SColumnInfo colInfo = createColumnInfo(1, TSDB_DATA_TYPE_BOOL, sizeof(bool)); int16_t dataBlockId = 0, slotId = 0; - scltAppendReservedSlot(blockList, &dataBlockId, &slotId, true, rowNum, &colInfo); - scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + code = scltAppendReservedSlot(blockList, &dataBlockId, &slotId, true, rowNum, &colInfo); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculate(opNode, blockList, NULL); - ASSERT_EQ(code, 0); + code = scalarCalculate(opNode, blockList, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SSDataBlock *res = *(SSDataBlock **)taosArrayGetLast(blockList); ASSERT_EQ(res->info.rows, rowNum); @@ -1693,26 +2081,40 @@ TEST(columnTest, int_column_in_double_list) { bool eRes[5] = {true, true, true, false, false}; SSDataBlock *src = NULL; int32_t rowNum = sizeof(leftv) / sizeof(leftv[0]); - scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_INT, sizeof(int32_t), rowNum, leftv); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_INT, sizeof(int32_t), rowNum, leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SNodeList *list = nodesMakeList(); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_DOUBLE, &rightv1); - nodesListAppend(list, pRight); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_DOUBLE, &rightv2); - nodesListAppend(list, pRight); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_DOUBLE, &rightv3); - nodesListAppend(list, pRight); - scltMakeListNode(&listNode, list, TSDB_DATA_TYPE_INT); - scltMakeOpNode(&opNode, OP_TYPE_IN, TSDB_DATA_TYPE_BOOL, pLeft, listNode); + ASSERT_NE(list, nullptr); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_DOUBLE, &rightv1); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = nodesListAppend(list, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_DOUBLE, &rightv2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = nodesListAppend(list, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_DOUBLE, &rightv3); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = nodesListAppend(list, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeListNode(&listNode, list, TSDB_DATA_TYPE_INT); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_IN, TSDB_DATA_TYPE_BOOL, pLeft, listNode); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SArray *blockList = taosArrayInit(1, POINTER_BYTES); - taosArrayPush(blockList, &src); + ASSERT_NE(blockList, nullptr); + ASSERT_NE(taosArrayPush(blockList, &src), nullptr); SColumnInfo colInfo = createColumnInfo(1, TSDB_DATA_TYPE_BOOL, sizeof(bool)); int16_t dataBlockId = 0, slotId = 0; - scltAppendReservedSlot(blockList, &dataBlockId, &slotId, true, rowNum, &colInfo); - scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + code = scltAppendReservedSlot(blockList, &dataBlockId, &slotId, true, rowNum, &colInfo); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculate(opNode, blockList, NULL); - ASSERT_EQ(code, 0); + code = scalarCalculate(opNode, blockList, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SSDataBlock *res = *(SSDataBlock **)taosArrayGetLast(blockList); ASSERT_EQ(res->info.rows, rowNum); @@ -1752,26 +2154,40 @@ TEST(columnTest, binary_column_in_binary_list) { } int32_t rowNum = sizeof(leftv) / sizeof(leftv[0]); - scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_BINARY, 3, rowNum, leftv); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_BINARY, 3, rowNum, leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SNodeList *list = nodesMakeList(); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv[0]); - nodesListAppend(list, pRight); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv[1]); - nodesListAppend(list, pRight); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv[2]); - nodesListAppend(list, pRight); - scltMakeListNode(&listNode, list, TSDB_DATA_TYPE_BINARY); - scltMakeOpNode(&opNode, OP_TYPE_IN, TSDB_DATA_TYPE_BOOL, pLeft, listNode); + ASSERT_NE(list, nullptr); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv[0]); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = nodesListAppend(list, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv[1]); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = nodesListAppend(list, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv[2]); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = nodesListAppend(list, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeListNode(&listNode, list, TSDB_DATA_TYPE_BINARY); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_IN, TSDB_DATA_TYPE_BOOL, pLeft, listNode); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SArray *blockList = taosArrayInit(1, POINTER_BYTES); - taosArrayPush(blockList, &src); + ASSERT_NE(blockList, nullptr); + ASSERT_NE(taosArrayPush(blockList, &src), nullptr); SColumnInfo colInfo = createColumnInfo(1, TSDB_DATA_TYPE_BOOL, sizeof(bool)); int16_t dataBlockId = 0, slotId = 0; - scltAppendReservedSlot(blockList, &dataBlockId, &slotId, false, rowNum, &colInfo); - scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + code = scltAppendReservedSlot(blockList, &dataBlockId, &slotId, false, rowNum, &colInfo); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculate(opNode, blockList, NULL); - ASSERT_EQ(code, 0); + code = scalarCalculate(opNode, blockList, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SSDataBlock *res = *(SSDataBlock **)taosArrayGetLast(blockList); ASSERT_EQ(res->info.rows, rowNum); @@ -1800,22 +2216,29 @@ TEST(columnTest, binary_column_like_binary) { } int32_t rowNum = sizeof(leftv) / sizeof(leftv[0]); - scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_BINARY, 3, rowNum, leftv); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_BINARY, 3, rowNum, leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - sprintf(&rightv[2], "%s", "__0"); + (void)sprintf(&rightv[2], "%s", "__0"); varDataSetLen(rightv, strlen(&rightv[2])); - scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv); - scltMakeOpNode(&opNode, OP_TYPE_LIKE, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + code = scltMakeValueNode(&pRight, TSDB_DATA_TYPE_BINARY, rightv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_LIKE, TSDB_DATA_TYPE_BOOL, pLeft, pRight); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SArray *blockList = taosArrayInit(1, POINTER_BYTES); - taosArrayPush(blockList, &src); + ASSERT_NE(blockList, nullptr); + ASSERT_NE(taosArrayPush(blockList, &src), nullptr); SColumnInfo colInfo = createColumnInfo(1, TSDB_DATA_TYPE_BOOL, sizeof(bool)); int16_t dataBlockId = 0, slotId = 0; - scltAppendReservedSlot(blockList, &dataBlockId, &slotId, false, rowNum, &colInfo); - scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + code = scltAppendReservedSlot(blockList, &dataBlockId, &slotId, false, rowNum, &colInfo); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculate(opNode, blockList, NULL); - ASSERT_EQ(code, 0); + code = scalarCalculate(opNode, blockList, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SSDataBlock *res = *(SSDataBlock **)taosArrayGetLast(blockList); ASSERT_EQ(res->info.rows, rowNum); @@ -1844,19 +2267,22 @@ TEST(columnTest, binary_column_is_true) { } int32_t rowNum = sizeof(leftv) / sizeof(leftv[0]); - scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_BINARY, 5, rowNum, leftv); - - scltMakeOpNode(&opNode, OP_TYPE_IS_TRUE, TSDB_DATA_TYPE_BOOL, pLeft, NULL); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_BINARY, 5, rowNum, leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode, OP_TYPE_IS_TRUE, TSDB_DATA_TYPE_BOOL, pLeft, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SArray *blockList = taosArrayInit(1, POINTER_BYTES); - taosArrayPush(blockList, &src); + ASSERT_NE(blockList, nullptr); + ASSERT_NE(taosArrayPush(blockList, &src), nullptr); SColumnInfo colInfo = createColumnInfo(1, TSDB_DATA_TYPE_BOOL, sizeof(bool)); int16_t dataBlockId = 0, slotId = 0; - scltAppendReservedSlot(blockList, &dataBlockId, &slotId, false, rowNum, &colInfo); - scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + code = scltAppendReservedSlot(blockList, &dataBlockId, &slotId, false, rowNum, &colInfo); + code = scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); - int32_t code = scalarCalculate(opNode, blockList, NULL); - ASSERT_EQ(code, 0); + code = scalarCalculate(opNode, blockList, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SSDataBlock *res = *(SSDataBlock **)taosArrayGetLast(blockList); ASSERT_EQ(res->info.rows, rowNum); @@ -1884,23 +2310,30 @@ TEST(columnTest, binary_column_is_null) { } int32_t rowNum = sizeof(leftv) / sizeof(leftv[0]); - scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_BINARY, 3, rowNum, leftv); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_BINARY, 3, rowNum, leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SColumnInfoData *pcolumn = (SColumnInfoData *)taosArrayGetLast(src->pDataBlock); - colDataSetVal(pcolumn, 2, NULL, true); - colDataSetVal(pcolumn, 4, NULL, true); + code = colDataSetVal(pcolumn, 2, NULL, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = colDataSetVal(pcolumn, 4, NULL, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - scltMakeOpNode(&opNode, OP_TYPE_IS_NULL, TSDB_DATA_TYPE_BOOL, pLeft, NULL); + code = scltMakeOpNode(&opNode, OP_TYPE_IS_NULL, TSDB_DATA_TYPE_BOOL, pLeft, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SArray *blockList = taosArrayInit(1, POINTER_BYTES); - taosArrayPush(blockList, &src); + ASSERT_NE(blockList, nullptr); + ASSERT_NE(taosArrayPush(blockList, &src), nullptr); SColumnInfo colInfo = createColumnInfo(1, TSDB_DATA_TYPE_BOOL, sizeof(bool)); int16_t dataBlockId = 0, slotId = 0; - scltAppendReservedSlot(blockList, &dataBlockId, &slotId, false, rowNum, &colInfo); - scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); - - int32_t code = scalarCalculate(opNode, blockList, NULL); - ASSERT_EQ(code, 0); + code = scltAppendReservedSlot(blockList, &dataBlockId, &slotId, false, rowNum, &colInfo); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scalarCalculate(opNode, blockList, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SSDataBlock *res = *(SSDataBlock **)taosArrayGetLast(blockList); ASSERT_EQ(res->info.rows, rowNum); @@ -1928,22 +2361,29 @@ TEST(columnTest, binary_column_is_not_null) { } int32_t rowNum = sizeof(leftv) / sizeof(leftv[0]); - scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_BINARY, 3, rowNum, leftv); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeColumnNode(&pLeft, &src, TSDB_DATA_TYPE_BINARY, 3, rowNum, leftv); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SColumnInfoData *pcolumn = (SColumnInfoData *)taosArrayGetLast(src->pDataBlock); - colDataSetVal(pcolumn, 4, NULL, true); + code = colDataSetVal(pcolumn, 4, NULL, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - scltMakeOpNode(&opNode, OP_TYPE_IS_NOT_NULL, TSDB_DATA_TYPE_BOOL, pLeft, NULL); + code = scltMakeOpNode(&opNode, OP_TYPE_IS_NOT_NULL, TSDB_DATA_TYPE_BOOL, pLeft, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SArray *blockList = taosArrayInit(1, POINTER_BYTES); - taosArrayPush(blockList, &src); + ASSERT_NE(blockList, nullptr); + ASSERT_NE(taosArrayPush(blockList, &src), nullptr); SColumnInfo colInfo = createColumnInfo(1, TSDB_DATA_TYPE_BOOL, sizeof(bool)); int16_t dataBlockId = 0, slotId = 0; - scltAppendReservedSlot(blockList, &dataBlockId, &slotId, false, rowNum, &colInfo); - scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + code = scltAppendReservedSlot(blockList, &dataBlockId, &slotId, false, rowNum, &colInfo); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeTargetNode(&opNode, dataBlockId, slotId, opNode); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculate(opNode, blockList, NULL); - ASSERT_EQ(code, 0); + code = scalarCalculate(opNode, blockList, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SSDataBlock *res = *(SSDataBlock **)taosArrayGetLast(blockList); ASSERT_EQ(res->info.rows, rowNum); @@ -1967,25 +2407,36 @@ TEST(columnTest, greater_and_lower) { bool eRes[5] = {false, true, false, false, false}; SSDataBlock *src = NULL; int32_t rowNum = sizeof(v1) / sizeof(v1[0]); - scltMakeColumnNode(&pcol1, &src, TSDB_DATA_TYPE_SMALLINT, sizeof(int16_t), rowNum, v1); - scltMakeColumnNode(&pcol2, &src, TSDB_DATA_TYPE_INT, sizeof(int32_t), rowNum, v2); - scltMakeOpNode(&opNode1, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pcol1, pcol2); - scltMakeColumnNode(&pcol1, &src, TSDB_DATA_TYPE_BIGINT, sizeof(int64_t), rowNum, v3); - scltMakeColumnNode(&pcol2, &src, TSDB_DATA_TYPE_INT, sizeof(int32_t), rowNum, v4); - scltMakeOpNode(&opNode2, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pcol1, pcol2); + int32_t code = TSDB_CODE_SUCCESS; + code = scltMakeColumnNode(&pcol1, &src, TSDB_DATA_TYPE_SMALLINT, sizeof(int16_t), rowNum, v1); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeColumnNode(&pcol2, &src, TSDB_DATA_TYPE_INT, sizeof(int32_t), rowNum, v2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode1, OP_TYPE_GREATER_THAN, TSDB_DATA_TYPE_BOOL, pcol1, pcol2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeColumnNode(&pcol1, &src, TSDB_DATA_TYPE_BIGINT, sizeof(int64_t), rowNum, v3); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeColumnNode(&pcol2, &src, TSDB_DATA_TYPE_INT, sizeof(int32_t), rowNum, v4); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeOpNode(&opNode2, OP_TYPE_LOWER_THAN, TSDB_DATA_TYPE_BOOL, pcol1, pcol2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); list[0] = opNode1; list[1] = opNode2; - scltMakeLogicNode(&logicNode, LOGIC_COND_TYPE_AND, list, 2); + code = scltMakeLogicNode(&logicNode, LOGIC_COND_TYPE_AND, list, 2); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SArray *blockList = taosArrayInit(1, POINTER_BYTES); - taosArrayPush(blockList, &src); + ASSERT_NE(blockList, nullptr); + ASSERT_NE(taosArrayPush(blockList, &src), nullptr); SColumnInfo colInfo = createColumnInfo(1, TSDB_DATA_TYPE_BOOL, sizeof(bool)); int16_t dataBlockId = 0, slotId = 0; - scltAppendReservedSlot(blockList, &dataBlockId, &slotId, false, rowNum, &colInfo); - scltMakeTargetNode(&logicNode, dataBlockId, slotId, logicNode); + code = scltAppendReservedSlot(blockList, &dataBlockId, &slotId, false, rowNum, &colInfo); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeTargetNode(&logicNode, dataBlockId, slotId, logicNode); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); - int32_t code = scalarCalculate(logicNode, blockList, NULL); - ASSERT_EQ(code, 0); + code = scalarCalculate(logicNode, blockList, NULL); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); SSDataBlock *res = *(SSDataBlock **)taosArrayGetLast(blockList); ASSERT_EQ(res->info.rows, rowNum); @@ -1999,8 +2450,11 @@ TEST(columnTest, greater_and_lower) { nodesDestroyNode(logicNode); } -void scltMakeDataBlock(SScalarParam **pInput, int32_t type, void *pVal, int32_t num, bool setVal) { +int32_t scltMakeDataBlock(SScalarParam **pInput, int32_t type, void *pVal, int32_t num, bool setVal) { SScalarParam *input = (SScalarParam *)taosMemoryCalloc(1, sizeof(SScalarParam)); + if (NULL == input) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } int32_t bytes; switch (type) { case TSDB_DATA_TYPE_TINYINT: { @@ -2030,20 +2484,24 @@ void scltMakeDataBlock(SScalarParam **pInput, int32_t type, void *pVal, int32_t } input->columnData = (SColumnInfoData *)taosMemoryCalloc(1, sizeof(SColumnInfoData)); + if (NULL == input->columnData) { + SCL_ERR_RET(TSDB_CODE_OUT_OF_MEMORY); + } input->numOfRows = num; input->columnData->info = createColumnInfo(0, type, bytes); - colInfoDataEnsureCapacity(input->columnData, num, true); + SCL_ERR_RET(colInfoDataEnsureCapacity(input->columnData, num, true)); if (setVal) { for (int32_t i = 0; i < num; ++i) { - colDataSetVal(input->columnData, i, (const char *)pVal, false); + SCL_ERR_RET(colDataSetVal(input->columnData, i, (const char *)pVal, false)); } } else { // memset(input->data, 0, num * bytes); } *pInput = input; + SCL_RET(TSDB_CODE_SUCCESS); } void scltDestroyDataBlock(SScalarParam *pInput) { @@ -2061,8 +2519,10 @@ TEST(ScalarFunctionTest, absFunction_constant) { // TINYINT int8_t val_tinyint = 10; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); @@ -2073,8 +2533,10 @@ TEST(ScalarFunctionTest, absFunction_constant) { scltDestroyDataBlock(pOutput); val_tinyint = -10; - scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); @@ -2087,8 +2549,10 @@ TEST(ScalarFunctionTest, absFunction_constant) { // SMALLINT int16_t val_smallint = 10; type = TSDB_DATA_TYPE_SMALLINT; - scltMakeDataBlock(&pInput, type, &val_smallint, rowNum, true); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_smallint, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); @@ -2099,8 +2563,10 @@ TEST(ScalarFunctionTest, absFunction_constant) { scltDestroyDataBlock(pOutput); val_smallint = -10; - scltMakeDataBlock(&pInput, type, &val_smallint, rowNum, true); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_smallint, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); @@ -2113,8 +2579,10 @@ TEST(ScalarFunctionTest, absFunction_constant) { // INT int32_t val_int = 10; type = TSDB_DATA_TYPE_INT; - scltMakeDataBlock(&pInput, type, &val_int, rowNum, true); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_int, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); @@ -2125,8 +2593,10 @@ TEST(ScalarFunctionTest, absFunction_constant) { scltDestroyDataBlock(pOutput); val_int = -10; - scltMakeDataBlock(&pInput, type, &val_int, rowNum, true); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_int, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); @@ -2139,8 +2609,10 @@ TEST(ScalarFunctionTest, absFunction_constant) { // BIGINT int64_t val_bigint = 10; type = TSDB_DATA_TYPE_BIGINT; - scltMakeDataBlock(&pInput, type, &val_bigint, rowNum, true); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_bigint, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); @@ -2151,8 +2623,10 @@ TEST(ScalarFunctionTest, absFunction_constant) { scltDestroyDataBlock(pOutput); val_bigint = -10; - scltMakeDataBlock(&pInput, type, &val_bigint, rowNum, true); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_bigint, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); @@ -2165,8 +2639,10 @@ TEST(ScalarFunctionTest, absFunction_constant) { // FLOAT float val_float = 10.15; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("float before ABS:%f\n", *(float *)pInput->data); code = absFunction(pInput, 1, pOutput); @@ -2179,8 +2655,10 @@ TEST(ScalarFunctionTest, absFunction_constant) { scltDestroyDataBlock(pOutput); val_float = -10.15; - scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("float before ABS:%f\n", *(float *)pInput->data); code = absFunction(pInput, 1, pOutput); @@ -2195,8 +2673,10 @@ TEST(ScalarFunctionTest, absFunction_constant) { // DOUBLE double val_double = 10.15; type = TSDB_DATA_TYPE_DOUBLE; - scltMakeDataBlock(&pInput, type, &val_double, rowNum, true); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_double, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); @@ -2207,8 +2687,10 @@ TEST(ScalarFunctionTest, absFunction_constant) { scltDestroyDataBlock(pOutput); val_double = -10.15; - scltMakeDataBlock(&pInput, type, &val_double, rowNum, true); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_double, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); code = absFunction(pInput, 1, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); @@ -2228,8 +2710,10 @@ TEST(ScalarFunctionTest, absFunction_column) { // TINYINT int8_t val_tinyint = 10; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { int8_t v = val_tinyint + i; colDataSetVal(pInput->columnData, i, (const char *)&v, false); @@ -2246,8 +2730,10 @@ TEST(ScalarFunctionTest, absFunction_column) { scltDestroyDataBlock(pOutput); val_tinyint = -10; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { int8_t v = val_tinyint + i; colDataSetVal(pInput->columnData, i, (const char *)&v, false); @@ -2266,8 +2752,10 @@ TEST(ScalarFunctionTest, absFunction_column) { // SMALLINT int16_t val_smallint = 10; type = TSDB_DATA_TYPE_SMALLINT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { int16_t v = val_smallint + i; colDataSetVal(pInput->columnData, i, (const char *)&v, false); @@ -2284,11 +2772,13 @@ TEST(ScalarFunctionTest, absFunction_column) { scltDestroyDataBlock(pOutput); val_smallint = -10; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { int16_t v = val_smallint + i; - colDataSetVal(pInput->columnData, i, (const char *)&v, false); + code = colDataSetVal(pInput->columnData, i, (const char *)&v, false); PRINTF("small_int before ABS:%d\n", v); } @@ -2304,11 +2794,12 @@ TEST(ScalarFunctionTest, absFunction_column) { // INT int32_t val_int = 10; type = TSDB_DATA_TYPE_INT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); for (int32_t i = 0; i < rowNum; ++i) { int32_t v = val_int + i; - colDataSetVal(pInput->columnData, i, (const char *)&v, false); + code = colDataSetVal(pInput->columnData, i, (const char *)&v, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("int before ABS:%d\n", v); } @@ -2322,11 +2813,14 @@ TEST(ScalarFunctionTest, absFunction_column) { scltDestroyDataBlock(pOutput); val_int = -10; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { int32_t v = val_int + i; - colDataSetVal(pInput->columnData, i, (const char *)&v, false); + code = colDataSetVal(pInput->columnData, i, (const char *)&v, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("int before ABS:%d\n", v); } @@ -2342,11 +2836,14 @@ TEST(ScalarFunctionTest, absFunction_column) { // FLOAT float val_float = 10.15; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { float v = val_float + i; - colDataSetVal(pInput->columnData, i, (const char *)&v, false); + code = colDataSetVal(pInput->columnData, i, (const char *)&v, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("float before ABS:%f\n", v); } @@ -2360,11 +2857,14 @@ TEST(ScalarFunctionTest, absFunction_column) { scltDestroyDataBlock(pOutput); val_float = -10.15; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { float v = val_float + i; - colDataSetVal(pInput->columnData, i, (const char *)&v, false); + code = colDataSetVal(pInput->columnData, i, (const char *)&v, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("float before ABS:%f\n", v); } @@ -2380,11 +2880,14 @@ TEST(ScalarFunctionTest, absFunction_column) { // DOUBLE double val_double = 10.15; type = TSDB_DATA_TYPE_DOUBLE; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { double v = val_double + i; - colDataSetVal(pInput->columnData, i, (const char *)&v, false); + code = colDataSetVal(pInput->columnData, i, (const char *)&v, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("double before ABS:%f\n", v); } @@ -2398,11 +2901,14 @@ TEST(ScalarFunctionTest, absFunction_column) { scltDestroyDataBlock(pOutput); val_double = -10.15; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { double v = val_double + i; - colDataSetVal(pInput->columnData, i, (const char *)&v, false); + code = colDataSetVal(pInput->columnData, i, (const char *)&v, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("double before ABS:%f\n", v); } @@ -2428,8 +2934,10 @@ TEST(ScalarFunctionTest, sinFunction_constant) { // TINYINT int8_t val_tinyint = 13; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("tiny_int before SIN:%d\n", *((int8_t *)pInput->data)); code = sinFunction(pInput, 1, pOutput); @@ -2444,8 +2952,10 @@ TEST(ScalarFunctionTest, sinFunction_constant) { // FLOAT float val_float = 13.00; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("float before SIN:%f\n", *((float *)pInput->data)); code = sinFunction(pInput, 1, pOutput); @@ -2470,10 +2980,13 @@ TEST(ScalarFunctionTest, sinFunction_column) { // TINYINT int8_t val_tinyint[] = {13, 14, 15}; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { - colDataSetVal(pInput->columnData, i, (const char *)&val_tinyint[i], false); + code = colDataSetVal(pInput->columnData, i, (const char *)&val_tinyint[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("tiny_int before SIN:%d\n", *(int8_t *)colDataGetData(pInput->columnData, i)); } @@ -2489,10 +3002,13 @@ TEST(ScalarFunctionTest, sinFunction_column) { // FLOAT float val_float[] = {13.00, 14.00, 15.00}; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { - colDataSetVal(pInput->columnData, i, (const char *)&val_float[i], false); + code = colDataSetVal(pInput->columnData, i, (const char *)&val_float[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("float before SIN:%f\n", *((float *)colDataGetData(pInput->columnData, i))); } @@ -2518,8 +3034,10 @@ TEST(ScalarFunctionTest, cosFunction_constant) { // TINYINT int8_t val_tinyint = 13; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("tiny_int before COS:%d\n", *((int8_t *)pInput->data)); code = cosFunction(pInput, 1, pOutput); @@ -2534,8 +3052,10 @@ TEST(ScalarFunctionTest, cosFunction_constant) { // FLOAT float val_float = 13.00; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("float before COS:%f\n", *((float *)pInput->data)); code = cosFunction(pInput, 1, pOutput); @@ -2560,10 +3080,13 @@ TEST(ScalarFunctionTest, cosFunction_column) { // TINYINT int8_t val_tinyint[] = {13, 14, 15}; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { - colDataSetVal(pInput->columnData, i, (const char *)&val_tinyint[i], false); + code = colDataSetVal(pInput->columnData, i, (const char *)&val_tinyint[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("tiny_int before COS:%d\n", *(int8_t *)colDataGetData(pInput->columnData, i)); } @@ -2579,10 +3102,13 @@ TEST(ScalarFunctionTest, cosFunction_column) { // FLOAT float val_float[] = {13.00, 14.00, 15.00}; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { - colDataSetVal(pInput->columnData, i, (const char *)&val_float[i], false); + code = colDataSetVal(pInput->columnData, i, (const char *)&val_float[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("float before COS:%f\n", *(float *)colDataGetData(pInput->columnData, i)); } @@ -2608,8 +3134,10 @@ TEST(ScalarFunctionTest, tanFunction_constant) { // TINYINT int8_t val_tinyint = 13; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("tiny_int before TAN:%d\n", *((int8_t *)pInput->data)); code = tanFunction(pInput, 1, pOutput); @@ -2624,8 +3152,10 @@ TEST(ScalarFunctionTest, tanFunction_constant) { // FLOAT float val_float = 13.00; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("float before TAN:%f\n", *((float *)pInput->data)); code = tanFunction(pInput, 1, pOutput); @@ -2650,10 +3180,13 @@ TEST(ScalarFunctionTest, tanFunction_column) { // TINYINT int8_t val_tinyint[] = {13, 14, 15}; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { - colDataSetVal(pInput->columnData, i, (const char *)&val_tinyint[i], false); + code = colDataSetVal(pInput->columnData, i, (const char *)&val_tinyint[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("tiny_int before TAN:%d\n", *((int8_t *)colDataGetData(pInput->columnData, i))); } @@ -2669,10 +3202,13 @@ TEST(ScalarFunctionTest, tanFunction_column) { // FLOAT float val_float[] = {13.00, 14.00, 15.00}; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { - colDataSetVal(pInput->columnData, i, (const char *)&val_float[i], false); + code = colDataSetVal(pInput->columnData, i, (const char *)&val_float[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("float before TAN:%f\n", *((float *)colDataGetData(pInput->columnData, i))); } @@ -2698,8 +3234,10 @@ TEST(ScalarFunctionTest, asinFunction_constant) { // TINYINT int8_t val_tinyint = 1; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("tiny_int before ASIN:%d\n", *((int8_t *)pInput->data)); code = asinFunction(pInput, 1, pOutput); @@ -2714,8 +3252,10 @@ TEST(ScalarFunctionTest, asinFunction_constant) { // FLOAT float val_float = 1.00; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("float before ASIN:%f\n", *((float *)pInput->data)); code = asinFunction(pInput, 1, pOutput); @@ -2740,10 +3280,13 @@ TEST(ScalarFunctionTest, asinFunction_column) { // TINYINT int8_t val_tinyint[] = {-1, 0, 1}; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { - colDataSetVal(pInput->columnData, i, (const char *)&val_tinyint[i], false); + code = colDataSetVal(pInput->columnData, i, (const char *)&val_tinyint[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("tiny_int before ASIN:%d\n", *((int8_t *)colDataGetData(pInput->columnData, i))); } @@ -2759,8 +3302,10 @@ TEST(ScalarFunctionTest, asinFunction_column) { // FLOAT float val_float[] = {-1.0, 0.0, 1.0}; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { *((float *)colDataGetData(pInput->columnData, i)) = val_float[i]; PRINTF("float before ASIN:%f\n", *((float *)colDataGetData(pInput->columnData, i))); @@ -2788,8 +3333,10 @@ TEST(ScalarFunctionTest, acosFunction_constant) { // TINYINT int8_t val_tinyint = 1; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("tiny_int before ACOS:%d\n", *((int8_t *)pInput->data)); code = acosFunction(pInput, 1, pOutput); @@ -2804,8 +3351,10 @@ TEST(ScalarFunctionTest, acosFunction_constant) { // FLOAT float val_float = 1.00; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("float before ACOS:%f\n", *((float *)pInput->data)); code = acosFunction(pInput, 1, pOutput); @@ -2830,8 +3379,10 @@ TEST(ScalarFunctionTest, acosFunction_column) { // TINYINT int8_t val_tinyint[] = {-1, 0, 1}; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { *((int8_t *)colDataGetData(pInput->columnData, i)) = val_tinyint[i]; PRINTF("tiny_int before ACOS:%d\n", *((int8_t *)colDataGetData(pInput->columnData, i))); @@ -2849,8 +3400,10 @@ TEST(ScalarFunctionTest, acosFunction_column) { // FLOAT float val_float[] = {-1.0, 0.0, 1.0}; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { *((float *)colDataGetData(pInput->columnData, i)) = val_float[i]; PRINTF("float before ACOS:%f\n", *((float *)colDataGetData(pInput->columnData, i))); @@ -2878,8 +3431,10 @@ TEST(ScalarFunctionTest, atanFunction_constant) { // TINYINT int8_t val_tinyint = 1; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("tiny_int before ATAN:%d\n", *((int8_t *)pInput->data)); code = atanFunction(pInput, 1, pOutput); @@ -2894,8 +3449,10 @@ TEST(ScalarFunctionTest, atanFunction_constant) { // FLOAT float val_float = 1.00; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("float before ATAN:%f\n", *((float *)pInput->data)); code = atanFunction(pInput, 1, pOutput); @@ -2920,8 +3477,10 @@ TEST(ScalarFunctionTest, atanFunction_column) { // TINYINT int8_t val_tinyint[] = {-1, 0, 1}; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { *((int8_t *)colDataGetData(pInput->columnData, i)) = val_tinyint[i]; PRINTF("tiny_int before ATAN:%d\n", *((int8_t *)colDataGetData(pInput->columnData, i))); @@ -2939,8 +3498,10 @@ TEST(ScalarFunctionTest, atanFunction_column) { // FLOAT float val_float[] = {-1.0, 0.0, 1.0}; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { *((float *)colDataGetData(pInput->columnData, i)) = val_float[i]; PRINTF("float before ATAN:%f\n", *((float *)colDataGetData(pInput->columnData, i))); @@ -2967,8 +3528,10 @@ TEST(ScalarFunctionTest, ceilFunction_constant) { // TINYINT int8_t val_tinyint = 10; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("tiny_int before CEIL:%d\n", *((int8_t *)pInput->data)); code = ceilFunction(pInput, 1, pOutput); @@ -2983,8 +3546,10 @@ TEST(ScalarFunctionTest, ceilFunction_constant) { // FLOAT float val_float = 9.5; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("float before CEIL:%f\n", *((float *)pInput->data)); code = ceilFunction(pInput, 1, pOutput); @@ -3008,8 +3573,10 @@ TEST(ScalarFunctionTest, ceilFunction_column) { // TINYINT int8_t val_tinyint[] = {-10, 0, 10}; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { *((int8_t *)colDataGetData(pInput->columnData, i)) = val_tinyint[i]; PRINTF("tiny_int before CEIL:%d\n", *((int8_t *)colDataGetData(pInput->columnData, i))); @@ -3027,8 +3594,10 @@ TEST(ScalarFunctionTest, ceilFunction_column) { // FLOAT float val_float[] = {-10.5, 0.0, 9.5}; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { *((float *)colDataGetData(pInput->columnData, i)) = val_float[i]; PRINTF("float before CEIL:%f\n", *((float *)colDataGetData(pInput->columnData, i))); @@ -3055,8 +3624,10 @@ TEST(ScalarFunctionTest, floorFunction_constant) { // TINYINT int8_t val_tinyint = 10; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("tiny_int before FLOOR:%d\n", *((int8_t *)pInput->data)); code = floorFunction(pInput, 1, pOutput); @@ -3071,8 +3642,10 @@ TEST(ScalarFunctionTest, floorFunction_constant) { // FLOAT float val_float = 10.5; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("float before FLOOR:%f\n", *((float *)pInput->data)); code = floorFunction(pInput, 1, pOutput); @@ -3096,8 +3669,10 @@ TEST(ScalarFunctionTest, floorFunction_column) { // TINYINT int8_t val_tinyint[] = {-10, 0, 10}; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { *((int8_t *)colDataGetData(pInput->columnData, i)) = val_tinyint[i]; PRINTF("tiny_int before FLOOR:%d\n", *((int8_t *)colDataGetData(pInput->columnData, i))); @@ -3115,8 +3690,10 @@ TEST(ScalarFunctionTest, floorFunction_column) { // FLOAT float val_float[] = {-9.5, 0.0, 10.5}; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { *((float *)colDataGetData(pInput->columnData, i)) = val_float[i]; PRINTF("float before FLOOR:%f\n", *((float *)colDataGetData(pInput->columnData, i))); @@ -3143,8 +3720,10 @@ TEST(ScalarFunctionTest, roundFunction_constant) { // TINYINT int8_t val_tinyint = 10; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("tiny_int before ROUND:%d\n", *((int8_t *)pInput->data)); code = roundFunction(pInput, 1, pOutput); @@ -3159,8 +3738,10 @@ TEST(ScalarFunctionTest, roundFunction_constant) { // FLOAT float val_float = 9.5; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("float before ROUND:%f\n", *((float *)pInput->data)); code = roundFunction(pInput, 1, pOutput); @@ -3184,8 +3765,10 @@ TEST(ScalarFunctionTest, roundFunction_column) { // TINYINT int8_t val_tinyint[] = {-10, 0, 10}; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { *((int8_t *)colDataGetData(pInput->columnData, i)) = val_tinyint[i]; PRINTF("tiny_int before ROUND:%d\n", *((int8_t *)colDataGetData(pInput->columnData, i))); @@ -3203,8 +3786,10 @@ TEST(ScalarFunctionTest, roundFunction_column) { // FLOAT float val_float[] = {-9.5, 0.0, 9.5}; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { *((float *)colDataGetData(pInput->columnData, i)) = val_float[i]; PRINTF("float before ROUND:%f\n", *((float *)colDataGetData(pInput->columnData, i))); @@ -3232,8 +3817,10 @@ TEST(ScalarFunctionTest, sqrtFunction_constant) { // TINYINT int8_t val_tinyint = 25; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_tinyint, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("tiny_int before SQRT:%d\n", *((int8_t *)pInput->data)); code = sqrtFunction(pInput, 1, pOutput); @@ -3248,8 +3835,10 @@ TEST(ScalarFunctionTest, sqrtFunction_constant) { // FLOAT float val_float = 25.0; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, &val_float, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("float before SQRT:%f\n", *((float *)pInput->data)); code = sqrtFunction(pInput, 1, pOutput); @@ -3274,8 +3863,10 @@ TEST(ScalarFunctionTest, sqrtFunction_column) { // TINYINT int8_t val_tinyint[] = {25, 81, 100}; type = TSDB_DATA_TYPE_TINYINT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { *((int8_t *)colDataGetData(pInput->columnData, i)) = val_tinyint[i]; PRINTF("tiny_int before SQRT:%d\n", *((int8_t *)colDataGetData(pInput->columnData, i))); @@ -3293,8 +3884,10 @@ TEST(ScalarFunctionTest, sqrtFunction_column) { // FLOAT float val_float[] = {25.0, 81.0, 100.0}; type = TSDB_DATA_TYPE_FLOAT; - scltMakeDataBlock(&pInput, type, 0, rowNum, false); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pInput, type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { *((float *)colDataGetData(pInput->columnData, i)) = val_float[i]; PRINTF("float before SQRT:%f\n", *((float *)colDataGetData(pInput->columnData, i))); @@ -3325,10 +3918,12 @@ TEST(ScalarFunctionTest, logFunction_constant) { int8_t val_tinyint[] = {27, 3}; type = TSDB_DATA_TYPE_TINYINT; for (int32_t i = 0; i < 2; ++i) { - scltMakeDataBlock(&input[i], type, &val_tinyint[i], rowNum, true); + code = scltMakeDataBlock(&input[i], type, &val_tinyint[i], rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); pInput[i] = *input[i]; } - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("tiny_int before LOG: %d,%d\n", *((int8_t *)pInput[0].data), *((int8_t *)pInput[1].data)); code = logFunction(pInput, 2, pOutput); @@ -3345,10 +3940,12 @@ TEST(ScalarFunctionTest, logFunction_constant) { float val_float[] = {64.0, 4.0}; type = TSDB_DATA_TYPE_FLOAT; for (int32_t i = 0; i < 2; ++i) { - scltMakeDataBlock(&input[i], type, &val_float[i], rowNum, true); + code = scltMakeDataBlock(&input[i], type, &val_float[i], rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); pInput[i] = *input[i]; } - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("float before LOG: %f,%f\n", *((float *)pInput[0].data), *((float *)pInput[1].data)); code = logFunction(pInput, 2, pOutput); @@ -3364,12 +3961,14 @@ TEST(ScalarFunctionTest, logFunction_constant) { // TINYINT AND FLOAT int8_t param0 = 64; float param1 = 4.0; - scltMakeDataBlock(&input[0], TSDB_DATA_TYPE_TINYINT, ¶m0, rowNum, true); + code = scltMakeDataBlock(&input[0], TSDB_DATA_TYPE_TINYINT, ¶m0, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); pInput[0] = *input[0]; - scltMakeDataBlock(&input[1], TSDB_DATA_TYPE_FLOAT, ¶m1, rowNum, true); + code = scltMakeDataBlock(&input[1], TSDB_DATA_TYPE_FLOAT, ¶m1, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); pInput[1] = *input[1]; - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); - + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("tiny_int,float before LOG: %d,%f\n", *((int8_t *)pInput[0].data), *((float *)pInput[1].data)); code = logFunction(pInput, 2, pOutput); @@ -3399,16 +3998,18 @@ TEST(ScalarFunctionTest, logFunction_column) { int8_t val_tinyint[2][3] = {{9, 27, 81}, {3, 3, 3}}; type = TSDB_DATA_TYPE_TINYINT; for (int32_t i = 0; i < 2; ++i) { - scltMakeDataBlock(&input[i], type, 0, rowNum, false); + code = scltMakeDataBlock(&input[i], type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); pInput[i] = *input[i]; for (int32_t j = 0; j < rowNum; ++j) { - colDataSetVal(pInput[i].columnData, j, (const char *)&val_tinyint[i][j], false); + code = colDataSetVal(pInput[i].columnData, j, (const char *)&val_tinyint[i][j], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } PRINTF("tiny_int before LOG:%d,%d,%d\n", *((int8_t *)pInput[i].data + 0), *((int8_t *)pInput[i].data + 1), *((int8_t *)pInput[i].data + 2)); } - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); - + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); code = logFunction(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { @@ -3423,16 +4024,18 @@ TEST(ScalarFunctionTest, logFunction_column) { float val_float[2][3] = {{9.0, 27.0, 81.0}, {3.0, 3.0, 3.0}}; type = TSDB_DATA_TYPE_FLOAT; for (int32_t i = 0; i < 2; ++i) { - scltMakeDataBlock(&input[i], type, 0, rowNum, false); + code = scltMakeDataBlock(&input[i], type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); pInput[i] = *input[i]; for (int32_t j = 0; j < rowNum; ++j) { - colDataSetVal(pInput[i].columnData, j, (const char *)&val_float[i][j], false); + code = colDataSetVal(pInput[i].columnData, j, (const char *)&val_float[i][j], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } PRINTF("float before LOG:%f,%f,%f\n", *((float *)colDataGetData(pInput[i], 0)), *((float *)colDataGetData(pInput[i], 1)), *((float *)colDataGetData(pInput[i], 2))); } - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); - + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); code = logFunction(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { @@ -3446,21 +4049,25 @@ TEST(ScalarFunctionTest, logFunction_column) { // TINYINT AND FLOAT int8_t param0[] = {9, 27, 81}; float param1[] = {3.0, 3.0, 3.0}; - scltMakeDataBlock(&input[0], TSDB_DATA_TYPE_TINYINT, 0, rowNum, false); + code = scltMakeDataBlock(&input[0], TSDB_DATA_TYPE_TINYINT, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); pInput[0] = *input[0]; for (int32_t i = 0; i < rowNum; ++i) { - colDataSetVal(pInput[0].columnData, i, (const char *)¶m0[i], false); + code = colDataSetVal(pInput[0].columnData, i, (const char *)¶m0[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } - scltMakeDataBlock(&input[1], TSDB_DATA_TYPE_FLOAT, 0, rowNum, false); + code = scltMakeDataBlock(&input[1], TSDB_DATA_TYPE_FLOAT, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); pInput[1] = *input[1]; for (int32_t i = 0; i < rowNum; ++i) { - colDataSetVal(pInput[1].columnData, i, (const char *)¶m1[i], false); + code = colDataSetVal(pInput[1].columnData, i, (const char *)¶m1[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } PRINTF("tiny_int, float before LOG:{%d,%f}, {%d,%f}, {%d,%f}\n", *((int8_t *)pInput[0].data + 0), *((float *)pInput[1].data + 0), *((int8_t *)pInput[0].data + 1), *((float *)pInput[1].data + 1), *((int8_t *)pInput[0].data + 2), *((float *)pInput[1].data + 2)); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); - + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); code = logFunction(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { @@ -3488,10 +4095,12 @@ TEST(ScalarFunctionTest, powFunction_constant) { int8_t val_tinyint[] = {2, 4}; type = TSDB_DATA_TYPE_TINYINT; for (int32_t i = 0; i < 2; ++i) { - scltMakeDataBlock(&input[i], type, &val_tinyint[i], rowNum, true); + code = scltMakeDataBlock(&input[i], type, &val_tinyint[i], rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); pInput[i] = *input[i]; } - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("tiny_int before POW: %d,%d\n", *((int8_t *)pInput[0].data), *((int8_t *)pInput[1].data)); code = powFunction(pInput, 2, pOutput); @@ -3508,10 +4117,12 @@ TEST(ScalarFunctionTest, powFunction_constant) { float val_float[] = {2.0, 4.0}; type = TSDB_DATA_TYPE_FLOAT; for (int32_t i = 0; i < 2; ++i) { - scltMakeDataBlock(&input[i], type, &val_float[i], rowNum, true); + code = scltMakeDataBlock(&input[i], type, &val_float[i], rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); pInput[i] = *input[i]; } - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("float before POW: %f,%f\n", *((float *)pInput[0].data), *((float *)pInput[1].data)); code = powFunction(pInput, 2, pOutput); @@ -3527,12 +4138,14 @@ TEST(ScalarFunctionTest, powFunction_constant) { // TINYINT AND FLOAT int8_t param0 = 2; float param1 = 4.0; - scltMakeDataBlock(&input[0], TSDB_DATA_TYPE_TINYINT, ¶m0, rowNum, true); + code = scltMakeDataBlock(&input[0], TSDB_DATA_TYPE_TINYINT, ¶m0, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); pInput[0] = *input[0]; - scltMakeDataBlock(&input[1], TSDB_DATA_TYPE_FLOAT, ¶m1, rowNum, true); + code = scltMakeDataBlock(&input[1], TSDB_DATA_TYPE_FLOAT, ¶m1, rowNum, true); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); pInput[1] = *input[1]; - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); - + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); PRINTF("tiny_int,float before POW: %d,%f\n", *((int8_t *)pInput[0].data), *((float *)pInput[1].data)); code = powFunction(pInput, 2, pOutput); @@ -3562,16 +4175,18 @@ TEST(ScalarFunctionTest, powFunction_column) { int8_t val_tinyint[2][3] = {{2, 3, 4}, {3, 3, 3}}; type = TSDB_DATA_TYPE_TINYINT; for (int32_t i = 0; i < 2; ++i) { - scltMakeDataBlock(&input[i], type, 0, rowNum, false); + code = scltMakeDataBlock(&input[i], type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); pInput[i] = *input[i]; for (int32_t j = 0; j < rowNum; ++j) { - colDataSetVal(pInput[i].columnData, j, (const char *)&val_tinyint[i][j], false); + code = colDataSetVal(pInput[i].columnData, j, (const char *)&val_tinyint[i][j], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } PRINTF("tiny_int before POW:%d,%d,%d\n", *((int8_t *)pInput[i].data + 0), *((int8_t *)pInput[i].data + 1), *((int8_t *)pInput[i].data + 2)); } - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); - + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); code = powFunction(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { @@ -3587,16 +4202,18 @@ TEST(ScalarFunctionTest, powFunction_column) { float val_float[2][3] = {{2.0, 3.0, 4.0}, {3.0, 3.0, 3.0}}; type = TSDB_DATA_TYPE_FLOAT; for (int32_t i = 0; i < 2; ++i) { - scltMakeDataBlock(&input[i], type, 0, rowNum, false); + code = scltMakeDataBlock(&input[i], type, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); pInput[i] = *input[i]; for (int32_t j = 0; j < rowNum; ++j) { - colDataSetVal(pInput[i].columnData, j, (const char *)&val_float[i][j], false); + code = colDataSetVal(pInput[i].columnData, j, (const char *)&val_float[i][j], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } PRINTF("float before POW:%f,%f,%f\n", *((float *)pInput[i].data + 0), *((float *)pInput[i].data + 1), *((float *)pInput[i].data + 2)); } - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); - + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); code = powFunction(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { @@ -3610,21 +4227,25 @@ TEST(ScalarFunctionTest, powFunction_column) { // TINYINT AND FLOAT int8_t param0[] = {2, 3, 4}; float param1[] = {3.0, 3.0, 3.0}; - scltMakeDataBlock(&input[0], TSDB_DATA_TYPE_TINYINT, 0, rowNum, false); + code = scltMakeDataBlock(&input[0], TSDB_DATA_TYPE_TINYINT, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); pInput[0] = *input[0]; for (int32_t i = 0; i < rowNum; ++i) { - colDataSetVal(pInput[0].columnData, i, (const char *)¶m0[i], false); + code = colDataSetVal(pInput[0].columnData, i, (const char *)¶m0[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } - scltMakeDataBlock(&input[1], TSDB_DATA_TYPE_FLOAT, 0, rowNum, false); + code = scltMakeDataBlock(&input[1], TSDB_DATA_TYPE_FLOAT, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); pInput[1] = *input[1]; for (int32_t i = 0; i < rowNum; ++i) { - colDataSetVal(pInput[1].columnData, i, (const char *)¶m1[i], false); + code = colDataSetVal(pInput[1].columnData, i, (const char *)¶m1[i], false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); } PRINTF("tiny_int, float before POW:{%d,%f}, {%d,%f}, {%d,%f}\n", *((int8_t *)pInput[0].data + 0), *((float *)pInput[1].data + 0), *((int8_t *)pInput[0].data + 1), *((float *)pInput[1].data + 1), *((int8_t *)pInput[0].data + 2), *((float *)pInput[1].data + 2)); - scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); - + code = scltMakeDataBlock(&pOutput, otype, 0, rowNum, false); + ASSERT_EQ(code, TSDB_CODE_SUCCESS); code = powFunction(pInput, 2, pOutput); ASSERT_EQ(code, TSDB_CODE_SUCCESS); for (int32_t i = 0; i < rowNum; ++i) { diff --git a/source/libs/stream/inc/streamInt.h b/source/libs/stream/inc/streamInt.h index fd248861e3..2fe86817e3 100644 --- a/source/libs/stream/inc/streamInt.h +++ b/source/libs/stream/inc/streamInt.h @@ -208,7 +208,7 @@ int32_t streamQueueOpen(int64_t cap, SStreamQueue** pQ); void streamQueueClose(SStreamQueue* pQueue, int32_t taskId); void streamQueueProcessSuccess(SStreamQueue* queue); void streamQueueProcessFail(SStreamQueue* queue); -void* streamQueueNextItem(SStreamQueue* pQueue); +void streamQueueNextItem(SStreamQueue* pQueue, SStreamQueueItem** pItem); void streamFreeQitem(SStreamQueueItem* data); int32_t streamQueueGetItemSize(const SStreamQueue* pQueue); @@ -226,7 +226,7 @@ int32_t streamTaskDownloadCheckpointData(const char* id, char* path); int32_t streamTaskOnNormalTaskReady(SStreamTask* pTask); int32_t streamTaskOnScanHistoryTaskReady(SStreamTask* pTask); -int32_t initCheckpointReadyInfo(STaskCheckpointReadyInfo* pReadyInfo, int32_t upstreamNodeId, int32_t upstreamTaskId, +void initCheckpointReadyInfo(STaskCheckpointReadyInfo* pReadyInfo, int32_t upstreamNodeId, int32_t upstreamTaskId, int32_t childId, SEpSet* pEpset, int64_t checkpointId); int32_t initCheckpointReadyMsg(SStreamTask* pTask, int32_t upstreamNodeId, int32_t upstreamTaskId, int32_t childId, int64_t checkpointId, SRpcMsg* pMsg); @@ -236,6 +236,10 @@ typedef int32_t (*__stream_async_exec_fn_t)(void* param); int32_t streamMetaAsyncExec(SStreamMeta* pMeta, __stream_async_exec_fn_t fn, void* param, int32_t* code); void flushStateDataInExecutor(SStreamTask* pTask, SStreamQueueItem* pCheckpointBlock); +void streamMutexLock(TdThreadMutex *pMutex); +void streamMutexUnlock(TdThreadMutex *pMutex); +void streamMutexDestroy(TdThreadMutex *pMutex); + #ifdef __cplusplus } #endif diff --git a/source/libs/stream/src/streamBackendRocksdb.c b/source/libs/stream/src/streamBackendRocksdb.c index 8b87019ee0..86144a3099 100644 --- a/source/libs/stream/src/streamBackendRocksdb.c +++ b/source/libs/stream/src/streamBackendRocksdb.c @@ -887,8 +887,8 @@ _EXIT: rocksdb_options_destroy(opts); rocksdb_cache_destroy(cache); rocksdb_env_destroy(env); - taosThreadMutexDestroy(&pHandle->mutex); - taosThreadMutexDestroy(&pHandle->cfMutex); + streamMutexDestroy(&pHandle->mutex); + streamMutexDestroy(&pHandle->cfMutex); taosHashCleanup(pHandle->cfInst); tdListFree(pHandle->list); taosMemoryFree(pHandle); @@ -923,9 +923,9 @@ void streamBackendCleanup(void* arg) { } tdListFree(pHandle->list); - taosThreadMutexDestroy(&pHandle->mutex); + streamMutexDestroy(&pHandle->mutex); - taosThreadMutexDestroy(&pHandle->cfMutex); + streamMutexDestroy(&pHandle->cfMutex); stDebug("destroy stream backend :%p", pHandle); taosMemoryFree(pHandle); return; @@ -1393,7 +1393,7 @@ int32_t taskDbBuildSnap(void* arg, SArray* pSnap) { // vnode task->db SStreamMeta* pMeta = arg; - taosThreadMutexLock(&pMeta->backendMutex); + streamMutexLock(&pMeta->backendMutex); void* pIter = taosHashIterate(pMeta->pTaskDbUnique, NULL); int32_t code = 0; @@ -1434,14 +1434,14 @@ int32_t taskDbBuildSnap(void* arg, SArray* pSnap) { pIter = taosHashIterate(pMeta->pTaskDbUnique, pIter); } - taosThreadMutexUnlock(&pMeta->backendMutex); + streamMutexUnlock(&pMeta->backendMutex); return code; } int32_t taskDbDestroySnap(void* arg, SArray* pSnapInfo) { if (pSnapInfo == NULL) return 0; SStreamMeta* pMeta = arg; int32_t code = 0; - taosThreadMutexLock(&pMeta->backendMutex); + streamMutexLock(&pMeta->backendMutex); char buf[128] = {0}; for (int i = 0; i < taosArrayGetSize(pSnapInfo); i++) { @@ -1457,7 +1457,7 @@ int32_t taskDbDestroySnap(void* arg, SArray* pSnapInfo) { taskDbUnRefChkp(*pTaskDb, pSnap->chkpId); } - taosThreadMutexUnlock(&pMeta->backendMutex); + streamMutexUnlock(&pMeta->backendMutex); return 0; } #ifdef BUILD_NO_CALL @@ -1697,17 +1697,17 @@ int32_t streamBackendDoCheckpoint(void* arg, int64_t chkpId, int64_t processVer) SListNode* streamBackendAddCompare(void* backend, void* arg) { SBackendWrapper* pHandle = (SBackendWrapper*)backend; SListNode* node = NULL; - taosThreadMutexLock(&pHandle->mutex); + streamMutexLock(&pHandle->mutex); node = tdListAdd(pHandle->list, arg); - taosThreadMutexUnlock(&pHandle->mutex); + streamMutexUnlock(&pHandle->mutex); return node; } void streamBackendDelCompare(void* backend, void* arg) { SBackendWrapper* pHandle = (SBackendWrapper*)backend; SListNode* node = NULL; - taosThreadMutexLock(&pHandle->mutex); + streamMutexLock(&pHandle->mutex); node = tdListPopNode(pHandle->list, arg); - taosThreadMutexUnlock(&pHandle->mutex); + streamMutexUnlock(&pHandle->mutex); if (node) { streamStateDestroyCompar(node->data); taosMemoryFree(node); @@ -2461,9 +2461,9 @@ int32_t taskDbBuildFullPath(char* path, char* key, char** dbFullPath, char** sta void taskDbUpdateChkpId(void* pTaskDb, int64_t chkpId) { STaskDbWrapper* p = pTaskDb; - taosThreadMutexLock(&p->mutex); + streamMutexLock(&p->mutex); p->chkpId = chkpId; - taosThreadMutexUnlock(&p->mutex); + streamMutexUnlock(&p->mutex); } STaskDbWrapper* taskDbOpenImpl(const char* key, char* statePath, char* dbPath) { @@ -2622,7 +2622,7 @@ void taskDbDestroy(void* pDb, bool flush) { taosMemoryFree(wrapper->pCfOpts); taosMemoryFree(wrapper->pCfParams); - taosThreadMutexDestroy(&wrapper->mutex); + streamMutexDestroy(&wrapper->mutex); taskDbDestroyChkpOpt(wrapper); @@ -2957,7 +2957,7 @@ int streamStateOpenBackend(void* backend, SStreamState* pState) { SBackendWrapper* handle = backend; SBackendCfWrapper* pBackendCfWrapper = taosMemoryCalloc(1, sizeof(SBackendCfWrapper)); - taosThreadMutexLock(&handle->cfMutex); + streamMutexLock(&handle->cfMutex); RocksdbCfInst** ppInst = taosHashGet(handle->cfInst, pState->pTdbState->idstr, strlen(pState->pTdbState->idstr) + 1); if (ppInst != NULL && *ppInst != NULL) { RocksdbCfInst* inst = *ppInst; @@ -2970,7 +2970,7 @@ int streamStateOpenBackend(void* backend, SStreamState* pState) { pBackendCfWrapper->param = inst->param; pBackendCfWrapper->pBackend = handle; pBackendCfWrapper->pComparNode = inst->pCompareNode; - taosThreadMutexUnlock(&handle->cfMutex); + streamMutexUnlock(&handle->cfMutex); pBackendCfWrapper->backendId = pState->streamBackendRid; memcpy(pBackendCfWrapper->idstr, pState->pTdbState->idstr, sizeof(pState->pTdbState->idstr)); @@ -2987,7 +2987,7 @@ int streamStateOpenBackend(void* backend, SStreamState* pState) { inst->rOpt = NULL; return 0; } - taosThreadMutexUnlock(&handle->cfMutex); + streamMutexUnlock(&handle->cfMutex); char* err = NULL; int cfLen = sizeof(ginitDict) / sizeof(ginitDict[0]); @@ -3046,14 +3046,14 @@ void streamStateCloseBackend(SStreamState* pState, bool remove) { stInfo("start to close state on backend: %p", pHandle); - taosThreadMutexLock(&pHandle->cfMutex); + streamMutexLock(&pHandle->cfMutex); RocksdbCfInst** ppInst = taosHashGet(pHandle->cfInst, wrapper->idstr, strlen(pState->pTdbState->idstr) + 1); if (ppInst != NULL && *ppInst != NULL) { RocksdbCfInst* inst = *ppInst; taosMemoryFree(inst); taosHashRemove(pHandle->cfInst, pState->pTdbState->idstr, strlen(pState->pTdbState->idstr) + 1); } - taosThreadMutexUnlock(&pHandle->cfMutex); + streamMutexUnlock(&pHandle->cfMutex); char* status[] = {"close", "drop"}; stInfo("start to %s state %p on backendWrapper %p %s", status[remove == false ? 0 : 1], pState, wrapper, @@ -3085,7 +3085,7 @@ int streamStateGetCfIdx(SStreamState* pState, const char* funcName) { return -1; } - taosThreadMutexLock(&wrapper->mutex); + streamMutexLock(&wrapper->mutex); rocksdb_column_family_handle_t* cf = wrapper->pCf[idx]; if (cf == NULL) { @@ -3100,7 +3100,7 @@ int streamStateGetCfIdx(SStreamState* pState, const char* funcName) { wrapper->pCf[idx] = cf; } } - taosThreadMutexUnlock(&wrapper->mutex); + streamMutexUnlock(&wrapper->mutex); } return idx; diff --git a/source/libs/stream/src/streamCheckStatus.c b/source/libs/stream/src/streamCheckStatus.c index e588be0784..5e67f1766f 100644 --- a/source/libs/stream/src/streamCheckStatus.c +++ b/source/libs/stream/src/streamCheckStatus.c @@ -23,10 +23,10 @@ static void processDownstreamReadyRsp(SStreamTask* pTask); static void addIntoNodeUpdateList(SStreamTask* pTask, int32_t nodeId); static void rspMonitorFn(void* param, void* tmrId); -static int32_t streamTaskInitTaskCheckInfo(STaskCheckInfo* pInfo, STaskOutputInfo* pOutputInfo, int64_t startTs); +static void streamTaskInitTaskCheckInfo(STaskCheckInfo* pInfo, STaskOutputInfo* pOutputInfo, int64_t startTs); static int32_t streamTaskStartCheckDownstream(STaskCheckInfo* pInfo, const char* id); -static int32_t streamTaskCompleteCheckRsp(STaskCheckInfo* pInfo, bool lock, const char* id); -static int32_t streamTaskAddReqInfo(STaskCheckInfo* pInfo, int64_t reqId, int32_t taskId, int32_t vgId, const char* id); +static void streamTaskCompleteCheckRsp(STaskCheckInfo* pInfo, bool lock, const char* id); +static void streamTaskAddReqInfo(STaskCheckInfo* pInfo, int64_t reqId, int32_t taskId, int32_t vgId, const char* id); static void doSendCheckMsg(SStreamTask* pTask, SDownstreamStatusInfo* p); static void handleTimeoutDownstreamTasks(SStreamTask* pTask, SArray* pTimeoutList); static void handleNotReadyDownstreamTask(SStreamTask* pTask, SArray* pNotReadyList); @@ -41,9 +41,9 @@ static SDownstreamStatusInfo* findCheckRspStatus(STaskCheckInfo* pInfo, int32_t int32_t streamTaskCheckStatus(SStreamTask* pTask, int32_t upstreamTaskId, int32_t vgId, int64_t stage, int64_t* oldStage) { SStreamUpstreamEpInfo* pInfo = NULL; - int32_t code = streamTaskGetUpstreamTaskEpInfo(pTask, upstreamTaskId, &pInfo); - if (code != TSDB_CODE_SUCCESS) { - return code; + streamTaskGetUpstreamTaskEpInfo(pTask, upstreamTaskId, &pInfo); + if (pInfo == NULL) { + return TSDB_CODE_STREAM_TASK_NOT_EXIST; } *oldStage = pInfo->stage; @@ -65,21 +65,21 @@ int32_t streamTaskCheckStatus(SStreamTask* pTask, int32_t upstreamTaskId, int32_ ", prev:%" PRId64, id, upstreamTaskId, vgId, stage, pInfo->stage); // record the checkpoint failure id and sent to mnode - taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); ETaskStatus status = streamTaskGetStatus(pTask).state; if (status == TASK_STATUS__CK) { streamTaskSetFailedCheckpointId(pTask); } - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); } if (pInfo->stage != stage) { - taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); ETaskStatus status = streamTaskGetStatus(pTask).state; if (status == TASK_STATUS__CK) { streamTaskSetFailedCheckpointId(pTask); } - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); return TASK_UPSTREAM_NEW_STAGE; } else if (pTask->status.downstreamReady != 1) { @@ -120,7 +120,7 @@ void streamTaskSendCheckMsg(SStreamTask* pTask) { idstr, pTask->info.nodeId, req.stage, req.downstreamTaskId, req.downstreamNodeId, pRange->range.minVer, pRange->range.maxVer, pWindow->skey, pWindow->ekey, req.reqId); - streamSendCheckMsg(pTask, &req, pTask->outputInfo.fixedDispatcher.nodeId, &pTask->outputInfo.fixedDispatcher.epSet); + (void) streamSendCheckMsg(pTask, &req, pTask->outputInfo.fixedDispatcher.nodeId, &pTask->outputInfo.fixedDispatcher.epSet); } else if (pTask->outputInfo.type == TASK_OUTPUT__SHUFFLE_DISPATCH) { streamTaskStartMonitorCheckRsp(pTask); @@ -140,7 +140,7 @@ void streamTaskSendCheckMsg(SStreamTask* pTask) { stDebug("s-task:%s (vgId:%d) stage:%" PRId64 " check downstream task:0x%x (vgId:%d) (shuffle), idx:%d, reqId:0x%" PRIx64, idstr, pTask->info.nodeId, req.stage, req.downstreamTaskId, req.downstreamNodeId, i, req.reqId); - streamSendCheckMsg(pTask, &req, pVgInfo->vgId, &pVgInfo->epSet); + (void) streamSendCheckMsg(pTask, &req, pVgInfo->vgId, &pVgInfo->epSet); } } else { // for sink task, set it ready directly. stDebug("s-task:%s (vgId:%d) set downstream ready, since no downstream", idstr, pTask->info.nodeId); @@ -265,7 +265,7 @@ int32_t streamTaskSendCheckRsp(const SStreamMeta* pMeta, int32_t vgId, SStreamTa void* abuf = POINTER_SHIFT(buf, sizeof(SMsgHead)); tEncoderInit(&encoder, (uint8_t*)abuf, len); - tEncodeStreamTaskCheckRsp(&encoder, pRsp); + (void) tEncodeStreamTaskCheckRsp(&encoder, pRsp); tEncoderClear(&encoder); SRpcMsg rspMsg = {.code = 0, .pCont = buf, .contLen = sizeof(SMsgHead) + len, .info = *pRpcInfo}; @@ -274,14 +274,16 @@ int32_t streamTaskSendCheckRsp(const SStreamMeta* pMeta, int32_t vgId, SStreamTa return 0; } -int32_t streamTaskStartMonitorCheckRsp(SStreamTask* pTask) { +void streamTaskStartMonitorCheckRsp(SStreamTask* pTask) { + int32_t vgId = pTask->pMeta->vgId; STaskCheckInfo* pInfo = &pTask->taskCheckInfo; - taosThreadMutexLock(&pInfo->checkInfoLock); + + streamMutexLock(&pInfo->checkInfoLock); int32_t code = streamTaskStartCheckDownstream(pInfo, pTask->id.idStr); if (code != TSDB_CODE_SUCCESS) { - taosThreadMutexUnlock(&pInfo->checkInfoLock); - return TSDB_CODE_FAILED; + streamMutexUnlock(&pInfo->checkInfoLock); + return; } /*SStreamTask* p = */ streamMetaAcquireOneTask(pTask); // add task ref here @@ -293,20 +295,18 @@ int32_t streamTaskStartMonitorCheckRsp(SStreamTask* pTask) { if (pInfo->checkRspTmr == NULL) { pInfo->checkRspTmr = taosTmrStart(rspMonitorFn, CHECK_RSP_CHECK_INTERVAL, pTask, streamTimer); } else { - taosTmrReset(rspMonitorFn, CHECK_RSP_CHECK_INTERVAL, pTask, streamTimer, &pInfo->checkRspTmr); + streamTmrReset(rspMonitorFn, CHECK_RSP_CHECK_INTERVAL, pTask, streamTimer, &pInfo->checkRspTmr, vgId, "check-status-monitor"); } - taosThreadMutexUnlock(&pInfo->checkInfoLock); - return 0; + streamMutexUnlock(&pInfo->checkInfoLock); } -int32_t streamTaskStopMonitorCheckRsp(STaskCheckInfo* pInfo, const char* id) { - taosThreadMutexLock(&pInfo->checkInfoLock); +void streamTaskStopMonitorCheckRsp(STaskCheckInfo* pInfo, const char* id) { + streamMutexLock(&pInfo->checkInfoLock); pInfo->stopCheckProcess = 1; - taosThreadMutexUnlock(&pInfo->checkInfoLock); + streamMutexUnlock(&pInfo->checkInfoLock); stDebug("s-task:%s set stop check-rsp monitor flag", id); - return TSDB_CODE_SUCCESS; } void streamTaskCleanupCheckInfo(STaskCheckInfo* pInfo) { @@ -316,21 +316,21 @@ void streamTaskCleanupCheckInfo(STaskCheckInfo* pInfo) { pInfo->pList = NULL; if (pInfo->checkRspTmr != NULL) { - /*bool ret = */ taosTmrStop(pInfo->checkRspTmr); + (void) taosTmrStop(pInfo->checkRspTmr); pInfo->checkRspTmr = NULL; } - taosThreadMutexDestroy(&pInfo->checkInfoLock); + streamMutexDestroy(&pInfo->checkInfoLock); } /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// void processDownstreamReadyRsp(SStreamTask* pTask) { EStreamTaskEvent event = (pTask->info.fillHistory == 0) ? TASK_EVENT_INIT : TASK_EVENT_INIT_SCANHIST; - streamTaskOnHandleEventSuccess(pTask->status.pSM, event, NULL, NULL); + (void) streamTaskOnHandleEventSuccess(pTask->status.pSM, event, NULL, NULL); int64_t checkTs = pTask->execInfo.checkTs; int64_t readyTs = pTask->execInfo.readyTs; - streamMetaAddTaskLaunchResult(pTask->pMeta, pTask->id.streamId, pTask->id.taskId, checkTs, readyTs, true); + (void) streamMetaAddTaskLaunchResult(pTask->pMeta, pTask->id.streamId, pTask->id.taskId, checkTs, readyTs, true); if (pTask->status.taskStatus == TASK_STATUS__HALT) { ASSERT(HAS_RELATED_FILLHISTORY_TASK(pTask) && (pTask->info.fillHistory == 0)); @@ -338,21 +338,25 @@ void processDownstreamReadyRsp(SStreamTask* pTask) { // halt it self for count window stream task until the related fill history task completed. stDebug("s-task:%s level:%d initial status is %s from mnode, set it to be halt", pTask->id.idStr, pTask->info.taskLevel, streamTaskGetStatusStr(pTask->status.taskStatus)); - streamTaskHandleEvent(pTask->status.pSM, TASK_EVENT_HALT); + int32_t code = streamTaskHandleEvent(pTask->status.pSM, TASK_EVENT_HALT); + if (code != 0) { + // todo: handle error + } } // start the related fill-history task, when current task is ready // not invoke in success callback due to the deadlock. + // todo: let's retry if (HAS_RELATED_FILLHISTORY_TASK(pTask)) { stDebug("s-task:%s try to launch related fill-history task", pTask->id.idStr); - streamLaunchFillHistoryTask(pTask); + (void) streamLaunchFillHistoryTask(pTask); } } void addIntoNodeUpdateList(SStreamTask* pTask, int32_t nodeId) { int32_t vgId = pTask->pMeta->vgId; - taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); int32_t num = taosArrayGetSize(pTask->outputInfo.pNodeEpsetUpdateList); bool existed = false; for (int i = 0; i < num; ++i) { @@ -365,16 +369,18 @@ void addIntoNodeUpdateList(SStreamTask* pTask, int32_t nodeId) { if (!existed) { SDownstreamTaskEpset t = {.nodeId = nodeId}; - taosArrayPush(pTask->outputInfo.pNodeEpsetUpdateList, &t); - + void* p = taosArrayPush(pTask->outputInfo.pNodeEpsetUpdateList, &t); + if (p == NULL) { + // todo let's retry + } stInfo("s-task:%s vgId:%d downstream nodeId:%d needs to be updated, total needs updated:%d", pTask->id.idStr, vgId, t.nodeId, (num + 1)); } - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); } -int32_t streamTaskInitTaskCheckInfo(STaskCheckInfo* pInfo, STaskOutputInfo* pOutputInfo, int64_t startTs) { +void streamTaskInitTaskCheckInfo(STaskCheckInfo* pInfo, STaskOutputInfo* pOutputInfo, int64_t startTs) { taosArrayClear(pInfo->pList); if (pOutputInfo->type == TASK_OUTPUT__FIXED_DISPATCH) { @@ -387,7 +393,6 @@ int32_t streamTaskInitTaskCheckInfo(STaskCheckInfo* pInfo, STaskOutputInfo* pOut pInfo->startTs = startTs; pInfo->timeoutStartTs = startTs; pInfo->stopCheckProcess = 0; - return TSDB_CODE_SUCCESS; } SDownstreamStatusInfo* findCheckRspStatus(STaskCheckInfo* pInfo, int32_t taskId) { @@ -403,7 +408,7 @@ SDownstreamStatusInfo* findCheckRspStatus(STaskCheckInfo* pInfo, int32_t taskId) int32_t streamTaskUpdateCheckInfo(STaskCheckInfo* pInfo, int32_t taskId, int32_t status, int64_t rspTs, int64_t reqId, int32_t* pNotReady, const char* id) { - taosThreadMutexLock(&pInfo->checkInfoLock); + streamMutexLock(&pInfo->checkInfoLock); SDownstreamStatusInfo* p = findCheckRspStatus(pInfo, taskId); if (p != NULL) { @@ -411,7 +416,7 @@ int32_t streamTaskUpdateCheckInfo(STaskCheckInfo* pInfo, int32_t taskId, int32_t stError("s-task:%s reqId:0x%" PRIx64 " expected:0x%" PRIx64 " expired check-rsp recv from downstream task:0x%x, discarded", id, reqId, p->reqId, taskId); - taosThreadMutexUnlock(&pInfo->checkInfoLock); + streamMutexUnlock(&pInfo->checkInfoLock); return TSDB_CODE_FAILED; } @@ -425,11 +430,11 @@ int32_t streamTaskUpdateCheckInfo(STaskCheckInfo* pInfo, int32_t taskId, int32_t p->status = status; p->rspTs = rspTs; - taosThreadMutexUnlock(&pInfo->checkInfoLock); + streamMutexUnlock(&pInfo->checkInfoLock); return TSDB_CODE_SUCCESS; } - taosThreadMutexUnlock(&pInfo->checkInfoLock); + streamMutexUnlock(&pInfo->checkInfoLock); stError("s-task:%s unexpected check rsp msg, invalid downstream task:0x%x, reqId:%" PRIx64 " discarded", id, taskId, reqId); return TSDB_CODE_FAILED; @@ -450,9 +455,9 @@ int32_t streamTaskStartCheckDownstream(STaskCheckInfo* pInfo, const char* id) { return TSDB_CODE_SUCCESS; } -int32_t streamTaskCompleteCheckRsp(STaskCheckInfo* pInfo, bool lock, const char* id) { +void streamTaskCompleteCheckRsp(STaskCheckInfo* pInfo, bool lock, const char* id) { if (lock) { - taosThreadMutexLock(&pInfo->checkInfoLock); + streamMutexLock(&pInfo->checkInfoLock); } if (pInfo->inCheckProcess) { @@ -474,27 +479,28 @@ int32_t streamTaskCompleteCheckRsp(STaskCheckInfo* pInfo, bool lock, const char* } if (lock) { - taosThreadMutexUnlock(&pInfo->checkInfoLock); + streamMutexUnlock(&pInfo->checkInfoLock); } - - return 0; } -int32_t streamTaskAddReqInfo(STaskCheckInfo* pInfo, int64_t reqId, int32_t taskId, int32_t vgId, const char* id) { +// todo: retry until success +void streamTaskAddReqInfo(STaskCheckInfo* pInfo, int64_t reqId, int32_t taskId, int32_t vgId, const char* id) { SDownstreamStatusInfo info = {.taskId = taskId, .status = -1, .vgId = vgId, .reqId = reqId, .rspTs = 0}; - taosThreadMutexLock(&pInfo->checkInfoLock); + streamMutexLock(&pInfo->checkInfoLock); SDownstreamStatusInfo* p = findCheckRspStatus(pInfo, taskId); if (p != NULL) { stDebug("s-task:%s check info to task:0x%x already sent", id, taskId); - taosThreadMutexUnlock(&pInfo->checkInfoLock); - return TSDB_CODE_SUCCESS; + streamMutexUnlock(&pInfo->checkInfoLock); + return; } - taosArrayPush(pInfo->pList, &info); + void* px = taosArrayPush(pInfo->pList, &info); + if (px == NULL) { + // todo: retry + } - taosThreadMutexUnlock(&pInfo->checkInfoLock); - return TSDB_CODE_SUCCESS; + streamMutexUnlock(&pInfo->checkInfoLock); } void doSendCheckMsg(SStreamTask* pTask, SDownstreamStatusInfo* p) { @@ -519,7 +525,7 @@ void doSendCheckMsg(SStreamTask* pTask, SDownstreamStatusInfo* p) { stDebug("s-task:%s (vgId:%d) stage:%" PRId64 " re-send check downstream task:0x%x(vgId:%d) reqId:0x%" PRIx64, id, pTask->info.nodeId, req.stage, req.downstreamTaskId, req.downstreamNodeId, req.reqId); - streamSendCheckMsg(pTask, &req, pOutputInfo->fixedDispatcher.nodeId, &pOutputInfo->fixedDispatcher.epSet); + (void) streamSendCheckMsg(pTask, &req, pOutputInfo->fixedDispatcher.nodeId, &pOutputInfo->fixedDispatcher.epSet); } else if (pOutputInfo->type == TASK_OUTPUT__SHUFFLE_DISPATCH) { SArray* vgInfo = pOutputInfo->shuffleDispatcher.dbInfo.pVgroupInfos; int32_t numOfVgs = taosArrayGetSize(vgInfo); @@ -533,7 +539,7 @@ void doSendCheckMsg(SStreamTask* pTask, SDownstreamStatusInfo* p) { stDebug("s-task:%s (vgId:%d) stage:%" PRId64 " re-send check downstream task:0x%x(vgId:%d) (shuffle), idx:%d reqId:0x%" PRIx64, id, pTask->info.nodeId, req.stage, req.downstreamTaskId, req.downstreamNodeId, i, p->reqId); - streamSendCheckMsg(pTask, &req, pVgInfo->vgId, &pVgInfo->epSet); + (void) streamSendCheckMsg(pTask, &req, pVgInfo->vgId, &pVgInfo->epSet); break; } } @@ -556,12 +562,12 @@ void getCheckRspStatus(STaskCheckInfo* pInfo, int64_t el, int32_t* numOfReady, i if (p->rspTs == 0) { // not response yet ASSERT(p->status == -1); if (el >= CHECK_NOT_RSP_DURATION) { // not receive info for 10 sec. - taosArrayPush(pTimeoutList, &p->taskId); + (void) taosArrayPush(pTimeoutList, &p->taskId); } else { // el < CHECK_NOT_RSP_DURATION (*numOfNotRsp) += 1; // do nothing and continue waiting for their rsp } } else { - taosArrayPush(pNotReadyList, &p->taskId); + (void) taosArrayPush(pNotReadyList, &p->taskId); } } } @@ -676,7 +682,7 @@ void rspMonitorFn(void* param, void* tmrId) { // not record the failed of the current task if try to close current vnode // otherwise, the put of message operation may incur invalid read of message queue. if (!pMeta->closeFlag) { - addDownstreamFailedStatusResultAsync(pTask->pMsgCb, vgId, pTask->id.streamId, pTask->id.taskId); + (void) addDownstreamFailedStatusResultAsync(pTask->pMsgCb, vgId, pTask->id.streamId, pTask->id.taskId); } streamMetaReleaseTask(pMeta, pTask); @@ -692,14 +698,14 @@ void rspMonitorFn(void* param, void* tmrId) { return; } - taosThreadMutexLock(&pInfo->checkInfoLock); + streamMutexLock(&pInfo->checkInfoLock); if (pInfo->notReadyTasks == 0) { int32_t ref = atomic_sub_fetch_32(&pTask->status.timerActive, 1); stDebug("s-task:%s status:%s vgId:%d all downstream ready, quit from monitor rsp tmr, ref:%d", id, pStat.name, vgId, ref); streamTaskCompleteCheckRsp(pInfo, false, id); - taosThreadMutexUnlock(&pInfo->checkInfoLock); + streamMutexUnlock(&pInfo->checkInfoLock); streamMetaReleaseTask(pMeta, pTask); return; } @@ -723,7 +729,7 @@ void rspMonitorFn(void* param, void* tmrId) { id, pStat.name, vgId, total, numOfNotRsp, numOfNotReady, numOfFault, numOfTimeout, numOfReady, ref); streamTaskCompleteCheckRsp(pInfo, false, id); - taosThreadMutexUnlock(&pInfo->checkInfoLock); + streamMutexUnlock(&pInfo->checkInfoLock); streamMetaReleaseTask(pMeta, pTask); taosArrayDestroy(pNotReadyList); @@ -743,9 +749,9 @@ void rspMonitorFn(void* param, void* tmrId) { id, pStat.name, vgId, total, numOfNotRsp, numOfNotReady, numOfFault, numOfTimeout, numOfReady, ref); streamTaskCompleteCheckRsp(pInfo, false, id); - taosThreadMutexUnlock(&pInfo->checkInfoLock); + streamMutexUnlock(&pInfo->checkInfoLock); - addDownstreamFailedStatusResultAsync(pTask->pMsgCb, vgId, pTask->id.streamId, pTask->id.taskId); + (void) addDownstreamFailedStatusResultAsync(pTask->pMsgCb, vgId, pTask->id.streamId, pTask->id.taskId); streamMetaReleaseTask(pMeta, pTask); taosArrayDestroy(pNotReadyList); @@ -761,8 +767,8 @@ void rspMonitorFn(void* param, void* tmrId) { handleTimeoutDownstreamTasks(pTask, pTimeoutList); } - taosTmrReset(rspMonitorFn, CHECK_RSP_CHECK_INTERVAL, pTask, streamTimer, &pInfo->checkRspTmr); - taosThreadMutexUnlock(&pInfo->checkInfoLock); + streamTmrReset(rspMonitorFn, CHECK_RSP_CHECK_INTERVAL, pTask, streamTimer, &pInfo->checkRspTmr, vgId, "check-status-monitor"); + streamMutexUnlock(&pInfo->checkInfoLock); stDebug( "s-task:%s vgId:%d continue checking rsp in 300ms, total:%d, notRsp:%d, notReady:%d, fault:%d, timeout:%d, " diff --git a/source/libs/stream/src/streamCheckpoint.c b/source/libs/stream/src/streamCheckpoint.c index 8de923e900..60019977cc 100644 --- a/source/libs/stream/src/streamCheckpoint.c +++ b/source/libs/stream/src/streamCheckpoint.c @@ -77,6 +77,7 @@ int32_t createChkptTriggerBlock(SStreamTask* pTask, int32_t checkpointType, int6 } // this message must be put into inputq successfully, continue retrying until it succeeds +// todo must be success int32_t appendCheckpointIntoInputQ(SStreamTask* pTask, int32_t checkpointType, int64_t checkpointId, int32_t transId, int32_t srcTaskId) { SStreamDataBlock* pCheckpoint = NULL; @@ -119,8 +120,8 @@ int32_t streamTaskProcessCheckpointTriggerRsp(SStreamTask* pTask, SCheckpointTri return TSDB_CODE_SUCCESS; } - appendCheckpointIntoInputQ(pTask, STREAM_INPUT__CHECKPOINT_TRIGGER, pRsp->checkpointId, pRsp->transId, - pRsp->upstreamTaskId); + (void)appendCheckpointIntoInputQ(pTask, STREAM_INPUT__CHECKPOINT_TRIGGER, pRsp->checkpointId, pRsp->transId, + pRsp->upstreamTaskId); return TSDB_CODE_SUCCESS; } @@ -164,7 +165,7 @@ int32_t continueDispatchCheckpointTriggerBlock(SStreamDataBlock* pBlock, SStream int32_t code = taosWriteQitem(pTask->outputq.queue->pQueue, pBlock); if (code == 0) { ASSERT(pTask->chkInfo.pActiveInfo->dispatchTrigger == false); - streamDispatchStreamBlock(pTask); + code = streamDispatchStreamBlock(pTask); } else { stError("s-task:%s failed to put checkpoint into outputQ, code:%s", pTask->id.idStr, tstrerror(code)); streamFreeQitem((SStreamQueueItem*)pBlock); @@ -184,12 +185,12 @@ int32_t streamProcessCheckpointTriggerBlock(SStreamTask* pTask, SStreamDataBlock SActiveCheckpointInfo* pActiveInfo = pTask->chkInfo.pActiveInfo; - (void) taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); if (pTask->chkInfo.checkpointId > checkpointId) { stError("s-task:%s vgId:%d current checkpointId:%" PRId64 " recv expired checkpoint-trigger block, checkpointId:%" PRId64 " transId:%d, discard", id, vgId, pTask->chkInfo.checkpointId, checkpointId, transId); - code = taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); streamFreeQitem((SStreamQueueItem*)pBlock); return code; @@ -199,13 +200,16 @@ int32_t streamProcessCheckpointTriggerBlock(SStreamTask* pTask, SStreamDataBlock { // send checkpoint-ready msg to upstream SRpcMsg msg = {0}; SStreamUpstreamEpInfo* pInfo = NULL; - code = streamTaskGetUpstreamTaskEpInfo(pTask, pBlock->srcTaskId, &pInfo); - if (code != TSDB_CODE_SUCCESS) { - return code; + streamTaskGetUpstreamTaskEpInfo(pTask, pBlock->srcTaskId, &pInfo); + if (pInfo == NULL) { + streamMutexUnlock(&pTask->lock); + return TSDB_CODE_STREAM_TASK_NOT_EXIST; } - initCheckpointReadyMsg(pTask, pInfo->nodeId, pBlock->srcTaskId, pInfo->childId, checkpointId, &msg); - tmsgSendReq(&pInfo->epSet, &msg); + code = initCheckpointReadyMsg(pTask, pInfo->nodeId, pBlock->srcTaskId, pInfo->childId, checkpointId, &msg); + if (code == TSDB_CODE_SUCCESS) { + (void)tmsgSendReq(&pInfo->epSet, &msg); + } } stWarn( @@ -214,7 +218,7 @@ int32_t streamProcessCheckpointTriggerBlock(SStreamTask* pTask, SStreamDataBlock id, vgId, pBlock->srcTaskId); streamTaskOpenUpstreamInput(pTask, pBlock->srcTaskId); - code = taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); streamFreeQitem((SStreamQueueItem*)pBlock); return code; @@ -225,7 +229,7 @@ int32_t streamProcessCheckpointTriggerBlock(SStreamTask* pTask, SStreamDataBlock stError("s-task:%s vgId:%d active checkpointId:%" PRId64 ", recv invalid checkpoint-trigger checkpointId:%" PRId64 " discard", id, vgId, pActiveInfo->activeId, checkpointId); - code = taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); streamFreeQitem((SStreamQueueItem*)pBlock); return code; @@ -235,7 +239,7 @@ int32_t streamProcessCheckpointTriggerBlock(SStreamTask* pTask, SStreamDataBlock "s-task:%s vgId:%d all upstream checkpoint-trigger recv, discard this checkpoint-trigger, " "checkpointId:%" PRId64 " transId:%d", id, vgId, checkpointId, transId); - code = taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); streamFreeQitem((SStreamQueueItem*)pBlock); return code; } @@ -250,7 +254,7 @@ int32_t streamProcessCheckpointTriggerBlock(SStreamTask* pTask, SStreamDataBlock ", prev recvTs:%" PRId64 " discard", pTask->id.idStr, p->upstreamTaskId, p->upstreamNodeId, p->checkpointId, p->recvTs); - code = taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); streamFreeQitem((SStreamQueueItem*)pBlock); return code; } @@ -259,7 +263,7 @@ int32_t streamProcessCheckpointTriggerBlock(SStreamTask* pTask, SStreamDataBlock } } - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); stDebug("s-task:%s vgId:%d start to handle the checkpoint-trigger block, checkpointId:%" PRId64 " ver:%" PRId64 ", transId:%d current active checkpointId:%" PRId64, @@ -284,7 +288,7 @@ int32_t streamProcessCheckpointTriggerBlock(SStreamTask* pTask, SStreamDataBlock if (pActiveInfo->pChkptTriggerTmr == NULL) { pActiveInfo->pChkptTriggerTmr = taosTmrStart(checkpointTriggerMonitorFn, 100, pTask, streamTimer); } else { - taosTmrReset(checkpointTriggerMonitorFn, 100, pTask, streamTimer, &pActiveInfo->pChkptTriggerTmr); + streamTmrReset(checkpointTriggerMonitorFn, 100, pTask, streamTimer, &pActiveInfo->pChkptTriggerTmr, vgId, "trigger-recv-monitor"); } } @@ -300,9 +304,10 @@ int32_t streamProcessCheckpointTriggerBlock(SStreamTask* pTask, SStreamDataBlock if (type == TASK_OUTPUT__FIXED_DISPATCH || type == TASK_OUTPUT__SHUFFLE_DISPATCH) { stDebug("s-task:%s set childIdx:%d, and add checkpoint-trigger block into outputQ", id, pTask->info.selfChildId); - continueDispatchCheckpointTriggerBlock(pBlock, pTask); + (void)continueDispatchCheckpointTriggerBlock(pBlock, pTask); // todo handle this failure } else { // only one task exists, no need to dispatch downstream info - appendCheckpointIntoInputQ(pTask, STREAM_INPUT__CHECKPOINT, pActiveInfo->activeId, pActiveInfo->transId, -1); + (void)appendCheckpointIntoInputQ(pTask, STREAM_INPUT__CHECKPOINT, pActiveInfo->activeId, pActiveInfo->transId, + -1); streamFreeQitem((SStreamQueueItem*)pBlock); } } else if (taskLevel == TASK_LEVEL__SINK || taskLevel == TASK_LEVEL__AGG) { @@ -312,8 +317,9 @@ int32_t streamProcessCheckpointTriggerBlock(SStreamTask* pTask, SStreamDataBlock pTask->execInfo.checkpoint += 1; } + // todo: handle this // update the child Id for downstream tasks - streamAddCheckpointReadyMsg(pTask, pBlock->srcTaskId, pTask->info.selfChildId, checkpointId); + (void) streamAddCheckpointReadyMsg(pTask, pBlock->srcTaskId, pTask->info.selfChildId, checkpointId); // there are still some upstream tasks not send checkpoint request, do nothing and wait for then if (pActiveInfo->allUpstreamTriggerRecv != 1) { @@ -325,7 +331,7 @@ int32_t streamProcessCheckpointTriggerBlock(SStreamTask* pTask, SStreamDataBlock if (taskLevel == TASK_LEVEL__SINK) { stDebug("s-task:%s process checkpoint-trigger block, all %d upstreams sent, send ready msg to upstream", id, num); streamFreeQitem((SStreamQueueItem*)pBlock); - streamTaskBuildCheckpoint(pTask); + (void)streamTaskBuildCheckpoint(pTask); // todo: not handle error yet } else { // source & agg tasks need to forward the checkpoint msg downwards stDebug("s-task:%s process checkpoint-trigger block, all %d upstreams sent, forwards to downstream", id, num); @@ -369,7 +375,7 @@ int32_t streamProcessCheckpointReadyMsg(SStreamTask* pTask, int64_t checkpointId return -1; } - (void) taosThreadMutexLock(&pInfo->lock); + streamMutexLock(&pInfo->lock); // only when all downstream tasks are send checkpoint rsp, we can start the checkpoint procedure for the agg task int32_t size = taosArrayGetSize(pInfo->pCheckpointReadyRecvList); @@ -391,16 +397,16 @@ int32_t streamProcessCheckpointReadyMsg(SStreamTask* pTask, int64_t checkpointId .transId = pInfo->transId, .streamId = pTask->id.streamId, .downstreamNodeId = downstreamNodeId}; - taosArrayPush(pInfo->pCheckpointReadyRecvList, &info); + (void)taosArrayPush(pInfo->pCheckpointReadyRecvList, &info); } int32_t notReady = total - taosArrayGetSize(pInfo->pCheckpointReadyRecvList); int32_t transId = pInfo->transId; - (void) taosThreadMutexUnlock(&pInfo->lock); + streamMutexUnlock(&pInfo->lock); if (notReady == 0) { stDebug("s-task:%s all downstream tasks have completed build checkpoint, do checkpoint for current task", id); - appendCheckpointIntoInputQ(pTask, STREAM_INPUT__CHECKPOINT, checkpointId, transId, -1); + (void)appendCheckpointIntoInputQ(pTask, STREAM_INPUT__CHECKPOINT, checkpointId, transId, -1); } return 0; @@ -411,7 +417,7 @@ int32_t streamTaskProcessCheckpointReadyRsp(SStreamTask* pTask, int32_t upstream int64_t now = taosGetTimestampMs(); int32_t numOfConfirmed = 0; - (void) taosThreadMutexLock(&pInfo->lock); + streamMutexLock(&pInfo->lock); for (int32_t i = 0; i < taosArrayGetSize(pInfo->pReadyMsgList); ++i) { STaskCheckpointReadyInfo* pReadyInfo = taosArrayGet(pInfo->pReadyMsgList, i); if (pReadyInfo->upstreamTaskId == upstreamTaskId && pReadyInfo->checkpointId == checkpointId) { @@ -432,7 +438,7 @@ int32_t streamTaskProcessCheckpointReadyRsp(SStreamTask* pTask, int32_t upstream stDebug("s-task:%s send checkpoint-ready msg to %d upstream confirmed, checkpointId:%" PRId64, pTask->id.idStr, numOfConfirmed, checkpointId); - (void) taosThreadMutexUnlock(&pInfo->lock); + streamMutexUnlock(&pInfo->lock); return TSDB_CODE_SUCCESS; } @@ -440,12 +446,12 @@ void streamTaskClearCheckInfo(SStreamTask* pTask, bool clearChkpReadyMsg) { pTask->chkInfo.startTs = 0; // clear the recorded start time streamTaskOpenAllUpstreamInput(pTask); // open inputQ for all upstream tasks - (void) taosThreadMutexLock(&pTask->chkInfo.pActiveInfo->lock); + streamMutexLock(&pTask->chkInfo.pActiveInfo->lock); streamTaskClearActiveInfo(pTask->chkInfo.pActiveInfo); if (clearChkpReadyMsg) { streamClearChkptReadyMsg(pTask->chkInfo.pActiveInfo); } - (void) taosThreadMutexUnlock(&pTask->chkInfo.pActiveInfo->lock); + streamMutexUnlock(&pTask->chkInfo.pActiveInfo->lock); } int32_t streamTaskUpdateTaskCheckpointInfo(SStreamTask* pTask, bool restored, SVUpdateCheckpointInfoReq* pReq) { @@ -455,7 +461,7 @@ int32_t streamTaskUpdateTaskCheckpointInfo(SStreamTask* pTask, bool restored, SV const char* id = pTask->id.idStr; SCheckpointInfo* pInfo = &pTask->chkInfo; - (void) taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); if (pReq->checkpointId <= pInfo->checkpointId) { stDebug("s-task:%s vgId:%d latest checkpointId:%" PRId64 " checkpointVer:%" PRId64 @@ -463,7 +469,7 @@ int32_t streamTaskUpdateTaskCheckpointInfo(SStreamTask* pTask, bool restored, SV " transId:%d ignored", id, vgId, pInfo->checkpointId, pInfo->checkpointVer, pReq->checkpointId, pReq->checkpointVer, pReq->transId); - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); { // destroy the related fill-history tasks // drop task should not in the meta-lock, and drop the related fill-history task now @@ -525,13 +531,14 @@ int32_t streamTaskUpdateTaskCheckpointInfo(SStreamTask* pTask, bool restored, SV pTask->status.taskStatus = TASK_STATUS__READY; code = streamMetaSaveTask(pMeta, pTask); + streamMutexUnlock(&pTask->lock); + if (code != TSDB_CODE_SUCCESS) { stError("s-task:%s vgId:%d failed to save task info after do checkpoint, checkpointId:%" PRId64 ", since %s", id, vgId, pReq->checkpointId, terrstr()); return code; } - (void) taosThreadMutexUnlock(&pTask->lock); streamMetaWUnLock(pMeta); // drop task should not in the meta-lock, and drop the related fill-history task now @@ -730,9 +737,9 @@ int32_t streamTaskBuildCheckpoint(SStreamTask* pTask) { code = streamSendChkptReportMsg(pTask, &pTask->chkInfo, dropRelHTask); } } else { // clear the checkpoint info if failed - (void) taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); streamTaskSetFailedCheckpointId(pTask); // set failed checkpoint id before clear the checkpoint info - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); code = streamTaskHandleEvent(pTask->status.pSM, TASK_EVENT_CHECKPOINT_DONE); stDebug("s-task:%s clear checkpoint flag since gen checkpoint failed, checkpointId:%" PRId64, id, ckId); @@ -763,20 +770,20 @@ void checkpointTriggerMonitorFn(void* param, void* tmrId) { } if (++pActiveInfo->checkCounter < 100) { - taosTmrReset(checkpointTriggerMonitorFn, 100, pTask, streamTimer, &pActiveInfo->pChkptTriggerTmr); + streamTmrReset(checkpointTriggerMonitorFn, 100, pTask, streamTimer, &pActiveInfo->pChkptTriggerTmr, vgId, "trigger-recv-monitor"); return; } pActiveInfo->checkCounter = 0; stDebug("s-task:%s vgId:%d checkpoint-trigger monitor in tmr, ts:%" PRId64, id, vgId, now); - (void) taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); SStreamTaskState pState = streamTaskGetStatus(pTask); if (pState.state != TASK_STATUS__CK) { int32_t ref = atomic_sub_fetch_32(&pTask->status.timerActive, 1); stDebug("s-task:%s vgId:%d not in checkpoint status, quit from monitor checkpoint-trigger, ref:%d", id, vgId, ref); - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); streamMetaReleaseTask(pTask->pMeta, pTask); return; } @@ -787,14 +794,14 @@ void checkpointTriggerMonitorFn(void* param, void* tmrId) { stDebug("s-task:%s vgId:%d all checkpoint-trigger recv, quit from monitor checkpoint-trigger, ref:%d", id, vgId, ref); - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); streamMetaReleaseTask(pTask->pMeta, pTask); return; } - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); - (void) taosThreadMutexLock(&pActiveInfo->lock); + streamMutexLock(&pActiveInfo->lock); // send msg to retrieve checkpoint trigger msg SArray* pList = pTask->upstreamInfo.pList; @@ -820,19 +827,19 @@ void checkpointTriggerMonitorFn(void* param, void* tmrId) { if (!recved) { // make sure the inputQ is opened for not recv upstream checkpoint-trigger message streamTaskOpenUpstreamInput(pTask, pInfo->taskId); - taosArrayPush(pNotSendList, pInfo); + (void)taosArrayPush(pNotSendList, pInfo); } } // do send retrieve checkpoint trigger msg to upstream int32_t size = taosArrayGetSize(pNotSendList); - doSendRetrieveTriggerMsg(pTask, pNotSendList); - (void) taosThreadMutexUnlock(&pActiveInfo->lock); + (void)doSendRetrieveTriggerMsg(pTask, pNotSendList); + streamMutexUnlock(&pActiveInfo->lock); // check every 100ms if (size > 0) { stDebug("s-task:%s start to monitor checkpoint-trigger in 10s", id); - taosTmrReset(checkpointTriggerMonitorFn, 100, pTask, streamTimer, &pActiveInfo->pChkptTriggerTmr); + streamTmrReset(checkpointTriggerMonitorFn, 100, pTask, streamTimer, &pActiveInfo->pChkptTriggerTmr, vgId, "trigger-recv-monitor"); } else { int32_t ref = atomic_sub_fetch_32(&pTask->status.timerActive, 1); stDebug("s-task:%s all checkpoint-trigger recved, quit from monitor checkpoint-trigger tmr, ref:%d", id, ref); @@ -863,7 +870,7 @@ int32_t doSendRetrieveTriggerMsg(SStreamTask* pTask, SArray* pNotSendList) { SRetrieveChkptTriggerReq* pReq = rpcMallocCont(sizeof(SRetrieveChkptTriggerReq)); if (pReq == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; stError("vgId:%d failed to create msg to retrieve trigger msg for task:%s exec, code:out of memory", vgId, pId); continue; } @@ -880,11 +887,16 @@ int32_t doSendRetrieveTriggerMsg(SStreamTask* pTask, SArray* pNotSendList) { initRpcMsg(&rpcMsg, TDMT_STREAM_RETRIEVE_TRIGGER, pReq, sizeof(SRetrieveChkptTriggerReq)); code = tmsgSendReq(&pUpstreamTask->epSet, &rpcMsg); - stDebug("s-task:%s vgId:%d send checkpoint-trigger retrieve msg to 0x%x(vgId:%d) checkpointId:%" PRId64, pId, vgId, - pUpstreamTask->taskId, pUpstreamTask->nodeId, checkpointId); + if (code == TSDB_CODE_SUCCESS) { + stDebug("s-task:%s vgId:%d send checkpoint-trigger retrieve msg to 0x%x(vgId:%d) checkpointId:%" PRId64, pId, + vgId, pUpstreamTask->taskId, pUpstreamTask->nodeId, checkpointId); + } else { + stError("s-task:%s vgId:%d failed to send checkpoint-trigger retrieve msg to 0x%x(vgId:%d) checkpointId:%" PRId64, + pId, vgId, pUpstreamTask->taskId, pUpstreamTask->nodeId, checkpointId); + } } - return TSDB_CODE_SUCCESS; + return code; } bool streamTaskAlreadySendTrigger(SStreamTask* pTask, int32_t downstreamNodeId) { @@ -897,9 +909,9 @@ bool streamTaskAlreadySendTrigger(SStreamTask* pTask, int32_t downstreamNodeId) return false; } - (void) taosThreadMutexLock(&pInfo->lock); + streamMutexLock(&pInfo->lock); if (!pInfo->dispatchTrigger) { - (void) taosThreadMutexUnlock(&pInfo->lock); + streamMutexUnlock(&pTask->lock); return false; } @@ -921,7 +933,7 @@ bool streamTaskAlreadySendTrigger(SStreamTask* pTask, int32_t downstreamNodeId) id, pSendInfo->sendTs, before, pInfo->activeId, pInfo->transId); } - (void) taosThreadMutexUnlock(&pInfo->lock); + streamMutexUnlock(&pTask->lock); return true; } @@ -945,7 +957,7 @@ void streamTaskInitTriggerDispatchInfo(SStreamTask* pTask) { SActiveCheckpointInfo* pInfo = pTask->chkInfo.pActiveInfo; int64_t now = taosGetTimestampMs(); - (void) taosThreadMutexLock(&pInfo->lock); + streamMutexLock(&pInfo->lock); // outputQ should be empty here ASSERT(streamQueueGetNumOfUnAccessedItems(pTask->outputq.queue) == 0); @@ -971,21 +983,21 @@ void streamTaskInitTriggerDispatchInfo(SStreamTask* pTask) { } } - (void) taosThreadMutexUnlock(&pInfo->lock); + streamMutexUnlock(&pInfo->lock); } int32_t streamTaskGetNumOfConfirmed(SStreamTask* pTask) { SActiveCheckpointInfo* pInfo = pTask->chkInfo.pActiveInfo; int32_t num = 0; - (void) taosThreadMutexLock(&pInfo->lock); + streamMutexLock(&pInfo->lock); for (int32_t i = 0; i < taosArrayGetSize(pInfo->pDispatchTriggerList); ++i) { STaskTriggerSendInfo* p = taosArrayGet(pInfo->pDispatchTriggerList, i); if (p->recved) { num++; } } - (void) taosThreadMutexUnlock(&pInfo->lock); + streamMutexUnlock(&pInfo->lock); return num; } @@ -993,7 +1005,7 @@ void streamTaskSetTriggerDispatchConfirmed(SStreamTask* pTask, int32_t vgId) { SActiveCheckpointInfo* pInfo = pTask->chkInfo.pActiveInfo; int32_t taskId = 0; - (void) taosThreadMutexLock(&pInfo->lock); + streamMutexLock(&pInfo->lock); for (int32_t i = 0; i < taosArrayGetSize(pInfo->pDispatchTriggerList); ++i) { STaskTriggerSendInfo* p = taosArrayGet(pInfo->pDispatchTriggerList, i); @@ -1007,7 +1019,7 @@ void streamTaskSetTriggerDispatchConfirmed(SStreamTask* pTask, int32_t vgId) { } } - (void) taosThreadMutexUnlock(&pInfo->lock); + streamMutexUnlock(&pInfo->lock); int32_t numOfConfirmed = streamTaskGetNumOfConfirmed(pTask); int32_t total = streamTaskGetNumOfDownstream(pTask); @@ -1184,16 +1196,16 @@ int32_t deleteCheckpointFile(const char* id, const char* name) { int32_t streamTaskSendRestoreChkptMsg(SStreamTask* pTask) { const char* id = pTask->id.idStr; - (void) taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); if (pTask->status.sendConsensusChkptId == true) { stDebug("s-task:%s already start to consensus-checkpointId, not start again before it completed", id); - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); return TSDB_CODE_SUCCESS; } else { pTask->status.sendConsensusChkptId = true; } - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); ASSERT(pTask->pBackend == NULL); pTask->status.requireConsensusChkptId = true; @@ -1207,12 +1219,12 @@ int32_t streamTaskSendCheckpointsourceRsp(SStreamTask* pTask) { return code; } - (void) taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); SStreamTaskState p = streamTaskGetStatus(pTask); if (p.state == TASK_STATUS__CK) { code = streamTaskSendCheckpointSourceRsp(pTask); } - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); return code; } \ No newline at end of file diff --git a/source/libs/stream/src/streamData.c b/source/libs/stream/src/streamData.c index af4946cf81..c0ee503f77 100644 --- a/source/libs/stream/src/streamData.c +++ b/source/libs/stream/src/streamData.c @@ -49,7 +49,7 @@ int32_t createStreamBlockFromDispatchMsg(const SStreamDispatchReq* pReq, int32_t pInput = p; } - blockDecode(pDataBlock, pInput); + (void) blockDecode(pDataBlock, pInput); if (pRetrieve->compressed && compLen < fullLen) { taosMemoryFree(pInput); @@ -116,11 +116,11 @@ int32_t streamRetrieveReqToData(const SStreamRetrieveReq* pReq, SStreamDataBlock return terrno; } - taosArrayPush(pArray, &(SSDataBlock){0}); + (void) taosArrayPush(pArray, &(SSDataBlock){0}); SRetrieveTableRsp* pRetrieve = pReq->pRetrieve; SSDataBlock* pDataBlock = taosArrayGet(pArray, 0); - blockDecode(pDataBlock, pRetrieve->data + PAYLOAD_PREFIX_LEN); + (void) blockDecode(pDataBlock, pRetrieve->data + PAYLOAD_PREFIX_LEN); // TODO: refactor pDataBlock->info.window.skey = be64toh(pRetrieve->skey); @@ -156,28 +156,31 @@ void streamDataSubmitDestroy(SStreamDataSubmit* pDataSubmit) { taosFreeQitem(pDataSubmit); } -SStreamMergedSubmit* streamMergedSubmitNew() { - SStreamMergedSubmit* pMerged; +int32_t streamMergedSubmitNew(SStreamMergedSubmit** pSubmit) { + *pSubmit = NULL; - int32_t code = taosAllocateQitem(sizeof(SStreamMergedSubmit), DEF_QITEM, 0, (void**)&pMerged); + int32_t code = taosAllocateQitem(sizeof(SStreamMergedSubmit), DEF_QITEM, 0, (void**)pSubmit); if (code) { - terrno = code; - return NULL; + return TSDB_CODE_OUT_OF_MEMORY; } - pMerged->submits = taosArrayInit(0, sizeof(SPackedData)); - if (pMerged->submits == NULL) { - taosArrayDestroy(pMerged->submits); - taosFreeQitem(pMerged); - return NULL; + (*pSubmit)->submits = taosArrayInit(0, sizeof(SPackedData)); + if ((*pSubmit)->submits == NULL) { + taosFreeQitem(*pSubmit); + *pSubmit = NULL; + return TSDB_CODE_OUT_OF_MEMORY; } - pMerged->type = STREAM_INPUT__MERGED_SUBMIT; - return pMerged; + (*pSubmit)->type = STREAM_INPUT__MERGED_SUBMIT; + return TSDB_CODE_SUCCESS; } int32_t streamMergeSubmit(SStreamMergedSubmit* pMerged, SStreamDataSubmit* pSubmit) { - taosArrayPush(pMerged->submits, &pSubmit->submit); + void* p = taosArrayPush(pMerged->submits, &pSubmit->submit); + if (p == NULL) { + return TSDB_CODE_OUT_OF_MEMORY; + } + if (pSubmit->ver > pMerged->ver) { pMerged->ver = pSubmit->ver; } @@ -187,11 +190,12 @@ int32_t streamMergeSubmit(SStreamMergedSubmit* pMerged, SStreamDataSubmit* pSubm // todo handle memory error int32_t streamQueueMergeQueueItem(SStreamQueueItem* dst, SStreamQueueItem* pElem, SStreamQueueItem** pRes) { *pRes = NULL; + int32_t code = 0; if (dst->type == STREAM_INPUT__DATA_BLOCK && pElem->type == STREAM_INPUT__DATA_BLOCK) { SStreamDataBlock* pBlock = (SStreamDataBlock*)dst; SStreamDataBlock* pBlockSrc = (SStreamDataBlock*)pElem; - taosArrayAddAll(pBlock->blocks, pBlockSrc->blocks); + (void) taosArrayAddAll(pBlock->blocks, pBlockSrc->blocks); taosArrayDestroy(pBlockSrc->blocks); streamQueueItemIncSize(dst, streamQueueItemGetSize(pElem)); @@ -201,33 +205,38 @@ int32_t streamQueueMergeQueueItem(SStreamQueueItem* dst, SStreamQueueItem* pElem } else if (dst->type == STREAM_INPUT__MERGED_SUBMIT && pElem->type == STREAM_INPUT__DATA_SUBMIT) { SStreamMergedSubmit* pMerged = (SStreamMergedSubmit*)dst; SStreamDataSubmit* pBlockSrc = (SStreamDataSubmit*)pElem; - streamMergeSubmit(pMerged, pBlockSrc); + + code = streamMergeSubmit(pMerged, pBlockSrc); streamQueueItemIncSize(dst, streamQueueItemGetSize(pElem)); taosFreeQitem(pElem); *pRes = dst; *pRes = dst; - return TSDB_CODE_SUCCESS; + return code; } else if (dst->type == STREAM_INPUT__DATA_SUBMIT && pElem->type == STREAM_INPUT__DATA_SUBMIT) { - SStreamMergedSubmit* pMerged = streamMergedSubmitNew(); - if (pMerged == NULL) { - return TSDB_CODE_OUT_OF_MEMORY; + SStreamMergedSubmit* pMerged = NULL; + code = streamMergedSubmitNew(&pMerged); + if (code != 0) { + return code; } streamQueueItemIncSize((SStreamQueueItem*)pMerged, streamQueueItemGetSize(pElem)); - streamMergeSubmit(pMerged, (SStreamDataSubmit*)dst); - streamMergeSubmit(pMerged, (SStreamDataSubmit*)pElem); + code = streamMergeSubmit(pMerged, (SStreamDataSubmit*)dst); + if (code == 0) { + code = streamMergeSubmit(pMerged, (SStreamDataSubmit*)pElem); + } taosFreeQitem(dst); taosFreeQitem(pElem); *pRes = (SStreamQueueItem*)pMerged; - return TSDB_CODE_SUCCESS; + return code; } else { + code = TSDB_CODE_FAILED; stDebug("block type:%s not merged with existed blocks list, type:%d", streamQueueItemGetTypeStr(pElem->type), dst->type); - return TSDB_CODE_FAILED; + return code; } } diff --git a/source/libs/stream/src/streamDispatch.c b/source/libs/stream/src/streamDispatch.c index 9e4b6bc09d..4e128ace54 100644 --- a/source/libs/stream/src/streamDispatch.c +++ b/source/libs/stream/src/streamDispatch.c @@ -121,7 +121,7 @@ int32_t streamTaskBroadcastRetrieveReq(SStreamTask* pTask, SStreamRetrieveReq* r void* abuf = POINTER_SHIFT(buf, sizeof(SMsgHead)); SEncoder encoder; tEncoderInit(&encoder, abuf, len); - tEncodeStreamRetrieveReq(&encoder, req); + (void) tEncodeStreamRetrieveReq(&encoder, req); tEncoderClear(&encoder); SRpcMsg rpcMsg = {0}; @@ -189,6 +189,7 @@ int32_t streamBroadcastToUpTasks(SStreamTask* pTask, const SSDataBlock* pBlock) return code; } +// no need to do anything if failed int32_t streamSendCheckMsg(SStreamTask* pTask, const SStreamTaskCheckReq* pReq, int32_t nodeId, SEpSet* pEpSet) { void* buf = NULL; int32_t code = -1; @@ -202,7 +203,7 @@ int32_t streamSendCheckMsg(SStreamTask* pTask, const SStreamTaskCheckReq* pReq, buf = rpcMallocCont(sizeof(SMsgHead) + tlen); if (buf == NULL) { - return -1; + return TSDB_CODE_OUT_OF_MEMORY; } ((SMsgHead*)buf)->vgId = htonl(nodeId); @@ -220,8 +221,7 @@ int32_t streamSendCheckMsg(SStreamTask* pTask, const SStreamTaskCheckReq* pReq, stDebug("s-task:%s (level:%d) send check msg to s-task:0x%" PRIx64 ":0x%x (vgId:%d)", pTask->id.idStr, pTask->info.taskLevel, pReq->streamId, pReq->downstreamTaskId, nodeId); - tmsgSendReq(pEpSet, &msg); - return 0; + return tmsgSendReq(pEpSet, &msg); } void destroyDispatchMsg(SStreamDispatchReq* pReq, int32_t numOfVgroups) { @@ -239,7 +239,7 @@ void clearBufferedDispatchMsg(SStreamTask* pTask) { destroyDispatchMsg(pMsgInfo->pData, streamTaskGetNumOfDownstream(pTask)); } - taosThreadMutexLock(&pMsgInfo->lock); + streamMutexLock(&pMsgInfo->lock); pMsgInfo->checkpointId = -1; pMsgInfo->transId = -1; @@ -249,7 +249,7 @@ void clearBufferedDispatchMsg(SStreamTask* pTask) { clearDispatchInfo(pMsgInfo); taosArrayClear(pTask->msgInfo.pSendInfo); - taosThreadMutexUnlock(&pMsgInfo->lock); + streamMutexUnlock(&pMsgInfo->lock); } static SStreamDispatchReq* createDispatchDataReq(SStreamTask* pTask, const SStreamDataBlock* pData) { @@ -424,9 +424,9 @@ static int32_t sendDispatchMsg(SStreamTask* pTask, SStreamDispatchReq* pDispatch } static void setNotInDispatchMonitor(SDispatchMsgInfo* pMsgInfo) { - taosThreadMutexLock(&pMsgInfo->lock); + streamMutexLock(&pMsgInfo->lock); pMsgInfo->inMonitor = 0; - taosThreadMutexUnlock(&pMsgInfo->lock); + streamMutexUnlock(&pMsgInfo->lock); } static void setResendInfo(SDispatchEntry* pEntry, int64_t now) { @@ -440,13 +440,13 @@ static void addDispatchEntry(SDispatchMsgInfo* pMsgInfo, int32_t nodeId, int64_t SDispatchEntry entry = {.nodeId = nodeId, .rspTs = -1, .status = 0, .sendTs = now}; if (lock) { - taosThreadMutexLock(&pMsgInfo->lock); + streamMutexLock(&pMsgInfo->lock); } - taosArrayPush(pMsgInfo->pSendInfo, &entry); + (void) taosArrayPush(pMsgInfo->pSendInfo, &entry); if (lock) { - taosThreadMutexUnlock(&pMsgInfo->lock); + streamMutexUnlock(&pMsgInfo->lock); } } @@ -496,16 +496,16 @@ static void doMonitorDispatchData(void* param, void* tmrId) { return; } - taosThreadMutexLock(&pMsgInfo->lock); + streamMutexLock(&pMsgInfo->lock); if (pTask->outputq.status == TASK_OUTPUT_STATUS__NORMAL) { int32_t ref = atomic_sub_fetch_32(&pTask->status.timerActive, 1); stDebug("s-task:%s not in dispatch procedure, abort from timer, ref:%d", pTask->id.idStr, ref); pTask->msgInfo.inMonitor = 0; - taosThreadMutexUnlock(&pMsgInfo->lock); + streamMutexUnlock(&pMsgInfo->lock); return; } - taosThreadMutexUnlock(&pMsgInfo->lock); + streamMutexUnlock(&pMsgInfo->lock); int32_t numOfFailed = getFailedDispatchInfo(pMsgInfo, now); if (numOfFailed == 0) { @@ -577,8 +577,9 @@ static void doMonitorDispatchData(void* param, void* tmrId) { } void streamStartMonitorDispatchData(SStreamTask* pTask, int64_t waitDuration) { + int32_t vgId = pTask->pMeta->vgId; if (pTask->msgInfo.pRetryTmr != NULL) { - taosTmrReset(doMonitorDispatchData, waitDuration, pTask, streamTimer, &pTask->msgInfo.pRetryTmr); + streamTmrReset(doMonitorDispatchData, waitDuration, pTask, streamTimer, &pTask->msgInfo.pRetryTmr, vgId, "dispatch-monitor-tmr"); } else { pTask->msgInfo.pRetryTmr = taosTmrStart(doMonitorDispatchData, waitDuration, pTask, streamTimer); } @@ -612,7 +613,7 @@ int32_t streamSearchAndAddBlock(SStreamTask* pTask, SStreamDispatchReq* pReqs, S } } } else { - buildCtbNameByGroupIdImpl(pTask->outputInfo.shuffleDispatcher.stbFullName, groupId, pDataBlock->info.parTbName); + (void) buildCtbNameByGroupIdImpl(pTask->outputInfo.shuffleDispatcher.stbFullName, groupId, pDataBlock->info.parTbName); } snprintf(ctbName, TSDB_TABLE_NAME_LEN, "%s.%s", pTask->outputInfo.shuffleDispatcher.dbInfo.db, @@ -624,8 +625,10 @@ int32_t streamSearchAndAddBlock(SStreamTask* pTask, SStreamDispatchReq* pReqs, S SBlockName bln = {0}; bln.hashValue = hashValue; memcpy(bln.parTbName, pDataBlock->info.parTbName, strlen(pDataBlock->info.parTbName)); + + // failed to put into name buffer, no need to do anything if (tSimpleHashGetSize(pTask->pNameMap) < MAX_BLOCK_NAME_NUM) { - tSimpleHashPut(pTask->pNameMap, &groupId, sizeof(int64_t), &bln, sizeof(SBlockName)); + (void) tSimpleHashPut(pTask->pNameMap, &groupId, sizeof(int64_t), &bln, sizeof(SBlockName)); } } @@ -633,14 +636,14 @@ int32_t streamSearchAndAddBlock(SStreamTask* pTask, SStreamDispatchReq* pReqs, S int32_t numOfVgroups = taosArrayGetSize(vgInfo); // TODO: optimize search - taosThreadMutexLock(&pTask->msgInfo.lock); + streamMutexLock(&pTask->msgInfo.lock); for (int32_t j = 0; j < numOfVgroups; j++) { SVgroupInfo* pVgInfo = taosArrayGet(vgInfo, j); if (hashValue >= pVgInfo->hashBegin && hashValue <= pVgInfo->hashEnd) { if (streamAddBlockIntoDispatchMsg(pDataBlock, &pReqs[j]) < 0) { - taosThreadMutexUnlock(&pTask->msgInfo.lock); + streamMutexUnlock(&pTask->msgInfo.lock); return -1; } @@ -655,7 +658,7 @@ int32_t streamSearchAndAddBlock(SStreamTask* pTask, SStreamDispatchReq* pReqs, S } } - taosThreadMutexUnlock(&pTask->msgInfo.lock); + streamMutexUnlock(&pTask->msgInfo.lock); ASSERT(found); return 0; } @@ -690,7 +693,8 @@ int32_t streamDispatchStreamBlock(SStreamTask* pTask) { ASSERT(pTask->msgInfo.pData == NULL); stDebug("s-task:%s start to dispatch msg, set output status:%d", id, pTask->outputq.status); - SStreamDataBlock* pBlock = streamQueueNextItem(pTask->outputq.queue); + SStreamDataBlock* pBlock = NULL; + streamQueueNextItem(pTask->outputq.queue, (SStreamQueueItem**)&pBlock); if (pBlock == NULL) { atomic_store_8(&pTask->outputq.status, TASK_OUTPUT_STATUS__NORMAL); stDebug("s-task:%s not dispatch since no elems in outputQ, output status:%d", id, pTask->outputq.status); @@ -703,9 +707,9 @@ int32_t streamDispatchStreamBlock(SStreamTask* pTask) { pTask->execInfo.dispatch += 1; - taosThreadMutexLock(&pTask->msgInfo.lock); + streamMutexLock(&pTask->msgInfo.lock); initDispatchInfo(&pTask->msgInfo, pTask->execInfo.dispatch); - taosThreadMutexUnlock(&pTask->msgInfo.lock); + streamMutexUnlock(&pTask->msgInfo.lock); int32_t code = doBuildDispatchMsg(pTask, pBlock); if (code == 0) { @@ -719,7 +723,7 @@ int32_t streamDispatchStreamBlock(SStreamTask* pTask) { code = sendDispatchMsg(pTask, pTask->msgInfo.pData); - taosThreadMutexLock(&pTask->msgInfo.lock); + streamMutexLock(&pTask->msgInfo.lock); if (pTask->msgInfo.inMonitor == 0) { int32_t ref = atomic_add_fetch_32(&pTask->status.timerActive, 1); stDebug("s-task:%s start dispatch monitor tmr in %dms, ref:%d, dispatch code:%s", id, DISPATCH_RETRY_INTERVAL_MS, @@ -730,7 +734,7 @@ int32_t streamDispatchStreamBlock(SStreamTask* pTask) { stDebug("s-task:%s already in dispatch monitor tmr", id); } - taosThreadMutexUnlock(&pTask->msgInfo.lock); + streamMutexUnlock(&pTask->msgInfo.lock); // this block can not be deleted until it has been sent to downstream task successfully. return TSDB_CODE_SUCCESS; @@ -758,7 +762,7 @@ int32_t initCheckpointReadyMsg(SStreamTask* pTask, int32_t upstreamNodeId, int32 buf = rpcMallocCont(sizeof(SMsgHead) + tlen); if (buf == NULL) { - return -1; + return TSDB_CODE_OUT_OF_MEMORY; } ((SMsgHead*)buf)->vgId = htonl(req.upstreamNodeId); @@ -791,33 +795,33 @@ static void checkpointReadyMsgSendMonitorFn(void* param, void* tmrId) { SActiveCheckpointInfo* pActiveInfo = pTask->chkInfo.pActiveInfo; if (++pActiveInfo->sendReadyCheckCounter < 100) { - taosTmrReset(checkpointReadyMsgSendMonitorFn, 100, pTask, streamTimer, &pActiveInfo->pSendReadyMsgTmr); + streamTmrReset(checkpointReadyMsgSendMonitorFn, 100, pTask, streamTimer, &pActiveInfo->pSendReadyMsgTmr, vgId, "chkpt-ready-monitor"); return; } pActiveInfo->sendReadyCheckCounter = 0; stDebug("s-task:%s in sending checkpoint-ready msg monitor timer", id); - taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); SStreamTaskState pState = streamTaskGetStatus(pTask); if (pState.state != TASK_STATUS__CK) { int32_t ref = atomic_sub_fetch_32(&pTask->status.timerActive, 1); stDebug("s-task:%s vgId:%d status:%s not in checkpoint, quit from monitor checkpoint-ready send, ref:%d", id, vgId, pState.name, ref); - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); streamMetaReleaseTask(pTask->pMeta, pTask); return; } - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); - taosThreadMutexLock(&pActiveInfo->lock); + streamMutexLock(&pActiveInfo->lock); SArray* pList = pActiveInfo->pReadyMsgList; int32_t num = taosArrayGetSize(pList); // active checkpoint info is cleared for now if ((pActiveInfo->activeId == 0) && (pActiveInfo->transId == 0) && (num == 0) && (pTask->chkInfo.startTs == 0)) { - taosThreadMutexUnlock(&pActiveInfo->lock); + streamMutexUnlock(&pActiveInfo->lock); int32_t ref = atomic_sub_fetch_32(&pTask->status.timerActive, 1); stWarn("s-task:%s vgId:%d active checkpoint may be cleared, quit from readyMsg send tmr, ref:%d", id, vgId, ref); @@ -835,7 +839,7 @@ static void checkpointReadyMsgSendMonitorFn(void* param, void* tmrId) { continue; } - taosArrayPush(pNotRspList, &pInfo->upstreamTaskId); + (void) taosArrayPush(pNotRspList, &pInfo->upstreamTaskId); stDebug("s-task:%s vgId:%d level:%d checkpoint-ready rsp from upstream:0x%x not confirmed yet", id, vgId, pTask->info.taskLevel, pInfo->upstreamTaskId); } @@ -852,17 +856,25 @@ static void checkpointReadyMsgSendMonitorFn(void* param, void* tmrId) { if (taskId == pReadyInfo->upstreamTaskId) { // send msg again SRpcMsg msg = {0}; - initCheckpointReadyMsg(pTask, pReadyInfo->upstreamNodeId, pReadyInfo->upstreamTaskId, pReadyInfo->childId, + int32_t code = initCheckpointReadyMsg(pTask, pReadyInfo->upstreamNodeId, pReadyInfo->upstreamTaskId, pReadyInfo->childId, checkpointId, &msg); - tmsgSendReq(&pReadyInfo->upstreamNodeEpset, &msg); - stDebug("s-task:%s level:%d checkpoint-ready msg sent to upstream:0x%x again", id, pTask->info.taskLevel, - pReadyInfo->upstreamTaskId); + if (code == TSDB_CODE_SUCCESS) { + code = tmsgSendReq(&pReadyInfo->upstreamNodeEpset, &msg); + if (code == TSDB_CODE_SUCCESS) { + stDebug("s-task:%s level:%d checkpoint-ready msg sent to upstream:0x%x again", id, pTask->info.taskLevel, + pReadyInfo->upstreamTaskId); + } else { + stError("s-task:%s failed to send checkpoint-ready msg, try nex time in 10s", id); + } + } else { + stError("s-task:%s failed to prepare the checkpoint-ready msg, try nex time in 10s", id); + } } } } - taosTmrReset(checkpointReadyMsgSendMonitorFn, 100, pTask, streamTimer, &pActiveInfo->pSendReadyMsgTmr); - taosThreadMutexUnlock(&pActiveInfo->lock); + streamTmrReset(checkpointReadyMsgSendMonitorFn, 100, pTask, streamTimer, &pActiveInfo->pSendReadyMsgTmr, vgId, "chkpt-ready-monitor"); + streamMutexUnlock(&pActiveInfo->lock); } else { int32_t ref = atomic_sub_fetch_32(&pTask->status.timerActive, 1); stDebug( @@ -871,7 +883,7 @@ static void checkpointReadyMsgSendMonitorFn(void* param, void* tmrId) { id, vgId, ref); streamClearChkptReadyMsg(pActiveInfo); - taosThreadMutexUnlock(&pActiveInfo->lock); + streamMutexUnlock(&pActiveInfo->lock); streamMetaReleaseTask(pTask->pMeta, pTask); } @@ -883,9 +895,10 @@ int32_t streamTaskSendCheckpointReadyMsg(SStreamTask* pTask) { SActiveCheckpointInfo* pActiveInfo = pTask->chkInfo.pActiveInfo; const char* id = pTask->id.idStr; + int32_t vgId = pTask->pMeta->vgId; SArray* pList = pActiveInfo->pReadyMsgList; - taosThreadMutexLock(&pActiveInfo->lock); + streamMutexLock(&pActiveInfo->lock); int32_t num = taosArrayGetSize(pList); ASSERT(taosArrayGetSize(pTask->upstreamInfo.pList) == num); @@ -894,15 +907,22 @@ int32_t streamTaskSendCheckpointReadyMsg(SStreamTask* pTask) { STaskCheckpointReadyInfo* pInfo = taosArrayGet(pList, i); SRpcMsg msg = {0}; - initCheckpointReadyMsg(pTask, pInfo->upstreamNodeId, pInfo->upstreamTaskId, pInfo->childId, pInfo->checkpointId, + int32_t code = initCheckpointReadyMsg(pTask, pInfo->upstreamNodeId, pInfo->upstreamTaskId, pInfo->childId, pInfo->checkpointId, &msg); - tmsgSendReq(&pInfo->upstreamNodeEpset, &msg); - - stDebug("s-task:%s level:%d checkpoint-ready msg sent to upstream:0x%x", id, pTask->info.taskLevel, - pInfo->upstreamTaskId); + if (code == TSDB_CODE_SUCCESS) { + code = tmsgSendReq(&pInfo->upstreamNodeEpset, &msg); + if (code == TSDB_CODE_SUCCESS) { + stDebug("s-task:%s level:%d checkpoint-ready msg sent to upstream:0x%x", id, pTask->info.taskLevel, + pInfo->upstreamTaskId); + } else { + stError("s-task:%s failed to send checkpoint-ready msg, try nex time in 10s", id); + } + } else { + stError("s-task:%s failed to prepare the checkpoint-ready msg, try nex time in 10s", id); + } } - taosThreadMutexUnlock(&pActiveInfo->lock); + streamMutexUnlock(&pActiveInfo->lock); stDebug("s-task:%s level:%d checkpoint-ready msg sent to all %d upstreams", id, pTask->info.taskLevel, num); // start to check if checkpoint ready msg has successfully received by upstream tasks. @@ -914,7 +934,7 @@ int32_t streamTaskSendCheckpointReadyMsg(SStreamTask* pTask) { if (pActiveInfo->pSendReadyMsgTmr == NULL) { pActiveInfo->pSendReadyMsgTmr = taosTmrStart(checkpointReadyMsgSendMonitorFn, 100, pTask, streamTimer); } else { - taosTmrReset(checkpointReadyMsgSendMonitorFn, 100, pTask, streamTimer, &pActiveInfo->pSendReadyMsgTmr); + streamTmrReset(checkpointReadyMsgSendMonitorFn, 100, pTask, streamTimer, &pActiveInfo->pSendReadyMsgTmr, vgId, "chkpt-ready-monitor"); } } @@ -925,7 +945,7 @@ int32_t streamTaskSendCheckpointReadyMsg(SStreamTask* pTask) { int32_t streamTaskSendCheckpointSourceRsp(SStreamTask* pTask) { SArray* pList = pTask->chkInfo.pActiveInfo->pReadyMsgList; - taosThreadMutexLock(&pTask->chkInfo.pActiveInfo->lock); + streamMutexLock(&pTask->chkInfo.pActiveInfo->lock); ASSERT(pTask->info.taskLevel == TASK_LEVEL__SOURCE); if (taosArrayGetSize(pList) == 1) { @@ -940,7 +960,7 @@ int32_t streamTaskSendCheckpointSourceRsp(SStreamTask* pTask) { pTask->info.taskLevel); } - taosThreadMutexUnlock(&pTask->chkInfo.pActiveInfo->lock); + streamMutexUnlock(&pTask->chkInfo.pActiveInfo->lock); return TSDB_CODE_SUCCESS; } @@ -978,8 +998,8 @@ int32_t streamAddBlockIntoDispatchMsg(const SSDataBlock* pBlock, SStreamDispatch payloadLen += sizeof(SRetrieveTableRsp); - taosArrayPush(pReq->dataLen, &payloadLen); - taosArrayPush(pReq->data, &buf); + (void) taosArrayPush(pReq->dataLen, &payloadLen); + (void) taosArrayPush(pReq->data, &buf); pReq->totalLen += dataStrLen; return 0; @@ -1056,7 +1076,7 @@ int32_t streamTaskBuildCheckpointSourceRsp(SStreamCheckpointSourceReq* pReq, SRp void* abuf = POINTER_SHIFT(pBuf, sizeof(SMsgHead)); tEncoderInit(&encoder, (uint8_t*)abuf, len); - tEncodeStreamCheckpointSourceRsp(&encoder, &rsp); + (void) tEncodeStreamCheckpointSourceRsp(&encoder, &rsp); tEncoderClear(&encoder); initRpcMsg(pMsg, 0, pBuf, sizeof(SMsgHead) + len); @@ -1071,10 +1091,11 @@ int32_t streamAddCheckpointSourceRspMsg(SStreamCheckpointSourceReq* pReq, SRpcHa STaskCheckpointReadyInfo info = { .recvTs = taosGetTimestampMs(), .transId = pReq->transId, .checkpointId = pReq->checkpointId}; - streamTaskBuildCheckpointSourceRsp(pReq, pRpcInfo, &info.msg, TSDB_CODE_SUCCESS); + // todo retry until it success + (void) streamTaskBuildCheckpointSourceRsp(pReq, pRpcInfo, &info.msg, TSDB_CODE_SUCCESS); SActiveCheckpointInfo* pActiveInfo = pTask->chkInfo.pActiveInfo; - taosThreadMutexLock(&pActiveInfo->lock); + streamMutexLock(&pActiveInfo->lock); int32_t size = taosArrayGetSize(pActiveInfo->pReadyMsgList); if (size > 0) { @@ -1091,15 +1112,15 @@ int32_t streamAddCheckpointSourceRspMsg(SStreamCheckpointSourceReq* pReq, SRpcHa ASSERT(0); // failed to handle it } } else { - taosArrayPush(pActiveInfo->pReadyMsgList, &info); + (void) taosArrayPush(pActiveInfo->pReadyMsgList, &info); stDebug("s-task:%s add checkpoint source rsp msg, total:%d", pTask->id.idStr, size + 1); } - taosThreadMutexUnlock(&pActiveInfo->lock); + streamMutexUnlock(&pActiveInfo->lock); return TSDB_CODE_SUCCESS; } -int32_t initCheckpointReadyInfo(STaskCheckpointReadyInfo* pReadyInfo, int32_t upstreamNodeId, int32_t upstreamTaskId, +void initCheckpointReadyInfo(STaskCheckpointReadyInfo* pReadyInfo, int32_t upstreamNodeId, int32_t upstreamTaskId, int32_t childId, SEpSet* pEpset, int64_t checkpointId) { ASSERT(upstreamTaskId != 0); @@ -1109,8 +1130,6 @@ int32_t initCheckpointReadyInfo(STaskCheckpointReadyInfo* pReadyInfo, int32_t up pReadyInfo->recvTs = taosGetTimestampMs(); pReadyInfo->checkpointId = checkpointId; pReadyInfo->childId = childId; - - return TSDB_CODE_SUCCESS; } int32_t streamAddCheckpointReadyMsg(SStreamTask* pTask, int32_t upstreamTaskId, int32_t index, int64_t checkpointId) { @@ -1119,9 +1138,9 @@ int32_t streamAddCheckpointReadyMsg(SStreamTask* pTask, int32_t upstreamTaskId, } SStreamUpstreamEpInfo* pInfo = NULL; - int32_t code = streamTaskGetUpstreamTaskEpInfo(pTask, upstreamTaskId, &pInfo); - if (code != TSDB_CODE_SUCCESS) { - return code; + streamTaskGetUpstreamTaskEpInfo(pTask, upstreamTaskId, &pInfo); + if (pInfo == NULL) { + return TSDB_CODE_STREAM_TASK_NOT_EXIST; } STaskCheckpointReadyInfo info = {0}; @@ -1132,8 +1151,8 @@ int32_t streamAddCheckpointReadyMsg(SStreamTask* pTask, int32_t upstreamTaskId, SActiveCheckpointInfo* pActiveInfo = pTask->chkInfo.pActiveInfo; - taosThreadMutexLock(&pActiveInfo->lock); - taosArrayPush(pActiveInfo->pReadyMsgList, &info); + streamMutexLock(&pActiveInfo->lock); + (void) taosArrayPush(pActiveInfo->pReadyMsgList, &info); int32_t numOfRecv = taosArrayGetSize(pActiveInfo->pReadyMsgList); int32_t total = streamTaskGetNumOfUpstream(pTask); @@ -1145,7 +1164,7 @@ int32_t streamAddCheckpointReadyMsg(SStreamTask* pTask, int32_t upstreamTaskId, stDebug("s-task:%s %d/%d checkpoint-trigger recv", pTask->id.idStr, numOfRecv, total); } - taosThreadMutexUnlock(&pActiveInfo->lock); + streamMutexUnlock(&pActiveInfo->lock); return 0; } @@ -1187,10 +1206,8 @@ static int32_t handleDispatchSuccessRsp(SStreamTask* pTask, int32_t downstreamId if (delayDispatch) { return 0; } else { - streamDispatchStreamBlock(pTask); + return streamDispatchStreamBlock(pTask); } - - return 0; } static bool setDispatchRspInfo(SDispatchMsgInfo* pMsgInfo, int32_t vgId, int32_t code, int64_t now, int32_t* pNotRsp, const char* id) { @@ -1200,7 +1217,7 @@ static bool setDispatchRspInfo(SDispatchMsgInfo* pMsgInfo, int32_t vgId, int32_t bool allRsp = false; *pNotRsp = 0; - taosThreadMutexLock(&pMsgInfo->lock); + streamMutexLock(&pMsgInfo->lock); int32_t numOfDispatchBranch = taosArrayGetSize(pMsgInfo->pSendInfo); for(int32_t i = 0; i < numOfDispatchBranch; ++i) { @@ -1228,7 +1245,7 @@ static bool setDispatchRspInfo(SDispatchMsgInfo* pMsgInfo, int32_t vgId, int32_t *pNotRsp = numOfDispatchBranch - numOfRsp; allRsp = (numOfRsp == numOfDispatchBranch); - taosThreadMutexUnlock(&pMsgInfo->lock); + streamMutexUnlock(&pMsgInfo->lock); ASSERT(updated); return allRsp; @@ -1240,7 +1257,7 @@ bool isDispatchRspTimeout(SDispatchEntry* pEntry, int64_t now) { int32_t getFailedDispatchInfo(SDispatchMsgInfo* pMsgInfo, int64_t now) { int32_t numOfFailed = 0; - taosThreadMutexLock(&pMsgInfo->lock); + streamMutexLock(&pMsgInfo->lock); for (int32_t j = 0; j < taosArrayGetSize(pMsgInfo->pSendInfo); ++j) { SDispatchEntry* pEntry = taosArrayGet(pMsgInfo->pSendInfo, j); @@ -1248,7 +1265,7 @@ int32_t getFailedDispatchInfo(SDispatchMsgInfo* pMsgInfo, int64_t now) { numOfFailed += 1; } } - taosThreadMutexUnlock(&pMsgInfo->lock); + streamMutexUnlock(&pMsgInfo->lock); return numOfFailed; } @@ -1260,9 +1277,9 @@ int32_t streamProcessDispatchRsp(SStreamTask* pTask, SStreamDispatchRsp* pRsp, i bool allRsp = false; int32_t notRsp = 0; - taosThreadMutexLock(&pMsgInfo->lock); + streamMutexLock(&pMsgInfo->lock); int32_t msgId = pMsgInfo->msgId; - taosThreadMutexUnlock(&pMsgInfo->lock); + streamMutexUnlock(&pMsgInfo->lock); // follower not handle the dispatch rsp if ((pTask->pMeta->role == NODE_ROLE_FOLLOWER) || (pTask->status.downstreamReady != 1)) { @@ -1315,7 +1332,7 @@ int32_t streamProcessDispatchRsp(SStreamTask* pTask, SStreamDispatchRsp* pRsp, i { bool delayDispatch = (pMsgInfo->dispatchMsgType == STREAM_INPUT__CHECKPOINT_TRIGGER); if (delayDispatch) { - taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); // we only set the dispatch msg info for current checkpoint trans if (streamTaskGetStatus(pTask).state == TASK_STATUS__CK && pTask->chkInfo.pActiveInfo->activeId == pMsgInfo->checkpointId) { @@ -1329,7 +1346,7 @@ int32_t streamProcessDispatchRsp(SStreamTask* pTask, SStreamDispatchRsp* pRsp, i " transId:%d discard, since expired", pTask->id.idStr, pMsgInfo->checkpointId, pMsgInfo->transId); } - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); } } } @@ -1374,12 +1391,12 @@ int32_t streamProcessDispatchRsp(SStreamTask* pTask, SStreamDispatchRsp* pRsp, i // now ready for next data output atomic_store_8(&pTask->outputq.status, TASK_OUTPUT_STATUS__NORMAL); } else { - handleDispatchSuccessRsp(pTask, pRsp->downstreamTaskId, pRsp->downstreamNodeId); + code = handleDispatchSuccessRsp(pTask, pRsp->downstreamTaskId, pRsp->downstreamNodeId); } } } - return 0; + return code; } static int32_t buildDispatchRsp(const SStreamTask* pTask, const SStreamDispatchReq* pReq, int32_t status, void** pBuf) { @@ -1438,9 +1455,9 @@ int32_t streamProcessDispatchMsg(SStreamTask* pTask, SStreamDispatchReq* pReq, S pReq->upstreamTaskId, pReq->upstreamNodeId, pReq->totalLen, pReq->msgId); SStreamUpstreamEpInfo* pInfo = NULL; - int32_t code = streamTaskGetUpstreamTaskEpInfo(pTask, pReq->upstreamTaskId, &pInfo); - if (code != TSDB_CODE_SUCCESS) { - return code; + streamTaskGetUpstreamTaskEpInfo(pTask, pReq->upstreamTaskId, &pInfo); + if (pInfo == NULL) { + return TSDB_CODE_STREAM_TASK_NOT_EXIST; } if (pMeta->role == NODE_ROLE_FOLLOWER) { @@ -1474,7 +1491,7 @@ int32_t streamProcessDispatchMsg(SStreamTask* pTask, SStreamDispatchReq* pReq, S { // do send response with the input status - code = buildDispatchRsp(pTask, pReq, status, &pRsp->pCont); + int32_t code = buildDispatchRsp(pTask, pReq, status, &pRsp->pCont); if (code != TSDB_CODE_SUCCESS) { stError("s-task:%s failed to build dispatch rsp, msgId:%d, code:%s", id, pReq->msgId, tstrerror(code)); return code; @@ -1484,6 +1501,5 @@ int32_t streamProcessDispatchMsg(SStreamTask* pTask, SStreamDispatchReq* pReq, S tmsgSendRsp(pRsp); } - streamTrySchedExec(pTask); - return code; + return streamTrySchedExec(pTask); } diff --git a/source/libs/stream/src/streamExec.c b/source/libs/stream/src/streamExec.c index 238db27d60..d222004fb7 100644 --- a/source/libs/stream/src/streamExec.c +++ b/source/libs/stream/src/streamExec.c @@ -24,7 +24,7 @@ #define FILL_HISTORY_TASK_EXEC_INTERVAL 5000 // 5 sec static int32_t streamTransferStateDoPrepare(SStreamTask* pTask); -static int32_t streamTaskExecImpl(SStreamTask* pTask, SStreamQueueItem* pItem, int64_t* totalSize, int32_t* totalBlocks); +static void streamTaskExecImpl(SStreamTask* pTask, SStreamQueueItem* pItem, int64_t* totalSize, int32_t* totalBlocks); bool streamTaskShouldStop(const SStreamTask* pTask) { SStreamTaskState pState = streamTaskGetStatus(pTask); @@ -52,8 +52,9 @@ static int32_t doOutputResultBlockImpl(SStreamTask* pTask, SStreamDataBlock* pBl return code; } + // not handle error, if dispatch failed, try next time. // checkpoint trigger will be checked - streamDispatchStreamBlock(pTask); + (void) streamDispatchStreamBlock(pTask); } return code; @@ -90,7 +91,7 @@ static int32_t doDumpResult(SStreamTask* pTask, SStreamQueueItem* pItem, SArray* return code; } -int32_t streamTaskExecImpl(SStreamTask* pTask, SStreamQueueItem* pItem, int64_t* totalSize, int32_t* totalBlocks) { +void streamTaskExecImpl(SStreamTask* pTask, SStreamQueueItem* pItem, int64_t* totalSize, int32_t* totalBlocks) { int32_t code = TSDB_CODE_SUCCESS; void* pExecutor = pTask->exec.pExecutor; @@ -108,7 +109,7 @@ int32_t streamTaskExecImpl(SStreamTask* pTask, SStreamQueueItem* pItem, int64_t* if (streamTaskShouldStop(pTask)) { taosArrayDestroyEx(pRes, (FDelete)blockDataFreeRes); - return 0; + return; } SSDataBlock* output = NULL; @@ -128,11 +129,16 @@ int32_t streamTaskExecImpl(SStreamTask* pTask, SStreamQueueItem* pItem, int64_t* const SStreamDataBlock* pRetrieveBlock = (const SStreamDataBlock*)pItem; ASSERT(taosArrayGetSize(pRetrieveBlock->blocks) == 1); - assignOneDataBlock(&block, taosArrayGet(pRetrieveBlock->blocks, 0)); + (void) assignOneDataBlock(&block, taosArrayGet(pRetrieveBlock->blocks, 0)); block.info.type = STREAM_PULL_OVER; block.info.childId = pTask->info.selfChildId; - taosArrayPush(pRes, &block); - numOfBlocks += 1; + + void* p = taosArrayPush(pRes, &block); + if (p != NULL) { + numOfBlocks += 1; + } else { + stError("s-task:%s failed to add retrieve block", pTask->id.idStr); + } stDebug("s-task:%s(child %d) retrieve process completed, reqId:0x%" PRIx64 " dump results", pTask->id.idStr, pTask->info.selfChildId, pRetrieveBlock->reqId); @@ -151,13 +157,21 @@ int32_t streamTaskExecImpl(SStreamTask* pTask, SStreamQueueItem* pItem, int64_t* } SSDataBlock block = {0}; - assignOneDataBlock(&block, output); + code = assignOneDataBlock(&block, output); + if (code) { + stError("s-task:%s failed to build result block due to out of memory", pTask->id.idStr); + continue; + } + block.info.childId = pTask->info.selfChildId; size += blockDataGetSize(output) + sizeof(SSDataBlock) + sizeof(SColumnInfoData) * blockDataGetNumOfCols(&block); numOfBlocks += 1; - taosArrayPush(pRes, &block); + void* p = taosArrayPush(pRes, &block); + if (p == NULL) { + stError("s-task:%s failed to add computing results, the final res may be incorrect", pTask->id.idStr); + } stDebug("s-task:%s (child %d) executed and get %d result blocks, size:%.2fMiB", pTask->id.idStr, pTask->info.selfChildId, numOfBlocks, SIZE_IN_MiB(size)); @@ -166,8 +180,9 @@ int32_t streamTaskExecImpl(SStreamTask* pTask, SStreamQueueItem* pItem, int64_t* if (numOfBlocks >= STREAM_RESULT_DUMP_THRESHOLD || size >= STREAM_RESULT_DUMP_SIZE_THRESHOLD) { ASSERT(numOfBlocks == taosArrayGetSize(pRes)); code = doDumpResult(pTask, pItem, pRes, size, totalSize, totalBlocks); + // todo: here we need continue retry to put it into output buffer if (code != TSDB_CODE_SUCCESS) { - return code; + return; } pRes = NULL; @@ -182,16 +197,16 @@ int32_t streamTaskExecImpl(SStreamTask* pTask, SStreamQueueItem* pItem, int64_t* } else { taosArrayDestroyEx(pRes, (FDelete)blockDataFreeRes); } - - return code; } -static int32_t handleSanhistoryResultBlocks(SStreamTask* pTask, SArray* pRes, int32_t size) { +// todo contiuous try to create result blocks +static int32_t handleScanhistoryResultBlocks(SStreamTask* pTask, SArray* pRes, int32_t size) { int32_t code = TSDB_CODE_SUCCESS; if (taosArrayGetSize(pRes) > 0) { SStreamDataBlock* pStreamBlocks = NULL; code = createStreamBlockFromResults(NULL, pTask, size, pRes, &pStreamBlocks); if (code) { + stError("s-task:%s failed to build history result blocks", pTask->id.idStr); return code; } @@ -236,9 +251,13 @@ static void streamScanHistoryDataImpl(SStreamTask* pTask, SArray* pRes, int32_t* } SSDataBlock block = {0}; - assignOneDataBlock(&block, output); + (void) assignOneDataBlock(&block, output); block.info.childId = pTask->info.selfChildId; - taosArrayPush(pRes, &block); + + void* p = taosArrayPush(pRes, &block); + if (p == NULL) { + stError("s-task:%s failed to add computing results, the final res may be incorrect", pTask->id.idStr); + } (*pSize) += blockDataGetSize(output) + sizeof(SSDataBlock) + sizeof(SColumnInfoData) * blockDataGetNumOfCols(&block); numOfBlocks += 1; @@ -264,7 +283,7 @@ SScanhistoryDataInfo streamScanHistoryData(SStreamTask* pTask, int64_t st) { const char* id = pTask->id.idStr; if (!pTask->hTaskInfo.operatorOpen) { - qSetStreamOpOpen(exec); + (void) qSetStreamOpOpen(exec); pTask->hTaskInfo.operatorOpen = true; } @@ -301,8 +320,8 @@ SScanhistoryDataInfo streamScanHistoryData(SStreamTask* pTask, int64_t st) { return buildScanhistoryExecRet(TASK_SCANHISTORY_QUIT, 0); } - // dispatch the generated results - /*int32_t code = */handleSanhistoryResultBlocks(pTask, pRes, size); + // dispatch the generated results, todo fix error + (void) handleScanhistoryResultBlocks(pTask, pRes, size); if (finished) { return buildScanhistoryExecRet(TASK_SCANHISTORY_CONT, 0); @@ -323,14 +342,15 @@ int32_t streamTransferStateDoPrepare(SStreamTask* pTask) { SStreamTask* pStreamTask = NULL; int32_t code = streamMetaAcquireTask(pMeta, pTask->streamTaskId.streamId, pTask->streamTaskId.taskId, &pStreamTask); - if (pStreamTask == NULL) { + if (pStreamTask == NULL || code != TSDB_CODE_SUCCESS) { stError( "s-task:%s failed to find related stream task:0x%x, it may have been destroyed or closed, destroy the related " "fill-history task", id, (int32_t) pTask->streamTaskId.taskId); // 1. free it and remove fill-history task from disk meta-store - streamBuildAndSendDropTaskMsg(pTask->pMsgCb, pMeta->vgId, &pTask->id, 0); + // todo: this function should never be failed. + (void) streamBuildAndSendDropTaskMsg(pTask->pMsgCb, pMeta->vgId, &pTask->id, 0); // 2. save to disk streamMetaWLock(pMeta); @@ -388,14 +408,14 @@ int32_t streamTransferStateDoPrepare(SStreamTask* pTask) { pStreamTask->id.idStr, TASK_LEVEL__SOURCE, pTimeWindow->skey, pTimeWindow->ekey, INT64_MIN, pTimeWindow->ekey, p, pStreamTask->status.schedStatus); - streamTaskResetTimewindowFilter(pStreamTask); + (void) streamTaskResetTimewindowFilter(pStreamTask); } else { stDebug("s-task:%s no need to update/reset filter time window for non-source tasks", pStreamTask->id.idStr); } // NOTE: transfer the ownership of executor state before handle the checkpoint block during stream exec // 2. send msg to mnode to launch a checkpoint to keep the state for current stream - streamTaskSendCheckpointReq(pStreamTask); + (void) streamTaskSendCheckpointReq(pStreamTask); // 3. assign the status to the value that will be kept in disk pStreamTask->status.taskStatus = streamTaskGetStatus(pStreamTask).state; @@ -409,7 +429,7 @@ int32_t streamTransferStateDoPrepare(SStreamTask* pTask) { static int32_t haltCallback(SStreamTask* pTask, void* param) { streamTaskOpenAllUpstreamInput(pTask); - streamTaskSendCheckpointReq(pTask); + (void) streamTaskSendCheckpointReq(pTask); return TSDB_CODE_SUCCESS; } @@ -445,18 +465,19 @@ int32_t streamTransferStatePrepare(SStreamTask* pTask) { } // set input -static void doSetStreamInputBlock(SStreamTask* pTask, const void* pInput, int64_t* pVer, const char* id) { +static int32_t doSetStreamInputBlock(SStreamTask* pTask, const void* pInput, int64_t* pVer, const char* id) { void* pExecutor = pTask->exec.pExecutor; + int32_t code = 0; const SStreamQueueItem* pItem = pInput; if (pItem->type == STREAM_INPUT__GET_RES) { const SStreamTrigger* pTrigger = (const SStreamTrigger*)pInput; - qSetMultiStreamInput(pExecutor, pTrigger->pBlock, 1, STREAM_INPUT__DATA_BLOCK); + code = qSetMultiStreamInput(pExecutor, pTrigger->pBlock, 1, STREAM_INPUT__DATA_BLOCK); } else if (pItem->type == STREAM_INPUT__DATA_SUBMIT) { ASSERT(pTask->info.taskLevel == TASK_LEVEL__SOURCE); const SStreamDataSubmit* pSubmit = (const SStreamDataSubmit*)pInput; - qSetMultiStreamInput(pExecutor, &pSubmit->submit, 1, STREAM_INPUT__DATA_SUBMIT); + code = qSetMultiStreamInput(pExecutor, &pSubmit->submit, 1, STREAM_INPUT__DATA_SUBMIT); stDebug("s-task:%s set submit blocks as source block completed, %p %p len:%d ver:%" PRId64, id, pSubmit, pSubmit->submit.msgStr, pSubmit->submit.msgLen, pSubmit->submit.ver); ASSERT((*pVer) <= pSubmit->submit.ver); @@ -468,7 +489,7 @@ static void doSetStreamInputBlock(SStreamTask* pTask, const void* pInput, int64_ SArray* pBlockList = pBlock->blocks; int32_t numOfBlocks = taosArrayGetSize(pBlockList); stDebug("s-task:%s set sdata blocks as input num:%d, ver:%" PRId64, id, numOfBlocks, pBlock->sourceVer); - qSetMultiStreamInput(pExecutor, pBlockList->pData, numOfBlocks, STREAM_INPUT__DATA_BLOCK); + code = qSetMultiStreamInput(pExecutor, pBlockList->pData, numOfBlocks, STREAM_INPUT__DATA_BLOCK); } else if (pItem->type == STREAM_INPUT__MERGED_SUBMIT) { const SStreamMergedSubmit* pMerged = (const SStreamMergedSubmit*)pInput; @@ -477,24 +498,26 @@ static void doSetStreamInputBlock(SStreamTask* pTask, const void* pInput, int64_ int32_t numOfBlocks = taosArrayGetSize(pBlockList); stDebug("s-task:%s %p set (merged) submit blocks as a batch, numOfBlocks:%d, ver:%" PRId64, id, pTask, numOfBlocks, pMerged->ver); - qSetMultiStreamInput(pExecutor, pBlockList->pData, numOfBlocks, STREAM_INPUT__MERGED_SUBMIT); + code = qSetMultiStreamInput(pExecutor, pBlockList->pData, numOfBlocks, STREAM_INPUT__MERGED_SUBMIT); ASSERT((*pVer) <= pMerged->ver); (*pVer) = pMerged->ver; } else if (pItem->type == STREAM_INPUT__REF_DATA_BLOCK) { const SStreamRefDataBlock* pRefBlock = (const SStreamRefDataBlock*)pInput; - qSetMultiStreamInput(pExecutor, pRefBlock->pBlock, 1, STREAM_INPUT__DATA_BLOCK); + code = qSetMultiStreamInput(pExecutor, pRefBlock->pBlock, 1, STREAM_INPUT__DATA_BLOCK); } else if (pItem->type == STREAM_INPUT__CHECKPOINT || pItem->type == STREAM_INPUT__CHECKPOINT_TRIGGER) { const SStreamDataBlock* pCheckpoint = (const SStreamDataBlock*)pInput; - qSetMultiStreamInput(pExecutor, pCheckpoint->blocks, 1, pItem->type); + code = qSetMultiStreamInput(pExecutor, pCheckpoint->blocks, 1, pItem->type); } else { ASSERT(0); } + + return code; } -int32_t streamProcessTransstateBlock(SStreamTask* pTask, SStreamDataBlock* pBlock) { +void streamProcessTransstateBlock(SStreamTask* pTask, SStreamDataBlock* pBlock) { const char* id = pTask->id.idStr; int32_t code = TSDB_CODE_SUCCESS; int32_t level = pTask->info.taskLevel; @@ -505,7 +528,7 @@ int32_t streamProcessTransstateBlock(SStreamTask* pTask, SStreamDataBlock* pBloc if (remain > 0) { streamFreeQitem((SStreamQueueItem*)pBlock); stDebug("s-task:%s receive upstream trans-state msg, not sent remain:%d", id, remain); - return 0; + return; } } @@ -526,7 +549,7 @@ int32_t streamProcessTransstateBlock(SStreamTask* pTask, SStreamDataBlock* pBloc pBlock->srcVgId = pTask->pMeta->vgId; code = taosWriteQitem(pTask->outputq.queue->pQueue, pBlock); if (code == 0) { - streamDispatchStreamBlock(pTask); + (void) streamDispatchStreamBlock(pTask); } else { // todo put into queue failed, retry streamFreeQitem((SStreamQueueItem*)pBlock); } @@ -540,11 +563,9 @@ int32_t streamProcessTransstateBlock(SStreamTask* pTask, SStreamDataBlock* pBloc code = streamTransferStatePrepare(pTask); if (code != TSDB_CODE_SUCCESS) { - /*int8_t status = */ streamTaskSetSchedStatusInactive(pTask); + (void)streamTaskSetSchedStatusInactive(pTask); } } - - return code; } //static void streamTaskSetIdleInfo(SStreamTask* pTask, int32_t idleTime) { pTask->status.schedIdleTime = idleTime; } @@ -559,7 +580,11 @@ static void doStreamTaskExecImpl(SStreamTask* pTask, SStreamQueueItem* pBlock, i stDebug("s-task:%s start to process batch blocks, num:%d, type:%s", id, num, streamQueueItemGetTypeStr(pBlock->type)); - doSetStreamInputBlock(pTask, pBlock, &ver, id); + int32_t code = doSetStreamInputBlock(pTask, pBlock, &ver, id); + if(code) { + stError("s-task:%s failed to set input block, not exec for these blocks", id); + return; + } int64_t totalSize = 0; int32_t totalBlocks = 0; @@ -601,9 +626,9 @@ void flushStateDataInExecutor(SStreamTask* pTask, SStreamQueueItem* pCheckpointB STaskId* pHTaskId = &pTask->hTaskInfo.id; SStreamTask* pHTask = NULL; int32_t code = streamMetaAcquireTask(pTask->pMeta, pHTaskId->streamId, pHTaskId->taskId, &pHTask); - if (pHTask != NULL) { - streamTaskReleaseState(pHTask); - streamTaskReloadState(pTask); + if (code == TSDB_CODE_SUCCESS) { // ignore the error code. + (void) streamTaskReleaseState(pHTask); + (void) streamTaskReloadState(pTask); stDebug("s-task:%s transfer state from fill-history task:%s, status:%s completed", id, pHTask->id.idStr, streamTaskGetStatus(pHTask).name); @@ -676,7 +701,7 @@ static int32_t doStreamExecTask(SStreamTask* pTask) { // dispatch checkpoint msg to all downstream tasks int32_t type = pInput->type; if (type == STREAM_INPUT__CHECKPOINT_TRIGGER) { - streamProcessCheckpointTriggerBlock(pTask, (SStreamDataBlock*)pInput); + (void) streamProcessCheckpointTriggerBlock(pTask, (SStreamDataBlock*)pInput); continue; } @@ -694,7 +719,10 @@ static int32_t doStreamExecTask(SStreamTask* pTask) { if (type == STREAM_INPUT__DATA_BLOCK) { pTask->execInfo.sink.dataSize += blockSize; stDebug("s-task:%s sink task start to sink %d blocks, size:%.2fKiB", id, numOfBlocks, SIZE_IN_KiB(blockSize)); - doOutputResultBlockImpl(pTask, (SStreamDataBlock*)pInput); + int32_t code = doOutputResultBlockImpl(pTask, (SStreamDataBlock*)pInput); + if (code != TSDB_CODE_SUCCESS) { + // todo handle error. + } double el = (taosGetTimestampMs() - st) / 1000.0; if (fabs(el - 0.0) <= DBL_EPSILON) { @@ -712,11 +740,11 @@ static int32_t doStreamExecTask(SStreamTask* pTask) { streamFreeQitem(pInput); } else { // todo other thread may change the status // do nothing after sync executor state to storage backend, untill the vnode-level checkpoint is completed. - taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); SStreamTaskState pState = streamTaskGetStatus(pTask); if (pState.state == TASK_STATUS__CK) { stDebug("s-task:%s checkpoint block received, set status:%s", id, pState.name); - streamTaskBuildCheckpoint(pTask); + (void) streamTaskBuildCheckpoint(pTask); // ignore this error msg, and continue } else { // todo refactor int32_t code = 0; if (pTask->info.taskLevel == TASK_LEVEL__SOURCE) { @@ -732,7 +760,7 @@ static int32_t doStreamExecTask(SStreamTask* pTask) { } } - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); streamFreeQitem(pInput); return 0; } @@ -765,21 +793,21 @@ bool streamTaskReadyToRun(const SStreamTask* pTask, char** pStatus) { } } -int32_t streamResumeTask(SStreamTask* pTask) { +void streamResumeTask(SStreamTask* pTask) { ASSERT(pTask->status.schedStatus == TASK_SCHED_STATUS__ACTIVE); const char* id = pTask->id.idStr; while (1) { - /*int32_t code = */ doStreamExecTask(pTask); + (void) doStreamExecTask(pTask); // check if continue - taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); int32_t numOfItems = streamQueueGetNumOfItems(pTask->inputq.queue); if ((numOfItems == 0) || streamTaskShouldStop(pTask) || streamTaskShouldPause(pTask)) { atomic_store_8(&pTask->status.schedStatus, TASK_SCHED_STATUS__INACTIVE); streamTaskClearSchedIdleInfo(pTask); - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); setLastExecTs(pTask, taosGetTimestampMs()); @@ -787,19 +815,19 @@ int32_t streamResumeTask(SStreamTask* pTask) { stDebug("s-task:%s exec completed, status:%s, sched-status:%d, lastExecTs:%" PRId64, id, p, pTask->status.schedStatus, pTask->status.lastExecTs); - return 0; + return; } else { // check if this task needs to be idle for a while if (pTask->status.schedIdleTime > 0) { streamTaskResumeInFuture(pTask); - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); setLastExecTs(pTask, taosGetTimestampMs()); - return 0; + return; } } - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); } } diff --git a/source/libs/stream/src/streamHb.c b/source/libs/stream/src/streamHb.c index 4aaaed615c..9804943ec2 100644 --- a/source/libs/stream/src/streamHb.c +++ b/source/libs/stream/src/streamHb.c @@ -54,7 +54,7 @@ static bool existInHbMsg(SStreamHbMsg* pMsg, SDownstreamTaskEpset* pTaskEpset) { static void addUpdateNodeIntoHbMsg(SStreamTask* pTask, SStreamHbMsg* pMsg) { SStreamMeta* pMeta = pTask->pMeta; - (void) taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); int32_t num = taosArrayGetSize(pTask->outputInfo.pNodeEpsetUpdateList); for (int j = 0; j < num; ++j) { @@ -73,7 +73,7 @@ static void addUpdateNodeIntoHbMsg(SStreamTask* pTask, SStreamHbMsg* pMsg) { } taosArrayClear(pTask->outputInfo.pNodeEpsetUpdateList); - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); } static int32_t doSendHbMsgInfo(SStreamHbMsg* pMsg, SStreamMeta* pMeta, SEpSet* pEpset) { @@ -170,9 +170,9 @@ int32_t streamMetaSendHbHelper(SStreamMeta* pMeta) { continue; } - (void) taosThreadMutexLock(&(*pTask)->lock); + streamMutexLock(&(*pTask)->lock); STaskStatusEntry entry = streamTaskGetStatusEntry(*pTask); - (void) taosThreadMutexUnlock(&(*pTask)->lock); + streamMutexUnlock(&(*pTask)->lock); entry.inputRate = entry.inputQUsed * 100.0 / (2 * STREAM_TASK_QUEUE_CAPACITY_IN_SIZE); if ((*pTask)->info.taskLevel == TASK_LEVEL__SINK) { @@ -190,9 +190,9 @@ int32_t streamMetaSendHbHelper(SStreamMeta* pMeta) { stInfo("s-task:%s set kill checkpoint trans in hbMsg, transId:%d, clear the active checkpointInfo", (*pTask)->id.idStr, p->transId); - (void) taosThreadMutexLock(&(*pTask)->lock); + streamMutexLock(&(*pTask)->lock); streamTaskClearCheckInfo((*pTask), true); - (void) taosThreadMutexUnlock(&(*pTask)->lock); + streamMutexUnlock(&(*pTask)->lock); } } diff --git a/source/libs/stream/src/streamMeta.c b/source/libs/stream/src/streamMeta.c index b48c90be16..42d2f86dac 100644 --- a/source/libs/stream/src/streamMeta.c +++ b/source/libs/stream/src/streamMeta.c @@ -57,10 +57,13 @@ static void streamMetaEnvInit() { streamMetaId = taosOpenRef(64, streamMetaCloseImpl); metaRefMgtInit(); - streamTimerInit(); + int32_t code = streamTimerInit(); + if (code != 0) { + stError("failed to init stream meta env, start failed"); + } } -void streamMetaInit() { taosThreadOnce(&streamMetaModuleInit, streamMetaEnvInit); } +void streamMetaInit() { (void) taosThreadOnce(&streamMetaModuleInit, streamMetaEnvInit); } void streamMetaCleanup() { taosCloseRef(streamBackendId); @@ -89,11 +92,11 @@ void metaRefMgtCleanup() { } taosHashCleanup(gMetaRefMgt.pTable); - taosThreadMutexDestroy(&gMetaRefMgt.mutex); + streamMutexDestroy(&gMetaRefMgt.mutex); } int32_t metaRefMgtAdd(int64_t vgId, int64_t* rid) { - taosThreadMutexLock(&gMetaRefMgt.mutex); + streamMutexLock(&gMetaRefMgt.mutex); void* p = taosHashGet(gMetaRefMgt.pTable, &vgId, sizeof(vgId)); if (p == NULL) { @@ -105,7 +108,7 @@ int32_t metaRefMgtAdd(int64_t vgId, int64_t* rid) { taosArrayPush(list, &rid); } - taosThreadMutexUnlock(&gMetaRefMgt.mutex); + streamMutexUnlock(&gMetaRefMgt.mutex); return 0; } @@ -238,7 +241,7 @@ int32_t streamMetaMayCvtDbFormat(SStreamMeta* pMeta) { int32_t streamTaskSetDb(SStreamMeta* pMeta, SStreamTask* pTask, const char* key) { int64_t chkpId = pTask->chkInfo.checkpointId; - taosThreadMutexLock(&pMeta->backendMutex); + streamMutexLock(&pMeta->backendMutex); void** ppBackend = taosHashGet(pMeta->pTaskDbUnique, key, strlen(key)); if ((ppBackend != NULL) && (*ppBackend != NULL)) { taskDbAddRef(*ppBackend); @@ -247,7 +250,7 @@ int32_t streamTaskSetDb(SStreamMeta* pMeta, SStreamTask* pTask, const char* key) pBackend->pMeta = pMeta; pTask->pBackend = pBackend; - taosThreadMutexUnlock(&pMeta->backendMutex); + streamMutexUnlock(&pMeta->backendMutex); stDebug("s-task:0x%x set backend %p", pTask->id.taskId, pBackend); return 0; } @@ -260,11 +263,11 @@ int32_t streamTaskSetDb(SStreamMeta* pMeta, SStreamTask* pTask, const char* key) break; } - taosThreadMutexUnlock(&pMeta->backendMutex); + streamMutexUnlock(&pMeta->backendMutex); taosMsleep(1000); stDebug("backend held by other task, restart later, path:%s, key:%s", pMeta->path, key); - taosThreadMutexLock(&pMeta->backendMutex); + streamMutexLock(&pMeta->backendMutex); } int64_t tref = taosAddRef(taskDbWrapperId, pBackend); @@ -276,7 +279,7 @@ int32_t streamTaskSetDb(SStreamMeta* pMeta, SStreamTask* pTask, const char* key) if (processVer != -1) pTask->chkInfo.processedVer = processVer; taosHashPut(pMeta->pTaskDbUnique, key, strlen(key), &pBackend, sizeof(void*)); - taosThreadMutexUnlock(&pMeta->backendMutex); + streamMutexUnlock(&pMeta->backendMutex); stDebug("s-task:0x%x set backend %p", pTask->id.taskId, pBackend); return 0; @@ -286,10 +289,10 @@ void streamMetaRemoveDB(void* arg, char* key) { if (arg == NULL || key == NULL) return; SStreamMeta* pMeta = arg; - taosThreadMutexLock(&pMeta->backendMutex); + streamMutexLock(&pMeta->backendMutex); taosHashRemove(pMeta->pTaskDbUnique, key, strlen(key)); - taosThreadMutexUnlock(&pMeta->backendMutex); + streamMutexUnlock(&pMeta->backendMutex); } int32_t streamMetaOpen(const char* path, void* ahandle, FTaskBuild buildTaskFn, FTaskExpand expandTaskFn, int32_t vgId, @@ -541,7 +544,7 @@ void streamMetaCloseImpl(void* arg) { pMeta->pHbInfo = NULL; taosMemoryFree(pMeta->path); - taosThreadMutexDestroy(&pMeta->backendMutex); + streamMutexDestroy(&pMeta->backendMutex); taosCleanUpScheduler(pMeta->qHandle); taosMemoryFree(pMeta->qHandle); @@ -1132,7 +1135,7 @@ int32_t streamMetaSendMsgBeforeCloseTasks(SStreamMeta* pMeta, SArray** pList) { continue; } - taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); SStreamTaskState pState = streamTaskGetStatus(pTask); if (pState.state == TASK_STATUS__CK) { @@ -1141,7 +1144,7 @@ int32_t streamMetaSendMsgBeforeCloseTasks(SStreamMeta* pMeta, SArray** pList) { stDebug("s-task:%s status:%s not reset the checkpoint", pTask->id.idStr, pState.name); } - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); streamMetaReleaseTask(pMeta, pTask); } @@ -1271,7 +1274,7 @@ int32_t streamMetaStartAllTasks(SStreamMeta* pMeta) { streamLaunchFillHistoryTask(pTask); } - streamMetaAddTaskLaunchResult(pMeta, pTaskId->streamId, pTaskId->taskId, pInfo->checkTs, pInfo->readyTs, true); + (void) streamMetaAddTaskLaunchResult(pMeta, pTaskId->streamId, pTaskId->taskId, pInfo->checkTs, pInfo->readyTs, true); streamMetaReleaseTask(pMeta, pTask); continue; } @@ -1388,16 +1391,16 @@ int32_t streamMetaStartOneTask(SStreamMeta* pMeta, int64_t streamId, int32_t tas ASSERT(pTask->status.downstreamReady == 0); // avoid initialization and destroy running concurrently. - taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); if (pTask->pBackend == NULL) { code = pMeta->expandTaskFn(pTask); - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); if (code != TSDB_CODE_SUCCESS) { streamMetaAddFailedTaskSelf(pTask, pInfo->readyTs); } } else { - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); } if (code == TSDB_CODE_SUCCESS) { @@ -1440,7 +1443,6 @@ int32_t streamMetaAddTaskLaunchResult(SStreamMeta* pMeta, int64_t streamId, int3 STaskId id = {.streamId = streamId, .taskId = taskId}; streamMetaWLock(pMeta); - SStreamTask** p = taosHashGet(pMeta->pTasksMap, &id, sizeof(id)); if (p == NULL) { // task does not exists in current vnode, not record the complete info stError("vgId:%d s-task:0x%x not exists discard the check downstream info", pMeta->vgId, taskId); @@ -1449,9 +1451,9 @@ int32_t streamMetaAddTaskLaunchResult(SStreamMeta* pMeta, int64_t streamId, int3 } // clear the send consensus-checkpointId flag - taosThreadMutexLock(&(*p)->lock); + streamMutexLock(&(*p)->lock); (*p)->status.sendConsensusChkptId = false; - taosThreadMutexUnlock(&(*p)->lock); + streamMutexUnlock(&(*p)->lock); if (pStartInfo->startAllTasks != 1) { int64_t el = endTs - startTs; @@ -1537,9 +1539,9 @@ int32_t streamMetaAddFailedTask(SStreamMeta* pMeta, int64_t streamId, int32_t ta streamMetaRUnLock(pMeta); // add the failed task info, along with the related fill-history task info into tasks list. - streamMetaAddTaskLaunchResult(pMeta, streamId, taskId, startTs, now, false); + (void) streamMetaAddTaskLaunchResult(pMeta, streamId, taskId, startTs, now, false); if (hasFillhistoryTask) { - streamMetaAddTaskLaunchResult(pMeta, hId.streamId, hId.taskId, startTs, now, false); + (void) streamMetaAddTaskLaunchResult(pMeta, hId.streamId, hId.taskId, startTs, now, false); } } else { streamMetaRUnLock(pMeta); @@ -1554,12 +1556,12 @@ int32_t streamMetaAddFailedTask(SStreamMeta* pMeta, int64_t streamId, int32_t ta void streamMetaAddFailedTaskSelf(SStreamTask* pTask, int64_t failedTs) { int32_t startTs = pTask->execInfo.checkTs; - streamMetaAddTaskLaunchResult(pTask->pMeta, pTask->id.streamId, pTask->id.taskId, startTs, failedTs, false); + (void) streamMetaAddTaskLaunchResult(pTask->pMeta, pTask->id.streamId, pTask->id.taskId, startTs, failedTs, false); // automatically set the related fill-history task to be failed. if (HAS_RELATED_FILLHISTORY_TASK(pTask)) { STaskId* pId = &pTask->hTaskInfo.id; - streamMetaAddTaskLaunchResult(pTask->pMeta, pId->streamId, pId->taskId, startTs, failedTs, false); + (void) streamMetaAddTaskLaunchResult(pTask->pMeta, pId->streamId, pId->taskId, startTs, failedTs, false); } } diff --git a/source/libs/stream/src/streamQueue.c b/source/libs/stream/src/streamQueue.c index b8cdcd4cf5..537062b04e 100644 --- a/source/libs/stream/src/streamQueue.c +++ b/source/libs/stream/src/streamQueue.c @@ -27,20 +27,24 @@ typedef struct SQueueReader { int32_t waitDuration; // maximum wait time to format several block into a batch to process, unit: ms } SQueueReader; +#define streamQueueCurItem(_q) ((_q)->qItem) + static bool streamTaskExtractAvailableToken(STokenBucket* pBucket, const char* id); static void streamTaskPutbackToken(STokenBucket* pBucket); static void streamTaskConsumeQuota(STokenBucket* pBucket, int32_t bytes); static void streamQueueCleanup(SStreamQueue* pQueue) { - void* qItem = NULL; - while ((qItem = streamQueueNextItem(pQueue)) != NULL) { + SStreamQueueItem* qItem = NULL; + while (1) { + streamQueueNextItem(pQueue, &qItem); + if (qItem == NULL) { + break; + } streamFreeQitem(qItem); } pQueue->status = STREAM_QUEUE__SUCESS; } -static void* streamQueueCurItem(SStreamQueue* queue) { return queue->qItem; } - int32_t streamQueueOpen(int64_t cap, SStreamQueue** pQ) { *pQ = NULL; int32_t code = 0; @@ -81,21 +85,22 @@ void streamQueueClose(SStreamQueue* pQueue, int32_t taskId) { taosMemoryFree(pQueue); } -void* streamQueueNextItem(SStreamQueue* pQueue) { +void streamQueueNextItem(SStreamQueue* pQueue, SStreamQueueItem** pItem) { + *pItem = NULL; int8_t flag = atomic_exchange_8(&pQueue->status, STREAM_QUEUE__PROCESSING); if (flag == STREAM_QUEUE__FAILED) { ASSERT(pQueue->qItem != NULL); - return streamQueueCurItem(pQueue); + *pItem = streamQueueCurItem(pQueue); } else { pQueue->qItem = NULL; - taosGetQitem(pQueue->qall, &pQueue->qItem); + (void) taosGetQitem(pQueue->qall, &pQueue->qItem); if (pQueue->qItem == NULL) { - taosReadAllQitems(pQueue->pQueue, pQueue->qall); - taosGetQitem(pQueue->qall, &pQueue->qItem); + (void) taosReadAllQitems(pQueue->pQueue, pQueue->qall); + (void) taosGetQitem(pQueue->qall, &pQueue->qItem); } - return streamQueueCurItem(pQueue); + *pItem = streamQueueCurItem(pQueue); } } @@ -181,7 +186,8 @@ EExtractDataCode streamTaskGetDataFromInputQ(SStreamTask* pTask, SStreamQueueIte return EXEC_CONTINUE; } - SStreamQueueItem* qItem = streamQueueNextItem(pTask->inputq.queue); + SStreamQueueItem* qItem = NULL; + streamQueueNextItem(pTask->inputq.queue, (SStreamQueueItem**)&qItem); if (qItem == NULL) { // restore the token to bucket if (*numOfBlocks > 0) { @@ -338,7 +344,8 @@ int32_t streamTaskPutDataIntoInputQ(SStreamTask* pTask, SStreamQueueItem* pItem) if (type != STREAM_INPUT__GET_RES && type != STREAM_INPUT__CHECKPOINT && type != STREAM_INPUT__CHECKPOINT_TRIGGER && (pTask->info.delaySchedParam != 0)) { - atomic_val_compare_exchange_8(&pTask->schedInfo.status, TASK_TRIGGER_STATUS__INACTIVE, TASK_TRIGGER_STATUS__ACTIVE); + (void)atomic_val_compare_exchange_8(&pTask->schedInfo.status, TASK_TRIGGER_STATUS__INACTIVE, + TASK_TRIGGER_STATUS__ACTIVE); stDebug("s-task:%s new data arrived, active the sched-trigger, triggerStatus:%d", pTask->id.idStr, pTask->schedInfo.status); } @@ -347,18 +354,19 @@ int32_t streamTaskPutDataIntoInputQ(SStreamTask* pTask, SStreamQueueItem* pItem) } int32_t streamTaskPutTranstateIntoInputQ(SStreamTask* pTask) { - int32_t code; - SStreamDataBlock* pTranstate; + int32_t code = 0; + SStreamDataBlock* pTranstate = NULL; + SSDataBlock* pBlock = NULL; code = taosAllocateQitem(sizeof(SStreamDataBlock), DEF_QITEM, sizeof(SSDataBlock), (void**)&pTranstate); if (code) { return code; } - SSDataBlock* pBlock = taosMemoryCalloc(1, sizeof(SSDataBlock)); + pBlock = taosMemoryCalloc(1, sizeof(SSDataBlock)); if (pBlock == NULL) { - taosFreeQitem(pTranstate); - return TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; + goto _err; } pTranstate->type = STREAM_INPUT__TRANS_STATE; @@ -368,15 +376,30 @@ int32_t streamTaskPutTranstateIntoInputQ(SStreamTask* pTask) { pBlock->info.childId = pTask->info.selfChildId; pTranstate->blocks = taosArrayInit(4, sizeof(SSDataBlock)); // pBlock; - taosArrayPush(pTranstate->blocks, pBlock); + if (pTranstate->blocks == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _err; + } + + void* p = taosArrayPush(pTranstate->blocks, pBlock); + if (p == NULL) { + code = TSDB_CODE_OUT_OF_MEMORY; + goto _err; + } taosMemoryFree(pBlock); if (streamTaskPutDataIntoInputQ(pTask, (SStreamQueueItem*)pTranstate) < 0) { - return TSDB_CODE_OUT_OF_MEMORY; + code = TSDB_CODE_OUT_OF_MEMORY; + goto _err; } pTask->status.appendTranstateBlock = true; return TSDB_CODE_SUCCESS; + +_err: + taosMemoryFree(pBlock); + taosFreeQitem(pTranstate); + return code; } // the result should be put into the outputQ in any cases, the result may be lost otherwise. diff --git a/source/libs/stream/src/streamSched.c b/source/libs/stream/src/streamSched.c index f11b135168..74f370d199 100644 --- a/source/libs/stream/src/streamSched.c +++ b/source/libs/stream/src/streamSched.c @@ -36,7 +36,7 @@ int32_t streamSetupScheduleTrigger(SStreamTask* pTask) { int32_t streamTrySchedExec(SStreamTask* pTask) { if (streamTaskSetSchedStatusWait(pTask)) { - streamTaskSchedTask(pTask->pMsgCb, pTask->info.nodeId, pTask->id.streamId, pTask->id.taskId, 0); + return streamTaskSchedTask(pTask->pMsgCb, pTask->info.nodeId, pTask->id.streamId, pTask->id.taskId, 0); } else { stTrace("s-task:%s not launch task since sched status:%d", pTask->id.idStr, pTask->status.schedStatus); } @@ -47,10 +47,9 @@ int32_t streamTrySchedExec(SStreamTask* pTask) { int32_t streamTaskSchedTask(SMsgCb* pMsgCb, int32_t vgId, int64_t streamId, int32_t taskId, int32_t execType) { SStreamTaskRunReq* pRunReq = rpcMallocCont(sizeof(SStreamTaskRunReq)); if (pRunReq == NULL) { - terrno = TSDB_CODE_OUT_OF_MEMORY; stError("vgId:%d failed to create msg to start stream task:0x%x exec, type:%d, code:%s", vgId, taskId, execType, terrstr()); - return -1; + return TSDB_CODE_OUT_OF_MEMORY; } if (streamId != 0) { @@ -65,29 +64,27 @@ int32_t streamTaskSchedTask(SMsgCb* pMsgCb, int32_t vgId, int64_t streamId, int3 pRunReq->reqType = execType; SRpcMsg msg = {.msgType = TDMT_STREAM_TASK_RUN, .pCont = pRunReq, .contLen = sizeof(SStreamTaskRunReq)}; - tmsgPutToQueue(pMsgCb, STREAM_QUEUE, &msg); - return TSDB_CODE_SUCCESS; + return tmsgPutToQueue(pMsgCb, STREAM_QUEUE, &msg); } void streamTaskClearSchedIdleInfo(SStreamTask* pTask) { pTask->status.schedIdleTime = 0; } void streamTaskSetIdleInfo(SStreamTask* pTask, int32_t idleTime) { pTask->status.schedIdleTime = idleTime; } -int32_t streamTaskResumeInFuture(SStreamTask* pTask) { +void streamTaskResumeInFuture(SStreamTask* pTask) { int32_t ref = atomic_add_fetch_32(&pTask->status.timerActive, 1); stDebug("s-task:%s task should idle, add into timer to retry in %dms, ref:%d", pTask->id.idStr, pTask->status.schedIdleTime, ref); // add one ref count for task - /*SStreamTask* pAddRefTask = */ streamMetaAcquireOneTask(pTask); + streamMetaAcquireOneTask(pTask); if (pTask->schedInfo.pIdleTimer == NULL) { pTask->schedInfo.pIdleTimer = taosTmrStart(streamTaskResumeHelper, pTask->status.schedIdleTime, pTask, streamTimer); } else { - taosTmrReset(streamTaskResumeHelper, pTask->status.schedIdleTime, pTask, streamTimer, &pTask->schedInfo.pIdleTimer); + streamTmrReset(streamTaskResumeHelper, pTask->status.schedIdleTime, pTask, streamTimer, + &pTask->schedInfo.pIdleTimer, pTask->pMeta->vgId, "resume-task-tmr"); } - - return TSDB_CODE_SUCCESS; } ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// @@ -97,7 +94,7 @@ void streamTaskResumeHelper(void* param, void* tmrId) { SStreamTaskState p = streamTaskGetStatus(pTask); if (p.state == TASK_STATUS__DROPPING || p.state == TASK_STATUS__STOP) { - streamTaskSetSchedStatusInactive(pTask); + (void) streamTaskSetSchedStatusInactive(pTask); int32_t ref = atomic_sub_fetch_32(&pTask->status.timerActive, 1); stDebug("s-task:%s status:%s not resume task, ref:%d", pId->idStr, p.name, ref); @@ -106,21 +103,25 @@ void streamTaskResumeHelper(void* param, void* tmrId) { return; } - streamTaskSchedTask(pTask->pMsgCb, pTask->info.nodeId, pId->streamId, pId->taskId, STREAM_EXEC_T_RESUME_TASK); + int32_t code = streamTaskSchedTask(pTask->pMsgCb, pTask->info.nodeId, pId->streamId, pId->taskId, STREAM_EXEC_T_RESUME_TASK); + if (code) { + stError("s-task:%s sched task failed, code:%s", pTask->id.idStr, strerror(code)); + } else { + int32_t ref = atomic_sub_fetch_32(&pTask->status.timerActive, 1); + stDebug("trigger to resume s-task:%s after being idled for %dms, ref:%d", pId->idStr, pTask->status.schedIdleTime, + ref); - int32_t ref = atomic_sub_fetch_32(&pTask->status.timerActive, 1); - stDebug("trigger to resume s-task:%s after being idled for %dms, ref:%d", pId->idStr, pTask->status.schedIdleTime, - ref); - - // release the task ref count - streamTaskClearSchedIdleInfo(pTask); - streamMetaReleaseTask(pTask->pMeta, pTask); + // release the task ref count + streamTaskClearSchedIdleInfo(pTask); + streamMetaReleaseTask(pTask->pMeta, pTask); + } } void streamTaskSchedHelper(void* param, void* tmrId) { SStreamTask* pTask = (void*)param; const char* id = pTask->id.idStr; int32_t nextTrigger = (int32_t)pTask->info.delaySchedParam; + int32_t vgId = pTask->pMeta->vgId; int8_t status = atomic_load_8(&pTask->schedInfo.status); stTrace("s-task:%s in scheduler, trigger status:%d, next:%dms", id, status, nextTrigger); @@ -140,7 +141,7 @@ void streamTaskSchedHelper(void* param, void* tmrId) { if (code) { stError("s-task:%s failed to prepare retrieve data trigger, code:%s, try again in %dms", id, "out of memory", nextTrigger); - taosTmrReset(streamTaskSchedHelper, nextTrigger, pTask, streamTimer, &pTask->schedInfo.pDelayTimer); + streamTmrReset(streamTaskSchedHelper, nextTrigger, pTask, streamTimer, &pTask->schedInfo.pDelayTimer, vgId, "sched-run-tmr"); terrno = code; return; } @@ -152,7 +153,7 @@ void streamTaskSchedHelper(void* param, void* tmrId) { stError("s-task:%s failed to prepare retrieve data trigger, code:%s, try again in %dms", id, "out of memory", nextTrigger); - taosTmrReset(streamTaskSchedHelper, nextTrigger, pTask, streamTimer, &pTask->schedInfo.pDelayTimer); + streamTmrReset(streamTaskSchedHelper, nextTrigger, pTask, streamTimer, &pTask->schedInfo.pDelayTimer, vgId, "sched-run-tmr"); return; } @@ -161,13 +162,16 @@ void streamTaskSchedHelper(void* param, void* tmrId) { code = streamTaskPutDataIntoInputQ(pTask, (SStreamQueueItem*)pTrigger); if (code != TSDB_CODE_SUCCESS) { - taosTmrReset(streamTaskSchedHelper, nextTrigger, pTask, streamTimer, &pTask->schedInfo.pDelayTimer); + streamTmrReset(streamTaskSchedHelper, nextTrigger, pTask, streamTimer, &pTask->schedInfo.pDelayTimer, vgId, "sched-run-tmr"); return; } - streamTrySchedExec(pTask); + code = streamTrySchedExec(pTask); + if (code != TSDB_CODE_SUCCESS) { + stError("s-task:%s failed to sched to run, wait for next time", pTask->id.idStr); + } } } - taosTmrReset(streamTaskSchedHelper, nextTrigger, pTask, streamTimer, &pTask->schedInfo.pDelayTimer); + streamTmrReset(streamTaskSchedHelper, nextTrigger, pTask, streamTimer, &pTask->schedInfo.pDelayTimer, vgId, "sched-run-tmr"); } diff --git a/source/libs/stream/src/streamStartHistory.c b/source/libs/stream/src/streamStartHistory.c index 3c7ad2639a..1efb2af381 100644 --- a/source/libs/stream/src/streamStartHistory.c +++ b/source/libs/stream/src/streamStartHistory.c @@ -212,7 +212,7 @@ int32_t streamLaunchFillHistoryTask(SStreamTask* pTask) { stDebug("s-task:%s not launch related fill-history task:0x%" PRIx64 "-0x%x, status:%s", idStr, hStreamId, hTaskId, pStatus.name); - streamMetaAddTaskLaunchResult(pMeta, hStreamId, hTaskId, pExecInfo->checkTs, pExecInfo->readyTs, false); + (void) streamMetaAddTaskLaunchResult(pMeta, hStreamId, hTaskId, pExecInfo->checkTs, pExecInfo->readyTs, false); return -1; // todo set the correct error code } @@ -228,11 +228,11 @@ int32_t streamLaunchFillHistoryTask(SStreamTask* pTask) { code = streamMetaAcquireTask(pMeta, hStreamId, hTaskId, &pHisTask); if (pHisTask == NULL) { stDebug("s-task:%s failed acquire and start fill-history task, it may have been dropped/stopped", idStr); - streamMetaAddTaskLaunchResult(pMeta, hStreamId, hTaskId, pExecInfo->checkTs, pExecInfo->readyTs, false); + (void) streamMetaAddTaskLaunchResult(pMeta, hStreamId, hTaskId, pExecInfo->checkTs, pExecInfo->readyTs, false); } else { if (pHisTask->status.downstreamReady == 1) { // it's ready now, do nothing stDebug("s-task:%s fill-history task is ready, no need to check downstream", pHisTask->id.idStr); - streamMetaAddTaskLaunchResult(pMeta, hStreamId, hTaskId, pExecInfo->checkTs, pExecInfo->readyTs, true); + (void) streamMetaAddTaskLaunchResult(pMeta, hStreamId, hTaskId, pExecInfo->checkTs, pExecInfo->readyTs, true); } else { // exist, but not ready, continue check downstream task status if (pHisTask->pBackend == NULL) { code = pMeta->expandTaskFn(pHisTask); @@ -289,7 +289,7 @@ void notRetryLaunchFillHistoryTask(SStreamTask* pTask, SLaunchHTaskInfo* pInfo, SHistoryTaskInfo* pHTaskInfo = &pTask->hTaskInfo; int32_t ref = atomic_sub_fetch_32(&pTask->status.timerActive, 1); - streamMetaAddTaskLaunchResult(pMeta, pInfo->hTaskId.streamId, pInfo->hTaskId.taskId, 0, now, false); + (void) streamMetaAddTaskLaunchResult(pMeta, pInfo->hTaskId.streamId, pInfo->hTaskId.taskId, 0, now, false); stError("s-task:%s max retry:%d reached, quit from retrying launch related fill-history task:0x%x, ref:%d", pTask->id.idStr, MAX_RETRY_LAUNCH_HISTORY_TASK, (int32_t)pHTaskInfo->id.taskId, ref); @@ -307,7 +307,7 @@ void doRetryLaunchFillHistoryTask(SStreamTask* pTask, SLaunchHTaskInfo* pInfo, i stDebug("s-task:0x%" PRIx64 " stopped, not launch rel history task:0x%" PRIx64 ", ref:%d", pInfo->id.taskId, pInfo->hTaskId.taskId, ref); - streamMetaAddTaskLaunchResult(pMeta, pInfo->hTaskId.streamId, pInfo->hTaskId.taskId, 0, now, false); + (void) streamMetaAddTaskLaunchResult(pMeta, pInfo->hTaskId.streamId, pInfo->hTaskId.taskId, 0, now, false); taosMemoryFree(pInfo); } else { char* p = streamTaskGetStatus(pTask).name; @@ -350,7 +350,7 @@ void tryLaunchHistoryTask(void* param, void* tmrId) { streamMetaWUnLock(pMeta); // record the related fill-history task failed - streamMetaAddTaskLaunchResult(pMeta, pInfo->hTaskId.streamId, pInfo->hTaskId.taskId, 0, now, false); + (void) streamMetaAddTaskLaunchResult(pMeta, pInfo->hTaskId.streamId, pInfo->hTaskId.taskId, 0, now, false); taosMemoryFree(pInfo); return; } @@ -407,7 +407,7 @@ void tryLaunchHistoryTask(void* param, void* tmrId) { streamMetaReleaseTask(pMeta, pTask); } else { - streamMetaAddTaskLaunchResult(pMeta, pInfo->hTaskId.streamId, pInfo->hTaskId.taskId, 0, now, false); + (void) streamMetaAddTaskLaunchResult(pMeta, pInfo->hTaskId.streamId, pInfo->hTaskId.taskId, 0, now, false); int32_t ref = atomic_sub_fetch_32(&(*ppTask)->status.timerActive, 1); stError("s-task:0x%x rel fill-history task:0x%" PRIx64 " may have been destroyed, not launch, ref:%d", @@ -448,7 +448,7 @@ int32_t launchNotBuiltFillHistoryTask(SStreamTask* pTask) { SLaunchHTaskInfo* pInfo = createHTaskLaunchInfo(pMeta, &id, hStreamId, hTaskId); if (pInfo == NULL) { stError("s-task:%s failed to launch related fill-history task, since Out Of Memory", idStr); - streamMetaAddTaskLaunchResult(pMeta, hStreamId, hTaskId, pExecInfo->checkTs, pExecInfo->readyTs, false); + (void) streamMetaAddTaskLaunchResult(pMeta, hStreamId, hTaskId, pExecInfo->checkTs, pExecInfo->readyTs, false); return terrno; } @@ -465,7 +465,7 @@ int32_t launchNotBuiltFillHistoryTask(SStreamTask* pTask) { stError("s-task:%s failed to start timer, related fill-history task not launched, ref:%d", idStr, ref); taosMemoryFree(pInfo); - streamMetaAddTaskLaunchResult(pMeta, hStreamId, hTaskId, pExecInfo->checkTs, pExecInfo->readyTs, false); + (void) streamMetaAddTaskLaunchResult(pMeta, hStreamId, hTaskId, pExecInfo->checkTs, pExecInfo->readyTs, false); return terrno; } diff --git a/source/libs/stream/src/streamTask.c b/source/libs/stream/src/streamTask.c index 39e12a9da7..7c2d0b3556 100644 --- a/source/libs/stream/src/streamTask.c +++ b/source/libs/stream/src/streamTask.c @@ -197,13 +197,13 @@ void tFreeStreamTask(SStreamTask* pTask) { STaskExecStatisInfo* pStatis = &pTask->execInfo; ETaskStatus status1 = TASK_STATUS__UNINIT; - taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); if (pTask->status.pSM != NULL) { SStreamTaskState pStatus = streamTaskGetStatus(pTask); p = pStatus.name; status1 = pStatus.state; } - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); stDebug("start to free s-task:0x%x %p, state:%s", taskId, pTask, p); @@ -284,11 +284,11 @@ void tFreeStreamTask(SStreamTask* pTask) { streamTaskDestroyUpstreamInfo(&pTask->upstreamInfo); taosMemoryFree(pTask->outputInfo.pTokenBucket); - taosThreadMutexDestroy(&pTask->lock); + streamMutexDestroy(&pTask->lock); taosArrayDestroy(pTask->msgInfo.pSendInfo); pTask->msgInfo.pSendInfo = NULL; - taosThreadMutexDestroy(&pTask->msgInfo.lock); + streamMutexDestroy(&pTask->msgInfo.lock); taosArrayDestroy(pTask->outputInfo.pNodeEpsetUpdateList); pTask->outputInfo.pNodeEpsetUpdateList = NULL; @@ -644,11 +644,7 @@ void streamTaskOpenAllUpstreamInput(SStreamTask* pTask) { void streamTaskCloseUpstreamInput(SStreamTask* pTask, int32_t taskId) { SStreamUpstreamEpInfo* pInfo = NULL; - - int32_t code = streamTaskGetUpstreamTaskEpInfo(pTask, taskId, &pInfo); - if (code != TSDB_CODE_SUCCESS) { - return; - } + streamTaskGetUpstreamTaskEpInfo(pTask, taskId, &pInfo); if ((pInfo != NULL) && pInfo->dataAllowed) { pInfo->dataAllowed = false; @@ -659,11 +655,7 @@ void streamTaskCloseUpstreamInput(SStreamTask* pTask, int32_t taskId) { void streamTaskOpenUpstreamInput(SStreamTask* pTask, int32_t taskId) { SStreamUpstreamEpInfo* pInfo = NULL; - - int32_t code = streamTaskGetUpstreamTaskEpInfo(pTask, taskId, &pInfo); - if (code != TSDB_CODE_SUCCESS) { - return; - } + streamTaskGetUpstreamTaskEpInfo(pTask, taskId, &pInfo); if (pInfo != NULL && (!pInfo->dataAllowed)) { int32_t t = atomic_sub_fetch_32(&pTask->upstreamInfo.numOfClosed, 1); @@ -679,34 +671,34 @@ bool streamTaskIsAllUpstreamClosed(SStreamTask* pTask) { bool streamTaskSetSchedStatusWait(SStreamTask* pTask) { bool ret = false; - taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); if (pTask->status.schedStatus == TASK_SCHED_STATUS__INACTIVE) { pTask->status.schedStatus = TASK_SCHED_STATUS__WAITING; ret = true; } - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); return ret; } int8_t streamTaskSetSchedStatusActive(SStreamTask* pTask) { - taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); int8_t status = pTask->status.schedStatus; if (status == TASK_SCHED_STATUS__WAITING) { pTask->status.schedStatus = TASK_SCHED_STATUS__ACTIVE; } - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); return status; } int8_t streamTaskSetSchedStatusInactive(SStreamTask* pTask) { - taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); int8_t status = pTask->status.schedStatus; ASSERT(status == TASK_SCHED_STATUS__WAITING || status == TASK_SCHED_STATUS__ACTIVE || status == TASK_SCHED_STATUS__INACTIVE); pTask->status.schedStatus = TASK_SCHED_STATUS__INACTIVE; - taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); return status; } @@ -723,7 +715,7 @@ int32_t streamTaskClearHTaskAttr(SStreamTask* pTask, int32_t resetRelHalt) { stDebug("s-task:%s clear the related stream task:0x%x attr to fill-history task", pTask->id.idStr, (int32_t)sTaskId.taskId); - taosThreadMutexLock(&(*ppStreamTask)->lock); + streamMutexLock(&(*ppStreamTask)->lock); CLEAR_RELATED_FILLHISTORY_TASK((*ppStreamTask)); if (resetRelHalt) { @@ -734,7 +726,7 @@ int32_t streamTaskClearHTaskAttr(SStreamTask* pTask, int32_t resetRelHalt) { } streamMetaSaveTask(pMeta, *ppStreamTask); - taosThreadMutexUnlock(&(*ppStreamTask)->lock); + streamMutexUnlock(&(*ppStreamTask)->lock); } return TSDB_CODE_SUCCESS; @@ -923,6 +915,7 @@ void streamTaskResume(SStreamTask* pTask) { bool streamTaskIsSinkTask(const SStreamTask* pTask) { return pTask->info.taskLevel == TASK_LEVEL__SINK; } +// this task must success int32_t streamTaskSendCheckpointReq(SStreamTask* pTask) { int32_t code; int32_t tlen = 0; @@ -960,24 +953,23 @@ int32_t streamTaskSendCheckpointReq(SStreamTask* pTask) { return 0; } -int32_t streamTaskGetUpstreamTaskEpInfo(SStreamTask* pTask, int32_t taskId, SStreamUpstreamEpInfo** pEpInfo) { +void streamTaskGetUpstreamTaskEpInfo(SStreamTask* pTask, int32_t taskId, SStreamUpstreamEpInfo** pEpInfo) { *pEpInfo = NULL; int32_t num = taosArrayGetSize(pTask->upstreamInfo.pList); for (int32_t i = 0; i < num; ++i) { SStreamUpstreamEpInfo* pInfo = taosArrayGetP(pTask->upstreamInfo.pList, i); if (pInfo == NULL) { - return TSDB_CODE_FAILED; + return; } if (pInfo->taskId == taskId) { *pEpInfo = pInfo; - return TSDB_CODE_SUCCESS; + return; } } stError("s-task:%s failed to find upstream task:0x%x", pTask->id.idStr, taskId); - return TSDB_CODE_FAILED; } SEpSet* streamTaskGetDownstreamEpInfo(SStreamTask* pTask, int32_t taskId) { @@ -1100,7 +1092,7 @@ void streamTaskDestroyActiveChkptInfo(SActiveCheckpointInfo* pInfo) { return; } - taosThreadMutexDestroy(&pInfo->lock); + streamMutexDestroy(&pInfo->lock); taosArrayDestroy(pInfo->pDispatchTriggerList); pInfo->pDispatchTriggerList = NULL; taosArrayDestroy(pInfo->pReadyMsgList); diff --git a/source/libs/stream/src/streamTaskSm.c b/source/libs/stream/src/streamTaskSm.c index 7e47857a39..c3e0df52d4 100644 --- a/source/libs/stream/src/streamTaskSm.c +++ b/source/libs/stream/src/streamTaskSm.c @@ -201,7 +201,7 @@ static int32_t doHandleWaitingEvent(SStreamTaskSM* pSM, const char* pEventName, pSM->pActiveTrans = pNextTrans; pSM->startTs = taosGetTimestampMs(); - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); code = pNextTrans->pAction(pSM->pTask); if (pNextTrans->autoInvokeEndFn) { @@ -210,7 +210,7 @@ static int32_t doHandleWaitingEvent(SStreamTaskSM* pSM, const char* pEventName, return code; } } else { - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); stDebug("s-task:%s state:%s event:%s in waiting list, req state:%s not fulfilled, put it back", pTask->id.idStr, pSM->current.name, GET_EVT_NAME(pEvtInfo->event), StreamTaskStatusList[pEvtInfo->status].name); @@ -247,7 +247,7 @@ int32_t streamTaskRestoreStatus(SStreamTask* pTask) { SStreamTaskSM* pSM = pTask->status.pSM; int32_t code = 0; - (void) taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); if (pSM->current.state == TASK_STATUS__PAUSE && pSM->pActiveTrans == NULL) { SStreamTaskState state = pSM->current; @@ -326,13 +326,13 @@ static int32_t doHandleEvent(SStreamTaskSM* pSM, EStreamTaskEvent event, STaskSt return code; } - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); while (1) { // wait for the task to be here - (void) taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); ETaskStatus s = streamTaskGetStatus(pTask).state; - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); if ((s == pTrans->next.state) && (pSM->prev.evt == pTrans->event)) {// this event has been handled already stDebug("s-task:%s attached event:%s handled", id, GET_EVT_NAME(pTrans->event)); @@ -349,7 +349,7 @@ static int32_t doHandleEvent(SStreamTaskSM* pSM, EStreamTaskEvent event, STaskSt } else { // override current active trans pSM->pActiveTrans = pTrans; pSM->startTs = taosGetTimestampMs(); - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); code = pTrans->pAction(pTask); @@ -374,11 +374,11 @@ static int32_t doHandleEventAsync(SStreamTaskSM* pSM, EStreamTaskEvent event, ST info.callBackFn = callbackFn; code = attachWaitedEvent(pTask, &info); - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); } else { // override current active trans pSM->pActiveTrans = pTrans; pSM->startTs = taosGetTimestampMs(); - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); code = pTrans->pAction(pTask); // todo handle error code; @@ -400,11 +400,11 @@ int32_t streamTaskHandleEvent(SStreamTaskSM* pSM, EStreamTaskEvent event) { STaskStateTrans* pTrans = NULL; while (1) { - (void) taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); if (pSM->pActiveTrans != NULL && pSM->pActiveTrans->autoInvokeEndFn) { EStreamTaskEvent evt = pSM->pActiveTrans->event; - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); stDebug("s-task:%s status:%s handling event:%s by some other thread, wait for 100ms and check if completed", pTask->id.idStr, pSM->current.name, GET_EVT_NAME(evt)); @@ -414,7 +414,7 @@ int32_t streamTaskHandleEvent(SStreamTaskSM* pSM, EStreamTaskEvent event) { pTrans = streamTaskFindTransform(pSM->current.state, event); if (pTrans == NULL) { stDebug("s-task:%s failed to handle event:%s", pTask->id.idStr, GET_EVT_NAME(event)); - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); return TSDB_CODE_STREAM_INVALID_STATETRANS; } @@ -439,11 +439,11 @@ int32_t streamTaskHandleEventAsync(SStreamTaskSM* pSM, EStreamTaskEvent event, _ STaskStateTrans* pTrans = NULL; while (1) { - (void) taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); if (pSM->pActiveTrans != NULL && pSM->pActiveTrans->autoInvokeEndFn) { EStreamTaskEvent evt = pSM->pActiveTrans->event; - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); stDebug("s-task:%s status:%s handling event:%s by some other thread, wait for 100ms and check if completed", pTask->id.idStr, pSM->current.name, GET_EVT_NAME(evt)); @@ -453,7 +453,7 @@ int32_t streamTaskHandleEventAsync(SStreamTaskSM* pSM, EStreamTaskEvent event, _ pTrans = streamTaskFindTransform(pSM->current.state, event); if (pTrans == NULL) { stDebug("s-task:%s failed to handle event:%s, status:%s", pTask->id.idStr, GET_EVT_NAME(event), pSM->current.name); - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); return TSDB_CODE_STREAM_INVALID_STATETRANS; } @@ -485,7 +485,7 @@ int32_t streamTaskOnHandleEventSuccess(SStreamTaskSM* pSM, EStreamTaskEvent even int32_t code = 0; // do update the task status - (void) taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); STaskStateTrans* pTrans = pSM->pActiveTrans; if (pTrans == NULL) { @@ -497,14 +497,14 @@ int32_t streamTaskOnHandleEventSuccess(SStreamTaskSM* pSM, EStreamTaskEvent even stDebug("s-task:%s event:%s handled failed, current status:%s, trigger event:%s", id, GET_EVT_NAME(event), pSM->current.name, GET_EVT_NAME(pSM->prev.evt)); - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); return TSDB_CODE_STREAM_INVALID_STATETRANS; } if (pTrans->event != event) { stWarn("s-task:%s handle event:%s failed, current status:%s, active trans evt:%s", id, GET_EVT_NAME(event), pSM->current.name, GET_EVT_NAME(pTrans->event)); - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); return TSDB_CODE_STREAM_INVALID_STATETRANS; } @@ -518,7 +518,7 @@ int32_t streamTaskOnHandleEventSuccess(SStreamTaskSM* pSM, EStreamTaskEvent even // on success callback, add into lock if necessary, or maybe we should add an option for this? code = pTrans->pSuccAction(pTask); - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); // todo: add parameter to control lock // after handling the callback function assigned by invoker, go on handling the waiting tasks @@ -532,13 +532,13 @@ int32_t streamTaskOnHandleEventSuccess(SStreamTaskSM* pSM, EStreamTaskEvent even stDebug("s-task:%s handle user-specified callback fn for event:%s completed", id, GET_EVT_NAME(pTrans->event)); } - (void) taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); // tasks in waiting list if (taosArrayGetSize(pSM->pWaitingEventList) > 0) { code = doHandleWaitingEvent(pSM, GET_EVT_NAME(pTrans->event), pTask); } else { - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); int64_t el = (taosGetTimestampMs() - pSM->startTs); stDebug("s-task:%s handle event:%s completed, elapsed time:%" PRId64 "ms state:%s -> %s", id, @@ -563,14 +563,14 @@ const char* streamTaskGetStatusStr(ETaskStatus status) { void streamTaskResetStatus(SStreamTask* pTask) { SStreamTaskSM* pSM = pTask->status.pSM; - (void) taosThreadMutexLock(&pTask->lock); + streamMutexLock(&pTask->lock); stDebug("s-task:%s level:%d fill-history:%d vgId:%d set uninit, prev status:%s", pTask->id.idStr, pTask->info.taskLevel, pTask->info.fillHistory, pTask->pMeta->vgId, pSM->current.name); pSM->current = StreamTaskStatusList[TASK_STATUS__UNINIT]; pSM->pActiveTrans = NULL; taosArrayClear(pSM->pWaitingEventList); - (void) taosThreadMutexUnlock(&pTask->lock); + streamMutexUnlock(&pTask->lock); // clear the downstream ready status pTask->status.downstreamReady = 0; diff --git a/source/libs/stream/src/streamTimer.c b/source/libs/stream/src/streamTimer.c index c76ec92e33..931de397cc 100644 --- a/source/libs/stream/src/streamTimer.c +++ b/source/libs/stream/src/streamTimer.c @@ -41,11 +41,11 @@ tmr_h streamTimerGetInstance() { void streamTmrReset(TAOS_TMR_CALLBACK fp, int32_t mseconds, void* param, void* handle, tmr_h* pTmrId, int32_t vgId, const char* pMsg) { - while (1) { +// while (1) { bool ret = taosTmrReset(fp, mseconds, param, handle, pTmrId); if (ret) { - break; +// break; } - stError("vgId:%d failed to reset %s, try again", vgId, pMsg); - } +// stError("vgId:%d failed to reset tmr: %s, try again", vgId, pMsg); +// } } diff --git a/source/libs/stream/src/streamUtil.c b/source/libs/stream/src/streamUtil.c new file mode 100644 index 0000000000..44c6adce5f --- /dev/null +++ b/source/libs/stream/src/streamUtil.c @@ -0,0 +1,26 @@ +/* + * Copyright (c) 2019 TAOS Data, Inc. + * + * This program is free software: you can use, redistribute, and/or modify + * it under the terms of the GNU Affero General Public License, version 3 + * or later ("AGPL"), as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ + +#include "streamInt.h" + +void streamMutexLock(TdThreadMutex *pMutex) { + (void) taosThreadMutexLock(pMutex); +} + +void streamMutexUnlock(TdThreadMutex *pMutex) { + (void) taosThreadMutexUnlock(pMutex); +} + +void streamMutexDestroy(TdThreadMutex *pMutex) { (void) taosThreadMutexDestroy(pMutex); } diff --git a/source/util/src/terror.c b/source/util/src/terror.c index 4543e746a1..990c84371f 100644 --- a/source/util/src/terror.c +++ b/source/util/src/terror.c @@ -471,6 +471,7 @@ TAOS_DEFINE_ERROR(TSDB_CODE_QRY_GEO_NOT_SUPPORT_ERROR, "Geometry not support TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INVALID_WINDOW_CONDITION, "The time pseudo column is illegally used in the condition of the event window.") TAOS_DEFINE_ERROR(TSDB_CODE_QRY_EXECUTOR_INTERNAL_ERROR, "Executor internal error") TAOS_DEFINE_ERROR(TSDB_CODE_QRY_INVALID_JOIN_CONDITION, "Not supported join on condition") +TAOS_DEFINE_ERROR(TSDB_CODE_QRY_FILTER_NOT_SUPPORT_TYPE, "Not supported range type") // grant TAOS_DEFINE_ERROR(TSDB_CODE_GRANT_EXPIRED, "License expired")