xxq250
/
homework-jianmu
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

enh: refactor return code

This commit is contained in:
Hongze Cheng 2024-07-19 14:36:02 +08:00
parent 90e4d16fcc
commit aa064abb47
8 changed files with 156 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
source/os/src/osMemory.c
View File

@ -266,7 +266,11 @@ void *taosMemoryMalloc(int64_t size) {
return (char *)tmp + sizeof(TdMemoryInfo);
#else
return malloc(size);
void *p = malloc(size);
if (!p) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
}
return p;
#endif
}
@ -283,7 +287,11 @@ void *taosMemoryCalloc(int64_t num, int64_t size) {
return (char *)tmp + sizeof(TdMemoryInfo);
#else
return calloc(num, size);
void *p = calloc(num, size);
if (!p) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
}
return p;
#endif
}
@ -309,7 +317,11 @@ void *taosMemoryRealloc(void *ptr, int64_t size) {
return (char *)tmp + sizeof(TdMemoryInfo);
#else
return realloc(ptr, size);
void *p = realloc(ptr, size);
if (!p) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
}
return p;
#endif
}

69
source/util/src/tarray.c
View File

@ -18,9 +18,9 @@
#include "tcoding.h"
// todo refactor API
#define BOUNDARY_SIZE 1024*1024*1024 // 1G
#define BOUNDARY_SIZE 1024 * 1024 * 1024 // 1G
#define BOUNDARY_SMALL_FACTOR 1.2
#define BOUNDARY_BIG_FACTOR 2
#define BOUNDARY_BIG_FACTOR 2
SArray* taosArrayInit(size_t size, size_t elemSize) {
if (elemSize == 0) {
@ -34,12 +34,14 @@ SArray* taosArrayInit(size_t size, size_t elemSize) {
SArray* pArray = taosMemoryMalloc(sizeof(SArray));
if (pArray == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
pArray->size = 0;
pArray->pData = taosMemoryCalloc(size, elemSize);
if (pArray->pData == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
taosMemoryFree(pArray);
return NULL;
}
@ -75,7 +77,7 @@ static int32_t taosArrayResize(SArray* pArray) {
void* tmp = taosMemoryRealloc(pArray->pData, size * pArray->elemSize);
if (tmp == NULL) { // reallocate failed, the original buffer remains
return -1;
return TSDB_CODE_OUT_OF_MEMORY;
}
pArray->pData = tmp;
@ -99,7 +101,7 @@ int32_t taosArrayEnsureCap(SArray* pArray, size_t newCap) {
pArray->pData = taosMemoryRealloc(pArray->pData, tsize * pArray->elemSize);
if (pArray->pData == NULL) {
return -1;
return TSDB_CODE_OUT_OF_MEMORY;
}
pArray->capacity = tsize;
@ -109,10 +111,13 @@ int32_t taosArrayEnsureCap(SArray* pArray, size_t newCap) {
void* taosArrayAddBatch(SArray* pArray, const void* pData, int32_t nEles) {
if (pData == NULL) {
terrno = TSDB_CODE_INVALID_PARA;
return NULL;
}
if (taosArrayEnsureCap(pArray, pArray->size + nEles) != 0) {
int32_t code = taosArrayEnsureCap(pArray, pArray->size + nEles);
if (code) {
terrno = code;
return NULL;
}
@ -166,12 +171,15 @@ void* taosArrayAddAll(SArray* pArray, const SArray* pInput) {
if (pInput) {
return taosArrayAddBatch(pArray, pInput->pData, (int32_t)taosArrayGetSize(pInput));
} else {
terrno = TSDB_CODE_INVALID_PARA;
return NULL;
}
}
void* taosArrayReserve(SArray* pArray, int32_t num) {
if (taosArrayEnsureCap(pArray, pArray->size + num) != 0) {
int32_t code = taosArrayEnsureCap(pArray, pArray->size + num);
if (code) {
terrno = code;
return NULL;
}
@ -194,11 +202,13 @@ void* taosArrayPop(SArray* pArray) {
void* taosArrayGet(const SArray* pArray, size_t index) {
if (NULL == pArray) {
terrno = TSDB_CODE_INVALID_PARA;
return NULL;
}
if (index >= pArray->size) {
uError("index is out of range, current:%" PRIzu " max:%"PRIzu, index, pArray->size);
uError("index is out of range, current:%" PRIzu " max:%" PRIzu, index, pArray->size);
terrno = TSDB_CODE_OUT_OF_RANGE;
return NULL;
}
@ -215,6 +225,7 @@ void* taosArrayGetP(const SArray* pArray, size_t index) {
void* taosArrayGetLast(const SArray* pArray) {
if (pArray->size == 0) {
terrno = TSDB_CODE_INVALID_PARA;
return NULL;
}
@ -230,6 +241,7 @@ size_t taosArrayGetSize(const SArray* pArray) {
void* taosArrayInsert(SArray* pArray, size_t index, const void* pData) {
if (pArray == NULL || pData == NULL) {
terrno = TSDB_CODE_INVALID_PARA;
return NULL;
}
@ -239,8 +251,8 @@ void* taosArrayInsert(SArray* pArray, size_t index, const void* pData) {
if (pArray->size >= pArray->capacity) {
int32_t ret = taosArrayResize(pArray);
if (ret < 0) {
terrno = ret;
return NULL;
}
}
@ -316,14 +328,17 @@ SArray* taosArrayFromList(const void* src, size_t size, size_t elemSize) {
}
SArray* pDst = taosArrayInit(size, elemSize);
memcpy(pDst->pData, src, elemSize * size);
pDst->size = size;
if (pDst) {
memcpy(pDst->pData, src, elemSize * size);
pDst->size = size;
}
return pDst;
}
SArray* taosArrayDup(const SArray* pSrc, __array_item_dup_fn_t fn) {
if (NULL == pSrc) {
terrno = TSDB_CODE_INVALID_PARA;
return NULL;
}
@ -333,18 +348,20 @@ SArray* taosArrayDup(const SArray* pSrc, __array_item_dup_fn_t fn) {
SArray* dst = taosArrayInit(pSrc->size, pSrc->elemSize);
if (fn == NULL) {
memcpy(dst->pData, pSrc->pData, pSrc->elemSize * pSrc->size);
} else {
ASSERT(pSrc->elemSize == sizeof(void*));
if (dst) {
if (fn == NULL) {
memcpy(dst->pData, pSrc->pData, pSrc->elemSize * pSrc->size);
} else {
ASSERT(pSrc->elemSize == sizeof(void*));
for (int32_t i = 0; i < pSrc->size; ++i) {
void* p = fn(taosArrayGetP(pSrc, i));
memcpy(((char*)dst->pData) + i * dst->elemSize, &p, dst->elemSize);
for (int32_t i = 0; i < pSrc->size; ++i) {
void* p = fn(taosArrayGetP(pSrc, i));
memcpy(((char*)dst->pData) + i * dst->elemSize, &p, dst->elemSize);
}
}
}
dst->size = pSrc->size;
dst->size = pSrc->size;
}
return dst;
}
@ -508,10 +525,22 @@ void* taosDecodeArray(const void* buf, SArray** pArray, FDecode decode, int32_t
int32_t sz;
buf = taosDecodeFixedI32(buf, &sz);
*pArray = taosArrayInit(sz, sizeof(void*));
if (*pArray == NULL) {
return NULL;
}
for (int32_t i = 0; i < sz; i++) {
void* data = taosMemoryCalloc(1, dataSz);
if (data == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
buf = decode(buf, data, sver);
taosArrayPush(*pArray, &data);
if (taosArrayPush(*pArray, &data) == NULL) {
taosMemoryFree(data);
return NULL;
}
}
return (void*)buf;
}

18
source/util/src/tlist.c
View File

@ -23,7 +23,10 @@ void tdListInit(SList *list, int32_t eleSize) {
SList *tdListNew(int32_t eleSize) {
SList *list = (SList *)taosMemoryMalloc(sizeof(SList));
if (list == NULL) return NULL;
if (list == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
tdListInit(list, eleSize);
return list;
@ -70,7 +73,9 @@ void tdListAppendNode(SList *list, SListNode *node) { TD_DLIST_APPEND(list, node
int32_t tdListPrepend(SList *list, void *data) {
SListNode *node = (SListNode *)taosMemoryMalloc(sizeof(SListNode) + list->eleSize);
if (node == NULL) return -1;
if (node == NULL) {
return terrno = TSDB_CODE_OUT_OF_MEMORY;
}
memcpy((void *)(node->data), data, list->eleSize);
TD_DLIST_PREPEND(list, node);
@ -80,7 +85,9 @@ int32_t tdListPrepend(SList *list, void *data) {
int32_t tdListAppend(SList *list, const void *data) {
SListNode *node = (SListNode *)taosMemoryCalloc(1, sizeof(SListNode) + list->eleSize);
if (node == NULL) return -1;
if (node == NULL) {
return terrno = TSDB_CODE_OUT_OF_MEMORY;
}
memcpy((void *)(node->data), data, list->eleSize);
TD_DLIST_APPEND(list, node);
@ -90,7 +97,10 @@ int32_t tdListAppend(SList *list, const void *data) {
// return the node pointer
SListNode *tdListAdd(SList *list, const void *data) {
SListNode *node = (SListNode *)taosMemoryCalloc(1, sizeof(SListNode) + list->eleSize);
if (node == NULL) return NULL;
if (node == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
memcpy((void *)(node->data), data, list->eleSize);
TD_DLIST_APPEND(list, node);

46
source/util/src/tskiplist.c
View File

@ -21,7 +21,7 @@
#include "tutil.h"
static int32_t initForwardBackwardPtr(SSkipList *pSkipList);
static SSkipListNode * getPriorNode(SSkipList *pSkipList, const char *val, int32_t order, SSkipListNode **pCur);
static SSkipListNode *getPriorNode(SSkipList *pSkipList, const char *val, int32_t order, SSkipListNode **pCur);
static void tSkipListRemoveNodeImpl(SSkipList *pSkipList, SSkipListNode *pNode);
static void tSkipListCorrectLevel(SSkipList *pSkipList);
static SSkipListIterator *doCreateSkipListIterator(SSkipList *pSkipList, int32_t order);
@ -40,7 +40,10 @@ static FORCE_INLINE int32_t getSkipListRandLevel(SSkipList *pSkipList);
SSkipList *tSkipListCreate(uint8_t maxLevel, uint8_t keyType, uint16_t keyLen, __compar_fn_t comparFn, uint8_t flags,
__sl_key_fn_t fn) {
SSkipList *pSkipList = (SSkipList *)taosMemoryCalloc(1, sizeof(SSkipList));
if (pSkipList == NULL) return NULL;
if (pSkipList == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
if (maxLevel > MAX_SKIP_LIST_LEVEL) {
maxLevel = MAX_SKIP_LIST_LEVEL;
@ -64,7 +67,7 @@ SSkipList *tSkipListCreate(uint8_t maxLevel, uint8_t keyType, uint16_t keyLen, _
pSkipList->comparFn = comparFn;
#endif
if (initForwardBackwardPtr(pSkipList) < 0) {
if (initForwardBackwardPtr(pSkipList) != TSDB_CODE_OUT_OF_MEMORY) {
tSkipListDestroy(pSkipList);
return NULL;
}
@ -73,11 +76,14 @@ SSkipList *tSkipListCreate(uint8_t maxLevel, uint8_t keyType, uint16_t keyLen, _
pSkipList->lock = (TdThreadRwlock *)taosMemoryCalloc(1, sizeof(TdThreadRwlock));
if (pSkipList->lock == NULL) {
tSkipListDestroy(pSkipList);
terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
if (taosThreadRwlockInit(pSkipList->lock, NULL) != 0) {
int32_t rc = taosThreadRwlockInit(pSkipList->lock, NULL);
if (rc) {
tSkipListDestroy(pSkipList);
terrno = TAOS_SYSTEM_ERROR(rc);
return NULL;
}
}
@ -137,8 +143,8 @@ void tSkipListPutBatchByIter(SSkipList *pSkipList, void *iter, iter_next_fn_t it
SSkipListNode *backward[MAX_SKIP_LIST_LEVEL] = {0};
SSkipListNode *forward[MAX_SKIP_LIST_LEVEL] = {0};
bool hasDup = false;
char * pKey = NULL;
char * pDataKey = NULL;
char *pKey = NULL;
char *pDataKey = NULL;
int32_t compare = 0;
tSkipListWLock(pSkipList);
@ -265,13 +271,17 @@ void tSkipListRemoveNode(SSkipList *pSkipList, SSkipListNode *pNode) {
#endif
SSkipListIterator *tSkipListCreateIter(SSkipList *pSkipList) {
if (pSkipList == NULL) return NULL;
if (pSkipList == NULL) {
terrno = TSDB_CODE_INVALID_PARA;
return NULL;
}
return doCreateSkipListIterator(pSkipList, TSDB_ORDER_ASC);
}
SSkipListIterator *tSkipListCreateIterFromVal(SSkipList *pSkipList, const char *val, int32_t type, int32_t order) {
if (order != TSDB_ORDER_ASC && order != TSDB_ORDER_DESC) {
terrno = TSDB_CODE_INVALID_PARA;
return NULL;
}
@ -362,7 +372,7 @@ void tSkipListPrint(SSkipList *pSkipList, int16_t nlevel) {
SSkipListNode *p = SL_NODE_GET_FORWARD_POINTER(pSkipList->pHead, nlevel - 1);
int32_t id = 1;
char * prev = NULL;
char *prev = NULL;
while (p != pSkipList->pTail) {
char *key = SL_GET_NODE_KEY(pSkipList, p);
@ -427,6 +437,10 @@ static void tSkipListDoInsert(SSkipList *pSkipList, SSkipListNode **direction, S
static SSkipListIterator *doCreateSkipListIterator(SSkipList *pSkipList, int32_t order) {
SSkipListIterator *iter = taosMemoryCalloc(1, sizeof(SSkipListIterator));
if (iter == NULL) {
terrno = TSDB_CODE_OUT_OF_BUFFER;
return NULL;
}
iter->pSkipList = pSkipList;
iter->order = order;
@ -465,7 +479,7 @@ static FORCE_INLINE int32_t tSkipListUnlock(SSkipList *pSkipList) {
static bool tSkipListGetPosToPut(SSkipList *pSkipList, SSkipListNode **backward, void *pData) {
int32_t compare = 0;
bool hasDupKey = false;
char * pDataKey = pSkipList->keyFn(pData);
char *pDataKey = pSkipList->keyFn(pData);
if (pSkipList->size == 0) {
for (int32_t i = 0; i < pSkipList->maxLevel; i++) {
@ -651,13 +665,15 @@ static int32_t initForwardBackwardPtr(SSkipList *pSkipList) {
// head info
pSkipList->pHead = tSkipListNewNode(maxLevel);
if (pSkipList->pHead == NULL) return -1;
if (pSkipList->pHead == NULL) {
return terrno;
}
// tail info
pSkipList->pTail = tSkipListNewNode(maxLevel);
if (pSkipList->pTail == NULL) {
tSkipListFreeNode(pSkipList->pHead);
return -1;
return terrno;
}
for (uint32_t i = 0; i < maxLevel; ++i) {
@ -672,7 +688,10 @@ static SSkipListNode *tSkipListNewNode(uint8_t level) {
int32_t tsize = sizeof(SSkipListNode) + sizeof(SSkipListNode *) * level * 2;
SSkipListNode *pNode = (SSkipListNode *)taosMemoryCalloc(1, tsize);
if (pNode == NULL) return NULL;
if (pNode == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
pNode->level = level;
return pNode;
@ -699,6 +718,9 @@ static SSkipListNode *tSkipListPutImpl(SSkipList *pSkipList, void *pData, SSkipL
if (pNode != NULL) {
pNode->pData = pData;
tSkipListDoInsert(pSkipList, direction, pNode, isForward);
} else {
terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
}

8
source/util/src/tthread.c
View File

@ -17,7 +17,12 @@
#include "tthread.h"
TdThread* taosCreateThread(void* (*__start_routine)(void*), void* param) {
TdThread* pthread = (TdThread*)taosMemoryMalloc(sizeof(TdThread));
TdThread* pthread = (TdThread*)taosMemoryMalloc(sizeof(TdThread));
if (pthread == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
return NULL;
}
TdThreadAttr thattr;
taosThreadAttrInit(&thattr);
taosThreadAttrSetDetachState(&thattr, PTHREAD_CREATE_JOINABLE);
@ -26,6 +31,7 @@ TdThread* taosCreateThread(void* (*__start_routine)(void*), void* param) {
if (ret != 0) {
taosMemoryFree(pthread);
terrno = TAOS_SYSTEM_ERROR(ret);
return NULL;
}
return pthread;

23
source/util/src/tunit.c
View File

@ -23,7 +23,7 @@
#define UNIT_ONE_PEBIBYTE (UNIT_ONE_TEBIBYTE * UNIT_SIZE_CONVERT_FACTOR)
#define UNIT_ONE_EXBIBYTE (UNIT_ONE_PEBIBYTE * UNIT_SIZE_CONVERT_FACTOR)
static int32_t parseCfgIntWithUnit(const char* str, double *res) {
static int32_t parseCfgIntWithUnit(const char* str, double* res) {
double val, temp = (double)INT64_MAX;
char* endPtr;
errno = 0;
@ -33,8 +33,7 @@ static int32_t parseCfgIntWithUnit(const char* str, double *res) {
val = taosStr2Double(str, &endPtr);
}
if (endPtr == str || errno == ERANGE || isnan(val)) {
terrno = TSDB_CODE_INVALID_CFG_VALUE;
return -1;
return terrno = TSDB_CODE_INVALID_CFG_VALUE;
}
while (isspace((unsigned char)*endPtr)) endPtr++;
uint64_t factor = 1;
@ -66,28 +65,25 @@ static int32_t parseCfgIntWithUnit(const char* str, double *res) {
factor = UNIT_ONE_KIBIBYTE;
} break;
default:
terrno = TSDB_CODE_INVALID_CFG_VALUE;
return -1;
return terrno = TSDB_CODE_INVALID_CFG_VALUE;
}
if ((val > 0 && val > temp) || (val < 0 && val < -temp)) {
terrno = TSDB_CODE_OUT_OF_RANGE;
return -1;
return terrno = TSDB_CODE_OUT_OF_RANGE;
}
endPtr++;
val *= factor;
}
while (isspace((unsigned char)*endPtr)) endPtr++;
if (*endPtr) {
terrno = TSDB_CODE_INVALID_CFG_VALUE;
return -1;
return terrno = TSDB_CODE_INVALID_CFG_VALUE;
}
val = rint(val);
*res = val;
return TSDB_CODE_SUCCESS;
}
int32_t taosStrHumanToInt64(const char* str, int64_t *out) {
double res;
int32_t taosStrHumanToInt64(const char* str, int64_t* out) {
double res;
int32_t code = parseCfgIntWithUnit(str, &res);
if (code == TSDB_CODE_SUCCESS) *out = (int64_t)res;
return code;
@ -113,12 +109,11 @@ void taosInt64ToHumanStr(int64_t val, char* outStr) {
#endif
int32_t taosStrHumanToInt32(const char* str, int32_t* out) {
double res;
double res;
int32_t code = parseCfgIntWithUnit(str, &res);
if (code == TSDB_CODE_SUCCESS) {
if (res < INT32_MIN || res > INT32_MAX) {
terrno = TSDB_CODE_OUT_OF_RANGE;
return -1;
return terrno = TSDB_CODE_OUT_OF_RANGE;
}
*out = (int32_t)res;
}

18
source/util/src/tversion.c
View File

@ -19,8 +19,7 @@
int32_t taosVersionStrToInt(const char *vstr, int32_t *vint) {
if (vstr == NULL) {
terrno = TSDB_CODE_INVALID_VERSION_STRING;
return -1;
return terrno = TSDB_CODE_INVALID_VERSION_STRING;
}
int32_t vnum[4] = {0};
@ -44,8 +43,7 @@ int32_t taosVersionStrToInt(const char *vstr, int32_t *vint) {
}
if (vnum[0] <= 0) {
terrno = TSDB_CODE_INVALID_VERSION_STRING;
return -1;
return terrno = TSDB_CODE_INVALID_VERSION_STRING;
}
*vint = vnum[0] * 1000000 + vnum[1] * 10000 + vnum[2] * 100 + vnum[3];
@ -58,8 +56,7 @@ int32_t taosVersionIntToStr(int32_t vint, char *vstr, int32_t len) {
int32_t s3 = (vint % 10000) / 100;
int32_t s4 = vint % 100;
if (s1 <= 0) {
terrno = TSDB_CODE_INVALID_VERSION_NUMBER;
return -1;
return terrno = TSDB_CODE_INVALID_VERSION_NUMBER;
}
snprintf(vstr, len, "%02d.%02d.%02d.%02d", s1, s2, s3, s4);
@ -83,15 +80,13 @@ int32_t taosCheckVersionCompatible(int32_t clientVer, int32_t serverVer, int32_t
serverVer /= 1000000;
break;
default:
terrno = TSDB_CODE_INVALID_VERSION_NUMBER;
return -1;
return terrno = TSDB_CODE_INVALID_VERSION_NUMBER;
}
if (clientVer == serverVer) {
return 0;
} else {
terrno = TSDB_CODE_VERSION_NOT_COMPATIBLE;
return -1;
return terrno = TSDB_CODE_VERSION_NOT_COMPATIBLE;
}
}
@ -106,8 +101,5 @@ int32_t taosCheckVersionCompatibleFromStr(const char *pClientVersion, const char
if (TSDB_CODE_SUCCESS == code) {
code = taosCheckVersionCompatible(clientVersion, serverVersion, comparedSegments);
}
if (TSDB_CODE_SUCCESS != code) {
code = terrno;
}
return code;
}

35
source/util/src/tworker.c
View File

@ -309,8 +309,7 @@ int32_t tWWorkerInit(SWWorkerPool *pool) {
pool->nextId = 0;
pool->workers = taosMemoryCalloc(pool->max, sizeof(SWWorker));
if (pool->workers == NULL) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
return -1;
return terrno = TSDB_CODE_OUT_OF_MEMORY;
}
(void)taosThreadMutexInit(&pool->mutex, NULL);
@ -434,6 +433,7 @@ _OVER:
if (queue != NULL) taosCloseQueue(queue);
if (worker->qset != NULL) taosCloseQset(worker->qset);
if (worker->qall != NULL) taosFreeQall(worker->qall);
terrno = code;
return NULL;
} else {
while (worker->pid <= 0) taosMsleep(10);
@ -450,6 +450,7 @@ void tWWorkerFreeQueue(SWWorkerPool *pool, STaosQueue *queue) {
}
int32_t tSingleWorkerInit(SSingleWorker *pWorker, const SSingleWorkerCfg *pCfg) {
int32_t code;
pWorker->poolType = pCfg->poolType;
pWorker->name = pCfg->name;
@ -457,32 +458,38 @@ int32_t tSingleWorkerInit(SSingleWorker *pWorker, const SSingleWorkerCfg *pCfg)
case QWORKER_POOL: {
SQWorkerPool *pPool = taosMemoryCalloc(1, sizeof(SQWorkerPool));
if (!pPool) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
return -1;
return terrno = TSDB_CODE_OUT_OF_MEMORY;
}
pPool->name = pCfg->name;
pPool->min = pCfg->min;
pPool->max = pCfg->max;
pWorker->pool = pPool;
if (tQWorkerInit(pPool) != 0) return -1;
if ((code = tQWorkerInit(pPool))) {
return (terrno = code);
}
pWorker->queue = tQWorkerAllocQueue(pPool, pCfg->param, pCfg->fp);
if (pWorker->queue == NULL) return -1;
if (pWorker->queue == NULL) {
return terrno;
}
} break;
case QUERY_AUTO_QWORKER_POOL: {
SQueryAutoQWorkerPool *pPool = taosMemoryCalloc(1, sizeof(SQueryAutoQWorkerPool));
if (!pPool) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
return -1;
return (terrno = TSDB_CODE_OUT_OF_MEMORY);
}
pPool->name = pCfg->name;
pPool->min = pCfg->min;
pPool->max = pCfg->max;
pWorker->pool = pPool;
if (tQueryAutoQWorkerInit(pPool) != 0) return -1;
code = tQueryAutoQWorkerInit(pPool);
if (code) return code;
pWorker->queue = tQueryAutoQWorkerAllocQueue(pPool, pCfg->param, pCfg->fp);
if (!pWorker->queue) return -1;
if (!pWorker->queue) {
return terrno;
}
} break;
default:
assert(0);
@ -516,10 +523,14 @@ int32_t tMultiWorkerInit(SMultiWorker *pWorker, const SMultiWorkerCfg *pCfg) {
SWWorkerPool *pPool = &pWorker->pool;
pPool->name = pCfg->name;
pPool->max = pCfg->max;
if (tWWorkerInit(pPool) != 0) return -1;
int32_t code = tWWorkerInit(pPool);
if (code) return code;
pWorker->queue = tWWorkerAllocQueue(pPool, pCfg->param, pCfg->fp);
if (pWorker->queue == NULL) return -1;
if (pWorker->queue == NULL) {
return terrno;
}
pWorker->name = pCfg->name;
return 0;