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

enh:modify error code passing

This commit is contained in:
lyh250-666 2024-09-20 17:48:04 +08:00
parent e45edbbda2
commit 69d62454d7
22 changed files with 121 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
source/libs/function/src/builtinsimpl.c
View File

@ -480,7 +480,7 @@ int32_t funcInputGetNextRowDescPk(SFuncInputRowIter* pIter, SFuncInputRow* pRow,
pIter->pPrevData = taosMemoryMalloc(pIter->pDataCol->info.bytes);
if (NULL == pIter->pPrevData) {
qError("out of memory when function get input row.");
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
char* srcData = colDataGetData(pIter->pDataCol, pIter->inputEndIndex);
(void)memcpy(pIter->pPrevData, srcData, pIter->pDataCol->info.bytes);
@ -489,7 +489,7 @@ int32_t funcInputGetNextRowDescPk(SFuncInputRowIter* pIter, SFuncInputRow* pRow,
if (NULL == pIter->pPrevPk) {
qError("out of memory when function get input row.");
taosMemoryFree(pIter->pPrevData);
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
char* pkData = colDataGetData(pIter->pPkCol, pIter->inputEndIndex);
(void)memcpy(pIter->pPrevPk, pkData, pIter->pPkCol->info.bytes);
@ -545,14 +545,14 @@ int32_t funcInputGetNextRowDescPk(SFuncInputRowIter* pIter, SFuncInputRow* pRow,
pIter->pPrevData = taosMemoryMalloc(pIter->pDataCol->info.bytes);
if (NULL == pIter->pPrevData) {
qError("out of memory when function get input row.");
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
(void)memcpy(pIter->pPrevData, colDataGetData(pIter->pDataCol, pIter->inputEndIndex), pIter->pDataCol->info.bytes);
pIter->pPrevPk = taosMemoryMalloc(pIter->pPkCol->info.bytes);
if (NULL == pIter->pPrevPk) {
qError("out of memory when function get input row.");
taosMemoryFree(pIter->pPrevData);
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
(void)memcpy(pIter->pPrevPk, colDataGetData(pIter->pPkCol, pIter->inputEndIndex), pIter->pPkCol->info.bytes);
@ -2644,7 +2644,7 @@ static int32_t prepareBuf(SqlFunctionCtx* pCtx) {
pCtx->subsidiaries.rowLen = rowLen + pCtx->subsidiaries.num * sizeof(bool);
pCtx->subsidiaries.buf = taosMemoryMalloc(pCtx->subsidiaries.rowLen);
if (NULL == pCtx->subsidiaries.buf) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
}
return TSDB_CODE_SUCCESS;
@ -6066,7 +6066,7 @@ int32_t modeFunctionSetup(SqlFunctionCtx* pCtx, SResultRowEntryInfo* pResInfo) {
if (NULL == pInfo->buf) {
taosHashCleanup(pInfo->pHash);
pInfo->pHash = NULL;
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
return TSDB_CODE_SUCCESS;

2
source/libs/function/src/detail/tminmax.c
View File

@ -947,7 +947,7 @@ int32_t doMinMaxHelper(SqlFunctionCtx* pCtx, int32_t isMinFunc, int32_t* nElems)
case TSDB_DATA_TYPE_NCHAR: {
pBuf->str = taosMemoryMalloc(pCol->info.bytes);
if (pBuf->str == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
(void)memcpy(pBuf->str, colDataGetData(pCol, i), varDataTLen(colDataGetData(pCol, i)));
break;

6
source/libs/function/src/thistogram.c
View File

@ -37,7 +37,7 @@ int32_t tHistogramCreate(int32_t numOfEntries, SHistogramInfo** pHisto) {
/* need one redundant slot */
*pHisto = taosMemoryMalloc(sizeof(SHistogramInfo) + sizeof(SHistBin) * (numOfEntries + 1));
if (NULL == *pHisto) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
#if !defined(USE_ARRAYLIST)
@ -468,7 +468,7 @@ int32_t tHistogramUniform(SHistogramInfo* pHisto, double* ratio, int32_t num, do
#if defined(USE_ARRAYLIST)
*pVal = taosMemoryMalloc(num * sizeof(double));
if (NULL == *pVal) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
for (int32_t i = 0; i < num; ++i) {
@ -521,7 +521,7 @@ int32_t tHistogramUniform(SHistogramInfo* pHisto, double* ratio, int32_t num, do
#else
double* pVal = taosMemoryMalloc(num * sizeof(double));
if (NULL == *pVal) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
for (int32_t i = 0; i < num; ++i) {
double numOfElem = ratio[i] * pHisto->numOfElems;

2
source/libs/function/src/tpercentile.c
View File

@ -460,7 +460,7 @@ int32_t tMemBucketPut(tMemBucket *pBucket, const void *data, size_t size) {
pSlot->info.pageId = pageId;
if (taosArrayPush(pPageIdList, &pageId) == NULL) {
taosArrayDestroy(pPageIdList);
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
}

8
source/libs/function/src/tudf.c
View File

@ -1678,7 +1678,7 @@ int32_t udfcInitializeUvTask(SClientUdfTask *task, int8_t uvTaskType, SClientUvT
void *bufBegin = taosMemoryMalloc(bufLen);
if(bufBegin == NULL) {
fnError("udfc create uv task, malloc buffer failed. size: %d", bufLen);
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
void *buf = bufBegin;
if(encodeUdfRequest(&buf, &request) <= 0)
@ -1733,7 +1733,7 @@ int32_t udfcStartUvTask(SClientUvTaskNode *uvTask) {
uv_pipe_t *pipe = taosMemoryMalloc(sizeof(uv_pipe_t));
if(pipe == NULL) {
fnError("udfc event loop start connect task malloc pipe failed.");
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
if (uv_pipe_init(&uvTask->udfc->uvLoop, pipe, 0) != 0) {
fnError("udfc event loop start connect task uv_pipe_init failed.");
@ -1762,7 +1762,7 @@ int32_t udfcStartUvTask(SClientUvTaskNode *uvTask) {
fnError("udfc event loop start connect task malloc connReq failed.");
taosMemoryFree(pipe);
taosMemoryFree(conn);
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
connReq->data = uvTask;
uv_pipe_connect(connReq, pipe, uvTask->udfc->udfdPipeName, onUdfcPipeConnect);
@ -1777,7 +1777,7 @@ int32_t udfcStartUvTask(SClientUvTaskNode *uvTask) {
uv_write_t *write = taosMemoryMalloc(sizeof(uv_write_t));
if(write == NULL) {
fnError("udfc event loop start req_rsp task malloc write failed.");
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
write->data = pipe->data;
QUEUE *connTaskQueue = &((SClientUvConn *)pipe->data)->taskQueue;

2
source/libs/function/src/udfd.c
View File

@ -1616,7 +1616,7 @@ int32_t udfdInitResidentFuncs() {
if(taosArrayPush(global.residentFuncs, func) == NULL)
{
taosArrayDestroy(global.residentFuncs);
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
}

20
source/libs/index/src/index.c
View File

@ -128,13 +128,13 @@ int32_t indexOpen(SIndexOpts* opts, const char* path, SIndex** index) {
idx->colObj = taosHashInit(8, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_ENTRY_LOCK);
if (idx->colObj == NULL) {
TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, END);
TAOS_CHECK_GOTO(terrno, NULL, END);
}
idx->version = 1;
idx->path = taosStrdup(path);
if (idx->path == NULL) {
TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, END);
TAOS_CHECK_GOTO(terrno, NULL, END);
}
(void)taosThreadMutexInit(&idx->mtx, NULL);
@ -261,7 +261,7 @@ int32_t indexSearch(SIndex* index, SIndexMultiTermQuery* multiQuerys, SArray* re
SArray* iRslts = taosArrayInit(4, POINTER_BYTES);
if (iRslts == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
int nQuery = taosArrayGetSize(multiQuerys->query);
@ -275,7 +275,7 @@ int32_t indexSearch(SIndex* index, SIndexMultiTermQuery* multiQuerys, SArray* re
}
if (taosArrayPush(iRslts, (void*)&trslt) == NULL) {
idxInterRsltDestroy(iRslts);
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
}
(void)idxMergeFinalResults(iRslts, opera, result);
@ -319,7 +319,7 @@ void indexMultiTermQueryDestroy(SIndexMultiTermQuery* pQuery) {
int32_t indexMultiTermQueryAdd(SIndexMultiTermQuery* pQuery, SIndexTerm* term, EIndexQueryType qType) {
SIndexTermQuery q = {.qType = qType, .term = term};
if (taosArrayPush(pQuery->query, &q) == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
return 0;
}
@ -387,7 +387,7 @@ SIndexMultiTerm* indexMultiTermCreate() { return taosArrayInit(4, sizeof(SIndexT
int32_t indexMultiTermAdd(SIndexMultiTerm* terms, SIndexTerm* term) {
if (taosArrayPush(terms, &term) == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
return 0;
}
@ -470,7 +470,7 @@ static int32_t idxTermSearch(SIndex* sIdx, SIndexTermQuery* query, SArray** resu
*result = taosArrayInit(4, sizeof(uint64_t));
if (*result == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
// TODO: iterator mem and tidex
@ -574,7 +574,7 @@ static int32_t idxMayMergeTempToFinalRslt(SArray* result, TFileValue* tfv, SIdxT
}
} else {
if (taosArrayPush(result, &tfv) == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
}
return code;
@ -658,7 +658,7 @@ int32_t idxFlushCacheToTFile(SIndex* sIdx, void* cache, bool quit) {
SArray* result = taosArrayInit(1024, sizeof(void*));
if (result == NULL) {
TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _exception);
TAOS_CHECK_GOTO(terrno, NULL, _exception);
}
bool cn = cacheIter ? cacheIter->next(cacheIter) : false;
@ -666,7 +666,7 @@ int32_t idxFlushCacheToTFile(SIndex* sIdx, void* cache, bool quit) {
SIdxTRslt* tr = idxTRsltCreate();
if (tr == NULL) {
TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _exception);
TAOS_CHECK_GOTO(terrno, NULL, _exception);
}
while (cn == true || tn == true) {
IterateValue* cv = (cn == true) ? cacheIter->getValue(cacheIter) : NULL;

6
source/libs/index/src/indexFilter.c
View File

@ -1033,7 +1033,7 @@ static int32_t sifCalculate(SNode *pNode, SIFParam *pDst) {
if (NULL == ctx.pRes) {
indexError("index-filter failed to taosHashInit");
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
nodesWalkExprPostOrder(pNode, sifCalcWalker, &ctx);
@ -1073,7 +1073,7 @@ static int32_t sifGetFltHint(SNode *pNode, SIdxFltStatus *status, SMetaDataFilte
ctx.pRes = taosHashInit(4, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BIGINT), false, HASH_NO_LOCK);
if (NULL == ctx.pRes) {
indexError("index-filter failed to taosHashInit");
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
nodesWalkExprPostOrder(pNode, sifCalcWalker, &ctx);
@ -1113,7 +1113,7 @@ int32_t doFilterTag(SNode *pFilterNode, SIndexMetaArg *metaArg, SArray *result,
SArray *output = taosArrayInit(8, sizeof(uint64_t));
if (output == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
SIFParam param = {.arg = *metaArg, .result = output, .status = SFLT_NOT_INDEX, .api = *pAPI};

8
source/libs/index/src/indexFstDfa.c
View File

@ -149,7 +149,7 @@ bool dfaBuilderCacheState(FstDfaBuilder *builder, FstSparseSet *set, uint32_t *r
int32_t code = 0;
SArray *tinsts = taosArrayInit(4, sizeof(uint32_t));
if (tinsts == NULL) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
goto _exception;
}
bool isMatch = false;
@ -163,13 +163,13 @@ bool dfaBuilderCacheState(FstDfaBuilder *builder, FstSparseSet *set, uint32_t *r
continue;
} else if (inst->ty == RANGE) {
if (taosArrayPush(tinsts, &ip) == NULL) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
goto _exception;
}
} else if (inst->ty == MATCH) {
isMatch = true;
if (taosArrayPush(tinsts, &ip) == NULL) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
goto _exception;
}
}
@ -185,7 +185,7 @@ bool dfaBuilderCacheState(FstDfaBuilder *builder, FstSparseSet *set, uint32_t *r
} else {
DfaState st = {.insts = tinsts, .isMatch = isMatch};
if (taosArrayPush(builder->dfa->states, &st) == NULL) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
goto _exception;
}

4
source/libs/index/src/indexFstNode.c
View File

@ -76,14 +76,14 @@ int32_t fstBuilderNodeCloneFrom(FstBuilderNode* dst, FstBuilderNode* src) {
size_t sz = taosArrayGetSize(src->trans);
dst->trans = taosArrayInit(sz, sizeof(FstTransition));
if (dst->trans == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
for (size_t i = 0; i < sz; i++) {
FstTransition* trn = taosArrayGet(src->trans, i);
if (taosArrayPush(dst->trans, trn) == NULL) {
taosArrayDestroy(dst->trans);
dst->trans = NULL;
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
}
return 0;

14
source/libs/index/src/indexTfile.c
View File

@ -280,7 +280,7 @@ static int32_t tfSearchPrefix(void* reader, SIndexTerm* tem, SIdxTRslt* tr) {
SArray* offsets = taosArrayInit(16, sizeof(uint64_t));
if (offsets == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
FAutoCtx* ctx = automCtxCreate((void*)p, AUTOMATION_PREFIX);
@ -675,7 +675,7 @@ int32_t tfileWriterPut(TFileWriter* tw, void* data, bool order) {
char* t = (char*)taosMemoryRealloc(buf, cap);
if (t == NULL) {
taosMemoryFree(buf);
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
buf = t;
}
@ -915,7 +915,7 @@ int32_t tfileValuePush(TFileValue* tf, uint64_t val) {
return TSDB_CODE_INVALID_PARA;
}
if (taosArrayPush(tf->tableId, &val) == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
return 0;
}
@ -1052,7 +1052,7 @@ static int32_t tfileReaderLoadTableIds(TFileReader* reader, int32_t offset, SArr
int32_t left = block + sizeof(block) - p;
if (left >= sizeof(uint64_t)) {
if (taosArrayPush(result, (uint64_t*)p) == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
p += sizeof(uint64_t);
} else {
@ -1065,7 +1065,7 @@ static int32_t tfileReaderLoadTableIds(TFileReader* reader, int32_t offset, SArr
memcpy(buf + left, block, sizeof(uint64_t) - left);
if (taosArrayPush(result, (uint64_t*)buf) == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
p = block + sizeof(uint64_t) - left;
}
@ -1118,7 +1118,7 @@ static int32_t tfileGetFileList(const char* path, SArray** ppResult) {
int64_t version;
SArray* files = taosArrayInit(4, sizeof(void*));
if (files == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
TdDirPtr pDir = taosOpenDir(path);
@ -1140,7 +1140,7 @@ static int32_t tfileGetFileList(const char* path, SArray** ppResult) {
sprintf(buf, "%s/%s", path, file);
if (taosArrayPush(files, &buf) == NULL) {
TAOS_CHECK_GOTO(TSDB_CODE_OUT_OF_MEMORY, NULL, _exception);
TAOS_CHECK_GOTO(terrno, NULL, _exception);
}
}
(void)taosCloseDir(&pDir);

10
source/libs/index/src/indexUtil.c
View File

@ -69,7 +69,7 @@ int32_t iIntersection(SArray *in, SArray *out) {
}
if (has == true) {
if (taosArrayPush(out, &tgt) == NULL) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
break;
}
}
@ -119,7 +119,7 @@ int32_t iUnion(SArray *in, SArray *out) {
}
}
if (taosArrayPush(out, &mVal) == NULL) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
break;
}
} else {
@ -220,17 +220,17 @@ int32_t idxTRsltMergeTo(SIdxTRslt *tr, SArray *result) {
} else {
SArray *arrs = taosArrayInit(2, sizeof(void *));
if (arrs == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
if (taosArrayPush(arrs, &tr->total) == NULL) {
taosArrayDestroy(arrs);
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
if (taosArrayPush(arrs, &tr->add) == NULL) {
taosArrayDestroy(arrs);
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
code = iUnion(arrs, result);
taosArrayDestroy(arrs);

2
source/libs/monitor/src/monMain.c
View File

@ -118,7 +118,7 @@ void monSetBmInfo(SMonBmInfo *pInfo) {
int32_t monInit(const SMonCfg *pCfg) {
tsMonitor.logs = taosArrayInit(16, sizeof(SMonLogItem));
if (tsMonitor.logs == NULL) {
TAOS_RETURN(TSDB_CODE_OUT_OF_MEMORY);
TAOS_RETURN(terrno);
}
tsMonitor.cfg = *pCfg;

8
source/libs/nodes/src/nodesCodeFuncs.c
View File

@ -440,7 +440,7 @@ static int32_t nodeListToJson(SJson* pJson, const char* pName, const SNodeList*
if (LIST_LENGTH(pList) > 0) {
SJson* jList = tjsonAddArrayToObject(pJson, pName);
if (NULL == jList) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
SNode* pNode;
FOREACH(pNode, pList) {
@ -8244,8 +8244,7 @@ int32_t nodesNodeToString(const SNode* pNode, bool format, char** pStr, int32_t*
SJson* pJson = tjsonCreateObject();
if (NULL == pJson) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
int32_t code = nodeToJson(pNode, pJson);
@ -8295,8 +8294,7 @@ int32_t nodesListToString(const SNodeList* pList, bool format, char** pStr, int3
SJson* pJson = tjsonCreateArray();
if (NULL == pJson) {
terrno = TSDB_CODE_OUT_OF_MEMORY;
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
SNode* pNode;

14
source/libs/nodes/src/nodesMsgFuncs.c
View File

@ -79,7 +79,7 @@ static int32_t initTlvEncoder(STlvEncoder* pEncoder) {
pEncoder->offset = 0;
pEncoder->tlvCount = 0;
pEncoder->pBuf = taosMemoryMalloc(pEncoder->allocSize);
return NULL == pEncoder->pBuf ? TSDB_CODE_OUT_OF_MEMORY : TSDB_CODE_SUCCESS;
return NULL == pEncoder->pBuf ? terrno : TSDB_CODE_SUCCESS;
}
static void clearTlvEncoder(STlvEncoder* pEncoder) { taosMemoryFree(pEncoder->pBuf); }
@ -96,7 +96,7 @@ static int32_t tlvEncodeImpl(STlvEncoder* pEncoder, int16_t type, const void* pV
pEncoder->allocSize = TMAX(pEncoder->allocSize * 2, pEncoder->allocSize + tlvLen);
void* pNewBuf = taosMemoryRealloc(pEncoder->pBuf, pEncoder->allocSize);
if (NULL == pNewBuf) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
pEncoder->pBuf = pNewBuf;
}
@ -113,7 +113,7 @@ static int32_t tlvEncodeValueImpl(STlvEncoder* pEncoder, const void* pValue, int
if (pEncoder->offset + len > pEncoder->allocSize) {
void* pNewBuf = taosMemoryRealloc(pEncoder->pBuf, pEncoder->allocSize * 2);
if (NULL == pNewBuf) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
pEncoder->pBuf = pNewBuf;
pEncoder->allocSize = pEncoder->allocSize * 2;
@ -248,7 +248,7 @@ static int32_t tlvEncodeObj(STlvEncoder* pEncoder, int16_t type, FToMsg func, co
pEncoder->allocSize = TMAX(pEncoder->allocSize * 2, pEncoder->allocSize + sizeof(STlv));
void* pNewBuf = taosMemoryRealloc(pEncoder->pBuf, pEncoder->allocSize);
if (NULL == pNewBuf) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
pEncoder->pBuf = pNewBuf;
}
@ -520,7 +520,7 @@ static int32_t tlvDecodeCStrP(STlv* pTlv, char** pValue) {
static int32_t tlvDecodeDynBinary(STlv* pTlv, void** pValue) {
*pValue = taosMemoryMalloc(pTlv->len);
if (NULL == *pValue) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
memcpy(*pValue, pTlv->value, pTlv->len);
return TSDB_CODE_SUCCESS;
@ -4841,7 +4841,7 @@ static int32_t msgToSArray(STlv* pTlv, void** pObj){
}
pArray = taosArrayInit(capacity, elemSize);
if (NULL == pArray) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
pArray->size = actualSize;
if (TSDB_CODE_SUCCESS != code || pTlvTemp == NULL) {
@ -4859,7 +4859,7 @@ static int32_t msgToSArray(STlv* pTlv, void** pObj){
if (pDataTlv != NULL) {
pArray = taosArrayInit(capacity, elemSize);
if (NULL == pArray) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
pArray->size = actualSize;
if (TSDB_CODE_SUCCESS != code || pTlvTemp == NULL) {

2
source/libs/nodes/src/nodesUtilFuncs.c
View File

@ -2765,7 +2765,7 @@ int32_t nodesMakeValueNodeFromString(char* literal, SValueNode** ppValNode) {
pValNode->node.resType.bytes = lenStr + VARSTR_HEADER_SIZE;
char* p = taosMemoryMalloc(lenStr + 1 + VARSTR_HEADER_SIZE);
if (p == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
varDataSetLen(p, lenStr);
memcpy(varDataVal(p), literal, lenStr + 1);

2
source/libs/parser/src/parAstCreater.c
View File

@ -932,7 +932,7 @@ SNode* createOperatorNode(SAstCreateContext* pCxt, EOperatorType type, SNode* pL
SValueNode* pVal = (SValueNode*)pLeft;
char* pNewLiteral = taosMemoryCalloc(1, strlen(pVal->literal) + 2);
if (!pNewLiteral) {
pCxt->errCode = TSDB_CODE_OUT_OF_MEMORY;
pCxt->errCode = terrno;
goto _err;
}
if ('+' == pVal->literal[0]) {

2
source/libs/parser/src/parCalcConst.c
View File

@ -210,7 +210,7 @@ static int32_t calcConstProject(SCalcConstContext* pCxt, SNode* pProject, bool d
if (NULL != ((SExprNode*)pProject)->pAssociation) {
pAssociation = taosArrayDup(((SExprNode*)pProject)->pAssociation, NULL);
if (NULL == pAssociation) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
}

16
source/libs/parser/src/parInsertSml.c
View File

@ -101,11 +101,11 @@ static int32_t smlBuildTagRow(SArray* cols, SBoundColInfo* tags, SSchema* pSchem
SMsgBuf* msg) {
SArray* pTagArray = taosArrayInit(tags->numOfBound, sizeof(STagVal));
if (!pTagArray) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
*tagName = taosArrayInit(8, TSDB_COL_NAME_LEN);
if (!*tagName) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
int32_t code = TSDB_CODE_SUCCESS;
@ -125,7 +125,7 @@ static int32_t smlBuildTagRow(SArray* cols, SBoundColInfo* tags, SSchema* pSchem
}
if (taosArrayPush(*tagName, pTagSchema->name) == NULL){
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
uError("SML smlBuildTagRow error push tag name");
goto end;
}
@ -160,7 +160,7 @@ static int32_t smlBuildTagRow(SArray* cols, SBoundColInfo* tags, SSchema* pSchem
(void)memcpy(&val.i64, &(kv->value), kv->length);
}
if (taosArrayPush(pTagArray, &val) == NULL){
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
uError("SML smlBuildTagRow error push tag array");
goto end;
}
@ -209,7 +209,7 @@ void clearColValArraySml(SArray* pCols) {
int32_t smlBuildRow(STableDataCxt* pTableCxt) {
SRow** pRow = taosArrayReserve(pTableCxt->pData->aRowP, 1);
if (pRow == NULL){
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
int ret = tRowBuild(pTableCxt->pValues, pTableCxt->pSchema, pRow);
if (TSDB_CODE_SUCCESS != ret) {
@ -423,7 +423,7 @@ int32_t smlBindData(SQuery* query, bool dataFormat, SArray* tags, SArray* colsSc
pVal->value.nData = kv->length;
pVal->value.pData = taosMemoryMalloc(kv->length);
if (NULL == pVal->value.pData) {
ret = TSDB_CODE_OUT_OF_MEMORY;
ret = terrno;
goto end;
}
(void)memcpy(pVal->value.pData, (uint8_t*)kv->value, kv->length);
@ -435,7 +435,7 @@ int32_t smlBindData(SQuery* query, bool dataFormat, SArray* tags, SArray* colsSc
SRow** pRow = taosArrayReserve(pTableCxt->pData->aRowP, 1);
if (NULL == pRow) {
ret = TSDB_CODE_OUT_OF_MEMORY;
ret = terrno;
goto end;
}
ret = tRowBuild(pTableCxt->pValues, pTableCxt->pSchema, pRow);
@ -480,7 +480,7 @@ int32_t smlInitHandle(SQuery** query) {
uError("create pTableBlockHashObj error");
qDestroyQuery(pQuery);
nodesDestroyNode((SNode*)stmt);
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
stmt->freeHashFunc = insDestroyTableDataCxtHashMap;
stmt->freeArrayFunc = insDestroyVgroupDataCxtList;

52
source/libs/parser/src/parInsertSql.c
View File

@ -662,7 +662,7 @@ static int32_t parseTagToken(const char** end, SToken* pToken, SSchema* pSchema,
} else {
val->pData = taosMemoryMalloc(size);
if (NULL == val->pData) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
} else {
memcpy(val->pData, output, size);
val->nData = size;
@ -679,7 +679,7 @@ static int32_t parseTagToken(const char** end, SToken* pToken, SSchema* pSchema,
if (realLen > pSchema->bytes - VARSTR_HEADER_SIZE) realLen = pSchema->bytes - VARSTR_HEADER_SIZE;
void* p = taosMemoryMalloc(realLen);
if (p == NULL) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
if (!taosMbsToUcs4(pToken->z, pToken->n, (TdUcs4*)(p), realLen, &output)) {
if (terrno == TAOS_SYSTEM_ERROR(E2BIG)) {
@ -732,7 +732,7 @@ int32_t parseTagValue(SMsgBuf* pMsgBuf, const char** pSql, uint8_t precision, SS
bool isNull = isNullValue(pTagSchema->type, pToken);
if (!isNull && pTagName) {
if (NULL == taosArrayPush(pTagName, pTagSchema->name)) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
}
@ -754,7 +754,7 @@ int32_t parseTagValue(SMsgBuf* pMsgBuf, const char** pSql, uint8_t precision, SS
int32_t code = parseTagToken(pSql, pToken, pTagSchema, precision, &val, pMsgBuf);
if (TSDB_CODE_SUCCESS == code) {
if (NULL == taosArrayPush(pTagVals, &val)){
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
}
}
@ -943,7 +943,7 @@ static int32_t parseTagsClauseImpl(SInsertParseContext* pCxt, SVnodeModifyOpStmt
if (!(pTagVals = taosArrayInit(pCxt->tags.numOfBound, sizeof(STagVal))) ||
!(pTagName = taosArrayInit(pCxt->tags.numOfBound, TSDB_COL_NAME_LEN))) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
goto _exit;
}
@ -1422,7 +1422,7 @@ int32_t initTableColSubmitData(STableDataCxt* pTableCxt) {
SSchema* pSchema = &pTableCxt->pMeta->schema[pTableCxt->boundColsInfo.pColIndex[i]];
SColData* pCol = taosArrayReserve(pTableCxt->pData->aCol, 1);
if (NULL == pCol) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
tColDataInit(pCol, pSchema->colId, pSchema->type, pSchema->flags);
}
@ -1592,7 +1592,7 @@ static int32_t parseValueTokenImpl(SInsertParseContext* pCxt, const char** pSql,
}
pVal->value.pData = taosMemoryMalloc(pToken->n);
if (NULL == pVal->value.pData) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
memcpy(pVal->value.pData, pToken->z, pToken->n);
pVal->value.nData = pToken->n;
@ -1612,7 +1612,7 @@ static int32_t parseValueTokenImpl(SInsertParseContext* pCxt, const char** pSql,
if (realLen > pSchema->bytes - VARSTR_HEADER_SIZE) realLen = pSchema->bytes - VARSTR_HEADER_SIZE;
char* pUcs4 = taosMemoryMalloc(realLen);
if (NULL == pUcs4) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
if (!taosMbsToUcs4(pToken->z, pToken->n, (TdUcs4*)pUcs4, realLen, &len)) {
taosMemoryFree(pUcs4);
@ -1633,7 +1633,7 @@ static int32_t parseValueTokenImpl(SInsertParseContext* pCxt, const char** pSql,
}
pVal->value.pData = taosMemoryMalloc(pToken->n);
if (NULL == pVal->value.pData) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
memcpy(pVal->value.pData, pToken->z, pToken->n);
pVal->value.nData = pToken->n;
@ -1654,7 +1654,7 @@ static int32_t parseValueTokenImpl(SInsertParseContext* pCxt, const char** pSql,
} else {
pVal->value.pData = taosMemoryMalloc(size);
if (NULL == pVal->value.pData) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
} else {
memcpy(pVal->value.pData, output, size);
pVal->value.nData = size;
@ -2215,7 +2215,7 @@ static int32_t parseDataFromFileImpl(SInsertParseContext* pCxt, SVnodeModifyOpSt
if (NULL == pStmt->pTableCxtHashObj) {
pStmt->pTableCxtHashObj = taosHashInit(128, taosGetDefaultHashFunction(TSDB_DATA_TYPE_BINARY), true, HASH_NO_LOCK);
if (!pStmt->pTableCxtHashObj) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
}
int32_t numOfRows = 0;
@ -2348,20 +2348,20 @@ static int32_t constructStbRowsDataContext(SVnodeModifyOpStmt* pStmt, SStbRowsDa
pStbRowsCxt->aTagNames = taosArrayInit(8, TSDB_COL_NAME_LEN);
if (!pStbRowsCxt->aTagNames) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
}
}
if (TSDB_CODE_SUCCESS == code) {
pStbRowsCxt->aTagVals = taosArrayInit(8, sizeof(STagVal));
if (!pStbRowsCxt->aTagVals) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
}
}
if (TSDB_CODE_SUCCESS == code) {
// col values and bound cols info of STableDataContext is not used
pStbRowsCxt->aColVals = taosArrayInit(getNumOfColumns(pStbRowsCxt->pStbMeta), sizeof(SColVal));
if (!pStbRowsCxt->aColVals)
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
}
if (TSDB_CODE_SUCCESS == code) {
code = insInitColValues(pStbRowsCxt->pStbMeta, pStbRowsCxt->aColVals);
@ -2536,7 +2536,7 @@ static int32_t checkTableClauseFirstToken(SInsertParseContext* pCxt, SVnodeModif
static int32_t setStmtInfo(SInsertParseContext* pCxt, SVnodeModifyOpStmt* pStmt) {
SBoundColInfo* tags = taosMemoryMalloc(sizeof(pCxt->tags));
if (NULL == tags) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
memcpy(tags, &pCxt->tags, sizeof(pCxt->tags));
@ -2723,13 +2723,13 @@ static int32_t addTableVgroupFromMetaData(const SArray* pTables, SVnodeModifyOpS
static int32_t buildTagNameFromMeta(STableMeta* pMeta, SArray** pTagName) {
*pTagName = taosArrayInit(pMeta->tableInfo.numOfTags, TSDB_COL_NAME_LEN);
if (NULL == *pTagName) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
SSchema* pSchema = getTableTagSchema(pMeta);
int32_t code = 0;
for (int32_t i = 0; i < pMeta->tableInfo.numOfTags; ++i) {
if (NULL == taosArrayPush(*pTagName, pSchema[i].name)) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
taosArrayDestroy(*pTagName);
*pTagName = NULL;
break;
@ -2869,12 +2869,12 @@ static int32_t setRefreshMeta(SQuery* pQuery) {
taosArrayDestroy(pQuery->pTableList);
pQuery->pTableList = taosArrayInit(taosHashGetSize(pStmt->pTableNameHashObj), sizeof(SName));
if (!pQuery->pTableList) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
} else {
SName* pTable = taosHashIterate(pStmt->pTableNameHashObj, NULL);
while (NULL != pTable) {
if (NULL == taosArrayPush(pQuery->pTableList, pTable)) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
taosHashCancelIterate(pStmt->pTableNameHashObj, pTable);
break;
}
@ -2887,12 +2887,12 @@ static int32_t setRefreshMeta(SQuery* pQuery) {
taosArrayDestroy(pQuery->pDbList);
pQuery->pDbList = taosArrayInit(taosHashGetSize(pStmt->pDbFNameHashObj), TSDB_DB_FNAME_LEN);
if (!pQuery->pDbList) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
} else {
char* pDb = taosHashIterate(pStmt->pDbFNameHashObj, NULL);
while (NULL != pDb) {
if (NULL == taosArrayPush(pQuery->pDbList, pDb)) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
taosHashCancelIterate(pStmt->pDbFNameHashObj, pDb);
break;
}
@ -2967,13 +2967,13 @@ static int32_t parseInsertSqlImpl(SInsertParseContext* pCxt, SVnodeModifyOpStmt*
static int32_t buildInsertTableReq(SName* pName, SArray** pTables) {
*pTables = taosArrayInit(1, sizeof(SName));
if (NULL == *pTables) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
if (NULL == taosArrayPush(*pTables, pName)) {
taosArrayDestroy(*pTables);
*pTables = NULL;
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
return TSDB_CODE_SUCCESS;
}
@ -2982,7 +2982,7 @@ static int32_t buildInsertDbReq(SName* pName, SArray** pDbs) {
if (NULL == *pDbs) {
*pDbs = taosArrayInit(1, sizeof(STablesReq));
if (NULL == *pDbs) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
}
@ -2999,7 +2999,7 @@ static int32_t buildInsertDbReq(SName* pName, SArray** pDbs) {
static int32_t buildInsertUserAuthReq(const char* pUser, SName* pName, SArray** pUserAuth) {
*pUserAuth = taosArrayInit(1, sizeof(SUserAuthInfo));
if (NULL == *pUserAuth) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
SUserAuthInfo userAuth = {.type = AUTH_TYPE_WRITE};
@ -3008,7 +3008,7 @@ static int32_t buildInsertUserAuthReq(const char* pUser, SName* pName, SArray**
if (NULL == taosArrayPush(*pUserAuth, &userAuth)) {
taosArrayDestroy(*pUserAuth);
*pUserAuth = NULL;
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
return TSDB_CODE_SUCCESS;

30
source/libs/parser/src/parInsertStmt.c
View File

@ -166,7 +166,7 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, const ch
}
}
if (NULL == taosArrayPush(tagName, pTagSchema->name)) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
goto end;
}
if (pTagSchema->type == TSDB_DATA_TYPE_JSON) {
@ -178,7 +178,7 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, const ch
isJson = true;
char* tmp = taosMemoryCalloc(1, colLen + 1);
if (!tmp) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
goto end;
}
memcpy(tmp, bind[c].buffer, colLen);
@ -219,7 +219,7 @@ int32_t qBindStmtTagsValue(void* pBlock, void* boundTags, int64_t suid, const ch
memcpy(&val.i64, bind[c].buffer, colLen);
}
if (NULL == taosArrayPush(pTagArray, &val)) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
goto end;
}
}
@ -261,7 +261,7 @@ int32_t convertStmtNcharCol(SMsgBuf* pMsgBuf, SSchema* pSchema, TAOS_MULTI_BIND*
if (dst->buffer_length < newBuflen) {
dst->buffer = taosMemoryRealloc(dst->buffer, newBuflen);
if (NULL == dst->buffer) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
}
@ -269,7 +269,7 @@ int32_t convertStmtNcharCol(SMsgBuf* pMsgBuf, SSchema* pSchema, TAOS_MULTI_BIND*
dst->length = taosMemoryRealloc(dst->length, sizeof(int32_t) * src->num);
if (NULL == dst->length) {
taosMemoryFreeClear(dst->buffer);
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
}
@ -514,7 +514,7 @@ int32_t qBindStmtTagsValue2(void* pBlock, void* boundTags, int64_t suid, const c
}
}
if (NULL == taosArrayPush(tagName, pTagSchema->name)) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
goto end;
}
if (pTagSchema->type == TSDB_DATA_TYPE_JSON) {
@ -526,7 +526,7 @@ int32_t qBindStmtTagsValue2(void* pBlock, void* boundTags, int64_t suid, const c
isJson = true;
char* tmp = taosMemoryCalloc(1, colLen + 1);
if (!tmp) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
goto end;
}
memcpy(tmp, bind[c].buffer, colLen);
@ -567,7 +567,7 @@ int32_t qBindStmtTagsValue2(void* pBlock, void* boundTags, int64_t suid, const c
memcpy(&val.i64, bind[c].buffer, colLen);
}
if (NULL == taosArrayPush(pTagArray, &val)) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
goto end;
}
}
@ -690,12 +690,12 @@ int32_t qBindStmtStbColsValue2(void* pBlock, SArray* pCols, TAOS_STMT2_BIND* bin
if (!ncharBinds) {
ncharBinds = taosArrayInit(1, sizeof(ncharBind));
if (!ncharBinds) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
goto _return;
}
}
if (!taosArrayPush(ncharBinds, &ncharBind)) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
goto _return;
}
pBindInfos[c].bind = taosArrayGetLast(ncharBinds);
@ -733,7 +733,7 @@ static int32_t convertStmtNcharCol2(SMsgBuf* pMsgBuf, SSchema* pSchema, TAOS_STM
// if (dst->buffer_length < newBuflen) {
dst->buffer = taosMemoryRealloc(dst->buffer, newBuflen);
if (NULL == dst->buffer) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
//}
@ -741,7 +741,7 @@ static int32_t convertStmtNcharCol2(SMsgBuf* pMsgBuf, SSchema* pSchema, TAOS_STM
dst->length = taosMemoryRealloc(dst->length, sizeof(int32_t) * src->num);
if (NULL == dst->length) {
taosMemoryFreeClear(dst->buffer);
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
}
@ -1000,7 +1000,7 @@ int32_t qCloneStmtDataBlock(STableDataCxt** pDst, STableDataCxt* pSrc, bool rese
void* pNewMeta = taosMemoryMalloc(TABLE_META_SIZE(pCxt->pMeta));
if (NULL == pNewMeta) {
insDestroyTableDataCxt(*pDst);
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
memcpy(pNewMeta, pCxt->pMeta, TABLE_META_SIZE(pCxt->pMeta));
pNewCxt->pMeta = pNewMeta;
@ -1013,7 +1013,7 @@ int32_t qCloneStmtDataBlock(STableDataCxt** pDst, STableDataCxt* pSrc, bool rese
void* pNewColIdx = taosMemoryMalloc(pCxt->boundColsInfo.numOfBound * sizeof(*pCxt->boundColsInfo.pColIndex));
if (NULL == pNewColIdx) {
insDestroyTableDataCxt(*pDst);
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
memcpy(pNewColIdx, pCxt->boundColsInfo.pColIndex,
pCxt->boundColsInfo.numOfBound * sizeof(*pCxt->boundColsInfo.pColIndex));
@ -1024,7 +1024,7 @@ int32_t qCloneStmtDataBlock(STableDataCxt** pDst, STableDataCxt* pSrc, bool rese
SSubmitTbData* pNewTb = (SSubmitTbData*)taosMemoryMalloc(sizeof(SSubmitTbData));
if (NULL == pNewTb) {
insDestroyTableDataCxt(*pDst);
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
memcpy(pNewTb, pCxt->pData, sizeof(*pCxt->pData));

22
source/libs/parser/src/parInsertUtil.c
View File

@ -173,7 +173,7 @@ static int32_t initColValues(STableMeta* pTableMeta, SArray* pValues) {
for (int32_t i = 0; i < pTableMeta->tableInfo.numOfColumns; ++i) {
SColVal val = COL_VAL_NONE(pSchemas[i].colId, pSchemas[i].type);
if (NULL == taosArrayPush(pValues, &val)) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
break;
}
}
@ -256,7 +256,7 @@ static int32_t createTableDataCxt(STableMeta* pTableMeta, SVCreateTbReq** pCreat
if (TSDB_CODE_SUCCESS == code && !ignoreColVals) {
pTableCxt->pValues = taosArrayInit(pTableMeta->tableInfo.numOfColumns, sizeof(SColVal));
if (NULL == pTableCxt->pValues) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
} else {
code = initColValues(pTableMeta, pTableCxt->pValues);
}
@ -276,12 +276,12 @@ static int32_t createTableDataCxt(STableMeta* pTableMeta, SVCreateTbReq** pCreat
if (pTableCxt->pData->flags & SUBMIT_REQ_COLUMN_DATA_FORMAT) {
pTableCxt->pData->aCol = taosArrayInit(128, sizeof(SColData));
if (NULL == pTableCxt->pData->aCol) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
}
} else {
pTableCxt->pData->aRowP = taosArrayInit(128, POINTER_BYTES);
if (NULL == pTableCxt->pData->aRowP) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
}
}
}
@ -318,13 +318,13 @@ static int32_t rebuildTableData(SSubmitTbData* pSrc, SSubmitTbData** pDst) {
if (pTmp->flags & SUBMIT_REQ_COLUMN_DATA_FORMAT) {
pTmp->aCol = taosArrayInit(128, sizeof(SColData));
if (NULL == pTmp->aCol) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
taosMemoryFree(pTmp);
}
} else {
pTmp->aRowP = taosArrayInit(128, POINTER_BYTES);
if (NULL == pTmp->aRowP) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
taosMemoryFree(pTmp);
}
}
@ -453,13 +453,13 @@ static int32_t fillVgroupDataCxt(STableDataCxt* pTableCxt, SVgroupDataCxt* pVgCx
if (NULL == pVgCxt->pData->aSubmitTbData) {
pVgCxt->pData->aSubmitTbData = taosArrayInit(128, sizeof(SSubmitTbData));
if (NULL == pVgCxt->pData->aSubmitTbData) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
}
// push data to submit, rebuild empty data for next submit
if (NULL == taosArrayPush(pVgCxt->pData->aSubmitTbData, pTableCxt->pData)) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
int32_t code = 0;
if (isRebuild) {
@ -489,7 +489,7 @@ static int32_t createVgroupDataCxt(STableDataCxt* pTableCxt, SHashObj* pVgroupHa
int32_t code = taosHashPut(pVgroupHash, &pVgCxt->vgId, sizeof(pVgCxt->vgId), &pVgCxt, POINTER_BYTES);
if (TSDB_CODE_SUCCESS == code) {
if (NULL == taosArrayPush(pVgroupList, &pVgCxt)) {
code = TSDB_CODE_OUT_OF_MEMORY;
code = terrno;
insDestroyVgroupDataCxt(pVgCxt);
return code;
}
@ -718,7 +718,7 @@ int32_t insMergeTableDataCxt(SHashObj* pTableHash, SArray** pVgDataBlocks, bool
if (NULL == pVgroupHash || NULL == pVgroupList) {
taosHashCleanup(pVgroupHash);
taosArrayDestroy(pVgroupList);
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
int32_t code = TSDB_CODE_SUCCESS;
@ -800,7 +800,7 @@ static int32_t buildSubmitReq(int32_t vgId, SSubmitReq2* pReq, void** pData, uin
len += sizeof(SSubmitReq2Msg);
pBuf = taosMemoryMalloc(len);
if (NULL == pBuf) {
return TSDB_CODE_OUT_OF_MEMORY;
return terrno;
}
((SSubmitReq2Msg*)pBuf)->header.vgId = htonl(vgId);
((SSubmitReq2Msg*)pBuf)->header.contLen = htonl(len);